From a314b18515a13e0349b154d1ee6ade12502089d2 Mon Sep 17 00:00:00 2001 From: Alex Szpakowski Date: Sun, 1 Feb 2015 03:13:14 -0400 Subject: [PATCH] Added love.keyboard.getKeyFromScancode and love.keyboard.getScancodeFromKey. Resolves issue #982. Scancodes represent a physical key independent of the keyboard's current layout. For example, pressing the key located where 'q' is on a U.S. keyboard will produce the key 'q' and the scancode 'q' when using a U.S. keyboard layout, but when using a French keyboard layout it will produce the key 'a' and the scancode 'q'. Scancodes are useful for creating default controls that have the same physical locations on on all keyboards. --- src/modules/keyboard/Keyboard.cpp | 279 ++++++++++++++++++++++- src/modules/keyboard/Keyboard.h | 292 +++++++++++++++++++++++- src/modules/keyboard/sdl/Keyboard.cpp | 295 +++++++++++++++++++++++++ src/modules/keyboard/sdl/Keyboard.h | 6 + src/modules/keyboard/wrap_Keyboard.cpp | 36 +++ src/modules/keyboard/wrap_Keyboard.h | 2 + 6 files changed, 907 insertions(+), 3 deletions(-) diff --git a/src/modules/keyboard/Keyboard.cpp b/src/modules/keyboard/Keyboard.cpp index 004691d74..5b9941176 100644 --- a/src/modules/keyboard/Keyboard.cpp +++ b/src/modules/keyboard/Keyboard.cpp @@ -27,18 +27,30 @@ namespace love namespace keyboard { -bool Keyboard::getConstant(const char *in, Keyboard::Key &out) +bool Keyboard::getConstant(const char *in, Key &out) { return keys.find(in, out); } -bool Keyboard::getConstant(Keyboard::Key in, const char *&out) +bool Keyboard::getConstant(Key in, const char *&out) { return keys.find(in, out); } +bool Keyboard::getConstant(const char *in, Scancode &out) +{ + return scancodes.find(in, out); +} + +bool Keyboard::getConstant(Scancode in, const char *&out) +{ + return scancodes.find(in, out); +} + StringMap::Entry Keyboard::keyEntries[] = { + {"unknown", Keyboard::KEY_UNKNOWN}, + {"return", Keyboard::KEY_RETURN}, {"escape", Keyboard::KEY_ESCAPE}, {"backspace", Keyboard::KEY_BACKSPACE}, @@ -244,6 +256,269 @@ StringMap::Entry Keyboard::keyEntries[] = StringMap Keyboard::keys(Keyboard::keyEntries, sizeof(Keyboard::keyEntries)); +StringMap::Entry Keyboard::scancodeEntries[] = +{ + {"unknown", SCANCODE_UNKNOWN}, + + {"a", SCANCODE_A}, + {"b", SCANCODE_B}, + {"c", SCANCODE_C}, + {"d", SCANCODE_D}, + {"e", SCANCODE_E}, + {"f", SCANCODE_F}, + {"g", SCANCODE_G}, + {"h", SCANCODE_H}, + {"i", SCANCODE_I}, + {"j", SCANCODE_J}, + {"k", SCANCODE_K}, + {"l", SCANCODE_L}, + {"m", SCANCODE_M}, + {"n", SCANCODE_N}, + {"o", SCANCODE_O}, + {"p", SCANCODE_P}, + {"q", SCANCODE_Q}, + {"r", SCANCODE_R}, + {"s", SCANCODE_S}, + {"t", SCANCODE_T}, + {"u", SCANCODE_U}, + {"v", SCANCODE_V}, + {"w", SCANCODE_W}, + {"x", SCANCODE_X}, + {"y", SCANCODE_Y}, + {"z", SCANCODE_Z}, + + {"1", SCANCODE_1}, + {"2", SCANCODE_2}, + {"3", SCANCODE_3}, + {"4", SCANCODE_4}, + {"5", SCANCODE_5}, + {"6", SCANCODE_6}, + {"7", SCANCODE_7}, + {"8", SCANCODE_8}, + {"9", SCANCODE_9}, + {"0", SCANCODE_0}, + + {"return", SCANCODE_RETURN}, + {"escape", SCANCODE_ESCAPE}, + {"backspace", SCANCODE_BACKSPACE}, + {"tab", SCANCODE_TAB}, + {" ", SCANCODE_SPACE}, + + {"-", SCANCODE_MINUS}, + {"=", SCANCODE_EQUALS}, + {"[", SCANCODE_LEFTBRACKET}, + {"]", SCANCODE_RIGHTBRACKET}, + {"\\", SCANCODE_BACKSLASH}, + {"nonus#", SCANCODE_NONUSHASH}, + {";", SCANCODE_SEMICOLON}, + {"'", SCANCODE_APOSTROPHE}, + {"`", SCANCODE_GRAVE}, + {",", SCANCODE_COMMA}, + {".", SCANCODE_PERIOD}, + {"/", SCANCODE_SLASH}, + + {"capslock", SCANCODE_CAPSLOCK}, + + {"f1", SCANCODE_F1}, + {"f2", SCANCODE_F2}, + {"f3", SCANCODE_F3}, + {"f4", SCANCODE_F4}, + {"f5", SCANCODE_F5}, + {"f6", SCANCODE_F6}, + {"f7", SCANCODE_F7}, + {"f8", SCANCODE_F8}, + {"f9", SCANCODE_F9}, + {"f10", SCANCODE_F10}, + {"f11", SCANCODE_F11}, + {"f12", SCANCODE_F12}, + + {"printscreen", SCANCODE_PRINTSCREEN}, + {"scrolllock", SCANCODE_SCROLLLOCK}, + {"pause", SCANCODE_PAUSE}, + {"insert", SCANCODE_INSERT}, + {"home", SCANCODE_HOME}, + {"pageup", SCANCODE_PAGEUP}, + {"delete", SCANCODE_DELETE}, + {"end", SCANCODE_END}, + {"pagedown", SCANCODE_PAGEDOWN}, + {"right", SCANCODE_RIGHT}, + {"left", SCANCODE_LEFT}, + {"down", SCANCODE_DOWN}, + {"up", SCANCODE_UP}, + + {"numlock", SCANCODE_NUMLOCKCLEAR}, + {"kp/", SCANCODE_KP_DIVIDE}, + {"kp*", SCANCODE_KP_MULTIPLY}, + {"kp-", SCANCODE_KP_MINUS}, + {"kp+", SCANCODE_KP_PLUS}, + {"kpenter", SCANCODE_KP_ENTER}, + {"kp1", SCANCODE_KP_1}, + {"kp2", SCANCODE_KP_2}, + {"kp3", SCANCODE_KP_3}, + {"kp4", SCANCODE_KP_4}, + {"kp5", SCANCODE_KP_5}, + {"kp6", SCANCODE_KP_6}, + {"kp7", SCANCODE_KP_7}, + {"kp8", SCANCODE_KP_8}, + {"kp9", SCANCODE_KP_9}, + {"kp0", SCANCODE_KP_0}, + {"kp.", SCANCODE_KP_PERIOD}, + + {"nonusbackslash", SCANCODE_NONUSBACKSLASH}, + {"application", SCANCODE_APPLICATION}, + {"power", SCANCODE_POWER}, + {"=", SCANCODE_KP_EQUALS}, + {"f13", SCANCODE_F13}, + {"f14", SCANCODE_F14}, + {"f15", SCANCODE_F15}, + {"f16", SCANCODE_F16}, + {"f17", SCANCODE_F17}, + {"f18", SCANCODE_F18}, + {"f19", SCANCODE_F19}, + {"f20", SCANCODE_F20}, + {"f21", SCANCODE_F21}, + {"f22", SCANCODE_F22}, + {"f23", SCANCODE_F23}, + {"f24", SCANCODE_F24}, + {"execute", SCANCODE_EXECUTE}, + {"help", SCANCODE_HELP}, + {"menu", SCANCODE_MENU}, + {"select", SCANCODE_SELECT}, + {"stop", SCANCODE_STOP}, + {"again", SCANCODE_AGAIN}, + {"undo", SCANCODE_UNDO}, + {"cut", SCANCODE_CUT}, + {"copy", SCANCODE_COPY}, + {"paste", SCANCODE_PASTE}, + {"find", SCANCODE_FIND}, + {"mute", SCANCODE_MUTE}, + {"volumeup", SCANCODE_VOLUMEUP}, + {"volumedown", SCANCODE_VOLUMEDOWN}, + {"kp,", SCANCODE_KP_COMMA}, + {"kp=400", SCANCODE_KP_EQUALSAS400}, + + {"international1", SCANCODE_INTERNATIONAL1}, + {"international2", SCANCODE_INTERNATIONAL2}, + {"international3", SCANCODE_INTERNATIONAL3}, + {"international4", SCANCODE_INTERNATIONAL4}, + {"international5", SCANCODE_INTERNATIONAL5}, + {"international6", SCANCODE_INTERNATIONAL6}, + {"international7", SCANCODE_INTERNATIONAL7}, + {"international8", SCANCODE_INTERNATIONAL8}, + {"international9", SCANCODE_INTERNATIONAL9}, + {"lang1", SCANCODE_LANG1}, + {"lang2", SCANCODE_LANG2}, + {"lang3", SCANCODE_LANG3}, + {"lang4", SCANCODE_LANG4}, + {"lang5", SCANCODE_LANG5}, + {"lang6", SCANCODE_LANG6}, + {"lang7", SCANCODE_LANG7}, + {"lang8", SCANCODE_LANG8}, + {"lang9", SCANCODE_LANG9}, + + {"alterase", SCANCODE_ALTERASE}, + {"sysreq", SCANCODE_SYSREQ}, + {"cancel", SCANCODE_CANCEL}, + {"clear", SCANCODE_CLEAR}, + {"prior", SCANCODE_PRIOR}, + {"return2", SCANCODE_RETURN2}, + {"separator", SCANCODE_SEPARATOR}, + {"out", SCANCODE_OUT}, + {"oper", SCANCODE_OPER}, + {"clearagain", SCANCODE_CLEARAGAIN}, + {"crsel", SCANCODE_CRSEL}, + {"exsel", SCANCODE_EXSEL}, + + {"kp00", SCANCODE_KP_00}, + {"kp000", SCANCODE_KP_000}, + {"thsousandsseparator", SCANCODE_THOUSANDSSEPARATOR}, + {"decimalseparator", SCANCODE_DECIMALSEPARATOR}, + {"currencyunit", SCANCODE_CURRENCYUNIT}, + {"currencysubunit", SCANCODE_CURRENCYSUBUNIT}, + {"kp(", SCANCODE_KP_LEFTPAREN}, + {"kp)", SCANCODE_KP_RIGHTPAREN}, + {"kp{", SCANCODE_KP_LEFTBRACE}, + {"kp}", SCANCODE_KP_RIGHTBRACE}, + {"kptab", SCANCODE_KP_TAB}, + {"kpbackspace", SCANCODE_KP_BACKSPACE}, + {"kpa", SCANCODE_KP_A}, + {"kpb", SCANCODE_KP_B}, + {"kpc", SCANCODE_KP_C}, + {"kpd", SCANCODE_KP_D}, + {"kpe", SCANCODE_KP_E}, + {"kpf", SCANCODE_KP_F}, + {"kpxor", SCANCODE_KP_XOR}, + {"kpower", SCANCODE_KP_POWER}, + {"kp%", SCANCODE_KP_PERCENT}, + {"kp<", SCANCODE_KP_LESS}, + {"kp>", SCANCODE_KP_GREATER}, + {"kp&", SCANCODE_KP_AMPERSAND}, + {"kp&&", SCANCODE_KP_DBLAMPERSAND}, + {"kp|", SCANCODE_KP_VERTICALBAR}, + {"kp||", SCANCODE_KP_DBLVERTICALBAR}, + {"kp:", SCANCODE_KP_COLON}, + {"kp#", SCANCODE_KP_HASH}, + {"kp ", SCANCODE_KP_SPACE}, + {"kp@", SCANCODE_KP_AT}, + {"kp!", SCANCODE_KP_EXCLAM}, + {"kpmemstore", SCANCODE_KP_MEMSTORE}, + {"kpmemrecall", SCANCODE_KP_MEMRECALL}, + {"kpmemclear", SCANCODE_KP_MEMCLEAR}, + {"kpmem+", SCANCODE_KP_MEMADD}, + {"kpmem-", SCANCODE_KP_MEMSUBTRACT}, + {"kpmem*", SCANCODE_KP_MEMMULTIPLY}, + {"kpmem/", SCANCODE_KP_MEMDIVIDE}, + {"kp+-", SCANCODE_KP_PLUSMINUS}, + {"kpclear", SCANCODE_KP_CLEAR}, + {"kpclearentry", SCANCODE_KP_CLEARENTRY}, + {"kpbinary", SCANCODE_KP_BINARY}, + {"kpoctal", SCANCODE_KP_OCTAL}, + {"kpdecimal", SCANCODE_KP_DECIMAL}, + {"kphex", SCANCODE_KP_HEXADECIMAL}, + + {"lctrl", SCANCODE_LCTRL}, + {"lshift", SCANCODE_LSHIFT}, + {"lalt", SCANCODE_LALT}, + {"lgui", SCANCODE_LGUI}, + {"rctrl", SCANCODE_RCTRL}, + {"rshift", SCANCODE_RSHIFT}, + {"ralt", SCANCODE_RALT}, + {"rgui", SCANCODE_RGUI}, + + {"mode", SCANCODE_MODE}, + + {"audionext", SCANCODE_AUDIONEXT}, + {"audioprev", SCANCODE_AUDIOPREV}, + {"audiostop", SCANCODE_AUDIOSTOP}, + {"audioplay", SCANCODE_AUDIOPLAY}, + {"audiomute", SCANCODE_AUDIOMUTE}, + {"mediaselect", SCANCODE_MEDIASELECT}, + {"www", SCANCODE_WWW}, + {"mail", SCANCODE_MAIL}, + {"calculator", SCANCODE_CALCULATOR}, + {"computer", SCANCODE_COMPUTER}, + {"acsearch", SCANCODE_AC_SEARCH}, + {"achome", SCANCODE_AC_HOME}, + {"acback", SCANCODE_AC_BACK}, + {"acforward", SCANCODE_AC_FORWARD}, + {"acstop", SCANCODE_AC_STOP}, + {"acrefresh", SCANCODE_AC_REFRESH}, + {"acbookmarks", SCANCODE_AC_BOOKMARKS}, + + {"brightnessdown", SCANCODE_BRIGHTNESSDOWN}, + {"brightnessup", SCANCODE_BRIGHTNESSUP}, + {"displayswitch", SCANCODE_DISPLAYSWITCH}, + {"kbdillumtoggle", SCANCODE_KBDILLUMTOGGLE}, + {"kbdillumdown", SCANCODE_KBDILLUMDOWN}, + {"kbdillumup", SCANCODE_KBDILLUMUP}, + {"eject", SCANCODE_EJECT}, + {"sleep", SCANCODE_SLEEP}, + + {"app1", SCANCODE_APP1}, + {"app2", SCANCODE_APP2}, +}; + +StringMap Keyboard::scancodes(Keyboard::scancodeEntries, sizeof(Keyboard::scancodeEntries)); } // keyboard } // love diff --git a/src/modules/keyboard/Keyboard.h b/src/modules/keyboard/Keyboard.h index e6a7e1b45..80fbed5c8 100644 --- a/src/modules/keyboard/Keyboard.h +++ b/src/modules/keyboard/Keyboard.h @@ -34,6 +34,9 @@ class Keyboard : public Module { public: + /** + * Keyboard keys. They are dependent on the current layout of the keyboard. + **/ enum Key { KEY_UNKNOWN, @@ -244,6 +247,275 @@ public: KEY_MAX_ENUM }; + /** + * Scancodes represent physical keys independent of the current layout. + * Their names may not match the names of the keys printed on the keyboard. + * Some of them are very esoteric... + **/ + enum Scancode + { + SCANCODE_UNKNOWN, + + SCANCODE_A, + SCANCODE_B, + SCANCODE_C, + SCANCODE_D, + SCANCODE_E, + SCANCODE_F, + SCANCODE_G, + SCANCODE_H, + SCANCODE_I, + SCANCODE_J, + SCANCODE_K, + SCANCODE_L, + SCANCODE_M, + SCANCODE_N, + SCANCODE_O, + SCANCODE_P, + SCANCODE_Q, + SCANCODE_R, + SCANCODE_S, + SCANCODE_T, + SCANCODE_U, + SCANCODE_V, + SCANCODE_W, + SCANCODE_X, + SCANCODE_Y, + SCANCODE_Z, + + SCANCODE_1, + SCANCODE_2, + SCANCODE_3, + SCANCODE_4, + SCANCODE_5, + SCANCODE_6, + SCANCODE_7, + SCANCODE_8, + SCANCODE_9, + SCANCODE_0, + + SCANCODE_RETURN, + SCANCODE_ESCAPE, + SCANCODE_BACKSPACE, + SCANCODE_TAB, + SCANCODE_SPACE, + + SCANCODE_MINUS, + SCANCODE_EQUALS, + SCANCODE_LEFTBRACKET, + SCANCODE_RIGHTBRACKET, + SCANCODE_BACKSLASH, + SCANCODE_NONUSHASH, + SCANCODE_SEMICOLON, + SCANCODE_APOSTROPHE, + SCANCODE_GRAVE, + SCANCODE_COMMA, + SCANCODE_PERIOD, + SCANCODE_SLASH, + + SCANCODE_CAPSLOCK, + + SCANCODE_F1, + SCANCODE_F2, + SCANCODE_F3, + SCANCODE_F4, + SCANCODE_F5, + SCANCODE_F6, + SCANCODE_F7, + SCANCODE_F8, + SCANCODE_F9, + SCANCODE_F10, + SCANCODE_F11, + SCANCODE_F12, + + SCANCODE_PRINTSCREEN, + SCANCODE_SCROLLLOCK, + SCANCODE_PAUSE, + SCANCODE_INSERT, + SCANCODE_HOME, + SCANCODE_PAGEUP, + SCANCODE_DELETE, + SCANCODE_END, + SCANCODE_PAGEDOWN, + SCANCODE_RIGHT, + SCANCODE_LEFT, + SCANCODE_DOWN, + SCANCODE_UP, + + SCANCODE_NUMLOCKCLEAR, + SCANCODE_KP_DIVIDE, + SCANCODE_KP_MULTIPLY, + SCANCODE_KP_MINUS, + SCANCODE_KP_PLUS, + SCANCODE_KP_ENTER, + SCANCODE_KP_1, + SCANCODE_KP_2, + SCANCODE_KP_3, + SCANCODE_KP_4, + SCANCODE_KP_5, + SCANCODE_KP_6, + SCANCODE_KP_7, + SCANCODE_KP_8, + SCANCODE_KP_9, + SCANCODE_KP_0, + SCANCODE_KP_PERIOD, + + SCANCODE_NONUSBACKSLASH, + SCANCODE_APPLICATION, + SCANCODE_POWER, + SCANCODE_KP_EQUALS, + SCANCODE_F13, + SCANCODE_F14, + SCANCODE_F15, + SCANCODE_F16, + SCANCODE_F17, + SCANCODE_F18, + SCANCODE_F19, + SCANCODE_F20, + SCANCODE_F21, + SCANCODE_F22, + SCANCODE_F23, + SCANCODE_F24, + SCANCODE_EXECUTE, + SCANCODE_HELP, + SCANCODE_MENU, + SCANCODE_SELECT, + SCANCODE_STOP, + SCANCODE_AGAIN, + SCANCODE_UNDO, + SCANCODE_CUT, + SCANCODE_COPY, + SCANCODE_PASTE, + SCANCODE_FIND, + SCANCODE_MUTE, + SCANCODE_VOLUMEUP, + SCANCODE_VOLUMEDOWN, + SCANCODE_KP_COMMA, + SCANCODE_KP_EQUALSAS400, + + SCANCODE_INTERNATIONAL1, + SCANCODE_INTERNATIONAL2, + SCANCODE_INTERNATIONAL3, + SCANCODE_INTERNATIONAL4, + SCANCODE_INTERNATIONAL5, + SCANCODE_INTERNATIONAL6, + SCANCODE_INTERNATIONAL7, + SCANCODE_INTERNATIONAL8, + SCANCODE_INTERNATIONAL9, + SCANCODE_LANG1, + SCANCODE_LANG2, + SCANCODE_LANG3, + SCANCODE_LANG4, + SCANCODE_LANG5, + SCANCODE_LANG6, + SCANCODE_LANG7, + SCANCODE_LANG8, + SCANCODE_LANG9, + + SCANCODE_ALTERASE, + SCANCODE_SYSREQ, + SCANCODE_CANCEL, + SCANCODE_CLEAR, + SCANCODE_PRIOR, + SCANCODE_RETURN2, + SCANCODE_SEPARATOR, + SCANCODE_OUT, + SCANCODE_OPER, + SCANCODE_CLEARAGAIN, + SCANCODE_CRSEL, + SCANCODE_EXSEL, + + SCANCODE_KP_00, + SCANCODE_KP_000, + SCANCODE_THOUSANDSSEPARATOR, + SCANCODE_DECIMALSEPARATOR, + SCANCODE_CURRENCYUNIT, + SCANCODE_CURRENCYSUBUNIT, + SCANCODE_KP_LEFTPAREN, + SCANCODE_KP_RIGHTPAREN, + SCANCODE_KP_LEFTBRACE, + SCANCODE_KP_RIGHTBRACE, + SCANCODE_KP_TAB, + SCANCODE_KP_BACKSPACE, + SCANCODE_KP_A, + SCANCODE_KP_B, + SCANCODE_KP_C, + SCANCODE_KP_D, + SCANCODE_KP_E, + SCANCODE_KP_F, + SCANCODE_KP_XOR, + SCANCODE_KP_POWER, + SCANCODE_KP_PERCENT, + SCANCODE_KP_LESS, + SCANCODE_KP_GREATER, + SCANCODE_KP_AMPERSAND, + SCANCODE_KP_DBLAMPERSAND, + SCANCODE_KP_VERTICALBAR, + SCANCODE_KP_DBLVERTICALBAR, + SCANCODE_KP_COLON, + SCANCODE_KP_HASH, + SCANCODE_KP_SPACE, + SCANCODE_KP_AT, + SCANCODE_KP_EXCLAM, + SCANCODE_KP_MEMSTORE, + SCANCODE_KP_MEMRECALL, + SCANCODE_KP_MEMCLEAR, + SCANCODE_KP_MEMADD, + SCANCODE_KP_MEMSUBTRACT, + SCANCODE_KP_MEMMULTIPLY, + SCANCODE_KP_MEMDIVIDE, + SCANCODE_KP_PLUSMINUS, + SCANCODE_KP_CLEAR, + SCANCODE_KP_CLEARENTRY, + SCANCODE_KP_BINARY, + SCANCODE_KP_OCTAL, + SCANCODE_KP_DECIMAL, + SCANCODE_KP_HEXADECIMAL, + + SCANCODE_LCTRL, + SCANCODE_LSHIFT, + SCANCODE_LALT, + SCANCODE_LGUI, + SCANCODE_RCTRL, + SCANCODE_RSHIFT, + SCANCODE_RALT, + SCANCODE_RGUI, + + SCANCODE_MODE, + + SCANCODE_AUDIONEXT, + SCANCODE_AUDIOPREV, + SCANCODE_AUDIOSTOP, + SCANCODE_AUDIOPLAY, + SCANCODE_AUDIOMUTE, + SCANCODE_MEDIASELECT, + SCANCODE_WWW, + SCANCODE_MAIL, + SCANCODE_CALCULATOR, + SCANCODE_COMPUTER, + SCANCODE_AC_SEARCH, + SCANCODE_AC_HOME, + SCANCODE_AC_BACK, + SCANCODE_AC_FORWARD, + SCANCODE_AC_STOP, + SCANCODE_AC_REFRESH, + SCANCODE_AC_BOOKMARKS, + + SCANCODE_BRIGHTNESSDOWN, + SCANCODE_BRIGHTNESSUP, + SCANCODE_DISPLAYSWITCH, + SCANCODE_KBDILLUMTOGGLE, + SCANCODE_KBDILLUMDOWN, + SCANCODE_KBDILLUMUP, + SCANCODE_EJECT, + SCANCODE_SLEEP, + + SCANCODE_APP1, + SCANCODE_APP2, + + SCANCODE_MAX_ENUM + }; + virtual ~Keyboard() {} // Implements Module. @@ -268,6 +540,18 @@ public: **/ virtual bool isDown(Key *keylist) const = 0; + /** + * Gets the key corresponding to the specified scancode according to the + * current keyboard layout. + **/ + virtual Key getKeyFromScancode(Scancode scancode) const = 0; + + /** + * Gets the scancode corresponding to the specified key according to the + * current keyboard layout. + **/ + virtual Scancode getScancodeFromKey(Key key) const = 0; + /** * Sets whether text input events should be sent * @param enable Whether to send text input events. @@ -280,13 +564,19 @@ public: virtual bool hasTextInput() const = 0; static bool getConstant(const char *in, Key &out); - static bool getConstant(Key in, const char *&out); + static bool getConstant(Key in, const char *&out); + + static bool getConstant(const char *in, Scancode &out); + static bool getConstant(Scancode in, const char *&out); private: static StringMap::Entry keyEntries[]; static StringMap keys; + static StringMap::Entry scancodeEntries[]; + static StringMap scancodes; + }; // Keyboard } // keyboard diff --git a/src/modules/keyboard/sdl/Keyboard.cpp b/src/modules/keyboard/sdl/Keyboard.cpp index b6a8a2a42..c19895011 100644 --- a/src/modules/keyboard/sdl/Keyboard.cpp +++ b/src/modules/keyboard/sdl/Keyboard.cpp @@ -61,6 +61,37 @@ bool Keyboard::isDown(Key *keylist) const return false; } +Keyboard::Key Keyboard::getKeyFromScancode(Scancode scancode) const +{ + SDL_Scancode sdlscancode = SDL_SCANCODE_UNKNOWN; + scancodes.find(scancode, sdlscancode); + + SDL_Keycode sdlkey = SDL_GetKeyFromScancode(sdlscancode); + + for (int i = 0; i < KEY_MAX_ENUM; i++) + { + if (keymap[i] == sdlkey) + return (Key) i; + } + + return KEY_UNKNOWN; +} + +Keyboard::Scancode Keyboard::getScancodeFromKey(Key key) const +{ + Scancode scancode = SCANCODE_UNKNOWN; + + if (key != KEY_MAX_ENUM) + { + SDL_Keycode sdlkey = keymap[key]; + + SDL_Scancode sdlscancode = SDL_GetScancodeFromKey(sdlkey); + scancodes.find(sdlscancode, scancode); + } + + return scancode; +} + void Keyboard::setTextInput(bool enable) { if (enable) @@ -288,6 +319,270 @@ const SDL_Keycode *Keyboard::createKeyMap() const SDL_Keycode *Keyboard::keymap = Keyboard::createKeyMap(); +EnumMap::Entry Keyboard::scancodeEntries[] = +{ + {SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN}, + + {SCANCODE_A, SDL_SCANCODE_A}, + {SCANCODE_B, SDL_SCANCODE_B}, + {SCANCODE_C, SDL_SCANCODE_C}, + {SCANCODE_D, SDL_SCANCODE_D}, + {SCANCODE_E, SDL_SCANCODE_E}, + {SCANCODE_F, SDL_SCANCODE_F}, + {SCANCODE_G, SDL_SCANCODE_G}, + {SCANCODE_H, SDL_SCANCODE_H}, + {SCANCODE_I, SDL_SCANCODE_I}, + {SCANCODE_J, SDL_SCANCODE_J}, + {SCANCODE_K, SDL_SCANCODE_K}, + {SCANCODE_L, SDL_SCANCODE_L}, + {SCANCODE_M, SDL_SCANCODE_M}, + {SCANCODE_N, SDL_SCANCODE_N}, + {SCANCODE_O, SDL_SCANCODE_O}, + {SCANCODE_P, SDL_SCANCODE_P}, + {SCANCODE_Q, SDL_SCANCODE_Q}, + {SCANCODE_R, SDL_SCANCODE_R}, + {SCANCODE_S, SDL_SCANCODE_S}, + {SCANCODE_T, SDL_SCANCODE_T}, + {SCANCODE_U, SDL_SCANCODE_U}, + {SCANCODE_V, SDL_SCANCODE_V}, + {SCANCODE_W, SDL_SCANCODE_W}, + {SCANCODE_X, SDL_SCANCODE_X}, + {SCANCODE_Y, SDL_SCANCODE_Y}, + {SCANCODE_Z, SDL_SCANCODE_Z}, + + {SCANCODE_1, SDL_SCANCODE_1}, + {SCANCODE_2, SDL_SCANCODE_2}, + {SCANCODE_3, SDL_SCANCODE_3}, + {SCANCODE_4, SDL_SCANCODE_4}, + {SCANCODE_5, SDL_SCANCODE_5}, + {SCANCODE_6, SDL_SCANCODE_6}, + {SCANCODE_7, SDL_SCANCODE_7}, + {SCANCODE_8, SDL_SCANCODE_8}, + {SCANCODE_9, SDL_SCANCODE_9}, + {SCANCODE_0, SDL_SCANCODE_0}, + + {SCANCODE_RETURN, SDL_SCANCODE_RETURN}, + {SCANCODE_ESCAPE, SDL_SCANCODE_ESCAPE}, + {SCANCODE_BACKSPACE, SDL_SCANCODE_BACKSPACE}, + {SCANCODE_TAB, SDL_SCANCODE_TAB}, + {SCANCODE_SPACE, SDL_SCANCODE_SPACE}, + + {SCANCODE_MINUS, SDL_SCANCODE_MINUS}, + {SCANCODE_EQUALS, SDL_SCANCODE_EQUALS}, + {SCANCODE_LEFTBRACKET, SDL_SCANCODE_LEFTBRACKET}, + {SCANCODE_RIGHTBRACKET, SDL_SCANCODE_RIGHTBRACKET}, + {SCANCODE_BACKSLASH, SDL_SCANCODE_BACKSLASH}, + {SCANCODE_NONUSHASH, SDL_SCANCODE_NONUSHASH}, + {SCANCODE_SEMICOLON, SDL_SCANCODE_SEMICOLON}, + {SCANCODE_APOSTROPHE, SDL_SCANCODE_APOSTROPHE}, + {SCANCODE_GRAVE, SDL_SCANCODE_GRAVE}, + {SCANCODE_COMMA, SDL_SCANCODE_COMMA}, + {SCANCODE_PERIOD, SDL_SCANCODE_PERIOD}, + {SCANCODE_SLASH, SDL_SCANCODE_SLASH}, + + {SCANCODE_CAPSLOCK, SDL_SCANCODE_CAPSLOCK}, + + {SCANCODE_F1, SDL_SCANCODE_F1}, + {SCANCODE_F2, SDL_SCANCODE_F2}, + {SCANCODE_F3, SDL_SCANCODE_F3}, + {SCANCODE_F4, SDL_SCANCODE_F4}, + {SCANCODE_F5, SDL_SCANCODE_F5}, + {SCANCODE_F6, SDL_SCANCODE_F6}, + {SCANCODE_F7, SDL_SCANCODE_F7}, + {SCANCODE_F8, SDL_SCANCODE_F8}, + {SCANCODE_F9, SDL_SCANCODE_F9}, + {SCANCODE_F10, SDL_SCANCODE_F10}, + {SCANCODE_F11, SDL_SCANCODE_F11}, + {SCANCODE_F12, SDL_SCANCODE_F12}, + + {SCANCODE_PRINTSCREEN, SDL_SCANCODE_PRINTSCREEN}, + {SCANCODE_SCROLLLOCK, SDL_SCANCODE_SCROLLLOCK}, + {SCANCODE_PAUSE, SDL_SCANCODE_PAUSE}, + {SCANCODE_INSERT, SDL_SCANCODE_INSERT}, + {SCANCODE_HOME, SDL_SCANCODE_HOME}, + {SCANCODE_PAGEUP, SDL_SCANCODE_PAGEUP}, + {SCANCODE_DELETE, SDL_SCANCODE_DELETE}, + {SCANCODE_END, SDL_SCANCODE_END}, + {SCANCODE_PAGEDOWN, SDL_SCANCODE_PAGEDOWN}, + {SCANCODE_RIGHT, SDL_SCANCODE_RIGHT}, + {SCANCODE_LEFT, SDL_SCANCODE_LEFT}, + {SCANCODE_DOWN, SDL_SCANCODE_DOWN}, + {SCANCODE_UP, SDL_SCANCODE_UP}, + + {SCANCODE_NUMLOCKCLEAR, SDL_SCANCODE_NUMLOCKCLEAR}, + {SCANCODE_KP_DIVIDE, SDL_SCANCODE_KP_DIVIDE}, + {SCANCODE_KP_MULTIPLY, SDL_SCANCODE_KP_MULTIPLY}, + {SCANCODE_KP_MINUS, SDL_SCANCODE_KP_MINUS}, + {SCANCODE_KP_PLUS, SDL_SCANCODE_KP_PLUS}, + {SCANCODE_KP_ENTER, SDL_SCANCODE_KP_ENTER}, + {SCANCODE_KP_1, SDL_SCANCODE_KP_1}, + {SCANCODE_KP_2, SDL_SCANCODE_KP_2}, + {SCANCODE_KP_3, SDL_SCANCODE_KP_3}, + {SCANCODE_KP_4, SDL_SCANCODE_KP_4}, + {SCANCODE_KP_5, SDL_SCANCODE_KP_5}, + {SCANCODE_KP_6, SDL_SCANCODE_KP_6}, + {SCANCODE_KP_7, SDL_SCANCODE_KP_7}, + {SCANCODE_KP_8, SDL_SCANCODE_KP_8}, + {SCANCODE_KP_9, SDL_SCANCODE_KP_9}, + {SCANCODE_KP_0, SDL_SCANCODE_KP_0}, + {SCANCODE_KP_PERIOD, SDL_SCANCODE_KP_PERIOD}, + + {SCANCODE_NONUSBACKSLASH, SDL_SCANCODE_NONUSBACKSLASH}, + {SCANCODE_APPLICATION, SDL_SCANCODE_APPLICATION}, + {SCANCODE_POWER, SDL_SCANCODE_POWER}, + {SCANCODE_KP_EQUALS, SDL_SCANCODE_KP_EQUALS}, + {SCANCODE_F13, SDL_SCANCODE_F13}, + {SCANCODE_F14, SDL_SCANCODE_F14}, + {SCANCODE_F15, SDL_SCANCODE_F15}, + {SCANCODE_F16, SDL_SCANCODE_F16}, + {SCANCODE_F17, SDL_SCANCODE_F17}, + {SCANCODE_F18, SDL_SCANCODE_F18}, + {SCANCODE_F19, SDL_SCANCODE_F19}, + {SCANCODE_F20, SDL_SCANCODE_F20}, + {SCANCODE_F21, SDL_SCANCODE_F21}, + {SCANCODE_F22, SDL_SCANCODE_F22}, + {SCANCODE_F23, SDL_SCANCODE_F23}, + {SCANCODE_F24, SDL_SCANCODE_F24}, + {SCANCODE_EXECUTE, SDL_SCANCODE_EXECUTE}, + {SCANCODE_HELP, SDL_SCANCODE_HELP}, + {SCANCODE_MENU, SDL_SCANCODE_MENU}, + {SCANCODE_SELECT, SDL_SCANCODE_SELECT}, + {SCANCODE_STOP, SDL_SCANCODE_STOP}, + {SCANCODE_AGAIN, SDL_SCANCODE_AGAIN}, + {SCANCODE_UNDO, SDL_SCANCODE_UNDO}, + {SCANCODE_CUT, SDL_SCANCODE_CUT}, + {SCANCODE_COPY, SDL_SCANCODE_COPY}, + {SCANCODE_PASTE, SDL_SCANCODE_PASTE}, + {SCANCODE_FIND, SDL_SCANCODE_FIND}, + {SCANCODE_MUTE, SDL_SCANCODE_MUTE}, + {SCANCODE_VOLUMEUP, SDL_SCANCODE_VOLUMEUP}, + {SCANCODE_VOLUMEDOWN, SDL_SCANCODE_VOLUMEDOWN}, + {SCANCODE_KP_COMMA, SDL_SCANCODE_KP_COMMA}, + {SCANCODE_KP_EQUALSAS400, SDL_SCANCODE_KP_EQUALSAS400}, + + {SCANCODE_INTERNATIONAL1, SDL_SCANCODE_INTERNATIONAL1}, + {SCANCODE_INTERNATIONAL2, SDL_SCANCODE_INTERNATIONAL2}, + {SCANCODE_INTERNATIONAL3, SDL_SCANCODE_INTERNATIONAL3}, + {SCANCODE_INTERNATIONAL4, SDL_SCANCODE_INTERNATIONAL4}, + {SCANCODE_INTERNATIONAL5, SDL_SCANCODE_INTERNATIONAL5}, + {SCANCODE_INTERNATIONAL6, SDL_SCANCODE_INTERNATIONAL6}, + {SCANCODE_INTERNATIONAL7, SDL_SCANCODE_INTERNATIONAL7}, + {SCANCODE_INTERNATIONAL8, SDL_SCANCODE_INTERNATIONAL8}, + {SCANCODE_INTERNATIONAL9, SDL_SCANCODE_INTERNATIONAL9}, + {SCANCODE_LANG1, SDL_SCANCODE_LANG1}, + {SCANCODE_LANG2, SDL_SCANCODE_LANG2}, + {SCANCODE_LANG3, SDL_SCANCODE_LANG3}, + {SCANCODE_LANG4, SDL_SCANCODE_LANG4}, + {SCANCODE_LANG5, SDL_SCANCODE_LANG5}, + {SCANCODE_LANG6, SDL_SCANCODE_LANG6}, + {SCANCODE_LANG7, SDL_SCANCODE_LANG7}, + {SCANCODE_LANG8, SDL_SCANCODE_LANG8}, + {SCANCODE_LANG9, SDL_SCANCODE_LANG9}, + + {SCANCODE_ALTERASE, SDL_SCANCODE_ALTERASE}, + {SCANCODE_SYSREQ, SDL_SCANCODE_SYSREQ}, + {SCANCODE_CANCEL, SDL_SCANCODE_CANCEL}, + {SCANCODE_CLEAR, SDL_SCANCODE_CLEAR}, + {SCANCODE_PRIOR, SDL_SCANCODE_PRIOR}, + {SCANCODE_RETURN2, SDL_SCANCODE_RETURN2}, + {SCANCODE_SEPARATOR, SDL_SCANCODE_SEPARATOR}, + {SCANCODE_OUT, SDL_SCANCODE_OUT}, + {SCANCODE_OPER, SDL_SCANCODE_OPER}, + {SCANCODE_CLEARAGAIN, SDL_SCANCODE_CLEARAGAIN}, + {SCANCODE_CRSEL, SDL_SCANCODE_CRSEL}, + {SCANCODE_EXSEL, SDL_SCANCODE_EXSEL}, + + {SCANCODE_KP_00, SDL_SCANCODE_KP_00}, + {SCANCODE_KP_000, SDL_SCANCODE_KP_000}, + {SCANCODE_THOUSANDSSEPARATOR, SDL_SCANCODE_THOUSANDSSEPARATOR}, + {SCANCODE_DECIMALSEPARATOR, SDL_SCANCODE_DECIMALSEPARATOR}, + {SCANCODE_CURRENCYUNIT, SDL_SCANCODE_CURRENCYUNIT}, + {SCANCODE_CURRENCYSUBUNIT, SDL_SCANCODE_CURRENCYSUBUNIT}, + {SCANCODE_KP_LEFTPAREN, SDL_SCANCODE_KP_LEFTPAREN}, + {SCANCODE_KP_RIGHTPAREN, SDL_SCANCODE_KP_RIGHTPAREN}, + {SCANCODE_KP_LEFTBRACE, SDL_SCANCODE_KP_LEFTBRACE}, + {SCANCODE_KP_RIGHTBRACE, SDL_SCANCODE_KP_RIGHTBRACE}, + {SCANCODE_KP_TAB, SDL_SCANCODE_KP_TAB}, + {SCANCODE_KP_BACKSPACE, SDL_SCANCODE_KP_BACKSPACE}, + {SCANCODE_KP_A, SDL_SCANCODE_KP_A}, + {SCANCODE_KP_B, SDL_SCANCODE_KP_B}, + {SCANCODE_KP_C, SDL_SCANCODE_KP_C}, + {SCANCODE_KP_D, SDL_SCANCODE_KP_D}, + {SCANCODE_KP_E, SDL_SCANCODE_KP_E}, + {SCANCODE_KP_F, SDL_SCANCODE_KP_F}, + {SCANCODE_KP_XOR, SDL_SCANCODE_KP_XOR}, + {SCANCODE_KP_POWER, SDL_SCANCODE_KP_POWER}, + {SCANCODE_KP_PERCENT, SDL_SCANCODE_KP_PERCENT}, + {SCANCODE_KP_LESS, SDL_SCANCODE_KP_LESS}, + {SCANCODE_KP_GREATER, SDL_SCANCODE_KP_GREATER}, + {SCANCODE_KP_AMPERSAND, SDL_SCANCODE_KP_AMPERSAND}, + {SCANCODE_KP_DBLAMPERSAND, SDL_SCANCODE_KP_DBLAMPERSAND}, + {SCANCODE_KP_VERTICALBAR, SDL_SCANCODE_KP_VERTICALBAR}, + {SCANCODE_KP_DBLVERTICALBAR, SDL_SCANCODE_KP_DBLVERTICALBAR}, + {SCANCODE_KP_COLON, SDL_SCANCODE_KP_COLON}, + {SCANCODE_KP_HASH, SDL_SCANCODE_KP_HASH}, + {SCANCODE_KP_SPACE, SDL_SCANCODE_KP_SPACE}, + {SCANCODE_KP_AT, SDL_SCANCODE_KP_AT}, + {SCANCODE_KP_EXCLAM, SDL_SCANCODE_KP_EXCLAM}, + {SCANCODE_KP_MEMSTORE, SDL_SCANCODE_KP_MEMSTORE}, + {SCANCODE_KP_MEMRECALL, SDL_SCANCODE_KP_MEMRECALL}, + {SCANCODE_KP_MEMCLEAR, SDL_SCANCODE_KP_MEMCLEAR}, + {SCANCODE_KP_MEMADD, SDL_SCANCODE_KP_MEMADD}, + {SCANCODE_KP_MEMSUBTRACT, SDL_SCANCODE_KP_MEMSUBTRACT}, + {SCANCODE_KP_MEMMULTIPLY, SDL_SCANCODE_KP_MEMMULTIPLY}, + {SCANCODE_KP_MEMDIVIDE, SDL_SCANCODE_KP_MEMDIVIDE}, + {SCANCODE_KP_PLUSMINUS, SDL_SCANCODE_KP_PLUSMINUS}, + {SCANCODE_KP_CLEAR, SDL_SCANCODE_KP_CLEAR}, + {SCANCODE_KP_CLEARENTRY, SDL_SCANCODE_KP_CLEARENTRY}, + {SCANCODE_KP_BINARY, SDL_SCANCODE_KP_BINARY}, + {SCANCODE_KP_OCTAL, SDL_SCANCODE_KP_OCTAL}, + {SCANCODE_KP_DECIMAL, SDL_SCANCODE_KP_DECIMAL}, + {SCANCODE_KP_HEXADECIMAL, SDL_SCANCODE_KP_HEXADECIMAL}, + + {SCANCODE_LCTRL, SDL_SCANCODE_LCTRL}, + {SCANCODE_LSHIFT, SDL_SCANCODE_LSHIFT}, + {SCANCODE_LALT, SDL_SCANCODE_LALT}, + {SCANCODE_LGUI, SDL_SCANCODE_LGUI}, + {SCANCODE_RCTRL, SDL_SCANCODE_RCTRL}, + {SCANCODE_RSHIFT, SDL_SCANCODE_RSHIFT}, + {SCANCODE_RALT, SDL_SCANCODE_RALT}, + {SCANCODE_RGUI, SDL_SCANCODE_RGUI}, + + {SCANCODE_MODE, SDL_SCANCODE_MODE}, + + {SCANCODE_AUDIONEXT, SDL_SCANCODE_AUDIONEXT}, + {SCANCODE_AUDIOPREV, SDL_SCANCODE_AUDIOPREV}, + {SCANCODE_AUDIOSTOP, SDL_SCANCODE_AUDIOSTOP}, + {SCANCODE_AUDIOPLAY, SDL_SCANCODE_AUDIOPLAY}, + {SCANCODE_AUDIOMUTE, SDL_SCANCODE_AUDIOMUTE}, + {SCANCODE_MEDIASELECT, SDL_SCANCODE_MEDIASELECT}, + {SCANCODE_WWW, SDL_SCANCODE_WWW}, + {SCANCODE_MAIL, SDL_SCANCODE_MAIL}, + {SCANCODE_CALCULATOR, SDL_SCANCODE_CALCULATOR}, + {SCANCODE_COMPUTER, SDL_SCANCODE_COMPUTER}, + {SCANCODE_AC_SEARCH, SDL_SCANCODE_AC_SEARCH}, + {SCANCODE_AC_HOME, SDL_SCANCODE_AC_HOME}, + {SCANCODE_AC_BACK, SDL_SCANCODE_AC_BACK}, + {SCANCODE_AC_FORWARD, SDL_SCANCODE_AC_FORWARD}, + {SCANCODE_AC_STOP, SDL_SCANCODE_AC_STOP}, + {SCANCODE_AC_REFRESH, SDL_SCANCODE_AC_REFRESH}, + {SCANCODE_AC_BOOKMARKS, SDL_SCANCODE_AC_BOOKMARKS}, + + {SCANCODE_BRIGHTNESSDOWN, SDL_SCANCODE_BRIGHTNESSDOWN}, + {SCANCODE_BRIGHTNESSUP, SDL_SCANCODE_BRIGHTNESSUP}, + {SCANCODE_DISPLAYSWITCH, SDL_SCANCODE_DISPLAYSWITCH}, + {SCANCODE_KBDILLUMTOGGLE, SDL_SCANCODE_KBDILLUMTOGGLE}, + {SCANCODE_KBDILLUMDOWN, SDL_SCANCODE_KBDILLUMDOWN}, + {SCANCODE_KBDILLUMUP, SDL_SCANCODE_KBDILLUMUP}, + {SCANCODE_EJECT, SDL_SCANCODE_EJECT}, + {SCANCODE_SLEEP, SDL_SCANCODE_SLEEP}, + + {SCANCODE_APP1, SDL_SCANCODE_APP1}, + {SCANCODE_APP2, SDL_SCANCODE_APP2}, +}; + +EnumMap Keyboard::scancodes(Keyboard::scancodeEntries, sizeof(Keyboard::scancodeEntries)); + } // sdl } // keyboard } // love diff --git a/src/modules/keyboard/sdl/Keyboard.h b/src/modules/keyboard/sdl/Keyboard.h index 96db50e60..7f4a83338 100644 --- a/src/modules/keyboard/sdl/Keyboard.h +++ b/src/modules/keyboard/sdl/Keyboard.h @@ -48,6 +48,9 @@ public: bool hasKeyRepeat() const; bool isDown(Key *keylist) const; + Key getKeyFromScancode(Scancode scancode) const; + Scancode getScancodeFromKey(Key key) const; + void setTextInput(bool enable); bool hasTextInput() const; @@ -60,6 +63,9 @@ private: static const SDL_Keycode *createKeyMap(); static const SDL_Keycode *keymap; + static EnumMap::Entry scancodeEntries[]; + static EnumMap scancodes; + }; // Keyboard } // sdl diff --git a/src/modules/keyboard/wrap_Keyboard.cpp b/src/modules/keyboard/wrap_Keyboard.cpp index e07fae101..cc5e26716 100644 --- a/src/modules/keyboard/wrap_Keyboard.cpp +++ b/src/modules/keyboard/wrap_Keyboard.cpp @@ -62,6 +62,40 @@ int w_isDown(lua_State *L) return 1; } +int w_getScancodeFromKey(lua_State *L) +{ + const char *keystr = luaL_checkstring(L, 1); + Keyboard::Key key; + if (!Keyboard::getConstant(keystr, key)) + return luaL_error(L, "Invalid key constant: %s", keystr); + + Keyboard::Scancode scancode = instance()->getScancodeFromKey(key); + + const char *scancodestr; + if (!Keyboard::getConstant(scancode, scancodestr)) + return luaL_error(L, "Unknown scancode."); + + lua_pushstring(L, scancodestr); + return 1; +} + +int w_getKeyFromScancode(lua_State *L) +{ + const char *scancodestr = luaL_checkstring(L, 1); + Keyboard::Scancode scancode; + if (!Keyboard::getConstant(scancodestr, scancode)) + return luaL_error(L, "Invalid scancode: %s", scancode); + + Keyboard::Key key = instance()->getKeyFromScancode(scancode); + + const char *keystr; + if (!Keyboard::getConstant(key, keystr)) + return luaL_error(L, "Unknown key constant"); + + lua_pushstring(L, keystr); + return 1; +} + int w_setTextInput(lua_State *L) { instance()->setTextInput(luax_toboolean(L, 1)); @@ -82,6 +116,8 @@ static const luaL_Reg functions[] = { "setTextInput", w_setTextInput }, { "hasTextInput", w_hasTextInput }, { "isDown", w_isDown }, + { "getScancodeFromKey", w_getScancodeFromKey }, + { "getKeyFromScancode", w_getKeyFromScancode }, { 0, 0 } }; diff --git a/src/modules/keyboard/wrap_Keyboard.h b/src/modules/keyboard/wrap_Keyboard.h index af81b9183..49f5239e7 100644 --- a/src/modules/keyboard/wrap_Keyboard.h +++ b/src/modules/keyboard/wrap_Keyboard.h @@ -33,6 +33,8 @@ namespace keyboard int w_setKeyRepeat(lua_State *L); int w_hasKeyRepeat(lua_State *L); int w_isDown(lua_State *L); +int w_getKeyFromScancode(lua_State *L); +int w_getScancodeFromkey(lua_State *L); int w_setTextInput(lua_State *L); int w_hasTextInput(lua_State *L); extern "C" LOVE_EXPORT int luaopen_love_keyboard(lua_State *L);