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

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;
        }
    }
}


const 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ú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é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, "Échap"},
    { VK_TAB,   "Tab"},
    { VK_UP,    "FlècheHaut"}, 
    { VK_DOWN,  "FlècheBas"}, 
    { VK_LEFT,  "FlècheGauche"},
    { VK_RIGHT, "FlècheDroite"},
    { VK_BACK,  "Retour"},
    { VK_RETURN, "Entrée"}, 
    { VK_PAUSE, "Pause"},
    { VK_CAPITAL, "CapsLock"},
    { VK_PRIOR, "PagePréc"},
    { VK_NEXT,  "PageSuiv"},
    { VK_END,   "Fin"},
    { VK_HOME,  "Origine"},
    { VK_SNAPSHOT,  "ImprÉ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èseG"},
    { VK_OEM_5,     "BarreInverse"},    
    { VK_OEM_6,     "Parenthè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,     "Ü"},
    { VK_OEM_2,     "#"},
    { VK_OEM_3,     "Ö"},
    { VK_OEM_4,     "ß"},
    { VK_OEM_5,     "Backslash"},   
    { VK_OEM_6,     "Akzent"},
    { VK_OEM_7,     "Ä"},
                
    { 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ús"},
    { VK_PRIOR, "RePág"},
    { VK_NEXT,  "AVPá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ás"},
    { VK_SHIFT,     "Mayúsculas"    },
    // not valid outside USA
    { VK_OEM_1,     "PuntoYComa"},
    { VK_OEM_2,     "Barra"},
    { VK_OEM_3,     "Tilde"},
    { VK_OEM_4,     "AbrirParéntesis"},
    { VK_OEM_5,     "BarraInvertida"},  
    { VK_OEM_6,     "CerrarParé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ù"}, 
    { VK_LEFT,  "FrecciaSx"},
    { VK_RIGHT, "FrecciaDx"},
    { VK_BACK,  "Backspace"},
    { VK_RETURN, "Invio"}, 
    { VK_PAUSE, "Pausa"},
    { VK_CAPITAL, "BlocMaiusc"},
    { VK_PRIOR, "PagSu"},
    { VK_NEXT,  "PagGiù"},
    { 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,     "ù"},
    { VK_OEM_3,     "ò"},
    { VK_OEM_4,     "Apostrofo"},
    { VK_OEM_5,     "\\"},  
    { VK_OEM_6,     "ì"},
    { VK_OEM_7,     "à"},
                
    { 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,             ""},
 
};