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
174 #include "localize.h"
176 #define KEY_BUFFER_SIZE 16
178 //-------- Variable accessed by outside functions ---------
179 ubyte keyd_buffer_type; // 0=No buffer, 1=buffer ASCII, 2=buffer scans
181 uint keyd_last_pressed;
182 uint keyd_last_released;
183 int keyd_time_when_last_pressed;
185 static bool keyd_pressed[SDL_NUM_SCANCODES];
187 typedef struct keyboard {
188 ushort keybuffer[KEY_BUFFER_SIZE];
189 uint time_pressed[KEY_BUFFER_SIZE];
190 uint TimeKeyWentDown[SDL_NUM_SCANCODES];
191 uint TimeKeyHeldDown[SDL_NUM_SCANCODES];
192 uint TimeKeyDownChecked[SDL_NUM_SCANCODES];
193 uint NumDowns[SDL_NUM_SCANCODES];
194 uint NumUps[SDL_NUM_SCANCODES];
195 int down_check[SDL_NUM_SCANCODES]; // nonzero if has been pressed yet this mission
196 uint keyhead, keytail;
203 //int Backspace_debug=1; // global flag that will enable/disable the backspace key from stopping execution
204 // This flag was created since the backspace key is also used to correct mistakes
205 // when typing in your pilots callsign. This global flag is checked before execution
208 // used to limit the keypresses that are accepted from the keyboard
209 #define MAX_FILTER_KEYS 64
211 int Key_filter[MAX_FILTER_KEYS];
213 static int Key_numlock_was_on = 0; // Flag to indicate whether NumLock is on at start
215 int Cheats_enabled = 0;
216 int Key_normal_game = 0;
218 static std::deque<int> key_text_input;
221 void key_set_text_input(int ch)
223 key_text_input.push_back(ch);
226 int key_get_text_input()
228 if ( key_text_input.empty() ) {
232 int ch = key_text_input.front();
234 key_text_input.pop_front();
239 bool key_pressed(int keycode)
241 SDL_Scancode scancode = SDL_GetScancodeFromKey(keycode & KEY_MASK);
243 return keyd_pressed[scancode];
246 int key_numlock_is_on()
249 state = SDL_GetKeyboardState(NULL);
250 if ( state[SDL_SCANCODE_NUMLOCKCLEAR] ) {
257 void key_turn_off_numlock()
261 void key_turn_on_numlock()
265 // checks if a keycode is ASCII printable or not
266 // returns true if ASCII, false if not
267 bool key_is_ascii(int keycode)
269 // bail on non-printable keycodes
270 if (keycode & SDLK_SCANCODE_MASK) {
276 // this is definitely never come back to bite me in the ass
277 if ( ((keycode >= SDLK_SPACE) && (keycode <= SDLK_AT))
278 || ((keycode >= SDLK_LEFTBRACKET) && (keycode <= SDLK_z)) )
286 // Flush the keyboard buffer.
287 // Clear the keyboard array (keyd_pressed).
293 if ( !key_inited ) return;
295 key_data.keyhead = key_data.keytail = 0;
297 //Clear the keyboard buffer
298 for (i=0; i<KEY_BUFFER_SIZE; i++ ) {
299 key_data.keybuffer[i] = 0;
300 key_data.time_pressed[i] = 0;
303 //Clear the keyboard array
305 CurTime = timer_get_milliseconds();
308 for (i=0; i<SDL_NUM_SCANCODES; i++ ) {
309 keyd_pressed[i] = false;
310 key_data.TimeKeyDownChecked[i] = CurTime;
311 key_data.TimeKeyWentDown[i] = CurTime;
312 key_data.TimeKeyHeldDown[i] = 0;
313 key_data.NumDowns[i]=0;
314 key_data.NumUps[i]=0;
317 key_text_input.clear();
320 // A nifty function which performs the function:
321 // n = (n+1) % KEY_BUFFER_SIZE
322 // (assuming positive values of n).
326 if ( n >= KEY_BUFFER_SIZE ) n=0;
330 // Returns 1 if character waiting... 0 otherwise
333 int is_one_waiting = 0;
335 if ( !key_inited ) return 0;
337 if (key_data.keytail != key_data.keyhead){
341 return is_one_waiting;
344 // Return keycode if a key has been pressed,
346 // Reads keys out of the key buffer and updates keyhead.
349 SDL_Scancode scancode = SDL_SCANCODE_UNKNOWN;
355 if (key_data.keytail != key_data.keyhead) {
356 scancode = (SDL_Scancode)key_data.keybuffer[key_data.keyhead];
357 key_data.keyhead = add_one(key_data.keyhead);
362 // need to strip key mod state for keycode lookup
363 mod = (scancode & 0xf900);
364 keycode = SDL_GetKeyFromScancode((SDL_Scancode)(scancode & KEY_MASK));
366 return (keycode | mod);
369 // If not installed, uses BIOS and returns getch();
370 // Else returns pending key (or waits for one if none waiting).
376 if ( !key_inited ) return 0;
378 while (!key_checkch()){
388 // Set global shift_status with modifier results (shift, ctrl, alt).
389 uint key_get_shift_status()
391 unsigned int shift_status = 0;
396 SDL_Keymod kmod = SDL_GetModState();
398 if (kmod & KMOD_SHIFT)
399 shift_status |= KEY_SHIFTED;
402 shift_status |= KEY_ALTED;
404 if (kmod & KMOD_CTRL)
405 shift_status |= KEY_CTRLED;
408 if (key_pressed(KEY_DEBUG_KEY))
409 shift_status |= KEY_DEBUGGED;
411 if (key_pressed(KEY_DEBUG_KEY)) {
412 mprintf(("Cheats_enabled = %i, Key_normal_game = %i\n", Cheats_enabled, Key_normal_game));
413 if ((Cheats_enabled) && Key_normal_game) {
414 mprintf(("Debug key\n"));
415 shift_status |= KEY_DEBUGGED1;
423 // Returns amount of time key (specified by "keycode") has been down since last call.
424 // Returns float, unlike key_down_time() which returns a fix.
425 float key_down_timef(int keycode)
427 uint time_down, time;
429 SDL_Scancode scancode;
434 scancode = SDL_GetScancodeFromKey(keycode & KEY_MASK);
436 if (scancode == SDL_SCANCODE_UNKNOWN)
439 time = timer_get_milliseconds();
440 delta_time = time - key_data.TimeKeyDownChecked[scancode];
441 key_data.TimeKeyDownChecked[scancode] = time;
443 if ( delta_time <= 1 ) {
444 key_data.TimeKeyWentDown[scancode] = time;
445 if (keyd_pressed[scancode]) {
452 if ( !keyd_pressed[scancode] ) {
453 time_down = key_data.TimeKeyHeldDown[scancode];
454 key_data.TimeKeyHeldDown[scancode] = 0;
456 time_down = time - key_data.TimeKeyWentDown[scancode];
457 key_data.TimeKeyWentDown[scancode] = time;
460 return i2fl(time_down) / i2fl(delta_time);
463 // Returns number of times key has went from up to down since last call.
464 int key_down_count(int keycode)
467 SDL_Scancode scancode;
472 scancode = SDL_GetScancodeFromKey(keycode & KEY_MASK);
474 if (scancode == SDL_SCANCODE_UNKNOWN)
477 n = key_data.NumDowns[scancode];
478 key_data.NumDowns[scancode] = 0;
484 // Returns number of times key has went from down to up since last call.
485 int key_up_count(int keycode)
488 SDL_Scancode scancode;
493 scancode = SDL_GetScancodeFromKey(keycode & KEY_MASK);
495 if (scancode == SDL_SCANCODE_UNKNOWN)
498 n = key_data.NumUps[scancode];
499 key_data.NumUps[scancode] = 0;
504 int key_check(int keycode)
506 SDL_Scancode scancode = SDL_GetScancodeFromKey(keycode & KEY_MASK);
508 return key_data.down_check[scancode];
511 // Add a key up or down code to the key buffer. state=1 -> down, state=0 -> up
512 // latency => time difference in ms between when key was actually pressed and now
513 //void key_mark( uint code, int state )
514 void key_mark(SDL_Scancode scancode, int state, ushort kmod, uint latency )
516 uint breakbit, temp, event_time;
519 if ( !key_inited ) return;
521 SDL_assert( scancode < SDL_NUM_SCANCODES );
523 // ignore GUI key, we use it for specials commands
524 if ( (scancode == SDL_SCANCODE_LGUI) || (scancode == SDL_SCANCODE_RGUI) ) {
528 // for Mac keyboard, make F13 be printscreen
529 if (scancode == SDL_SCANCODE_F13) {
530 scancode = SDL_SCANCODE_PRINTSCREEN;
533 event_time = timer_get_milliseconds() - latency;
534 // event_time = timeGetTime() - latency;
540 keyd_last_released = scancode;
541 keyd_pressed[scancode] = false;
542 key_data.NumUps[scancode]++;
544 if (event_time < key_data.TimeKeyWentDown[scancode])
545 key_data.TimeKeyHeldDown[scancode] = 0;
547 key_data.TimeKeyHeldDown[scancode] += event_time - key_data.TimeKeyWentDown[scancode];
550 keyd_last_pressed = scancode;
551 keyd_time_when_last_pressed = event_time;
552 if (!keyd_pressed[scancode]) {
554 key_data.TimeKeyWentDown[scancode] = event_time;
555 keyd_pressed[scancode] = true;
556 key_data.NumDowns[scancode]++;
557 key_data.down_check[scancode]++;
559 // mprintf(( "Scancode = %x\n", scancode ));
561 // if ( scancode == KEY_BREAK )
565 keycode = (unsigned short)scancode;
567 if (kmod & KMOD_SHIFT)
568 keycode |= KEY_SHIFTED;
571 keycode |= KEY_ALTED;
573 if (kmod & KMOD_CTRL)
574 keycode |= KEY_CTRLED;
577 if ( key_pressed(KEY_DEBUG_KEY) )
578 keycode |= KEY_DEBUGGED;
580 // if ( keycode == (KEY_BACKSP + KEY_DEBUGGED) ) {
582 // keyd_pressed[KEY_DEBUG_KEY] = 0;
583 // keyd_pressed[KEY_BACKSP] = 0;
587 if ( key_pressed(KEY_DEBUG_KEY) ) {
588 mprintf(("Cheats_enabled = %i, Key_normal_game = %i\n", Cheats_enabled, Key_normal_game));
589 if (Cheats_enabled && Key_normal_game) {
590 keycode |= KEY_DEBUGGED1;
597 temp = key_data.keytail+1;
598 if ( temp >= KEY_BUFFER_SIZE ) temp=0;
600 if (temp!=key_data.keyhead) {
601 int i, accept_key = 1;
602 // Num_filter_keys will only be non-zero when a key filter has
603 // been explicity set up via key_set_filter()
604 for ( i = 0; i < Num_filter_keys; i++ ) {
606 if ( Key_filter[i] == keycode ) {
613 key_data.keybuffer[key_data.keytail] = keycode;
614 key_data.time_pressed[key_data.keytail] = keyd_time_when_last_pressed;
615 key_data.keytail = temp;
627 if ( Key_numlock_was_on ) {
628 key_turn_on_numlock();
629 Key_numlock_was_on = 0;
643 keyd_time_when_last_pressed = timer_get_milliseconds();
644 keyd_buffer_type = 1;
646 // Clear the keyboard array
655 void key_level_init()
659 for (i=0; i<SDL_NUM_SCANCODES; i++)
660 key_data.down_check[i] = 0;
663 void key_lost_focus()
679 // Restricts the keys that are accepted from the keyboard
681 // filter_array => array of keys to act as a filter
682 // num => number of keys in filter_array
684 void key_set_filter(int *filter_array, int num)
688 if ( num >= MAX_FILTER_KEYS ) {
690 num = MAX_FILTER_KEYS;
693 Num_filter_keys = num;
695 for ( i = 0; i < num; i++ ) {
696 Key_filter[i] = filter_array[i];
700 // Clear the key filter, so all keypresses are accepted from keyboard
702 void key_clear_filter()
707 for ( i = 0; i < MAX_FILTER_KEYS; i++ ) {