keys.h File Reference

Go to the source code of this file.

Enumerations
enum	QKEYS {   K_TAB = 9, K_ENTER = 13, K_ESCAPE = 27, K_SPACE = 32,   K_BACKSPACE = 127, K_UPARROW = 128, K_DOWNARROW = 129, K_LEFTARROW = 130,   K_RIGHTARROW = 131, K_ALT = 132, K_CTRL = 133, K_SHIFT = 134,   K_F1 = 135, K_F2 = 136, K_F3 = 137, K_F4 = 138,   K_F5 = 139, K_F6 = 140, K_F7 = 141, K_F8 = 142,   K_F9 = 143, K_F10 = 144, K_F11 = 145, K_F12 = 146,   K_INS = 147, K_DEL = 148, K_PGDN = 149, K_PGUP = 150,   K_HOME = 151, K_END = 152, K_KP_HOME = 160, K_KP_UPARROW = 161,   K_KP_PGUP = 162, K_KP_LEFTARROW = 163, K_KP_5 = 164, K_KP_RIGHTARROW = 165,   K_KP_END = 166, K_KP_DOWNARROW = 167, K_KP_PGDN = 168, K_KP_ENTER = 169,   K_KP_INS = 170, K_KP_DEL = 171, K_KP_SLASH = 172, K_KP_MINUS = 173,   K_KP_PLUS = 174, K_MOUSE1 = 200, K_MOUSE2 = 201, K_MOUSE3 = 202,   K_MOUSE4 = 241, K_MOUSE5 = 242, K_JOY1 = 203, K_JOY2 = 204,   K_JOY3 = 205, K_JOY4 = 206, K_AUX1 = 207, K_AUX2 = 208,   K_AUX3 = 209, K_AUX4 = 210, K_AUX5 = 211, K_AUX6 = 212,   K_AUX7 = 213, K_AUX8 = 214, K_AUX9 = 215, K_AUX10 = 216,   K_AUX11 = 217, K_AUX12 = 218, K_AUX13 = 219, K_AUX14 = 220,   K_AUX15 = 221, K_AUX16 = 222, K_AUX17 = 223, K_AUX18 = 224,   K_AUX19 = 225, K_AUX20 = 226, K_AUX21 = 227, K_AUX22 = 228,   K_AUX23 = 229, K_AUX24 = 230, K_AUX25 = 231, K_AUX26 = 232,   K_AUX27 = 233, K_AUX28 = 234, K_AUX29 = 235, K_AUX30 = 236,   K_AUX31 = 237, K_AUX32 = 238, K_MWHEELDOWN = 239, K_MWHEELUP = 240,   K_PAUSE = 255, K_LAST }

Functions
void	Key_Event (int key, qboolean down, unsigned time)
void	Key_Init (void)
void	Key_WriteBindings (FILE *f)
void	Key_SetBinding (int keynum, char *binding)
void	Key_ClearStates (void)
int	Key_GetKey (void)

Variables
char *	keybindings [K_LAST]
int	key_repeats [K_LAST]
int	anykeydown
char	chat_buffer []
int	chat_bufferlen
qboolean	chat_team

Enumeration Type Documentation

QKEYS

enum QKEYS

Enumerator
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_KP_HOME
K_KP_UPARROW
K_KP_PGUP
K_KP_LEFTARROW
K_KP_5
K_KP_RIGHTARROW
K_KP_END
K_KP_DOWNARROW
K_KP_PGDN
K_KP_ENTER
K_KP_INS
K_KP_DEL
K_KP_SLASH
K_KP_MINUS
K_KP_PLUS
K_MOUSE1
K_MOUSE2
K_MOUSE3
K_MOUSE4
K_MOUSE5
K_JOY1
K_JOY2
K_JOY3
K_JOY4
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_MWHEELDOWN
K_MWHEELUP
K_PAUSE
K_LAST

