most of Q2's keyboard handling ported over - what this means: keypad is now separatel...
[divverent/darkplaces.git] / keys.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 #include "quakedef.h"
21
22 /*
23
24 key up events are sent even if in console mode
25
26 */
27
28
29 #define MAXCMDLINE 256
30 char key_lines[32][MAXCMDLINE];
31 int key_linepos;
32 int shift_down = false;
33 int key_insert; // insert key toggle (for editing)
34
35 int edit_line = 0;
36 int history_line = 0;
37
38 int key_consoleactive;
39 keydest_t key_dest;
40
41 char *keybindings[256];
42 qboolean consolekeys[256];      // if true, can't be rebound while in console
43 qboolean menubound[256];        // if true, can't be rebound while in menu
44 int keyshift[256];              // key to map to if shift held down in console
45 int key_repeats[256];   // if > 1, it is autorepeating
46 qboolean keydown[256];
47
48 typedef struct
49 {
50         char *name;
51         int keynum;
52 } keyname_t;
53
54 keyname_t keynames[] =
55 {
56         {"TAB", K_TAB},
57         {"ENTER", K_ENTER},
58         {"ESCAPE", K_ESCAPE},
59         {"SPACE", K_SPACE},
60         {"BACKSPACE", K_BACKSPACE},
61         {"UPARROW", K_UPARROW},
62         {"DOWNARROW", K_DOWNARROW},
63         {"LEFTARROW", K_LEFTARROW},
64         {"RIGHTARROW", K_RIGHTARROW},
65
66         {"ALT", K_ALT},
67         {"CTRL", K_CTRL},
68         {"SHIFT", K_SHIFT},
69
70         {"F1", K_F1},
71         {"F2", K_F2},
72         {"F3", K_F3},
73         {"F4", K_F4},
74         {"F5", K_F5},
75         {"F6", K_F6},
76         {"F7", K_F7},
77         {"F8", K_F8},
78         {"F9", K_F9},
79         {"F10", K_F10},
80         {"F11", K_F11},
81         {"F12", K_F12},
82
83         {"INS", K_INS},
84         {"DEL", K_DEL},
85         {"PGDN", K_PGDN},
86         {"PGUP", K_PGUP},
87         {"HOME", K_HOME},
88         {"END", K_END},
89
90         {"MOUSE1", K_MOUSE1},
91         {"MOUSE2", K_MOUSE2},
92         {"MOUSE3", K_MOUSE3},
93
94         {"JOY1", K_JOY1},
95         {"JOY2", K_JOY2},
96         {"JOY3", K_JOY3},
97         {"JOY4", K_JOY4},
98
99         {"AUX1", K_AUX1},
100         {"AUX2", K_AUX2},
101         {"AUX3", K_AUX3},
102         {"AUX4", K_AUX4},
103         {"AUX5", K_AUX5},
104         {"AUX6", K_AUX6},
105         {"AUX7", K_AUX7},
106         {"AUX8", K_AUX8},
107         {"AUX9", K_AUX9},
108         {"AUX10", K_AUX10},
109         {"AUX11", K_AUX11},
110         {"AUX12", K_AUX12},
111         {"AUX13", K_AUX13},
112         {"AUX14", K_AUX14},
113         {"AUX15", K_AUX15},
114         {"AUX16", K_AUX16},
115         {"AUX17", K_AUX17},
116         {"AUX18", K_AUX18},
117         {"AUX19", K_AUX19},
118         {"AUX20", K_AUX20},
119         {"AUX21", K_AUX21},
120         {"AUX22", K_AUX22},
121         {"AUX23", K_AUX23},
122         {"AUX24", K_AUX24},
123         {"AUX25", K_AUX25},
124         {"AUX26", K_AUX26},
125         {"AUX27", K_AUX27},
126         {"AUX28", K_AUX28},
127         {"AUX29", K_AUX29},
128         {"AUX30", K_AUX30},
129         {"AUX31", K_AUX31},
130         {"AUX32", K_AUX32},
131
132         {"KP_HOME",                     K_KP_HOME },
133         {"KP_UPARROW",          K_KP_UPARROW },
134         {"KP_PGUP",                     K_KP_PGUP },
135         {"KP_LEFTARROW",        K_KP_LEFTARROW },
136         {"KP_5",                        K_KP_5 },
137         {"KP_RIGHTARROW",       K_KP_RIGHTARROW },
138         {"KP_END",                      K_KP_END },
139         {"KP_DOWNARROW",        K_KP_DOWNARROW },
140         {"KP_PGDN",                     K_KP_PGDN },
141         {"KP_ENTER",            K_KP_ENTER },
142         {"KP_INS",                      K_KP_INS },
143         {"KP_DEL",                      K_KP_DEL },
144         {"KP_SLASH",            K_KP_SLASH },
145         {"KP_MINUS",            K_KP_MINUS },
146         {"KP_PLUS",                     K_KP_PLUS },
147
148         {"MWHEELUP", K_MWHEELUP },
149         {"MWHEELDOWN", K_MWHEELDOWN },
150
151         {"PAUSE", K_PAUSE},
152
153         {"SEMICOLON", ';'},     // because a raw semicolon seperates commands
154
155         {NULL,0}
156 };
157
158 /*
159 ==============================================================================
160
161                         LINE TYPING INTO THE CONSOLE
162
163 ==============================================================================
164 */
165
166
167 /*
168 ====================
169 Key_Console
170
171 Interactive line editing and console scrollback
172 ====================
173 */
174 void Key_Console (int key)
175 {
176         // LordHavoc: copied most of this from Q2 to improve keyboard handling
177         switch (key)
178         {
179         case K_KP_SLASH:
180                 key = '/';
181                 break;
182         case K_KP_MINUS:
183                 key = '-';
184                 break;
185         case K_KP_PLUS:
186                 key = '+';
187                 break;
188         case K_KP_HOME:
189                 key = '7';
190                 break;
191         case K_KP_UPARROW:
192                 key = '8';
193                 break;
194         case K_KP_PGUP:
195                 key = '9';
196                 break;
197         case K_KP_LEFTARROW:
198                 key = '4';
199                 break;
200         case K_KP_5:
201                 key = '5';
202                 break;
203         case K_KP_RIGHTARROW:
204                 key = '6';
205                 break;
206         case K_KP_END:
207                 key = '1';
208                 break;
209         case K_KP_DOWNARROW:
210                 key = '2';
211                 break;
212         case K_KP_PGDN:
213                 key = '3';
214                 break;
215         case K_KP_INS:
216                 key = '0';
217                 break;
218         case K_KP_DEL:
219                 key = '.';
220                 break;
221         }
222
223         // LordHavoc: FIXME: implement this sometime
224         #if 0
225         if ((toupper(key) == 'V' && keydown[K_CTRL]) || ((key == K_INS || key == K_KP_INS) && keydown[K_SHIFT]))
226         {
227                 char *cbd;
228                 if ((cbd = Sys_GetClipboardData()) != 0)
229                 {
230                         int i;
231                         strtok(cbd, "\n\r\b");
232                         i = strlen(cbd);
233                         if (i + key_linepos >= MAXCMDLINE)
234                                 i= MAXCMDLINE - key_linepos;
235                         if (i > 0)
236                         {
237                                 cbd[i]=0;
238                                 strcat(key_lines[edit_line], cbd);
239                                 key_linepos += i;
240                         }
241                         free(cbd);
242                 }
243                 return;
244         }
245         #endif
246
247         if (key == 'l')
248         {
249                 if (keydown[K_CTRL])
250                 {
251                         Cbuf_AddText ("clear\n");
252                         return;
253                 }
254         }
255
256         if (key == K_ENTER || key == K_KP_ENTER)
257         {
258                 Cbuf_AddText (key_lines[edit_line]+1);  // skip the ]
259                 Cbuf_AddText ("\n");
260                 Con_Printf ("%s\n",key_lines[edit_line]);
261                 edit_line = (edit_line + 1) & 31;
262                 history_line = edit_line;
263                 key_lines[edit_line][0] = ']';
264                 key_lines[edit_line][1] = 0;    // EvilTypeGuy: null terminate
265                 key_linepos = 1;
266                 // force an update, because the command may take some time
267                 if (cls.state == ca_disconnected)
268                 {
269                         CL_UpdateScreen ();
270                         CL_UpdateScreen ();
271                 }
272                 return;
273         }
274
275         if (key == K_TAB)
276         {
277                 // Enhanced command completion
278                 // by EvilTypeGuy eviltypeguy@qeradiant.com
279                 // Thanks to Fett, Taniwha
280                 Con_CompleteCommandLine();
281                 return;
282         }
283
284         // Advanced Console Editing by Radix radix@planetquake.com
285         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
286
287         // left arrow will just move left one without erasing, backspace will
288         // actually erase charcter
289         if (key == K_LEFTARROW || key == K_KP_LEFTARROW)
290         {
291                 if (key_linepos > 1)
292                         key_linepos--;
293                 return;
294         }
295
296         // delete char before cursor
297         if (key == K_BACKSPACE || (key == 'h' && keydown[K_CTRL]))
298         {
299                 if (key_linepos > 1)
300                 {
301                         strcpy(key_lines[edit_line] + key_linepos - 1, key_lines[edit_line] + key_linepos);
302                         key_linepos--;
303                 }
304                 return;
305         }
306
307         // delete char on cursor
308         if (key == K_DEL || key == K_KP_DEL)
309         {
310                 if ((size_t)key_linepos < strlen(key_lines[edit_line]))
311                         strcpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + 1);
312                 return;
313         }
314
315
316         // if we're at the end, get one character from previous line,
317         // otherwise just go right one
318         if (key == K_RIGHTARROW || key == K_KP_RIGHTARROW)
319         {
320                 if (strlen(key_lines[edit_line]) == (size_t)key_linepos)
321                 {
322                         if (strlen(key_lines[(edit_line + 31) & 31]) <= (size_t)key_linepos)
323                                 return; // no character to get
324
325                         key_lines[edit_line][key_linepos] = key_lines[(edit_line + 31) & 31][key_linepos];
326                         key_linepos++;
327                         key_lines[edit_line][key_linepos] = 0;
328                 }
329                 else
330                         key_linepos++;
331
332                 return;
333         }
334
335         if (key == K_INS || key == K_KP_INS) // toggle insert mode
336         {
337                 key_insert ^= 1;
338                 return;
339         }
340
341         // End Advanced Console Editing
342
343         if (key == K_UPARROW || key == K_KP_UPARROW || (key == 'p' && keydown[K_CTRL]))
344         {
345                 do
346                 {
347                         history_line = (history_line - 1) & 31;
348                 } while (history_line != edit_line
349                                 && !key_lines[history_line][1]);
350                 if (history_line == edit_line)
351                         history_line = (edit_line+1)&31;
352                 strcpy(key_lines[edit_line], key_lines[history_line]);
353                 key_linepos = strlen(key_lines[edit_line]);
354                 return;
355         }
356
357         if (key == K_DOWNARROW || key == K_KP_DOWNARROW || (key == 'n' && keydown[K_CTRL]))
358         {
359                 if (history_line == edit_line) return;
360                 do
361                 {
362                         history_line = (history_line + 1) & 31;
363                 }
364                 while (history_line != edit_line
365                         && !key_lines[history_line][1]);
366                 if (history_line == edit_line)
367                 {
368                         key_lines[edit_line][0] = ']';
369                         key_linepos = 1;
370                 }
371                 else
372                 {
373                         strcpy(key_lines[edit_line], key_lines[history_line]);
374                         key_linepos = strlen(key_lines[edit_line]);
375                 }
376                 return;
377         }
378
379         if (key == K_PGUP || key == K_KP_PGUP || key == K_MWHEELUP)
380         {
381                 con_backscroll += ((int) scr_conlines >> 4);
382                 if (con_backscroll > con_totallines - (vid.conheight>>3) - 1)
383                         con_backscroll = con_totallines - (vid.conheight>>3) - 1;
384                 return;
385         }
386
387         if (key == K_PGDN || key == K_KP_PGDN || key == K_MWHEELDOWN)
388         {
389                 con_backscroll -= ((int) scr_conlines >> 4);
390                 if (con_backscroll < 0)
391                         con_backscroll = 0;
392                 return;
393         }
394
395         if (key == K_HOME || key == K_KP_HOME)
396         {
397                 con_backscroll = con_totallines - (vid.conheight>>3) - 1;
398                 return;
399         }
400
401         if (key == K_END || key == K_KP_END)
402         {
403                 con_backscroll = 0;
404                 return;
405         }
406
407         // non printable
408         if (key < 32 || key > 127)
409                 return;
410
411         if (key_linepos < MAXCMDLINE-1)
412         {
413                 int i;
414
415                 if (key_insert) // check insert mode
416                 {
417                         // can't do strcpy to move string to right
418                         i = strlen(key_lines[edit_line]) - 1;
419
420                         if (i == 254)
421                                 i--;
422
423                         for (; i >= key_linepos; i--)
424                                 key_lines[edit_line][i + 1] = key_lines[edit_line][i];
425                 }
426
427                 // only null terminate if at the end
428                 i = key_lines[edit_line][key_linepos];
429                 key_lines[edit_line][key_linepos] = key;
430                 key_linepos++;
431
432                 if (!i)
433                         key_lines[edit_line][key_linepos] = 0;
434         }
435 }
436
437 //============================================================================
438
439 // LordHavoc: increased messagemode length (was 32)
440 qboolean chat_team = false;
441 char chat_buffer[256];
442 int chat_bufferlen = 0;
443
444 void Key_Message (int key)
445 {
446         if (key == K_ENTER || key == K_KP_ENTER)
447         {
448                 if (chat_team)
449                         Cbuf_AddText ("say_team \"");
450                 else
451                         Cbuf_AddText ("say \"");
452                 Cbuf_AddText(chat_buffer);
453                 Cbuf_AddText("\"\n");
454
455                 key_dest = key_game;
456                 chat_bufferlen = 0;
457                 chat_buffer[0] = 0;
458                 return;
459         }
460
461         if (key == K_ESCAPE)
462         {
463                 key_dest = key_game;
464                 chat_bufferlen = 0;
465                 chat_buffer[0] = 0;
466                 return;
467         }
468
469         // non printable
470         if (key < 32 || key > 127)
471                 return;
472
473         if (key == K_BACKSPACE)
474         {
475                 if (chat_bufferlen)
476                 {
477                         chat_bufferlen--;
478                         chat_buffer[chat_bufferlen] = 0;
479                 }
480                 return;
481         }
482
483         if (chat_bufferlen == sizeof(chat_buffer) - 1)
484                 return; // all full
485
486         chat_buffer[chat_bufferlen++] = key;
487         chat_buffer[chat_bufferlen] = 0;
488 }
489
490 //============================================================================
491
492
493 /*
494 ===================
495 Key_StringToKeynum
496
497 Returns a key number to be used to index keybindings[] by looking at
498 the given string.  Single ascii characters return themselves, while
499 the K_* names are matched up.
500 ===================
501 */
502 int Key_StringToKeynum (const char *str)
503 {
504         keyname_t *kn;
505
506         if (!str || !str[0])
507                 return -1;
508         if (!str[1])
509                 return str[0];
510
511         for (kn=keynames ; kn->name ; kn++)
512                 if (!Q_strcasecmp(str,kn->name))
513                         return kn->keynum;
514         return -1;
515 }
516
517 /*
518 ===================
519 Key_KeynumToString
520
521 Returns a string (either a single ascii char, or a K_* name) for the
522 given keynum.
523 FIXME: handle quote special (general escape sequence?)
524 ===================
525 */
526 char *Key_KeynumToString (int keynum)
527 {
528         keyname_t *kn;
529         static char tinystr[2];
530
531         if (keynum == -1)
532                 return "<KEY NOT FOUND>";
533         if (keynum > 32 && keynum < 127)
534         {       // printable ascii
535                 tinystr[0] = keynum;
536                 tinystr[1] = 0;
537                 return tinystr;
538         }
539
540         for (kn=keynames ; kn->name ; kn++)
541                 if (keynum == kn->keynum)
542                         return kn->name;
543
544         return "<UNKNOWN KEYNUM>";
545 }
546
547
548 /*
549 ===================
550 Key_SetBinding
551 ===================
552 */
553 void Key_SetBinding (int keynum, char *binding)
554 {
555         char *new;
556         int l;
557
558         if (keynum < 0 || keynum >= 256)
559                 return;
560
561 // free old bindings
562         if (keybindings[keynum])
563         {
564                 Z_Free (keybindings[keynum]);
565                 keybindings[keynum] = NULL;
566         }
567
568 // allocate memory for new binding
569         l = strlen (binding);
570         new = Z_Malloc (l+1);
571         strcpy (new, binding);
572         new[l] = 0;
573         keybindings[keynum] = new;
574 }
575
576 /*
577 ===================
578 Key_Unbind_f
579 ===================
580 */
581 void Key_Unbind_f (void)
582 {
583         int b;
584
585         if (Cmd_Argc() != 2)
586         {
587                 Con_Printf ("unbind <key> : remove commands from a key\n");
588                 return;
589         }
590
591         b = Key_StringToKeynum (Cmd_Argv(1));
592         if (b == -1)
593         {
594                 Con_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
595                 return;
596         }
597
598         Key_SetBinding (b, "");
599 }
600
601 void Key_Unbindall_f (void)
602 {
603         int i;
604
605         for (i = 0;i < 256;i++)
606                 if (keybindings[i])
607                         Key_SetBinding (i, "");
608 }
609
610
611 /*
612 ===================
613 Key_Bind_f
614 ===================
615 */
616 void Key_Bind_f (void)
617 {
618         int i, c, b;
619         char cmd[1024];
620
621         c = Cmd_Argc();
622
623         if (c != 2 && c != 3)
624         {
625                 Con_Printf ("bind <key> [command] : attach a command to a key\n");
626                 return;
627         }
628         b = Key_StringToKeynum (Cmd_Argv(1));
629         if (b == -1)
630         {
631                 Con_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
632                 return;
633         }
634
635         if (c == 2)
636         {
637                 if (keybindings[b])
638                         Con_Printf ("\"%s\" = \"%s\"\n", Cmd_Argv(1), keybindings[b] );
639                 else
640                         Con_Printf ("\"%s\" is not bound\n", Cmd_Argv(1) );
641                 return;
642         }
643
644 // copy the rest of the command line
645         // start out with a null string
646         cmd[0] = 0;
647         for (i=2 ; i< c ; i++)
648         {
649                 if (i > 2)
650                         strcat (cmd, " ");
651                 strcat (cmd, Cmd_Argv(i));
652         }
653
654         Key_SetBinding (b, cmd);
655 }
656
657 /*
658 ============
659 Key_WriteBindings
660
661 Writes lines containing "bind key value"
662 ============
663 */
664 void Key_WriteBindings (QFile *f)
665 {
666         int i;
667
668         for (i = 0;i < 256;i++)
669                 if (keybindings[i] && *keybindings[i])
670                         Qprintf (f, "bind \"%s\" \"%s\"\n", Key_KeynumToString(i), keybindings[i]);
671 }
672
673
674 /*
675 ============
676 Key_Bindlist_f
677
678 ============
679 */
680 void Key_Bindlist_f (void)
681 {
682         int i;
683
684         for (i = 0;i < 256;i++)
685                 if (keybindings[i] && keybindings[i][0])
686                         Con_Printf ("%s \"%s\"\n", Key_KeynumToString(i), keybindings[i]);
687 }
688
689
690 /*
691 ===================
692 Key_Init
693 ===================
694 */
695 void Key_Init (void)
696 {
697         int i;
698
699         // LordHavoc: clear keybindings array so bounds checking won't freak
700         for (i = 0;i < 256;i++)
701                 keybindings[i] = NULL;
702
703         for (i = 0;i < 32;i++)
704         {
705                 key_lines[i][0] = ']';
706                 key_lines[i][1] = 0;
707         }
708         key_linepos = 1;
709
710 //
711 // init ascii characters in console mode
712 //
713         for (i = 32;i < 128;i++)
714                 consolekeys[i] = true;
715         consolekeys[K_ENTER] = true;consolekeys[K_KP_ENTER] = true;
716         consolekeys[K_TAB] = true;
717         consolekeys[K_LEFTARROW] = true;consolekeys[K_KP_LEFTARROW] = true;
718         consolekeys[K_RIGHTARROW] = true;consolekeys[K_KP_RIGHTARROW] = true;
719         consolekeys[K_UPARROW] = true;consolekeys[K_KP_UPARROW] = true;
720         consolekeys[K_DOWNARROW] = true;consolekeys[K_KP_DOWNARROW] = true;
721         consolekeys[K_BACKSPACE] = true;
722         consolekeys[K_HOME] = true;consolekeys[K_KP_HOME] = true;
723         consolekeys[K_END] = true;consolekeys[K_KP_END] = true;
724         consolekeys[K_PGUP] = true;consolekeys[K_KP_PGUP] = true;
725         consolekeys[K_PGDN] = true;consolekeys[K_KP_PGDN] = true;
726         consolekeys[K_SHIFT] = true;
727         consolekeys[K_INS] = true;consolekeys[K_KP_INS] = true;
728         consolekeys[K_DEL] = true;consolekeys[K_KP_DEL] = true;
729         consolekeys[K_KP_SLASH] = true;
730         consolekeys[K_KP_PLUS] = true;
731         consolekeys[K_KP_MINUS] = true;
732         consolekeys[K_KP_5] = true;
733         consolekeys[K_MWHEELUP] = true;
734         consolekeys[K_MWHEELDOWN] = true;
735
736         consolekeys['`'] = false;
737         consolekeys['~'] = false;
738
739         for (i = 0;i < 256;i++)
740                 keyshift[i] = i;
741         for (i = 'a';i <= 'z';i++)
742                 keyshift[i] = i - 'a' + 'A';
743         keyshift['1'] = '!';
744         keyshift['2'] = '@';
745         keyshift['3'] = '#';
746         keyshift['4'] = '$';
747         keyshift['5'] = '%';
748         keyshift['6'] = '^';
749         keyshift['7'] = '&';
750         keyshift['8'] = '*';
751         keyshift['9'] = '(';
752         keyshift['0'] = ')';
753         keyshift['-'] = '_';
754         keyshift['='] = '+';
755         keyshift[','] = '<';
756         keyshift['.'] = '>';
757         keyshift['/'] = '?';
758         keyshift[';'] = ':';
759         keyshift['\''] = '"';
760         keyshift['['] = '{';
761         keyshift[']'] = '}';
762         keyshift['`'] = '~';
763         keyshift['\\'] = '|';
764
765         menubound[K_ESCAPE] = true;
766         for (i=0 ; i<12 ; i++)
767                 menubound[K_F1+i] = true;
768
769 //
770 // register our functions
771 //
772         Cmd_AddCommand ("bind",Key_Bind_f);
773         Cmd_AddCommand ("unbind",Key_Unbind_f);
774         Cmd_AddCommand ("unbindall",Key_Unbindall_f);
775         Cmd_AddCommand ("bindlist",Key_Bindlist_f);
776 }
777
778 /*
779 ===================
780 Key_Event
781
782 Called by the system between frames for both key up and key down events
783 Should NOT be called during an interrupt!
784 ===================
785 */
786 void Key_Event (int key, qboolean down)
787 {
788         char    *kb;
789         char    cmd[1024];
790
791         keydown[key] = down;
792
793         // update auto-repeat status
794         if (down)
795         {
796                 key_repeats[key]++;
797                 if (key != K_BACKSPACE
798                  && key != K_PAUSE
799                  && key != K_PGUP
800                  && key != K_KP_PGUP
801                  && key != K_PGDN
802                  && key != K_KP_PGDN
803                  && key_repeats[key] > 1)
804                         return; // ignore most autorepeats
805
806                 if (key >= 200 && !keybindings[key])
807                         Con_Printf ("%s is unbound, hit F4 to set.\n", Key_KeynumToString (key));
808         }
809         else
810                 key_repeats[key] = 0;
811
812         if (key == K_SHIFT)
813                 shift_down = down;
814
815 //
816 // handle escape specialy, so the user can never unbind it
817 //
818         if (key == K_ESCAPE)
819         {
820                 if (!down)
821                         return;
822                 switch (key_dest)
823                 {
824                 case key_message:
825                         Key_Message (key);
826                         break;
827                 case key_menu:
828                         M_Keydown (key);
829                         break;
830                 case key_game:
831                         M_ToggleMenu_f ();
832                         break;
833                 default:
834                         Sys_Error ("Bad key_dest");
835                 }
836                 return;
837         }
838
839         // console key is hardcoded, so the user can never unbind it
840         if (key == '`' || key == '~')
841         {
842                 if (down)
843                         Con_ToggleConsole_f ();
844                 return;
845         }
846
847         if (down)
848         {
849                 kb = keybindings[key];
850                 if (kb && !strncmp(kb, "toggleconsole", strlen("toggleconsole")))
851                 {
852                         Cbuf_AddText (kb);
853                         Cbuf_AddText ("\n");
854                         return;
855                 }
856         }
857
858         if (key_consoleactive && consolekeys[key])
859         {
860                 // console only wants key down events
861                 if (!down)
862                         return;
863
864                 // FIXME: this does not support non-QWERTY keyboards
865                 if (shift_down)
866                         key = keyshift[key];
867
868                 Key_Console (key);
869         }
870         else
871         {
872                 //
873                 // key up events only generate commands if the game key binding is
874                 // a button command (leading + sign).  These will occur even in console mode,
875                 // to keep the character from continuing an action started before a console
876                 // switch.  Button commands include the keynum as a parameter, so multiple
877                 // downs can be matched with ups
878                 //
879                 if (!down)
880                 {
881                         kb = keybindings[key];
882                         if (kb && kb[0] == '+')
883                         {
884                                 sprintf (cmd, "-%s %i\n", kb+1, key);
885                                 Cbuf_AddText (cmd);
886                         }
887                         if (keyshift[key] != key)
888                         {
889                                 kb = keybindings[keyshift[key]];
890                                 if (kb && kb[0] == '+')
891                                 {
892                                         sprintf (cmd, "-%s %i\n", kb+1, key);
893                                         Cbuf_AddText (cmd);
894                                 }
895                         }
896                         return;
897                 }
898
899                 //
900                 // during demo playback, most keys bring up the main menu
901                 //
902                 if (cls.demoplayback && down && consolekeys[key] && key_dest == key_game)
903                         key = K_ESCAPE;
904
905                 //
906                 // if not a consolekey, send to the interpreter no matter what mode is
907                 //
908                 if ((key_consoleactive && !consolekeys[key])
909                  || (key_dest == key_menu && menubound[key])
910                  || key_dest == key_game)
911                 {
912                         kb = keybindings[key];
913                         if (kb)
914                         {
915                                 if (kb[0] == '+')
916                                 {
917                                         // button commands add keynum as a parm
918                                         sprintf (cmd, "%s %i\n", kb, key);
919                                         Cbuf_AddText (cmd);
920                                 }
921                                 else
922                                 {
923                                         Cbuf_AddText (kb);
924                                         Cbuf_AddText ("\n");
925                                 }
926                         }
927                         return;
928                 }
929
930                 if (!down)
931                         return;         // other systems only care about key down events
932
933                 // FIXME: this does not support non-QWERTY keyboards
934                 if (shift_down)
935                         key = keyshift[key];
936
937                 switch (key_dest)
938                 {
939                 case key_message:
940                         Key_Message (key);
941                         break;
942                 case key_menu:
943                         M_Keydown (key);
944                         break;
945
946                 case key_game:
947                 //case key_console:
948                         Key_Console (key);
949                         break;
950                 default:
951                         Sys_Error ("Bad key_dest");
952                 }
953         }
954 }
955
956
957 /*
958 ===================
959 Key_ClearStates
960 ===================
961 */
962 void Key_ClearStates (void)
963 {
964         int i;
965
966         for (i = 0;i < 256;i++)
967         {
968                 keydown[i] = false;
969                 key_repeats[i] = 0;
970         }
971 }
972