tf2/tf2_src/game/client/tf/vgui/class_loadout_panel.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//


#include "cbase.h"
#include "class_loadout_panel.h"
#include "c_tf_player.h"
#include "vgui_controls/CheckButton.h"
#include "econ_gcmessages.h"
#include "gc_clientsystem.h"
#include "tf_item_system.h"
#include "loadout_preset_panel.h"
#include "econ_item_description.h"
#include "item_style_select_dialog.h"
#include "vgui/IInput.h"
#include "vgui_controls/PanelListPanel.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

extern ConVar tf_respawn_on_loadoutchanges;

ConVar tf_show_preset_explanation_in_class_loadout( "tf_show_preset_explanation_in_class_loadout", "1", FCVAR_HIDDEN | FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar tf_show_taunt_explanation_in_class_loadout( "tf_show_taunt_explanation_in_class_loadout", "1", FCVAR_HIDDEN | FCVAR_CLIENTDLL | FCVAR_ARCHIVE );

void ParticleSlider_UpdateRequest( int iLoadoutPosition, float value )
{
	CClassLoadoutPanel *pPanel = g_pClassLoadoutPanel;
	if ( !pPanel )
		return;

	CEconItemView *pHat = pPanel->GetItemInSlot( iLoadoutPosition );
	if ( !pHat )
		return;

	// does this hat even have a particle effect
	static CSchemaAttributeDefHandle pAttrDef_AttachParticleEffect( "attach particle effect" );
	uint32 iHasEffect = 0;
	if ( !pHat->FindAttribute( pAttrDef_AttachParticleEffect, &iHasEffect ) )
		return;

	// Check for use head toggle
	static CSchemaAttributeDefHandle pAttrDef_UseHeadOrigin( "particle effect use head origin" );
	uint32 iUseHead = 0;
	if ( !pHat->FindAttribute( pAttrDef_UseHeadOrigin, &iUseHead ) || iUseHead == 0 )
		return;

	// Look for the attribute and request to change it
	static CSchemaAttributeDefHandle pAttrDef_VerticalOffset( "particle effect vertical offset" );
	uint32 iOffSet = 0;
	if ( !pHat->FindAttribute( pAttrDef_VerticalOffset, &iOffSet ) && value == 0 )
	{
		return;
	}
	else
	{
		const float& flAttrValue = (float&)iOffSet;
		if ( value == flAttrValue )
			return; // no change do nothing
	}

	// Send a message to the GC to request a change
	GCSDK::CProtoBufMsg<CMsgSetItemEffectVerticalOffset> msg( k_EMsgGCSetItemEffectVerticalOffset );
	msg.Body().set_item_id( pHat->GetItemID() );
	msg.Body().set_offset( value );
	GCClientSystem()->BSendMessage( msg );
}

void HatOffset_Callback( IConVar *pConVar, char const *pOldString, float flOldValue )
{
	ConVarRef cVarRef( pConVar );
	ParticleSlider_UpdateRequest( LOADOUT_POSITION_HEAD, cVarRef.GetFloat() );
}
ConVar tf_hat_effect_offset( "tf_hat_effect_offset", "0", FCVAR_DEVELOPMENTONLY, "Adjust the position of the unusual effect for your hat.", HatOffset_Callback );

void Misc1Offset_Callback( IConVar *pConVar, char const *pOldString, float flOldValue )
{
	ConVarRef cVarRef( pConVar );
	ParticleSlider_UpdateRequest( LOADOUT_POSITION_MISC, cVarRef.GetFloat() );
}
ConVar tf_misc1_effect_offset( "tf_misc1_effect_offset", "0", FCVAR_DEVELOPMENTONLY, "Adjust the position of the unusual effect for your hat.", Misc1Offset_Callback );

void Misc2Offset_Callback( IConVar *pConVar, char const *pOldString, float flOldValue )
{
	ConVarRef cVarRef( pConVar );
	ParticleSlider_UpdateRequest( LOADOUT_POSITION_MISC2, cVarRef.GetFloat() );
}
ConVar tf_misc2_effect_offset( "tf_misc2_effect_offset", "0", FCVAR_DEVELOPMENTONLY, "Adjust the position of the unusual effect for your hat.", Misc2Offset_Callback );


// Hacky solution to different classes wanting different slots visible in their loadouts, and in different positions
struct LoadoutPanelPositioningInstance
{
	int m_iPos[NUM_ITEM_PANELS_IN_LOADOUT];
};

bool IsTauntPanelPosition( int iButtonPos )
{
	return iButtonPos >= 9 && iButtonPos <= 16;
}

const LoadoutPanelPositioningInstance g_DefaultLoadoutPanelPositioning =
{
	{
		1,	// LOADOUT_POSITION_PRIMARY = 0,
		2,	// LOADOUT_POSITION_SECONDARY,
		3,	// LOADOUT_POSITION_MELEE,
		0,	// LOADOUT_POSITION_UTILITY,  // STAGING ONLY
		0,	// LOADOUT_POSITION_BUILDING,
		0,	// LOADOUT_POSITION_PDA,
		0,	// LOADOUT_POSITION_PDA2,
		5,	// LOADOUT_POSITION_HEAD,
		6,	// LOADOUT_POSITION_MISC,
		8,	// LOADOUT_POSITION_ACTION,
		7,	// LOADOUT_POSITION_MISC2,
		9,	// LOADOUT_POSITION_TAUNT,
		10,	// LOADOUT_POSITION_TAUNT2,
		11,	// LOADOUT_POSITION_TAUNT3,
		12,	// LOADOUT_POSITION_TAUNT4,
		13,	// LOADOUT_POSITION_TAUNT5,
		14,	// LOADOUT_POSITION_TAUNT6,
		15,	// LOADOUT_POSITION_TAUNT7,
		16,	// LOADOUT_POSITION_TAUNT8,

#ifdef STAGING_ONLY
		0,	// LOADOUT_POSITION_PDA_ADDON1,
		0,	// LOADOUT_POSITION_PDA_ADDON2,
		0,  // LOADOUT_POSITION_PDA3,
		//9,	// LOADOUT_POSITION_MISC3,
		//10,	// LOADOUT_POSITION_MISC4,
		//11,	// LOADOUT_POSITION_MISC5,
		//12,	// LOADOUT_POSITION_MISC6,
		//13,	// LOADOUT_POSITION_MISC7,
		//14,	// LOADOUT_POSITION_MISC8,
		//15,	// LOADOUT_POSITION_MISC9,
		//16,	// LOADOUT_POSITION_MISC10,
		0,	// LOADOUT_POSITION_BUILDING2,
#endif // STAGING_ONLY
	}
};

const LoadoutPanelPositioningInstance g_LoadoutPanelPositioning_Spy =
{
	{
		0,	// LOADOUT_POSITION_PRIMARY = 0,
		1,	// LOADOUT_POSITION_SECONDARY,
		2,	// LOADOUT_POSITION_MELEE,
		0,	// LOADOUT_POSITION_UTILITY,  // STAGING ONLY
		4,	// LOADOUT_POSITION_BUILDING,		// sapper
		0,	// LOADOUT_POSITION_PDA,			// disguise kit (Hidden)
		3,	// LOADOUT_POSITION_PDA2,			// Watch
		5,	// LOADOUT_POSITION_HEAD,
		6,	// LOADOUT_POSITION_MISC,
		8,	// LOADOUT_POSITION_ACTION,
		7,	// LOADOUT_POSITION_MISC2,
		9,	// LOADOUT_POSITION_TAUNT,
		10,	// LOADOUT_POSITION_TAUNT2,
		11,	// LOADOUT_POSITION_TAUNT3,
		12,	// LOADOUT_POSITION_TAUNT4,
		13,	// LOADOUT_POSITION_TAUNT5,
		14,	// LOADOUT_POSITION_TAUNT6,
		15,	// LOADOUT_POSITION_TAUNT7,
		16,	// LOADOUT_POSITION_TAUNT8,
#ifdef STAGING_ONLY
		0,	// LOADOUT_POSITION_PDA_ADDON1,
		0,	// LOADOUT_POSITION_PDA_ADDON2,
		0,  // LOADOUT_POSITION_PDA3,
		//9,	// LOADOUT_POSITION_MISC3,
		//10,	// LOADOUT_POSITION_MISC4,
		//11,	// LOADOUT_POSITION_MISC5,
		//12,	// LOADOUT_POSITION_MISC6,
		//13,	// LOADOUT_POSITION_MISC7,
		//14,	// LOADOUT_POSITION_MISC8,
		//15,	// LOADOUT_POSITION_MISC9,
		//16,	// LOADOUT_POSITION_MISC10,
		0,	// LOADOUT_POSITION_BUILDING2,
#endif // STAGING_ONLY
	}
};

const LoadoutPanelPositioningInstance g_LoadoutPanelPositioning_Engineer =
{
	{
		1,	// LOADOUT_POSITION_PRIMARY = 0,
		2,	// LOADOUT_POSITION_SECONDARY,
		3,	// LOADOUT_POSITION_MELEE,
		0,	// LOADOUT_POSITION_UTILITY,  // STAGING ONLY
		0,	// LOADOUT_POSITION_BUILDING,
		4,	// LOADOUT_POSITION_PDA,
		0,	// LOADOUT_POSITION_PDA2,
		5,	// LOADOUT_POSITION_HEAD,
		6,	// LOADOUT_POSITION_MISC,
		8,	// LOADOUT_POSITION_ACTION,
		7,	// LOADOUT_POSITION_MISC2,
		9,	// LOADOUT_POSITION_TAUNT,
		10,	// LOADOUT_POSITION_TAUNT2,
		11,	// LOADOUT_POSITION_TAUNT3,
		12,	// LOADOUT_POSITION_TAUNT4,
		13,	// LOADOUT_POSITION_TAUNT5,
		14,	// LOADOUT_POSITION_TAUNT6,
		15,	// LOADOUT_POSITION_TAUNT7,
		16,	// LOADOUT_POSITION_TAUNT8,
#ifdef STAGING_ONLY
		17,	// LOADOUT_POSITION_PDA_ADDON1,
		18,	// LOADOUT_POSITION_PDA_ADDON2,
		0,  // LOADOUT_POSITION_PDA3,
		//9,	// LOADOUT_POSITION_MISC3,
		//10,	// LOADOUT_POSITION_MISC4,
		//11,	// LOADOUT_POSITION_MISC5,
		//12,	// LOADOUT_POSITION_MISC6,
		//13,	// LOADOUT_POSITION_MISC7,
		//14,	// LOADOUT_POSITION_MISC8,
		//15,	// LOADOUT_POSITION_MISC9,
		//16,	// LOADOUT_POSITION_MISC10,
		0,	// LOADOUT_POSITION_BUILDING2,
#endif // STAGING_ONLY
	}
};

const LoadoutPanelPositioningInstance *g_VisibleLoadoutSlotsPerClass[] =
{
	&g_DefaultLoadoutPanelPositioning,			// TF_CLASS_UNDEFINED
	&g_DefaultLoadoutPanelPositioning,			// TF_CLASS_SCOUT
	&g_DefaultLoadoutPanelPositioning,			// TF_CLASS_SNIPER
	&g_DefaultLoadoutPanelPositioning,			// TF_CLASS_SOLDIER
	&g_DefaultLoadoutPanelPositioning,			// TF_CLASS_DEMOMAN
	&g_DefaultLoadoutPanelPositioning,			// TF_CLASS_MEDIC
	&g_DefaultLoadoutPanelPositioning,			// TF_CLASS_HEAVYWEAPONS
	&g_DefaultLoadoutPanelPositioning,			// TF_CLASS_PYRO
	&g_LoadoutPanelPositioning_Spy,				// TF_CLASS_SPY
	&g_LoadoutPanelPositioning_Engineer,		// TF_CLASS_ENGINEER
};

COMPILE_TIME_ASSERT( ARRAYSIZE( g_VisibleLoadoutSlotsPerClass ) == TF_LAST_NORMAL_CLASS );

//-----------------------------------------------------------------------------
// Particle Effect Slider
//-----------------------------------------------------------------------------
CLoadoutItemOptionsPanel::CLoadoutItemOptionsPanel( Panel *parent, const char *pName ) : vgui::EditablePanel( parent, pName )
{
	m_pHatParticleSlider = NULL;
	m_pHatParticleUseHeadButton = NULL;

	m_iCurrentClassIndex = -1;
	m_eItemSlot = LOADOUT_POSITION_INVALID;

	m_pListPanel = new vgui::PanelListPanel( this, "PanelListPanel" );
	m_pListPanel->SetFirstColumnWidth( 0 );
	m_pHatParticleSlider = new CCvarSlider( m_pListPanel, "HatParticleSlider" );
	m_pHatParticleSlider->AddActionSignalTarget( this );
	m_pHatParticleUseHeadButton = new vgui::CheckButton( m_pListPanel, "HatUseHeadCheckButton", "#GameUI_ParticleHatUseHead" );
	m_pHatParticleUseHeadButton->AddActionSignalTarget( this );
	m_pSetStyleButton = new CExButton( m_pListPanel, "SetStyleButton", "#TF_Item_SelectStyle" );
	m_pSetStyleButton->AddActionSignalTarget( this );
}

//-----------------------------------------------------------------------------
void CLoadoutItemOptionsPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	LoadControlSettings( "resource/UI/ItemOptionsPanel.res" );
}

