keys.c File Reference

#include "client.h"

Go to the source code of this file.

Classes
struct	keyname_s

Macros
#define	K(x)   { #x, K_##x }
#define	K(x)   Q_SetBit(consolekeys, K_##x)

Typedefs
typedef struct keyname_s	keyname_t

Functions
qboolean	Key_GetOverstrikeMode (void)
void	Key_SetOverstrikeMode (qboolean overstrike)
keydest_t	Key_GetDest (void)
void	Key_SetDest (keydest_t dest)
int	Key_IsDown (int key)
int	Key_AnyKeyDown (void)
int	Key_StringToKeynum (const char *str)
char *	Key_KeynumToString (int keynum)
char *	Key_GetBinding (const char *binding)
char *	Key_GetBindingForKey (int keynum)
int	Key_EnumBindings (int key, const char *binding)
void	Key_SetBinding (int keynum, const char *binding)
static void	Key_Name_g (genctx_t *ctx)
static void	Key_Bound_g (genctx_t *ctx)
static void	Key_Bind_c (genctx_t *ctx, int argnum)
static void	Key_Unbind_c (genctx_t *ctx, int argnum)
static void	Key_Unbind_f (void)
static void	Key_Unbindall_f (void)
static void	Key_Bind_f (void)
void	Key_WriteBindings (qhandle_t f)
static void	Key_Bindlist_f (void)
void	Key_Init (void)
void	Key_Event (unsigned key, qboolean down, unsigned time)
void	Key_ClearStates (void)
void	Key_WaitKey (keywaitcb_t wait, void *arg)

Variables
static keywaitcb_t	key_wait_cb
static void *	key_wait_arg
static char *	keybindings [256]
static byte	consolekeys [256/8]
static byte	keyshift [256]
static byte	keydown [256]
static int	anykeydown
static byte	buttondown [256/8]
static qboolean	key_overstrike
static const keyname_t	keynames []
static cmdreg_t	c_keys []

Macro Definition Documentation

K [1/2]

#define K

(

x

)

{ #x, K_##x }

Definition at line 48 of file keys.c.

K [2/2]

#define K

(

x

)

Q_SetBit(consolekeys, K_##x)

Definition at line 48 of file keys.c.

Typedef Documentation

keyname_t

typedef struct keyname_s keyname_t

Function Documentation

Key_AnyKeyDown()

int Key_AnyKeyDown

(

void

)

Definition at line 220 of file keys.c.

{
    return anykeydown;
}

Referenced by CL_FinalizeCmd().

Key_Bind_c()

static void Key_Bind_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 381 of file keys.c.

{
    if (argnum == 1) {
        Key_Name_g(ctx);
    } else {
        Com_Generic_c(ctx, argnum - 2);
    }
}

Key_Bind_f()

static void Key_Bind_f ( void  )

static

Definition at line 440 of file keys.c.

{
    int c, b;
 
    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
    Key_SetBinding(b, Cmd_ArgsFrom(2));
}

Key_Bindlist_f()

static void Key_Bindlist_f ( void  )

static

Definition at line 494 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]);
        }
    }
}

Key_Bound_g()

static void Key_Bound_g ( genctx_t *  ctx )

static

Definition at line 367 of file keys.c.

{
    int i;
 
    ctx->ignorecase = qtrue;
    for (i = 0; i < 256; i++) {
        if (keybindings[i]) {
            if (!Prompt_AddMatch(ctx, Key_KeynumToString(i))) {
                break;
            }
        }
    }
}

Referenced by Key_Unbind_c().

Key_ClearStates()

void Key_ClearStates

(

void

)

Definition at line 875 of file keys.c.

{
    int     i;
 
    // hack for menu key binding
    if (key_wait_cb) {
        key_wait_cb(key_wait_arg, K_ESCAPE);
        key_wait_cb = NULL;
    }
 
    for (i = 0; i < 256; i++) {
        if (keydown[i])
            Key_Event(i, qfalse, com_eventTime);
    }
 
    memset(buttondown, 0, sizeof(buttondown));
    anykeydown = 0;
}

Referenced by CL_Activate().

Key_EnumBindings()

int Key_EnumBindings	(	int	key,
		const char *	binding
	)

Definition at line 320 of file keys.c.

{
    if (key < 0) {
        key = 0;
    }
    for (; key < 256; key++) {
        if (keybindings[key]) {
            if (!Q_stricmp(keybindings[key], binding)) {
                return key;
            }
        }
    }
 
    return -1;
}

Referenced by Keybind_Push(), and Keybind_Remove().

Key_Event()

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

Definition at line 627 of file keys.c.

