qf/newtree
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/newtree synced 2025-02-16 16:41:30 +00:00
Code Issues Projects Releases Packages Wiki Activity

New branch!

Browse source 
The sledge hammer approach to rewriting the key handling, it is so VERY
broken right now.
This commit is contained in:
Zephaniah E. Hull 2000-09-30 08:56:09 +00:00
parent 2186a58fe5
commit b5bf9eb32c
8 changed files with 545 additions and 660 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
include/keys.h
View file

@ -34,6 +34,14 @@
// these are the key numbers that should be passed to Key_Event
typedef enum
{
BIND_GAME = 0, // In game binds.
BIND_CONSOLE, // Console binds.
BIND_ALL, // Valid in all, other binds override.
BIND_MAX
} bind_states;
typedef enum {
K_TAB = 9,
K_ENTER = 13,
@ -160,22 +168,10 @@ typedef enum {
K_MWHEELDOWN
} keynum_t;
typedef enum {key_game, key_console, key_message, key_menu} keydest_t;
extern keydest_t key_dest;
extern char *keybindings[256];
extern int key_repeats[256];
extern int key_lastpress;
extern char chat_buffer[];
extern int chat_bufferlen;
extern qboolean chat_team;
void Key_Event (int key, qboolean down);
void Key_Init (void);
void Key_WriteBindings (QFile *f);
void Key_SetBinding (int keynum, char *binding);
void Key_SetBinding (bind_states state, int keynum, char *binding);
void Key_ClearStates (void);
#endif // _KEYS_H

36
include/wtoi.h Normal file
View file

@ -0,0 +1,36 @@
/*
wtoi.c
Word to int, int to word conversion (typedef, prototypes)
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id$
*/
typedef struct
{
char *name;
int num;
} wic_t;
char *WIC_IntToStr (int, wic_t *);
int WIC_StrToInt (char *, wic_t *);

3
source/Makefile.am
View file

@ -46,7 +46,8 @@ endif
common_SOURCES= net_chan.c net_com.c net_udp.c pmove.c pmovetst.c zone.c \
mdfour.c mathlib.c cvar.c crc.c cmd.c \
qargs.c qendian.c quakefs.c quakeio.c msg.c sizebuf.c info.c \
checksum.c link.c buildnum.c va.c com.c model.c model_brush.c $(math_ASM)
checksum.c link.c buildnum.c va.c com.c model.c model_brush.c \
wtoi.c $(math_ASM)
#
# Server builds

244
source/console.c
View file

@ -56,6 +56,7 @@ float con_cursorspeed = 4;
cvar_t *con_notifytime; //seconds
#define NUM_CON_TIMES 4
float con_times[NUM_CON_TIMES]; // realtime time the line was generated
// for transparent notify lines
@ -66,10 +67,12 @@ int con_notifylines; // scan lines to clear for notify lines
qboolean con_debuglog;
#define MAXCMDLINE 256
extern char key_lines[32][MAXCMDLINE];
extern int edit_line;
extern int key_linepos;
char key_lines[32][MAXCMDLINE];
int edit_line;
int key_linepos;
static cvar_t *cl_chatmode;
static int history_line=0;
qboolean con_initialized;
@ -89,6 +92,7 @@ void Con_ToggleConsole_f (void)
{
Key_ClearTyping ();
/*
if (key_dest == key_console)
{
if (cls.state == ca_active)
@ -96,6 +100,7 @@ void Con_ToggleConsole_f (void)
}
else
key_dest = key_console;
*/
Con_ClearNotify ();
}
@ -109,6 +114,7 @@ void Con_ToggleChat_f (void)
{
Key_ClearTyping ();
/*
if (key_dest == key_console)
{
if (cls.state == ca_active)
@ -116,6 +122,7 @@ void Con_ToggleChat_f (void)
}
else
key_dest = key_console;
*/
Con_ClearNotify ();
}
@ -158,8 +165,10 @@ void Con_MessageMode_f (void)
{
if (cls.state != ca_active)
return;
/*
chat_team = false;
key_dest = key_message;
*/
}
/*
@ -171,8 +180,10 @@ void Con_MessageMode2_f (void)
{
if (cls.state != ca_active)
return;
/*
chat_team = true;
key_dest = key_message;
*/
}
/*
@ -268,6 +279,10 @@ void Con_Init (void)
// register our commands
//
con_notifytime = Cvar_Get("con_notifytime", "3", CVAR_NONE, "None");
cl_chatmode = Cvar_Get ("cl_chatmode", "2", 0,
"Controls when console text will be treated as a chat message\n"
"0 - never, 1 - always, 2 - smart");
Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
Cmd_AddCommand ("togglechat", Con_ToggleChat_f);
@ -449,7 +464,7 @@ void Con_DrawInput (void)
char *text;
char temp[MAXCMDLINE];
if (key_dest != key_console && cls.state == ca_active)
if (/*key_dest != key_console &&*/ cls.state == ca_active)
return; // don't draw anything (allways draw if not active)
text = strcpy (temp, key_lines[edit_line]);
@ -487,8 +502,10 @@ void Con_DrawNotify (void)
char *text;
int i;
float time;
/*
char *s;
int skip;
*/
v = 0;
for (i= con->current-NUM_CON_TIMES+1 ; i<=con->current ; i++)
@ -513,6 +530,7 @@ void Con_DrawNotify (void)
}
/*
if (key_dest == key_message)
{
clearnotify = 0;
@ -541,6 +559,7 @@ void Con_DrawNotify (void)
Draw_Character8 ( (x+skip)<<3, v, 10+((int)(realtime*con_cursorspeed)&1));
v += 8;
}
*/
if (v > con_notifylines)
con_notifylines = v;
@ -647,3 +666,220 @@ void Con_DrawConsole (int lines)
// draw the input prompt, user text, and cursor if desired
Con_DrawInput ();
}
/*
* Commands for new key bindings!
*/
void
Con_Insert_Char_f(void)
{
int key;
int i;
if (Cmd_Argc() != 2) {
Con_Printf("usage: con_insert_char <char>\n");
return;
}
key = *Cmd_Argv(1);
if (key < 32 || key > 127)
return; // non printable
i = strlen(key_lines[edit_line]);
if (i >= MAXCMDLINE-1)
return;
// This also moves the ending \0
memmove (key_lines[edit_line]+key_linepos+1, key_lines[edit_line]+key_linepos, i-key_linepos+1);
key_lines[edit_line][key_linepos] = key;
key_linepos++;
}
void
Con_Backspace_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_backspace\n");
return;
}
if (key_linepos > 1) {
strcpy(key_lines[edit_line] + key_linepos - 1, key_lines[edit_line] + key_linepos);
key_linepos--;
}
}
void
Con_Enter_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_enter\n");
return;
}
// backslash text are commands
if (key_lines[edit_line][1] == '/' && key_lines[edit_line][2] == '/')
goto no_lf;
else if (key_lines[edit_line][1] == '\\' || key_lines[edit_line][1] == '/')
Cbuf_AddText (key_lines[edit_line]+2); // skip the ]/
/*
else if (cl_chatmode->value != 1 && CheckForCommand())
Cbuf_AddText (key_lines[edit_line]+1); // valid command
*/
else if ((cls.state >= ca_connected && cl_chatmode->value == 2) || cl_chatmode->value == 1) {
if (cls.state < ca_connected) // can happen if cl_chatmode is 1
goto no_lf; // the text goes to /dev/null :)
// convert to a chat message
Cbuf_AddText ("say ");
Cbuf_AddText (key_lines[edit_line]+1);
} else
Cbuf_AddText (key_lines[edit_line]+1); // skip the ]
Cbuf_AddText ("\n");
no_lf:
Con_Printf ("%s\n",key_lines[edit_line]);
edit_line = (edit_line + 1) & 31;
history_line = edit_line;
key_lines[edit_line][0] = ']';
key_lines[edit_line][1] = 0;
key_linepos = 1;
if (cls.state == ca_disconnected)
SCR_UpdateScreen (); // force an update, because the command
// may take some time
}
void
Con_Delete_Char_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_delete_char\n");
return;
}
if (key_linepos < strlen(key_lines[edit_line]))
strcpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + 1);
}
void
Con_Cursor_Left_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_cursor_left\n");
return;
}
if (key_linepos > 1)
key_linepos--;
}
void
Con_Cursor_Right_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_cursor_right\n");
return;
}
if (key_linepos < strlen(key_lines[edit_line]))
key_linepos++;
}
void
Con_Cursor_Up_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_cursor_up\n");
return;
}
do {
history_line = (history_line - 1) & 31;
} while (history_line != edit_line
&& !key_lines[history_line][1]);
if (history_line == edit_line)
history_line = (edit_line+1)&31;
strcpy(key_lines[edit_line], key_lines[history_line]);
key_linepos = strlen(key_lines[edit_line]);
}
void
Con_Cursor_Down_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_cursor_down\n");
return;
}
if (history_line == edit_line) return;
do {
history_line = (history_line + 1) & 31;
} while (history_line != edit_line
&& !key_lines[history_line][1]);
if (history_line == edit_line) {
key_lines[edit_line][0] = ']';
key_lines[edit_line][1] = 0;
key_linepos = 1;
} else {
strcpy(key_lines[edit_line], key_lines[history_line]);
key_linepos = strlen(key_lines[edit_line]);
}
}
void
Con_Page_Up_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_page_up\n");
return;
}
if (con->display - con->current + con->numlines > 2)
con->display -= 2;
}
void
Con_Page_Down_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_page_down\n");
return;
}
con->display += 2;
if (con->display > con->current)
con->display = con->current;
}
void
Con_BeginningOfBuffer_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_beginningofbuffer\n");
return;
}
if (con->numlines > 10)
con->display = con->current - con->numlines + 10;
}
void
Con_EndOfBuffer_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_endofbuffer\n");
return;
}
con->display = con->current;
}
void
Con_BeginningOfLine_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_beginningofline\n");
return;
}
key_linepos = 1;
}
void
Con_EndOfLine_f(void)
{
if (Cmd_Argc() != 1) {
Con_Printf("usage: con_endofline\n");
return;
}
key_linepos = strlen(key_lines[edit_line]);
}