//-----------------------------------------------------------------------------
void CLoadoutItemOptionsPanel::PerformLayout( void ) 
{
	BaseClass::PerformLayout();
	m_pHatParticleSlider->SetTickColor( Color( 235, 226, 202, 255 ) ); // tanlight
}

//-----------------------------------------------------------------------------
void CLoadoutItemOptionsPanel::OnCommand( const char *command )
{
	if ( FStrEq( command, "particle_button_clicked" ) )
	{
		UpdateItemOptionsUI();
		return;
	}
	else if ( FStrEq( command, "particle_use_head_clicked" ) )
	{
		// Grab current hat
		CEconItemView *pHat = TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, m_eItemSlot );
		if ( !pHat )
			return;

		// does this hat even have a particle effect
		static CSchemaAttributeDefHandle pAttrDef_AttachParticleEffect( "attach particle effect" );
		uint32 iHasEffect = 0;
		if ( !pHat->FindAttribute( pAttrDef_AttachParticleEffect, &iHasEffect ) )
			return;

		// Send a message to the GC to request a change
		GCSDK::CProtoBufMsg<CMsgSetHatEffectUseHeadOrigin> msg( k_EMsgGCSetHatEffectUseHeadOrigin );
		msg.Body().set_item_id( pHat->GetItemID() );
		msg.Body().set_use_head( m_pHatParticleUseHeadButton->IsSelected() );
		GCClientSystem()->BSendMessage( msg );
		return;
	}
	else if ( FStrEq( command, "set_style" ) )
	{
		CEconItemView *pHat = TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, m_eItemSlot );
		CStyleSelectDialog *pStyle = vgui::SETUP_PANEL( new CStyleSelectDialog( GetParent(), pHat ) );
		if ( pStyle )
		{
			pStyle->Show();
		}
	}
}

