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 |