Home | History | Annotate | Download | only in chromedriver
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/test/chromedriver/keycode_text_conversion.h"
      6 
      7 #include <algorithm>
      8 #include <X11/keysym.h>
      9 #include <X11/XKBlib.h>
     10 #include <X11/Xlib.h>
     11 #include <X11/Xutil.h>
     12 
     13 #include "base/strings/utf_string_conversions.h"
     14 #include "chrome/test/chromedriver/chrome/ui_events.h"
     15 #include "ui/base/x/x11_util.h"
     16 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
     17 
     18 namespace {
     19 
     20 struct KeyCodeAndXKeyCode {
     21   ui::KeyboardCode key_code;
     22   int x_key_code;
     23 };
     24 
     25 // Contains a list of keyboard codes, in order, with their corresponding
     26 // X key code. This list is not complete.
     27 // TODO(kkania): Merge this table with the existing one in
     28 // keyboard_code_conversion_x.cc.
     29 KeyCodeAndXKeyCode kKeyCodeToXKeyCode[] = {
     30   { ui::VKEY_BACK, 22 },
     31   { ui::VKEY_TAB, 23 },
     32   { ui::VKEY_RETURN, 36 },
     33   { ui::VKEY_SHIFT, 50 },
     34   { ui::VKEY_CONTROL, 37 },
     35   { ui::VKEY_MENU, 64 },
     36   { ui::VKEY_CAPITAL, 66 },
     37   { ui::VKEY_HANGUL, 130 },
     38   { ui::VKEY_HANJA, 131 },
     39   { ui::VKEY_ESCAPE, 9 },
     40   { ui::VKEY_SPACE, 65 },
     41   { ui::VKEY_PRIOR, 112 },
     42   { ui::VKEY_NEXT, 117 },
     43   { ui::VKEY_END, 115 },
     44   { ui::VKEY_HOME, 110 },
     45   { ui::VKEY_LEFT, 113 },
     46   { ui::VKEY_UP, 111 },
     47   { ui::VKEY_RIGHT, 114 },
     48   { ui::VKEY_DOWN, 116 },
     49   { ui::VKEY_INSERT, 118 },
     50   { ui::VKEY_DELETE, 119 },
     51   { ui::VKEY_0, 19 },
     52   { ui::VKEY_1, 10 },
     53   { ui::VKEY_2, 11 },
     54   { ui::VKEY_3, 12 },
     55   { ui::VKEY_4, 13 },
     56   { ui::VKEY_5, 14 },
     57   { ui::VKEY_6, 15 },
     58   { ui::VKEY_7, 16 },
     59   { ui::VKEY_8, 17 },
     60   { ui::VKEY_9, 18 },
     61   { ui::VKEY_A, 38 },
     62   { ui::VKEY_B, 56 },
     63   { ui::VKEY_C, 54 },
     64   { ui::VKEY_D, 40 },
     65   { ui::VKEY_E, 26 },
     66   { ui::VKEY_F, 41 },
     67   { ui::VKEY_G, 42 },
     68   { ui::VKEY_H, 43 },
     69   { ui::VKEY_I, 31 },
     70   { ui::VKEY_J, 44 },
     71   { ui::VKEY_K, 45 },
     72   { ui::VKEY_L, 46 },
     73   { ui::VKEY_M, 58 },
     74   { ui::VKEY_N, 57 },
     75   { ui::VKEY_O, 32 },
     76   { ui::VKEY_P, 33 },
     77   { ui::VKEY_Q, 24 },
     78   { ui::VKEY_R, 27 },
     79   { ui::VKEY_S, 39 },
     80   { ui::VKEY_T, 28 },
     81   { ui::VKEY_U, 30 },
     82   { ui::VKEY_V, 55 },
     83   { ui::VKEY_W, 25 },
     84   { ui::VKEY_X, 53 },
     85   { ui::VKEY_Y, 29 },
     86   { ui::VKEY_Z, 52 },
     87   { ui::VKEY_LWIN, 133 },
     88   { ui::VKEY_NUMPAD0, 90 },
     89   { ui::VKEY_NUMPAD1, 87 },
     90   { ui::VKEY_NUMPAD2, 88 },
     91   { ui::VKEY_NUMPAD3, 89 },
     92   { ui::VKEY_NUMPAD4, 83 },
     93   { ui::VKEY_NUMPAD5, 84 },
     94   { ui::VKEY_NUMPAD6, 85 },
     95   { ui::VKEY_NUMPAD7, 79 },
     96   { ui::VKEY_NUMPAD8, 80 },
     97   { ui::VKEY_NUMPAD9, 81 },
     98   { ui::VKEY_MULTIPLY, 63 },
     99   { ui::VKEY_ADD, 86 },
    100   { ui::VKEY_SUBTRACT, 82 },
    101   { ui::VKEY_DECIMAL, 129 },
    102   { ui::VKEY_DIVIDE, 106 },
    103   { ui::VKEY_F1, 67 },
    104   { ui::VKEY_F2, 68 },
    105   { ui::VKEY_F3, 69 },
    106   { ui::VKEY_F4, 70 },
    107   { ui::VKEY_F5, 71 },
    108   { ui::VKEY_F6, 72 },
    109   { ui::VKEY_F7, 73 },
    110   { ui::VKEY_F8, 74 },
    111   { ui::VKEY_F9, 75 },
    112   { ui::VKEY_F10, 76 },
    113   { ui::VKEY_F11, 95 },
    114   { ui::VKEY_F12, 96 },
    115   { ui::VKEY_NUMLOCK, 77 },
    116   { ui::VKEY_SCROLL, 78 },
    117   { ui::VKEY_OEM_1, 47 },
    118   { ui::VKEY_OEM_PLUS, 21 },
    119   { ui::VKEY_OEM_COMMA, 59 },
    120   { ui::VKEY_OEM_MINUS, 20 },
    121   { ui::VKEY_OEM_PERIOD, 60 },
    122   { ui::VKEY_OEM_2, 61 },
    123   { ui::VKEY_OEM_3, 49 },
    124   { ui::VKEY_OEM_4, 34 },
    125   { ui::VKEY_OEM_5, 51 },
    126   { ui::VKEY_OEM_6, 35 },
    127   { ui::VKEY_OEM_7, 48 }
    128 };
    129 
    130 // Uses to compare two KeyCodeAndXKeyCode structs based on their key code.
    131 bool operator<(const KeyCodeAndXKeyCode& a, const KeyCodeAndXKeyCode& b) {
    132   return a.key_code < b.key_code;
    133 }
    134 
    135 // Returns the equivalent X key code for the given key code. Returns -1 if
    136 // no X equivalent was found.
    137 int KeyboardCodeToXKeyCode(ui::KeyboardCode key_code) {
    138   KeyCodeAndXKeyCode find;
    139   find.key_code = key_code;
    140   const KeyCodeAndXKeyCode* found = std::lower_bound(
    141       kKeyCodeToXKeyCode, kKeyCodeToXKeyCode + arraysize(kKeyCodeToXKeyCode),
    142       find);
    143   if (found >= kKeyCodeToXKeyCode + arraysize(kKeyCodeToXKeyCode) ||
    144       found->key_code != key_code)
    145     return -1;
    146   return found->x_key_code;
    147 }
    148 
    149 // Gets the X modifier mask (Mod1Mask through Mod5Mask) for the given
    150 // modifier. Only checks the alt, meta, and num lock keys currently.
    151 // Returns true on success.
    152 bool GetXModifierMask(Display* display, int modifier, int* x_modifier) {
    153   XModifierKeymap* mod_map = XGetModifierMapping(display);
    154   bool found = false;
    155   int max_mod_keys = mod_map->max_keypermod;
    156   for (int mod_index = 0; mod_index <= 8; ++mod_index) {
    157     for (int key_index = 0; key_index < max_mod_keys; ++key_index) {
    158       int key = mod_map->modifiermap[mod_index * max_mod_keys + key_index];
    159       int keysym = XkbKeycodeToKeysym(display, key, 0, 0);
    160       if (modifier == kAltKeyModifierMask)
    161         found = keysym == XK_Alt_L || keysym == XK_Alt_R;
    162       else if (modifier == kMetaKeyModifierMask)
    163         found = keysym == XK_Meta_L || keysym == XK_Meta_R;
    164       else if (modifier == kNumLockKeyModifierMask)
    165         found = keysym == XK_Num_Lock;
    166       if (found) {
    167         *x_modifier = 1 << mod_index;
    168         break;
    169       }
    170     }
    171     if (found)
    172       break;
    173   }
    174   XFreeModifiermap(mod_map);
    175   return found;
    176 }
    177 
    178 }  // namespace
    179 
    180 bool ConvertKeyCodeToText(
    181     ui::KeyboardCode key_code, int modifiers, std::string* text,
    182     std::string* error_msg) {
    183   *error_msg = std::string();
    184   int x_key_code = KeyboardCodeToXKeyCode(key_code);
    185   if (x_key_code == -1) {
    186     *text = std::string();
    187     return true;
    188   }
    189 
    190   XEvent event;
    191   memset(&event, 0, sizeof(XEvent));
    192   XKeyEvent* key_event = &event.xkey;
    193   XDisplay* display = gfx::GetXDisplay();
    194   if (!display) {
    195     *error_msg =
    196         "an X display is required for keycode conversions, consider using Xvfb";
    197     *text = std::string();
    198     return false;
    199   }
    200   key_event->display = display;
    201   key_event->keycode = x_key_code;
    202   if (modifiers & kShiftKeyModifierMask)
    203     key_event->state |= ShiftMask;
    204   if (modifiers & kControlKeyModifierMask)
    205     key_event->state |= ControlMask;
    206 
    207   // Make a best attempt for non-standard modifiers.
    208   int x_modifier;
    209   if (modifiers & kAltKeyModifierMask &&
    210       GetXModifierMask(display, kAltKeyModifierMask, &x_modifier)) {
    211     key_event->state |= x_modifier;
    212   }
    213   if (modifiers & kMetaKeyModifierMask &&
    214       GetXModifierMask(display, kMetaKeyModifierMask, &x_modifier)) {
    215     key_event->state |= x_modifier;
    216   }
    217   if (modifiers & kNumLockKeyModifierMask &&
    218       GetXModifierMask(display, kNumLockKeyModifierMask, &x_modifier)) {
    219     key_event->state |= x_modifier;
    220   }
    221   key_event->type = KeyPress;
    222   uint16 character = ui::GetCharacterFromXEvent(&event);
    223 
    224   if (!character)
    225     *text = std::string();
    226   else
    227     *text = UTF16ToUTF8(string16(1, character));
    228   return true;
    229 }
    230 
    231 bool ConvertCharToKeyCode(
    232     char16 key,
    233     ui::KeyboardCode* key_code,
    234     int* necessary_modifiers,
    235     std::string* error_msg) {
    236   std::string key_string(UTF16ToUTF8(string16(1, key)));
    237   bool found = false;
    238   ui::KeyboardCode test_code;
    239   int test_modifiers;
    240   *error_msg = std::string();
    241   std::string conv_string;
    242   for (size_t i = 0; i < arraysize(kKeyCodeToXKeyCode); ++i) {
    243     test_code = kKeyCodeToXKeyCode[i].key_code;
    244     // Skip the numpad keys.
    245     if (test_code >= ui::VKEY_NUMPAD0 && test_code <= ui::VKEY_DIVIDE)
    246       continue;
    247     test_modifiers = 0;
    248     if (!ConvertKeyCodeToText(
    249         test_code, test_modifiers, &conv_string, error_msg))
    250       return false;
    251     if (conv_string == key_string) {
    252       found = true;
    253       break;
    254     }
    255     test_modifiers = kShiftKeyModifierMask;
    256     if (!ConvertKeyCodeToText(
    257         test_code, test_modifiers, &conv_string, error_msg))
    258       return false;
    259     if (conv_string == key_string) {
    260       found = true;
    261       break;
    262     }
    263   }
    264   if (found) {
    265     *key_code = test_code;
    266     *necessary_modifiers = test_modifiers;
    267   }
    268   return found;
    269 }
    270