Definition at line 24 of file keys.h.

           {
    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       = 128,
    K_DOWNARROW     = 129,
    K_LEFTARROW     = 130,
    K_RIGHTARROW        = 131,
 
    K_ALT           = 132,
    K_CTRL          = 133,
    K_SHIFT         = 134,
    K_F1            = 135,
    K_F2            = 136,
    K_F3            = 137,
    K_F4            = 138,
    K_F5            = 139,
    K_F6            = 140,
    K_F7            = 141,
    K_F8            = 142,
    K_F9            = 143,
    K_F10           = 144,
    K_F11           = 145,
    K_F12           = 146,
    K_INS           = 147,
    K_DEL           = 148,
    K_PGDN          = 149,
    K_PGUP          = 150,
    K_HOME          = 151,
    K_END           = 152,
 
    K_KP_HOME       = 160,
    K_KP_UPARROW        = 161,
    K_KP_PGUP       = 162,
    K_KP_LEFTARROW      = 163,
    K_KP_5          = 164,
    K_KP_RIGHTARROW     = 165,
    K_KP_END        = 166,
    K_KP_DOWNARROW      = 167,
    K_KP_PGDN       = 168,
    K_KP_ENTER      = 169,
    K_KP_INS        = 170,
    K_KP_DEL        = 171,
    K_KP_SLASH      = 172,
    K_KP_MINUS      = 173,
    K_KP_PLUS       = 174,
 
//
// mouse buttons generate virtual keys
//
    K_MOUSE1        = 200,
    K_MOUSE2        = 201,
    K_MOUSE3        = 202,
    K_MOUSE4        = 241,
    K_MOUSE5        = 242,
    
//
// joystick buttons
//
    K_JOY1          = 203,
    K_JOY2          = 204,
    K_JOY3          = 205,
    K_JOY4          = 206,
 
//
// aux keys are for multi-buttoned joysticks to generate so they can use
// the normal binding process
//
    K_AUX1          = 207,
    K_AUX2          = 208,
    K_AUX3          = 209,
    K_AUX4          = 210,
    K_AUX5          = 211,
    K_AUX6          = 212,
    K_AUX7          = 213,
    K_AUX8          = 214,
    K_AUX9          = 215,
    K_AUX10         = 216,
    K_AUX11         = 217,
    K_AUX12         = 218,
    K_AUX13         = 219,
    K_AUX14         = 220,
    K_AUX15         = 221,
    K_AUX16         = 222,
    K_AUX17         = 223,
    K_AUX18         = 224,
    K_AUX19         = 225,
    K_AUX20         = 226,
    K_AUX21         = 227,
    K_AUX22         = 228,
    K_AUX23         = 229,
    K_AUX24         = 230,
    K_AUX25         = 231,
    K_AUX26         = 232,
    K_AUX27         = 233,
    K_AUX28         = 234,
    K_AUX29         = 235,
    K_AUX30         = 236,
    K_AUX31         = 237,
    K_AUX32         = 238,
 
    K_MWHEELDOWN        = 239,
    K_MWHEELUP      = 240,
 
    K_PAUSE         = 255,
 
    K_LAST
};

Function Documentation

Key_ClearStates()

void Key_ClearStates

(

void

)

Definition at line 919 of file keys.c.

{
    int     i;
 
    anykeydown = false;
 
    for (i=0 ; i<K_LAST ; i++)
    {
        if ( keydown[i] || key_repeats[i] )
            Key_Event( i, false, 0 );
        keydown[i] = 0;
        key_repeats[i] = 0;
    }
}

Referenced by AppActivate(), and M_ForceMenuOff().

Key_Event()

void Key_Event	(	int	key,
		qboolean	down,
		unsigned	time
	)

Definition at line 745 of file keys.c.

