Ozone keyboard layout

ui/events/keycodes/keyboard_code_conversion.cc

Index: ui/events/keycodes/keyboard_code_conversion.cc
diff --git a/ui/events/keycodes/keyboard_code_conversion.cc b/ui/events/keycodes/keyboard_code_conversion.cc
index e7b067c5c9f75470a7bd654d3cabd586c3d5868a..85e62217efbd28c0d9f4da96992bdd01ed054b7a 100644
--- a/ui/events/keycodes/keyboard_code_conversion.cc
+++ b/ui/events/keycodes/keyboard_code_conversion.cc
@@ -5,113 +5,260 @@
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 
 #include "ui/events/event_constants.h"
+#include "ui/events/keycodes/dom3/dom_key.h"
 
 namespace ui {
 
-uint16 GetCharacterFromKeyCode(KeyboardCode key_code, int flags) {
+namespace {
+
+// This table maps a subset of |KeyboardCode| (VKEYs) to DomKey and character.
+// Only values not otherwise handled by GetMeaningFromKeyCode() are here.
+const struct KeyboardCodeToMeaning {
+  KeyboardCode key_code;
+  DomKey key;
+  base::char16 plain_character;
+  base::char16 shift_character;
+} kKeyboardCodeToMeaning[] = {
+    {VKEY_BACK, DomKey::BACKSPACE, '\b'},
+    {VKEY_TAB, DomKey::TAB, '\t'},
+    {VKEY_RETURN, DomKey::ENTER, '\r'},
+    {VKEY_ESCAPE, DomKey::ESCAPE, 0x1B},
+    {VKEY_SPACE, DomKey::CHARACTER, ' '},
+    {VKEY_MULTIPLY, DomKey::CHARACTER, '*'},
+    {VKEY_ADD, DomKey::CHARACTER, '+'},
+    {VKEY_SEPARATOR, DomKey::CHARACTER, ','},
+    {VKEY_SUBTRACT, DomKey::CHARACTER, '-'},
+    {VKEY_DECIMAL, DomKey::CHARACTER, '.'},
+    {VKEY_DIVIDE, DomKey::CHARACTER, '/'},
+    {VKEY_OEM_1, DomKey::CHARACTER, ';', ':'},
+    {VKEY_OEM_PLUS, DomKey::CHARACTER, '=', '+'},
+    {VKEY_OEM_COMMA, DomKey::CHARACTER, ',', '<'},
+    {VKEY_OEM_MINUS, DomKey::CHARACTER, '-', '_'},
+    {VKEY_OEM_PERIOD, DomKey::CHARACTER, '.', '>'},
+    {VKEY_OEM_2, DomKey::CHARACTER, '/', '?'},
+    {VKEY_OEM_3, DomKey::CHARACTER, '`', '~'},
+    {VKEY_OEM_4, DomKey::CHARACTER, '[', '{'},
+    {VKEY_OEM_5, DomKey::CHARACTER, '\\', '|'},
+    {VKEY_OEM_6, DomKey::CHARACTER, ']', '}'},
+    {VKEY_OEM_7, DomKey::CHARACTER, '\'', '"'},
+    {VKEY_OEM_102, DomKey::CHARACTER, '<', '>'},
+    {VKEY_CLEAR, DomKey::CLEAR},

[Wez, 2014/12/12 20:04:18]

Won't C extend the DomKey::CLEAR value out into the plain_character and
shift_character fields, if you don't specify NULL explicitly?

[kpschoedel, 2014/12/12 21:20:39]

Uninitialized fields are 0, but I'll make it explicit.

+    {VKEY_SHIFT, DomKey::SHIFT},
+    {VKEY_CONTROL, DomKey::CONTROL},
+    {VKEY_MENU, DomKey::ALT},
+    {VKEY_PAUSE, DomKey::PAUSE},
+    {VKEY_CAPITAL, DomKey::CAPS_LOCK},
+    // Windows conflates 'KanaMode' and 'HangulMode'.
+    {VKEY_KANA, DomKey::KANA_MODE},
+    {VKEY_JUNJA, DomKey::JUNJA_MODE},
+    {VKEY_FINAL, DomKey::FINAL_MODE},
+    // Windows conflates 'HanjaMode' and 'KanjiMode'.
+    {VKEY_HANJA, DomKey::HANJA_MODE},
+    {VKEY_CONVERT, DomKey::CONVERT},
+    {VKEY_NONCONVERT, DomKey::NON_CONVERT},
+    {VKEY_ACCEPT, DomKey::ACCEPT},
+    {VKEY_MODECHANGE, DomKey::MODE_CHANGE},
+    {VKEY_PRIOR, DomKey::PAGE_UP},
+    {VKEY_NEXT, DomKey::PAGE_DOWN},
+    {VKEY_END, DomKey::END},
+    {VKEY_HOME, DomKey::HOME},
+    {VKEY_LEFT, DomKey::ARROW_LEFT},
+    {VKEY_UP, DomKey::ARROW_UP},
+    {VKEY_RIGHT, DomKey::ARROW_RIGHT},
+    {VKEY_DOWN, DomKey::ARROW_DOWN},
+    {VKEY_SELECT, DomKey::SELECT},
+    {VKEY_PRINT, DomKey::PRINT},
+    {VKEY_EXECUTE, DomKey::EXECUTE},
+    {VKEY_SNAPSHOT, DomKey::PRINT_SCREEN},
+    {VKEY_INSERT, DomKey::INSERT},
+    {VKEY_DELETE, DomKey::DEL},
+    {VKEY_HELP, DomKey::HELP},
+    {VKEY_LWIN, DomKey::OS},
+    {VKEY_RWIN, DomKey::OS},
+    {VKEY_APPS, DomKey::MEDIA_APPS},
+    {VKEY_NUMLOCK, DomKey::NUM_LOCK},
+    {VKEY_SCROLL, DomKey::SCROLL_LOCK},
+    {VKEY_LSHIFT, DomKey::SHIFT},
+    {VKEY_RSHIFT, DomKey::SHIFT},
+    {VKEY_LCONTROL, DomKey::CONTROL},
+    {VKEY_RCONTROL, DomKey::CONTROL},
+    {VKEY_LMENU, DomKey::ALT},
+    {VKEY_RMENU, DomKey::ALT},
+    {VKEY_BROWSER_BACK, DomKey::BROWSER_BACK},
+    {VKEY_BROWSER_FORWARD, DomKey::BROWSER_FORWARD},
+    {VKEY_BROWSER_REFRESH, DomKey::BROWSER_REFRESH},
+    {VKEY_BROWSER_STOP, DomKey::BROWSER_STOP},
+    {VKEY_BROWSER_SEARCH, DomKey::BROWSER_SEARCH},
+    {VKEY_BROWSER_FAVORITES, DomKey::BROWSER_FAVORITES},
+    {VKEY_BROWSER_HOME, DomKey::BROWSER_HOME},
+    {VKEY_VOLUME_MUTE, DomKey::VOLUME_MUTE},
+    {VKEY_VOLUME_DOWN, DomKey::VOLUME_DOWN},
+    {VKEY_VOLUME_UP, DomKey::VOLUME_UP},
+    {VKEY_MEDIA_NEXT_TRACK, DomKey::MEDIA_TRACK_NEXT},
+    {VKEY_MEDIA_PREV_TRACK, DomKey::MEDIA_TRACK_PREVIOUS},
+    {VKEY_MEDIA_STOP, DomKey::MEDIA_STOP},
+    {VKEY_MEDIA_PLAY_PAUSE, DomKey::MEDIA_PLAY_PAUSE},
+    {VKEY_MEDIA_LAUNCH_MAIL, DomKey::LAUNCH_MAIL},
+    {VKEY_MEDIA_LAUNCH_MEDIA_SELECT, DomKey::LAUNCH_MEDIA_PLAYER},
+    {VKEY_MEDIA_LAUNCH_APP1, DomKey::LAUNCH_MY_COMPUTER},
+    {VKEY_MEDIA_LAUNCH_APP2, DomKey::LAUNCH_CALCULATOR},
+    {VKEY_OEM_8, DomKey::SUPER},  // ISO Level 5 Shift in ChromeOS
+    {VKEY_PROCESSKEY, DomKey::PROCESS},
+    {VKEY_DBE_SBCSCHAR, DomKey::HANKAKU},
+    {VKEY_DBE_DBCSCHAR, DomKey::ZENKAKU},
+    {VKEY_ATTN, DomKey::ATTN},
+    {VKEY_CRSEL, DomKey::CR_SEL},
+    {VKEY_EXSEL, DomKey::EX_SEL},
+    {VKEY_EREOF, DomKey::ERASE_EOF},
+    {VKEY_PLAY, DomKey::MEDIA_PLAY},
+    {VKEY_ZOOM, DomKey::ZOOM_TOGGLE},
+    {VKEY_OEM_CLEAR, DomKey::CLEAR},
+    {VKEY_ALTGR, DomKey::ALT_GRAPH},
+#if defined(OS_POSIX)
+    {VKEY_POWER, DomKey::POWER},
+    {VKEY_BRIGHTNESS_DOWN, DomKey::BRIGHTNESS_DOWN},
+    {VKEY_BRIGHTNESS_UP, DomKey::BRIGHTNESS_UP},
+    {VKEY_COMPOSE, DomKey::COMPOSE},
+    {VKEY_OEM_103, DomKey::MEDIA_REWIND},
+    {VKEY_OEM_104, DomKey::MEDIA_FAST_FORWARD},
+#endif
+};
+
+}  // anonymous namespace
+
+base::char16 GetCharacterFromKeyCode(KeyboardCode key_code, int flags) {
+  ui::DomKey dom_key;
+  base::char16 character;
+  if (GetMeaningFromKeyCode(key_code, flags, &dom_key, &character))
+    return character;
+  return 0;
+}
+
+bool GetMeaningFromKeyCode(KeyboardCode key_code,
+                           int flags,
+                           DomKey* dom_key,
+                           base::char16* character) {
   const bool ctrl = (flags & EF_CONTROL_DOWN) != 0;
   const bool shift = (flags & EF_SHIFT_DOWN) != 0;
   const bool upper = shift ^ ((flags & EF_CAPS_LOCK_DOWN) != 0);
 
-  // Following Windows behavior to map ctrl-a ~ ctrl-z to \x01 ~ \x1A.
-  if (key_code >= VKEY_A && key_code <= VKEY_Z) {
-    return static_cast<uint16>
-        (key_code - VKEY_A + (ctrl ? 1 : (upper ? 'A' : 'a')));
-  }
-
-  // Other ctrl characters
+  // Control characters.
   if (ctrl) {
+    // Following Windows behavior to map ctrl-a ~ ctrl-z to \x01 ~ \x1A.
+    if (key_code >= VKEY_A && key_code <= VKEY_Z) {
+      *character = static_cast<uint16>(key_code - VKEY_A + 1);
+      switch (key_code) {
+        case VKEY_H:
+          *dom_key = DomKey::BACKSPACE;
+          break;
+        case VKEY_I:
+          *dom_key = DomKey::TAB;
+          break;
+        case VKEY_J:
+        case VKEY_M:
+          *dom_key = DomKey::ENTER;
+          break;
+        default:
+          *dom_key = DomKey::CHARACTER;
+          break;
+      }
+      return true;
+    }
+    // Other ctrl characters
     if (shift) {
       // following graphics chars require shift key to input.
       switch (key_code) {
         // ctrl-@ maps to \x00 (Null byte)
         case VKEY_2:
-          return 0;
+          *dom_key = DomKey::CHARACTER;
+          *character = 0;
+          return true;
         // ctrl-^ maps to \x1E (Record separator, Information separator two)
         case VKEY_6:
-          return 0x1E;
+          *dom_key = DomKey::CHARACTER;
+          *character = 0x1E;
+          return true;
         // ctrl-_ maps to \x1F (Unit separator, Information separator one)
         case VKEY_OEM_MINUS:
-          return 0x1F;
+          *dom_key = DomKey::CHARACTER;
+          *character = 0x1F;
+          return true;
         // Returns 0 for all other keys to avoid inputting unexpected chars.
         default:
-          return 0;
+          *dom_key = DomKey::UNIDENTIFIED;
+          *character = 0;
+          return false;
       }
     } else {
       switch (key_code) {
         // ctrl-[ maps to \x1B (Escape)
         case VKEY_OEM_4:
-          return 0x1B;
+          *dom_key = DomKey::ESCAPE;
+          *character = 0x1B;
+          return true;
         // ctrl-\ maps to \x1C (File separator, Information separator four)
         case VKEY_OEM_5:
-          return 0x1C;
+          *dom_key = DomKey::CHARACTER;
+          *character = 0x1C;
+          return true;
         // ctrl-] maps to \x1D (Group separator, Information separator three)
         case VKEY_OEM_6:
-          return 0x1D;
+          *dom_key = DomKey::CHARACTER;
+          *character = 0x1D;
+          return true;
         // ctrl-Enter maps to \x0A (Line feed)
         case VKEY_RETURN:
-          return 0x0A;
+          *dom_key = DomKey::CHARACTER;
+          *character = 0x0A;
+          return true;
         // Returns 0 for all other keys to avoid inputting unexpected chars.
         default:
-          return 0;
+          *dom_key = DomKey::UNIDENTIFIED;
+          *character = 0;
+          return false;
       }
     }
   }
 
-  // For IME support.
-  if (key_code == ui::VKEY_PROCESSKEY)
-    return 0xE5;
-
   // Normal characters
+  if (key_code >= VKEY_A && key_code <= VKEY_Z) {
+    *dom_key = DomKey::CHARACTER;
+    *character = static_cast<uint16>(key_code - VKEY_A + (upper ? 'A' : 'a'));
+    return true;
+  }
   if (key_code >= VKEY_0 && key_code <= VKEY_9) {
-    return shift ? ")!@#$%^&*("[key_code - VKEY_0] :
-        static_cast<uint16>(key_code);
-  } else if (key_code >= VKEY_NUMPAD0 && key_code <= VKEY_NUMPAD9) {
-    return static_cast<uint16>(key_code - VKEY_NUMPAD0 + '0');
+    *dom_key = DomKey::CHARACTER;
+    *character =
+        shift ? ")!@#$%^&*("[key_code - VKEY_0] : static_cast<uint16>(key_code);
+    return true;
+  }
+  if (key_code >= VKEY_NUMPAD0 && key_code <= VKEY_NUMPAD9) {
+    *dom_key = DomKey::CHARACTER;
+    *character = static_cast<uint16>(key_code - VKEY_NUMPAD0 + '0');
+    return true;
+  }
+
+  // Function keys
+  if (key_code >= VKEY_F1 && key_code <= VKEY_F24) {
+    *dom_key =
+        static_cast<DomKey>(key_code - VKEY_F1 + static_cast<int>(DomKey::F1));
+    *character = 0;
+    return true;
   }
 
-  switch (key_code) {
-    case VKEY_TAB:
-      return '\t';
-    case VKEY_RETURN:
-      return '\r';
-    case VKEY_MULTIPLY:
-      return '*';
-    case VKEY_ADD:
-      return '+';
-    case VKEY_SUBTRACT:
-      return '-';
-    case VKEY_DECIMAL:
-      return '.';
-    case VKEY_DIVIDE:
-      return '/';
-    case VKEY_SPACE:
-      return ' ';
-    case VKEY_OEM_1:
-      return shift ? ':' : ';';
-    case VKEY_OEM_PLUS:
-      return shift ? '+' : '=';
-    case VKEY_OEM_COMMA:
-      return shift ? '<' : ',';
-    case VKEY_OEM_MINUS:
-      return shift ? '_' : '-';
-    case VKEY_OEM_PERIOD:
-      return shift ? '>' : '.';
-    case VKEY_OEM_2:
-      return shift ? '?' : '/';
-    case VKEY_OEM_3:
-      return shift ? '~' : '`';
-    case VKEY_OEM_4:
-      return shift ? '{' : '[';
-    case VKEY_OEM_5:
-      return shift ? '|' : '\\';
-    case VKEY_OEM_6:
-      return shift ? '}' : ']';
-    case VKEY_OEM_7:
-      return shift ? '"' : '\'';
-    default:
-      return 0;
+  // Isolated characters.

[Wez, 2014/12/12 20:04:18]

Needs a better description - how would you go about describing these characters?
Seems basically to be non-alphanumeric, non-numpad, non-function and
non-ctrl-modified?

[kpschoedel, 2014/12/12 21:20:39]

Changed to ‘Other keys.’

+  for (size_t i = 0; i < arraysize(kKeyboardCodeToMeaning); ++i) {
+    if (kKeyboardCodeToMeaning[i].key_code == key_code) {
+      const KeyboardCodeToMeaning* p = &kKeyboardCodeToMeaning[i];
+      *dom_key = p->key;
+      *character = (shift && p->shift_character) ? p->shift_character
+                                                 : p->plain_character;
+      return true;
+    }
   }
+  *dom_key = DomKey::UNIDENTIFIED;
+  *character = 0;
+  return false;
 }
 
 }  // namespace ui