| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_ | |
| 6 #define CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_ | |
| 7 | |
| 8 #include <map> | |
| 9 #include <memory> | |
| 10 #include <set> | |
| 11 #include <string> | |
| 12 | |
| 13 #include "base/compiler_specific.h" | |
| 14 #include "base/containers/hash_tables.h" | |
| 15 #include "base/macros.h" | |
| 16 #include "ui/events/event.h" | |
| 17 #include "ui/events/event_rewriter.h" | |
| 18 #include "ui/events/keycodes/dom/dom_key.h" | |
| 19 | |
| 20 class PrefService; | |
| 21 | |
| 22 namespace ui { | |
| 23 enum class DomCode; | |
| 24 }; | |
| 25 | |
| 26 namespace chromeos { | |
| 27 namespace input_method { | |
| 28 class ImeKeyboard; | |
| 29 } | |
| 30 | |
| 31 // EventRewriter makes various changes to keyboard-related events, | |
| 32 // including KeyEvents and some other events with keyboard modifier flags: | |
| 33 // - maps certain non-character keys according to user preferences | |
| 34 // (Control, Alt, Search, Caps Lock, Escape, Backspace, Diamond); | |
| 35 // - maps Command to Control on Apple keyboards; | |
| 36 // - converts numeric pad editing keys to their numeric forms; | |
| 37 // - converts top-row function keys to special keys where necessary; | |
| 38 // - handles various key combinations like Search+Backspace -> Delete | |
| 39 // and Search+number to Fnumber; | |
| 40 // - handles key/pointer combinations like Alt+Button1 -> Button3. | |
| 41 class EventRewriter : public ui::EventRewriter { | |
| 42 public: | |
| 43 enum DeviceType { | |
| 44 kDeviceUnknown = 0, | |
| 45 kDeviceAppleKeyboard, | |
| 46 kDeviceHotrodRemote, | |
| 47 kDeviceVirtualCoreKeyboard, // X-server generated events. | |
| 48 }; | |
| 49 | |
| 50 // Things that keyboard-related rewriter phases can change about an Event. | |
| 51 struct MutableKeyState { | |
| 52 int flags; | |
| 53 ui::DomCode code; | |
| 54 ui::DomKey::Base key; | |
| 55 ui::KeyboardCode key_code; | |
| 56 }; | |
| 57 | |
| 58 // Does not take ownership of the |sticky_keys_controller|, which may also | |
| 59 // be NULL (for testing without ash), in which case sticky key operations | |
| 60 // don't happen. | |
| 61 explicit EventRewriter(ui::EventRewriter* sticky_keys_controller); | |
| 62 ~EventRewriter() override; | |
| 63 | |
| 64 // Calls KeyboardDeviceAddedInternal. | |
| 65 DeviceType KeyboardDeviceAddedForTesting(int device_id, | |
| 66 const std::string& device_name); | |
| 67 | |
| 68 // Calls RewriteMouseEvent(). | |
| 69 void RewriteMouseButtonEventForTesting( | |
| 70 const ui::MouseEvent& event, | |
| 71 std::unique_ptr<ui::Event>* rewritten_event); | |
| 72 | |
| 73 const std::map<int, DeviceType>& device_id_to_type_for_testing() const { | |
| 74 return device_id_to_type_; | |
| 75 } | |
| 76 void set_last_keyboard_device_id_for_testing(int device_id) { | |
| 77 last_keyboard_device_id_ = device_id; | |
| 78 } | |
| 79 void set_pref_service_for_testing(const PrefService* pref_service) { | |
| 80 pref_service_for_testing_ = pref_service; | |
| 81 } | |
| 82 void set_ime_keyboard_for_testing( | |
| 83 chromeos::input_method::ImeKeyboard* ime_keyboard) { | |
| 84 ime_keyboard_for_testing_ = ime_keyboard; | |
| 85 } | |
| 86 | |
| 87 // EventRewriter overrides: | |
| 88 ui::EventRewriteStatus RewriteEvent( | |
| 89 const ui::Event& event, | |
| 90 std::unique_ptr<ui::Event>* rewritten_event) override; | |
| 91 ui::EventRewriteStatus NextDispatchEvent( | |
| 92 const ui::Event& last_event, | |
| 93 std::unique_ptr<ui::Event>* new_event) override; | |
| 94 | |
| 95 // Generate a new key event from an original key event and the replacement | |
| 96 // state determined by a key rewriter. | |
| 97 static void BuildRewrittenKeyEvent( | |
| 98 const ui::KeyEvent& key_event, | |
| 99 const MutableKeyState& state, | |
| 100 std::unique_ptr<ui::Event>* rewritten_event); | |
| 101 | |
| 102 private: | |
| 103 void DeviceKeyPressedOrReleased(int device_id); | |
| 104 | |
| 105 // Returns the PrefService that should be used. | |
| 106 const PrefService* GetPrefService() const; | |
| 107 | |
| 108 // Adds a device to |device_id_to_type_|. | |
| 109 DeviceType KeyboardDeviceAdded(int device_id); | |
| 110 | |
| 111 // Checks the type of the |device_name|, |vendor_id| and |product_id|, and | |
| 112 // inserts a new entry to |device_id_to_type_|. | |
| 113 DeviceType KeyboardDeviceAddedInternal(int device_id, | |
| 114 const std::string& device_name, | |
| 115 int vendor_id, | |
| 116 int product_id); | |
| 117 | |
| 118 // Returns true if |last_keyboard_device_id_| is Apple's. | |
| 119 bool IsAppleKeyboard() const; | |
| 120 // Returns true if |last_keyboard_device_id_| is Hotrod remote. | |
| 121 bool IsHotrodRemote() const; | |
| 122 // Returns true if |last_keyboard_device_id_| is of given |device_type|. | |
| 123 bool IsLastKeyboardOfType(DeviceType device_type) const; | |
| 124 | |
| 125 // Returns true if the target for |event| would prefer to receive raw function | |
| 126 // keys instead of having them rewritten into back, forward, brightness, | |
| 127 // volume, etc. or if the user has specified that they desire top-row keys to | |
| 128 // be treated as function keys globally. | |
| 129 bool TopRowKeysAreFunctionKeys(const ui::KeyEvent& event) const; | |
| 130 | |
| 131 // Given modifier flags |original_flags|, returns the remapped modifiers | |
| 132 // according to user preferences and/or event properties. | |
| 133 int GetRemappedModifierMasks(const PrefService& pref_service, | |
| 134 const ui::Event& event, | |
| 135 int original_flags) const; | |
| 136 | |
| 137 // Rewrite a particular kind of event. | |
| 138 ui::EventRewriteStatus RewriteKeyEvent( | |
| 139 const ui::KeyEvent& key_event, | |
| 140 std::unique_ptr<ui::Event>* rewritten_event); | |
| 141 ui::EventRewriteStatus RewriteMouseButtonEvent( | |
| 142 const ui::MouseEvent& mouse_event, | |
| 143 std::unique_ptr<ui::Event>* rewritten_event); | |
| 144 ui::EventRewriteStatus RewriteMouseWheelEvent( | |
| 145 const ui::MouseWheelEvent& mouse_event, | |
| 146 std::unique_ptr<ui::Event>* rewritten_event); | |
| 147 ui::EventRewriteStatus RewriteTouchEvent( | |
| 148 const ui::TouchEvent& touch_event, | |
| 149 std::unique_ptr<ui::Event>* rewritten_event); | |
| 150 ui::EventRewriteStatus RewriteScrollEvent( | |
| 151 const ui::ScrollEvent& scroll_event, | |
| 152 std::unique_ptr<ui::Event>* rewritten_event); | |
| 153 | |
| 154 // Rewriter phases. These can inspect the original |event|, but operate using | |
| 155 // the current |state|, which may have been modified by previous phases. | |
| 156 bool RewriteModifierKeys(const ui::KeyEvent& event, MutableKeyState* state); | |
| 157 void RewriteNumPadKeys(const ui::KeyEvent& event, MutableKeyState* state); | |
| 158 void RewriteExtendedKeys(const ui::KeyEvent& event, MutableKeyState* state); | |
| 159 void RewriteFunctionKeys(const ui::KeyEvent& event, MutableKeyState* state); | |
| 160 void RewriteLocatedEvent(const ui::Event& event, int* flags); | |
| 161 int RewriteModifierClick(const ui::MouseEvent& event, int* flags); | |
| 162 | |
| 163 // A set of device IDs whose press event has been rewritten. | |
| 164 // This is to ensure that press and release events are rewritten consistently. | |
| 165 std::set<int> pressed_device_ids_; | |
| 166 | |
| 167 std::map<int, DeviceType> device_id_to_type_; | |
| 168 | |
| 169 // The |source_device_id()| of the most recent keyboard event, | |
| 170 // used to interpret modifiers on pointer events. | |
| 171 int last_keyboard_device_id_; | |
| 172 | |
| 173 chromeos::input_method::ImeKeyboard* ime_keyboard_for_testing_; | |
| 174 const PrefService* pref_service_for_testing_; | |
| 175 | |
| 176 // The sticky keys controller is not owned here; | |
| 177 // at time of writing it is a singleton in ash::Shell. | |
| 178 ui::EventRewriter* const sticky_keys_controller_; | |
| 179 | |
| 180 // Some keyboard layouts have 'latching' keys, which either apply | |
| 181 // a modifier while held down (like normal modifiers), or, if no | |
| 182 // non-modifier is pressed while the latching key is down, apply the | |
| 183 // modifier to the next non-modifier keypress. Under Ozone the stateless | |
| 184 // layout model requires this to be handled explicitly. See crbug.com/518237 | |
| 185 // Pragmatically this, like the Diamond key, is handled here in | |
| 186 // EventRewriter, but modifier state management is scattered between | |
| 187 // here, sticky keys, and the system layer (X11 or Ozone), and could | |
| 188 // do with refactoring. | |
| 189 // - |pressed_modifier_latches_| records the latching keys currently pressed. | |
| 190 // It also records the active modifier flags for non-modifier keys that are | |
| 191 // remapped to modifiers, e.g. Diamond/F15. | |
| 192 // - |latched_modifier_latches_| records the latching keys just released, | |
| 193 // to be applied to the next non-modifier key. | |
| 194 // - |used_modifier_latches_| records the latching keys applied to a non- | |
| 195 // modifier while pressed, so that they do not get applied after release. | |
| 196 int pressed_modifier_latches_; | |
| 197 int latched_modifier_latches_; | |
| 198 int used_modifier_latches_; | |
| 199 | |
| 200 DISALLOW_COPY_AND_ASSIGN(EventRewriter); | |
| 201 }; | |
| 202 | |
| 203 } // namespace chromeos | |
| 204 | |
| 205 #endif // CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2724913002:
Move chromeos::EventRewriter to //ui/chromeos/events (Closed)