{
    char    *kb;
    char    cmd[MAX_STRING_CHARS];
 
    if (key >= 256) {
        Com_Error(ERR_FATAL, "%s: bad key", __func__);
    }
 
    Com_DDDPrintf("%u: %c%s\n", time,
                  down ? '+' : '-', Key_KeynumToString(key));
 
    // hack for menu key binding
    if (key_wait_cb && down && !key_wait_cb(key_wait_arg, key)) {
        return;
    }
 
    // update key down and auto-repeat status
    if (down) {
        if (keydown[key] < 255)
            keydown[key]++;
    } else {
        keydown[key] = 0;
    }
 
    // console key is hardcoded, so the user can never unbind it
    if (!Key_IsDown(K_SHIFT) && (key == '`' || key == '~')) {
        if (keydown[key] == 1) {
            Con_ToggleConsole_f();
        }
        return;
    }
 
    // Alt+Enter is hardcoded for all systems
    if (Key_IsDown(K_ALT) && key == K_ENTER) {
        if (keydown[key] == 1) {
            VID_ToggleFullscreen();
        }
        return;
    }
 
    // menu key is hardcoded, so the user can never unbind it
    if (key == K_ESCAPE) {
        if (!down) {
            return;
        }
 
        if (cls.key_dest == KEY_GAME &&
            cl.frame.ps.stats[STAT_LAYOUTS] &&
            cls.demo.playback == qfalse) {
            if (keydown[key] == 2) {
                // force main menu if escape is held
                UI_OpenMenu(UIMENU_GAME);
            } else if (keydown[key] == 1) {
                // put away help computer / inventory
                CL_ClientCommand("putaway");
            }
            return;
        }
 
        // ignore autorepeats
        if (keydown[key] > 1) {
            return;
        }
 
        if (cls.key_dest & KEY_CONSOLE) {
            if (cls.state < ca_active && !(cls.key_dest & KEY_MENU)) {
                UI_OpenMenu(UIMENU_MAIN);
            } else {
                Con_Close(qtrue);
            }
        } else if (cls.key_dest & KEY_MENU) {
            UI_KeyEvent(key, down);
        } else if (cls.key_dest & KEY_MESSAGE) {
            Key_Message(key);
        } else if (cls.state >= ca_active) {
            UI_OpenMenu(UIMENU_GAME);
        } else {
            UI_OpenMenu(UIMENU_MAIN);
        }
        return;
    }
 
    // track if any key is down for BUTTON_ANY
    if (down) {
        if (keydown[key] == 1)
            anykeydown++;
    } else {
        anykeydown--;
        if (anykeydown < 0)
            anykeydown = 0;
    }
 
    // hack for demo freelook in windowed mode
    if (cls.key_dest == KEY_GAME && cls.demo.playback && key == K_SHIFT && keydown[key] <= 1) {
        IN_Activate();
    }
 
    // skip the rest of the cinematic
    if (cls.key_dest == KEY_GAME && cls.state == ca_cinematic && down) {
        SCR_FinishCinematic();
    }
 
    if (cls.key_dest == KEY_GAME)
    {
        if(R_InterceptKey(key, down))
            return;
    }
 
//
// if not a consolekey, send to the interpreter no matter what mode is
//
    if ((cls.key_dest == KEY_GAME) ||
        ((cls.key_dest & KEY_CONSOLE) && !Q_IsBitSet(consolekeys, key)) ||
        ((cls.key_dest & KEY_MENU) && (key >= K_F1 && key <= K_F12)) ||
        (!down && Q_IsBitSet(buttondown, key))) {
//
// 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] == '+') {
                Q_snprintf(cmd, sizeof(cmd), "-%s %i %i\n",
                           kb + 1, key, time);
                Cbuf_AddText(&cmd_buffer, cmd);
            }
            Q_ClearBit(buttondown, key);
            return;
        }
 
        // ignore autorepeats
        if (keydown[key] > 1) {
            return;
        }
 
        // generate button up command when released
        Q_SetBit(buttondown, key);
 
        kb = keybindings[key];
        if (kb) {
            if (kb[0] == '+') {
                // button commands add keynum and time as a parm
                Q_snprintf(cmd, sizeof(cmd), "%s %i %i\n", kb, key, time);
                Cbuf_AddText(&cmd_buffer, cmd);
            } else {
                Cbuf_AddText(&cmd_buffer, kb);
                Cbuf_AddText(&cmd_buffer, "\n");
            }
        }
        return;
    }
 
    if (cls.key_dest == KEY_GAME)
        return;
 
    if (!down) {
        if (cls.key_dest & KEY_MENU)
            UI_KeyEvent(key, down);
        return;     // other subsystems only care about key down events
    }
 
    if (cls.key_dest & KEY_CONSOLE) {
        Key_Console(key);
    } else if (cls.key_dest & KEY_MENU) {
        UI_KeyEvent(key, down);
    } else if (cls.key_dest & KEY_MESSAGE) {
        Key_Message(key);
    }
 
    if (Key_IsDown(K_CTRL) || Key_IsDown(K_ALT)) {
        return;
    }
 
    switch (key) {
    case K_KP_SLASH:
        key = '/';
        break;
    case K_KP_MULTIPLY:
        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 key is printable, generate char events
    if (key < 32 || key >= 127) {
        return;
    }
 
    if (Key_IsDown(K_SHIFT)) {
        key = keyshift[key];
    }
 
    if (cls.key_dest & KEY_CONSOLE) {
        Char_Console(key);
    } else if (cls.key_dest & KEY_MENU) {
        UI_CharEvent(key);
    } else if (cls.key_dest & KEY_MESSAGE) {
        Char_Message(key);
    }
}

