src/events/SDL_keyboard.c
changeset 2303 d87417504c75
parent 2300 c97ad1abe05b
child 2305 fbe8ff44c519
equal deleted inserted replaced
2302:7ae1c419b626 2303:d87417504c75
    25 
    25 
    26 #include "SDL_timer.h"
    26 #include "SDL_timer.h"
    27 #include "SDL_events.h"
    27 #include "SDL_events.h"
    28 #include "SDL_events_c.h"
    28 #include "SDL_events_c.h"
    29 #include "SDL_sysevents.h"
    29 #include "SDL_sysevents.h"
    30 #include "SDL_keynames.h"
       
    31 
    30 
    32 
    31 
    33 /* Global keyboard information */
    32 /* Global keyboard information */
    34 int SDL_TranslateUNICODE = 0;
       
    35 static int SDL_num_keyboards;
    33 static int SDL_num_keyboards;
    36 static int SDL_current_keyboard;
    34 static int SDL_current_keyboard;
    37 static SDL_Keyboard **SDL_keyboards;
    35 static SDL_Keyboard **SDL_keyboards;
    38 
    36 
       
    37 static SDLKey SDL_default_keymap[SDL_NUM_SCANCODES] = {
       
    38     0, 0, 0, 0,
       
    39     'a',
       
    40     'b',
       
    41     'c',
       
    42     'd',
       
    43     'e',
       
    44     'f',
       
    45     'g',
       
    46     'h',
       
    47     'i',
       
    48     'j',
       
    49     'k',
       
    50     'l',
       
    51     'm',
       
    52     'n',
       
    53     'o',
       
    54     'p',
       
    55     'q',
       
    56     'r',
       
    57     's',
       
    58     't',
       
    59     'u',
       
    60     'v',
       
    61     'w',
       
    62     'x',
       
    63     'y',
       
    64     'z',
       
    65     '1',
       
    66     '2',
       
    67     '3',
       
    68     '4',
       
    69     '5',
       
    70     '6',
       
    71     '7',
       
    72     '8',
       
    73     '9',
       
    74     '0',
       
    75     SDLK_RETURN,
       
    76     SDLK_ESCAPE,
       
    77     SDLK_BACKSPACE,
       
    78     SDLK_TAB,
       
    79     SDLK_SPACE,
       
    80     '-',
       
    81     '=',
       
    82     '[',
       
    83     ']',
       
    84     '\\',
       
    85     '#',
       
    86     ';',
       
    87     '\'',
       
    88     '`',
       
    89     ',',
       
    90     '.',
       
    91     '/',
       
    92     SDLK_CAPSLOCK,
       
    93     SDLK_F1,
       
    94     SDLK_F2,
       
    95     SDLK_F3,
       
    96     SDLK_F4,
       
    97     SDLK_F5,
       
    98     SDLK_F6,
       
    99     SDLK_F7,
       
   100     SDLK_F8,
       
   101     SDLK_F9,
       
   102     SDLK_F10,
       
   103     SDLK_F11,
       
   104     SDLK_F12,
       
   105     SDLK_PRINTSCREEN,
       
   106     SDLK_SCROLLLOCK,
       
   107     SDLK_PAUSE,
       
   108     SDLK_INSERT,
       
   109     SDLK_HOME,
       
   110     SDLK_PAGEUP,
       
   111     SDLK_DELETE,
       
   112     SDLK_END,
       
   113     SDLK_PAGEDOWN,
       
   114     SDLK_RIGHT,
       
   115     SDLK_LEFT,
       
   116     SDLK_DOWN,
       
   117     SDLK_UP,
       
   118     SDLK_NUMLOCKCLEAR,
       
   119     SDLK_KP_DIVIDE,
       
   120     SDLK_KP_MULTIPLY,
       
   121     SDLK_KP_MINUS,
       
   122     SDLK_KP_PLUS,
       
   123     SDLK_KP_ENTER,
       
   124     SDLK_KP_1,
       
   125     SDLK_KP_2,
       
   126     SDLK_KP_3,
       
   127     SDLK_KP_4,
       
   128     SDLK_KP_5,
       
   129     SDLK_KP_6,
       
   130     SDLK_KP_7,
       
   131     SDLK_KP_8,
       
   132     SDLK_KP_9,
       
   133     SDLK_KP_0,
       
   134     SDLK_KP_PERIOD,
       
   135     0,
       
   136     SDLK_APPLICATION,
       
   137     SDLK_POWER,
       
   138     SDLK_KP_EQUALS,
       
   139     SDLK_F13,
       
   140     SDLK_F14,
       
   141     SDLK_F15,
       
   142     SDLK_F16,
       
   143     SDLK_F17,
       
   144     SDLK_F18,
       
   145     SDLK_F19,
       
   146     SDLK_F20,
       
   147     SDLK_F21,
       
   148     SDLK_F22,
       
   149     SDLK_F23,
       
   150     SDLK_F24,
       
   151     SDLK_EXECUTE,
       
   152     SDLK_HELP,
       
   153     SDLK_MENU,
       
   154     SDLK_SELECT,
       
   155     SDLK_STOP,
       
   156     SDLK_AGAIN,
       
   157     SDLK_UNDO,
       
   158     SDLK_CUT,
       
   159     SDLK_COPY,
       
   160     SDLK_PASTE,
       
   161     SDLK_FIND,
       
   162     SDLK_MUTE,
       
   163     SDLK_VOLUMEUP,
       
   164     SDLK_VOLUMEDOWN,
       
   165     0, 0, 0,
       
   166     SDLK_KP_COMMA,
       
   167     SDLK_KP_EQUALSAS400,
       
   168     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       
   169     SDLK_ALTERASE,
       
   170     SDLK_SYSREQ,
       
   171     SDLK_CANCEL,
       
   172     SDLK_CLEAR,
       
   173     SDLK_PRIOR,
       
   174     SDLK_RETURN2,
       
   175     SDLK_SEPARATOR,
       
   176     SDLK_OUT,
       
   177     SDLK_OPER,
       
   178     SDLK_CLEARAGAIN,
       
   179     SDLK_CRSEL,
       
   180     SDLK_EXSEL,
       
   181     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       
   182     SDLK_KP_00,
       
   183     SDLK_KP_000,
       
   184     SDLK_THOUSANDSSEPARATOR,
       
   185     SDLK_DECIMALSEPARATOR,
       
   186     SDLK_CURRENCYUNIT,
       
   187     SDLK_CURRENCYSUBUNIT,
       
   188     SDLK_KP_LEFTPAREN,
       
   189     SDLK_KP_RIGHTPAREN,
       
   190     SDLK_KP_LEFTBRACE,
       
   191     SDLK_KP_RIGHTBRACE,
       
   192     SDLK_KP_TAB,
       
   193     SDLK_KP_BACKSPACE,
       
   194     SDLK_KP_A,
       
   195     SDLK_KP_B,
       
   196     SDLK_KP_C,
       
   197     SDLK_KP_D,
       
   198     SDLK_KP_E,
       
   199     SDLK_KP_F,
       
   200     SDLK_KP_XOR,
       
   201     SDLK_KP_POWER,
       
   202     SDLK_KP_PERCENT,
       
   203     SDLK_KP_LESS,
       
   204     SDLK_KP_GREATER,
       
   205     SDLK_KP_AMPERSAND,
       
   206     SDLK_KP_DBLAMPERSAND,
       
   207     SDLK_KP_VERTICALBAR,
       
   208     SDLK_KP_DBLVERTICALBAR,
       
   209     SDLK_KP_COLON,
       
   210     SDLK_KP_HASH,
       
   211     SDLK_KP_SPACE,
       
   212     SDLK_KP_AT,
       
   213     SDLK_KP_EXCLAM,
       
   214     SDLK_KP_MEMSTORE,
       
   215     SDLK_KP_MEMRECALL,
       
   216     SDLK_KP_MEMCLEAR,
       
   217     SDLK_KP_MEMADD,
       
   218     SDLK_KP_MEMSUBTRACT,
       
   219     SDLK_KP_MEMMULTIPLY,
       
   220     SDLK_KP_MEMDIVIDE,
       
   221     SDLK_KP_PLUSMINUS,
       
   222     SDLK_KP_CLEAR,
       
   223     SDLK_KP_CLEARENTRY,
       
   224     SDLK_KP_BINARY,
       
   225     SDLK_KP_OCTAL,
       
   226     SDLK_KP_DECIMAL,
       
   227     SDLK_KP_HEXADECIMAL,
       
   228     0, 0,
       
   229     SDLK_LCTRL,
       
   230     SDLK_LSHIFT,
       
   231     SDLK_LALT,
       
   232     SDLK_LGUI,
       
   233     SDLK_RCTRL,
       
   234     SDLK_RSHIFT,
       
   235     SDLK_RALT,
       
   236     SDLK_RGUI,
       
   237     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       
   238     SDLK_MODE,
       
   239     SDLK_AUDIONEXT,
       
   240     SDLK_AUDIOPREV,
       
   241     SDLK_AUDIOSTOP,
       
   242     SDLK_AUDIOPLAY,
       
   243     SDLK_AUDIOMUTE,
       
   244     SDLK_MEDIASELECT,
       
   245     SDLK_MAIL,
       
   246     SDLK_CALCULATOR,
       
   247     SDLK_COMPUTER,
       
   248     SDLK_AC_SEARCH,
       
   249     SDLK_AC_HOME,
       
   250     SDLK_AC_BACK,
       
   251     SDLK_AC_FORWARD,
       
   252     SDLK_AC_STOP,
       
   253     SDLK_AC_REFRESH,
       
   254     SDLK_AC_BOOKMARKS,
       
   255     SDLK_BRIGHTNESSDOWN,
       
   256     SDLK_BRIGHTNESSUP,
       
   257     SDLK_DISPLAYSWITCH,
       
   258     SDLK_KBDILLUMTOGGLE,
       
   259     SDLK_KBDILLUMDOWN,
       
   260     SDLK_KBDILLUMUP,
       
   261     SDLK_EJECT,
       
   262     SDLK_SLEEP,
       
   263 };
       
   264 
       
   265 static const char *SDL_scancode_names[SDL_NUM_SCANCODES] = {
       
   266     NULL, NULL, NULL, NULL,
       
   267     "A",
       
   268     "B",
       
   269     "C",
       
   270     "D",
       
   271     "E",
       
   272     "F",
       
   273     "G",
       
   274     "H",
       
   275     "I",
       
   276     "J",
       
   277     "K",
       
   278     "L",
       
   279     "M",
       
   280     "N",
       
   281     "O",
       
   282     "P",
       
   283     "Q",
       
   284     "R",
       
   285     "S",
       
   286     "T",
       
   287     "U",
       
   288     "V",
       
   289     "W",
       
   290     "X",
       
   291     "Y",
       
   292     "Z",
       
   293     "1",
       
   294     "2",
       
   295     "3",
       
   296     "4",
       
   297     "5",
       
   298     "6",
       
   299     "7",
       
   300     "8",
       
   301     "9",
       
   302     "0",
       
   303     "Return",
       
   304     "Escape",
       
   305     "Backspace",
       
   306     "Tab",
       
   307     "Space",
       
   308     "-",
       
   309     "=",
       
   310     "[",
       
   311     "]",
       
   312     "\\",
       
   313     "#",
       
   314     ";",
       
   315     "'",
       
   316     "`",
       
   317     ",",
       
   318     ".",
       
   319     "/",
       
   320     "CapsLock",
       
   321     "F1",
       
   322     "F2",
       
   323     "F3",
       
   324     "F4",
       
   325     "F5",
       
   326     "F6",
       
   327     "F7",
       
   328     "F8",
       
   329     "F9",
       
   330     "F10",
       
   331     "F11",
       
   332     "F12",
       
   333     "PrintScreen",
       
   334     "ScrollLock",
       
   335     "Pause",
       
   336     "Insert",
       
   337     "Home",
       
   338     "PageUp",
       
   339     "Delete",
       
   340     "End",
       
   341     "PageDown",
       
   342     "Right",
       
   343     "Left",
       
   344     "Down",
       
   345     "Up",
       
   346     "Numlock",
       
   347     "Keypad /",
       
   348     "Keypad *",
       
   349     "Keypad -",
       
   350     "Keypad +",
       
   351     "Keypad Enter",
       
   352     "Keypad 1",
       
   353     "Keypad 2",
       
   354     "Keypad 3",
       
   355     "Keypad 4",
       
   356     "Keypad 5",
       
   357     "Keypad 6",
       
   358     "Keypad 7",
       
   359     "Keypad 8",
       
   360     "Keypad 9",
       
   361     "Keypad 0",
       
   362     "Keypad .",
       
   363     NULL,
       
   364     "Application",
       
   365     "Power",
       
   366     "Keypad =",
       
   367     "F13",
       
   368     "F14",
       
   369     "F15",
       
   370     "F16",
       
   371     "F17",
       
   372     "F18",
       
   373     "F19",
       
   374     "F20",
       
   375     "F21",
       
   376     "F22",
       
   377     "F23",
       
   378     "F24",
       
   379     "Execute",
       
   380     "Help",
       
   381     "Menu",
       
   382     "Select",
       
   383     "Stop",
       
   384     "Again",
       
   385     "Undo",
       
   386     "Cut",
       
   387     "Copy",
       
   388     "Paste",
       
   389     "Find",
       
   390     "Mute",
       
   391     "VolumeUp",
       
   392     "VolumeDown",
       
   393     NULL, NULL, NULL,
       
   394     "Keypad ,",
       
   395     "Keypad = (AS400)",
       
   396     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
       
   397     NULL, NULL, NULL, NULL, NULL, NULL,
       
   398     "AltErase",
       
   399     "SysReq",
       
   400     "Cancel",
       
   401     "Clear",
       
   402     "Prior",
       
   403     "Return",
       
   404     "Separator",
       
   405     "Out",
       
   406     "Oper",
       
   407     "Clear / Again",
       
   408     "CrSel",
       
   409     "ExSel",
       
   410     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
       
   411     "Keypad 00",
       
   412     "Keypad 000",
       
   413     "ThousandsSeparator",
       
   414     "DecimalSeparator",
       
   415     "CurrencyUnit",
       
   416     "CurrencySubUnit",
       
   417     "Keypad (",
       
   418     "Keypad )",
       
   419     "Keypad {",
       
   420     "Keypad }",
       
   421     "Keypad Tab",
       
   422     "Keypad Backspace",
       
   423     "Keypad A",
       
   424     "Keypad B",
       
   425     "Keypad C",
       
   426     "Keypad D",
       
   427     "Keypad E",
       
   428     "Keypad F",
       
   429     "Keypad XOR",
       
   430     "Keypad ^",
       
   431     "Keypad %",
       
   432     "Keypad <",
       
   433     "Keypad >",
       
   434     "Keypad &",
       
   435     "Keypad &&",
       
   436     "Keypad |",
       
   437     "Keypad ||",
       
   438     "Keypad :",
       
   439     "Keypad #",
       
   440     "Keypad Space",
       
   441     "Keypad @",
       
   442     "Keypad !",
       
   443     "Keypad MemStore",
       
   444     "Keypad MemRecall",
       
   445     "Keypad MemClear",
       
   446     "Keypad MemAdd",
       
   447     "Keypad MemSubtract",
       
   448     "Keypad MemMultiply",
       
   449     "Keypad MemDivide",
       
   450     "Keypad +/-",
       
   451     "Keypad Clear",
       
   452     "Keypad ClearEntry",
       
   453     "Keypad Binary",
       
   454     "Keypad Octal",
       
   455     "Keypad Decimal",
       
   456     "Keypad Hexadecimal",
       
   457     NULL, NULL,
       
   458     "Left Ctrl",
       
   459     "Left Shift",
       
   460     "Left Alt",
       
   461     "Left GUI",
       
   462     "Right Ctrl",
       
   463     "Right Shift",
       
   464     "Right Alt",
       
   465     "Right GUI",
       
   466     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
       
   467     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
       
   468     NULL,
       
   469     "ModeSwitch",
       
   470     "AudioNext",
       
   471     "AudioPrev",
       
   472     "AudioStop",
       
   473     "AudioPlay",
       
   474     "AudioMute",
       
   475     "MediaSelect",
       
   476     "Mail",
       
   477     "Calculator",
       
   478     "Computer",
       
   479     "AC Search",
       
   480     "AC Home",
       
   481     "AC Back",
       
   482     "AC Forward",
       
   483     "AC Stop",
       
   484     "AC Refresh",
       
   485     "AC Bookmarks",
       
   486     "BrightnessDown",
       
   487     "BrightnessUp",
       
   488     "DisplaySwitch",
       
   489     "KBDIllumToggle",
       
   490     "KBDIllumDown",
       
   491     "KBDIllumUp",
       
   492     "Eject",
       
   493     "Sleep",
       
   494 };
       
   495 
    39 /* Taken from SDL_iconv() */
   496 /* Taken from SDL_iconv() */
    40 char *
   497 static char *
    41 SDL_Ucs4ToUtf8(Uint32 ch, char *dst)
   498 SDL_UCS4ToUTF8(Uint32 ch, char *dst)
    42 {
   499 {
    43     Uint8 *p = (Uint8 *) dst;
   500     Uint8 *p = (Uint8 *) dst;
    44     if (ch <= 0x7F) {
   501     if (ch <= 0x7F) {
    45         *p = (Uint8) ch;
   502         *p = (Uint8) ch;
    46         ++dst;
   503         ++dst;
    80 
   537 
    81 /* Public functions */
   538 /* Public functions */
    82 int
   539 int
    83 SDL_KeyboardInit(void)
   540 SDL_KeyboardInit(void)
    84 {
   541 {
    85     /* Set default mode of UNICODE translation */
       
    86     SDL_EnableUNICODE(DEFAULT_UNICODE_TRANSLATION);
       
    87 
       
    88     return (0);
   542     return (0);
    89 }
   543 }
    90 
   544 
    91 SDL_Keyboard *
   545 SDL_Keyboard *
    92 SDL_GetKeyboard(int index)
   546 SDL_GetKeyboard(int index)
   146 
   600 
   147 void
   601 void
   148 SDL_ResetKeyboard(int index)
   602 SDL_ResetKeyboard(int index)
   149 {
   603 {
   150     SDL_Keyboard *keyboard = SDL_GetKeyboard(index);
   604     SDL_Keyboard *keyboard = SDL_GetKeyboard(index);
   151     int key;
   605     SDL_scancode scancode;
   152 
   606 
   153     if (!keyboard) {
   607     if (!keyboard) {
   154         return;
   608         return;
   155     }
   609     }
   156 
   610 
   157     for (key = SDLK_FIRST; key < SDLK_LAST; ++key) {
   611     for (scancode = 0; scancode < SDL_NUM_SCANCODES; ++scancode) {
   158         if (keyboard->keystate[key] == SDL_PRESSED) {
   612         if (keyboard->keystate[scancode] == SDL_PRESSED) {
   159             SDL_SendKeyboardKey(index, SDL_RELEASED, 0,
   613             SDL_SendKeyboardKey(index, SDL_RELEASED, scancode);
   160                                 key | SDL_KEY_CAN_BE_PHYSICAL_BIT);
       
   161         }
   614         }
   162     }
   615     }
   163 }
   616 }
   164 
   617 
   165 void
   618 void
   166 SDL_KeyboardQuit(void)
   619 SDL_GetDefaultKeymap(SDLKey * keymap)
   167 {
   620 {
   168     int i;
   621     SDL_memcpy(keymap, SDL_default_keymap, sizeof(SDL_default_keymap));
   169 
       
   170     for (i = 0; i < SDL_num_keyboards; ++i) {
       
   171         SDL_DelKeyboard(i);
       
   172     }
       
   173     SDL_num_keyboards = 0;
       
   174     SDL_current_keyboard = 0;
       
   175 
       
   176     if (SDL_keyboards) {
       
   177         SDL_free(SDL_keyboards);
       
   178         SDL_keyboards = NULL;
       
   179     }
       
   180 }
       
   181 
       
   182 int
       
   183 SDL_GetNumKeyboards(void)
       
   184 {
       
   185     return SDL_num_keyboards;
       
   186 }
       
   187 
       
   188 int
       
   189 SDL_SelectKeyboard(int index)
       
   190 {
       
   191     if (index >= 0 && index < SDL_num_keyboards) {
       
   192         SDL_current_keyboard = index;
       
   193     }
       
   194     return SDL_current_keyboard;
       
   195 }
       
   196 
       
   197 int
       
   198 SDL_EnableUNICODE(int enable)
       
   199 {
       
   200     int old_mode;
       
   201 
       
   202     old_mode = SDL_TranslateUNICODE;
       
   203     if (enable >= 0) {
       
   204         SDL_TranslateUNICODE = enable;
       
   205     }
       
   206     return (old_mode);
       
   207 }
       
   208 
       
   209 Uint8 *
       
   210 SDL_GetKeyState(int *numkeys)
       
   211 {
       
   212     SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard);
       
   213 
       
   214     if (numkeys != (int *) 0) {
       
   215         *numkeys = SDLK_LAST;
       
   216     }
       
   217 
       
   218     if (!keyboard) {
       
   219         return NULL;
       
   220     }
       
   221     return keyboard->keystate;
       
   222 }
       
   223 
       
   224 SDLMod
       
   225 SDL_GetModState(void)
       
   226 {
       
   227     SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard);
       
   228 
       
   229     if (!keyboard) {
       
   230         return KMOD_NONE;
       
   231     }
       
   232     return keyboard->modstate;
       
   233 }
   622 }
   234 
   623 
   235 void
   624 void
   236 SDL_SetModState(SDLMod modstate)
   625 SDL_SetKeymap(int index, int start, SDLKey * keys, int length)
   237 {
   626 {
   238     SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard);
   627     SDL_Keyboard *keyboard = SDL_GetKeyboard(index);
   239 
   628 
   240     if (!keyboard) {
   629     if (!keyboard) {
   241         return;
   630         return;
   242     }
   631     }
   243     keyboard->modstate = modstate;
   632 
   244 }
   633     if (start < 0 || start + length > SDL_NUM_SCANCODES) {
   245 
   634         return;
   246 SDLKey
   635     }
   247 SDL_GetLayoutKey(SDLKey physicalKey)
   636 
   248 {
   637     SDL_memcpy(&keyboard->keymap[start], keys, sizeof(*keys) * length);
   249     SDL_VideoDevice *_this = SDL_GetVideoDevice();
       
   250     if (_this && _this->GetLayoutKey) {
       
   251         return _this->GetLayoutKey(_this, physicalKey)
       
   252             | (physicalKey & SDL_KEY_KEYPAD_BIT);
       
   253     } else {
       
   254         return physicalKey;
       
   255     }
       
   256 }
       
   257 
       
   258 const char *
       
   259 SDL_GetKeyName(SDLKey layoutKey)
       
   260 {
       
   261     const char *keyname = NULL;
       
   262 
       
   263     if ((layoutKey & SDL_KEY_LAYOUT_SPECIAL_BIT) != 0) {
       
   264         SDL_VideoDevice *_this = SDL_GetVideoDevice();
       
   265         if (_this && _this->GetSpecialKeyName) {
       
   266             keyname = _this->GetSpecialKeyName(_this, layoutKey);
       
   267         }
       
   268     } else if ((layoutKey & SDL_KEY_CAN_BE_PHYSICAL_BIT) == 0) {
       
   269         /* SDLK_INDEX(layoutKey) is the unicode code point of the
       
   270            character generated by the key */
       
   271         static char buffer[9];  /* 6 (maximal UTF-8 char length) + 2 ([] for keypad) + 1 (null teminator) */
       
   272         char *bufferPtr = &buffer[1];
       
   273         Uint32 codepoint = SDLK_INDEX(layoutKey);
       
   274 
       
   275         /* Unaccented letter keys on latin keyboards are normally
       
   276            labeled in upper case (and probably on others like Greek or
       
   277            Cyrillic too, so if you happen to know for sure, please
       
   278            adapt this). */
       
   279         if (codepoint >= 'a' && codepoint <= 'z') {
       
   280             codepoint -= 32;
       
   281         }
       
   282 
       
   283         bufferPtr = SDL_Ucs4ToUtf8(codepoint, bufferPtr);
       
   284         *bufferPtr = '\0';
       
   285 
       
   286         if ((layoutKey & SDL_KEY_KEYPAD_BIT) != 0) {
       
   287             buffer[0] = '[';
       
   288             *bufferPtr++ = ']';
       
   289             *bufferPtr = '\0';
       
   290             keyname = buffer;
       
   291         } else {
       
   292             keyname = &buffer[1];
       
   293         }
       
   294     } else {
       
   295         /* SDLK_INDEX(layoutKey) is a physical key number */
       
   296         if (SDLK_INDEX(layoutKey) < SDL_arraysize(SDL_keynames)) {
       
   297             keyname = SDL_keynames[SDLK_INDEX(layoutKey)];
       
   298         }
       
   299     }
       
   300 
       
   301     if (keyname == NULL) {
       
   302         keyname = SDL_keynames[SDLK_INDEX(SDLK_UNKNOWN)];
       
   303     }
       
   304 
       
   305     return keyname;
       
   306 }
   638 }
   307 
   639 
   308 void
   640 void
   309 SDL_SetKeyName(SDLKey physicalKey, const char *name)
   641 SDL_SetScancodeName(SDL_scancode scancode, const char *name)
   310 {
   642 {
   311     physicalKey = SDLK_INDEX(physicalKey);
   643     SDL_scancode_names[scancode] = name;
   312     if (physicalKey < SDL_arraysize(SDL_keynames)) {
       
   313         SDL_keynames[physicalKey] = name;
       
   314     }
       
   315 }
   644 }
   316 
   645 
   317 void
   646 void
   318 SDL_SetKeyboardFocus(int index, SDL_WindowID windowID)
   647 SDL_SetKeyboardFocus(int index, SDL_WindowID windowID)
   319 {
   648 {
   364         }
   693         }
   365     }
   694     }
   366 }
   695 }
   367 
   696 
   368 int
   697 int
   369 SDL_SendKeyboardKey(int index, Uint8 state, Uint8 scancode,
   698 SDL_SendKeyboardKey(int index, Uint8 state, SDL_scancode scancode)
   370                     SDLKey physicalKey)
       
   371 {
   699 {
   372     SDL_Keyboard *keyboard = SDL_GetKeyboard(index);
   700     SDL_Keyboard *keyboard = SDL_GetKeyboard(index);
   373     int posted;
   701     int posted;
   374     Uint16 modstate;
   702     Uint16 modstate;
   375     Uint8 type;
   703     Uint8 type;
   376 
   704 
   377     if (!keyboard || physicalKey == SDLK_NONE) {
   705     if (!keyboard || !scancode) {
   378         return 0;
   706         return 0;
   379     }
   707     }
   380 #if 0
   708 #if 0
   381     printf("The '%s' key has been %s\n", SDL_GetKeyName(physicalKey),
   709     printf("The '%s' key has been %s\n", SDL_GetScancodeName(scancode),
   382            state == SDL_PRESSED ? "pressed" : "released");
   710            state == SDL_PRESSED ? "pressed" : "released");
   383 #endif
   711 #endif
   384     if (state == SDL_PRESSED) {
   712     if (state == SDL_PRESSED) {
   385         modstate = keyboard->modstate;
   713         modstate = keyboard->modstate;
   386         switch (physicalKey) {
   714         switch (scancode) {
   387         case SDLK_UNKNOWN:
   715         case SDL_SCANCODE_NUMLOCKCLEAR:
   388             break;
       
   389         case SDLK_KP_NUMLOCKCLEAR:
       
   390             keyboard->modstate ^= KMOD_NUM;
   716             keyboard->modstate ^= KMOD_NUM;
   391             break;
   717             break;
   392         case SDLK_CAPSLOCK:
   718         case SDL_SCANCODE_CAPSLOCK:
   393             keyboard->modstate ^= KMOD_CAPS;
   719             keyboard->modstate ^= KMOD_CAPS;
   394             break;
   720             break;
   395         case SDLK_LCTRL:
   721         case SDL_SCANCODE_LCTRL:
   396             keyboard->modstate |= KMOD_LCTRL;
   722             keyboard->modstate |= KMOD_LCTRL;
   397             break;
   723             break;
   398         case SDLK_RCTRL:
   724         case SDL_SCANCODE_RCTRL:
   399             keyboard->modstate |= KMOD_RCTRL;
   725             keyboard->modstate |= KMOD_RCTRL;
   400             break;
   726             break;
   401         case SDLK_LSHIFT:
   727         case SDL_SCANCODE_LSHIFT:
   402             keyboard->modstate |= KMOD_LSHIFT;
   728             keyboard->modstate |= KMOD_LSHIFT;
   403             break;
   729             break;
   404         case SDLK_RSHIFT:
   730         case SDL_SCANCODE_RSHIFT:
   405             keyboard->modstate |= KMOD_RSHIFT;
   731             keyboard->modstate |= KMOD_RSHIFT;
   406             break;
   732             break;
   407         case SDLK_LALT:
   733         case SDL_SCANCODE_LALT:
   408             keyboard->modstate |= KMOD_LALT;
   734             keyboard->modstate |= KMOD_LALT;
   409             break;
   735             break;
   410         case SDLK_RALT:
   736         case SDL_SCANCODE_RALT:
   411             keyboard->modstate |= KMOD_RALT;
   737             keyboard->modstate |= KMOD_RALT;
   412             break;
   738             break;
   413         case SDLK_LMETA:
   739         case SDL_SCANCODE_LGUI:
   414             keyboard->modstate |= KMOD_LMETA;
   740             keyboard->modstate |= KMOD_LGUI;
   415             break;
   741             break;
   416         case SDLK_RMETA:
   742         case SDL_SCANCODE_RGUI:
   417             keyboard->modstate |= KMOD_RMETA;
   743             keyboard->modstate |= KMOD_RGUI;
   418             break;
   744             break;
   419         case SDLK_MODE:
   745         case SDL_SCANCODE_MODE:
   420             keyboard->modstate |= KMOD_MODE;
   746             keyboard->modstate |= KMOD_MODE;
   421             break;
   747             break;
   422         default:
   748         default:
   423             break;
   749             break;
   424         }
   750         }
   425     } else {
   751     } else {
   426         switch (physicalKey) {
   752         switch (scancode) {
   427         case SDLK_UNKNOWN:
   753         case SDL_SCANCODE_NUMLOCKCLEAR:
   428             break;
   754         case SDL_SCANCODE_CAPSLOCK:
   429         case SDLK_KP_NUMLOCKCLEAR:
   755             break;
   430         case SDLK_CAPSLOCK:
   756         case SDL_SCANCODE_LCTRL:
   431             break;
       
   432         case SDLK_LCTRL:
       
   433             keyboard->modstate &= ~KMOD_LCTRL;
   757             keyboard->modstate &= ~KMOD_LCTRL;
   434             break;
   758             break;
   435         case SDLK_RCTRL:
   759         case SDL_SCANCODE_RCTRL:
   436             keyboard->modstate &= ~KMOD_RCTRL;
   760             keyboard->modstate &= ~KMOD_RCTRL;
   437             break;
   761             break;
   438         case SDLK_LSHIFT:
   762         case SDL_SCANCODE_LSHIFT:
   439             keyboard->modstate &= ~KMOD_LSHIFT;
   763             keyboard->modstate &= ~KMOD_LSHIFT;
   440             break;
   764             break;
   441         case SDLK_RSHIFT:
   765         case SDL_SCANCODE_RSHIFT:
   442             keyboard->modstate &= ~KMOD_RSHIFT;
   766             keyboard->modstate &= ~KMOD_RSHIFT;
   443             break;
   767             break;
   444         case SDLK_LALT:
   768         case SDL_SCANCODE_LALT:
   445             keyboard->modstate &= ~KMOD_LALT;
   769             keyboard->modstate &= ~KMOD_LALT;
   446             break;
   770             break;
   447         case SDLK_RALT:
   771         case SDL_SCANCODE_RALT:
   448             keyboard->modstate &= ~KMOD_RALT;
   772             keyboard->modstate &= ~KMOD_RALT;
   449             break;
   773             break;
   450         case SDLK_LMETA:
   774         case SDL_SCANCODE_LGUI:
   451             keyboard->modstate &= ~KMOD_LMETA;
   775             keyboard->modstate &= ~KMOD_LGUI;
   452             break;
   776             break;
   453         case SDLK_RMETA:
   777         case SDL_SCANCODE_RGUI:
   454             keyboard->modstate &= ~KMOD_RMETA;
   778             keyboard->modstate &= ~KMOD_RGUI;
   455             break;
   779             break;
   456         case SDLK_MODE:
   780         case SDL_SCANCODE_MODE:
   457             keyboard->modstate &= ~KMOD_MODE;
   781             keyboard->modstate &= ~KMOD_MODE;
   458             break;
   782             break;
   459         default:
   783         default:
   460             break;
   784             break;
   461         }
   785         }
   473     default:
   797     default:
   474         /* Invalid state -- bail */
   798         /* Invalid state -- bail */
   475         return 0;
   799         return 0;
   476     }
   800     }
   477 
   801 
   478     if (physicalKey != SDLK_UNKNOWN) {
   802     /* Drop events that don't change state */
   479         /* Drop events that don't change state */
   803     if (keyboard->keystate[scancode] == state) {
   480         if (keyboard->keystate[SDLK_INDEX(physicalKey)] == state) {
       
   481 #if 0
   804 #if 0
   482             printf("Keyboard event didn't change state - dropped!\n");
   805         printf("Keyboard event didn't change state - dropped!\n");
   483 #endif
   806 #endif
   484             return 0;
   807         return 0;
   485         }
   808     }
   486 
   809 
   487         /* Update internal keyboard state */
   810     /* Update internal keyboard state */
   488         keyboard->keystate[SDLK_INDEX(physicalKey)] = state;
   811     keyboard->keystate[scancode] = state;
   489     }
       
   490 
   812 
   491     /* Post the event, if desired */
   813     /* Post the event, if desired */
   492     posted = 0;
   814     posted = 0;
   493     if (SDL_ProcessEvents[type] == SDL_ENABLE) {
   815     if (SDL_ProcessEvents[type] == SDL_ENABLE) {
   494         SDL_Event event;
   816         SDL_Event event;
   495         event.key.type = type;
   817         event.key.type = type;
   496         event.key.which = (Uint8) index;
   818         event.key.which = (Uint8) index;
   497         event.key.state = state;
   819         event.key.state = state;
   498         event.key.keysym.scancode = scancode;
   820         event.key.keysym.scancode = scancode;
   499         event.key.keysym.sym = physicalKey;
   821         event.key.keysym.sym = keyboard->keymap[scancode];
   500         event.key.keysym.mod = modstate;
   822         event.key.keysym.mod = modstate;
   501         event.key.keysym.unicode = 0;
   823         event.key.keysym.unicode = 0;
   502         event.key.windowID = keyboard->focus;
   824         event.key.windowID = keyboard->focus;
   503         posted = (SDL_PushEvent(&event) > 0);
   825         posted = (SDL_PushEvent(&event) > 0);
   504     }
   826     }
   526         posted = (SDL_PushEvent(&event) > 0);
   848         posted = (SDL_PushEvent(&event) > 0);
   527     }
   849     }
   528     return (posted);
   850     return (posted);
   529 }
   851 }
   530 
   852 
       
   853 void
       
   854 SDL_KeyboardQuit(void)
       
   855 {
       
   856     int i;
       
   857 
       
   858     for (i = 0; i < SDL_num_keyboards; ++i) {
       
   859         SDL_DelKeyboard(i);
       
   860     }
       
   861     SDL_num_keyboards = 0;
       
   862     SDL_current_keyboard = 0;
       
   863 
       
   864     if (SDL_keyboards) {
       
   865         SDL_free(SDL_keyboards);
       
   866         SDL_keyboards = NULL;
       
   867     }
       
   868 }
       
   869 
       
   870 int
       
   871 SDL_GetNumKeyboards(void)
       
   872 {
       
   873     return SDL_num_keyboards;
       
   874 }
       
   875 
       
   876 int
       
   877 SDL_SelectKeyboard(int index)
       
   878 {
       
   879     if (index >= 0 && index < SDL_num_keyboards) {
       
   880         SDL_current_keyboard = index;
       
   881     }
       
   882     return SDL_current_keyboard;
       
   883 }
       
   884 
       
   885 Uint8 *
       
   886 SDL_GetKeyboardState(int *numkeys)
       
   887 {
       
   888     SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard);
       
   889 
       
   890     if (numkeys != (int *) 0) {
       
   891         *numkeys = SDL_NUM_SCANCODES;
       
   892     }
       
   893 
       
   894     if (!keyboard) {
       
   895         return NULL;
       
   896     }
       
   897     return keyboard->keystate;
       
   898 }
       
   899 
       
   900 SDLMod
       
   901 SDL_GetModState(void)
       
   902 {
       
   903     SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard);
       
   904 
       
   905     if (!keyboard) {
       
   906         return KMOD_NONE;
       
   907     }
       
   908     return keyboard->modstate;
       
   909 }
       
   910 
       
   911 void
       
   912 SDL_SetModState(SDLMod modstate)
       
   913 {
       
   914     SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard);
       
   915 
       
   916     if (!keyboard) {
       
   917         return;
       
   918     }
       
   919     keyboard->modstate = modstate;
       
   920 }
       
   921 
       
   922 SDLKey
       
   923 SDL_GetKeyFromScancode(SDL_scancode scancode)
       
   924 {
       
   925     SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard);
       
   926 
       
   927     if (!keyboard) {
       
   928         return SDLK_UNKNOWN;
       
   929     }
       
   930     return keyboard->keymap[scancode];
       
   931 }
       
   932 
       
   933 SDL_scancode
       
   934 SDL_GetScancodeFromKey(SDLKey key)
       
   935 {
       
   936     SDL_Keyboard *keyboard = SDL_GetKeyboard(SDL_current_keyboard);
       
   937     SDL_scancode scancode;
       
   938 
       
   939     if (!keyboard) {
       
   940         return SDL_SCANCODE_UNKNOWN;
       
   941     }
       
   942 
       
   943     for (scancode = SDL_SCANCODE_UNKNOWN; scancode < SDL_NUM_SCANCODES;
       
   944          ++scancode) {
       
   945         if (keyboard->keymap[scancode] == key) {
       
   946             return scancode;
       
   947         }
       
   948     }
       
   949     return SDL_SCANCODE_UNKNOWN;
       
   950 }
       
   951 
       
   952 const char *
       
   953 SDL_GetScancodeName(SDL_scancode scancode)
       
   954 {
       
   955     const char *name = SDL_scancode_names[scancode];
       
   956 
       
   957     if (name)
       
   958         return name;
       
   959     else
       
   960         return "";
       
   961 }
       
   962 
       
   963 const char *
       
   964 SDL_GetKeyName(SDLKey key)
       
   965 {
       
   966     static char name[8];
       
   967     char *end;
       
   968 
       
   969     if (key & SDLK_SCANCODE_MASK) {
       
   970         return
       
   971             SDL_GetScancodeName((SDL_scancode) (key & ~SDLK_SCANCODE_MASK));
       
   972     }
       
   973 
       
   974     /* Unaccented letter keys on latin keyboards are normally
       
   975        labeled in upper case (and probably on others like Greek or
       
   976        Cyrillic too, so if you happen to know for sure, please
       
   977        adapt this). */
       
   978     if (key >= 'a' && key <= 'z') {
       
   979         key -= 32;
       
   980     }
       
   981 
       
   982     end = SDL_UCS4ToUTF8((Uint32) key, name);
       
   983     *end = '\0';
       
   984     return name;
       
   985 }
       
   986 
   531 /* vi: set ts=4 sw=4 expandtab: */
   987 /* vi: set ts=4 sw=4 expandtab: */