#include "quakedef.h"
#include "cl_video.h"
#include "utf8lib.h"
#include "csprogs.h"

Include dependency graph for keys.c:

Data Structures
struct	eventqueueitem_t

struct	keyname_t

Macros
#define	KM_ALT (!keydown[K_CTRL] && !keydown[K_SHIFT] && keydown[K_ALT])

#define	KM_CTRL ( keydown[K_CTRL] && !keydown[K_SHIFT] && !keydown[K_ALT])

#define	KM_CTRL_ALT ( keydown[K_CTRL] && !keydown[K_SHIFT] && keydown[K_ALT])

#define	KM_CTRL_SHIFT ( keydown[K_CTRL] && keydown[K_SHIFT] && !keydown[K_ALT])

#define	KM_CTRL_SHIFT_ALT ( keydown[K_CTRL] && keydown[K_SHIFT] && keydown[K_ALT])

#define	KM_NONE (!keydown[K_CTRL] && !keydown[K_SHIFT] && !keydown[K_ALT])

#define	KM_SHIFT (!keydown[K_CTRL] && keydown[K_SHIFT] && !keydown[K_ALT])

#define	KM_SHIFT_ALT (!keydown[K_CTRL] && keydown[K_SHIFT] && keydown[K_ALT])

Functions
int	Key_AddChar (int unicode, qbool is_console)

static void	Key_Bind_f (cmd_state_t *cmd)

static void	Key_BindList_f (cmd_state_t *cmd)

int	Key_ClearEditLine (qbool is_console)

static void	Key_Console (cmd_state_t *cmd, int key, int unicode)

static int	Key_Convert_NumPadKey (int key)

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

static void	Key_EventQueue_Add (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)

static void	Key_History_Down (void)

static void	Key_History_f (cmd_state_t *cmd)

static void	Key_History_Find_All (void)

static void	Key_History_Find_Backwards (void)

static void	Key_History_Find_Forwards (void)

static void	Key_History_First (void)

static qbool	Key_History_Get_foundCommand (void)

static void	Key_History_Init (void)

static void	Key_History_Last (void)

static void	Key_History_Push (void)

static void	Key_History_Shutdown (void)

static void	Key_History_Up (void)

static void	Key_In_Bind_f (cmd_state_t *cmd)

static void	Key_In_BindList_f (cmd_state_t *cmd)

static void	Key_In_Bindmap_f (cmd_state_t *cmd)

static void	Key_In_Unbind_f (cmd_state_t *cmd)

void	Key_Init (void)

const char *	Key_KeynumToString (int keynum, char *tinystr, size_t tinystrlength)

static void	Key_Message (cmd_state_t *cmd, int key, int ascii)

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

static void	Key_PrintBindList (int j)

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)

static void	Key_Unbind_f (cmd_state_t *cmd)

static void	Key_Unbindall_f (cmd_state_t *cmd)

void	Key_WriteBindings (qfile_t *f)

Variables
char	chat_buffer [MAX_INPUTLINE]

int	chat_bufferpos = 0

signed char	chat_mode

cvar_t	con_closeontoggleconsole = {CF_CLIENT \| CF_ARCHIVE, "con_closeontoggleconsole","1", "allows toggleconsole binds to close the console as well; when set to 2, this even works when not at the start of the line in console input; when set to 3, this works even if the toggleconsole key is the color tag"}

cvar_t	con_textsize

static eventqueueitem_t	eventqueue [32]

static unsigned	eventqueue_idx = 0

static int	events_blocked = 0

conbuffer_t	history

int	history_line

qbool	history_matchfound = false

char	history_savedline [MAX_INPUTLINE]

char	history_searchstring [MAX_INPUTLINE]

static int	key_bmap

static int	key_bmap2

int	key_consoleactive

keydest_t	key_dest

qbool	key_insert = true

char	key_line [MAX_INPUTLINE]

int	key_linepos

char *	keybindings [MAX_BINDMAPS][MAX_KEYS]

static unsigned char	keydown [MAX_KEYS]

static const keyname_t	keynames []

static char	tbl_keyascii [MAX_KEYS]

static keydest_t	tbl_keydest [MAX_KEYS]

Macro Definition Documentation

◆ KM_ALT

#define KM_ALT (!keydown[K_CTRL] && !keydown[K_SHIFT] && keydown[K_ALT])

Definition at line 691 of file keys.c.

◆ KM_CTRL

#define KM_CTRL ( keydown[K_CTRL] && !keydown[K_SHIFT] && !keydown[K_ALT])

Definition at line 689 of file keys.c.

Referenced by Key_Console(), and Key_Parse_CommonKeys().

◆ KM_CTRL_ALT

#define KM_CTRL_ALT ( keydown[K_CTRL] && !keydown[K_SHIFT] && keydown[K_ALT])

Definition at line 687 of file keys.c.

◆ KM_CTRL_SHIFT

#define KM_CTRL_SHIFT ( keydown[K_CTRL] && keydown[K_SHIFT] && !keydown[K_ALT])

Definition at line 686 of file keys.c.

Referenced by Key_Console().

◆ KM_CTRL_SHIFT_ALT

#define KM_CTRL_SHIFT_ALT ( keydown[K_CTRL] && keydown[K_SHIFT] && keydown[K_ALT])

Definition at line 685 of file keys.c.

◆ KM_NONE

#define KM_NONE (!keydown[K_CTRL] && !keydown[K_SHIFT] && !keydown[K_ALT])

Definition at line 684 of file keys.c.

Referenced by Key_Console(), and Key_Parse_CommonKeys().

◆ KM_SHIFT

#define KM_SHIFT (!keydown[K_CTRL] && keydown[K_SHIFT] && !keydown[K_ALT])

Definition at line 690 of file keys.c.

Referenced by Key_Console(), and Key_Parse_CommonKeys().

◆ KM_SHIFT_ALT

#define KM_SHIFT_ALT (!keydown[K_CTRL] && keydown[K_SHIFT] && keydown[K_ALT])

Definition at line 688 of file keys.c.

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_Bind_f()

static void Key_Bind_f ( cmd_state_t * cmd )

static

Definition at line 1639 of file keys.c.

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

References b, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), dp_strlcat, i, Key_SetBinding(), Key_StringToKeynum(), keybindings, MAX_INPUTLINE, and MAX_KEYS.

Referenced by Key_Init().

◆ Key_BindList_f()

static void Key_BindList_f ( cmd_state_t * cmd )

static

Definition at line 1633 of file keys.c.

{
    Key_PrintBindList(0);
}

References Key_PrintBindList().

Referenced by Key_Init().

◆ 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_Console()

static void Key_Console	(	cmd_state_t *	cmd,
		int	key,
		int	unicode )

static

Definition at line 1103 of file keys.c.

