/*
================
Message_Key
In game talk message
================
*/
void Message_Key( int key ) {
char buffer[MAX_STRING_CHARS];
if (key == K_ESCAPE) {
Key_SetCatcher( Key_GetCatcher( ) & ~KEYCATCH_MESSAGE );
Field_Clear( &chatField );
return;
}
if ( key == K_ENTER || key == K_KP_ENTER )
{
if ( chatField.buffer[0] && cls.state == CA_ACTIVE ) {
if (chat_playerNum != -1 )
Com_sprintf( buffer, sizeof( buffer ), "tell %i \"%s\"\n", chat_playerNum, chatField.buffer );
else if (chat_team)
Com_sprintf( buffer, sizeof( buffer ), "say_team \"%s\"\n", chatField.buffer );
else
Com_sprintf( buffer, sizeof( buffer ), "say \"%s\"\n", chatField.buffer );
CL_AddReliableCommand( buffer, qfalse );
}
Key_SetCatcher( Key_GetCatcher( ) & ~KEYCATCH_MESSAGE );
Field_Clear( &chatField );
return;
}
Field_KeyDownEvent( &chatField, key );
}
/*
================
Con_Init
================
*/
void Con_Init (void) {
int i;
con_notifytime = Cvar_Get ("con_notifytime", "3", 0);
con_conspeed = Cvar_Get ("scr_conspeed", "3", 0);
Cvar_CheckRange (con_conspeed, 1.0f, 100.0f, qfalse);
con_opacity = Cvar_Get ("con_opacity", "1.0", CVAR_ARCHIVE);
con_autoclear = Cvar_Get ("con_autoclear", "1", CVAR_ARCHIVE);
Field_Clear( &g_consoleField );
g_consoleField.widthInChars = g_console_field_width;
for ( i = 0 ; i < COMMAND_HISTORY ; i++ ) {
Field_Clear( &historyEditLines[i] );
historyEditLines[i].widthInChars = g_console_field_width;
}
Cmd_AddCommand( "toggleconsole", Con_ToggleConsole_f );
Cmd_AddCommand( "togglemenu", Con_ToggleMenu_f );
Cmd_AddCommand( "messagemode", Con_MessageMode_f );
Cmd_AddCommand( "messagemode2", Con_MessageMode2_f );
Cmd_AddCommand( "messagemode3", Con_MessageMode3_f );
Cmd_AddCommand( "messagemode4", Con_MessageMode4_f );
Cmd_AddCommand( "clear", Con_Clear_f );
Cmd_AddCommand( "condump", Con_Dump_f );
Cmd_SetCommandCompletionFunc( "condump", Cmd_CompleteTxtName );
}
void CG_MessageModeTeam( void ) {
chatActive = qtrue;
chat_team = qtrue;
Field_Clear( &chatField );
chatField.widthInChars = 25;
trap->Key_SetCatcher( trap->Key_GetCatcher() ^ KEYCATCH_CGAME );
}
/*
==================
CON_Init
Initialize the console input (tty mode if possible)
==================
*/
void CON_Init( void )
{
struct termios tc;
qboolean stdinIsATTY;
const char* term = getenv( "TERM" );
// If the process is backgrounded (running non interactively)
// then SIGTTIN or SIGTOU is emitted, if not caught, turns into a SIGSTP
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
// If SIGCONT is received, reinitialize console
signal(SIGCONT, CON_SigCont);
// Make stdin reads non-blocking
fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL, 0) | O_NONBLOCK );
stdinIsATTY = _isatty( STDIN_FILENO ) && !( term && ( !strcmp( term, "raw" ) || !strcmp( term, "dumb" ) ) );
if (!stdinIsATTY)
{
Com_Printf("tty console mode disabled\n");
ttycon_on = qfalse;
stdin_active = qtrue;
return;
}
Field_Clear(&TTY_con);
tcgetattr (STDIN_FILENO, &TTY_tc);
TTY_erase = TTY_tc.c_cc[VERASE];
TTY_eof = TTY_tc.c_cc[VEOF];
tc = TTY_tc;
/*
ECHO: don't echo input characters
ICANON: enable canonical mode. This enables the special
characters EOF, EOL, EOL2, ERASE, KILL, REPRINT,
STATUS, and WERASE, and buffers by lines.
ISIG: when any of the characters INTR, QUIT, SUSP, or
DSUSP are received, generate the corresponding sig
nal
*/
tc.c_lflag &= ~(ECHO | ICANON);
/*
ISTRIP strip off bit 8
INPCK enable input parity checking
*/
tc.c_iflag &= ~(ISTRIP | INPCK);
tc.c_cc[VMIN] = 1;
tc.c_cc[VTIME] = 0;
tcsetattr (STDIN_FILENO, TCSADRAIN, &tc);
ttycon_on = qtrue;
com_ansiColor = Cvar_RegisterBool("ttycon_ansiColor", qtrue, CVAR_ARCHIVE, "Use ansi colors for sysconsole output");
}
void CG_ChatboxHistoryDn( void ) {
// Com_Printf( "History down\n" );
if ( currentHistory )
currentHistory = currentHistory->prev;
if ( currentHistory )
{
Q_strncpyz( chatField.buffer, currentHistory->message, sizeof( chatField.buffer ) );
chatField.cursor = strlen( chatField.buffer );
}
else
Field_Clear( &chatField );
}
/*
==================
CON_Init
Initialize the console input (tty mode if possible)
==================
*/
void CON_Init( void )
{
struct termios tc;
// If the process is backgrounded (running non interactively)
// then SIGTTIN or SIGTOU is emitted, if not caught, turns into a SIGSTP
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
// Make stdin reads non-blocking
fcntl( 0, F_SETFL, fcntl( 0, F_GETFL, 0 ) | O_NONBLOCK );
if (isatty(STDIN_FILENO)!=1)
{
Com_Printf( "stdin is not a tty, tty console mode disabled\n");
ttycon_on = qfalse;
return;
}
Field_Clear(&TTY_con);
tcgetattr (0, &TTY_tc);
TTY_erase = TTY_tc.c_cc[VERASE];
TTY_eof = TTY_tc.c_cc[VEOF];
tc = TTY_tc;
/*
ECHO: don't echo input characters
ICANON: enable canonical mode. This enables the special
characters EOF, EOL, EOL2, ERASE, KILL, REPRINT,
STATUS, and WERASE, and buffers by lines.
ISIG: when any of the characters INTR, QUIT, SUSP, or
DSUSP are received, generate the corresponding sig
nal
*/
tc.c_lflag &= ~(ECHO | ICANON);
/*
ISTRIP strip off bit 8
INPCK enable input parity checking
*/
tc.c_iflag &= ~(ISTRIP | INPCK);
tc.c_cc[VMIN] = 1;
tc.c_cc[VTIME] = 0;
tcsetattr (0, TCSADRAIN, &tc);
ttycon_on = qtrue;
// open named pipe
Com_Printf("Opening pipe...\n");
urtpipe_fd = open(CON_NAMED_PIPE_NAME, O_RDONLY | O_NONBLOCK);
Com_Printf("pipe fd = %d\n", urtpipe_fd);
//fcntl( urtpipe_fd, F_SETFL, fcntl( 0, F_GETFL, 0 ) | O_NONBLOCK );
}
void Con_Close( void )
{
if ( !com_cl_running->integer )
{
return;
}
Field_Clear( &g_consoleField );
Con_ClearNotify();
cls.keyCatchers &= ~KEYCATCH_CONSOLE;
con.finalFrac = 0; // none visible
con.displayFrac = 0;
}
/*
==================
Hist_Prev
==================
*/
void Hist_Prev( void )
{
if (hist_current == hist_head)
return;
hist_current = (hist_current + CON_HISTORY - 1) % CON_HISTORY;
CON_Hide();
Field_Clear(&TTY_con);
memcpy(TTY_con.buffer, ttyEditLines[hist_current], MAX_EDIT_LINE);
TTY_con.cursor = strlen(TTY_con.buffer);
CON_Show();
}
/*
==================
CON_Init
Initialize the console input (tty mode if possible)
==================
*/
void CON_Init(void)
{
struct termios tc;
// If the process is backgrounded (running non interactively)
// then SIGTTIN or SIGTOU is emitted, if not caught, turns into a SIGSTP
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
// If SIGCONT is received, reinitialize console
signal(SIGCONT, CON_SigCont);
// Make stdin reads non-blocking
fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL, 0) | O_NONBLOCK);
if(!stdinIsATTY)
{
Com_Printf("tty console mode disabled\n");
ttycon_on = qfalse;
stdin_active = qtrue;
return;
}
Field_Clear(&TTY_con);
tcgetattr(STDIN_FILENO, &TTY_tc);
TTY_erase = TTY_tc.c_cc[VERASE];
TTY_eof = TTY_tc.c_cc[VEOF];
tc = TTY_tc;
/*
ECHO: don't echo input characters
ICANON: enable canonical mode. This enables the special
characters EOF, EOL, EOL2, ERASE, KILL, REPRINT,
STATUS, and WERASE, and buffers by lines.
ISIG: when any of the characters INTR, QUIT, SUSP, or
DSUSP are received, generate the corresponding signal
*/
tc.c_lflag &= ~(ECHO | ICANON);
/*
ISTRIP strip off bit 8
INPCK enable input parity checking
*/
tc.c_iflag &= ~(ISTRIP | INPCK);
tc.c_cc[VMIN] = 1;
tc.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSADRAIN, &tc);
ttycon_on = qtrue;
ttycon_hide = 1; // Mark as hidden, so prompt is shown in CON_Show
CON_Show();
}
/*
================
Con_ToggleConsole_f
================
*/
void Con_ToggleConsole_f (void) {
// closing a full screen console restarts the demo loop
if ( cls.state == CA_DISCONNECTED && Key_GetCatcher( ) == KEYCATCH_CONSOLE ) {
CL_StartDemoLoop();
return;
}
if( con_autoclear->integer )
Field_Clear( &g_consoleField );
g_consoleField.widthInChars = g_console_field_width;
Con_ClearNotify ();
Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_CONSOLE );
}
void Con_Close( void )
{
if ( !com_cl_running->integer )
{
return;
}
Field_Clear( &g_consoleField );
cls.keyCatchers &= ~KEYCATCH_CONSOLE;
consoleState.isOpened = qfalse;
//instant disappearance, if we need it for situations where this is not called by the user
consoleState.currentAnimationFraction = 0;
}
// initialize the console input (tty mode if wanted and possible)
void Sys_ConsoleInputInit()
{
struct termios tc;
// TTimo
// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=390
// ttycon 0 or 1, if the process is backgrounded (running non interactively)
// then SIGTTIN or SIGTOU is emitted, if not catched, turns into a SIGSTP
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
// FIXME TTimo initialize this in Sys_Init or something?
ttycon = Cvar_Get("ttycon", "1", 0);
if (ttycon && ttycon->value)
{
if (isatty(STDIN_FILENO)!=1)
{
Com_Printf("stdin is not a tty, tty console mode failed\n");
Cvar_Set("ttycon", "0");
ttycon_on = qfalse;
return;
}
Com_Printf("Started tty console (use +set ttycon 0 to disable)\n");
Field_Clear(&tty_con);
tcgetattr (0, &tty_tc);
tty_erase = tty_tc.c_cc[VERASE];
tty_eof = tty_tc.c_cc[VEOF];
tc = tty_tc;
/*
ECHO: don't echo input characters
ICANON: enable canonical mode. This enables the special
characters EOF, EOL, EOL2, ERASE, KILL, REPRINT,
STATUS, and WERASE, and buffers by lines.
ISIG: when any of the characters INTR, QUIT, SUSP, or
DSUSP are received, generate the corresponding sig-
nal
*/
tc.c_lflag &= ~(ECHO | ICANON);
/*
ISTRIP strip off bit 8
INPCK enable input parity checking
*/
tc.c_iflag &= ~(ISTRIP | INPCK);
tc.c_cc[VMIN] = 1;
tc.c_cc[VTIME] = 0;
tcsetattr (0, TCSADRAIN, &tc);
ttycon_on = qtrue;
} else
ttycon_on = qfalse;
}
/*
==================
Hist_Next
==================
*/
void Hist_Next( void )
{
if (hist_current == hist_tail)
return;
hist_current = (hist_current + 1) % CON_HISTORY;
CON_Hide();
Field_Clear(&TTY_con);
if (hist_current != hist_tail)
memcpy(TTY_con.buffer, ttyEditLines[hist_current], MAX_EDIT_LINE);
TTY_con.cursor = strlen(TTY_con.buffer);
CON_Show();
}
/*
================
Con_ToggleConsole_f
================
*/
void Con_ToggleConsole_f( void )
{
// ydnar: persistent console input is more useful
if ( con_autoclear->integer )
{
Field_Clear( &g_consoleField );
}
g_consoleField.widthInChars = g_console_field_width;
if (consoleState.isOpened) {
cls.keyCatchers &= ~KEYCATCH_CONSOLE;
} else {
cls.keyCatchers |= KEYCATCH_CONSOLE;
}
}
/*
================
Con_ToggleConsole_f
================
*/
void Con_ToggleConsole_f( void )
{
con.acLength = 0;
if ( con_restricted->integer && ( !keys[ K_CTRL ].down || !keys[ K_SHIFT ].down ) )
{
return;
}
// ydnar: persistent console input is more useful
// Arnout: added cvar
if ( con_autoclear->integer )
{
Field_Clear( &g_consoleField );
}
g_consoleField.widthInChars = g_console_field_width;
Con_ClearNotify();
// ydnar: multiple console size support
if ( cls.keyCatchers & KEYCATCH_CONSOLE )
{
cls.keyCatchers &= ~KEYCATCH_CONSOLE;
con.desiredFrac = 0.0;
}
else
{
cls.keyCatchers |= KEYCATCH_CONSOLE;
// short console
if ( keys[ K_CTRL ].down )
{
con.desiredFrac = ( 5.0 * SMALLCHAR_HEIGHT ) / cls.glconfig.vidHeight;
}
// full console
else if ( keys[ K_ALT ].down )
{
con.desiredFrac = 1.0;
}
// half-screen console
else
{
con.desiredFrac = 0.5;
}
}
}
/*
================
Con_Init
================
*/
void Con_Init( void )
{
con_notifytime = Cvar_Get( "con_notifytime", "7", 0 ); // JPW NERVE increased per id req for obits
con_conspeed = Cvar_Get( "scr_conspeed", "3", 0 );
con_debug = Cvar_Get( "con_debug", "0", CVAR_ARCHIVE ); //----(SA) added
con_autoclear = Cvar_Get( "con_autoclear", "1", CVAR_ARCHIVE );
con_restricted = Cvar_Get( "con_restricted", "0", CVAR_INIT ); // DHM - Nerve
// Defines cvar for color and alpha for console/bar under console
scr_conUseShader = Cvar_Get( "scr_conUseShader", "0", CVAR_ARCHIVE );
scr_conColorAlpha = Cvar_Get( "scr_conColorAlpha", "0.5", CVAR_ARCHIVE );
scr_conColorRed = Cvar_Get( "scr_conColorRed", "0", CVAR_ARCHIVE );
scr_conColorBlue = Cvar_Get( "scr_conColorBlue", "0.3", CVAR_ARCHIVE );
scr_conColorGreen = Cvar_Get( "scr_conColorGreen", "0.23", CVAR_ARCHIVE );
scr_conUseOld = Cvar_Get( "scr_conUseOld", "0", CVAR_ARCHIVE | CVAR_LATCH );
scr_conBarHeight = Cvar_Get( "scr_conBarHeight", "2", CVAR_ARCHIVE );
scr_conBarColorAlpha = Cvar_Get( "scr_conBarColorAlpha", "0.3", CVAR_ARCHIVE );
scr_conBarColorRed = Cvar_Get( "scr_conBarColorRed", "1", CVAR_ARCHIVE );
scr_conBarColorBlue = Cvar_Get( "scr_conBarColorBlue", "1", CVAR_ARCHIVE );
scr_conBarColorGreen = Cvar_Get( "scr_conBarColorGreen", "1", CVAR_ARCHIVE );
scr_conHeight = Cvar_Get( "scr_conHeight", "50", CVAR_ARCHIVE );
scr_conBarSize = Cvar_Get( "scr_conBarSize", "2", CVAR_ARCHIVE );
// Done defining cvars for console colors
Field_Clear( &g_consoleField );
g_consoleField.widthInChars = g_console_field_width;
Cmd_AddCommand( "toggleConsole", Con_ToggleConsole_f );
Cmd_AddCommand( "clear", Con_Clear_f );
Cmd_AddCommand( "condump", Con_Dump_f );
Cmd_AddCommand( "search", Con_Search_f );
Cmd_AddCommand( "searchDown", Con_Search_f );
Cmd_AddCommand( "grep", Con_Grep_f );
}
void KG_GenerateEcdsaParameters(const char* encryptiontemplate, char* private_text, char* basepoint_text, char* public_x_text, char* public_y_text)
{
EC_PARAMETER Base;
EC_KEYPAIR Signer;
ECC_POINT temp;
char encryption_template[512];
char rndinitstring[1024];
unsigned long i[4];
unsigned int basepointinit;
BigInt test = BigInt_Create();
BigInt secretkeyhash = BigInt_Create();
BigInt prime_order = BigInt_Create();
CookText(encryption_template, encryptiontemplate);
md5(i, encryption_template, strlen(encryption_template));
basepointinit = i[0];
sprintf(basepoint_text, "%u", basepointinit);
ECC_InitializeTable();
BigInt_FromString(ECC_PRIMEORDER, 10, prime_order);
BigIntToField(prime_order, &Base.pnt_order);
Field_Clear(&Base.cofactor);
Base.cofactor.e[ECC_NUMWORD] = 2;
Base.crv.form = 1;
Field_Set(&Base.crv.a2);
Field_Set(&Base.crv.a6);
InitRandomGenerator(basepointinit);
ECC_RandomPoint(&temp, &Base.crv);
ECC_PointDouble(&temp, &Base.pnt, &Base.crv);
strcpy(rndinitstring, encryption_template);
strcat(rndinitstring, "PVTKEY");
BigInt_Hash(rndinitstring, strlen(rndinitstring), secretkeyhash);
ECC_KeyGenerationPrimitive(&Base, &Signer, secretkeyhash);
FieldToBigInt(&Signer.pblc_key.x, test);
BigInt_ToString(test, 10, public_x_text);
FieldToBigInt(&Signer.pblc_key.y, test);
BigInt_ToString(test, 10, public_y_text);
FieldToBigInt(&Signer.prvt_key, test);
BigInt_ToString(test, 10, private_text);
BigInt_Destroy(test);
BigInt_Destroy(secretkeyhash);
BigInt_Destroy(prime_order);
}
/*
================
Con_Init
================
*/
void Con_Init( void )
{
con_animationSpeed = Cvar_Get( "con_animationSpeed", "3", 0 );
con_animationType = Cvar_Get( "con_animationType", "2", 0 );
con_autoclear = Cvar_Get( "con_autoclear", "1", CVAR_ARCHIVE );
con_scrollLock = Cvar_Get( "con_scrollLock", "2", CVAR_ARCHIVE );
con_prompt = Cvar_Get( "con_prompt", "^3->", CVAR_ARCHIVE );
con_height = Cvar_Get( "con_height", "55", CVAR_ARCHIVE );
con_colorRed = Cvar_Get( "con_colorRed", "0", CVAR_ARCHIVE );
con_colorBlue = Cvar_Get( "con_colorBlue", "0.3", CVAR_ARCHIVE );
con_colorGreen = Cvar_Get( "con_colorGreen", "0.18", CVAR_ARCHIVE );
con_colorAlpha = Cvar_Get( "con_colorAlpha", "0.5", CVAR_ARCHIVE );
con_margin = Cvar_Get( "con_margin", "10", CVAR_ARCHIVE );
con_horizontalPadding = Cvar_Get( "con_horizontalPadding", "0", CVAR_ARCHIVE );
con_borderWidth = Cvar_Get( "con_borderWidth", "1", CVAR_ARCHIVE );
con_borderColorRed = Cvar_Get( "con_borderColorRed", "1", CVAR_ARCHIVE );
con_borderColorBlue = Cvar_Get( "con_borderColorBlue", "1", CVAR_ARCHIVE );
con_borderColorGreen = Cvar_Get( "con_borderColorGreen", "1", CVAR_ARCHIVE );
con_borderColorAlpha = Cvar_Get( "con_borderColorAlpha", "0.2", CVAR_ARCHIVE );
con_debug = Cvar_Get( "con_debug", "0", 0 );
// Done defining cvars for console colors
Field_Clear( &g_consoleField );
g_consoleField.widthInChars = g_console_field_width;
Cmd_AddCommand( "toggleConsole", Con_ToggleConsole_f );
Cmd_AddCommand( "toggleMenu", Con_ToggleMenu_f );
Cmd_AddCommand( "clear", Con_Clear_f );
Cmd_AddCommand( "condump", Con_Dump_f );
Cmd_AddCommand( "search", Con_Search_f );
Cmd_AddCommand( "searchDown", Con_Search_f );
Cmd_AddCommand( "grep", Con_Grep_f );
}
/*
** Sys_CreateConsole
*/
void Sys_CreateConsole( void )
{
HDC hDC;
WNDCLASS wc;
RECT rect;
const char *DEDCLASS = "JAMP WinConsole";
int nHeight;
int swidth, sheight;
DWORD DEDSTYLE = WS_POPUPWINDOW | WS_CAPTION | WS_MINIMIZEBOX;
memset( &wc, 0, sizeof( wc ) );
wc.style = 0;
wc.lpfnWndProc = (WNDPROC) ConWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = g_wv.hInstance;
wc.hIcon = LoadIcon( g_wv.hInstance, MAKEINTRESOURCE(IDI_ICON1));
wc.hCursor = LoadCursor (NULL,IDC_ARROW);
wc.hbrBackground = (HBRUSH)COLOR_INACTIVEBORDER;
wc.lpszMenuName = 0;
wc.lpszClassName = DEDCLASS;
if ( !RegisterClass (&wc) ) {
return;
}
rect.left = 0;
rect.right = 600;
rect.top = 0;
rect.bottom = 450;
AdjustWindowRect( &rect, DEDSTYLE, FALSE );
hDC = GetDC( GetDesktopWindow() );
swidth = GetDeviceCaps( hDC, HORZRES );
sheight = GetDeviceCaps( hDC, VERTRES );
ReleaseDC( GetDesktopWindow(), hDC );
s_wcd.windowWidth = rect.right - rect.left + 1;
s_wcd.windowHeight = rect.bottom - rect.top + 1;
s_wcd.hWnd = CreateWindowEx( 0,
DEDCLASS,
CLIENT_CONSOLE_TITLE,
DEDSTYLE,
( swidth - 600 ) / 2, ( sheight - 450 ) / 2 , rect.right - rect.left + 1, rect.bottom - rect.top + 1,
NULL,
NULL,
g_wv.hInstance,
NULL );
if ( s_wcd.hWnd == NULL )
{
return;
}
//
// create fonts
//
hDC = GetDC( s_wcd.hWnd );
nHeight = -MulDiv( 8, GetDeviceCaps( hDC, LOGPIXELSY), 72);
s_wcd.hfBufferFont = CreateFont( nHeight,
0,
0,
0,
FW_LIGHT,
0,
0,
0,
DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY,
FF_MODERN | FIXED_PITCH,
"Courier New" );
ReleaseDC( s_wcd.hWnd, hDC );
//
// create the input line
//
s_wcd.hwndInputLine = CreateWindow( "edit", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER |
ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP,
6, 400, s_wcd.windowWidth-20, 20,
s_wcd.hWnd,
( HMENU ) INPUT_ID, // child window ID
g_wv.hInstance, NULL );
//
// create the buttons
//
s_wcd.hwndButtonCopy = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON | WS_TABSTOP,
5, 425, 72, 24,
s_wcd.hWnd,
( HMENU ) COPY_ID, // child window ID
g_wv.hInstance, NULL );
SendMessage( s_wcd.hwndButtonCopy, WM_SETTEXT, 0, ( LPARAM ) "Copy" );
s_wcd.hwndButtonClear = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON | WS_TABSTOP,
82, 425, 72, 24,
s_wcd.hWnd,
( HMENU ) CLEAR_ID, // child window ID
g_wv.hInstance, NULL );
SendMessage( s_wcd.hwndButtonClear, WM_SETTEXT, 0, ( LPARAM ) "Clear" );
s_wcd.hwndButtonQuit = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON | WS_TABSTOP,
s_wcd.windowWidth-92, 425, 72, 24,
s_wcd.hWnd,
( HMENU ) QUIT_ID, // child window ID
g_wv.hInstance, NULL );
SendMessage( s_wcd.hwndButtonQuit, WM_SETTEXT, 0, ( LPARAM ) "Quit" );
//
// create the scrollbuffer
//
s_wcd.hwndBuffer = CreateWindow( "edit", NULL, WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_BORDER |
ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY | WS_TABSTOP,
6, 40, s_wcd.windowWidth-20, 354,
s_wcd.hWnd,
( HMENU ) EDIT_ID, // child window ID
g_wv.hInstance, NULL );
SendMessage( s_wcd.hwndBuffer, WM_SETFONT, ( WPARAM ) s_wcd.hfBufferFont, 0 );
s_wcd.SysInputLineWndProc = ( WNDPROC ) SetWindowLongPtr( s_wcd.hwndInputLine, GWLP_WNDPROC, ( LONG_PTR ) InputLineWndProc );
SendMessage( s_wcd.hwndInputLine, WM_SETFONT, ( WPARAM ) s_wcd.hfBufferFont, 0 );
SendMessage( s_wcd.hwndBuffer, EM_LIMITTEXT, ( WPARAM ) 0x7fff, 0 );
ShowWindow( s_wcd.hWnd, SW_SHOWDEFAULT);
UpdateWindow( s_wcd.hWnd );
SetForegroundWindow( s_wcd.hWnd );
SetFocus( s_wcd.hwndInputLine );
Field_Clear( &s_wcd.g_consoleField );
s_wcd.g_consoleField.widthInChars = g_console_field_width;
for ( int i = 0 ; i < COMMAND_HISTORY ; i++ ) {
Field_Clear( &s_wcd.historyEditLines[i] );
s_wcd.historyEditLines[i].widthInChars = g_console_field_width;
}
s_wcd.visLevel = 1;
}
/*
==================
CON_Input
==================
*/
char *CON_Input( void )
{
// we use this when sending back commands
static char text[MAX_EDIT_LINE];
int avail;
char key;
field_t *history;
size_t size;
if(ttycon_on)
{
avail = read(STDIN_FILENO, &key, 1);
if (avail != -1)
{
// we have something
// backspace?
// NOTE TTimo testing a lot of values .. seems it's the only way to get it to work everywhere
if ((key == TTY_erase) || (key == 127) || (key == 8))
{
if (TTY_con.cursor > 0)
{
TTY_con.cursor--;
TTY_con.buffer[TTY_con.cursor] = '\0';
CON_Back();
}
return NULL;
}
// check if this is a control char
if ((key) && (key) < ' ')
{
if (key == '\n')
{
// push it in history
Hist_Add(&TTY_con);
Q_strncpyz(text, TTY_con.buffer, sizeof(text));
Field_Clear(&TTY_con);
key = '\n';
size = write(1, &key, 1);
size = write( 1, "]", 1 );
return text;
}
if (key == '\t')
{
CON_Hide();
Field_AutoComplete( &TTY_con );
CON_Show();
return NULL;
}
avail = read(STDIN_FILENO, &key, 1);
if (avail != -1)
{
// VT 100 keys
if (key == '[' || key == 'O')
{
avail = read(STDIN_FILENO, &key, 1);
if (avail != -1)
{
switch (key)
{
case 'A':
history = Hist_Prev();
if (history)
{
CON_Hide();
TTY_con = *history;
CON_Show();
}
CON_FlushIn();
return NULL;
break;
case 'B':
history = Hist_Next();
CON_Hide();
if (history)
{
TTY_con = *history;
} else
{
Field_Clear(&TTY_con);
}
CON_Show();
CON_FlushIn();
return NULL;
break;
case 'C':
return NULL;
case 'D':
return NULL;
}
}
}
}
Com_DPrintf("droping ISCTL sequence: %d, TTY_erase: %d\n", key, TTY_erase);
CON_FlushIn();
return NULL;
}
if (TTY_con.cursor >= sizeof(text) - 1)
return NULL;
// push regular character
TTY_con.buffer[TTY_con.cursor] = key;
TTY_con.cursor++;
// print the current line (this is differential)
size = write(STDOUT_FILENO, &key, 1);
}
return NULL;
}
else if (stdin_active)
{
int len;
fd_set fdset;
struct timeval timeout;
FD_ZERO(&fdset);
FD_SET(STDIN_FILENO, &fdset); // stdin
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if(select (STDIN_FILENO + 1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(STDIN_FILENO, &fdset))
return NULL;
len = read(STDIN_FILENO, text, sizeof(text));
if (len == 0)
{ // eof!
stdin_active = qfalse;
return NULL;
}
if (len < 1)
return NULL;
text[len-1] = 0; // rip off the /n and terminate
return text;
}
return NULL;
}
/*
==================
CON_Input
==================
*/
char *CON_Input(void)
{
// we use this when sending back commands
static char text[MAX_EDIT_LINE];
int avail;
char key;
field_t *history;
size_t UNUSED_VAR size;
if(ttycon_on)
{
avail = read(STDIN_FILENO, &key, 1);
if(avail != -1)
{
// we have something
// backspace?
// NOTE TTimo testing a lot of values .. seems it's the only way to get it to work everywhere
if((key == TTY_erase) || (key == 127) || (key == 8))
{
if(TTY_con.cursor > 0)
{
TTY_con.cursor--;
TTY_con.buffer[TTY_con.cursor] = '\0';
CON_Back();
}
return NULL;
}
// check if this is a control char
if((key) && (key) < ' ')
{
if(key == '\n')
{
#ifndef DEDICATED
// if not in the game explicitly prepend a slash if needed
if (clc.state != CA_ACTIVE && TTY_con.cursor &&
TTY_con.buffer[0] != '/' && TTY_con.buffer[0] != '\\')
{
memmove(TTY_con.buffer + 1, TTY_con.buffer, sizeof(TTY_con.buffer) - 1);
TTY_con.buffer[0] = '\\';
TTY_con.cursor++;
}
if (TTY_con.buffer[0] == '/' || TTY_con.buffer[0] == '\\') {
Q_strncpyz(text, TTY_con.buffer + 1, sizeof(text));
} else if (TTY_con.cursor) {
Com_sprintf(text, sizeof(text), "cmd say %s", TTY_con.buffer);
} else {
text[0] = '\0';
}
// push it in history
Hist_Add(&TTY_con);
CON_Hide();
Com_Printf("%s%s\n", TTY_CONSOLE_PROMPT, TTY_con.buffer);
Field_Clear(&TTY_con);
CON_Show();
#else
// push it in history
Hist_Add(&TTY_con);
Q_strncpyz(text, TTY_con.buffer, sizeof(text));
Field_Clear(&TTY_con);
key = '\n';
size = write(STDOUT_FILENO, &key, 1);
size = write(STDOUT_FILENO, TTY_CONSOLE_PROMPT, strlen(TTY_CONSOLE_PROMPT));
#endif
return text;
}
if(key == '\t')
{
CON_Hide();
Field_AutoComplete(&TTY_con);
CON_Show();
return NULL;
}
avail = read(STDIN_FILENO, &key, 1);
if(avail != -1)
{
// VT 100 keys
if(key == '[' || key == 'O')
{
avail = read(STDIN_FILENO, &key, 1);
if(avail != -1)
{
switch (key)
{
case 'A':
history = Hist_Prev();
if(history)
{
CON_Hide();
TTY_con = *history;
CON_Show();
}
CON_FlushIn();
return NULL;
break;
case 'B':
history = Hist_Next();
CON_Hide();
if(history)
{
TTY_con = *history;
}
else
{
Field_Clear(&TTY_con);
}
CON_Show();
CON_FlushIn();
return NULL;
break;
case 'C':
return NULL;
case 'D':
return NULL;
}
}
}
}
Com_DPrintf("droping ISCTL sequence: %d, TTY_erase: %d\n", key, TTY_erase);
CON_FlushIn();
return NULL;
}
if(TTY_con.cursor >= sizeof(text) - 1)
return NULL;
// push regular character
TTY_con.buffer[TTY_con.cursor] = key;
TTY_con.cursor++; // next char will always be '\0'
// print the current line (this is differential)
size = write(STDOUT_FILENO, &key, 1);
}
return NULL;
}
else if(stdin_active)
{
int len;
fd_set fdset;
struct timeval timeout;
FD_ZERO(&fdset);
FD_SET(STDIN_FILENO, &fdset); // stdin
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if(select(STDIN_FILENO + 1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(STDIN_FILENO, &fdset))
return NULL;
len = read(STDIN_FILENO, text, sizeof(text));
if(len == 0)
{ // eof!
stdin_active = qfalse;
return NULL;
}
if(len < 1)
return NULL;
text[len - 1] = 0; // rip off the /n and terminate
return text;
}
return NULL;
}
static LRESULT CALLBACK InputLineWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
switch ( uMsg )
{
case WM_KILLFOCUS:
if ( ( HWND ) wParam == s_wcd.hWnd ||
( HWND ) wParam == s_wcd.hwndErrorBox )
{
SetFocus( hWnd );
return 0;
}
break;
case WM_CHAR:
GetWindowText( s_wcd.hwndInputLine, s_wcd.g_consoleField.buffer, sizeof( s_wcd.g_consoleField.buffer ) );
SendMessage( s_wcd.hwndInputLine, EM_GETSEL, (WPARAM) NULL, (LPARAM) &s_wcd.g_consoleField.cursor );
if ( wParam == VK_RETURN )
{
strncat( s_wcd.consoleText, s_wcd.g_consoleField.buffer, sizeof( s_wcd.consoleText ) - strlen( s_wcd.consoleText ) - 5 );
strcat( s_wcd.consoleText, "\n" );
SetWindowText( s_wcd.hwndInputLine, "" );
Sys_Print( va( "%c%s\n", CONSOLE_PROMPT_CHAR, s_wcd.g_consoleField.buffer ) );
// empty lines just scroll the console without adding to history
if ( !s_wcd.g_consoleField.buffer[0] )
return 0;
// copy line to history buffer
s_wcd.historyEditLines[s_wcd.nextHistoryLine % COMMAND_HISTORY] = s_wcd.g_consoleField;
s_wcd.nextHistoryLine++;
s_wcd.historyLine = s_wcd.nextHistoryLine;
Field_Clear( &s_wcd.g_consoleField );
s_wcd.g_consoleField.widthInChars = g_console_field_width;
return 0;
}
if ( wParam == VK_TAB )
{
Field_AutoComplete( &s_wcd.g_consoleField );
SetWindowText( s_wcd.hwndInputLine, s_wcd.g_consoleField.buffer );
SendMessage( s_wcd.hwndInputLine, EM_SETSEL, s_wcd.g_consoleField.cursor, s_wcd.g_consoleField.cursor );
return 0;
}
break;
case WM_KEYDOWN:
// history scrolling
if ( wParam == VK_UP )
{// scroll up: arrow-up
if ( s_wcd.nextHistoryLine - s_wcd.historyLine < COMMAND_HISTORY && s_wcd.historyLine > 0 )
s_wcd.historyLine--;
s_wcd.g_consoleField = s_wcd.historyEditLines[s_wcd.historyLine % COMMAND_HISTORY];
SetWindowText( s_wcd.hwndInputLine, s_wcd.g_consoleField.buffer );
SendMessage( s_wcd.hwndInputLine, EM_SETSEL, s_wcd.g_consoleField.cursor, s_wcd.g_consoleField.cursor );
return 0;
}
if ( wParam == VK_DOWN )
{// scroll down: arrow-down
s_wcd.historyLine++;
if (s_wcd.historyLine >= s_wcd.nextHistoryLine) {
s_wcd.historyLine = s_wcd.nextHistoryLine;
Field_Clear( &s_wcd.g_consoleField );
s_wcd.g_consoleField.widthInChars = g_console_field_width;
SetWindowText( s_wcd.hwndInputLine, s_wcd.g_consoleField.buffer );
SendMessage( s_wcd.hwndInputLine, EM_SETSEL, s_wcd.g_consoleField.cursor, s_wcd.g_consoleField.cursor );
return 0;
}
s_wcd.g_consoleField = s_wcd.historyEditLines[s_wcd.historyLine % COMMAND_HISTORY];
SetWindowText( s_wcd.hwndInputLine, s_wcd.g_consoleField.buffer );
SendMessage( s_wcd.hwndInputLine, EM_SETSEL, s_wcd.g_consoleField.cursor, s_wcd.g_consoleField.cursor );
return 0;
}
break;
}
return CallWindowProc( s_wcd.SysInputLineWndProc, hWnd, uMsg, wParam, lParam );
}
/*
==================
CON_Input
==================
*/
char *CON_Input( void )
{
// we use this when sending back commands
static char text[MAX_EDIT_LINE];
int avail;
char key;
if(ttycon_on)
{
CON_CheckRep();
avail = read(STDIN_FILENO, &key, 1);
if (avail != -1)
{
// we have something
// disable hibernation for ten seconds to workaround console input lagg
svs.hibernation.disableUntil = svs.time + 10000;
// backspace?
// NOTE TTimo testing a lot of values .. seems it's the only way to get it to work everywhere
if ((key == TTY_erase) || (key == 127) || (key == 8))
{
if (TTY_con.cursor > 0)
{
TTY_con.cursor--;
TTY_con.buffer[TTY_con.cursor] = '\0';
CON_Back();
}
return NULL;
}
// check if this is a control char
if ((key) && (key) < ' ')
{
if (key == '\n')
{
#ifndef DEDICATED
if (TTY_con.buffer[0] == '/' || TTY_con.buffer[0] == '\\') {
Q_strncpyz(text, TTY_con.buffer + 1, sizeof(text));
} else if (TTY_con.cursor) {
Q_strncpyz(text, TTY_con.buffer, sizeof(text));
} else {
text[0] = '\0';
}
// push it in history
Hist_Add();
CON_Hide();
Com_Printf("%s%s\n", TTY_CONSOLE_PROMPT, TTY_con.buffer);
Field_Clear(&TTY_con);
CON_Show();
#else
// push it in history
Hist_Add();
Q_strncpyz(text, TTY_con.buffer, sizeof(text));
Field_Clear(&TTY_con);
key = '\n';
write(STDOUT_FILENO, &key, 1);
write(STDOUT_FILENO, TTY_CONSOLE_PROMPT, strlen(TTY_CONSOLE_PROMPT));
#endif
return text;
}
if (key == '\t')
{
CON_Hide();
Field_AutoComplete( &TTY_con );
CON_Show();
return NULL;
}
avail = read(STDIN_FILENO, &key, 1);
if (avail != -1)
{
// VT 100 keys
if (key == '[' || key == 'O')
{
avail = read(STDIN_FILENO, &key, 1);
if (avail != -1)
{
switch (key)
{
case 'A':
Hist_Prev();
CON_FlushIn();
return NULL;
break;
case 'B':
Hist_Next();
CON_FlushIn();
return NULL;
break;
case 'C':
return NULL;
case 'D':
return NULL;
}
}
}
}
Com_DPrintf("droping ISCTL sequence: %d, TTY_erase: %d\n", key, TTY_erase);
CON_FlushIn();
return NULL;
}
if (TTY_con.cursor >= (int)sizeof(text) - 1)
return NULL;
// push regular character
TTY_con.buffer[TTY_con.cursor] = key;
TTY_con.cursor++; // next char will always be '\0'
// print the current line (this is differential)
write(STDOUT_FILENO, &key, 1);
}
return NULL;
}
else if (stdin_active)
{
int len;
fd_set fdset;
struct timeval timeout;
FD_ZERO(&fdset);
FD_SET(STDIN_FILENO, &fdset); // stdin
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if(select (STDIN_FILENO + 1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(STDIN_FILENO, &fdset))
return NULL;
len = read(STDIN_FILENO, text, sizeof(text));
if (len == 0)
{ // eof!
stdin_active = qfalse;
return NULL;
}
if (len < 1)
return NULL;
text[len-1] = 0; // rip off the /n and terminate
return text;
}
return NULL;
}
char *Sys_ConsoleInput(void)
{
// we use this when sending back commands
static char text[256];
int i;
int avail;
char key;
field_t *history;
if (ttycon && ttycon->value)
{
avail = read(0, &key, 1);
if (avail != -1)
{
// we have something
// backspace?
// NOTE TTimo testing a lot of values .. seems it's the only way to get it to work everywhere
if ((key == tty_erase) || (key == 127) || (key == 8))
{
if (tty_con.cursor > 0)
{
tty_con.cursor--;
tty_con.buffer[tty_con.cursor] = '\0';
tty_Back();
}
return NULL;
}
// check if this is a control char
if ((key) && (key) < ' ')
{
if (key == '\n')
{
// push it in history
Hist_Add(&tty_con);
strcpy(text, tty_con.buffer);
Field_Clear(&tty_con);
key = '\n';
write(1, &key, 1);
return text;
}
if (key == '\t')
{
tty_Hide();
Field_CompleteCommand( &tty_con );
// Field_CompleteCommand does weird things to the string, do a cleanup
// it adds a '\' at the beginning of the string
// cursor doesn't reflect actual length of the string that's sent back
tty_con.cursor = strlen(tty_con.buffer);
if (tty_con.cursor>0)
{
if (tty_con.buffer[0] == '\\')
{
for (i=0; i<=tty_con.cursor; i++)
{
tty_con.buffer[i] = tty_con.buffer[i+1];
}
tty_con.cursor--;
}
}
tty_Show();
return NULL;
}
avail = read(0, &key, 1);
if (avail != -1)
{
// VT 100 keys
if (key == '[' || key == 'O')
{
avail = read(0, &key, 1);
if (avail != -1)
{
switch (key)
{
case 'A':
history = Hist_Prev();
if (history)
{
tty_Hide();
tty_con = *history;
tty_Show();
}
tty_FlushIn();
return NULL;
break;
case 'B':
history = Hist_Next();
tty_Hide();
if (history)
{
tty_con = *history;
} else
{
Field_Clear(&tty_con);
}
tty_Show();
tty_FlushIn();
return NULL;
break;
case 'C':
return NULL;
case 'D':
return NULL;
}
}
}
}
Com_DPrintf("droping ISCTL sequence: %d, tty_erase: %d\n", key, tty_erase);
tty_FlushIn();
return NULL;
}
// push regular character
tty_con.buffer[tty_con.cursor] = key;
tty_con.cursor++;
// print the current line (this is differential)
write(1, &key, 1);
}
return NULL;
} else
{
int len;
fd_set fdset;
struct timeval timeout;
if (!com_dedicated || !com_dedicated->value)
return NULL;
if (!stdin_active)
return NULL;
FD_ZERO(&fdset);
FD_SET(0, &fdset); // stdin
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if (select (1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(0, &fdset))
{
return NULL;
}
len = read (0, text, sizeof(text));
if (len == 0)
{ // eof!
stdin_active = qfalse;
return NULL;
}
if (len < 1)
return NULL;
text[len-1] = 0; // rip off the /n and terminate
return text;
}
}
/*
==================
CON_Input
==================
*/
char *CON_Input(void)
{
int chr, num_chars = 0;
static char text[MAX_EDIT_LINE];
static int lasttime = -1;
if (!curses_on)
return CON_Input_tty();
if (com_ansiColor->modified) {
CON_Resize();
com_ansiColor->modified = qfalse;
}
if (Com_RealTime(NULL) != lasttime) {
lasttime = Com_RealTime(NULL);
CON_UpdateClock();
num_chars++;
}
while (1) {
chr = getch();
num_chars++;
// Special characters
switch (chr) {
case ERR:
if (num_chars > 1) {
werase(inputwin);
if (input_field.cursor < input_field.scroll) {
input_field.scroll = input_field.cursor - INPUT_SCROLL;
if (input_field.scroll < 0)
input_field.scroll = 0;
} else if (input_field.cursor >= input_field.scroll + input_field.widthInChars)
input_field.scroll = input_field.cursor - input_field.widthInChars + INPUT_SCROLL;
CON_ColorPrint(inputwin, input_field.buffer + input_field.scroll, qfalse);
#ifdef _WIN32
wrefresh(inputwin); // If this is not done the cursor moves strangely
#else
wnoutrefresh(inputwin);
#endif
CON_UpdateCursor();
doupdate();
}
return NULL;
case '\n':
case '\r':
case KEY_ENTER:
if (!input_field.buffer[0])
continue;
Hist_Add(input_field.buffer);
strcpy(text, input_field.buffer);
Field_Clear(&input_field);
werase(inputwin);
wnoutrefresh(inputwin);
CON_UpdateCursor();
//doupdate();
Com_Printf(PROMPT "^7%s\n", text);
return text;
case '\t':
case KEY_STAB:
Field_AutoComplete(&input_field, PROMPT);
input_field.cursor = strlen(input_field.buffer);
continue;
case '\f':
CON_Resize();
continue;
case KEY_LEFT:
if (input_field.cursor > 0)
input_field.cursor--;
continue;
case KEY_RIGHT:
if (input_field.cursor < strlen(input_field.buffer))
input_field.cursor++;
continue;
case KEY_UP:
Q_strncpyz(input_field.buffer, Hist_Prev(), sizeof(input_field.buffer));
input_field.cursor = strlen(input_field.buffer);
continue;
case KEY_DOWN:
Q_strncpyz(input_field.buffer, Hist_Next(input_field.buffer), sizeof(input_field.buffer));
input_field.cursor = strlen(input_field.buffer);
continue;
case KEY_HOME:
input_field.cursor = 0;
continue;
case KEY_END:
input_field.cursor = strlen(input_field.buffer);
continue;
case KEY_NPAGE:
if (lastline > scrollline + LOG_LINES) {
scrollline += LOG_SCROLL;
if (scrollline + LOG_LINES > lastline)
scrollline = lastline - LOG_LINES;
pnoutrefresh(logwin, scrollline, 0, 2, 1, LOG_LINES + 1, LOG_COLS + 1);
CON_DrawScrollBar();
}
continue;
case KEY_PPAGE:
if (scrollline > 0) {
scrollline -= LOG_SCROLL;
if (scrollline < 0)
scrollline = 0;
pnoutrefresh(logwin, scrollline, 0, 2, 1, LOG_LINES + 1, LOG_COLS + 1);
CON_DrawScrollBar();
}
continue;
case '\b':
case 127:
case KEY_BACKSPACE:
if (input_field.cursor <= 0)
continue;
input_field.cursor--;
// Fall through
case KEY_DC:
if (input_field.cursor < strlen(input_field.buffer)) {
memmove(input_field.buffer + input_field.cursor,
input_field.buffer + input_field.cursor + 1,
strlen(input_field.buffer) - input_field.cursor);
}
continue;
}
// Normal characters
if (chr >= ' ' && chr < 256 && strlen(input_field.buffer) + 1 < sizeof(input_field.buffer)) {
memmove(input_field.buffer + input_field.cursor + 1,
input_field.buffer + input_field.cursor,
strlen(input_field.buffer) - input_field.cursor);
input_field.buffer[input_field.cursor] = chr;
input_field.cursor++;
}
}
}
/*
========================
UI_DrawConnectScreen
This will also be overlaid on the cgame info screen during loading
to prevent it from blinking away too rapidly on local or lan games.
========================
*/
void UI_DrawConnectScreen( qboolean overlay ) {
char *s;
uiClientState_t cstate;
char info[MAX_INFO_VALUE];
Menu_Cache();
if ( !overlay ) {
// draw the dialog background
UI_SetColor( color_white );
UI_DrawHandlePic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, uis.connecting );
}
// see what information we should display
trap_GetClientState( &cstate );
info[0] = '\0';
if( trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) ) ) {
UI_DrawProportionalString( 320, 16, va( "Loading %s", Info_ValueForKey( info, "mapname" ) ), UI_BIGFONT|UI_CENTER|UI_DROPSHADOW, 1.0, g_color_table[60] );
}
UI_DrawProportionalString( 320, 64, va("Connecting to %s", cstate.servername), UI_CENTER|UI_SMALLFONT|UI_DROPSHADOW, 0.75, g_color_table[60] );
//UI_DrawProportionalString( 320, 96, "Press Esc to abort", UI_CENTER|UI_SMALLFONT|UI_DROPSHADOW, menu_text_color );
// display global MOTD at bottom
UI_DrawProportionalString( SCREEN_WIDTH/2, SCREEN_HEIGHT-32,
Info_ValueForKey( cstate.updateInfoString, "motd" ), UI_CENTER|UI_SMALLFONT|UI_DROPSHADOW, 0.75, menu_text_color );
// print any server info (server full, bad version, etc)
if ( cstate.connState < CA_CONNECTED ) {
UI_DrawProportionalString_AutoWrapped( 320, 192, 630, 20, cstate.messageString, UI_CENTER|UI_SMALLFONT|UI_DROPSHADOW, menu_text_color );
//Here is what prints the ban message!
//Com_Printf("DBG: %s\n", cstate.messageString);
}
#if 0
// display password field
if ( passwordNeeded ) {
s_ingame_menu.x = SCREEN_WIDTH * 0.50 - 128;
s_ingame_menu.nitems = 0;
s_ingame_menu.wrapAround = qtrue;
passwordField.generic.type = MTYPE_FIELD;
passwordField.generic.name = "Password:"******"password"),
sizeof(passwordField.field.buffer) );
Menu_AddItem( &s_ingame_menu, ( void * ) &s_customize_player_action );
MField_Draw( &passwordField );
}
#endif
if ( lastConnState > cstate.connState ) {
lastLoadingText[0] = '\0';
}
lastConnState = cstate.connState;
switch ( cstate.connState ) {
case CA_CONNECTING:
s = va("Awaiting challenge...%i", cstate.connectPacketCount);
break;
case CA_CHALLENGING:
s = va("Awaiting connection...%i", cstate.connectPacketCount);
break;
case CA_CONNECTED: {
char downloadName[MAX_INFO_VALUE];
trap_Cvar_VariableStringBuffer( "cl_downloadName", downloadName, sizeof(downloadName) );
if (*downloadName) {
UI_DisplayDownloadInfo( downloadName );
return;
}
}
s = "Awaiting gamestate...";
break;
case CA_LOADING:
return;
case CA_PRIMED:
return;
default:
return;
}
UI_DrawProportionalString( 320, 128, s, UI_CENTER|UI_SMALLFONT|UI_DROPSHADOW, 0.75, g_color_table[60] );
// password required / connection rejected information goes here
}
/*
====================
Console_Key
Handles history and console scrollback
====================
*/
void Console_Key (int key) {
// ctrl-L clears screen
if ( key == 'l' && keys[K_CTRL].down ) {
Cbuf_AddText ("clear\n");
return;
}
// enter finishes the line
if ( key == K_ENTER || key == K_KP_ENTER ) {
// if not in the game explicitly prepend a slash if needed
if ( cls.state != CA_ACTIVE
&& g_consoleField.buffer[0] != '\0'
&& g_consoleField.buffer[0] != '\\'
&& g_consoleField.buffer[0] != '/' ) {
char temp[MAX_EDIT_LINE-1];
Q_strncpyz( temp, g_consoleField.buffer, sizeof( temp ) );
Com_sprintf( g_consoleField.buffer, sizeof( g_consoleField.buffer ), "\\%s", temp );
g_consoleField.cursor++;
}
Com_Printf ( "]%s\n", g_consoleField.buffer );
// leading slash is an explicit command
if ( g_consoleField.buffer[0] == '\\' || g_consoleField.buffer[0] == '/' ) {
Cbuf_AddText( g_consoleField.buffer+1 ); // valid command
Cbuf_AddText ("\n");
} else {
// other text will be chat messages
if ( !g_consoleField.buffer[0] ) {
return; // empty lines just scroll the console without adding to history
} else {
Cbuf_AddText ("cmd say ");
Cbuf_AddText( g_consoleField.buffer );
Cbuf_AddText ("\n");
}
}
// copy line to history buffer
Con_SaveField( &g_consoleField );
Field_Clear( &g_consoleField );
g_consoleField.widthInChars = g_console_field_width;
if ( cls.state == CA_DISCONNECTED ) {
SCR_UpdateScreen (); // force an update, because the command
} // may take some time
return;
}
// command completion
if (key == K_TAB) {
Field_AutoComplete(&g_consoleField);
return;
}
// command history (ctrl-p ctrl-n for unix style)
if ( (key == K_MWHEELUP && keys[K_SHIFT].down) || ( key == K_UPARROW ) || ( key == K_KP_UPARROW ) ||
( ( tolower(key) == 'p' ) && keys[K_CTRL].down ) ) {
Con_HistoryGetPrev( &g_consoleField );
g_consoleField.widthInChars = g_console_field_width;
return;
}
if ( (key == K_MWHEELDOWN && keys[K_SHIFT].down) || ( key == K_DOWNARROW ) || ( key == K_KP_DOWNARROW ) ||
( ( tolower(key) == 'n' ) && keys[K_CTRL].down ) ) {
Con_HistoryGetNext( &g_consoleField );
g_consoleField.widthInChars = g_console_field_width;
return;
}
// console scrolling
if ( key == K_PGUP ) {
if ( keys[K_CTRL].down ) { // hold <ctrl> to accelerate scrolling
Con_PageUp( 0 ); // by one visible page
} else {
Con_PageUp( 1 );
}
return;
}
if ( key == K_PGDN ) {
if ( keys[K_CTRL].down ) { // hold <ctrl> to accelerate scrolling
Con_PageDown( 0 ); // by one visible page
} else {
Con_PageDown( 1 );
}
return;
}
if ( key == K_MWHEELUP ) { //----(SA) added some mousewheel functionality to the console
if ( keys[K_CTRL].down ) { // hold <ctrl> to accelerate scrolling
Con_PageUp( 4 );
} else {
Con_PageUp( 1 );
}
return;
}
if ( key == K_MWHEELDOWN ) { //----(SA) added some mousewheel functionality to the console
if ( keys[K_CTRL].down ) { // hold <ctrl> to accelerate scrolling
Con_PageDown( 4 );
} else {
Con_PageDown( 1 );
}
return;
}
// ctrl-home = top of console
if ( key == K_HOME && keys[K_CTRL].down ) {
Con_Top();
return;
}
// ctrl-end = bottom of console
if ( key == K_END && keys[K_CTRL].down ) {
Con_Bottom();
return;
}
// pass to the normal editline routine
Field_KeyDownEvent( &g_consoleField, key );
}
/*
==================
CON_ConsoleInput
==================
*/
char *CON_ConsoleInput (void)
{
INPUT_RECORD buff[MAXCMDLINE];
DWORD count = 0, events = 0;
WORD key = 0;
int i;
int newlinepos = -1;
if (!GetNumberOfConsoleInputEvents(qconsole_hin, &events))
return NULL;
if (events < 1)
return NULL;
// if we have overflowed, start dropping oldest input events
if (events >= MAXCMDLINE)
{
ReadConsoleInput(qconsole_hin, buff, 1, &events);
return NULL;
}
if (!ReadConsoleInput(qconsole_hin, buff, events, &count))
return NULL;
FlushConsoleInputBuffer(qconsole_hin);
for (i = 0; i < count; i++)
{
if (buff[i].EventType != KEY_EVENT)
continue;
if (!buff[i].Event.KeyEvent.bKeyDown)
continue;
key = buff[i].Event.KeyEvent.wVirtualKeyCode;
if (key == VK_RETURN)
{
newlinepos = i;
break;
}
else if (key == VK_UP)
{
CON_HistPrev();
break;
}
else if (key == VK_DOWN)
{
CON_HistNext();
break;
}
else if (key == VK_TAB)
{
// command completion
field_t f;
Field_Clear(&f);
Q_strlcpy(f.buffer, qconsole_line, sizeof(f.buffer));
Field_AutoComplete(&f);
Q_strlcpy(qconsole_line, f.buffer, sizeof(qconsole_line));
qconsole_linelen = strlen(qconsole_line);
break;
}
if (qconsole_linelen < sizeof(qconsole_line) - 1)
{
char c = buff[i].Event.KeyEvent.uChar.AsciiChar;
if (key == VK_BACK)
{
int pos = (qconsole_linelen > 0) ? qconsole_linelen - 1 : 0;
qconsole_line[pos] = '\0';
qconsole_linelen = pos;
}
else if (c)
{
qconsole_line[qconsole_linelen++] = c;
qconsole_line[qconsole_linelen] = '\0';
}
}
}
if (newlinepos < 0)
{
CON_Show();
return NULL;
}
if (!qconsole_linelen)
{
CON_Show();
Com_Printf("\n");
return NULL;
}
qconsole_linelen = 0;
CON_Show();
CON_HistAdd();
Com_Printf("%s\n", qconsole_line);
return qconsole_line;
}
/*
==================
Field_CharEvent
==================
*/
void Field_CharEvent( field_t *edit, int ch ) {
int len;
if ( ch == 'v' - 'a' + 1 ) { // ctrl-v is paste
Field_Paste( edit );
return;
}
if ( ch == 'c' - 'a' + 1 ) { // ctrl-c clears the field
Field_Clear( edit );
return;
}
len = strlen( edit->buffer );
if ( ch == 'h' - 'a' + 1 ) { // ctrl-h is backspace
if ( edit->cursor > 0 ) {
memmove( edit->buffer + edit->cursor - 1,
edit->buffer + edit->cursor, len + 1 - edit->cursor );
edit->cursor--;
if ( edit->cursor < edit->scroll )
{
edit->scroll--;
}
}
return;
}
if ( ch == 'a' - 'a' + 1 ) { // ctrl-a is home
edit->cursor = 0;
edit->scroll = 0;
return;
}
if ( ch == 'e' - 'a' + 1 ) { // ctrl-e is end
edit->cursor = len;
edit->scroll = edit->cursor - edit->widthInChars;
return;
}
//
// ignore any other non printable chars
//
if ( ch < 32 ) {
return;
}
if ( key_overstrikeMode ) {
// - 2 to leave room for the leading slash and trailing \0
if ( edit->cursor == MAX_EDIT_LINE - 2 )
return;
edit->buffer[edit->cursor] = ch;
edit->cursor++;
} else { // insert mode
// - 2 to leave room for the leading slash and trailing \0
if ( len == MAX_EDIT_LINE - 2 ) {
return; // all full
}
memmove( edit->buffer + edit->cursor + 1,
edit->buffer + edit->cursor, len + 1 - edit->cursor );
edit->buffer[edit->cursor] = ch;
edit->cursor++;
}
if ( edit->cursor >= edit->widthInChars ) {
edit->scroll++;
}
if ( edit->cursor == len + 1) {
edit->buffer[edit->cursor] = 0;
}
}