{

memset( m_Bindings, 0, sizeof( m_Bindings ));

// create the key bindings list

CreateKeyBindingList();

// Store all current key bindings

SaveCurrentBindings();

// Parse default descriptions

ParseActionDescriptions();

m_pSetBindingButton = new Button(this, "ChangeKeyButton", "");

m_pClearBindingButton = new Button(this, "ClearKeyButton", "");

LoadControlSettings("Resource/OptionsSubKeyboard.res");

m_pSetBindingButton->SetEnabled(false);

m_pClearBindingButton->SetEnabled(false);

{

// Populate list based on current settings

FillInCurrentBindings();

if ( IsVisible() )

{

m_pKeyBindList->SetSelectedItem(0);

}

{

// Create the control

m_pKeyBindList = new VControlsListPanel(this, "listpanel_keybindlist");

{

if (code == KEY_ENTER)

{

OnCommand("ChangeKey");

}

else

{

BaseClass::OnKeyCodeTyped(code);

}

{

if ( !stricmp( command, "Defaults" ) )

{

// open a box asking if we want to restore defaults

QueryBox *box = new QueryBox("#GameUI_KeyboardSettings", "#GameUI_KeyboardSettingsText");

box->AddActionSignalTarget(this);

box->SetOKCommand(new KeyValues("Command", "command", "DefaultsOK"));

box->DoModal();

}

else if ( !stricmp(command, "DefaultsOK"))

{

// Restore defaults from default keybindings file

FillInDefaultBindings();

m_pKeyBindList->RequestFocus();

}

else if ( !m_pKeyBindList->IsCapturing() && !stricmp( command, "ChangeKey" ) )

{

m_pKeyBindList->StartCaptureMode(dc_blank);

}

else if ( !m_pKeyBindList->IsCapturing() && !stricmp( command, "ClearKey" ) )

{

OnKeyCodePressed(KEY_DELETE);

m_pKeyBindList->RequestFocus();

}

else if ( !stricmp(command, "Advanced") )

{

OpenKeyboardAdvancedDialog();

}

else

{

BaseClass::OnCommand( command );

}

{

char szBinding[256];

char szDescription[256];

KeyValues *item;

// Load the default keys list

CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );

if ( !g_pFullFileSystem->ReadFile( "scripts/kb_act.lst", NULL, buf ) )

return;

const char *data = (const char*)buf.Base();

int sectionIndex = 0;

char token[512];

while ( 1 )

{

data = UTIL_Parse( data, token, sizeof(token) );

// Done.

if ( strlen( token ) <= 0 )

break;

Q_strncpy( szBinding, token, sizeof( szBinding ) );

data = UTIL_Parse( data, token, sizeof(token) );

if ( strlen(token) <= 0 )

{

break;

}

Q_strncpy(szDescription, token, sizeof( szDescription ) );

// Skip '======' rows

if ( szDescription[ 0 ] != '=' )

{

// Flag as special header row if binding is "blank"

if (!stricmp(szBinding, "blank"))

{

// add header item

m_pKeyBindList->AddSection(++sectionIndex, szDescription);

m_pKeyBindList->AddColumnToSection(sectionIndex, "Action", szDescription, SectionedListPanel::COLUMN_BRIGHT, 286);

m_pKeyBindList->AddColumnToSection(sectionIndex, "Key", "#GameUI_KeyButton", SectionedListPanel::COLUMN_BRIGHT, 128);

}

else

{

// Create a new: blank item

item = new KeyValues( "Item" );

// fill in data

item->SetString("Action", szDescription);

item->SetString("Binding", szBinding);

item->SetString("Key", "");

// Add to list

m_pKeyBindList->AddItem(sectionIndex, item);

item->deleteThis();

}

}

}

{

// See if it's already there as a binding

if ( !stricmp( item->GetString( "Key", "" ), keyname ) )

return;

// Make sure it doesn't live anywhere

RemoveKeyFromBindItems( item, keyname );

const char *binding = item->GetString( "Binding", "" );

// Loop through all the key bindings and set all entries that have

// the same binding. This allows us to have multiple entries pointing

// to the same binding.

for (int i = 0; i < m_pKeyBindList->GetItemCount(); i++)

{

KeyValues *curitem = m_pKeyBindList->GetItemData(m_pKeyBindList->GetItemIDFromRow(i));

if ( !curitem )

continue;

const char *curbinding = curitem->GetString( "Binding", "" );

if (!stricmp(curbinding, binding))

{

curitem->SetString( "Key", keyname );

m_pKeyBindList->InvalidateItem(i);

}

}

{

for (int i = 0; i < m_pKeyBindList->GetItemCount(); i++)

{

KeyValues *item = m_pKeyBindList->GetItemData(m_pKeyBindList->GetItemIDFromRow(i));

if ( !item )

continue;

// Reset keys

item->SetString( "Key", "" );

m_pKeyBindList->InvalidateItem(i);

}

m_pKeyBindList->InvalidateLayout();

{

Assert( key && key[ 0 ] );

if ( !key || !key[ 0 ] )

return;

int len = Q_strlen( key );

char *pszKey = new char[len + 1];

if ( !pszKey )

return;

Q_memcpy( pszKey, key, len+1 );

for (int i = 0; i < m_pKeyBindList->GetItemCount(); i++)

{

KeyValues *item = m_pKeyBindList->GetItemData(m_pKeyBindList->GetItemIDFromRow(i));

if ( !item )

continue;

// If it's bound to the primary: then remove it

if ( !stricmp( pszKey, item->GetString( "Key", "" ) ) )

{

bool bClearEntry = true;

if ( org_item )

{

// Only clear it out if the actual binding isn't the same. This allows

// us to have the same key bound to multiple entries in the keybinding list

// if they point to the same command.

const char *org_binding = org_item->GetString( "Binding", "" );

const char *binding = item->GetString( "Binding", "" );

if ( !stricmp( org_binding, binding ) )

{

bClearEntry = false;

}

}

if ( bClearEntry )

{

item->SetString( "Key", "" );

m_pKeyBindList->InvalidateItem(i);

}

}

}

delete [] pszKey;

// Make sure the display is up to date

m_pKeyBindList->InvalidateLayout();

{

// reset the unbind list

// we only unbind keys used by the normal config items (not custom binds)

m_KeysToUnbind.RemoveAll();

// Clear any current settings

ClearBindItems();

bool bJoystick = false;

ConVarRef var( "joystick" );

if ( var.IsValid() )

{

bJoystick = var.GetBool();

}

// NVNT see if we have a falcon connected.

bool bFalcon = false;

ConVarRef falconVar("hap_HasDevice");

if ( var.IsValid() )

{

bFalcon = var.GetBool();

}

for ( int i = 0; i < BUTTON_CODE_LAST; i++ )

{

// Look up binding

const char *binding = gameuifuncs->GetBindingForButtonCode( (ButtonCode_t)i );

if ( !binding )

continue;

// See if there is an item for this one?

KeyValues *item = GetItemForBinding( binding );

if ( item )

{

// Bind it by name

const char *keyName = g_pInputSystem->ButtonCodeToString( (ButtonCode_t)i );

// Already in list, means user had two keys bound to this item. We'll only note the first one we encounter

char const *currentKey = item->GetString( "Key", "" );

if ( currentKey && currentKey[ 0 ] )

{

ButtonCode_t currentBC = (ButtonCode_t)gameuifuncs->GetButtonCodeForBind( currentKey );

// If we're using a joystick, joystick bindings override keyboard ones

bool bShouldOverride = bJoystick && IsJoystickCode((ButtonCode_t)i) && !IsJoystickCode(currentBC);

// NVNT If we're not using a joystick, falcon bindings override keyboard ones

if( !bShouldOverride && bFalcon && IsNovintCode((ButtonCode_t)i) && !IsNovintCode(currentBC) )

bShouldOverride = true;

if ( !bShouldOverride )

continue;

// Remove the key we're about to override from the unbinding list

m_KeysToUnbind.FindAndRemove( currentKey );

}

AddBinding( item, keyName );

// remember to apply unbinding of this key when we apply

m_KeysToUnbind.AddToTail( keyName );

}

}

{

for ( int i = 0; i < BUTTON_CODE_LAST; i++ )

{

if ( m_Bindings[ i ].binding )

{

delete[] m_Bindings[ i ].binding;

m_Bindings[ i ].binding = NULL;

}

}

{

DeleteSavedBindings();

for (int i = 0; i < BUTTON_CODE_LAST; i++)

{

const char *binding = gameuifuncs->GetBindingForButtonCode( (ButtonCode_t)i );

if ( !binding || !binding[0])

continue;

// Copy the binding string

m_Bindings[ i ].binding = UTIL_CopyString( binding );

}

{

#ifndef _XBOX

engine->ClientCmd_Unrestricted( UTIL_va( "bind \"%s\" \"%s\"\n", key, binding ) );

#else

char buff[256];

Q_snprintf(buff, sizeof(buff), "bind \"%s\" \"%s\"\n", key, binding);

engine->ClientCmd_Unrestricted(buff);

#endif

{

#ifndef _XBOX

engine->ClientCmd_Unrestricted( UTIL_va( "unbind \"%s\"\n", key ) );

#else

char buff[256];

Q_snprintf(buff, sizeof(buff), "unbind \"%s\"\n", key);

engine->ClientCmd_Unrestricted(buff);

#endif

{

// unbind everything that the user unbound

{for (int i = 0; i < m_KeysToUnbind.Count(); i++)

{

UnbindKey(m_KeysToUnbind[i].String());

}}

m_KeysToUnbind.RemoveAll();

// free binding memory

DeleteSavedBindings();

for (int i = 0; i < m_pKeyBindList->GetItemCount(); i++)

{

KeyValues *item = m_pKeyBindList->GetItemData(m_pKeyBindList->GetItemIDFromRow(i));

if ( !item )

continue;

// See if it has a binding

const char *binding = item->GetString( "Binding", "" );

if ( !binding || !binding[ 0 ] )

continue;

const char *keyname;

// Check main binding

keyname = item->GetString( "Key", "" );

if ( keyname && keyname[ 0 ] )

{

// Tell the engine

BindKey( keyname, binding );

ButtonCode_t code = g_pInputSystem->StringToButtonCode( keyname );

if ( code != BUTTON_CODE_INVALID )

{

m_Bindings[ code ].binding = UTIL_CopyString( binding );

}

}

}

// Now exec their custom bindings

engine->ClientCmd_Unrestricted( "exec userconfig.cfg\nhost_writeconfig\n" );

{

CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );

if ( !g_pFullFileSystem->ReadFile( "cfg/config_default.cfg", NULL, buf ) )

return;

// Clear out all current bindings

ClearBindItems();

const char *data = (const char*)buf.Base();

// loop through all the binding

while ( data != NULL )

{

char cmd[64];

data = UTIL_Parse( data, cmd, sizeof(cmd) );

if ( strlen( cmd ) <= 0 )

break;

if ( !stricmp(cmd, "bind") )

{

// Key name

char szKeyName[256];

data = UTIL_Parse( data, szKeyName, sizeof(szKeyName) );

if ( strlen( szKeyName ) <= 0 )

break; // Error

char szBinding[256];

data = UTIL_Parse( data, szBinding, sizeof(szBinding) );

if ( strlen( szKeyName ) <= 0 )

break; // Error

// Find item

KeyValues *item = GetItemForBinding( szBinding );

if ( item )

{

// Bind it

AddBinding( item, szKeyName );

}

}

}

PostActionSignal(new KeyValues("ApplyButtonEnable"));

// Make sure console and escape key are always valid

KeyValues *item = GetItemForBinding( "toggleconsole" );

if (item)

{

// Bind it

AddBinding( item, "`" );

}

item = GetItemForBinding( "cancelselect" );

if (item)

{

// Bind it

AddBinding( item, "ESCAPE" );

}

{

m_pKeyBindList->SetItemOfInterest(itemID);

if (m_pKeyBindList->IsItemIDValid(itemID))

{

// find the details, see if we should be enabled/clear/whatever

m_pSetBindingButton->SetEnabled(true);

KeyValues *kv = m_pKeyBindList->GetItemData(itemID);

if (kv)

{

const char *key = kv->GetString("Key", NULL);

if (key && *key)

{

m_pClearBindingButton->SetEnabled(true);

}

else

{

m_pClearBindingButton->SetEnabled(false);

}

if (kv->GetInt("Header"))

{

m_pSetBindingButton->SetEnabled(false);

}

}

}

else

{

m_pSetBindingButton->SetEnabled(false);

m_pClearBindingButton->SetEnabled(false);

}

{

int r = m_pKeyBindList->GetItemOfInterest();

// Retrieve clicked row and column

m_pKeyBindList->EndCaptureMode( dc_arrow );

// Find item for this row

KeyValues *item = m_pKeyBindList->GetItemData(r);

if ( item )

{

// Handle keys: but never rebind the escape key

// Esc just exits bind mode silently

if ( code != BUTTON_CODE_NONE && code != KEY_ESCAPE && code != BUTTON_CODE_INVALID )

{

// Bind the named key

AddBinding( item, g_pInputSystem->ButtonCodeToString( code ) );

PostActionSignal( new KeyValues( "ApplyButtonEnable" ) );

}

m_pKeyBindList->InvalidateItem(r);

}

m_pSetBindingButton->SetEnabled(true);

m_pClearBindingButton->SetEnabled(true);

{

BaseClass::OnThink();

if ( m_pKeyBindList->IsCapturing() )

{

ButtonCode_t code = BUTTON_CODE_INVALID;

if ( engine->CheckDoneKeyTrapping( code ) )

{

Finish( code );

}

}

{

// Enter key pressed and not already trapping next key/button press

if ( !m_pKeyBindList->IsCapturing() )

{

// Grab which item was set as interesting

int r = m_pKeyBindList->GetItemOfInterest();

// Check that it's visible

int x, y, w, h;

bool visible = m_pKeyBindList->GetCellBounds(r, 1, x, y, w, h);

if (visible)

{

if ( KEY_DELETE == code )

{

// find the current binding and remove it

KeyValues *kv = m_pKeyBindList->GetItemData(r);

const char *key = kv->GetString("Key", NULL);

if (key && *key)

{

RemoveKeyFromBindItems(NULL, key);

}

m_pClearBindingButton->SetEnabled(false);

m_pKeyBindList->InvalidateItem(r);

PostActionSignal(new KeyValues("ApplyButtonEnable"));

// message handled, don't pass on

return;

}

}

}

// Allow base class to process message instead

BaseClass::OnKeyCodePressed( code );

{

DECLARE_CLASS_SIMPLE( COptionsSubKeyboardAdvancedDlg, vgui::Frame );

COptionsSubKeyboardAdvancedDlg( vgui::VPANEL hParent ) : BaseClass( NULL, NULL )

{

// parent is ignored, since we want look like we're steal focus from the parent (we'll become modal below)

if( NeedProportional() )

SetProportional(true);

SetTitle("#GameUI_KeyboardAdvanced_Title", true);

if( IsProportional() )

SetSize( scheme()->GetProportionalScaledValue( 280 ), scheme()->GetProportionalScaledValue( 140 ) );

else

SetSize( 280, 140 );

LoadControlSettings( "resource/OptionsSubKeyboardAdvancedDlg.res" );

MoveToCenterOfScreen();

SetSizeable( false );

SetDeleteSelfOnClose( true );

}

virtual void Activate()

{

BaseClass::Activate();

input()->SetAppModalSurface(GetVPanel());

// reset the data

ConVarRef con_enable( "con_enable" );

if ( con_enable.IsValid() )

{

SetControlInt("ConsoleCheck", con_enable.GetInt() ? 1 : 0);

}

ConVarRef hud_fastswitch( "hud_fastswitch" );

if ( hud_fastswitch.IsValid() )

{

SetControlInt("FastSwitchCheck", hud_fastswitch.GetInt() ? 1 : 0);

}

}

virtual void OnApplyData()

{

// apply data

ConVarRef con_enable( "con_enable" );

con_enable.SetValue( GetControlInt( "ConsoleCheck", 0 ) );

ConVarRef hud_fastswitch( "hud_fastswitch" );

hud_fastswitch.SetValue( GetControlInt( "FastSwitchCheck", 0 ) );

}

virtual void OnCommand( const char *command )

{

if ( !stricmp(command, "OK") )

{

// apply the data

OnApplyData();

Close();

}

else

{

BaseClass::OnCommand( command );

}

}

void OnKeyCodeTyped(KeyCode code)

{

// force ourselves to be closed if the escape key it pressed

if (code == KEY_ESCAPE)

{

Close();

}

else

{

BaseClass::OnKeyCodeTyped(code);

}

}

{

if (!m_OptionsSubKeyboardAdvancedDlg.Get())

{

m_OptionsSubKeyboardAdvancedDlg = new COptionsSubKeyboardAdvancedDlg(GetVParent());

}

m_OptionsSubKeyboardAdvancedDlg->Activate();