mirror of
https://github.com/TTimo/doom3.gpl.git
synced 2026-03-20 00:49:30 +01:00
hello world
This commit is contained in:
Timothee 'TTimo' Besset
785
neo/framework/KeyInput.cpp
Normal file
785
neo/framework/KeyInput.cpp
Normal file
@@ -0,0 +1,785 @@
|
||||
/*
|
||||
===========================================================================
|
||||
|
||||
Doom 3 GPL Source Code
|
||||
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
||||
|
||||
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
||||
|
||||
Doom 3 Source Code 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 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Doom 3 Source Code 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
||||
|
||||
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
||||
|
||||
===========================================================================
|
||||
*/
|
||||
|
||||
#include "../idlib/precompiled.h"
|
||||
#pragma hdrstop
|
||||
|
||||
typedef struct {
|
||||
char *name;
|
||||
int keynum;
|
||||
char *strId; // localized string id
|
||||
} keyname_t;
|
||||
|
||||
// keys that can be set without a special name
|
||||
static const char unnamedkeys[] = "*,-=./[\\]1234567890abcdefghijklmnopqrstuvwxyz";
|
||||
|
||||
#if MACOS_X
|
||||
const char* OSX_GetLocalizedString( const char* );
|
||||
#endif
|
||||
|
||||
// names not in this list can either be lowercase ascii, or '0xnn' hex sequences
|
||||
keyname_t keynames[] =
|
||||
{
|
||||
{"TAB", K_TAB, "#str_07018"},
|
||||
{"ENTER", K_ENTER, "#str_07019"},
|
||||
{"ESCAPE", K_ESCAPE, "#str_07020"},
|
||||
{"SPACE", K_SPACE, "#str_07021"},
|
||||
{"BACKSPACE", K_BACKSPACE, "#str_07022"},
|
||||
{"UPARROW", K_UPARROW, "#str_07023"},
|
||||
{"DOWNARROW", K_DOWNARROW, "#str_07024"},
|
||||
{"LEFTARROW", K_LEFTARROW, "#str_07025"},
|
||||
{"RIGHTARROW", K_RIGHTARROW, "#str_07026"},
|
||||
|
||||
{"ALT", K_ALT, "#str_07027"},
|
||||
{"RIGHTALT", K_RIGHT_ALT, "#str_07027"},
|
||||
{"CTRL", K_CTRL, "#str_07028"},
|
||||
{"SHIFT", K_SHIFT, "#str_07029"},
|
||||
|
||||
{"LWIN", K_LWIN, "#str_07030"},
|
||||
{"RWIN", K_RWIN, "#str_07031"},
|
||||
{"MENU", K_MENU, "#str_07032"},
|
||||
|
||||
{"COMMAND", K_COMMAND, "#str_07033"},
|
||||
|
||||
{"CAPSLOCK", K_CAPSLOCK, "#str_07034"},
|
||||
{"SCROLL", K_SCROLL, "#str_07035"},
|
||||
{"PRINTSCREEN", K_PRINT_SCR, "#str_07179"},
|
||||
|
||||
{"F1", K_F1, "#str_07036"},
|
||||
{"F2", K_F2, "#str_07037"},
|
||||
{"F3", K_F3, "#str_07038"},
|
||||
{"F4", K_F4, "#str_07039"},
|
||||
{"F5", K_F5, "#str_07040"},
|
||||
{"F6", K_F6, "#str_07041"},
|
||||
{"F7", K_F7, "#str_07042"},
|
||||
{"F8", K_F8, "#str_07043"},
|
||||
{"F9", K_F9, "#str_07044"},
|
||||
{"F10", K_F10, "#str_07045"},
|
||||
{"F11", K_F11, "#str_07046"},
|
||||
{"F12", K_F12, "#str_07047"},
|
||||
|
||||
{"INS", K_INS, "#str_07048"},
|
||||
{"DEL", K_DEL, "#str_07049"},
|
||||
{"PGDN", K_PGDN, "#str_07050"},
|
||||
{"PGUP", K_PGUP, "#str_07051"},
|
||||
{"HOME", K_HOME, "#str_07052"},
|
||||
{"END", K_END, "#str_07053"},
|
||||
|
||||
{"MOUSE1", K_MOUSE1, "#str_07054"},
|
||||
{"MOUSE2", K_MOUSE2, "#str_07055"},
|
||||
{"MOUSE3", K_MOUSE3, "#str_07056"},
|
||||
{"MOUSE4", K_MOUSE4, "#str_07057"},
|
||||
{"MOUSE5", K_MOUSE5, "#str_07058"},
|
||||
{"MOUSE6", K_MOUSE6, "#str_07059"},
|
||||
{"MOUSE7", K_MOUSE7, "#str_07060"},
|
||||
{"MOUSE8", K_MOUSE8, "#str_07061"},
|
||||
|
||||
{"MWHEELUP", K_MWHEELUP, "#str_07131"},
|
||||
{"MWHEELDOWN", K_MWHEELDOWN, "#str_07132"},
|
||||
|
||||
{"JOY1", K_JOY1, "#str_07062"},
|
||||
{"JOY2", K_JOY2, "#str_07063"},
|
||||
{"JOY3", K_JOY3, "#str_07064"},
|
||||
{"JOY4", K_JOY4, "#str_07065"},
|
||||
{"JOY5", K_JOY5, "#str_07066"},
|
||||
{"JOY6", K_JOY6, "#str_07067"},
|
||||
{"JOY7", K_JOY7, "#str_07068"},
|
||||
{"JOY8", K_JOY8, "#str_07069"},
|
||||
{"JOY9", K_JOY9, "#str_07070"},
|
||||
{"JOY10", K_JOY10, "#str_07071"},
|
||||
{"JOY11", K_JOY11, "#str_07072"},
|
||||
{"JOY12", K_JOY12, "#str_07073"},
|
||||
{"JOY13", K_JOY13, "#str_07074"},
|
||||
{"JOY14", K_JOY14, "#str_07075"},
|
||||
{"JOY15", K_JOY15, "#str_07076"},
|
||||
{"JOY16", K_JOY16, "#str_07077"},
|
||||
{"JOY17", K_JOY17, "#str_07078"},
|
||||
{"JOY18", K_JOY18, "#str_07079"},
|
||||
{"JOY19", K_JOY19, "#str_07080"},
|
||||
{"JOY20", K_JOY20, "#str_07081"},
|
||||
{"JOY21", K_JOY21, "#str_07082"},
|
||||
{"JOY22", K_JOY22, "#str_07083"},
|
||||
{"JOY23", K_JOY23, "#str_07084"},
|
||||
{"JOY24", K_JOY24, "#str_07085"},
|
||||
{"JOY25", K_JOY25, "#str_07086"},
|
||||
{"JOY26", K_JOY26, "#str_07087"},
|
||||
{"JOY27", K_JOY27, "#str_07088"},
|
||||
{"JOY28", K_JOY28, "#str_07089"},
|
||||
{"JOY29", K_JOY29, "#str_07090"},
|
||||
{"JOY30", K_JOY30, "#str_07091"},
|
||||
{"JOY31", K_JOY31, "#str_07092"},
|
||||
{"JOY32", K_JOY32, "#str_07093"},
|
||||
|
||||
{"AUX1", K_AUX1, "#str_07094"},
|
||||
{"AUX2", K_AUX2, "#str_07095"},
|
||||
{"AUX3", K_AUX3, "#str_07096"},
|
||||
{"AUX4", K_AUX4, "#str_07097"},
|
||||
{"AUX5", K_AUX5, "#str_07098"},
|
||||
{"AUX6", K_AUX6, "#str_07099"},
|
||||
{"AUX7", K_AUX7, "#str_07100"},
|
||||
{"AUX8", K_AUX8, "#str_07101"},
|
||||
{"AUX9", K_AUX9, "#str_07102"},
|
||||
{"AUX10", K_AUX10, "#str_07103"},
|
||||
{"AUX11", K_AUX11, "#str_07104"},
|
||||
{"AUX12", K_AUX12, "#str_07105"},
|
||||
{"AUX13", K_AUX13, "#str_07106"},
|
||||
{"AUX14", K_AUX14, "#str_07107"},
|
||||
{"AUX15", K_AUX15, "#str_07108"},
|
||||
{"AUX16", K_AUX16, "#str_07109"},
|
||||
|
||||
{"KP_HOME", K_KP_HOME, "#str_07110"},
|
||||
{"KP_UPARROW", K_KP_UPARROW, "#str_07111"},
|
||||
{"KP_PGUP", K_KP_PGUP, "#str_07112"},
|
||||
{"KP_LEFTARROW", K_KP_LEFTARROW, "#str_07113"},
|
||||
{"KP_5", K_KP_5, "#str_07114"},
|
||||
{"KP_RIGHTARROW", K_KP_RIGHTARROW, "#str_07115"},
|
||||
{"KP_END", K_KP_END, "#str_07116"},
|
||||
{"KP_DOWNARROW", K_KP_DOWNARROW, "#str_07117"},
|
||||
{"KP_PGDN", K_KP_PGDN, "#str_07118"},
|
||||
{"KP_ENTER", K_KP_ENTER, "#str_07119"},
|
||||
{"KP_INS", K_KP_INS, "#str_07120"},
|
||||
{"KP_DEL", K_KP_DEL, "#str_07121"},
|
||||
{"KP_SLASH", K_KP_SLASH, "#str_07122"},
|
||||
{"KP_MINUS", K_KP_MINUS, "#str_07123"},
|
||||
{"KP_PLUS", K_KP_PLUS, "#str_07124"},
|
||||
{"KP_NUMLOCK", K_KP_NUMLOCK, "#str_07125"},
|
||||
{"KP_STAR", K_KP_STAR, "#str_07126"},
|
||||
{"KP_EQUALS", K_KP_EQUALS, "#str_07127"},
|
||||
|
||||
{"PAUSE", K_PAUSE, "#str_07128"},
|
||||
|
||||
{"SEMICOLON", ';', "#str_07129"}, // because a raw semicolon separates commands
|
||||
{"APOSTROPHE", '\'', "#str_07130"}, // because a raw apostrophe messes with parsing
|
||||
|
||||
{NULL, 0, NULL}
|
||||
};
|
||||
|
||||
|
||||
|
||||
static const int MAX_KEYS = 256;
|
||||
|
||||
class idKey {
|
||||
public:
|
||||
idKey( void ) { down = false; repeats = 0; usercmdAction = 0; }
|
||||
bool down;
|
||||
int repeats; // if > 1, it is autorepeating
|
||||
idStr binding;
|
||||
int usercmdAction; // for testing by the asyncronous usercmd generation
|
||||
};
|
||||
|
||||
bool key_overstrikeMode = false;
|
||||
idKey * keys = NULL;
|
||||
|
||||
#define ID_DOOM_LEGACY
|
||||
|
||||
#ifdef ID_DOOM_LEGACY
|
||||
|
||||
char * cheatCodes[] = {
|
||||
"iddqd", // Invincibility
|
||||
"idkfa", // All weapons, keys, ammo, and 200% armor
|
||||
"idfa", // Reset ammunition
|
||||
"idspispopd", // Walk through walls
|
||||
"idclip", // Walk through walls
|
||||
"idchoppers", // Chainsaw
|
||||
/*
|
||||
"idbeholds", // Berserker strength
|
||||
"idbeholdv", // Temporary invincibility
|
||||
"idbeholdi", // Temporary invisibility
|
||||
"idbeholda", // Full automap
|
||||
"idbeholdr", // Anti-radiation suit
|
||||
"idbeholdl", // Light amplification visor
|
||||
"idclev", // Level select
|
||||
"iddt", // Toggle full map; full map and objects; normal map
|
||||
"idmypos", // Display coordinates and heading
|
||||
"idmus", // Change music to indicated level
|
||||
"fhhall", // Kill all enemies in level
|
||||
"fhshh", // Invisible to enemies until attack
|
||||
*/
|
||||
NULL
|
||||
};
|
||||
char lastKeys[32];
|
||||
int lastKeyIndex;
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::ArgCompletion_KeyName
|
||||
===================
|
||||
*/
|
||||
void idKeyInput::ArgCompletion_KeyName( const idCmdArgs &args, void(*callback)( const char *s ) ) {
|
||||
keyname_t *kn;
|
||||
int i;
|
||||
|
||||
for( i = 0; i < sizeof( unnamedkeys ) - 1; i++ ) {
|
||||
callback( va( "%s %c", args.Argv( 0 ), unnamedkeys[ i ] ) );
|
||||
}
|
||||
|
||||
for ( kn = keynames; kn->name; kn++ ) {
|
||||
callback( va( "%s %s", args.Argv( 0 ), kn->name ) );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::GetOverstrikeMode
|
||||
===================
|
||||
*/
|
||||
bool idKeyInput::GetOverstrikeMode( void ) {
|
||||
return key_overstrikeMode;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::SetOverstrikeMode
|
||||
===================
|
||||
*/
|
||||
void idKeyInput::SetOverstrikeMode( bool state ) {
|
||||
key_overstrikeMode = state;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::IsDown
|
||||
===================
|
||||
*/
|
||||
bool idKeyInput::IsDown( int keynum ) {
|
||||
if ( keynum == -1 ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return keys[keynum].down;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::StringToKeyNum
|
||||
|
||||
Returns a key number to be used to index keys[] by looking at
|
||||
the given string. Single ascii characters return themselves, while
|
||||
the K_* names are matched up.
|
||||
|
||||
0x11 will be interpreted as raw hex, which will allow new controlers
|
||||
to be configured even if they don't have defined names.
|
||||
===================
|
||||
*/
|
||||
int idKeyInput::StringToKeyNum( const char *str ) {
|
||||
keyname_t *kn;
|
||||
|
||||
if ( !str || !str[0] ) {
|
||||
return -1;
|
||||
}
|
||||
if ( !str[1] ) {
|
||||
return (unsigned char)(str[0]);
|
||||
}
|
||||
|
||||
// check for hex code
|
||||
if ( str[0] == '0' && str[1] == 'x' && strlen( str ) == 4 ) {
|
||||
int n1, n2;
|
||||
|
||||
n1 = str[2];
|
||||
if ( n1 >= '0' && n1 <= '9' ) {
|
||||
n1 -= '0';
|
||||
} else if ( n1 >= 'a' && n1 <= 'f' ) {
|
||||
n1 = n1 - 'a' + 10;
|
||||
} else {
|
||||
n1 = 0;
|
||||
}
|
||||
|
||||
n2 = str[3];
|
||||
if ( n2 >= '0' && n2 <= '9' ) {
|
||||
n2 -= '0';
|
||||
} else if ( n2 >= 'a' && n2 <= 'f' ) {
|
||||
n2 = n2 - 'a' + 10;
|
||||
} else {
|
||||
n2 = 0;
|
||||
}
|
||||
|
||||
return n1 * 16 + n2;
|
||||
}
|
||||
|
||||
// scan for a text match
|
||||
for ( kn = keynames; kn->name; kn++ ) {
|
||||
if ( !idStr::Icmp( str, kn->name ) ) {
|
||||
return kn->keynum;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::KeyNumToString
|
||||
|
||||
Returns a string (either a single ascii char, a K_* name, or a 0x11 hex string) for the
|
||||
given keynum.
|
||||
===================
|
||||
*/
|
||||
const char *idKeyInput::KeyNumToString( int keynum, bool localized ) {
|
||||
keyname_t *kn;
|
||||
static char tinystr[5];
|
||||
int i, j;
|
||||
|
||||
if ( keynum == -1 ) {
|
||||
return "<KEY NOT FOUND>";
|
||||
}
|
||||
|
||||
if ( keynum < 0 || keynum > 255 ) {
|
||||
return "<OUT OF RANGE>";
|
||||
}
|
||||
|
||||
// check for printable ascii (don't use quote)
|
||||
if ( keynum > 32 && keynum < 127 && keynum != '"' && keynum != ';' && keynum != '\'' ) {
|
||||
tinystr[0] = Sys_MapCharForKey( keynum );
|
||||
tinystr[1] = 0;
|
||||
return tinystr;
|
||||
}
|
||||
|
||||
// check for a key string
|
||||
for ( kn = keynames; kn->name; kn++ ) {
|
||||
if ( keynum == kn->keynum ) {
|
||||
if ( !localized || kn->strId[0] != '#' ) {
|
||||
return kn->name;
|
||||
} else {
|
||||
#if MACOS_X
|
||||
|
||||
switch ( kn->keynum ) {
|
||||
case K_ENTER:
|
||||
case K_BACKSPACE:
|
||||
case K_ALT:
|
||||
case K_INS:
|
||||
case K_PRINT_SCR:
|
||||
return OSX_GetLocalizedString( kn->name );
|
||||
break;
|
||||
default :
|
||||
return common->GetLanguageDict()->GetString( kn->strId ); break;
|
||||
}
|
||||
#else
|
||||
return common->GetLanguageDict()->GetString( kn->strId );
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// check for European high-ASCII characters
|
||||
if ( localized && keynum >= 161 && keynum <= 255 ) {
|
||||
tinystr[0] = keynum;
|
||||
tinystr[1] = 0;
|
||||
return tinystr;
|
||||
}
|
||||
|
||||
// make a hex string
|
||||
i = keynum >> 4;
|
||||
j = keynum & 15;
|
||||
|
||||
tinystr[0] = '0';
|
||||
tinystr[1] = 'x';
|
||||
tinystr[2] = i > 9 ? i - 10 + 'a' : i + '0';
|
||||
tinystr[3] = j > 9 ? j - 10 + 'a' : j + '0';
|
||||
tinystr[4] = 0;
|
||||
|
||||
return tinystr;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::SetBinding
|
||||
===================
|
||||
*/
|
||||
void idKeyInput::SetBinding( int keynum, const char *binding ) {
|
||||
if ( keynum == -1 ) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Clear out all button states so we aren't stuck forever thinking this key is held down
|
||||
usercmdGen->Clear();
|
||||
|
||||
// allocate memory for new binding
|
||||
keys[keynum].binding = binding;
|
||||
|
||||
// find the action for the async command generation
|
||||
keys[keynum].usercmdAction = usercmdGen->CommandStringUsercmdData( binding );
|
||||
|
||||
// consider this like modifying an archived cvar, so the
|
||||
// file write will be triggered at the next oportunity
|
||||
cvarSystem->SetModifiedFlags( CVAR_ARCHIVE );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::GetBinding
|
||||
===================
|
||||
*/
|
||||
const char *idKeyInput::GetBinding( int keynum ) {
|
||||
if ( keynum == -1 ) {
|
||||
return "";
|
||||
}
|
||||
|
||||
return keys[ keynum ].binding;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::GetUsercmdAction
|
||||
===================
|
||||
*/
|
||||
int idKeyInput::GetUsercmdAction( int keynum ) {
|
||||
return keys[ keynum ].usercmdAction;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
Key_Unbind_f
|
||||
===================
|
||||
*/
|
||||
void Key_Unbind_f( const idCmdArgs &args ) {
|
||||
int b;
|
||||
|
||||
if ( args.Argc() != 2 ) {
|
||||
common->Printf( "unbind <key> : remove commands from a key\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
b = idKeyInput::StringToKeyNum( args.Argv(1) );
|
||||
if ( b == -1 ) {
|
||||
// If it wasn't a key, it could be a command
|
||||
if ( !idKeyInput::UnbindBinding( args.Argv(1) ) ) {
|
||||
common->Printf( "\"%s\" isn't a valid key\n", args.Argv(1) );
|
||||
}
|
||||
} else {
|
||||
idKeyInput::SetBinding( b, "" );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
Key_Unbindall_f
|
||||
===================
|
||||
*/
|
||||
void Key_Unbindall_f( const idCmdArgs &args ) {
|
||||
int i;
|
||||
|
||||
for ( i = 0; i < MAX_KEYS; i++ ) {
|
||||
idKeyInput::SetBinding( i, "" );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
Key_Bind_f
|
||||
===================
|
||||
*/
|
||||
void Key_Bind_f( const idCmdArgs &args ) {
|
||||
int i, c, b;
|
||||
char cmd[MAX_STRING_CHARS];
|
||||
|
||||
c = args.Argc();
|
||||
|
||||
if ( c < 2 ) {
|
||||
common->Printf( "bind <key> [command] : attach a command to a key\n" );
|
||||
return;
|
||||
}
|
||||
b = idKeyInput::StringToKeyNum( args.Argv(1) );
|
||||
if ( b == -1 ) {
|
||||
common->Printf( "\"%s\" isn't a valid key\n", args.Argv(1) );
|
||||
return;
|
||||
}
|
||||
|
||||
if ( c == 2 ) {
|
||||
if ( keys[b].binding.Length() ) {
|
||||
common->Printf( "\"%s\" = \"%s\"\n", args.Argv(1), keys[b].binding.c_str() );
|
||||
}
|
||||
else {
|
||||
common->Printf( "\"%s\" is not bound\n", args.Argv(1) );
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// copy the rest of the command line
|
||||
cmd[0] = 0; // start out with a null string
|
||||
for ( i = 2; i < c; i++ ) {
|
||||
strcat( cmd, args.Argv( i ) );
|
||||
if ( i != (c-1) ) {
|
||||
strcat( cmd, " " );
|
||||
}
|
||||
}
|
||||
|
||||
idKeyInput::SetBinding( b, cmd );
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
Key_BindUnBindTwo_f
|
||||
|
||||
binds keynum to bindcommand and unbinds if there are already two binds on the key
|
||||
============
|
||||
*/
|
||||
void Key_BindUnBindTwo_f( const idCmdArgs &args ) {
|
||||
int c = args.Argc();
|
||||
if ( c < 3 ) {
|
||||
common->Printf( "bindunbindtwo <keynum> [command]\n" );
|
||||
return;
|
||||
}
|
||||
int key = atoi( args.Argv( 1 ) );
|
||||
idStr bind = args.Argv( 2 );
|
||||
if ( idKeyInput::NumBinds( bind ) >= 2 && !idKeyInput::KeyIsBoundTo( key, bind ) ) {
|
||||
idKeyInput::UnbindBinding( bind );
|
||||
}
|
||||
idKeyInput::SetBinding( key, bind );
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
============
|
||||
idKeyInput::WriteBindings
|
||||
|
||||
Writes lines containing "bind key value"
|
||||
============
|
||||
*/
|
||||
void idKeyInput::WriteBindings( idFile *f ) {
|
||||
int i;
|
||||
|
||||
f->Printf( "unbindall\n" );
|
||||
|
||||
for ( i = 0; i < MAX_KEYS; i++ ) {
|
||||
if ( keys[i].binding.Length() ) {
|
||||
const char *name = KeyNumToString( i, false );
|
||||
|
||||
// handle the escape character nicely
|
||||
if ( !strcmp( name, "\\" ) ) {
|
||||
f->Printf( "bind \"\\\" \"%s\"\n", keys[i].binding.c_str() );
|
||||
} else {
|
||||
f->Printf( "bind \"%s\" \"%s\"\n", KeyNumToString( i, false ), keys[i].binding.c_str() );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
Key_ListBinds_f
|
||||
============
|
||||
*/
|
||||
void Key_ListBinds_f( const idCmdArgs &args ) {
|
||||
int i;
|
||||
|
||||
for ( i = 0; i < MAX_KEYS; i++ ) {
|
||||
if ( keys[i].binding.Length() ) {
|
||||
common->Printf( "%s \"%s\"\n", idKeyInput::KeyNumToString( i, false ), keys[i].binding.c_str() );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
idKeyInput::KeysFromBinding
|
||||
returns the localized name of the key for the binding
|
||||
============
|
||||
*/
|
||||
const char *idKeyInput::KeysFromBinding( const char *bind ) {
|
||||
int i;
|
||||
static char keyName[MAX_STRING_CHARS];
|
||||
|
||||
keyName[0] = '\0';
|
||||
if ( bind && *bind ) {
|
||||
for ( i = 0; i < MAX_KEYS; i++ ) {
|
||||
if ( keys[i].binding.Icmp( bind ) == 0 ) {
|
||||
if ( keyName[0] != '\0' ) {
|
||||
idStr::Append( keyName, sizeof( keyName ), common->GetLanguageDict()->GetString( "#str_07183" ) );
|
||||
}
|
||||
idStr::Append( keyName, sizeof( keyName ), KeyNumToString( i, true ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( keyName[0] == '\0' ) {
|
||||
idStr::Copynz( keyName, common->GetLanguageDict()->GetString( "#str_07133" ), sizeof( keyName ) );
|
||||
}
|
||||
idStr::ToLower( keyName );
|
||||
return keyName;
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
idKeyInput::BindingFromKey
|
||||
returns the binding for the localized name of the key
|
||||
============
|
||||
*/
|
||||
const char *idKeyInput::BindingFromKey( const char *key ) {
|
||||
const int keyNum = idKeyInput::StringToKeyNum( key );
|
||||
if ( keyNum<0 || keyNum >= MAX_KEYS ) {
|
||||
return NULL;
|
||||
}
|
||||
return keys[keyNum].binding.c_str();
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
idKeyInput::UnbindBinding
|
||||
============
|
||||
*/
|
||||
bool idKeyInput::UnbindBinding( const char *binding ) {
|
||||
bool unbound = false;
|
||||
int i;
|
||||
|
||||
if ( binding && *binding ) {
|
||||
for ( i = 0; i < MAX_KEYS; i++ ) {
|
||||
if ( keys[i].binding.Icmp( binding ) == 0 ) {
|
||||
SetBinding( i, "" );
|
||||
unbound = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return unbound;
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
idKeyInput::NumBinds
|
||||
============
|
||||
*/
|
||||
int idKeyInput::NumBinds( const char *binding ) {
|
||||
int i, count = 0;
|
||||
|
||||
if ( binding && *binding ) {
|
||||
for ( i = 0; i < MAX_KEYS; i++ ) {
|
||||
if ( keys[i].binding.Icmp( binding ) == 0 ) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
idKeyInput::KeyIsBountTo
|
||||
============
|
||||
*/
|
||||
bool idKeyInput::KeyIsBoundTo( int keynum, const char *binding ) {
|
||||
if ( keynum >= 0 && keynum < MAX_KEYS ) {
|
||||
return ( keys[keynum].binding.Icmp( binding ) == 0 );
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::PreliminaryKeyEvent
|
||||
|
||||
Tracks global key up/down state
|
||||
Called by the system for both key up and key down events
|
||||
===================
|
||||
*/
|
||||
void idKeyInput::PreliminaryKeyEvent( int keynum, bool down ) {
|
||||
keys[keynum].down = down;
|
||||
|
||||
#ifdef ID_DOOM_LEGACY
|
||||
if ( down ) {
|
||||
lastKeys[ 0 + ( lastKeyIndex & 15 )] = keynum;
|
||||
lastKeys[16 + ( lastKeyIndex & 15 )] = keynum;
|
||||
lastKeyIndex = ( lastKeyIndex + 1 ) & 15;
|
||||
for ( int i = 0; cheatCodes[i] != NULL; i++ ) {
|
||||
int l = strlen( cheatCodes[i] );
|
||||
assert( l <= 16 );
|
||||
if ( idStr::Icmpn( lastKeys + 16 + ( lastKeyIndex & 15 ) - l, cheatCodes[i], l ) == 0 ) {
|
||||
common->Printf( "your memory serves you well!\n" );
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
idKeyInput::ExecKeyBinding
|
||||
=================
|
||||
*/
|
||||
bool idKeyInput::ExecKeyBinding( int keynum ) {
|
||||
// commands that are used by the async thread
|
||||
// don't add text
|
||||
if ( keys[keynum].usercmdAction ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// send the bound action
|
||||
if ( keys[keynum].binding.Length() ) {
|
||||
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, keys[keynum].binding.c_str() );
|
||||
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "\n" );
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::ClearStates
|
||||
===================
|
||||
*/
|
||||
void idKeyInput::ClearStates( void ) {
|
||||
int i;
|
||||
|
||||
for ( i = 0; i < MAX_KEYS; i++ ) {
|
||||
if ( keys[i].down ) {
|
||||
PreliminaryKeyEvent( i, false );
|
||||
}
|
||||
keys[i].down = false;
|
||||
}
|
||||
|
||||
// clear the usercommand states
|
||||
usercmdGen->Clear();
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::Init
|
||||
===================
|
||||
*/
|
||||
void idKeyInput::Init( void ) {
|
||||
|
||||
keys = new idKey[MAX_KEYS];
|
||||
|
||||
// register our functions
|
||||
cmdSystem->AddCommand( "bind", Key_Bind_f, CMD_FL_SYSTEM, "binds a command to a key", idKeyInput::ArgCompletion_KeyName );
|
||||
cmdSystem->AddCommand( "bindunbindtwo", Key_BindUnBindTwo_f, CMD_FL_SYSTEM, "binds a key but unbinds it first if there are more than two binds" );
|
||||
cmdSystem->AddCommand( "unbind", Key_Unbind_f, CMD_FL_SYSTEM, "unbinds any command from a key", idKeyInput::ArgCompletion_KeyName );
|
||||
cmdSystem->AddCommand( "unbindall", Key_Unbindall_f, CMD_FL_SYSTEM, "unbinds any commands from all keys" );
|
||||
cmdSystem->AddCommand( "listBinds", Key_ListBinds_f, CMD_FL_SYSTEM, "lists key bindings" );
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
idKeyInput::Shutdown
|
||||
===================
|
||||
*/
|
||||
void idKeyInput::Shutdown( void ) {
|
||||
delete [] keys;
|
||||
keys = NULL;
|
||||
}
|
||||
Reference in New Issue
Block a user