keys.c File Reference

#include "client.h"
#include <ctype.h>

Go to the source code of this file.

Classes
struct	keyname_t

Macros
#define	MAXCMDLINE   256

Functions
void	CompleteCommand (void)
void	Key_Console (int key)
void	Key_Message (int key)
int	Key_StringToKeynum (char *str)
char *	Key_KeynumToString (int keynum)
void	Key_SetBinding (int keynum, char *binding)
void	Key_Unbind_f (void)
void	Key_Unbindall_f (void)
void	Key_Bind_f (void)
void	Key_WriteBindings (FILE *f)
void	Key_Bindlist_f (void)
void	Key_Init (void)
void	Key_Event (int key, qboolean down, unsigned time)
void	Key_ClearStates (void)
int	Key_GetKey (void)

Variables
char	key_lines [128][MAXCMDLINE]
int	key_linepos
int	shift_down =false
int	anykeydown
int	edit_line =0
int	history_line =0
int	key_waiting
char *	keybindings [256]
qboolean	consolekeys [256]
qboolean	menubound [256]
int	keyshift [256]
int	key_repeats [256]
qboolean	keydown [256]
keyname_t	keynames []
qboolean	chat_team
char	chat_buffer [MAXCMDLINE]
int	chat_bufferlen = 0

Macro Definition Documentation

MAXCMDLINE

#define MAXCMDLINE   256

Definition at line 30 of file keys.c.

Function Documentation

CompleteCommand()

void CompleteCommand

(

void

)

Definition at line 166 of file keys.c.

{
    char    *cmd, *s;
 
    s = key_lines[edit_line]+1;
    if (*s == '\\' || *s == '/')
        s++;
 
    cmd = Cmd_CompleteCommand (s);
    if (!cmd)
        cmd = Cvar_CompleteVariable (s);
    if (cmd)
    {
        key_lines[edit_line][1] = '/';
        strcpy (key_lines[edit_line]+2, cmd);
        key_linepos = (int)strlen(cmd)+2;
        key_lines[edit_line][key_linepos] = ' ';
        key_linepos++;
        key_lines[edit_line][key_linepos] = 0;
        return;
    }
}

Referenced by Key_Console().

Key_Bind_f()

void Key_Bind_f

(

void

)

Definition at line 569 of file keys.c.

{
    int         i, c, b;
    char        cmd[1024];
    
    c = Cmd_Argc();
 
    if (c < 2)
    {
        Com_Printf ("bind <key> [command] : attach a command to a key\n");
        return;
    }
    b = Key_StringToKeynum (Cmd_Argv(1));
    if (b==-1)
    {
        Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
        return;
    }
 
    if (c == 2)
    {
        if (keybindings[b])
            Com_Printf ("\"%s\" = \"%s\"\n", Cmd_Argv(1), keybindings[b] );
        else
            Com_Printf ("\"%s\" is not bound\n", Cmd_Argv(1) );
        return;
    }
    
// copy the rest of the command line
    cmd[0] = 0;     // start out with a null string
    for (i=2 ; i< c ; i++)
    {
        strcat (cmd, Cmd_Argv(i));
        if (i != (c-1))
            strcat (cmd, " ");
    }
 
    Key_SetBinding (b, cmd);
}

Referenced by Key_Init().

Key_Bindlist_f()

void Key_Bindlist_f

(

void

)

Definition at line 632 of file keys.c.

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

Referenced by Key_Init().

Key_ClearStates()

void Key_ClearStates

(

void

)

Definition at line 935 of file keys.c.

