src/events/SDL_keyboard.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2009 Sam Lantinga
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Lesser General Public
   7     License as published by the Free Software Foundation; either
   8     version 2.1 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Lesser General Public License for more details.
  14
  15     You should have received a copy of the GNU Lesser General Public
  16     License along with this library; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19     Sam Lantinga
  20     slouken@libsdl.org
  21 */
  22 #include "SDL_config.h"
  23
  24 /* General keyboard handling code for SDL */
  25
  26 #include "SDL_timer.h"
  27 #include "SDL_events.h"
  28 #include "SDL_events_c.h"
  29 #include "SDL_sysevents.h"
  30
  31
  32 /* Global keystate information */
  33 static Uint8  SDL_KeyState[SDLK_LAST];
  34 static SDLMod SDL_ModState;
  35 int SDL_TranslateUNICODE = 0;
  36
  37 static const char *keynames[SDLK_LAST]; /* Array of keycode names */
  38
  39 /*
  40  * jk 991215 - added
  41  */
  42 struct {
  43         int firsttime;    /* if we check against the delay or repeat value */
  44         int delay;        /* the delay before we start repeating */
  45         int interval;     /* the delay between key repeat events */
  46         Uint32 timestamp; /* the time the first keydown event occurred */
  47
  48         SDL_Event evt;    /* the event we are supposed to repeat */
  49 } SDL_KeyRepeat;
  50
  51 /* Global no-lock-keys support */
  52 static Uint8 SDL_NoLockKeys;
  53
  54 #define SDL_NLK_CAPS 0x01
  55 #define SDL_NLK_NUM  0x02
  56
  57 /* Public functions */
  58 int SDL_KeyboardInit(void)
  59 {
  60         const char* env;
  61         SDL_VideoDevice *video = current_video;
  62         SDL_VideoDevice *this  = current_video;
  63
  64         /* Set default mode of UNICODE translation */
  65         SDL_EnableUNICODE(DEFAULT_UNICODE_TRANSLATION);
  66
  67         /* Initialize the tables */
  68         SDL_ModState = KMOD_NONE;
  69         SDL_memset((void*)keynames, 0, sizeof(keynames));
  70         SDL_memset(SDL_KeyState, 0, sizeof(SDL_KeyState));
  71         video->InitOSKeymap(this);
  72
  73         SDL_EnableKeyRepeat(0, 0);
  74
  75         /* Allow environment override to disable special lock-key behavior */
  76         SDL_NoLockKeys = 0;
  77         env = SDL_getenv("SDL_DISABLE_LOCK_KEYS");
  78         if (env) {
  79                 switch (SDL_atoi(env)) {
  80                         case 1:
  81                                 SDL_NoLockKeys = SDL_NLK_CAPS | SDL_NLK_NUM;
  82                                 break;
  83                         case 2:
  84                                 SDL_NoLockKeys = SDL_NLK_CAPS;
  85                                 break;
  86                         case 3:
  87                                 SDL_NoLockKeys = SDL_NLK_NUM;
  88                                 break;
  89                         default:
  90                                 break;
  91                 }
  92         }
  93
  94         /* Fill in the blanks in keynames */
  95         keynames[SDLK_BACKSPACE] = "backspace";
  96         keynames[SDLK_TAB] = "tab";
  97         keynames[SDLK_CLEAR] = "clear";
  98         keynames[SDLK_RETURN] = "return";
  99         keynames[SDLK_PAUSE] = "pause";
 100         keynames[SDLK_ESCAPE] = "escape";
 101         keynames[SDLK_SPACE] = "space";
 102         keynames[SDLK_EXCLAIM]  = "!";
 103         keynames[SDLK_QUOTEDBL]  = "\"";
 104         keynames[SDLK_HASH]  = "#";
 105         keynames[SDLK_DOLLAR]  = "$";
 106         keynames[SDLK_AMPERSAND]  = "&";
 107         keynames[SDLK_QUOTE] = "'";
 108         keynames[SDLK_LEFTPAREN] = "(";
 109         keynames[SDLK_RIGHTPAREN] = ")";
 110         keynames[SDLK_ASTERISK] = "*";
 111         keynames[SDLK_PLUS] = "+";
 112         keynames[SDLK_COMMA] = ",";
 113         keynames[SDLK_MINUS] = "-";
 114         keynames[SDLK_PERIOD] = ".";
 115         keynames[SDLK_SLASH] = "/";
 116         keynames[SDLK_0] = "0";
 117         keynames[SDLK_1] = "1";
 118         keynames[SDLK_2] = "2";
 119         keynames[SDLK_3] = "3";
 120         keynames[SDLK_4] = "4";
 121         keynames[SDLK_5] = "5";
 122         keynames[SDLK_6] = "6";
 123         keynames[SDLK_7] = "7";
 124         keynames[SDLK_8] = "8";
 125         keynames[SDLK_9] = "9";
 126         keynames[SDLK_COLON] = ":";
 127         keynames[SDLK_SEMICOLON] = ";";
 128         keynames[SDLK_LESS] = "<";
 129         keynames[SDLK_EQUALS] = "=";
 130         keynames[SDLK_GREATER] = ">";
 131         keynames[SDLK_QUESTION] = "?";
 132         keynames[SDLK_AT] = "@";
 133         keynames[SDLK_LEFTBRACKET] = "[";
 134         keynames[SDLK_BACKSLASH] = "\\";
 135         keynames[SDLK_RIGHTBRACKET] = "]";
 136         keynames[SDLK_CARET] = "^";
 137         keynames[SDLK_UNDERSCORE] = "_";
 138         keynames[SDLK_BACKQUOTE] = "`";
 139         keynames[SDLK_a] = "a";
 140         keynames[SDLK_b] = "b";
 141         keynames[SDLK_c] = "c";
 142         keynames[SDLK_d] = "d";
 143         keynames[SDLK_e] = "e";
 144         keynames[SDLK_f] = "f";
 145         keynames[SDLK_g] = "g";
 146         keynames[SDLK_h] = "h";
 147         keynames[SDLK_i] = "i";
 148         keynames[SDLK_j] = "j";
 149         keynames[SDLK_k] = "k";
 150         keynames[SDLK_l] = "l";
 151         keynames[SDLK_m] = "m";
 152         keynames[SDLK_n] = "n";
 153         keynames[SDLK_o] = "o";
 154         keynames[SDLK_p] = "p";
 155         keynames[SDLK_q] = "q";
 156         keynames[SDLK_r] = "r";
 157         keynames[SDLK_s] = "s";
 158         keynames[SDLK_t] = "t";
 159         keynames[SDLK_u] = "u";
 160         keynames[SDLK_v] = "v";
 161         keynames[SDLK_w] = "w";
 162         keynames[SDLK_x] = "x";
 163         keynames[SDLK_y] = "y";
 164         keynames[SDLK_z] = "z";
 165         keynames[SDLK_DELETE] = "delete";
 166
 167         keynames[SDLK_WORLD_0] = "world 0";
 168         keynames[SDLK_WORLD_1] = "world 1";
 169         keynames[SDLK_WORLD_2] = "world 2";
 170         keynames[SDLK_WORLD_3] = "world 3";
 171         keynames[SDLK_WORLD_4] = "world 4";
 172         keynames[SDLK_WORLD_5] = "world 5";
 173         keynames[SDLK_WORLD_6] = "world 6";
 174         keynames[SDLK_WORLD_7] = "world 7";
 175         keynames[SDLK_WORLD_8] = "world 8";
 176         keynames[SDLK_WORLD_9] = "world 9";
 177         keynames[SDLK_WORLD_10] = "world 10";
 178         keynames[SDLK_WORLD_11] = "world 11";
 179         keynames[SDLK_WORLD_12] = "world 12";
 180         keynames[SDLK_WORLD_13] = "world 13";
 181         keynames[SDLK_WORLD_14] = "world 14";
 182         keynames[SDLK_WORLD_15] = "world 15";
 183         keynames[SDLK_WORLD_16] = "world 16";
 184         keynames[SDLK_WORLD_17] = "world 17";
 185         keynames[SDLK_WORLD_18] = "world 18";
 186         keynames[SDLK_WORLD_19] = "world 19";
 187         keynames[SDLK_WORLD_20] = "world 20";
 188         keynames[SDLK_WORLD_21] = "world 21";
 189         keynames[SDLK_WORLD_22] = "world 22";
 190         keynames[SDLK_WORLD_23] = "world 23";
 191         keynames[SDLK_WORLD_24] = "world 24";
 192         keynames[SDLK_WORLD_25] = "world 25";
 193         keynames[SDLK_WORLD_26] = "world 26";
 194         keynames[SDLK_WORLD_27] = "world 27";
 195         keynames[SDLK_WORLD_28] = "world 28";
 196         keynames[SDLK_WORLD_29] = "world 29";
 197         keynames[SDLK_WORLD_30] = "world 30";
 198         keynames[SDLK_WORLD_31] = "world 31";
 199         keynames[SDLK_WORLD_32] = "world 32";
 200         keynames[SDLK_WORLD_33] = "world 33";
 201         keynames[SDLK_WORLD_34] = "world 34";
 202         keynames[SDLK_WORLD_35] = "world 35";
 203         keynames[SDLK_WORLD_36] = "world 36";
 204         keynames[SDLK_WORLD_37] = "world 37";
 205         keynames[SDLK_WORLD_38] = "world 38";
 206         keynames[SDLK_WORLD_39] = "world 39";
 207         keynames[SDLK_WORLD_40] = "world 40";
 208         keynames[SDLK_WORLD_41] = "world 41";
 209         keynames[SDLK_WORLD_42] = "world 42";
 210         keynames[SDLK_WORLD_43] = "world 43";
 211         keynames[SDLK_WORLD_44] = "world 44";
 212         keynames[SDLK_WORLD_45] = "world 45";
 213         keynames[SDLK_WORLD_46] = "world 46";
 214         keynames[SDLK_WORLD_47] = "world 47";
 215         keynames[SDLK_WORLD_48] = "world 48";
 216         keynames[SDLK_WORLD_49] = "world 49";
 217         keynames[SDLK_WORLD_50] = "world 50";
 218         keynames[SDLK_WORLD_51] = "world 51";
 219         keynames[SDLK_WORLD_52] = "world 52";
 220         keynames[SDLK_WORLD_53] = "world 53";
 221         keynames[SDLK_WORLD_54] = "world 54";
 222         keynames[SDLK_WORLD_55] = "world 55";
 223         keynames[SDLK_WORLD_56] = "world 56";
 224         keynames[SDLK_WORLD_57] = "world 57";
 225         keynames[SDLK_WORLD_58] = "world 58";
 226         keynames[SDLK_WORLD_59] = "world 59";
 227         keynames[SDLK_WORLD_60] = "world 60";
 228         keynames[SDLK_WORLD_61] = "world 61";
 229         keynames[SDLK_WORLD_62] = "world 62";
 230         keynames[SDLK_WORLD_63] = "world 63";
 231         keynames[SDLK_WORLD_64] = "world 64";
 232         keynames[SDLK_WORLD_65] = "world 65";
 233         keynames[SDLK_WORLD_66] = "world 66";
 234         keynames[SDLK_WORLD_67] = "world 67";
 235         keynames[SDLK_WORLD_68] = "world 68";
 236         keynames[SDLK_WORLD_69] = "world 69";
 237         keynames[SDLK_WORLD_70] = "world 70";
 238         keynames[SDLK_WORLD_71] = "world 71";
 239         keynames[SDLK_WORLD_72] = "world 72";
 240         keynames[SDLK_WORLD_73] = "world 73";
 241         keynames[SDLK_WORLD_74] = "world 74";
 242         keynames[SDLK_WORLD_75] = "world 75";
 243         keynames[SDLK_WORLD_76] = "world 76";
 244         keynames[SDLK_WORLD_77] = "world 77";
 245         keynames[SDLK_WORLD_78] = "world 78";
 246         keynames[SDLK_WORLD_79] = "world 79";
 247         keynames[SDLK_WORLD_80] = "world 80";
 248         keynames[SDLK_WORLD_81] = "world 81";
 249         keynames[SDLK_WORLD_82] = "world 82";
 250         keynames[SDLK_WORLD_83] = "world 83";
 251         keynames[SDLK_WORLD_84] = "world 84";
 252         keynames[SDLK_WORLD_85] = "world 85";
 253         keynames[SDLK_WORLD_86] = "world 86";
 254         keynames[SDLK_WORLD_87] = "world 87";
 255         keynames[SDLK_WORLD_88] = "world 88";
 256         keynames[SDLK_WORLD_89] = "world 89";
 257         keynames[SDLK_WORLD_90] = "world 90";
 258         keynames[SDLK_WORLD_91] = "world 91";
 259         keynames[SDLK_WORLD_92] = "world 92";
 260         keynames[SDLK_WORLD_93] = "world 93";
 261         keynames[SDLK_WORLD_94] = "world 94";
 262         keynames[SDLK_WORLD_95] = "world 95";
 263
 264         keynames[SDLK_KP0] = "[0]";
 265         keynames[SDLK_KP1] = "[1]";
 266         keynames[SDLK_KP2] = "[2]";
 267         keynames[SDLK_KP3] = "[3]";
 268         keynames[SDLK_KP4] = "[4]";
 269         keynames[SDLK_KP5] = "[5]";
 270         keynames[SDLK_KP6] = "[6]";
 271         keynames[SDLK_KP7] = "[7]";
 272         keynames[SDLK_KP8] = "[8]";
 273         keynames[SDLK_KP9] = "[9]";
 274         keynames[SDLK_KP_PERIOD] = "[.]";
 275         keynames[SDLK_KP_DIVIDE] = "[/]";
 276         keynames[SDLK_KP_MULTIPLY] = "[*]";
 277         keynames[SDLK_KP_MINUS] = "[-]";
 278         keynames[SDLK_KP_PLUS] = "[+]";
 279         keynames[SDLK_KP_ENTER] = "enter";
 280         keynames[SDLK_KP_EQUALS] = "equals";
 281
 282         keynames[SDLK_UP] = "up";
 283         keynames[SDLK_DOWN] = "down";
 284         keynames[SDLK_RIGHT] = "right";
 285         keynames[SDLK_LEFT] = "left";
 286         keynames[SDLK_DOWN] = "down";
 287         keynames[SDLK_INSERT] = "insert";
 288         keynames[SDLK_HOME] = "home";
 289         keynames[SDLK_END] = "end";
 290         keynames[SDLK_PAGEUP] = "page up";
 291         keynames[SDLK_PAGEDOWN] = "page down";
 292
 293         keynames[SDLK_F1] = "f1";
 294         keynames[SDLK_F2] = "f2";
 295         keynames[SDLK_F3] = "f3";
 296         keynames[SDLK_F4] = "f4";
 297         keynames[SDLK_F5] = "f5";
 298         keynames[SDLK_F6] = "f6";
 299         keynames[SDLK_F7] = "f7";
 300         keynames[SDLK_F8] = "f8";
 301         keynames[SDLK_F9] = "f9";
 302         keynames[SDLK_F10] = "f10";
 303         keynames[SDLK_F11] = "f11";
 304         keynames[SDLK_F12] = "f12";
 305         keynames[SDLK_F13] = "f13";
 306         keynames[SDLK_F14] = "f14";
 307         keynames[SDLK_F15] = "f15";
 308
 309         keynames[SDLK_NUMLOCK] = "numlock";
 310         keynames[SDLK_CAPSLOCK] = "caps lock";
 311         keynames[SDLK_SCROLLOCK] = "scroll lock";
 312         keynames[SDLK_RSHIFT] = "right shift";
 313         keynames[SDLK_LSHIFT] = "left shift";
 314         keynames[SDLK_RCTRL] = "right ctrl";
 315         keynames[SDLK_LCTRL] = "left ctrl";
 316         keynames[SDLK_RALT] = "right alt";
 317         keynames[SDLK_LALT] = "left alt";
 318         keynames[SDLK_RMETA] = "right meta";
 319         keynames[SDLK_LMETA] = "left meta";
 320         keynames[SDLK_LSUPER] = "left super";   /* "Windows" keys */
 321         keynames[SDLK_RSUPER] = "right super";
 322         keynames[SDLK_MODE] = "alt gr";
 323         keynames[SDLK_COMPOSE] = "compose";
 324
 325         keynames[SDLK_HELP] = "help";
 326         keynames[SDLK_PRINT] = "print screen";
 327         keynames[SDLK_SYSREQ] = "sys req";
 328         keynames[SDLK_BREAK] = "break";
 329         keynames[SDLK_MENU] = "menu";
 330         keynames[SDLK_POWER] = "power";
 331         keynames[SDLK_EURO] = "euro";
 332         keynames[SDLK_UNDO] = "undo";
 333
 334         /* Done.  Whew. */
 335         return(0);
 336 }
 337 void SDL_KeyboardQuit(void)
 338 {
 339 }
 340
 341 /* We lost the keyboard, so post key up messages for all pressed keys */
 342 void SDL_ResetKeyboard(void)
 343 {
 344         SDL_keysym keysym;
 345         SDLKey key;
 346
 347         SDL_memset(&keysym, 0, (sizeof keysym));
 348         for ( key=SDLK_FIRST; key<SDLK_LAST; ++key ) {
 349                 if ( SDL_KeyState[key] == SDL_PRESSED ) {
 350                         keysym.sym = key;
 351                         SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
 352                 }
 353         }
 354         SDL_KeyRepeat.timestamp = 0;
 355 }
 356
 357 int SDL_EnableUNICODE(int enable)
 358 {
 359         int old_mode;
 360
 361         old_mode = SDL_TranslateUNICODE;
 362         if ( enable >= 0 ) {
 363                 SDL_TranslateUNICODE = enable;
 364         }
 365         return(old_mode);
 366 }
 367
 368 Uint8 * SDL_GetKeyState (int *numkeys)
 369 {
 370         if ( numkeys != (int *)0 )
 371                 *numkeys = SDLK_LAST;
 372         return(SDL_KeyState);
 373 }
 374 SDLMod SDL_GetModState (void)
 375 {
 376         return(SDL_ModState);
 377 }
 378 void SDL_SetModState (SDLMod modstate)
 379 {
 380         SDL_ModState = modstate;
 381 }
 382
 383 char *SDL_GetKeyName(SDLKey key)
 384 {
 385         const char *keyname;
 386
 387         keyname = NULL;
 388         if ( key < SDLK_LAST ) {
 389                 keyname = keynames[key];
 390         }
 391         if ( keyname == NULL ) {
 392                 keyname = "unknown key";
 393         }
 394         /* FIXME: make this function const in 1.3 */
 395         return (char *)(keyname);
 396 }
 397
 398 /* These are global for SDL_eventloop.c */
 399 int SDL_PrivateKeyboard(Uint8 state, SDL_keysym *keysym)
 400 {
 401         SDL_Event event;
 402         int posted, repeatable;
 403         Uint16 modstate;
 404
 405         SDL_memset(&event, 0, sizeof(event));
 406
 407 #if 0
 408 printf("The '%s' key has been %s\n", SDL_GetKeyName(keysym->sym),
 409                                 state == SDL_PRESSED ? "pressed" : "released");
 410 #endif
 411         /* Set up the keysym */
 412         modstate = (Uint16)SDL_ModState;
 413
 414         repeatable = 0;
 415
 416         if ( state == SDL_PRESSED ) {
 417                 keysym->mod = (SDLMod)modstate;
 418                 switch (keysym->sym) {
 419                         case SDLK_UNKNOWN:
 420                                 break;
 421                         case SDLK_NUMLOCK:
 422                                 modstate ^= KMOD_NUM;
 423                                 if ( SDL_NoLockKeys & SDL_NLK_NUM )
 424                                         break;
 425                                 if ( ! (modstate&KMOD_NUM) )
 426                                         state = SDL_RELEASED;
 427                                 keysym->mod = (SDLMod)modstate;
 428                                 break;
 429                         case SDLK_CAPSLOCK:
 430                                 modstate ^= KMOD_CAPS;
 431                                 if ( SDL_NoLockKeys & SDL_NLK_CAPS )
 432                                         break;
 433                                 if ( ! (modstate&KMOD_CAPS) )
 434                                         state = SDL_RELEASED;
 435                                 keysym->mod = (SDLMod)modstate;
 436                                 break;
 437                         case SDLK_LCTRL:
 438                                 modstate |= KMOD_LCTRL;
 439                                 break;
 440                         case SDLK_RCTRL:
 441                                 modstate |= KMOD_RCTRL;
 442                                 break;
 443                         case SDLK_LSHIFT:
 444                                 modstate |= KMOD_LSHIFT;
 445                                 break;
 446                         case SDLK_RSHIFT:
 447                                 modstate |= KMOD_RSHIFT;
 448                                 break;
 449                         case SDLK_LALT:
 450                                 modstate |= KMOD_LALT;
 451                                 break;
 452                         case SDLK_RALT:
 453                                 modstate |= KMOD_RALT;
 454                                 break;
 455                         case SDLK_LMETA:
 456                                 modstate |= KMOD_LMETA;
 457                                 break;
 458                         case SDLK_RMETA:
 459                                 modstate |= KMOD_RMETA;
 460                                 break;
 461                         case SDLK_MODE:
 462                                 modstate |= KMOD_MODE;
 463                                 break;
 464                         default:
 465                                 repeatable = 1;
 466                                 break;
 467                 }
 468         } else {
 469                 switch (keysym->sym) {
 470                         case SDLK_UNKNOWN:
 471                                 break;
 472                         case SDLK_NUMLOCK:
 473                                 if ( SDL_NoLockKeys & SDL_NLK_NUM )
 474                                         break;
 475                                 /* Only send keydown events */
 476                                 return(0);
 477                         case SDLK_CAPSLOCK:
 478                                 if ( SDL_NoLockKeys & SDL_NLK_CAPS )
 479                                         break;
 480                                 /* Only send keydown events */
 481                                 return(0);
 482                         case SDLK_LCTRL:
 483                                 modstate &= ~KMOD_LCTRL;
 484                                 break;
 485                         case SDLK_RCTRL:
 486                                 modstate &= ~KMOD_RCTRL;
 487                                 break;
 488                         case SDLK_LSHIFT:
 489                                 modstate &= ~KMOD_LSHIFT;
 490                                 break;
 491                         case SDLK_RSHIFT:
 492                                 modstate &= ~KMOD_RSHIFT;
 493                                 break;
 494                         case SDLK_LALT:
 495                                 modstate &= ~KMOD_LALT;
 496                                 break;
 497                         case SDLK_RALT:
 498                                 modstate &= ~KMOD_RALT;
 499                                 break;
 500                         case SDLK_LMETA:
 501                                 modstate &= ~KMOD_LMETA;
 502                                 break;
 503                         case SDLK_RMETA:
 504                                 modstate &= ~KMOD_RMETA;
 505                                 break;
 506                         case SDLK_MODE:
 507                                 modstate &= ~KMOD_MODE;
 508                                 break;
 509                         default:
 510                                 break;
 511                 }
 512                 keysym->mod = (SDLMod)modstate;
 513         }
 514
 515         /* Figure out what type of event this is */
 516         switch (state) {
 517                 case SDL_PRESSED:
 518                         event.type = SDL_KEYDOWN;
 519                         break;
 520                 case SDL_RELEASED:
 521                         event.type = SDL_KEYUP;
 522                         /*
 523                          * jk 991215 - Added
 524                          */
 525                         if ( SDL_KeyRepeat.timestamp &&
 526                              SDL_KeyRepeat.evt.key.keysym.sym == keysym->sym ) {
 527                                 SDL_KeyRepeat.timestamp = 0;
 528                         }
 529                         break;
 530                 default:
 531                         /* Invalid state -- bail */
 532                         return(0);
 533         }
 534
 535         if ( keysym->sym != SDLK_UNKNOWN ) {
 536                 /* Drop events that don't change state */
 537                 if ( SDL_KeyState[keysym->sym] == state ) {
 538 #if 0
 539 printf("Keyboard event didn't change state - dropped!\n");
 540 #endif
 541                         return(0);
 542                 }
 543
 544                 /* Update internal keyboard state */
 545                 SDL_ModState = (SDLMod)modstate;
 546                 SDL_KeyState[keysym->sym] = state;
 547         }
 548
 549         /* Post the event, if desired */
 550         posted = 0;
 551         if ( SDL_ProcessEvents[event.type] == SDL_ENABLE ) {
 552                 event.key.state = state;
 553                 event.key.keysym = *keysym;
 554                 /*
 555                  * jk 991215 - Added
 556                  */
 557                 if (repeatable && (SDL_KeyRepeat.delay != 0)) {
 558                         SDL_KeyRepeat.evt = event;
 559                         SDL_KeyRepeat.firsttime = 1;
 560                         SDL_KeyRepeat.timestamp=SDL_GetTicks();
 561                 }
 562                 if ( (SDL_EventOK == NULL) || SDL_EventOK(&event) ) {
 563                         posted = 1;
 564                         SDL_PushEvent(&event);
 565                 }
 566         }
 567         return(posted);
 568 }
 569
 570 /*
 571  * jk 991215 - Added
 572  */
 573 void SDL_CheckKeyRepeat(void)
 574 {
 575         if ( SDL_KeyRepeat.timestamp ) {
 576                 Uint32 now, interval;
 577
 578                 now = SDL_GetTicks();
 579                 interval = (now - SDL_KeyRepeat.timestamp);
 580                 if ( SDL_KeyRepeat.firsttime ) {
 581                         if ( interval > (Uint32)SDL_KeyRepeat.delay ) {
 582                                 SDL_KeyRepeat.timestamp = now;
 583                                 SDL_KeyRepeat.firsttime = 0;
 584                         }
 585                 } else {
 586                         if ( interval > (Uint32)SDL_KeyRepeat.interval ) {
 587                                 SDL_KeyRepeat.timestamp = now;
 588                                 if ( (SDL_EventOK == NULL) || SDL_EventOK(&SDL_KeyRepeat.evt) ) {
 589                                         SDL_PushEvent(&SDL_KeyRepeat.evt);
 590                                 }
 591                         }
 592                 }
 593         }
 594 }
 595
 596 int SDL_EnableKeyRepeat(int delay, int interval)
 597 {
 598         if ( (delay < 0) || (interval < 0) ) {
 599                 SDL_SetError("keyboard repeat value less than zero");
 600                 return(-1);
 601         }
 602         SDL_KeyRepeat.firsttime = 0;
 603         SDL_KeyRepeat.delay = delay;
 604         SDL_KeyRepeat.interval = interval;
 605         SDL_KeyRepeat.timestamp = 0;
 606         return(0);
 607 }
 608
 609 void SDL_GetKeyRepeat(int *delay, int *interval)
 610 {
 611         *delay = SDL_KeyRepeat.delay;
 612         *interval = SDL_KeyRepeat.interval;
 613 }
 614