| 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_EVENT_REWRITER_H_ | |
| 6 #define CHROME_BROWSER_CHROMEOS_EVENT_REWRITER_H_ | |
| 7 | |
| 8 #include <map> | |
| 9 #include <set> | |
| 10 #include <string> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/compiler_specific.h" | |
| 14 #include "base/containers/hash_tables.h" | |
| 15 #include "base/memory/scoped_ptr.h" | |
| 16 #include "base/message_loop/message_pump_observer.h" | |
| 17 #include "chrome/browser/chromeos/device_hierarchy_observer.h" | |
| 18 #include "ui/aura/root_window_observer.h" | |
| 19 #include "ui/events/keycodes/keyboard_codes.h" | |
| 20 | |
| 21 class PrefService; | |
| 22 typedef union _XEvent XEvent; | |
| 23 | |
| 24 namespace aura { | |
| 25 class RootWindow; | |
| 26 } | |
| 27 | |
| 28 namespace chromeos { | |
| 29 class KeyboardDrivenEventRewriter; | |
| 30 namespace input_method { | |
| 31 class XKeyboard; | |
| 32 } | |
| 33 | |
| 34 class EventRewriter : public aura::RootWindowObserver, | |
| 35 public DeviceHierarchyObserver, | |
| 36 public base::MessagePumpObserver { | |
| 37 public: | |
| 38 enum DeviceType { | |
| 39 kDeviceUnknown = 0, | |
| 40 kDeviceAppleKeyboard, | |
| 41 }; | |
| 42 | |
| 43 EventRewriter(); | |
| 44 virtual ~EventRewriter(); | |
| 45 | |
| 46 // Calls DeviceAddedInternal. | |
| 47 DeviceType DeviceAddedForTesting(int device_id, | |
| 48 const std::string& device_name); | |
| 49 // Calls Rewrite. | |
| 50 void RewriteForTesting(XEvent* event); | |
| 51 | |
| 52 const std::map<int, DeviceType>& device_id_to_type_for_testing() const { | |
| 53 return device_id_to_type_; | |
| 54 } | |
| 55 void set_last_device_id_for_testing(int device_id) { | |
| 56 last_device_id_ = device_id; | |
| 57 } | |
| 58 void set_pref_service_for_testing(const PrefService* pref_service) { | |
| 59 pref_service_for_testing_ = pref_service; | |
| 60 } | |
| 61 void set_xkeyboard_for_testing(input_method::XKeyboard* xkeyboard) { | |
| 62 xkeyboard_for_testing_ = xkeyboard; | |
| 63 } | |
| 64 | |
| 65 // Gets DeviceType from the |device_name|. | |
| 66 static DeviceType GetDeviceType(const std::string& device_name); | |
| 67 | |
| 68 private: | |
| 69 friend class EventRewriterAshTest; | |
| 70 friend class EventRewriterTest; | |
| 71 | |
| 72 // aura::RootWindowObserver overrides: | |
| 73 virtual void OnKeyboardMappingChanged(const aura::RootWindow* root) OVERRIDE; | |
| 74 | |
| 75 // base::MessagePumpObserver overrides: | |
| 76 virtual base::EventStatus WillProcessEvent( | |
| 77 const base::NativeEvent& event) OVERRIDE; | |
| 78 virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE; | |
| 79 | |
| 80 // DeviceHierarchyObserver overrides: | |
| 81 virtual void DeviceHierarchyChanged() OVERRIDE {} | |
| 82 virtual void DeviceAdded(int device_id) OVERRIDE; | |
| 83 virtual void DeviceRemoved(int device_id) OVERRIDE; | |
| 84 virtual void DeviceKeyPressedOrReleased(int device_id) OVERRIDE; | |
| 85 | |
| 86 // We don't want to include Xlib.h here since it has polluting macros, so | |
| 87 // define these locally. | |
| 88 typedef unsigned long KeySym; | |
| 89 typedef unsigned char KeyCode; | |
| 90 | |
| 91 // Updates |*_xkeycode_| in response to a keyboard map change. | |
| 92 void RefreshKeycodes(); | |
| 93 // Converts an X key symbol like XK_Control_L to a key code. | |
| 94 unsigned char NativeKeySymToNativeKeycode(KeySym keysym); | |
| 95 | |
| 96 struct KeyboardRemapping { | |
| 97 KeySym input_keysym; | |
| 98 unsigned int input_native_mods; | |
| 99 KeySym output_keysym; | |
| 100 unsigned int output_native_mods; | |
| 101 }; | |
| 102 | |
| 103 // Returns true if the target for |event| would prefer to receive raw function | |
| 104 // keys instead of having them rewritten into back, forward, brightness, | |
| 105 // volume, etc. or if the user has specified that they desire top-row keys to | |
| 106 // be treated as function keys globally. | |
| 107 bool TopRowKeysAreFunctionKeys(XEvent* event) const; | |
| 108 | |
| 109 // Given a set of KeyboardRemapping structs, it finds a matching struct | |
| 110 // if possible, and updates the remapped event values. Returns true if a | |
| 111 // remapping was found and remapped values were updated. | |
| 112 bool RewriteWithKeyboardRemappingsByKeySym( | |
| 113 const KeyboardRemapping* remappings, | |
| 114 size_t num_remappings, | |
| 115 KeySym keysym, | |
| 116 unsigned int native_mods, | |
| 117 KeySym* remapped_native_keysym, | |
| 118 unsigned int* remapped_native_mods); | |
| 119 | |
| 120 // Given a set of KeyboardRemapping structs, it finds a matching struct | |
| 121 // if possible, and updates the remapped event values. This function converts | |
| 122 // the KeySym in the KeyboardRemapping struct into the KeyCode before matching | |
| 123 // to allow any KeyCode on the same physical key as the given KeySym to match. | |
| 124 // Returns true if a remapping was found and remapped values were updated. | |
| 125 bool RewriteWithKeyboardRemappingsByKeyCode( | |
| 126 const KeyboardRemapping* remappings, | |
| 127 size_t num_remappings, | |
| 128 KeyCode keycode, | |
| 129 unsigned int native_mods, | |
| 130 KeySym* remapped_native_keysym, | |
| 131 unsigned int* remapped_native_mods); | |
| 132 | |
| 133 // Returns the PrefService that should be used. | |
| 134 const PrefService* GetPrefService() const; | |
| 135 | |
| 136 // Rewrites the |event| by applying all RewriteXXX functions as needed. | |
| 137 void Rewrite(XEvent* event); | |
| 138 | |
| 139 // Rewrites a modifier key press/release following the current user | |
| 140 // preferences. | |
| 141 bool RewriteModifiers(XEvent* event); | |
| 142 | |
| 143 // Rewrites Fn key press/release to Control. In some cases, Fn key is not | |
| 144 // intercepted by the EC, but generates a key event like "XK_F15 + Mod3Mask" | |
| 145 // as shown in crosbug.com/p/14339. | |
| 146 bool RewriteFnKey(XEvent* event); | |
| 147 | |
| 148 // Rewrites a NumPad key press/release without Num Lock to a corresponding key | |
| 149 // press/release with the lock. Returns true when |event| is rewritten. | |
| 150 bool RewriteNumPadKeys(XEvent* event); | |
| 151 | |
| 152 // Rewrites Backspace and Arrow keys following the Chrome OS keyboard spec. | |
| 153 // * Alt+Backspace -> Delete | |
| 154 // * Alt+Up -> Prior (aka PageUp) | |
| 155 // * Alt+Down -> Next (aka PageDown) | |
| 156 // * Ctrl+Alt+Up -> Home | |
| 157 // * Ctrl+Alt+Down -> End | |
| 158 // When the Search key acts as a function key, it instead maps: | |
| 159 // * Search+Backspace -> Delete | |
| 160 // * Search+Up -> Prior (aka PageUp) | |
| 161 // * Search+Down -> Next (aka PageDown) | |
| 162 // * Search+Left -> Home | |
| 163 // * Search+Right -> End | |
| 164 // * Search+. -> Insert | |
| 165 // Returns true when the |event| is rewritten. | |
| 166 bool RewriteExtendedKeys(XEvent* event); | |
| 167 | |
| 168 // When the Search key acts as a function key, it remaps Search+1 | |
| 169 // through Search+= to F1 through F12. Returns true when the |event| is | |
| 170 // rewritten. | |
| 171 bool RewriteFunctionKeys(XEvent* event); | |
| 172 | |
| 173 // Rewrites the located |event|. | |
| 174 void RewriteLocatedEvent(XEvent* event); | |
| 175 | |
| 176 // Overwrites |event| with the keycodes and flags. | |
| 177 void OverwriteEvent(XEvent* event, | |
| 178 unsigned int new_native_keycode, | |
| 179 unsigned int new_native_state); | |
| 180 | |
| 181 // Checks the type of the |device_name|, and inserts a new entry to | |
| 182 // |device_id_to_type_|. | |
| 183 DeviceType DeviceAddedInternal(int device_id, const std::string& device_name); | |
| 184 | |
| 185 // Returns true if |last_device_id_| is Apple's. | |
| 186 bool IsAppleKeyboard() const; | |
| 187 | |
| 188 // Remaps |original_native_modifiers| to |remapped_native_modifiers| following | |
| 189 // the current user prefs. | |
| 190 void GetRemappedModifierMasks(unsigned int original_native_modifiers, | |
| 191 unsigned int* remapped_native_modifiers) const; | |
| 192 | |
| 193 std::map<int, DeviceType> device_id_to_type_; | |
| 194 int last_device_id_; | |
| 195 | |
| 196 // A mapping from X11 KeySym keys to KeyCode values. | |
| 197 base::hash_map<unsigned long, unsigned long> keysym_to_keycode_map_; | |
| 198 | |
| 199 // A set of device IDs whose press event has been rewritten. | |
| 200 std::set<int> pressed_device_ids_; | |
| 201 | |
| 202 input_method::XKeyboard* xkeyboard_for_testing_; | |
| 203 | |
| 204 scoped_ptr<KeyboardDrivenEventRewriter> | |
| 205 keyboard_driven_event_rewriter_; | |
| 206 | |
| 207 const PrefService* pref_service_for_testing_; | |
| 208 | |
| 209 DISALLOW_COPY_AND_ASSIGN(EventRewriter); | |
| 210 }; | |
| 211 | |
| 212 } // namespace chromeos | |
| 213 | |
| 214 #endif // CHROME_BROWSER_CHROMEOS_EVENT_REWRITER_H_ | |
| OLD | NEW |