keys.h File Reference

#include <stddef.h>
#include "qtypes.h"
#include "qdefs.h"
#include "fs.h"
#include "cmd.h"

Include dependency graph for keys.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	KEY_CONSOLEACTIVE_FORCED   4
#define	KEY_CONSOLEACTIVE_USER   1
#define	MAX_KEY_BINDS   0xAC00
#define	TINYSTR_LEN   4

Enumerations
enum	keydest_t {   key_game , key_message , key_menu , key_menu_grabbed ,   key_console , key_void }
enum	keynum_t {   K_TEXT = 1 , K_TAB = 9 , K_ENTER = 13 , K_ESCAPE = 27 ,   K_SPACE = 32 , K_BACKSPACE = 127 , K_UPARROW , K_DOWNARROW ,   K_LEFTARROW , K_RIGHTARROW , K_ALT , K_CTRL ,   K_SHIFT , K_F1 , K_F2 , K_F3 ,   K_F4 , K_F5 , K_F6 , K_F7 ,   K_F8 , K_F9 , K_F10 , K_F11 ,   K_F12 , K_INS , K_DEL , K_PGDN ,   K_PGUP , K_HOME , K_END , K_PAUSE ,   K_NUMLOCK , K_CAPSLOCK , K_SCROLLOCK , K_KP_0 ,   K_KP_INS = K_KP_0 , K_KP_1 , K_KP_END = K_KP_1 , K_KP_2 ,   K_KP_DOWNARROW = K_KP_2 , K_KP_3 , K_KP_PGDN = K_KP_3 , K_KP_4 ,   K_KP_LEFTARROW = K_KP_4 , K_KP_5 , K_KP_6 , K_KP_RIGHTARROW = K_KP_6 ,   K_KP_7 , K_KP_HOME = K_KP_7 , K_KP_8 , K_KP_UPARROW = K_KP_8 ,   K_KP_9 , K_KP_PGUP = K_KP_9 , K_KP_PERIOD , K_KP_DEL = K_KP_PERIOD ,   K_KP_DIVIDE , K_KP_SLASH = K_KP_DIVIDE , K_KP_MULTIPLY , K_KP_MINUS ,   K_KP_PLUS , K_KP_ENTER , K_KP_EQUALS , K_PRINTSCREEN ,   K_MOUSE1 = 512 , K_OTHERDEVICESBEGIN = K_MOUSE1 , K_MOUSE2 , K_MOUSE3 ,   K_MWHEELUP , K_MWHEELDOWN , K_MOUSE4 , K_MOUSE5 ,   K_MOUSE6 , K_MOUSE7 , K_MOUSE8 , K_MOUSE9 ,   K_MOUSE10 , K_MOUSE11 , K_MOUSE12 , K_MOUSE13 ,   K_MOUSE14 , K_MOUSE15 , K_MOUSE16 , K_JOY1 = 768 ,   K_JOY2 , K_JOY3 , K_JOY4 , K_JOY5 ,   K_JOY6 , K_JOY7 , K_JOY8 , K_JOY9 ,   K_JOY10 , K_JOY11 , K_JOY12 , K_JOY13 ,   K_JOY14 , K_JOY15 , K_JOY16 , K_AUX1 ,   K_AUX2 , K_AUX3 , K_AUX4 , K_AUX5 ,   K_AUX6 , K_AUX7 , K_AUX8 , K_AUX9 ,   K_AUX10 , K_AUX11 , K_AUX12 , K_AUX13 ,   K_AUX14 , K_AUX15 , K_AUX16 , K_AUX17 ,   K_AUX18 , K_AUX19 , K_AUX20 , K_AUX21 ,   K_AUX22 , K_AUX23 , K_AUX24 , K_AUX25 ,   K_AUX26 , K_AUX27 , K_AUX28 , K_AUX29 ,   K_AUX30 , K_AUX31 , K_AUX32 , K_X360_DPAD_UP ,   K_X360_DPAD_DOWN , K_X360_DPAD_LEFT , K_X360_DPAD_RIGHT , K_X360_START ,   K_X360_BACK , K_X360_LEFT_THUMB , K_X360_RIGHT_THUMB , K_X360_LEFT_SHOULDER ,   K_X360_RIGHT_SHOULDER , K_X360_A , K_X360_B , K_X360_X ,   K_X360_Y , K_X360_LEFT_TRIGGER , K_X360_RIGHT_TRIGGER , K_X360_LEFT_THUMB_UP ,   K_X360_LEFT_THUMB_DOWN , K_X360_LEFT_THUMB_LEFT , K_X360_LEFT_THUMB_RIGHT , K_X360_RIGHT_THUMB_UP ,   K_X360_RIGHT_THUMB_DOWN , K_X360_RIGHT_THUMB_LEFT , K_X360_RIGHT_THUMB_RIGHT , K_JOY_UP ,   K_JOY_DOWN , K_JOY_LEFT , K_JOY_RIGHT , K_MIDINOTE0 = 896 ,   K_MIDINOTE1 , K_MIDINOTE2 , K_MIDINOTE3 , K_MIDINOTE4 ,   K_MIDINOTE5 , K_MIDINOTE6 , K_MIDINOTE7 , K_MIDINOTE8 ,   K_MIDINOTE9 , K_MIDINOTE10 , K_MIDINOTE11 , K_MIDINOTE12 ,   K_MIDINOTE13 , K_MIDINOTE14 , K_MIDINOTE15 , K_MIDINOTE16 ,   K_MIDINOTE17 , K_MIDINOTE18 , K_MIDINOTE19 , K_MIDINOTE20 ,   K_MIDINOTE21 , K_MIDINOTE22 , K_MIDINOTE23 , K_MIDINOTE24 ,   K_MIDINOTE25 , K_MIDINOTE26 , K_MIDINOTE27 , K_MIDINOTE28 ,   K_MIDINOTE29 , K_MIDINOTE30 , K_MIDINOTE31 , K_MIDINOTE32 ,   K_MIDINOTE33 , K_MIDINOTE34 , K_MIDINOTE35 , K_MIDINOTE36 ,   K_MIDINOTE37 , K_MIDINOTE38 , K_MIDINOTE39 , K_MIDINOTE40 ,   K_MIDINOTE41 , K_MIDINOTE42 , K_MIDINOTE43 , K_MIDINOTE44 ,   K_MIDINOTE45 , K_MIDINOTE46 , K_MIDINOTE47 , K_MIDINOTE48 ,   K_MIDINOTE49 , K_MIDINOTE50 , K_MIDINOTE51 , K_MIDINOTE52 ,   K_MIDINOTE53 , K_MIDINOTE54 , K_MIDINOTE55 , K_MIDINOTE56 ,   K_MIDINOTE57 , K_MIDINOTE58 , K_MIDINOTE59 , K_MIDINOTE60 ,   K_MIDINOTE61 , K_MIDINOTE62 , K_MIDINOTE63 , K_MIDINOTE64 ,   K_MIDINOTE65 , K_MIDINOTE66 , K_MIDINOTE67 , K_MIDINOTE68 ,   K_MIDINOTE69 , K_MIDINOTE70 , K_MIDINOTE71 , K_MIDINOTE72 ,   K_MIDINOTE73 , K_MIDINOTE74 , K_MIDINOTE75 , K_MIDINOTE76 ,   K_MIDINOTE77 , K_MIDINOTE78 , K_MIDINOTE79 , K_MIDINOTE80 ,   K_MIDINOTE81 , K_MIDINOTE82 , K_MIDINOTE83 , K_MIDINOTE84 ,   K_MIDINOTE85 , K_MIDINOTE86 , K_MIDINOTE87 , K_MIDINOTE88 ,   K_MIDINOTE89 , K_MIDINOTE90 , K_MIDINOTE91 , K_MIDINOTE92 ,   K_MIDINOTE93 , K_MIDINOTE94 , K_MIDINOTE95 , K_MIDINOTE96 ,   K_MIDINOTE97 , K_MIDINOTE98 , K_MIDINOTE99 , K_MIDINOTE100 ,   K_MIDINOTE101 , K_MIDINOTE102 , K_MIDINOTE103 , K_MIDINOTE104 ,   K_MIDINOTE105 , K_MIDINOTE106 , K_MIDINOTE107 , K_MIDINOTE108 ,   K_MIDINOTE109 , K_MIDINOTE110 , K_MIDINOTE111 , K_MIDINOTE112 ,   K_MIDINOTE113 , K_MIDINOTE114 , K_MIDINOTE115 , K_MIDINOTE116 ,   K_MIDINOTE117 , K_MIDINOTE118 , K_MIDINOTE119 , K_MIDINOTE120 ,   K_MIDINOTE121 , K_MIDINOTE122 , K_MIDINOTE123 , K_MIDINOTE124 ,   K_MIDINOTE125 , K_MIDINOTE126 , K_MIDINOTE127 , MAX_KEYS = MAX_KEY_BINDS }