{
    char    *kb;
    char    cmd[1024];
 
    // hack for modal presses
    if (key_waiting == -1)
    {
        if (down)
            key_waiting = key;
        return;
    }
 
    // update auto-repeat status
    if (down)
    {
        key_repeats[key]++;
        if (key != K_BACKSPACE 
            && key != K_PAUSE 
            && key != K_PGUP 
            && key != K_KP_PGUP 
            && key != K_PGDN
            && key != K_KP_PGDN
            && key_repeats[key] > 1)
          return;   // ignore most autorepeats
            
        if (key >= 200 && !keybindings[key])
            Com_Printf ("%s is unbound, hit F4 to set.\n", Key_KeynumToString (key) );
    }
    else
    {
        key_repeats[key] = 0;
    }
 
    if (key == K_SHIFT)
        shift_down = down;
 
    // console key is hardcoded, so the user can never unbind it
    if (key == '`' || key == '~')
    {
        if (!down)
            return;
        Con_ToggleConsole_f ();
        return;
    }
 
    // any key during the attract mode will bring up the menu
    if (cl.attractloop && cls.key_dest != key_menu &&
        !(key >= K_F1 && key <= K_F12))
        key = K_ESCAPE;
 
    // menu key is hardcoded, so the user can never unbind it
    if (key == K_ESCAPE)
    {
        if (!down)
            return;
 
        if (cl.frame.playerstate.stats[STAT_LAYOUTS] && cls.key_dest == key_game)
        {   // put away help computer / inventory
            Cbuf_AddText ("cmd putaway\n");
            return;
        }
        switch (cls.key_dest)
        {
        case key_message:
            Key_Message (key);
            break;
        case key_menu:
            M_Keydown (key);
            break;
        case key_game:
        case key_console:
            M_Menu_Main_f ();
            break;
        default:
            Com_Error (ERR_FATAL, "Bad cls.key_dest");
        }
        return;
    }
 
    // track if any key is down for BUTTON_ANY
    keydown[key] = down;
    if (down)
    {
        if (key_repeats[key] == 1)
            anykeydown++;
    }
    else
    {
        anykeydown--;
        if (anykeydown < 0)
            anykeydown = 0;
    }
 
//
// key up events only generate commands if the game key binding is
// a button command (leading + sign).  These will occur even in console mode,
// to keep the character from continuing an action started before a console
// switch.  Button commands include the kenum as a parameter, so multiple
// downs can be matched with ups
//
    if (!down)
    {
        kb = keybindings[key];
        if (kb && kb[0] == '+')
        {
            Com_sprintf (cmd, sizeof(cmd), "-%s %i %i\n", kb+1, key, time);
            Cbuf_AddText (cmd);
        }
        if (keyshift[key] != key)
        {
            kb = keybindings[keyshift[key]];
            if (kb && kb[0] == '+')
            {
                Com_sprintf (cmd, sizeof(cmd), "-%s %i %i\n", kb+1, key, time);
                Cbuf_AddText (cmd);
            }
        }
        return;
    }
 
//
// if not a consolekey, send to the interpreter no matter what mode is
//
    if ( (cls.key_dest == key_menu && menubound[key])
    || (cls.key_dest == key_console && !consolekeys[key])
    || (cls.key_dest == key_game && ( cls.state == ca_active || !consolekeys[key] ) ) )
    {
        kb = keybindings[key];
        if (kb)
        {
            if (kb[0] == '+')
            {   // button commands add keynum and time as a parm
                Com_sprintf (cmd, sizeof(cmd), "%s %i %i\n", kb, key, time);
                Cbuf_AddText (cmd);
            }
            else
            {
                Cbuf_AddText (kb);
                Cbuf_AddText ("\n");
            }
        }
        return;
    }
 
    if (!down)
        return;     // other systems only care about key down events
 
    if (shift_down)
        key = keyshift[key];
 
    switch (cls.key_dest)
    {
    case key_message:
        Key_Message (key);
        break;
    case key_menu:
        M_Keydown (key);
        break;
 
    case key_game:
    case key_console:
        Key_Console (key);
        break;
    default:
        Com_Error (ERR_FATAL, "Bad cls.key_dest");
    }
}

Referenced by IN_Commands(), IN_MouseEvent(), Key_ClearStates(), and MainWndProc().

Key_GetKey()

int Key_GetKey

(

void

)

Definition at line 940 of file keys.c.

{
    key_waiting = -1;
 
    while (key_waiting == -1)
        Sys_SendKeyEvents ();
 
    return key_waiting;
}

Key_Init()

void Key_Init

(

void

)

Definition at line 650 of file keys.c.