{
    int linepos;
 
    key = Key_Convert_NumPadKey(key);
 
    // Forbid Ctrl Alt shortcuts since on Windows they are used to type some characters
    // in certain non-English keyboards using the AltGr key (which emulates Ctrl Alt)
    // Reference: "Why Ctrl+Alt shouldn't be used as a shortcut modifier"
    //            https://blogs.msdn.microsoft.com/oldnewthing/20040329-00/?p=40003
    if (keydown[K_CTRL] && keydown[K_ALT])
        goto add_char;
 
    linepos = Key_Parse_CommonKeys(cmd, true, key, unicode);
    if (linepos >= 0)
    {
        key_linepos = linepos;
        return;
    }
 
    if ((key == K_ENTER || key == K_KP_ENTER) && KM_NONE)
    {
        // bones_was_here: prepending allows a loop such as `alias foo "bar; wait; foo"; foo`
        // to be broken with an alias or unalias command
        Cbuf_InsertText(cmd, key_line+1); // skip the ]
        Key_History_Push();
        key_linepos = Key_ClearEditLine(true);
        // force an update, because the command may take some time
        if (cls.state == ca_disconnected)
            CL_UpdateScreen ();
        return;
    }
 
    if (key == 'l' && KM_CTRL)
    {
        Cbuf_AddText (cmd, "clear\n");
        return;
    }
 
    if (key == 'q' && KM_CTRL) // like zsh ^q: push line to history, don't execute, and clear
    {
        // clear line
        Key_History_Push();
        key_linepos = Key_ClearEditLine(true);
        return;
    }
 
    // End Advanced Console Editing
 
    if (((key == K_UPARROW || key == K_KP_UPARROW) && KM_NONE) || (key == 'p' && KM_CTRL))
    {
        Key_History_Up();
        return;
    }
 
    if (((key == K_DOWNARROW || key == K_KP_DOWNARROW) && KM_NONE) || (key == 'n' && KM_CTRL))
    {
        Key_History_Down();
        return;
    }
 
    if (keydown[K_CTRL])
    {
        // prints all the matching commands
        if (key == 'f' && KM_CTRL)
        {
            Key_History_Find_All();
            return;
        }
        // Search forwards/backwards, pointing the history's index to the
        // matching command but without fetching it to let one continue the search.
        // To fetch it, it suffices to just press UP or DOWN.
        if (key == 'r' && KM_CTRL_SHIFT)
        {
            Key_History_Find_Forwards();
            return;
        }
        if (key == 'r' && KM_CTRL)
        {
            Key_History_Find_Backwards();
            return;
        }
 
        // go to the last/first command of the history
        if (key == ',' && KM_CTRL)
        {
            Key_History_First();
            return;
        }
        if (key == '.' && KM_CTRL)
        {
            Key_History_Last();
            return;
        }
    }
 
    if (key == K_PGUP || key == K_KP_PGUP)
    {
        if (KM_CTRL)
        {
            con_backscroll += ((vid_conheight.integer >> 2) / con_textsize.integer)-1;
            return;
        }
        if (KM_NONE)
        {
            con_backscroll += ((vid_conheight.integer >> 1) / con_textsize.integer)-3;
            return;
        }
    }
 
    if (key == K_PGDN || key == K_KP_PGDN)
    {
        if (KM_CTRL)
        {
            con_backscroll -= ((vid_conheight.integer >> 2) / con_textsize.integer)-1;
            return;
        }
        if (KM_NONE)
        {
            con_backscroll -= ((vid_conheight.integer >> 1) / con_textsize.integer)-3;
            return;
        }
    }
 
    if (key == K_MWHEELUP)
    {
        if (KM_CTRL)
        {
            con_backscroll += 1;
            return;
        }
        if (KM_SHIFT)
        {
            con_backscroll += ((vid_conheight.integer >> 2) / con_textsize.integer)-1;
            return;
        }
        if (KM_NONE)
        {
            con_backscroll += 5;
            return;
        }
    }
 
    if (key == K_MWHEELDOWN)
    {
        if (KM_CTRL)
        {
            con_backscroll -= 1;
            return;
        }
        if (KM_SHIFT)
        {
            con_backscroll -= ((vid_conheight.integer >> 2) / con_textsize.integer)-1;
            return;
        }
        if (KM_NONE)
        {
            con_backscroll -= 5;
            return;
        }
    }
 
    if (keydown[K_CTRL])
    {
        // text zoom in
        if ((key == '=' || key == '+' || key == K_KP_PLUS) && KM_CTRL)
        {
            if (con_textsize.integer < 128)
                Cvar_SetValueQuick(&con_textsize, con_textsize.integer + 1);
            return;
        }
        // text zoom out
        if ((key == '-' || key == K_KP_MINUS) && KM_CTRL)
        {
            if (con_textsize.integer > 1)
                Cvar_SetValueQuick(&con_textsize, con_textsize.integer - 1);
            return;
        }
        // text zoom reset
        if ((key == '0' || key == K_KP_INS) && KM_CTRL)
        {
            Cvar_SetValueQuick(&con_textsize, atoi(Cvar_VariableDefString(&cvars_all, "con_textsize", CF_CLIENT | CF_SERVER)));
            return;
        }
    }
 
add_char:
 
    // non printable
    if (unicode < 32)
        return;
 
    key_linepos = Key_AddChar(unicode, true);
}