Functions
int	Key_AddChar (int unicode, qbool is_console)
int	Key_ClearEditLine (qbool is_console)
void	Key_Event (int key, int ascii, qbool down)
void	Key_EventQueue_Block (void)
void	Key_EventQueue_Unblock (void)
void	Key_FindKeysForCommand (const char *command, int *keys, int numkeys, int bindmap)
const char *	Key_GetBind (int key, int bindmap)
void	Key_GetBindMap (int *fg, int *bg)
void	Key_Init (void)
void	Key_Init_Cvars (void)
const char *	Key_KeynumToString (int keynum, char *buf, size_t buflength)
int	Key_Parse_CommonKeys (cmd_state_t *cmd, qbool is_console, int key, int unicode)
void	Key_ReleaseAll (void)
void	Key_ReleaseAll_f (cmd_state_t *cmd)
qbool	Key_SetBinding (int keynum, int bindmap, const char *binding)
qbool	Key_SetBindMap (int fg, int bg)
void	Key_Shutdown (void)
int	Key_StringToKeynum (const char *str)
void	Key_WriteBindings (qfile_t *f)

Variables
char	chat_buffer [MAX_INPUTLINE]
int	chat_bufferpos
signed char	chat_mode
int	key_consoleactive
keydest_t	key_dest
qbool	key_insert
char	key_line [MAX_INPUTLINE]
int	key_linepos
char *	keybindings [MAX_BINDMAPS][MAX_KEYS]

Macro Definition Documentation

KEY_CONSOLEACTIVE_FORCED

#define KEY_CONSOLEACTIVE_FORCED   4

Definition at line 382 of file keys.h.

Referenced by Key_Event(), SCR_DrawConsole(), SCR_DrawScreen(), and SCR_SetUpToDrawConsole().

KEY_CONSOLEACTIVE_USER

#define KEY_CONSOLEACTIVE_USER   1

Definition at line 380 of file keys.h.

Referenced by Con_ToggleConsole_f(), IN_Move(), IN_Move_TouchScreen_Quake(), IN_Move_TouchScreen_SteelStorm(), Key_Event(), and SCR_SetUpToDrawConsole().

MAX_KEY_BINDS

#define MAX_KEY_BINDS   0xAC00

Definition at line 41 of file keys.h.

TINYSTR_LEN

#define TINYSTR_LEN   4

Definition at line 46 of file keys.h.

Referenced by Key_PrintBindList(), Key_WriteBindings(), M_Keys_Draw(), M_Keys_Key(), and VM_keynumtostring().

Enumeration Type Documentation

keydest_t

enum keydest_t

Enumerator
key_game
key_message
key_menu
key_menu_grabbed
key_console
key_void

Definition at line 372 of file keys.h.

{ key_game, key_message, key_menu, key_menu_grabbed, key_console, key_void } keydest_t;

keynum_t

enum keynum_t

Enumerator
K_TEXT
K_TAB
K_ENTER
K_ESCAPE
K_SPACE
K_BACKSPACE
K_UPARROW
K_DOWNARROW
K_LEFTARROW
K_RIGHTARROW
K_ALT
K_CTRL
K_SHIFT
K_F1
K_F2
K_F3
K_F4
K_F5
K_F6
K_F7
K_F8
K_F9
K_F10
K_F11
K_F12
K_INS
K_DEL
K_PGDN
K_PGUP
K_HOME
K_END
K_PAUSE
K_NUMLOCK
K_CAPSLOCK
K_SCROLLOCK
K_KP_0
K_KP_INS
K_KP_1
K_KP_END
K_KP_2
K_KP_DOWNARROW
K_KP_3
K_KP_PGDN
K_KP_4
K_KP_LEFTARROW
K_KP_5
K_KP_6
K_KP_RIGHTARROW
K_KP_7
K_KP_HOME
K_KP_8
K_KP_UPARROW
K_KP_9
K_KP_PGUP
K_KP_PERIOD
K_KP_DEL
K_KP_DIVIDE
K_KP_SLASH
K_KP_MULTIPLY
K_KP_MINUS
K_KP_PLUS
K_KP_ENTER
K_KP_EQUALS
K_PRINTSCREEN
K_MOUSE1
K_OTHERDEVICESBEGIN
K_MOUSE2
K_MOUSE3
K_MWHEELUP
K_MWHEELDOWN
K_MOUSE4
K_MOUSE5
K_MOUSE6
K_MOUSE7
K_MOUSE8
K_MOUSE9
K_MOUSE10
K_MOUSE11
K_MOUSE12
K_MOUSE13
K_MOUSE14
K_MOUSE15
K_MOUSE16
K_JOY1
K_JOY2
K_JOY3
K_JOY4
K_JOY5
K_JOY6
K_JOY7
K_JOY8
K_JOY9
K_JOY10
K_JOY11
K_JOY12
K_JOY13
K_JOY14
K_JOY15
K_JOY16
K_AUX1
K_AUX2
K_AUX3
K_AUX4
K_AUX5
K_AUX6
K_AUX7
K_AUX8
K_AUX9
K_AUX10
K_AUX11
K_AUX12
K_AUX13
K_AUX14
K_AUX15
K_AUX16
K_AUX17
K_AUX18
K_AUX19
K_AUX20
K_AUX21
K_AUX22
K_AUX23
K_AUX24
K_AUX25
K_AUX26
K_AUX27
K_AUX28
K_AUX29
K_AUX30
K_AUX31
K_AUX32
K_X360_DPAD_UP
K_X360_DPAD_DOWN
K_X360_DPAD_LEFT
K_X360_DPAD_RIGHT
K_X360_START
K_X360_BACK
K_X360_LEFT_THUMB
K_X360_RIGHT_THUMB
K_X360_LEFT_SHOULDER
K_X360_RIGHT_SHOULDER
K_X360_A
K_X360_B
K_X360_X
K_X360_Y
K_X360_LEFT_TRIGGER
K_X360_RIGHT_TRIGGER
K_X360_LEFT_THUMB_UP
K_X360_LEFT_THUMB_DOWN
K_X360_LEFT_THUMB_LEFT
K_X360_LEFT_THUMB_RIGHT
K_X360_RIGHT_THUMB_UP
K_X360_RIGHT_THUMB_DOWN
K_X360_RIGHT_THUMB_LEFT
K_X360_RIGHT_THUMB_RIGHT
K_JOY_UP
K_JOY_DOWN
K_JOY_LEFT
K_JOY_RIGHT
K_MIDINOTE0
K_MIDINOTE1
K_MIDINOTE2
K_MIDINOTE3
K_MIDINOTE4
K_MIDINOTE5
K_MIDINOTE6
K_MIDINOTE7
K_MIDINOTE8
K_MIDINOTE9
K_MIDINOTE10
K_MIDINOTE11
K_MIDINOTE12
K_MIDINOTE13
K_MIDINOTE14
K_MIDINOTE15
K_MIDINOTE16
K_MIDINOTE17
K_MIDINOTE18
K_MIDINOTE19
K_MIDINOTE20
K_MIDINOTE21
K_MIDINOTE22
K_MIDINOTE23
K_MIDINOTE24
K_MIDINOTE25
K_MIDINOTE26
K_MIDINOTE27
K_MIDINOTE28
K_MIDINOTE29
K_MIDINOTE30
K_MIDINOTE31
K_MIDINOTE32
K_MIDINOTE33
K_MIDINOTE34
K_MIDINOTE35
K_MIDINOTE36
K_MIDINOTE37
K_MIDINOTE38
K_MIDINOTE39
K_MIDINOTE40
K_MIDINOTE41
K_MIDINOTE42
K_MIDINOTE43
K_MIDINOTE44
K_MIDINOTE45
K_MIDINOTE46
K_MIDINOTE47
K_MIDINOTE48
K_MIDINOTE49
K_MIDINOTE50
K_MIDINOTE51
K_MIDINOTE52
K_MIDINOTE53
K_MIDINOTE54
K_MIDINOTE55
K_MIDINOTE56
K_MIDINOTE57
K_MIDINOTE58
K_MIDINOTE59
K_MIDINOTE60
K_MIDINOTE61
K_MIDINOTE62
K_MIDINOTE63
K_MIDINOTE64
K_MIDINOTE65
K_MIDINOTE66
K_MIDINOTE67
K_MIDINOTE68
K_MIDINOTE69
K_MIDINOTE70
K_MIDINOTE71
K_MIDINOTE72
K_MIDINOTE73
K_MIDINOTE74
K_MIDINOTE75
K_MIDINOTE76
K_MIDINOTE77
K_MIDINOTE78
K_MIDINOTE79
K_MIDINOTE80
K_MIDINOTE81
K_MIDINOTE82
K_MIDINOTE83
K_MIDINOTE84
K_MIDINOTE85
K_MIDINOTE86
K_MIDINOTE87
K_MIDINOTE88
K_MIDINOTE89
K_MIDINOTE90
K_MIDINOTE91
K_MIDINOTE92
K_MIDINOTE93
K_MIDINOTE94
K_MIDINOTE95
K_MIDINOTE96
K_MIDINOTE97
K_MIDINOTE98
K_MIDINOTE99
K_MIDINOTE100
K_MIDINOTE101
K_MIDINOTE102
K_MIDINOTE103
K_MIDINOTE104
K_MIDINOTE105
K_MIDINOTE106
K_MIDINOTE107
K_MIDINOTE108
K_MIDINOTE109
K_MIDINOTE110
K_MIDINOTE111
K_MIDINOTE112
K_MIDINOTE113
K_MIDINOTE114
K_MIDINOTE115
K_MIDINOTE116
K_MIDINOTE117
K_MIDINOTE118
K_MIDINOTE119
K_MIDINOTE120
K_MIDINOTE121
K_MIDINOTE122
K_MIDINOTE123
K_MIDINOTE124
K_MIDINOTE125
K_MIDINOTE126
K_MIDINOTE127
MAX_KEYS

