Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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