Referenced by DI_GetMouseEvents(), Key_ClearStates(), legacy_key_event(), legacy_mouse_event(), LowLevelKeyboardProc(), mouse_hwheel_event(), mouse_wheel_event(), and raw_mouse_event().

Key_GetBinding()

char* Key_GetBinding

(

const char *

binding

)

Definition at line 288 of file keys.c.

{
    int key;
 
    for (key = 0; key < 256; key++) {
        if (keybindings[key]) {
            if (!Q_stricmp(keybindings[key], binding)) {
                return Key_KeynumToString(key);
            }
        }
    }
 
    return "";
}

Referenced by SCR_DrawInventory().

Key_GetBindingForKey()

char* Key_GetBindingForKey

(

int

keynum

)

Definition at line 310 of file keys.c.

{
    return keybindings[keynum];
}

Referenced by R_InterceptKey_RTX().

Key_GetDest()

keydest_t Key_GetDest

(

void

)

Definition at line 168 of file keys.c.

{
    return cls.key_dest;
}

Referenced by mouse_wheel_event(), UI_Draw(), UI_ForceMenuOff(), UI_IsTransparent(), and UI_PushMenu().

Key_GetOverstrikeMode()

qboolean Key_GetOverstrikeMode

(

void

)

Definition at line 148 of file keys.c.

{
    return key_overstrike;
}

Key_Init()

void Key_Init

(

void

)

Definition at line 520 of file keys.c.