Definition at line 51 of file keys.h.

{
    K_TEXT          = 1, // used only for unicode character input
    K_TAB           = 9,
    K_ENTER         = 13,
    K_ESCAPE        = 27,
    K_SPACE         = 32,
 
    // normal keys should be passed as lowercased ascii
 
    K_BACKSPACE     = 127,
    K_UPARROW,
    K_DOWNARROW,
    K_LEFTARROW,
    K_RIGHTARROW,
 
    K_ALT,
    K_CTRL,
    K_SHIFT,
 
    K_F1,
    K_F2,
    K_F3,
    K_F4,
    K_F5,
    K_F6,
    K_F7,
    K_F8,
    K_F9,
    K_F10,
    K_F11,
    K_F12,
 
    K_INS,
    K_DEL,
    K_PGDN,
    K_PGUP,
    K_HOME,
    K_END,
 
    K_PAUSE,
 
    K_NUMLOCK,
    K_CAPSLOCK,
    K_SCROLLOCK,
 
    K_KP_0,
    K_KP_INS = K_KP_0,
    K_KP_1,
    K_KP_END = K_KP_1,
    K_KP_2,
    K_KP_DOWNARROW = K_KP_2,
    K_KP_3,
    K_KP_PGDN = K_KP_3,
    K_KP_4,
    K_KP_LEFTARROW = K_KP_4,
    K_KP_5,
    K_KP_6,
    K_KP_RIGHTARROW = K_KP_6,
    K_KP_7,
    K_KP_HOME = K_KP_7,
    K_KP_8,
    K_KP_UPARROW = K_KP_8,
    K_KP_9,
    K_KP_PGUP = K_KP_9,
    K_KP_PERIOD,
    K_KP_DEL = K_KP_PERIOD,
    K_KP_DIVIDE,
    K_KP_SLASH = K_KP_DIVIDE,
    K_KP_MULTIPLY,
    K_KP_MINUS,
    K_KP_PLUS,
    K_KP_ENTER,
    K_KP_EQUALS,
 
    K_PRINTSCREEN,
 
    // mouse buttons generate virtual keys
 
    K_MOUSE1 = 512,
    K_OTHERDEVICESBEGIN = K_MOUSE1,
    K_MOUSE2,
    K_MOUSE3,
    K_MWHEELUP,
    K_MWHEELDOWN,
    K_MOUSE4,
    K_MOUSE5,
    K_MOUSE6,
    K_MOUSE7,
    K_MOUSE8,
    K_MOUSE9,
    K_MOUSE10,
    K_MOUSE11,
    K_MOUSE12,
    K_MOUSE13,
    K_MOUSE14,
    K_MOUSE15,
    K_MOUSE16,
 
//
// joystick buttons
//
    K_JOY1 = 768,
    K_JOY2,
    K_JOY3,
    K_JOY4,
    K_JOY5,
    K_JOY6,
    K_JOY7,
    K_JOY8,
    K_JOY9,
    K_JOY10,
    K_JOY11,
    K_JOY12,
    K_JOY13,
    K_JOY14,
    K_JOY15,
    K_JOY16,
 
//
// aux keys are for multi-buttoned joysticks to generate so they can use
// the normal binding process
//
    K_AUX1,
    K_AUX2,
    K_AUX3,
    K_AUX4,
    K_AUX5,
    K_AUX6,
    K_AUX7,
    K_AUX8,
    K_AUX9,
    K_AUX10,
    K_AUX11,
    K_AUX12,
    K_AUX13,
    K_AUX14,
    K_AUX15,
    K_AUX16,
    K_AUX17,
    K_AUX18,
    K_AUX19,
    K_AUX20,
    K_AUX21,
    K_AUX22,
    K_AUX23,
    K_AUX24,
    K_AUX25,
    K_AUX26,
    K_AUX27,
    K_AUX28,
    K_AUX29,
    K_AUX30,
    K_AUX31,
    K_AUX32,
 
    // Microsoft Xbox 360 Controller For Windows
    K_X360_DPAD_UP,
    K_X360_DPAD_DOWN,
    K_X360_DPAD_LEFT,
    K_X360_DPAD_RIGHT,
    K_X360_START,
    K_X360_BACK,
    K_X360_LEFT_THUMB,
    K_X360_RIGHT_THUMB,
    K_X360_LEFT_SHOULDER,
    K_X360_RIGHT_SHOULDER,
    K_X360_A,
    K_X360_B,
    K_X360_X,
    K_X360_Y,
    K_X360_LEFT_TRIGGER,
    K_X360_RIGHT_TRIGGER,
    K_X360_LEFT_THUMB_UP,
    K_X360_LEFT_THUMB_DOWN,
    K_X360_LEFT_THUMB_LEFT,
    K_X360_LEFT_THUMB_RIGHT,
    K_X360_RIGHT_THUMB_UP,
    K_X360_RIGHT_THUMB_DOWN,
    K_X360_RIGHT_THUMB_LEFT,
    K_X360_RIGHT_THUMB_RIGHT,
 
    // generic joystick emulation for menu
    K_JOY_UP,
    K_JOY_DOWN,
    K_JOY_LEFT,
    K_JOY_RIGHT,
 
    K_MIDINOTE0 = 896, // to this, the note number is added
    K_MIDINOTE1,
    K_MIDINOTE2,
    K_MIDINOTE3,
    K_MIDINOTE4,
    K_MIDINOTE5,
    K_MIDINOTE6,
    K_MIDINOTE7,
    K_MIDINOTE8,
    K_MIDINOTE9,
    K_MIDINOTE10,
    K_MIDINOTE11,
    K_MIDINOTE12,
    K_MIDINOTE13,
    K_MIDINOTE14,
    K_MIDINOTE15,
    K_MIDINOTE16,
    K_MIDINOTE17,
    K_MIDINOTE18,
    K_MIDINOTE19,
    K_MIDINOTE20,
    K_MIDINOTE21,
    K_MIDINOTE22,
    K_MIDINOTE23,
    K_MIDINOTE24,
    K_MIDINOTE25,
    K_MIDINOTE26,
    K_MIDINOTE27,
    K_MIDINOTE28,
    K_MIDINOTE29,
    K_MIDINOTE30,
    K_MIDINOTE31,
    K_MIDINOTE32,
    K_MIDINOTE33,
    K_MIDINOTE34,
    K_MIDINOTE35,
    K_MIDINOTE36,
    K_MIDINOTE37,
    K_MIDINOTE38,
    K_MIDINOTE39,
    K_MIDINOTE40,
    K_MIDINOTE41,
    K_MIDINOTE42,
    K_MIDINOTE43,
    K_MIDINOTE44,
    K_MIDINOTE45,
    K_MIDINOTE46,
    K_MIDINOTE47,
    K_MIDINOTE48,
    K_MIDINOTE49,
    K_MIDINOTE50,
    K_MIDINOTE51,
    K_MIDINOTE52,
    K_MIDINOTE53,
    K_MIDINOTE54,
    K_MIDINOTE55,
    K_MIDINOTE56,
    K_MIDINOTE57,
    K_MIDINOTE58,
    K_MIDINOTE59,
    K_MIDINOTE60,
    K_MIDINOTE61,
    K_MIDINOTE62,
    K_MIDINOTE63,
    K_MIDINOTE64,
    K_MIDINOTE65,
    K_MIDINOTE66,
    K_MIDINOTE67,
    K_MIDINOTE68,
    K_MIDINOTE69,
    K_MIDINOTE70,
    K_MIDINOTE71,
    K_MIDINOTE72,
    K_MIDINOTE73,
    K_MIDINOTE74,
    K_MIDINOTE75,
    K_MIDINOTE76,
    K_MIDINOTE77,
    K_MIDINOTE78,
    K_MIDINOTE79,
    K_MIDINOTE80,
    K_MIDINOTE81,
    K_MIDINOTE82,
    K_MIDINOTE83,
    K_MIDINOTE84,
    K_MIDINOTE85,
    K_MIDINOTE86,
    K_MIDINOTE87,
    K_MIDINOTE88,
    K_MIDINOTE89,
    K_MIDINOTE90,
    K_MIDINOTE91,
    K_MIDINOTE92,
    K_MIDINOTE93,
    K_MIDINOTE94,
    K_MIDINOTE95,
    K_MIDINOTE96,
    K_MIDINOTE97,
    K_MIDINOTE98,
    K_MIDINOTE99,
    K_MIDINOTE100,
    K_MIDINOTE101,
    K_MIDINOTE102,
    K_MIDINOTE103,
    K_MIDINOTE104,
    K_MIDINOTE105,
    K_MIDINOTE106,
    K_MIDINOTE107,
    K_MIDINOTE108,
    K_MIDINOTE109,
    K_MIDINOTE110,
    K_MIDINOTE111,
    K_MIDINOTE112,
    K_MIDINOTE113,
    K_MIDINOTE114,
    K_MIDINOTE115,
    K_MIDINOTE116,
    K_MIDINOTE117,
    K_MIDINOTE118,
    K_MIDINOTE119,
    K_MIDINOTE120,
    K_MIDINOTE121,
    K_MIDINOTE122,
    K_MIDINOTE123,
    K_MIDINOTE124,
    K_MIDINOTE125,
    K_MIDINOTE126,
    K_MIDINOTE127,
 
    MAX_KEYS = MAX_KEY_BINDS
}

