Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(224)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: ui/events/keycodes/keyboard_code_conversion_x.cc

Issue 357613002: Gets correct KeyboardCode from XEvent for non-US layouts. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: fixed test failures due to unsorted MAP1. Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « ui/events/keycodes/keyboard_code_conversion_x.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "ui/events/keycodes/keyboard_code_conversion_x.h" 5 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
6 6
7 #include <algorithm>
8
7 #define XK_3270 // for XK_3270_BackTab 9 #define XK_3270 // for XK_3270_BackTab
8 #include <X11/keysym.h> 10 #include <X11/keysym.h>
9 #include <X11/Xlib.h> 11 #include <X11/Xlib.h>
10 #include <X11/Xutil.h> 12 #include <X11/Xutil.h>
11 #include <X11/XF86keysym.h> 13 #include <X11/XF86keysym.h>
12 14
13 #include "base/basictypes.h" 15 #include "base/basictypes.h"
14 #include "base/logging.h" 16 #include "base/logging.h"
15 #include "base/strings/stringprintf.h" 17 #include "base/strings/stringprintf.h"
16 #include "base/strings/sys_string_conversions.h" 18 #include "base/strings/sys_string_conversions.h"
17 #include "base/strings/utf_string_conversions.h" 19 #include "base/strings/utf_string_conversions.h"
18 #include "ui/events/keycodes/dom4/keycode_converter.h" 20 #include "ui/events/keycodes/dom4/keycode_converter.h"
19 21
20 namespace ui { 22 namespace ui {
21 23
24 namespace {
25
26 // MAP0 - MAP3:
27 // They are the generated VKEY code maps for all possible Latin keyboard
28 // layouts in Windows. And the maps are only for special letter keys exclude
29 // [a-z] & [0-9].
30 //
31 // ch0: the keysym without modifier states.
32 // ch1: the keysym with shift state.
33 // ch2: the keysym with altgr state.
34 // sc: the hardware keycode (in Windows, it's called scan code).
35 // vk: the VKEY code.
36 //
37 // MAP0: maps from ch0 to vk.
38 // MAP1: maps from ch0+sc to vk.
39 // MAP2: maps from ch0+ch1+sc to vk.
40 // MAP3: maps from ch0+ch1+ch2+sc to vk.
41 // MAP0 - MAP3 are all sorted, so that finding VK can be binary search.
42 //
43 // The reason of creating these maps is because a hard-coded mapping in
44 // KeyboardCodeFromXKeysym() doesn't support non-US keyboard layouts.
45 // e.g. in UK keyboard, the # key is located at BackSlash key position, and its
46 // VKEY code should be VKEY_OEM_5 instead of VKEY_3.
Wez 2014/06/26 02:10:42 I think it's important to make clear in this comme
Shu Chen 2014/06/26 06:55:39 Done.
47 //
48 // Please refer to crbug.com/386066.
49 //
50 const struct MAP0 {
51 uint16 ch0;
52 uint8 vk;
53 bool operator()(const MAP0& m1, const MAP0& m2) const {
54 return m1.ch0 < m2.ch0;
55 }
56 } map0[] = {
57 {0x0025, 0x35},
Wez 2014/06/26 02:10:42 This table is basically impossible to sanity-check
Shu Chen 2014/06/26 06:55:39 Done.
58 {0x0026, 0x31},
59 {0x003C, 0xDC},
60 {0x007B, 0xDE},
61 {0x007C, 0xDC},
62 {0x007D, 0xBF},
63 {0x007E, 0xDC},
64 {0x00A1, 0xDD},
65 {0x00AD, 0xC0},
66 {0x00B0, 0xDE},
67 {0x00B2, 0xDE},
68 {0x00B5, 0xDC},
69 {0x00BB, 0x39},
70 {0x00BD, 0xDC},
71 {0x00BF, 0xDD},
72 {0x00DF, 0xDB},
73 {0x00E5, 0xDD},
74 {0x00EA, 0x33},
75 {0x00EB, 0xBA},
76 {0x00EC, 0xDD},
77 {0x00EE, 0xDD},
78 {0x00F1, 0xC0},
79 {0x00F2, 0xC0},
80 {0x00F5, 0xDB},
81 {0x00F7, 0xDD},
82 {0x00FD, 0x37},
83 {0x00FE, 0xBD},
84 {0x0101, 0xDF},
85 {0x0107, 0xDE},
86 {0x010B, 0xC0},
87 {0x0113, 0x57},
88 {0x011B, 0x32},
89 {0x011F, 0xDD},
90 {0x0121, 0xDB},
91 {0x0127, 0xDD},
92 {0x012B, 0xDD},
93 {0x0131, 0xBA},
94 {0x0137, 0xDC},
95 {0x013C, 0xBF},
96 {0x013E, 0x32},
97 {0x0146, 0xDB},
98 {0x0148, 0xDC},
99 {0x0151, 0xDB},
100 {0x0159, 0x35},
101 {0x015B, 0xDD},
102 {0x0163, 0xDE},
103 {0x0165, 0x35},
104 {0x016F, 0xBA},
105 {0x0171, 0xDC},
106 {0x01A1, 0xDD},
107 {0x01B0, 0xDB},
108 {0x0219, 0xBA},
109 {0x021B, 0xDE},
110 {0x0259, 0xC0},
111 {0x0300, 0x35},
112 {0x0301, 0x38},
113 {0x0303, 0x37},
114 {0x0309, 0x36},
115 {0x0323, 0x39},
116 };
117
118 const struct MAP1 {
119 uint16 ch0;
120 uint8 sc;
121 uint8 vk;
122 bool operator()(const MAP1& m1, const MAP1& m2) const {
123 if (m1.ch0 == m2.ch0)
124 return m1.sc < m2.sc;
125 return m1.ch0 < m2.ch0;
126 }
127 } map1[] = {
128 {0x0021, 0x0A, 0x31},
129 {0x0021, 0x11, 0x38},
130 {0x0021, 0x3D, 0xDF},
131 {0x0022, 0x0B, 0x32},
132 {0x0022, 0x0C, 0x33},
133 {0x0023, 0x31, 0xDE},
134 {0x0024, 0x23, 0xBA},
135 {0x0024, 0x33, 0xDF},
136 {0x0027, 0x0D, 0x34},
137 {0x0027, 0x18, 0xDE},
138 {0x0027, 0x23, 0xBA},
139 {0x0027, 0x3D, 0xDE},
140 {0x0028, 0x0E, 0x35},
141 {0x0028, 0x12, 0x39},
142 {0x0028, 0x33, 0xDC},
143 {0x0029, 0x13, 0x30},
144 {0x0029, 0x14, 0xDB},
145 {0x0029, 0x23, 0xDD},
146 {0x002A, 0x23, 0xBA},
147 {0x002A, 0x33, 0xDC},
148 {0x002B, 0x0A, 0x31},
149 {0x002B, 0x15, 0xBB},
150 {0x002B, 0x22, 0xBB},
151 {0x002B, 0x23, 0xBB},
152 {0x002B, 0x2F, 0xBB},
153 {0x002B, 0x33, 0xBF},
154 {0x002C, 0x0C, 0x33},
155 {0x002C, 0x0E, 0x35},
156 {0x002C, 0x0F, 0x36},
157 {0x002C, 0x12, 0x39},
158 {0x002C, 0x19, 0xBC},
159 {0x002C, 0x37, 0xBC},
160 {0x002C, 0x3A, 0xBC},
161 {0x002C, 0x3B, 0xBC},
162 {0x002D, 0x0B, 0x32},
163 {0x002D, 0x0F, 0x36},
164 {0x002D, 0x14, 0xBD},
165 {0x002D, 0x26, 0xBD},
166 {0x002D, 0x30, 0xBD},
167 {0x002E, 0x10, 0x37},
168 {0x002E, 0x11, 0x38},
169 {0x002E, 0x1A, 0xBE},
170 {0x002E, 0x1B, 0xBE},
171 {0x002E, 0x20, 0xBE},
172 {0x002E, 0x30, 0xDE},
173 {0x002E, 0x3C, 0xBE},
174 {0x002E, 0x3D, 0xBF},
175 {0x002F, 0x14, 0xDB},
176 {0x002F, 0x22, 0xBF},
177 {0x002F, 0x31, 0xDE},
178 {0x002F, 0x33, 0xDC},
179 {0x002F, 0x3D, 0xBF},
180 {0x003A, 0x0A, 0x31},
181 {0x003A, 0x0E, 0x35},
182 {0x003A, 0x0F, 0x36},
183 {0x003A, 0x3C, 0xBF},
184 {0x003B, 0x0D, 0x34},
185 {0x003B, 0x11, 0x38},
186 {0x003B, 0x18, 0xBA},
187 {0x003B, 0x22, 0xBA},
188 {0x003B, 0x23, 0xDD},
189 {0x003B, 0x2F, 0xBA},
190 {0x003B, 0x34, 0xBA},
191 {0x003B, 0x3B, 0xBE},
192 {0x003B, 0x3D, 0xBF},
193 {0x003D, 0x11, 0x38},
194 {0x003D, 0x15, 0xBB},
195 {0x003D, 0x23, 0xBB},
196 {0x003F, 0x0B, 0x32},
197 {0x003F, 0x10, 0x37},
198 {0x003F, 0x11, 0x38},
199 {0x003F, 0x14, 0xBB},
200 {0x0040, 0x23, 0xDD},
201 {0x0040, 0x31, 0xDE},
202 {0x005B, 0x0A, 0xDB},
203 {0x005B, 0x14, 0xDB},
204 {0x005B, 0x22, 0xDB},
205 {0x005B, 0x23, 0xDD},
206 {0x005B, 0x30, 0xDE},
207 {0x005D, 0x0B, 0xDD},
208 {0x005D, 0x15, 0xDD},
209 {0x005D, 0x23, 0xDD},
210 {0x005D, 0x31, 0xC0},
211 {0x005D, 0x33, 0xDC},
212 {0x005F, 0x11, 0x38},
213 {0x005F, 0x14, 0xBD},
214 {0x00A7, 0x0D, 0x34},
215 {0x00A7, 0x0F, 0x36},
216 {0x00A7, 0x30, 0xDE},
217 {0x00AB, 0x11, 0x38},
218 {0x00AB, 0x15, 0xDD},
219 {0x00BA, 0x30, 0xDE},
220 {0x00BA, 0x31, 0xDC},
221 {0x00E0, 0x13, 0x30},
222 {0x00E0, 0x33, 0xDC},
223 {0x00E1, 0x11, 0x38},
224 {0x00E1, 0x30, 0xDE},
225 {0x00E2, 0x0B, 0x32},
226 {0x00E2, 0x33, 0xDC},
227 {0x00E4, 0x23, 0xDD},
228 {0x00E6, 0x2F, 0xC0},
229 {0x00E6, 0x30, 0xDE},
230 {0x00E7, 0x12, 0x39},
231 {0x00E7, 0x22, 0xDB},
232 {0x00E7, 0x23, 0xDD},
233 {0x00E7, 0x30, 0xDE},
234 {0x00E7, 0x33, 0xBF},
235 {0x00E7, 0x3B, 0xBC},
236 {0x00E8, 0x10, 0x37},
237 {0x00E8, 0x22, 0xBA},
238 {0x00E8, 0x30, 0xC0},
239 {0x00E9, 0x0B, 0x32},
240 {0x00E9, 0x13, 0x30},
241 {0x00E9, 0x3D, 0xBF},
242 {0x00ED, 0x12, 0x39},
243 {0x00ED, 0x31, 0x30},
244 {0x00F0, 0x22, 0xDD},
245 {0x00F0, 0x23, 0xBA},
246 {0x00F3, 0x15, 0xBB},
247 {0x00F3, 0x33, 0xDC},
248 {0x00F4, 0x0D, 0x34},
249 {0x00F4, 0x2F, 0xBA},
250 {0x00F6, 0x13, 0xC0},
251 {0x00F6, 0x14, 0xBB},
252 {0x00F6, 0x22, 0xDB},
253 {0x00F8, 0x2F, 0xC0},
254 {0x00F8, 0x30, 0xDE},
255 {0x00F9, 0x30, 0xC0},
256 {0x00F9, 0x33, 0xBF},
257 {0x00FA, 0x22, 0xDB},
258 {0x00FA, 0x23, 0xDD},
259 {0x00FC, 0x19, 0x57},
260 {0x0103, 0x0A, 0x31},
261 {0x0103, 0x22, 0xDB},
262 {0x0105, 0x0A, 0x31},
263 {0x0105, 0x18, 0x51},
264 {0x0105, 0x30, 0xDE},
265 {0x010D, 0x0B, 0x32},
266 {0x010D, 0x0D, 0x34},
267 {0x010D, 0x21, 0x58},
268 {0x010D, 0x2F, 0xBA},
269 {0x010D, 0x3B, 0xBC},
270 {0x0111, 0x13, 0x30},
271 {0x0111, 0x23, 0xDD},
272 {0x0117, 0x0D, 0x34},
273 {0x0117, 0x30, 0xDE},
274 {0x0119, 0x0C, 0x33},
275 {0x012F, 0x0E, 0x35},
276 {0x0142, 0x2F, 0xBA},
277 {0x0142, 0x33, 0xBF},
278 {0x015F, 0x2F, 0xBA},
279 {0x015F, 0x3C, 0xBE},
280 {0x0161, 0x0C, 0x33},
281 {0x0161, 0x0F, 0x36},
282 {0x0161, 0x22, 0xDB},
283 {0x0161, 0x26, 0xBA},
284 {0x0161, 0x29, 0x46},
285 {0x0161, 0x3C, 0xBE},
286 {0x016B, 0x11, 0x38},
287 {0x016B, 0x18, 0x51},
288 {0x016B, 0x35, 0x58},
289 {0x0173, 0x10, 0x37},
290 {0x017C, 0x22, 0xDB},
291 {0x017C, 0x33, 0xDC},
292 {0x017E, 0x0F, 0x36},
293 {0x017E, 0x15, 0xBB},
294 {0x017E, 0x19, 0x57},
295 {0x017E, 0x22, 0x59},
296 {0x017E, 0x33, 0xDC},
297 };
298
299 const struct MAP2 {
300 uint16 ch0;
301 uint8 sc;
302 uint16 ch1;
303 uint8 vk;
304 bool operator()(const MAP2& m1, const MAP2& m2) const {
305 if (m1.ch0 == m2.ch0 && m1.sc == m2.sc)
306 return m1.ch1 < m2.ch1;
307 if (m1.ch0 == m2.ch0)
308 return m1.sc < m2.sc;
309 return m1.ch0 < m2.ch0;
310 }
311 } map2[] = {
312 {0x0023, 0x33, 0x0027, 0xBF},
313 {0x0027, 0x30, 0x0022, 0xDE},
314 {0x0027, 0x31, 0x0022, 0xC0},
315 {0x0027, 0x31, 0x00B7, 0xDC},
316 {0x002D, 0x3D, 0x003D, 0xBD},
317 {0x002F, 0x0C, 0x0033, 0x33},
318 {0x002F, 0x0C, 0x003F, 0xBF},
319 {0x002F, 0x13, 0x0030, 0x30},
320 {0x002F, 0x13, 0x003F, 0xBF},
321 {0x003D, 0x3D, 0x0025, 0xDF},
322 {0x003D, 0x3D, 0x002B, 0xBB},
323 {0x005C, 0x33, 0x002F, 0xDE},
324 {0x005C, 0x33, 0x007C, 0xDC},
325 {0x0060, 0x31, 0x00AC, 0xDF},
326 {0x00A7, 0x31, 0x00B0, 0xBF},
327 {0x00A7, 0x31, 0x00BD, 0xDC},
328 {0x00E0, 0x30, 0x00B0, 0xDE},
329 {0x00E0, 0x30, 0x00E4, 0xDC},
330 {0x00E4, 0x30, 0x00E0, 0xDC},
331 {0x00E9, 0x2F, 0x00C9, 0xBA},
332 {0x00E9, 0x2F, 0x00F6, 0xDE},
333 {0x00F6, 0x2F, 0x00E9, 0xDE},
334 {0x00FC, 0x22, 0x00E8, 0xBA},
335 };
336
337 const struct MAP3 {
338 uint16 ch0;
339 uint8 sc;
340 uint16 ch1;
341 uint16 ch2;
342 uint8 vk;
343 bool operator()(const MAP3& m1, const MAP3& m2) const {
344 if (m1.ch0 == m2.ch0 && m1.sc == m2.sc && m1.ch1 == m2.ch1)
345 return m1.ch2 < m2.ch2;
346 if (m1.ch0 == m2.ch0 && m1.sc == m2.sc)
347 return m1.ch1 < m2.ch1;
348 if (m1.ch0 == m2.ch0)
349 return m1.sc < m2.sc;
350 return m1.ch0 < m2.ch0;
351 }
352 } map3[] = {
353 {0x0023, 0x33, 0x007E, 0x0000, 0xDC},
354 {0x0023, 0x33, 0x007E, 0x001C, 0xDE},
355 {0x0027, 0x14, 0x003F, 0x001C, 0xDB},
356 {0x0027, 0x14, 0x003F, 0x00DD, 0xDB},
357 {0x0027, 0x14, 0x003F, 0xF001, 0xBF},
358 {0x0027, 0x15, 0x002A, 0x0000, 0xBB},
359 {0x0027, 0x15, 0x002A, 0xF001, 0xBF},
360 {0x0027, 0x30, 0x0040, 0x0000, 0xC0},
361 {0x0027, 0x30, 0x0040, 0xF001, 0xC0},
362 {0x0027, 0x33, 0x002A, 0x0000, 0xBF},
363 {0x0027, 0x33, 0x002A, 0x00BD, 0xDC},
364 {0x0027, 0x33, 0x002A, 0x0141, 0xBF},
365 {0x0027, 0x34, 0x0022, 0x0000, 0x5A},
366 {0x0027, 0x34, 0x0022, 0x0158, 0xDE},
367 {0x002B, 0x14, 0x003F, 0x0000, 0xBB},
368 {0x002B, 0x14, 0x003F, 0x005C, 0xBD},
369 {0x002B, 0x14, 0x003F, 0x0151, 0xBB},
370 {0x002B, 0x14, 0x003F, 0xF001, 0xBB},
371 {0x002D, 0x15, 0x005F, 0x0000, 0xBD},
372 {0x002D, 0x15, 0x005F, 0x0157, 0xDB},
373 {0x002D, 0x3D, 0x005F, 0x0000, 0xBD},
374 {0x002D, 0x3D, 0x005F, 0x001F, 0xBD},
375 {0x002D, 0x3D, 0x005F, 0x002A, 0xBD},
376 {0x002D, 0x3D, 0x005F, 0x002F, 0xBF},
377 {0x002D, 0x3D, 0x005F, 0x006E, 0xBD},
378 {0x003D, 0x14, 0x0025, 0x002D, 0xBD},
379 {0x003D, 0x14, 0x0025, 0xF001, 0xBB},
380 {0x005C, 0x31, 0x007C, 0x0031, 0xDC},
381 {0x005C, 0x31, 0x007C, 0x0145, 0xC0},
382 {0x0060, 0x31, 0x007E, 0x0000, 0xC0},
383 {0x0060, 0x31, 0x007E, 0x0031, 0xC0},
384 {0x0060, 0x31, 0x007E, 0x003B, 0xC0},
385 {0x0060, 0x31, 0x007E, 0x0060, 0xC0},
386 {0x0060, 0x31, 0x007E, 0x00BF, 0xC0},
387 {0x0060, 0x31, 0x007E, 0x0151, 0xC0},
388 {0x00E4, 0x30, 0x00C4, 0x0000, 0xDE},
389 {0x00E4, 0x30, 0x00C4, 0x0159, 0xDE},
390 {0x00E4, 0x30, 0x00C4, 0x015A, 0xDE},
391 {0x00E4, 0x30, 0x00C4, 0xF001, 0xBF},
392 {0x00E7, 0x2F, 0x00C7, 0x0000, 0xBA},
393 {0x00E7, 0x2F, 0x00C7, 0x00DE, 0xC0},
394 {0x00F6, 0x2F, 0x00D6, 0x0000, 0xBA},
395 {0x00F6, 0x2F, 0x00D6, 0x01DE, 0xC0},
396 {0x00FC, 0x14, 0x00DC, 0x0000, 0xBD},
397 {0x00FC, 0x14, 0x00DC, 0xF001, 0xBF},
398 {0x00FC, 0x22, 0x00DC, 0x0000, 0xBA},
399 {0x00FC, 0x22, 0x00DC, 0x0141, 0xC0},
400 {0x0119, 0x3D, 0x0118, 0x0000, 0xBD},
401 {0x0119, 0x3D, 0x0118, 0x006E, 0xBF},
402 {0x012F, 0x22, 0x012E, 0x0000, 0xDD},
403 {0x012F, 0x22, 0x012E, 0x001B, 0xDB},
404 {0x0173, 0x2F, 0x0172, 0x0000, 0xC0},
405 {0x0173, 0x2F, 0x0172, 0x01DE, 0xBA},
406 };
407
408 template<class T_MAP>
409 KeyboardCode FindVK(const T_MAP& key, const T_MAP* map, size_t size)
410 {
411 T_MAP comp = {0};
412 const T_MAP* p = std::lower_bound(map, map + size, key, comp);
413 if (p != map + size && !comp(*p, key) && !comp(key, *p))
414 return static_cast<KeyboardCode>(p->vk);
415 return VKEY_UNKNOWN;
416 }
417
418 } // namespace
419
22 // Get an ui::KeyboardCode from an X keyevent 420 // Get an ui::KeyboardCode from an X keyevent
23 KeyboardCode KeyboardCodeFromXKeyEvent(XEvent* xev) { 421 KeyboardCode KeyboardCodeFromXKeyEvent(XEvent* xev) {
24 // XLookupKeysym does not take into consideration the state of the lock/shift 422 // Gets correct VKEY code from XEvent is performed as the following steps:
Wez 2014/06/26 02:10:42 This doesn't necessarily find the correct VKEY, th
Shu Chen 2014/06/26 06:55:40 It is necessary to find the correct VKEY, and US i
25 // etc. keys. So it is necessary to use XLookupString instead. 423 // 1. Gets the keysym without modifier states.
26 KeySym keysym; 424 // 2. For [a-z] & [0-9] cases, returns the VKEY code accordingly.
27 XLookupString(&xev->xkey, NULL, 0, &keysym, NULL); 425 // 3. Find keysym in map0.
28 KeyboardCode keycode = KeyboardCodeFromXKeysym(keysym); 426 // 4. If not found, fallback to find keysym + hardware_code in map1.
29 if (keycode == VKEY_UNKNOWN) { 427 // 5. If not found, fallback to find keysym + keysym_shift + hardware_code
30 keysym = DefaultXKeysymFromHardwareKeycode(xev->xkey.keycode); 428 // in map2.
31 keycode = KeyboardCodeFromXKeysym(keysym); 429 // 6. If not found, fallback to find keysym + keysym_shift + keysym_altgr +
32 } 430 // hardware_code in map3.
431 // 7. If not found, fallback to find in KeyboardCodeFromXKeysym(), which
432 // mainly for non-letter keys.
433 // 8. If not found, fallback to find with the hardward code in US layout.
434
435 KeySym keysym = NoSymbol;
436 XKeyEvent xkey = xev->xkey;
437 xkey.state = 0;
438 XLookupString(&xkey, NULL, 0, &keysym, NULL);
439
440 // [a-z] cases.
441 if (keysym >= XK_a && keysym <= XK_z)
442 return static_cast<KeyboardCode>(VKEY_A + keysym - XK_a);
443
444 // [0-9] cases.
445 if (keysym >= XK_0 && keysym <= XK_9)
446 return static_cast<KeyboardCode>(VKEY_0 + keysym - XK_0);
447
448 MAP0 key0 = {keysym, 0};
449 KeyboardCode keycode = FindVK(key0, map0, arraysize(map0));
450 if (keycode != VKEY_UNKNOWN)
451 return keycode;
452
453 MAP1 key1 = {keysym, xkey.keycode, 0};
454 keycode = FindVK(key1, map1, arraysize(map1));
455 if (keycode != VKEY_UNKNOWN)
456 return keycode;
457
458 KeySym keysym_shift = NoSymbol;
459 xkey.state = ShiftMask;
460 XLookupString(&xkey, NULL, 0, &keysym_shift, NULL);
461 MAP2 key2 = {keysym, keysym_shift, xkey.keycode, 0};
462 keycode = FindVK(key2, map2, arraysize(map2));
463 if (keycode != VKEY_UNKNOWN)
464 return keycode;
465
466 KeySym keysym_altgr = NoSymbol;
467 xkey.state = Mod1Mask;
468 XLookupString(&xkey, NULL, 0, &keysym_altgr, NULL);
469 MAP3 key3 = {keysym, keysym_shift, keysym_altgr, xkey.keycode, 0};
470 keycode = FindVK(key3, map3, arraysize(map3));
471 if (keycode != VKEY_UNKNOWN)
472 return keycode;
473
474 keycode = KeyboardCodeFromXKeysym(keysym);
475 if (keycode == VKEY_UNKNOWN)
476 keycode = DefaultKeyboardCodeFromHardwareKeycode(xkey.keycode);
33 477
34 return keycode; 478 return keycode;
35 } 479 }
36 480
37 KeyboardCode KeyboardCodeFromXKeysym(unsigned int keysym) { 481 KeyboardCode KeyboardCodeFromXKeysym(unsigned int keysym) {
38 // TODO(sad): Have |keysym| go through the X map list? 482 // TODO(sad): Have |keysym| go through the X map list?
39 483
40 switch (keysym) { 484 switch (keysym) {
41 case XK_BackSpace: 485 case XK_BackSpace:
42 return VKEY_BACK; 486 return VKEY_BACK;
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
93 case XK_Hangul_Hanja: 537 case XK_Hangul_Hanja:
94 return VKEY_HANJA; 538 return VKEY_HANJA;
95 case XK_Kanji: 539 case XK_Kanji:
96 return VKEY_KANJI; 540 return VKEY_KANJI;
97 case XK_Henkan: 541 case XK_Henkan:
98 return VKEY_CONVERT; 542 return VKEY_CONVERT;
99 case XK_Muhenkan: 543 case XK_Muhenkan:
100 return VKEY_NONCONVERT; 544 return VKEY_NONCONVERT;
101 case XK_Zenkaku_Hankaku: 545 case XK_Zenkaku_Hankaku:
102 return VKEY_DBE_DBCSCHAR; 546 return VKEY_DBE_DBCSCHAR;
103 case XK_A:
104 case XK_a:
105 return VKEY_A;
106 case XK_B:
107 case XK_b:
108 return VKEY_B;
109 case XK_C:
110 case XK_c:
111 return VKEY_C;
112 case XK_D:
113 case XK_d:
114 return VKEY_D;
115 case XK_E:
116 case XK_e:
117 return VKEY_E;
118 case XK_F:
119 case XK_f:
120 return VKEY_F;
121 case XK_G:
122 case XK_g:
123 return VKEY_G;
124 case XK_H:
125 case XK_h:
126 return VKEY_H;
127 case XK_I:
128 case XK_i:
129 return VKEY_I;
130 case XK_J:
131 case XK_j:
132 return VKEY_J;
133 case XK_K:
134 case XK_k:
135 return VKEY_K;
136 case XK_L:
137 case XK_l:
138 return VKEY_L;
139 case XK_M:
140 case XK_m:
141 return VKEY_M;
142 case XK_N:
143 case XK_n:
144 return VKEY_N;
145 case XK_O:
146 case XK_o:
147 return VKEY_O;
148 case XK_P:
149 case XK_p:
150 return VKEY_P;
151 case XK_Q:
152 case XK_q:
153 return VKEY_Q;
154 case XK_R:
155 case XK_r:
156 return VKEY_R;
157 case XK_S:
158 case XK_s:
159 return VKEY_S;
160 case XK_T:
161 case XK_t:
162 return VKEY_T;
163 case XK_U:
164 case XK_u:
165 return VKEY_U;
166 case XK_V:
167 case XK_v:
168 return VKEY_V;
169 case XK_W:
170 case XK_w:
171 return VKEY_W;
172 case XK_X:
173 case XK_x:
174 return VKEY_X;
175 case XK_Y:
176 case XK_y:
177 return VKEY_Y;
178 case XK_Z:
179 case XK_z:
180 return VKEY_Z;
181
182 case XK_0:
183 case XK_1:
184 case XK_2:
185 case XK_3:
186 case XK_4:
187 case XK_5:
188 case XK_6:
189 case XK_7:
190 case XK_8:
191 case XK_9:
192 return static_cast<KeyboardCode>(VKEY_0 + (keysym - XK_0));
193
194 case XK_parenright:
195 return VKEY_0;
196 case XK_exclam:
197 return VKEY_1;
198 case XK_at:
199 return VKEY_2;
200 case XK_numbersign:
201 return VKEY_3;
202 case XK_dollar:
203 return VKEY_4;
204 case XK_percent:
205 return VKEY_5;
206 case XK_asciicircum:
207 return VKEY_6;
208 case XK_ampersand:
209 return VKEY_7;
210 case XK_asterisk:
211 return VKEY_8;
212 case XK_parenleft:
213 return VKEY_9;
214 547
215 case XK_KP_0: 548 case XK_KP_0:
216 case XK_KP_1: 549 case XK_KP_1:
217 case XK_KP_2: 550 case XK_KP_2:
218 case XK_KP_3: 551 case XK_KP_3:
219 case XK_KP_4: 552 case XK_KP_4:
220 case XK_KP_5: 553 case XK_KP_5:
221 case XK_KP_6: 554 case XK_KP_6:
222 case XK_KP_7: 555 case XK_KP_7:
223 case XK_KP_8: 556 case XK_KP_8:
(...skipping 213 matching lines...) Expand 10 before | Expand all | Expand 10 after
437 int bytes_written = XLookupString(&xev->xkey, buf, 6, NULL, NULL); 770 int bytes_written = XLookupString(&xev->xkey, buf, 6, NULL, NULL);
438 DCHECK_LE(bytes_written, 6); 771 DCHECK_LE(bytes_written, 6);
439 772
440 if (bytes_written <= 0) 773 if (bytes_written <= 0)
441 return 0; 774 return 0;
442 const base::string16& result = base::WideToUTF16( 775 const base::string16& result = base::WideToUTF16(
443 base::SysNativeMBToWide(base::StringPiece(buf, bytes_written))); 776 base::SysNativeMBToWide(base::StringPiece(buf, bytes_written)));
444 return result.length() == 1 ? result[0] : 0; 777 return result.length() == 1 ? result[0] : 0;
445 } 778 }
446 779
447 unsigned int DefaultXKeysymFromHardwareKeycode(unsigned int hardware_code) { 780 KeyboardCode DefaultKeyboardCodeFromHardwareKeycode(
781 unsigned int hardware_code) {
448 // This function assumes that X11 is using evdev-based keycodes. 782 // This function assumes that X11 is using evdev-based keycodes.
449 static const unsigned int kHardwareKeycodeMap[] = { 783 static const KeyboardCode kHardwareKeycodeMap[] = {
450 // This table covers the core 105-key keyboard. 784 // This table covers the core 105-key keyboard.
451 0, // 0x00: 785 VKEY_UNKNOWN, // 0x00:
452 0, // 0x01: 786 VKEY_UNKNOWN, // 0x01:
453 0, // 0x02: 787 VKEY_UNKNOWN, // 0x02:
454 0, // 0x03: 788 VKEY_UNKNOWN, // 0x03:
455 0, // 0x04: 789 VKEY_UNKNOWN, // 0x04:
456 0, // 0x05: 790 VKEY_UNKNOWN, // 0x05:
457 0, // 0x06: 791 VKEY_UNKNOWN, // 0x06:
458 0, // XKB evdev (XKB - 8) X KeySym 792 VKEY_UNKNOWN, // XKB evdev (XKB - 8) X KeySym
459 0, // === =============== ====== 793 VKEY_UNKNOWN, // === =============== ======
460 XK_Escape, // 0x09: KEY_ESC Escape 794 VKEY_ESCAPE, // 0x09: KEY_ESC Escape
461 XK_1, // 0x0A: KEY_1 1 795 VKEY_1, // 0x0A: KEY_1 1
462 XK_2, // 0x0B: KEY_2 2 796 VKEY_2, // 0x0B: KEY_2 2
463 XK_3, // 0x0C: KEY_3 3 797 VKEY_3, // 0x0C: KEY_3 3
464 XK_4, // 0x0D: KEY_4 4 798 VKEY_4, // 0x0D: KEY_4 4
465 XK_5, // 0x0E: KEY_5 5 799 VKEY_5, // 0x0E: KEY_5 5
466 XK_6, // 0x0F: KEY_6 6 800 VKEY_6, // 0x0F: KEY_6 6
467 XK_7, // 0x10: KEY_7 7 801 VKEY_7, // 0x10: KEY_7 7
468 XK_8, // 0x11: KEY_8 8 802 VKEY_8, // 0x11: KEY_8 8
469 XK_9, // 0x12: KEY_9 9 803 VKEY_9, // 0x12: KEY_9 9
470 XK_0, // 0x13: KEY_0 0 804 VKEY_0, // 0x13: KEY_0 0
471 XK_minus, // 0x14: KEY_MINUS minus 805 VKEY_OEM_MINUS, // 0x14: KEY_MINUS minus
472 XK_equal, // 0x15: KEY_EQUAL equal 806 VKEY_OEM_PLUS, // 0x15: KEY_EQUAL equal
473 XK_BackSpace, // 0x16: KEY_BACKSPACE BackSpace 807 VKEY_BACK, // 0x16: KEY_BACKSPACE BackSpace
474 XK_Tab, // 0x17: KEY_TAB Tab 808 VKEY_TAB, // 0x17: KEY_TAB Tab
475 XK_q, // 0x18: KEY_Q q 809 VKEY_Q, // 0x18: KEY_Q q
476 XK_w, // 0x19: KEY_W w 810 VKEY_W, // 0x19: KEY_W w
477 XK_e, // 0x1A: KEY_E e 811 VKEY_E, // 0x1A: KEY_E e
478 XK_r, // 0x1B: KEY_R r 812 VKEY_R, // 0x1B: KEY_R r
479 XK_t, // 0x1C: KEY_T t 813 VKEY_T, // 0x1C: KEY_T t
480 XK_y, // 0x1D: KEY_Y y 814 VKEY_Y, // 0x1D: KEY_Y y
481 XK_u, // 0x1E: KEY_U u 815 VKEY_U, // 0x1E: KEY_U u
482 XK_i, // 0x1F: KEY_I i 816 VKEY_I, // 0x1F: KEY_I i
483 XK_o, // 0x20: KEY_O o 817 VKEY_O, // 0x20: KEY_O o
484 XK_p, // 0x21: KEY_P p 818 VKEY_P, // 0x21: KEY_P p
485 XK_bracketleft, // 0x22: KEY_LEFTBRACE bracketleft 819 VKEY_OEM_4, // 0x22: KEY_LEFTBRACE bracketleft
486 XK_bracketright, // 0x23: KEY_RIGHTBRACE bracketright 820 VKEY_OEM_6, // 0x23: KEY_RIGHTBRACE bracketright
487 XK_Return, // 0x24: KEY_ENTER Return 821 VKEY_RETURN, // 0x24: KEY_ENTER Return
488 XK_Control_L, // 0x25: KEY_LEFTCTRL Control_L 822 VKEY_LCONTROL, // 0x25: KEY_LEFTCTRL Control_L
489 XK_a, // 0x26: KEY_A a 823 VKEY_A, // 0x26: KEY_A a
490 XK_s, // 0x27: KEY_S s 824 VKEY_S, // 0x27: KEY_S s
491 XK_d, // 0x28: KEY_D d 825 VKEY_D, // 0x28: KEY_D d
492 XK_f, // 0x29: KEY_F f 826 VKEY_F, // 0x29: KEY_F f
493 XK_g, // 0x2A: KEY_G g 827 VKEY_G, // 0x2A: KEY_G g
494 XK_h, // 0x2B: KEY_H h 828 VKEY_H, // 0x2B: KEY_H h
495 XK_j, // 0x2C: KEY_J j 829 VKEY_J, // 0x2C: KEY_J j
496 XK_k, // 0x2D: KEY_K k 830 VKEY_K, // 0x2D: KEY_K k
497 XK_l, // 0x2E: KEY_L l 831 VKEY_L, // 0x2E: KEY_L l
498 XK_semicolon, // 0x2F: KEY_SEMICOLON semicolon 832 VKEY_OEM_1, // 0x2F: KEY_SEMICOLON semicolon
499 XK_apostrophe, // 0x30: KEY_APOSTROPHE apostrophe 833 VKEY_OEM_7, // 0x30: KEY_APOSTROPHE apostrophe
500 XK_grave, // 0x31: KEY_GRAVE grave 834 VKEY_OEM_3, // 0x31: KEY_GRAVE grave
501 XK_Shift_L, // 0x32: KEY_LEFTSHIFT Shift_L 835 VKEY_LSHIFT, // 0x32: KEY_LEFTSHIFT Shift_L
502 XK_backslash, // 0x33: KEY_BACKSLASH backslash 836 VKEY_OEM_5, // 0x33: KEY_BACKSLASH backslash
503 XK_z, // 0x34: KEY_Z z 837 VKEY_Z, // 0x34: KEY_Z z
504 XK_x, // 0x35: KEY_X x 838 VKEY_X, // 0x35: KEY_X x
505 XK_c, // 0x36: KEY_C c 839 VKEY_C, // 0x36: KEY_C c
506 XK_v, // 0x37: KEY_V v 840 VKEY_V, // 0x37: KEY_V v
507 XK_b, // 0x38: KEY_B b 841 VKEY_B, // 0x38: KEY_B b
508 XK_n, // 0x39: KEY_N n 842 VKEY_N, // 0x39: KEY_N n
509 XK_m, // 0x3A: KEY_M m 843 VKEY_M, // 0x3A: KEY_M m
510 XK_comma, // 0x3B: KEY_COMMA comma 844 VKEY_OEM_COMMA, // 0x3B: KEY_COMMA comma
511 XK_period, // 0x3C: KEY_DOT period 845 VKEY_OEM_PERIOD, // 0x3C: KEY_DOT period
512 XK_slash, // 0x3D: KEY_SLASH slash 846 VKEY_OEM_2, // 0x3D: KEY_SLASH slash
513 XK_Shift_R, // 0x3E: KEY_RIGHTSHIFT Shift_R 847 VKEY_RSHIFT, // 0x3E: KEY_RIGHTSHIFT Shift_R
514 0, // 0x3F: KEY_KPASTERISK KP_Multiply 848 VKEY_MULTIPLY, // 0x3F: KEY_KPASTERISK KP_Multiply
515 XK_Alt_L, // 0x40: KEY_LEFTALT Alt_L 849 VKEY_LMENU, // 0x40: KEY_LEFTALT Alt_L
516 XK_space, // 0x41: KEY_SPACE space 850 VKEY_SPACE, // 0x41: KEY_SPACE space
517 XK_Caps_Lock, // 0x42: KEY_CAPSLOCK Caps_Lock 851 VKEY_CAPITAL, // 0x42: KEY_CAPSLOCK Caps_Lock
518 XK_F1, // 0x43: KEY_F1 F1 852 VKEY_F1, // 0x43: KEY_F1 F1
519 XK_F2, // 0x44: KEY_F2 F2 853 VKEY_F2, // 0x44: KEY_F2 F2
520 XK_F3, // 0x45: KEY_F3 F3 854 VKEY_F3, // 0x45: KEY_F3 F3
521 XK_F4, // 0x46: KEY_F4 F4 855 VKEY_F4, // 0x46: KEY_F4 F4
522 XK_F5, // 0x47: KEY_F5 F5 856 VKEY_F5, // 0x47: KEY_F5 F5
523 XK_F6, // 0x48: KEY_F6 F6 857 VKEY_F6, // 0x48: KEY_F6 F6
524 XK_F7, // 0x49: KEY_F7 F7 858 VKEY_F7, // 0x49: KEY_F7 F7
525 XK_F8, // 0x4A: KEY_F8 F8 859 VKEY_F8, // 0x4A: KEY_F8 F8
526 XK_F9, // 0x4B: KEY_F9 F9 860 VKEY_F9, // 0x4B: KEY_F9 F9
527 XK_F10, // 0x4C: KEY_F10 F10 861 VKEY_F10, // 0x4C: KEY_F10 F10
528 XK_Num_Lock, // 0x4D: KEY_NUMLOCK Num_Lock 862 VKEY_NUMLOCK, // 0x4D: KEY_NUMLOCK Num_Lock
529 XK_Scroll_Lock, // 0x4E: KEY_SCROLLLOCK Scroll_Lock 863 VKEY_SCROLL, // 0x4E: KEY_SCROLLLOCK Scroll_Lock
530 XK_KP_7, // 0x4F: KEY_KP7 KP_7 864 VKEY_NUMPAD7, // 0x4F: KEY_KP7 KP_7
531 XK_KP_8, // 0x50: KEY_KP8 KP_8 865 VKEY_NUMPAD8, // 0x50: KEY_KP8 KP_8
532 XK_KP_9, // 0x51: KEY_KP9 KP_9 866 VKEY_NUMPAD9, // 0x51: KEY_KP9 KP_9
533 XK_KP_Subtract, // 0x52: KEY_KPMINUS KP_Subtract 867 VKEY_SUBTRACT, // 0x52: KEY_KPMINUS KP_Subtract
534 XK_KP_4, // 0x53: KEY_KP4 KP_4 868 VKEY_NUMPAD4, // 0x53: KEY_KP4 KP_4
535 XK_KP_5, // 0x54: KEY_KP5 KP_5 869 VKEY_NUMPAD5, // 0x54: KEY_KP5 KP_5
536 XK_KP_6, // 0x55: KEY_KP6 KP_6 870 VKEY_NUMPAD6, // 0x55: KEY_KP6 KP_6
537 XK_KP_Add, // 0x56: KEY_KPPLUS KP_Add 871 VKEY_ADD, // 0x56: KEY_KPPLUS KP_Add
538 XK_KP_1, // 0x57: KEY_KP1 KP_1 872 VKEY_NUMPAD1, // 0x57: KEY_KP1 KP_1
539 XK_KP_2, // 0x58: KEY_KP2 KP_2 873 VKEY_NUMPAD2, // 0x58: KEY_KP2 KP_2
540 XK_KP_3, // 0x59: KEY_KP3 KP_3 874 VKEY_NUMPAD3, // 0x59: KEY_KP3 KP_3
541 XK_KP_0, // 0x5A: KEY_KP0 KP_0 875 VKEY_NUMPAD0, // 0x5A: KEY_KP0 KP_0
542 XK_KP_Decimal, // 0x5B: KEY_KPDOT KP_Decimal 876 VKEY_DECIMAL, // 0x5B: KEY_KPDOT KP_Decimal
543 0, // 0x5C: 877 VKEY_UNKNOWN, // 0x5C:
544 XK_Zenkaku_Hankaku, // 0x5D: KEY_ZENKAKUHANKAKU Zenkaku_Hankaku 878 VKEY_DBE_DBCSCHAR, // 0x5D: KEY_ZENKAKUHANKAKU Zenkaku_Hankaku
545 XK_backslash, // 0x5E: KEY_102ND backslash 879 VKEY_OEM_5, // 0x5E: KEY_102ND backslash
546 XK_F11, // 0x5F: KEY_F11 F11 880 VKEY_F11, // 0x5F: KEY_F11 F11
547 XK_F12, // 0x60: KEY_F12 F12 881 VKEY_F12, // 0x60: KEY_F12 F12
548 XK_Romaji, // 0x61: KEY_RO Romaji 882 VKEY_UNKNOWN, // 0x61: KEY_RO Romaji
549 XK_Katakana, // 0x62: KEY_KATAKANA Katakana 883 VKEY_UNKNOWN, // 0x62: KEY_KATAKANA Katakana
550 XK_Hiragana, // 0x63: KEY_HIRAGANA Hiragana 884 VKEY_UNKNOWN, // 0x63: KEY_HIRAGANA Hiragana
551 XK_Henkan, // 0x64: KEY_HENKAN Henkan 885 VKEY_CONVERT, // 0x64: KEY_HENKAN Henkan
552 XK_Hiragana_Katakana, // 0x65: KEY_KATAKANAHIRAGANA Hiragana_Katakana 886 VKEY_UNKNOWN, // 0x65: KEY_KATAKANAHIRAGANA Hiragana_Katakana
553 XK_Muhenkan, // 0x66: KEY_MUHENKAN Muhenkan 887 VKEY_NONCONVERT, // 0x66: KEY_MUHENKAN Muhenkan
554 XK_KP_Separator, // 0x67: KEY_KPJPCOMMA KP_Separator 888 VKEY_SEPARATOR, // 0x67: KEY_KPJPCOMMA KP_Separator
555 XK_KP_Enter, // 0x68: KEY_KPENTER KP_Enter 889 VKEY_RETURN, // 0x68: KEY_KPENTER KP_Enter
556 XK_Control_R, // 0x69: KEY_RIGHTCTRL Control_R 890 VKEY_RCONTROL, // 0x69: KEY_RIGHTCTRL Control_R
557 XK_KP_Divide, // 0x6A: KEY_KPSLASH KP_Divide 891 VKEY_DIVIDE, // 0x6A: KEY_KPSLASH KP_Divide
558 XK_Print, // 0x6B: KEY_SYSRQ Print 892 VKEY_PRINT, // 0x6B: KEY_SYSRQ Print
559 XK_Alt_R, // 0x6C: KEY_RIGHTALT Alt_R 893 VKEY_RMENU, // 0x6C: KEY_RIGHTALT Alt_R
560 XK_Linefeed, // 0x6D: KEY_LINEFEED Linefeed 894 VKEY_RETURN, // 0x6D: KEY_LINEFEED Linefeed
561 XK_Home, // 0x6E: KEY_HOME Home 895 VKEY_HOME, // 0x6E: KEY_HOME Home
562 XK_Up, // 0x6F: KEY_UP Up 896 VKEY_UP, // 0x6F: KEY_UP Up
563 XK_Page_Up, // 0x70: KEY_PAGEUP Page_Up 897 VKEY_PRIOR, // 0x70: KEY_PAGEUP Page_Up
564 XK_Left, // 0x71: KEY_LEFT Left 898 VKEY_LEFT, // 0x71: KEY_LEFT Left
565 XK_Right, // 0x72: KEY_RIGHT Right 899 VKEY_RIGHT, // 0x72: KEY_RIGHT Right
566 XK_End, // 0x73: KEY_END End 900 VKEY_END, // 0x73: KEY_END End
567 XK_Down, // 0x74: KEY_DOWN Down 901 VKEY_DOWN, // 0x74: KEY_DOWN Down
568 XK_Page_Down, // 0x75: KEY_PAGEDOWN Page_Down 902 VKEY_NEXT, // 0x75: KEY_PAGEDOWN Page_Down
569 XK_Insert, // 0x76: KEY_INSERT Insert 903 VKEY_INSERT, // 0x76: KEY_INSERT Insert
570 XK_Delete, // 0x77: KEY_DELETE Delete 904 VKEY_DELETE, // 0x77: KEY_DELETE Delete
571 0, // 0x78: KEY_MACRO 905 VKEY_UNKNOWN, // 0x78: KEY_MACRO
572 XF86XK_AudioMute, // 0x79: KEY_MUTE XF86AudioMute 906 VKEY_VOLUME_MUTE, // 0x79: KEY_MUTE XF86AudioMute
573 XF86XK_AudioLowerVolume, // 0x7A: KEY_VOLUMEDOWN XF86AudioLowerVolume 907 VKEY_VOLUME_DOWN, // 0x7A: KEY_VOLUMEDOWN XF86AudioLowerVolume
574 XF86XK_AudioRaiseVolume, // 0x7B: KEY_VOLUMEUP XF86AudioRaiseVolume 908 VKEY_VOLUME_UP, // 0x7B: KEY_VOLUMEUP XF86AudioRaiseVolume
575 XF86XK_PowerOff, // 0x7C: KEY_POWER XF86PowerOff 909 VKEY_POWER, // 0x7C: KEY_POWER XF86PowerOff
576 XK_KP_Equal, // 0x7D: KEY_KPEQUAL KP_Equal 910 VKEY_OEM_PLUS, // 0x7D: KEY_KPEQUAL KP_Equal
577 XK_plusminus, // 0x7E: KEY_KPPLUSMINUS plusminus 911 VKEY_UNKNOWN, // 0x7E: KEY_KPPLUSMINUS plusminus
578 XK_Pause, // 0x7F: KEY_PAUSE Pause 912 VKEY_PAUSE, // 0x7F: KEY_PAUSE Pause
579 XF86XK_LaunchA, // 0x80: KEY_SCALE XF86LaunchA 913 VKEY_MEDIA_LAUNCH_APP1, // 0x80: KEY_SCALE XF86LaunchA
580 XK_KP_Decimal, // 0x81: KEY_KPCOMMA KP_Decimal 914 VKEY_DECIMAL, // 0x81: KEY_KPCOMMA KP_Decimal
581 XK_Hangul, // 0x82: KEY_HANGUEL Hangul 915 VKEY_HANGUL, // 0x82: KEY_HANGUEL Hangul
582 XK_Hangul_Hanja, // 0x83: KEY_HANJA Hangul_Hanja 916 VKEY_HANJA, // 0x83: KEY_HANJA Hangul_Hanja
583 XK_yen, // 0x84: KEY_YEN yen 917 VKEY_UNKNOWN, // 0x84: KEY_YEN yen
584 XK_Super_L, // 0x85: KEY_LEFTMETA Super_L 918 VKEY_LWIN, // 0x85: KEY_LEFTMETA Super_L
585 XK_Super_R, // 0x86: KEY_RIGHTMETA Super_R 919 VKEY_RWIN, // 0x86: KEY_RIGHTMETA Super_R
586 XK_Menu, // 0x87: KEY_COMPOSE Menu 920 VKEY_COMPOSE, // 0x87: KEY_COMPOSE Menu
587 }; 921 };
588 922
589 if (hardware_code >= arraysize(kHardwareKeycodeMap)) { 923 if (hardware_code >= arraysize(kHardwareKeycodeMap)) {
590 // Additional keycodes used by the Chrome OS top row special function keys. 924 // Additional keycodes used by the Chrome OS top row special function keys.
591 switch (hardware_code) { 925 switch (hardware_code) {
592 case 0xA6: // KEY_BACK 926 case 0xA6: // KEY_BACK
593 return XF86XK_Back; 927 return VKEY_BACK;
594 case 0xA7: // KEY_FORWARD 928 case 0xA7: // KEY_FORWARD
595 return XF86XK_Forward; 929 return VKEY_BROWSER_FORWARD;
596 case 0xB5: // KEY_REFRESH 930 case 0xB5: // KEY_REFRESH
597 return XF86XK_Reload; 931 return VKEY_BROWSER_REFRESH;
598 case 0xD4: // KEY_DASHBOARD 932 case 0xD4: // KEY_DASHBOARD
599 return XF86XK_LaunchB; 933 return VKEY_MEDIA_LAUNCH_APP2;
600 case 0xE8: // KEY_BRIGHTNESSDOWN 934 case 0xE8: // KEY_BRIGHTNESSDOWN
601 return XF86XK_MonBrightnessDown; 935 return VKEY_BRIGHTNESS_DOWN;
602 case 0xE9: // KEY_BRIGHTNESSUP 936 case 0xE9: // KEY_BRIGHTNESSUP
603 return XF86XK_MonBrightnessUp; 937 return VKEY_BRIGHTNESS_UP;
604 } 938 }
605 return 0; 939 return VKEY_UNKNOWN;
606 } 940 }
607 return kHardwareKeycodeMap[hardware_code]; 941 return kHardwareKeycodeMap[hardware_code];
608 } 942 }
609 943
610 // TODO(jcampan): this method might be incomplete. 944 // TODO(jcampan): this method might be incomplete.
611 int XKeysymForWindowsKeyCode(KeyboardCode keycode, bool shift) { 945 int XKeysymForWindowsKeyCode(KeyboardCode keycode, bool shift) {
612 switch (keycode) { 946 switch (keycode) {
613 case VKEY_NUMPAD0: 947 case VKEY_NUMPAD0:
614 return XK_KP_0; 948 return XK_KP_0;
615 case VKEY_NUMPAD1: 949 case VKEY_NUMPAD1:
(...skipping 254 matching lines...) Expand 10 before | Expand all | Expand 10 after
870 case VKEY_KBD_BRIGHTNESS_UP: 1204 case VKEY_KBD_BRIGHTNESS_UP:
871 return XF86XK_KbdBrightnessUp; 1205 return XF86XK_KbdBrightnessUp;
872 1206
873 default: 1207 default:
874 LOG(WARNING) << "Unknown keycode:" << keycode; 1208 LOG(WARNING) << "Unknown keycode:" << keycode;
875 return 0; 1209 return 0;
876 } 1210 }
877 } 1211 }
878 1212
879 } // namespace ui 1213 } // namespace ui
OLDNEW
« no previous file with comments | « ui/events/keycodes/keyboard_code_conversion_x.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698