| // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ui/events/keycodes/keyboard_code_conversion.h" |
| |
| #include <algorithm> |
| |
| #include "ui/events/event_constants.h" |
| #include "ui/events/keycodes/dom/dom_code.h" |
| #include "ui/events/keycodes/dom/dom_key.h" |
| #include "ui/events/keycodes/dom_us_layout_data.h" |
| |
| namespace ui { |
| |
| 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', 0}, |
| {VKEY_TAB, DomKey::TAB, '\t', 0}, |
| {VKEY_RETURN, DomKey::ENTER, '\r', 0}, |
| {VKEY_ESCAPE, DomKey::ESCAPE, 0x1B, 0}, |
| {VKEY_SPACE, DomKey::CHARACTER, ' ', 0}, |
| {VKEY_MULTIPLY, DomKey::CHARACTER, '*', 0}, |
| {VKEY_ADD, DomKey::CHARACTER, '+', 0}, |
| {VKEY_SEPARATOR, DomKey::CHARACTER, ',', 0}, |
| {VKEY_SUBTRACT, DomKey::CHARACTER, '-', 0}, |
| {VKEY_DECIMAL, DomKey::CHARACTER, '.', 0}, |
| {VKEY_DIVIDE, DomKey::CHARACTER, '/', 0}, |
| {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, 0, 0}, |
| {VKEY_SHIFT, DomKey::SHIFT, 0, 0}, |
| {VKEY_CONTROL, DomKey::CONTROL, 0, 0}, |
| {VKEY_MENU, DomKey::ALT, 0, 0}, |
| {VKEY_PAUSE, DomKey::PAUSE, 0, 0}, |
| {VKEY_CAPITAL, DomKey::CAPS_LOCK, 0, 0}, |
| // Windows conflates 'KanaMode' and 'HangulMode'. |
| {VKEY_KANA, DomKey::KANA_MODE, 0, 0}, |
| {VKEY_JUNJA, DomKey::JUNJA_MODE, 0, 0}, |
| {VKEY_FINAL, DomKey::FINAL_MODE, 0, 0}, |
| // Windows conflates 'HanjaMode' and 'KanjiMode'. |
| {VKEY_HANJA, DomKey::HANJA_MODE, 0, 0}, |
| {VKEY_CONVERT, DomKey::CONVERT, 0, 0}, |
| {VKEY_NONCONVERT, DomKey::NON_CONVERT, 0, 0}, |
| {VKEY_ACCEPT, DomKey::ACCEPT, 0, 0}, |
| {VKEY_MODECHANGE, DomKey::MODE_CHANGE, 0, 0}, |
| {VKEY_PRIOR, DomKey::PAGE_UP, 0, 0}, |
| {VKEY_NEXT, DomKey::PAGE_DOWN, 0, 0}, |
| {VKEY_END, DomKey::END, 0, 0}, |
| {VKEY_HOME, DomKey::HOME, 0, 0}, |
| {VKEY_LEFT, DomKey::ARROW_LEFT, 0, 0}, |
| {VKEY_UP, DomKey::ARROW_UP, 0, 0}, |
| {VKEY_RIGHT, DomKey::ARROW_RIGHT, 0, 0}, |
| {VKEY_DOWN, DomKey::ARROW_DOWN, 0, 0}, |
| {VKEY_SELECT, DomKey::SELECT, 0, 0}, |
| {VKEY_PRINT, DomKey::PRINT, 0, 0}, |
| {VKEY_EXECUTE, DomKey::EXECUTE, 0, 0}, |
| {VKEY_SNAPSHOT, DomKey::PRINT_SCREEN, 0, 0}, |
| {VKEY_INSERT, DomKey::INSERT, 0, 0}, |
| {VKEY_DELETE, DomKey::DEL, 0, 0}, |
| {VKEY_HELP, DomKey::HELP, 0, 0}, |
| {VKEY_LWIN, DomKey::OS, 0, 0}, |
| {VKEY_RWIN, DomKey::OS, 0, 0}, |
| {VKEY_APPS, DomKey::MEDIA_APPS, 0, 0}, |
| {VKEY_NUMLOCK, DomKey::NUM_LOCK, 0, 0}, |
| {VKEY_SCROLL, DomKey::SCROLL_LOCK, 0, 0}, |
| {VKEY_LSHIFT, DomKey::SHIFT, 0, 0}, |
| {VKEY_RSHIFT, DomKey::SHIFT, 0, 0}, |
| {VKEY_LCONTROL, DomKey::CONTROL, 0, 0}, |
| {VKEY_RCONTROL, DomKey::CONTROL, 0, 0}, |
| {VKEY_LMENU, DomKey::ALT, 0, 0}, |
| {VKEY_RMENU, DomKey::ALT, 0, 0}, |
| {VKEY_BROWSER_BACK, DomKey::BROWSER_BACK, 0, 0}, |
| {VKEY_BROWSER_FORWARD, DomKey::BROWSER_FORWARD, 0, 0}, |
| {VKEY_BROWSER_REFRESH, DomKey::BROWSER_REFRESH, 0, 0}, |
| {VKEY_BROWSER_STOP, DomKey::BROWSER_STOP, 0, 0}, |
| {VKEY_BROWSER_SEARCH, DomKey::BROWSER_SEARCH, 0, 0}, |
| {VKEY_BROWSER_FAVORITES, DomKey::BROWSER_FAVORITES, 0, 0}, |
| {VKEY_BROWSER_HOME, DomKey::BROWSER_HOME, 0, 0}, |
| {VKEY_VOLUME_MUTE, DomKey::VOLUME_MUTE, 0, 0}, |
| {VKEY_VOLUME_DOWN, DomKey::VOLUME_DOWN, 0, 0}, |
| {VKEY_VOLUME_UP, DomKey::VOLUME_UP, 0, 0}, |
| {VKEY_MEDIA_NEXT_TRACK, DomKey::MEDIA_TRACK_NEXT, 0, 0}, |
| {VKEY_MEDIA_PREV_TRACK, DomKey::MEDIA_TRACK_PREVIOUS, 0, 0}, |
| {VKEY_MEDIA_STOP, DomKey::MEDIA_STOP, 0, 0}, |
| {VKEY_MEDIA_PLAY_PAUSE, DomKey::MEDIA_PLAY_PAUSE, 0, 0}, |
| {VKEY_MEDIA_LAUNCH_MAIL, DomKey::LAUNCH_MAIL, 0, 0}, |
| {VKEY_MEDIA_LAUNCH_MEDIA_SELECT, DomKey::LAUNCH_MEDIA_PLAYER, 0, 0}, |
| {VKEY_MEDIA_LAUNCH_APP1, DomKey::LAUNCH_MY_COMPUTER, 0, 0}, |
| {VKEY_MEDIA_LAUNCH_APP2, DomKey::LAUNCH_CALCULATOR, 0, 0}, |
| {VKEY_OEM_8, DomKey::SUPER, 0, 0}, // ISO Level 5 Shift in ChromeOS |
| {VKEY_PROCESSKEY, DomKey::PROCESS, 0, 0}, |
| {VKEY_DBE_SBCSCHAR, DomKey::HANKAKU, 0, 0}, |
| {VKEY_DBE_DBCSCHAR, DomKey::ZENKAKU, 0, 0}, |
| {VKEY_ATTN, DomKey::ATTN, 0, 0}, |
| {VKEY_CRSEL, DomKey::CR_SEL, 0, 0}, |
| {VKEY_EXSEL, DomKey::EX_SEL, 0, 0}, |
| {VKEY_EREOF, DomKey::ERASE_EOF, 0, 0}, |
| {VKEY_PLAY, DomKey::MEDIA_PLAY, 0, 0}, |
| {VKEY_ZOOM, DomKey::ZOOM_TOGGLE, 0, 0}, |
| {VKEY_OEM_CLEAR, DomKey::CLEAR, 0, 0}, |
| {VKEY_ALTGR, DomKey::ALT_GRAPH, 0, 0}, |
| #if defined(OS_POSIX) |
| {VKEY_POWER, DomKey::POWER, 0, 0}, |
| {VKEY_BRIGHTNESS_DOWN, DomKey::BRIGHTNESS_DOWN, 0, 0}, |
| {VKEY_BRIGHTNESS_UP, DomKey::BRIGHTNESS_UP, 0, 0}, |
| {VKEY_COMPOSE, DomKey::COMPOSE, 0, 0}, |
| {VKEY_OEM_103, DomKey::MEDIA_REWIND, 0, 0}, |
| {VKEY_OEM_104, DomKey::MEDIA_FAST_FORWARD, 0, 0}, |
| #endif |
| }; |
| |
| bool IsRightSideDomCode(DomCode code) { |
| return (code == DomCode::SHIFT_RIGHT) || (code == DomCode::CONTROL_RIGHT) || |
| (code == DomCode::ALT_RIGHT) || (code == DomCode::OS_RIGHT); |
| } |
| |
| bool IsModifierDomCode(DomCode code) { |
| return (code == DomCode::CONTROL_LEFT) || (code == DomCode::CONTROL_RIGHT) || |
| (code == DomCode::SHIFT_LEFT) || (code == DomCode::SHIFT_RIGHT) || |
| (code == DomCode::ALT_LEFT) || (code == DomCode::ALT_RIGHT) || |
| (code == DomCode::OS_LEFT) || (code == DomCode::OS_RIGHT); |
| } |
| |
| // Returns the Windows-based VKEY value corresponding to a DOM Level 3 |code|, |
| // assuming a base US English layout. The returned VKEY is located |
| // (e.g. VKEY_LSHIFT). |
| KeyboardCode DomCodeToUsLayoutKeyboardCode(DomCode dom_code) { |
| const DomCodeToKeyboardCodeEntry* end = |
| kDomCodeToKeyboardCodeMap + arraysize(kDomCodeToKeyboardCodeMap); |
| const DomCodeToKeyboardCodeEntry* found = |
| std::lower_bound(kDomCodeToKeyboardCodeMap, end, dom_code, |
| [](const DomCodeToKeyboardCodeEntry& a, DomCode b) { |
| return static_cast<int>(a.dom_code) < static_cast<int>(b); |
| }); |
| if ((found != end) && (found->dom_code == dom_code)) |
| return found->key_code; |
| return VKEY_UNKNOWN; |
| } |
| |
| } // 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); |
| |
| // 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 control characters. |
| if (shift) { |
| // The following graphics characters require the shift key to input. |
| switch (key_code) { |
| // ctrl-@ maps to \x00 (Null byte) |
| case VKEY_2: |
| *dom_key = DomKey::CHARACTER; |
| *character = 0; |
| return true; |
| // ctrl-^ maps to \x1E (Record separator, Information separator two) |
| case VKEY_6: |
| *dom_key = DomKey::CHARACTER; |
| *character = 0x1E; |
| return true; |
| // ctrl-_ maps to \x1F (Unit separator, Information separator one) |
| case VKEY_OEM_MINUS: |
| *dom_key = DomKey::CHARACTER; |
| *character = 0x1F; |
| return true; |
| // Returns 0 for all other keys to avoid inputting unexpected chars. |
| default: |
| *dom_key = DomKey::UNIDENTIFIED; |
| *character = 0; |
| return false; |
| } |
| } else { |
| switch (key_code) { |
| // ctrl-[ maps to \x1B (Escape) |
| case VKEY_OEM_4: |
| *dom_key = DomKey::ESCAPE; |
| *character = 0x1B; |
| return true; |
| // ctrl-\ maps to \x1C (File separator, Information separator four) |
| case VKEY_OEM_5: |
| *dom_key = DomKey::CHARACTER; |
| *character = 0x1C; |
| return true; |
| // ctrl-] maps to \x1D (Group separator, Information separator three) |
| case VKEY_OEM_6: |
| *dom_key = DomKey::CHARACTER; |
| *character = 0x1D; |
| return true; |
| // ctrl-Enter maps to \x0A (Line feed) |
| case VKEY_RETURN: |
| *dom_key = DomKey::CHARACTER; |
| *character = 0x0A; |
| return true; |
| // Returns 0 for all other keys to avoid inputting unexpected chars. |
| default: |
| *dom_key = DomKey::UNIDENTIFIED; |
| *character = 0; |
| return false; |
| } |
| } |
| } |
| |
| // ASCII alphanumeric 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) { |
| *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; |
| } |
| |
| // 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; |
| } |
| |
| bool DomCodeToUsLayoutMeaning(DomCode dom_code, |
| int flags, |
| DomKey* out_dom_key, |
| base::char16* out_character, |
| KeyboardCode* out_key_code) { |
| if ((flags & EF_CONTROL_DOWN) == EF_CONTROL_DOWN) { |
| if (DomCodeToControlCharacter(dom_code, flags, out_dom_key, out_character, |
| out_key_code)) { |
| return true; |
| } |
| if (!IsModifierDomCode(dom_code)) { |
| *out_dom_key = DomKey::UNIDENTIFIED; |
| *out_character = 0; |
| *out_key_code = LocatedToNonLocatedKeyboardCode( |
| DomCodeToUsLayoutKeyboardCode(dom_code)); |
| return true; |
| } |
| } else { |
| for (const auto& it : kPrintableCodeMap) { |
| if (it.dom_code == dom_code) { |
| int state = ((flags & EF_SHIFT_DOWN) == EF_SHIFT_DOWN); |
| base::char16 ch = it.character[state]; |
| *out_dom_key = DomKey::CHARACTER; |
| *out_character = ch; |
| if ((flags & EF_CAPS_LOCK_DOWN) == EF_CAPS_LOCK_DOWN) { |
| ch |= 0x20; |
| if ((ch >= 'a') && (ch <= 'z')) |
| *out_character = it.character[state ^ 1]; |
| } |
| *out_key_code = LocatedToNonLocatedKeyboardCode( |
| DomCodeToUsLayoutKeyboardCode(dom_code)); |
| return true; |
| } |
| } |
| } |
| for (const auto& it : kNonPrintableCodeMap) { |
| if (it.dom_code == dom_code) { |
| *out_dom_key = it.dom_key; |
| *out_character = it.character; |
| *out_key_code = NonPrintableDomKeyToKeyboardCode(it.dom_key); |
| return true; |
| } |
| } |
| if ((flags & EF_CONTROL_DOWN) == EF_CONTROL_DOWN) { |
| *out_dom_key = DomKey::UNIDENTIFIED; |
| *out_character = 0; |
| *out_key_code = LocatedToNonLocatedKeyboardCode( |
| DomCodeToUsLayoutKeyboardCode(dom_code)); |
| return true; |
| } |
| return false; |
| } |
| |
| bool DomCodeToControlCharacter(DomCode dom_code, |
| int flags, |
| DomKey* dom_key, |
| base::char16* character, |
| KeyboardCode* key_code) { |
| if ((flags & EF_CONTROL_DOWN) == 0) |
| return false; |
| |
| int code = static_cast<int>(dom_code); |
| const int kKeyA = static_cast<int>(DomCode::KEY_A); |
| // Control-A - Control-Z map to 0x01 - 0x1A. |
| if (code >= kKeyA && code <= static_cast<int>(DomCode::KEY_Z)) { |
| *character = static_cast<base::char16>(code - kKeyA + 1); |
| switch (dom_code) { |
| case DomCode::KEY_H: |
| *dom_key = DomKey::BACKSPACE; |
| *key_code = VKEY_BACK; |
| break; |
| case DomCode::KEY_I: |
| *dom_key = DomKey::TAB; |
| *key_code = VKEY_TAB; |
| break; |
| case DomCode::KEY_M: |
| *dom_key = DomKey::ENTER; |
| *key_code = VKEY_RETURN; |
| break; |
| default: |
| *dom_key = DomKey::CHARACTER; |
| *key_code = static_cast<KeyboardCode>(code - kKeyA + VKEY_A); |
| break; |
| } |
| return true; |
| } |
| |
| if (flags & EF_SHIFT_DOWN) { |
| switch (dom_code) { |
| case DomCode::DIGIT2: |
| // NUL |
| *character = 0; |
| *dom_key = DomKey::CHARACTER; |
| *key_code = VKEY_2; |
| return true; |
| case DomCode::DIGIT6: |
| // RS |
| *character = 0x1E; |
| *dom_key = DomKey::CHARACTER; |
| *key_code = VKEY_6; |
| return true; |
| case DomCode::MINUS: |
| // US |
| *character = 0x1F; |
| *dom_key = DomKey::CHARACTER; |
| *key_code = VKEY_OEM_MINUS; |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| switch (dom_code) { |
| case DomCode::ENTER: |
| // NL |
| *character = 0x0A; |
| *dom_key = DomKey::CHARACTER; |
| *key_code = VKEY_RETURN; |
| return true; |
| case DomCode::BRACKET_LEFT: |
| // ESC |
| *character = 0x1B; |
| *dom_key = DomKey::ESCAPE; |
| *key_code = VKEY_OEM_4; |
| return true; |
| case DomCode::BACKSLASH: |
| // FS |
| *character = 0x1C; |
| *dom_key = DomKey::CHARACTER; |
| *key_code = VKEY_OEM_5; |
| return true; |
| case DomCode::BRACKET_RIGHT: |
| // GS |
| *character = 0x1D; |
| *dom_key = DomKey::CHARACTER; |
| *key_code = VKEY_OEM_6; |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| DomKey CharacterToDomKey(uint32 character) { |
| switch (character) { |
| case 0x08: |
| return DomKey::BACKSPACE; |
| case 0x09: |
| return DomKey::TAB; |
| case 0x0D: |
| return DomKey::ENTER; |
| case 0x1B: |
| return DomKey::ESCAPE; |
| case 0x7F: |
| return DomKey::DEL; |
| default: |
| return DomKey::CHARACTER; |
| } |
| } |
| |
| // Returns a Windows-based VKEY for a non-printable DOM Level 3 |key|. |
| // The returned VKEY is non-positional (e.g. VKEY_SHIFT). |
| KeyboardCode NonPrintableDomKeyToKeyboardCode(DomKey dom_key) { |
| for (const auto& it : kDomKeyToKeyboardCodeMap) { |
| if (it.dom_key == dom_key) |
| return it.key_code; |
| } |
| return VKEY_UNKNOWN; |
| } |
| |
| // Determine the non-located VKEY corresponding to a located VKEY. |
| KeyboardCode LocatedToNonLocatedKeyboardCode(KeyboardCode key_code) { |
| switch (key_code) { |
| case VKEY_RWIN: |
| return VKEY_LWIN; |
| case VKEY_LSHIFT: |
| case VKEY_RSHIFT: |
| return VKEY_SHIFT; |
| case VKEY_LCONTROL: |
| case VKEY_RCONTROL: |
| return VKEY_CONTROL; |
| case VKEY_LMENU: |
| case VKEY_RMENU: |
| return VKEY_MENU; |
| case VKEY_NUMPAD0: |
| return VKEY_0; |
| case VKEY_NUMPAD1: |
| return VKEY_1; |
| case VKEY_NUMPAD2: |
| return VKEY_2; |
| case VKEY_NUMPAD3: |
| return VKEY_3; |
| case VKEY_NUMPAD4: |
| return VKEY_4; |
| case VKEY_NUMPAD5: |
| return VKEY_5; |
| case VKEY_NUMPAD6: |
| return VKEY_6; |
| case VKEY_NUMPAD7: |
| return VKEY_7; |
| case VKEY_NUMPAD8: |
| return VKEY_8; |
| case VKEY_NUMPAD9: |
| return VKEY_9; |
| default: |
| return key_code; |
| } |
| } |
| |
| // Determine the located VKEY corresponding to a non-located VKEY. |
| KeyboardCode NonLocatedToLocatedKeyboardCode(KeyboardCode key_code, |
| DomCode dom_code) { |
| switch (key_code) { |
| case VKEY_SHIFT: |
| return IsRightSideDomCode(dom_code) ? VKEY_RSHIFT : VKEY_LSHIFT; |
| case VKEY_CONTROL: |
| return IsRightSideDomCode(dom_code) ? VKEY_RCONTROL : VKEY_LCONTROL; |
| case VKEY_MENU: |
| return IsRightSideDomCode(dom_code) ? VKEY_RMENU : VKEY_LMENU; |
| case VKEY_LWIN: |
| return IsRightSideDomCode(dom_code) ? VKEY_RWIN : VKEY_LWIN; |
| case VKEY_0: |
| return (dom_code == DomCode::NUMPAD0) ? VKEY_NUMPAD0 : VKEY_0; |
| case VKEY_1: |
| return (dom_code == DomCode::NUMPAD1) ? VKEY_NUMPAD1 : VKEY_1; |
| case VKEY_2: |
| return (dom_code == DomCode::NUMPAD2) ? VKEY_NUMPAD2 : VKEY_2; |
| case VKEY_3: |
| return (dom_code == DomCode::NUMPAD3) ? VKEY_NUMPAD3 : VKEY_3; |
| case VKEY_4: |
| return (dom_code == DomCode::NUMPAD4) ? VKEY_NUMPAD4 : VKEY_4; |
| case VKEY_5: |
| return (dom_code == DomCode::NUMPAD5) ? VKEY_NUMPAD5 : VKEY_5; |
| case VKEY_6: |
| return (dom_code == DomCode::NUMPAD6) ? VKEY_NUMPAD6 : VKEY_6; |
| case VKEY_7: |
| return (dom_code == DomCode::NUMPAD7) ? VKEY_NUMPAD7 : VKEY_7; |
| case VKEY_8: |
| return (dom_code == DomCode::NUMPAD8) ? VKEY_NUMPAD8 : VKEY_8; |
| case VKEY_9: |
| return (dom_code == DomCode::NUMPAD9) ? VKEY_NUMPAD9 : VKEY_9; |
| default: |
| return key_code; |
| } |
| } |
| |
| DomCode UsLayoutKeyboardCodeToDomCode(KeyboardCode key_code) { |
| key_code = NonLocatedToLocatedKeyboardCode(key_code, DomCode::NONE); |
| for (const auto& it : kDomCodeToKeyboardCodeMap) { |
| if (it.key_code == key_code) |
| return it.dom_code; |
| } |
| for (const auto& it : kFallbackKeyboardCodeToDomCodeMap) { |
| if (it.key_code == key_code) |
| return it.dom_code; |
| } |
| return DomCode::NONE; |
| } |
| |
| } // namespace ui |