Function Documentation

Key_AddChar()

int Key_AddChar	(	int	unicode,
		qbool	is_console )

Definition at line 703 of file keys.c.

{
    char *line;
    char buf[16];
    int len, blen, linepos;
 
    if (is_console)
    {
        line = key_line;
        linepos = key_linepos;
    }
    else
    {
        line = chat_buffer;
        linepos = chat_bufferpos;
    }
 
    if (linepos >= MAX_INPUTLINE-1)
        return linepos;
 
    blen = u8_fromchar(unicode, buf, sizeof(buf));
    if (!blen)
        return linepos;
    len = (int)strlen(&line[linepos]);
    // check insert mode, or always insert if at end of line
    if (key_insert || len == 0)
    {
        if (linepos + len + blen >= MAX_INPUTLINE)
            return linepos;
        // can't use strcpy to move string to right
        len++;
        if (linepos + blen + len >= MAX_INPUTLINE)
            return linepos;
        memmove(&line[linepos + blen], &line[linepos], len);
    }
    else if (linepos + len + blen - u8_bytelen(line + linepos, 1) >= MAX_INPUTLINE)
        return linepos;
    memcpy(line + linepos, buf, blen);
    if (blen > len)
        line[linepos + blen] = 0;
    linepos += blen;
    return linepos;
}

References buf, chat_buffer, chat_bufferpos, int(), key_insert, key_line, key_linepos, MAX_INPUTLINE, strlen(), u8_bytelen(), and u8_fromchar().

Referenced by Key_Console(), and Key_Message().

Key_ClearEditLine()

int Key_ClearEditLine

(

qbool

is_console

)

Definition at line 668 of file keys.c.

{
    if (is_console)
    {
        key_line[0] = ']';
        key_line[1] = 0;
        return 1;
    }
    else
    {
        chat_buffer[0] = 0;
        return 0;
    }
}

References chat_buffer, and key_line.

Referenced by Key_Console(), Key_Init(), Key_Message(), and Key_Parse_CommonKeys().

Key_Event()

void Key_Event	(	int	key,
		int	ascii,
		qbool	down )

Definition at line 1836 of file keys.c.

