Index: ui/events/keycodes/keyboard_code_conversion_x.cc |
diff --git a/ui/events/keycodes/keyboard_code_conversion_x.cc b/ui/events/keycodes/keyboard_code_conversion_x.cc |
index 5d6c6ace60609550e06a34e47da506a94bef181b..20c329771e7f75dd6345aba42c82ba077c437114 100644 |
--- a/ui/events/keycodes/keyboard_code_conversion_x.cc |
+++ b/ui/events/keycodes/keyboard_code_conversion_x.cc |
@@ -4,6 +4,8 @@ |
#include "ui/events/keycodes/keyboard_code_conversion_x.h" |
+#include <algorithm> |
+ |
#define XK_3270 // for XK_3270_BackTab |
#include <X11/keysym.h> |
#include <X11/Xlib.h> |
@@ -17,20 +19,525 @@ |
#include "base/strings/utf_string_conversions.h" |
#include "ui/events/keycodes/dom4/keycode_converter.h" |
+#define VKEY_UNSUPPORTED VKEY_UNKNOWN |
+ |
namespace ui { |
+namespace { |
+ |
+// MAP0 - MAP3: |
+// These are the generated VKEY code maps for all possible Latin keyboard |
+// layouts in Windows. And the maps are only for special letter keys excluding |
+// [a-z] & [0-9]. |
+// |
+// ch0: the keysym without modifier states. |
+// ch1: the keysym with shift state. |
+// ch2: the keysym with altgr state. |
+// sc: the hardware keycode (in Windows, it's called scan code). |
+// vk: the VKEY code. |
+// |
+// MAP0: maps from ch0 to vk. |
+// MAP1: maps from ch0+sc to vk. |
+// MAP2: maps from ch0+ch1+sc to vk. |
+// MAP3: maps from ch0+ch1+ch2+sc to vk. |
+// MAP0 - MAP3 are all sorted, so that finding VK can be binary search. |
+// |
+// Reason for creating these maps is because a hard-coded mapping in |
+// KeyboardCodeFromXKeysym() doesn't support non-US keyboard layouts. |
+// e.g. in UK keyboard, the key between Quote and Enter keys has the VKEY code |
+// VKEY_OEM_5 instead of VKEY_3. |
+// |
+// The key symbols which are not [a-zA-Z0-9] and functional/extend keys (e.g. |
+// TAB, ENTER, BS, Arrow keys, modifier keys, F1-F12, media/app keys, etc.) |
+// should go through these maps for correct VKEY codes. |
+// |
+// Please refer to crbug.com/386066. |
+// |
+const struct MAP0 { |
+ uint16 ch0; |
+ uint8 vk; |
+ bool operator()(const MAP0& m1, const MAP0& m2) const { |
+ return m1.ch0 < m2.ch0; |
+ } |
+} map0[] = { |
+ {0x0025, 0x35}, // XK_percent: VKEY_5 |
+ {0x0026, 0x31}, // XK_ampersand: VKEY_1 |
+ {0x003C, 0xDC}, // XK_less: VKEY_OEM_5 |
+ {0x007B, 0xDE}, // XK_braceleft: VKEY_OEM_7 |
+ {0x007C, 0xDC}, // XK_bar: VKEY_OEM_5 |
+ {0x007D, 0xBF}, // XK_braceright: VKEY_OEM_2 |
+ {0x007E, 0xDC}, // XK_asciitilde: VKEY_OEM_5 |
+ {0x00A1, 0xDD}, // XK_exclamdown: VKEY_OEM_6 |
+ {0x00AD, 0xC0}, // XK_hyphen: VKEY_OEM_3 |
+ {0x00B2, 0xDE}, // XK_twosuperior: VKEY_OEM_7 |
+ {0x00B5, 0xDC}, // XK_mu: VKEY_OEM_5 |
+ {0x00BB, 0x39}, // XK_guillemotright: VKEY_9 |
+ {0x00BD, 0xDC}, // XK_onehalf: VKEY_OEM_5 |
+ {0x00BF, 0xDD}, // XK_questiondown: VKEY_OEM_6 |
+ {0x00DF, 0xDB}, // XK_ssharp: VKEY_OEM_4 |
+ {0x00E5, 0xDD}, // XK_aring: VKEY_OEM_6 |
+ {0x00EA, 0x33}, // XK_ecircumflex: VKEY_3 |
+ {0x00EB, 0xBA}, // XK_ediaeresis: VKEY_OEM_1 |
+ {0x00EC, 0xDD}, // XK_igrave: VKEY_OEM_6 |
+ {0x00EE, 0xDD}, // XK_icircumflex: VKEY_OEM_6 |
+ {0x00F1, 0xC0}, // XK_ntilde: VKEY_OEM_3 |
+ {0x00F2, 0xC0}, // XK_ograve: VKEY_OEM_3 |
+ {0x00F5, 0xDB}, // XK_otilde: VKEY_OEM_4 |
+ {0x00F7, 0xDD}, // XK_division: VKEY_OEM_6 |
+ {0x00FD, 0x37}, // XK_yacute: VKEY_7 |
+ {0x00FE, 0xBD}, // XK_thorn: VKEY_OEM_MINUS |
+ {0x01A1, 0xDD}, // XK_ohorn: VKEY_OEM_6 |
+ {0x01B0, 0xDB}, // XK_uhorn: VKEY_OEM_4 |
+ {0x01B5, 0x32}, // XK_lcaron: VKEY_2 |
+ {0x01B6, 0xDD}, // XK_zstroke: VKEY_OEM_6 |
+ {0x01BB, 0x35}, // XK_tcaron: VKEY_5 |
+ {0x01E6, 0xDE}, // XK_cacute: VKEY_OEM_7 |
+ {0x01EC, 0x32}, // XK_ecaron: VKEY_2 |
+ {0x01F2, 0xDC}, // XK_ncaron: VKEY_OEM_5 |
+ {0x01F5, 0xDB}, // XK_odoubleacute: VKEY_OEM_4 |
+ {0x01F8, 0x35}, // XK_rcaron: VKEY_5 |
+ {0x01F9, 0xBA}, // XK_uring: VKEY_OEM_1 |
+ {0x01FB, 0xDC}, // XK_udoubleacute: VKEY_OEM_5 |
+ {0x01FE, 0xDE}, // XK_tcedilla: VKEY_OEM_7 |
+ {0x0259, 0xC0}, // XK_schwa: VKEY_OEM_3 |
+ {0x02B1, 0xDD}, // XK_hstroke: VKEY_OEM_6 |
+ {0x02B9, 0xBA}, // XK_idotless: VKEY_OEM_1 |
+ {0x02BB, 0xDD}, // XK_gbreve: VKEY_OEM_6 |
+ {0x02E5, 0xC0}, // XK_cabovedot: VKEY_OEM_3 |
+ {0x02F5, 0xDB}, // XK_gabovedot: VKEY_OEM_4 |
+ {0x03B6, 0xBF}, // XK_lcedilla: VKEY_OEM_2 |
+ {0x03BA, 0x57}, // XK_emacron: VKEY_W |
+ {0x03E0, 0xDF}, // XK_amacron: VKEY_OEM_8 |
+ {0x03EF, 0xDD}, // XK_imacron: VKEY_OEM_6 |
+ {0x03F1, 0xDB}, // XK_ncedilla: VKEY_OEM_4 |
+ {0x03F3, 0xDC}, // XK_kcedilla: VKEY_OEM_5 |
+}; |
+ |
+const struct MAP1 { |
+ uint16 ch0; |
+ uint8 sc; |
+ uint8 vk; |
+ bool operator()(const MAP1& m1, const MAP1& m2) const { |
+ if (m1.ch0 == m2.ch0) |
+ return m1.sc < m2.sc; |
+ return m1.ch0 < m2.ch0; |
+ } |
+} map1[] = { |
+ {0x0021, 0x0A, 0x31}, // XK_exclam+AE01: VKEY_1 |
+ {0x0021, 0x11, 0x38}, // XK_exclam+AE08: VKEY_8 |
+ {0x0021, 0x3D, 0xDF}, // XK_exclam+AB10: VKEY_OEM_8 |
+ {0x0022, 0x0B, 0x32}, // XK_quotedbl+AE02: VKEY_2 |
+ {0x0022, 0x0C, 0x33}, // XK_quotedbl+AE03: VKEY_3 |
+ {0x0023, 0x31, 0xDE}, // XK_numbersign+TLDE: VKEY_OEM_7 |
+ {0x0024, 0x23, 0xBA}, // XK_dollar+AD12: VKEY_OEM_1 |
+ {0x0024, 0x33, 0xDF}, // XK_dollar+BKSL: VKEY_OEM_8 |
+ {0x0027, 0x0D, 0x34}, // XK_quoteright+AE04: VKEY_4 |
+ {0x0027, 0x18, 0xDE}, // XK_quoteright+AD01: VKEY_OEM_7 |
+ {0x0027, 0x23, 0xBA}, // XK_quoteright+AD12: VKEY_OEM_1 |
+ {0x0027, 0x3D, 0xDE}, // XK_quoteright+AB10: VKEY_OEM_7 |
+ {0x0028, 0x0E, 0x35}, // XK_parenleft+AE05: VKEY_5 |
+ {0x0028, 0x12, 0x39}, // XK_parenleft+AE09: VKEY_9 |
+ {0x0028, 0x33, 0xDC}, // XK_parenleft+BKSL: VKEY_OEM_5 |
+ {0x0029, 0x13, 0x30}, // XK_parenright+AE10: VKEY_0 |
+ {0x0029, 0x14, 0xDB}, // XK_parenright+AE11: VKEY_OEM_4 |
+ {0x0029, 0x23, 0xDD}, // XK_parenright+AD12: VKEY_OEM_6 |
+ {0x002A, 0x23, 0xBA}, // XK_asterisk+AD12: VKEY_OEM_1 |
+ {0x002A, 0x33, 0xDC}, // XK_asterisk+BKSL: VKEY_OEM_5 |
+ {0x002B, 0x0A, 0x31}, // XK_plus+AE01: VKEY_1 |
+ {0x002B, 0x15, 0xBB}, // XK_plus+AE12: VKEY_OEM_PLUS |
+ {0x002B, 0x22, 0xBB}, // XK_plus+AD11: VKEY_OEM_PLUS |
+ {0x002B, 0x23, 0xBB}, // XK_plus+AD12: VKEY_OEM_PLUS |
+ {0x002B, 0x2F, 0xBB}, // XK_plus+AC10: VKEY_OEM_PLUS |
+ {0x002B, 0x33, 0xBF}, // XK_plus+BKSL: VKEY_OEM_2 |
+ {0x002C, 0x0C, 0x33}, // XK_comma+AE03: VKEY_3 |
+ {0x002C, 0x0E, 0x35}, // XK_comma+AE05: VKEY_5 |
+ {0x002C, 0x0F, 0x36}, // XK_comma+AE06: VKEY_6 |
+ {0x002C, 0x12, 0x39}, // XK_comma+AE09: VKEY_9 |
+ {0x002C, 0x19, 0xBC}, // XK_comma+AD02: VKEY_OEM_COMMA |
+ {0x002C, 0x37, 0xBC}, // XK_comma+AB04: VKEY_OEM_COMMA |
+ {0x002C, 0x3A, 0xBC}, // XK_comma+AB07: VKEY_OEM_COMMA |
+ {0x002C, 0x3B, 0xBC}, // XK_comma+AB08: VKEY_OEM_COMMA |
+ {0x002D, 0x0B, 0x32}, // XK_minus+AE02: VKEY_2 |
+ {0x002D, 0x0F, 0x36}, // XK_minus+AE06: VKEY_6 |
+ {0x002D, 0x14, 0xBD}, // XK_minus+AE11: VKEY_OEM_MINUS |
+ {0x002D, 0x26, 0xBD}, // XK_minus+AC01: VKEY_OEM_MINUS |
+ {0x002D, 0x30, 0xBD}, // XK_minus+AC11: VKEY_OEM_MINUS |
+ {0x002E, 0x10, 0x37}, // XK_period+AE07: VKEY_7 |
+ {0x002E, 0x11, 0x38}, // XK_period+AE08: VKEY_8 |
+ {0x002E, 0x1A, 0xBE}, // XK_period+AD03: VKEY_OEM_PERIOD |
+ {0x002E, 0x1B, 0xBE}, // XK_period+AD04: VKEY_OEM_PERIOD |
+ {0x002E, 0x20, 0xBE}, // XK_period+AD09: VKEY_OEM_PERIOD |
+ {0x002E, 0x30, 0xDE}, // XK_period+AC11: VKEY_OEM_7 |
+ {0x002E, 0x3C, 0xBE}, // XK_period+AB09: VKEY_OEM_PERIOD |
+ {0x002E, 0x3D, 0xBF}, // XK_period+AB10: VKEY_OEM_2 |
+ {0x002F, 0x14, 0xDB}, // XK_slash+AE11: VKEY_OEM_4 |
+ {0x002F, 0x22, 0xBF}, // XK_slash+AD11: VKEY_OEM_2 |
+ {0x002F, 0x31, 0xDE}, // XK_slash+TLDE: VKEY_OEM_7 |
+ {0x002F, 0x33, 0xDC}, // XK_slash+BKSL: VKEY_OEM_5 |
+ {0x002F, 0x3D, 0xBF}, // XK_slash+AB10: VKEY_OEM_2 |
+ {0x003A, 0x0A, 0x31}, // XK_colon+AE01: VKEY_1 |
+ {0x003A, 0x0E, 0x35}, // XK_colon+AE05: VKEY_5 |
+ {0x003A, 0x0F, 0x36}, // XK_colon+AE06: VKEY_6 |
+ {0x003A, 0x3C, 0xBF}, // XK_colon+AB09: VKEY_OEM_2 |
+ {0x003B, 0x0D, 0x34}, // XK_semicolon+AE04: VKEY_4 |
+ {0x003B, 0x11, 0x38}, // XK_semicolon+AE08: VKEY_8 |
+ {0x003B, 0x18, 0xBA}, // XK_semicolon+AD01: VKEY_OEM_1 |
+ {0x003B, 0x22, 0xBA}, // XK_semicolon+AD11: VKEY_OEM_1 |
+ {0x003B, 0x23, 0xDD}, // XK_semicolon+AD12: VKEY_OEM_6 |
+ {0x003B, 0x2F, 0xBA}, // XK_semicolon+AC10: VKEY_OEM_1 |
+ {0x003B, 0x31, 0xC0}, // XK_semicolon+TLDE: VKEY_OEM_3 |
+ {0x003B, 0x34, 0xBA}, // XK_semicolon+AB01: VKEY_OEM_1 |
+ {0x003B, 0x3B, 0xBE}, // XK_semicolon+AB08: VKEY_OEM_PERIOD |
+ {0x003B, 0x3D, 0xBF}, // XK_semicolon+AB10: VKEY_OEM_2 |
+ {0x003D, 0x11, 0x38}, // XK_equal+AE08: VKEY_8 |
+ {0x003D, 0x15, 0xBB}, // XK_equal+AE12: VKEY_OEM_PLUS |
+ {0x003D, 0x23, 0xBB}, // XK_equal+AD12: VKEY_OEM_PLUS |
+ {0x003F, 0x0B, 0x32}, // XK_question+AE02: VKEY_2 |
+ {0x003F, 0x10, 0x37}, // XK_question+AE07: VKEY_7 |
+ {0x003F, 0x11, 0x38}, // XK_question+AE08: VKEY_8 |
+ {0x003F, 0x14, 0xBB}, // XK_question+AE11: VKEY_OEM_PLUS |
+ {0x0040, 0x23, 0xDD}, // XK_at+AD12: VKEY_OEM_6 |
+ {0x0040, 0x31, 0xDE}, // XK_at+TLDE: VKEY_OEM_7 |
+ {0x005B, 0x0A, 0xDB}, // XK_bracketleft+AE01: VKEY_OEM_4 |
+ {0x005B, 0x14, 0xDB}, // XK_bracketleft+AE11: VKEY_OEM_4 |
+ {0x005B, 0x22, 0xDB}, // XK_bracketleft+AD11: VKEY_OEM_4 |
+ {0x005B, 0x23, 0xDD}, // XK_bracketleft+AD12: VKEY_OEM_6 |
+ {0x005B, 0x30, 0xDE}, // XK_bracketleft+AC11: VKEY_OEM_7 |
+ {0x005C, 0x15, 0xDB}, // XK_backslash+AE12: VKEY_OEM_4 |
+ {0x005D, 0x0B, 0xDD}, // XK_bracketright+AE02: VKEY_OEM_6 |
+ {0x005D, 0x15, 0xDD}, // XK_bracketright+AE12: VKEY_OEM_6 |
+ {0x005D, 0x23, 0xDD}, // XK_bracketright+AD12: VKEY_OEM_6 |
+ {0x005D, 0x31, 0xC0}, // XK_bracketright+TLDE: VKEY_OEM_3 |
+ {0x005D, 0x33, 0xDC}, // XK_bracketright+BKSL: VKEY_OEM_5 |
+ {0x005F, 0x11, 0x38}, // XK_underscore+AE08: VKEY_8 |
+ {0x005F, 0x14, 0xBD}, // XK_underscore+AE11: VKEY_OEM_MINUS |
+ {0x00A7, 0x0D, 0x34}, // XK_section+AE04: VKEY_4 |
+ {0x00A7, 0x0F, 0x36}, // XK_section+AE06: VKEY_6 |
+ {0x00A7, 0x30, 0xDE}, // XK_section+AC11: VKEY_OEM_7 |
+ {0x00AB, 0x11, 0x38}, // XK_guillemotleft+AE08: VKEY_8 |
+ {0x00AB, 0x15, 0xDD}, // XK_guillemotleft+AE12: VKEY_OEM_6 |
+ {0x00B0, 0x15, 0xBF}, // XK_degree+AE12: VKEY_OEM_2 |
+ {0x00B0, 0x31, 0xDE}, // XK_degree+TLDE: VKEY_OEM_7 |
+ {0x00BA, 0x30, 0xDE}, // XK_masculine+AC11: VKEY_OEM_7 |
+ {0x00BA, 0x31, 0xDC}, // XK_masculine+TLDE: VKEY_OEM_5 |
+ {0x00E0, 0x13, 0x30}, // XK_agrave+AE10: VKEY_0 |
+ {0x00E0, 0x33, 0xDC}, // XK_agrave+BKSL: VKEY_OEM_5 |
+ {0x00E1, 0x11, 0x38}, // XK_aacute+AE08: VKEY_8 |
+ {0x00E1, 0x30, 0xDE}, // XK_aacute+AC11: VKEY_OEM_7 |
+ {0x00E2, 0x0B, 0x32}, // XK_acircumflex+AE02: VKEY_2 |
+ {0x00E2, 0x33, 0xDC}, // XK_acircumflex+BKSL: VKEY_OEM_5 |
+ {0x00E4, 0x23, 0xDD}, // XK_adiaeresis+AD12: VKEY_OEM_6 |
+ {0x00E6, 0x2F, 0xC0}, // XK_ae+AC10: VKEY_OEM_3 |
+ {0x00E6, 0x30, 0xDE}, // XK_ae+AC11: VKEY_OEM_7 |
+ {0x00E7, 0x12, 0x39}, // XK_ccedilla+AE09: VKEY_9 |
+ {0x00E7, 0x22, 0xDB}, // XK_ccedilla+AD11: VKEY_OEM_4 |
+ {0x00E7, 0x23, 0xDD}, // XK_ccedilla+AD12: VKEY_OEM_6 |
+ {0x00E7, 0x30, 0xDE}, // XK_ccedilla+AC11: VKEY_OEM_7 |
+ {0x00E7, 0x33, 0xBF}, // XK_ccedilla+BKSL: VKEY_OEM_2 |
+ {0x00E7, 0x3B, 0xBC}, // XK_ccedilla+AB08: VKEY_OEM_COMMA |
+ {0x00E8, 0x10, 0x37}, // XK_egrave+AE07: VKEY_7 |
+ {0x00E8, 0x22, 0xBA}, // XK_egrave+AD11: VKEY_OEM_1 |
+ {0x00E8, 0x30, 0xC0}, // XK_egrave+AC11: VKEY_OEM_3 |
+ {0x00E9, 0x0B, 0x32}, // XK_eacute+AE02: VKEY_2 |
+ {0x00E9, 0x13, 0x30}, // XK_eacute+AE10: VKEY_0 |
+ {0x00E9, 0x3D, 0xBF}, // XK_eacute+AB10: VKEY_OEM_2 |
+ {0x00ED, 0x12, 0x39}, // XK_iacute+AE09: VKEY_9 |
+ {0x00ED, 0x31, 0x30}, // XK_iacute+TLDE: VKEY_0 |
+ {0x00F0, 0x22, 0xDD}, // XK_eth+AD11: VKEY_OEM_6 |
+ {0x00F0, 0x23, 0xBA}, // XK_eth+AD12: VKEY_OEM_1 |
+ {0x00F3, 0x15, 0xBB}, // XK_oacute+AE12: VKEY_OEM_PLUS |
+ {0x00F3, 0x33, 0xDC}, // XK_oacute+BKSL: VKEY_OEM_5 |
+ {0x00F4, 0x0D, 0x34}, // XK_ocircumflex+AE04: VKEY_4 |
+ {0x00F4, 0x2F, 0xBA}, // XK_ocircumflex+AC10: VKEY_OEM_1 |
+ {0x00F6, 0x13, 0xC0}, // XK_odiaeresis+AE10: VKEY_OEM_3 |
+ {0x00F6, 0x14, 0xBB}, // XK_odiaeresis+AE11: VKEY_OEM_PLUS |
+ {0x00F6, 0x22, 0xDB}, // XK_odiaeresis+AD11: VKEY_OEM_4 |
+ {0x00F8, 0x2F, 0xC0}, // XK_oslash+AC10: VKEY_OEM_3 |
+ {0x00F8, 0x30, 0xDE}, // XK_oslash+AC11: VKEY_OEM_7 |
+ {0x00F9, 0x30, 0xC0}, // XK_ugrave+AC11: VKEY_OEM_3 |
+ {0x00F9, 0x33, 0xBF}, // XK_ugrave+BKSL: VKEY_OEM_2 |
+ {0x00FA, 0x22, 0xDB}, // XK_uacute+AD11: VKEY_OEM_4 |
+ {0x00FA, 0x23, 0xDD}, // XK_uacute+AD12: VKEY_OEM_6 |
+ {0x00FC, 0x19, 0x57}, // XK_udiaeresis+AD02: VKEY_W |
+ {0x01B1, 0x0A, 0x31}, // XK_aogonek+AE01: VKEY_1 |
+ {0x01B1, 0x18, 0x51}, // XK_aogonek+AD01: VKEY_Q |
+ {0x01B1, 0x30, 0xDE}, // XK_aogonek+AC11: VKEY_OEM_7 |
+ {0x01B3, 0x2F, 0xBA}, // XK_lstroke+AC10: VKEY_OEM_1 |
+ {0x01B3, 0x33, 0xBF}, // XK_lstroke+BKSL: VKEY_OEM_2 |
+ {0x01B9, 0x0C, 0x33}, // XK_scaron+AE03: VKEY_3 |
+ {0x01B9, 0x0F, 0x36}, // XK_scaron+AE06: VKEY_6 |
+ {0x01B9, 0x22, 0xDB}, // XK_scaron+AD11: VKEY_OEM_4 |
+ {0x01B9, 0x26, 0xBA}, // XK_scaron+AC01: VKEY_OEM_1 |
+ {0x01B9, 0x29, 0x46}, // XK_scaron+AC04: VKEY_F |
+ {0x01B9, 0x3C, 0xBE}, // XK_scaron+AB09: VKEY_OEM_PERIOD |
+ {0x01BA, 0x2F, 0xBA}, // XK_scedilla+AC10: VKEY_OEM_1 |
+ {0x01BA, 0x3C, 0xBE}, // XK_scedilla+AB09: VKEY_OEM_PERIOD |
+ {0x01BE, 0x0F, 0x36}, // XK_zcaron+AE06: VKEY_6 |
+ {0x01BE, 0x15, 0xBB}, // XK_zcaron+AE12: VKEY_OEM_PLUS |
+ {0x01BE, 0x19, 0x57}, // XK_zcaron+AD02: VKEY_W |
+ {0x01BE, 0x22, 0x59}, // XK_zcaron+AD11: VKEY_Y |
+ {0x01BE, 0x33, 0xDC}, // XK_zcaron+BKSL: VKEY_OEM_5 |
+ {0x01BF, 0x22, 0xDB}, // XK_zabovedot+AD11: VKEY_OEM_4 |
+ {0x01BF, 0x33, 0xDC}, // XK_zabovedot+BKSL: VKEY_OEM_5 |
+ {0x01E3, 0x0A, 0x31}, // XK_abreve+AE01: VKEY_1 |
+ {0x01E3, 0x22, 0xDB}, // XK_abreve+AD11: VKEY_OEM_4 |
+ {0x01E8, 0x0B, 0x32}, // XK_ccaron+AE02: VKEY_2 |
+ {0x01E8, 0x0D, 0x34}, // XK_ccaron+AE04: VKEY_4 |
+ {0x01E8, 0x21, 0x58}, // XK_ccaron+AD10: VKEY_X |
+ {0x01E8, 0x2F, 0xBA}, // XK_ccaron+AC10: VKEY_OEM_1 |
+ {0x01E8, 0x3B, 0xBC}, // XK_ccaron+AB08: VKEY_OEM_COMMA |
+ {0x01EA, 0x0C, 0x33}, // XK_eogonek+AE03: VKEY_3 |
+ {0x01F0, 0x13, 0x30}, // XK_dstroke+AE10: VKEY_0 |
+ {0x01F0, 0x23, 0xDD}, // XK_dstroke+AD12: VKEY_OEM_6 |
+ {0x03E7, 0x0E, 0x35}, // XK_iogonek+AE05: VKEY_5 |
+ {0x03EC, 0x0D, 0x34}, // XK_eabovedot+AE04: VKEY_4 |
+ {0x03EC, 0x30, 0xDE}, // XK_eabovedot+AC11: VKEY_OEM_7 |
+ {0x03F9, 0x10, 0x37}, // XK_uogonek+AE07: VKEY_7 |
+ {0x03FE, 0x11, 0x38}, // XK_umacron+AE08: VKEY_8 |
+ {0x03FE, 0x18, 0x51}, // XK_umacron+AD01: VKEY_Q |
+ {0x03FE, 0x35, 0x58}, // XK_umacron+AB02: VKEY_X |
+}; |
+ |
+const struct MAP2 { |
+ uint16 ch0; |
+ uint8 sc; |
+ uint16 ch1; |
+ uint8 vk; |
+ bool operator()(const MAP2& m1, const MAP2& m2) const { |
+ if (m1.ch0 == m2.ch0 && m1.sc == m2.sc) |
+ return m1.ch1 < m2.ch1; |
+ if (m1.ch0 == m2.ch0) |
+ return m1.sc < m2.sc; |
+ return m1.ch0 < m2.ch0; |
+ } |
+} map2[] = { |
+ {0x0023, 0x33, 0x0027, |
+ 0xBF}, // XK_numbersign+BKSL+XK_quoteright: VKEY_OEM_2 |
+ {0x0027, 0x30, 0x0022, |
+ 0xDE}, // XK_quoteright+AC11+XK_quotedbl: VKEY_OEM_7 |
+ {0x0027, 0x31, 0x0022, |
+ 0xC0}, // XK_quoteright+TLDE+XK_quotedbl: VKEY_OEM_3 |
+ {0x0027, 0x31, 0x00B7, |
+ 0xDC}, // XK_quoteright+TLDE+XK_periodcentered: VKEY_OEM_5 |
+ {0x0027, 0x33, 0x0000, 0xDC}, // XK_quoteright+BKSL+NoSymbol: VKEY_OEM_5 |
+ {0x002D, 0x3D, 0x003D, 0xBD}, // XK_minus+AB10+XK_equal: VKEY_OEM_MINUS |
+ {0x002F, 0x0C, 0x0033, 0x33}, // XK_slash+AE03+XK_3: VKEY_3 |
+ {0x002F, 0x0C, 0x003F, 0xBF}, // XK_slash+AE03+XK_question: VKEY_OEM_2 |
+ {0x002F, 0x13, 0x0030, 0x30}, // XK_slash+AE10+XK_0: VKEY_0 |
+ {0x002F, 0x13, 0x003F, 0xBF}, // XK_slash+AE10+XK_question: VKEY_OEM_2 |
+ {0x003D, 0x3D, 0x0025, 0xDF}, // XK_equal+AB10+XK_percent: VKEY_OEM_8 |
+ {0x003D, 0x3D, 0x002B, 0xBB}, // XK_equal+AB10+XK_plus: VKEY_OEM_PLUS |
+ {0x005C, 0x33, 0x002F, 0xDE}, // XK_backslash+BKSL+XK_slash: VKEY_OEM_7 |
+ {0x005C, 0x33, 0x007C, 0xDC}, // XK_backslash+BKSL+XK_bar: VKEY_OEM_5 |
+ {0x0060, 0x31, 0x0000, 0xC0}, // XK_quoteleft+TLDE+NoSymbol: VKEY_OEM_3 |
+ {0x0060, 0x31, 0x00AC, 0xDF}, // XK_quoteleft+TLDE+XK_notsign: VKEY_OEM_8 |
+ {0x00A7, 0x31, 0x00B0, 0xBF}, // XK_section+TLDE+XK_degree: VKEY_OEM_2 |
+ {0x00A7, 0x31, 0x00BD, 0xDC}, // XK_section+TLDE+XK_onehalf: VKEY_OEM_5 |
+ {0x00E0, 0x30, 0x00B0, 0xDE}, // XK_agrave+AC11+XK_degree: VKEY_OEM_7 |
+ {0x00E0, 0x30, 0x00E4, 0xDC}, // XK_agrave+AC11+XK_adiaeresis: VKEY_OEM_5 |
+ {0x00E4, 0x30, 0x00E0, 0xDC}, // XK_adiaeresis+AC11+XK_agrave: VKEY_OEM_5 |
+ {0x00E9, 0x2F, 0x00C9, 0xBA}, // XK_eacute+AC10+XK_Eacute: VKEY_OEM_1 |
+ {0x00E9, 0x2F, 0x00F6, 0xDE}, // XK_eacute+AC10+XK_odiaeresis: VKEY_OEM_7 |
+ {0x00F6, 0x2F, 0x00E9, 0xDE}, // XK_odiaeresis+AC10+XK_eacute: VKEY_OEM_7 |
+ {0x00FC, 0x22, 0x00E8, 0xBA}, // XK_udiaeresis+AD11+XK_egrave: VKEY_OEM_1 |
+}; |
+ |
+const struct MAP3 { |
+ uint16 ch0; |
+ uint8 sc; |
+ uint16 ch1; |
+ uint16 ch2; |
+ uint8 vk; |
+ bool operator()(const MAP3& m1, const MAP3& m2) const { |
+ if (m1.ch0 == m2.ch0 && m1.sc == m2.sc && m1.ch1 == m2.ch1) |
+ return m1.ch2 < m2.ch2; |
+ if (m1.ch0 == m2.ch0 && m1.sc == m2.sc) |
+ return m1.ch1 < m2.ch1; |
+ if (m1.ch0 == m2.ch0) |
+ return m1.sc < m2.sc; |
+ return m1.ch0 < m2.ch0; |
+ } |
+} map3[] = { |
+ {0x0023, 0x33, 0x007E, 0x0000, |
+ 0xDE}, // XK_numbersign+BKSL+XK_asciitilde+NoSymbol: VKEY_OEM_7 |
+ {0x0027, 0x14, 0x003F, 0x0000, |
+ 0xDB}, // XK_quoteright+AE11+XK_question+NoSymbol: VKEY_OEM_4 |
+ {0x0027, 0x14, 0x003F, 0x00DD, |
+ 0xDB}, // XK_quoteright+AE11+XK_question+XK_Yacute: VKEY_OEM_4 |
+ {0x0027, 0x15, 0x002A, 0x0000, |
+ 0xBB}, // XK_quoteright+AE12+XK_asterisk+NoSymbol: VKEY_OEM_PLUS |
+ {0x0027, 0x30, 0x0040, 0x0000, |
+ 0xC0}, // XK_quoteright+AC11+XK_at+NoSymbol: VKEY_OEM_3 |
+ {0x0027, 0x33, 0x002A, 0x0000, |
+ 0xBF}, // XK_quoteright+BKSL+XK_asterisk+NoSymbol: VKEY_OEM_2 |
+ {0x0027, 0x33, 0x002A, 0x00BD, |
+ 0xDC}, // XK_quoteright+BKSL+XK_asterisk+XK_onehalf: VKEY_OEM_5 |
+ {0x0027, 0x33, 0x002A, 0x01A3, |
+ 0xBF}, // XK_quoteright+BKSL+XK_asterisk+XK_Lstroke: VKEY_OEM_2 |
+ {0x0027, 0x34, 0x0022, 0x0000, |
+ 0x5A}, // XK_quoteright+AB01+XK_quotedbl+NoSymbol: VKEY_Z |
+ {0x0027, 0x34, 0x0022, 0x01D8, |
+ 0xDE}, // XK_quoteright+AB01+XK_quotedbl+XK_Rcaron: VKEY_OEM_7 |
+ {0x002B, 0x14, 0x003F, 0x0000, |
+ 0xBB}, // XK_plus+AE11+XK_question+NoSymbol: VKEY_OEM_PLUS |
+ {0x002B, 0x14, 0x003F, 0x005C, |
+ 0xBD}, // XK_plus+AE11+XK_question+XK_backslash: VKEY_OEM_MINUS |
+ {0x002B, 0x14, 0x003F, 0x01F5, |
+ 0xBB}, // XK_plus+AE11+XK_question+XK_odoubleacute: VKEY_OEM_PLUS |
+ {0x002D, 0x15, 0x005F, 0x0000, |
+ 0xBD}, // XK_minus+AE12+XK_underscore+NoSymbol: VKEY_OEM_MINUS |
+ {0x002D, 0x15, 0x005F, 0x03B3, |
+ 0xDB}, // XK_minus+AE12+XK_underscore+XK_rcedilla: VKEY_OEM_4 |
+ {0x002D, 0x3D, 0x005F, 0x0000, |
+ 0xBD}, // XK_minus+AB10+XK_underscore+NoSymbol: VKEY_OEM_MINUS |
+ {0x002D, 0x3D, 0x005F, 0x002A, |
+ 0xBD}, // XK_minus+AB10+XK_underscore+XK_asterisk: VKEY_OEM_MINUS |
+ {0x002D, 0x3D, 0x005F, 0x002F, |
+ 0xBF}, // XK_minus+AB10+XK_underscore+XK_slash: VKEY_OEM_2 |
+ {0x002D, 0x3D, 0x005F, 0x006E, |
+ 0xBD}, // XK_minus+AB10+XK_underscore+XK_n: VKEY_OEM_MINUS |
+ {0x003D, 0x14, 0x0025, 0x0000, |
+ 0xBB}, // XK_equal+AE11+XK_percent+NoSymbol: VKEY_OEM_PLUS |
+ {0x003D, 0x14, 0x0025, 0x002D, |
+ 0xBD}, // XK_equal+AE11+XK_percent+XK_minus: VKEY_OEM_MINUS |
+ {0x005C, 0x31, 0x007C, 0x0031, |
+ 0xDC}, // XK_backslash+TLDE+XK_bar+XK_1: VKEY_OEM_5 |
+ {0x005C, 0x31, 0x007C, 0x03D1, |
+ 0xC0}, // XK_backslash+TLDE+XK_bar+XK_Ncedilla: VKEY_OEM_3 |
+ {0x0060, 0x31, 0x007E, 0x0000, |
+ 0xC0}, // XK_quoteleft+TLDE+XK_asciitilde+NoSymbol: VKEY_OEM_3 |
+ {0x0060, 0x31, 0x007E, 0x0031, |
+ 0xC0}, // XK_quoteleft+TLDE+XK_asciitilde+XK_1: VKEY_OEM_3 |
+ {0x0060, 0x31, 0x007E, 0x003B, |
+ 0xC0}, // XK_quoteleft+TLDE+XK_asciitilde+XK_semicolon: VKEY_OEM_3 |
+ {0x0060, 0x31, 0x007E, 0x0060, |
+ 0xC0}, // XK_quoteleft+TLDE+XK_asciitilde+XK_quoteleft: VKEY_OEM_3 |
+ {0x0060, 0x31, 0x007E, 0x00BF, |
+ 0xC0}, // XK_quoteleft+TLDE+XK_asciitilde+XK_questiondown: VKEY_OEM_3 |
+ {0x0060, 0x31, 0x007E, 0x01F5, |
+ 0xC0}, // XK_quoteleft+TLDE+XK_asciitilde+XK_odoubleacute: VKEY_OEM_3 |
+ {0x00E4, 0x30, 0x00C4, 0x0000, |
+ 0xDE}, // XK_adiaeresis+AC11+XK_Adiaeresis+NoSymbol: VKEY_OEM_7 |
+ {0x00E4, 0x30, 0x00C4, 0x01A6, |
+ 0xDE}, // XK_adiaeresis+AC11+XK_Adiaeresis+XK_Sacute: VKEY_OEM_7 |
+ {0x00E4, 0x30, 0x00C4, 0x01F8, |
+ 0xDE}, // XK_adiaeresis+AC11+XK_Adiaeresis+XK_rcaron: VKEY_OEM_7 |
+ {0x00E7, 0x2F, 0x00C7, 0x0000, |
+ 0xBA}, // XK_ccedilla+AC10+XK_Ccedilla+NoSymbol: VKEY_OEM_1 |
+ {0x00E7, 0x2F, 0x00C7, 0x00DE, |
+ 0xC0}, // XK_ccedilla+AC10+XK_Ccedilla+XK_Thorn: VKEY_OEM_3 |
+ {0x00F6, 0x2F, 0x00D6, 0x0000, |
+ 0xC0}, // XK_odiaeresis+AC10+XK_Odiaeresis+NoSymbol: VKEY_OEM_3 |
+ {0x00F6, 0x2F, 0x00D6, 0x01DE, |
+ 0xC0}, // XK_odiaeresis+AC10+XK_Odiaeresis+XK_Tcedilla: VKEY_OEM_3 |
+ {0x00FC, 0x14, 0x00DC, 0x0000, |
+ 0xBF}, // XK_udiaeresis+AE11+XK_Udiaeresis+NoSymbol: VKEY_OEM_2 |
+ {0x00FC, 0x22, 0x00DC, 0x0000, |
+ 0xBA}, // XK_udiaeresis+AD11+XK_Udiaeresis+NoSymbol: VKEY_OEM_1 |
+ {0x00FC, 0x22, 0x00DC, 0x01A3, |
+ 0xC0}, // XK_udiaeresis+AD11+XK_Udiaeresis+XK_Lstroke: VKEY_OEM_3 |
+ {0x01EA, 0x3D, 0x01CA, 0x0000, |
+ 0xBD}, // XK_eogonek+AB10+XK_Eogonek+NoSymbol: VKEY_OEM_MINUS |
+ {0x01EA, 0x3D, 0x01CA, 0x006E, |
+ 0xBF}, // XK_eogonek+AB10+XK_Eogonek+XK_n: VKEY_OEM_2 |
+ {0x03E7, 0x22, 0x03C7, 0x0000, |
+ 0xDB}, // XK_iogonek+AD11+XK_Iogonek+NoSymbol: VKEY_OEM_4 |
+ {0x03F9, 0x2F, 0x03D9, 0x0000, |
+ 0xC0}, // XK_uogonek+AC10+XK_Uogonek+NoSymbol: VKEY_OEM_3 |
+ {0x03F9, 0x2F, 0x03D9, 0x01DE, |
+ 0xBA}, // XK_uogonek+AC10+XK_Uogonek+XK_Tcedilla: VKEY_OEM_1 |
+}; |
+ |
+template <class T_MAP> |
+KeyboardCode FindVK(const T_MAP& key, const T_MAP* map, size_t size) { |
+ T_MAP comp = {0}; |
+ const T_MAP* p = std::lower_bound(map, map + size, key, comp); |
+ if (p != map + size && !comp(*p, key) && !comp(key, *p)) |
+ return static_cast<KeyboardCode>(p->vk); |
+ return VKEY_UNKNOWN; |
+} |
+ |
+} // namespace |
+ |
// Get an ui::KeyboardCode from an X keyevent |
KeyboardCode KeyboardCodeFromXKeyEvent(XEvent* xev) { |
+ // Gets correct VKEY code from XEvent is performed as the following steps: |
+ // 1. Gets the keysym without modifier states. |
+ // 2. For [a-z] & [0-9] cases, returns the VKEY code accordingly. |
+ // 3. Find keysym in map0. |
+ // 4. If not found, fallback to find keysym + hardware_code in map1. |
+ // 5. If not found, fallback to find keysym + keysym_shift + hardware_code |
+ // in map2. |
+ // 6. If not found, fallback to find keysym + keysym_shift + keysym_altgr + |
+ // hardware_code in map3. |
+ // 7. If not found, fallback to find in KeyboardCodeFromXKeysym(), which |
+ // mainly for non-letter keys. |
+ // 8. If not found, fallback to find with the hardware code in US layout. |
+ |
+ KeySym keysym = NoSymbol; |
+ XKeyEvent xkey = xev->xkey; |
+ xkey.state &= ~(ShiftMask | Mod1Mask); |
// XLookupKeysym does not take into consideration the state of the lock/shift |
// etc. keys. So it is necessary to use XLookupString instead. |
- KeySym keysym; |
- XLookupString(&xev->xkey, NULL, 0, &keysym, NULL); |
- KeyboardCode keycode = KeyboardCodeFromXKeysym(keysym); |
- if (keycode == VKEY_UNKNOWN) { |
- keysym = DefaultXKeysymFromHardwareKeycode(xev->xkey.keycode); |
- keycode = KeyboardCodeFromXKeysym(keysym); |
+ XLookupString(&xkey, NULL, 0, &keysym, NULL); |
+ |
+ // [a-z] cases. |
+ if (keysym >= XK_a && keysym <= XK_z) |
+ return static_cast<KeyboardCode>(VKEY_A + keysym - XK_a); |
+ |
+ // [0-9] cases. |
+ if (keysym >= XK_0 && keysym <= XK_9) |
+ return static_cast<KeyboardCode>(VKEY_0 + keysym - XK_0); |
+ |
+ KeyboardCode keycode = VKEY_UNKNOWN; |
+ |
+ if (!IsKeypadKey(keysym) && !IsPrivateKeypadKey(keysym) && |
+ !IsCursorKey(keysym) && !IsPFKey(keysym) && !IsFunctionKey(keysym) && |
+ !IsModifierKey(keysym)) { |
+ MAP0 key0 = {keysym & 0xFFFF, 0}; |
+ keycode = FindVK(key0, map0, arraysize(map0)); |
+ if (keycode != VKEY_UNKNOWN) |
+ return keycode; |
+ |
+ MAP1 key1 = {keysym & 0xFFFF, xkey.keycode, 0}; |
+ keycode = FindVK(key1, map1, arraysize(map1)); |
+ if (keycode != VKEY_UNKNOWN) |
+ return keycode; |
+ |
+ KeySym keysym_shift = NoSymbol; |
+ xkey.state |= ShiftMask; |
+ XLookupString(&xkey, NULL, 0, &keysym_shift, NULL); |
+ MAP2 key2 = {keysym & 0xFFFF, xkey.keycode, keysym_shift & 0xFFFF, 0}; |
+ keycode = FindVK(key2, map2, arraysize(map2)); |
+ if (keycode != VKEY_UNKNOWN) |
+ return keycode; |
+ |
+ KeySym keysym_altgr = NoSymbol; |
+ xkey.state &= ~ShiftMask; |
+ xkey.state |= Mod1Mask; |
+ XLookupString(&xkey, NULL, 0, &keysym_altgr, NULL); |
+ MAP3 key3 = {keysym & 0xFFFF, xkey.keycode, keysym_shift & 0xFFFF, |
+ keysym_altgr & 0xFFFF, 0}; |
+ keycode = FindVK(key3, map3, arraysize(map3)); |
+ if (keycode != VKEY_UNKNOWN) |
+ return keycode; |
+ |
+ // On Linux some keys has AltGr char but not on Windows. |
+ // So if cannot find VKEY with (ch0+sc+ch1+ch2) in map3, tries to fallback |
+ // to just find VKEY with (ch0+sc+ch1). This is the best we could do. |
+ MAP3 key4 = {keysym & 0xFFFF, xkey.keycode, keysym_shift & 0xFFFF, 0xFFFF, |
+ 0}; |
+ const MAP3* p = |
+ std::lower_bound(map3, map3 + arraysize(map3), key4, MAP3()); |
+ if (p != map3 + arraysize(map3) && p->ch0 == key4.ch0 && p->sc == key4.sc && |
+ p->ch1 == key4.ch1) |
+ return static_cast<KeyboardCode>(p->vk); |
} |
+ keycode = KeyboardCodeFromXKeysym(keysym); |
+ if (keycode == VKEY_UNKNOWN) |
+ keycode = DefaultKeyboardCodeFromHardwareKeycode(xkey.keycode); |
+ |
return keycode; |
} |
@@ -100,117 +607,6 @@ KeyboardCode KeyboardCodeFromXKeysym(unsigned int keysym) { |
return VKEY_NONCONVERT; |
case XK_Zenkaku_Hankaku: |
return VKEY_DBE_DBCSCHAR; |
- case XK_A: |
- case XK_a: |
- return VKEY_A; |
- case XK_B: |
- case XK_b: |
- return VKEY_B; |
- case XK_C: |
- case XK_c: |
- return VKEY_C; |
- case XK_D: |
- case XK_d: |
- return VKEY_D; |
- case XK_E: |
- case XK_e: |
- return VKEY_E; |
- case XK_F: |
- case XK_f: |
- return VKEY_F; |
- case XK_G: |
- case XK_g: |
- return VKEY_G; |
- case XK_H: |
- case XK_h: |
- return VKEY_H; |
- case XK_I: |
- case XK_i: |
- return VKEY_I; |
- case XK_J: |
- case XK_j: |
- return VKEY_J; |
- case XK_K: |
- case XK_k: |
- return VKEY_K; |
- case XK_L: |
- case XK_l: |
- return VKEY_L; |
- case XK_M: |
- case XK_m: |
- return VKEY_M; |
- case XK_N: |
- case XK_n: |
- return VKEY_N; |
- case XK_O: |
- case XK_o: |
- return VKEY_O; |
- case XK_P: |
- case XK_p: |
- return VKEY_P; |
- case XK_Q: |
- case XK_q: |
- return VKEY_Q; |
- case XK_R: |
- case XK_r: |
- return VKEY_R; |
- case XK_S: |
- case XK_s: |
- return VKEY_S; |
- case XK_T: |
- case XK_t: |
- return VKEY_T; |
- case XK_U: |
- case XK_u: |
- return VKEY_U; |
- case XK_V: |
- case XK_v: |
- return VKEY_V; |
- case XK_W: |
- case XK_w: |
- return VKEY_W; |
- case XK_X: |
- case XK_x: |
- return VKEY_X; |
- case XK_Y: |
- case XK_y: |
- return VKEY_Y; |
- case XK_Z: |
- case XK_z: |
- return VKEY_Z; |
- |
- case XK_0: |
- case XK_1: |
- case XK_2: |
- case XK_3: |
- case XK_4: |
- case XK_5: |
- case XK_6: |
- case XK_7: |
- case XK_8: |
- case XK_9: |
- return static_cast<KeyboardCode>(VKEY_0 + (keysym - XK_0)); |
- |
- case XK_parenright: |
- return VKEY_0; |
- case XK_exclam: |
- return VKEY_1; |
- case XK_at: |
- return VKEY_2; |
- case XK_numbersign: |
- return VKEY_3; |
- case XK_dollar: |
- return VKEY_4; |
- case XK_percent: |
- return VKEY_5; |
- case XK_asciicircum: |
- return VKEY_6; |
- case XK_ampersand: |
- return VKEY_7; |
- case XK_asterisk: |
- return VKEY_8; |
- case XK_parenleft: |
- return VKEY_9; |
case XK_KP_0: |
case XK_KP_1: |
@@ -444,165 +840,169 @@ uint16 GetCharacterFromXEvent(XEvent* xev) { |
return result.length() == 1 ? result[0] : 0; |
} |
-unsigned int DefaultXKeysymFromHardwareKeycode(unsigned int hardware_code) { |
+KeyboardCode DefaultKeyboardCodeFromHardwareKeycode( |
+ unsigned int hardware_code) { |
// This function assumes that X11 is using evdev-based keycodes. |
- static const unsigned int kHardwareKeycodeMap[] = { |
- // This table covers the core 105-key keyboard. |
- 0, // 0x00: |
- 0, // 0x01: |
- 0, // 0x02: |
- 0, // 0x03: |
- 0, // 0x04: |
- 0, // 0x05: |
- 0, // 0x06: |
- 0, // XKB evdev (XKB - 8) X KeySym |
- 0, // === =============== ====== |
- XK_Escape, // 0x09: KEY_ESC Escape |
- XK_1, // 0x0A: KEY_1 1 |
- XK_2, // 0x0B: KEY_2 2 |
- XK_3, // 0x0C: KEY_3 3 |
- XK_4, // 0x0D: KEY_4 4 |
- XK_5, // 0x0E: KEY_5 5 |
- XK_6, // 0x0F: KEY_6 6 |
- XK_7, // 0x10: KEY_7 7 |
- XK_8, // 0x11: KEY_8 8 |
- XK_9, // 0x12: KEY_9 9 |
- XK_0, // 0x13: KEY_0 0 |
- XK_minus, // 0x14: KEY_MINUS minus |
- XK_equal, // 0x15: KEY_EQUAL equal |
- XK_BackSpace, // 0x16: KEY_BACKSPACE BackSpace |
- XK_Tab, // 0x17: KEY_TAB Tab |
- XK_q, // 0x18: KEY_Q q |
- XK_w, // 0x19: KEY_W w |
- XK_e, // 0x1A: KEY_E e |
- XK_r, // 0x1B: KEY_R r |
- XK_t, // 0x1C: KEY_T t |
- XK_y, // 0x1D: KEY_Y y |
- XK_u, // 0x1E: KEY_U u |
- XK_i, // 0x1F: KEY_I i |
- XK_o, // 0x20: KEY_O o |
- XK_p, // 0x21: KEY_P p |
- XK_bracketleft, // 0x22: KEY_LEFTBRACE bracketleft |
- XK_bracketright, // 0x23: KEY_RIGHTBRACE bracketright |
- XK_Return, // 0x24: KEY_ENTER Return |
- XK_Control_L, // 0x25: KEY_LEFTCTRL Control_L |
- XK_a, // 0x26: KEY_A a |
- XK_s, // 0x27: KEY_S s |
- XK_d, // 0x28: KEY_D d |
- XK_f, // 0x29: KEY_F f |
- XK_g, // 0x2A: KEY_G g |
- XK_h, // 0x2B: KEY_H h |
- XK_j, // 0x2C: KEY_J j |
- XK_k, // 0x2D: KEY_K k |
- XK_l, // 0x2E: KEY_L l |
- XK_semicolon, // 0x2F: KEY_SEMICOLON semicolon |
- XK_apostrophe, // 0x30: KEY_APOSTROPHE apostrophe |
- XK_grave, // 0x31: KEY_GRAVE grave |
- XK_Shift_L, // 0x32: KEY_LEFTSHIFT Shift_L |
- XK_backslash, // 0x33: KEY_BACKSLASH backslash |
- XK_z, // 0x34: KEY_Z z |
- XK_x, // 0x35: KEY_X x |
- XK_c, // 0x36: KEY_C c |
- XK_v, // 0x37: KEY_V v |
- XK_b, // 0x38: KEY_B b |
- XK_n, // 0x39: KEY_N n |
- XK_m, // 0x3A: KEY_M m |
- XK_comma, // 0x3B: KEY_COMMA comma |
- XK_period, // 0x3C: KEY_DOT period |
- XK_slash, // 0x3D: KEY_SLASH slash |
- XK_Shift_R, // 0x3E: KEY_RIGHTSHIFT Shift_R |
- 0, // 0x3F: KEY_KPASTERISK KP_Multiply |
- XK_Alt_L, // 0x40: KEY_LEFTALT Alt_L |
- XK_space, // 0x41: KEY_SPACE space |
- XK_Caps_Lock, // 0x42: KEY_CAPSLOCK Caps_Lock |
- XK_F1, // 0x43: KEY_F1 F1 |
- XK_F2, // 0x44: KEY_F2 F2 |
- XK_F3, // 0x45: KEY_F3 F3 |
- XK_F4, // 0x46: KEY_F4 F4 |
- XK_F5, // 0x47: KEY_F5 F5 |
- XK_F6, // 0x48: KEY_F6 F6 |
- XK_F7, // 0x49: KEY_F7 F7 |
- XK_F8, // 0x4A: KEY_F8 F8 |
- XK_F9, // 0x4B: KEY_F9 F9 |
- XK_F10, // 0x4C: KEY_F10 F10 |
- XK_Num_Lock, // 0x4D: KEY_NUMLOCK Num_Lock |
- XK_Scroll_Lock, // 0x4E: KEY_SCROLLLOCK Scroll_Lock |
- XK_KP_7, // 0x4F: KEY_KP7 KP_7 |
- XK_KP_8, // 0x50: KEY_KP8 KP_8 |
- XK_KP_9, // 0x51: KEY_KP9 KP_9 |
- XK_KP_Subtract, // 0x52: KEY_KPMINUS KP_Subtract |
- XK_KP_4, // 0x53: KEY_KP4 KP_4 |
- XK_KP_5, // 0x54: KEY_KP5 KP_5 |
- XK_KP_6, // 0x55: KEY_KP6 KP_6 |
- XK_KP_Add, // 0x56: KEY_KPPLUS KP_Add |
- XK_KP_1, // 0x57: KEY_KP1 KP_1 |
- XK_KP_2, // 0x58: KEY_KP2 KP_2 |
- XK_KP_3, // 0x59: KEY_KP3 KP_3 |
- XK_KP_0, // 0x5A: KEY_KP0 KP_0 |
- XK_KP_Decimal, // 0x5B: KEY_KPDOT KP_Decimal |
- 0, // 0x5C: |
- XK_Zenkaku_Hankaku, // 0x5D: KEY_ZENKAKUHANKAKU Zenkaku_Hankaku |
- XK_backslash, // 0x5E: KEY_102ND backslash |
- XK_F11, // 0x5F: KEY_F11 F11 |
- XK_F12, // 0x60: KEY_F12 F12 |
- XK_Romaji, // 0x61: KEY_RO Romaji |
- XK_Katakana, // 0x62: KEY_KATAKANA Katakana |
- XK_Hiragana, // 0x63: KEY_HIRAGANA Hiragana |
- XK_Henkan, // 0x64: KEY_HENKAN Henkan |
- XK_Hiragana_Katakana, // 0x65: KEY_KATAKANAHIRAGANA Hiragana_Katakana |
- XK_Muhenkan, // 0x66: KEY_MUHENKAN Muhenkan |
- XK_KP_Separator, // 0x67: KEY_KPJPCOMMA KP_Separator |
- XK_KP_Enter, // 0x68: KEY_KPENTER KP_Enter |
- XK_Control_R, // 0x69: KEY_RIGHTCTRL Control_R |
- XK_KP_Divide, // 0x6A: KEY_KPSLASH KP_Divide |
- XK_Print, // 0x6B: KEY_SYSRQ Print |
- XK_Alt_R, // 0x6C: KEY_RIGHTALT Alt_R |
- XK_Linefeed, // 0x6D: KEY_LINEFEED Linefeed |
- XK_Home, // 0x6E: KEY_HOME Home |
- XK_Up, // 0x6F: KEY_UP Up |
- XK_Page_Up, // 0x70: KEY_PAGEUP Page_Up |
- XK_Left, // 0x71: KEY_LEFT Left |
- XK_Right, // 0x72: KEY_RIGHT Right |
- XK_End, // 0x73: KEY_END End |
- XK_Down, // 0x74: KEY_DOWN Down |
- XK_Page_Down, // 0x75: KEY_PAGEDOWN Page_Down |
- XK_Insert, // 0x76: KEY_INSERT Insert |
- XK_Delete, // 0x77: KEY_DELETE Delete |
- 0, // 0x78: KEY_MACRO |
- XF86XK_AudioMute, // 0x79: KEY_MUTE XF86AudioMute |
- XF86XK_AudioLowerVolume, // 0x7A: KEY_VOLUMEDOWN XF86AudioLowerVolume |
- XF86XK_AudioRaiseVolume, // 0x7B: KEY_VOLUMEUP XF86AudioRaiseVolume |
- XF86XK_PowerOff, // 0x7C: KEY_POWER XF86PowerOff |
- XK_KP_Equal, // 0x7D: KEY_KPEQUAL KP_Equal |
- XK_plusminus, // 0x7E: KEY_KPPLUSMINUS plusminus |
- XK_Pause, // 0x7F: KEY_PAUSE Pause |
- XF86XK_LaunchA, // 0x80: KEY_SCALE XF86LaunchA |
- XK_KP_Decimal, // 0x81: KEY_KPCOMMA KP_Decimal |
- XK_Hangul, // 0x82: KEY_HANGUEL Hangul |
- XK_Hangul_Hanja, // 0x83: KEY_HANJA Hangul_Hanja |
- XK_yen, // 0x84: KEY_YEN yen |
- XK_Super_L, // 0x85: KEY_LEFTMETA Super_L |
- XK_Super_R, // 0x86: KEY_RIGHTMETA Super_R |
- XK_Menu, // 0x87: KEY_COMPOSE Menu |
+ static const KeyboardCode kHardwareKeycodeMap[] = { |
+ // Please refer to below links for the table content: |
+ // http://www.w3.org/TR/DOM-Level-3-Events-code/#keyboard-101 |
+ // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent.keyCode |
+ // http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/translate.pdf |
+ VKEY_UNKNOWN, // 0x00: |
+ VKEY_UNKNOWN, // 0x01: |
+ VKEY_UNKNOWN, // 0x02: |
+ VKEY_UNKNOWN, // 0x03: |
+ VKEY_UNKNOWN, // 0x04: |
+ VKEY_UNKNOWN, // 0x05: |
+ VKEY_UNKNOWN, // 0x06: |
+ VKEY_UNKNOWN, // XKB evdev (XKB - 8) X KeySym |
+ VKEY_UNKNOWN, // === =============== ====== |
+ VKEY_ESCAPE, // 0x09: KEY_ESC Escape |
+ VKEY_1, // 0x0A: KEY_1 1 |
+ VKEY_2, // 0x0B: KEY_2 2 |
+ VKEY_3, // 0x0C: KEY_3 3 |
+ VKEY_4, // 0x0D: KEY_4 4 |
+ VKEY_5, // 0x0E: KEY_5 5 |
+ VKEY_6, // 0x0F: KEY_6 6 |
+ VKEY_7, // 0x10: KEY_7 7 |
+ VKEY_8, // 0x11: KEY_8 8 |
+ VKEY_9, // 0x12: KEY_9 9 |
+ VKEY_0, // 0x13: KEY_0 0 |
+ VKEY_OEM_MINUS, // 0x14: KEY_MINUS minus |
+ VKEY_OEM_PLUS, // 0x15: KEY_EQUAL equal |
+ VKEY_BACK, // 0x16: KEY_BACKSPACE BackSpace |
+ VKEY_TAB, // 0x17: KEY_TAB Tab |
+ VKEY_Q, // 0x18: KEY_Q q |
+ VKEY_W, // 0x19: KEY_W w |
+ VKEY_E, // 0x1A: KEY_E e |
+ VKEY_R, // 0x1B: KEY_R r |
+ VKEY_T, // 0x1C: KEY_T t |
+ VKEY_Y, // 0x1D: KEY_Y y |
+ VKEY_U, // 0x1E: KEY_U u |
+ VKEY_I, // 0x1F: KEY_I i |
+ VKEY_O, // 0x20: KEY_O o |
+ VKEY_P, // 0x21: KEY_P p |
+ VKEY_OEM_4, // 0x22: KEY_LEFTBRACE bracketleft |
+ VKEY_OEM_6, // 0x23: KEY_RIGHTBRACE bracketright |
+ VKEY_RETURN, // 0x24: KEY_ENTER Return |
+ VKEY_LCONTROL, // 0x25: KEY_LEFTCTRL Control_L |
+ VKEY_A, // 0x26: KEY_A a |
+ VKEY_S, // 0x27: KEY_S s |
+ VKEY_D, // 0x28: KEY_D d |
+ VKEY_F, // 0x29: KEY_F f |
+ VKEY_G, // 0x2A: KEY_G g |
+ VKEY_H, // 0x2B: KEY_H h |
+ VKEY_J, // 0x2C: KEY_J j |
+ VKEY_K, // 0x2D: KEY_K k |
+ VKEY_L, // 0x2E: KEY_L l |
+ VKEY_OEM_1, // 0x2F: KEY_SEMICOLON semicolon |
+ VKEY_OEM_7, // 0x30: KEY_APOSTROPHE apostrophe |
+ VKEY_OEM_3, // 0x31: KEY_GRAVE grave |
+ VKEY_LSHIFT, // 0x32: KEY_LEFTSHIFT Shift_L |
+ VKEY_OEM_5, // 0x33: KEY_BACKSLASH backslash |
+ VKEY_Z, // 0x34: KEY_Z z |
+ VKEY_X, // 0x35: KEY_X x |
+ VKEY_C, // 0x36: KEY_C c |
+ VKEY_V, // 0x37: KEY_V v |
+ VKEY_B, // 0x38: KEY_B b |
+ VKEY_N, // 0x39: KEY_N n |
+ VKEY_M, // 0x3A: KEY_M m |
+ VKEY_OEM_COMMA, // 0x3B: KEY_COMMA comma |
+ VKEY_OEM_PERIOD, // 0x3C: KEY_DOT period |
+ VKEY_OEM_2, // 0x3D: KEY_SLASH slash |
+ VKEY_RSHIFT, // 0x3E: KEY_RIGHTSHIFT Shift_R |
+ VKEY_MULTIPLY, // 0x3F: KEY_KPASTERISK KP_Multiply |
+ VKEY_LMENU, // 0x40: KEY_LEFTALT Alt_L |
+ VKEY_SPACE, // 0x41: KEY_SPACE space |
+ VKEY_CAPITAL, // 0x42: KEY_CAPSLOCK Caps_Lock |
+ VKEY_F1, // 0x43: KEY_F1 F1 |
+ VKEY_F2, // 0x44: KEY_F2 F2 |
+ VKEY_F3, // 0x45: KEY_F3 F3 |
+ VKEY_F4, // 0x46: KEY_F4 F4 |
+ VKEY_F5, // 0x47: KEY_F5 F5 |
+ VKEY_F6, // 0x48: KEY_F6 F6 |
+ VKEY_F7, // 0x49: KEY_F7 F7 |
+ VKEY_F8, // 0x4A: KEY_F8 F8 |
+ VKEY_F9, // 0x4B: KEY_F9 F9 |
+ VKEY_F10, // 0x4C: KEY_F10 F10 |
+ VKEY_NUMLOCK, // 0x4D: KEY_NUMLOCK Num_Lock |
+ VKEY_SCROLL, // 0x4E: KEY_SCROLLLOCK Scroll_Lock |
+ VKEY_NUMPAD7, // 0x4F: KEY_KP7 KP_7 |
+ VKEY_NUMPAD8, // 0x50: KEY_KP8 KP_8 |
+ VKEY_NUMPAD9, // 0x51: KEY_KP9 KP_9 |
+ VKEY_SUBTRACT, // 0x52: KEY_KPMINUS KP_Subtract |
+ VKEY_NUMPAD4, // 0x53: KEY_KP4 KP_4 |
+ VKEY_NUMPAD5, // 0x54: KEY_KP5 KP_5 |
+ VKEY_NUMPAD6, // 0x55: KEY_KP6 KP_6 |
+ VKEY_ADD, // 0x56: KEY_KPPLUS KP_Add |
+ VKEY_NUMPAD1, // 0x57: KEY_KP1 KP_1 |
+ VKEY_NUMPAD2, // 0x58: KEY_KP2 KP_2 |
+ VKEY_NUMPAD3, // 0x59: KEY_KP3 KP_3 |
+ VKEY_NUMPAD0, // 0x5A: KEY_KP0 KP_0 |
+ VKEY_DECIMAL, // 0x5B: KEY_KPDOT KP_Decimal |
+ VKEY_UNKNOWN, // 0x5C: |
+ VKEY_DBE_DBCSCHAR, // 0x5D: KEY_ZENKAKUHANKAKU Zenkaku_Hankaku |
+ VKEY_OEM_5, // 0x5E: KEY_102ND backslash |
+ VKEY_F11, // 0x5F: KEY_F11 F11 |
+ VKEY_F12, // 0x60: KEY_F12 F12 |
+ VKEY_OEM_102, // 0x61: KEY_RO Romaji |
+ VKEY_UNSUPPORTED, // 0x62: KEY_KATAKANA Katakana |
+ VKEY_UNSUPPORTED, // 0x63: KEY_HIRAGANA Hiragana |
+ VKEY_CONVERT, // 0x64: KEY_HENKAN Henkan |
+ VKEY_UNSUPPORTED, // 0x65: KEY_KATAKANAHIRAGANA Hiragana_Katakana |
+ VKEY_NONCONVERT, // 0x66: KEY_MUHENKAN Muhenkan |
+ VKEY_SEPARATOR, // 0x67: KEY_KPJPCOMMA KP_Separator |
+ VKEY_RETURN, // 0x68: KEY_KPENTER KP_Enter |
+ VKEY_RCONTROL, // 0x69: KEY_RIGHTCTRL Control_R |
+ VKEY_DIVIDE, // 0x6A: KEY_KPSLASH KP_Divide |
+ VKEY_PRINT, // 0x6B: KEY_SYSRQ Print |
+ VKEY_RMENU, // 0x6C: KEY_RIGHTALT Alt_R |
+ VKEY_RETURN, // 0x6D: KEY_LINEFEED Linefeed |
+ VKEY_HOME, // 0x6E: KEY_HOME Home |
+ VKEY_UP, // 0x6F: KEY_UP Up |
+ VKEY_PRIOR, // 0x70: KEY_PAGEUP Page_Up |
+ VKEY_LEFT, // 0x71: KEY_LEFT Left |
+ VKEY_RIGHT, // 0x72: KEY_RIGHT Right |
+ VKEY_END, // 0x73: KEY_END End |
+ VKEY_DOWN, // 0x74: KEY_DOWN Down |
+ VKEY_NEXT, // 0x75: KEY_PAGEDOWN Page_Down |
+ VKEY_INSERT, // 0x76: KEY_INSERT Insert |
+ VKEY_DELETE, // 0x77: KEY_DELETE Delete |
+ VKEY_UNSUPPORTED, // 0x78: KEY_MACRO |
+ VKEY_VOLUME_MUTE, // 0x79: KEY_MUTE XF86AudioMute |
+ VKEY_VOLUME_DOWN, // 0x7A: KEY_VOLUMEDOWN XF86AudioLowerVolume |
+ VKEY_VOLUME_UP, // 0x7B: KEY_VOLUMEUP XF86AudioRaiseVolume |
+ VKEY_POWER, // 0x7C: KEY_POWER XF86PowerOff |
+ VKEY_OEM_PLUS, // 0x7D: KEY_KPEQUAL KP_Equal |
+ VKEY_UNSUPPORTED, // 0x7E: KEY_KPPLUSMINUS plusminus |
+ VKEY_PAUSE, // 0x7F: KEY_PAUSE Pause |
+ VKEY_MEDIA_LAUNCH_APP1, // 0x80: KEY_SCALE XF86LaunchA |
+ VKEY_DECIMAL, // 0x81: KEY_KPCOMMA KP_Decimal |
+ VKEY_HANGUL, // 0x82: KEY_HANGUEL Hangul |
+ VKEY_HANJA, // 0x83: KEY_HANJA Hangul_Hanja |
+ VKEY_OEM_5, // 0x84: KEY_YEN yen |
+ VKEY_LWIN, // 0x85: KEY_LEFTMETA Super_L |
+ VKEY_RWIN, // 0x86: KEY_RIGHTMETA Super_R |
+ VKEY_COMPOSE, // 0x87: KEY_COMPOSE Menu |
}; |
if (hardware_code >= arraysize(kHardwareKeycodeMap)) { |
// Additional keycodes used by the Chrome OS top row special function keys. |
switch (hardware_code) { |
case 0xA6: // KEY_BACK |
- return XF86XK_Back; |
+ return VKEY_BACK; |
case 0xA7: // KEY_FORWARD |
- return XF86XK_Forward; |
+ return VKEY_BROWSER_FORWARD; |
case 0xB5: // KEY_REFRESH |
- return XF86XK_Reload; |
+ return VKEY_BROWSER_REFRESH; |
case 0xD4: // KEY_DASHBOARD |
- return XF86XK_LaunchB; |
+ return VKEY_MEDIA_LAUNCH_APP2; |
case 0xE8: // KEY_BRIGHTNESSDOWN |
- return XF86XK_MonBrightnessDown; |
+ return VKEY_BRIGHTNESS_DOWN; |
case 0xE9: // KEY_BRIGHTNESSUP |
- return XF86XK_MonBrightnessUp; |
+ return VKEY_BRIGHTNESS_UP; |
} |
- return 0; |
+ return VKEY_UNKNOWN; |
} |
return kHardwareKeycodeMap[hardware_code]; |
} |