References ca_disconnected, Cbuf_AddText(), Cbuf_InsertText(), CF_CLIENT, CF_SERVER, CL_UpdateScreen(), cls, cmd(), con_backscroll, con_textsize, Cvar_SetValueQuick(), Cvar_VariableDefString(), cvars_all, cvar_t::integer, K_ALT, K_CTRL, K_DOWNARROW, K_ENTER, K_KP_DOWNARROW, K_KP_ENTER, K_KP_INS, K_KP_MINUS, K_KP_PGDN, K_KP_PGUP, K_KP_PLUS, K_KP_UPARROW, K_MWHEELDOWN, K_MWHEELUP, K_PGDN, K_PGUP, K_UPARROW, Key_AddChar(), Key_ClearEditLine(), Key_Convert_NumPadKey(), Key_History_Down(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_First(), Key_History_Last(), Key_History_Push(), Key_History_Up(), key_line, key_linepos, Key_Parse_CommonKeys(), keydown, KM_CTRL, KM_CTRL_SHIFT, KM_NONE, KM_SHIFT, client_static_t::state, and vid_conheight.

Referenced by Key_Event().

◆ Key_Convert_NumPadKey()

static int Key_Convert_NumPadKey ( int key )

static

Definition at line 1080 of file keys.c.

{
    // LadyHavoc: copied most of this from Q2 to improve keyboard handling
    switch (key)
    {
        case K_KP_SLASH:      return '/';
        case K_KP_MINUS:      return '-';
        case K_KP_PLUS:       return '+';
        case K_KP_HOME:       return '7';
        case K_KP_UPARROW:    return '8';
        case K_KP_PGUP:       return '9';
        case K_KP_LEFTARROW:  return '4';
        case K_KP_5:          return '5';
        case K_KP_RIGHTARROW: return '6';
        case K_KP_END:        return '1';
        case K_KP_DOWNARROW:  return '2';
        case K_KP_PGDN:       return '3';
        case K_KP_INS:        return '0';
        case K_KP_DEL:        return '.';
    }
    return key;
}

References K_KP_5, K_KP_DEL, K_KP_DOWNARROW, K_KP_END, K_KP_HOME, K_KP_INS, K_KP_LEFTARROW, K_KP_MINUS, K_KP_PGDN, K_KP_PGUP, K_KP_PLUS, K_KP_RIGHTARROW, K_KP_SLASH, and K_KP_UPARROW.

Referenced by Key_Console(), and Key_Message().

◆ 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_Add()

static void Key_EventQueue_Add	(	int	key,
		int	ascii,
		qbool	down )

static

Definition at line 1808 of file keys.c.

{
    if(eventqueue_idx < sizeof(eventqueue) / sizeof(*eventqueue))
    {
        eventqueue[eventqueue_idx].key = key;
        eventqueue[eventqueue_idx].ascii = ascii;
        eventqueue[eventqueue_idx].down = down;
        ++eventqueue_idx;
    }
}

References eventqueueitem_t::ascii, eventqueueitem_t::down, eventqueue, eventqueue_idx, and eventqueueitem_t::key.

Referenced by Key_Event().

◆ 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_History_Down()

static void Key_History_Down ( void )

static

Definition at line 163 of file keys.c.

{
    if(history_line == -1) // editing the "new" line
        return;
 
    if (Key_History_Get_foundCommand())
        return;
 
    if(history_line < CONBUFFER_LINES_COUNT(&history) - 1)
    {
        ++history_line;
        dp_strlcpy(key_line + 1, ConBuffer_GetLine(&history, history_line), sizeof(key_line) - 1);
    }
    else
    {
        history_line = -1;
        dp_strlcpy(key_line + 1, history_savedline, sizeof(key_line) - 1);
    }
 
    key_linepos = (int)strlen(key_line);
}

References ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, dp_strlcpy, history, history_line, history_savedline, int(), Key_History_Get_foundCommand(), key_line, key_linepos, and strlen().

Referenced by Key_Console().

◆ Key_History_f()

static void Key_History_f ( cmd_state_t * cmd )

static

Definition at line 300 of file keys.c.

{
    char *errchar = NULL;
    int i = 0;
    char vabuf[1024];
    size_t digits = strlen(va(vabuf, sizeof(vabuf), "%i", HIST_MAXLINES));
 
    if (Cmd_Argc (cmd) > 1)
    {
        if (!strcmp(Cmd_Argv(cmd, 1), "-c"))
        {
            ConBuffer_Clear(&history);
            return;
        }
        i = strtol(Cmd_Argv(cmd, 1), &errchar, 0);
        if ((i < 0) || (i > CONBUFFER_LINES_COUNT(&history)) || (errchar && *errchar))
            i = 0;
        else
            i = CONBUFFER_LINES_COUNT(&history) - i;
    }
 
    for ( ; i<CONBUFFER_LINES_COUNT(&history); i++)
        Con_Printf("^3%*i^7 %s\n", (int)digits, i+1, ConBuffer_GetLine(&history, i));
    Con_Printf("\n");
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), ConBuffer_Clear(), ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, HIST_MAXLINES, history, i, NULL, strlen(), and va().

Referenced by Key_Init().

◆ Key_History_Find_All()

static void Key_History_Find_All ( void )

static

Definition at line 278 of file keys.c.

{
    const char *partial = key_line + 1;
    int i, count = 0;
    char vabuf[1024];
    size_t digits = strlen(va(vabuf, sizeof(vabuf), "%i", HIST_MAXLINES));
    Con_Printf("History commands containing \"%s\":\n", key_line + 1);
 
    if (!*partial)
        partial = "*";
    else if (!( strchr(partial, '*') || strchr(partial, '?') )) // no pattern?
        partial = va(vabuf, sizeof(vabuf), "*%s*", partial);
 
    for (i=0; i<CONBUFFER_LINES_COUNT(&history); i++)
        if (matchpattern_with_separator(ConBuffer_GetLine(&history, i), partial, true, "", false))
        {
            Con_Printf("%s%*i^7 %s\n", (i == history_line) ? "^2" : "^3", (int)digits, i+1, ConBuffer_GetLine(&history, i));
            count++;
        }
    Con_Printf("%i result%s\n\n", count, (count != 1) ? "s" : "");
}

References Con_Printf(), ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, count, HIST_MAXLINES, history, history_line, i, key_line, matchpattern_with_separator(), strlen(), and va().

Referenced by Key_Console().

◆ Key_History_Find_Backwards()

static void Key_History_Find_Backwards ( void )

static

Definition at line 211 of file keys.c.

{
    int i;
    const char *partial = key_line + 1;
    char vabuf[1024];
    size_t digits = strlen(va(vabuf, sizeof(vabuf), "%i", HIST_MAXLINES));
 
    if (history_line == -1) // editing the "new" line
        dp_strlcpy(history_savedline, key_line + 1, sizeof(history_savedline));
 
    if (strcmp(key_line + 1, history_searchstring)) // different string? Start a new search
    {
        dp_strlcpy(history_searchstring, key_line + 1, sizeof(history_searchstring));
        i = CONBUFFER_LINES_COUNT(&history) - 1;
    }
    else if (history_line == -1)
        i = CONBUFFER_LINES_COUNT(&history) - 1;
    else
        i = history_line - 1;
 
    if (!*partial)
        partial = "*";
    else if (!( strchr(partial, '*') || strchr(partial, '?') )) // no pattern?
        partial = va(vabuf, sizeof(vabuf), "*%s*", partial);
 
    for ( ; i >= 0; i--)
        if (matchpattern_with_separator(ConBuffer_GetLine(&history, i), partial, true, "", false))
        {
            Con_Printf("^2%*i^7 %s\n", (int)digits, i+1, ConBuffer_GetLine(&history, i));
            history_line = i;
            history_matchfound = true;
            return;
        }
}

References Con_Printf(), ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, dp_strlcpy, HIST_MAXLINES, history, history_line, history_matchfound, history_savedline, history_searchstring, i, key_line, matchpattern_with_separator(), strlen(), and va().

Referenced by Key_Console().

◆ Key_History_Find_Forwards()

static void Key_History_Find_Forwards ( void )

static

Definition at line 246 of file keys.c.

{
    int i;
    const char *partial = key_line + 1;
    char vabuf[1024];
    size_t digits = strlen(va(vabuf, sizeof(vabuf), "%i", HIST_MAXLINES));
 
    if (history_line == -1) // editing the "new" line
        return;
 
    if (strcmp(key_line + 1, history_searchstring)) // different string? Start a new search
    {
        dp_strlcpy(history_searchstring, key_line + 1, sizeof(history_searchstring));
        i = 0;
    }
    else i = history_line + 1;
 
    if (!*partial)
        partial = "*";
    else if (!( strchr(partial, '*') || strchr(partial, '?') )) // no pattern?
        partial = va(vabuf, sizeof(vabuf), "*%s*", partial);
 
    for ( ; i < CONBUFFER_LINES_COUNT(&history); i++)
        if (matchpattern_with_separator(ConBuffer_GetLine(&history, i), partial, true, "", false))
        {
            Con_Printf("^2%*i^7 %s\n", (int)digits, i+1, ConBuffer_GetLine(&history, i));
            history_line = i;
            history_matchfound = true;
            return;
        }
}

References Con_Printf(), ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, dp_strlcpy, HIST_MAXLINES, history, history_line, history_matchfound, history_searchstring, i, key_line, matchpattern_with_separator(), strlen(), and va().

Referenced by Key_Console().

◆ Key_History_First()

static void Key_History_First ( void )

static

Definition at line 185 of file keys.c.

{
    if(history_line == -1) // editing the "new" line
        dp_strlcpy(history_savedline, key_line + 1, sizeof(history_savedline));
 
    if (CONBUFFER_LINES_COUNT(&history) > 0)
    {
        history_line = 0;
        dp_strlcpy(key_line + 1, ConBuffer_GetLine(&history, history_line), sizeof(key_line) - 1);
        key_linepos = (int)strlen(key_line);
    }
}

References ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, dp_strlcpy, history, history_line, history_savedline, int(), key_line, key_linepos, and strlen().

Referenced by Key_Console().

◆ Key_History_Get_foundCommand()

static qbool Key_History_Get_foundCommand ( void )

static

Definition at line 128 of file keys.c.

{
    if (!history_matchfound)
        return false;
    dp_strlcpy(key_line + 1, ConBuffer_GetLine(&history, history_line), sizeof(key_line) - 1);
    key_linepos = (int)strlen(key_line);
    history_matchfound = false;
    return true;
}

References ConBuffer_GetLine(), dp_strlcpy, history, history_line, history_matchfound, int(), key_line, key_linepos, and strlen().

Referenced by Key_History_Down(), and Key_History_Up().

◆ Key_History_Init()

static void Key_History_Init ( void )

static

Definition at line 50 of file keys.c.

{
    qfile_t *historyfile;
    ConBuffer_Init(&history, HIST_TEXTSIZE, HIST_MAXLINES, zonemempool);
 
// not necessary for mobile
#ifndef DP_MOBILETOUCH
    historyfile = FS_OpenRealFile("darkplaces_history.txt", "rb", false); // rb to handle unix line endings on windows too
    if(historyfile)
    {
        char buf[MAX_INPUTLINE];
        int bufpos;
        int c;
 
        bufpos = 0;
        for(;;)
        {
            c = FS_Getc(historyfile);
            if(c < 0 || c == 0 || c == '\r' || c == '\n')
            {
                if(bufpos > 0)
                {
                    buf[bufpos] = 0;
                    ConBuffer_AddLine(&history, buf, bufpos, 0);
                    bufpos = 0;
                }
                if(c < 0)
                    break;
            }
            else
            {
                if(bufpos < MAX_INPUTLINE - 1)
                    buf[bufpos++] = c;
            }
        }
 
        FS_Close(historyfile);
    }
#endif
 
    history_line = -1;
}

References buf, ConBuffer_AddLine(), ConBuffer_Init(), FS_Close(), FS_Getc(), FS_OpenRealFile(), HIST_MAXLINES, HIST_TEXTSIZE, history, history_line, MAX_INPUTLINE, and zonemempool.

Referenced by Key_Init().

◆ Key_History_Last()

static void Key_History_Last ( void )

static

Definition at line 198 of file keys.c.

{
    if(history_line == -1) // editing the "new" line
        dp_strlcpy(history_savedline, key_line + 1, sizeof(history_savedline));
 
    if (CONBUFFER_LINES_COUNT(&history) > 0)
    {
        history_line = CONBUFFER_LINES_COUNT(&history) - 1;
        dp_strlcpy(key_line + 1, ConBuffer_GetLine(&history, history_line), sizeof(key_line) - 1);
        key_linepos = (int)strlen(key_line);
    }
}

References ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, dp_strlcpy, history, history_line, history_savedline, int(), key_line, key_linepos, and strlen().

Referenced by Key_Console().

◆ Key_History_Push()

static void Key_History_Push ( void )

static

Definition at line 114 of file keys.c.

{
    if(key_line[1]) // empty?
    if(strcmp(key_line, "]quit")) // putting these into the history just sucks
    if(strncmp(key_line, "]quit ", 6)) // putting these into the history just sucks
    if(strcmp(key_line, "]rcon_password")) // putting these into the history just sucks
    if(strncmp(key_line, "]rcon_password ", 15)) // putting these into the history just sucks
        ConBuffer_AddLine(&history, key_line + 1, (int)strlen(key_line) - 1, 0);
    Con_Printf("%s\n", key_line); // don't mark empty lines as history
    history_line = -1;
    if (history_matchfound)
        history_matchfound = false;
}

References Con_Printf(), ConBuffer_AddLine(), history, history_line, history_matchfound, key_line, and strlen().

Referenced by Key_Console().

◆ Key_History_Shutdown()

static void Key_History_Shutdown ( void )

static

Definition at line 93 of file keys.c.

{
// not necessary for mobile
#ifndef DP_MOBILETOUCH
    qfile_t *historyfile = FS_OpenRealFile("darkplaces_history.txt", "w", false);
    if(historyfile)
    {
        int i;
 
        Con_Print("Saving command history to darkplaces_history.txt ...\n");
        for(i = 0; i < CONBUFFER_LINES_COUNT(&history); ++i)
            FS_Printf(historyfile, "%s\n", ConBuffer_GetLine(&history, i));
        FS_Close(historyfile);
    }
    else
        Con_Print(CON_ERROR "Couldn't write darkplaces_history.txt\n");
#endif
 
    ConBuffer_Shutdown(&history);
}

References CON_ERROR, Con_Print(), ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, ConBuffer_Shutdown(), FS_Close(), FS_OpenRealFile(), FS_Printf(), history, and i.

Referenced by Key_Shutdown().

◆ Key_History_Up()

static void Key_History_Up ( void )

static

Definition at line 138 of file keys.c.

{
    if(history_line == -1) // editing the "new" line
        dp_strlcpy(history_savedline, key_line + 1, sizeof(history_savedline));
 
    if (Key_History_Get_foundCommand())
        return;
 
    if(history_line == -1)
    {
        history_line = CONBUFFER_LINES_COUNT(&history) - 1;
        if(history_line != -1)
        {
            dp_strlcpy(key_line + 1, ConBuffer_GetLine(&history, history_line), sizeof(key_line) - 1);
            key_linepos = (int)strlen(key_line);
        }
    }
    else if(history_line > 0)
    {
        --history_line; // this also does -1 -> 0, so it is good
        dp_strlcpy(key_line + 1, ConBuffer_GetLine(&history, history_line), sizeof(key_line) - 1);
        key_linepos = (int)strlen(key_line);
    }
}

References ConBuffer_GetLine(), CONBUFFER_LINES_COUNT, dp_strlcpy, history, history_line, history_savedline, int(), Key_History_Get_foundCommand(), key_line, key_linepos, and strlen().

Referenced by Key_Console().

◆ Key_In_Bind_f()

static void Key_In_Bind_f ( cmd_state_t * cmd )

static

Definition at line 1484 of file keys.c.

{
    int         i, c, b, m;
    char        line[MAX_INPUTLINE];
    char *errchar = NULL;
 
    c = Cmd_Argc (cmd);
 
    if (c != 3 && c != 4) {
        Con_Print("in_bind <bindmap> <key> [command] : attach a command to a key\n");
        return;
    }
 
    m = strtol(Cmd_Argv(cmd, 1), &errchar, 0);
    if ((m < 0) || (m >= MAX_BINDMAPS) || (errchar && *errchar)) {
        Con_Printf("%s isn't a valid bindmap\n", Cmd_Argv(cmd, 1));
        return;
    }
 
    b = Key_StringToKeynum (Cmd_Argv(cmd, 2));
    if (b == -1 || b >= MAX_KEYS) {
        Con_Printf("\"%s\" isn't a valid key\n", Cmd_Argv(cmd, 2));
        return;
    }
 
    if (c == 3) {
        if (keybindings[m][b])
            Con_Printf("\"%s\" = \"%s\"\n", Cmd_Argv(cmd, 2), keybindings[m][b]);
        else
            Con_Printf("\"%s\" is not bound\n", Cmd_Argv(cmd, 2));
        return;
    }
// copy the rest of the command line
    line[0] = 0;                            // start out with a null string
    for (i = 3; i < c; i++) {
        dp_strlcat (line, Cmd_Argv(cmd, i), sizeof (line));
        if (i != (c - 1))
            dp_strlcat (line, " ", sizeof (line));
    }
 
    if(!Key_SetBinding (b, m, line))
        Con_Printf("Key_SetBinding failed for unknown reason\n");
}

References b, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), dp_strlcat, i, Key_SetBinding(), Key_StringToKeynum(), keybindings, MAX_BINDMAPS, MAX_INPUTLINE, MAX_KEYS, and NULL.