{
    cmd_state_t *cmd = cmd_local;
    const char *bind;
    qbool q;
    keydest_t keydest = key_dest;
    char vabuf[1024];
 
    if (key < 0 || key >= MAX_KEYS)
        return;
 
    if(events_blocked)
    {
        Key_EventQueue_Add(key, ascii, down);
        return;
    }
 
    // get key binding
    bind = keybindings[key_bmap][key];
    if (!bind)
        bind = keybindings[key_bmap2][key];
 
    if (developer_insane.integer)
        Con_DPrintf("Key_Event(%i, '%c', %s) keydown %i bind \"%s\"\n", key, ascii ? ascii : '?', down ? "down" : "up", keydown[key], bind ? bind : "");
 
    if(key_consoleactive)
        keydest = key_console;
 
    if (down)
    {
        // increment key repeat count each time a down is received so that things
        // which want to ignore key repeat can ignore it
        keydown[key] = min(keydown[key] + 1, 2);
        if(keydown[key] == 1) {
            tbl_keyascii[key] = ascii;
            tbl_keydest[key] = keydest;
        } else {
            ascii = tbl_keyascii[key];
            keydest = tbl_keydest[key];
        }
    }
    else
    {
        // clear repeat count now that the key is released
        keydown[key] = 0;
        keydest = tbl_keydest[key];
        ascii = tbl_keyascii[key];
    }
 
    if(keydest == key_void)
        return;
 
    // key_consoleactive is a flag not a key_dest because the console is a
    // high priority overlay ontop of the normal screen (designed as a safety
    // feature so that developers and users can rescue themselves from a bad
    // situation).
    //
    // this also means that toggling the console on/off does not lose the old
    // key_dest state
 
    // specially handle escape (togglemenu) and shift-escape (toggleconsole)
    // engine bindings, these are not handled as normal binds so that the user
    // can recover from a completely empty bindmap
    if (key == K_ESCAPE)
    {
        // ignore key repeats on escape
        if (keydown[key] > 1)
            return;
 
        // escape does these things:
        // key_consoleactive - close console
        // key_message - abort messagemode
        // key_menu - go to parent menu (or key_game)
        // key_game - open menu
 
        // in all modes shift-escape toggles console
        if (keydown[K_SHIFT])
        {
            if(down)
            {
                Con_ToggleConsole_f(cmd_local);
                tbl_keydest[key] = key_void; // esc release should go nowhere (especially not to key_menu or key_game)
            }
            return;
        }
 
        switch (keydest)
        {
            case key_console:
                if(down)
                {
                    if(key_consoleactive & KEY_CONSOLEACTIVE_FORCED)
                    {
                        key_consoleactive &= ~KEY_CONSOLEACTIVE_USER;
#ifdef CONFIG_MENU
                        MR_ToggleMenu(1);
#endif
                    }
                    else
                        Con_ToggleConsole_f(cmd_local);
                }
                break;
 
            case key_message:
                if (down)
                    Key_Message (cmd, key, ascii); // that'll close the message input
                break;
 
            case key_menu:
            case key_menu_grabbed:
#ifdef CONFIG_MENU
                MR_KeyEvent (key, ascii, down);
#endif
                break;
 
            case key_game:
                // csqc has priority over toggle menu if it wants to (e.g. handling escape for UI stuff in-game.. :sick:)
                q = CL_VM_InputEvent(down ? 0 : 1, key, ascii);
#ifdef CONFIG_MENU
                if (!q && down)
                    MR_ToggleMenu(1);
#endif
                break;
 
            default:
                Con_Printf ("Key_Event: Bad key_dest\n");
        }
        return;
    }
 
    // send function keydowns to interpreter no matter what mode is (unless the menu has specifically grabbed the keyboard, for rebinding keys)
    // VorteX: Omnicide does bind F* keys
    if (keydest != key_menu_grabbed)
    if (key >= K_F1 && key <= K_F12 && gamemode != GAME_BLOODOMNICIDE)
    {
        if (bind)
        {
            if(keydown[key] == 1 && down)
            {
                // button commands add keynum as a parm
                // prepend to avoid delays from `wait` commands added by other sources
                if (bind[0] == '+')
                    Cbuf_InsertText(cmd, va(vabuf, sizeof(vabuf), "%s %i\n", bind, key));
                else
                    Cbuf_InsertText(cmd, bind);
            }
            else if(bind[0] == '+' && !down && keydown[key] == 0)
                // append -bind to ensure it's after the +bind in case they arrive in the same frame
                Cbuf_AddText(cmd, va(vabuf, sizeof(vabuf), "-%s %i\n", bind + 1, key));
        }
        return;
    }
 
    // send input to console if it wants it
    if (keydest == key_console)
    {
        if (!down)
            return;
        // con_closeontoggleconsole enables toggleconsole keys to close the
        // console, as long as they are not the color prefix character
        // (special exemption for german keyboard layouts)
        if (con_closeontoggleconsole.integer && bind && !strncmp(bind, "toggleconsole", strlen("toggleconsole")) && (key_consoleactive & KEY_CONSOLEACTIVE_USER) && (con_closeontoggleconsole.integer >= ((ascii != STRING_COLOR_TAG) ? 2 : 3) || key_linepos == 1))
        {
            Con_ToggleConsole_f(cmd_local);
            return;
        }
 
        if (Sys_CheckParm ("-noconsole"))
            return; // only allow the key bind to turn off console
 
        Key_Console (cmd, key, ascii);
        return;
    }
 
    // handle toggleconsole in menu too
    if (keydest == key_menu)
    {
        if (down && con_closeontoggleconsole.integer && bind && !strncmp(bind, "toggleconsole", strlen("toggleconsole")) && ascii != STRING_COLOR_TAG)
        {
            Cbuf_InsertText(cmd, "toggleconsole\n");  // Deferred to next frame so we're not sending the text event to the console.
            tbl_keydest[key] = key_void; // key release should go nowhere (especially not to key_menu or key_game)
            return;
        }
    }
 
    // ignore binds while a video is played, let the video system handle the key event
    if (cl_videoplaying)
    {
        if (gamemode == GAME_BLOODOMNICIDE) // menu controls key events
#ifdef CONFIG_MENU
            MR_KeyEvent(key, ascii, down);
#else
            {
            }
#endif
        else
            CL_Video_KeyEvent (key, ascii, keydown[key] != 0);
        return;
    }
 
    // anything else is a key press into the game, chat line, or menu
    switch (keydest)
    {
        case key_message:
            if (down)
                Key_Message (cmd, key, ascii);
            break;
        case key_menu:
        case key_menu_grabbed:
#ifdef CONFIG_MENU
            MR_KeyEvent (key, ascii, down);
#endif
            break;
        case key_game:
            q = CL_VM_InputEvent(down ? 0 : 1, key, ascii);
            // ignore key repeats on binds and only send the bind if the event hasnt been already processed by csqc
            if (!q && bind)
            {
                if(keydown[key] == 1 && down)
                {
                    // button commands add keynum as a parm
                    // prepend to avoid delays from `wait` commands added by other sources
                    if (bind[0] == '+')
                        Cbuf_InsertText(cmd, va(vabuf, sizeof(vabuf), "%s %i\n", bind, key));
                    else
                        Cbuf_InsertText(cmd, bind);
                }
                else if(bind[0] == '+' && !down && keydown[key] == 0)
                    // append -bind to ensure it's after the +bind in case they arrive in the same frame
                    Cbuf_AddText(cmd, va(vabuf, sizeof(vabuf), "-%s %i\n", bind + 1, key));
            }
            break;
        default:
            Con_Printf ("Key_Event: Bad key_dest\n");
    }
}

References Cbuf_AddText(), Cbuf_InsertText(), CL_Video_KeyEvent(), cl_videoplaying, CL_VM_InputEvent(), cmd(), cmd_local, con_closeontoggleconsole, Con_DPrintf(), Con_Printf(), Con_ToggleConsole_f(), developer_insane, events_blocked, GAME_BLOODOMNICIDE, gamemode, cvar_t::integer, K_ESCAPE, K_F1, K_F12, K_SHIFT, key_bmap, key_bmap2, Key_Console(), key_console, key_consoleactive, KEY_CONSOLEACTIVE_FORCED, KEY_CONSOLEACTIVE_USER, key_dest, Key_EventQueue_Add(), key_game, key_linepos, key_menu, key_menu_grabbed, Key_Message(), key_message, key_void, keybindings, keydown, MAX_KEYS, min, MR_KeyEvent, MR_ToggleMenu, STRING_COLOR_TAG, strlen(), Sys_CheckParm(), tbl_keyascii, tbl_keydest, and va().

Referenced by Key_EventQueue_Unblock(), Key_ReleaseAll(), Sys_SDL_HandleEvents(), VID_KeyEventForButton(), VID_TouchscreenArea(), and VID_TouchscreenCursor().

Key_EventQueue_Block()

void Key_EventQueue_Block

(

void

)

Definition at line 1819 of file keys.c.

{
    // block key events until call to Unblock
    events_blocked = true;
}

References events_blocked.

Key_EventQueue_Unblock()

void Key_EventQueue_Unblock

(

void

)

Definition at line 1825 of file keys.c.

{
    // unblocks key events again
    unsigned i;
    events_blocked = false;
    for(i = 0; i < eventqueue_idx; ++i)
        Key_Event(eventqueue[i].key, eventqueue[i].ascii, eventqueue[i].down);
    eventqueue_idx = 0;
}

References eventqueue, eventqueue_idx, events_blocked, i, and Key_Event().

Key_FindKeysForCommand()

void Key_FindKeysForCommand	(	const char *	command,
		int *	keys,
		int	numkeys,
		int	bindmap )

Definition at line 1760 of file keys.c.

{
    int     count;
    int     j;
    const char  *b;
 
    for (j = 0;j < numkeys;j++)
        keys[j] = -1;
 
    if(bindmap >= MAX_BINDMAPS)
        return;
 
    count = 0;
 
    for (j = 0; j < MAX_KEYS; ++j)
    {
        b = Key_GetBind(j, bindmap);
        if (!b)
            continue;
        if (!strcmp (b, command) )
        {
            keys[count++] = j;
            if (count == numkeys)
                break;
        }
    }
}

References b, count, Key_GetBind(), MAX_BINDMAPS, and MAX_KEYS.

Referenced by M_Keys_Draw(), M_Keys_Key(), and VM_findkeysforcommand().

Key_GetBind()

const char * Key_GetBind	(	int	key,
		int	bindmap )

Definition at line 1740 of file keys.c.

{
    const char *bind;
    if (key < 0 || key >= MAX_KEYS)
        return NULL;
    if(bindmap >= MAX_BINDMAPS)
        return NULL;
    if(bindmap >= 0)
    {
        bind = keybindings[bindmap][key];
    }
    else
    {
        bind = keybindings[key_bmap][key];
        if (!bind)
            bind = keybindings[key_bmap2][key];
    }
    return bind;
}

