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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 611993002: linux: Do not fallback to the hardware keycodes for modifers. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix builds. Created 6 years, 2 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> 7 #include <algorithm>
8 8
9 #define XK_3270 // for XK_3270_BackTab 9 #define XK_3270 // for XK_3270_BackTab
10 #include <X11/XF86keysym.h> 10 #include <X11/XF86keysym.h>
11 #include <X11/Xlib.h> 11 #include <X11/Xlib.h>
12 #include <X11/Xutil.h> 12 #include <X11/Xutil.h>
13 #include <X11/extensions/XInput2.h> 13 #include <X11/extensions/XInput2.h>
14 #include <X11/keysym.h> 14 #include <X11/keysym.h>
15 #if !defined(XK_dead_greek)
Wez 2014/10/03 12:38:44 Under what circumstances will this be undefined?
Yuki 2014/10/03 14:33:47 Added a comment. XK_dead_greek was recently added
16 #define XK_dead_greek 0xfe8c
17 #endif
15 18
16 #include "base/basictypes.h" 19 #include "base/basictypes.h"
17 #include "base/logging.h" 20 #include "base/logging.h"
18 #include "base/strings/stringprintf.h" 21 #include "base/strings/stringprintf.h"
19 #include "base/strings/sys_string_conversions.h" 22 #include "base/strings/sys_string_conversions.h"
20 #include "base/strings/utf_string_conversions.h" 23 #include "base/strings/utf_string_conversions.h"
21 #include "ui/events/keycodes/dom4/keycode_converter.h" 24 #include "ui/events/keycodes/dom4/keycode_converter.h"
22 #include "ui/events/x/keysym_to_unicode.h" 25 #include "ui/events/x/keysym_to_unicode.h"
23 26
24 #define VKEY_UNSUPPORTED VKEY_UNKNOWN 27 #define VKEY_UNSUPPORTED VKEY_UNKNOWN
(...skipping 427 matching lines...) Expand 10 before | Expand all | Expand 10 after
452 455
453 template <class T_MAP> 456 template <class T_MAP>
454 KeyboardCode FindVK(const T_MAP& key, const T_MAP* map, size_t size) { 457 KeyboardCode FindVK(const T_MAP& key, const T_MAP* map, size_t size) {
455 T_MAP comp = {0}; 458 T_MAP comp = {0};
456 const T_MAP* p = std::lower_bound(map, map + size, key, comp); 459 const T_MAP* p = std::lower_bound(map, map + size, key, comp);
457 if (p != map + size && !comp(*p, key) && !comp(key, *p)) 460 if (p != map + size && !comp(*p, key) && !comp(key, *p))
458 return static_cast<KeyboardCode>(p->vk); 461 return static_cast<KeyboardCode>(p->vk);
459 return VKEY_UNKNOWN; 462 return VKEY_UNKNOWN;
460 } 463 }
461 464
462 } // namespace 465 KeyboardCode KeyboardCodeFromHardwareKeycode(
466 unsigned int hardware_code) {
467 // This function assumes that X11 is using evdev-based keycodes.
468 static const KeyboardCode kHardwareKeycodeMap[] = {
469 // Please refer to below links for the table content:
470 // http://www.w3.org/TR/DOM-Level-3-Events-code/#keyboard-101
471 // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent.keyCode
472 // http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-92 3143f3456c/translate.pdf
473 VKEY_UNKNOWN, // 0x00:
474 VKEY_UNKNOWN, // 0x01:
475 VKEY_UNKNOWN, // 0x02:
476 VKEY_UNKNOWN, // 0x03:
477 VKEY_UNKNOWN, // 0x04:
478 VKEY_UNKNOWN, // 0x05:
479 VKEY_UNKNOWN, // 0x06:
480 VKEY_UNKNOWN, // XKB evdev (XKB - 8) X KeySym
481 VKEY_UNKNOWN, // === =============== ======
482 VKEY_ESCAPE, // 0x09: KEY_ESC Escape
483 VKEY_1, // 0x0A: KEY_1 1
484 VKEY_2, // 0x0B: KEY_2 2
485 VKEY_3, // 0x0C: KEY_3 3
486 VKEY_4, // 0x0D: KEY_4 4
487 VKEY_5, // 0x0E: KEY_5 5
488 VKEY_6, // 0x0F: KEY_6 6
489 VKEY_7, // 0x10: KEY_7 7
490 VKEY_8, // 0x11: KEY_8 8
491 VKEY_9, // 0x12: KEY_9 9
492 VKEY_0, // 0x13: KEY_0 0
493 VKEY_OEM_MINUS, // 0x14: KEY_MINUS minus
494 VKEY_OEM_PLUS, // 0x15: KEY_EQUAL equal
495 VKEY_BACK, // 0x16: KEY_BACKSPACE BackSpace
496 VKEY_TAB, // 0x17: KEY_TAB Tab
497 VKEY_Q, // 0x18: KEY_Q q
498 VKEY_W, // 0x19: KEY_W w
499 VKEY_E, // 0x1A: KEY_E e
500 VKEY_R, // 0x1B: KEY_R r
501 VKEY_T, // 0x1C: KEY_T t
502 VKEY_Y, // 0x1D: KEY_Y y
503 VKEY_U, // 0x1E: KEY_U u
504 VKEY_I, // 0x1F: KEY_I i
505 VKEY_O, // 0x20: KEY_O o
506 VKEY_P, // 0x21: KEY_P p
507 VKEY_OEM_4, // 0x22: KEY_LEFTBRACE bracketleft
508 VKEY_OEM_6, // 0x23: KEY_RIGHTBRACE bracketright
509 VKEY_RETURN, // 0x24: KEY_ENTER Return
510 VKEY_LCONTROL, // 0x25: KEY_LEFTCTRL Control_L
511 VKEY_A, // 0x26: KEY_A a
512 VKEY_S, // 0x27: KEY_S s
513 VKEY_D, // 0x28: KEY_D d
514 VKEY_F, // 0x29: KEY_F f
515 VKEY_G, // 0x2A: KEY_G g
516 VKEY_H, // 0x2B: KEY_H h
517 VKEY_J, // 0x2C: KEY_J j
518 VKEY_K, // 0x2D: KEY_K k
519 VKEY_L, // 0x2E: KEY_L l
520 VKEY_OEM_1, // 0x2F: KEY_SEMICOLON semicolon
521 VKEY_OEM_7, // 0x30: KEY_APOSTROPHE apostrophe
522 VKEY_OEM_3, // 0x31: KEY_GRAVE grave
523 VKEY_LSHIFT, // 0x32: KEY_LEFTSHIFT Shift_L
524 VKEY_OEM_5, // 0x33: KEY_BACKSLASH backslash
525 VKEY_Z, // 0x34: KEY_Z z
526 VKEY_X, // 0x35: KEY_X x
527 VKEY_C, // 0x36: KEY_C c
528 VKEY_V, // 0x37: KEY_V v
529 VKEY_B, // 0x38: KEY_B b
530 VKEY_N, // 0x39: KEY_N n
531 VKEY_M, // 0x3A: KEY_M m
532 VKEY_OEM_COMMA, // 0x3B: KEY_COMMA comma
533 VKEY_OEM_PERIOD, // 0x3C: KEY_DOT period
534 VKEY_OEM_2, // 0x3D: KEY_SLASH slash
535 VKEY_RSHIFT, // 0x3E: KEY_RIGHTSHIFT Shift_R
536 VKEY_MULTIPLY, // 0x3F: KEY_KPASTERISK KP_Multiply
537 VKEY_LMENU, // 0x40: KEY_LEFTALT Alt_L
538 VKEY_SPACE, // 0x41: KEY_SPACE space
539 VKEY_CAPITAL, // 0x42: KEY_CAPSLOCK Caps_Lock
540 VKEY_F1, // 0x43: KEY_F1 F1
541 VKEY_F2, // 0x44: KEY_F2 F2
542 VKEY_F3, // 0x45: KEY_F3 F3
543 VKEY_F4, // 0x46: KEY_F4 F4
544 VKEY_F5, // 0x47: KEY_F5 F5
545 VKEY_F6, // 0x48: KEY_F6 F6
546 VKEY_F7, // 0x49: KEY_F7 F7
547 VKEY_F8, // 0x4A: KEY_F8 F8
548 VKEY_F9, // 0x4B: KEY_F9 F9
549 VKEY_F10, // 0x4C: KEY_F10 F10
550 VKEY_NUMLOCK, // 0x4D: KEY_NUMLOCK Num_Lock
551 VKEY_SCROLL, // 0x4E: KEY_SCROLLLOCK Scroll_Lock
552 VKEY_NUMPAD7, // 0x4F: KEY_KP7 KP_7
553 VKEY_NUMPAD8, // 0x50: KEY_KP8 KP_8
554 VKEY_NUMPAD9, // 0x51: KEY_KP9 KP_9
555 VKEY_SUBTRACT, // 0x52: KEY_KPMINUS KP_Subtract
556 VKEY_NUMPAD4, // 0x53: KEY_KP4 KP_4
557 VKEY_NUMPAD5, // 0x54: KEY_KP5 KP_5
558 VKEY_NUMPAD6, // 0x55: KEY_KP6 KP_6
559 VKEY_ADD, // 0x56: KEY_KPPLUS KP_Add
560 VKEY_NUMPAD1, // 0x57: KEY_KP1 KP_1
561 VKEY_NUMPAD2, // 0x58: KEY_KP2 KP_2
562 VKEY_NUMPAD3, // 0x59: KEY_KP3 KP_3
563 VKEY_NUMPAD0, // 0x5A: KEY_KP0 KP_0
564 VKEY_DECIMAL, // 0x5B: KEY_KPDOT KP_Decimal
565 VKEY_UNKNOWN, // 0x5C:
566 VKEY_DBE_DBCSCHAR, // 0x5D: KEY_ZENKAKUHANKAKU Zenkaku_Hankaku
567 VKEY_OEM_5, // 0x5E: KEY_102ND backslash
568 VKEY_F11, // 0x5F: KEY_F11 F11
569 VKEY_F12, // 0x60: KEY_F12 F12
570 VKEY_OEM_102, // 0x61: KEY_RO Romaji
571 VKEY_UNSUPPORTED, // 0x62: KEY_KATAKANA Katakana
572 VKEY_UNSUPPORTED, // 0x63: KEY_HIRAGANA Hiragana
573 VKEY_CONVERT, // 0x64: KEY_HENKAN Henkan
574 VKEY_UNSUPPORTED, // 0x65: KEY_KATAKANAHIRAGANA Hiragana_Katakana
575 VKEY_NONCONVERT, // 0x66: KEY_MUHENKAN Muhenkan
576 VKEY_SEPARATOR, // 0x67: KEY_KPJPCOMMA KP_Separator
577 VKEY_RETURN, // 0x68: KEY_KPENTER KP_Enter
578 VKEY_RCONTROL, // 0x69: KEY_RIGHTCTRL Control_R
579 VKEY_DIVIDE, // 0x6A: KEY_KPSLASH KP_Divide
580 VKEY_PRINT, // 0x6B: KEY_SYSRQ Print
581 VKEY_RMENU, // 0x6C: KEY_RIGHTALT Alt_R
582 VKEY_RETURN, // 0x6D: KEY_LINEFEED Linefeed
583 VKEY_HOME, // 0x6E: KEY_HOME Home
584 VKEY_UP, // 0x6F: KEY_UP Up
585 VKEY_PRIOR, // 0x70: KEY_PAGEUP Page_Up
586 VKEY_LEFT, // 0x71: KEY_LEFT Left
587 VKEY_RIGHT, // 0x72: KEY_RIGHT Right
588 VKEY_END, // 0x73: KEY_END End
589 VKEY_DOWN, // 0x74: KEY_DOWN Down
590 VKEY_NEXT, // 0x75: KEY_PAGEDOWN Page_Down
591 VKEY_INSERT, // 0x76: KEY_INSERT Insert
592 VKEY_DELETE, // 0x77: KEY_DELETE Delete
593 VKEY_UNSUPPORTED, // 0x78: KEY_MACRO
594 VKEY_VOLUME_MUTE, // 0x79: KEY_MUTE XF86AudioMute
595 VKEY_VOLUME_DOWN, // 0x7A: KEY_VOLUMEDOWN XF86AudioLowerVolume
596 VKEY_VOLUME_UP, // 0x7B: KEY_VOLUMEUP XF86AudioRaiseVolume
597 VKEY_POWER, // 0x7C: KEY_POWER XF86PowerOff
598 VKEY_OEM_PLUS, // 0x7D: KEY_KPEQUAL KP_Equal
599 VKEY_UNSUPPORTED, // 0x7E: KEY_KPPLUSMINUS plusminus
600 VKEY_PAUSE, // 0x7F: KEY_PAUSE Pause
601 VKEY_MEDIA_LAUNCH_APP1, // 0x80: KEY_SCALE XF86LaunchA
602 VKEY_DECIMAL, // 0x81: KEY_KPCOMMA KP_Decimal
603 VKEY_HANGUL, // 0x82: KEY_HANGUEL Hangul
604 VKEY_HANJA, // 0x83: KEY_HANJA Hangul_Hanja
605 VKEY_OEM_5, // 0x84: KEY_YEN yen
606 VKEY_LWIN, // 0x85: KEY_LEFTMETA Super_L
607 VKEY_RWIN, // 0x86: KEY_RIGHTMETA Super_R
608 VKEY_COMPOSE, // 0x87: KEY_COMPOSE Menu
609 };
463 610
464 // Get an ui::KeyboardCode from an X keyevent 611 if (hardware_code >= arraysize(kHardwareKeycodeMap)) {
465 KeyboardCode KeyboardCodeFromXKeyEvent(const XEvent* xev) { 612 // Additional keycodes used by the Chrome OS top row special function keys.
466 // Gets correct VKEY code from XEvent is performed as the following steps: 613 switch (hardware_code) {
467 // 1. Gets the keysym without modifier states. 614 case 0xA6: // KEY_BACK
468 // 2. For [a-z] & [0-9] cases, returns the VKEY code accordingly. 615 return VKEY_BACK;
469 // 3. Find keysym in map0. 616 case 0xA7: // KEY_FORWARD
470 // 4. If not found, fallback to find keysym + hardware_code in map1. 617 return VKEY_BROWSER_FORWARD;
471 // 5. If not found, fallback to find keysym + keysym_shift + hardware_code 618 case 0xB5: // KEY_REFRESH
472 // in map2. 619 return VKEY_BROWSER_REFRESH;
473 // 6. If not found, fallback to find keysym + keysym_shift + keysym_altgr + 620 case 0xD4: // KEY_DASHBOARD
474 // hardware_code in map3. 621 return VKEY_MEDIA_LAUNCH_APP2;
475 // 7. If not found, fallback to find in KeyboardCodeFromXKeysym(), which 622 case 0xE8: // KEY_BRIGHTNESSDOWN
476 // mainly for non-letter keys. 623 return VKEY_BRIGHTNESS_DOWN;
477 // 8. If not found, fallback to find with the hardware code in US layout. 624 case 0xE9: // KEY_BRIGHTNESSUP
478 625 return VKEY_BRIGHTNESS_UP;
479 KeySym keysym = NoSymbol; 626 }
480 XEvent xkeyevent = {0}; 627 return VKEY_UNKNOWN;
481 if (xev->type == GenericEvent) {
482 // Convert the XI2 key event into a core key event so that we can
483 // continue to use XLookupString() until crbug.com/367732 is complete.
484 InitXKeyEventFromXIDeviceEvent(*xev, &xkeyevent);
485 } else {
486 xkeyevent.xkey = xev->xkey;
487 } 628 }
488 XKeyEvent* xkey = &xkeyevent.xkey; 629 return kHardwareKeycodeMap[hardware_code];
489 xkey->state &= (~0xFF | Mod2Mask); // Clears the xkey's state except numlock.
490 // XLookupKeysym does not take into consideration the state of the lock/shift
491 // etc. keys. So it is necessary to use XLookupString instead.
492 XLookupString(xkey, NULL, 0, &keysym, NULL);
493
494 // [a-z] cases.
495 if (keysym >= XK_a && keysym <= XK_z)
496 return static_cast<KeyboardCode>(VKEY_A + keysym - XK_a);
497
498 // [0-9] cases.
499 if (keysym >= XK_0 && keysym <= XK_9)
500 return static_cast<KeyboardCode>(VKEY_0 + keysym - XK_0);
501
502 KeyboardCode keycode = VKEY_UNKNOWN;
503
504 if (!IsKeypadKey(keysym) && !IsPrivateKeypadKey(keysym) &&
505 !IsCursorKey(keysym) && !IsPFKey(keysym) && !IsFunctionKey(keysym) &&
506 !IsModifierKey(keysym)) {
507 MAP0 key0 = {keysym & 0xFFFF, 0};
508 keycode = FindVK(key0, map0, arraysize(map0));
509 if (keycode != VKEY_UNKNOWN)
510 return keycode;
511
512 MAP1 key1 = {keysym & 0xFFFF, xkey->keycode, 0};
513 keycode = FindVK(key1, map1, arraysize(map1));
514 if (keycode != VKEY_UNKNOWN)
515 return keycode;
516
517 KeySym keysym_shift = NoSymbol;
518 xkey->state |= ShiftMask;
519 XLookupString(xkey, NULL, 0, &keysym_shift, NULL);
520 MAP2 key2 = {keysym & 0xFFFF, xkey->keycode, keysym_shift & 0xFFFF, 0};
521 keycode = FindVK(key2, map2, arraysize(map2));
522 if (keycode != VKEY_UNKNOWN)
523 return keycode;
524
525 KeySym keysym_altgr = NoSymbol;
526 xkey->state &= ~ShiftMask;
527 xkey->state |= Mod1Mask;
528 XLookupString(xkey, NULL, 0, &keysym_altgr, NULL);
529 MAP3 key3 = {keysym & 0xFFFF, xkey->keycode, keysym_shift & 0xFFFF,
530 keysym_altgr & 0xFFFF, 0};
531 keycode = FindVK(key3, map3, arraysize(map3));
532 if (keycode != VKEY_UNKNOWN)
533 return keycode;
534
535 // On Linux some keys has AltGr char but not on Windows.
536 // So if cannot find VKEY with (ch0+sc+ch1+ch2) in map3, tries to fallback
537 // to just find VKEY with (ch0+sc+ch1). This is the best we could do.
538 MAP3 key4 = {keysym & 0xFFFF, xkey->keycode, keysym_shift & 0xFFFF, 0xFFFF,
539 0};
540 const MAP3* p =
541 std::lower_bound(map3, map3 + arraysize(map3), key4, MAP3());
542 if (p != map3 + arraysize(map3) && p->ch0 == key4.ch0 && p->sc == key4.sc &&
543 p->ch1 == key4.ch1)
544 return static_cast<KeyboardCode>(p->vk);
545 }
546
547 keycode = KeyboardCodeFromXKeysym(keysym);
548 if (keycode == VKEY_UNKNOWN)
549 keycode = DefaultKeyboardCodeFromHardwareKeycode(xkey->keycode);
550
551 return keycode;
552 } 630 }
553 631
554 KeyboardCode KeyboardCodeFromXKeysym(unsigned int keysym) { 632 KeyboardCode KeyboardCodeFromXKeysymOrHardwareKeycode(unsigned int keysym,
633 unsigned int keycode) {
555 // TODO(sad): Have |keysym| go through the X map list? 634 // TODO(sad): Have |keysym| go through the X map list?
556 635
557 switch (keysym) { 636 switch (keysym) {
558 case XK_BackSpace: 637 case XK_BackSpace:
559 return VKEY_BACK; 638 return VKEY_BACK;
560 case XK_Delete: 639 case XK_Delete:
561 case XK_KP_Delete: 640 case XK_KP_Delete:
562 return VKEY_DELETE; 641 return VKEY_DELETE;
563 case XK_Tab: 642 case XK_Tab:
564 case XK_KP_Tab: 643 case XK_KP_Tab:
(...skipping 189 matching lines...) Expand 10 before | Expand all | Expand 10 after
754 case XK_guillemotleft: 833 case XK_guillemotleft:
755 case XK_guillemotright: 834 case XK_guillemotright:
756 case XK_degree: 835 case XK_degree:
757 // In the case of canadian multilingual keyboard layout, VKEY_OEM_102 is 836 // In the case of canadian multilingual keyboard layout, VKEY_OEM_102 is
758 // assigned to ugrave key. 837 // assigned to ugrave key.
759 case XK_ugrave: 838 case XK_ugrave:
760 case XK_Ugrave: 839 case XK_Ugrave:
761 case XK_brokenbar: 840 case XK_brokenbar:
762 return VKEY_OEM_102; // international backslash key in 102 keyboard. 841 return VKEY_OEM_102; // international backslash key in 102 keyboard.
763 842
843 case XK_Hyper_L:
Wez 2014/10/03 12:38:44 Regardless of where this list of always-UNKNOWN co
Yuki 2014/10/03 14:33:47 Added a comment.
844 case XK_Hyper_R:
845 case XK_ISO_Lock:
846 case XK_ISO_Level2_Latch:
847 case XK_ISO_Level3_Latch:
848 case XK_ISO_Level3_Lock:
849 case XK_ISO_Level5_Latch:
850 case XK_ISO_Level5_Lock:
851 case XK_ISO_Group_Latch:
852 case XK_ISO_Group_Lock:
853 case XK_ISO_Next_Group:
854 case XK_ISO_Next_Group_Lock:
855 case XK_ISO_Prev_Group:
856 case XK_ISO_Prev_Group_Lock:
857 case XK_ISO_First_Group:
858 case XK_ISO_First_Group_Lock:
859 case XK_ISO_Last_Group:
860 case XK_ISO_Last_Group_Lock:
861 case XK_dead_grave:
862 case XK_dead_acute:
863 case XK_dead_circumflex:
864 case XK_dead_tilde:
865 case XK_dead_macron:
866 case XK_dead_breve:
867 case XK_dead_abovedot:
868 case XK_dead_diaeresis:
869 case XK_dead_abovering:
870 case XK_dead_doubleacute:
871 case XK_dead_caron:
872 case XK_dead_cedilla:
873 case XK_dead_ogonek:
874 case XK_dead_iota:
875 case XK_dead_voiced_sound:
876 case XK_dead_semivoiced_sound:
877 case XK_dead_belowdot:
878 case XK_dead_hook:
879 case XK_dead_horn:
880 case XK_dead_stroke:
881 case XK_dead_abovecomma:
882 case XK_dead_abovereversedcomma:
883 case XK_dead_doublegrave:
884 case XK_dead_belowring:
885 case XK_dead_belowmacron:
886 case XK_dead_belowcircumflex:
887 case XK_dead_belowtilde:
888 case XK_dead_belowbreve:
889 case XK_dead_belowdiaeresis:
890 case XK_dead_invertedbreve:
891 case XK_dead_belowcomma:
892 case XK_dead_currency:
893 case XK_dead_a:
894 case XK_dead_A:
895 case XK_dead_e:
896 case XK_dead_E:
897 case XK_dead_i:
898 case XK_dead_I:
899 case XK_dead_o:
900 case XK_dead_O:
901 case XK_dead_u:
902 case XK_dead_U:
903 case XK_dead_small_schwa:
904 case XK_dead_capital_schwa:
905 case XK_dead_greek:
906 case XK_First_Virtual_Screen:
907 case XK_Prev_Virtual_Screen:
908 case XK_Next_Virtual_Screen:
909 case XK_Last_Virtual_Screen:
910 case XK_Terminate_Server:
911 case XK_AccessX_Enable:
912 case XK_AccessX_Feedback_Enable:
913 case XK_RepeatKeys_Enable:
914 case XK_SlowKeys_Enable:
915 case XK_BounceKeys_Enable:
916 case XK_StickyKeys_Enable:
917 case XK_MouseKeys_Enable:
918 case XK_MouseKeys_Accel_Enable:
919 case XK_Overlay1_Enable:
920 case XK_Overlay2_Enable:
921 case XK_AudibleBell_Enable:
922 case XK_Pointer_Left:
923 case XK_Pointer_Right:
924 case XK_Pointer_Up:
925 case XK_Pointer_Down:
926 case XK_Pointer_UpLeft:
927 case XK_Pointer_UpRight:
928 case XK_Pointer_DownLeft:
929 case XK_Pointer_DownRight:
930 case XK_Pointer_Button_Dflt:
931 case XK_Pointer_Button1:
932 case XK_Pointer_Button2:
933 case XK_Pointer_Button3:
934 case XK_Pointer_Button4:
935 case XK_Pointer_Button5:
936 case XK_Pointer_DblClick_Dflt:
937 case XK_Pointer_DblClick1:
938 case XK_Pointer_DblClick2:
939 case XK_Pointer_DblClick3:
940 case XK_Pointer_DblClick4:
941 case XK_Pointer_DblClick5:
942 case XK_Pointer_Drag_Dflt:
943 case XK_Pointer_Drag1:
944 case XK_Pointer_Drag2:
945 case XK_Pointer_Drag3:
946 case XK_Pointer_Drag4:
947 case XK_Pointer_Drag5:
948 case XK_Pointer_EnableKeys:
949 case XK_Pointer_Accelerate:
950 case XK_Pointer_DfltBtnNext:
951 case XK_Pointer_DfltBtnPrev:
952 return VKEY_UNKNOWN;
953
764 // When evdev is in use, /usr/share/X11/xkb/symbols/inet maps F13-18 keys 954 // When evdev is in use, /usr/share/X11/xkb/symbols/inet maps F13-18 keys
765 // to the special XF86XK symbols to support Microsoft Ergonomic keyboards: 955 // to the special XF86XK symbols to support Microsoft Ergonomic keyboards:
766 // https://bugs.freedesktop.org/show_bug.cgi?id=5783 956 // https://bugs.freedesktop.org/show_bug.cgi?id=5783
767 // In Chrome, we map these X key symbols back to F13-18 since we don't have 957 // In Chrome, we map these X key symbols back to F13-18 since we don't have
768 // VKEYs for these XF86XK symbols. 958 // VKEYs for these XF86XK symbols.
769 case XF86XK_Launch5: 959 case XF86XK_Launch5:
770 return VKEY_F14; 960 return VKEY_F14;
771 case XF86XK_Launch6: 961 case XF86XK_Launch6:
772 return VKEY_F15; 962 return VKEY_F15;
773 case XF86XK_Launch7: 963 case XF86XK_Launch7:
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
828 return VKEY_BRIGHTNESS_DOWN; 1018 return VKEY_BRIGHTNESS_DOWN;
829 case XF86XK_MonBrightnessUp: 1019 case XF86XK_MonBrightnessUp:
830 return VKEY_BRIGHTNESS_UP; 1020 return VKEY_BRIGHTNESS_UP;
831 case XF86XK_KbdBrightnessDown: 1021 case XF86XK_KbdBrightnessDown:
832 return VKEY_KBD_BRIGHTNESS_DOWN; 1022 return VKEY_KBD_BRIGHTNESS_DOWN;
833 case XF86XK_KbdBrightnessUp: 1023 case XF86XK_KbdBrightnessUp:
834 return VKEY_KBD_BRIGHTNESS_UP; 1024 return VKEY_KBD_BRIGHTNESS_UP;
835 1025
836 // TODO(sad): some keycodes are still missing. 1026 // TODO(sad): some keycodes are still missing.
837 } 1027 }
1028
838 DVLOG(1) << "Unknown keysym: " << base::StringPrintf("0x%x", keysym); 1029 DVLOG(1) << "Unknown keysym: " << base::StringPrintf("0x%x", keysym);
839 return VKEY_UNKNOWN; 1030 return KeyboardCodeFromHardwareKeycode(keycode);
1031 }
1032
1033 } // namespace
1034
1035 // Get an ui::KeyboardCode from an X keyevent
1036 KeyboardCode KeyboardCodeFromXKeyEvent(const XEvent* xev) {
1037 // Gets correct VKEY code from XEvent is performed as the following steps:
1038 // 1. Gets the keysym without modifier states.
1039 // 2. For [a-z] & [0-9] cases, returns the VKEY code accordingly.
1040 // 3. Find keysym in map0.
1041 // 4. If not found, fallback to find keysym + hardware_code in map1.
1042 // 5. If not found, fallback to find keysym + keysym_shift + hardware_code
1043 // in map2.
1044 // 6. If not found, fallback to find keysym + keysym_shift + keysym_altgr +
1045 // hardware_code in map3.
1046 // 7. If not found, fallback to find in KeyboardCodeFromXKeysym(), which
1047 // mainly for non-letter keys.
1048 // 8. If not found, fallback to find with the hardware code in US layout.
Wez 2014/10/03 12:38:44 Looks like steps #7 and #8 are now folded into Fro
Yuki 2014/10/03 14:33:47 Thanks for the suggestion. I made a separate func
1049
1050 KeySym keysym = NoSymbol;
1051 XEvent xkeyevent = {0};
1052 if (xev->type == GenericEvent) {
1053 // Convert the XI2 key event into a core key event so that we can
1054 // continue to use XLookupString() until crbug.com/367732 is complete.
1055 InitXKeyEventFromXIDeviceEvent(*xev, &xkeyevent);
1056 } else {
1057 xkeyevent.xkey = xev->xkey;
1058 }
1059 XKeyEvent* xkey = &xkeyevent.xkey;
1060 xkey->state &= (~0xFF | Mod2Mask); // Clears the xkey's state except numlock.
1061 // XLookupKeysym does not take into consideration the state of the lock/shift
1062 // etc. keys. So it is necessary to use XLookupString instead.
1063 XLookupString(xkey, NULL, 0, &keysym, NULL);
1064
1065 // [a-z] cases.
1066 if (keysym >= XK_a && keysym <= XK_z)
1067 return static_cast<KeyboardCode>(VKEY_A + keysym - XK_a);
1068
1069 // [0-9] cases.
1070 if (keysym >= XK_0 && keysym <= XK_9)
1071 return static_cast<KeyboardCode>(VKEY_0 + keysym - XK_0);
1072
1073 KeyboardCode keycode = VKEY_UNKNOWN;
1074
1075 if (!IsKeypadKey(keysym) && !IsPrivateKeypadKey(keysym) &&
1076 !IsCursorKey(keysym) && !IsPFKey(keysym) && !IsFunctionKey(keysym) &&
1077 !IsModifierKey(keysym)) {
1078 MAP0 key0 = {keysym & 0xFFFF, 0};
1079 keycode = FindVK(key0, map0, arraysize(map0));
1080 if (keycode != VKEY_UNKNOWN)
1081 return keycode;
1082
1083 MAP1 key1 = {keysym & 0xFFFF, xkey->keycode, 0};
1084 keycode = FindVK(key1, map1, arraysize(map1));
1085 if (keycode != VKEY_UNKNOWN)
1086 return keycode;
1087
1088 KeySym keysym_shift = NoSymbol;
1089 xkey->state |= ShiftMask;
1090 XLookupString(xkey, NULL, 0, &keysym_shift, NULL);
1091 MAP2 key2 = {keysym & 0xFFFF, xkey->keycode, keysym_shift & 0xFFFF, 0};
1092 keycode = FindVK(key2, map2, arraysize(map2));
1093 if (keycode != VKEY_UNKNOWN)
1094 return keycode;
1095
1096 KeySym keysym_altgr = NoSymbol;
1097 xkey->state &= ~ShiftMask;
1098 xkey->state |= Mod1Mask;
1099 XLookupString(xkey, NULL, 0, &keysym_altgr, NULL);
1100 MAP3 key3 = {keysym & 0xFFFF, xkey->keycode, keysym_shift & 0xFFFF,
1101 keysym_altgr & 0xFFFF, 0};
1102 keycode = FindVK(key3, map3, arraysize(map3));
1103 if (keycode != VKEY_UNKNOWN)
1104 return keycode;
1105
1106 // On Linux some keys has AltGr char but not on Windows.
1107 // So if cannot find VKEY with (ch0+sc+ch1+ch2) in map3, tries to fallback
1108 // to just find VKEY with (ch0+sc+ch1). This is the best we could do.
1109 MAP3 key4 = {keysym & 0xFFFF, xkey->keycode, keysym_shift & 0xFFFF, 0xFFFF,
1110 0};
1111 const MAP3* p =
1112 std::lower_bound(map3, map3 + arraysize(map3), key4, MAP3());
1113 if (p != map3 + arraysize(map3) && p->ch0 == key4.ch0 && p->sc == key4.sc &&
1114 p->ch1 == key4.ch1)
1115 return static_cast<KeyboardCode>(p->vk);
1116 }
1117
1118 return KeyboardCodeFromXKeysymOrHardwareKeycode(keysym, xkey->keycode);
1119 }
1120
1121 KeyboardCode KeyboardCodeFromXKeysym(unsigned int keysym) {
1122 return KeyboardCodeFromXKeysymOrHardwareKeycode(keysym, 0);
840 } 1123 }
841 1124
842 const char* CodeFromXEvent(const XEvent* xev) { 1125 const char* CodeFromXEvent(const XEvent* xev) {
843 int keycode = (xev->type == GenericEvent) 1126 int keycode = (xev->type == GenericEvent)
844 ? static_cast<XIDeviceEvent*>(xev->xcookie.data)->detail 1127 ? static_cast<XIDeviceEvent*>(xev->xcookie.data)->detail
845 : xev->xkey.keycode; 1128 : xev->xkey.keycode;
846 return ui::KeycodeConverter::NativeKeycodeToCode(keycode); 1129 return ui::KeycodeConverter::NativeKeycodeToCode(keycode);
847 } 1130 }
848 1131
849 uint16 GetCharacterFromXEvent(const XEvent* xev) { 1132 uint16 GetCharacterFromXEvent(const XEvent* xev) {
850 XEvent xkeyevent = {0}; 1133 XEvent xkeyevent = {0};
851 const XKeyEvent* xkey = NULL; 1134 const XKeyEvent* xkey = NULL;
852 if (xev->type == GenericEvent) { 1135 if (xev->type == GenericEvent) {
853 // Convert the XI2 key event into a core key event so that we can 1136 // Convert the XI2 key event into a core key event so that we can
854 // continue to use XLookupString() until crbug.com/367732 is complete. 1137 // continue to use XLookupString() until crbug.com/367732 is complete.
855 InitXKeyEventFromXIDeviceEvent(*xev, &xkeyevent); 1138 InitXKeyEventFromXIDeviceEvent(*xev, &xkeyevent);
856 xkey = &xkeyevent.xkey; 1139 xkey = &xkeyevent.xkey;
857 } else { 1140 } else {
858 xkey = &xev->xkey; 1141 xkey = &xev->xkey;
859 } 1142 }
860 KeySym keysym = XK_VoidSymbol; 1143 KeySym keysym = XK_VoidSymbol;
861 XLookupString(const_cast<XKeyEvent*>(xkey), NULL, 0, &keysym, NULL); 1144 XLookupString(const_cast<XKeyEvent*>(xkey), NULL, 0, &keysym, NULL);
862 return GetUnicodeCharacterFromXKeySym(keysym); 1145 return GetUnicodeCharacterFromXKeySym(keysym);
863 } 1146 }
864 1147
865 KeyboardCode DefaultKeyboardCodeFromHardwareKeycode(
866 unsigned int hardware_code) {
867 // This function assumes that X11 is using evdev-based keycodes.
868 static const KeyboardCode kHardwareKeycodeMap[] = {
869 // Please refer to below links for the table content:
870 // http://www.w3.org/TR/DOM-Level-3-Events-code/#keyboard-101
871 // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent.keyCode
872 // http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-92 3143f3456c/translate.pdf
873 VKEY_UNKNOWN, // 0x00:
874 VKEY_UNKNOWN, // 0x01:
875 VKEY_UNKNOWN, // 0x02:
876 VKEY_UNKNOWN, // 0x03:
877 VKEY_UNKNOWN, // 0x04:
878 VKEY_UNKNOWN, // 0x05:
879 VKEY_UNKNOWN, // 0x06:
880 VKEY_UNKNOWN, // XKB evdev (XKB - 8) X KeySym
881 VKEY_UNKNOWN, // === =============== ======
882 VKEY_ESCAPE, // 0x09: KEY_ESC Escape
883 VKEY_1, // 0x0A: KEY_1 1
884 VKEY_2, // 0x0B: KEY_2 2
885 VKEY_3, // 0x0C: KEY_3 3
886 VKEY_4, // 0x0D: KEY_4 4
887 VKEY_5, // 0x0E: KEY_5 5
888 VKEY_6, // 0x0F: KEY_6 6
889 VKEY_7, // 0x10: KEY_7 7
890 VKEY_8, // 0x11: KEY_8 8
891 VKEY_9, // 0x12: KEY_9 9
892 VKEY_0, // 0x13: KEY_0 0
893 VKEY_OEM_MINUS, // 0x14: KEY_MINUS minus
894 VKEY_OEM_PLUS, // 0x15: KEY_EQUAL equal
895 VKEY_BACK, // 0x16: KEY_BACKSPACE BackSpace
896 VKEY_TAB, // 0x17: KEY_TAB Tab
897 VKEY_Q, // 0x18: KEY_Q q
898 VKEY_W, // 0x19: KEY_W w
899 VKEY_E, // 0x1A: KEY_E e
900 VKEY_R, // 0x1B: KEY_R r
901 VKEY_T, // 0x1C: KEY_T t
902 VKEY_Y, // 0x1D: KEY_Y y
903 VKEY_U, // 0x1E: KEY_U u
904 VKEY_I, // 0x1F: KEY_I i
905 VKEY_O, // 0x20: KEY_O o
906 VKEY_P, // 0x21: KEY_P p
907 VKEY_OEM_4, // 0x22: KEY_LEFTBRACE bracketleft
908 VKEY_OEM_6, // 0x23: KEY_RIGHTBRACE bracketright
909 VKEY_RETURN, // 0x24: KEY_ENTER Return
910 VKEY_LCONTROL, // 0x25: KEY_LEFTCTRL Control_L
911 VKEY_A, // 0x26: KEY_A a
912 VKEY_S, // 0x27: KEY_S s
913 VKEY_D, // 0x28: KEY_D d
914 VKEY_F, // 0x29: KEY_F f
915 VKEY_G, // 0x2A: KEY_G g
916 VKEY_H, // 0x2B: KEY_H h
917 VKEY_J, // 0x2C: KEY_J j
918 VKEY_K, // 0x2D: KEY_K k
919 VKEY_L, // 0x2E: KEY_L l
920 VKEY_OEM_1, // 0x2F: KEY_SEMICOLON semicolon
921 VKEY_OEM_7, // 0x30: KEY_APOSTROPHE apostrophe
922 VKEY_OEM_3, // 0x31: KEY_GRAVE grave
923 VKEY_LSHIFT, // 0x32: KEY_LEFTSHIFT Shift_L
924 VKEY_OEM_5, // 0x33: KEY_BACKSLASH backslash
925 VKEY_Z, // 0x34: KEY_Z z
926 VKEY_X, // 0x35: KEY_X x
927 VKEY_C, // 0x36: KEY_C c
928 VKEY_V, // 0x37: KEY_V v
929 VKEY_B, // 0x38: KEY_B b
930 VKEY_N, // 0x39: KEY_N n
931 VKEY_M, // 0x3A: KEY_M m
932 VKEY_OEM_COMMA, // 0x3B: KEY_COMMA comma
933 VKEY_OEM_PERIOD, // 0x3C: KEY_DOT period
934 VKEY_OEM_2, // 0x3D: KEY_SLASH slash
935 VKEY_RSHIFT, // 0x3E: KEY_RIGHTSHIFT Shift_R
936 VKEY_MULTIPLY, // 0x3F: KEY_KPASTERISK KP_Multiply
937 VKEY_LMENU, // 0x40: KEY_LEFTALT Alt_L
938 VKEY_SPACE, // 0x41: KEY_SPACE space
939 VKEY_CAPITAL, // 0x42: KEY_CAPSLOCK Caps_Lock
940 VKEY_F1, // 0x43: KEY_F1 F1
941 VKEY_F2, // 0x44: KEY_F2 F2
942 VKEY_F3, // 0x45: KEY_F3 F3
943 VKEY_F4, // 0x46: KEY_F4 F4
944 VKEY_F5, // 0x47: KEY_F5 F5
945 VKEY_F6, // 0x48: KEY_F6 F6
946 VKEY_F7, // 0x49: KEY_F7 F7
947 VKEY_F8, // 0x4A: KEY_F8 F8
948 VKEY_F9, // 0x4B: KEY_F9 F9
949 VKEY_F10, // 0x4C: KEY_F10 F10
950 VKEY_NUMLOCK, // 0x4D: KEY_NUMLOCK Num_Lock
951 VKEY_SCROLL, // 0x4E: KEY_SCROLLLOCK Scroll_Lock
952 VKEY_NUMPAD7, // 0x4F: KEY_KP7 KP_7
953 VKEY_NUMPAD8, // 0x50: KEY_KP8 KP_8
954 VKEY_NUMPAD9, // 0x51: KEY_KP9 KP_9
955 VKEY_SUBTRACT, // 0x52: KEY_KPMINUS KP_Subtract
956 VKEY_NUMPAD4, // 0x53: KEY_KP4 KP_4
957 VKEY_NUMPAD5, // 0x54: KEY_KP5 KP_5
958 VKEY_NUMPAD6, // 0x55: KEY_KP6 KP_6
959 VKEY_ADD, // 0x56: KEY_KPPLUS KP_Add
960 VKEY_NUMPAD1, // 0x57: KEY_KP1 KP_1
961 VKEY_NUMPAD2, // 0x58: KEY_KP2 KP_2
962 VKEY_NUMPAD3, // 0x59: KEY_KP3 KP_3
963 VKEY_NUMPAD0, // 0x5A: KEY_KP0 KP_0
964 VKEY_DECIMAL, // 0x5B: KEY_KPDOT KP_Decimal
965 VKEY_UNKNOWN, // 0x5C:
966 VKEY_DBE_DBCSCHAR, // 0x5D: KEY_ZENKAKUHANKAKU Zenkaku_Hankaku
967 VKEY_OEM_5, // 0x5E: KEY_102ND backslash
968 VKEY_F11, // 0x5F: KEY_F11 F11
969 VKEY_F12, // 0x60: KEY_F12 F12
970 VKEY_OEM_102, // 0x61: KEY_RO Romaji
971 VKEY_UNSUPPORTED, // 0x62: KEY_KATAKANA Katakana
972 VKEY_UNSUPPORTED, // 0x63: KEY_HIRAGANA Hiragana
973 VKEY_CONVERT, // 0x64: KEY_HENKAN Henkan
974 VKEY_UNSUPPORTED, // 0x65: KEY_KATAKANAHIRAGANA Hiragana_Katakana
975 VKEY_NONCONVERT, // 0x66: KEY_MUHENKAN Muhenkan
976 VKEY_SEPARATOR, // 0x67: KEY_KPJPCOMMA KP_Separator
977 VKEY_RETURN, // 0x68: KEY_KPENTER KP_Enter
978 VKEY_RCONTROL, // 0x69: KEY_RIGHTCTRL Control_R
979 VKEY_DIVIDE, // 0x6A: KEY_KPSLASH KP_Divide
980 VKEY_PRINT, // 0x6B: KEY_SYSRQ Print
981 VKEY_RMENU, // 0x6C: KEY_RIGHTALT Alt_R
982 VKEY_RETURN, // 0x6D: KEY_LINEFEED Linefeed
983 VKEY_HOME, // 0x6E: KEY_HOME Home
984 VKEY_UP, // 0x6F: KEY_UP Up
985 VKEY_PRIOR, // 0x70: KEY_PAGEUP Page_Up
986 VKEY_LEFT, // 0x71: KEY_LEFT Left
987 VKEY_RIGHT, // 0x72: KEY_RIGHT Right
988 VKEY_END, // 0x73: KEY_END End
989 VKEY_DOWN, // 0x74: KEY_DOWN Down
990 VKEY_NEXT, // 0x75: KEY_PAGEDOWN Page_Down
991 VKEY_INSERT, // 0x76: KEY_INSERT Insert
992 VKEY_DELETE, // 0x77: KEY_DELETE Delete
993 VKEY_UNSUPPORTED, // 0x78: KEY_MACRO
994 VKEY_VOLUME_MUTE, // 0x79: KEY_MUTE XF86AudioMute
995 VKEY_VOLUME_DOWN, // 0x7A: KEY_VOLUMEDOWN XF86AudioLowerVolume
996 VKEY_VOLUME_UP, // 0x7B: KEY_VOLUMEUP XF86AudioRaiseVolume
997 VKEY_POWER, // 0x7C: KEY_POWER XF86PowerOff
998 VKEY_OEM_PLUS, // 0x7D: KEY_KPEQUAL KP_Equal
999 VKEY_UNSUPPORTED, // 0x7E: KEY_KPPLUSMINUS plusminus
1000 VKEY_PAUSE, // 0x7F: KEY_PAUSE Pause
1001 VKEY_MEDIA_LAUNCH_APP1, // 0x80: KEY_SCALE XF86LaunchA
1002 VKEY_DECIMAL, // 0x81: KEY_KPCOMMA KP_Decimal
1003 VKEY_HANGUL, // 0x82: KEY_HANGUEL Hangul
1004 VKEY_HANJA, // 0x83: KEY_HANJA Hangul_Hanja
1005 VKEY_OEM_5, // 0x84: KEY_YEN yen
1006 VKEY_LWIN, // 0x85: KEY_LEFTMETA Super_L
1007 VKEY_RWIN, // 0x86: KEY_RIGHTMETA Super_R
1008 VKEY_COMPOSE, // 0x87: KEY_COMPOSE Menu
1009 };
1010
1011 if (hardware_code >= arraysize(kHardwareKeycodeMap)) {
1012 // Additional keycodes used by the Chrome OS top row special function keys.
1013 switch (hardware_code) {
1014 case 0xA6: // KEY_BACK
1015 return VKEY_BACK;
1016 case 0xA7: // KEY_FORWARD
1017 return VKEY_BROWSER_FORWARD;
1018 case 0xB5: // KEY_REFRESH
1019 return VKEY_BROWSER_REFRESH;
1020 case 0xD4: // KEY_DASHBOARD
1021 return VKEY_MEDIA_LAUNCH_APP2;
1022 case 0xE8: // KEY_BRIGHTNESSDOWN
1023 return VKEY_BRIGHTNESS_DOWN;
1024 case 0xE9: // KEY_BRIGHTNESSUP
1025 return VKEY_BRIGHTNESS_UP;
1026 }
1027 return VKEY_UNKNOWN;
1028 }
1029 return kHardwareKeycodeMap[hardware_code];
1030 }
1031
1032 // TODO(jcampan): this method might be incomplete. 1148 // TODO(jcampan): this method might be incomplete.
1033 int XKeysymForWindowsKeyCode(KeyboardCode keycode, bool shift) { 1149 int XKeysymForWindowsKeyCode(KeyboardCode keycode, bool shift) {
1034 switch (keycode) { 1150 switch (keycode) {
1035 case VKEY_NUMPAD0: 1151 case VKEY_NUMPAD0:
1036 return XK_KP_0; 1152 return XK_KP_0;
1037 case VKEY_NUMPAD1: 1153 case VKEY_NUMPAD1:
1038 return XK_KP_1; 1154 return XK_KP_1;
1039 case VKEY_NUMPAD2: 1155 case VKEY_NUMPAD2:
1040 return XK_KP_2; 1156 return XK_KP_2;
1041 case VKEY_NUMPAD3: 1157 case VKEY_NUMPAD3:
(...skipping 305 matching lines...) Expand 10 before | Expand all | Expand 10 after
1347 // alone does not map to XK_less; XKeysymToKeycode() returns KEY_102ND 1463 // alone does not map to XK_less; XKeysymToKeycode() returns KEY_102ND
1348 // (the '<>' key between Shift and Z on 105-key keyboards) which does. 1464 // (the '<>' key between Shift and Z on 105-key keyboards) which does.
1349 // 1465 //
1350 // crbug.com/386066 and crbug.com/390263 are examples of problems 1466 // crbug.com/386066 and crbug.com/390263 are examples of problems
1351 // associated with this. 1467 // associated with this.
1352 // 1468 //
1353 return XKeysymToKeycode(display, XKeysymForWindowsKeyCode(key_code, false)); 1469 return XKeysymToKeycode(display, XKeysymForWindowsKeyCode(key_code, false));
1354 } 1470 }
1355 1471
1356 } // namespace ui 1472 } // 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