Referenced by Key_Init().

◆ Key_In_BindList_f()

static void Key_In_BindList_f ( cmd_state_t * cmd )

static

Definition at line 1611 of file keys.c.

{
    int m;
    char *errchar = NULL;
 
    if(Cmd_Argc(cmd) >= 2)
    {
        m = strtol(Cmd_Argv(cmd, 1), &errchar, 0);
        if ((m < 0) || (m >= MAX_BINDMAPS) || (errchar && *errchar)) {
            Con_Printf("%s isn't a valid bindmap\n", Cmd_Argv(cmd, 1));
            return;
        }
        Key_PrintBindList(m);
    }
    else
    {
        for (m = 0; m < MAX_BINDMAPS; m++)
            Key_PrintBindList(m);
    }
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), Key_PrintBindList(), MAX_BINDMAPS, and NULL.

Referenced by Key_Init().

◆ Key_In_Bindmap_f()

static void Key_In_Bindmap_f ( cmd_state_t * cmd )

static

Definition at line 1529 of file keys.c.

{
    int         m1, m2, c;
    char *errchar = NULL;
 
    c = Cmd_Argc (cmd);
 
    if (c != 3) {
        Con_Print("in_bindmap <bindmap> <fallback>: set current bindmap and fallback\n");
        return;
    }
 
    m1 = strtol(Cmd_Argv(cmd, 1), &errchar, 0);
    if ((m1 < 0) || (m1 >= MAX_BINDMAPS) || (errchar && *errchar)) {
        Con_Printf("%s isn't a valid bindmap\n", Cmd_Argv(cmd, 1));
        return;
    }
 
    m2 = strtol(Cmd_Argv(cmd, 2), &errchar, 0);
    if ((m2 < 0) || (m2 >= MAX_BINDMAPS) || (errchar && *errchar)) {
        Con_Printf("%s isn't a valid bindmap\n", Cmd_Argv(cmd, 2));
        return;
    }
 
    key_bmap = m1;
    key_bmap2 = m2;
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), key_bmap, key_bmap2, MAX_BINDMAPS, and NULL.

