void Con_OpenConsole_f( void )
{
if ( !( cls.keyCatchers & KEYCATCH_CONSOLE ) )
{
Con_ToggleConsole_f();
}
}
void Con_OpenConsole_f( void )
{
if ( !consoleState.isOpened )
{
Con_ToggleConsole_f();
}
}
/*
============
VID_CheckChanges
This function gets called once just before drawing each frame, and it's sole purpose in life
is to check to see if any of the video mode parameters have changed, and if they have to
update the rendering DLL and/or video mode to match.
============
*/
void VID_CheckChanges (void)
{
if ( win_noalttab->modified )
{
if ( win_noalttab->value )
{
WIN_DisableAltTab();
}
else
{
WIN_EnableAltTab();
}
win_noalttab->modified = false;
}
if ( vid_ref_modified /*vid_ref->modified*/ )
{
cl.force_refdef = true; // can't use a paused refdef
S_StopAllSounds();
}
while ( vid_ref_modified /*vid_ref->modified*/ )
{
/*
** refresh has changed
*/
vid_ref_modified = false;
/*vid_ref->modified = false;*/
vid_fullscreen->modified = true;
cl.refresh_prepped = false;
cls.disable_screen = true;
if ( !VID_LoadRefresh() )
{
/*
** drop the console if we fail to load a refresh
*/
if ( cls.key_dest != key_console )
{
Con_ToggleConsole_f();
}
}
cls.disable_screen = false;
}
/*
** update our window position
*/
if ( vid_xpos->modified || vid_ypos->modified )
{
if (!vid_fullscreen->value)
VID_UpdateWindowPosAndSize( vid_xpos->value, vid_ypos->value );
vid_xpos->modified = false;
vid_ypos->modified = false;
}
}
/*
============
VID_CheckChanges
This function gets called once just before drawing each frame, and it's sole purpose in life
is to check to see if any of the video mode parameters have changed, and if they have to
update the rendering DLL and/or video mode to match.
============
*/
void VID_CheckChanges (void)
{
char name[100];
cvar_t *sw_mode;
if ( vid_ref->modified )
{
S_StopAllSounds();
}
while (vid_ref->modified)
{
/*
** refresh has changed
*/
vid_ref->modified = false;
vid_fullscreen->modified = true;
cl.refresh_prepped = false;
cls.disable_screen = true;
sprintf( name, "ref_%s.so", vid_ref->string );
if ( !VID_LoadRefresh( name ) )
{
if ( strcmp (vid_ref->string, "soft") == 0 ||
strcmp (vid_ref->string, "softx") == 0 ) {
Com_Printf("Refresh failed\n");
sw_mode = Cvar_Get( "sw_mode", "0", 0 );
if (sw_mode->value != 0) {
Com_Printf("Trying mode 0\n");
Cvar_SetValue("sw_mode", 0);
if ( !VID_LoadRefresh( name ) )
Com_Error (ERR_FATAL, "Couldn't fall back to software refresh!");
} else
Com_Error (ERR_FATAL, "Couldn't fall back to software refresh!");
}
/* prefer to fall back on X if active */
if (getenv("DISPLAY"))
Cvar_Set( "vid_ref", "softx" );
else
Cvar_Set( "vid_ref", "soft" );
/*
** drop the console if we fail to load a refresh
*/
if ( cls.key_dest != key_console )
{
Con_ToggleConsole_f();
}
}
cls.disable_screen = false;
}
}
void VID_CheckChanges (void)
{
char name[100];
if (vid_ref->modified)
{
S_StopAllSounds();
}
while (vid_ref->modified)
{
// refresh has changed
vid_ref->modified = false;
vid_fullscreen->modified = true;
cl.refresh_prepped = false;
cls.disable_screen = true;
sprintf(name, "ref_%s.so", vid_ref->string );
if (!VID_LoadRefresh(name))
{
if (strcmp (vid_ref->string, "pbgl") == 0 ||
strcmp (vid_ref->string, "pbsdl") == 0 ) {
Com_Error (ERR_FATAL, "Couldn't load gl refresh!");
}
if (getenv("DISPLAY"))
Cvar_Set( "vid_ref", "pbgl" );
else
Cvar_Set( "vid_ref", "pbsdl" );
// drop the console if we fail to load a refresh
if (cls.key_dest != key_console)
{
Con_ToggleConsole_f();
}
}
if (!vid_ref->modified)
{
cls.disable_screen = false;
CL_InitImages();
M_ReloadMenu(); // jitmenu
}
}
}
/**
* timedemo [demoname]
*/
void CL_TimeDemo_f(void) {
if (CmdArgs::getSource() != CmdArgs::COMMAND)
return;
if (CmdArgs::getArgCount() != 2) {
Con_Printf("timedemo <demoname> : gets demo speeds\n");
return;
}
if (key_dest == key_console) {
//make console disappare fast
saveconspeed = scr_conspeed.getFloat();
scr_conspeed.set(1000000.0f);
Con_ToggleConsole_f();
}
CL_PlayDemo_f();
// cls.td_starttime will be grabbed at the second frame of the demo, so
// all the loading time doesn't get counted
cls.timedemo = true;
cls.td_startframe = host_framecount;
cls.td_lastframe = -1; // get a new message this frame
}
/*
===================
Key_Event
Called by the system for both key up and key down events
===================
*/
void Key_Event( int key, qboolean down )
{
const char *kb;
char cmd[1024];
//Con_Printf( "Keycode %d\n", key );
if ( key > 255 || key < 0)
{
Con_Printf ("Keynum %d out of range\n", key);
return;
}
// update auto-repeat status and BUTTON_ANY status
keys[key].down = down;
if( down )
{
//keys[key].repeats++;
if( key != K_BACKSPACE && key != K_PAUSE && keys[key].repeats > 1 )
{
if( cls.key_dest == key_game )
{
// ignore most autorepeats
return;
}
}
}
else
{
keys[key].repeats = 0;
}
// console key is hardcoded, so the user can never unbind it
if( key == '`' || key == '~' )
{
// we are in typing mode, so don't switch to console
if( cls.key_dest == key_message || !down )
return;
Con_ToggleConsole_f();
return;
}
// escape is always handled specially
if( key == K_ESCAPE && down )
{
switch( cls.key_dest )
{
case key_game:
if( host.mouse_visible && cls.state != ca_cinematic )
{
clgame.dllFuncs.pfnKey_Event( down, key, keys[key].binding );
return; // handled in client.dll
}
break;
case key_message:
Key_Message( key );
return;
case key_console:
if( cls.state == ca_active && !cl.background )
Key_SetKeyDest( key_game );
else UI_SetActiveMenu( true );
return;
case key_menu:
UI_KeyEvent( key, true );
return;
default:
MsgDev( D_ERROR, "Key_Event: bad cls.key_dest\n" );
return;
}
}
if( cls.key_dest == key_menu )
{
// only non printable keys passed
UI_KeyEvent( key, down );
return;
}
// key up events only perform actions if the game key binding is
// a button command (leading + sign). These will be processed even in
// console mode and menu mode, to keep the character from continuing
// an action started before a mode switch.
if( !down )
{
kb = keys[key].binding;
if( cls.key_dest == key_game && ( key != K_ESCAPE ))
clgame.dllFuncs.pfnKey_Event( down, key, kb );
Key_AddKeyUpCommands( key, kb );
return;
}
// distribute the key down event to the apropriate handler
if( cls.key_dest == key_game )
{
if( cls.state == ca_cinematic )
{
// only escape passed when cinematic is playing
// HLFX 0.6 bug: crash in vgui3.dll while press +attack during movie playback
if( key != K_ESCAPE || !down )
return;
}
else if( host.mouse_visible )
return;
// send the bound action
kb = keys[key].binding;
if( !clgame.dllFuncs.pfnKey_Event( down, key, keys[key].binding ))
{
// handled in client.dll
}
else if( kb != NULL )
{
if( kb[0] == '+' )
{
int i;
char button[1024], *buttonPtr;
for( i = 0, buttonPtr = button; ; i++ )
{
if( kb[i] == ';' || !kb[i] )
{
*buttonPtr = '\0';
if( button[0] == '+' )
{
Q_sprintf( cmd, "%s %i\n", button, key );
Cbuf_AddText( cmd );
}
else
{
// down-only command
Cbuf_AddText( button );
Cbuf_AddText( "\n" );
}
buttonPtr = button;
while (( kb[i] <= ' ' || kb[i] == ';' ) && kb[i] != 0 )
i++;
}
*buttonPtr++ = kb[i];
if( !kb[i] ) break;
}
}
else
{
// down-only command
Cbuf_AddText( kb );
Cbuf_AddText( "\n" );
}
}
}
else if( cls.key_dest == key_console )
{
Key_Console( key );
}
else if( cls.key_dest == key_message )
{
Key_Message( key );
}
}
/*
* Key_Event
*
* Called by the system between frames for both key up and key down events
* Should NOT be called during an interrupt!
*/
void Key_Event( int key, qboolean down, unsigned time )
{
char *kb;
char cmd[1024];
qboolean handled = qfalse;
// 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_UPARROW && key != K_DOWNARROW
&& key != K_PGUP && key != K_PGDN && ( key < 32 || key > 126 || key == '`' ) )
|| cls.key_dest == key_game )
return;
}
}
else
{
key_repeats[key] = 0;
}
#ifndef WIN32
// switch between fullscreen/windowed when ALT+ENTER is pressed
if( key == K_ENTER && down && (keydown[K_LALT] || keydown[K_RALT]) )
{
Cbuf_ExecuteText( EXEC_APPEND, "toggle vid_fullscreen\n" );
return;
}
#endif
#if defined ( __MACOSX__ )
// quit the game when Control + q is pressed
if( key == 'q' && down && keydown[K_COMMAND] )
{
Cbuf_ExecuteText( EXEC_APPEND, "quit\n" );
return;
}
#endif
if( Key_IsToggleConsole( key ) )
{
if( !down )
return;
Con_ToggleConsole_f();
return;
}
// menu key is hardcoded, so the user can never unbind it
if( key == K_ESCAPE )
{
if( !down )
return;
if( cls.state != CA_ACTIVE )
{
if( cls.key_dest == key_game || cls.key_dest == key_menu )
{
if( cls.state != CA_DISCONNECTED )
Cbuf_AddText( "disconnect\n" );
else if( cls.key_dest == key_menu )
CL_UIModule_Keydown( key );
return;
}
}
switch( cls.key_dest )
{
case key_message:
Con_MessageKeyDown( key );
break;
case key_menu:
CL_UIModule_Keydown( key );
break;
case key_game:
CL_GameModule_EscapeKey();
break;
case key_console:
Con_ToggleConsole_f();
break;
case key_delegate:
Key_DelegateCallKeyDel( key );
break;
default:
Com_Error( ERR_FATAL, "Bad cls.key_dest" );
}
return;
}
//
// if not a consolekey, send to the interpreter no matter what mode is
//
if( ( cls.key_dest == key_menu && menubound[key] )
|| ( cls.key_dest == key_console && !consolekeys[key] )
|| ( cls.key_dest == key_game && ( cls.state == CA_ACTIVE || !consolekeys[key] ) )
|| ( cls.key_dest == key_message && ( key >= K_F1 && key <= K_F15 ) ) )
{
kb = keybindings[key];
if( kb )
{
if( in_debug && in_debug->integer ) {
Com_Printf( "key:%i down:%i time:%i %s\n", key, down, time, kb );
}
if( kb[0] == '+' )
{ // button commands add keynum and time as a parm
if( down )
{
Q_snprintfz( cmd, sizeof( cmd ), "%s %i %u\n", kb, key, time );
Cbuf_AddText( cmd );
}
else if( keydown[key] )
{
Q_snprintfz( cmd, sizeof( cmd ), "-%s %i %u\n", kb+1, key, time );
Cbuf_AddText( cmd );
}
}
else if( down )
{
Cbuf_AddText( kb );
Cbuf_AddText( "\n" );
}
}
handled = qtrue; // can't return here, because we want to track keydown & repeats
}
// track if any key is down for BUTTON_ANY
keydown[key] = down;
if( down )
{
if( key_repeats[key] == 1 )
anykeydown++;
}
else
{
anykeydown--;
if( anykeydown < 0 )
anykeydown = 0;
}
if( cls.key_dest == key_menu )
{
if( down )
CL_UIModule_Keydown( key );
else
CL_UIModule_Keyup( key );
return;
}
if( handled || !down )
return; // other systems only care about key down events
switch( cls.key_dest )
{
case key_message:
Con_MessageKeyDown( key );
break;
case key_game:
case key_console:
Con_KeyDown( key );
break;
case key_delegate:
Key_DelegateCallKeyDel( key );
break;
default:
Com_Error( ERR_FATAL, "Bad cls.key_dest" );
}
}
/**
* @brief Called by the system between frames for both key up and key down events
* @note Should NOT be called during an interrupt!
* @sa Key_Message
*/
void Key_Event (unsigned int key, unsigned short unicode, qboolean down, unsigned time)
{
char cmd[MAX_STRING_CHARS];
/* unbindable key */
if (key >= K_KEY_SIZE)
return;
/* any key (except F1-F12) during the sequence mode will bring up the menu */
if (cls.keyDest == key_game && down) {
if (UI_KeyPressed(key, unicode))
return;
}
/* menu key is hardcoded, so the user can never unbind it */
if (key == K_ESCAPE) {
if (!down)
return;
switch (cls.keyDest) {
case key_console:
Con_ToggleConsole_f();
break;
default:
Com_Error(ERR_FATAL, "Bad cls.key_dest");
}
return;
}
/* track if any key is down for BUTTON_ANY */
keyDown[key] = down;
if (!down) {
int i;
/* 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 */
const char *kb = menuKeyBindings[key];
/* this loop ensures, that every down event reaches it's proper kbutton_t */
for (i = 0; i < 3; i++) {
if (kb && kb[0] == '+') {
/* '-' means we have released the key
* the key number is used to determine whether the kbutton_t is really
* released or whether any other bound key will still ensure that the
* kbutton_t is pressed
* the time is the msec value when the key was released */
Com_sprintf(cmd, sizeof(cmd), "-%s %i %i\n", kb + 1, key, time);
Cbuf_AddText(cmd);
}
if (i == 0)
kb = keyBindings[key];
else
kb = battleKeyBindings[key];
}
return;
}
/* if not a consolekey, send to the interpreter no matter what mode is */
if (cls.keyDest == key_game || (key >= K_MOUSE1 && key <= K_MWHEELUP)) {
/* Some keyboards need modifiers to access key values that are
* present as bare keys on other keyboards. Smooth over the difference
* here by using the translated value if there is a binding for it. */
const char *kb = NULL;
if (mouseSpace == MS_UI && unicode >= 32 && unicode < 127)
kb = menuKeyBindings[unicode];
if (!kb && mouseSpace == MS_UI)
kb = menuKeyBindings[key];
if (!kb && unicode >= 32 && unicode < 127)
kb = keyBindings[unicode];
if (!kb)
kb = keyBindings[key];
if (!kb && CL_OnBattlescape())
kb = battleKeyBindings[key];
if (kb) {
if (kb[0] == '+') { /* button commands add keynum and time as a parm */
/* '+' means we have pressed the key
* the key number is used because the kbutton_t can be 'pressed' by several keys
* the time is the msec value when the key was pressed */
Com_sprintf(cmd, sizeof(cmd), "%s %i %i\n", kb, key, time);
Cbuf_AddText(cmd);
} else {
Cbuf_AddText(kb);
Cbuf_AddText("\n");
}
if (cls.keyDest == key_game)
return;
}
}
if (!down)
return; /* other systems only care about key down events */
switch (cls.keyDest) {
case key_game:
case key_console:
Key_Console(key, unicode);
break;
default:
Com_Error(ERR_FATAL, "Bad cls.key_dest");
}
}
/*
============
VID_CheckChanges
This function gets called once just before drawing each frame, and it's sole purpose in life
is to check to see if any of the video mode parameters have changed, and if they have to
update the rendering DLL and/or video mode to match.
============
*/
void VID_CheckChanges (void)
{
char name[100];
if ( win_noalttab->modified )
{
if ( win_noalttab->value )
{
WIN_DisableAltTab();
}
else
{
WIN_EnableAltTab();
}
win_noalttab->modified = 0;
}
if ( vid_ref->modified )
{
cl.force_refdef = 1; // can't use a paused refdef
S_StopAllSounds();
Cam_Reset_f (); // NeVo - reset the camera
}
while (vid_ref->modified)
{
/*
** refresh has changed
*/
vid_ref->modified = 0;
vid_fullscreen->modified = 1;
cl.refresh_prepped = 0;
cls.disable_screen = 1;
Com_sprintf( name, sizeof(name), "ref_%s.dll", vid_ref->string );
if ( !VID_LoadRefresh( name ) )
{
if ( strcmp (vid_ref->string, "soft") == 0 )
Com_Error (ERR_FATAL, "Couldn't fall back to software refresh!");
Cvar_Set( "vid_ref", "soft" );
/*
** drop the console if we fail to load a refresh
*/
if ( cls.key_dest != key_console )
{
Con_ToggleConsole_f();
}
}
cls.disable_screen = 0;
}
/*
** update our window position
*/
if ( vid_xpos->modified || vid_ypos->modified )
{
if (!vid_fullscreen->value)
VID_UpdateWindowPosAndSize( vid_xpos->value, vid_ypos->value );
vid_xpos->modified = 0;
vid_ypos->modified = 0;
}
}
/*
===================
Key_Event
Called by the system between frames for both key up and key down events
Should NOT be called during an interrupt!
===================
*/
void Key_Event(unsigned key, qboolean down, unsigned time)
{
char *kb;
char cmd[MAX_STRING_CHARS];
if (key >= 256) {
Com_Error(ERR_FATAL, "%s: bad key", __func__);
}
Com_DDDPrintf("%u: %c%s\n", time,
down ? '+' : '-', Key_KeynumToString(key));
// hack for menu key binding
if (key_wait_cb && down && !key_wait_cb(key_wait_arg, key)) {
return;
}
// update key down and auto-repeat status
if (down) {
if (keydown[key] < 255)
keydown[key]++;
} else {
keydown[key] = 0;
}
// console key is hardcoded, so the user can never unbind it
if (!Key_IsDown(K_SHIFT) && (key == '`' || key == '~')) {
if (keydown[key] == 1) {
Con_ToggleConsole_f();
}
return;
}
// Alt+Enter is hardcoded for all systems
if (Key_IsDown(K_ALT) && key == K_ENTER) {
if (keydown[key] == 1) {
VID_ToggleFullscreen();
}
return;
}
// menu key is hardcoded, so the user can never unbind it
if (key == K_ESCAPE) {
if (!down) {
return;
}
if (cls.key_dest == KEY_GAME &&
cl.frame.ps.stats[STAT_LAYOUTS] &&
cls.demo.playback == qfalse) {
if (keydown[key] == 2) {
// force main menu if escape is held
UI_OpenMenu(UIMENU_GAME);
} else if (keydown[key] == 1) {
// put away help computer / inventory
CL_ClientCommand("putaway");
}
return;
}
// ignore autorepeats
if (keydown[key] > 1) {
return;
}
if (cls.key_dest & KEY_CONSOLE) {
if (cls.state < ca_active && !(cls.key_dest & KEY_MENU)) {
UI_OpenMenu(UIMENU_MAIN);
} else {
Con_Close(qtrue);
}
} else if (cls.key_dest & KEY_MENU) {
UI_Keydown(key);
} else if (cls.key_dest & KEY_MESSAGE) {
Key_Message(key);
} else if (cls.state == ca_active) {
UI_OpenMenu(UIMENU_GAME);
} else {
UI_OpenMenu(UIMENU_MAIN);
}
return;
}
// track if any key is down for BUTTON_ANY
if (down) {
if (keydown[key] == 1)
anykeydown++;
} else {
anykeydown--;
if (anykeydown < 0)
anykeydown = 0;
}
// hack for demo freelook in windowed mode
if (cls.key_dest == KEY_GAME && cls.demo.playback && key == K_SHIFT && keydown[key] <= 1) {
IN_Activate();
}
//
// if not a consolekey, send to the interpreter no matter what mode is
//
if ((cls.key_dest == KEY_GAME) ||
((cls.key_dest & KEY_CONSOLE) && !Q_IsBitSet(consolekeys, key)) ||
((cls.key_dest & KEY_MENU) && (key >= K_F1 && key <= K_F12)) ||
(!down && Q_IsBitSet(buttondown, key))) {
//
// Key up events only generate commands if the game key binding is a button
// command (leading + sign). These will occur even in console mode, to keep the
// character from continuing an action started before a console switch. Button
// commands include the kenum as a parameter, so multiple downs can be matched
// with ups.
//
if (!down) {
kb = keybindings[key];
if (kb && kb[0] == '+') {
Q_snprintf(cmd, sizeof(cmd), "-%s %i %i\n",
kb + 1, key, time);
Cbuf_AddText(&cmd_buffer, cmd);
}
Q_ClearBit(buttondown, key);
return;
}
// ignore autorepeats
if (keydown[key] > 1) {
return;
}
// generate button up command when released
Q_SetBit(buttondown, key);
kb = keybindings[key];
if (kb) {
if (kb[0] == '+') {
// button commands add keynum and time as a parm
Q_snprintf(cmd, sizeof(cmd), "%s %i %i\n", kb, key, time);
Cbuf_AddText(&cmd_buffer, cmd);
} else {
Cbuf_AddText(&cmd_buffer, kb);
Cbuf_AddText(&cmd_buffer, "\n");
}
}
return;
}
if (cls.key_dest == KEY_GAME)
return;
if (!down)
return; // other subsystems only care about key down events
if (cls.key_dest & KEY_CONSOLE) {
Key_Console(key);
} else if (cls.key_dest & KEY_MENU) {
UI_Keydown(key);
} else if (cls.key_dest & KEY_MESSAGE) {
Key_Message(key);
}
if (Key_IsDown(K_CTRL) || Key_IsDown(K_ALT)) {
return;
}
switch (key) {
case K_KP_SLASH:
key = '/';
break;
case K_KP_MULTIPLY:
key = '*';
break;
case K_KP_MINUS:
key = '-';
break;
case K_KP_PLUS:
key = '+';
break;
case K_KP_HOME:
key = '7';
break;
case K_KP_UPARROW:
key = '8';
break;
case K_KP_PGUP:
key = '9';
break;
case K_KP_LEFTARROW:
key = '4';
break;
case K_KP_5:
key = '5';
break;
case K_KP_RIGHTARROW:
key = '6';
break;
case K_KP_END:
key = '1';
break;
case K_KP_DOWNARROW:
key = '2';
break;
case K_KP_PGDN:
key = '3';
break;
case K_KP_INS:
key = '0';
break;
case K_KP_DEL:
key = '.';
break;
}
// if key is printable, generate char events
if (key < 32 || key >= 127) {
return;
}
if (Key_IsDown(K_SHIFT)) {
key = keyshift[key];
}
if (cls.key_dest & KEY_CONSOLE) {
Char_Console(key);
} else if (cls.key_dest & KEY_MENU) {
UI_CharEvent(key);
} else if (cls.key_dest & KEY_MESSAGE) {
Char_Message(key);
}
}
void VID_CheckChanges (void)
{
char name[100];
if (win_noalttab->modified)
{
if (win_noalttab->value)
WIN_DisableAltTab();
else
WIN_EnableAltTab();
win_noalttab->modified = false;
}
if (vid_ref->modified)
{
cl.force_refdef = true; // can't use a paused refdef
S_StopAllSounds();
}
while (vid_ref->modified)
{
char driverstring[32]; // jit
cvar_t *gl_driver; // jit
gl_driver = Cvar_Get("gl_driver", "opengl32", CVAR_ARCHIVE); // jit
Com_sprintf(driverstring, sizeof(driverstring), "%s", gl_driver->string);
Cvar_Get("gl_swapinterval", "0", CVAR_ARCHIVE)->modified = true; // jit
/*
** refresh has changed, jitodo, cheatcheck!
*/
vid_ref->modified = false;
vid_fullscreen->modified = true;
cl.refresh_prepped = false;
cls.disable_screen = true;
// jit -- only allow opengl32 or 3dfxgl:
if (!Q_streq(gl_driver->string, "opengl32") && !Q_streq(gl_driver->string, "3dfxgl"))
Cvar_Set("gl_driver", "opengl32");
// Com_sprintf(name, sizeof(name), "ref_%s.dll", vid_ref->string );
Com_sprintf(name, sizeof(name), "ref_pbgl.dll"); // jit
if (!VID_LoadRefresh(name))
{
// jit3dfx - check if driver string changed:
if (!Q_streq(gl_driver->string, driverstring))
{
vid_ref->modified = true;
Q_strncpyz(driverstring, gl_driver->string, sizeof(driverstring));
}
if (!vid_ref->modified) // jit
Com_Error(ERR_FATAL, "Unable to load OpenGL refresh!"); // jit
// drop the console if we fail to load a refresh
if (cls.key_dest != key_console)
Con_ToggleConsole_f();
}
if (!vid_ref->modified) // jit3dfx
{
cls.disable_screen = false;
CL_InitImages();
M_ReloadMenu(); // jitmenu (need to do a full reload beacuse pic indexes can change)
}
}
/*
** update our window position
*/
if ( vid_xpos->modified || vid_ypos->modified )
{
if (!vid_fullscreen->value)
VID_UpdateWindowPosAndSize( vid_xpos->value, vid_ypos->value );
vid_xpos->modified = false;
vid_ypos->modified = false;
}
}
/**
* \brief Called by the system between frames for both key up and key down events.
* \param[in] key Key mapping
* \param[in] down Is key being pressed?
* \param[in] time
* \note Should NOT be called during an interrupt!
*/
PUBLIC void Key_Event( int key, _boolean down, unsigned time )
{
char *kb;
char cmd[ 1024 ];
// hack for modal presses
if (key_waiting == -1)
{
if (down)
{
key_waiting = key;
}
return;
}
// update auto-repeat status
if (down)
{
key_repeats[key]++;
if (key != K_BACKSPACE
&& key != K_PAUSE
&& key != K_PGUP
&& key != K_KP_PGUP
&& key != K_PGDN
&& key != K_KP_PGDN
&& key_repeats[key] > 1)
{
return; // ignore most autorepeats
}
if (key >= 200 && !keybindings[key])
{
Com_Printf ( "%s is unbound, hit F4 to set.\n", Key_KeynumToString (key) );
}
}
else
{
key_repeats[ key ] = 0;
}
if( key == K_SHIFT )
{
shift_down = down;
}
// console key is hardcoded, so the user can never unbind it
if( key == '`' || key == '~' )
{
if( ! down )
{
return;
}
Con_ToggleConsole_f();
return;
}
// any key during the attract mode will bring up the menu
// if (cl.attractloop && ClientStatic.key_dest != key_menu &&
// !(key >= K_F1 && key <= K_F12))
// key = K_ESCAPE;
// menu key is hardcoded, so the user can never unbind it
if( key == K_ESCAPE )
{
if( ! down )
{
return;
}
// if (cl.frame.playerstate.stats[STAT_LAYOUTS] && ClientStatic.key_dest == key_game)
// { // put away help computer / inventory
// Cbuf_AddText ("cmd putaway\n");
// return;
// }
switch( ClientStatic.key_dest )
{
case key_message:
Key_Message( key );
break;
case KEY_AUTOMAP:
automap_keydown( key );
break;
case key_menu:
M_Keydown( key );
break;
case key_game:
case key_console:
M_Menu_Main_f();
break;
default:
Com_DPrintf( "Bad ClientStatic.key_dest\n" );
}
return;
}
// track if any key is down for BUTTON_ANY
keydown[key] = down;
if (down)
{
if (key_repeats[key] == 1)
{
anykeydown++;
}
}
else
{
anykeydown--;
if (anykeydown < 0)
{
anykeydown = 0;
}
}
//
// key up events only generate commands if the game key binding is
// a button command (leading + sign). These will occur even in console mode,
// to keep the character from continuing an action started before a console
// switch. Button commands include the kenum as a parameter, so multiple
// downs can be matched with ups
//
if( ! down )
{
kb = keybindings[key];
if (kb && kb[0] == '+')
{
com_snprintf (cmd, sizeof(cmd), "-%s %i %i\n", kb+1, key, time);
Cbuf_AddText (cmd);
}
if (keyshift[key] != key)
{
kb = keybindings[keyshift[key]];
if (kb && kb[0] == '+')
{
com_snprintf (cmd, sizeof(cmd), "-%s %i %i\n", kb+1, key, time);
Cbuf_AddText (cmd);
}
}
return;
}
//
// if not a consolekey, send to the interpreter no matter what mode is
//
if ( (ClientStatic.key_dest == key_menu && menubound[key])
|| (ClientStatic.key_dest == key_console && !consolekeys[key])
|| (ClientStatic.key_dest == key_game ) )
{
kb = keybindings[key];
if (kb)
{
if (kb[0] == '+')
{ // button commands add keynum and time as a parm
com_snprintf (cmd, sizeof(cmd), "%s %i %i\n", kb, key, time);
Cbuf_AddText (cmd);
}
else
{
Cbuf_AddText (kb);
Cbuf_AddText ("\n");
}
}
return;
}
if( ! down )
{
return; // other systems only care about key down events
}
if (shift_down)
{
key = keyshift[ key ];
}
switch (ClientStatic.key_dest)
{
case KEY_AUTOMAP:
automap_keydown( key );
break;
case key_message:
Key_Message (key);
break;
case key_menu:
M_Keydown (key);
break;
case key_game:
case key_console:
Key_Console (key);
break;
default:
Com_DPrintf( "Bad ClientStatic.key_dest\n" );
}
}
/**
* @brief Handle input events like keys presses and joystick movement as well
* as window events
* @sa CL_Frame
* @sa IN_Parse
* @sa IN_JoystickMove
*/
void IN_Frame (void)
{
int mouse_buttonstate;
unsigned short unicode;
unsigned int key;
SDL_Event event;
IN_Parse();
IN_JoystickMove();
if (vid_grabmouse->modified) {
vid_grabmouse->modified = qfalse;
if (!vid_grabmouse->integer) {
/* ungrab the pointer */
Com_Printf("Switch grab input off\n");
SDL_WM_GrabInput(SDL_GRAB_OFF);
/* don't allow grabbing the input in fullscreen mode */
} else if (!vid_fullscreen->integer) {
/* grab the pointer */
Com_Printf("Switch grab input on\n");
SDL_WM_GrabInput(SDL_GRAB_ON);
} else {
Com_Printf("No input grabbing in fullscreen mode\n");
Cvar_SetValue("vid_grabmouse", 0);
}
}
oldMousePosX = mousePosX;
oldMousePosY = mousePosY;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
switch (event.button.button) {
case SDL_BUTTON_LEFT:
mouse_buttonstate = K_MOUSE1;
break;
case SDL_BUTTON_MIDDLE:
mouse_buttonstate = K_MOUSE3;
break;
case SDL_BUTTON_RIGHT:
mouse_buttonstate = K_MOUSE2;
break;
case SDL_BUTTON_WHEELUP:
mouse_buttonstate = K_MWHEELUP;
break;
case SDL_BUTTON_WHEELDOWN:
mouse_buttonstate = K_MWHEELDOWN;
break;
case 6:
mouse_buttonstate = K_MOUSE4;
break;
case 7:
mouse_buttonstate = K_MOUSE5;
break;
default:
mouse_buttonstate = K_AUX1 + (event.button.button - 8) % 16;
break;
}
IN_EventEnqueue(mouse_buttonstate, 0, (event.type == SDL_MOUSEBUTTONDOWN));
break;
case SDL_MOUSEMOTION:
SDL_GetMouseState(&mousePosX, &mousePosY);
mousePosX /= viddef.rx;
mousePosY /= viddef.ry;
break;
case SDL_KEYDOWN:
IN_PrintKey(&event, 1);
#ifndef _WIN32
if ((event.key.keysym.mod & KMOD_ALT) && event.key.keysym.sym == SDLK_RETURN) {
SDL_Surface *surface = SDL_GetVideoSurface();
if (!SDL_WM_ToggleFullScreen(surface)) {
int flags = surface->flags ^= SDL_FULLSCREEN;
SDL_SetVideoMode(surface->w, surface->h, 0, flags);
}
if (surface->flags & SDL_FULLSCREEN) {
Cvar_SetValue("vid_fullscreen", 1);
/* make sure, that input grab is deactivated in fullscreen mode */
Cvar_SetValue("vid_grabmouse", 0);
} else {
Cvar_SetValue("vid_fullscreen", 0);
}
vid_fullscreen->modified = qfalse; /* we just changed it with SDL. */
break; /* ignore this key */
}
#endif
if ((event.key.keysym.mod & KMOD_CTRL) && event.key.keysym.sym == SDLK_g) {
SDL_GrabMode gm = SDL_WM_GrabInput(SDL_GRAB_QUERY);
Cvar_SetValue("vid_grabmouse", (gm == SDL_GRAB_ON) ? 0 : 1);
break; /* ignore this key */
}
/* console key is hardcoded, so the user can never unbind it */
if ((event.key.keysym.mod & KMOD_SHIFT) && event.key.keysym.sym == SDLK_ESCAPE) {
Con_ToggleConsole_f();
break;
}
IN_TranslateKey(&event.key.keysym, &key, &unicode);
IN_EventEnqueue(key, unicode, qtrue);
break;
case SDL_VIDEOEXPOSE:
break;
case SDL_KEYUP:
IN_PrintKey(&event, 0);
IN_TranslateKey(&event.key.keysym, &key, &unicode);
IN_EventEnqueue(key, unicode, qfalse);
break;
case SDL_ACTIVEEVENT:
/* make sure menu no more capture input when the game window lose the focus */
if (event.active.state == SDL_APPINPUTFOCUS && event.active.gain == 0)
UI_ReleaseInput();
break;
case SDL_QUIT:
Cmd_ExecuteString("quit");
break;
case SDL_VIDEORESIZE:
/* make sure that SDL_SetVideoMode is called again after we changed the size
* otherwise the mouse will make problems */
vid_mode->modified = qtrue;
break;
}
}
}
/*
===================
CL_KeyDownEvent
Called by CL_KeyEvent to handle a keypress
===================
*/
void CL_KeyDownEvent( int key, unsigned time )
{
keys[key].down = qtrue;
keys[key].repeats++;
if( keys[key].repeats == 1 )
anykeydown++;
#ifndef _WIN32
if( keys[K_ALT].down && key == K_ENTER )
{
Cvar_SetValue( "r_fullscreen",
!Cvar_VariableIntegerValue( "r_fullscreen" ) );
Cbuf_ExecuteText( EXEC_APPEND, "vid_restart\n" );
return;
}
#endif
// console key is hardcoded, so the user can never unbind it
if( key == K_CONSOLE || ( keys[K_SHIFT].down && key == K_ESCAPE ) )
{
Con_ToggleConsole_f ();
Key_ClearStates ();
return;
}
// keys can still be used for bound actions
if ( ( key < 128 || key == K_MOUSE1 )
&& cls.state == CA_CINEMATIC && Key_GetCatcher( ) == 0 ) {
if ( Cvar_VariableIntegerValue( "com_cameraMode" ) == 0 ) {
Cvar_Set ("nextdemo","");
key = K_ESCAPE;
}
}
// escape is always handled special
if ( key == K_ESCAPE ) {
if ( Key_GetCatcher( ) & KEYCATCH_MESSAGE ) {
// clear message mode
Message_Key( key );
return;
}
// escape always gets out of CGAME stuff
if (Key_GetCatcher( ) & KEYCATCH_CGAME) {
Key_SetCatcher( Key_GetCatcher( ) & ~KEYCATCH_CGAME );
VM_Call (cgvm, CG_EVENT_HANDLING, CGAME_EVENT_NONE);
return;
}
if ( !( Key_GetCatcher( ) & KEYCATCH_UI ) ) {
if ( cls.state == CA_ACTIVE && !clc.demoplaying ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_INGAME );
}
else if ( cls.state != CA_DISCONNECTED ) {
CL_Disconnect_f();
S_StopAllSounds();
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_MAIN );
}
return;
}
VM_Call( uivm, UI_KEY_EVENT, key, qtrue );
return;
}
// distribute the key down event to the apropriate handler
if ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) {
Console_Key( key );
} else if ( Key_GetCatcher( ) & KEYCATCH_UI ) {
if ( uivm ) {
VM_Call( uivm, UI_KEY_EVENT, key, qtrue );
}
} else if ( Key_GetCatcher( ) & KEYCATCH_CGAME ) {
if ( cgvm ) {
VM_Call( cgvm, CG_KEY_EVENT, key, qtrue );
}
} else if ( Key_GetCatcher( ) & KEYCATCH_MESSAGE ) {
Message_Key( key );
} else if ( cls.state == CA_DISCONNECTED ) {
Console_Key( key );
} else {
// send the bound action
Key_ParseBinding( key, qtrue, time );
}
return;
}
/*
===================
Key_Event
Called by the system between frames for both key up and key down events
Should NOT be called during an interrupt!
===================
*/
void Key_Event (int key, qboolean down, uint32 time)
{
char *kb;
char cmd[1024];
// hack for modal presses
/*if (key_waiting == -1)
{
if (down)
key_waiting = key;
return;
}*/
//Com_Printf ("%d is %d for %u\n", LOG_GENERAL, key, down, time);
// update auto-repeat status
if (down)
{
key_repeats[key]++;
if (cls.key_dest != key_console && key != K_BACKSPACE && key != K_DEL && key != K_LEFTARROW && key != K_RIGHTARROW
&& key != K_PAUSE
&& key != K_PGUP
&& key != K_KP_PGUP
&& key != K_PGDN
&& key != K_KP_PGDN
&& key_repeats[key] > 1)
return; // ignore most autorepeats
if (key >= 200 && !keybindings[key])
Com_Printf ("%s is unbound, hit F4 to set.\n", LOG_CLIENT, Key_KeynumToString (key) );
}
else
{
key_repeats[key] = 0;
}
//for dinput
if (down && keydown[K_ALT])
{
if (key == K_ENTER)
{
Com_Printf ("ALT+Enter, setting fullscreen %d.\n", LOG_CLIENT, !vid_fullscreen->intvalue);
Cvar_SetValue( "vid_fullscreen", (float)!vid_fullscreen->intvalue );
return;
}
else if (key == K_TAB)
{
//prevent executing action on alt+tab
return;
}
}
if (key == K_SHIFT)
shift_down = down;
// console key is hardcoded, so the user can never unbind it
if ((key == '`' || key == '~') && !shift_down)
{
if (!down)
return;
Con_ToggleConsole_f ();
return;
}
// any key during the attract mode will bring up the menu
/*if (cl.attractloop && cls.key_dest != key_menu &&
!(key >= K_F1 && key <= K_F12))
key = K_ESCAPE;*/
// menu key is hardcoded, so the user can never unbind it
if (key == K_ESCAPE)
{
if (!down)
return;
if (cl.frame.playerstate.stats[STAT_LAYOUTS] && cls.key_dest == key_game)
{ // put away help computer / inventory
Cbuf_AddText ("cmd putaway\n");
return;
}
switch (cls.key_dest)
{
case key_message:
Key_Message (key);
break;
case key_menu:
M_Keydown (key);
break;
case key_game:
case key_console:
M_Menu_Main_f ();
break;
default:
Com_Error (ERR_FATAL, "Bad cls.key_dest");
}
return;
}
if (!keydown[key])
key_lastrepeat[key] = curtime + key_repeatdelay;
// track if any key is down for BUTTON_ANY
keydown[key] = down;
if (down)
{
if (key_repeats[key] == 1)
anykeydown++;
}
else
{
key_lastrepeat[key] = 0;
anykeydown--;
if (anykeydown < 0)
anykeydown = 0;
}
//
// key up events only generate commands if the game key binding is
// a button command (leading + sign). These will occur even in console mode,
// to keep the character from continuing an action started before a console
// switch. Button commands include the kenum as a parameter, so multiple
// downs can be matched with ups
//
if (!down)
{
//r1ch: only generate -events if key was down (prevents -binds in menu / messagemode)
if (buttondown[key])
{
kb = keybindings[key];
if (kb && kb[0] == '+')
{
Com_sprintf (cmd, sizeof(cmd), "-%s %i %u\n", kb+1, key, time);
Cbuf_AddText (cmd);
}
if (keyshift[key] != key)
{
kb = keybindings[keyshift[key]];
if (kb && kb[0] == '+')
{
Com_sprintf (cmd, sizeof(cmd), "-%s %i %u\n", kb+1, key, time);
Cbuf_AddText (cmd);
}
}
buttondown[key] = false;
}
return;
}
//
// if not a consolekey, send to the interpreter no matter what mode is
//
if ( (cls.key_dest == key_menu && menubound[key])
|| (cls.key_dest == key_console && !consolekeys[key])
|| (cls.key_dest == key_game && ( cls.state == ca_active || !consolekeys[key] ) ) )
{
kb = keybindings[key];
if (kb && kb[0])
{
if (kb[0] == '+')
{
// button commands add keynum and time as a parm
if (cls.key_dest != key_game) //r1: don't run buttons in console
return;
Com_sprintf (cmd, sizeof(cmd), "%s %i %u\n", kb, key, time);
Cbuf_AddText (cmd);
buttondown[key] = true;
}
else
{
Cbuf_AddText (kb);
Cbuf_AddText ("\n");
}
}
return;
}
//if (!down)
// return; // other systems only care about key down events
if (shift_down)
key = keyshift[key];
switch (cls.key_dest)
{
case key_message:
Key_Message (key);
break;
case key_menu:
M_Keydown (key);
break;
case key_game:
case key_console:
Key_Console (key);
break;
default:
Com_Error (ERR_FATAL, "Bad cls.key_dest");
}
}
void IN_SendKeyEvents (void)
{
SDL_Event event;
int sym, state;
int modstate;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_ACTIVEEVENT:
if (event.active.state & (SDL_APPINPUTFOCUS|SDL_APPACTIVE))
{
if (event.active.gain)
{
// Sys_Printf("FOCUS GAIN\n");
S_UnblockSound();
}
else
{
// Sys_Printf("FOCUS LOSS\n");
S_BlockSound();
}
}
break;
case SDL_KEYDOWN:
if ((event.key.keysym.sym == SDLK_RETURN) &&
(event.key.keysym.mod & KMOD_ALT))
{
VID_ToggleFullscreen();
break;
}
else if ((event.key.keysym.sym == SDLK_ESCAPE) &&
(event.key.keysym.mod & KMOD_SHIFT))
{
Con_ToggleConsole_f();
break;
}
else if ((event.key.keysym.sym == SDLK_g) &&
(event.key.keysym.mod & KMOD_CTRL))
{
SDL_WM_GrabInput( (SDL_WM_GrabInput (SDL_GRAB_QUERY) == SDL_GRAB_ON) ? SDL_GRAB_OFF : SDL_GRAB_ON );
break;
}
case SDL_KEYUP:
sym = event.key.keysym.sym;
state = event.key.state;
modstate = SDL_GetModState();
switch (key_dest)
{
case key_game:
if ((event.key.keysym.unicode != 0) || (modstate & KMOD_SHIFT))
{ /* only use unicode for ~ and ` in game mode */
if ((event.key.keysym.unicode & 0xFF80) == 0)
{
if (((event.key.keysym.unicode & 0x7F) == '`') ||
((event.key.keysym.unicode & 0x7F) == '~') )
sym = event.key.keysym.unicode & 0x7F;
}
}
break;
case key_message:
case key_console:
if ((event.key.keysym.unicode != 0) || (modstate & KMOD_SHIFT))
{
#if defined(__QNX__)
if ((sym == SDLK_BACKSPACE) || (sym == SDLK_RETURN))
break; // S.A: fixes QNX weirdness
#endif /* __QNX__ */
if ((event.key.keysym.unicode & 0xFF80) == 0)
sym = event.key.keysym.unicode & 0x7F;
/* else: it's an international character */
}
// printf("You pressed %s (%d) (%c)\n", SDL_GetKeyName(sym), sym, sym);
break;
default:
break;
}
switch (sym)
{
case SDLK_DELETE:
sym = K_DEL;
break;
case SDLK_BACKSPACE:
sym = K_BACKSPACE;
break;
case SDLK_F1:
sym = K_F1;
break;
case SDLK_F2:
sym = K_F2;
break;
case SDLK_F3:
sym = K_F3;
break;
case SDLK_F4:
sym = K_F4;
break;
case SDLK_F5:
sym = K_F5;
break;
case SDLK_F6:
sym = K_F6;
break;
case SDLK_F7:
sym = K_F7;
break;
case SDLK_F8:
sym = K_F8;
break;
case SDLK_F9:
sym = K_F9;
break;
case SDLK_F10:
sym = K_F10;
break;
case SDLK_F11:
sym = K_F11;
break;
case SDLK_F12:
sym = K_F12;
break;
case SDLK_BREAK:
case SDLK_PAUSE:
sym = K_PAUSE;
break;
case SDLK_UP:
sym = K_UPARROW;
break;
case SDLK_DOWN:
sym = K_DOWNARROW;
break;
case SDLK_RIGHT:
sym = K_RIGHTARROW;
break;
case SDLK_LEFT:
sym = K_LEFTARROW;
break;
case SDLK_INSERT:
sym = K_INS;
break;
case SDLK_HOME:
sym = K_HOME;
break;
case SDLK_END:
sym = K_END;
break;
case SDLK_PAGEUP:
sym = K_PGUP;
break;
case SDLK_PAGEDOWN:
sym = K_PGDN;
break;
case SDLK_RSHIFT:
case SDLK_LSHIFT:
sym = K_SHIFT;
break;
case SDLK_RCTRL:
case SDLK_LCTRL:
sym = K_CTRL;
break;
case SDLK_RALT:
case SDLK_LALT:
sym = K_ALT;
break;
case SDLK_KP0:
if (modstate & KMOD_NUM)
sym = K_INS;
else
sym = SDLK_0;
break;
case SDLK_KP1:
if (modstate & KMOD_NUM)
sym = K_END;
else
sym = SDLK_1;
break;
case SDLK_KP2:
if (modstate & KMOD_NUM)
sym = K_DOWNARROW;
else
sym = SDLK_2;
break;
case SDLK_KP3:
if (modstate & KMOD_NUM)
sym = K_PGDN;
else
sym = SDLK_3;
break;
case SDLK_KP4:
if (modstate & KMOD_NUM)
sym = K_LEFTARROW;
else
sym = SDLK_4;
break;
case SDLK_KP5:
sym = SDLK_5;
break;
case SDLK_KP6:
if (modstate & KMOD_NUM)
sym = K_RIGHTARROW;
else
sym = SDLK_6;
break;
case SDLK_KP7:
if (modstate & KMOD_NUM)
sym = K_HOME;
else
sym = SDLK_7;
break;
case SDLK_KP8:
if (modstate & KMOD_NUM)
sym = K_UPARROW;
else
sym = SDLK_8;
break;
case SDLK_KP9:
if (modstate & KMOD_NUM)
sym = K_PGUP;
else
sym = SDLK_9;
break;
case SDLK_KP_PERIOD:
if (modstate & KMOD_NUM)
sym = K_DEL;
else
sym = SDLK_PERIOD;
break;
case SDLK_KP_DIVIDE:
sym = SDLK_SLASH;
break;
case SDLK_KP_MULTIPLY:
sym = SDLK_ASTERISK;
break;
case SDLK_KP_MINUS:
sym = SDLK_MINUS;
break;
case SDLK_KP_PLUS:
sym = SDLK_PLUS;
break;
case SDLK_KP_ENTER:
sym = SDLK_RETURN;
break;
case SDLK_KP_EQUALS:
sym = SDLK_EQUALS;
break;
case 178: /* the '²' key */
sym = '~';
break;
}
// If we're not directly handled and still
// above 255, just force it to 0
if (sym > 255)
sym = 0;
Key_Event (sym, state);
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if (!mouseactive || in_mode_set)
break;
if (event.button.button < 1 ||
event.button.button > sizeof(buttonremap) / sizeof(buttonremap[0]))
{
Con_Printf ("Ignored event for mouse button %d\n",
event.button.button);
break;
}
Key_Event(buttonremap[event.button.button - 1], event.button.state == SDL_PRESSED);
break;
case SDL_MOUSEMOTION:
// SDL_GetMouseState (NULL, NULL);
break;
#if USE_JOYSTICK
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
if (!in_joystick.value)
break;
if (event.jbutton.button > K_AUX32 - K_JOY1)
{
Con_Printf ("Ignored event for joystick button %d\n",
event.jbutton.button);
break;
}
Key_Event(K_JOY1 + event.jbutton.button, event.jbutton.state == SDL_PRESSED);
break;
case SDL_JOYAXISMOTION:
case SDL_JOYHATMOTION:
case SDL_JOYBALLMOTION:
/* to be coded.. */
break;
#endif /* USE_JOYSTICK */
case SDL_QUIT:
CL_Disconnect ();
Sys_Quit ();
break;
default:
break;
}
}
}
