CWE-ou-minkata/Sources/Plasma/NucleusLib/pnInputCore/plInputMap.cpp

/*==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/>.

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.

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"
#include "hsUtils.h"
#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;
}

hsBool plKeyCombo::IsSatisfiedBy(const plKeyCombo &combo) const
{
	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;
}

plKeyBinding::plKeyBinding( ControlEventCode code, UInt32 codeFlags, const plKeyCombo &key1, const plKeyCombo &key2, const char *string /*= nil*/ )
{
	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;
}

hsBool	plKeyBinding::HasUnmappedKey() const
{
	return fKey1.fKey == KEY_UNMAPPED || fKey2.fKey == KEY_UNMAPPED;
}

//////////////////////////////////////////////////////////////////////////////
//// plKeyMap Implementation /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

plKeyMap::plKeyMap()
{
}

plKeyMap::~plKeyMap()
{
	ClearAll();
}

void	plKeyMap::ClearAll( void )
{
	UInt32	i;


	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

hsBool	plKeyMap::AddCode( ControlEventCode code, UInt32 codeFlags )
{
	if( IFindBinding( code ) != nil )
		return false;

	fBindings.Append( TRACKED_NEW plKeyBinding( code, codeFlags, plKeyCombo::kUnmapped, plKeyCombo::kUnmapped ) );
	return true;
}

//// AddConsoleCommand ///////////////////////////////////////////////////////
//	Same but for console commands. No flags b/c console commands always use 
//	the same flags.

hsBool	plKeyMap::AddConsoleCommand( const char *command )
{
	if( IFindConsoleBinding( command ) != nil )
		return false;

	fBindings.Append( TRACKED_NEW plKeyBinding( B_CONTROL_CONSOLE_COMMAND, 
										kControlFlagDownEvent | kControlFlagNoRepeat | kControlFlagNoDeactivate,
										plKeyCombo::kUnmapped, plKeyCombo::kUnmapped, 
										command ) );
	return true;
}

//// IFindBinding ////////////////////////////////////////////////////////////
//	Find the binding for a given code.

plKeyBinding	*plKeyMap::IFindBinding( ControlEventCode code ) const
{
	UInt32	i;


	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
{
	UInt32	i;


	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
{
	UInt32 i;
	UInt8 bestScore = 0;
	for (i = 0; i < fBindings.GetCount(); i++)
	{
		hsBool s1, s2;
		s1 = fBindings[i]->GetKey1().IsSatisfiedBy(combo);
		s2 = fBindings[i]->GetKey2().IsSatisfiedBy(combo);
		if (s1 || s2)
		{
			UInt8 myScore = 0;
			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
{
	UInt32	i;


	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.

hsBool	plKeyMap::BindKey( const plKeyCombo &combo, ControlEventCode code, BindPref pref /*= kNoPreference*/ )
{
	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

hsBool	plKeyMap::BindKeyToConsoleCmd( const plKeyCombo &combo, const char *command, BindPref pref /*= kNoPreference*/ )
{
	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 )
{
	UInt32	i;

	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 )
{
	UInt32	i;


	for( i = 0; i < fBindings.GetCount(); i++ )
	{
		if( fBindings[ i ]->GetCode() == code )
		{
			delete fBindings[ i ];
			fBindings.Remove( i );
			return;
		}
	}
}


char* plKeyMap::ConvertVKeyToChar( UInt32 vk )
{
	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,				""},
 
};