Referenced by Key_Init().

◆ Key_In_Unbind_f()

static void Key_In_Unbind_f ( cmd_state_t * cmd )

static

Definition at line 1457 of file keys.c.

{
    int         b, m;
    char *errchar = NULL;
 
    if (Cmd_Argc (cmd) != 3) {
        Con_Print("in_unbind <bindmap> <key> : remove commands from a key\n");
        return;
    }
 
    m = strtol(Cmd_Argv(cmd, 1), &errchar, 0);
    if ((m < 0) || (m >= MAX_BINDMAPS) || (errchar && *errchar)) {
        Con_Printf("%s isn't a valid bindmap\n", Cmd_Argv(cmd, 1));
        return;
    }
 
    b = Key_StringToKeynum (Cmd_Argv(cmd, 2));
    if (b == -1) {
        Con_Printf("\"%s\" isn't a valid key\n", Cmd_Argv(cmd, 2));
        return;
    }
 
    if(!Key_SetBinding (b, m, ""))
        Con_Printf("Key_SetBinding failed for unknown reason\n");
}

References b, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), Key_SetBinding(), Key_StringToKeynum(), MAX_BINDMAPS, and NULL.

Referenced by Key_Init().

◆ 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_KeynumToString()

const char * Key_KeynumToString	(	int	keynum,
		char *	tinystr,
		size_t	tinystrlength )

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_Message()

static void Key_Message	(	cmd_state_t *	cmd,
		int	key,
		int	ascii )

static

Definition at line 1301 of file keys.c.

{
    int linepos;
    char vabuf[1024];
 
    key = Key_Convert_NumPadKey(key);
 
    if (key == K_ENTER || key == K_KP_ENTER || ascii == 10 || ascii == 13)
    {
        if(chat_mode < 0)
            Cmd_ExecuteString(cmd, chat_buffer, strlen(chat_buffer), src_local, true); // not Cbuf_AddText to allow semiclons in args; however, this allows no variables then. Use aliases!
        else
            CL_ForwardToServer(va(vabuf, sizeof(vabuf), "%s %s", chat_mode ? "say_team" : "say ", chat_buffer));
 
        key_dest = key_game;
        chat_bufferpos = Key_ClearEditLine(false);
        return;
    }
 
    if (key == K_ESCAPE) {
        key_dest = key_game;
        chat_bufferpos = Key_ClearEditLine(false);
        return;
    }
 
    linepos = Key_Parse_CommonKeys(cmd, false, key, ascii);
    if (linepos >= 0)
    {
        chat_bufferpos = linepos;
        return;
    }
 
    // ctrl+key generates an ascii value < 32 and shows a char from the charmap
    if (ascii > 0 && ascii < 32 && utf8_enable.integer)
        ascii = 0xE000 + ascii;
 
    if (!ascii)
        return;                         // non printable
 
    chat_bufferpos = Key_AddChar(ascii, false);
}

References chat_buffer, chat_bufferpos, chat_mode, CL_ForwardToServer(), cmd(), Cmd_ExecuteString(), cvar_t::integer, K_ENTER, K_ESCAPE, K_KP_ENTER, Key_AddChar(), Key_ClearEditLine(), Key_Convert_NumPadKey(), key_dest, key_game, Key_Parse_CommonKeys(), src_local, strlen(), utf8_enable, and va().

Referenced by Key_Event().

◆ 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_PrintBindList()

static void Key_PrintBindList ( int j )

static

Definition at line 1589 of file keys.c.

{
    char bindbuf[MAX_INPUTLINE];
    char tinystr[TINYSTR_LEN];
    const char *p;
    int i;
 
    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);
            if (j == 0)
                Con_Printf("^2%s ^7= \"%s\"\n", Key_KeynumToString (i, tinystr, TINYSTR_LEN), bindbuf);
            else
                Con_Printf("^3bindmap %d: ^2%s ^7= \"%s\"\n", j, Key_KeynumToString (i, tinystr, TINYSTR_LEN), bindbuf);
        }
    }
}

References Cmd_QuoteString(), Con_Printf(), i, int(), Key_KeynumToString(), keybindings, MAX_INPUTLINE, and TINYSTR_LEN.

Referenced by Key_BindList_f(), and Key_In_BindList_f().

◆ 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_Unbind_f()

static void Key_Unbind_f ( cmd_state_t * cmd )

static

Definition at line 1558 of file keys.c.

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

References b, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), Key_SetBinding(), and Key_StringToKeynum().

Referenced by Key_Init().

◆ Key_Unbindall_f()

static void Key_Unbindall_f ( cmd_state_t * cmd )

static

Definition at line 1578 of file keys.c.

{
    int         i, j;
 
    for (j = 0; j < MAX_BINDMAPS; j++)
        for (i = 0; i < (int)(sizeof(keybindings[0])/sizeof(keybindings[0][0])); i++)
            if (keybindings[j][i])
                Key_SetBinding (i, j, "");
}

References i, int(), Key_SetBinding(), keybindings, and MAX_BINDMAPS.

Referenced by Key_Init().

◆ 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]

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 = 0

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

Definition at line 699 of file keys.c.

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

◆ con_closeontoggleconsole

cvar_t con_closeontoggleconsole = {CF_CLIENT | CF_ARCHIVE, "con_closeontoggleconsole","1", "allows toggleconsole binds to close the console as well; when set to 2, this even works when not at the start of the line in console input; when set to 3, this works even if the toggleconsole key is the color tag"}