References key_bmap, key_bmap2, keybindings, MAX_BINDMAPS, MAX_KEYS, and NULL.

Referenced by Key_FindKeysForCommand(), and VM_getkeybind().

Key_GetBindMap()

void Key_GetBindMap	(	int *	fg,
		int *	bg )

Definition at line 1435 of file keys.c.

{
    if(fg)
        *fg = key_bmap;
    if(bg)
        *bg = key_bmap2;
}

References key_bmap, and key_bmap2.

Referenced by VM_getbindmaps().

Key_Init()

void Key_Init

(

void

)

Definition at line 1710 of file keys.c.

{
    Key_History_Init();
    key_linepos = Key_ClearEditLine(true);
 
//
// register our functions
//
    Cmd_AddCommand(CF_CLIENT, "in_bind", Key_In_Bind_f, "binds a command to the specified key in the selected bindmap");
    Cmd_AddCommand(CF_CLIENT, "in_unbind", Key_In_Unbind_f, "removes command on the specified key in the selected bindmap");
    Cmd_AddCommand(CF_CLIENT, "in_bindlist", Key_In_BindList_f, "bindlist: displays bound keys for all bindmaps, or the given bindmap");
    Cmd_AddCommand(CF_CLIENT, "in_bindmap", Key_In_Bindmap_f, "selects active foreground and background (used only if a key is not bound in the foreground) bindmaps for typing");
    Cmd_AddCommand(CF_CLIENT, "in_releaseall", Key_ReleaseAll_f, "releases all currently pressed keys (debug command)");
 
    Cmd_AddCommand(CF_CLIENT, "bind", Key_Bind_f, "binds a command to the specified key in bindmap 0");
    Cmd_AddCommand(CF_CLIENT, "unbind", Key_Unbind_f, "removes a command on the specified key in bindmap 0");
    Cmd_AddCommand(CF_CLIENT, "bindlist", Key_BindList_f, "bindlist: displays bound keys for bindmap 0 bindmaps");
    Cmd_AddCommand(CF_CLIENT, "unbindall", Key_Unbindall_f, "removes all commands from all keys in all bindmaps (leaving only shift-escape and escape)");
 
    Cmd_AddCommand(CF_CLIENT, "history", Key_History_f, "prints the history of executed commands (history X prints the last X entries, history -c clears the whole history)");
 
    Cvar_RegisterVariable (&con_closeontoggleconsole);
}

References CF_CLIENT, Cmd_AddCommand(), con_closeontoggleconsole, Cvar_RegisterVariable(), Key_Bind_f(), Key_BindList_f(), Key_ClearEditLine(), Key_History_f(), Key_History_Init(), Key_In_Bind_f(), Key_In_BindList_f(), Key_In_Bindmap_f(), Key_In_Unbind_f(), key_linepos, Key_ReleaseAll_f(), Key_Unbind_f(), and Key_Unbindall_f().

Referenced by CL_Init().

Key_Init_Cvars()

void Key_Init_Cvars

(

void

)

Key_KeynumToString()

const char * Key_KeynumToString	(	int	keynum,
		char *	buf,
		size_t	buflength )

Definition at line 1383 of file keys.c.

{
    const keyname_t  *kn;
 
    // -1 is an invalid code
    if (keynum < 0)
        return "<KEY NOT FOUND>";
 
    // search overrides first, because some characters are special
    for (kn = keynames; kn->name; kn++)
        if (keynum == kn->keynum)
            return kn->name;
 
    // if it is printable, output it as a single character
    if (keynum > 32)
    {
        u8_fromchar(keynum, tinystr, tinystrlength);
        return tinystr;
    }
 
    // if it is not overridden and not printable, we don't know what to do with it
    return "<UNKNOWN KEYNUM>";
}

References keynames, keyname_t::keynum, keyname_t::name, and u8_fromchar().

Referenced by Key_PrintBindList(), Key_WriteBindings(), M_Keys_Draw(), M_Keys_Key(), and VM_keynumtostring().

Key_Parse_CommonKeys()

int Key_Parse_CommonKeys	(	cmd_state_t *	cmd,
		qbool	is_console,
		int	key,
		int	unicode )

Definition at line 750 of file keys.c.