{
    int     i;
 
    anykeydown = false;
 
    for (i=0 ; i<256 ; 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_Console()

void Key_Console

(

int

key

)

Definition at line 196 of file keys.c.

{
 
    switch ( key )
    {
    case K_KP_SLASH:
        key = '/';
        break;
    case K_KP_MINUS:
        key = '-';
        break;
    case K_KP_PLUS:
        key = '+';
        break;
    case K_KP_HOME:
        key = '7';
        break;
    case K_KP_UPARROW:
        key = '8';
        break;
    case K_KP_PGUP:
        key = '9';
        break;
    case K_KP_LEFTARROW:
        key = '4';
        break;
    case K_KP_5:
        key = '5';
        break;
    case K_KP_RIGHTARROW:
        key = '6';
        break;
    case K_KP_END:
        key = '1';
        break;
    case K_KP_DOWNARROW:
        key = '2';
        break;
    case K_KP_PGDN:
        key = '3';
        break;
    case K_KP_INS:
        key = '0';
        break;
    case K_KP_DEL:
        key = '.';
        break;
    }
 
    if ( ( toupper( key ) == 'V' && keydown[K_CTRL] ) ||
         ( ( ( key == K_INS ) || ( key == K_KP_INS ) ) && keydown[K_SHIFT] ) )
    {
        char *cbd;
        
        if ( ( cbd = Sys_GetClipboardData() ) != 0 )
        {
            int i;
 
            strtok( cbd, "\n\r\b" );
 
            i = (int)strlen( cbd );
            if ( i + key_linepos >= MAXCMDLINE)
                i= MAXCMDLINE - key_linepos;
 
            if ( i > 0 )
            {
                cbd[i]=0;
                strcat( key_lines[edit_line], cbd );
                key_linepos += i;
            }
            free( cbd );
        }
 
        return;
    }
 
    if ( key == 'l' ) 
    {
        if ( keydown[K_CTRL] )
        {
            Cbuf_AddText ("clear\n");
            return;
        }
    }
 
    if ( key == K_ENTER || key == K_KP_ENTER )
    {   // backslash text are commands, else chat
        if (key_lines[edit_line][1] == '\\' || key_lines[edit_line][1] == '/')
            Cbuf_AddText (key_lines[edit_line]+2);  // skip the >
        else
            Cbuf_AddText (key_lines[edit_line]+1);  // valid command
 
        Cbuf_AddText ("\n");
        Com_Printf ("%s\n",key_lines[edit_line]);
        edit_line = (edit_line + 1) & 31;
        history_line = edit_line;
        key_lines[edit_line][0] = ']';
        key_linepos = 1;
        if (cls.state == ca_disconnected)
            SCR_UpdateScreen ();    // force an update, because the command
                                    // may take some time
        return;
    }
 
    if (key == K_TAB)
    {   // command completion
        CompleteCommand ();
        return;
    }
    
    if ( ( key == K_BACKSPACE ) || ( key == K_LEFTARROW ) || ( key == K_KP_LEFTARROW ) || ( ( key == 'h' ) && ( keydown[K_CTRL] ) ) )
    {
        if (key_linepos > 1)
            key_linepos--;
        return;
    }
 
    if ( ( key == K_UPARROW ) || ( key == K_KP_UPARROW ) ||
         ( ( key == 'p' ) && keydown[K_CTRL] ) )
    {
        do
        {
            history_line = (history_line - 1) & 31;
        } while (history_line != edit_line
                && !key_lines[history_line][1]);
        if (history_line == edit_line)
            history_line = (edit_line+1)&31;
        strcpy(key_lines[edit_line], key_lines[history_line]);
        key_linepos = (int)strlen(key_lines[edit_line]);
        return;
    }
 
    if ( ( key == K_DOWNARROW ) || ( key == K_KP_DOWNARROW ) ||
         ( ( key == 'n' ) && keydown[K_CTRL] ) )
    {
        if (history_line == edit_line) return;
        do
        {
            history_line = (history_line + 1) & 31;
        }
        while (history_line != edit_line
            && !key_lines[history_line][1]);
        if (history_line == edit_line)
        {
            key_lines[edit_line][0] = ']';
            key_linepos = 1;
        }
        else
        {
            strcpy(key_lines[edit_line], key_lines[history_line]);
            key_linepos = (int)strlen(key_lines[edit_line]);
        }
        return;
    }
 
    if (key == K_PGUP || key == K_MWHEELUP || key == K_KP_PGUP )
    {
        con.display -= 2;
        return;
    }
 
    if (key == K_PGDN || key == K_MWHEELDOWN || key == K_KP_PGDN )
    {
        con.display += 2;
        if (con.display > con.current)
            con.display = con.current;
        return;
    }
 
    if (key == K_HOME || key == K_KP_HOME )
    {
        con.display = con.current - con.totallines + 10;
        return;
    }
 
    if (key == K_END || key == K_KP_END )
    {
        con.display = con.current;
        return;
    }
    
    if (key < 32 || key > 127)
        return; // non printable
        
    if (key_linepos < MAXCMDLINE-1)
    {
        key_lines[edit_line][key_linepos] = key;
        key_linepos++;
        key_lines[edit_line][key_linepos] = 0;
    }
 
}

Referenced by Key_Event().

Key_Event()

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

Definition at line 744 of file keys.c.

{
    char    *kb;
    char    cmd[1024];
 
    // hack for modal presses
    if (key_waiting == -1)
    {
        if (down)
            key_waiting = key;
        return;
    }
 
    keydown[key] = down;
    // ALT+ENTER fullscreen toggle
    if (down && keydown[K_ALT] && key == K_ENTER)
    {
        extern cvar_t *vid_fullscreen;
        Cvar_Set("vid_fullscreen", vid_fullscreen->value ? "0" : "1");
        vid_fullscreen->modified = true;
        return;
    }
 
#ifdef __APPLE__
    // ALT+F4 game shutdown
    if (down && keydown[K_ALT] && key == K_F4)
    {
        CL_Quit_f();
        return;
    }
#endif
 
    // 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 && key != K_MWHEELUP && key != K_MWHEELDOWN && !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;
    }
 
    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 956 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 647 of file keys.c.

{
    int     i;
 
    for (i=0 ; i<128 ; 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_MWHEELUP] = true;
    consolekeys[K_MWHEELDOWN] = 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<256 ; 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);
}

Referenced by Qcommon_Init().

Key_KeynumToString()

char* Key_KeynumToString

(

int

keynum

)

Definition at line 479 of file keys.c.

{
    keyname_t   *kn;    
    static  char    tinystr[2];
    
    if (keynum == -1)
        return "<KEY NOT FOUND>";
    if (keynum > 32 && keynum < 127)
    {   // printable ascii
        tinystr[0] = keynum;
        tinystr[1] = 0;
        return tinystr;
    }
    
    for (kn=keynames ; kn->name ; kn++)
        if (keynum == kn->keynum)
            return kn->name;
 
    return "<UNKNOWN KEYNUM>";
}

Referenced by CL_DrawInventory(), DrawKeyBindingFunc(), Key_Bindlist_f(), Key_Event(), Key_WriteBindings(), and Keys_MenuKey().

Key_Message()

void Key_Message

(

int

key

)

Definition at line 395 of file keys.c.

{
 
    if ( key == K_ENTER || key == K_KP_ENTER )
    {
        if (chat_team)
            Cbuf_AddText ("say_team \"");
        else
            Cbuf_AddText ("say \"");
        Cbuf_AddText(chat_buffer);
        Cbuf_AddText("\"\n");
 
        cls.key_dest = key_game;
        chat_bufferlen = 0;
        chat_buffer[0] = 0;
        return;
    }
 
    if (key == K_ESCAPE)
    {
        cls.key_dest = key_game;
        chat_bufferlen = 0;
        chat_buffer[0] = 0;
        return;
    }
 
    if (key < 32 || key > 127)
        return; // non printable
 
    if (key == K_BACKSPACE)
    {
        if (chat_bufferlen)
        {
            chat_bufferlen--;
            chat_buffer[chat_bufferlen] = 0;
        }
        return;
    }
 
    if (chat_bufferlen == sizeof(chat_buffer)-1)
        return; // all full
 
    chat_buffer[chat_bufferlen++] = key;
    chat_buffer[chat_bufferlen] = 0;
}

Referenced by Key_Event().

Key_SetBinding()

void Key_SetBinding	(	int	keynum,
		char *	binding
	)

Definition at line 506 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 = (int)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_StringToKeynum()

int Key_StringToKeynum

(

char *

str

)

Definition at line 453 of file keys.c.

{
    keyname_t   *kn;
    
    if (!str || !str[0])
        return -1;
    if (!str[1])
        return str[0];
 
    for (kn=keynames ; kn->name ; kn++)
    {
        if (!Q_strcasecmp(str,kn->name))
            return kn->keynum;
    }
    return -1;
}

Referenced by Key_Bind_f(), and Key_Unbind_f().

Key_Unbind_f()

void Key_Unbind_f

(

void

)

Definition at line 534 of file keys.c.

{
    int     b;
 
    if (Cmd_Argc() != 2)
    {
        Com_Printf ("unbind <key> : remove commands from a key\n");
        return;
    }
    
    b = Key_StringToKeynum (Cmd_Argv(1));
    if (b==-1)
    {
        Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
        return;
    }
 
    Key_SetBinding (b, "");
}

Referenced by Key_Init().

Key_Unbindall_f()

void Key_Unbindall_f

(

void

)

Definition at line 554 of file keys.c.

{
    int     i;
    
    for (i=0 ; i<256 ; i++)
        if (keybindings[i])
            Key_SetBinding (i, "");
}

Referenced by Key_Init().

Key_WriteBindings()

void Key_WriteBindings

(

FILE *

f

)

Definition at line 616 of file keys.c.

{
    int     i;
 
    for (i=0 ; i<256 ; 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 34 of file keys.c.

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

chat_buffer

char chat_buffer[MAXCMDLINE]

Definition at line 392 of file keys.c.

Referenced by Con_DrawNotify(), and Key_Message().

chat_bufferlen

int chat_bufferlen = 0

Definition at line 393 of file keys.c.

Referenced by Con_DrawNotify(), and Key_Message().

chat_team

qboolean chat_team

Definition at line 391 of file keys.c.

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

consolekeys

qboolean consolekeys[256]

Definition at line 41 of file keys.c.

Referenced by Key_Event(), and Key_Init().

edit_line

int edit_line =0

Definition at line 36 of file keys.c.

Referenced by CompleteCommand(), Con_DrawInput(), Key_ClearTyping(), and Key_Console().

history_line

int history_line =0

Definition at line 37 of file keys.c.

Referenced by Key_Console().

key_linepos

int key_linepos

Definition at line 32 of file keys.c.

Referenced by CompleteCommand(), Con_DrawInput(), Key_ClearTyping(), Key_Console(), and Key_Init().

key_lines

char key_lines[128][MAXCMDLINE]

Definition at line 31 of file keys.c.

Referenced by CompleteCommand(), Con_DrawInput(), Key_ClearTyping(), Key_Console(), and Key_Init().

key_repeats

int key_repeats[256]

Definition at line 44 of file keys.c.

Referenced by Key_ClearStates(), and Key_Event().

key_waiting

int key_waiting

Definition at line 39 of file keys.c.

Referenced by Key_Event(), and Key_GetKey().

keybindings

char* keybindings[256]

Definition at line 40 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().

keydown

qboolean keydown[256]

Definition at line 45 of file keys.c.

Referenced by Field_Key(), Key_ClearStates(), Key_Console(), and Key_Event().

keynames

keyname_t keynames[]

Definition at line 53 of file keys.c.

Referenced by Key_KeynumToString(), and Key_StringToKeynum().

keyshift

int keyshift[256]

Definition at line 43 of file keys.c.

Referenced by Key_Event(), and Key_Init().

menubound

qboolean menubound[256]

Definition at line 42 of file keys.c.

Referenced by Key_Event(), and Key_Init().

shift_down

int shift_down =false

Definition at line 33 of file keys.c.

Referenced by Key_Event().