Definition at line 28 of file keys.c.

28{CF_CLIENT | CF_ARCHIVE, "con_closeontoggleconsole","1", "allows toggleconsole binds to close the console as well; when set to 2, this even works when not at the start of the line in console input; when set to 3, this works even if the toggleconsole key is the color tag"};

CF_ARCHIVE

#define CF_ARCHIVE

cvar should have its set value saved to config.cfg and persist across sessions

Definition cmd.h:53

Referenced by Key_Event(), and Key_Init().

◆ con_textsize

cvar_t con_textsize

extern

Definition at line 57 of file console.c.

57{CF_CLIENT | CF_ARCHIVE, "con_textsize","8", "console text size in virtual 2D pixels"};

Referenced by Con_CheckResize(), Con_DrawConsole(), Con_DrawConsoleLine(), Con_Init(), Con_LineHeight(), and Key_Console().

◆ eventqueue

eventqueueitem_t eventqueue[32]

static

Definition at line 1805 of file keys.c.

Referenced by Key_EventQueue_Add(), and Key_EventQueue_Unblock().

◆ eventqueue_idx

unsigned eventqueue_idx = 0

static

Definition at line 1806 of file keys.c.

Referenced by Key_EventQueue_Add(), Key_EventQueue_Unblock(), and Key_ReleaseAll().

◆ events_blocked

int events_blocked = 0

static

Definition at line 1804 of file keys.c.

Referenced by Key_Event(), Key_EventQueue_Block(), and Key_EventQueue_Unblock().

◆ history

conbuffer_t history

Definition at line 45 of file keys.c.

Referenced by CL_FinishTimeDemo(), Key_History_Down(), Key_History_f(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_First(), Key_History_Get_foundCommand(), Key_History_Init(), Key_History_Last(), Key_History_Push(), Key_History_Shutdown(), and Key_History_Up().

◆ history_line

int history_line

Definition at line 41 of file keys.c.

Referenced by Key_History_Down(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_First(), Key_History_Get_foundCommand(), Key_History_Init(), Key_History_Last(), Key_History_Push(), and Key_History_Up().

◆ history_matchfound

qbool history_matchfound = false

Definition at line 44 of file keys.c.

Referenced by Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_Get_foundCommand(), and Key_History_Push().

◆ history_savedline

char history_savedline[MAX_INPUTLINE]

Definition at line 42 of file keys.c.

Referenced by Key_History_Down(), Key_History_Find_Backwards(), Key_History_First(), Key_History_Last(), and Key_History_Up().

◆ history_searchstring

char history_searchstring[MAX_INPUTLINE]

Definition at line 43 of file keys.c.

Referenced by Key_History_Find_Backwards(), and Key_History_Find_Forwards().

◆ key_bmap

int key_bmap

static

Definition at line 326 of file keys.c.

Referenced by Key_Event(), Key_GetBind(), Key_GetBindMap(), Key_In_Bindmap_f(), and Key_SetBindMap().

◆ key_bmap2

int key_bmap2

static

Definition at line 326 of file keys.c.

Referenced by Key_Event(), Key_GetBind(), Key_GetBindMap(), Key_In_Bindmap_f(), and Key_SetBindMap().

◆ key_consoleactive

int key_consoleactive

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

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 = true

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]

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

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]

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().

◆ keydown

unsigned char keydown[MAX_KEYS]

static

Definition at line 327 of file keys.c.

Referenced by Key_Console(), Key_Event(), and Key_ReleaseAll().

◆ keynames

const keyname_t keynames[]

static