//-----------------------------------------------------------------------------
void CLoadoutItemOptionsPanel::OnMessage( const KeyValues* pParams, vgui::VPANEL hFromPanel )
{
	if ( FStrEq( pParams->GetName(), "SliderDragEnd" ) )
	{
		m_pHatParticleSlider->ApplyChanges();
	}

	BaseClass::OnMessage( pParams, hFromPanel );
}

//-----------------------------------------------------------------------------
void CLoadoutItemOptionsPanel::SetItemSlot( loadout_positions_t eItemSlot, int iClassIndex )
{
	m_eItemSlot = eItemSlot;
	m_iCurrentClassIndex = iClassIndex;
	// Init the Slider based on the slot
	const char * pszConVarName = NULL;

	switch ( eItemSlot )
	{
	case LOADOUT_POSITION_HEAD :
		pszConVarName = "tf_hat_effect_offset";
		break;
	case LOADOUT_POSITION_MISC :
		pszConVarName = "tf_misc1_effect_offset";
		break;
	case LOADOUT_POSITION_MISC2 :
		pszConVarName = "tf_misc2_effect_offset";
		break;
	default:
		break;
	}
	
	if ( pszConVarName )
	{
		m_pHatParticleSlider->SetupSlider( -8, 8, pszConVarName, false );
	}
	
	m_pHatParticleSlider->SetTickColor( Color( 235, 226, 202, 255 ) ); // tanlight
	m_pHatParticleSlider->SetTickCaptions( "", "" );
	
	UpdateItemOptionsUI();
}

//-----------------------------------------------------------------------------
void CLoadoutItemOptionsPanel::UpdateItemOptionsUI()
{
	if ( m_eItemSlot == LOADOUT_POSITION_INVALID )
		return;

	m_pListPanel->RemoveAll();

	// Add controls for various item options
	AddControlsParticleEffect();
	AddControlsSetStyle();

	// Bail if no controls added
	if ( m_pListPanel->GetItemCount() == 0 )
	{
		// We should have some controls if we get to this point.
		Assert( 0 );
		SetVisible( false );
		return;
	}

	// Resize the background and list panel to contain all the controls
	int nVertPixels = m_pListPanel->ComputeVPixelsNeeded();
	int nNewTall = Min( 200, nVertPixels );
	m_pListPanel->SetTall( nNewTall );
	SetTall( nNewTall );
	InvalidateLayout( true, false );
}

//-----------------------------------------------------------------------------
void CLoadoutItemOptionsPanel::AddControlsParticleEffect( void ) const
{
	m_pHatParticleUseHeadButton->SetVisible( false );
	m_pHatParticleSlider->SetVisible( false );

	CEconItemView *pItem = TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, m_eItemSlot );
	if ( pItem )
	{
		// does this hat even have a particle effect
		static CSchemaAttributeDefHandle pAttrDef_AttachParticleEffect( "attach particle effect" );
		uint32 iValue = 0;
		if ( pItem->FindAttribute( pAttrDef_AttachParticleEffect, &iValue ) )
		{
			m_pHatParticleUseHeadButton->SetVisible( true );
			m_pListPanel->AddItem( NULL, m_pHatParticleUseHeadButton );
			m_pListPanel->AddItem( NULL, m_pHatParticleSlider );

			// Check for use head toggle
			static CSchemaAttributeDefHandle pAttrDef_UseHeadOrigin( "particle effect use head origin" );
			uint32 iUseHead = 0;
			if ( pItem->FindAttribute( pAttrDef_UseHeadOrigin, &iUseHead ) && iUseHead > 0 )
			{
				m_pHatParticleSlider->SetVisible( true );

				m_pHatParticleUseHeadButton->SetSelected( true );
				m_pHatParticleSlider->SetTickColor( Color( 235, 226, 202, 255 ) ); // tanlight
				m_pHatParticleSlider->Repaint();

				// Get offset if it exists
				static CSchemaAttributeDefHandle pAttrDef_VerticalOffset( "particle effect vertical offset" );
				uint32 iOffset = 0;
				if ( pItem->FindAttribute( pAttrDef_VerticalOffset, &iOffset ) )
				{
					m_pHatParticleSlider->SetSliderValue( (float&)iOffset );
				}
			}
			else
			{
				m_pHatParticleUseHeadButton->SetSelected( false );
			}
		}
	}
}

//-----------------------------------------------------------------------------
void CLoadoutItemOptionsPanel::AddControlsSetStyle( void ) const
{
	m_pSetStyleButton->SetVisible( false );

	CEconItemView *pItem = GetItem();
	if ( pItem && pItem->GetStaticData()->GetNumStyles() )
	{
		m_pSetStyleButton->SetVisible( true );
		m_pListPanel->AddItem( NULL, m_pSetStyleButton );
	}
}

//-----------------------------------------------------------------------------
CEconItemView* CLoadoutItemOptionsPanel::GetItem( void ) const
{ 
	return TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, m_eItemSlot );
}

CClassLoadoutPanel *g_pClassLoadoutPanel = NULL;
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CClassLoadoutPanel::CClassLoadoutPanel( vgui::Panel *parent ) 
	: CBaseLoadoutPanel( parent, "class_loadout_panel" )
	, m_pItemOptionPanelKVs( NULL )
{
	m_iCurrentClassIndex = TF_CLASS_UNDEFINED;
	m_iCurrentTeamIndex = TF_TEAM_RED;
	m_iCurrentSlotIndex = -1;
	m_pPlayerModelPanel = NULL;
	m_pSelectionPanel = NULL;
	m_pTauntHintLabel = NULL;
	m_pTauntLabel = NULL;
	m_pTauntCaratLabel = NULL;
	m_pPassiveAttribsLabel = NULL;
	m_pLoadoutPresetPanel = NULL;
	m_pPresetsExplanationPopup = NULL;
	m_pTauntsExplanationPopup = NULL;
	m_pBuildablesButton = NULL;
	
	m_pCharacterLoadoutButton = NULL;
	m_pTauntLoadoutButton = NULL;

	m_bInTauntLoadoutMode = false;

	g_pClassLoadoutPanel = this;

	m_pItemOptionPanel = new CLoadoutItemOptionsPanel( this, "ItemOptionsPanel" );
}