12
source/gl_screen.c
View file

@ -253,8 +253,10 @@ void SCR_CheckDrawCenterString (void)
if (scr_centertime_off <= 0 && !cl.intermission)
return;
/*
if (key_dest != key_game)
return;
*/
SCR_DrawCenterString ();
}
@ -328,9 +330,8 @@ static void SCR_CalcRefdef (void)
if (scr_viewsize->value >= 100.0) {
full = true;
size = 100.0;
} else {
} else
size = scr_viewsize->value;
}
if (cl.intermission)
{
full = true;
@ -542,8 +543,10 @@ void SCR_SetUpToDrawConsole (void)
scr_conlines = vid.height; // full screen
scr_con_current = scr_conlines;
}
/*
else if (key_dest == key_console)
scr_conlines = vid.height/2; // half screen
*/
else
scr_conlines = 0; // none visible
@ -587,8 +590,10 @@ void SCR_DrawConsole (void)
}
else
{
/*
if (key_dest == key_game || key_dest == key_message)
Con_DrawNotify (); // only draw notify in game
*/
}
}
@ -1101,12 +1106,13 @@ void SCR_UpdateScreen (void)
if (r_netgraph->value)
R_NetGraph ();
/*
if (cl.intermission == 1 && key_dest == key_game) {
Sbar_IntermissionOverlay ();
} else if (cl.intermission == 2 && key_dest == key_game) {
Sbar_FinaleOverlay ();
SCR_CheckDrawCenterString ();
} else {
}*/ else {
if (crosshair->int_val)
Draw_Crosshair();

791
source/keys.c
View file

@ -48,6 +48,7 @@
#include "cvar.h"
#include "screen.h"
#include "client.h"
#include "wtoi.h"
/*
@ -55,149 +56,142 @@ key up events are sent even if in console mode
*/
cvar_t *cl_chatmode;
#define NUM_BINDS 256 // Can never be higher, can it?
#define BIND_STATES 3 // Number of bind states.
#define MAXCMDLINE 256
char key_lines[32][MAXCMDLINE];
int key_linepos;
int key_lastpress;
int edit_line=0;
int history_line=0;
keydest_t key_dest;
char *keybindings[256];
qboolean consolekeys[256]; // if true, can't be rebound while in console
qboolean menubound[256]; // if true, can't be rebound while in menu
char *bindings[BIND_STATES][NUM_BINDS];
int keyshift[256]; // key to map to if shift held down in console
int key_repeats[256]; // if > 1, it is autorepeating
qboolean keydown[256];
typedef struct
bind_states bind_state = BIND_CONSOLE;
static wic_t bindnames[] =
{
char *name;
int keynum;
} keyname_t;
{ "GAME", BIND_GAME },
{ "CONSOLE", BIND_CONSOLE },
{ "ALL", BIND_ALL },
{ NULL, 0 }
};
keyname_t keynames[] =
static wic_t keynames[] =
{
{"TAB", K_TAB},
{"ENTER", K_ENTER},
{"ESCAPE", K_ESCAPE},
{"SPACE", K_SPACE},
{"BACKSPACE", K_BACKSPACE},
{"TAB", K_TAB},
{"ENTER", K_ENTER},
{"ESCAPE", K_ESCAPE},
{"SPACE", K_SPACE},
{"BACKSPACE", K_BACKSPACE},
{"CAPSLOCK",K_CAPSLOCK},
{"PRINTSCR", K_PRNTSCR},
{"SCRLCK", K_SCRLCK},
{"PAUSE", K_PAUSE},
{"CAPSLOCK", K_CAPSLOCK},
{"PRINTSCR", K_PRNTSCR},
{"SCRLCK", K_SCRLCK},
{"PAUSE", K_PAUSE},
{"UPARROW", K_UPARROW},
{"DOWNARROW", K_DOWNARROW},
{"LEFTARROW", K_LEFTARROW},
{"RIGHTARROW", K_RIGHTARROW},
{"UPARROW", K_UPARROW},
{"DOWNARROW", K_DOWNARROW},
{"LEFTARROW", K_LEFTARROW},
{"RIGHTARROW", K_RIGHTARROW},
{"ALT", K_ALT},
{"CTRL", K_CTRL},
{"SHIFT", K_SHIFT},
{"ALT", K_ALT},
{"CTRL", K_CTRL},
{"SHIFT", K_SHIFT},
// Keypad stuff..
// These are duplicated
{"NUMLOCK", KP_NUMLCK},
{"KP_NUMLCK", KP_NUMLCK},
{"KP_NUMLOCK", KP_NUMLCK},
{"KP_SLASH", KP_DIVIDE},
{"KP_DIVIDE", KP_DIVIDE},
{"KP_STAR", KP_MULTIPLY},
{"KP_MULTIPLY", KP_MULTIPLY},
{"KP_MINUS", KP_MINUS},
{"NUMLOCK", KP_NUMLCK},
{"KP_NUMLCK", KP_NUMLCK},
{"KP_NUMLOCK", KP_NUMLCK},
{"KP_SLASH", KP_DIVIDE},
{"KP_DIVIDE", KP_DIVIDE},
{"KP_STAR", KP_MULTIPLY},
{"KP_MULTIPLY", KP_MULTIPLY},
{"KP_MINUS", KP_MINUS},
{"KP_HOME", KP_HOME},
{"KP_UPARROW", KP_UPARROW},
{"KP_PGUP", KP_PGUP},
{"KP_PLUS", KP_PLUS},
{"KP_HOME", KP_HOME},
{"KP_UPARROW", KP_UPARROW},
{"KP_PGUP", KP_PGUP},
{"KP_PLUS", KP_PLUS},
{"KP_LEFTARROW", KP_LEFTARROW},
{"KP_5", KP_5},
{"KP_RIGHTARROW", KP_RIGHTARROW},
{"KP_LEFTARROW", KP_LEFTARROW},
{"KP_5", KP_5},
{"KP_RIGHTARROW", KP_RIGHTARROW},
{"KP_END", KP_END},
{"KP_DOWNARROW", KP_DOWNARROW},
{"KP_PGDN", KP_PGDN},
{"KP_END", KP_END},
{"KP_DOWNARROW", KP_DOWNARROW},
{"KP_PGDN", KP_PGDN},
{"KP_INS", KP_INS},
{"KP_DEL", KP_DEL},
{"KP_ENTER", KP_ENTER},
{"KP_INS", KP_INS},
{"KP_DEL", KP_DEL},
{"KP_ENTER", KP_ENTER},
{"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},
{"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},
{"INS", K_INS},
{"DEL", K_DEL},
{"PGDN", K_PGDN},
{"PGUP", K_PGUP},
{"HOME", K_HOME},
{"END", K_END},
{"MOUSE1", K_MOUSE1},
{"MOUSE2", K_MOUSE2},
{"MOUSE3", K_MOUSE3},
{"MOUSE1", K_MOUSE1},
{"MOUSE2", K_MOUSE2},
{"MOUSE3", K_MOUSE3},
{"JOY1", K_JOY1},
{"JOY2", K_JOY2},
{"JOY3", K_JOY3},
{"JOY4", K_JOY4},
{"JOY1", K_JOY1},
{"JOY2", K_JOY2},
{"JOY3", K_JOY3},
{"JOY4", K_JOY4},
{"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},
{"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},
{"MWHEELUP", K_MWHEELUP},
{"MWHEELDOWN", K_MWHEELDOWN},
{"MWHEELUP", K_MWHEELUP},
{"MWHEELDOWN", K_MWHEELDOWN},
{"SEMICOLON", ';'}, // because a raw semicolon seperates commands
{"SEMICOLON", ';'}, // because a raw semicolon seperates commands
{NULL,0}
};
@ -210,316 +204,24 @@ keyname_t keynames[] =
==============================================================================
*/
qboolean
CheckForCommand ( void )
{
char command[128];
char *cmd, *s;
int i;
s = key_lines[edit_line]+1;
for (i=0 ; i<127 ; i++)
if (s[i] <= ' ')
break;
else
command[i] = s[i];
command[i] = 0;
cmd = Cmd_CompleteCommand (command);
if (!cmd || strcmp (cmd, command))
cmd = Cvar_CompleteVariable (command);
if (!cmd || strcmp (cmd, command) )
return false; // just a chat message
return true;
}
void
CompleteCommand ( void )
{
char *cmd, *s;
s = key_lines[edit_line]+1;
if (*s == '\\' || *s == '/')
s++;
cmd = Cmd_CompleteCommand (s);
if (!cmd)
cmd = Cvar_CompleteVariable (s);
if (cmd)
{
key_lines[edit_line][1] = '/';
strcpy (key_lines[edit_line]+2, cmd);
key_linepos = strlen(cmd)+2;
key_lines[edit_line][key_linepos] = ' ';
key_linepos++;
key_lines[edit_line][key_linepos] = 0;
return;
}
}
/*
====================
Key_Console
Interactive line editing and console scrollback
====================
*/
void
Key_Console ( int key )
{
int i;
#ifdef _WIN32
HANDLE th;
char *clipText, *textCopied;
#endif
switch (key)
{
case K_ENTER:
// backslash text are commands
if (key_lines[edit_line][1] == '/' && key_lines[edit_line][2] == '/')
goto no_lf;
else if (key_lines[edit_line][1] == '\\' || key_lines[edit_line][1] == '/')
Cbuf_AddText (key_lines[edit_line]+2); // skip the ]/
else if (cl_chatmode->value != 1 && CheckForCommand())
Cbuf_AddText (key_lines[edit_line]+1); // valid command
else if ((cls.state >= ca_connected && cl_chatmode->value == 2) || cl_chatmode->value == 1)
{
if (cls.state < ca_connected) // can happen if cl_chatmode is 1
goto no_lf; // the text goes to /dev/null :)
// convert to a chat message
Cbuf_AddText ("say ");
Cbuf_AddText (key_lines[edit_line]+1);
}
else
Cbuf_AddText (key_lines[edit_line]+1); // skip the ]
Cbuf_AddText ("\n");
no_lf:
Con_Printf ("%s\n",key_lines[edit_line]);
edit_line = (edit_line + 1) & 31;
history_line = edit_line;
key_lines[edit_line][0] = ']';
key_lines[edit_line][1] = 0;
key_linepos = 1;
if (cls.state == ca_disconnected)
SCR_UpdateScreen (); // force an update, because the command
// may take some time
return;
case K_TAB:
// command completion
CompleteCommand ();
return;
case K_BACKSPACE:
if (key_linepos > 1)
{
strcpy(key_lines[edit_line] + key_linepos - 1, key_lines[edit_line] + key_linepos);
key_linepos--;
}
return;
case K_DEL:
if (key_linepos < strlen(key_lines[edit_line]))
strcpy(key_lines[edit_line] + key_linepos, key_lines[edit_line] + key_linepos + 1);
return;
case K_RIGHTARROW:
if (key_linepos < strlen(key_lines[edit_line]))
key_linepos++;
return;
case K_LEFTARROW:
if (key_linepos > 1)
key_linepos--;
return;
case K_UPARROW:
do {
history_line = (history_line - 1) & 31;
} while (history_line != edit_line
&& !key_lines[history_line][1]);
if (history_line == edit_line)
history_line = (edit_line+1)&31;
strcpy(key_lines[edit_line], key_lines[history_line]);
key_linepos = strlen(key_lines[edit_line]);
return;
case K_DOWNARROW:
if (history_line == edit_line) return;
do {
history_line = (history_line + 1) & 31;
} while (history_line != edit_line
&& !key_lines[history_line][1]);
if (history_line == edit_line) {
key_lines[edit_line][0] = ']';
key_lines[edit_line][1] = 0;
key_linepos = 1;
} else {
strcpy(key_lines[edit_line], key_lines[history_line]);
key_linepos = strlen(key_lines[edit_line]);
}
return;
case K_MWHEELUP:
case K_PGUP:
if (con->display - con->current + con->numlines > 2)
con->display -= 2;
return;
case K_MWHEELDOWN:
case K_PGDN:
con->display += 2;
if (con->display > con->current)
con->display = con->current;
return;
case K_HOME:
if (keydown[K_CTRL])
{
if (con->numlines > 10)
con->display = con->current - con->numlines + 10;
}
else
key_linepos = 1;
return;
case K_END:
if (keydown[K_CTRL])
con->display = con->current;
else
key_linepos = strlen(key_lines[edit_line]);
return;
}
#ifdef _WIN32
if ((key=='V' || key=='v') && GetKeyState(VK_CONTROL)<0) {
if (OpenClipboard(NULL)) {
th = GetClipboardData(CF_TEXT);
if (th) {
clipText = GlobalLock(th);
if (clipText) {
textCopied = malloc(GlobalSize(th)+1);
strcpy(textCopied, clipText);
/* Substitutes a NULL for every token */
strtok(textCopied, "\n\r\b");
i = strlen(textCopied);
if (i + strlen(key_lines[edit_line]) > MAXCMDLINE-1)
i = MAXCMDLINE-1 - strlen(key_lines[edit_line]);
if (i > 0)
{ // insert the string
memmove (key_lines[edit_line] + key_linepos + i,
key_lines[edit_line] + key_linepos, strlen(key_lines[edit_line]) - key_linepos + 1);
memcpy (key_lines[edit_line] + key_linepos, textCopied, i);
key_linepos += i;
}
free(textCopied);
}
GlobalUnlock(th);
}
CloseClipboard();
return;
}
}
#endif
if (key < 32 || key > 127)
return; // non printable
i = strlen(key_lines[edit_line]);
if (i >= MAXCMDLINE-1)
return;
// This also moves the ending \0
memmove (key_lines[edit_line]+key_linepos+1, key_lines[edit_line]+key_linepos, i-key_linepos+1);
key_lines[edit_line][key_linepos] = key;
key_linepos++;
}
//============================================================================
qboolean chat_team;
char chat_buffer[MAXCMDLINE];
int chat_bufferlen = 0;
void
Key_Message ( int key )
{
if (key == K_ENTER)
{
if (chat_team)
Cbuf_AddText ("say_team \"");
else
Cbuf_AddText ("say \"");
Cbuf_AddText(chat_buffer);
Cbuf_AddText("\"\n");
key_dest = key_game;
chat_bufferlen = 0;
chat_buffer[0] = 0;
return;
}
if (key == K_ESCAPE)
{
key_dest = key_game;
chat_bufferlen = 0;
chat_buffer[0] = 0;
return;
}
if (key < 32 || key > 127)
return; // non printable
if (key == K_BACKSPACE)
{
if (chat_bufferlen)
{
chat_bufferlen--;
chat_buffer[chat_bufferlen] = 0;
}
return;
}
if (chat_bufferlen == sizeof(chat_buffer)-1)
return; // all full
chat_buffer[chat_bufferlen++] = key;
chat_buffer[chat_bufferlen] = 0;
}
//============================================================================
/*
===================
Key_StringToKeynum
Returns a key number to be used to index keybindings[] by looking at
Returns a key number to be used to index bindings[] by looking at
the given string. Single ascii characters return themselves, while
the K_* names are matched up.
===================
*/
int
Key_StringToKeynum ( char *str )
Key_StringToKeynum (char *str)
{
keyname_t *kn;
if (!str || !str[0])
return -1;
if (!str[1])
return str[0];
for (kn=keynames ; kn->name ; kn++)
{
if (!strcasecmp(str,kn->name))
return kn->keynum;
}
return -1;
return WIC_StrToInt(str, keynames);
}
/*
@ -532,25 +234,22 @@ FIXME: handle quote special (general escape sequence?)
===================
*/
char *
Key_KeynumToString ( int keynum )
Key_KeynumToString (int num)
{
keyname_t *kn;
static char tinystr[2];
static char *str, tinystr[2];
if (keynum == -1)
if (num == -1)
return "<KEY NOT FOUND>";
if (keynum > 32 && keynum < 127)
{ // printable ascii
tinystr[0] = keynum;
if (num > 32 && num < 127) { // printable ascii
tinystr[0] = num;
tinystr[1] = 0;
return tinystr;
}
for (kn=keynames ; kn->name ; kn++)
if (keynum == kn->keynum)
return kn->name;
return "<UNKNOWN KEYNUM>";
if ((str = WIC_IntToStr(num, keynames)))
return str;
else
return "<UNKNOWN KEYNUM>";
}
@ -560,7 +259,7 @@ Key_SetBinding
===================
*/
void
Key_SetBinding ( int keynum, char *binding )
Key_SetBinding (bind_states state, int keynum, char *binding)
{
char *new;
int l;
@ -569,10 +268,10 @@ Key_SetBinding ( int keynum, char *binding )
return;
// free old bindings
if (keybindings[keynum])
if (bindings[state][keynum])
{
free (keybindings[keynum]);
keybindings[keynum] = NULL;
free (bindings[state][keynum]);
bindings[state][keynum] = NULL;
}
// allocate memory for new binding
@ -580,7 +279,7 @@ Key_SetBinding ( int keynum, char *binding )
new = malloc (l+1);
strcpy (new, binding);
new[l] = 0;
keybindings[keynum] = new;
bindings[state][keynum] = new;
}
/*
@ -591,11 +290,11 @@ Key_Unbind_f
void
Key_Unbind_f ( void )
{
int b;
int b, state;
if (Cmd_Argc() != 2)
if (Cmd_Argc() != 3)
{
Con_Printf ("unbind <key> : remove commands from a key\n");
Con_Printf ("unbind <state> <key> : remove commands from a key\n");
return;
}
@ -605,18 +304,23 @@ Key_Unbind_f ( void )
Con_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
return;
}
state = WIC_StrToInt(Cmd_Argv(2), bindnames);
Key_SetBinding (b, "");
Key_SetBinding (state, b, "");
}
void
Key_Unbindall_f ( void )
{
int i;
int a, i;
for (i=0 ; i<256 ; i++)
if (keybindings[i])
Key_SetBinding (i, "");
for (a = 0; a < BIND_MAX; a++) {
for (i=0 ; i < NUM_BINDS ; i++) {
if (bindings[a][i]) {
Key_SetBinding (a, i, "");
}
}
}
}
@ -630,40 +334,30 @@ Key_Bind_f ( void )
{
int i, c, b;
char cmd[1024];
bind_states state;
c = Cmd_Argc();
if (c < 2)
{
Con_Printf ("bind <key> [command] : attach a command to a key\n");
if (c < 3) {
Con_Printf("bind <state> <key> [command] :attach a command to a key\n");
return;
}
b = Key_StringToKeynum (Cmd_Argv(1));
if (b==-1)
{
b = Key_StringToKeynum (Cmd_Argv(2));
if (b == -1) {
Con_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
return;
}
state = WIC_StrToInt(Cmd_Argv(1), bindnames);
if (c == 2)
{
if (keybindings[b])
Con_Printf ("\"%s\" = \"%s\"\n", Cmd_Argv(1), keybindings[b] );
else
Con_Printf ("\"%s\" is not bound\n", Cmd_Argv(1) );
return;
}
// copy the rest of the command line
// copy the rest of the command line
cmd[0] = 0; // start out with a null string
for (i=2 ; i< c ; i++)
{
for (i = 2 ; i < c ; i++) {
strcat (cmd, Cmd_Argv(i));
if (i != (c-1))
strcat (cmd, " ");
}
Key_SetBinding (b, cmd);
Key_SetBinding (state, b, cmd);
}
/*
@ -676,11 +370,12 @@ Writes lines containing "bind key value"
void
Key_WriteBindings ( QFile *f )
{
int i;
int i, a;
for (i=0 ; i<256 ; i++)
if (keybindings[i])
Qprintf (f, "bind \"%s\" \"%s\"\n", Key_KeynumToString(i), keybindings[i]); // 1999-12-26 bound keys not saved in quotes fix by Maddes
for (a=0; a<BIND_MAX; a++)
for (i=0 ; i<256 ; i++)
if (bindings[a][i])
Qprintf (f, "sbind %s \"%s\" \"%s\"\n", WIC_IntToStr(a, bindnames), Key_KeynumToString(i), bindings[a][i]);
}
@ -694,36 +389,6 @@ Key_Init ( void )
{
int i;
for (i=0 ; i<32 ; i++)
{
key_lines[i][0] = ']';
key_lines[i][1] = 0;
}
key_linepos = 1;
//
// init ascii characters in console mode
//
for (i=32 ; i<128 ; i++)
consolekeys[i] = true;
consolekeys[K_ENTER] = true;
consolekeys[K_TAB] = true;
consolekeys[K_LEFTARROW] = true;
consolekeys[K_RIGHTARROW] = true;
consolekeys[K_UPARROW] = true;
consolekeys[K_DOWNARROW] = true;
consolekeys[K_BACKSPACE] = true;
consolekeys[K_DEL] = true;
consolekeys[K_HOME] = true;
consolekeys[K_END] = true;
consolekeys[K_PGUP] = true;
consolekeys[K_PGDN] = true;
consolekeys[K_SHIFT] = true;
consolekeys[K_MWHEELUP] = true;
consolekeys[K_MWHEELDOWN] = true;
consolekeys['`'] = false;
consolekeys['~'] = false;
for (i=0 ; i<256 ; i++)
keyshift[i] = i;
for (i='a' ; i<='z' ; i++)
@ -750,20 +415,12 @@ Key_Init ( void )
keyshift['`'] = '~';
keyshift['\\'] = '|';
menubound[K_ESCAPE] = true;
for (i=0 ; i<12 ; i++)
menubound[K_F1+i] = true;
//
// register our functions
//
Cmd_AddCommand ("bind", Key_Bind_f);
Cmd_AddCommand ("unbind", Key_Unbind_f);
Cmd_AddCommand ("unbindall", Key_Unbindall_f);
cl_chatmode = Cvar_Get ("cl_chatmode", "2", 0,
"Controls when console text will be treated as a chat message\n"
"0 - never, 1 - always, 2 - smart");
}
/*
@ -784,139 +441,15 @@ Key_Event ( int key, qboolean down )
keydown[key] = down;
if (!down)
key_repeats[key] = 0;
key_lastpress = key;
// update auto-repeat status
if (down)
{
key_repeats[key]++;
if (key_repeats[key] > 1)
{
if ((key != K_BACKSPACE && key != K_DEL
&& key != K_LEFTARROW && key != K_RIGHTARROW
&& key != K_PGUP && key != K_PGDN)
|| (key_dest == key_game && cls.state == ca_active))
return; // ignore most autorepeats
if ((kb = bindings[bind_state][key]) || (kb = bindings[BIND_ALL][key])) {
if (kb[0] == '+') { // button commands add keynum as a parm
snprintf (cmd, sizeof(cmd), "%s %i\n", kb, key);
if (!down)
cmd[0] = '-';
} else {
snprintf(cmd, sizeof(cmd), "%s\n", kb);
}
if (key >= 200 && !keybindings[key])
Con_Printf ("%s is unbound, hit F4 to set.\n", Key_KeynumToString (key) );
}
// Exit message mode is disconnected
if (key_dest == key_message && cls.state != ca_active)
key_dest = key_console;
//
// handle escape specialy, so the user can never unbind it
//
if (key == K_ESCAPE)
{
if (!down)
return;
switch (key_dest)
{
case key_message:
Key_Message (key);
break;
case key_menu:
M_Keydown (key);
break;
case key_game:
case key_console:
M_ToggleMenu_f ();
break;
default:
Sys_Error ("Bad key_dest");
}
return;
}
//
// 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] == '+')
{
snprintf (cmd, sizeof(cmd), "-%s %i\n", kb+1, key);
Cbuf_AddText (cmd);
}
if (keyshift[key] != key)
{
kb = keybindings[keyshift[key]];
if (kb && kb[0] == '+')
{
snprintf (cmd, sizeof(cmd), "-%s %i\n", kb+1, key);
Cbuf_AddText (cmd);
}
}
return;
}
//
// during demo playback, most keys bring up the main menu
//
if (cls.demoplayback && down && consolekeys[key] && key_dest == key_game
&& key != K_CTRL && key != K_DEL && key != K_HOME && key != K_END && key != K_TAB)
{
M_ToggleMenu_f ();
return;
}
//
// if not a consolekey, send to the interpreter no matter what mode is
//
if ( (key_dest == key_menu && menubound[key])
|| (key_dest == key_console && !consolekeys[key])
|| (key_dest == key_game && ( cls.state == ca_active || !consolekeys[key] ) ) )
{
kb = keybindings[key];
if (kb)
{
if (kb[0] == '+')
{ // button commands add keynum as a parm
snprintf (cmd, sizeof(cmd), "%s %i\n", kb, key);
Cbuf_AddText (cmd);
}
else
{
Cbuf_AddText (kb);
Cbuf_AddText ("\n");
}
}
return;
}
if (!down)
return; // other systems only care about key down events
if (keydown[K_SHIFT])
key = keyshift[key];
switch (key_dest)
{
case key_message:
Key_Message (key);
break;
case key_menu:
M_Keydown (key);
break;
case key_game:
case key_console:
Key_Console (key);
break;
default:
Sys_Error ("Bad key_dest");
Cbuf_AddText (cmd);
}
}

36
source/menu.c
View file

@ -271,6 +271,7 @@ void M_ToggleMenu_f (void)
{
m_entersound = true;
/*
if (key_dest == key_menu)
{
if (m_state != m_main)
@ -292,6 +293,7 @@ void M_ToggleMenu_f (void)
{
M_Menu_Main_f ();
}
*/
}
@ -304,12 +306,14 @@ int m_main_cursor;
void M_Menu_Main_f (void)
{
/*
if (key_dest != key_menu)
{
m_save_demonum = cls.demonum;
cls.demonum = -1;
}
key_dest = key_menu;
*/
m_state = m_main;
m_entersound = true;
}
@ -333,6 +337,7 @@ void M_Main_Draw (void)
void M_Main_Key (int key)
{
/*
switch (key)
{
case K_ESCAPE:
@ -381,6 +386,7 @@ void M_Main_Key (int key)
break;
}
}
*/
}
@ -395,7 +401,9 @@ int options_cursor;
void M_Menu_Options_f (void)
{
/*
key_dest = key_menu;
*/
m_state = m_options;
m_entersound = true;
}
@ -638,7 +646,7 @@ void M_Options_Key (int k)
//=============================================================================
/* KEYS MENU */
char *bindnames[][2] =
static char *bindnames[][2] =
{
{"+attack", "attack"},
{"impulse 10", "change weapon"},
@ -667,7 +675,7 @@ int bind_grab;
void M_Menu_Keys_f (void)
{
key_dest = key_menu;
//key_dest = key_menu;
m_state = m_keys;
m_entersound = true;
}
@ -676,14 +684,15 @@ void M_Menu_Keys_f (void)
void M_FindKeysForCommand (char *command, int *twokeys)
{
int count;
int j;
//int j;
int l;
char *b;
//char *b;
twokeys[0] = twokeys[1] = -1;
l = strlen(command);
count = 0;
/*
for (j=0 ; j<256 ; j++)
{
b = keybindings[j];
@ -697,10 +706,12 @@ void M_FindKeysForCommand (char *command, int *twokeys)
break;
}
}
*/
}
void M_UnbindCommand (char *command)
{
/*
int j;
int l;
char *b;
@ -715,6 +726,7 @@ void M_UnbindCommand (char *command)
if (!strncmp (b, command, l) )
Key_SetBinding (j, "");
}
*/
}
@ -834,7 +846,7 @@ void M_Keys_Key (int k)
void M_Menu_Video_f (void)
{
key_dest = key_menu;
//key_dest = key_menu;
m_state = m_video;
m_entersound = true;
}
@ -860,7 +872,7 @@ int help_page;
void M_Menu_Help_f (void)
{
key_dest = key_menu;
//key_dest = key_menu;
m_state = m_help;
m_entersound = true;
help_page = 0;
@ -954,8 +966,10 @@ void M_Menu_Quit_f (void)
{
if (m_state == m_quit)
return;
/*
wasInMenus = (key_dest == key_menu);
key_dest = key_menu;
*/
m_quit_prevstate = m_state;
m_state = m_quit;
m_entersound = true;
@ -977,14 +991,16 @@ void M_Quit_Key (int key)
}
else
{
/*
key_dest = key_game;
m_state = m_none;
*/
}
break;
case 'Y':
case 'y':
key_dest = key_console;
//key_dest = key_console;
CL_Disconnect ();
Sys_Quit ();
break;
@ -1030,7 +1046,7 @@ int m_multip_maxs=10;
int m_multip_horiz;
void M_Menu_MultiPlayer_f (void) {
key_dest = key_menu;
//key_dest = key_menu;
m_entersound = true;
m_state = m_multiplayer;
m_multip_horiz = 0;
@ -1192,7 +1208,7 @@ qboolean sedit_state;
void M_Menu_SEdit_f (void) {
server_entry_t *c;
key_dest = key_menu;
//key_dest = key_menu;
m_entersound = true;
m_state = m_sedit;
sedit_state = false;
@ -1380,7 +1396,7 @@ void M_Init (void)
void M_Draw (void)
{
if (m_state == m_none || key_dest != key_menu)
//if (m_state == m_none || key_dest != key_menu)
return;
if (!m_recursiveDraw)

61
source/wtoi.c Normal file
View file

@ -0,0 +1,61 @@
/*
wtoi.c
Word to int, int to word conversion
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id$
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <string.h>
#include "wtoi.h"
char *
WIC_IntToStr (int needle, wic_t *haystack)
{
char *result = NULL;
for (; haystack->name != NULL; haystack++) {
if (needle == haystack->num) {
result = haystack->name;
}
}
return result;
}
int
WIC_StrToInt (char *needle, wic_t *haystack)
{
int result = -1;
for (; haystack->name != NULL; haystack++) {
if (!strcasecmp(needle, haystack->name)) {
result = haystack->num;
}
}
return result;
}