Definition at line 336 of file keys.c.

                                      {
    {"TAB", K_TAB},
    {"ENTER", K_ENTER},
    {"ESCAPE", K_ESCAPE},
    {"SPACE", K_SPACE},
 
    // spacer so it lines up with keys.h
 
    {"BACKSPACE", K_BACKSPACE},
    {"UPARROW", K_UPARROW},
    {"DOWNARROW", K_DOWNARROW},
    {"LEFTARROW", K_LEFTARROW},
    {"RIGHTARROW", K_RIGHTARROW},
 
    {"ALT", K_ALT},
    {"CTRL", K_CTRL},
    {"SHIFT", K_SHIFT},
 
    {"F1", K_F1},
    {"F2", K_F2},
    {"F3", K_F3},
    {"F4", K_F4},
    {"F5", K_F5},
    {"F6", K_F6},
    {"F7", K_F7},
    {"F8", K_F8},
    {"F9", K_F9},
    {"F10", K_F10},
    {"F11", K_F11},
    {"F12", K_F12},
 
    {"INS", K_INS},
    {"DEL", K_DEL},
    {"PGDN", K_PGDN},
    {"PGUP", K_PGUP},
    {"HOME", K_HOME},
    {"END", K_END},
 
    {"PAUSE", K_PAUSE},
 
    {"NUMLOCK", K_NUMLOCK},
    {"CAPSLOCK", K_CAPSLOCK},
    {"SCROLLOCK", K_SCROLLOCK},
 
    {"KP_INS",          K_KP_INS },
    {"KP_0", K_KP_0},
    {"KP_END",          K_KP_END },
    {"KP_1", K_KP_1},
    {"KP_DOWNARROW",    K_KP_DOWNARROW },
    {"KP_2", K_KP_2},
    {"KP_PGDN",         K_KP_PGDN },
    {"KP_3", K_KP_3},
    {"KP_LEFTARROW",    K_KP_LEFTARROW },
    {"KP_4", K_KP_4},
    {"KP_5", K_KP_5},
    {"KP_RIGHTARROW",   K_KP_RIGHTARROW },
    {"KP_6", K_KP_6},
    {"KP_HOME",         K_KP_HOME },
    {"KP_7", K_KP_7},
    {"KP_UPARROW",      K_KP_UPARROW },
    {"KP_8", K_KP_8},
    {"KP_PGUP",         K_KP_PGUP },
    {"KP_9", K_KP_9},
    {"KP_DEL",          K_KP_DEL },
    {"KP_PERIOD", K_KP_PERIOD},
    {"KP_SLASH",        K_KP_SLASH },
    {"KP_DIVIDE", K_KP_DIVIDE},
    {"KP_MULTIPLY", K_KP_MULTIPLY},
    {"KP_MINUS", K_KP_MINUS},
    {"KP_PLUS", K_KP_PLUS},
    {"KP_ENTER", K_KP_ENTER},
    {"KP_EQUALS", K_KP_EQUALS},
 
    {"PRINTSCREEN", K_PRINTSCREEN},
 
 
 
    {"MOUSE1", K_MOUSE1},
 
    {"MOUSE2", K_MOUSE2},
    {"MOUSE3", K_MOUSE3},
    {"MWHEELUP", K_MWHEELUP},
    {"MWHEELDOWN", K_MWHEELDOWN},
    {"MOUSE4", K_MOUSE4},
    {"MOUSE5", K_MOUSE5},
    {"MOUSE6", K_MOUSE6},
    {"MOUSE7", K_MOUSE7},
    {"MOUSE8", K_MOUSE8},
    {"MOUSE9", K_MOUSE9},
    {"MOUSE10", K_MOUSE10},
    {"MOUSE11", K_MOUSE11},
    {"MOUSE12", K_MOUSE12},
    {"MOUSE13", K_MOUSE13},
    {"MOUSE14", K_MOUSE14},
    {"MOUSE15", K_MOUSE15},
    {"MOUSE16", K_MOUSE16},
 
 
 
 
    {"JOY1",  K_JOY1},
    {"JOY2",  K_JOY2},
    {"JOY3",  K_JOY3},
    {"JOY4",  K_JOY4},
    {"JOY5",  K_JOY5},
    {"JOY6",  K_JOY6},
    {"JOY7",  K_JOY7},
    {"JOY8",  K_JOY8},
    {"JOY9",  K_JOY9},
    {"JOY10", K_JOY10},
    {"JOY11", K_JOY11},
    {"JOY12", K_JOY12},
    {"JOY13", K_JOY13},
    {"JOY14", K_JOY14},
    {"JOY15", K_JOY15},
    {"JOY16", K_JOY16},
 
 
 
 
 
 
    {"AUX1", K_AUX1},
    {"AUX2", K_AUX2},
    {"AUX3", K_AUX3},
    {"AUX4", K_AUX4},
    {"AUX5", K_AUX5},
    {"AUX6", K_AUX6},
    {"AUX7", K_AUX7},
    {"AUX8", K_AUX8},
    {"AUX9", K_AUX9},
    {"AUX10", K_AUX10},
    {"AUX11", K_AUX11},
    {"AUX12", K_AUX12},
    {"AUX13", K_AUX13},
    {"AUX14", K_AUX14},
    {"AUX15", K_AUX15},
    {"AUX16", K_AUX16},
    {"AUX17", K_AUX17},
    {"AUX18", K_AUX18},
    {"AUX19", K_AUX19},
    {"AUX20", K_AUX20},
    {"AUX21", K_AUX21},
    {"AUX22", K_AUX22},
    {"AUX23", K_AUX23},
    {"AUX24", K_AUX24},
    {"AUX25", K_AUX25},
    {"AUX26", K_AUX26},
    {"AUX27", K_AUX27},
    {"AUX28", K_AUX28},
    {"AUX29", K_AUX29},
    {"AUX30", K_AUX30},
    {"AUX31", K_AUX31},
    {"AUX32", K_AUX32},
 
    {"X360_DPAD_UP", K_X360_DPAD_UP},
    {"X360_DPAD_DOWN", K_X360_DPAD_DOWN},
    {"X360_DPAD_LEFT", K_X360_DPAD_LEFT},
    {"X360_DPAD_RIGHT", K_X360_DPAD_RIGHT},
    {"X360_START", K_X360_START},
    {"X360_BACK", K_X360_BACK},
    {"X360_LEFT_THUMB", K_X360_LEFT_THUMB},
    {"X360_RIGHT_THUMB", K_X360_RIGHT_THUMB},
    {"X360_LEFT_SHOULDER", K_X360_LEFT_SHOULDER},
    {"X360_RIGHT_SHOULDER", K_X360_RIGHT_SHOULDER},
    {"X360_A", K_X360_A},
    {"X360_B", K_X360_B},
    {"X360_X", K_X360_X},
    {"X360_Y", K_X360_Y},
    {"X360_LEFT_TRIGGER", K_X360_LEFT_TRIGGER},
    {"X360_RIGHT_TRIGGER", K_X360_RIGHT_TRIGGER},
    {"X360_LEFT_THUMB_UP", K_X360_LEFT_THUMB_UP},
    {"X360_LEFT_THUMB_DOWN", K_X360_LEFT_THUMB_DOWN},
    {"X360_LEFT_THUMB_LEFT", K_X360_LEFT_THUMB_LEFT},
    {"X360_LEFT_THUMB_RIGHT", K_X360_LEFT_THUMB_RIGHT},
    {"X360_RIGHT_THUMB_UP", K_X360_RIGHT_THUMB_UP},
    {"X360_RIGHT_THUMB_DOWN", K_X360_RIGHT_THUMB_DOWN},
    {"X360_RIGHT_THUMB_LEFT", K_X360_RIGHT_THUMB_LEFT},
    {"X360_RIGHT_THUMB_RIGHT", K_X360_RIGHT_THUMB_RIGHT},
 
    {"JOY_UP", K_JOY_UP},
    {"JOY_DOWN", K_JOY_DOWN},
    {"JOY_LEFT", K_JOY_LEFT},
    {"JOY_RIGHT", K_JOY_RIGHT},
 
    {"SEMICOLON", ';'},         // because a raw semicolon separates commands
    {"TILDE", '~'},
    {"BACKQUOTE", '`'},
    {"QUOTE", '"'},
    {"APOSTROPHE", '\''},
    {"BACKSLASH", '\\'},        // because a raw backslash is used for special characters
 
    {"MIDINOTE0", K_MIDINOTE0},
    {"MIDINOTE1", K_MIDINOTE1},
    {"MIDINOTE2", K_MIDINOTE2},
    {"MIDINOTE3", K_MIDINOTE3},
    {"MIDINOTE4", K_MIDINOTE4},
    {"MIDINOTE5", K_MIDINOTE5},
    {"MIDINOTE6", K_MIDINOTE6},
    {"MIDINOTE7", K_MIDINOTE7},
    {"MIDINOTE8", K_MIDINOTE8},
    {"MIDINOTE9", K_MIDINOTE9},
    {"MIDINOTE10", K_MIDINOTE10},
    {"MIDINOTE11", K_MIDINOTE11},
    {"MIDINOTE12", K_MIDINOTE12},
    {"MIDINOTE13", K_MIDINOTE13},
    {"MIDINOTE14", K_MIDINOTE14},
    {"MIDINOTE15", K_MIDINOTE15},
    {"MIDINOTE16", K_MIDINOTE16},
    {"MIDINOTE17", K_MIDINOTE17},
    {"MIDINOTE18", K_MIDINOTE18},
    {"MIDINOTE19", K_MIDINOTE19},
    {"MIDINOTE20", K_MIDINOTE20},
    {"MIDINOTE21", K_MIDINOTE21},
    {"MIDINOTE22", K_MIDINOTE22},
    {"MIDINOTE23", K_MIDINOTE23},
    {"MIDINOTE24", K_MIDINOTE24},
    {"MIDINOTE25", K_MIDINOTE25},
    {"MIDINOTE26", K_MIDINOTE26},
    {"MIDINOTE27", K_MIDINOTE27},
    {"MIDINOTE28", K_MIDINOTE28},
    {"MIDINOTE29", K_MIDINOTE29},
    {"MIDINOTE30", K_MIDINOTE30},
    {"MIDINOTE31", K_MIDINOTE31},
    {"MIDINOTE32", K_MIDINOTE32},
    {"MIDINOTE33", K_MIDINOTE33},
    {"MIDINOTE34", K_MIDINOTE34},
    {"MIDINOTE35", K_MIDINOTE35},
    {"MIDINOTE36", K_MIDINOTE36},
    {"MIDINOTE37", K_MIDINOTE37},
    {"MIDINOTE38", K_MIDINOTE38},
    {"MIDINOTE39", K_MIDINOTE39},
    {"MIDINOTE40", K_MIDINOTE40},
    {"MIDINOTE41", K_MIDINOTE41},
    {"MIDINOTE42", K_MIDINOTE42},
    {"MIDINOTE43", K_MIDINOTE43},
    {"MIDINOTE44", K_MIDINOTE44},
    {"MIDINOTE45", K_MIDINOTE45},
    {"MIDINOTE46", K_MIDINOTE46},
    {"MIDINOTE47", K_MIDINOTE47},
    {"MIDINOTE48", K_MIDINOTE48},
    {"MIDINOTE49", K_MIDINOTE49},
    {"MIDINOTE50", K_MIDINOTE50},
    {"MIDINOTE51", K_MIDINOTE51},
    {"MIDINOTE52", K_MIDINOTE52},
    {"MIDINOTE53", K_MIDINOTE53},
    {"MIDINOTE54", K_MIDINOTE54},
    {"MIDINOTE55", K_MIDINOTE55},
    {"MIDINOTE56", K_MIDINOTE56},
    {"MIDINOTE57", K_MIDINOTE57},
    {"MIDINOTE58", K_MIDINOTE58},
    {"MIDINOTE59", K_MIDINOTE59},
    {"MIDINOTE60", K_MIDINOTE60},
    {"MIDINOTE61", K_MIDINOTE61},
    {"MIDINOTE62", K_MIDINOTE62},
    {"MIDINOTE63", K_MIDINOTE63},
    {"MIDINOTE64", K_MIDINOTE64},
    {"MIDINOTE65", K_MIDINOTE65},
    {"MIDINOTE66", K_MIDINOTE66},
    {"MIDINOTE67", K_MIDINOTE67},
    {"MIDINOTE68", K_MIDINOTE68},
    {"MIDINOTE69", K_MIDINOTE69},
    {"MIDINOTE70", K_MIDINOTE70},
    {"MIDINOTE71", K_MIDINOTE71},
    {"MIDINOTE72", K_MIDINOTE72},
    {"MIDINOTE73", K_MIDINOTE73},
    {"MIDINOTE74", K_MIDINOTE74},
    {"MIDINOTE75", K_MIDINOTE75},
    {"MIDINOTE76", K_MIDINOTE76},
    {"MIDINOTE77", K_MIDINOTE77},
    {"MIDINOTE78", K_MIDINOTE78},
    {"MIDINOTE79", K_MIDINOTE79},
    {"MIDINOTE80", K_MIDINOTE80},
    {"MIDINOTE81", K_MIDINOTE81},
    {"MIDINOTE82", K_MIDINOTE82},
    {"MIDINOTE83", K_MIDINOTE83},
    {"MIDINOTE84", K_MIDINOTE84},
    {"MIDINOTE85", K_MIDINOTE85},
    {"MIDINOTE86", K_MIDINOTE86},
    {"MIDINOTE87", K_MIDINOTE87},
    {"MIDINOTE88", K_MIDINOTE88},
    {"MIDINOTE89", K_MIDINOTE89},
    {"MIDINOTE90", K_MIDINOTE90},
    {"MIDINOTE91", K_MIDINOTE91},
    {"MIDINOTE92", K_MIDINOTE92},
    {"MIDINOTE93", K_MIDINOTE93},
    {"MIDINOTE94", K_MIDINOTE94},
    {"MIDINOTE95", K_MIDINOTE95},
    {"MIDINOTE96", K_MIDINOTE96},
    {"MIDINOTE97", K_MIDINOTE97},
    {"MIDINOTE98", K_MIDINOTE98},
    {"MIDINOTE99", K_MIDINOTE99},
    {"MIDINOTE100", K_MIDINOTE100},
    {"MIDINOTE101", K_MIDINOTE101},
    {"MIDINOTE102", K_MIDINOTE102},
    {"MIDINOTE103", K_MIDINOTE103},
    {"MIDINOTE104", K_MIDINOTE104},
    {"MIDINOTE105", K_MIDINOTE105},
    {"MIDINOTE106", K_MIDINOTE106},
    {"MIDINOTE107", K_MIDINOTE107},
    {"MIDINOTE108", K_MIDINOTE108},
    {"MIDINOTE109", K_MIDINOTE109},
    {"MIDINOTE110", K_MIDINOTE110},
    {"MIDINOTE111", K_MIDINOTE111},
    {"MIDINOTE112", K_MIDINOTE112},
    {"MIDINOTE113", K_MIDINOTE113},
    {"MIDINOTE114", K_MIDINOTE114},
    {"MIDINOTE115", K_MIDINOTE115},
    {"MIDINOTE116", K_MIDINOTE116},
    {"MIDINOTE117", K_MIDINOTE117},
    {"MIDINOTE118", K_MIDINOTE118},
    {"MIDINOTE119", K_MIDINOTE119},
    {"MIDINOTE120", K_MIDINOTE120},
    {"MIDINOTE121", K_MIDINOTE121},
    {"MIDINOTE122", K_MIDINOTE122},
    {"MIDINOTE123", K_MIDINOTE123},
    {"MIDINOTE124", K_MIDINOTE124},
    {"MIDINOTE125", K_MIDINOTE125},
    {"MIDINOTE126", K_MIDINOTE126},
    {"MIDINOTE127", K_MIDINOTE127},
 
    {NULL, 0}
};

