OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1871 Commits
81 Branches
23 Tags
172 MiB
Tree: d08a9c8cfa
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd08a9c8cfa'
${ noResults }
CWE-ou-minkata/Sources/Plasma/NucleusLib/pnInputCore/plInputMap.cpp

1113 lines
32 KiB
Raw Normal View History Unescape

Fix line endings and tabs
14 years ago
/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Open source re-licensing
13 years ago
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
Fix line endings and tabs
14 years ago
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
// plInputDevice.cpp
#include <string>
#include "plInputMap.h"
#include "plKeyMap.h"
HeadSpin.h is now the core header. Rearrange some things so such that low-level CoreLib headers aren't quite so crazy. For higher level stuff, you still need to include the appropriate header.
13 years ago
Fix line endings and tabs
14 years ago
#include "plResMgr/plLocalization.h"
ControlEventCode plInputMap::ConvertCharToControlCode(const char* c)
{
for (int i = 0; fCmdConvert[i].fCode != END_CONTROLS; i++)
{
if (stricmp(fCmdConvert[i].fDesc, c) == 0)
return (fCmdConvert[i].fCode);
}
return (END_CONTROLS);
}
const char *plInputMap::ConvertControlCodeToString( ControlEventCode code )
{
for( int i = 0; fCmdConvert[ i ].fCode != END_CONTROLS; i++ )
{
if( fCmdConvert[ i ].fCode == code )
return fCmdConvert[ i ].fDesc;
}
return nil;
}
//
// plMouseMap
//
plMouseMap::~plMouseMap()
{
for (int i = 0; i < fMap.Count(); i++)
delete(fMap[i]);
fMap.SetCountAndZero(0);
}
int plMouseMap::AddMapping(plMouseInfo* pNfo)
{
for (int i = 0; i < fMap.Count(); i++)
{
if (fMap[i] == pNfo)
return -1;
}
fMap.Append(pNfo);
return (fMap.Count() - 1);
}
//// plKeyBinding and Smaller Classes ////////////////////////////////////////
plKeyCombo::plKeyCombo()
{
fKey = KEY_UNMAPPED;
fFlags = 0;
}
Obliterate hsBool
12 years ago
bool plKeyCombo::IsSatisfiedBy(const plKeyCombo &combo) const
Fix line endings and tabs
14 years ago
{
if (fKey != combo.fKey)
return false;
if ((fFlags & kShift) && !(combo.fFlags & kShift))
return false;
if ((fFlags & kCtrl) && !(combo.fFlags & kCtrl))
return false;
return true;
}
// Handy konstant for plKeyCombos
plKeyCombo plKeyCombo::kUnmapped = plKeyCombo( KEY_UNMAPPED, 0 );
plKeyBinding::plKeyBinding()
{
fCode = END_CONTROLS;
fCodeFlags = 0;
fKey1 = plKeyCombo::kUnmapped;
fKey2 = plKeyCombo::kUnmapped;
fString = nil;
}
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
plKeyBinding::plKeyBinding( ControlEventCode code, uint32_t codeFlags, const plKeyCombo &key1, const plKeyCombo &key2, const char *string /*= nil*/ )
Fix line endings and tabs
14 years ago
{
fCode = code;
fCodeFlags = codeFlags;
fKey1 = key1;
fKey2 = key2;
fString = ( string == nil ) ? nil : hsStrcpy( string );
}
plKeyBinding::~plKeyBinding()
{
delete [] fString;
}
const plKeyCombo &plKeyBinding::GetMatchingKey( plKeyDef keyDef ) const
{
if (fKey1.fKey == keyDef)
return fKey1;
if (fKey2.fKey == keyDef)
return fKey2;
return plKeyCombo::kUnmapped;
}
void plKeyBinding::SetKey1( const plKeyCombo &newCombo )
{
fKey1 = newCombo;
}
void plKeyBinding::SetKey2( const plKeyCombo &newCombo )
{
fKey2 = newCombo;
}
void plKeyBinding::ClearKeys( void )
{
fKey1 = fKey2 = plKeyCombo::kUnmapped;
}
Obliterate hsBool
12 years ago
bool plKeyBinding::HasUnmappedKey() const
Fix line endings and tabs
14 years ago
{
return fKey1.fKey == KEY_UNMAPPED || fKey2.fKey == KEY_UNMAPPED;
}
//////////////////////////////////////////////////////////////////////////////
//// plKeyMap Implementation /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
plKeyMap::plKeyMap()
{
}
plKeyMap::~plKeyMap()
{
ClearAll();
}
void plKeyMap::ClearAll( void )
{
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
uint32_t i;
Fix line endings and tabs
14 years ago
for( i = 0; i < fBindings.GetCount(); i++ )
delete fBindings[ i ];
fBindings.Reset();
}
//// AddCode //////////////////////////////////////////////////////////////////////////
// Adds a given control code to the map. Once you add it, you can't change its flags.
// Returns false if the code is already present
Obliterate hsBool
12 years ago
bool plKeyMap::AddCode( ControlEventCode code, uint32_t codeFlags )
Fix line endings and tabs
14 years ago
{
if( IFindBinding( code ) != nil )
return false;
Get rid of NEW(), TRACKED_NEW, and ZERO().
13 years ago
fBindings.Append( new plKeyBinding( code, codeFlags, plKeyCombo::kUnmapped, plKeyCombo::kUnmapped ) );
Fix line endings and tabs
14 years ago
return true;
}
//// AddConsoleCommand ///////////////////////////////////////////////////////
// Same but for console commands. No flags b/c console commands always use
// the same flags.
Obliterate hsBool
12 years ago
bool plKeyMap::AddConsoleCommand( const char *command )
Fix line endings and tabs
14 years ago
{
if( IFindConsoleBinding( command ) != nil )
return false;
Get rid of NEW(), TRACKED_NEW, and ZERO().
13 years ago
fBindings.Append( new plKeyBinding( B_CONTROL_CONSOLE_COMMAND,
Fix line endings and tabs
14 years ago
kControlFlagDownEvent | kControlFlagNoRepeat | kControlFlagNoDeactivate,
plKeyCombo::kUnmapped, plKeyCombo::kUnmapped,
command ) );
return true;
}
//// IFindBinding ////////////////////////////////////////////////////////////
// Find the binding for a given code.
plKeyBinding *plKeyMap::IFindBinding( ControlEventCode code ) const
{
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
uint32_t i;
Fix line endings and tabs
14 years ago
for( i = 0; i < fBindings.GetCount(); i++ )
{
if( fBindings[ i ]->GetCode() == code )
return fBindings[ i ];
}
return nil;
}
//// IFindBindingByKey ///////////////////////////////////////////////////////
// Find the binding for a given key.
plKeyBinding *plKeyMap::IFindBindingByKey( const plKeyCombo &combo ) const
{
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
uint32_t i;
Fix line endings and tabs
14 years ago
for( i = 0; i < fBindings.GetCount(); i++ )
{
if( fBindings[ i ]->GetKey1() == combo || fBindings[ i ]->GetKey2() == combo )
return fBindings[ i ];
}
return nil;
}
// Find ALL bindings that could be triggered by this combo. Meaning that if we have multiple
// bindings for a key with different shift/ctrl combinations, we want any that are satisfied with
// the given combo.
// We guarantee that the first binding in the result array is that one with priority.
void plKeyMap::IFindAllBindingsByKey(const plKeyCombo &combo, hsTArray<plKeyBinding*> &result) const
{
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
uint32_t i;
uint8_t bestScore = 0;
Fix line endings and tabs
14 years ago
for (i = 0; i < fBindings.GetCount(); i++)
{
Obliterate hsBool
12 years ago
bool s1, s2;
Fix line endings and tabs
14 years ago
s1 = fBindings[i]->GetKey1().IsSatisfiedBy(combo);
s2 = fBindings[i]->GetKey2().IsSatisfiedBy(combo);
if (s1 || s2)
{
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
uint8_t myScore = 0;
Fix line endings and tabs
14 years ago
if (s1)
myScore = fBindings[i]->GetKey1().fFlags;
if (s2 && (fBindings[i]->GetKey2().fFlags > myScore))
myScore = fBindings[i]->GetKey2().fFlags;
if (myScore >= bestScore)
result.Insert(0, fBindings[i]);
else
result.Append(fBindings[i]);
}
}
}
//// IFindConsoleBinding /////////////////////////////////////////////////////
// You should be able to figure this out by now.
plKeyBinding *plKeyMap::IFindConsoleBinding( const char *command ) const
{
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
uint32_t i;
Fix line endings and tabs
14 years ago
for( i = 0; i < fBindings.GetCount(); i++ )
{
if( fBindings[ i ]->GetCode() == B_CONTROL_CONSOLE_COMMAND )
{
if( stricmp( fBindings[ i ]->GetExtendedString(), command ) == 0 )
return fBindings[ i ];
}
}
return nil;
}
//// IActuallyBind ///////////////////////////////////////////////////////////
// Does the nitty gritty of binding by pref
void plKeyMap::IActuallyBind( plKeyBinding *binding, const plKeyCombo &combo, BindPref pref )
{
// Bind according to preference
switch( pref )
{
case kNoPreference:
// Pick a free slot, or 1st one if none
if( binding->GetKey1() == plKeyCombo::kUnmapped )
binding->SetKey1( combo );
else if( binding->GetKey2() == plKeyCombo::kUnmapped )
binding->SetKey2( combo );
else
binding->SetKey1( combo );
break;
case kNoPreference2nd:
// Pick a free slot, or 2nd one if none
if( binding->GetKey1() == plKeyCombo::kUnmapped )
binding->SetKey1( combo );
else if( binding->GetKey2() == plKeyCombo::kUnmapped )
binding->SetKey2( combo );
else
binding->SetKey2( combo );
break;
case kFirstAlways:
// Always bind to the first key
binding->SetKey1( combo );
break;
case kSecondAlways:
// You get the idea
binding->SetKey2( combo );
break;
default:
hsAssert( false, "Invalid bind preference in IActuallyBind()" );
}
}
//// BindKey /////////////////////////////////////////////////////////////////
// Adds a key binding to a given code. Returns false if the code isn't in
// this map or if key is already mapped.
Obliterate hsBool
12 years ago
bool plKeyMap::BindKey( const plKeyCombo &combo, ControlEventCode code, BindPref pref /*= kNoPreference*/ )
Fix line endings and tabs
14 years ago
{
plKeyBinding* binding = nil;
// Control combos are ok. Binding directly to control is not.
if ( combo.fKey == KEY_CTRL )
return false;
// unless we are bindind to unmappped...
if ( combo.fKey != KEY_UNMAPPED)
{
// Make sure key isn't already used
binding = IFindBindingByKey( combo );
if( binding != nil )
return false;
}
// Get binding for this code
binding = IFindBinding( code );
if( binding == nil )
return false;
IActuallyBind( binding, combo, pref );
return true;
}
//// BindKeyToConsoleCmd /////////////////////////////////////////////////////
// Console command version
Obliterate hsBool
12 years ago
bool plKeyMap::BindKeyToConsoleCmd( const plKeyCombo &combo, const char *command, BindPref pref /*= kNoPreference*/ )
Fix line endings and tabs
14 years ago
{
plKeyBinding* binding = nil;
// Control combos are ok. Binding directly to control is not.
if ( combo.fKey == KEY_CTRL )
return false;
// unless we are bindind to unmappped...
if ( combo.fKey != KEY_UNMAPPED)
{
// Make sure key isn't already used
binding = IFindBindingByKey( combo );
if( binding != nil )
return false;
}
// Get binding for this code
binding = IFindConsoleBinding( command );
if( binding == nil )
return false;
IActuallyBind( binding, combo, pref );
return true;
}
//// FindBinding /////////////////////////////////////////////////////////////
// Searches for the binding for a given code. Returns nil if not found
const plKeyBinding *plKeyMap::FindBinding( ControlEventCode code ) const
{
return IFindBinding( code );
}
//// FindBindingByKey ////////////////////////////////////////////////////////
// Same thing but by key
const plKeyBinding *plKeyMap::FindBindingByKey( const plKeyCombo &combo ) const
{
return IFindBindingByKey( combo );
}
// Same thing, but returns multiple matches (see IFindAllBindingsByKey)
void plKeyMap::FindAllBindingsByKey( const plKeyCombo &combo, hsTArray<const plKeyBinding*> &result ) const
{
hsTArray<plKeyBinding*> bindings;
IFindAllBindingsByKey( combo, bindings );
int i;
for (i = 0; i < bindings.GetCount(); i++)
result.Append(bindings[i]);
}
const plKeyBinding* plKeyMap::FindConsoleBinding( const char *command ) const
{
return IFindConsoleBinding(command);
}
//// EnsureKeysClear /////////////////////////////////////////////////////////
// Basically UnmapKey(), but for two keys at once and won't assert if you
// give it unmapped keys
void plKeyMap::EnsureKeysClear( const plKeyCombo &key1, const plKeyCombo &key2 )
{
if( key1 != plKeyCombo::kUnmapped )
UnmapKey( key1 );
if( key2 != plKeyCombo::kUnmapped )
UnmapKey( key2 );
}
//// UnmapKey ////////////////////////////////////////////////////////////////
// Unmaps the given key, no matter what binding it is in
void plKeyMap::UnmapKey( const plKeyCombo &combo )
{
if( combo == plKeyCombo::kUnmapped )
{
hsAssert( false, "Trying to unbind invalid key" );
return;
}
plKeyBinding *binding;
// Just in case we're in multiple bindings, even tho we are guarding against
// that
while( ( binding = IFindBindingByKey( combo ) ) != nil )
{
if( binding->GetKey1() == combo )
binding->SetKey1( plKeyCombo::kUnmapped );
if( binding->GetKey2() == combo )
binding->SetKey2( plKeyCombo::kUnmapped );
}
}
//// UnmapBinding ////////////////////////////////////////////////////////////
// Unmaps the keys for a single binding
void plKeyMap::UnmapBinding( ControlEventCode code )
{
plKeyBinding *binding = IFindBinding( code );
if( binding != nil )
binding->ClearKeys();
}
//// UnmapAllBindings ////////////////////////////////////////////////////////
// Unmaps all the bindings, but leaves the code records themselves
void plKeyMap::UnmapAllBindings( void )
{
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
uint32_t i;
Fix line endings and tabs
14 years ago
for( i = 0; i < fBindings.GetCount(); i++ )
fBindings[ i ]->ClearKeys();
}
//// EraseBinding ////////////////////////////////////////////////////////////
// Erases the given code binding. Note: should never really be used, but
// provided here for completeness
void plKeyMap::EraseBinding( ControlEventCode code )
{
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
uint32_t i;
Fix line endings and tabs
14 years ago
for( i = 0; i < fBindings.GetCount(); i++ )
{
if( fBindings[ i ]->GetCode() == code )
{
delete fBindings[ i ];
fBindings.Remove( i );
return;
}
}
}
Convert custom HeadSpin integer types to standard types from stdint.h
13 years ago
const char* plKeyMap::ConvertVKeyToChar( uint32_t vk )
Fix line endings and tabs
14 years ago
{
Win32keyConvert* keyConvert = &fKeyConversionEnglish[0];
switch (plLocalization::GetLanguage())
{
case plLocalization::kFrench:
keyConvert = &fKeyConversionFrench[0];
break;
case plLocalization::kGerman:
keyConvert = &fKeyConversionGerman[0];
break;
// case plLocalization::kSpanish:
// keyConvert = &fKeyConversionSpanish[0];
// break;
// case plLocalization::kItalian:
// keyConvert = &fKeyConversionItalian[0];
// break;
// default is English
}
for (int i = 0; keyConvert[i].fVKey != 0xffffffff; i++)
{
if (keyConvert[i].fVKey == vk)
return (keyConvert[i].fKeyName);
}
return nil;
}
plKeyDef plKeyMap::ConvertCharToVKey( const char *c )
{
Win32keyConvert* keyConvert = &fKeyConversionEnglish[0];
switch (plLocalization::GetLanguage())
{
case plLocalization::kFrench:
keyConvert = &fKeyConversionFrench[0];
break;
case plLocalization::kGerman:
keyConvert = &fKeyConversionGerman[0];
break;
// case plLocalization::kSpanish:
// keyConvert = &fKeyConversionSpanish[0];
// break;
// case plLocalization::kItalian:
// keyConvert = &fKeyConversionItalian[0];
// break;
// default is English
}
for (int i = 0; keyConvert[i].fVKey != 0xffffffff; i++)
{
if (stricmp(keyConvert[i].fKeyName, c) == 0)
return (plKeyDef)(keyConvert[i].fVKey);
}
// Is it just a single character?
if( isalnum( *c ) && strlen( c ) == 1 )
return (plKeyDef)toupper( *c );
// if we didn't find anything yet...
// ...then look thru all the other language mappings that we know about,
// ...just in case they keep switching languages on us
if ( plLocalization::GetLanguage() != plLocalization::kEnglish)
{
for (int i = 0; fKeyConversionEnglish[i].fVKey != 0xffffffff; i++)
{
if (stricmp(fKeyConversionEnglish[i].fKeyName, c) == 0)
return (plKeyDef)(fKeyConversionEnglish[i].fVKey);
}
}
if ( plLocalization::GetLanguage() != plLocalization::kFrench)
{
for (int i = 0; fKeyConversionFrench[i].fVKey != 0xffffffff; i++)
{
if (stricmp(fKeyConversionFrench[i].fKeyName, c) == 0)
return (plKeyDef)(fKeyConversionFrench[i].fVKey);
}
}
if ( plLocalization::GetLanguage() != plLocalization::kGerman)
{
for (int i = 0; fKeyConversionGerman[i].fVKey != 0xffffffff; i++)
{
if (stricmp(fKeyConversionGerman[i].fKeyName, c) == 0)
return (plKeyDef)(fKeyConversionGerman[i].fVKey);
}
}
/*
if ( plLocalization::GetLanguage() != plLocalization::kSpanish)
{
for (int i = 0; fKeyConversionSpanish[i].fVKey != 0xffffffff; i++)
{
if (stricmp(fKeyConversionSpanish[i].fKeyName, c) == 0)
return (plKeyDef)(fKeyConversionSpanish[i].fVKey);
}
}
if ( plLocalization::GetLanguage() != plLocalization::kItalian)
{
for (int i = 0; fKeyConversionItalian[i].fVKey != 0xffffffff; i++)
{
if (stricmp(fKeyConversionItalian[i].fKeyName, c) == 0)
return (plKeyDef)(fKeyConversionItalian[i].fVKey);
}
}
*/
// finally, just give up... unmapped!
return KEY_UNMAPPED;
}
const char* plKeyMap::GetStringCtrl()
{
switch (plLocalization::GetLanguage())
{
case plLocalization::kFrench:
return "Ctrl+";
break;
case plLocalization::kGerman:
return "Strg+";
break;
/* case plLocalization::kSpanish:
return "Ctrl+";
break;
case plLocalization::kItalian:
return "Ctrl+";
break;
*/
// default is English
}
return "Ctrl+";
}
const char* plKeyMap::GetStringShift()
{
switch (plLocalization::GetLanguage())
{
case plLocalization::kFrench:
return "Maj+";
break;
case plLocalization::kGerman:
return "Umschalt+";
break;
/* case plLocalization::kSpanish:
return "May<EFBFBD>sculas+";
break;
case plLocalization::kItalian:
return "Shift+";
break;
*/
// default is English
}
return "Shift+";
}
const char* plKeyMap::GetStringUnmapped()
{
switch (plLocalization::GetLanguage())
{
case plLocalization::kFrench:
return "(NonD<EFBFBD>fini)";
break;
case plLocalization::kGerman:
return "(NichtZugewiesen)";
break;
/* case plLocalization::kSpanish:
return "(SinMapear)";
break;
case plLocalization::kItalian:
return "(NonAssegnato)";
break;
*/
// default is English
}
return "(unmapped)";
}
// If the binding has one of these keys, but not the other, go and bind the other
// (if there's an unmapped space for it).
void plKeyMap::HandleAutoDualBinding(plKeyDef key1, plKeyDef key2)
{
ICheckAndBindDupe(key1, key2);
ICheckAndBindDupe(key2, key1);
}
void plKeyMap::ICheckAndBindDupe(plKeyDef origKey, plKeyDef dupeKey)
{
hsTArray<plKeyBinding*> bindings;
plKeyCombo combo;
combo.fKey = origKey;
IFindAllBindingsByKey(combo, bindings);
int i;
for (i = 0; i < bindings.GetCount(); i++)
{
plKeyBinding *binding = bindings[i];
if (binding->HasUnmappedKey())
{
combo = binding->GetMatchingKey(origKey);
combo.fKey = dupeKey;
if (IFindBindingByKey(combo) == nil)
IActuallyBind(binding, combo, kNoPreference);
}
}
}
Win32keyConvert plKeyMap::fKeyConversionEnglish[] =
{
{ VK_F1, "F1"},
{ VK_F2, "F2"},
{ VK_F3, "F3"},
{ VK_F4, "F4"},
{ VK_F5, "F5"},
{ VK_F6, "F6"},
{ VK_F7, "F7"},
{ VK_F8, "F8"},
{ VK_F9, "F9"},
{ VK_F10, "F10"},
{ VK_F11, "F11"},
{ VK_F12, "F12"},
{ VK_ESCAPE, "Esc"},
{ VK_TAB, "Tab"},
{ VK_UP, "UpArrow"},
{ VK_DOWN, "DownArrow"},
{ VK_LEFT, "LeftArrow"},
{ VK_RIGHT, "RightArrow"},
{ VK_BACK, "Backspace"},
{ VK_RETURN, "Enter"},
{ VK_PAUSE, "Pause"},
{ VK_CAPITAL, "CapsLock"},
{ VK_PRIOR, "PageUp"},
{ VK_NEXT, "PageDn"},
{ VK_END, "End"},
{ VK_HOME, "Home"},
{ VK_SNAPSHOT, "PrintScrn"},
{ VK_INSERT, "Insert"},
{ VK_DELETE, "Delete"},
{ VK_NUMPAD0, "NumPad0"},
{ VK_NUMPAD1, "NumPad1"},
{ VK_NUMPAD2, "NumPad2"},
{ VK_NUMPAD3, "NumPad3"},
{ VK_NUMPAD4, "NumPad4"},
{ VK_NUMPAD5, "NumPad5"},
{ VK_NUMPAD6, "NumPad6"},
{ VK_NUMPAD7, "NumPad7"},
{ VK_NUMPAD8, "NumPad8"},
{ VK_NUMPAD9, "NumPad9"},
{ VK_MULTIPLY, "NumPad*"},
{ VK_ADD, "NumPad+"},
{ VK_SUBTRACT, "NumPad-"},
{ VK_DECIMAL, "NumPad."},
{ VK_DIVIDE, "NumPad/"},
{ VK_SPACE, "SpaceBar"},
{ VK_OEM_COMMA, "Comma"},
{ VK_OEM_PERIOD,"Period"},
{ VK_OEM_MINUS, "Minus"},
{ VK_OEM_PLUS, "Plus"},
{ VK_SHIFT, "Shift" },
// not valid outside USA
{ VK_OEM_1, "Semicolon"},
{ VK_OEM_2, "ForewardSlash"},
{ VK_OEM_3, "Tilde"},
{ VK_OEM_4, "LeftBracket"},
{ VK_OEM_5, "Backslash"},
{ VK_OEM_6, "RightBracket"},
{ VK_OEM_7, "Quote"},
{ 0xffffffff, "Unused"},
};
Win32keyConvert plKeyMap::fKeyConversionFrench[] =
{
{ VK_F1, "F1"},
{ VK_F2, "F2"},
{ VK_F3, "F3"},
{ VK_F4, "F4"},
{ VK_F5, "F5"},
{ VK_F6, "F6"},
{ VK_F7, "F7"},
{ VK_F8, "F8"},
{ VK_F9, "F9"},
{ VK_F10, "F10"},
{ VK_F11, "F11"},
{ VK_F12, "F12"},
{ VK_ESCAPE, "<EFBFBD>chap"},
{ VK_TAB, "Tab"},
{ VK_UP, "Fl<EFBFBD>cheHaut"},
{ VK_DOWN, "Fl<EFBFBD>cheBas"},
{ VK_LEFT, "Fl<EFBFBD>cheGauche"},
{ VK_RIGHT, "Fl<EFBFBD>cheDroite"},
{ VK_BACK, "Retour"},
{ VK_RETURN, "Entr<EFBFBD>e"},
{ VK_PAUSE, "Pause"},
{ VK_CAPITAL, "CapsLock"},
{ VK_PRIOR, "PagePr<EFBFBD>c"},
{ VK_NEXT, "PageSuiv"},
{ VK_END, "Fin"},
{ VK_HOME, "Origine"},
{ VK_SNAPSHOT, "Impr<EFBFBD>cran"},
{ VK_INSERT, "Inser"},
{ VK_DELETE, "Suppr"},
{ VK_NUMPAD0, "PavNum0"},
{ VK_NUMPAD1, "PavNum1"},
{ VK_NUMPAD2, "PavNum2"},
{ VK_NUMPAD3, "PavNum3"},
{ VK_NUMPAD4, "PavNum4"},
{ VK_NUMPAD5, "PavNum5"},
{ VK_NUMPAD6, "PavNum6"},
{ VK_NUMPAD7, "PavNum7"},
{ VK_NUMPAD8, "PavNum8"},
{ VK_NUMPAD9, "PavNum9"},
{ VK_MULTIPLY, "PavNum*"},
{ VK_ADD, "PavNum+"},
{ VK_SUBTRACT, "PavNum-"},
{ VK_DECIMAL, "PavNum."},
{ VK_DIVIDE, "PavNum/"},
{ VK_SPACE, "Espace"},
{ VK_OEM_COMMA, "Virgule"},
{ VK_OEM_PERIOD,"Point"},
{ VK_OEM_MINUS, "Moins"},
{ VK_OEM_PLUS, "Plus"},
{ VK_SHIFT, "Maj" },
// not valid outside USA
{ VK_OEM_1, "Point-virgule"},
{ VK_OEM_2, "BarreOblique"},
{ VK_OEM_3, "Tilde"},
{ VK_OEM_4, "Parenth<EFBFBD>seG"},
{ VK_OEM_5, "BarreInverse"},
{ VK_OEM_6, "Parenth<EFBFBD>seD"},
{ VK_OEM_7, "Guillemet"},
{ 0xffffffff, "Unused"},
};
Win32keyConvert plKeyMap::fKeyConversionGerman[] =
{
{ VK_F1, "F1"},
{ VK_F2, "F2"},
{ VK_F3, "F3"},
{ VK_F4, "F4"},
{ VK_F5, "F5"},
{ VK_F6, "F6"},
{ VK_F7, "F7"},
{ VK_F8, "F8"},
{ VK_F9, "F9"},
{ VK_F10, "F10"},
{ VK_F11, "F11"},
{ VK_F12, "F12"},
{ VK_ESCAPE, "Esc"},
{ VK_TAB, "Tab"},
{ VK_UP, "PfeilHoch"},
{ VK_DOWN, "PfeilRunter"},
{ VK_LEFT, "PfeilLinks"},
{ VK_RIGHT, "PfeilRechts"},
{ VK_BACK, "Backspace"},
{ VK_RETURN, "Enter"},
{ VK_PAUSE, "Pause"},
{ VK_CAPITAL, "Feststelltaste"},
{ VK_PRIOR, "BildHoch"},
{ VK_NEXT, "BildRunter"},
{ VK_END, "Ende"},
{ VK_HOME, "Pos1"},
{ VK_SNAPSHOT, "Druck"},
{ VK_INSERT, "Einf"},
{ VK_DELETE, "Entf"},
{ VK_NUMPAD0, "ZB0"},
{ VK_NUMPAD1, "ZB1"},
{ VK_NUMPAD2, "ZB2"},
{ VK_NUMPAD3, "ZB3"},
{ VK_NUMPAD4, "ZB4"},
{ VK_NUMPAD5, "ZB5"},
{ VK_NUMPAD6, "ZB6"},
{ VK_NUMPAD7, "ZB7"},
{ VK_NUMPAD8, "ZB8"},
{ VK_NUMPAD9, "ZB9"},
{ VK_MULTIPLY, "ZB*"},
{ VK_ADD, "ZB+"},
{ VK_SUBTRACT, "ZB-"},
{ VK_DECIMAL, "ZB."},
{ VK_DIVIDE, "ZB/"},
{ VK_SPACE, "Leertaste"},
{ VK_OEM_COMMA, "Komma"},
{ VK_OEM_PERIOD,"Punkt"},
{ VK_OEM_MINUS, "Minus"},
{ VK_OEM_PLUS, "Plus"},
{ VK_SHIFT, "Umschalt" },
// not valid outside USA
{ VK_OEM_1, "<EFBFBD>"},
{ VK_OEM_2, "#"},
{ VK_OEM_3, "<EFBFBD>"},
{ VK_OEM_4, "<EFBFBD>"},
{ VK_OEM_5, "Backslash"},
{ VK_OEM_6, "Akzent"},
{ VK_OEM_7, "<EFBFBD>"},
{ 0xffffffff, "Unused"},
};
/*
Win32keyConvert plKeyMap::fKeyConversionSpanish[] =
{
{ VK_F1, "F1"},
{ VK_F2, "F2"},
{ VK_F3, "F3"},
{ VK_F4, "F4"},
{ VK_F5, "F5"},
{ VK_F6, "F6"},
{ VK_F7, "F7"},
{ VK_F8, "F8"},
{ VK_F9, "F9"},
{ VK_F10, "F10"},
{ VK_F11, "F11"},
{ VK_F12, "F12"},
{ VK_ESCAPE, "Esc"},
{ VK_TAB, "Tabulador"},
{ VK_UP, "CursorArriba"},
{ VK_DOWN, "CursorAbajo"},
{ VK_LEFT, "CursorIzquierdo"},
{ VK_RIGHT, "CursorDerecho"},
{ VK_BACK, "Retroceso"},
{ VK_RETURN, "Intro"},
{ VK_PAUSE, "Pausa"},
{ VK_CAPITAL, "BloqMay<EFBFBD>s"},
{ VK_PRIOR, "ReP<EFBFBD>g"},
{ VK_NEXT, "AVP<EFBFBD>g"},
{ VK_END, "Fin"},
{ VK_HOME, "Inicio"},
{ VK_SNAPSHOT, "ImprPetSis"},
{ VK_INSERT, "Insert"},
{ VK_DELETE, "Supr"},
{ VK_NUMPAD0, "TecNum0"},
{ VK_NUMPAD1, "TecNum1"},
{ VK_NUMPAD2, "TecNum2"},
{ VK_NUMPAD3, "TecNum3"},
{ VK_NUMPAD4, "TecNum4"},
{ VK_NUMPAD5, "TecNum5"},
{ VK_NUMPAD6, "TecNum6"},
{ VK_NUMPAD7, "TecNum7"},
{ VK_NUMPAD8, "TecNum8"},
{ VK_NUMPAD9, "TecNum9"},
{ VK_MULTIPLY, "TecNum*"},
{ VK_ADD, "TecNum+"},
{ VK_SUBTRACT, "TecNum-"},
{ VK_DECIMAL, "TecNum."},
{ VK_DIVIDE, "TecNum/"},
{ VK_SPACE, "BarraEspacio"},
{ VK_OEM_COMMA, "Coma"},
{ VK_OEM_PERIOD,"Punto"},
{ VK_OEM_MINUS, "Menos"},
{ VK_OEM_PLUS, "M<EFBFBD>s"},
{ VK_SHIFT, "May<EFBFBD>sculas" },
// not valid outside USA
{ VK_OEM_1, "PuntoYComa"},
{ VK_OEM_2, "Barra"},
{ VK_OEM_3, "Tilde"},
{ VK_OEM_4, "AbrirPar<EFBFBD>ntesis"},
{ VK_OEM_5, "BarraInvertida"},
{ VK_OEM_6, "CerrarPar<EFBFBD>ntesis"},
{ VK_OEM_7, "Comillas"},
{ 0xffffffff, "Unused"},
};
Win32keyConvert plKeyMap::fKeyConversionItalian[] =
{
{ VK_F1, "F1"},
{ VK_F2, "F2"},
{ VK_F3, "F3"},
{ VK_F4, "F4"},
{ VK_F5, "F5"},
{ VK_F6, "F6"},
{ VK_F7, "F7"},
{ VK_F8, "F8"},
{ VK_F9, "F9"},
{ VK_F10, "F10"},
{ VK_F11, "F11"},
{ VK_F12, "F12"},
{ VK_ESCAPE, "Esc"},
{ VK_TAB, "Tab"},
{ VK_UP, "FrecciaSu"},
{ VK_DOWN, "FrecciaGi<EFBFBD>"},
{ VK_LEFT, "FrecciaSx"},
{ VK_RIGHT, "FrecciaDx"},
{ VK_BACK, "Backspace"},
{ VK_RETURN, "Invio"},
{ VK_PAUSE, "Pausa"},
{ VK_CAPITAL, "BlocMaiusc"},
{ VK_PRIOR, "PagSu"},
{ VK_NEXT, "PagGi<EFBFBD>"},
{ VK_END, "Fine"},
{ VK_HOME, "Home"},
{ VK_SNAPSHOT, "Stamp"},
{ VK_INSERT, "Ins"},
{ VK_DELETE, "Canc"},
{ VK_NUMPAD0, "TastNum0"},
{ VK_NUMPAD1, "TastNum1"},
{ VK_NUMPAD2, "TastNum2"},
{ VK_NUMPAD3, "TastNum3"},
{ VK_NUMPAD4, "TastNum4"},
{ VK_NUMPAD5, "TastNum5"},
{ VK_NUMPAD6, "TastNum6"},
{ VK_NUMPAD7, "TastNum7"},
{ VK_NUMPAD8, "TastNum8"},
{ VK_NUMPAD9, "TastNum9"},
{ VK_MULTIPLY, "TastNum*"},
{ VK_ADD, "TastNum+"},
{ VK_SUBTRACT, "TastNum-"},
{ VK_DECIMAL, "TastNum."},
{ VK_DIVIDE, "TastNum/"},
{ VK_SPACE, "Spazio"},
{ VK_OEM_COMMA, "Virgola"},
{ VK_OEM_PERIOD,"Punto"},
{ VK_OEM_MINUS, "Meno"},
{ VK_OEM_PLUS, "QuadraDx"},
{ VK_SHIFT, "Shift" },
// not valid outside USA
{ VK_OEM_1, "QuadraSx"},
{ VK_OEM_2, "<EFBFBD>"},
{ VK_OEM_3, "<EFBFBD>"},
{ VK_OEM_4, "Apostrofo"},
{ VK_OEM_5, "\\"},
{ VK_OEM_6, "<EFBFBD>"},
{ VK_OEM_7, "<EFBFBD>"},
{ 0xffffffff, "Unused"},
};
*/
CommandConvert plInputMap::fCmdConvert[] =
{
{ B_CONTROL_ACTION, "Use Key" },
{ B_CONTROL_JUMP, "Jump Key" },
{ B_CONTROL_DIVE, "Dive Key" },
{ B_CONTROL_MOVE_FORWARD, "Walk Forward" },
{ B_CONTROL_MOVE_BACKWARD, "Walk Backward" },
{ B_CONTROL_STRAFE_LEFT, "Strafe Left" },
{ B_CONTROL_STRAFE_RIGHT, "Strafe Right" },
{ B_CONTROL_MOVE_UP, "Move Up" },
{ B_CONTROL_MOVE_DOWN, "Move Down" },
{ B_CONTROL_ROTATE_LEFT, "Turn Left" },
{ B_CONTROL_ROTATE_RIGHT, "Turn Right" },
{ B_CONTROL_ROTATE_UP, "Turn Up" },
{ B_CONTROL_ROTATE_DOWN, "Turn Down" },
{ B_CONTROL_MODIFIER_FAST, "Fast Modifier" },
{ B_CONTROL_EQUIP, "PickUp Item" },
{ B_CONTROL_DROP, "Drop Item" },
{ B_TOGGLE_DRIVE_MODE, "Drive" },
{ B_CONTROL_ALWAYS_RUN, "Always Run" },
{ B_CAMERA_MOVE_FORWARD, "Camera Forward"},
{ B_CAMERA_MOVE_BACKWARD, "Camera Backward"},
{ B_CAMERA_MOVE_UP, "Camera Up"},
{ B_CAMERA_MOVE_DOWN, "Camera Down"},
{ B_CAMERA_MOVE_LEFT, "Camera Left"},
{ B_CAMERA_MOVE_RIGHT, "Camera Right"},
{ B_CAMERA_MOVE_FAST, "Camera Fast"},
{ B_CAMERA_ROTATE_RIGHT, "Camera Yaw Right"},
{ B_CAMERA_ROTATE_LEFT, "Camera Yaw Left"},
{ B_CAMERA_ROTATE_UP, "Camera Pitch Up"},
{ B_CAMERA_ROTATE_DOWN, "Camera Pitch Down"},
{ B_CAMERA_PAN_UP, "Camera Pan Up"},
{ B_CAMERA_PAN_DOWN, "Camera Pan Down"},
{ B_CAMERA_PAN_LEFT, "Camera Pan Left"},
{ B_CAMERA_PAN_RIGHT, "Camera Pan Right"},
{ B_CAMERA_PAN_TO_CURSOR, "Camera Pan To Cursor"},
{ B_CAMERA_RECENTER, "Camera Recenter"},
{ B_SET_CONSOLE_MODE, "Console"},
{ B_CAMERA_DRIVE_SPEED_UP, "Decrease Camera Drive Speed" },
{ B_CAMERA_DRIVE_SPEED_DOWN, "Increase Camera Drive Speed" },
{ S_INCREASE_MIC_VOL, "Increase Microphone Sensitivity" },
{ S_DECREASE_MIC_VOL, "Decrease Microphone Sensitivity" },
{ S_PUSH_TO_TALK, "Push to talk" },
{ S_SET_WALK_MODE, "Set Walk Mode" },
{ B_CONTROL_TURN_TO, "Turn To Click" },
{ B_CONTROL_TOGGLE_PHYSICAL, "Toggle Physical" },
{ S_SET_FIRST_PERSON_MODE, "Toggle First Person" },
{ B_CAMERA_ZOOM_IN, "Camera Zoom In" },
{ B_CAMERA_ZOOM_OUT, "Camera Zoom Out" },
{ B_CONTROL_EXIT_MODE, "Exit Mode" },
{ B_CONTROL_OPEN_KI, "Open KI" },
{ B_CONTROL_OPEN_BOOK, "Open Player Book" },
{ B_CONTROL_EXIT_GUI_MODE, "Exit GUI Mode" },
{ B_CONTROL_MODIFIER_STRAFE, "Strafe Modifier" },
{ END_CONTROLS, ""},
Make a bunch more strings const.
13 years ago
};