diff --git a/library/Core.cpp b/library/Core.cpp index 94d408b80..165f5e5e8 100644 --- a/library/Core.cpp +++ b/library/Core.cpp @@ -68,6 +68,8 @@ using namespace DFHack; #include #include "tinythread.h" +#include "SDL_events.h" + using namespace tthread; using namespace df::enums; using df::global::init; @@ -1218,29 +1220,31 @@ bool Core::ncurses_wgetch(int in, int & out) return true; } -int Core::UnicodeAwareSym(const SDL_KeyboardEvent& ke) +int UnicodeAwareSym(const SDL::Event& event) { + auto ke = (const SDL::KeyboardEvent &) event; // Assume keyboard layouts don't change the order of numbers: - if( '0' <= ke.keysym.sym && ke.keysym.sym <= '9') return ke.keysym.sym; - if(SDLK_F1 <= ke.keysym.sym && ke.keysym.sym <= SDLK_F12) return ke.keysym.sym; + if( '0' <= ke.ksym.sym && ke.ksym.sym <= '9') return ke.ksym.sym; + if(SDL::K_F1 <= ke.ksym.sym && ke.ksym.sym <= SDL::K_F12) return ke.ksym.sym; // These keys are mapped to the same control codes as Ctrl-? - switch (ke.keysym.sym) { - case SDLK_RETURN: - case SDLK_KP_ENTER: - case SDLK_TAB: - case SDLK_ESCAPE: - case SDLK_DELETE: - return ke.keysym.sym; - default: - break; + switch (ke.ksym.sym) + { + case SDL::K_RETURN: + case SDL::K_KP_ENTER: + case SDL::K_TAB: + case SDL::K_ESCAPE: + case SDL::K_DELETE: + return ke.ksym.sym; + default: + break; } - int unicode = ke.keysym.unicode; + int unicode = ke.ksym.unicode; // convert Ctrl characters to their 0x40-0x5F counterparts: if (unicode < ' ') - { + { unicode += 'A' - 1; } @@ -1248,7 +1252,7 @@ int Core::UnicodeAwareSym(const SDL_KeyboardEvent& ke) if('A' < unicode && unicode < 'Z') { unicode += 'a' - 'A'; - } + } // convert various other punctuation marks: if('\"' == unicode) unicode = '\''; @@ -1265,29 +1269,30 @@ int Core::UnicodeAwareSym(const SDL_KeyboardEvent& ke) return unicode; } + //MEMO: return false if event is consumed -int Core::DFH_SDL_Event(SDL_Event* ev) +int Core::DFH_SDL_Event(SDL::Event* ev) { // do NOT process events before we are ready. if(!started) return true; if(!ev) return true; - if(ev && (ev->type == SDL_KEYDOWN || ev->type == SDL_KEYUP)) + if(ev && (ev->type == SDL::ET_KEYDOWN || ev->type == SDL::ET_KEYUP)) { - SDL_KeyboardEvent * ke = (SDL_KeyboardEvent *)ev; + auto ke = (SDL::KeyboardEvent *)ev; - if(ke->state == SDL_PRESSED && !hotkey_states[ke->keysym.sym]) + if(ke->state == SDL::BTN_PRESSED && !hotkey_states[ke->ksym.sym]) { - hotkey_states[ke->keysym.sym] = true; + hotkey_states[ke->ksym.sym] = true; int mod = 0; - if (ke->keysym.mod & KMOD_SHIFT) mod |= 1; - if (ke->keysym.mod & KMOD_CTRL) mod |= 2; - if (ke->keysym.mod & KMOD_ALT) mod |= 4; + if (ke->ksym.mod & SDL::KMOD_SHIFT) mod |= 1; + if (ke->ksym.mod & SDL::KMOD_CTRL) mod |= 2; + if (ke->ksym.mod & SDL::KMOD_ALT) mod |= 4; // Use unicode so Windows gives the correct value for the // user's Input Language - if((ke->keysym.unicode & 0xff80) == 0) + if((ke->ksym.unicode & 0xff80) == 0) { int key = UnicodeAwareSym(*ke); SelectHotkey(key, mod); @@ -1295,12 +1300,12 @@ int Core::DFH_SDL_Event(SDL_Event* ev) else { // Pretend non-ascii characters don't happen: - SelectHotkey(ke->keysym.sym, mod); + SelectHotkey(ke->ksym.sym, mod); } } - else if(ke->state == SDL_RELEASED) + else if(ke->state == SDL::BTN_RELEASED) { - hotkey_states[ke->keysym.sym] = false; + hotkey_states[ke->ksym.sym] = false; } } return true; @@ -1317,8 +1322,8 @@ bool Core::SelectHotkey(int sym, int modifiers) while (screen->child) screen = screen->child; - if (sym == SDLK_KP_ENTER) - sym = SDLK_RETURN; + if (sym == SDL::K_KP_ENTER) + sym = SDL::K_RETURN; std::string cmd; @@ -1341,7 +1346,7 @@ bool Core::SelectHotkey(int sym, int modifiers) if (cmd.empty()) { // Check the hotkey keybindings - int idx = sym - SDLK_F1; + int idx = sym - SDL::K_F1; if(idx >= 0 && idx < 8) { if (modifiers & 1) @@ -1396,13 +1401,13 @@ static bool parseKeySpec(std::string keyspec, int *psym, int *pmod, std::string } if (keyspec.size() == 1 && keyspec[0] >= 'A' && keyspec[0] <= 'Z') { - *psym = SDLK_a + (keyspec[0]-'A'); + *psym = SDL::K_a + (keyspec[0]-'A'); return true; } else if (keyspec.size() == 2 && keyspec[0] == 'F' && keyspec[1] >= '1' && keyspec[1] <= '9') { - *psym = SDLK_F1 + (keyspec[1]-'1'); + *psym = SDL::K_F1 + (keyspec[1]-'1'); return true; } else if (keyspec == "Enter") { - *psym = SDLK_RETURN; + *psym = SDL::K_RETURN; return true; } else return false; diff --git a/library/include/Core.h b/library/include/Core.h index 2810ff14a..e4d1080d6 100644 --- a/library/include/Core.h +++ b/library/include/Core.h @@ -33,7 +33,6 @@ distribution. #include #include "Console.h" #include "modules/Graphic.h" -#include "SDL_events.h" #include "RemoteClient.h" @@ -86,14 +85,14 @@ namespace DFHack { friend int ::SDL_NumJoysticks(void); friend void ::SDL_Quit(void); - friend int ::SDL_PollEvent(SDL_Event *); + friend int ::SDL_PollEvent(SDL::Event *); friend int ::SDL_Init(uint32_t flags); friend int ::wgetch(WINDOW * w); friend int ::egg_init(void); friend int ::egg_shutdown(void); friend int ::egg_tick(void); friend int ::egg_prerender(void); - friend int ::egg_sdl_event(SDL_Event* event); + friend int ::egg_sdl_event(SDL::Event* event); friend int ::egg_curses_event(int orig_return); public: /// Get the single Core instance or make one. @@ -170,7 +169,7 @@ namespace DFHack int Update (void); int TileUpdate (void); int Shutdown (void); - int DFH_SDL_Event(SDL_Event* event); + int DFH_SDL_Event(SDL::Event* event); bool ncurses_wgetch(int in, int & out); void onUpdate(color_ostream &out); @@ -215,7 +214,6 @@ namespace DFHack tthread::mutex * HotkeyMutex; tthread::condition_variable * HotkeyCond; - int UnicodeAwareSym(const SDL_KeyboardEvent& ke); bool SelectHotkey(int key, int modifiers); // for state change tracking diff --git a/library/include/Hooks.h b/library/include/Hooks.h index 83a39ea18..418a5ce3b 100644 --- a/library/include/Hooks.h +++ b/library/include/Hooks.h @@ -33,8 +33,6 @@ distribution. #include #include -#include "SDL.h" - // function and variable pointer... we don't try to understand what SDL does here typedef void * fPtr; typedef void * vPtr; @@ -48,7 +46,7 @@ namespace SDL // be declared as friend functions/known DFhackCExport int SDL_NumJoysticks(void); DFhackCExport void SDL_Quit(void); -DFhackCExport int SDL_PollEvent(SDL_Event* event); +DFhackCExport int SDL_PollEvent(SDL::Event* event); DFhackCExport int SDL_Init(uint32_t flags); DFhackCExport int wgetch(WINDOW * win); @@ -65,7 +63,7 @@ DFhackCExport int egg_tick(void); DFhackCExport int egg_prerender(void); // hook - called for each SDL event, can filter both the event and the return value -DFhackCExport int egg_sdl_event(SDL_Event* event); +DFhackCExport int egg_sdl_event(SDL::Event* event); // hook - ncurses event. return -1 to consume DFhackCExport int egg_curses_event(int orig_return); diff --git a/library/include/SDL_events.h b/library/include/SDL_events.h new file mode 100644 index 000000000..0457dbca1 --- /dev/null +++ b/library/include/SDL_events.h @@ -0,0 +1,210 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2009 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ + +// Fake - only structs. Shamelessly pilfered from the SDL library. +// Needed for processing its event types without polluting our namespaces with C garbage + +#pragma once +#include "SDL_keyboard.h" + +namespace SDL +{ + enum ButtonState + { + BTN_RELEASED = 0, + BTN_PRESSED = 1 + }; + + /** Event enumerations */ + enum EventType + { + ET_NOEVENT = 0, /**< Unused (do not remove) */ + ET_ACTIVEEVENT, /**< Application loses/gains visibility */ + ET_KEYDOWN, /**< Keys pressed */ + ET_KEYUP, /**< Keys released */ + ET_MOUSEMOTION, /**< Mouse moved */ + ET_MOUSEBUTTONDOWN, /**< Mouse button pressed */ + ET_MOUSEBUTTONUP, /**< Mouse button released */ + ET_JOYAXISMOTION, /**< Joystick axis motion */ + ET_JOYBALLMOTION, /**< Joystick trackball motion */ + ET_JOYHATMOTION, /**< Joystick hat position change */ + ET_JOYBUTTONDOWN, /**< Joystick button pressed */ + ET_JOYBUTTONUP, /**< Joystick button released */ + ET_QUIT, /**< User-requested quit */ + ET_SYSWMEVENT, /**< System specific event */ + ET_EVENT_RESERVEDA, /**< Reserved for future use.. */ + ET_EVENT_RESERVEDB, /**< Reserved for future use.. */ + ET_VIDEORESIZE, /**< User resized video mode */ + ET_VIDEOEXPOSE, /**< Screen needs to be redrawn */ + ET_EVENT_RESERVED2, /**< Reserved for future use.. */ + ET_EVENT_RESERVED3, /**< Reserved for future use.. */ + ET_EVENT_RESERVED4, /**< Reserved for future use.. */ + ET_EVENT_RESERVED5, /**< Reserved for future use.. */ + ET_EVENT_RESERVED6, /**< Reserved for future use.. */ + ET_EVENT_RESERVED7, /**< Reserved for future use.. */ + /** Events ET_USEREVENT through ET_MAXEVENTS-1 are for your use */ + ET_USEREVENT = 24, + /** This last event is only for bounding internal arrays + * It is the number of bits in the event mask datatype -- Uint32 + */ + ET_NUMEVENTS = 32 + }; + + /** Application visibility event structure */ + struct ActiveEvent + { + uint8_t type; /**< ET_ACTIVEEVENT */ + uint8_t gain; /**< Whether given states were gained or lost (1/0) */ + uint8_t state; /**< A mask of the focus states */ + }; + + /** Keyboard event structure */ + struct KeyboardEvent + { + uint8_t type; /**< ET_KEYDOWN or ET_KEYUP */ + uint8_t which; /**< The keyboard device index */ + uint8_t state; /**< BTN_PRESSED or BTN_RELEASED */ + keysym ksym; + }; + + /** Mouse motion event structure */ + struct MouseMotionEvent + { + uint8_t type; /**< ET_MOUSEMOTION */ + uint8_t which; /**< The mouse device index */ + uint8_t state; /**< The current button state */ + uint16_t x, y; /**< The X/Y coordinates of the mouse */ + int16_t xrel; /**< The relative motion in the X direction */ + int16_t yrel; /**< The relative motion in the Y direction */ + }; + + /** Mouse button event structure */ + struct MouseButtonEvent + { + uint8_t type; /**< ET_MOUSEBUTTONDOWN or ET_MOUSEBUTTONUP */ + uint8_t which; /**< The mouse device index */ + uint8_t button; /**< The mouse button index */ + uint8_t state; /**< BTN_PRESSED or BTN_RELEASED */ + uint16_t x, y; /**< The X/Y coordinates of the mouse at press time */ + }; + + /** Joystick axis motion event structure */ + struct JoyAxisEvent + { + uint8_t type; /**< ET_JOYAXISMOTION */ + uint8_t which; /**< The joystick device index */ + uint8_t axis; /**< The joystick axis index */ + int16_t value; /**< The axis value (range: -32768 to 32767) */ + }; + + /** Joystick trackball motion event structure */ + struct JoyBallEvent + { + uint8_t type; /**< ET_JOYBALLMOTION */ + uint8_t which; /**< The joystick device index */ + uint8_t ball; /**< The joystick trackball index */ + int16_t xrel; /**< The relative motion in the X direction */ + int16_t yrel; /**< The relative motion in the Y direction */ + }; + + /** Joystick hat position change event structure */ + struct JoyHatEvent + { + uint8_t type; /**< ET_JOYHATMOTION */ + uint8_t which; /**< The joystick device index */ + uint8_t hat; /**< The joystick hat index */ + uint8_t value; /**< The hat position value: + * SDL_HAT_LEFTUP SDL_HAT_UP SDL_HAT_RIGHTUP + * SDL_HAT_LEFT SDL_HAT_CENTERED SDL_HAT_RIGHT + * SDL_HAT_LEFTDOWN SDL_HAT_DOWN SDL_HAT_RIGHTDOWN + * Note that zero means the POV is centered. + */ + }; + + /** Joystick button event structure */ + struct JoyButtonEvent + { + uint8_t type; /**< ET_JOYBUTTONDOWN or ET_JOYBUTTONUP */ + uint8_t which; /**< The joystick device index */ + uint8_t button; /**< The joystick button index */ + uint8_t state; /**< BTN_PRESSED or BTN_RELEASED */ + }; + + /** The "window resized" event + * When you get this event, you are responsible for setting a new video + * mode with the new width and height. + */ + struct ResizeEvent + { + uint8_t type; /**< ET_VIDEORESIZE */ + int w; /**< New width */ + int h; /**< New height */ + }; + + /** The "screen redraw" event */ + struct ExposeEvent + { + uint8_t type; /**< ET_VIDEOEXPOSE */ + }; + + /** The "quit requested" event */ + struct QuitEvent + { + uint8_t type; /**< ET_QUIT */ + }; + + /** A user-defined event type */ + struct UserEvent + { + uint8_t type; /**< ETL_USEREVENT through ET_NUMEVENTS-1 */ + int code; /**< User defined event code */ + void *data1; /**< User defined data pointer */ + void *data2; /**< User defined data pointer */ + }; + + /** If you want to use this event, you should include SDL_syswm.h */ + struct SysWMmsg; + struct SysWMEvent + { + uint8_t type; + SysWMmsg *msg; + }; + + /** General event structure */ + union Event + { + uint8_t type; + ActiveEvent active; + KeyboardEvent key; + MouseMotionEvent motion; + MouseButtonEvent button; + JoyAxisEvent jaxis; + JoyBallEvent jball; + JoyHatEvent jhat; + JoyButtonEvent jbutton; + ResizeEvent resize; + ExposeEvent expose; + QuitEvent quit; + UserEvent user; + SysWMEvent syswm; + }; +} \ No newline at end of file diff --git a/library/include/SDL_keyboard.h b/library/include/SDL_keyboard.h new file mode 100644 index 000000000..f0d325f57 --- /dev/null +++ b/library/include/SDL_keyboard.h @@ -0,0 +1,61 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2009 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ + +// Fake - only structs. Shamelessly pilfered from the SDL library. +// Needed for processing its event types without polluting our namespaces with C garbage + +#pragma once +#include "SDL_keysym.h" +#include + +namespace SDL +{ + /** Keysym structure + * + * - The scancode is hardware dependent, and should not be used by general + * applications. If no hardware scancode is available, it will be 0. + * + * - The 'unicode' translated character is only available when character + * translation is enabled by the SDL_EnableUNICODE() API. If non-zero, + * this is a UNICODE character corresponding to the keypress. If the + * high 9 bits of the character are 0, then this maps to the equivalent + * ASCII character: + * @code + * char ch; + * if ( (keysym.unicode & 0xFF80) == 0 ) { + * ch = keysym.unicode & 0x7F; + * } else { + * An international character.. + * } + * @endcode + */ + typedef struct keysym + { + uint8_t scancode; /**< hardware specific scancode */ + Key sym; /**< SDL virtual keysym */ + Mod mod; /**< current key modifiers */ + uint16_t unicode; /**< translated character */ + } keysym; + + /** This is the mask which refers to all hotkey bindings */ + #define ALL_HOTKEYS 0xFFFFFFFF +} \ No newline at end of file diff --git a/library/include/SDL_keysym.h b/library/include/SDL_keysym.h new file mode 100644 index 000000000..4f01cfa9c --- /dev/null +++ b/library/include/SDL_keysym.h @@ -0,0 +1,329 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2009 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ + +// Fake - only structs. Shamelessly pilfered from the SDL library. +// Needed for processing its event types without polluting our namespaces with C garbage + +#pragma once + +namespace SDL +{ + /** What we really want is a mapping of every raw key on the keyboard. + * To support international keyboards, we use the range 0xA1 - 0xFF + * as international virtual keycodes. We'll follow in the footsteps of X11... + * @brief The names of the keys + */ + enum Key + { + /** @name ASCII mapped keysyms + * The keyboard syms have been cleverly chosen to map to ASCII + */ + /*@{*/ + K_UNKNOWN = 0, + K_FIRST = 0, + K_BACKSPACE = 8, + K_TAB = 9, + K_CLEAR = 12, + K_RETURN = 13, + K_PAUSE = 19, + K_ESCAPE = 27, + K_SPACE = 32, + K_EXCLAIM = 33, + K_QUOTEDBL = 34, + K_HASH = 35, + K_DOLLAR = 36, + K_AMPERSAND = 38, + K_QUOTE = 39, + K_LEFTPAREN = 40, + K_RIGHTPAREN = 41, + K_ASTERISK = 42, + K_PLUS = 43, + K_COMMA = 44, + K_MINUS = 45, + K_PERIOD = 46, + K_SLASH = 47, + K_0 = 48, + K_1 = 49, + K_2 = 50, + K_3 = 51, + K_4 = 52, + K_5 = 53, + K_6 = 54, + K_7 = 55, + K_8 = 56, + K_9 = 57, + K_COLON = 58, + K_SEMICOLON = 59, + K_LESS = 60, + K_EQUALS = 61, + K_GREATER = 62, + K_QUESTION = 63, + K_AT = 64, + /* + Skip uppercase letters + */ + K_LEFTBRACKET = 91, + K_BACKSLASH = 92, + K_RIGHTBRACKET = 93, + K_CARET = 94, + K_UNDERSCORE = 95, + K_BACKQUOTE = 96, + K_a = 97, + K_b = 98, + K_c = 99, + K_d = 100, + K_e = 101, + K_f = 102, + K_g = 103, + K_h = 104, + K_i = 105, + K_j = 106, + K_k = 107, + K_l = 108, + K_m = 109, + K_n = 110, + K_o = 111, + K_p = 112, + K_q = 113, + K_r = 114, + K_s = 115, + K_t = 116, + K_u = 117, + K_v = 118, + K_w = 119, + K_x = 120, + K_y = 121, + K_z = 122, + K_DELETE = 127, + /* End of ASCII mapped keysyms */ + /*@}*/ + + /** @name International keyboard syms */ + /*@{*/ + K_WORLD_0 = 160, /* 0xA0 */ + K_WORLD_1 = 161, + K_WORLD_2 = 162, + K_WORLD_3 = 163, + K_WORLD_4 = 164, + K_WORLD_5 = 165, + K_WORLD_6 = 166, + K_WORLD_7 = 167, + K_WORLD_8 = 168, + K_WORLD_9 = 169, + K_WORLD_10 = 170, + K_WORLD_11 = 171, + K_WORLD_12 = 172, + K_WORLD_13 = 173, + K_WORLD_14 = 174, + K_WORLD_15 = 175, + K_WORLD_16 = 176, + K_WORLD_17 = 177, + K_WORLD_18 = 178, + K_WORLD_19 = 179, + K_WORLD_20 = 180, + K_WORLD_21 = 181, + K_WORLD_22 = 182, + K_WORLD_23 = 183, + K_WORLD_24 = 184, + K_WORLD_25 = 185, + K_WORLD_26 = 186, + K_WORLD_27 = 187, + K_WORLD_28 = 188, + K_WORLD_29 = 189, + K_WORLD_30 = 190, + K_WORLD_31 = 191, + K_WORLD_32 = 192, + K_WORLD_33 = 193, + K_WORLD_34 = 194, + K_WORLD_35 = 195, + K_WORLD_36 = 196, + K_WORLD_37 = 197, + K_WORLD_38 = 198, + K_WORLD_39 = 199, + K_WORLD_40 = 200, + K_WORLD_41 = 201, + K_WORLD_42 = 202, + K_WORLD_43 = 203, + K_WORLD_44 = 204, + K_WORLD_45 = 205, + K_WORLD_46 = 206, + K_WORLD_47 = 207, + K_WORLD_48 = 208, + K_WORLD_49 = 209, + K_WORLD_50 = 210, + K_WORLD_51 = 211, + K_WORLD_52 = 212, + K_WORLD_53 = 213, + K_WORLD_54 = 214, + K_WORLD_55 = 215, + K_WORLD_56 = 216, + K_WORLD_57 = 217, + K_WORLD_58 = 218, + K_WORLD_59 = 219, + K_WORLD_60 = 220, + K_WORLD_61 = 221, + K_WORLD_62 = 222, + K_WORLD_63 = 223, + K_WORLD_64 = 224, + K_WORLD_65 = 225, + K_WORLD_66 = 226, + K_WORLD_67 = 227, + K_WORLD_68 = 228, + K_WORLD_69 = 229, + K_WORLD_70 = 230, + K_WORLD_71 = 231, + K_WORLD_72 = 232, + K_WORLD_73 = 233, + K_WORLD_74 = 234, + K_WORLD_75 = 235, + K_WORLD_76 = 236, + K_WORLD_77 = 237, + K_WORLD_78 = 238, + K_WORLD_79 = 239, + K_WORLD_80 = 240, + K_WORLD_81 = 241, + K_WORLD_82 = 242, + K_WORLD_83 = 243, + K_WORLD_84 = 244, + K_WORLD_85 = 245, + K_WORLD_86 = 246, + K_WORLD_87 = 247, + K_WORLD_88 = 248, + K_WORLD_89 = 249, + K_WORLD_90 = 250, + K_WORLD_91 = 251, + K_WORLD_92 = 252, + K_WORLD_93 = 253, + K_WORLD_94 = 254, + K_WORLD_95 = 255, /* 0xFF */ + /*@}*/ + + /** @name Numeric keypad */ + /*@{*/ + K_KP0 = 256, + K_KP1 = 257, + K_KP2 = 258, + K_KP3 = 259, + K_KP4 = 260, + K_KP5 = 261, + K_KP6 = 262, + K_KP7 = 263, + K_KP8 = 264, + K_KP9 = 265, + K_KP_PERIOD = 266, + K_KP_DIVIDE = 267, + K_KP_MULTIPLY = 268, + K_KP_MINUS = 269, + K_KP_PLUS = 270, + K_KP_ENTER = 271, + K_KP_EQUALS = 272, + /*@}*/ + + /** @name Arrows + Home/End pad */ + /*@{*/ + K_UP = 273, + K_DOWN = 274, + K_RIGHT = 275, + K_LEFT = 276, + K_INSERT = 277, + K_HOME = 278, + K_END = 279, + K_PAGEUP = 280, + K_PAGEDOWN = 281, + /*@}*/ + + /** @name Function keys */ + /*@{*/ + K_F1 = 282, + K_F2 = 283, + K_F3 = 284, + K_F4 = 285, + K_F5 = 286, + K_F6 = 287, + K_F7 = 288, + K_F8 = 289, + K_F9 = 290, + K_F10 = 291, + K_F11 = 292, + K_F12 = 293, + K_F13 = 294, + K_F14 = 295, + K_F15 = 296, + /*@}*/ + + /** @name Key state modifier keys */ + /*@{*/ + K_NUMLOCK = 300, + K_CAPSLOCK = 301, + K_SCROLLOCK = 302, + K_RSHIFT = 303, + K_LSHIFT = 304, + K_RCTRL = 305, + K_LCTRL = 306, + K_RALT = 307, + K_LALT = 308, + K_RMETA = 309, + K_LMETA = 310, + K_LSUPER = 311, /**< Left "Windows" key */ + K_RSUPER = 312, /**< Right "Windows" key */ + K_MODE = 313, /**< "Alt Gr" key */ + K_COMPOSE = 314, /**< Multi-key compose key */ + /*@}*/ + + /** @name Miscellaneous function keys */ + /*@{*/ + K_HELP = 315, + K_PRINT = 316, + K_SYSREQ = 317, + K_BREAK = 318, + K_MENU = 319, + K_POWER = 320, /**< Power Macintosh power key */ + K_EURO = 321, /**< Some european keyboards */ + K_UNDO = 322, /**< Atari keyboard has Undo */ + /*@}*/ + + /* Add any other keys here */ + + K_LAST + }; + + /** Enumeration of valid key mods (possibly OR'd together) */ + enum Mod { + KMOD_NONE = 0x0000, + KMOD_LSHIFT= 0x0001, + KMOD_RSHIFT= 0x0002, + KMOD_LCTRL = 0x0040, + KMOD_RCTRL = 0x0080, + KMOD_LALT = 0x0100, + KMOD_RALT = 0x0200, + KMOD_LMETA = 0x0400, + KMOD_RMETA = 0x0800, + KMOD_NUM = 0x1000, + KMOD_CAPS = 0x2000, + KMOD_MODE = 0x4000, + KMOD_RESERVED = 0x8000, + KMOD_CTRL = (KMOD_LCTRL|KMOD_RCTRL), + KMOD_SHIFT = (KMOD_LSHIFT|KMOD_RSHIFT), + KMOD_ALT = (KMOD_LALT|KMOD_RALT), + KMOD_META = (KMOD_LMETA|KMOD_RMETA) + }; +} \ No newline at end of file