Referenced by Key_KeynumToString(), and Key_StringToKeynum().

◆ tbl_keyascii

char tbl_keyascii[MAX_KEYS]

static

Definition at line 1794 of file keys.c.

Referenced by Key_Event().

◆ tbl_keydest

keydest_t tbl_keydest[MAX_KEYS]

static

Definition at line 1795 of file keys.c.

Referenced by Key_Event().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ KM_ALT

◆ KM_CTRL

◆ KM_CTRL_ALT

◆ KM_CTRL_SHIFT

◆ KM_CTRL_SHIFT_ALT

◆ KM_NONE

◆ KM_SHIFT

◆ KM_SHIFT_ALT

Function Documentation

◆ Key_AddChar()

◆ Key_Bind_f()

◆ Key_BindList_f()

◆ Key_ClearEditLine()

◆ Key_Console()

◆ Key_Convert_NumPadKey()

◆ Key_Event()

◆ Key_EventQueue_Add()

◆ Key_EventQueue_Block()

◆ Key_EventQueue_Unblock()

◆ Key_FindKeysForCommand()

◆ Key_GetBind()

◆ Key_GetBindMap()

◆ Key_History_Down()

◆ Key_History_f()

◆ Key_History_Find_All()

◆ Key_History_Find_Backwards()

◆ Key_History_Find_Forwards()

◆ Key_History_First()

◆ Key_History_Get_foundCommand()

◆ Key_History_Init()

◆ Key_History_Last()

◆ Key_History_Push()

◆ Key_History_Shutdown()

◆ Key_History_Up()

◆ Key_In_Bind_f()

◆ Key_In_BindList_f()

◆ Key_In_Bindmap_f()

◆ Key_In_Unbind_f()

◆ Key_Init()

◆ Key_KeynumToString()

◆ Key_Message()

◆ Key_Parse_CommonKeys()

◆ Key_PrintBindList()

◆ Key_ReleaseAll()

◆ Key_ReleaseAll_f()

◆ Key_SetBinding()

◆ Key_SetBindMap()

◆ Key_Shutdown()

◆ Key_StringToKeynum()

◆ Key_Unbind_f()

◆ Key_Unbindall_f()

◆ Key_WriteBindings()

Variable Documentation

◆ chat_buffer

◆ chat_bufferpos

◆ chat_mode

◆ con_closeontoggleconsole

◆ con_textsize

◆ eventqueue

◆ eventqueue_idx

◆ events_blocked

◆ history

◆ history_line

◆ history_matchfound

◆ history_savedline

◆ history_searchstring

◆ key_bmap

◆ key_bmap2

◆ key_consoleactive

◆ key_dest

◆ key_insert

◆ key_line

◆ key_linepos

◆ keybindings

◆ keydown