From 002503d9bdc3210dfea6722b7b12234a0c25af7f Mon Sep 17 00:00:00 2001 From: Alex Shvartzkop Date: Sun, 7 Apr 2024 19:41:01 +0300 Subject: [PATCH] Use scancodes instead of keycodes for hotkeys. This allows hotkeys to work on non-English keyboard layouts. Prevents Ctrl+I from being treated as Tab. Fixes https://gitlab.com/kicad/code/kicad/-/issues/1811 Fixes https://gitlab.com/kicad/code/kicad/-/issues/9519 Fixes https://gitlab.com/kicad/code/kicad/-/issues/12992 Fixes https://gitlab.com/kicad/code/kicad/-/issues/16303 --- common/CMakeLists.txt | 1 + common/hotkeys_basic.cpp | 2 + common/tool/tool_dispatcher.cpp | 93 +- common/widgets/widget_hotkey_list.cpp | 87 +- thirdparty/CMakeLists.txt | 1 + thirdparty/gecko-keys/CMakeLists.txt | 8 + .../gecko-keys/NativeKeyToDOMCodeName.h | 1003 +++++++++++++++++ .../gecko-keys/PhysicalKeyCodeNameList.h | 235 ++++ thirdparty/gecko-keys/gecko_keys.cpp | 103 ++ thirdparty/gecko-keys/gecko_keys.h | 37 + 10 files changed, 1476 insertions(+), 94 deletions(-) create mode 100644 thirdparty/gecko-keys/CMakeLists.txt create mode 100644 thirdparty/gecko-keys/NativeKeyToDOMCodeName.h create mode 100644 thirdparty/gecko-keys/PhysicalKeyCodeNameList.h create mode 100644 thirdparty/gecko-keys/gecko_keys.cpp create mode 100644 thirdparty/gecko-keys/gecko_keys.h diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 6bc36acb42..9b5a65c22b 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -661,6 +661,7 @@ target_link_libraries( common dxflib_qcad tinyspline_lib scripting + gecko-keys nlohmann_json pybind11::embed compoundfilereader diff --git a/common/hotkeys_basic.cpp b/common/hotkeys_basic.cpp index d017ac91d2..900337c2a6 100644 --- a/common/hotkeys_basic.cpp +++ b/common/hotkeys_basic.cpp @@ -31,6 +31,7 @@ #include #include #include +#include #include #include "dialogs/dialog_hotkey_list.h" @@ -93,6 +94,7 @@ static struct hotkey_name_descr hotkeyNameList[] = { wxT( "Tab" ), WXK_TAB }, { wxT( "Back" ), WXK_BACK }, { wxT( "Ins" ), WXK_INSERT }, + { wxT( "Pause" ), WXK_PAUSE }, { wxT( "Home" ), WXK_HOME }, { wxT( "End" ), WXK_END }, diff --git a/common/tool/tool_dispatcher.cpp b/common/tool/tool_dispatcher.cpp index b675223293..132e51d0bd 100644 --- a/common/tool/tool_dispatcher.cpp +++ b/common/tool/tool_dispatcher.cpp @@ -35,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -340,7 +341,7 @@ std::optional TOOL_DISPATCHER::GetToolEvent( wxKeyEvent* aKeyEvent, { std::optional evt; int key = aKeyEvent->GetKeyCode(); - int unicode_key = aKeyEvent->GetUnicodeKey(); +// int unicode_key = aKeyEvent->GetUnicodeKey(); // This wxEVT_CHAR_HOOK event can be ignored: not useful in Kicad if( isKeyModifierOnly( key ) ) @@ -355,57 +356,59 @@ std::optional TOOL_DISPATCHER::GetToolEvent( wxKeyEvent* aKeyEvent, // and do nothing. *keyIsSpecial = isKeySpecialCode( key ); + key = GeckoKeys::WXKFromKeyEvent( aKeyEvent->GetRawKeyCode(), aKeyEvent->GetRawKeyFlags() ); + if( aKeyEvent->GetEventType() == wxEVT_CHAR_HOOK ) key = translateSpecialCode( key ); int mods = decodeModifiers( aKeyEvent ); - if( mods & MD_CTRL ) - { - // wxWidgets maps key codes related to Ctrl+letter handled by CHAR_EVT - // (http://docs.wxwidgets.org/trunk/classwx_key_event.html): - // char events for ASCII letters in this case carry codes corresponding to the ASCII - // value of Ctrl-Latter, i.e. 1 for Ctrl-A, 2 for Ctrl-B and so on until 26 for Ctrl-Z. - // They are remapped here to be more easy to handle in code - // Note also on OSX wxWidgets has a different behavior and the mapping is made - // only for ctrl+'A' to ctlr+'Z' (unicode code return 'A' to 'Z'). - // Others OS return WXK_CONTROL_A to WXK_CONTROL_Z, and Ctrl+'M' returns the same code as - // the return key, so the remapping does not use the unicode key value. -#ifdef __APPLE__ - if( unicode_key >= 'A' && unicode_key <= 'Z' && key >= WXK_CONTROL_A && key <= WXK_CONTROL_Z ) -#else - ignore_unused( unicode_key ); + // if( mods & MD_CTRL ) + // { + // // wxWidgets maps key codes related to Ctrl+letter handled by CHAR_EVT + // // (http://docs.wxwidgets.org/trunk/classwx_key_event.html): + // // char events for ASCII letters in this case carry codes corresponding to the ASCII + // // value of Ctrl-Latter, i.e. 1 for Ctrl-A, 2 for Ctrl-B and so on until 26 for Ctrl-Z. + // // They are remapped here to be more easy to handle in code + // // Note also on OSX wxWidgets has a different behavior and the mapping is made + // // only for ctrl+'A' to ctlr+'Z' (unicode code return 'A' to 'Z'). + // // Others OS return WXK_CONTROL_A to WXK_CONTROL_Z, and Ctrl+'M' returns the same code as + // // the return key, so the remapping does not use the unicode key value. + // #ifdef __APPLE__ + // if( unicode_key >= 'A' && unicode_key <= 'Z' && key >= WXK_CONTROL_A && key <= WXK_CONTROL_Z ) + // #else + // ignore_unused( unicode_key ); - if( key >= WXK_CONTROL_A && key <= WXK_CONTROL_Z ) -#endif - key += 'A' - 1; - } + // if( key >= WXK_CONTROL_A && key <= WXK_CONTROL_Z ) + // #endif + // key += 'A' - 1; + // } -#ifdef __APPLE__ - if( mods & MD_ALT ) - { - // OSX maps a bunch of commonly used extended-ASCII characters onto the keyboard - // using the ALT key. Since we use ALT for some of our hotkeys, we need to map back - // to the underlying keys. The kVK_ANSI_* values come from Apple and are said to be - // hardware independent. - switch( aKeyEvent->GetRawKeyCode() ) - { - case /* kVK_ANSI_1 */ 0x12: key = '1'; break; - case /* kVK_ANSI_2 */ 0x13: key = '2'; break; - case /* kVK_ANSI_3 */ 0x14: key = '3'; break; - case /* kVK_ANSI_4 */ 0x15: key = '4'; break; - case /* kVK_ANSI_6 */ 0x16: key = '6'; break; - case /* kVK_ANSI_5 */ 0x17: key = '5'; break; - case /* kVK_ANSI_Equal */ 0x18: key = '='; break; - case /* kVK_ANSI_9 */ 0x19: key = '9'; break; - case /* kVK_ANSI_7 */ 0x1A: key = '7'; break; - case /* kVK_ANSI_Minus */ 0x1B: key = '-'; break; - case /* kVK_ANSI_8 */ 0x1C: key = '8'; break; - case /* kVK_ANSI_0 */ 0x1D: key = '0'; break; - default: ; - } - } -#endif + // #ifdef __APPLE__ + // if( mods & MD_ALT ) + // { + // // OSX maps a bunch of commonly used extended-ASCII characters onto the keyboard + // // using the ALT key. Since we use ALT for some of our hotkeys, we need to map back + // // to the underlying keys. The kVK_ANSI_* values come from Apple and are said to be + // // hardware independent. + // switch( aKeyEvent->GetRawKeyCode() ) + // { + // case /* kVK_ANSI_1 */ 0x12: key = '1'; break; + // case /* kVK_ANSI_2 */ 0x13: key = '2'; break; + // case /* kVK_ANSI_3 */ 0x14: key = '3'; break; + // case /* kVK_ANSI_4 */ 0x15: key = '4'; break; + // case /* kVK_ANSI_6 */ 0x16: key = '6'; break; + // case /* kVK_ANSI_5 */ 0x17: key = '5'; break; + // case /* kVK_ANSI_Equal */ 0x18: key = '='; break; + // case /* kVK_ANSI_9 */ 0x19: key = '9'; break; + // case /* kVK_ANSI_7 */ 0x1A: key = '7'; break; + // case /* kVK_ANSI_Minus */ 0x1B: key = '-'; break; + // case /* kVK_ANSI_8 */ 0x1C: key = '8'; break; + // case /* kVK_ANSI_0 */ 0x1D: key = '0'; break; + // default: ; + // } + // } + // #endif if( key == WXK_ESCAPE ) // ESC is the special key for canceling tools evt = TOOL_EVENT( TC_COMMAND, TA_CANCEL_TOOL, WXK_ESCAPE ); diff --git a/common/widgets/widget_hotkey_list.cpp b/common/widgets/widget_hotkey_list.cpp index 2a59cbb83b..ac765d5dd1 100644 --- a/common/widgets/widget_hotkey_list.cpp +++ b/common/widgets/widget_hotkey_list.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include #include @@ -120,10 +121,10 @@ public: wxStaticText* key_label_0 = new wxStaticText( panelDisplayCurrent, wxID_ANY, _( "Current key:" ) ); fgsizer->Add( key_label_0, 0, wxALL | wxALIGN_CENTRE_VERTICAL, 5 ); - wxStaticText* key_label_1 = new wxStaticText( panelDisplayCurrent, wxID_ANY, wxEmptyString ); - key_label_1->SetFont( key_label_1->GetFont().Bold() ); - key_label_1->SetLabel( aCurrentKey ); - fgsizer->Add( key_label_1, 0, wxALL | wxALIGN_CENTRE_VERTICAL, 5 ); + m_key_label_1 = new wxStaticText( panelDisplayCurrent, wxID_ANY, wxEmptyString ); + m_key_label_1->SetFont( m_key_label_1->GetFont().Bold() ); + m_key_label_1->SetLabel( aCurrentKey ); + fgsizer->Add( m_key_label_1, 0, wxALL | wxALIGN_CENTRE_VERTICAL, 5 ); fgsizer->AddStretchSpacer(); @@ -139,7 +140,6 @@ public: // Binding both EVT_CHAR and EVT_CHAR_HOOK ensures that all key events, including // specials like Tab and Return, are received, particularly on MSW. - panelDisplayCurrent->Bind( wxEVT_CHAR, &HK_PROMPT_DIALOG::OnChar, this ); panelDisplayCurrent->Bind( wxEVT_CHAR_HOOK, &HK_PROMPT_DIALOG::OnCharHook, this ); panelDisplayCurrent->Bind( wxEVT_KEY_UP, &HK_PROMPT_DIALOG::OnKeyUp, this ); @@ -189,7 +189,7 @@ protected: WXK_RAW_CONTROL }; - int key = aEvent.GetKeyCode(); + int key = GeckoKeys::WXKFromKeyEvent( aEvent.GetRawKeyCode(), aEvent.GetRawKeyFlags() ); for( wxKeyCode skipped_key : skipped_keys ) { @@ -197,28 +197,12 @@ protected: return; } - if( key <= 255 && isprint( key ) && !isspace( key ) ) - { - // Let EVT_CHAR handle this one - aEvent.DoAllowNextEvent(); + long keycode = WIDGET_HOTKEY_LIST::MapKeypressToKeycode( aEvent ); -#ifdef __WXMSW__ - // On Windows, looks like a OnChar event is not generated when - // using the Alt key modifier. So ensure m_event is up to date - // to handle the right key code when releasing the key and therefore - // closing the dialog - m_event = aEvent; -#endif - aEvent.Skip(); - } - else - { - OnChar( aEvent ); - } - } + if( keycode == WXK_NONE ) + return; - void OnChar( wxKeyEvent& aEvent ) - { + m_key_label_1->SetLabel( KeyNameFromKeyCode( keycode ) ); m_event = aEvent; } @@ -239,8 +223,9 @@ protected: } private: - bool m_resetkey = false; - wxKeyEvent m_event; + wxStaticText* m_key_label_1 = nullptr; + bool m_resetkey = false; + wxKeyEvent m_event; }; @@ -669,40 +654,44 @@ bool WIDGET_HOTKEY_LIST::TransferDataFromControl() long WIDGET_HOTKEY_LIST::MapKeypressToKeycode( const wxKeyEvent& aEvent ) { - long key = aEvent.GetKeyCode(); - bool is_tab = aEvent.IsKeyInCategory( WXK_CATEGORY_TAB ); + long code = GeckoKeys::WXKFromKeyEvent( aEvent.GetRawKeyCode(), aEvent.GetRawKeyFlags() ); - if( key == WXK_ESCAPE ) + // bool is_tab = aEvent.IsKeyInCategory( WXK_CATEGORY_TAB ); + + if( code == WXK_ESCAPE ) { return 0; } else { - if( key >= 'a' && key <= 'z' ) // convert to uppercase - key = key + ('A' - 'a'); + // if( code >= 'a' && code <= 'z' ) // convert to uppercase + // code = code + ('A' - 'a'); - // Remap Ctrl A (=1+GR_KB_CTRL) to Ctrl Z(=26+GR_KB_CTRL) - // to GR_KB_CTRL+'A' .. GR_KB_CTRL+'Z' - if( !is_tab && aEvent.ControlDown() && key >= WXK_CONTROL_A && key <= WXK_CONTROL_Z ) - key += 'A' - 1; + // // Remap Ctrl A (=1+GR_KB_CTRL) to Ctrl Z(=26+GR_KB_CTRL) + // // to GR_KB_CTRL+'A' .. GR_KB_CTRL+'Z' + // if( !is_tab && aEvent.ControlDown() && key >= WXK_CONTROL_A && key <= WXK_CONTROL_Z ) + // key += 'A' - 1; - /* Disallow shift for keys that have two keycodes on them (e.g. number and - * punctuation keys) leaving only the "letter keys" of A-Z, tab and space - * Then, you can have, e.g. Ctrl-5 and Ctrl-% (GB layout) - * and Ctrl-( and Ctrl-5 (FR layout). - * Otherwise, you'd have to have to say Ctrl-Shift-5 on a FR layout - */ - bool keyIsLetter = key >= 'A' && key <= 'Z'; + // /* Disallow shift for keys that have two keycodes on them (e.g. number and + // * punctuation keys) leaving only the "letter keys" of A-Z, tab and space + // * Then, you can have, e.g. Ctrl-5 and Ctrl-% (GB layout) + // * and Ctrl-( and Ctrl-5 (FR layout). + // * Otherwise, you'd have to have to say Ctrl-Shift-5 on a FR layout + // */ + // bool keyIsLetter = key >= 'A' && key <= 'Z'; - if( aEvent.ShiftDown() && ( keyIsLetter || key > 256 || key == 9 || key == 32 ) ) - key |= MD_SHIFT; + // if( aEvent.ShiftDown() && ( keyIsLetter || key > 256 || key == 9 || key == 32 ) ) + // key |= MD_SHIFT; + + if( aEvent.ShiftDown() ) + code |= MD_SHIFT; if( aEvent.ControlDown() ) - key |= MD_CTRL; + code |= MD_CTRL; if( aEvent.AltDown() ) - key |= MD_ALT; + code |= MD_ALT; - return key; + return code; } } diff --git a/thirdparty/CMakeLists.txt b/thirdparty/CMakeLists.txt index 138f3c9dc8..c89ff793b0 100644 --- a/thirdparty/CMakeLists.txt +++ b/thirdparty/CMakeLists.txt @@ -42,6 +42,7 @@ add_subdirectory( dxflib_qcad ) add_subdirectory( expected ) set( FMT_INSTALL OFF ) add_subdirectory( fmt ) +add_subdirectory( gecko-keys ) add_subdirectory( gzip-hpp ) add_subdirectory( lemon ) add_subdirectory( libcontext ) diff --git a/thirdparty/gecko-keys/CMakeLists.txt b/thirdparty/gecko-keys/CMakeLists.txt new file mode 100644 index 0000000000..b99474a13d --- /dev/null +++ b/thirdparty/gecko-keys/CMakeLists.txt @@ -0,0 +1,8 @@ +add_library( gecko-keys OBJECT + gecko_keys.cpp +) + +target_include_directories( gecko-keys + PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} +) \ No newline at end of file diff --git a/thirdparty/gecko-keys/NativeKeyToDOMCodeName.h b/thirdparty/gecko-keys/NativeKeyToDOMCodeName.h new file mode 100644 index 0000000000..2dcbc9de59 --- /dev/null +++ b/thirdparty/gecko-keys/NativeKeyToDOMCodeName.h @@ -0,0 +1,1003 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/** + * This header file defines simple code mapping between native scancode or + * something and DOM code name index. + * You must define NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX macro before include + * this. + * + * It must have two arguments, (aNativeKey, aCodeNameIndex). + * aNativeKey is a scancode value or something (depends on the platform). + * aCodeNameIndex is the widget::CodeNameIndex value. + */ + +// Windows +#define CODE_MAP_WIN(aCPPCodeName, aNativeKey) +// Mac OS X +#define CODE_MAP_MAC(aCPPCodeName, aNativeKey) +// GTK and Qt on Linux +#define CODE_MAP_X11(aCPPCodeName, aNativeKey) +// Android +#define CODE_MAP_ANDROID(aCPPCodeName, aNativeKey) + +#ifndef NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX +#define NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX( aNativeKey, aCodeIndexName ) +#endif + +#ifndef NS_WX_KEY_TO_DOM_CODE_NAME_INDEX +#define NS_WX_KEY_TO_DOM_CODE_NAME_INDEX( aWXKey, aCodeIndexName ) +#endif + +#if defined(_WIN32) +# undef CODE_MAP_WIN +// aNativeKey is scan code +# define CODE_MAP_WIN(aCPPCodeName, aNativeKey) \ + NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX(aNativeKey, \ + CODE_NAME_INDEX_##aCPPCodeName) +#elif defined(__APPLE__) +# undef CODE_MAP_MAC +// aNativeKey is key code starting with kVK_. +# define CODE_MAP_MAC(aCPPCodeName, aNativeKey) \ + NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX(aNativeKey, \ + CODE_NAME_INDEX_##aCPPCodeName) +#elif defined(__WXGTK__) +# undef CODE_MAP_X11 +// aNativeKey is hardware_keycode of GDKEvent or nativeScanCode of QKeyEvent. +# define CODE_MAP_X11(aCPPCodeName, aNativeKey) \ + NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX(aNativeKey, \ + CODE_NAME_INDEX_##aCPPCodeName) +#elif defined(ANDROID) +# undef CODE_MAP_ANDROID +// aNativeKey is scan code +# define CODE_MAP_ANDROID(aCPPCodeName, aNativeKey) \ + NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX(aNativeKey, \ + CODE_NAME_INDEX_##aCPPCodeName) +#endif + +// wxWidgets WXK_ +#define CODE_MAP_WX( aCPPCodeName, aWXKey ) \ + NS_WX_KEY_TO_DOM_CODE_NAME_INDEX( aWXKey, CODE_NAME_INDEX_##aCPPCodeName ) + + +// Writing system keys +CODE_MAP_WIN(Backquote, 0x0029) +CODE_MAP_MAC(Backquote, kVK_ANSI_Grave) +CODE_MAP_X11(Backquote, 0x0031) +CODE_MAP_ANDROID(Backquote, 0x0029) +CODE_MAP_WX( Backquote, '`' ) + +CODE_MAP_WIN(Backslash, 0x002B) +CODE_MAP_MAC(Backslash, kVK_ANSI_Backslash) +CODE_MAP_X11(Backslash, 0x0033) +CODE_MAP_ANDROID(Backslash, 0x002B) +// IntlBackslash +CODE_MAP_WIN( Backslash, 0x0056 ) +CODE_MAP_MAC( Backslash, kVK_ISO_Section ) +CODE_MAP_X11( Backslash, 0x005E ) +CODE_MAP_ANDROID( Backslash, 0x0056 ) +CODE_MAP_WX( Backslash, '\\' ) + +CODE_MAP_WIN(Backspace, 0x000E) +CODE_MAP_MAC(Backspace, kVK_Delete) +CODE_MAP_X11(Backspace, 0x0016) +CODE_MAP_ANDROID(Backspace, 0x000E) +CODE_MAP_WX( Backspace, WXK_BACK ) + +CODE_MAP_WIN(BracketLeft, 0x001A) +CODE_MAP_MAC(BracketLeft, kVK_ANSI_LeftBracket) +CODE_MAP_X11(BracketLeft, 0x0022) +CODE_MAP_ANDROID(BracketLeft, 0x001A) +CODE_MAP_WX( BracketLeft, '[' ) + +CODE_MAP_WIN(BracketRight, 0x001B) +CODE_MAP_MAC(BracketRight, kVK_ANSI_RightBracket) +CODE_MAP_X11(BracketRight, 0x0023) +CODE_MAP_ANDROID(BracketRight, 0x001B) +CODE_MAP_WX( BracketRight, ']' ) + +CODE_MAP_WIN(Comma, 0x0033) +CODE_MAP_MAC(Comma, kVK_ANSI_Comma) +CODE_MAP_X11(Comma, 0x003B) +CODE_MAP_ANDROID(Comma, 0x00033) +CODE_MAP_WX( Comma, ',' ) + +CODE_MAP_WIN(Digit0, 0x000B) +CODE_MAP_MAC(Digit0, kVK_ANSI_0) +CODE_MAP_X11(Digit0, 0x0013) +CODE_MAP_ANDROID(Digit0, 0x000B) +CODE_MAP_WX( Digit0, '0' ) + +CODE_MAP_WIN(Digit1, 0x0002) +CODE_MAP_MAC(Digit1, kVK_ANSI_1) +CODE_MAP_X11(Digit1, 0x000A) +CODE_MAP_ANDROID(Digit1, 0x0002) +CODE_MAP_WX( Digit1, '1' ) + +CODE_MAP_WIN(Digit2, 0x0003) +CODE_MAP_MAC(Digit2, kVK_ANSI_2) +CODE_MAP_X11(Digit2, 0x000B) +CODE_MAP_ANDROID(Digit2, 0x0003) +CODE_MAP_WX( Digit2, '2' ) + +CODE_MAP_WIN(Digit3, 0x0004) +CODE_MAP_MAC(Digit3, kVK_ANSI_3) +CODE_MAP_X11(Digit3, 0x000C) +CODE_MAP_ANDROID(Digit3, 0x0004) +CODE_MAP_WX( Digit3, '3' ) + +CODE_MAP_WIN(Digit4, 0x0005) +CODE_MAP_MAC(Digit4, kVK_ANSI_4) +CODE_MAP_X11(Digit4, 0x000D) +CODE_MAP_ANDROID(Digit4, 0x0005) +CODE_MAP_WX( Digit4, '4' ) + +CODE_MAP_WIN(Digit5, 0x0006) +CODE_MAP_MAC(Digit5, kVK_ANSI_5) +CODE_MAP_X11(Digit5, 0x000E) +CODE_MAP_ANDROID(Digit5, 0x0006) +CODE_MAP_WX( Digit5, '5' ) + +CODE_MAP_WIN(Digit6, 0x0007) +CODE_MAP_MAC(Digit6, kVK_ANSI_6) +CODE_MAP_X11(Digit6, 0x000F) +CODE_MAP_ANDROID(Digit6, 0x0007) +CODE_MAP_WX( Digit6, '6' ) + +CODE_MAP_WIN(Digit7, 0x0008) +CODE_MAP_MAC(Digit7, kVK_ANSI_7) +CODE_MAP_X11(Digit7, 0x0010) +CODE_MAP_ANDROID(Digit7, 0x0008) +CODE_MAP_WX( Digit7, '7' ) + +CODE_MAP_WIN(Digit8, 0x0009) +CODE_MAP_MAC(Digit8, kVK_ANSI_8) +CODE_MAP_X11(Digit8, 0x0011) +CODE_MAP_ANDROID(Digit8, 0x0009) +CODE_MAP_WX( Digit8, '8' ) + +CODE_MAP_WIN(Digit9, 0x000A) +CODE_MAP_MAC(Digit9, kVK_ANSI_9) +CODE_MAP_X11(Digit9, 0x0012) +CODE_MAP_ANDROID(Digit9, 0x000A) +CODE_MAP_WX( Digit9, '9' ) + +CODE_MAP_WIN(Equal, 0x000D) +CODE_MAP_MAC(Equal, kVK_ANSI_Equal) +CODE_MAP_X11(Equal, 0x0015) +CODE_MAP_ANDROID(Equal, 0x000D) +CODE_MAP_WX( Equal, '=' ) + +//CODE_MAP_WIN(IntlBackslash, 0x0056) +//CODE_MAP_MAC(IntlBackslash, kVK_ISO_Section) +//CODE_MAP_X11(IntlBackslash, 0x005E) +//CODE_MAP_ANDROID(IntlBackslash, 0x0056) +//CODE_MAP_WX( IntlBackslash, '\\' ) + +// Win: IntlHash's scan code is shared with "Backslash" key. +// Mac: IntlHash's virtual key code is shared with "Backslash" key. +// X11: IntlHash's scan code is shared with "Backslash" key. +// Android: IntlHash's scan code is shared with "Backslash" key. + +//CODE_MAP_WIN(IntlRo, 0x0073) +//CODE_MAP_MAC(IntlRo, kVK_JIS_Underscore) +//CODE_MAP_X11(IntlRo, 0x0061) +//CODE_MAP_ANDROID(IntlRo, 0x0059) +//CODE_MAP_WX( IntlRo, '/' ) + +CODE_MAP_WIN(IntlYen, 0x007D) +CODE_MAP_MAC(IntlYen, kVK_JIS_Yen) +CODE_MAP_X11(IntlYen, 0x0084) +CODE_MAP_ANDROID(IntlYen, 0x007C) +CODE_MAP_WX( IntlYen, '\u00a5' ) // ¥ + +CODE_MAP_WIN(KeyA, 0x001E) +CODE_MAP_MAC(KeyA, kVK_ANSI_A) +CODE_MAP_X11(KeyA, 0x0026) +CODE_MAP_ANDROID(KeyA, 0x001E) +CODE_MAP_WX( KeyA, 'A' ) + +CODE_MAP_WIN(KeyB, 0x0030) +CODE_MAP_MAC(KeyB, kVK_ANSI_B) +CODE_MAP_X11(KeyB, 0x0038) +CODE_MAP_ANDROID(KeyB, 0x0030) +CODE_MAP_WX( KeyB, 'B' ) + +CODE_MAP_WIN(KeyC, 0x002E) +CODE_MAP_MAC(KeyC, kVK_ANSI_C) +CODE_MAP_X11(KeyC, 0x0036) +CODE_MAP_ANDROID(KeyC, 0x002E) +CODE_MAP_WX( KeyC, 'C' ) + +CODE_MAP_WIN(KeyD, 0x0020) +CODE_MAP_MAC(KeyD, kVK_ANSI_D) +CODE_MAP_X11(KeyD, 0x0028) +CODE_MAP_ANDROID(KeyD, 0x0020) +CODE_MAP_WX( KeyD, 'D' ) + +CODE_MAP_WIN(KeyE, 0x0012) +CODE_MAP_MAC(KeyE, kVK_ANSI_E) +CODE_MAP_X11(KeyE, 0x001A) +CODE_MAP_ANDROID(KeyE, 0x0012) +CODE_MAP_WX( KeyE, 'E' ) + +CODE_MAP_WIN(KeyF, 0x0021) +CODE_MAP_MAC(KeyF, kVK_ANSI_F) +CODE_MAP_X11(KeyF, 0x0029) +CODE_MAP_ANDROID(KeyF, 0x0021) +CODE_MAP_WX( KeyF, 'F' ) + +CODE_MAP_WIN(KeyG, 0x0022) +CODE_MAP_MAC(KeyG, kVK_ANSI_G) +CODE_MAP_X11(KeyG, 0x002A) +CODE_MAP_ANDROID(KeyG, 0x0022) +CODE_MAP_WX( KeyG, 'G' ) + +CODE_MAP_WIN(KeyH, 0x0023) +CODE_MAP_MAC(KeyH, kVK_ANSI_H) +CODE_MAP_X11(KeyH, 0x002B) +CODE_MAP_ANDROID(KeyH, 0x0023) +CODE_MAP_WX( KeyH, 'H' ) + +CODE_MAP_WIN(KeyI, 0x0017) +CODE_MAP_MAC(KeyI, kVK_ANSI_I) +CODE_MAP_X11(KeyI, 0x001F) +CODE_MAP_ANDROID(KeyI, 0x0017) +CODE_MAP_WX( KeyI, 'I' ) + +CODE_MAP_WIN(KeyJ, 0x0024) +CODE_MAP_MAC(KeyJ, kVK_ANSI_J) +CODE_MAP_X11(KeyJ, 0x002C) +CODE_MAP_ANDROID(KeyJ, 0x0024) +CODE_MAP_WX( KeyJ, 'J' ) + +CODE_MAP_WIN(KeyK, 0x0025) +CODE_MAP_MAC(KeyK, kVK_ANSI_K) +CODE_MAP_X11(KeyK, 0x002D) +CODE_MAP_ANDROID(KeyK, 0x0025) +CODE_MAP_WX( KeyK, 'K' ) + +CODE_MAP_WIN(KeyL, 0x0026) +CODE_MAP_MAC(KeyL, kVK_ANSI_L) +CODE_MAP_X11(KeyL, 0x002E) +CODE_MAP_ANDROID(KeyL, 0x0026) +CODE_MAP_WX( KeyL, 'L' ) + +CODE_MAP_WIN(KeyM, 0x0032) +CODE_MAP_MAC(KeyM, kVK_ANSI_M) +CODE_MAP_X11(KeyM, 0x003A) +CODE_MAP_ANDROID(KeyM, 0x0032) +CODE_MAP_WX( KeyM, 'M' ) + +CODE_MAP_WIN(KeyN, 0x0031) +CODE_MAP_MAC(KeyN, kVK_ANSI_N) +CODE_MAP_X11(KeyN, 0x0039) +CODE_MAP_ANDROID(KeyN, 0x0031) +CODE_MAP_WX( KeyN, 'N' ) + +CODE_MAP_WIN(KeyO, 0x0018) +CODE_MAP_MAC(KeyO, kVK_ANSI_O) +CODE_MAP_X11(KeyO, 0x0020) +CODE_MAP_ANDROID(KeyO, 0x0018) +CODE_MAP_WX( KeyO, 'O' ) + +CODE_MAP_WIN(KeyP, 0x0019) +CODE_MAP_MAC(KeyP, kVK_ANSI_P) +CODE_MAP_X11(KeyP, 0x0021) +CODE_MAP_ANDROID(KeyP, 0x0019) +CODE_MAP_WX( KeyP, 'P' ) + +CODE_MAP_WIN(KeyQ, 0x0010) +CODE_MAP_MAC(KeyQ, kVK_ANSI_Q) +CODE_MAP_X11(KeyQ, 0x0018) +CODE_MAP_ANDROID(KeyQ, 0x0010) +CODE_MAP_WX( KeyQ, 'Q' ) + +CODE_MAP_WIN(KeyR, 0x0013) +CODE_MAP_MAC(KeyR, kVK_ANSI_R) +CODE_MAP_X11(KeyR, 0x001B) +CODE_MAP_ANDROID(KeyR, 0x0013) +CODE_MAP_WX( KeyR, 'R' ) + +CODE_MAP_WIN(KeyS, 0x001F) +CODE_MAP_MAC(KeyS, kVK_ANSI_S) +CODE_MAP_X11(KeyS, 0x0027) +CODE_MAP_ANDROID(KeyS, 0x001F) +CODE_MAP_WX( KeyS, 'S' ) + +CODE_MAP_WIN(KeyT, 0x0014) +CODE_MAP_MAC(KeyT, kVK_ANSI_T) +CODE_MAP_X11(KeyT, 0x001C) +CODE_MAP_ANDROID(KeyT, 0x0014) +CODE_MAP_WX( KeyT, 'T' ) + +CODE_MAP_WIN(KeyU, 0x0016) +CODE_MAP_MAC(KeyU, kVK_ANSI_U) +CODE_MAP_X11(KeyU, 0x001E) +CODE_MAP_ANDROID(KeyU, 0x0016) +CODE_MAP_WX( KeyU, 'U' ) + +CODE_MAP_WIN(KeyV, 0x002F) +CODE_MAP_MAC(KeyV, kVK_ANSI_V) +CODE_MAP_X11(KeyV, 0x0037) +CODE_MAP_ANDROID(KeyV, 0x002F) +CODE_MAP_WX( KeyV, 'V' ) + +CODE_MAP_WIN(KeyW, 0x0011) +CODE_MAP_MAC(KeyW, kVK_ANSI_W) +CODE_MAP_X11(KeyW, 0x0019) +CODE_MAP_ANDROID(KeyW, 0x0011) +CODE_MAP_WX( KeyW, 'W' ) + +CODE_MAP_WIN(KeyX, 0x002D) +CODE_MAP_MAC(KeyX, kVK_ANSI_X) +CODE_MAP_X11(KeyX, 0x0035) +CODE_MAP_ANDROID(KeyX, 0x002D) +CODE_MAP_WX( KeyX, 'X' ) + +CODE_MAP_WIN(KeyY, 0x0015) +CODE_MAP_MAC(KeyY, kVK_ANSI_Y) +CODE_MAP_X11(KeyY, 0x001D) +CODE_MAP_ANDROID(KeyY, 0x0015) +CODE_MAP_WX( KeyY, 'Y' ) + +CODE_MAP_WIN(KeyZ, 0x002C) +CODE_MAP_MAC(KeyZ, kVK_ANSI_Z) +CODE_MAP_X11(KeyZ, 0x0034) +CODE_MAP_ANDROID(KeyZ, 0x002C) +CODE_MAP_WX( KeyZ, 'Z' ) + +CODE_MAP_WIN(Minus, 0x000C) +CODE_MAP_MAC(Minus, kVK_ANSI_Minus) +CODE_MAP_X11(Minus, 0x0014) +CODE_MAP_ANDROID(Minus, 0x000C) +CODE_MAP_WX( Minus, '-' ) + +CODE_MAP_WIN(Period, 0x0034) +CODE_MAP_MAC(Period, kVK_ANSI_Period) +CODE_MAP_X11(Period, 0x003C) +CODE_MAP_ANDROID(Period, 0x0034) +CODE_MAP_WX( Period, '.' ) + +CODE_MAP_WIN(Quote, 0x0028) +CODE_MAP_MAC(Quote, kVK_ANSI_Quote) +CODE_MAP_X11(Quote, 0x0030) +CODE_MAP_ANDROID(Quote, 0x0028) +CODE_MAP_WX( Quote, '\'' ) + +CODE_MAP_WIN(Semicolon, 0x0027) +CODE_MAP_MAC(Semicolon, kVK_ANSI_Semicolon) +CODE_MAP_X11(Semicolon, 0x002F) +CODE_MAP_ANDROID(Semicolon, 0x0027) +CODE_MAP_WX( Semicolon, ';' ) + +CODE_MAP_WIN(Slash, 0x0035) +CODE_MAP_MAC(Slash, kVK_ANSI_Slash) +CODE_MAP_X11(Slash, 0x003D) +CODE_MAP_ANDROID(Slash, 0x0035) +// IntlRo +CODE_MAP_WIN( Slash, 0x0073 ) +CODE_MAP_MAC( Slash, kVK_JIS_Underscore ) +CODE_MAP_X11( Slash, 0x0061 ) +CODE_MAP_ANDROID( Slash, 0x0059 ) +CODE_MAP_WX( Slash, '/' ) + +// Functional keys +CODE_MAP_WIN(AltLeft, 0x0038) +CODE_MAP_MAC(AltLeft, kVK_Option) +CODE_MAP_X11(AltLeft, 0x0040) +CODE_MAP_ANDROID(AltLeft, 0x0038) +// AltRight +CODE_MAP_WIN( AltLeft, 0xE038 ) +CODE_MAP_MAC( AltLeft, kVK_RightOption ) +CODE_MAP_X11( AltLeft, 0x006C ) +CODE_MAP_ANDROID( AltLeft, 0x0064 ) +CODE_MAP_WX( AltLeft, WXK_ALT ) + +//CODE_MAP_WIN(AltRight, 0xE038) +//CODE_MAP_MAC(AltRight, kVK_RightOption) +//CODE_MAP_X11(AltRight, 0x006C) +//CODE_MAP_ANDROID(AltRight, 0x0064) +//CODE_MAP_WX( AltRight, WXK_ALT ) + +CODE_MAP_WIN(CapsLock, 0x003A) +CODE_MAP_MAC(CapsLock, kVK_CapsLock) +CODE_MAP_X11(CapsLock, 0x0042) +CODE_MAP_ANDROID(CapsLock, 0x003A) +CODE_MAP_WX( CapsLock, WXK_CAPITAL ) + +CODE_MAP_WIN(ContextMenu, 0xE05D) +CODE_MAP_MAC(ContextMenu, kVK_PC_ContextMenu) +CODE_MAP_X11(ContextMenu, 0x0087) +CODE_MAP_ANDROID(ContextMenu, 0x007F) +CODE_MAP_WX( ContextMenu, WXK_WINDOWS_MENU ) + +CODE_MAP_WIN(ControlLeft, 0x001D) +CODE_MAP_MAC(ControlLeft, kVK_Control) +CODE_MAP_X11(ControlLeft, 0x0025) +CODE_MAP_ANDROID(ControlLeft, 0x001D) +// ControlRight +CODE_MAP_WIN( ControlLeft, 0xE01D ) +CODE_MAP_MAC( ControlLeft, kVK_RightControl ) +CODE_MAP_X11( ControlLeft, 0x0069 ) +CODE_MAP_ANDROID( ControlLeft, 0x0061 ) +CODE_MAP_WX( ControlLeft, WXK_CONTROL ) + +//CODE_MAP_WIN(ControlRight, 0xE01D) +//CODE_MAP_MAC(ControlRight, kVK_RightControl) +//CODE_MAP_X11(ControlRight, 0x0069) +//CODE_MAP_ANDROID(ControlRight, 0x0061) +//CODE_MAP_WX( ControlRight, WXK_CONTROL ) + +CODE_MAP_WIN(Enter, 0x001C) +CODE_MAP_MAC(Enter, kVK_Return) +CODE_MAP_X11(Enter, 0x0024) +CODE_MAP_ANDROID(Enter, 0x001C) +CODE_MAP_WX( Enter, WXK_RETURN ) + +CODE_MAP_WIN(MetaLeft, 0xE05B) +CODE_MAP_MAC(MetaLeft, kVK_Command) +CODE_MAP_X11(MetaLeft, 0x0085) +CODE_MAP_ANDROID(MetaLeft, 0x007D) +CODE_MAP_WX( MetaLeft, WXK_WINDOWS_LEFT ) + +CODE_MAP_WIN(MetaRight, 0xE05C) +CODE_MAP_MAC(MetaRight, kVK_RightCommand) +CODE_MAP_X11(MetaRight, 0x0086) +CODE_MAP_ANDROID(MetaRight, 0x007E) +CODE_MAP_WX( MetaRight, WXK_WINDOWS_RIGHT ) + +CODE_MAP_WIN(ShiftLeft, 0x002A) +CODE_MAP_MAC(ShiftLeft, kVK_Shift) +CODE_MAP_X11(ShiftLeft, 0x0032) +CODE_MAP_ANDROID(ShiftLeft, 0x002A) +// ShiftRight +CODE_MAP_WIN( ShiftLeft, 0x0036 ) +CODE_MAP_MAC( ShiftLeft, kVK_RightShift ) +CODE_MAP_X11( ShiftLeft, 0x003E ) +CODE_MAP_ANDROID( ShiftLeft, 0x0036 ) +CODE_MAP_WX( ShiftLeft, WXK_SHIFT ) + +//CODE_MAP_WIN(ShiftRight, 0x0036) +//CODE_MAP_MAC(ShiftRight, kVK_RightShift) +//CODE_MAP_X11(ShiftRight, 0x003E) +//CODE_MAP_ANDROID(ShiftRight, 0x0036) +//CODE_MAP_WX( ShiftRight, WXK_SHIFT ) + +CODE_MAP_WIN(Space, 0x0039) +CODE_MAP_MAC(Space, kVK_Space) +CODE_MAP_X11(Space, 0x0041) +CODE_MAP_ANDROID(Space, 0x0039) +CODE_MAP_WX( Space, WXK_SPACE ) + +CODE_MAP_WIN(Tab, 0x000F) +CODE_MAP_MAC(Tab, kVK_Tab) +CODE_MAP_X11(Tab, 0x0017) +CODE_MAP_ANDROID(Tab, 0x000F) +CODE_MAP_WX( Tab, WXK_TAB ) + +// IME keys +CODE_MAP_WIN(Convert, 0x0079) +CODE_MAP_X11(Convert, 0x0064) +CODE_MAP_ANDROID(Convert, 0x005C) + +CODE_MAP_WIN(Lang1, 0x0072) // for non-Korean layout +CODE_MAP_WIN(Lang1, 0xE0F2) // for Korean layout +CODE_MAP_MAC(Lang1, kVK_JIS_Kana) +CODE_MAP_X11(Lang1, 0x0082) +CODE_MAP_ANDROID(Lang1, 0x007A) + +CODE_MAP_WIN(Lang2, 0x0071) // for non-Korean layout +CODE_MAP_WIN(Lang2, 0xE0F1) // for Korean layout +CODE_MAP_MAC(Lang2, kVK_JIS_Eisu) +CODE_MAP_X11(Lang2, 0x0083) +CODE_MAP_ANDROID(Lang2, 0x007B) + +CODE_MAP_WIN(KanaMode, 0x0070) +CODE_MAP_X11(KanaMode, 0x0065) +CODE_MAP_ANDROID(KanaMode, 0x005D) + +CODE_MAP_WIN(NonConvert, 0x007B) +CODE_MAP_X11(NonConvert, 0x0066) +CODE_MAP_ANDROID(NonConvert, 0x005E) + +// Control pad section +CODE_MAP_WIN(Delete, 0xE053) +CODE_MAP_MAC(Delete, kVK_ForwardDelete) +CODE_MAP_X11(Delete, 0x0077) +CODE_MAP_ANDROID(Delete, 0x006F) +CODE_MAP_WX( Delete, WXK_DELETE ) + +CODE_MAP_WIN(End, 0xE04F) +CODE_MAP_MAC(End, kVK_End) +CODE_MAP_X11(End, 0x0073) +CODE_MAP_ANDROID(End, 0x006B) +CODE_MAP_WX( End, WXK_END ) + +CODE_MAP_MAC(Help, kVK_Help) // Insert key on PC keyboard +CODE_MAP_X11(Help, 0x0092) // Help key on Sun keyboard +CODE_MAP_ANDROID(Help, 0x008A) // Help key on Sun keyboard +CODE_MAP_WX( Help, WXK_HELP ) + +CODE_MAP_WIN(Home, 0xE047) +CODE_MAP_MAC(Home, kVK_Home) +CODE_MAP_X11(Home, 0x006E) +CODE_MAP_ANDROID(Home, 0x0066) +CODE_MAP_WX( Home, WXK_HOME ) + +CODE_MAP_WIN(Insert, 0xE052) +CODE_MAP_X11(Insert, 0x0076) +CODE_MAP_ANDROID(Insert, 0x006E) +CODE_MAP_WX( Insert, WXK_INSERT ) + +CODE_MAP_WIN(PageDown, 0xE051) +CODE_MAP_MAC(PageDown, kVK_PageDown) +CODE_MAP_X11(PageDown, 0x0075) +CODE_MAP_ANDROID(PageDown, 0x006D) +CODE_MAP_WX( PageDown, WXK_PAGEDOWN ) + +CODE_MAP_WIN(PageUp, 0xE049) +CODE_MAP_MAC(PageUp, kVK_PageUp) +CODE_MAP_X11(PageUp, 0x0070) +CODE_MAP_ANDROID(PageUp, 0x0068) +CODE_MAP_WX( PageUp, WXK_PAGEUP ) + +// Arrow pad section +CODE_MAP_WIN(ArrowDown, 0xE050) +CODE_MAP_MAC(ArrowDown, kVK_DownArrow) +CODE_MAP_X11(ArrowDown, 0x0074) +CODE_MAP_ANDROID(ArrowDown, 0x006C) +CODE_MAP_WX( ArrowDown, WXK_DOWN ) + +CODE_MAP_WIN(ArrowLeft, 0xE04B) +CODE_MAP_MAC(ArrowLeft, kVK_LeftArrow) +CODE_MAP_X11(ArrowLeft, 0x0071) +CODE_MAP_ANDROID(ArrowLeft, 0x0069) +CODE_MAP_WX( ArrowLeft, WXK_LEFT ) + +CODE_MAP_WIN(ArrowRight, 0xE04D) +CODE_MAP_MAC(ArrowRight, kVK_RightArrow) +CODE_MAP_X11(ArrowRight, 0x0072) +CODE_MAP_ANDROID(ArrowRight, 0x006A) +CODE_MAP_WX( ArrowRight, WXK_RIGHT ) + +CODE_MAP_WIN(ArrowUp, 0xE048) +CODE_MAP_MAC(ArrowUp, kVK_UpArrow) +CODE_MAP_X11(ArrowUp, 0x006F) +CODE_MAP_ANDROID(ArrowUp, 0x0067) +CODE_MAP_WX( ArrowUp, WXK_UP ) + +// Numpad section +CODE_MAP_WIN(NumLock, 0xE045) // MSDN says 0x0045, though... +CODE_MAP_MAC(NumLock, kVK_ANSI_KeypadClear) +CODE_MAP_X11(NumLock, 0x004D) +CODE_MAP_ANDROID(NumLock, 0x0045) +CODE_MAP_WX( NumLock, WXK_NUMLOCK ) + +CODE_MAP_WIN(Numpad0, 0x0052) +CODE_MAP_MAC(Numpad0, kVK_ANSI_Keypad0) +CODE_MAP_X11(Numpad0, 0x005A) +CODE_MAP_ANDROID(Numpad0, 0x0052) +CODE_MAP_WX( Numpad0, WXK_NUMPAD0 ) + +CODE_MAP_WIN(Numpad1, 0x004F) +CODE_MAP_MAC(Numpad1, kVK_ANSI_Keypad1) +CODE_MAP_X11(Numpad1, 0x0057) +CODE_MAP_ANDROID(Numpad1, 0x004F) +CODE_MAP_WX( Numpad1, WXK_NUMPAD1 ) + +CODE_MAP_WIN(Numpad2, 0x0050) +CODE_MAP_MAC(Numpad2, kVK_ANSI_Keypad2) +CODE_MAP_X11(Numpad2, 0x0058) +CODE_MAP_ANDROID(Numpad2, 0x0050) +CODE_MAP_WX( Numpad2, WXK_NUMPAD2 ) + +CODE_MAP_WIN(Numpad3, 0x0051) +CODE_MAP_MAC(Numpad3, kVK_ANSI_Keypad3) +CODE_MAP_X11(Numpad3, 0x0059) +CODE_MAP_ANDROID(Numpad3, 0x0051) +CODE_MAP_WX( Numpad3, WXK_NUMPAD3 ) + +CODE_MAP_WIN(Numpad4, 0x004B) +CODE_MAP_MAC(Numpad4, kVK_ANSI_Keypad4) +CODE_MAP_X11(Numpad4, 0x0053) +CODE_MAP_ANDROID(Numpad4, 0x004B) +CODE_MAP_WX( Numpad4, WXK_NUMPAD4 ) + +CODE_MAP_WIN(Numpad5, 0x004C) +CODE_MAP_MAC(Numpad5, kVK_ANSI_Keypad5) +CODE_MAP_X11(Numpad5, 0x0054) +CODE_MAP_ANDROID(Numpad5, 0x004C) +CODE_MAP_WX( Numpad5, WXK_NUMPAD5 ) + +CODE_MAP_WIN(Numpad6, 0x004D) +CODE_MAP_MAC(Numpad6, kVK_ANSI_Keypad6) +CODE_MAP_X11(Numpad6, 0x0055) +CODE_MAP_ANDROID(Numpad6, 0x004D) +CODE_MAP_WX( Numpad6, WXK_NUMPAD6 ) + +CODE_MAP_WIN(Numpad7, 0x0047) +CODE_MAP_MAC(Numpad7, kVK_ANSI_Keypad7) +CODE_MAP_X11(Numpad7, 0x004F) +CODE_MAP_ANDROID(Numpad7, 0x0047) +CODE_MAP_WX( Numpad7, WXK_NUMPAD7 ) + +CODE_MAP_WIN(Numpad8, 0x0048) +CODE_MAP_MAC(Numpad8, kVK_ANSI_Keypad8) +CODE_MAP_X11(Numpad8, 0x0050) +CODE_MAP_ANDROID(Numpad8, 0x0048) +CODE_MAP_WX( Numpad8, WXK_NUMPAD8 ) + +CODE_MAP_WIN(Numpad9, 0x0049) +CODE_MAP_MAC(Numpad9, kVK_ANSI_Keypad9) +CODE_MAP_X11(Numpad9, 0x0051) +CODE_MAP_ANDROID(Numpad9, 0x0049) +CODE_MAP_WX( Numpad9, WXK_NUMPAD9 ) + +CODE_MAP_WIN(NumpadAdd, 0x004E) +CODE_MAP_MAC(NumpadAdd, kVK_ANSI_KeypadPlus) +CODE_MAP_X11(NumpadAdd, 0x0056) +CODE_MAP_ANDROID(NumpadAdd, 0x004E) +CODE_MAP_WX( NumpadAdd, WXK_NUMPAD_ADD ) + +CODE_MAP_WIN(NumpadComma, 0x007E) +CODE_MAP_MAC(NumpadComma, kVK_JIS_KeypadComma) +CODE_MAP_X11(NumpadComma, 0x0081) +CODE_MAP_ANDROID(NumpadComma, 0x0079) +CODE_MAP_WX( NumpadComma, WXK_NUMPAD_DELETE ) + +CODE_MAP_WIN(NumpadDecimal, 0x0053) +CODE_MAP_MAC(NumpadDecimal, kVK_ANSI_KeypadDecimal) +CODE_MAP_X11(NumpadDecimal, 0x005B) +CODE_MAP_ANDROID(NumpadDecimal, 0x0053) +CODE_MAP_WX( NumpadDecimal, WXK_NUMPAD_DECIMAL ) + +CODE_MAP_WIN(NumpadDivide, 0xE035) +CODE_MAP_MAC(NumpadDivide, kVK_ANSI_KeypadDivide) +CODE_MAP_X11(NumpadDivide, 0x006A) +CODE_MAP_ANDROID(NumpadDivide, 0x0062) +CODE_MAP_WX( NumpadDivide, WXK_NUMPAD_DIVIDE ) + +CODE_MAP_WIN(NumpadEnter, 0xE01C) +CODE_MAP_MAC(NumpadEnter, kVK_ANSI_KeypadEnter) +CODE_MAP_MAC(NumpadEnter, kVK_Powerbook_KeypadEnter) +CODE_MAP_X11(NumpadEnter, 0x0068) +CODE_MAP_ANDROID(NumpadEnter, 0x0060) +CODE_MAP_WX( NumpadEnter, WXK_NUMPAD_ENTER ) + +CODE_MAP_WIN(NumpadEqual, 0x0059) +CODE_MAP_MAC(NumpadEqual, kVK_ANSI_KeypadEquals) +CODE_MAP_X11(NumpadEqual, 0x007D) +CODE_MAP_ANDROID(NumpadEqual, 0x0075) +CODE_MAP_WX( NumpadEqual, WXK_NUMPAD_EQUAL ) + +CODE_MAP_WIN(NumpadMultiply, 0x0037) +CODE_MAP_MAC(NumpadMultiply, kVK_ANSI_KeypadMultiply) +CODE_MAP_X11(NumpadMultiply, 0x003F) +CODE_MAP_ANDROID(NumpadMultiply, 0x0037) +CODE_MAP_WX( NumpadMultiply, WXK_NUMPAD_MULTIPLY ) + +CODE_MAP_WIN(NumpadSubtract, 0x004A) +CODE_MAP_MAC(NumpadSubtract, kVK_ANSI_KeypadMinus) +CODE_MAP_X11(NumpadSubtract, 0x0052) +CODE_MAP_ANDROID(NumpadSubtract, 0x004A) +CODE_MAP_WX( NumpadSubtract, WXK_NUMPAD_SUBTRACT ) + +// Function section +CODE_MAP_WIN(Escape, 0x0001) +CODE_MAP_MAC(Escape, kVK_Escape) +CODE_MAP_X11(Escape, 0x0009) +CODE_MAP_ANDROID(Escape, 0x0001) +CODE_MAP_WX( Escape, WXK_ESCAPE ) + +CODE_MAP_WIN(F1, 0x003B) +CODE_MAP_MAC(F1, kVK_F1) +CODE_MAP_X11(F1, 0x0043) +CODE_MAP_ANDROID(F1, 0x003B) +CODE_MAP_WX( F1, WXK_F1 ) + +CODE_MAP_WIN(F2, 0x003C) +CODE_MAP_MAC(F2, kVK_F2) +CODE_MAP_X11(F2, 0x0044) +CODE_MAP_ANDROID(F2, 0x003C) +CODE_MAP_WX( F2, WXK_F2 ) + +CODE_MAP_WIN(F3, 0x003D) +CODE_MAP_MAC(F3, kVK_F3) +CODE_MAP_X11(F3, 0x0045) +CODE_MAP_ANDROID(F3, 0x003D) +CODE_MAP_WX( F3, WXK_F3 ) + +CODE_MAP_WIN(F4, 0x003E) +CODE_MAP_MAC(F4, kVK_F4) +CODE_MAP_X11(F4, 0x0046) +CODE_MAP_ANDROID(F4, 0x003E) +CODE_MAP_WX( F4, WXK_F4 ) + +CODE_MAP_WIN(F5, 0x003F) +CODE_MAP_MAC(F5, kVK_F5) +CODE_MAP_X11(F5, 0x0047) +CODE_MAP_ANDROID(F5, 0x003F) +CODE_MAP_WX( F5, WXK_F5 ) + +CODE_MAP_WIN(F6, 0x0040) +CODE_MAP_MAC(F6, kVK_F6) +CODE_MAP_X11(F6, 0x0048) +CODE_MAP_ANDROID(F6, 0x0040) +CODE_MAP_WX( F6, WXK_F6 ) + +CODE_MAP_WIN(F7, 0x0041) +CODE_MAP_MAC(F7, kVK_F7) +CODE_MAP_X11(F7, 0x0049) +CODE_MAP_ANDROID(F7, 0x0041) +CODE_MAP_WX( F7, WXK_F7 ) + +CODE_MAP_WIN(F8, 0x0042) +CODE_MAP_MAC(F8, kVK_F8) +CODE_MAP_X11(F8, 0x004A) +CODE_MAP_ANDROID(F8, 0x0042) +CODE_MAP_WX( F8, WXK_F8 ) + +CODE_MAP_WIN(F9, 0x0043) +CODE_MAP_MAC(F9, kVK_F9) +CODE_MAP_X11(F9, 0x004B) +CODE_MAP_ANDROID(F9, 0x0043) +CODE_MAP_WX( F9, WXK_F9 ) + +CODE_MAP_WIN(F10, 0x0044) +CODE_MAP_MAC(F10, kVK_F10) +CODE_MAP_X11(F10, 0x004C) +CODE_MAP_ANDROID(F10, 0x0044) +CODE_MAP_WX( F10, WXK_F10 ) + +CODE_MAP_WIN(F11, 0x0057) +CODE_MAP_MAC(F11, kVK_F11) +CODE_MAP_X11(F11, 0x005F) +CODE_MAP_ANDROID(F11, 0x0057) +CODE_MAP_WX( F11, WXK_F11 ) + +CODE_MAP_WIN(F12, 0x0058) +CODE_MAP_MAC(F12, kVK_F12) +CODE_MAP_X11(F12, 0x0060) +CODE_MAP_ANDROID(F12, 0x0058) +CODE_MAP_WX( F12, WXK_F12 ) + +CODE_MAP_WIN(F13, 0x0064) +CODE_MAP_MAC(F13, kVK_F13) // PrintScreen on PC keyboard +CODE_MAP_X11(F13, 0x00BF) +CODE_MAP_ANDROID(F13, 0x00B7) +CODE_MAP_WX( F13, WXK_F13 ) + +CODE_MAP_WIN(F14, 0x0065) +CODE_MAP_MAC(F14, kVK_F14) // ScrollLock on PC keyboard +CODE_MAP_X11(F14, 0x00C0) +CODE_MAP_ANDROID(F14, 0x00B8) +CODE_MAP_WX( F14, WXK_F14 ) + +CODE_MAP_WIN(F15, 0x0066) +CODE_MAP_MAC(F15, kVK_F15) // Pause on PC keyboard +CODE_MAP_X11(F15, 0x00C1) +CODE_MAP_ANDROID(F15, 0x00B9) +CODE_MAP_WX( F15, WXK_F15 ) + +CODE_MAP_WIN(F16, 0x0067) +CODE_MAP_MAC(F16, kVK_F16) +CODE_MAP_X11(F16, 0x00C2) +CODE_MAP_ANDROID(F16, 0x00BA) +CODE_MAP_WX( F16, WXK_F16 ) + +CODE_MAP_WIN(F17, 0x0068) +CODE_MAP_MAC(F17, kVK_F17) +CODE_MAP_X11(F17, 0x00C3) +CODE_MAP_ANDROID(F17, 0x00BB) +CODE_MAP_WX( F17, WXK_F17 ) + +CODE_MAP_WIN(F18, 0x0069) +CODE_MAP_MAC(F18, kVK_F18) +CODE_MAP_X11(F18, 0x00C4) +CODE_MAP_ANDROID(F18, 0x00BC) +CODE_MAP_WX( F18, WXK_F18 ) + +CODE_MAP_WIN(F19, 0x006A) +CODE_MAP_MAC(F19, kVK_F19) +CODE_MAP_X11(F19, 0x00C5) +CODE_MAP_ANDROID(F19, 0x00BD) +CODE_MAP_WX( F19, WXK_F19 ) + +CODE_MAP_WIN(F20, 0x006B) +CODE_MAP_MAC(F20, kVK_F20) +CODE_MAP_X11(F20, 0x00C6) +CODE_MAP_ANDROID(F20, 0x00BE) +CODE_MAP_WX( F20, WXK_F20 ) + +CODE_MAP_WIN(F21, 0x006C) +CODE_MAP_X11(F21, 0x00C7) +CODE_MAP_ANDROID(F21, 0x00BF) +CODE_MAP_WX( F21, WXK_F21 ) + +CODE_MAP_WIN(F22, 0x006D) +CODE_MAP_X11(F22, 0x00C8) +CODE_MAP_ANDROID(F22, 0x00C0) +CODE_MAP_WX( F22, WXK_F22 ) + +CODE_MAP_WIN(F23, 0x006E) +CODE_MAP_X11(F23, 0x00C9) +CODE_MAP_ANDROID(F23, 0x00C1) +CODE_MAP_WX( F23, WXK_F23 ) + +CODE_MAP_WIN(F24, 0x0076) +CODE_MAP_X11(F24, 0x00CA) +CODE_MAP_ANDROID(F24, 0x00C2) +CODE_MAP_WX( F24, WXK_F24 ) + +CODE_MAP_MAC(Fn, kVK_Function) // not available? +CODE_MAP_ANDROID(Fn, 0x01D0) + +CODE_MAP_WIN(PrintScreen, 0xE037) +CODE_MAP_WIN(PrintScreen, 0x0054) // Alt + PrintScreen +CODE_MAP_X11(PrintScreen, 0x006B) +CODE_MAP_ANDROID(PrintScreen, 0x0063) +CODE_MAP_WX( PrintScreen, WXK_SNAPSHOT ) + +CODE_MAP_WIN(ScrollLock, 0x0046) +CODE_MAP_X11(ScrollLock, 0x004E) +CODE_MAP_ANDROID(ScrollLock, 0x0046) +CODE_MAP_WX( ScrollLock, WXK_SCROLL ) + +CODE_MAP_WIN(Pause, 0x0045) +CODE_MAP_WIN(Pause, 0xE046) // Ctrl + Pause +CODE_MAP_X11(Pause, 0x007F) +CODE_MAP_ANDROID(Pause, 0x0077) +CODE_MAP_WX( Pause, WXK_PAUSE ) + +// Media keys +CODE_MAP_WIN(BrowserBack, 0xE06A) +CODE_MAP_X11(BrowserBack, 0x00A6) +CODE_MAP_ANDROID(BrowserBack, 0x009E) +CODE_MAP_WX( BrowserBack, WXK_BROWSER_BACK ) + +CODE_MAP_WIN(BrowserFavorites, 0xE066) +CODE_MAP_X11(BrowserFavorites, 0x00A4) +CODE_MAP_ANDROID(BrowserFavorites, 0x009C) +CODE_MAP_WX( BrowserFavorites, WXK_BROWSER_FAVORITES ) + +CODE_MAP_WIN(BrowserForward, 0xE069) +CODE_MAP_X11(BrowserForward, 0x00A7) +CODE_MAP_ANDROID(BrowserForward, 0x009F) +CODE_MAP_WX( BrowserForward, WXK_BROWSER_FORWARD ) + +CODE_MAP_WIN(BrowserHome, 0xE032) +CODE_MAP_X11(BrowserHome, 0x00B4) +// CODE_MAP_ANDROID(BrowserHome) // not available? works as Home key. +CODE_MAP_WX( BrowserHome, WXK_BROWSER_HOME ) + +CODE_MAP_WIN(BrowserRefresh, 0xE067) +CODE_MAP_X11(BrowserRefresh, 0x00B5) +CODE_MAP_ANDROID(BrowserRefresh, 0x00AD) +CODE_MAP_WX( BrowserRefresh, WXK_BROWSER_REFRESH ) + +CODE_MAP_WIN(BrowserSearch, 0xE065) +CODE_MAP_X11(BrowserSearch, 0x00E1) +CODE_MAP_ANDROID(BrowserSearch, 0x00D9) +CODE_MAP_WX( BrowserSearch, WXK_BROWSER_SEARCH ) + +CODE_MAP_WIN(BrowserStop, 0xE068) +CODE_MAP_X11(BrowserStop, 0x0088) +CODE_MAP_ANDROID(BrowserStop, 0x0080) +CODE_MAP_WX( BrowserStop, WXK_BROWSER_STOP ) + +// CODE_MAP_WIN(Eject) // not available? +// CODE_MAP_MAC(Eject) // not available? +CODE_MAP_X11(Eject, 0x00A9) +CODE_MAP_ANDROID(Eject, 0x00A1) + +CODE_MAP_WIN(LaunchApp1, 0xE06B) +CODE_MAP_X11(LaunchApp1, 0x0098) +CODE_MAP_ANDROID(LaunchApp1, 0x0090) +CODE_MAP_WX( LaunchApp1, WXK_LAUNCH_APP1 ) + +CODE_MAP_WIN(LaunchApp2, 0xE021) +CODE_MAP_X11(LaunchApp2, 0x0094) +// CODE_MAP_ANDROID(LaunchApp2) // not available? +CODE_MAP_WX( LaunchApp2, WXK_LAUNCH_APP2 ) + +CODE_MAP_WIN(LaunchMail, 0xE06C) +CODE_MAP_X11(LaunchMail, 0x00A3) +// CODE_MAP_ANDROID(LaunchMail) // not available? +CODE_MAP_WX( LaunchMail, WXK_LAUNCH_MAIL ) + +CODE_MAP_WIN(MediaPlayPause, 0xE022) +CODE_MAP_X11(MediaPlayPause, 0x00AC) +CODE_MAP_ANDROID(MediaPlayPause, 0x00A4) +CODE_MAP_WX( MediaPlayPause, WXK_MEDIA_PLAY_PAUSE ) + +CODE_MAP_WIN(MediaSelect, 0xE06D) +CODE_MAP_X11(MediaSelect, 0x00B3) +// CODE_MAP_ANDROID(MediaSelect) // not available? +//CODE_MAP_WX( MediaSelect, WXK_LAUNCH_0 ) // VK_LAUNCH_MEDIA_SELECT on Windows + +CODE_MAP_WIN(MediaStop, 0xE024) +CODE_MAP_X11(MediaStop, 0x00AE) +CODE_MAP_ANDROID(MediaStop, 0x00A6) +CODE_MAP_WX( MediaStop, WXK_MEDIA_STOP ) + +CODE_MAP_WIN(MediaTrackNext, 0xE019) +CODE_MAP_X11(MediaTrackNext, 0x00AB) +CODE_MAP_ANDROID(MediaTrackNext, 0x00A3) +CODE_MAP_WX( MediaTrackNext, WXK_MEDIA_NEXT_TRACK ) + +CODE_MAP_WIN(MediaTrackPrevious, 0xE010) +CODE_MAP_X11(MediaTrackPrevious, 0x00AD) +CODE_MAP_ANDROID(MediaTrackPrevious, 0x00A5) +CODE_MAP_WX( MediaTrackPrevious, WXK_MEDIA_PREV_TRACK ) + +CODE_MAP_WIN(Power, 0xE05E) +CODE_MAP_MAC(Power, 0x007F) // On 10.7 and 10.8 only +// CODE_MAP_X11(Power) // not available? +CODE_MAP_ANDROID(Power, 0x0074) + +// CODE_MAP_WIN(Sleep) // not available? +// CODE_MAP_X11(Sleep) // not available? +CODE_MAP_ANDROID(Sleep, 0x008E) + +CODE_MAP_WIN(VolumeDown, 0xE02E) +CODE_MAP_MAC(VolumeDown, kVK_VolumeDown) // not available? +CODE_MAP_X11(VolumeDown, 0x007A) +CODE_MAP_ANDROID(VolumeDown, 0x0072) +CODE_MAP_WX( VolumeDown, WXK_VOLUME_DOWN ) + +CODE_MAP_WIN(VolumeMute, 0xE020) +CODE_MAP_MAC(VolumeMute, kVK_Mute) // not available? +CODE_MAP_X11(VolumeMute, 0x0079) +CODE_MAP_ANDROID(VolumeMute, 0x0071) +CODE_MAP_WX( VolumeMute, WXK_VOLUME_MUTE ) + +CODE_MAP_WIN(VolumeUp, 0xE030) +CODE_MAP_MAC(VolumeUp, kVK_VolumeUp) // not available? +CODE_MAP_X11(VolumeUp, 0x007B) +CODE_MAP_ANDROID(VolumeUp, 0x0073) // side of body, not on keyboard +CODE_MAP_WX( VolumeUp, WXK_VOLUME_UP ) + +// CODE_MAP_WIN(WakeUp) // not available? +CODE_MAP_X11(WakeUp, 0x0097) +CODE_MAP_ANDROID(WakeUp, 0x008F) + +// Legacy editing keys +CODE_MAP_X11(Again, 0x0089) // Again key on Sun keyboard +CODE_MAP_ANDROID(Again, 0x0081) // Again key on Sun keyboard + +CODE_MAP_X11(Copy, 0x008D) // Copy key on Sun keyboard +CODE_MAP_ANDROID(Copy, 0x0085) // Copy key on Sun keyboard + +CODE_MAP_X11(Cut, 0x0091) // Cut key on Sun keyboard +CODE_MAP_ANDROID(Cut, 0x0089) // Cut key on Sun keyboard + +CODE_MAP_X11(Find, 0x0090) // Find key on Sun keyboard +CODE_MAP_ANDROID(Find, 0x0088) // Find key on Sun keyboard + +CODE_MAP_X11(Open, 0x008E) // Open key on Sun keyboard +CODE_MAP_ANDROID(Open, 0x0086) // Open key on Sun keyboard + +CODE_MAP_X11(Paste, 0x008F) // Paste key on Sun keyboard +CODE_MAP_ANDROID(Paste, 0x0087) // Paste key on Sun keyboard + +CODE_MAP_X11(Props, 0x008A) // Props key on Sun keyboard +CODE_MAP_ANDROID(Props, 0x0082) // Props key on Sun keyboard + +CODE_MAP_X11(Select, 0x008C) // Front key on Sun keyboard +CODE_MAP_ANDROID(Select, 0x0084) // Front key on Sun keyboard + +CODE_MAP_X11(Undo, 0x008B) // Undo key on Sun keyboard +CODE_MAP_ANDROID(Undo, 0x0083) // Undo key on Sun keyboard + +#undef CODE_MAP_WIN +#undef CODE_MAP_MAC +#undef CODE_MAP_X11 +#undef CODE_MAP_ANDROID +#undef CODE_MAP_WX + +#undef NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX +#undef NS_WX_KEY_TO_DOM_CODE_NAME_INDEX \ No newline at end of file diff --git a/thirdparty/gecko-keys/PhysicalKeyCodeNameList.h b/thirdparty/gecko-keys/PhysicalKeyCodeNameList.h new file mode 100644 index 0000000000..4cbe23e87b --- /dev/null +++ b/thirdparty/gecko-keys/PhysicalKeyCodeNameList.h @@ -0,0 +1,235 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/** + * This header file defines all DOM code name which are used for DOM + * KeyboardEvent.code. + * You must define NS_DEFINE_PHYSICAL_KEY_CODE_NAME macro before including this. + * + * It must have two arguments, (aCPPName, aDOMCodeName) + * aCPPName is usable name for a part of C++ constants. + * aDOMCodeName is the actual value. + */ + +#define NS_DEFINE_PHYSICAL_KEY_CODE_NAME_INTERNAL(aCPPName, aDOMCodeName) \ + NS_DEFINE_PHYSICAL_KEY_CODE_NAME(aCPPName, aDOMCodeName) + +#define DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(aName) \ + NS_DEFINE_PHYSICAL_KEY_CODE_NAME_INTERNAL(aName, #aName) + +// Unknown key +NS_DEFINE_PHYSICAL_KEY_CODE_NAME_INTERNAL(UNKNOWN, "") + +// Writing system keys +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Backquote) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Backslash) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Backspace) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BracketLeft) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BracketRight) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Comma) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit0) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit1) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit2) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit3) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit4) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit5) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit6) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit7) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit8) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Digit9) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Equal) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(IntlBackslash) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(IntlHash) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(IntlRo) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(IntlYen) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyA) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyB) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyC) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyD) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyE) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyF) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyG) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyH) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyI) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyJ) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyK) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyL) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyM) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyN) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyO) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyP) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyQ) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyR) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyS) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyT) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyU) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyV) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyW) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyX) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyY) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KeyZ) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Minus) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Period) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Quote) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Semicolon) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Slash) + +// Functional keys +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(AltLeft) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(AltRight) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(CapsLock) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ContextMenu) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ControlLeft) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ControlRight) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Enter) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(MetaLeft) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(MetaRight) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ShiftLeft) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ShiftRight) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Space) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Tab) + +// IME keys +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Convert) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(KanaMode) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Lang1) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Lang2) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Lang3) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Lang4) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Lang5) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NonConvert) + +// Control pad section +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Delete) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(End) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Help) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Home) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Insert) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(PageDown) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(PageUp) + +// Arrow pad section +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ArrowDown) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ArrowLeft) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ArrowRight) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ArrowUp) + +// Numpad section +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumLock) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad0) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad1) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad2) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad3) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad4) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad5) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad6) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad7) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad8) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Numpad9) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadAdd) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadBackspace) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadClear) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadClearEntry) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadComma) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadDecimal) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadDivide) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadEnter) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadEqual) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadMemoryAdd) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadMemoryClear) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadMemoryRecall) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadMemoryStore) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadMemorySubtract) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadMultiply) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadParenLeft) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadParenRight) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(NumpadSubtract) + +// Function section +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Escape) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F1) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F2) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F3) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F4) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F5) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F6) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F7) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F8) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F9) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F10) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F11) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F12) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F13) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F14) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F15) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F16) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F17) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F18) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F19) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F20) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F21) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F22) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F23) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(F24) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Fn) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(FnLock) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(PrintScreen) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(ScrollLock) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Pause) + +// Media keys +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BrowserBack) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BrowserFavorites) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BrowserForward) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BrowserHome) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BrowserRefresh) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BrowserSearch) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(BrowserStop) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Eject) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(LaunchApp1) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(LaunchApp2) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(LaunchMail) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(MediaPlayPause) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(MediaSelect) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(MediaStop) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(MediaTrackNext) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(MediaTrackPrevious) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Power) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Sleep) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(VolumeDown) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(VolumeMute) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(VolumeUp) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(WakeUp) + +// Legacy Keys and Non-Standard Keys + +// Legacy modifier keys +// DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Hyper) +// DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Super) +// DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Turbo) + +// Legacy process control keys +// DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Abort) +// DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Resume) +// DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Suspend) + +// Legacy editing keys +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Again) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Copy) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Cut) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Find) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Open) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Paste) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Props) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Select) +DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Undo) + +// International keyboards +// DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Hiragana) +// DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME(Katakana) + +#undef DEFINE_PHYSICAL_KEY_CODE_NAME_WITH_SAME_NAME +#undef NS_DEFINE_PHYSICAL_KEY_CODE_NAME_INTERNAL diff --git a/thirdparty/gecko-keys/gecko_keys.cpp b/thirdparty/gecko-keys/gecko_keys.cpp new file mode 100644 index 0000000000..24f39a5186 --- /dev/null +++ b/thirdparty/gecko-keys/gecko_keys.cpp @@ -0,0 +1,103 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include +#include + + +namespace GeckoKeys +{ + +unsigned int ScanCodeFromKeyEvent( uint32_t aRawKeyCode, uint32_t aRawKeyFlags ) +{ +#if defined( _WIN32 ) + + uint16_t scanCode = ( aRawKeyFlags >> 16 ) & 0xFF; + + if( ( aRawKeyFlags & 0x1000000 ) != 0 ) // Extended + { + return ( 0xE000 | scanCode ); + } + + return scanCode; +#elif defined( __APPLE__ ) + return aRawKeyCode; +#else + return aRawKeyFlags; +#endif +} + + +CodeNameIndex CodeNameIndexFromScanCode( unsigned int aScanCode ) +{ + // clang-format off + switch (aScanCode) { +#define NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX(aNativeKey, aCodeNameIndex) \ + case aNativeKey: \ + return aCodeNameIndex; + +#include "NativeKeyToDOMCodeName.h" + +#undef NS_NATIVE_KEY_TO_DOM_CODE_NAME_INDEX + + default: + break; + } + // clang-format on + + return CODE_NAME_INDEX_UNKNOWN; +} + + +int WXKFromCodeNameIndex( CodeNameIndex aCodeNameIndex ) +{ + // clang-format off + switch (aCodeNameIndex) { +#define NS_WX_KEY_TO_DOM_CODE_NAME_INDEX(aWXKey, aCPPCodeName) \ + case aCPPCodeName: \ + return aWXKey; + +#include "NativeKeyToDOMCodeName.h" + +#undef NS_WX_KEY_TO_DOM_CODE_NAME_INDEX + + default: + break; + } + // clang-format on + + return WXK_NONE; +} + + +CodeNameIndex CodeNameIndexFromWXK( int aWXKey ) +{ + // clang-format off + switch (aWXKey) { +#define NS_WX_KEY_TO_DOM_CODE_NAME_INDEX(aWXKey, aCPPCodeName) \ + case aWXKey: \ + return aCPPCodeName; + +#include "NativeKeyToDOMCodeName.h" + +#undef NS_WX_KEY_TO_DOM_CODE_NAME_INDEX + + default: + break; + } + // clang-format on + + return CODE_NAME_INDEX_UNKNOWN; +} + + +int WXKFromKeyEvent( uint32_t aRawKeyCode, uint32_t aRawKeyFlags ) +{ + return WXKFromCodeNameIndex( + CodeNameIndexFromScanCode( ScanCodeFromKeyEvent( aRawKeyCode, aRawKeyFlags ) ) ); +} + + +} diff --git a/thirdparty/gecko-keys/gecko_keys.h b/thirdparty/gecko-keys/gecko_keys.h new file mode 100644 index 0000000000..56a1bc753d --- /dev/null +++ b/thirdparty/gecko-keys/gecko_keys.h @@ -0,0 +1,37 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef _GECKO_KEYS_H_ +#define _GECKO_KEYS_H_ + +#include +#include + +namespace GeckoKeys +{ + +#define NS_DEFINE_PHYSICAL_KEY_CODE_NAME( aCPPName, aDOMCodeName ) CODE_NAME_INDEX_##aCPPName, + +typedef uint8_t CodeNameIndexType; +enum CodeNameIndex : CodeNameIndexType +{ +#include "PhysicalKeyCodeNameList.h" + // If a DOM keyboard event is synthesized by script, this is used. Then, + // specified code name should be stored and use it as .code value. + CODE_NAME_INDEX_USE_STRING +}; + +#undef NS_DEFINE_PHYSICAL_KEY_CODE_NAME + + +unsigned int ScanCodeFromKeyEvent( uint32_t aRawKeyCode, uint32_t aRawKeyFlags ); +CodeNameIndex CodeNameIndexFromScanCode( unsigned int aScanCode ); +int WXKFromCodeNameIndex( CodeNameIndex aCodeNameIndex ); +CodeNameIndex CodeNameIndexFromWXK( int aWXKey ); +int WXKFromKeyEvent( uint32_t aRawKeyCode, uint32_t aRawKeyFlags ); + +} // namespace GeckoKeys + +#endif // _GECKO_KEYS_H_