{
    int     i;
 
    for (i=0 ; i<32 ; i++)
    {
        key_lines[i][0] = ']';
        key_lines[i][1] = 0;
    }
    key_linepos = 1;
    
//
// init ascii characters in console mode
//
    for (i=32 ; i<128 ; i++)
        consolekeys[i] = true;
    consolekeys[K_ENTER] = true;
    consolekeys[K_KP_ENTER] = true;
    consolekeys[K_TAB] = true;
    consolekeys[K_LEFTARROW] = true;
    consolekeys[K_KP_LEFTARROW] = true;
    consolekeys[K_RIGHTARROW] = true;
    consolekeys[K_KP_RIGHTARROW] = true;
    consolekeys[K_UPARROW] = true;
    consolekeys[K_KP_UPARROW] = true;
    consolekeys[K_DOWNARROW] = true;
    consolekeys[K_KP_DOWNARROW] = true;
    consolekeys[K_BACKSPACE] = true;
    consolekeys[K_HOME] = true;
    consolekeys[K_KP_HOME] = true;
    consolekeys[K_END] = true;
    consolekeys[K_KP_END] = true;
    consolekeys[K_PGUP] = true;
    consolekeys[K_KP_PGUP] = true;
    consolekeys[K_PGDN] = true;
    consolekeys[K_KP_PGDN] = true;
    consolekeys[K_SHIFT] = true;
    consolekeys[K_INS] = true;
    consolekeys[K_KP_INS] = true;
    consolekeys[K_KP_DEL] = true;
    consolekeys[K_KP_SLASH] = true;
    consolekeys[K_KP_PLUS] = true;
    consolekeys[K_KP_MINUS] = true;
    consolekeys[K_KP_5] = true;
 
    consolekeys['`'] = false;
    consolekeys['~'] = false;
 
    for (i=0 ; i<K_LAST ; i++)
        keyshift[i] = i;
    for (i='a' ; i<='z' ; i++)
        keyshift[i] = i - 'a' + 'A';
    keyshift['1'] = '!';
    keyshift['2'] = '@';
    keyshift['3'] = '#';
    keyshift['4'] = '$';
    keyshift['5'] = '%';
    keyshift['6'] = '^';
    keyshift['7'] = '&';
    keyshift['8'] = '*';
    keyshift['9'] = '(';
    keyshift['0'] = ')';
    keyshift['-'] = '_';
    keyshift['='] = '+';
    keyshift[','] = '<';
    keyshift['.'] = '>';
    keyshift['/'] = '?';
    keyshift[';'] = ':';
    keyshift['\''] = '"';
    keyshift['['] = '{';
    keyshift[']'] = '}';
    keyshift['`'] = '~';
    keyshift['\\'] = '|';
 
    menubound[K_ESCAPE] = true;
    for (i=0 ; i<12 ; i++)
        menubound[K_F1+i] = true;
 
//
// register our functions
//
    Cmd_AddCommand ("bind",Key_Bind_f);
    Cmd_AddCommand ("unbind",Key_Unbind_f);
    Cmd_AddCommand ("unbindall",Key_Unbindall_f);
    Cmd_AddCommand ("bindlist",Key_Bindlist_f);
}

Key_SetBinding()

void Key_SetBinding	(	int	keynum,
		char *	binding
	)

Definition at line 509 of file keys.c.

{
    char    *new;
    int     l;
            
    if (keynum == -1)
        return;
 
// free old bindings
    if (keybindings[keynum])
    {
        Z_Free (keybindings[keynum]);
        keybindings[keynum] = NULL;
    }
            
// allocate memory for new binding
    l = strlen (binding);   
    new = Z_Malloc (l+1);
    strcpy (new, binding);
    new[l] = 0;
    keybindings[keynum] = new;  
}

Referenced by Key_Bind_f(), Key_Unbind_f(), Key_Unbindall_f(), and M_UnbindCommand().

Key_WriteBindings()

void Key_WriteBindings

(

FILE *

f

)

Definition at line 619 of file keys.c.

{
    int     i;
 
    for (i=0 ; i<K_LAST ; i++)
        if (keybindings[i] && keybindings[i][0])
            fprintf (f, "bind %s \"%s\"\n", Key_KeynumToString(i), keybindings[i]);
}

Referenced by CL_WriteConfiguration().

Variable Documentation

anykeydown

int anykeydown

Definition at line 33 of file keys.c.

Referenced by CL_FinishMove(), Key_ClearStates(), and Key_Event().

chat_buffer

char chat_buffer[]

Definition at line 395 of file keys.c.

Referenced by Con_DrawNotify(), and Key_Message().

chat_bufferlen

int chat_bufferlen

Definition at line 396 of file keys.c.

Referenced by Con_DrawNotify(), and Key_Message().

chat_team

qboolean chat_team

Definition at line 394 of file keys.c.

Referenced by Con_DrawNotify(), Con_MessageMode2_f(), Con_MessageMode_f(), and Key_Message().

key_repeats

int key_repeats[K_LAST]

Definition at line 43 of file keys.c.

Referenced by Key_ClearStates(), and Key_Event().

keybindings

char* keybindings[K_LAST]

Definition at line 39 of file keys.c.

Referenced by CL_DrawInventory(), Key_Bind_f(), Key_Bindlist_f(), Key_Event(), Key_SetBinding(), Key_Unbindall_f(), Key_WriteBindings(), M_FindKeysForCommand(), and M_UnbindCommand().