2 * Copyright (C) Volition, Inc. 1999. All rights reserved.
4 * All source code herein is the property of Volition, Inc. You may not sell
5 * or otherwise commercially exploit the source or things you created based on
10 * $Logfile: /Freespace2/code/Io/Key.cpp $
15 * <insert description of file here>
18 * Revision 1.12 2004/06/11 01:14:12 tigital
19 * OSX: switched to __APPLE__
21 * Revision 1.11 2003/05/18 03:57:08 taylor
22 * do not swap German z and y keys if they are already swapped
24 * Revision 1.9 2003/01/30 19:55:01 relnev
25 * add German keys (this is mostly a patch already sent in by someone else that hasn't made it into cvs yet) (Taylor Richards)
27 * Revision 1.8 2002/06/17 23:11:39 relnev
28 * enable sdl key repeating.
32 * Revision 1.7 2002/06/09 04:41:21 relnev
33 * added copyright header
35 * Revision 1.6 2002/06/05 04:03:32 relnev
36 * finished cfilesystem.
38 * removed some old code.
40 * fixed mouse save off-by-one.
44 * Revision 1.5 2002/05/31 03:34:02 theoddone33
48 * Revision 1.4 2002/05/30 23:46:29 theoddone33
49 * some minor key changes (not necessarily fixes)
51 * Revision 1.3 2002/05/30 16:50:24 theoddone33
52 * Keyboard partially fixed
54 * Revision 1.2 2002/05/29 23:17:50 theoddone33
55 * Non working text code and fixed keys
57 * Revision 1.1.1.1 2002/05/03 03:28:09 root
61 * 6 10/29/99 6:10p Jefff
62 * squashed the damned y/z german issues once and for all
64 * 5 6/07/99 1:21p Dave
65 * Fixed debug console scrolling problem. Thread related.
67 * 4 6/02/99 6:18p Dave
68 * Fixed TNT lockup problems! Wheeeee!
70 * 3 11/05/98 4:18p Dave
71 * First run nebula support. Beefed up localization a bit. Removed all
72 * conditional compiles for foreign versions. Modified mission file
75 * 2 10/07/98 10:53a Dave
78 * 1 10/07/98 10:49a Dave
80 * 37 6/19/98 3:50p Lawrance
81 * change GERMAN to GR_BUILD
83 * 36 6/17/98 11:05a Lawrance
84 * translate french and german keys
86 * 35 6/12/98 4:49p Hoffoss
87 * Added code to remap scancodes for german and french keyboards.
89 * 34 5/20/98 12:10a Mike
92 * 33 5/19/98 12:19p Mike
95 * 32 5/19/98 12:28a Mike
98 * 31 5/18/98 11:01p Mike
99 * Adding support for cheat system.
101 * 30 5/11/98 12:09a Lawrance
102 * Put in code to turn on/off NumLock key when running under 95
104 * 29 5/01/98 4:23p Lawrance
105 * Remap the scancode for the UK "\" key
107 * 28 4/18/98 12:42p John
108 * Added code to use DirectInput to read keyboard. Took out because it
109 * didn't differentiate btwn Pause and Numlock and sometimes Ctrl.
111 * 27 4/13/98 10:16a John
112 * Switched gettime back to timer_get_milliseconds, which is now thread
115 * 26 4/12/98 11:08p Lawrance
116 * switch back to using gettime() in separate threads
118 * 25 4/12/98 5:31p Lawrance
119 * use timer_get_milliseconds() instead of gettime()
121 * 24 3/25/98 8:08p John
122 * Restructured software rendering into two modules; One for windowed
123 * debug mode and one for DirectX fullscreen.
125 * 23 1/23/98 3:49p Mike
126 * Fix bug in negative time-down due to latency.
128 * 22 1/07/98 6:41p Lawrance
129 * Pass message latency to the keyboard lib.
131 * 21 11/17/97 10:42a John
132 * On Debug+Backsp, cleared out keys so that it looks like nothing ever
133 * happened, so they're not stuck down.
135 * 20 11/14/97 4:33p Mike
136 * Change Debug key to backquote (from F11).
137 * Balance a ton of subsystems in ships.tbl.
138 * Change "Heavy Laser" to "Disruptor".
140 * 19 9/13/97 9:30a Lawrance
141 * added ability to block certain keys from the keyboard
143 * 18 9/10/97 6:02p Hoffoss
144 * Added code to check for key-pressed sexp operator in FreeSpace as part
145 * of training mission stuff.
147 * 17 9/09/97 11:08a Sandeep
148 * fixed warning level 4
150 * 16 7/29/97 5:30p Lawrance
151 * move gettime() to timer module
153 * 15 4/22/97 10:56a John
154 * fixed some resource leaks.
156 * 14 2/03/97 4:23p Allender
157 * use F11 as debug key now
159 * 13 1/10/97 5:15p Mike
160 * Moved ship-specific parameters from obj_subsystem to ship_subsys.
162 * Added turret code to AI system.
167 #include <ctype.h> // for toupper
173 #include "localize.h"
175 #define KEY_BUFFER_SIZE 16
177 //-------- Variable accessed by outside functions ---------
178 ubyte keyd_buffer_type; // 0=No buffer, 1=buffer ASCII, 2=buffer scans
180 uint keyd_last_pressed;
181 uint keyd_last_released;
182 int keyd_time_when_last_pressed;
184 static bool keyd_pressed[SDL_NUM_SCANCODES];
186 typedef struct keyboard {
187 ushort keybuffer[KEY_BUFFER_SIZE];
188 uint time_pressed[KEY_BUFFER_SIZE];
189 uint TimeKeyWentDown[SDL_NUM_SCANCODES];
190 uint TimeKeyHeldDown[SDL_NUM_SCANCODES];
191 uint TimeKeyDownChecked[SDL_NUM_SCANCODES];
192 uint NumDowns[SDL_NUM_SCANCODES];
193 uint NumUps[SDL_NUM_SCANCODES];
194 int down_check[SDL_NUM_SCANCODES]; // nonzero if has been pressed yet this mission
195 uint keyhead, keytail;
202 CRITICAL_SECTION key_lock;
204 //int Backspace_debug=1; // global flag that will enable/disable the backspace key from stopping execution
205 // This flag was created since the backspace key is also used to correct mistakes
206 // when typing in your pilots callsign. This global flag is checked before execution
209 // used to limit the keypresses that are accepted from the keyboard
210 #define MAX_FILTER_KEYS 64
212 int Key_filter[MAX_FILTER_KEYS];
214 static int Key_numlock_was_on = 0; // Flag to indicate whether NumLock is on at start
216 int Cheats_enabled = 0;
217 int Key_normal_game = 0;
220 bool key_pressed(int keycode)
222 SDL_Scancode scancode = SDL_GetScancodeFromKey(keycode);
224 return keyd_pressed[scancode];
227 int key_numlock_is_on()
230 state = SDL_GetKeyboardState(NULL);
231 if ( state[SDL_SCANCODE_NUMLOCKCLEAR] ) {
238 void key_turn_off_numlock()
242 void key_turn_on_numlock()
246 // Convert a BIOS scancode to ASCII.
247 // If scancode >= 127, returns 255, meaning there is no corresponding ASCII code.
248 // Uses ascii_table and shifted_ascii_table to translate scancode to ASCII.
249 int key_to_ascii(int keycode)
251 if ( ((keycode >= SDLK_SPACE) && (keycode <= SDLK_AT))
252 || ((keycode >= SDLK_LEFTBRACKET) && (keycode <= SDLK_z)) )
260 // Flush the keyboard buffer.
261 // Clear the keyboard array (keyd_pressed).
267 if ( !key_inited ) return;
269 ENTER_CRITICAL_SECTION(&key_lock);
271 key_data.keyhead = key_data.keytail = 0;
273 //Clear the keyboard buffer
274 for (i=0; i<KEY_BUFFER_SIZE; i++ ) {
275 key_data.keybuffer[i] = 0;
276 key_data.time_pressed[i] = 0;
279 //Clear the keyboard array
281 CurTime = timer_get_milliseconds();
284 for (i=0; i<SDL_NUM_SCANCODES; i++ ) {
285 keyd_pressed[i] = false;
286 key_data.TimeKeyDownChecked[i] = CurTime;
287 key_data.TimeKeyWentDown[i] = CurTime;
288 key_data.TimeKeyHeldDown[i] = 0;
289 key_data.NumDowns[i]=0;
290 key_data.NumUps[i]=0;
293 LEAVE_CRITICAL_SECTION(&key_lock);
296 // A nifty function which performs the function:
297 // n = (n+1) % KEY_BUFFER_SIZE
298 // (assuming positive values of n).
302 if ( n >= KEY_BUFFER_SIZE ) n=0;
306 // Returns 1 if character waiting... 0 otherwise
309 int is_one_waiting = 0;
311 if ( !key_inited ) return 0;
313 ENTER_CRITICAL_SECTION(&key_lock);
315 if (key_data.keytail != key_data.keyhead){
319 LEAVE_CRITICAL_SECTION(&key_lock);
321 return is_one_waiting;
324 // Return keycode if a key has been pressed,
326 // Reads keys out of the key buffer and updates keyhead.
329 SDL_Scancode scancode;
334 ENTER_CRITICAL_SECTION(&key_lock);
336 if (key_data.keytail != key_data.keyhead) {
337 scancode = (SDL_Scancode)key_data.keybuffer[key_data.keyhead];
338 key_data.keyhead = add_one(key_data.keyhead);
341 LEAVE_CRITICAL_SECTION(&key_lock);
343 return (int)SDL_GetKeyFromScancode(scancode);
346 // If not installed, uses BIOS and returns getch();
347 // Else returns pending key (or waits for one if none waiting).
353 if ( !key_inited ) return 0;
355 while (!key_checkch()){
365 // Set global shift_status with modifier results (shift, ctrl, alt).
366 uint key_get_shift_status()
368 unsigned int shift_status = 0;
370 if ( !key_inited ) return 0;
372 ENTER_CRITICAL_SECTION(&key_lock);
374 if ( keyd_pressed[SDL_SCANCODE_LSHIFT] || keyd_pressed[SDL_SCANCODE_RSHIFT] )
375 shift_status |= KEY_SHIFTED;
377 if ( keyd_pressed[SDL_SCANCODE_LALT] || keyd_pressed[SDL_SCANCODE_RALT] )
378 shift_status |= KEY_ALTED;
380 if ( keyd_pressed[SDL_SCANCODE_LCTRL] || keyd_pressed[SDL_SCANCODE_RCTRL] )
381 shift_status |= KEY_CTRLED;
384 if (keyd_pressed[KEY_DEBUG_KEY])
385 shift_status |= KEY_DEBUGGED;
387 if (keyd_pressed[KEY_DEBUG_KEY]) {
388 mprintf(("Cheats_enabled = %i, Key_normal_game = %i\n", Cheats_enabled, Key_normal_game));
389 if ((Cheats_enabled) && Key_normal_game) {
390 mprintf(("Debug key\n"));
391 shift_status |= KEY_DEBUGGED1;
395 LEAVE_CRITICAL_SECTION(&key_lock);
400 // Returns amount of time key (specified by "keycode") has been down since last call.
401 // Returns float, unlike key_down_time() which returns a fix.
402 float key_down_timef(int keycode)
404 uint time_down, time;
406 SDL_Scancode scancode;
411 scancode = SDL_GetScancodeFromKey(keycode);
413 if (scancode == SDL_SCANCODE_UNKNOWN)
416 ENTER_CRITICAL_SECTION(&key_lock);
418 time = timer_get_milliseconds();
419 delta_time = time - key_data.TimeKeyDownChecked[scancode];
420 key_data.TimeKeyDownChecked[scancode] = time;
422 if ( delta_time <= 1 ) {
423 key_data.TimeKeyWentDown[scancode] = time;
424 if (keyd_pressed[scancode]) {
425 LEAVE_CRITICAL_SECTION(&key_lock);
428 LEAVE_CRITICAL_SECTION(&key_lock);
433 if ( !keyd_pressed[scancode] ) {
434 time_down = key_data.TimeKeyHeldDown[scancode];
435 key_data.TimeKeyHeldDown[scancode] = 0;
437 time_down = time - key_data.TimeKeyWentDown[scancode];
438 key_data.TimeKeyWentDown[scancode] = time;
441 LEAVE_CRITICAL_SECTION(&key_lock);
443 return i2fl(time_down) / i2fl(delta_time);
446 // Returns number of times key has went from up to down since last call.
447 int key_down_count(int keycode)
450 SDL_Scancode scancode;
455 scancode = SDL_GetScancodeFromKey(keycode);
457 if (scancode == SDL_SCANCODE_UNKNOWN)
460 ENTER_CRITICAL_SECTION(&key_lock);
462 n = key_data.NumDowns[scancode];
463 key_data.NumDowns[scancode] = 0;
465 LEAVE_CRITICAL_SECTION(&key_lock);
471 // Returns number of times key has went from down to up since last call.
472 int key_up_count(int keycode)
475 SDL_Scancode scancode;
480 scancode = SDL_GetScancodeFromKey(keycode);
482 if (scancode == SDL_SCANCODE_UNKNOWN)
485 ENTER_CRITICAL_SECTION(&key_lock);
487 n = key_data.NumUps[scancode];
488 key_data.NumUps[scancode] = 0;
490 LEAVE_CRITICAL_SECTION(&key_lock);
495 int key_check(int keycode)
497 SDL_Scancode scancode = SDL_GetScancodeFromKey(keycode);
499 return key_data.down_check[scancode];
502 // Add a key up or down code to the key buffer. state=1 -> down, state=0 -> up
503 // latency => time difference in ms between when key was actually pressed and now
504 //void key_mark( uint code, int state )
505 void key_mark(SDL_Scancode scancode, int state, ushort kmod, uint latency )
507 uint breakbit, temp, event_time;
510 if ( !key_inited ) return;
512 ENTER_CRITICAL_SECTION(&key_lock);
514 Assert( scancode < SDL_NUM_SCANCODES );
516 event_time = timer_get_milliseconds() - latency;
517 // event_time = timeGetTime() - latency;
523 keyd_last_released = scancode;
524 keyd_pressed[scancode] = false;
525 key_data.NumUps[scancode]++;
527 if (event_time < key_data.TimeKeyWentDown[scancode])
528 key_data.TimeKeyHeldDown[scancode] = 0;
530 key_data.TimeKeyHeldDown[scancode] += event_time - key_data.TimeKeyWentDown[scancode];
533 keyd_last_pressed = scancode;
534 keyd_time_when_last_pressed = event_time;
535 if (!keyd_pressed[scancode]) {
537 key_data.TimeKeyWentDown[scancode] = event_time;
538 keyd_pressed[scancode] = true;
539 key_data.NumDowns[scancode]++;
540 key_data.down_check[scancode]++;
542 // mprintf(( "Scancode = %x\n", scancode ));
544 // if ( scancode == KEY_BREAK )
548 keycode = (unsigned short)scancode;
550 if (kmod & KMOD_SHIFT)
551 keycode |= KEY_SHIFTED;
554 keycode |= KEY_ALTED;
556 if (kmod & KMOD_CTRL)
557 keycode |= KEY_CTRLED;
560 if ( keyd_pressed[KEY_DEBUG_KEY] )
561 keycode |= KEY_DEBUGGED;
562 // if ( keycode == (KEY_BACKSP + KEY_DEBUGGED) ) {
564 // keyd_pressed[KEY_DEBUG_KEY] = 0;
565 // keyd_pressed[KEY_BACKSP] = 0;
569 if ( keyd_pressed[KEY_DEBUG_KEY] ) {
570 mprintf(("Cheats_enabled = %i, Key_normal_game = %i\n", Cheats_enabled, Key_normal_game));
571 if (Cheats_enabled && Key_normal_game) {
572 keycode |= KEY_DEBUGGED1;
579 temp = key_data.keytail+1;
580 if ( temp >= KEY_BUFFER_SIZE ) temp=0;
582 if (temp!=key_data.keyhead) {
583 int i, accept_key = 1;
584 // Num_filter_keys will only be non-zero when a key filter has
585 // been explicity set up via key_set_filter()
586 for ( i = 0; i < Num_filter_keys; i++ ) {
588 if ( Key_filter[i] == keycode ) {
595 key_data.keybuffer[key_data.keytail] = keycode;
596 key_data.time_pressed[key_data.keytail] = keyd_time_when_last_pressed;
597 key_data.keytail = temp;
603 LEAVE_CRITICAL_SECTION(&key_lock);
611 if ( Key_numlock_was_on ) {
612 key_turn_on_numlock();
613 Key_numlock_was_on = 0;
627 keyd_time_when_last_pressed = timer_get_milliseconds();
628 keyd_buffer_type = 1;
630 // Clear the keyboard array
639 void key_level_init()
643 for (i=0; i<SDL_NUM_SCANCODES; i++)
644 key_data.down_check[i] = 0;
647 void key_lost_focus()
663 // Restricts the keys that are accepted from the keyboard
665 // filter_array => array of keys to act as a filter
666 // num => number of keys in filter_array
668 void key_set_filter(int *filter_array, int num)
672 if ( num >= MAX_FILTER_KEYS ) {
674 num = MAX_FILTER_KEYS;
677 Num_filter_keys = num;
679 for ( i = 0; i < num; i++ ) {
680 Key_filter[i] = filter_array[i];
684 // Clear the key filter, so all keypresses are accepted from keyboard
686 void key_clear_filter()
691 for ( i = 0; i < MAX_FILTER_KEYS; i++ ) {