CClassLoadoutPanel::~CClassLoadoutPanel()
{
	if ( m_pItemOptionPanelKVs )
	{
		m_pItemOptionPanelKVs->deleteThis();
		m_pItemOptionPanelKVs = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	LoadControlSettings( "Resource/UI/ClassLoadoutPanel.res" );

	BaseClass::ApplySchemeSettings( pScheme );

	m_pPlayerModelPanel = dynamic_cast<CTFPlayerModelPanel*>( FindChildByName("classmodelpanel") );
	m_pTauntHintLabel = dynamic_cast<vgui::Label*>( FindChildByName("TauntHintLabel") );
	m_pTauntLabel = dynamic_cast<CExLabel*>( FindChildByName("TauntLabel") );
	m_pTauntCaratLabel = dynamic_cast<CExLabel*>( FindChildByName("TauntCaratLabel") );
	m_pBuildablesButton = dynamic_cast<CExButton*>( FindChildByName("BuildablesButton") );
	m_pCharacterLoadoutButton = dynamic_cast<CExImageButton*>( FindChildByName("CharacterLoadoutButton") );
	m_pTauntLoadoutButton = dynamic_cast<CExImageButton*>( FindChildByName("TauntLoadoutButton") );
	m_pPassiveAttribsLabel = dynamic_cast<CExLabel*>( FindChildByName("PassiveAttribsLabel") );
	m_pLoadoutPresetPanel = dynamic_cast<CLoadoutPresetPanel*>( FindChildByName( "loadout_preset_panel" ) );
	m_pPresetsExplanationPopup = dynamic_cast<CExplanationPopup*>( FindChildByName( "PresetsExplanation" ) );
	m_pTauntsExplanationPopup = dynamic_cast<CExplanationPopup*>( FindChildByName( "TauntsExplanation" ) );
	m_pTopLinePanel = FindChildByName( "TopLine" );
	if ( m_pPassiveAttribsLabel )
	{
		m_pPassiveAttribsLabel->SetMouseInputEnabled( false );
	}

	m_pMouseOverTooltip->SetPositioningStrategy( IPTTP_BOTTOM_SIDE );

	m_aDefaultColors[LOADED][FG][DEFAULT] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Econ.Button.PresetDefaultColorFg", Color( 255, 255, 255, 255 ) );
	m_aDefaultColors[LOADED][FG][ARMED] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Econ.Button.PresetArmedColorFg", Color( 255, 255, 255, 255 ) );
	m_aDefaultColors[LOADED][FG][DEPRESSED] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Econ.Button.PresetDepressedColorFg", Color( 255, 255, 255, 255 ) );

	m_aDefaultColors[LOADED][BG][DEFAULT] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Econ.Button.PresetDefaultColorBg", Color( 255, 255, 255, 255 ) );
	m_aDefaultColors[LOADED][BG][ARMED] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Econ.Button.PresetArmedColorBg", Color( 255, 255, 255, 255 ) );
	m_aDefaultColors[LOADED][BG][DEPRESSED] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Econ.Button.PresetDepressedColorBg", Color( 255, 255, 255, 255 ) );

	m_aDefaultColors[NOTLOADED][FG][DEFAULT] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Button.TextColor", Color( 255, 255, 255, 255 ) );
	m_aDefaultColors[NOTLOADED][FG][ARMED] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Button.ArmedTextColor", Color( 255, 255, 255, 255 ) );
	m_aDefaultColors[NOTLOADED][FG][DEPRESSED] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Button.DepressedTextColor", Color( 255, 255, 255, 255 ) );

	m_aDefaultColors[NOTLOADED][BG][DEFAULT] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Button.BgColor", Color( 255, 255, 255, 255 ) );
	m_aDefaultColors[NOTLOADED][BG][ARMED] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Button.ArmedBgColor", Color( 255, 255, 255, 255 ) );
	m_aDefaultColors[NOTLOADED][BG][DEPRESSED] = vgui::scheme()->GetIScheme( GetScheme() )->GetColor( "Button.DepressedBgColor", Color( 255, 255, 255, 255 ) );
}


void CClassLoadoutPanel::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	KeyValues *pItemKV = inResourceData->FindKey( "itemoptionpanels_kv" );
	if ( pItemKV )
	{
		if ( m_pItemOptionPanelKVs )
		{
			m_pItemOptionPanelKVs->deleteThis();
		}
		m_pItemOptionPanelKVs = new KeyValues("itemoptionpanels_kv");
		pItemKV->CopySubkeys( m_pItemOptionPanelKVs );
	}

#ifdef STAGING_ONLY
	// PDA Panels
	if ( m_pItemModelPanels.Count() > LOADOUT_POSITION_PDA_ADDON2 )
	{
		for ( int i = LOADOUT_POSITION_PDA_ADDON1; i <= LOADOUT_POSITION_PDA_ADDON2; i++ )
		{
			int wide = m_pItemModelPanels[i]->GetWide();
			int tall = m_pItemModelPanels[i]->GetTall();

			m_pItemModelPanels[i]->SetSize( wide / 2, tall / 2 );
			m_pItemModelPanels[i]->InvalidateLayout();
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::PerformLayout( void ) 
{
	BaseClass::PerformLayout();

	// This is disabled by default in res file. IF we turn it on again, uncomment this.
	/*if ( m_pPassiveAttribsLabel )
	{
		m_pPassiveAttribsLabel->SetVisible( !m_bInTauntLoadoutMode );
	}*/

	if ( m_pTauntHintLabel )
	{
		m_pTauntHintLabel->SetVisible( m_bInTauntLoadoutMode );
		
		const char *key = engine->Key_LookupBinding( "taunt" );
		if ( !key )
		{
			key = "< not bound >";
		}
		SetDialogVariable( "taunt", key );
	}

	if ( m_pTauntLabel )
	{
		m_pTauntLabel->SetVisible( m_bInTauntLoadoutMode );
	}
	if ( m_pTauntCaratLabel )
	{
		m_pTauntCaratLabel->SetVisible( m_bInTauntLoadoutMode );
	}
	if ( m_pCharacterLoadoutButton )
	{
		UpdatePageButtonColor( m_pCharacterLoadoutButton, !m_bInTauntLoadoutMode );
	}
	if ( m_pTauntLoadoutButton )
	{
		UpdatePageButtonColor( m_pTauntLoadoutButton, m_bInTauntLoadoutMode );
	}

	FOR_EACH_VEC( m_vecItemOptionButtons, i )
	{
		m_vecItemOptionButtons[i]->SetVisible( false );
	}
	
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		// Viewing a class loadout. Layout the buttons & the class image.
		if ( i >= NUM_ITEM_PANELS_IN_LOADOUT )
		{
			m_pItemModelPanels[i]->SetVisible( false );
			continue;
		}

		int iButtonPos = 0;
		if ( m_iCurrentClassIndex != TF_CLASS_UNDEFINED )
		{
			iButtonPos = g_VisibleLoadoutSlotsPerClass[m_iCurrentClassIndex]->m_iPos[i];
		}

		bool bIsVisible = false;
		if ( iButtonPos > 0 )
		{
			bIsVisible = m_bInTauntLoadoutMode ? IsTauntPanelPosition( iButtonPos ) : !IsTauntPanelPosition( iButtonPos );
		}
		m_pItemModelPanels[i]->SetVisible( bIsVisible );

		if ( bIsVisible )
		{
			if ( m_bInTauntLoadoutMode )
			{
				iButtonPos -= g_VisibleLoadoutSlotsPerClass[m_iCurrentClassIndex]->m_iPos[LOADOUT_POSITION_TAUNT];
			}
			else
			{
				iButtonPos--;
			}
			
#ifdef STAGING_ONLY
			// Override for the PDA AddOnSlots
			if ( i == LOADOUT_POSITION_PDA_ADDON1 )
			{
				int iYPos, iXPos;
				m_pItemModelPanels[ LOADOUT_POSITION_PDA ]->GetPos( iXPos, iYPos );
				int iWide, iTall;
				m_pItemModelPanels[ LOADOUT_POSITION_PDA ]->GetSize( iWide, iTall );

				m_pItemModelPanels[i]->SetPos( iXPos + iWide + XRES(1), iYPos );
				m_pItemModelPanels[i]->SetSize( iWide / 2.1, iTall / 2.1 );
				continue;
			}
			else if ( i == LOADOUT_POSITION_PDA_ADDON2 )
			{
				int iYPos, iXPos;
				m_pItemModelPanels[LOADOUT_POSITION_PDA]->GetPos( iXPos, iYPos );
				int iWide, iTall;
				m_pItemModelPanels[LOADOUT_POSITION_PDA]->GetSize( iWide, iTall );

				m_pItemModelPanels[i]->SetPos( iXPos + iWide + XRES(1), iYPos + iTall - (iTall / 2.1 ) );
				m_pItemModelPanels[i]->SetSize( iWide / 2.1, iTall / 2.1 );
				continue;
			}
#endif

			m_pItemModelPanels[i]->SetNoItemText( ItemSystem()->GetItemSchema()->GetLoadoutStringsForDisplay( EEquipType_t::EQUIP_TYPE_CLASS )[i] );

			int iCenter = GetWide() * 0.5;
			int iColumnHeight = 4;
			int iColumn = iButtonPos / iColumnHeight;
			int iYButtonPos = iButtonPos % iColumnHeight;
			
			int iOffset = iColumn == 0 ? m_iItemXPosOffcenterA : m_iItemXPosOffcenterB + ((iColumn - 1) * 200);
			int	iXPos = iCenter + iOffset;
			int	iYPos = m_iItemYPos + (m_iItemYDelta * iYButtonPos);
			m_pItemModelPanels[i]->SetPos( iXPos, iYPos );

			// Update position and visibility of the item option buttons
			if ( i < m_vecItemOptionButtons.Count() )
			{
				// Place the button just inside the item model panel
				CExButton* pItemOptionsPanel = m_vecItemOptionButtons[iButtonPos];
				int iButtonWide = m_pItemModelPanels[i]->GetWide();
				int iMyWide = pItemOptionsPanel->GetWide();
				int iOptionsXPos = iColumn == 0 
								 ? iXPos + iButtonWide - iMyWide
								 : iXPos;
				pItemOptionsPanel->SetPos( iOptionsXPos, iYPos );

				CEconItemView *pItemData = TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, i );
				// Enable or disable the item options button for this item model panel
				pItemOptionsPanel->SetVisible( !m_bInTauntLoadoutMode && AnyOptionsAvailableForItem( pItemData ) );
				pItemOptionsPanel->SetCommand( CFmtStr( "options%d", i ) );
			}
		}

		m_pItemModelPanels[ i ]->SetSelected( false );
	}

	if ( m_pLoadoutPresetPanel )
	{
		m_pLoadoutPresetPanel->SetPos( ( ScreenWidth() - m_pLoadoutPresetPanel->GetWide() ) / 2, m_iItemYPos );
	}

	LinkModelPanelControllerNavigation( true );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnKeyCodePressed( vgui::KeyCode code )
{
	// See if the preset control uses this key
	if( m_pLoadoutPresetPanel->HandlePresetKeyPressed( code ) )
	{
		return;
	}

	ButtonCode_t nButtonCode = GetBaseButtonCode( code );

	if (nButtonCode == KEY_XBUTTON_LEFT || 
		nButtonCode == KEY_XSTICK1_LEFT ||
		nButtonCode == KEY_XSTICK2_LEFT ||
		nButtonCode == STEAMCONTROLLER_DPAD_LEFT ||
		code == KEY_LEFT ||
		nButtonCode == KEY_XBUTTON_RIGHT || 
		nButtonCode == KEY_XSTICK1_RIGHT ||
		nButtonCode == KEY_XSTICK2_RIGHT ||
		nButtonCode == STEAMCONTROLLER_DPAD_RIGHT ||
		code == KEY_RIGHT ||
		nButtonCode == KEY_XBUTTON_UP || 
		nButtonCode == KEY_XSTICK1_UP ||
		nButtonCode == KEY_XSTICK2_UP ||
		nButtonCode == STEAMCONTROLLER_DPAD_UP ||
		code == KEY_UP ||
		nButtonCode == KEY_XBUTTON_DOWN || 
		nButtonCode == KEY_XSTICK1_DOWN ||
		nButtonCode == KEY_XSTICK2_DOWN ||
		nButtonCode == STEAMCONTROLLER_DPAD_DOWN ||
		code == KEY_DOWN )
	{
		// just eat all navigation keys so we don't 
		// end up with undesirable navigation behavior bubbling from 
		// one item model panel to another
	}
	else if( nButtonCode == KEY_XBUTTON_A || code == KEY_ENTER || nButtonCode == STEAMCONTROLLER_A )
	{
		// show the current loadout slot
		int nSelected = GetFirstSelectedItemIndex( true );
		if( nSelected != -1 )
		{
			OnCommand( VarArgs("change%d", nSelected ) );
		}
	}
	else
	{
		BaseClass::OnKeyCodePressed( code );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnNavigateTo( const char* panelName )
{
	CItemModelPanel *pChild = dynamic_cast<CItemModelPanel *>( FindChildByName( panelName ) );
	if( !pChild )
		return;

	pChild->SetSelected( true );
	SetBorderForItem( pChild, false );
	pChild->RequestFocus();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnNavigateFrom( const char* panelName )
{
	CItemModelPanel *pChild = dynamic_cast<CItemModelPanel *>( FindChildByName( panelName ) );
	if( !pChild )
		return;

	pChild->SetSelected( false );
	SetBorderForItem( pChild, false );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnShowPanel( bool bVisible, bool bReturningFromArmory )
{
	if ( bVisible )
	{
		// always start in character loadout page
		SetLoadoutPage( CHARACTER_LOADOUT_PAGE );

		if ( m_pSelectionPanel )
		{
			m_pSelectionPanel->SetVisible( false );
			m_pSelectionPanel->MarkForDeletion();
			m_pSelectionPanel = NULL;
		}

		m_iCurrentSlotIndex = TF_WPN_TYPE_PRIMARY;
		if( m_pItemModelPanels.Count() && m_pItemModelPanels[0] )
		{
			m_pItemModelPanels[0]->SetSelected( true );
			SetBorderForItem( m_pItemModelPanels[0], false );
		}

		m_bLoadoutHasChanged = false;

		if ( tf_show_preset_explanation_in_class_loadout.GetBool() && m_pPresetsExplanationPopup )
		{
			m_pPresetsExplanationPopup->Popup();
			tf_show_preset_explanation_in_class_loadout.SetValue( 0 );
		}
		else if ( tf_show_taunt_explanation_in_class_loadout.GetBool() && m_pTauntsExplanationPopup )
		{
			m_pTauntsExplanationPopup->Popup();
			tf_show_taunt_explanation_in_class_loadout.SetValue( 0 );
		}

		ClearItemOptionsMenu();
	}
	else
	{
		if ( m_pPlayerModelPanel )
		{
			m_pPlayerModelPanel->ClearCarriedItems();
		}
	}
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::PostShowPanel( bool bVisible )
{
	if ( bVisible )
	{
		if ( m_pPlayerModelPanel )
		{
			m_pPlayerModelPanel->SetVisible( true );
		}

		if ( m_pBuildablesButton )
		{
			m_pBuildablesButton->SetVisible( m_iCurrentClassIndex == TF_CLASS_ENGINEER );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::SetClass( int iClass )
{
	m_iCurrentClassIndex = iClass;

	if ( m_pLoadoutPresetPanel )
	{
		m_pLoadoutPresetPanel->SetClass( m_iCurrentClassIndex );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::SetTeam( int iTeam )
{
	Assert( IsValidTFTeam( iTeam ) );
	m_iCurrentTeamIndex = iTeam;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CClassLoadoutPanel::GetNumRelevantSlots() const
{
	return m_pItemModelPanels.Count();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CEconItemView *CClassLoadoutPanel::GetItemInSlot( int iSlot )
{
	if( iSlot >= 0 && iSlot < m_pItemModelPanels.Count() )
	{
		return m_pItemModelPanels[iSlot]->GetItem();
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::FireGameEvent( IGameEvent *event )
{
	// If we're not visible, ignore all events
	if ( !IsVisible() )
		return;

	BaseClass::FireGameEvent( event );

	// We need to update ourselves after the base has done it, so our item models have been updated
	const char *type = event->GetName();
	if ( Q_strcmp( "inventory_updated", type ) == 0 )
	{
		if ( m_pPlayerModelPanel )
		{
			m_pPlayerModelPanel->HoldItemInSlot( m_iCurrentSlotIndex );
		}
	}
}

void CClassLoadoutPanel::AddNewItemPanel( int iPanelIndex )
{
	BaseClass::AddNewItemPanel( iPanelIndex );

	m_vecItemOptionButtons[ m_vecItemOptionButtons.AddToTail() ] = new CExButton( this,
																				  CFmtStr( "item_options_button%d", iPanelIndex ),
																				  "+",
																				  this,
																				  CFmtStr( "options%d", iPanelIndex ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::UpdateModelPanels( void )
{
	// Search for a Robot Costume
	bool bIsRobot = false;
	static CSchemaAttributeDefHandle pAttrDef_PlayerRobot( "appear as mvm robot" );
	// For now, fill them out with the local player's currently wielded items
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		CEconItemView *pItemData = TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, i );
		if ( !pItemData )
			continue;
		if ( FindAttribute( pItemData, pAttrDef_PlayerRobot ) )
		{
			bIsRobot = true;
			break;
		}
	}

	// We're showing the loadout for a specific class.
	TFPlayerClassData_t *pData = GetPlayerClassData( m_iCurrentClassIndex );
	if ( m_pPlayerModelPanel )
	{
		m_pPlayerModelPanel->ClearCarriedItems();
		m_pPlayerModelPanel->SetToPlayerClass( m_iCurrentClassIndex, bIsRobot );
		m_pPlayerModelPanel->SetTeam( m_iCurrentTeamIndex );
	}

	// For now, fill them out with the local player's currently wielded items
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		CEconItemView *pItemData = TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, i );
		m_pItemModelPanels[i]->SetItem( pItemData );
		m_pItemModelPanels[i]->SetShowQuantity( true );
		m_pItemModelPanels[i]->SetSelected( false );
		SetBorderForItem( m_pItemModelPanels[i], false );

		if ( m_pPlayerModelPanel && pItemData && pItemData->IsValid() )
		{
			m_pPlayerModelPanel->AddCarriedItem( pItemData );
		}
	}

	if ( m_pPlayerModelPanel )
	{
		m_pPlayerModelPanel->HoldItemInSlot( m_iCurrentSlotIndex );
	}

	SetDialogVariable( "loadoutclass", g_pVGuiLocalize->Find( pData->m_szLocalizableName ) );

	UpdatePassiveAttributes();

	// Now layout again to position our item buttons 
	InvalidateLayout();

	if ( m_pItemOptionPanel->IsVisible() )
	{
		m_pItemOptionPanel->UpdateItemOptionsUI();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnItemPanelMouseReleased( vgui::Panel *panel )
{
	CItemModelPanel *pItemPanel = dynamic_cast < CItemModelPanel * > ( panel );

	if ( pItemPanel && IsVisible() )
	{
		for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
		{
			if ( m_pItemModelPanels[i] == pItemPanel  )
			{
				OnCommand( VarArgs("change%d", i) );
				return;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnSelectionReturned( KeyValues *data )
{
	if ( data )
	{
		uint64 ulIndex = data->GetUint64( "itemindex", INVALID_ITEM_ID );

		// ulIndex implies do nothing (escape key)
		if ( ulIndex != 0 )
		{
			TFInventoryManager()->EquipItemInLoadout( m_iCurrentClassIndex, m_iCurrentSlotIndex, ulIndex );

			m_bLoadoutHasChanged = true;

			UpdateModelPanels();

			// Send the preset panel a msg so it can save the change
			KeyValues *pLoadoutChangedMsg = new KeyValues( "LoadoutChanged" );
			pLoadoutChangedMsg->SetInt( "slot", m_iCurrentSlotIndex );
			pLoadoutChangedMsg->SetUint64( "itemid", ulIndex );
			PostMessage( m_pLoadoutPresetPanel, pLoadoutChangedMsg );
		}
	}

	PostMessage( GetParent(), new KeyValues("SelectionEnded") );

	// It'll have deleted itself, so we don't need to clean it up
	m_pSelectionPanel = NULL;
	OnCancelSelection();

	// find the selected item and give it the focus
	CItemModelPanel *pSelection = GetFirstSelectedItemModelPanel( true );
	if( !pSelection )
	{
		m_pItemModelPanels[0]->SetSelected( true );
		pSelection = m_pItemModelPanels[0];
	}

	pSelection->RequestFocus();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnCancelSelection( void )
{
	if ( m_pSelectionPanel )
	{
		m_pSelectionPanel->SetVisible( false );
		m_pSelectionPanel->MarkForDeletion();
		m_pSelectionPanel = NULL;
	}

	if ( m_pPlayerModelPanel )
	{
		m_pPlayerModelPanel->SetVisible( true );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::RespawnPlayer()
{
	if ( tf_respawn_on_loadoutchanges.GetBool() )
	{
		// Tell the GC to tell server that we should respawn if we're in a respawn room
		GCSDK::CGCMsg< MsgGCEmpty_t > msg( k_EMsgGCRespawnPostLoadoutChange );
		GCClientSystem()->BSendMessage( msg );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Apply KVs to the item option buttons
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::ApplyKVsToItemPanels( void )
{
	BaseClass::ApplyKVsToItemPanels();

	if ( m_pItemOptionPanelKVs )
	{
		for ( int i = 0; i < m_vecItemOptionButtons.Count(); i++ )
		{
			m_vecItemOptionButtons[i]->ApplySettings( m_pItemOptionPanelKVs );
			m_vecItemOptionButtons[i]->InvalidateLayout();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnClosing( void )
{
	if ( m_pPlayerModelPanel )
	{
		m_pPlayerModelPanel->ClearCarriedItems();
	}

	if ( m_bLoadoutHasChanged )
	{
		RespawnPlayer();

		m_bLoadoutHasChanged = false;
	}
}

extern const char *g_szItemBorders[AE_MAX_TYPES][5];
extern ConVar cl_showbackpackrarities;
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::SetBorderForItem( CItemModelPanel *pItemPanel, bool bMouseOver )
{
	if ( !pItemPanel )
		return;

	const char *pszBorder = NULL;

	if ( pItemPanel->IsGreyedOut() )
	{
		pszBorder = "EconItemBorder";
	}
	else
	{
		int iRarity = 0;
		if ( pItemPanel->HasItem() && cl_showbackpackrarities.GetBool() )
		{
			iRarity = pItemPanel->GetItem()->GetItemQuality();

			uint8 nRarity = pItemPanel->GetItem()->GetItemDefinition()->GetRarity();
			if ( ( nRarity != k_unItemRarity_Any ) && ( iRarity != AE_SELFMADE ) )
			{
				// translate this quality to rarity
				iRarity = nRarity + AE_RARITY_DEFAULT;
			}

			if ( iRarity > 0 )
			{
				if ( bMouseOver || pItemPanel->IsSelected() )
				{
					pszBorder = g_szItemBorders[iRarity][1];
				}
				else
				{
					pszBorder = g_szItemBorders[iRarity][0];
				}
			}
		}
		
		
		if ( iRarity == 0 )
		{
			if ( bMouseOver || pItemPanel->IsSelected() )
			{
				pszBorder = "LoadoutItemMouseOverBorder";
			}
			else
			{
				pszBorder = "EconItemBorder";
			}
		}
	}

	vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
	pItemPanel->SetBorder( pScheme->GetBorder( pszBorder ) );
}

//-----------------------------------------------------------------------------
// Purpose: Clear the item options menu and reset the button that summoned it
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::ClearItemOptionsMenu( void )
{
	SetOptionsButtonText( m_pItemOptionPanel->GetItemSlot(), "+" );
	m_pItemOptionPanel->SetItemSlot( LOADOUT_POSITION_INVALID, m_iCurrentClassIndex );
	m_pItemOptionPanel->SetVisible( false );
}

//-----------------------------------------------------------------------------
// Purpose: Safely set the text for a button
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::SetOptionsButtonText( int nIndex, const char* pszText )
{
	if ( nIndex >= 0 && nIndex < m_vecItemOptionButtons.Count() )
	{
		m_vecItemOptionButtons[ m_pItemOptionPanel->GetItemSlot() ]->SetText( pszText );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Return if the passed in item has any options
//-----------------------------------------------------------------------------
bool CClassLoadoutPanel::AnyOptionsAvailableForItem( const CEconItemView *pItem )
{
	if ( !pItem )
		return false;
		
	// Styles!
	if ( pItem->GetStaticData()->GetNumSelectableStyles() > 1 )
		return true;

	// Unusual particle effect! For Cosmetics only
	static CSchemaAttributeDefHandle pAttrDef_AttachParticleEffect( "attach particle effect" );
	if ( pItem->FindAttribute( pAttrDef_AttachParticleEffect ) && pItem->GetItemDefinition()->GetLoadoutSlot( 0 ) >= LOADOUT_POSITION_HEAD )
		return true;

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::SetLoadoutPage( classloadoutpage_t loadoutPage )
{
	ClearItemOptionsMenu();
	switch ( loadoutPage )
	{
		case CHARACTER_LOADOUT_PAGE:
		{
			m_bInTauntLoadoutMode = false;
		}
		break;
		case TAUNT_LOADOUT_PAGE:
		{
			m_bInTauntLoadoutMode = true;
		}
		break;
		default:
		{
			// Unhandled loadout page
			Assert( 0 );
		}
	}
	InvalidateLayout();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnCommand( const char *command )
{
	if ( FStrEq( command, "characterloadout" ) )
	{
		SetLoadoutPage( CHARACTER_LOADOUT_PAGE );
		return;
	}
	else if ( FStrEq( command, "tauntloadout" ) )
	{
		SetLoadoutPage( TAUNT_LOADOUT_PAGE );
		return;
	}
	else if ( !V_strnicmp( command, "change", 6 ) )
	{
		const char *pszNum = command+6;
		if ( pszNum && pszNum[0] )
		{
			int iSlot = atoi(pszNum);
			if ( iSlot >= 0 && iSlot < CLASS_LOADOUT_POSITION_COUNT && m_iCurrentClassIndex != TF_CLASS_UNDEFINED )
			{
				if ( m_iCurrentSlotIndex != iSlot )
				{
					m_iCurrentSlotIndex = iSlot;
				}

				// Create the selection screen. It removes itself on close.
				m_pSelectionPanel = new CEquipSlotItemSelectionPanel( this, m_iCurrentClassIndex, iSlot );
				m_pSelectionPanel->ShowPanel( 0, true );

				if ( m_pPlayerModelPanel )
				{
					m_pPlayerModelPanel->SetVisible( false );
				}

				ClearItemOptionsMenu();

				PostMessage( GetParent(), new KeyValues("SelectionStarted") );
			}
		}

		return;
	}
	else if ( !V_strnicmp( command, "options", 7 ) )
	{
		const char *pszNum = command + 7;
		if( pszNum && pszNum[0] )
		{
			int iSlot = atoi( pszNum );
			//iSlot = g_VisibleLoadoutSlotsPerClass[m_iCurrentClassIndex]->m_iPos[iSlot - 1];
			if ( iSlot >= 0 && iSlot < m_vecItemOptionButtons.Count() && m_iCurrentClassIndex != TF_CLASS_UNDEFINED )
			{
				// Change the button we're coming from to be a "+"
				SetOptionsButtonText( m_pItemOptionPanel->GetItemSlot(), "+" );

				// Update the current slot index for callback from the setstyle button.
				// It will send us a message to change the item the player model is holding
				// and we need this to be updated for that.
				m_iCurrentSlotIndex = iSlot;
				

				// Did they just toggle?
				if ( m_pItemOptionPanel->GetItemSlot() == iSlot )
				{
					m_pItemOptionPanel->SetVisible( !m_pItemOptionPanel->IsVisible() );
				}
				else
				{
					// Set the options panel to have the data for this slot
					m_pItemOptionPanel->SetItemSlot( (loadout_positions_t)iSlot, m_iCurrentClassIndex );
					m_pItemOptionPanel->SetVisible( true );
					// Figure out if this is on the left or right
					int iColumnHeight = 4;
					int iColumn = iSlot / iColumnHeight;
					PinCorner_e myCornerToPin = iColumn == 0 ? PIN_TOPLEFT : PIN_TOPRIGHT;
					PinCorner_e siblingCornerPinTo = iColumn == 0 ? PIN_TOPRIGHT : PIN_TOPLEFT;
					// Pin to the appropriate side
					int iButtonPos = g_VisibleLoadoutSlotsPerClass[m_iCurrentClassIndex]->m_iPos[ iSlot ] - 1;
					m_pItemOptionPanel->PinToSibling( m_vecItemOptionButtons[ iButtonPos ]->GetName(), myCornerToPin, siblingCornerPinTo );
					m_pItemOptionPanel->UpdateItemOptionsUI();
				}

				// Change the button we're going to to be "-" if we're visible, "+" if we're not
				SetOptionsButtonText( m_pItemOptionPanel->GetItemSlot(), m_pItemOptionPanel->IsVisible() ? "-" : "+" );
			}
			return;
		}
	}
	BaseClass::OnCommand( command );
}

//-----------------------------------------------------------------------------
void CClassLoadoutPanel::OnMessage( const KeyValues* pParams, vgui::VPANEL hFromPanel )
{
	BaseClass::OnMessage( pParams, hFromPanel );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
struct passive_attrib_to_print_t
{
	const CEconItemAttributeDefinition *m_pAttrDef;
	attrib_value_t m_value;
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
class CAttributeIterator_AddPassiveAttribsToPassiveList : public CEconItemSpecificAttributeIterator
{
public:
	CAttributeIterator_AddPassiveAttribsToPassiveList( CUtlVector<passive_attrib_to_print_t> *pList, bool bForceAdd )
		: m_pList( pList )
		, m_bForceAdd( bForceAdd )
	{
		Assert( m_pList );
	}

	virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, attrib_value_t value )
	{
		Assert( pAttrDef );

		if ( pAttrDef->IsHidden() )
			return true;

		if ( !m_bForceAdd )
		{
			const char *pDesc = pAttrDef->GetArmoryDescString();
			if ( !pDesc || !pDesc[0] )
				return true;

			// If we have the "on_wearer" key, we're a passive attribute
			if ( !Q_stristr(pDesc, "on_wearer") )
				return true;
		}

		// Now see if we're already in the list
		FOR_EACH_VEC( (*m_pList), i )
		{
			passive_attrib_to_print_t& passiveAttr = (*m_pList)[i];

			Assert( passiveAttr.m_pAttrDef );

			// We match if our class is the same -- this is a case-sensitive compare!
			if ( Q_strcmp( passiveAttr.m_pAttrDef->GetAttributeClass(), pAttrDef->GetAttributeClass() ) )
				continue;

			// We've found a matching attribute. Collate our values and stomp over the earlier value.
			passiveAttr.m_value = CollateAttributeValues( passiveAttr.m_pAttrDef, passiveAttr.m_value, pAttrDef, value );

			return true;
		}

		// We didn't find it. Add it to the list.
		passive_attrib_to_print_t newPassiveAttr = { pAttrDef, value };
		m_pList->AddToTail( newPassiveAttr );

		return true;
	}

	// Other types are ignored.

private:
	CUtlVector<passive_attrib_to_print_t> *m_pList;
	bool m_bForceAdd;
};

//-----------------------------------------------------------------------------
void CClassLoadoutPanel::UpdatePassiveAttributes( void )
{
	if ( !m_pPassiveAttribsLabel )
		return;

	// We build a list of attributes & associated values by looping through all equipped items.
	// This way we can identify & collate attributes based on the same definition index.
	CUtlVector<passive_attrib_to_print_t> vecAttribsToPrint;

	// Loop through all equipped items
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		CEconItemView *pItemData = TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, i );
		if ( pItemData && pItemData->IsValid() )
		{
			CAttributeIterator_AddPassiveAttribsToPassiveList attrItPassives( &vecAttribsToPrint, false );
			pItemData->IterateAttributes( &attrItPassives );
		}
	}

	// Then add any set bonuses
	if ( steamapicontext && steamapicontext->SteamUser() )
	{
		CSteamID localSteamID = steamapicontext->SteamUser()->GetSteamID();
		CUtlVector<const CEconItemSetDefinition *> pActiveSets;
		TFInventoryManager()->GetActiveSets( &pActiveSets, localSteamID, m_iCurrentClassIndex );

		FOR_EACH_VEC( pActiveSets, set )
		{
			CAttributeIterator_AddPassiveAttribsToPassiveList attrItSetPassives( &vecAttribsToPrint, true );
			pActiveSets[set]->IterateAttributes( &attrItSetPassives );
		}
	}

	// Now build the text
	wchar_t wszPassiveDesc[4096];
	wszPassiveDesc[0] = '\0';
	m_pPassiveAttribsLabel->GetTextImage()->ClearColorChangeStream();

	wchar_t *pHeader = g_pVGuiLocalize->Find( "#TF_PassiveAttribs" );
	if ( pHeader )
	{
		V_wcscpy_safe( wszPassiveDesc, pHeader );
		V_wcscat_safe( wszPassiveDesc, L"\n" );
	}

	if ( vecAttribsToPrint.Count() )
	{
		FOR_EACH_VEC( vecAttribsToPrint, i )
		{
			CEconAttributeDescription AttrDesc( GLocalizationProvider(), vecAttribsToPrint[i].m_pAttrDef, vecAttribsToPrint[i].m_value );
			AddAttribPassiveText( AttrDesc, wszPassiveDesc, ARRAYSIZE(wszPassiveDesc) );
		}
	}
	else
	{
		vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
		Color col = pScheme->GetColor( GetColorNameForAttribColor( ATTRIB_COL_NEUTRAL ), Color(255,255,255,255) );
		m_pPassiveAttribsLabel->GetTextImage()->AddColorChange( col, Q_wcslen( wszPassiveDesc ) );

		wchar_t *pNone = g_pVGuiLocalize->Find( "#TF_PassiveAttribs_None" );
		if ( pNone )
		{
			V_wcscat_safe( wszPassiveDesc, pNone );
		}
	}

	m_pPassiveAttribsLabel->SetText( wszPassiveDesc );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::AddAttribPassiveText( const CEconAttributeDescription& AttrDesc, INOUT_Z_CAP(iNumPassiveChars) wchar_t *out_wszPassiveDesc, int iNumPassiveChars )
{
	vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
	Assert( pScheme );

	if ( !AttrDesc.GetDescription().IsEmpty() )
	{
		// Insert the color change at the current position
		Color col = pScheme->GetColor( GetColorNameForAttribColor( AttrDesc.GetDefaultColor() ), Color(255,255,255,255) );
		m_pPassiveAttribsLabel->GetTextImage()->AddColorChange( col, Q_wcslen( out_wszPassiveDesc ) );

		// Now append the text of the attribute
		V_wcsncat( out_wszPassiveDesc, AttrDesc.GetDescription().Get(), iNumPassiveChars );
		V_wcsncat( out_wszPassiveDesc, L"\n", iNumPassiveChars );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLoadoutPanel::UpdatePageButtonColor( CExImageButton *pPageButton, bool bIsActive )
{
	if ( pPageButton )
	{
		int iLoaded = bIsActive ? LOADED : NOTLOADED;
		pPageButton->SetDefaultColor( m_aDefaultColors[iLoaded][FG][DEFAULT], m_aDefaultColors[iLoaded][BG][DEFAULT] );
		pPageButton->SetArmedColor( m_aDefaultColors[iLoaded][FG][ARMED], m_aDefaultColors[iLoaded][BG][ARMED] );
		pPageButton->SetDepressedColor( m_aDefaultColors[iLoaded][FG][DEPRESSED], m_aDefaultColors[iLoaded][BG][DEPRESSED] );
	}
}