{
    char *line;
    int linepos, linestart;
    unsigned int linesize;
    if (is_console)
    {
        line = key_line;
        linepos = key_linepos;
        linesize = sizeof(key_line);
        linestart = 1;
    }
    else
    {
        line = chat_buffer;
        linepos = chat_bufferpos;
        linesize = sizeof(chat_buffer);
        linestart = 0;
    }
 
    if ((key == 'v' && KM_CTRL) || ((key == K_INS || key == K_KP_INS) && KM_SHIFT))
    {
        char *cbd, *p;
        if ((cbd = Sys_SDL_GetClipboardData()) != 0)
        {
            int i;
#if 1
            p = cbd;
            while (*p)
            {
                if (*p == '\r' && *(p+1) == '\n')
                {
                    *p++ = ';';
                    *p++ = ' ';
                }
                else if (*p == '\n' || *p == '\r' || *p == '\b')
                    *p++ = ';';
                else
                    p++;
            }
#else
            strtok(cbd, "\n\r\b");
#endif
            i = (int)strlen(cbd);
            if (i + linepos >= MAX_INPUTLINE)
                i= MAX_INPUTLINE - linepos - 1;
            if (i > 0)
            {
                cbd[i] = 0;
                memmove(line + linepos + i, line + linepos, linesize - linepos - i);
                memcpy(line + linepos, cbd, i);
                linepos += i;
            }
            Z_Free(cbd);
        }
        return linepos;
    }
 
    if (key == 'u' && KM_CTRL) // like vi/readline ^u: delete currently edited line
    {
        return Key_ClearEditLine(is_console);
    }
 
    if (key == K_TAB)
    {
        if (is_console && KM_CTRL) // append the cvar value to the cvar name
        {
            int     cvar_len, cvar_str_len, chars_to_move;
            char    k;
            char    cvar[MAX_INPUTLINE];
            const char *cvar_str;
 
            // go to the start of the variable
            while(--linepos)
            {
                k = line[linepos];
                if(k == '\"' || k == ';' || k == ' ' || k == '\'')
                    break;
            }
            linepos++;
 
            // save the variable name in cvar
            for(cvar_len=0; (k = line[linepos + cvar_len]) != 0; cvar_len++)
            {
                if(k == '\"' || k == ';' || k == ' ' || k == '\'')
                    break;
                cvar[cvar_len] = k;
            }
            if (cvar_len==0)
                return linepos;
            cvar[cvar_len] = 0;
 
            // go to the end of the cvar
            linepos += cvar_len;
 
            // save the content of the variable in cvar_str
            cvar_str = Cvar_VariableString(&cvars_all, cvar, CF_CLIENT | CF_SERVER);
            cvar_str_len = (int)strlen(cvar_str);
            if (cvar_str_len==0)
                return linepos;
 
            // insert space and cvar_str in line
            chars_to_move = (int)strlen(&line[linepos]);
            if (linepos + 1 + cvar_str_len + chars_to_move < MAX_INPUTLINE)
            {
                if (chars_to_move)
                    memmove(&line[linepos + 1 + cvar_str_len], &line[linepos], chars_to_move);
                line[linepos++] = ' ';
                memcpy(&line[linepos], cvar_str, cvar_str_len);
                linepos += cvar_str_len;
                line[linepos + chars_to_move] = 0;
            }
            else
                Con_Printf("Couldn't append cvar value, edit line too long.\n");
            return linepos;
        }
 
        if (KM_NONE)
            return Con_CompleteCommandLine(cmd, is_console);
    }
 
    // Advanced Console Editing by Radix radix@planetquake.com
    // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
    // Enhanced by [515]
    // Enhanced by terencehill
 
    // move cursor to the previous character
    if (key == K_LEFTARROW || key == K_KP_LEFTARROW)
    {
        if(KM_CTRL) // move cursor to the previous word
        {
            int     pos;
            char    k;
            if (linepos <= linestart + 1)
                return linestart;
            pos = linepos;
 
            do {
                k = line[--pos];
                if (!(k == '\"' || k == ';' || k == ' ' || k == '\''))
                    break;
            } while(pos > linestart); // skip all "; ' after the word
 
            if (pos == linestart)
                return linestart;
 
            do {
                k = line[--pos];
                if (k == '\"' || k == ';' || k == ' ' || k == '\'')
                {
                    pos++;
                    break;
                }
            } while(pos > linestart);
 
            linepos = pos;
            return linepos;
        }
 
        if(KM_SHIFT) // move cursor to the previous character ignoring colors
        {
            int     pos;
            size_t          inchar = 0;
            if (linepos <= linestart + 1)
                return linestart;
            pos = (int)u8_prevbyte(line + linestart, linepos - linestart) + linestart;
            while (pos > linestart)
                if(pos-1 >= linestart && line[pos-1] == STRING_COLOR_TAG && isdigit(line[pos]))
                    pos-=2;
                else if(pos-4 >= linestart && line[pos-4] == STRING_COLOR_TAG && line[pos-3] == STRING_COLOR_RGB_TAG_CHAR
                        && isxdigit(line[pos-2]) && isxdigit(line[pos-1]) && isxdigit(line[pos]))
                    pos-=5;
                else
                {
                    if(pos-1 >= linestart && line[pos-1] == STRING_COLOR_TAG && line[pos] == STRING_COLOR_TAG) // consider ^^ as a character
                        pos--;
                    pos--;
                    break;
                }
            if (pos < linestart)
                return linestart;
            // we need to move to the beginning of the character when in a wide character:
            u8_charidx(line, pos + 1, &inchar);
            linepos = (int)(pos + 1 - inchar);
            return linepos;
        }
 
        if(KM_NONE)
        {
            if (linepos <= linestart + 1)
                return linestart;
            // hide ']' from u8_prevbyte otherwise it could go out of bounds
            linepos = (int)u8_prevbyte(line + linestart, linepos - linestart) + linestart;
            return linepos;
        }
    }
 
    // delete char before cursor
    if ((key == K_BACKSPACE && KM_NONE) || (key == 'h' && KM_CTRL))
    {
        if (linepos > linestart)
        {
            // hide ']' from u8_prevbyte otherwise it could go out of bounds
            int newpos = (int)u8_prevbyte(line + linestart, linepos - linestart) + linestart;
            dp_strlcpy(line + newpos, line + linepos, linesize + 1 - linepos);
            linepos = newpos;
        }
        return linepos;
    }
 
    // delete char on cursor
    if ((key == K_DEL || key == K_KP_DEL) && KM_NONE)
    {
        size_t linelen;
        linelen = strlen(line);
        if (linepos < (int)linelen)
            memmove(line + linepos, line + linepos + u8_bytelen(line + linepos, 1), linelen - linepos);
        return linepos;
    }
 
    // move cursor to the next character
    if (key == K_RIGHTARROW || key == K_KP_RIGHTARROW)
    {
        if (KM_CTRL) // move cursor to the next word
        {
            int     pos, len;
            char    k;
            len = (int)strlen(line);
            if (linepos >= len)
                return linepos;
            pos = linepos;
 
            while(++pos < len)
            {
                k = line[pos];
                if(k == '\"' || k == ';' || k == ' ' || k == '\'')
                    break;
            }
 
            if (pos < len) // skip all "; ' after the word
                while(++pos < len)
                {
                    k = line[pos];
                    if (!(k == '\"' || k == ';' || k == ' ' || k == '\''))
                        break;
                }
            linepos = pos;
            return linepos;
        }
 
        if (KM_SHIFT) // move cursor to the next character ignoring colors
        {
            int     pos, len;
            len = (int)strlen(line);
            if (linepos >= len)
                return linepos;
            pos = linepos;
 
            // go beyond all initial consecutive color tags, if any
            if(pos < len)
                while (line[pos] == STRING_COLOR_TAG)
                {
                    if(isdigit(line[pos+1]))
                        pos+=2;
                    else if(line[pos+1] == STRING_COLOR_RGB_TAG_CHAR && isxdigit(line[pos+2]) && isxdigit(line[pos+3]) && isxdigit(line[pos+4]))
                        pos+=5;
                    else
                        break;
                }
 
            // skip the char
            if (line[pos] == STRING_COLOR_TAG && line[pos+1] == STRING_COLOR_TAG) // consider ^^ as a character
                pos++;
            pos += (int)u8_bytelen(line + pos, 1);
 
            // now go beyond all next consecutive color tags, if any
            if(pos < len)
                while (line[pos] == STRING_COLOR_TAG)
                {
                    if(isdigit(line[pos+1]))
                        pos+=2;
                    else if(line[pos+1] == STRING_COLOR_RGB_TAG_CHAR && isxdigit(line[pos+2]) && isxdigit(line[pos+3]) && isxdigit(line[pos+4]))
                        pos+=5;
                    else
                        break;
                }
            linepos = pos;
            return linepos;
        }
 
        if (KM_NONE)
        {
            if (linepos >= (int)strlen(line))
                return linepos;
            linepos += (int)u8_bytelen(line + linepos, 1);
            return linepos;
        }
    }
 
    if ((key == K_INS || key == K_KP_INS) && KM_NONE) // toggle insert mode
    {
        key_insert ^= 1;
        return linepos;
    }
 
    if (key == K_HOME || key == K_KP_HOME)
    {
        if (is_console && KM_CTRL)
        {
            con_backscroll = CON_TEXTSIZE;
            return linepos;
        }
        if (KM_NONE)
            return linestart;
    }
 
    if (key == K_END || key == K_KP_END)
    {
        if (is_console && KM_CTRL)
        {
            con_backscroll = 0;
            return linepos;
        }
        if (KM_NONE)
            return (int)strlen(line);
    }
 
    return -1;
}

References CF_CLIENT, CF_SERVER, chat_buffer, chat_bufferpos, cmd(), con_backscroll, Con_CompleteCommandLine(), Con_Printf(), CON_TEXTSIZE, cvar(), Cvar_VariableString(), cvars_all, dp_strlcpy, i, int(), K_BACKSPACE, K_DEL, K_END, K_HOME, K_INS, K_KP_DEL, K_KP_END, K_KP_HOME, K_KP_INS, K_KP_LEFTARROW, K_KP_RIGHTARROW, K_LEFTARROW, K_RIGHTARROW, K_TAB, Key_ClearEditLine(), key_insert, key_line, key_linepos, KM_CTRL, KM_NONE, KM_SHIFT, MAX_INPUTLINE, STRING_COLOR_RGB_TAG_CHAR, STRING_COLOR_TAG, strlen(), Sys_SDL_GetClipboardData(), u8_bytelen(), u8_charidx(), u8_prevbyte(), and Z_Free.

Referenced by Key_Console(), and Key_Message().

Key_ReleaseAll()

void Key_ReleaseAll

(

void

)

Definition at line 2075 of file keys.c.

{
    int key;
    // clear the event queue first
    eventqueue_idx = 0;
    // then send all down events (possibly into the event queue)
    for(key = 0; key < MAX_KEYS; ++key)
        if(keydown[key])
            Key_Event(key, 0, false);
    // now all keys are guaranteed down (once the event queue is unblocked)
    // and only future events count
}

References eventqueue_idx, Key_Event(), keydown, and MAX_KEYS.

Referenced by Key_ReleaseAll_f(), VID_Restart_f(), and VID_Start().

Key_ReleaseAll_f()

void Key_ReleaseAll_f

(

cmd_state_t *

cmd

)

Definition at line 2088 of file keys.c.

{
    Key_ReleaseAll();
}

References Key_ReleaseAll().

Referenced by Key_Init().

Key_SetBinding()

qbool Key_SetBinding	(	int	keynum,
		int	bindmap,
		const char *	binding )

Definition at line 1409 of file keys.c.

{
    char *newbinding;
    size_t l;
 
    if (keynum == -1 || keynum >= MAX_KEYS)
        return false;
    if ((bindmap < 0) || (bindmap >= MAX_BINDMAPS))
        return false;
 
// free old bindings
    if (keybindings[bindmap][keynum]) {
        Z_Free (keybindings[bindmap][keynum]);
        keybindings[bindmap][keynum] = NULL;
    }
    if(!binding[0]) // make "" binds be removed --blub
        return true;
// allocate memory for new binding
    l = strlen (binding);
    newbinding = (char *)Z_Malloc (l + 1);
    memcpy (newbinding, binding, l + 1);
    newbinding[l] = 0;
    keybindings[bindmap][keynum] = newbinding;
    return true;
}