{
    int     i;
 
//
// init ascii characters in console mode
//
    for (i = K_ASCIIFIRST; i <= K_ASCIILAST; i++)
        Q_SetBit(consolekeys, i);
 
#define K(x) \
    Q_SetBit(consolekeys, K_##x)
 
    K(BACKSPACE);
    K(TAB);
    K(ENTER);
 
    K(UPARROW);
    K(DOWNARROW);
    K(LEFTARROW);
    K(RIGHTARROW);
 
    K(ALT);
    K(LALT);
    K(RALT);
    K(CTRL);
    K(LCTRL);
    K(RCTRL);
    K(SHIFT);
    K(LSHIFT);
    K(RSHIFT);
 
    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(KP_MULTIPLY);
 
    K(MOUSE3);
 
    K(MWHEELUP);
    K(MWHEELDOWN);
 
#undef K
 
//
// init ascii keyshift characters
//
    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['\\'] = '|';
 
//
// register our functions
//
    Cmd_Register(c_keys);
}

Referenced by Qcommon_Init().

Key_IsDown()

int Key_IsDown

(

int

key

)

Definition at line 204 of file keys.c.

{
    if (key < 0 || key > 255) {
        return 0;
    }
 
    return keydown[key];
}

Referenced by IN_GetCurrentGrab(), Key_Console(), Key_Event(), Key_Message(), Keydown(), MenuList_Key(), R_InterceptKey_RTX(), SCR_DrawLayout(), vkpt_freecam_mousemove(), and vkpt_freecam_update().

Key_KeynumToString()

char* Key_KeynumToString

(

int

keynum

)

Definition at line 259 of file keys.c.

{
    const keyname_t *kn;
    static char tinystr[2];
 
    if (keynum == -1)
        return "<KEY NOT FOUND>";
 
    if (keynum > 32 && keynum < 127 && keynum != ';' && keynum != '"') {
        // 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 Key_Bindlist_f(), Key_Bound_g(), Key_Event(), Key_GetBinding(), Key_WriteBindings(), and Keybind_Push().

Key_Name_g()

static void Key_Name_g ( genctx_t *  ctx )

static

Definition at line 355 of file keys.c.

{
    const keyname_t *k;
 
    ctx->ignorecase = qtrue;
    for (k = keynames; k->name; k++) {
        if (!Prompt_AddMatch(ctx, k->name)) {
            break;
        }
    }
}

Referenced by Key_Bind_c().

Key_SetBinding()

void Key_SetBinding	(	int	keynum,
		const char *	binding
	)

Definition at line 341 of file keys.c.

{
    if (keynum < 0 || keynum > 255)
        return;
 
// free old binding
    if (keybindings[keynum]) {
        Z_Free(keybindings[keynum]);
    }
 
// allocate memory for new binding
    keybindings[keynum] = Z_CopyString(binding);
}

Referenced by Key_Bind_f(), Key_Unbind_f(), Key_Unbindall_f(), keybind_cb(), and Keybind_Remove().

Key_SetDest()

void Key_SetDest

(

keydest_t

dest

)

Definition at line 178 of file keys.c.

{
    int diff;
 
// if not connected, console or menu should be up
    if (cls.state < ca_active && !(dest & (KEY_MENU | KEY_CONSOLE))) {
        dest |= KEY_CONSOLE;
    }
 
    diff = cls.key_dest ^ dest;
    cls.key_dest = dest;
 
// activate or deactivate mouse
    if (diff & (KEY_CONSOLE | KEY_MENU)) {
        IN_Activate();
        CL_CheckForPause();
    }
}

Referenced by Con_Close(), Con_Popup(), Key_Message(), start_message_mode(), toggle_console(), UI_ForceMenuOff(), and UI_PushMenu().

Key_SetOverstrikeMode()

void Key_SetOverstrikeMode

(

qboolean

overstrike

)

Definition at line 158 of file keys.c.

{
    key_overstrike = overstrike;
}

Key_StringToKeynum()

int Key_StringToKeynum

(

const char *

str

)

Definition at line 234 of file keys.c.

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

Referenced by Key_Bind_f(), and Key_Unbind_f().

Key_Unbind_c()

static void Key_Unbind_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 390 of file keys.c.

{
    if (argnum == 1) {
        Key_Bound_g(ctx);
    }
}

Key_Unbind_f()

static void Key_Unbind_f ( void  )

static

Definition at line 402 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, NULL);
}

Key_Unbindall_f()

static void Key_Unbindall_f ( void  )

static

Definition at line 425 of file keys.c.

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

Key_WaitKey()

void Key_WaitKey	(	keywaitcb_t	wait,
		void *	arg
	)

Definition at line 899 of file keys.c.

{
    key_wait_cb = wait;
    key_wait_arg = arg;
}

Referenced by keybind_cb(), Keybind_DoEnter(), and Keybind_Pop().

Key_WriteBindings()

void Key_WriteBindings

(

qhandle_t

f

)

Definition at line 475 of file keys.c.

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

Referenced by CL_WriteConfig(), and CL_WriteConfig_f().

Variable Documentation

anykeydown

int anykeydown

static

Definition at line 36 of file keys.c.

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

buttondown

byte buttondown[256/8]

static

Definition at line 39 of file keys.c.

Referenced by Key_ClearStates(), and Key_Event().

c_keys

cmdreg_t c_keys[]

static

Initial value:

= {
    { "bind", Key_Bind_f, Key_Bind_c },
    { "unbind", Key_Unbind_f, Key_Unbind_c },
    { "unbindall", Key_Unbindall_f },
    { "bindlist", Key_Bindlist_f },
 
    { NULL }
}

Definition at line 506 of file keys.c.

Referenced by Key_Init().

consolekeys

byte consolekeys[256/8]

static

Definition at line 27 of file keys.c.

Referenced by Key_Event(), and Key_Init().

key_overstrike

qboolean key_overstrike

static

Definition at line 41 of file keys.c.

Referenced by Key_GetOverstrikeMode(), and Key_SetOverstrikeMode().

key_wait_arg

void* key_wait_arg

static

Definition at line 22 of file keys.c.

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

key_wait_cb

keywaitcb_t key_wait_cb

static

Definition at line 21 of file keys.c.

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

keybindings

char* keybindings[256]

static

Definition at line 24 of file keys.c.

Referenced by Key_Bind_f(), Key_Bindlist_f(), Key_Bound_g(), Key_EnumBindings(), Key_Event(), Key_GetBinding(), Key_GetBindingForKey(), Key_SetBinding(), Key_Unbindall_f(), and Key_WriteBindings().

keydown

byte keydown[256]

static

Definition at line 33 of file keys.c.

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

keynames

const keyname_t keynames[]

static

Definition at line 50 of file keys.c.

Referenced by Key_KeynumToString(), Key_Name_g(), and Key_StringToKeynum().

keyshift

byte keyshift[256]

static

Definition at line 30 of file keys.c.

Referenced by Key_Event(), and Key_Init().