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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « ui/events/keycodes/keyboard_code_conversion_x.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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..30c0a005d63e8e80d488c7c886306affac98c390 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>
@@ -19,17 +21,459 @@
namespace ui {
+namespace {
+
+// MAP0 - MAP3:
+// They are the generated VKEY code maps for all possible Latin keyboard
+// layouts in Windows. And the maps are only for special letter keys exclude
+// [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.
+//
+// The reason of 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 is located at BackSlash key position, and its
+// 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.
+//
+// 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},
Wez 2014/06/26 02:10:42 This table is basically impossible to sanity-check
Shu Chen 2014/06/26 06:55:39 Done.
+ {0x0026, 0x31},
+ {0x003C, 0xDC},
+ {0x007B, 0xDE},
+ {0x007C, 0xDC},
+ {0x007D, 0xBF},
+ {0x007E, 0xDC},
+ {0x00A1, 0xDD},
+ {0x00AD, 0xC0},
+ {0x00B0, 0xDE},
+ {0x00B2, 0xDE},
+ {0x00B5, 0xDC},
+ {0x00BB, 0x39},
+ {0x00BD, 0xDC},
+ {0x00BF, 0xDD},
+ {0x00DF, 0xDB},
+ {0x00E5, 0xDD},
+ {0x00EA, 0x33},
+ {0x00EB, 0xBA},
+ {0x00EC, 0xDD},
+ {0x00EE, 0xDD},
+ {0x00F1, 0xC0},
+ {0x00F2, 0xC0},
+ {0x00F5, 0xDB},
+ {0x00F7, 0xDD},
+ {0x00FD, 0x37},
+ {0x00FE, 0xBD},
+ {0x0101, 0xDF},
+ {0x0107, 0xDE},
+ {0x010B, 0xC0},
+ {0x0113, 0x57},
+ {0x011B, 0x32},
+ {0x011F, 0xDD},
+ {0x0121, 0xDB},
+ {0x0127, 0xDD},
+ {0x012B, 0xDD},
+ {0x0131, 0xBA},
+ {0x0137, 0xDC},
+ {0x013C, 0xBF},
+ {0x013E, 0x32},
+ {0x0146, 0xDB},
+ {0x0148, 0xDC},
+ {0x0151, 0xDB},
+ {0x0159, 0x35},
+ {0x015B, 0xDD},
+ {0x0163, 0xDE},
+ {0x0165, 0x35},
+ {0x016F, 0xBA},
+ {0x0171, 0xDC},
+ {0x01A1, 0xDD},
+ {0x01B0, 0xDB},
+ {0x0219, 0xBA},
+ {0x021B, 0xDE},
+ {0x0259, 0xC0},
+ {0x0300, 0x35},
+ {0x0301, 0x38},
+ {0x0303, 0x37},
+ {0x0309, 0x36},
+ {0x0323, 0x39},
+};
+
+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},
+ {0x0021, 0x11, 0x38},
+ {0x0021, 0x3D, 0xDF},
+ {0x0022, 0x0B, 0x32},
+ {0x0022, 0x0C, 0x33},
+ {0x0023, 0x31, 0xDE},
+ {0x0024, 0x23, 0xBA},
+ {0x0024, 0x33, 0xDF},
+ {0x0027, 0x0D, 0x34},
+ {0x0027, 0x18, 0xDE},
+ {0x0027, 0x23, 0xBA},
+ {0x0027, 0x3D, 0xDE},
+ {0x0028, 0x0E, 0x35},
+ {0x0028, 0x12, 0x39},
+ {0x0028, 0x33, 0xDC},
+ {0x0029, 0x13, 0x30},
+ {0x0029, 0x14, 0xDB},
+ {0x0029, 0x23, 0xDD},
+ {0x002A, 0x23, 0xBA},
+ {0x002A, 0x33, 0xDC},
+ {0x002B, 0x0A, 0x31},
+ {0x002B, 0x15, 0xBB},
+ {0x002B, 0x22, 0xBB},
+ {0x002B, 0x23, 0xBB},
+ {0x002B, 0x2F, 0xBB},
+ {0x002B, 0x33, 0xBF},
+ {0x002C, 0x0C, 0x33},
+ {0x002C, 0x0E, 0x35},
+ {0x002C, 0x0F, 0x36},
+ {0x002C, 0x12, 0x39},
+ {0x002C, 0x19, 0xBC},
+ {0x002C, 0x37, 0xBC},
+ {0x002C, 0x3A, 0xBC},
+ {0x002C, 0x3B, 0xBC},
+ {0x002D, 0x0B, 0x32},
+ {0x002D, 0x0F, 0x36},
+ {0x002D, 0x14, 0xBD},
+ {0x002D, 0x26, 0xBD},
+ {0x002D, 0x30, 0xBD},
+ {0x002E, 0x10, 0x37},
+ {0x002E, 0x11, 0x38},
+ {0x002E, 0x1A, 0xBE},
+ {0x002E, 0x1B, 0xBE},
+ {0x002E, 0x20, 0xBE},
+ {0x002E, 0x30, 0xDE},
+ {0x002E, 0x3C, 0xBE},
+ {0x002E, 0x3D, 0xBF},
+ {0x002F, 0x14, 0xDB},
+ {0x002F, 0x22, 0xBF},
+ {0x002F, 0x31, 0xDE},
+ {0x002F, 0x33, 0xDC},
+ {0x002F, 0x3D, 0xBF},
+ {0x003A, 0x0A, 0x31},
+ {0x003A, 0x0E, 0x35},
+ {0x003A, 0x0F, 0x36},
+ {0x003A, 0x3C, 0xBF},
+ {0x003B, 0x0D, 0x34},
+ {0x003B, 0x11, 0x38},
+ {0x003B, 0x18, 0xBA},
+ {0x003B, 0x22, 0xBA},
+ {0x003B, 0x23, 0xDD},
+ {0x003B, 0x2F, 0xBA},
+ {0x003B, 0x34, 0xBA},
+ {0x003B, 0x3B, 0xBE},
+ {0x003B, 0x3D, 0xBF},
+ {0x003D, 0x11, 0x38},
+ {0x003D, 0x15, 0xBB},
+ {0x003D, 0x23, 0xBB},
+ {0x003F, 0x0B, 0x32},
+ {0x003F, 0x10, 0x37},
+ {0x003F, 0x11, 0x38},
+ {0x003F, 0x14, 0xBB},
+ {0x0040, 0x23, 0xDD},
+ {0x0040, 0x31, 0xDE},
+ {0x005B, 0x0A, 0xDB},
+ {0x005B, 0x14, 0xDB},
+ {0x005B, 0x22, 0xDB},
+ {0x005B, 0x23, 0xDD},
+ {0x005B, 0x30, 0xDE},
+ {0x005D, 0x0B, 0xDD},
+ {0x005D, 0x15, 0xDD},
+ {0x005D, 0x23, 0xDD},
+ {0x005D, 0x31, 0xC0},
+ {0x005D, 0x33, 0xDC},
+ {0x005F, 0x11, 0x38},
+ {0x005F, 0x14, 0xBD},
+ {0x00A7, 0x0D, 0x34},
+ {0x00A7, 0x0F, 0x36},
+ {0x00A7, 0x30, 0xDE},
+ {0x00AB, 0x11, 0x38},
+ {0x00AB, 0x15, 0xDD},
+ {0x00BA, 0x30, 0xDE},
+ {0x00BA, 0x31, 0xDC},
+ {0x00E0, 0x13, 0x30},
+ {0x00E0, 0x33, 0xDC},
+ {0x00E1, 0x11, 0x38},
+ {0x00E1, 0x30, 0xDE},
+ {0x00E2, 0x0B, 0x32},
+ {0x00E2, 0x33, 0xDC},
+ {0x00E4, 0x23, 0xDD},
+ {0x00E6, 0x2F, 0xC0},
+ {0x00E6, 0x30, 0xDE},
+ {0x00E7, 0x12, 0x39},
+ {0x00E7, 0x22, 0xDB},
+ {0x00E7, 0x23, 0xDD},
+ {0x00E7, 0x30, 0xDE},
+ {0x00E7, 0x33, 0xBF},
+ {0x00E7, 0x3B, 0xBC},
+ {0x00E8, 0x10, 0x37},
+ {0x00E8, 0x22, 0xBA},
+ {0x00E8, 0x30, 0xC0},
+ {0x00E9, 0x0B, 0x32},
+ {0x00E9, 0x13, 0x30},
+ {0x00E9, 0x3D, 0xBF},
+ {0x00ED, 0x12, 0x39},
+ {0x00ED, 0x31, 0x30},
+ {0x00F0, 0x22, 0xDD},
+ {0x00F0, 0x23, 0xBA},
+ {0x00F3, 0x15, 0xBB},
+ {0x00F3, 0x33, 0xDC},
+ {0x00F4, 0x0D, 0x34},
+ {0x00F4, 0x2F, 0xBA},
+ {0x00F6, 0x13, 0xC0},
+ {0x00F6, 0x14, 0xBB},
+ {0x00F6, 0x22, 0xDB},
+ {0x00F8, 0x2F, 0xC0},
+ {0x00F8, 0x30, 0xDE},
+ {0x00F9, 0x30, 0xC0},
+ {0x00F9, 0x33, 0xBF},
+ {0x00FA, 0x22, 0xDB},
+ {0x00FA, 0x23, 0xDD},
+ {0x00FC, 0x19, 0x57},
+ {0x0103, 0x0A, 0x31},
+ {0x0103, 0x22, 0xDB},
+ {0x0105, 0x0A, 0x31},
+ {0x0105, 0x18, 0x51},
+ {0x0105, 0x30, 0xDE},
+ {0x010D, 0x0B, 0x32},
+ {0x010D, 0x0D, 0x34},
+ {0x010D, 0x21, 0x58},
+ {0x010D, 0x2F, 0xBA},
+ {0x010D, 0x3B, 0xBC},
+ {0x0111, 0x13, 0x30},
+ {0x0111, 0x23, 0xDD},
+ {0x0117, 0x0D, 0x34},
+ {0x0117, 0x30, 0xDE},
+ {0x0119, 0x0C, 0x33},
+ {0x012F, 0x0E, 0x35},
+ {0x0142, 0x2F, 0xBA},
+ {0x0142, 0x33, 0xBF},
+ {0x015F, 0x2F, 0xBA},
+ {0x015F, 0x3C, 0xBE},
+ {0x0161, 0x0C, 0x33},
+ {0x0161, 0x0F, 0x36},
+ {0x0161, 0x22, 0xDB},
+ {0x0161, 0x26, 0xBA},
+ {0x0161, 0x29, 0x46},
+ {0x0161, 0x3C, 0xBE},
+ {0x016B, 0x11, 0x38},
+ {0x016B, 0x18, 0x51},
+ {0x016B, 0x35, 0x58},
+ {0x0173, 0x10, 0x37},
+ {0x017C, 0x22, 0xDB},
+ {0x017C, 0x33, 0xDC},
+ {0x017E, 0x0F, 0x36},
+ {0x017E, 0x15, 0xBB},
+ {0x017E, 0x19, 0x57},
+ {0x017E, 0x22, 0x59},
+ {0x017E, 0x33, 0xDC},
+};
+
+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},
+ {0x0027, 0x30, 0x0022, 0xDE},
+ {0x0027, 0x31, 0x0022, 0xC0},
+ {0x0027, 0x31, 0x00B7, 0xDC},
+ {0x002D, 0x3D, 0x003D, 0xBD},
+ {0x002F, 0x0C, 0x0033, 0x33},
+ {0x002F, 0x0C, 0x003F, 0xBF},
+ {0x002F, 0x13, 0x0030, 0x30},
+ {0x002F, 0x13, 0x003F, 0xBF},
+ {0x003D, 0x3D, 0x0025, 0xDF},
+ {0x003D, 0x3D, 0x002B, 0xBB},
+ {0x005C, 0x33, 0x002F, 0xDE},
+ {0x005C, 0x33, 0x007C, 0xDC},
+ {0x0060, 0x31, 0x00AC, 0xDF},
+ {0x00A7, 0x31, 0x00B0, 0xBF},
+ {0x00A7, 0x31, 0x00BD, 0xDC},
+ {0x00E0, 0x30, 0x00B0, 0xDE},
+ {0x00E0, 0x30, 0x00E4, 0xDC},
+ {0x00E4, 0x30, 0x00E0, 0xDC},
+ {0x00E9, 0x2F, 0x00C9, 0xBA},
+ {0x00E9, 0x2F, 0x00F6, 0xDE},
+ {0x00F6, 0x2F, 0x00E9, 0xDE},
+ {0x00FC, 0x22, 0x00E8, 0xBA},
+};
+
+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, 0xDC},
+ {0x0023, 0x33, 0x007E, 0x001C, 0xDE},
+ {0x0027, 0x14, 0x003F, 0x001C, 0xDB},
+ {0x0027, 0x14, 0x003F, 0x00DD, 0xDB},
+ {0x0027, 0x14, 0x003F, 0xF001, 0xBF},
+ {0x0027, 0x15, 0x002A, 0x0000, 0xBB},
+ {0x0027, 0x15, 0x002A, 0xF001, 0xBF},
+ {0x0027, 0x30, 0x0040, 0x0000, 0xC0},
+ {0x0027, 0x30, 0x0040, 0xF001, 0xC0},
+ {0x0027, 0x33, 0x002A, 0x0000, 0xBF},
+ {0x0027, 0x33, 0x002A, 0x00BD, 0xDC},
+ {0x0027, 0x33, 0x002A, 0x0141, 0xBF},
+ {0x0027, 0x34, 0x0022, 0x0000, 0x5A},
+ {0x0027, 0x34, 0x0022, 0x0158, 0xDE},
+ {0x002B, 0x14, 0x003F, 0x0000, 0xBB},
+ {0x002B, 0x14, 0x003F, 0x005C, 0xBD},
+ {0x002B, 0x14, 0x003F, 0x0151, 0xBB},
+ {0x002B, 0x14, 0x003F, 0xF001, 0xBB},
+ {0x002D, 0x15, 0x005F, 0x0000, 0xBD},
+ {0x002D, 0x15, 0x005F, 0x0157, 0xDB},
+ {0x002D, 0x3D, 0x005F, 0x0000, 0xBD},
+ {0x002D, 0x3D, 0x005F, 0x001F, 0xBD},
+ {0x002D, 0x3D, 0x005F, 0x002A, 0xBD},
+ {0x002D, 0x3D, 0x005F, 0x002F, 0xBF},
+ {0x002D, 0x3D, 0x005F, 0x006E, 0xBD},
+ {0x003D, 0x14, 0x0025, 0x002D, 0xBD},
+ {0x003D, 0x14, 0x0025, 0xF001, 0xBB},
+ {0x005C, 0x31, 0x007C, 0x0031, 0xDC},
+ {0x005C, 0x31, 0x007C, 0x0145, 0xC0},
+ {0x0060, 0x31, 0x007E, 0x0000, 0xC0},
+ {0x0060, 0x31, 0x007E, 0x0031, 0xC0},
+ {0x0060, 0x31, 0x007E, 0x003B, 0xC0},
+ {0x0060, 0x31, 0x007E, 0x0060, 0xC0},
+ {0x0060, 0x31, 0x007E, 0x00BF, 0xC0},
+ {0x0060, 0x31, 0x007E, 0x0151, 0xC0},
+ {0x00E4, 0x30, 0x00C4, 0x0000, 0xDE},
+ {0x00E4, 0x30, 0x00C4, 0x0159, 0xDE},
+ {0x00E4, 0x30, 0x00C4, 0x015A, 0xDE},
+ {0x00E4, 0x30, 0x00C4, 0xF001, 0xBF},
+ {0x00E7, 0x2F, 0x00C7, 0x0000, 0xBA},
+ {0x00E7, 0x2F, 0x00C7, 0x00DE, 0xC0},
+ {0x00F6, 0x2F, 0x00D6, 0x0000, 0xBA},
+ {0x00F6, 0x2F, 0x00D6, 0x01DE, 0xC0},
+ {0x00FC, 0x14, 0x00DC, 0x0000, 0xBD},
+ {0x00FC, 0x14, 0x00DC, 0xF001, 0xBF},
+ {0x00FC, 0x22, 0x00DC, 0x0000, 0xBA},
+ {0x00FC, 0x22, 0x00DC, 0x0141, 0xC0},
+ {0x0119, 0x3D, 0x0118, 0x0000, 0xBD},
+ {0x0119, 0x3D, 0x0118, 0x006E, 0xBF},
+ {0x012F, 0x22, 0x012E, 0x0000, 0xDD},
+ {0x012F, 0x22, 0x012E, 0x001B, 0xDB},
+ {0x0173, 0x2F, 0x0172, 0x0000, 0xC0},
+ {0x0173, 0x2F, 0x0172, 0x01DE, 0xBA},
+};
+
+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) {
- // 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);
- }
+ // 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
+ // 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 hardward code in US layout.
+
+ KeySym keysym = NoSymbol;
+ XKeyEvent xkey = xev->xkey;
+ xkey.state = 0;
+ 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);
+
+ MAP0 key0 = {keysym, 0};
+ KeyboardCode keycode = FindVK(key0, map0, arraysize(map0));
+ if (keycode != VKEY_UNKNOWN)
+ return keycode;
+
+ MAP1 key1 = {keysym, 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, keysym_shift, xkey.keycode, 0};
+ keycode = FindVK(key2, map2, arraysize(map2));
+ if (keycode != VKEY_UNKNOWN)
+ return keycode;
+
+ KeySym keysym_altgr = NoSymbol;
+ xkey.state = Mod1Mask;
+ XLookupString(&xkey, NULL, 0, &keysym_altgr, NULL);
+ MAP3 key3 = {keysym, keysym_shift, keysym_altgr, xkey.keycode, 0};
+ keycode = FindVK(key3, map3, arraysize(map3));
+ if (keycode != VKEY_UNKNOWN)
+ return keycode;
+
+ keycode = KeyboardCodeFromXKeysym(keysym);
+ if (keycode == VKEY_UNKNOWN)
+ keycode = DefaultKeyboardCodeFromHardwareKeycode(xkey.keycode);
return keycode;
}
@@ -100,117 +544,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 +777,166 @@ 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[] = {
+ static const KeyboardCode 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
+ 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_UNKNOWN, // 0x61: KEY_RO Romaji
+ VKEY_UNKNOWN, // 0x62: KEY_KATAKANA Katakana
+ VKEY_UNKNOWN, // 0x63: KEY_HIRAGANA Hiragana
+ VKEY_CONVERT, // 0x64: KEY_HENKAN Henkan
+ VKEY_UNKNOWN, // 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_UNKNOWN, // 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_UNKNOWN, // 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_UNKNOWN, // 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];
}
« 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