References keybindings, MAX_BINDMAPS, MAX_KEYS, NULL, strlen(), Z_Free, and Z_Malloc.

Referenced by Key_Bind_f(), Key_In_Bind_f(), Key_In_Unbind_f(), Key_Unbind_f(), Key_Unbindall_f(), M_UnbindCommand(), and VM_setkeybind().

Key_SetBindMap()

qbool Key_SetBindMap	(	int	fg,
		int	bg )

Definition at line 1443 of file keys.c.

{
    if(fg >= MAX_BINDMAPS)
        return false;
    if(bg >= MAX_BINDMAPS)
        return false;
    if(fg >= 0)
        key_bmap = fg;
    if(bg >= 0)
        key_bmap2 = bg;
    return true;
}

References key_bmap, key_bmap2, and MAX_BINDMAPS.

Referenced by VM_setbindmaps().

Key_Shutdown()

void Key_Shutdown

(

void

)

Definition at line 1735 of file keys.c.

{
    Key_History_Shutdown();
}

References Key_History_Shutdown().

Referenced by CL_Shutdown().

Key_StringToKeynum()

int Key_StringToKeynum

(

const char *

str

)

Definition at line 1354 of file keys.c.

{
    Uchar ch;
    const keyname_t  *kn;
 
    if (!str || !str[0])
        return -1;
    if (!str[1])
        return tolower(str[0]);
 
    for (kn = keynames; kn->name; kn++) {
        if (!strcasecmp (str, kn->name))
            return kn->keynum;
    }
 
    // non-ascii keys are Unicode codepoints, so give the character if it's valid;
    // error message have more than one character, don't allow it
    ch = u8_getnchar(str, &str, 3);
    return (ch == 0 || *str != 0) ? -1 : (int)ch;
}

References int(), keynames, keyname_t::keynum, keyname_t::name, and u8_getnchar.

Referenced by Key_Bind_f(), Key_In_Bind_f(), Key_In_Unbind_f(), Key_Unbind_f(), and VM_stringtokeynum().

Key_WriteBindings()

void Key_WriteBindings

(

qfile_t *

f

)

Definition at line 1681 of file keys.c.

{
    int         i, j;
    char bindbuf[MAX_INPUTLINE];
    char tinystr[TINYSTR_LEN];
    const char *p;
 
    // Override default binds
    FS_Printf(f, "unbindall\n");
 
    for (j = 0; j < MAX_BINDMAPS; j++)
    {
        for (i = 0; i < (int)(sizeof(keybindings[0])/sizeof(keybindings[0][0])); i++)
        {
            p = keybindings[j][i];
            if (p)
            {
                Cmd_QuoteString(bindbuf, sizeof(bindbuf), p, "\"\\", false); // don't need to escape $ because cvars are not expanded inside bind
                if (j == 0)
                    FS_Printf(f, "bind %s \"%s\"\n", Key_KeynumToString (i, tinystr, TINYSTR_LEN), bindbuf);
                else
                    FS_Printf(f, "in_bind %d %s \"%s\"\n", j, Key_KeynumToString (i, tinystr, TINYSTR_LEN), bindbuf);
            }
        }
    }
}

References Cmd_QuoteString(), f, FS_Printf(), i, int(), Key_KeynumToString(), keybindings, MAX_BINDMAPS, MAX_INPUTLINE, and TINYSTR_LEN.

Referenced by Host_SaveConfig().

Variable Documentation

chat_buffer

char chat_buffer[MAX_INPUTLINE]

extern

Definition at line 700 of file keys.c.

Referenced by Con_CompleteCommandLine(), Con_DrawInput(), Con_MsgCmdMode(), Key_AddChar(), Key_ClearEditLine(), Key_Message(), and Key_Parse_CommonKeys().

chat_bufferpos

int chat_bufferpos

extern

Definition at line 701 of file keys.c.

Referenced by Con_CompleteCommandLine(), Con_DrawInput(), Con_DrawNotify(), Con_MsgCmdMode(), Key_AddChar(), Key_Message(), and Key_Parse_CommonKeys().

chat_mode

signed char chat_mode

extern

Definition at line 699 of file keys.c.

Referenced by Con_DrawInput(), Con_MsgCmdMode(), and Key_Message().

key_consoleactive

int key_consoleactive

extern

Definition at line 38 of file keys.c.

Referenced by CL_Input(), CL_SendMove(), CL_TimeDemo_f(), Con_DrawInput(), Con_ToggleConsole_f(), IN_Move(), IN_Move_TouchScreen_Quake(), IN_Move_TouchScreen_SteelStorm(), Key_Event(), SCR_DrawConsole(), SCR_DrawScreen(), SCR_SetUpToDrawConsole(), Sys_SDL_HandleEvents(), VID_ApplyDisplayMode_c(), VM_CL_getmousepos(), and VM_M_getmousepos().

key_dest

keydest_t key_dest

extern

Definition at line 37 of file keys.c.

Referenced by CL_Input(), CL_SendMove(), CL_TimeDemo_f(), CL_ToggleMenu_Hook(), CL_VM_DrawHud(), CL_VM_UpdateView(), Con_DrawNotify(), Con_MsgCmdMode(), IN_Move(), IN_Move_TouchScreen_Quake(), IN_Move_TouchScreen_SteelStorm(), Key_Event(), Key_Message(), M_Demo_Key(), M_Draw(), M_Load_Key(), M_Main_Key(), M_Menu_Credits_f(), M_Menu_Demos_f(), M_Menu_GameOptions_f(), M_Menu_Help_f(), M_Menu_Keys_f(), M_Menu_LanConfig_f(), M_Menu_Load_f(), M_Menu_Main_f(), M_Menu_ModList_f(), M_Menu_MultiPlayer_f(), M_Menu_Options_ColorControl_f(), M_Menu_Options_Effects_f(), M_Menu_Options_f(), M_Menu_Options_Graphics_f(), M_Menu_Quit_f(), M_Menu_Reset_f(), M_Menu_Save_f(), M_Menu_ServerList_f(), M_Menu_Setup_f(), M_Menu_SinglePlayer_f(), M_Menu_Transfusion_Episode_f(), M_Menu_Transfusion_Skill_f(), M_Menu_Video_f(), M_Options_Key(), M_Quit_Key(), M_Save_Key(), M_Shutdown(), M_SinglePlayer_Key(), M_ToggleMenu(), M_Transfusion_Skill_Key(), MP_Shutdown(), MVM_error_cmd(), NetConn_ClientParsePacket(), NetConn_ConnectionEstablished(), SCR_CheckDrawCenterString(), SCR_DrawScreen(), SCR_SetUpToDrawConsole(), Sys_SDL_HandleEvents(), VID_ApplyDisplayMode_c(), VM_CL_getmousepos(), VM_M_getkeydest(), VM_M_getmousepos(), and VM_M_setkeydest().

key_insert

qbool key_insert

extern

Definition at line 36 of file keys.c.

Referenced by Con_DrawInput(), Key_AddChar(), and Key_Parse_CommonKeys().

key_line

char key_line[MAX_INPUTLINE]

extern

Definition at line 34 of file keys.c.

Referenced by Con_CompleteCommandLine(), Con_DrawInput(), Key_AddChar(), Key_ClearEditLine(), Key_Console(), Key_History_Down(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_First(), Key_History_Get_foundCommand(), Key_History_Last(), Key_History_Push(), Key_History_Up(), and Key_Parse_CommonKeys().

key_linepos

int key_linepos

extern

Definition at line 35 of file keys.c.

Referenced by Con_CompleteCommandLine(), Con_DrawInput(), Key_AddChar(), Key_Console(), Key_Event(), Key_History_Down(), Key_History_First(), Key_History_Get_foundCommand(), Key_History_Last(), Key_History_Up(), Key_Init(), and Key_Parse_CommonKeys().

keybindings

char* keybindings[MAX_BINDMAPS][MAX_KEYS]

extern

Definition at line 39 of file keys.c.

Referenced by Key_Bind_f(), Key_Event(), Key_GetBind(), Key_In_Bind_f(), Key_PrintBindList(), Key_SetBinding(), Key_Unbindall_f(), Key_WriteBindings(), and M_UnbindCommand().