tf2/tf2_src/game/client/econ/backpack_panel.cpp

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


#include "cbase.h"
#include "backpack_panel.h"
#include "item_confirm_delete_dialog.h"
#include "vgui/ISurface.h"
#include "gamestringpool.h"
#include "iclientmode.h"
#include "econ_item_inventory.h"
#include "ienginevgui.h"
#include <vgui/ILocalize.h>
#include "vgui_controls/TextImage.h"
#include "vgui_controls/CheckButton.h"
#include "vgui_controls/ComboBox.h"
#include "vgui_controls/ScalableImagePanel.h"
#include "vgui/IInput.h"
#include "econ/tool_items/tool_items.h"
#include "econ_gcmessages.h"
#include "item_style_select_dialog.h"
#include "econ_item_system.h"
#include "econ_item_tools.h"
#include "econ_ui.h"
#include "gc_clientsystem.h"
#include "econ_store.h"
#include "rtime.h"
#include "econ_item_description.h"
#include "dynamic_recipe_subpanel.h"
#include "item_slot_panel.h"
#include "crate_detail_panels.h"
#include "tf_warinfopanel.h"
#include "character_info_panel.h"
#include "trading_start_dialog.h"
#include "vgui_controls/MenuItem.h"
#include "tf_duckleaderboard.h"
#include "tf_item_inventory.h"
#include "store/store_panel.h"
#include "strange_count_transfer_panel.h"
#include "collection_crafting_panel.h"
#include "halloween_offering_panel.h"
#include "store/v2/tf_store_preview_item2.h"
#include "item_ad_panel.h"
#include "client_community_market.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>


#ifdef STAGING_ONLY
extern ConVar tf_use_card_tooltips;
extern ConVar tf_weapon_force_allow_inspect;
#endif // STAGING_ONLY

ConVar tf_trade_up_use_count( "tf_trade_up_use_count", "3", FCVAR_ARCHIVE | FCVAR_HIDDEN );


void UseConsumableItem( CEconItemView *pItem, vgui::Panel* pParent );

const ItemSortTypeData_t g_BackpackSortTypes[] =
{
	{ "#Backpack_SortBy_Header",		kGCItemSort_NoSort },
	{ "#Backpack_SortBy_Rarity",		kGCItemSort_SortByRarity },
	{ "#Backpack_SortBy_Type",			kGCItemSort_SortByType },
	{ "#Backpack_SortBy_Class",			kTFGCItemSort_SortByClass },
	{ "#Backpack_SortBy_Slot",			kTFGCItemSort_SortBySlot },
	{ "#Backpack_SortBy_Date",			kGCItemSort_SortByDate },
};

// Array of borders for rarities. Three borders for each rarity: Base, Mouseover, and Selected
const char *g_szItemBorders[][5] =
{
	{ "BackpackItemBorder",				"BackpackItemMouseOverBorder",				"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder",				"BackpackItemGreyedOutSelectedBorder"				},		// AE_NORMAL = 0
	{ "BackpackItemBorder_1",			"BackpackItemMouseOverBorder_1",			"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_1",			"BackpackItemGreyedOutSelectedBorder_1"				},		// AE_RARITY1 = 1
	{ "BackpackItemBorder_2",			"BackpackItemMouseOverBorder_2",			"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_2",			"BackpackItemGreyedOutSelectedBorder_2"				},		// AE_RARITY2 = 2
	{ "BackpackItemBorder_Vintage",		"BackpackItemMouseOverBorder_Vintage",		"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Vintage",		"BackpackItemGreyedOutSelectedBorder_Vintage"		},		// AE_VINTAGE = 3
	{ "BackpackItemBorder_3",			"BackpackItemMouseOverBorder_3",			"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_3",			"BackpackItemGreyedOutSelectedBorder_3"				},		// AE_RARITY3
	{ "BackpackItemBorder_4",			"BackpackItemMouseOverBorder_4",			"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_4",			"BackpackItemGreyedOutSelectedBorder_4"				},		// AE_RARITY4
	{ "BackpackItemBorder_Unique",		"BackpackItemMouseOverBorder_Unique",		"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Unique",		"BackpackItemGreyedOutSelectedBorder_Unique"		},		// AE_UNIQUE
	{ "BackpackItemBorder_Community",	"BackpackItemMouseOverBorder_Community",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Community",	"BackpackItemGreyedOutSelectedBorder_Community"		},		// AE_COMMUNITY
	{ "BackpackItemBorder_Developer",	"BackpackItemMouseOverBorder_Developer",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Developer",	"BackpackItemGreyedOutSelectedBorder_Developer"		},		// AE_DEVELOPER
	{ "BackpackItemBorder_SelfMade",	"BackpackItemMouseOverBorder_SelfMade",		"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_SelfMade",		"BackpackItemGreyedOutSelectedBorder_SelfMade"		},		// AE_SELFMADE
	{ "BackpackItemBorder_Customized",	"BackpackItemMouseOverBorder_Customized",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Customized",	"BackpackItemGreyedOutSelectedBorder_Customized"	},		// AE_CUSTOMIZED
	{ "BackpackItemBorder_Strange",		"BackpackItemMouseOverBorder_Strange",		"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Strange",		"BackpackItemGreyedOutSelectedBorder_Strange"		},		// AE_STRANGE
	{ "BackpackItemBorder_Completed",	"BackpackItemMouseOverBorder_Completed",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Completed",	"BackpackItemGreyedOutSelectedBorder_Completed"		},		// AE_COMPLETED
	{ "BackpackItemBorder_Haunted",		"BackpackItemMouseOverBorder_Haunted",		"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Haunted",		"BackpackItemGreyedOutSelectedBorder_Haunted"		},		// AE_HAUNTED
	{ "BackpackItemBorder_Collectors",	"BackpackItemMouseOverBorder_Collectors",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_Collectors",	"BackpackItemGreyedOutSelectedBorder_Collectors"	},		// AE_COLLECTORS

	{ "BackpackItemBorder_PaintkitWeapon",	"BackpackItemMouseOverBorder_PaintkitWeapon",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_PaintkitWeapon",	"BackpackItemGreyedOutSelectedBorder_PaintkitWeapon"	},	// AE_Paintkit
	{ "BackpackItemBorder_RarityDefault",	"BackpackItemMouseOverBorder_RarityDefault",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_RarityDefault",	"BackpackItemGreyedOutSelectedBorder_RarityDefault"		}, // AE_RARITY_DEFAULT,
	{ "BackpackItemBorder_RarityCommon",	"BackpackItemMouseOverBorder_RarityCommon",		"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_RarityCommon",		"BackpackItemGreyedOutSelectedBorder_RarityCommon"		}, // AE_RARITY_COMMON,
	{ "BackpackItemBorder_RarityUncommon",	"BackpackItemMouseOverBorder_RarityUncommon",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_RarityUncommon",	"BackpackItemGreyedOutSelectedBorder_RarityUncommon"	}, // AE_RARITY_UNCOMMON,
	{ "BackpackItemBorder_RarityRare",		"BackpackItemMouseOverBorder_RarityRare",		"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_RarityRare",		"BackpackItemGreyedOutSelectedBorder_RarityRare"		}, // AE_RARITY_RARE,
	{ "BackpackItemBorder_RarityMythical",	"BackpackItemMouseOverBorder_RarityMythical",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_RarityMythical",	"BackpackItemGreyedOutSelectedBorder_RarityMythical"	}, // AE_RARITY_MYTHICAL,
	{ "BackpackItemBorder_RarityLegendary",	"BackpackItemMouseOverBorder_RarityLegendary",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_RarityLegendary",	"BackpackItemGreyedOutSelectedBorder_RarityLegendary"	}, // AE_RARITY_LEGENDARY,
	{ "BackpackItemBorder_RarityAncient",	"BackpackItemMouseOverBorder_RarityAncient",	"BackpackItemSelectedBorder",	"BackpackItemGreyedOutBorder_RarityAncient",	"BackpackItemGreyedOutSelectedBorder_RarityAncient"		}, // AE_RARITY_ANCIENT,
};	

COMPILE_TIME_ASSERT( ARRAYSIZE(g_szItemBorders) == AE_MAX_TYPES );

enum { kNoUserData = -1 };

static bool HasPaint ( const CEconItemView *pEconItemView, const char *, int )
{
	static CSchemaAttributeDefHandle pAttrDef_PaintRGB( "set item tint RGB" );
	static CSchemaAttributeDefHandle pAttrDef_PaintRGB2( "set item tint RGB 2" );

	return pEconItemView->FindAttribute( pAttrDef_PaintRGB )
		|| pEconItemView->FindAttribute( pAttrDef_PaintRGB2 );
}

static bool HasCustomAttribute ( const CEconItemView *pEconItemView, const char *szAttrName, int )
{
	const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinitionByName( szAttrName );

	return pAttrDef
		 ? pEconItemView->FindAttribute( pAttrDef )
		 : NULL;
}

static bool HasCustomUserAttribute ( const CEconItemView *pEconItemView, const char *, int iUserData )
{
	Assert( iUserData != kNoUserData );

	CCountUserGeneratedAttributeIterator countIterator;
	pEconItemView->IterateAttributes( &countIterator );

	return countIterator.GetCount() > iUserData;
}	

static bool HasRemovableCustomName ( const CEconItemView *pEconItemView, const char *, int )
{
	if ( !pEconItemView->GetItemDefinition() )
		return false;

	if ( pEconItemView->GetQuality() == AE_UNIQUE && pEconItemView->GetItemDefinition()->GetArmoryDescString() && !V_stricmp( pEconItemView->GetItemDefinition()->GetArmoryDescString(), "stockitem" ) )
		return false;

	return pEconItemView->GetSOCData() && pEconItemView->GetSOCData()->GetCustomName();
}

static bool HasRemovableCustomDesc ( const CEconItemView *pEconItemView, const char *, int )
{
	if ( !pEconItemView->GetItemDefinition() )
		return false;

	if ( pEconItemView->GetQuality() == AE_UNIQUE && pEconItemView->GetItemDefinition()->GetArmoryDescString() && !V_stricmp( pEconItemView->GetItemDefinition()->GetArmoryDescString(), "stockitem" ) )
		return false;

	return pEconItemView->GetSOCData() && pEconItemView->GetSOCData()->GetCustomDesc();
}

enum EItemCustomizationRemoveType
{
	kCustomizationRemove_Paint,
	kCustomizationRemove_Name,
	kCustomizationRemove_Desc,
	kCustomizationRemove_CustomTexture,
	kCustomizationRemove_MakersMark,
	kCustomizationRemove_UniqueCraftIndex,
	kCustomizationRemove_StrangePart,
	kCustomizationRemove_StrangeScores,
	kCustomizationRemove_UpgradeCard,
	kCustomizationRemove_KillStreak,
	kCustomizationRemove_GiftedBy,
	kCustomizationRemove_Festivizer,
};

typedef bool (* HasRefurbishablePropertyFunc_t)( const CEconItemView *pEconItemView, const char *pArg, int iUserData );

void GetCustomDialogToken_PaintName( const CEconItemView *pEconItemView, int iUserData, CUtlConstWideString& out_String )
{
	extern const CEconItemDefinition *GetPaintItemDefinitionForPaintedItem( const IEconItemInterface *pEconItem );

	Assert( iUserData == kNoUserData );

	const CEconItemDefinition *pPaintItemDef = GetPaintItemDefinitionForPaintedItem( pEconItemView );
	if ( !pPaintItemDef )
	{
		out_String = L"";
		return;
	}

	out_String = GLocalizationProvider()->Find( pPaintItemDef->GetItemBaseName() );
}

void GetCustomDialogToken_StrangePartName( const CEconItemView *pEconItemView, int iUserData, CUtlConstWideString& out_String )
{
	extern uint32 GetScoreTypeForKillEaterAttr( const IEconItemInterface *pEconItem, const CEconItemAttributeDefinition *pAttribDef );
	extern const wchar_t *GetLocalizedStringForKillEaterTypeAttr( const CLocalizationProvider *pLocalizationProvider, uint32 unKillEaterEventType );		// return type changed from locchar_t * because the backpack panel only exists on the client

	uint32 unKillEaterBaseType = GetScoreTypeForKillEaterAttr( pEconItemView, GetKillEaterAttr_Type( iUserData ) );
	
	out_String = GetLocalizedStringForKillEaterTypeAttr( GLocalizationProvider(), unKillEaterBaseType );
}

void GetCustomDialogToken_UserAttributeName( const CEconItemView *pEconItemView, int iUserData, CUtlConstWideString& out_String )
{
	Assert( pEconItemView );

	const CEconItemAttributeDefinition *pAttrDef = GetCardUpgradeForIndex( pEconItemView, iUserData );
	if ( !pAttrDef )
	{
		out_String = L"unknown";
		return;
	}

	attrib_value_t attrVal;
	Verify( pEconItemView->FindAttribute( pAttrDef, &attrVal ) );
	CEconAttributeDescription attrDesc( GLocalizationProvider(), pAttrDef, attrVal );
	out_String = attrDesc.GetShortDescription();
}

typedef void (* GetCustomDialogLocalizationTokenFunc_t)( const CEconItemView *pEconItemView, int iUserData, CUtlConstWideString& out_String );

struct RefurbishableProperty
{
	HasRefurbishablePropertyFunc_t m_pFunc;
	GetCustomDialogLocalizationTokenFunc_t m_pGetCustomDialogLocalizationTokenFunc;
	const char *m_szArg;
	const char *m_pszSelectionUILocalizationToken;
	const char *m_szDialogTitle;
	const char *m_szDialogDesc;
	EItemCustomizationRemoveType m_eRemovalType;
	int m_iUserData;
};

// TODO: Add Gifted by Tag here
static RefurbishableProperty g_RemoveableAttributes[] =
{
	{ &HasRemovableCustomName,	NULL,								NULL,					"#RefurbishItem_RemoveNameCombo",			"#RefurbishItem_RemoveNameTitle",			"#RefurbishItem_RemoveName",			kCustomizationRemove_Name,				kNoUserData },	// does this item have a custom name?
	{ &HasRemovableCustomDesc,	NULL,								NULL,					"#RefurbishItem_RemoveDescCombo",			"#RefurbishItem_RemoveDescTitle",			"#RefurbishItem_RemoveDesc",			kCustomizationRemove_Desc,				kNoUserData },	// does this item have a custom description?
	{ &HasPaint,				&GetCustomDialogToken_PaintName,	"set item tint rgb",	"#RefurbishItem_RemovePaintCombo",			"#RefurbishItem_RemovePaintTitle",			"#RefurbishItem_RemovePaint",			kCustomizationRemove_Paint,				kNoUserData },	// is this item painted?
	{ &HasCustomAttribute,		NULL,								"custom texture hi",	"#RefurbishItem_RemoveCustomTextureCombo",	"#RefurbishItem_RemoveCustomTextureTitle",	"#RefurbishItem_RemoveCustomTexture",	kCustomizationRemove_CustomTexture,		kNoUserData },	// does this have a custom texture applied?
	{ &HasCustomAttribute,		NULL,								"makers mark id",		"#RefurbishItem_RemoveMakersMarkCombo",		"#RefurbishItem_RemoveMakersMarkTitle",		"#RefurbishItem_RemoveMakersMark",		kCustomizationRemove_MakersMark,		kNoUserData },	// was this item crafted by a specific dude?
	{ &HasCustomAttribute,		NULL,								"killstreak tier",		"#RefurbishItem_RemoveKillStreakCombo",		"#RefurbishItem_RemoveKillStreakTitle",		"#RefurbishItem_RemoveKillStreak",		kCustomizationRemove_KillStreak,		kNoUserData },	// Killstreak Effect
	{ &HasCustomAttribute,		NULL,								"gifter account id",	"#RefurbishItem_RemoveGifterCombo",			"#RefurbishItem_RemoveGifterTitle",			"#RefurbishItem_RemoveGifter",			kCustomizationRemove_GiftedBy,			kNoUserData },	// Gifted by
	{ &HasCustomAttribute,		NULL,								"is_festivized",		"#RefurbishItem_RemoveFestivizerCombo",		"#RefurbishItem_RemoveFestivizerTitle",		"#RefurbishItem_RemoveFestivizer",		kCustomizationRemove_Festivizer,		kNoUserData },	// Festivizer

	//"gifter account id",		// who gifted us this item? (will also remove "event date")
};

//-----------------------------------------------------------------------------
// Purpose: Look over this weapon to see if it has any strange stat counters to reset optionally.
//-----------------------------------------------------------------------------
static bool HasResettableScoreAttributes ( const CEconItemView *pEconItemView, const char *, int )
{
	if ( !pEconItemView )
		return false;

	for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
	{
		uint32 unScore;
		if ( pEconItemView->FindAttribute( GetKillEaterAttr_Score( i ), &unScore ) && unScore > 0 )
			return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int GetRemovableAttributesCount()
{
	return ARRAYSIZE( g_RemoveableAttributes )
		 + GetKillEaterAttrCount()
		 + GetMaxCardUpgradesPerItem()						// remove card upgrades
		 + 1;												// strange quality item score reset
}

RefurbishableProperty RemovableAttributes_GetAttributeDetails( int i )
{
	Assert( i >= 0 );
	Assert( i < GetRemovableAttributesCount() );

	if ( i < ARRAYSIZE( g_RemoveableAttributes ) )
		return g_RemoveableAttributes[i];
	
	// Which attribute in particular are we looking for?
	int iStrangePartIndex = i - ARRAYSIZE( g_RemoveableAttributes );
	if ( iStrangePartIndex < GetKillEaterAttrCount() )
	{
		int iKillEaterAttrIndex = (GetKillEaterAttrCount() - GetKillEaterAttrCount()) + iStrangePartIndex;

		// if we're looking at strange attributes...
		if ( GetKillEaterAttr_IsUserCustomizable( iKillEaterAttrIndex ) )
		{
			// Common properties for all strange part attributes.
			static RefurbishableProperty sStrangePartProperty = { &HasCustomAttribute, &GetCustomDialogToken_StrangePartName, NULL, "#RefurbishItem_RemoveStrangePartCombo", "#RefurbishItem_RemoveStrangePartTitle", "#RefurbishItem_RemoveStrangePart", kCustomizationRemove_StrangePart, kNoUserData };

			RefurbishableProperty partReturnProp = sStrangePartProperty;
			partReturnProp.m_szArg = GetKillEaterAttr_Score( iKillEaterAttrIndex )->GetDefinitionName();				// ...then we check for the presence of a score attribute if this slot is a strange part...
			partReturnProp.m_iUserData = iKillEaterAttrIndex;

			return partReturnProp;
		}
		
		// ...or the presence of a restriction attribute if this slot is a base slot that might have a filter
		static RefurbishableProperty sStrangeFilterProperty = { &HasCustomAttribute, &GetCustomDialogToken_StrangePartName, NULL, "#RefurbishItem_RemoveStrangeFilterCombo", "#RefurbishItem_RemoveStrangeFilterTitle", "#RefurbishItem_RemoveStrangeFilter", kCustomizationRemove_StrangePart, kNoUserData };

		RefurbishableProperty filterReturnProp = sStrangeFilterProperty;
		filterReturnProp.m_szArg = GetKillEaterAttr_Restriction( iKillEaterAttrIndex )->GetDefinitionName();
		filterReturnProp.m_iUserData = iKillEaterAttrIndex;

		return filterReturnProp;
	}

	// Look for any properties that were user-assigned. We allow users to remove them.
	int iCardUpgradeIndex = iStrangePartIndex - GetKillEaterAttrCount();
	if ( iCardUpgradeIndex < GetMaxCardUpgradesPerItem() )
	{
		// Common properties for all card upgrade attributes.
		static RefurbishableProperty sCardUpgradeProperty = { &HasCustomUserAttribute, &GetCustomDialogToken_UserAttributeName, NULL, "#RefurbishItem_RemoveSpellCombo", "#RefurbishItem_RemoveSpellTitle", "#RefurbishItem_RemoveSpellUpgrade", kCustomizationRemove_UpgradeCard, kNoUserData };

		RefurbishableProperty returnProp = sCardUpgradeProperty;
		// FIX THIS FOR CARDS / SPELLS?
		// returnProp.m_szArg = GetCustomDialogToken_UserAttributeName ?
		returnProp.m_iUserData = iCardUpgradeIndex;

		return returnProp;
	}

	// We might also be trying to reset the strange score counters.
	Assert( iStrangePartIndex == GetKillEaterAttrCount() + GetMaxCardUpgradesPerItem() );
	Assert( i == GetRemovableAttributesCount() - 1 );

	static RefurbishableProperty sStrangeScoreReset = { &HasResettableScoreAttributes, NULL, NULL, "#RefurbishItem_RemoveStrangeScoresCombo", "#RefurbishItem_RemoveStrangeScoresTitle", "#RefurbishItem_RemoveStrangeScores", kCustomizationRemove_StrangeScores, kNoUserData };
	return sStrangeScoreReset;
}

bool RemovableAttributes_DoesAttributeApply( int i, const CEconItemView *pEconItemView )
{
	static CSchemaAttributeDefHandle pAttr_CannotRestore( "cannot restore" );
	if ( pEconItemView->FindAttribute( pAttr_CannotRestore ) )
		return false;

	RefurbishableProperty attr = RemovableAttributes_GetAttributeDetails( i );

	return attr.m_pFunc( pEconItemView, attr.m_szArg, attr.m_iUserData );
}

bool RemovableAttributes_DoAnyAttributesApply( const CEconItemView *pEconItemView )
{
	static CSchemaAttributeDefHandle pAttr_CannotRestore( "cannot restore" );
	if ( pEconItemView->FindAttribute( pAttr_CannotRestore ) )
		return false;

	for ( int i = 0; i < GetRemovableAttributesCount(); i++ )
	{
		if ( RemovableAttributes_DoesAttributeApply( i, pEconItemView ) )
			return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
ConVar cl_showbackpackrarities( "cl_showbackpackrarities", "0", FCVAR_ARCHIVE, "0 = Show no backpack icon border colors. 1 = Show item rarities within the backpack. 2 = Show item rarities only for Market-listable items." );
ConVar cl_show_market_data_on_items( "cl_show_market_data_on_items", "1", FCVAR_ARCHIVE, "0 = Never. 1 = Only when showing borders for Market-listable items. 2 = Always." );

ConVar tf_explanations_backpackpanel( "tf_explanations_backpackpanel", "0", FCVAR_ARCHIVE, "Whether the user has seen explanations for this panel." );

ConVar tf_backpack_page_button_delay( "tf_backpack_page_button_delay", "0.5", FCVAR_ARCHIVE, "Amount of time the mouse cursor needs to hover over the page button to select the page." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBackpackPanel::CBackpackPanel( vgui::Panel *parent, const char *panelName ) : CBaseLoadoutPanel( parent, panelName )
{
	m_nQuickOpenTxn = 0;
	m_pContextMenu = NULL;
	m_pPageButtonKVs = NULL;
	m_mapSeenItems.SetLessFunc( DefLessFunc( itemid_t ) );
	m_bInitializedSeenItems = false;
	m_pNameFilterTextEntry = NULL;
	m_flFilterItemTime = 0.f;
	m_mapFilteringItems.SetLessFunc( DefLessFunc(int) );

	m_pNextPageButton = NULL;
	m_pPrevPageButton = NULL;
	m_pShowExplanationsButton = NULL;
	m_pCurPageLabel = NULL;
	m_pSortByComboBox = NULL;
	m_pShowRarityComboBox = NULL;
	m_pShowBaseItemsCheckbox = NULL;
	m_pDragToNextPageButton = NULL;
	m_pDragToPrevPageButton = NULL;
	m_flPreventDragPageSwitchUntil = 0;
	m_flStartExplanationsAt = 0;

	m_flMouseDownTime = 0;
	m_pItemDraggedFromPanel = NULL;
	m_iDraggedFromPage = 0;
	m_bMouseDownOnItemPanel = false;
	m_bDragging = false;
	m_iMouseDownX = m_iMouseDownY = 0;

	m_pMouseDragItemPanel = vgui::SETUP_PANEL( new CItemModelPanel( this, "mousedragitempanel" ) );
	m_pCancelToolButton = NULL;
	m_pCraftButton = NULL;
	m_bShowBaseItems = false;
	m_pConfirmDeleteDialog = NULL;
	m_pToolIcon = NULL;
	m_eSelectionMode = StandardSelection;
	m_nLastToolPage = 0;
	m_pDynamicRecipePanel = NULL;
	m_pItemSlotPanel = NULL;
	m_pStrangeToolPanel = NULL;

	m_nNumActivePages = 0;

	m_pInspectPanel = new CTFItemInspectionPanel( this, "InspectionPanel" );
	m_pInspectCosmeticPanel = new CTFStorePreviewItemPanel2( this, "Resource/UI/econ/InspectionPanel_Cosmetic.res", "storepreviewitem", NULL );
	m_pCollectionCraftPanel = NULL;
	m_pHalloweenOfferingPanel = NULL;
	m_pMannCoTradePanel = NULL;

	CancelToolSelection();

	ListenForGameEvent( "gc_connected" );
}

CBackpackPanel::~CBackpackPanel()
{
	if ( m_pPageButtonKVs )
	{
		m_pPageButtonKVs->deleteThis();
		m_pPageButtonKVs = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	if ( !m_pSortByComboBox && UsesRarityControls() )
	{
		m_pSortByComboBox = new vgui::ComboBox( this, "SortByComboBox", 5, false );
		m_pSortByComboBox->AddActionSignalTarget( this );
	}

	LoadControlSettings( GetResFile() );

	BaseClass::ApplySchemeSettings( pScheme );

	m_pNameFilterTextEntry = FindControl<vgui::TextEntry>( "NameFilterTextEntry" );
	if ( m_pNameFilterTextEntry )
	{
		m_pNameFilterTextEntry->AddActionSignalTarget( this );
	}

	m_pCancelToolButton = dynamic_cast<CExButton*>( FindChildByName("CancelApplyToolButton") );
	m_pCraftButton = dynamic_cast<CExButton*>( FindChildByName("CraftButton") );
	m_pToolIcon = dynamic_cast<vgui::ScalableImagePanel*>( FindChildByName("tool_icon") );

	m_pNextPageButton = dynamic_cast<CExButton*>( FindChildByName("NextPageButton") );
	m_pPrevPageButton = dynamic_cast<CExButton*>( FindChildByName("PrevPageButton") );
	m_pShowExplanationsButton = dynamic_cast<CExButton*>( FindChildByName("ShowExplanationsButton") );
	m_pDragToNextPageButton = dynamic_cast<CExButton*>( FindChildByName("DragToNextPageButton") );
	m_pDragToPrevPageButton = dynamic_cast<CExButton*>( FindChildByName("DragToPrevPageButton") );
	m_pCurPageLabel = dynamic_cast<vgui::Label*>( FindChildByName("CurPageLabel") );
	m_pShowRarityComboBox = dynamic_cast<vgui::ComboBox*>( FindChildByName( "ShowRarityComboBox" ) );
	if ( m_pShowRarityComboBox )
	{
		m_pShowRarityComboBox->AddActionSignalTarget( this );

		m_pShowRarityComboBox->AddItem( "#TF_Backpack_ShowNoBorders", NULL );
		m_pShowRarityComboBox->AddItem( "#TF_Backpack_ShowQualityBorders", NULL );
		m_pShowRarityComboBox->AddItem( "#TF_Backpack_ShowMarketableBorders", NULL );

		m_pShowRarityComboBox->ActivateItemByRow( cl_showbackpackrarities.GetInt() );
	}
	m_pShowBaseItemsCheckbox = dynamic_cast<vgui::CheckButton*>( FindChildByName( "ShowBaseItemsCheckbox" ) );
	if ( m_pShowBaseItemsCheckbox )
	{
		m_pShowBaseItemsCheckbox->AddActionSignalTarget( this );
		m_pShowBaseItemsCheckbox->SetSelected( m_bShowBaseItems );
	}

	m_pMouseDragItemPanel->SetBorder( pScheme->GetBorder("BackpackItemMouseOverBorder") );

	// Setup our combo box
	if ( m_pSortByComboBox )
	{
		m_pSortByComboBox->RemoveAll();
		vgui::HFont hFont = pScheme->GetFont( "HudFontSmallestBold", true );
		m_pSortByComboBox->SetFont( hFont );
		KeyValues *pKeyValues = new KeyValues( "data" );
		for ( int i = 0; i < ARRAYSIZE(g_BackpackSortTypes); i++ )
		{
			pKeyValues->SetInt( "sortby", i );
			m_pSortByComboBox->AddItem( g_BackpackSortTypes[i].szSortDesc, pKeyValues );
		}
		pKeyValues->deleteThis();
		m_pSortByComboBox->ActivateItemByRow( 0 );
		m_pSortByComboBox->GetMenu()->SetNumberOfVisibleItems( ARRAYSIZE(g_BackpackSortTypes) );
	}

	// Create page buttons
	const int nNumMaxPages = GetNumMaxPages();
	for ( int i=m_Pages.Count(); i<nNumMaxPages; ++i )
	{
		EditablePanel *pPage = vgui::SETUP_PANEL( new EditablePanel( this, CFmtStr( "page_%d", i ) ) );
		m_Pages.AddToTail( pPage );
	}

	if ( m_pInspectCosmeticPanel )
	{
		// Force it to load it's scheme now, because it needs to be done before we set it's visibility below
		m_pInspectCosmeticPanel->InvalidateLayout( false, true );
		m_pInspectCosmeticPanel->SetVisible( false );
	}
}

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

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

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::AddNewItemPanel( int iPanelIndex )
{
	BaseClass::AddNewItemPanel( iPanelIndex );

	// Store a position for our new panel
	m_ItemModelPanelPos.AddToTail();
	m_ItemModelPanelPos[iPanelIndex].x = m_ItemModelPanelPos[iPanelIndex].y = 0;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CItemModelPanel *CBackpackPanel::GetItemPanelAtPos( int x, int y )
{
	if ( !m_pItemModelPanels.Count() )
		return NULL;

	int iW = m_pItemModelPanels[0]->GetWide();
	int iH = m_pItemModelPanels[0]->GetTall();
	for ( int i = 0; i < m_ItemModelPanelPos.Count(); i++ )
	{
		if ( (x < m_ItemModelPanelPos[i].x) || (x > (m_ItemModelPanelPos[i].x + iW)) )
			continue;
		if ( (y < m_ItemModelPanelPos[i].y) || (y > (m_ItemModelPanelPos[i].y + iH)) )
			continue;
		return m_pItemModelPanels[i];
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBackpackPanel::GetPageButtonIndexAtPos( int x, int y )
{
	if ( !m_Pages.Count() )
		return -1;

	int iW = m_Pages[0]->GetWide();
	int iH = m_Pages[0]->GetTall();
	for ( int i = 0; i < m_PageButtonPos.Count(); i++ )
	{
		if ( (x < m_PageButtonPos[i].x) || (x > (m_PageButtonPos[i].x + iW)) )
			continue;
		if ( (y < m_PageButtonPos[i].y) || (y > (m_PageButtonPos[i].y + iH)) )
			continue;
		return m_Pages[i]->IsVisible() ? i : -1;
	}

	return -1;
}

//-----------------------------------------------------------------------------
// Purpose: Change the text color on the page buttons based on the context of the
//			page they represent.
//-----------------------------------------------------------------------------
void CBackpackPanel::SetPageButtonTextColorBasedOnContents()
{
	vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );

	if ( m_Pages.Count() == 0 )
		return;

	if ( !pScheme )
		return;

	const Color& colorEmpty =  pScheme->GetColor( "TanDarker", Color( 235, 226, 202, 255 ) );
	const Color& colorPartial = Color( 170, 161, 137, 255 );
	const Color& colorFull = pScheme->GetColor( "TanLight", Color( 235, 226, 202, 255 ) );
	const Color& colorSelected = pScheme->GetColor( "TFOrange", Color( 145, 73, 59, 255 ) );

	CUtlVector<int> vecPageCount;
	CUtlVector<int> vecNewPageCount;
	vecPageCount.EnsureCount( m_Pages.Count() );
	vecNewPageCount.EnsureCount( m_Pages.Count() );
	// Initialize to 0
	FOR_EACH_VEC( vecPageCount, i )
	{
		vecPageCount[i] = 0;
		vecNewPageCount[i] = 0;
	}

	CPlayerInventory *pInv = InventoryManager()->GetLocalInventory();
	Assert( pInv );
	// Tally up how many items are on each page
	if ( pInv )
	{
		for ( int i = 0 ; i < pInv->GetItemCount() ; ++i )
		{
			CEconItemView *pItem = pInv->GetItem( i );
			const int nSlot = InventoryManager()->GetBackpackPositionFromBackend( pItem->GetInventoryPosition() ) - 1;
			const int nPage = nSlot / GetNumSlotsPerPage();	 
			if ( nPage >= 0 && nPage < m_Pages.Count() )
			{
				vecPageCount[ nPage ] = vecPageCount[ nPage ] + 1;

				// Unackknowledged items technically are on the 1st page, so dont count them
				if ( m_mapSeenItems.Find( pItem->GetItemID() ) == m_mapSeenItems.InvalidIndex()
					&& IsUnacknowledged( pItem->GetInventoryPosition() ) == false && !m_bShowBaseItems && !HasNameFilter() )
				{
					vecNewPageCount[ nPage ] = vecNewPageCount[ nPage ] + 1;
				}
			}
		}
	}

	// Set the color for each page button
	FOR_EACH_VEC( m_Pages, i )
	{
		const int nNewCount = vecNewPageCount[i];
		const int nCount = vecPageCount[i];
		CExButton* pButton = dynamic_cast<CExButton*>( m_Pages[i]->FindChildByName( "Button" ) );
		if ( pButton )
		{
			Color setColor = colorEmpty;
			const Color& bgColor = GetCurrentPage() == i ? colorSelected : pButton->GetButtonDefaultBgColor();

			if ( nCount == GetNumSlotsPerPage() )
				setColor = colorFull;
			else if ( nCount > 0 )
				setColor = colorPartial;

			pButton->SetSelectedColor( setColor, pButton->GetButtonSelectedBgColor() );
			pButton->SetDefaultColor( setColor, bgColor );
			pButton->SetArmedColor( setColor, pButton->GetButtonArmedBgColor() );
			pButton->SetDepressedColor( setColor, pButton->GetButtonDepressedBgColor() );
		}

		// Show our "NEW!" label if there's any unseen items on that page
		CExLabel* pNew = dynamic_cast<CExLabel*>( m_Pages[i]->FindChildByName( "New" ) );
		if ( pNew )
		{
			pNew->SetVisible( nNewCount > 0 );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::MarkItemIDDirty( itemid_t itemID )
{
	if ( m_vecDirtyItems.Find( itemID ) == m_vecDirtyItems.InvalidIndex() )
	{
		m_vecDirtyItems.AddToTail( itemID );
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::PositionItemPanel( CItemModelPanel *pPanel, int iIndex )
{
	int iCenter = GetWide() * 0.5;
	int iButtonX = (iIndex % GetNumColumns());
	int iButtonY = (iIndex / GetNumColumns());
	int iXPos = (iCenter + m_iItemBackpackOffcenterX) + (iButtonX * m_pItemModelPanels[iIndex]->GetWide()) + (m_iItemBackpackXDelta * iButtonX);
	int iYPos = m_iItemYPos + (iButtonY * m_pItemModelPanels[iIndex]->GetTall() ) + (m_iItemBackpackYDelta * iButtonY);

	m_pItemModelPanels[iIndex]->SetPos( iXPos, iYPos );
}

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

	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		// Viewing the backpack. Layout all the buttons and hide the class image.
		m_pItemModelPanels[i]->SetVisible( true );
		m_pItemModelPanels[i]->SetNoItemText( "#SelectNoItemSlot" );

		PositionItemPanel( m_pItemModelPanels[i], i );

		// Cache off where we put the panel
		m_pItemModelPanels[i]->GetPos( m_ItemModelPanelPos[i].x, m_ItemModelPanelPos[i].y );

		// Take into account parent's position
		Panel* pParent = m_pItemModelPanels[i]->GetParent();
		if( pParent )
		{
			int x = 0,y = 0;
			pParent->GetPos( x, y );
			m_ItemModelPanelPos[i].x += x;
			m_ItemModelPanelPos[i].y += y;
		}
	}

	// adjust page buttons
	{
		m_nNumActivePages = GetNumPages();

		int iCenter = GetWide() * 0.5;

		int iPageBarWidth = 2 * abs( m_iItemBackpackOffcenterX );
		int iPageButtonWidth = ( iPageBarWidth - ( m_iPageButtonPerRow - 1 ) * m_iPageButtonXDelta ) / m_iPageButtonPerRow;
		int iPageButtonWidthPlusDelta = iPageButtonWidth + m_iPageButtonXDelta;
		int iPageButtonHeightPlusDelta = m_iPageButtonHeight + m_iPageButtonYDelta;
		int iStart = iCenter + m_iItemBackpackOffcenterX;

		m_PageButtonPos.EnsureCount( m_Pages.Count() );
		for ( int i=0; i<m_Pages.Count(); ++i )
		{
			EditablePanel *pPage = m_Pages[i];
			if ( pPage )
			{
				// Apply control settings here
				if ( m_pPageButtonKVs )
					pPage->ApplySettings( m_pPageButtonKVs );
				CExButton* pButton = dynamic_cast<CExButton*>( pPage->FindChildByName( "Button" ) );
				pPage->InvalidateLayout( true, true );
				// Make the button have the right command and send it's signals to us
				if ( pButton )
				{
					pButton->SetSelected( false );
					pButton->SetCommand( CFmtStr( "goto_page_%d", i ) );
					pButton->AddActionSignalTarget( this );
				}
				pPage->SetDialogVariable( "page", i+1 );
				
				bool bVisible = i < m_nNumActivePages;
				if ( bVisible )
				{
					int iRow = i /m_iPageButtonPerRow;
					int iColumn = i % m_iPageButtonPerRow;
					pPage->SetBounds( iStart + iColumn * iPageButtonWidthPlusDelta, m_iPageButtonYPos + iRow * iPageButtonHeightPlusDelta, iPageButtonWidth, m_iPageButtonHeight );
					pPage->GetPos( m_PageButtonPos[i].x , m_PageButtonPos[i].y );
				}
				pPage->SetVisible( bVisible );
			}
		}

		// Update colors and the "NEW!" labels
		SetPageButtonTextColorBasedOnContents();
	}

	if ( m_pNextPageButton )
	{
		m_pNextPageButton->SetVisible( true );
	}
	if ( m_pPrevPageButton )
	{
		m_pPrevPageButton->SetVisible( true );
	}
	if ( m_pCurPageLabel )
	{
		m_pCurPageLabel->SetVisible( true );
	}

	if ( m_pSortByComboBox )
	{
		m_pSortByComboBox->SetVisible( !InToolSelectionMode() );
	}
	if ( m_pShowRarityComboBox )
	{
		m_pShowRarityComboBox->SetVisible( true );
	}

	if ( m_pNextPageButton )
	{
		m_pNextPageButton->SetEnabled( GetNumPages() > 1 );
	}
	if ( m_pPrevPageButton )
	{
		m_pPrevPageButton->SetEnabled( GetNumPages() > 1 );
	}

	if ( !m_bDragging )
	{	
		if ( m_pDragToNextPageButton && m_pDragToPrevPageButton )
		{
			m_pDragToNextPageButton->SetVisible( false );
			m_pDragToPrevPageButton->SetVisible( false );
		}
	}

	bool bShowActions = (!m_bItemsOnly && !InToolSelectionMode());
	if ( m_pCraftButton )
	{
		m_pCraftButton->SetVisible( bShowActions );
	}
	if ( m_pCancelToolButton )
	{
		m_pCancelToolButton->SetVisible( InToolSelectionMode() );
	}

	if ( m_pShowExplanationsButton )
	{
		m_pShowExplanationsButton->SetVisible( !m_bItemsOnly );
	}
	if ( m_pShowBaseItemsCheckbox )
	{
		m_pShowBaseItemsCheckbox->SetVisible( !m_bItemsOnly );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::FireGameEvent( IGameEvent *event )
{
	static CSchemaItemDefHandle pItemDef_BasePaintCan( "Paint Can" );
	const char *type = event->GetName();
	if ( Q_strcmp( "gc_connected", type ) == 0 )
	{
		if ( !m_bInitializedSeenItems )
		{
			CPlayerInventory *pInventory = InventoryManager()->GetLocalInventory();
			if ( pInventory )
			{
				for ( int i = 0; i < pInventory->GetItemCount(); i++ )
				{
					CEconItemView *pItem = pInventory->GetItem(i);
					m_mapSeenItems.Insert( pItem->GetItemID() );
				}
			}

			m_bInitializedSeenItems = true;
		}

		m_vecPaintCans.Purge();
		m_vecStrangeParts.Purge();
		const CEconItemSchema::ToolsItemDefinitionMap_t &toolDefs = GetItemSchema()->GetToolsItemDefinitionMap();

		// Store all of the active paint can item defs
		FOR_EACH_MAP_FAST( toolDefs, i )
		{
			const CEconItemDefinition *pItemDef = toolDefs[i];
			const IEconTool *pEconTool = pItemDef->GetEconTool();
			if ( !pEconTool )
				continue;

			// Paint can list
			// Ignore the stock paintcan thats only for armory purposes
			if ( !V_strcmp( pEconTool->GetTypeName(), "paint_can" ) && pItemDef_BasePaintCan != pItemDef ) 
			{
				// Paint Can
				m_vecPaintCans.AddToTail( pItemDef->GetDefinitionIndex() );
			}
			// Strange Parts List
			else if ( !V_strcmp( pEconTool->GetTypeName(), "strange_part" ) )
			{
				m_vecStrangeParts.AddToTail( pItemDef->GetDefinitionIndex() );
			}
		}
	}

	BaseClass::FireGameEvent( event );
}

void CBackpackPanel::CheckForQuickOpenKey()
{
	if ( !m_hQuickOpenCrate )
		return;

	// We only want to continue if it's the transaction we're listening for
	if ( EconUI()->GetStorePanel()->GetMostRecentSuccessfulTransactionID() != m_nQuickOpenTxn )
	{
		return;
	}

	CPlayerInventory *pInventory = InventoryManager()->GetLocalInventory();
	if ( pInventory )
	{
		for ( int i = 0; i < pInventory->GetItemCount(); i++ )
		{
			CEconItemView *pInvItem = pInventory->GetItem( i );

			uint32 iPosition = pInvItem->GetInventoryPosition();
			if ( IsUnacknowledged( iPosition ) == false )
				continue;

			if ( InventoryManager()->GetBackpackPositionFromBackend( iPosition ) != 0 )
				continue;

			// Now make sure we haven't got a clientside saved ack for this item.
			if ( InventoryManager()->HasBeenAckedByClient( pInvItem ) )
				continue;

			// If item is not a drop we want to show the notification otherwise they'll get the notification on death
			int iFoundMethod = GetUnacknowledgedReason( iPosition );
			if ( iFoundMethod != UNACK_ITEM_PURCHASED )
				continue;

			if ( !pInvItem->GetStaticData()->IsTool() )
				continue;

			if( !CEconSharedToolSupport::ToolCanApplyTo( pInvItem, m_hQuickOpenCrate ) )
				continue;

			if ( !pInvItem->GetStaticData()->GetEconTool() )
				continue;

			if ( !Q_strcmp( pInvItem->GetStaticData()->GetEconTool()->GetTypeName(), "decoder_ring" ) == 0 )
				continue;

			ApplyTool( this, pInvItem, m_hQuickOpenCrate );
			CloseStoreStatusDialog();

			m_hQuickOpenCrate = NULL;
			m_nQuickOpenTxn = 0;
			return;
		}
	}

	m_hQuickOpenCrate = NULL;
	m_nQuickOpenTxn = 0;
}

//-----------------------------------------------------------------------------
// Purpose: When the store get's a new transaction ID, it comes here as well
//-----------------------------------------------------------------------------
void CBackpackPanel::SetCurrentTransactionID( uint64 nTxnID )
{
	// If we've got a quick open crate st, and no quick open transaction ID,
	// then we want to capture the incoming transaction ID so that we can
	// compare future incoming successful transactions to see if they have
	// the key we're expecting
	if ( m_hQuickOpenCrate && m_nQuickOpenTxn == 0 )
	{
		m_nQuickOpenTxn = nTxnID;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OnShowPanel( bool bVisible, bool bReturningFromArmory )
{
	if ( bVisible )
	{
		m_pMouseDragItemPanel->SetVisible( false );

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

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

		m_bShowBaseItems = false;
		if ( m_pShowBaseItemsCheckbox )
		{
			m_pShowBaseItemsCheckbox->SetSelected( m_bShowBaseItems );
		}

		if ( !bReturningFromArmory )
		{
			SetCurrentPage( 0 );
			CancelToolSelection();
		}

		m_nNumActivePages = 0;

#ifdef STAGING_ONLY
		// Reset pinned-state of the card
		m_pMouseOverCardPanel->PinCard( false );
#endif
	}
	else
	{
		if ( m_bDragging )
		{
			StopDrag( false );
		}
	}

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

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

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

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

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

	if ( m_pStrangeToolPanel )
	{
		m_pStrangeToolPanel->MarkForDeletion();
		m_pStrangeToolPanel = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::PostShowPanel( bool bVisible )
{
	if ( bVisible )
	{
		DeSelectAllBackpackItemPanels();

		RequestFocus();

		// Clear out text field
		ClearNameFilter( true );
	}

	// If this is the first time we've opened the loadout, start the loadout explanations
	ConVar *pConVar = GetExplanationConVar();
	if ( bVisible && pConVar && !pConVar->GetBool() && ShouldShowExplanations() )
	{
		m_flStartExplanationsAt = Plat_FloatTime() + 0.5;
		vgui::ivgui()->AddTickSignal( GetVPanel() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CBackpackPanel::GetNumPages( void )
{
	int iMaxItems = InventoryManager()->GetLocalInventory()->GetMaxItemCount();
	return (int)(ceil((float)iMaxItems / (float)BACKPACK_SLOTS_PER_PAGE));
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::AssignItemToPanel( CItemModelPanel *pPanel, int iIndex )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );

	static int iItemBackpackPos = 0;
	if ( iIndex == 0 )
	{
		iItemBackpackPos = 0;
	}
	int iPanelBackpackPos = GetBackpackPosForPanelIndex(iIndex);

	static int iLastMapItem = -1;

	pPanel->SetShowQuantity( true );

	const wchar_t* wszFilter = GetNameFilter();
	bool bInToolSelection = InToolSelectionMode() && m_ToolSelectionItem.IsValid();

	CEconItemView *pItemData = NULL;
	CEconItemView tempItem;
	if ( m_bShowBaseItems )
	{
		const CEconItemDefinition* pItemDef = NULL;

		const CEconItemSchema::BaseItemDefinitionMap_t& mapItems = GetItemSchema()->GetBaseItemDefinitionMap();
		int iStart = iIndex == 0 ? mapItems.FirstInorder() : mapItems.NextInorder( iLastMapItem );
		for ( int it = iStart; it != mapItems.InvalidIndex(); it = mapItems.NextInorder( it ) )
		{
			iLastMapItem = it;

			if ( mapItems[it]->IsBaseItem() && !mapItems[it]->IsHidden() )
			{
				// Instead of linking to this base item definition, link to the definition of what it will become
				// when we customize it.
				CFmtStr fmtStrCustomizedDefName( "Upgradeable %s", mapItems[it]->GetDefinitionName() );
				pItemDef = GetItemSchema()->GetItemDefinitionByName( fmtStrCustomizedDefName.Access() );
				
				// If we don't have an upgradeable version, we assume that we can't upgrade it and link to the base
				// definition instead. We expect this to only happen if the item won't actually be useable for whatever
				// purpose (name tags, etc.). We sanity-check this on the GC.
				if ( !pItemDef )
				{
					pItemDef = mapItems[it];
				}

				tempItem.Init( pItemDef->GetDefinitionIndex(), AE_UNIQUE, AE_USE_SCRIPT_VALUE, true );

				// skip this item if the tool cannot be applied to it
				if ( bInToolSelection && !CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, &tempItem ) )
				{
					pItemDef = NULL;
					continue;
				}

				if ( DoesItemPassSearchFilter( tempItem.GetDescription(), wszFilter ) )
				{
					break;
				}
			}

			pItemDef = NULL;
		}

		if ( pItemDef )
		{
			pItemData = &tempItem;

			++iItemBackpackPos;
		}
	}
	else if ( HasNameFilter() )
	{
		int iStart = iIndex == 0 ? m_mapFilteringItems.FirstInorder() : m_mapFilteringItems.NextInorder( iLastMapItem );
		for ( int it = iStart; it != m_mapFilteringItems.InvalidIndex(); it = m_mapFilteringItems.NextInorder( it ) )
		{
			iLastMapItem = it;

			CEconItemView *pItem = m_mapFilteringItems[it];

			// skip this item if the tool cannot be applied to it
			if ( bInToolSelection && !CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, pItem ) )
			{
				continue;
			}

			if ( !DoesItemPassSearchFilter( pItem->GetDescription(), wszFilter ) )
			{
				continue;
			}

			if ( ++iItemBackpackPos != iPanelBackpackPos )
			{
				continue;
			}

			pItemData = pItem;
			break;
		}
	}
	else if ( bInToolSelection )
	{
		CPlayerInventory *pInventory = InventoryManager()->GetLocalInventory();
		if ( pInventory )
		{
			// Backpack positions start from 1
			Assert( iPanelBackpackPos > 0 && iPanelBackpackPos <= pInventory->GetMaxItemCount() );
			int iStart = iIndex == 0 ? 0 : iLastMapItem + 1;
			for ( int i = iStart; i < pInventory->GetItemCount(); i++ )
			{
				iLastMapItem = i;

				CEconItemView *pItem = pInventory->GetItem(i);

				if ( m_ToolSelectionItem.GetStaticData()->IsTool() )
				{
					if ( !CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, pItem ) )
					{
						continue;
					}
				}
				else
				{
					if ( !pItem->GetStaticData()->IsTool() )
					{
						continue;
					}

					if ( !CEconSharedToolSupport::ToolCanApplyTo( pItem, &m_ToolSelectionItem ) )
					{
						continue;
					}

					if ( ( m_ToolSelectionItem.GetStaticData()->GetCapabilities() & ITEM_CAP_DECODABLE ) && pItem->GetStaticData()->GetEconTool() && ( Q_strcmp( pItem->GetStaticData()->GetEconTool()->GetTypeName(), "decoder_ring" ) != 0 ) )
					{
						continue;
					}
				}

				if ( ++iItemBackpackPos != iPanelBackpackPos )
				{
					continue;
				}

				pItemData = pItem;
				break;
			}
		}
	}
	else
	{
		pItemData = InventoryManager()->GetItemByBackpackPosition( iPanelBackpackPos );
		iItemBackpackPos = iPanelBackpackPos;

		if ( pItemData == NULL && pPanel->GetItem() == NULL )
		{
			return;
		}

		int nDirtyIndex = pItemData ? m_vecDirtyItems.Find( pItemData->GetItemID() ) : m_vecDirtyItems.InvalidIndex();

		if ( pItemData	// Want to put in an item
		  && pPanel->GetItem()	// Panel has an item
		  && pItemData->GetItemID() == pPanel->GetItem()->GetItemID() // That panel has the same item that we want to put in
		  && nDirtyIndex == m_vecDirtyItems.InvalidIndex() ) // And that item is not dirtied.  
		{
			// We dont do anything
			return;
		}

		if ( nDirtyIndex != m_vecDirtyItems.InvalidIndex() )
		{
			m_vecDirtyItems.Remove( nDirtyIndex );
		}
	}

	if ( iItemBackpackPos != iPanelBackpackPos )
	{
		pItemData = NULL;
	}

	pPanel->SetItem( pItemData );

	bool bSeen = true;
	// Have we not seen this item before?
	if ( !m_bShowBaseItems && pItemData && m_mapSeenItems.Find( pItemData->GetItemID() ) == m_mapSeenItems.InvalidIndex() )
	{
		bSeen = false;
	}

	// Show our "NEW!" label if this item hasnt been seen
	CExLabel *pNewPanel = dynamic_cast< CExLabel* >( pPanel->FindChildByName( "New" ) );
	if ( pNewPanel )
	{
		pNewPanel->SetVisible( !bSeen );
	}

	pPanel->DirtyDescription();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::ClearNameFilter( bool bUpdateModelPanels )
{
	if ( m_wNameFilter.Count() == 0 )
		return;

	m_wNameFilter.RemoveAll();
	if( m_pNameFilterTextEntry )
	{
		m_pNameFilterTextEntry->SetText( "" );
	}

	if ( bUpdateModelPanels )
	{
		m_flFilterItemTime = gpGlobals->curtime + 0.1f;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::UpdateFilteringItems()
{
	m_mapFilteringItems.RemoveAll();

	if ( !HasNameFilter() )
		return;

	CPlayerInventory *pInventory = InventoryManager()->GetLocalInventory();
	if ( !pInventory )
		return;

	for ( int i = 0; i < pInventory->GetItemCount(); i++ )
	{
		CEconItemView *pItem = pInventory->GetItem(i);

		if ( pItem->GetItemDefinition()->IsHidden() )
			continue;

		int iBackpackPosition = InventoryManager()->GetBackpackPositionFromBackend( pItem->GetInventoryPosition() );
		m_mapFilteringItems.Insert( iBackpackPosition, pItem );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::UpdateModelPanels( void )
{
	tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ );

	UpdateFilteringItems();
	
	// We're showing the backpack. Show all the items in our inventory
	FOR_EACH_VEC( m_pItemModelPanels, i )
	{
		m_pItemModelPanels[i]->SetShowEquipped( true );
		m_pItemModelPanels[i]->SetShowGreyedOutTooltip( true );
		AssignItemToPanel( m_pItemModelPanels[i], i );

		if ( !m_pItemModelPanels[i]->HasItem() && m_pItemModelPanels[i]->IsSelected() )
		{
			m_pItemModelPanels[i]->SetSelected( false );
		}

		SetBorderForItem( m_pItemModelPanels[i], false );
	}

	// Clean out.  We just did all the heavy lifting.
	m_vecDirtyItems.Purge();

	if ( InToolSelectionMode() && m_ToolSelectionItem.IsValid() )
	{
		wchar_t	wTemp[256];
		g_pVGuiLocalize->ConstructString_safe( wTemp, g_pVGuiLocalize->Find( "BackpackApplyTool" ), 1, m_ToolSelectionItem.GetItemName() );
		SetDialogVariable( "loadoutclass", wTemp );
	}
	else
	{
		SetDialogVariable( "loadoutclass", g_pVGuiLocalize->Find( "BackpackTitle" ) );
	}

	char szTmp[16];
	V_sprintf_safe( szTmp, "%d/%d", GetCurrentPage()+1, GetNumPages() );
	SetDialogVariable( "backpackpage", szTmp );

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

//-----------------------------------------------------------------------------
// Purpose: Mark visited item model panels as seen
//-----------------------------------------------------------------------------
void CBackpackPanel::OnItemPanelEntered( vgui::Panel *panel )
{
	if ( m_pContextMenu && m_pContextMenu->IsVisible() )
		return;

	CItemModelPanel *pItemPanel = dynamic_cast < CItemModelPanel * > ( panel );
	if ( pItemPanel )
	{
		// Hide the "NEW!" label
		CExLabel *pNewPanel = dynamic_cast< CExLabel* >( pItemPanel->FindChildByName( "New" ) );
		if ( pNewPanel )
		{
			pNewPanel->SetVisible( false );
		}

		// Mark this item as "seen"
		CEconItemView *pItem = pItemPanel->GetItem();
		if ( pItem )
		{
			if ( m_mapSeenItems.Find( pItem->GetItemID() ) == m_mapSeenItems.InvalidIndex() )
			{
				m_mapSeenItems.Insert( pItem->GetItemID() );
				SetPageButtonTextColorBasedOnContents();
			}
		}
	}

	BaseClass::OnItemPanelEntered( panel );
}

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

	if ( pItemPanel && IsVisible() && pItemPanel->IsGreyedOut() == false && AllowDragging( pItemPanel ) )
	{
		m_flMouseDownTime = gpGlobals->curtime;
		m_iMouseDownX = m_iMouseDownY = 0;
		m_pItemDraggedFromPanel = pItemPanel;
		m_iDraggedFromPage = GetCurrentPage();
		m_bDragging = false;
		m_bMouseDownOnItemPanel = true;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Handle the escape key since it doesn't show up in OnKeyCodePressed
//-----------------------------------------------------------------------------
void CBackpackPanel::OnKeyCodeTyped(vgui::KeyCode code)
{
	if ( code == KEY_ESCAPE && InToolSelectionMode() )
	{
		CancelToolSelection();
	}
	else if ( code == KEY_ENTER )
	{
		// Do nothing.  This gets hit frequently when people type in the filter
		// text entry and then hit 'Enter', expecting it to execute the filter.
		// We automatically apply it, so let's just eat 'Enter', which was causing
		// us to activate some button on the main menu.
	}
	else
	{
		BaseClass::OnKeyCodeTyped( code );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Handles key press events in the backpack
//-----------------------------------------------------------------------------
void CBackpackPanel::OnKeyCodePressed( vgui::KeyCode code )
{
	// Ignore key events while the confirm delete dialog is up
	if( m_pConfirmDeleteDialog )
		return;

	// let our parent class handle all the arrow key/dpad stuff
	if( HandleItemSelectionKeyPressed( code ) )
	{
		return;
	}

	// Handle close here, CBasePanel parent doesn't support "DialogClosing" command
	ButtonCode_t nButtonCode = GetBaseButtonCode( code );

	if ( (nButtonCode == KEY_XBUTTON_B || nButtonCode == STEAMCONTROLLER_B) && InToolSelectionMode() )
	{
		CancelToolSelection();
	}
	else if( code == KEY_PAGEDOWN )
	{
		OnCommand( "nextpage" );
	}
	else if( code == KEY_PAGEUP )
	{
		OnCommand( "prevpage" );
	}
	else if ( ( nButtonCode == KEY_XBUTTON_A || code == KEY_ENTER || nButtonCode == STEAMCONTROLLER_A ) )
	{
		if( InToolSelectionMode() )
		{
			HandleToolItemSelection( GetFirstSelectedItem() );
		}
		else
		{
			OpenContextMenu();
		}
	}
	else if ( nButtonCode == KEY_XBUTTON_X || nButtonCode == STEAMCONTROLLER_X )
	{
		if( !InToolSelectionMode() )
		{
			OnCommand( "deleteitem" );
		}
	}
	else
	{
		BaseClass::OnKeyCodePressed( code );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Handles key press events in the backpack
//-----------------------------------------------------------------------------
void CBackpackPanel::OnKeyCodeReleased( vgui::KeyCode code )
{
	if( ! HandleItemSelectionKeyReleased( code ) )
		BaseClass::OnKeyCodeReleased( code );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OnMouseCaptureLost( void )
{
	if ( m_bDragging )
	{
		StopDrag( false );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OnMouseReleased(vgui::MouseCode code)
{
	if ( code == MOUSE_LEFT )
	{
		if ( m_bDragging )
		{
			// When we're dragging, we have mouse capture, so the item panels aren't getting mouse input.
			// We need to find out what item panel we're over, and let it know.
			if ( m_pPrevDragOverItemPanel )
			{
				OnItemPanelMouseReleased( m_pPrevDragOverItemPanel );
			}
			else
			{
				StopDrag( false );
			}
		}
	}

	BaseClass::OnMouseReleased( code );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OnConfirmDelete( KeyValues *data )
{
	// Delete all the selected item
	if ( data )
	{
		int iConfirmed = data->GetInt( "confirmed", 0 );
		if ( iConfirmed )
		{
			for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
			{
				if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
				{
					EconUI()->Gamestats_ItemTransaction( IE_ITEM_DELETED, m_pItemModelPanels[i]->GetItem() );
					InventoryManager()->DropItem( m_pItemModelPanels[i]->GetItem()->GetItemID() );
				}
			}
			DeSelectAllBackpackItemPanels();
		}
	}

	m_pConfirmDeleteDialog = NULL;

	// If we're embedded in the discard item panel, it needs to know we made room. Send a message to our parent that it can catch.
	PostMessage( GetParent(), new KeyValues("ConfirmDlgResult", "confirmed", 2 ) );
}

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

	if ( pItemPanel && IsVisible() )
	{
		if ( InToolSelectionMode() )
		{
			// They're selecting the item they'd like to apply a tool to
			HandleToolItemSelection( pItemPanel->GetItem() );
		}
		else if ( !m_bDragging )
		{
			// If they're not holding down ctrl, deselect all existing selections
			if ( !vgui::input()->IsKeyDown(KEY_LCONTROL) && !vgui::input()->IsKeyDown(KEY_RCONTROL) )
			{
				DeSelectAllBackpackItemPanels();
			}

			// Quick clicks just select the item
			ToggleSelectBackpackItemPanel( pItemPanel );

			if ( pItemPanel->IsSelected() )
			{
				OpenContextMenu();
			}
		}
		else
		{
			int iPanelIndex = GetBackpackPositionForPanel( pItemPanel );
			if ( !CanDragTo(pItemPanel, iPanelIndex) )
			{
				StopDrag(false);
			}
			else
			{
				StopDrag( true );
				if ( (pItemPanel != m_pItemDraggedFromPanel || m_iDraggedFromPage != GetCurrentPage() ) && m_pMouseDragItemPanel->HasItem() )
				{
					HandleDragTo( pItemPanel, iPanelIndex );
				}
				else if ( m_iDraggedFromPage == GetCurrentPage() )
				{
					m_pItemDraggedFromPanel->SetItem( m_pMouseDragItemPanel->GetItem() );
				}
			}
		}

		m_pItemDraggedFromPanel = NULL;
	}
}


bool GetDecodedByItemDefIndex( const CEconItemView *pItem, uint32 *pDecodedBy = NULL )
{
	static CSchemaAttributeDefHandle pAttrDef_DecodedBy( "decoded by itemdefindex" );

	if ( pDecodedBy )
	{
		return pItem->FindAttribute( pAttrDef_DecodedBy, pDecodedBy );
	}
	else
	{
		return pItem->FindAttribute( pAttrDef_DecodedBy );
	}
}

CEconItemView* GetFirstCompatibleKeyForCrate( const CEconItemView *pItem )
{
	// Check if we have any decoder rings that can be applied onto this
	CPlayerInventory *pInv = InventoryManager()->GetLocalInventory();
	Assert( pInv );
	if ( pInv )
	{
		for ( int i = 0; i < pInv->GetItemCount(); ++i )
		{
			CEconItemView *pInvItem = pInv->GetItem( i );

			if ( pInvItem->GetQuality() == AE_SELFMADE )
				continue;

			if ( pInvItem->GetStaticData()->IsTool() && CEconSharedToolSupport::ToolCanApplyTo( pInvItem, pItem ) && pInvItem->GetStaticData()->GetEconTool() && ( Q_strcmp( pInvItem->GetStaticData()->GetEconTool()->GetTypeName(), "decoder_ring" ) == 0 ) )
			{
				return pInvItem;
			}
		}
	}

	return NULL;
}

bool CanInventoryItemsApplyTo( const CEconItemView *pItem )
{
	// Check if we have any tools that can be applied onto this
	CPlayerInventory *pInv = InventoryManager()->GetLocalInventory();
	Assert( pInv );
	if ( pInv )
	{
		for ( int i = 0 ; i < pInv->GetItemCount() ; ++i )
		{
			CEconItemView *pInvItem = pInv->GetItem( i );
			if ( pInvItem->GetStaticData()->IsTool() && CEconSharedToolSupport::ToolCanApplyTo( pInvItem, pItem ) )
			{
				return true;
			}
		}
	}

	return false;
}
//-----------------------------------------------------------------------------
bool CreateMarketPriceString( item_definition_index_t iDefIndex, wchar_t *pszString, int iBufferSize )
{
	// Get Market Price
	steam_market_gc_identifier_t ident;
	ident.m_unDefIndex = iDefIndex;
	ident.m_unQuality = AE_UNIQUE;			// Get this from default item def?

	const client_market_data_t *pClientMarketData = GetClientMarketData( ident );
	if ( !pClientMarketData )
		return false;

	const ECurrency eCurrency = EconUI()->GetStorePanel()->GetCurrency();

	// Set that price into the button
	wchar_t pszCurrencyString[kLocalizedPriceSizeInChararacters];
	MakeMoneyString( pszCurrencyString, ARRAYSIZE( pszCurrencyString ), pClientMarketData->m_unLowestPrice, eCurrency );

	wchar_t pszConstructed[kLocalizedPriceSizeInChararacters];
	g_pVGuiLocalize->ConstructString_safe( pszConstructed, g_pVGuiLocalize->Find( "#TF_MarketPrice" ), 1, pszCurrencyString );

	// copy result;
	V_wcsncpy( pszString, pszConstructed, iBufferSize );
	return true;
}
//-----------------------------------------------------------------------------
bool CreateStorePriceString( item_definition_index_t iDefIndex, wchar_t *pszString, int iBufferSize )
{
	// Get Market Price
	steam_market_gc_identifier_t ident;
	ident.m_unDefIndex = iDefIndex;
	ident.m_unQuality = AE_UNIQUE;			// Get this from default item def?

	// Get the price of the item
	const econ_store_entry_t *pEntry = EconUI()->GetStorePanel()->GetPriceSheet()->GetEntry( iDefIndex );
	if ( !pEntry )
		return false;

	const ECurrency eCurrency = EconUI()->GetStorePanel()->GetCurrency();

	// Set that price into the button
	wchar_t pszCurrencyString[kLocalizedPriceSizeInChararacters];
	MakeMoneyString( pszCurrencyString, ARRAYSIZE( pszCurrencyString ), pEntry->GetCurrentPrice( eCurrency ), eCurrency );

	wchar_t pszConstructed[kLocalizedPriceSizeInChararacters];
	g_pVGuiLocalize->ConstructString_safe( pszConstructed, g_pVGuiLocalize->Find( "#TF_StorePrice" ), 1, pszCurrencyString );

	// copy result;
	V_wcsncpy( pszString, pszConstructed, iBufferSize );
	return true;
}
//-----------------------------------------------------------------------------
void CBackpackPanel::AddCommerceSubmenus( Menu *pSubMenu, item_definition_index_t iItemDef, const char* pszActionFmt )
{
	wchar_t wPriceListing[256];
	// Store
	if ( CreateStorePriceString( iItemDef, wPriceListing, sizeof( wPriceListing ) ) )
	{
		int nIndex = pSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "%s%s%d", "store_", pszActionFmt, iItemDef ) ), this );
		vgui::MenuItem *pMenuItem = pSubMenu->GetMenuItem( nIndex );
		pMenuItem->SetText( wPriceListing );
		pMenuItem->InvalidateLayout( true, false );
	}
	
	// Market
	if ( CreateMarketPriceString( iItemDef, wPriceListing, sizeof( wPriceListing ) ) )
	{
		int nIndex = pSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "%s%s%d", "market_", pszActionFmt, iItemDef ) ), this );
		vgui::MenuItem *pMenuItem = pSubMenu->GetMenuItem( nIndex );
		pMenuItem->SetText( wPriceListing );
		pMenuItem->InvalidateLayout( true, false );
	}
	else
	{
		int nIndex = pSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "%s%s%d", "market_", pszActionFmt, iItemDef ) ), this );
		vgui::MenuItem *pMenuItem = pSubMenu->GetMenuItem( nIndex );
		pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_MarketUnavailable" ) );
		pMenuItem->InvalidateLayout( true, false );
	}

}
//-----------------------------------------------------------------------------
void CBackpackPanel::AddPaintToContextMenu( Menu *pPaintSubMenu, item_definition_index_t iPaintDef, bool bAddCommerce )
{
	GameItemDefinition_t * pPaintCanDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinition( iPaintDef ) );
	if ( !pPaintCanDef )
		return;

	wchar_t wBuff[256];
	char cBuff[256];
	V_swprintf_safe( wBuff, L"     %ls", g_pVGuiLocalize->Find( pPaintCanDef->GetItemBaseName() ) );

	char szItemName[256];
	g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pPaintCanDef->GetItemBaseName() ), szItemName, sizeof( szItemName ) );
	V_sprintf_safe( cBuff, "     %s", szItemName );

	uint32 unPaintRGB0 = 0;
	uint32 unPaintRGB1 = 0;

	static CSchemaAttributeDefHandle pAttrDef_PaintRGB( "set item tint RGB" );
	static CSchemaAttributeDefHandle pAttrDef_PaintRGB2( "set item tint RGB 2" );

	float fRGB = 0.0f;

	if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pPaintCanDef, pAttrDef_PaintRGB, &fRGB ) && fRGB != 0.0f )
	{
		unPaintRGB0 = fRGB;

		// We may or may not have a secondary paint color as well. If we don't, we just use the primary
		// paint color to fill both slots.
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pPaintCanDef, pAttrDef_PaintRGB2, &fRGB ) )
		{
			unPaintRGB1 = fRGB;
		}
		else
		{
			unPaintRGB1 = unPaintRGB0;
		}
	}

	if ( !bAddCommerce )
	{
		int nIndex = pPaintSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "paint%d", iPaintDef ) ), this );
		vgui::MenuItem *pMenuItem = pPaintSubMenu->GetMenuItem( nIndex );
		pMenuItem->SetText( wBuff );
		pMenuItem->InvalidateLayout( true, false );

		CItemMaterialCustomizationIconPanel *pCustomPanel = new CItemMaterialCustomizationIconPanel( pMenuItem, "paint" );
		pCustomPanel->SetZPos( -100 );
		pCustomPanel->SetTall( 30 );
		pCustomPanel->SetWide( 30 );
		pCustomPanel->m_colPaintColors.AddToTail( Color( clamp( ( unPaintRGB0 & 0xFF0000 ) >> 16, 0, 255 ), clamp( ( unPaintRGB0 & 0xFF00 ) >> 8, 0, 255 ), clamp( ( unPaintRGB0 & 0xFF ), 0, 255 ), 255 ) );
		pCustomPanel->m_colPaintColors.AddToTail( Color( clamp( ( unPaintRGB1 & 0xFF0000 ) >> 16, 0, 255 ), clamp( ( unPaintRGB1 & 0xFF00 ) >> 8, 0, 255 ), clamp( ( unPaintRGB1 & 0xFF ), 0, 255 ), 255 ) );
	}
	else
	{
		// 
		const char *pszContextMenuBorder = "NotificationDefault";
		const char *pszContextMenuFont = "HudFontMediumSecondary";

		Menu *pSubMenu = new Menu( this, "PaintSubMenu" );
		pSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
		pSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
		int iPos = pPaintSubMenu->AddCascadingMenuItem( cBuff, this, pSubMenu );

		CItemMaterialCustomizationIconPanel *pCustomPanel = new CItemMaterialCustomizationIconPanel( pPaintSubMenu, "paint" );
		pCustomPanel->SetZPos( 100 );
		pCustomPanel->SetPos( 0, iPos * pPaintSubMenu->GetMenuItemHeight() );
		pCustomPanel->SetTall( 30 );
		pCustomPanel->SetWide( 30 );
		pCustomPanel->m_colPaintColors.AddToTail( Color( clamp( ( unPaintRGB0 & 0xFF0000 ) >> 16, 0, 255 ), clamp( ( unPaintRGB0 & 0xFF00 ) >> 8, 0, 255 ), clamp( ( unPaintRGB0 & 0xFF ), 0, 255 ), 255 ) );
		pCustomPanel->m_colPaintColors.AddToTail( Color( clamp( ( unPaintRGB1 & 0xFF0000 ) >> 16, 0, 255 ), clamp( ( unPaintRGB1 & 0xFF00 ) >> 8, 0, 255 ), clamp( ( unPaintRGB1 & 0xFF ), 0, 255 ), 255 ) );

		AddCommerceSubmenus( pSubMenu, iPaintDef, "paint" );
	}
}
//
// Add commerce context options for an item.  Adds 'Store' and 'Market' options if appropriate (and Pricing) other wise just click to use
//
void CBackpackPanel::AddCommerceToContextMenu( Menu *pMenu, const char* pszActionFmt, item_definition_index_t iItemDefIndex, bool bAddMarket, bool bAddStore )
{
	GameItemDefinition_t * pItemDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinition( iItemDefIndex ) );
	if ( !pItemDef )
		return;

	//
	if ( !bAddMarket && !bAddStore )
	{
		int nIndex = pMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "%s%d", pszActionFmt, iItemDefIndex ) ), this );
		vgui::MenuItem *pMenuItem = pMenu->GetMenuItem( nIndex );
		pMenuItem->SetText( g_pVGuiLocalize->Find( pItemDef->GetItemBaseName() ) );
		pMenuItem->InvalidateLayout( true, false );
	}
	else
	{
		// 
		const char *pszContextMenuBorder = "NotificationDefault";
		const char *pszContextMenuFont = "HudFontMediumSecondary";

		Menu *pSubMenu = new Menu( this, "CommerceSubMenu" );
		pSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
		pSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
		pMenu->AddCascadingMenuItem( pItemDef->GetItemBaseName(), this, pSubMenu );

		AddCommerceSubmenus( pSubMenu, iItemDefIndex, pszActionFmt );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Opens a context menu with actions relevant for the passed in item
//-----------------------------------------------------------------------------
void CBackpackPanel::OpenContextMenu()
{
	CUtlVector<CEconItemView*> vecSelectedItems; 
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->GetItem() )
		{
			vecSelectedItems.AddToTail( m_pItemModelPanels[i]->GetItem() );
		}
	}

	if ( m_pContextMenu )
		delete m_pContextMenu;

	m_pContextMenu = new Menu( this, "ContextMenu" );
	MenuBuilder contextMenuBuilder( m_pContextMenu, this );
	const char *pszContextMenuBorder = "NotificationDefault";
	const char *pszContextMenuFont = "HudFontMediumSecondary";
	m_pContextMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
	m_pContextMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );

	if ( vecSelectedItems.Count() == 1 )
	{
		const CEconItemView *pItem = vecSelectedItems.Head();
		const CTFItemDefinition *pItemDef = pItem->GetStaticData();
		static CSchemaItemDefHandle DuckBadgeItemDef( "Duck Badge" );
		static CSchemaItemDefHandle StrangeCountTransferItemDef( "Strange Count Transfer Tool" );

		// Tools of any kind can't be used if they are in escrow.
		static CSchemaAttributeDefHandle pAttrib_ToolEscrowUntil( "tool escrow until date" );
		uint32 unEscrowTime;
		const bool bToolIsInEscrow = pItem->FindAttribute( pAttrib_ToolEscrowUntil, &unEscrowTime )
									&& unEscrowTime > CRTime::RTime32TimeCur();
			
		const IEconTool *pEconTool = pItem->GetItemDefinition()->GetEconTool();

		const bool bIsTool = pItem->GetStaticData()->IsTool() && (pEconTool != NULL);
		const bool bIsGCConsumable = ( ( pItem->GetStaticData()->GetCapabilities() & ITEM_CAP_USABLE_GC ) != 0 );
		bool bSkipAddTrade = false;		// Hack: We should really ask the tool if the command supplants trade.

		// Tool usage goes first.  The cursor starts on this element, so double-clicks will work like how they used to.
		// Strange Count Transfer
		if ( StrangeCountTransferItemDef == pItem->GetItemDefinition() )
		{
			contextMenuBuilder.AddMenuItem( "#ApplyOnItem", new KeyValues( "Context_OpenStrangeCountTransfer" ), "primaryaction" );
		}
		else if ( pItem->GetStaticData()->IsTool() && pEconTool == NULL )
		{
			// do nothing. not a real tool (basic balloons with color that we don't want to 'remove' the paint)
		}
		else if ( (bIsTool || bIsGCConsumable) && !bToolIsInEscrow && pEconTool->CanBeUsedNow( pItem ) )
		{
			Assert( pEconTool );

			const int nTokens = pEconTool->GetUseCommandCount( pItem );
			for ( int i = 0; i < nTokens; ++i )
			{
				const char *pszToolUsageString = pEconTool->GetUseCommandLocalizationToken( pItem, i );

				// If we didn't have a custom usage string, fall back to a sane default based on whether or
				// not we're a consumable or not.
				if ( !pszToolUsageString )
				{
					pszToolUsageString = bIsGCConsumable ? "#ConsumeItem" : "#ApplyOnItem";
				}

				const char *pszContext = pEconTool->GetUseCommand( pItem, i );
				contextMenuBuilder.AddMenuItem( pszToolUsageString, new KeyValues( pszContext ), "primaryaction" );
			}

			// Hack: We should really ask the tool if the command supplants trade. For now, if we have two
			// things, then one of them is trade, so skip it.
			bSkipAddTrade = nTokens > 1;
		}
		else if ( pItem->GetItemDefinition()->GetCapabilities() & ITEM_CAP_DECODABLE )
		{
			
			static CSchemaAttributeDefHandle pAttrDef_CanShuffleCrateContents( "can shuffle crate contents" );

			if ( pItem->FindAttribute( pAttrDef_CanShuffleCrateContents ) )
			{
				contextMenuBuilder.AddMenuItem( "#ShuffleContents", new KeyValues( "Context_Shuffle" ), "primaryaction" );
			}

			if ( GetFirstCompatibleKeyForCrate( pItem ) != NULL )
			{
				contextMenuBuilder.AddMenuItem( "#UseKey", new KeyValues( "Context_OpenCrateWithKey" ), "primaryaction" );
			}
			
			if ( GetDecodedByItemDefIndex( pItem ) )
			{
				contextMenuBuilder.AddMenuItem( "#GetKey", new KeyValues( "Context_GetItemFromStore" ), "primaryaction" );
				contextMenuBuilder.AddMenuItem( "#BuyAndUseKey", new KeyValues( "Context_BuyKeyAndOpenCrate" ), "primaryaction" );
			}
		}
		else if ( pItem->GetItemDefinition()->GetCapabilities() & ITEM_CAP_HAS_SLOTS )
		{
			// check if we have at least 1 slot criteria
			static CSchemaAttributeDefHandle pAttrDef_Slot( "item slot criteria 1" );
			if ( pItem->FindAttribute( pAttrDef_Slot ) )
			{	
				contextMenuBuilder.AddMenuItem( "#EditSlots", new KeyValues( "Context_EditSlot" ), "primaryaction" );
			}
		}
		else if ( DuckBadgeItemDef == pItem->GetItemDefinition() )
		{
			contextMenuBuilder.AddMenuItem( "#Duck_ViewLeaderboards", new KeyValues( "Context_OpenDuckLeaderboards" ), "primaryaction" );

			if ( CanInventoryItemsApplyTo( pItem ) )
			{
				contextMenuBuilder.AddMenuItem( "#UseDuckToken", new KeyValues( "Context_ApplyByItem" ), "primaryaction" );
			}
			
			if ( GetDecodedByItemDefIndex( pItem ) )
			{
				contextMenuBuilder.AddMenuItem( "#GetDuckToken", new KeyValues( "Context_GetItemFromStore" ), "primaryaction" );
			}
		}

		// 3D Inspect
		float flInspect = 0;
		static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
		static CSchemaAttributeDefHandle pAttrib_CosmeticAllowInspect( "cosmetic_allow_inspect" );
		if ( pItem && pItem->IsValid() &&
			( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttrib_WeaponAllowInspect, &flInspect ) || FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttrib_CosmeticAllowInspect, &flInspect ) 
#ifdef STAGING_ONLY
			|| tf_weapon_force_allow_inspect.GetBool()
#endif
			) )
		{
			if ( flInspect != 0
#ifdef STAGING_ONLY
				|| tf_weapon_force_allow_inspect.GetBool() 
#endif
				)
			{
				contextMenuBuilder.AddMenuItem( "#Context_InspectModel", new KeyValues( "Context_InspectModel" ), "primaryaction" );
			}
		}

		// Add equip sub menu
		{
			Menu *pEquipSubMenu = NULL;
			for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
			{
				if ( !pItemDef->CanBeUsedByClass( iClass ) )
					continue;
			
				if ( pEquipSubMenu == NULL )
				{
					pEquipSubMenu = new Menu( this, "EquipMenu" );
					pEquipSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
					pEquipSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );

					contextMenuBuilder.AddCascadingMenuItem( "#Context_Equip", pEquipSubMenu, "primaryaction" );
				}

				const char *pszClassName = NULL;
				switch ( iClass )
				{
					case TF_CLASS_SCOUT: 			pszClassName = "#TF_Class_Name_Scout"; break;
					case TF_CLASS_SNIPER: 			pszClassName = "#TF_Class_Name_Sniper"; break;
					case TF_CLASS_SOLDIER: 			pszClassName = "#TF_Class_Name_Soldier"; break;
					case TF_CLASS_DEMOMAN: 			pszClassName = "#TF_Class_Name_Demoman"; break;
					case TF_CLASS_MEDIC: 			pszClassName = "#TF_Class_Name_Medic"; break;
					case TF_CLASS_HEAVYWEAPONS: 	pszClassName = "#TF_Class_Name_HWGuy"; break;
					case TF_CLASS_PYRO: 			pszClassName = "#TF_Class_Name_Pyro"; break;
					case TF_CLASS_SPY: 				pszClassName = "#TF_Class_Name_Spy"; break;
					case TF_CLASS_ENGINEER: 		pszClassName = "#TF_Class_Name_Engineer"; break;
				}
			
				pEquipSubMenu->AddMenuItem( pszClassName, new KeyValues( "Command", "command", CFmtStr( "equipclass%d", iClass ) ), this );
			}
		}
		
		// For customizable items only
		if ( !pItem->IsTemporaryItem() )
		{
			bool bCanCraftUp = GetCollectionCraftingInvalidReason(pItem, NULL) == NULL;
			bool bCanStatClockTrade = GetCraftCommonStatClockInvalidReason(pItem, NULL) == NULL;
			Menu *pMannCoTradeSubMenu = NULL;

			if ( bCanCraftUp || bCanStatClockTrade )
			{
				pMannCoTradeSubMenu = new Menu(this, "MannCoTradeSubMenu");
				pMannCoTradeSubMenu->SetBorder(scheme()->GetIScheme(GetScheme())->GetBorder(pszContextMenuBorder));
				pMannCoTradeSubMenu->SetFont(scheme()->GetIScheme(GetScheme())->GetFont(pszContextMenuFont));
				contextMenuBuilder.AddCascadingMenuItem("#Context_MannCoTrade", pMannCoTradeSubMenu, "customization");

				if ( bCanCraftUp )
				{
					int nIndex = pMannCoTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftUpCollection"), this);
					vgui::MenuItem *pMenuItem = pMannCoTradeSubMenu->GetMenuItem(nIndex);
					pMenuItem->SetText("#Context_TradeUp");
					pMenuItem->InvalidateLayout(true, false);
				}

				if ( bCanStatClockTrade )
				{
					int nIndex = pMannCoTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftCommonStatClock"), this);
					vgui::MenuItem *pMenuItem = pMannCoTradeSubMenu->GetMenuItem(nIndex);
					pMenuItem->SetText("#Context_CommonStatClock");
					pMenuItem->InvalidateLayout(true, false);
				}
			}



			// Campaign coin access trades
			static CSchemaAttributeDefHandle pAttrDef_IsOperationPass( "is_operation_pass" );
			if ( pItem->FindAttribute( pAttrDef_IsOperationPass ) )
			{
				Menu *pMannCoCoinTradeSubMenu = new Menu( this, "MannCoTradeSubMenu" );
				pMannCoCoinTradeSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
				pMannCoCoinTradeSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
				contextMenuBuilder.AddCascadingMenuItem( "#Context_MannCoTrade", pMannCoCoinTradeSubMenu, "customization" );

				int nIndex = pMannCoCoinTradeSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "Context_CraftUpCollection" ), this );
				vgui::MenuItem *pMenuItem = pMannCoCoinTradeSubMenu->GetMenuItem( nIndex );
				pMenuItem->SetText( "#Context_TradeUp" );
				pMenuItem->InvalidateLayout( true, false );

				nIndex = pMannCoCoinTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftCommonStatClock"), this);
				pMenuItem = pMannCoCoinTradeSubMenu->GetMenuItem(nIndex);
				pMenuItem->SetText("#Context_CommonStatClock");
				pMenuItem->InvalidateLayout(true, false);
			}

			// Halloween trade up offering.
			// Needs two attrs
			static CSchemaAttributeDefHandle pAttrDef_HalloweenOffering( "allow_halloween_offering" );
			static CSchemaAttributeDefHandle pAttrDef_DeactiveDate( "deactive date" );

			// Check the date
			uint32 unDeactiveDate = 0;
			uint32 unCurrentDate = CRTime::RTime32TimeCur();
			if ( pAttrDef_HalloweenOffering && pItem->FindAttribute( pAttrDef_HalloweenOffering ) && pItem->FindAttribute( pAttrDef_DeactiveDate, &unDeactiveDate ) && unDeactiveDate > unCurrentDate )
			{
				vgui::MenuItem *pMenuItem = contextMenuBuilder.AddMenuItem( "#Context_HalloweenOffering", new KeyValues( "Context_HalloweenOffering" ), "customization" );

				ImagePanel *pNewImage = new ImagePanel( pMenuItem, "new" );
				pNewImage->SetZPos( 100 );
				pNewImage->SetWide( 40 );
				pNewImage->SetTall( 40 );
				pNewImage->SetPos( 220, -5 );
				pNewImage->SetMouseInputEnabled( false );
				pNewImage->SetShouldScaleImage( true );
				pNewImage->SetImage( "new" );
			}

			// Change name
			GameItemDefinition_t * pNameTagDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinitionByName( "Name Tag" ) );
			if ( CEconSharedToolSupport::ToolCanApplyToDefinition( dynamic_cast<const GameItemDefinition_t *>( pNameTagDef ), pItemDef ) )
			{
				contextMenuBuilder.AddMenuItem( "#Context_Rename", new KeyValues( "DoRename" ), "customization" );
			}

			// Change description
			GameItemDefinition_t * pDescTagDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinitionByName( "Description Tag" ) );
			if ( CEconSharedToolSupport::ToolCanApplyToDefinition( dynamic_cast<const GameItemDefinition_t *>( pDescTagDef ), pItemDef ) )
			{
				contextMenuBuilder.AddMenuItem( "#Context_Description", new KeyValues( "DoDescription" ), "customization" );
			}

			// Add paint options sub menu
			if ( m_vecPaintCans.Count() > 0 )
			{
				GameItemDefinition_t * pPaintCanDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinition( m_vecPaintCans[0] ) );
				if ( pPaintCanDef && CEconSharedToolSupport::ToolCanApplyToDefinition( dynamic_cast<const GameItemDefinition_t *>( pPaintCanDef ), pItemDef ) )
				{
					Menu *pPaintSubMenu = NULL;
					pPaintSubMenu = new Menu( this, "PaintSubMenu" );
					pPaintSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
					pPaintSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
					contextMenuBuilder.AddCascadingMenuItem( "#Context_Paint", pPaintSubMenu, "customization" );

					CUtlVector<item_definition_index_t> vecOwnedPaints;
					CUtlVector<item_definition_index_t> vecStorePaints;

					// Find out if the user owns this item or not and place in the proper bucket
					CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();

					FOR_EACH_VEC( m_vecPaintCans, i )
					{	
						if ( pLocalInv && pLocalInv->FindFirstItembyItemDef( m_vecPaintCans[i] ) )
						{
							vecOwnedPaints.AddToTail( m_vecPaintCans[i] );
						}
						else
						{
							vecStorePaints.AddToTail( m_vecPaintCans[i] );
						}
					}

					if ( vecOwnedPaints.Count() > 0 )
					{
						// Add Header and loop
						int nIndex = pPaintSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "" ), this );
						vgui::MenuItem *pMenuItem = pPaintSubMenu->GetMenuItem( nIndex );
						pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_Owned" ) );
						pMenuItem->InvalidateLayout( true, false );

						FOR_EACH_VEC( vecOwnedPaints, i )
						{
							AddPaintToContextMenu( pPaintSubMenu, vecOwnedPaints[i], false );
						}
					}

					pPaintSubMenu->AddSeparator();
					if ( vecStorePaints.Count() > 0 )
					{
						// Add Header and loop
						int nIndex = pPaintSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "" ), this );
						vgui::MenuItem *pMenuItem = pPaintSubMenu->GetMenuItem( nIndex );
						pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_Commerce" ) );
						pMenuItem->InvalidateLayout( true, false );

						FOR_EACH_VEC( vecStorePaints, i )
						{
							AddPaintToContextMenu( pPaintSubMenu, vecStorePaints[i], true );
						}
					}
				}
			}

			// Strange Parts
			if ( BIsItemStrange( pItem ) )
			{
				Menu *pStrangePartsSubMenu = NULL;
				CUtlVector<item_definition_index_t> vecOwnedParts;
				CUtlVector<item_definition_index_t> vecStoreParts;

				// Find out if the user owns this item or not and place in the proper bucket
				CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
				FOR_EACH_VEC( m_vecStrangeParts, i )
				{
					// Determine if this can be applied
					//GameItemDefinition_t *pStrangePartDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinition( m_vecStrangeParts[i] ) );
					CEconItemView partItemView;
					partItemView.Init( m_vecStrangeParts[i], AE_USE_SCRIPT_VALUE, 1 );
					if ( CEconSharedToolSupport::ToolCanApplyTo( &partItemView, pItem ) )
					{
						// Create menu
						if ( !pStrangePartsSubMenu )
						{
							pStrangePartsSubMenu = new Menu( this, "StrangePartsSubMenu" );
							pStrangePartsSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
							pStrangePartsSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
							contextMenuBuilder.AddCascadingMenuItem( "#Context_StrangeParts", pStrangePartsSubMenu, "customization" );
						}

						if ( pLocalInv && pLocalInv->FindFirstItembyItemDef( m_vecStrangeParts[i] ) )
						{
							vecOwnedParts.AddToTail( m_vecStrangeParts[i] );
						}
						else
						{
							vecStoreParts.AddToTail( m_vecStrangeParts[i] );
						}
					}
				}

				if ( pStrangePartsSubMenu )
				{
					if ( vecOwnedParts.Count() > 0 )
					{
						// Add Header and loop
						int nIndex = pStrangePartsSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "" ), this );
						vgui::MenuItem *pMenuItem = pStrangePartsSubMenu->GetMenuItem( nIndex );
						pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_Owned" ) );
						pMenuItem->InvalidateLayout( true, false );

						FOR_EACH_VEC( vecOwnedParts, i )
						{
							AddCommerceToContextMenu( pStrangePartsSubMenu, "strangepart_", vecOwnedParts[i], false, false );
						}
					}

					pStrangePartsSubMenu->AddSeparator();
					if ( vecStoreParts.Count() > 0 )
					{
						// Add Header and loop 
						int nIndex = pStrangePartsSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "" ), this );
						vgui::MenuItem *pMenuItem = pStrangePartsSubMenu->GetMenuItem( nIndex );
						pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_Market" ) );
						pMenuItem->InvalidateLayout( true, false );

						FOR_EACH_VEC( vecStoreParts, i )
						{
							AddCommerceToContextMenu( pStrangePartsSubMenu, "strangepart_", vecStoreParts[i], true, false );
						}
					}
				}
			}

			if ( pItem->IsMarketable() )
			{
				contextMenuBuilder.AddMenuItem( "#Context_MarketPlaceSell", new KeyValues( "DoSellMarketplace" ), "economy" );
			}

			// Trade to another player
			if ( pItem->IsTradable() && !bSkipAddTrade )
			{
				contextMenuBuilder.AddMenuItem( "#Context_Trade", new KeyValues( "DoTradeToPlayer" ), "economy" );
			}

			if ( pItem->GetItemDefinition()->GetCapabilities() & ITEM_CAP_CAN_BE_RESTORED )
			{
				if ( RemovableAttributes_DoAnyAttributesApply( pItem ) )
				{
					contextMenuBuilder.AddMenuItem( "#RefurbishItem", new KeyValues( "Context_RefurbishItem" ), "destructive" );
				}
			}
		}
	}
	else
	{
		// Check if ALL selected items can be crafted together
		bool bCanCraftUp = true;
		for( int i=0; i < COLLECTION_CRAFTING_ITEM_COUNT && i < vecSelectedItems.Count(); ++i )
		{
			CEconItemView* pPrevItem = ( i - 1 ) < 0 ? NULL : vecSelectedItems[ i - 1 ];
			bCanCraftUp &= GetCollectionCraftingInvalidReason( vecSelectedItems[ i ], pPrevItem ) == NULL;
		}

		bool bCanStatClockTrade = true;
		for (int i = 0; i < COLLECTION_CRAFTING_ITEM_COUNT && i < vecSelectedItems.Count(); ++i)
		{
			CEconItemView* pPrevItem = (i - 1) < 0 ? NULL : vecSelectedItems[i - 1];
			bCanStatClockTrade &= GetCraftCommonStatClockInvalidReason(vecSelectedItems[i], pPrevItem) == NULL;
		}

		Menu *pMannCoTradeSubMenu = NULL;

		if ( bCanCraftUp || bCanStatClockTrade )
		{
			pMannCoTradeSubMenu = new Menu(this, "MannCoTradeSubMenu");
			pMannCoTradeSubMenu->SetBorder(scheme()->GetIScheme(GetScheme())->GetBorder(pszContextMenuBorder));
			pMannCoTradeSubMenu->SetFont(scheme()->GetIScheme(GetScheme())->GetFont(pszContextMenuFont));
			contextMenuBuilder.AddCascadingMenuItem("#Context_MannCoTrade", pMannCoTradeSubMenu, "customization");

			if (bCanCraftUp)
			{
				int nIndex = pMannCoTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftUpCollection"), this);
				vgui::MenuItem *pMenuItem = pMannCoTradeSubMenu->GetMenuItem(nIndex);
				pMenuItem->SetText("#Context_TradeUp");
				pMenuItem->InvalidateLayout(true, false);
			}

			if (bCanStatClockTrade)
			{
				int nIndex = pMannCoTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftCommonStatClock"), this);
				vgui::MenuItem *pMenuItem = pMannCoTradeSubMenu->GetMenuItem(nIndex);
				pMenuItem->SetText("#Context_CommonStatClock");
				pMenuItem->InvalidateLayout(true, false);
			}
		}
	}

	if ( !m_bShowBaseItems )
	{
		bool bDeleteAvailable = true;
		// Check that all of the selected items are deletable
		for( int i=0; i < vecSelectedItems.Count() && bDeleteAvailable; ++i )
		{
			static CSchemaAttributeDefHandle pAttrDef_NoDelete( "cannot delete" );
			bDeleteAvailable &= !vecSelectedItems[i]->FindAttribute( pAttrDef_NoDelete );
		}

		// Only show the delete button if every slected item is deletable
		if ( bDeleteAvailable )
		{
			contextMenuBuilder.AddMenuItem( "#TF_SteamWorkshop_Delete", new KeyValues( "DoDelete" ), "destructive" );
		}
	}

	// Position to the cursor's position
	int nX, nY;
	g_pVGuiInput->GetCursorPosition( nX, nY );
	m_pContextMenu->SetPos( nX - 1, nY - 1 );
	
	m_pContextMenu->SetVisible(true);
	m_pContextMenu->AddActionSignalTarget(this);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OnItemPanelMouseRightRelease( vgui::Panel *panel )
{
#ifdef STAGING_ONLY
	if ( tf_use_card_tooltips.GetBool() )
	{
		m_pMouseOverCardPanel->PinCard( true );
	}
	else
#endif
	{
		CItemModelPanel *pItemPanel = dynamic_cast < CItemModelPanel * > ( panel );
		if ( pItemPanel && pItemPanel->IsVisible() )
		{
			// If they're not holding down ctrl, deselect all existing selections
			if ( !vgui::input()->IsKeyDown(KEY_LCONTROL) && !vgui::input()->IsKeyDown(KEY_RCONTROL) )
			{
				DeSelectAllBackpackItemPanels();
				ToggleSelectBackpackItemPanel( pItemPanel );
			}
			else if ( AllowSelection() && !pItemPanel->IsGreyedOut() )
			{
				if ( !pItemPanel->IsSelected() && pItemPanel->HasItem() )
				{
					pItemPanel->SetSelected( true );
				}
				SetBorderForItem( pItemPanel, false );
			}

			OpenContextMenu();
		}
	}
}

void CBackpackPanel::OnMouseMismatchedRelease( MouseCode code, Panel* pPressedPanel )
{
	if ( pPressedPanel )
	{
		OnMouseReleased( code );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::StartDrag( int x, int y )
{
	// don't allow item drag if there's a filter
	if ( HasNameFilter() )
		return;

	m_bDragging = true;
	HideMouseOverPanel();

	vgui::ivgui()->AddTickSignal( GetVPanel() );

	m_pMouseDragItemPanel->SetItem( m_pItemDraggedFromPanel->GetItem() );
	m_pMouseDragItemPanel->InvalidateLayout( true );

	m_pItemDraggedFromPanel->Dragged( true );

	// Calculate the mouse offset from the top left of the panel we're going to drag
	m_iDragOffsetX = m_pMouseDragItemPanel->GetWide() * 0.5f;
	m_iDragOffsetY = m_pMouseDragItemPanel->GetTall() * 0.5f;
	m_flPreventDragPageSwitchUntil = 0;

	m_pMouseDragItemPanel->SetVisible( true );

	m_pItemDraggedFromPanel->SetItem( NULL );
	SetBorderForItem( m_pItemDraggedFromPanel, false );
	m_pPrevDragOverItemPanel = NULL;

	vgui::input()->SetMouseCapture( GetVPanel() );

	if ( m_pDragToNextPageButton && m_pDragToPrevPageButton )
	{
		m_pDragToNextPageButton->SetVisible( GetNumPages() > 1 );
		m_pDragToPrevPageButton->SetVisible( GetNumPages() > 1 );
	}

	// play pickup sound
	CEconItemView *item = m_pMouseDragItemPanel->GetItem();
	if ( item )
	{
		const char *soundFilename = item->GetDefinitionString( "pickup_sound", "" );
		if ( soundFilename[0] )
		{
			vgui::surface()->PlaySound( soundFilename );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::StopDrag( bool bSucceeded )
{
	if ( !m_pItemDraggedFromPanel )
		return;

	if ( !bSucceeded )
	{
		if ( m_iDraggedFromPage == GetCurrentPage() )
		{
			m_pItemDraggedFromPanel->SetItem( m_pMouseDragItemPanel->GetItem() );
		}
		m_pItemDraggedFromPanel = NULL;
	}

	m_pMouseDragItemPanel->SetVisible( false );
	m_bDragging = false;

	vgui::input()->SetMouseCapture( NULL );

	if ( m_pDragToNextPageButton && m_pDragToPrevPageButton )
	{
		m_pDragToNextPageButton->SetVisible( false );
		m_pDragToPrevPageButton->SetVisible( false );
	}

	// play drop sound
	CEconItemView *item = m_pMouseDragItemPanel->GetItem();
	if ( item )
	{
		const char *soundFilename = item->GetDefinitionString( "drop_sound", "ui/item_default_drop.wav" );
		vgui::surface()->PlaySound( soundFilename );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBackpackPanel::GetBackpackPositionForPanel( CItemModelPanel *pItemPanel )
{
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		if ( m_pItemModelPanels[i] == pItemPanel  )
			return i;
	}
	return -1;
}



//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::HandleDragTo( CItemModelPanel *pItemPanel, int iPanelIndex )
{
	// Find the position based on the panel we're dragging to
	if ( iPanelIndex != -1 )
	{
		// If the current panel is selected, unselect it
		if ( m_pItemModelPanels[iPanelIndex]->IsSelected() )
		{
			ToggleSelectBackpackItemPanel( m_pItemModelPanels[iPanelIndex] );
		}
		if ( m_pItemDraggedFromPanel->IsSelected() )
		{
			ToggleSelectBackpackItemPanel( m_pItemDraggedFromPanel );
		}

		// We "move" the items in the backpack immediately, because when the messages come back 
		// from steam they'll fix the positions if the move fails for some reason.
		CEconItemView *pItem = NULL;
		if ( m_pItemModelPanels[iPanelIndex]->HasItem() )
		{
			// We need to copy it because it's about to get stomped by the other item
			pItem = new CEconItemView( *m_pItemModelPanels[iPanelIndex]->GetItem() );
		}
		m_pItemModelPanels[iPanelIndex]->SetItem( m_pMouseDragItemPanel->GetItem() );

		if ( m_iDraggedFromPage == GetCurrentPage() )
		{
			m_pItemDraggedFromPanel->SetItem( pItem );
		}

		if ( pItem )
		{
			delete pItem;
		}

		// Tell the inventory to move the item
		// Translate it to the right page
		int iBackpackPosition = GetBackpackPosForPanelIndex( iPanelIndex );
		InventoryManager()->MoveItemToBackpackPosition( m_pMouseDragItemPanel->GetItem(), iBackpackPosition );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::OnTick( void )
{
	BaseClass::OnTick();

	bool bNeedsTick = false;
	if ( m_flStartExplanationsAt && m_flStartExplanationsAt < Plat_FloatTime() )
	{
		m_flStartExplanationsAt = 0;

		if ( ShouldShowExplanations() )
		{
			ConVar *pConVar = GetExplanationConVar();
			if ( pConVar )
			{
				pConVar->SetValue( 1 );
			}

			CExplanationPopup *pPopup = dynamic_cast<CExplanationPopup*>( FindChildByName("StartExplanation") );
			if ( pPopup )
			{
				pPopup->Popup();
			}
		}
	}
	else
	{
		bNeedsTick = true;
	}

	// To handle page movement while holding the mouse still over the page buttons, 
	// we need to keep calling OnCursorMoved() whenever we're dragging.
	if ( m_bDragging && m_pMouseDragItemPanel && m_pItemDraggedFromPanel && IsVisible() )
	{
		int mx,my;
		vgui::input()->GetCursorPos( mx, my );
		ScreenToLocal( mx, my );
		OnCursorMoved( mx,my );

		bNeedsTick = true;
	}

	if ( !bNeedsTick && !NeedsDerivedTickSignal() )
	{
		vgui::ivgui()->RemoveTickSignal( GetVPanel() );
	}

}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::OnThink( void )
{
	BaseClass::OnThink();

	if ( m_flFilterItemTime > 0 && gpGlobals->curtime >= m_flFilterItemTime )
	{
		SetCurrentPage( 0 );
		DeSelectAllBackpackItemPanels();
		UpdateModelPanels();

		m_flFilterItemTime = 0.0f;
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::OnCursorMoved( int x, int y )
{
	if ( !m_pItemDraggedFromPanel )
		return;

	if ( m_bDragging && m_pMouseDragItemPanel )
	{
		m_pMouseDragItemPanel->SetPos( x - m_iDragOffsetX, y - m_iDragOffsetY );

		// When we're dragging, we have mouse capture, so the item panels aren't getting mouse input.
		// We need to find out what item panel we're over, and let it know.

		if ( m_flPreventDragPageSwitchUntil < Plat_FloatTime() )
		{
			// First, are we over the page turning areas?
			bool bDragNext = false;
			if ( m_pDragToNextPageButton && m_pDragToNextPageButton->IsVisible() )
			{
				int iDragX, iDragY;
				m_pDragToNextPageButton->GetPos( iDragX, iDragY );
				bDragNext = ( x >= iDragX && x <= (iDragX + m_pDragToNextPageButton->GetWide() ) );
			}
			if ( !bDragNext && m_pNextPageButton && m_pNextPageButton->IsEnabled() )
			{
				int iDragX, iDragY;
				m_pNextPageButton->GetPos( iDragX, iDragY );
				bDragNext = ( x >= iDragX && x <= (iDragX + m_pNextPageButton->GetWide()) && y >= iDragY && y <= (iDragY + m_pNextPageButton->GetTall()) );
			}
			if ( bDragNext )
			{
				OnCommand( "nextpage" );
				m_flPreventDragPageSwitchUntil = Plat_FloatTime() + tf_backpack_page_button_delay.GetFloat();
				return;
			}

			bool bDragPrev = false;
			if ( m_pDragToPrevPageButton && m_pDragToPrevPageButton->IsVisible() )
			{
				int iDragX, iDragY;
				m_pDragToPrevPageButton->GetPos( iDragX, iDragY );
				bDragPrev = ( x >= iDragX && x <= (iDragX + m_pDragToPrevPageButton->GetWide() ) );
			}
			if ( !bDragPrev && m_pPrevPageButton && m_pPrevPageButton->IsEnabled() )
			{
				int iDragX, iDragY;
				m_pPrevPageButton->GetPos( iDragX, iDragY );
				bDragPrev = ( x >= iDragX && x <= (iDragX + m_pPrevPageButton->GetWide()) && y >= iDragY && y <= (iDragY + m_pPrevPageButton->GetTall()) );
			}
			if ( bDragPrev )
			{
				OnCommand( "prevpage" );
				m_flPreventDragPageSwitchUntil = Plat_FloatTime() + tf_backpack_page_button_delay.GetFloat();
				return;
			}
		}

		// check if we're hovering page button
		static int iPrevHoveringPage = -1;
		static float flLastPageButtonEnterTime = 0.f;
		int iHoveringPage = GetPageButtonIndexAtPos( x, y );
		if ( iHoveringPage != -1 )
		{
			if ( iHoveringPage == GetCurrentPage() )
			{
				iPrevHoveringPage = -1;
				flLastPageButtonEnterTime = 0.f;
			}
			else if ( iPrevHoveringPage != iHoveringPage )
			{
				iPrevHoveringPage = iHoveringPage;
				flLastPageButtonEnterTime = Plat_FloatTime() + tf_backpack_page_button_delay.GetFloat();
			}
			else if ( flLastPageButtonEnterTime > 0 && flLastPageButtonEnterTime < Plat_FloatTime() )
			{
				flLastPageButtonEnterTime = 0.f;
				SetCurrentPage( iHoveringPage );
				UpdateModelPanels();
			}
			return;
		}
		else
		{
			// reset hovering page buttons data
			iPrevHoveringPage = -1;
			flLastPageButtonEnterTime = 0.f;
		}

		CItemModelPanel *pOverPanel = GetItemPanelAtPos( x, y );
		if ( m_pPrevDragOverItemPanel != pOverPanel )
		{
			if ( m_pPrevDragOverItemPanel )
			{
				OnItemPanelExited( m_pPrevDragOverItemPanel );
			}

			m_pPrevDragOverItemPanel = pOverPanel;

			if ( m_pPrevDragOverItemPanel )
			{
				OnItemPanelEntered( m_pPrevDragOverItemPanel );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBackpackPanel::OnItemPanelCursorMoved( int x, int y )
{
	if ( !m_pItemDraggedFromPanel )
		return;

	if ( !m_bDragging && m_pItemDraggedFromPanel->HasItem() && !InToolSelectionMode() )
	{
		// Don't drag instantly, so it's easy to select
		if ( (gpGlobals->curtime - m_flMouseDownTime) > 0.3 )
		{
			StartDrag( x,y );
		}
		else
		{
			if ( !m_iMouseDownX )
			{
				m_iMouseDownX = x;
				m_iMouseDownY = y;
			}
			else if ( abs(m_iMouseDownX - x) > XRES(10) || abs(m_iMouseDownY - y) > YRES(10) )
			{
				StartDrag( x,y );
			}
		}
	}

	OnCursorMoved( x, y );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::ToggleSelectBackpackItemPanel( CItemModelPanel *pPanel )
{
	if ( !AllowSelection() || pPanel->IsGreyedOut() )
		return;

	if ( pPanel->IsSelected() || !pPanel->HasItem() )
	{
		pPanel->SetSelected( false );
	}
	else
	{
		pPanel->SetSelected( true );
	}
	SetBorderForItem( pPanel, false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::DeSelectAllBackpackItemPanels( void )
{
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		if ( m_pItemModelPanels[i]->IsSelected() )
		{
			m_pItemModelPanels[i]->SetSelected( false );
			SetBorderForItem( m_pItemModelPanels[i], false );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Called whenever the selection changes in the item loadout panel
//-----------------------------------------------------------------------------
void CBackpackPanel::OnItemContentsChanged( CEconItemView *pEconItemView )
{
	Assert( pEconItemView );

	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		CEconItemView *pInternalItem = m_pItemModelPanels[i] && m_pItemModelPanels[i]->HasItem()
									 ? m_pItemModelPanels[i]->GetItem()
									 : NULL;

		if ( *pInternalItem == *pEconItemView )
		{
			m_pItemModelPanels[i]->DirtyDescription();
			OnItemSelectionChanged();
			return;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called when text changes in combo box
//-----------------------------------------------------------------------------
void CBackpackPanel::OnTextChanged( KeyValues *data )
{
	Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );

	vgui::TextEntry *pTextEntry = dynamic_cast<vgui::TextEntry *>( pPanel );
	if ( pTextEntry )
	{
		if ( pTextEntry == m_pNameFilterTextEntry )
		{
			m_wNameFilter.RemoveAll();
			if ( m_pNameFilterTextEntry->GetTextLength() )
			{
				m_wNameFilter.EnsureCount( m_pNameFilterTextEntry->GetTextLength() + 1 );
				m_pNameFilterTextEntry->GetText( m_wNameFilter.Base(), m_wNameFilter.Count() * sizeof(wchar_t) );
				V_wcslower( m_wNameFilter.Base() );
			}
			m_flFilterItemTime = gpGlobals->curtime + 0.5f;
			return;
		}
	}

	vgui::ComboBox *pComboBox = dynamic_cast<vgui::ComboBox *>( pPanel );
	if ( pComboBox )
	{
		if ( pComboBox == m_pSortByComboBox )
		{
			// the class selection combo box changed, update class details
			KeyValues *pUserData = m_pSortByComboBox->GetActiveItemUserData();
			if ( !pUserData )
				return;

			enum { kSortType_Dummy = -1 };
			int iSortTypeSelectionIndex = pUserData->GetInt( "sortby", kSortType_Dummy );
			if ( iSortTypeSelectionIndex != kSortType_Dummy )
			{
				uint32 iSortType = g_BackpackSortTypes[iSortTypeSelectionIndex].iSortType;
				if ( iSortType != kGCItemSort_NoSort )
				{
					InventoryManager()->SortBackpackBy( iSortType );

					// Now go back to the "Sort by" header, and move the focus to the close button.
					m_pSortByComboBox->ActivateItemByRow( 0 );
				}
			}
		}
		else if ( pComboBox == m_pShowRarityComboBox )
		{
			cl_showbackpackrarities.SetValue( m_pShowRarityComboBox->GetActiveItem() );

			// Refresh all item borders
			for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
			{
				SetBorderForItem( m_pItemModelPanels[i], false );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OnButtonChecked( KeyValues *pData )
{
	Panel *pPanel = reinterpret_cast<vgui::Panel *>( pData->GetPtr("panel") );
	
	if ( m_bShowBaseItems != m_pShowBaseItemsCheckbox->IsSelected() && m_pShowBaseItemsCheckbox == pPanel && IsVisible() )
	{
		SetShowBaseItems( m_pShowBaseItemsCheckbox->IsSelected() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OnCancelSelection( void )
{
	if ( m_pConfirmDeleteDialog )
	{
		m_pConfirmDeleteDialog->MarkForDeletion();
		m_pConfirmDeleteDialog = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CBackpackPanel::GetGreyOutItemPanelReason( CItemModelPanel *pItemPanel )
{
	if ( InToolSelectionMode() )
	{
		bool bIsSelectedTool = (m_ToolSelectionItem.IsValid() && pItemPanel->HasItem()) ? (m_ToolSelectionItem == *pItemPanel->GetItem()) : false;
		if ( !bIsSelectedTool )
		{
			if ( m_ToolSelectionItem.GetStaticData()->IsTool() )
			{
				if ( !CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, pItemPanel->GetItem() ) )
				{
					return "#Econ_GreyOutReason_ToolCannotApply";
				}
			}
			else if ( pItemPanel->GetItem() && pItemPanel->GetItem()->GetStaticData()->IsTool() )
			{
				if ( !CEconSharedToolSupport::ToolCanApplyTo( pItemPanel->GetItem(), &m_ToolSelectionItem ) )
				{
					return "#Econ_GreyOutReason_ToolCannotApply";
				}
			}
		}
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::SetBorderForItem( CItemModelPanel *pItemPanel, bool bMouseOver )
{
	tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ );

	if ( !pItemPanel )
		return;

	const char *pszBorder = NULL;

	bool bIsSelectedTool = (m_ToolSelectionItem.IsValid() && pItemPanel->HasItem()) ? (m_ToolSelectionItem == *pItemPanel->GetItem()) : false;

	// Handle grey out
	const char *pszGreyOutReason = GetGreyOutItemPanelReason( pItemPanel );
	const bool bGreyOut = pszGreyOutReason != NULL;

	pItemPanel->SetGreyedOut( pszGreyOutReason );

	int iRarity = GetItemQualityForBorder( pItemPanel );

	if ( InToolSelectionMode() && bIsSelectedTool )
	{
		// We're in tool application mode, and this panel is the tool being used
		pszBorder = "BackpackItemBorder_SelfMade";

		if ( m_pToolIcon )
		{
			int iX, iY;
			pItemPanel->GetPos( iX, iY );
			m_pToolIcon->SetPos( iX, iY );
			m_pToolIcon->SetVisible( true );
		}
	}
	else if ( bGreyOut )
	{
		if( pItemPanel->IsSelected() )
		{
			pszBorder = g_szItemBorders[iRarity][4];
		}
		else
		{
			pszBorder = g_szItemBorders[iRarity][3];
		}
	}
	else
	{
		
		if ( pItemPanel->IsSelected() )
		{
			pszBorder = g_szItemBorders[iRarity][2];
		}
		else if ( bMouseOver )
		{
			pszBorder = g_szItemBorders[iRarity][1];
		}
		else
		{
			pszBorder = g_szItemBorders[iRarity][0];
		}
	}

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

//-----------------------------------------------------------------------------
class CTFRemoveItemCustomizationConfirmDialog : public CTFGenericConfirmDialog
{
	DECLARE_CLASS_SIMPLE( CTFRemoveItemCustomizationConfirmDialog, CTFGenericConfirmDialog );
public:
	CTFRemoveItemCustomizationConfirmDialog( const RefurbishableProperty& prop, CEconItemView *pItem )
		: CTFGenericConfirmDialog( prop.m_szDialogTitle,	// dialog title
								   prop.m_szDialogDesc,		// dialog text
								   "#RefurbishItem_Yes",	// confirm button text
								   "#RefurbishItem_No",		// cancel button text
								   NULL,					// callback
								   NULL )					// parent
		, m_prop( prop )
		, m_Item( *pItem )									// copy in case our UI changes behind us
	{
		GetCustomDialogLocalizationTokenFunc_t m_pDialogCustomTokenFunc = m_prop.m_pGetCustomDialogLocalizationTokenFunc;
		if ( m_pDialogCustomTokenFunc )
		{
			CUtlConstWideString wsDialogCustomToken;
			(*m_pDialogCustomTokenFunc)( &m_Item, m_prop.m_iUserData, wsDialogCustomToken );
			if ( !wsDialogCustomToken.IsEmpty() )
			{
				AddStringToken( "confirm_dialog_token", wsDialogCustomToken.Get() );
			}
		}
	}

	virtual ~CTFRemoveItemCustomizationConfirmDialog() { }

	virtual void OnCommand( const char *command );

private:
	RefurbishableProperty m_prop;
	CEconItemView m_Item;
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void SendGCSimpleAttributeRemovalMessage( CEconItemView *pEconItemView, const char *szDesc, EGCItemMsg eItemMsg )
{
	EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, pEconItemView, szDesc );
	GCSDK::CProtoBufMsg<CMsgGCRemoveCustomizationAttributeSimple> msg( eItemMsg );
	msg.Body().set_item_id( pEconItemView->GetItemID() );
	GCClientSystem()->BSendMessage( msg );
}

void CTFRemoveItemCustomizationConfirmDialog::OnCommand( const char *command )
{
	BaseClass::OnCommand( command );

	// Did the user say "yes, remove this particular attribute"? If so, notify the GC. We can't
	// remove multiple attributes at a time because each removal will cause a new item to be created,
	// invalidating the item reference we've got in this dialog.
	if ( !Q_strnicmp( command, "confirm", 7 ) )
	{
		// remove the attribute
		switch( m_prop.m_eRemovalType )
		{
			case kCustomizationRemove_Paint:
				SendGCSimpleAttributeRemovalMessage( &m_Item, "paint", k_EMsgGCRemoveItemPaint );
				break;

			case kCustomizationRemove_Name:
			{
				EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, &m_Item, "name" );
				GCSDK::CGCMsg< MsgGCRemoveItemName_t > msg( k_EMsgGCRemoveItemName );
				msg.Body().m_unItemID = m_Item.GetItemID();
				msg.Body().m_bDescription = false;
				GCClientSystem()->BSendMessage( msg );
			}
			break;

			case kCustomizationRemove_Desc:
			{
				EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, &m_Item, "description" );
				GCSDK::CGCMsg< MsgGCRemoveItemName_t > msg( k_EMsgGCRemoveItemName );
				msg.Body().m_unItemID = m_Item.GetItemID();
				msg.Body().m_bDescription = true;
				GCClientSystem()->BSendMessage( msg );
			}
			break;

			case kCustomizationRemove_CustomTexture:
				SendGCSimpleAttributeRemovalMessage( &m_Item, "custom_texture", k_EMsgGCRemoveCustomTexture );
				break;

			case kCustomizationRemove_MakersMark:
				SendGCSimpleAttributeRemovalMessage( &m_Item, "makers_mark", k_EMsgGCRemoveMakersMark );
				break;
			
			case kCustomizationRemove_StrangePart:
			{
				Assert( m_prop.m_iUserData != kNoUserData );
				int iKillEaterAttrIndex = m_prop.m_iUserData;

				// What attribute did we select?
				const CEconItemAttributeDefinition *pAttrDef = GetKillEaterAttr_Type( iKillEaterAttrIndex );
				Assert( pAttrDef );

				// Make sure this item has this attribute.
				float fScoreType = kKillEaterEvent_PlayerKill;
				Verify( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( &m_Item, pAttrDef, &fScoreType ) || iKillEaterAttrIndex == 0 );
				
				// Dispatch message.
				EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, &m_Item, "strange_part" );
				GCSDK::CProtoBufMsg<CMsgGCRemoveStrangePart> msg( k_EMsgGCRemoveStrangePart );
				
				msg.Body().set_item_id( m_Item.GetItemID() );
				msg.Body().set_strange_part_score_type( (int)fScoreType );
				GCClientSystem()->BSendMessage( msg );
			}
			break;

			case kCustomizationRemove_StrangeScores:
			{
				Assert( m_prop.m_iUserData == kNoUserData );

				EconUI()->Gamestats_ItemTransaction( IE_ITEM_RESET_STRANGE_COUNTERS, &m_Item );
				GCSDK::CProtoBufMsg<CMsgGCResetStrangeScores> msg( k_EMsgGCResetStrangeScores );
				msg.Body().set_item_id( m_Item.GetItemID() );
				GCClientSystem()->BSendMessage( msg );
			}
			break;

			case kCustomizationRemove_UpgradeCard:
				{
					Assert( m_prop.m_iUserData != kNoUserData );
				
					// Make sure we selected a valid attribute that this item has.
					const CEconItemAttributeDefinition *pAttrDef = GetCardUpgradeForIndex( &m_Item, m_prop.m_iUserData );
					Assert( pAttrDef );
					Verify( m_Item.FindAttribute( pAttrDef ) );
				
					// Dispatch message.
					EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, &m_Item, "upgrade_card" );
					GCSDK::CProtoBufMsg<CMsgGCRemoveUpgradeCard> msg( k_EMsgGCRemoveUpgradeCard );
				
					msg.Body().set_item_id( m_Item.GetItemID() );
					msg.Body().set_attribute_index( pAttrDef->GetDefinitionIndex() );
					GCClientSystem()->BSendMessage( msg );
				}
				break;

			case kCustomizationRemove_KillStreak:
				SendGCSimpleAttributeRemovalMessage( &m_Item, "killstreak", k_EMsgGCRemoveKillStreak );
				break;
			case kCustomizationRemove_GiftedBy:
				SendGCSimpleAttributeRemovalMessage( &m_Item, "giftedby", k_EMsgGCRemoveGiftedBy );
				break;
			case kCustomizationRemove_Festivizer:
				SendGCSimpleAttributeRemovalMessage( &m_Item, "festivizer", k_EMsgGCRemoveFestivizer );
				break;
			default:
				AssertMsg( false, "Unknown item customization removal type!" );
				break;
		}
	}

	SetVisible( false );
	MarkForDeletion();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
class CRefurbishItemDialog : public CComboBoxBackpackOverlayDialogBase
{
public:
	DECLARE_CLASS_SIMPLE( CRefurbishItemDialog, CComboBoxBackpackOverlayDialogBase );

public:
	CRefurbishItemDialog( vgui::Panel *pParent, CEconItemView *m_pItem ) : CComboBoxBackpackOverlayDialogBase( pParent, m_pItem ) { }

private:
	virtual void PopulateComboBoxOptions()
	{
		Assert( m_pItem );

		KeyValues *pKeyValues = new KeyValues( "data" );
		for ( int i = 0; i < GetRemovableAttributesCount(); i++ )
		{
			if ( RemovableAttributes_DoesAttributeApply( i, m_pItem ) )
			{
				pKeyValues->SetInt( "data", i );

				RefurbishableProperty prop = RemovableAttributes_GetAttributeDetails( i );

				CUtlConstWideString wsDialogCustomToken;
				if ( prop.m_pGetCustomDialogLocalizationTokenFunc )
				{
					(*prop.m_pGetCustomDialogLocalizationTokenFunc)( m_pItem, prop.m_iUserData, wsDialogCustomToken );
				}
				CConstructLocalizedString localizedUI( GLocalizationProvider()->Find( prop.m_pszSelectionUILocalizationToken ), wsDialogCustomToken.IsEmpty() ? L"" : wsDialogCustomToken.Get() );
				GetComboBox()->AddItem( localizedUI, pKeyValues );
			}
		}
		pKeyValues->deleteThis();

		Assert( GetComboBox()->GetItemCount() > 0 );

		GetComboBox()->ActivateItemByRow( 0 );
	}

	virtual void OnComboBoxApplication()
	{
		if ( !m_pItem )
			return;

		KeyValues *pKVActiveUserData = GetComboBox()->GetActiveItemUserData();
		int iIndex = pKVActiveUserData ? pKVActiveUserData->GetInt( "data", -1 ) : -1;
		if ( iIndex < 0 )
			return;

		const RefurbishableProperty RefurbProp = RemovableAttributes_GetAttributeDetails( iIndex );

		CTFRemoveItemCustomizationConfirmDialog *pDialog = new CTFRemoveItemCustomizationConfirmDialog( RefurbProp, m_pItem );
		if ( pDialog )
		{
			pDialog->Show();
		}
	}

	virtual const char *GetTitleLabelLocalizationToken() const { return "#TF_Item_RefurbishItemHeader"; }
};


//-----------------------------------------------------------------------------
// Purpose: Handles item selection while in tool selection mode
//-----------------------------------------------------------------------------
void CBackpackPanel::HandleToolItemSelection( CEconItemView *pItem )
{
	if ( !InToolSelectionMode() )
	{
		// must be in tool selection mode
		Assert( InToolSelectionMode() );
		return;
	}

	if ( pItem )
	{
		// Check if we should bring up the shuffle dialog instead of directly using the tool
		static CSchemaAttributeDefHandle pAttrDef_CanShuffleCrateContents( "can shuffle crate contents" );
		if ( pItem->FindAttribute( pAttrDef_CanShuffleCrateContents ) )
		{
			CInputStringForItemBackpackOverlayDialog *pDialog = vgui::SETUP_PANEL( new CInputStringForItemBackpackOverlayDialog( this, pItem, &m_ToolSelectionItem ) );
			if ( pDialog )
			{
				pDialog->Show();
				CancelToolSelection();
			}
		}
		else if ( m_ToolSelectionItem.FindAttribute( pAttrDef_CanShuffleCrateContents ) )
		{
			CInputStringForItemBackpackOverlayDialog *pDialog = vgui::SETUP_PANEL( new CInputStringForItemBackpackOverlayDialog( this, &m_ToolSelectionItem, pItem ) );
			if ( pDialog )
			{
				pDialog->Show();
				CancelToolSelection();
			}
		}
		// is a tool being applied onto this item
		else if ( m_ToolSelectionItem.GetStaticData()->IsTool() && ApplyTool( this, &m_ToolSelectionItem, pItem ) )
		{
			CancelToolSelection();
			UpdateModelPanels();
		}
		// is this item a tool that can be applied on a selected item
		else if ( pItem->GetStaticData()->IsTool() && ApplyTool( this, pItem, &m_ToolSelectionItem ) )
		{
			CancelToolSelection();
			UpdateModelPanels();
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Tries to use the item. This might switch the panel to a tool item
//			selection mode, or launch the recipe crafting panel.
//-----------------------------------------------------------------------------
void CBackpackPanel::SetupToolSelectionItem()
{
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
		{
			m_ToolSelectionItem = *m_pItemModelPanels[i]->GetItem();
			break;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Open up the trade dialog
//-----------------------------------------------------------------------------
void CBackpackPanel::DoTradeToPlayer()
{
	OpenTradingStartDialog( this );
}

//-----------------------------------------------------------------------------
// Purpose: Use the trade dialog to send a gift to a player.
//-----------------------------------------------------------------------------
void CBackpackPanel::DoGiftToPlayer()
{
	OpenTradingStartDialog( this, &m_ToolSelectionItem );
}

//-----------------------------------------------------------------------------
// Purpose: Open up the overlay to sell the selected item
//-----------------------------------------------------------------------------
void CBackpackPanel::DoSellMarketplace()
{
	CUtlVector< CItemModelPanel* > m_vecSelected;
	GetSelectedPanels( SELECT_FIRST, m_vecSelected );
	Assert( m_vecSelected.Count() );
	if( !m_vecSelected.Count() )
		return;

	if ( m_vecSelected.Count() && steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUtils() )
	{
		CEconItemView *pItem = m_vecSelected.Head()->GetItem();
		const char *pszPrefix = "";
		if ( GetUniverse() == k_EUniverseBeta )
		{
			pszPrefix = "beta.";
		}
		uint32 nAssetContext = 2; // k_EEconContextBackpack
		char szURL[512];
		V_snprintf( szURL, sizeof(szURL), "http://%ssteamcommunity.com/my/inventory/?sellOnLoad=1#%d_%d_%llu", pszPrefix, engine->GetAppID(), nAssetContext, pItem->GetItemID() );
		steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( szURL );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Use a description tag, or offer to buy one
//-----------------------------------------------------------------------------
void CBackpackPanel::DoDescription()
{
	static CSchemaItemDefHandle pItemDef_DescTag( "Description Tag" );
	if ( !AttemptToUseItem( pItemDef_DescTag->GetDefinitionIndex() ) )
	{
		AttemptToShowItemInStore( pItemDef_DescTag->GetDefinitionIndex() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Use a name tag, or offer to buy one
//-----------------------------------------------------------------------------
void CBackpackPanel::DoRename()
{
	static CSchemaItemDefHandle pItemDef_NameTag( "Name Tag" );
	if ( !AttemptToUseItem( pItemDef_NameTag->GetDefinitionIndex() ) )
	{
		AttemptToShowItemInStore( pItemDef_NameTag->GetDefinitionIndex() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Delete the selected items
//-----------------------------------------------------------------------------
void CBackpackPanel::DoDelete()
{
	// Hide the mouseover panel
	HideMouseOverPanel();

	int iItemsToDelete = 0;
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
		{
			iItemsToDelete++;
		}
	}

	// Bring up confirm dialog
	CConfirmDeleteItemDialog *pConfirm = vgui::SETUP_PANEL( new CConfirmDeleteItemDialog( this, ( iItemsToDelete > 1 ) ) );
	if ( pConfirm )
	{
		pConfirm->Show();

		m_pConfirmDeleteDialog = pConfirm;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Use the selected tool
//-----------------------------------------------------------------------------
void CBackpackPanel::DoApplyOnItem()
{
	SetupToolSelectionItem();

	if ( m_ToolSelectionItem.IsValid() )
	{
		const IEconTool *pEconTool = m_ToolSelectionItem.GetItemDefinition()->GetEconTool();

		// Gather all quest objective attributes
		CRecipeComponentMatchingIterator recipeIterator( NULL, NULL );
		if ( m_ToolSelectionItem.GetSOCData() )
		{
			m_ToolSelectionItem.GetSOCData()->IterateAttributes( &recipeIterator );
		}

		if( pEconTool && recipeIterator.GetMatchingComponentInputs().Count() > 0 )
		{
			// Launch new crafting window if we need to
			if( m_pDynamicRecipePanel == NULL )
			{
				m_pDynamicRecipePanel = vgui::SETUP_PANEL( new CDynamicRecipePanel( this, "dynamic_recipe_panel", &m_ToolSelectionItem ) );
			}

			// Set recipe item into panel
			if ( m_pDynamicRecipePanel )
			{
				m_pDynamicRecipePanel->SetVisible( true );
				m_pDynamicRecipePanel->SetNewRecipe( &m_ToolSelectionItem );
			}
			return;
		}

		// Check if we actually have any items we can use this tool on
		bool bHasValidTargetItem = false;
		CPlayerInventory *pInv = InventoryManager()->GetLocalInventory();
		Assert( pInv );
		if ( pInv )
		{
			for ( int i = 0 ; i < pInv->GetItemCount() ; ++i )
			{
				CEconItemView *pItem = pInv->GetItem( i );
				if ( CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, pItem ) )
				{
					bHasValidTargetItem = true;
					break;
				}
			}

			// If no applicable items, try stock items
			if ( !bHasValidTargetItem )
			{
				// this is really inefficient, maybe have a list of baseitems somewhere
				CEconItemView tempItem;
				const CEconItemDefinition* pItemDef = NULL;

				const CEconItemSchema::SortedItemDefinitionMap_t& mapItems = GetItemSchema()->GetSortedItemDefinitionMap();
				for ( int it = mapItems.FirstInorder(); it != mapItems.InvalidIndex(); it = mapItems.NextInorder( it ) )
				{
					if ( mapItems[it]->IsBaseItem() && !mapItems[it]->IsHidden() )
					{
						CFmtStr fmtStrCustomizedDefName( "Upgradeable %s", mapItems[it]->GetDefinitionName() );
						pItemDef = GetItemSchema()->GetItemDefinitionByName( fmtStrCustomizedDefName.Access() );
						if ( pItemDef )
						{
							tempItem.Init( pItemDef->GetDefinitionIndex(), AE_UNIQUE, AE_USE_SCRIPT_VALUE, true );
							if ( CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, &tempItem ) )
							{
								bHasValidTargetItem = true;
								break;
							}
						}
					}
				}

				if ( bHasValidTargetItem )
				{
					// automatically switch to stock items
					OnCommand( "showbaseitems" );
				}
			}
		}

		if ( !bHasValidTargetItem )
		{
			ShowMessageBox( NULL, "#ToolNoTargetItems", "#GameUI_OK" );
			return;
		}

		m_eSelectionMode = ToolSelection;
		m_nLastToolPage = GetCurrentPage();

		if ( m_pMouseOverTooltip )
		{
			m_pMouseOverTooltip->HideTooltip();
		}

		ClearNameFilter( true );
		SetCurrentPage( 0 );
		UpdateModelPanels();
	}
}

//-----------------------------------------------------------------------------
// Purpose: use a consumable item directly from the backpack
//-----------------------------------------------------------------------------
void CBackpackPanel::DoUseConsumableItem()
{
	SetupToolSelectionItem();

#ifdef TF_CLIENT_DLL
	UseConsumableItem( &m_ToolSelectionItem, this );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Use the tool to unwrap an item
//-----------------------------------------------------------------------------
void CBackpackPanel::DoUnwrapItem()
{
	DoUseConsumableItem();
}

//-----------------------------------------------------------------------------
// Purpose: Use the tool to deliver an item
//-----------------------------------------------------------------------------
void CBackpackPanel::DoDeliverItem()
{
	SetupToolSelectionItem();

#ifdef TF_CLIENT_DLL
	const CEconTool_WrappedGift *pWrappedGiftTool = m_ToolSelectionItem.GetItemDefinition()
												  ? m_ToolSelectionItem.GetItemDefinition()->GetTypedEconTool<CEconTool_WrappedGift>()
												  : NULL;

	if ( pWrappedGiftTool && pWrappedGiftTool->BIsDirectGift() )
	{
		DoUseConsumableItem();
		return;
	}
	else if ( pWrappedGiftTool && pWrappedGiftTool->BIsGlobalGift() )
	{
		// If this is a global gift, we don't let the user pick a target so we're done as of now.
		extern void UseUntargetedGiftConfirm( bool bConfirmed, void *pContext );
		CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#TF_DeliverGiftDialog_Title", "#TF_DeliverGiftDialog_Random_Text", 
														      "#TF_DeliverGiftDialog_Confirm", "#TF_DeliverGiftDialog_Cancel", 
														      &UseUntargetedGiftConfirm );

		pDialog->SetContext( &m_ToolSelectionItem );
		return;
	}

	DoGiftToPlayer();
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Show
//-----------------------------------------------------------------------------
void CBackpackPanel::DoApplyByItem()
{
	SetupToolSelectionItem();

	m_eSelectionMode = ToolSelection;
	m_nLastToolPage = GetCurrentPage();

	if ( m_pMouseOverTooltip )
	{
		m_pMouseOverTooltip->HideTooltip();
	}

	ClearNameFilter( true );
	SetCurrentPage( 0 );
	UpdateModelPanels();
}

//-----------------------------------------------------------------------------
// Purpose: open shuffle items dialog
//-----------------------------------------------------------------------------
void CBackpackPanel::DoShuffle()
{
	SetupToolSelectionItem();

	CInputStringForItemBackpackOverlayDialog *pDialog = vgui::SETUP_PANEL( new CInputStringForItemBackpackOverlayDialog( this, &m_ToolSelectionItem ) );
	if ( pDialog )
	{
		pDialog->Show();
	}
}

void CBackpackPanel::DoEditSlot()
{
	SetupToolSelectionItem();

	// Launch new slot window if we need to
	if( m_pItemSlotPanel == NULL )
	{
		m_pItemSlotPanel = vgui::SETUP_PANEL( new CItemSlotPanel( this ) );
	}
				
	// Set item into panel
	if ( m_pItemSlotPanel )
	{
		m_pItemSlotPanel->SetVisible( true );
		m_pItemSlotPanel->SetItem( m_ToolSelectionItem.GetSOCData() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Refurbish item
//-----------------------------------------------------------------------------
void CBackpackPanel::DoRefurbishItem()
{
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
		{
			m_ComboBoxOverlaySelectionItem = *m_pItemModelPanels[i]->GetItem();
			break;
		}
	}

	CRefurbishItemDialog *pRefurbishDialog = vgui::SETUP_PANEL( new CRefurbishItemDialog( this, &m_ComboBoxOverlaySelectionItem ) );
	if ( pRefurbishDialog )
	{
		pRefurbishDialog->Show();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Deode by item
//-----------------------------------------------------------------------------
void CBackpackPanel::DoGetItemFromStore()
{
	SetupToolSelectionItem();

	uint32 iDecoableItemDef = 0;
	if ( GetDecodedByItemDefIndex( &m_ToolSelectionItem, &iDecoableItemDef ) )
	{
		// casting to the proper type since our econ system is dumb
		const float& value_as_float = (float&)iDecoableItemDef;
		CEconItemDefinition * pDefIndex = GetItemSchema()->GetItemDefinition( (int)value_as_float );

		EconUI()->GetStorePanel()->AddToCartAndCheckoutImmediately( pDefIndex->GetDefinitionIndex() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Open End of the Line duck leaderboards
//-----------------------------------------------------------------------------
void CBackpackPanel::DoOpenDuckLeaderboards()
{
	CCharacterInfoPanel* pCharInfo = dynamic_cast< CCharacterInfoPanel* >( EconUI() );
	CDucksLeaderboardManager *pDuckLeaderboards = vgui::SETUP_PANEL( new CDucksLeaderboardManager( pCharInfo, "DucksLeaderboardPanel" ) );
	pDuckLeaderboards->SetVisible( true );
}

//-----------------------------------------------------------------------------
// Strange Count Transfer Dialog
//-----------------------------------------------------------------------------
void CBackpackPanel::DoStrangeCountTransfer()
{
	CUtlVector< CItemModelPanel* > vecSelected;
	GetSelectedPanels( SELECT_FIRST, vecSelected );

	Assert( vecSelected.Count() );
	if ( vecSelected.IsEmpty() )
		return;

	m_pStrangeToolPanel = vgui::SETUP_PANEL( new CStrangeCountTransferPanel( this, vecSelected[0]->GetItem() ) );
}

//-----------------------------------------------------------------------------
// Collection crafting
//-----------------------------------------------------------------------------
void CBackpackPanel::DoCraftUpCollection()
{
	CUtlVector< CItemModelPanel* > vecSelected;
	GetSelectedPanels( SELECT_ALL, vecSelected );

	//Assert( vecSelected.Count() );
	//if ( vecSelected.IsEmpty() )
	//	return;

	// Get all the items that were selected
	CUtlVector< const CEconItemView* > vecSelectedItems;
	FOR_EACH_VEC( vecSelected, i )
	{
		if ( vecSelected[ i ]->GetItem() && GetCollectionCraftingInvalidReason( vecSelected[ i ]->GetItem(), NULL ) == NULL )
		{
			vecSelectedItems.AddToTail( vecSelected[ i ]->GetItem() );
		}
	}

	// For tracking how many times they've opened this menu
	tf_trade_up_use_count.SetValue( tf_trade_up_use_count.GetInt() - 1 );

	// Open it up!
	GetCollectionCraftPanel()->Show( vecSelectedItems );
}

//-----------------------------------------------------------------------------
// Collection crafting
//-----------------------------------------------------------------------------
void CBackpackPanel::DoHalloweenOffering()
{
	// Open it up!
	if ( !m_pHalloweenOfferingPanel )
	{
		m_pHalloweenOfferingPanel = vgui::SETUP_PANEL( new CHalloweenOfferingPanel( this, m_pMouseOverTooltip ) );
		m_pHalloweenOfferingPanel->InvalidateLayout( true, true );
	}
		// empty
	CUtlVector< const CEconItemView* > vecSelectedItems;
	m_pHalloweenOfferingPanel->Show( vecSelectedItems );
}

//-----------------------------------------------------------------------------
// Craft Common StatClock
//-----------------------------------------------------------------------------
void CBackpackPanel::DoCraftCommonStatClock()
{
	// Open it up!
	if ( !m_pMannCoTradePanel )
	{
		m_pMannCoTradePanel = vgui::SETUP_PANEL( new CCraftCommonStatClockPanel( this, m_pMouseOverTooltip ) );		// make this more generic
		m_pMannCoTradePanel->InvalidateLayout( true, true );
	}

	CUtlVector< CItemModelPanel* > vecSelected;
	GetSelectedPanels(SELECT_ALL, vecSelected);

	CUtlVector< const CEconItemView* > vecSelectedItems;
	FOR_EACH_VEC(vecSelected, i)
	{
		if (vecSelected[i]->GetItem() && GetCraftCommonStatClockInvalidReason(vecSelected[i]->GetItem(), NULL) == NULL)
		{
			vecSelectedItems.AddToTail(vecSelected[i]->GetItem());
		}
	}

	m_pMannCoTradePanel->Show( vecSelectedItems );
}

//-----------------------------------------------------------------------------
// Purpose: Bring up the 3D inspect panel for the selected item
//-----------------------------------------------------------------------------
void CBackpackPanel::DoInspectModel()
{
	CUtlVector< CItemModelPanel* > vecSelected;
	GetSelectedPanels( SELECT_FIRST, vecSelected );

	if ( vecSelected.IsEmpty() )
		return;

	CEconItemView *pItem = vecSelected[0]->GetItem();
	if ( pItem )
	{
		float flInspect = 0;
		static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
		if ( ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttrib_WeaponAllowInspect, &flInspect ) && flInspect != 0.f )
#ifdef STAGING_ONLY
			|| tf_weapon_force_allow_inspect.GetBool()
#endif
			)
		{
			m_pInspectPanel->SetVisible( true );
			m_pInspectPanel->SetItemCopy( vecSelected[0]->GetItem() );
		}
		else
		{
			for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; ++iClass )
			{
				if ( pItem->GetStaticData()->CanBeUsedByClass( iClass ) )
				{
					m_pInspectCosmeticPanel->PreviewItem( iClass, pItem );
					break;
				}
			}
			m_pInspectCosmeticPanel->SetVisible( true );
		}
	}
}
//-----------------------------------------------------------------------------
void CBackpackPanel::OpenInspectModelPanelAndCopyItem( CEconItemView *pItemView )
{
	if ( !pItemView )
		return;

	EconUI()->OpenEconUI( ECONUI_BACKPACK );

	// Figure out which preview to show
	float flInspect = 0;
	static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
	if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItemView, pAttrib_WeaponAllowInspect, &flInspect ) && flInspect != 0.f )
	{
		m_pInspectPanel->SetVisible( true );
		m_pInspectPanel->SetItemCopy( pItemView );
	}
	else
	{
		for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; ++iClass )
		{
			if ( pItemView->GetStaticData()->CanBeUsedByClass( iClass ) )
			{
				m_pInspectCosmeticPanel->PreviewItemCopy( iClass, pItemView );
				m_pInspectCosmeticPanel->SetVisible( true );
				break;
			}
		}
	}
}

CCollectionCraftingPanel* CBackpackPanel::GetCollectionCraftPanel()
{
	if ( !m_pCollectionCraftPanel )
	{
		m_pCollectionCraftPanel = vgui::SETUP_PANEL( new CCollectionCraftingPanel( this, m_pMouseOverTooltip ) );
		m_pCollectionCraftPanel->InvalidateLayout( true, true );
	}

	return m_pCollectionCraftPanel;
}

//-----------------------------------------------------------------------------
// Purpose: Buy a key, and then immediately use it on the selected crate once
//			tbe store transaction completes
//-----------------------------------------------------------------------------
void CBackpackPanel::DoBuyKeyAndOpenCrate()
{
	CUtlVector< CItemModelPanel* > vecSelected;
	GetSelectedPanels( SELECT_FIRST, vecSelected );

	if ( vecSelected.IsEmpty() )
		return;

	m_hQuickOpenCrate.SetItem( vecSelected.Head()->GetItem() );

	uint32 iDecoableItemDef = 0;
	if ( GetDecodedByItemDefIndex( m_hQuickOpenCrate, &iDecoableItemDef ) )
	{
		// casting to the proper type since our econ system is dumb
		const float& value_as_float = (float&)iDecoableItemDef;
		CEconItemDefinition * pDefIndex = GetItemSchema()->GetItemDefinition( (int)value_as_float );

		EconUI()->GetStorePanel()->AddToCartAndCheckoutImmediately( pDefIndex->GetDefinitionIndex() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Find the first compatible key in our inventory, and use it on the
//			selected crate
//-----------------------------------------------------------------------------
void CBackpackPanel::DoOpenCrateWithKey()
{
	CUtlVector< CItemModelPanel* > vecSelected;
	GetSelectedPanels( SELECT_FIRST, vecSelected );

	if ( vecSelected.IsEmpty() )
		return;

	CEconItemView *pCrate = vecSelected.Head()->GetItem();

	CEconItemView *pKey = GetFirstCompatibleKeyForCrate( pCrate );
	if ( !pKey )
		return;

	ApplyTool( this, pKey, pCrate );
}


//-----------------------------------------------------------------------------
// Purpose: Open up the loadout for a class
//-----------------------------------------------------------------------------
void CBackpackPanel::DoEquipForClass( int nClass )
{
	// Negative because reasons
	EconUI()->OpenEconUI( -nClass );	
}

//-----------------------------------------------------------------------------
// Purpose: Given a paint can index, offer to use one or buy one
//-----------------------------------------------------------------------------
void CBackpackPanel::DoPaint( int nPaintItemIndex, bool bUseStore, bool bUseMarket )
{
	if ( !bUseStore && !bUseMarket )
	{
		AttemptToUseItem( nPaintItemIndex );
	}

	if ( bUseStore )
	{
		AttemptToShowItemInStore( nPaintItemIndex );
	}
	else if ( bUseMarket )
	{
		AttemptToShowItemInMarket( nPaintItemIndex );
	}
}
//-----------------------------------------------------------------------------
// Purpose: Given a strange part index, offer to use one or buy one (Market)
//-----------------------------------------------------------------------------
void CBackpackPanel::DoStrangePart( int nStrangePartIndex, bool bUseMarket )
{
	if ( !bUseMarket )
	{
		AttemptToUseItem( nStrangePartIndex );
	}

	if ( bUseMarket )
	{
		AttemptToShowItemInMarket( nStrangePartIndex );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Try to find the first item with the passed-in item name in our inventory
//			and try to use it on the selected panel's item.  If we dont have an item
//			matching the name passed in, go to the store and prompt the user to buy one.
//-----------------------------------------------------------------------------
bool CBackpackPanel::AttemptToUseItem( item_definition_index_t iItemDefIndex )
{
	CUtlVector< CItemModelPanel* > m_vecSelected;
	GetSelectedPanels( SELECT_FIRST, m_vecSelected );
	Assert( m_vecSelected.Count() );
	if ( !m_vecSelected.Count() )
		return false;

	CEconItemView *pSelectedItem = m_vecSelected.Head()->GetItem();
	Assert( pSelectedItem );
	if ( !pSelectedItem )
		return false;

	CEconItemView *pNameTag = CTFPlayerInventory::GetFirstItemOfItemDef( iItemDefIndex );
	if ( pNameTag )
	{
		if ( ApplyTool( this, pNameTag, pSelectedItem ) )
		{
			CancelToolSelection();
			UpdateModelPanels();
		}
		return true;
	}
	return false;
}
//-----------------------------------------------------------------------------
void CBackpackPanel::AttemptToShowItemInStore( item_definition_index_t iItemDefIndex )
{
	CUtlVector< CItemModelPanel* > m_vecSelected;
	GetSelectedPanels( SELECT_FIRST, m_vecSelected );
	Assert( m_vecSelected.Count() );
	if( !m_vecSelected.Count() )
		return;

	CEconItemView *pSelectedItem = m_vecSelected.Head()->GetItem();
	Assert( pSelectedItem );
	if ( !pSelectedItem )
		return;

	EconUI()->OpenStorePanel( iItemDefIndex, false );
}
//-----------------------------------------------------------------------------
void CBackpackPanel::AttemptToShowItemInMarket( item_definition_index_t iItemDefIndex )
{
	CUtlVector< CItemModelPanel* > m_vecSelected;
	GetSelectedPanels( SELECT_FIRST, m_vecSelected );
	Assert( m_vecSelected.Count() );
	if ( !m_vecSelected.Count() )
		return;

	CEconItemView *pSelectedItem = m_vecSelected.Head()->GetItem();
	Assert( pSelectedItem );
	if ( !pSelectedItem )
		return;

	CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinition( iItemDefIndex );
	Assert( pItemDef );
	if ( !pItemDef )
		return;

	if ( !CBaseAdPanel::CheckForRequiredSteamComponents( "#StoreUpdate_SteamRequired", "#MMenu_OverlayRequired" ) )
		return;

	if ( pItemDef && steamapicontext && steamapicontext->SteamFriends() )
	{
		const char *pszPrefix = "";
		if ( GetUniverse() == k_EUniverseBeta )
		{
			pszPrefix = "beta.";
		}

		static char pszItemName[256];
		g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pItemDef->GetItemBaseName() ), pszItemName, sizeof( pszItemName ) );

		char szURL[512];
		V_snprintf( szURL, sizeof( szURL ), "http://%ssteamcommunity.com/market/listings/%d/%s", pszPrefix, engine->GetAppID(), pszItemName );
		steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( szURL );
	}
}
//-----------------------------------------------------------------------------
// Purpose: Get the first, or all selected item model panels
//-----------------------------------------------------------------------------
void CBackpackPanel::GetSelectedPanels( ESelection eSelection, CUtlVector< CItemModelPanel* >& m_vecSelected ) const
{
	for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
	{
		if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
		{
			m_vecSelected.AddToTail( m_pItemModelPanels[i] );

			if ( eSelection == SELECT_FIRST )
			{
				return;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OnCommand( const char *command )
{
	if ( V_strncasecmp( command, "goto_page_", V_strlen( "goto_page_" ) ) == 0 )
	{
		int iPage = V_atoi( &command[ V_strlen( "goto_page_" ) ] );
		SetCurrentPage( iPage );
		UpdateModelPanels();
		return;
	}
	else if ( !Q_strnicmp( command, "nextpage", 8 ) )
	{
		if ( !m_bDragging )
		{
			DeSelectAllBackpackItemPanels();
		}

		SetCurrentPage( GetCurrentPage() + 1 );
		UpdateModelPanels();
		return;
	}
	else if ( !Q_strnicmp( command, "prevpage", 8 ) )
	{
		if ( !m_bDragging )
		{
			DeSelectAllBackpackItemPanels();
		}

		SetCurrentPage( GetCurrentPage() - 1 );
		UpdateModelPanels();
		return;
	}
	else if ( !Q_strnicmp( command, "useitem", 7 ) )
	{
		AssertMsg( 0, "Everything should be going through the context menu. Fix the calling code." );
		return;
	}
	else if ( !Q_strnicmp( command, "showbackpackitems", 17 ) )
	{
		SetShowBaseItems( false );
		if ( m_pShowBaseItemsCheckbox )
		{
			m_pShowBaseItemsCheckbox->SetSelected( false );
		}
		return;
	}
	else if ( !Q_strnicmp( command, "showbaseitems", 13 ) )
	{
		SetShowBaseItems( true );
		if ( m_pShowBaseItemsCheckbox )
		{
			m_pShowBaseItemsCheckbox->SetSelected( true );
		}
		return;
	}
	else if ( !Q_strnicmp( command, "canceltool", 10 ) )
	{
		CancelToolSelection();
		UpdateModelPanels();
		return;
	}
	else if ( !Q_stricmp( command, "show_explanations" ) )
	{
		if ( !m_flStartExplanationsAt )
		{
			m_flStartExplanationsAt = Plat_FloatTime();
			vgui::ivgui()->AddTickSignal( GetVPanel() );
		}
		RequestFocus();
	}
	else if ( !Q_stricmp( command, "showdetails" ) )
	{
		for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
		{
			if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
			{
				OpenArmory( m_pItemModelPanels[i]->GetItem() );
				break;
			}
		}
		UpdateModelPanels();
		return;
	}
	else if ( !V_strnicmp( command, "equipclass", 10 ) )
	{
		int nClass = atoi( command + 10 );
		DoEquipForClass( nClass );
	}
	else if ( !V_strnicmp( command, "paint", 5 ) )
	{
		int nIndex = atoi( command + 5 );
		DoPaint( nIndex, false, false );
	}
	else if ( !V_strnicmp( command, "market_paint", 12 ) )
	{
		int nIndex = atoi( command + 12 );
		DoPaint( nIndex, false, true );
	}
	else if ( !V_strnicmp( command, "store_paint", 11 ) )
	{
		int nIndex = atoi( command + 11 );
		DoPaint( nIndex, true, false );
	}
	else if ( !V_strnicmp( command, "strangepart_", 12 ) )
	{
		int nIndex = atoi( command + 12 );
		DoStrangePart( nIndex, false );
	}
	else if ( !V_strnicmp( command, "market_strangepart_", 19 ) )
	{
		int nIndex = atoi( command + 19 );
		DoStrangePart( nIndex, true );
	}
	else if ( !V_strnicmp( command, "Context_CraftUpCollection", 25 ) )
	{
		DoCraftUpCollection();
	}
	else if ( !V_strnicmp( command, "Context_CraftCommonStatClock", 25 ) )
	{
		DoCraftCommonStatClock();
	}
#ifdef STAGING_ONLY
	else if ( !V_strnicmp( command, "unpin", 5 ) )
	{
		m_pMouseOverCardPanel->PinCard( false );
	}
#endif

	BaseClass::OnCommand( command );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::OpenArmory( CEconItemView* item )
{
	PostMessage( GetParent()->GetParent()->GetParent(), new KeyValues("OpenArmoryDirect", "itemdef", item->GetItemDefIndex() ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::CancelToolSelection( void )
{
	if ( m_eSelectionMode == StandardSelection )
		return;

	m_eSelectionMode = StandardSelection;

	ClearNameFilter( false );

	OnCommand( "showbackpackitems" );

	SetCurrentPage( m_nLastToolPage );
	m_nLastToolPage = 0;

	m_ToolSelectionItem.Invalidate();
	if ( m_pToolIcon )
	{
		m_pToolIcon->SetVisible( false );
	}
	DeSelectAllBackpackItemPanels();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::SetShowBaseItems( bool bShow )
{
	bool bGoToFirstPage = m_bShowBaseItems != bShow;
	m_bShowBaseItems = bShow;
	if( bGoToFirstPage )
	{
		SetCurrentPage( 0 );
	}

	DeSelectAllBackpackItemPanels();
	if ( m_pToolIcon )
	{
		m_pToolIcon->SetVisible( false );
	}
	UpdateModelPanels();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
ConVar *CBackpackPanel::GetExplanationConVar( void )
{
	return &tf_explanations_backpackpanel;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBackpackPanel::SetCurrentPage( int nNewPage )
{
	if( m_pToolIcon )
	{
		m_pToolIcon->SetVisible( false );
	}

	if ( nNewPage < 0 )
	{
		nNewPage = GetNumPages() - 1;
	}
	else if ( nNewPage >= GetNumPages() )
	{
		nNewPage = 0;
	}

	// deselect old page button
	if ( m_Pages.Count() > GetCurrentPage() && m_Pages[GetCurrentPage()] )
	{
		CExButton* pButton = dynamic_cast<CExButton*>( m_Pages[GetCurrentPage()]->FindChildByName( "Button" ) );
		if ( pButton )
		{
			pButton->SetSelected( false );
		}
	}

	BaseClass::SetCurrentPage( nNewPage );

	// mark new page button as selected
	if ( m_Pages.Count() > GetCurrentPage() &&  m_Pages[GetCurrentPage()] )
	{
		CExButton* pButton = dynamic_cast<CExButton*>( m_Pages[GetCurrentPage()]->FindChildByName( "Button" ) );
		if ( pButton )
		{
			pButton->SetSelected( true );
		}
	}
}


int	CBackpackPanel::GetItemQualityForBorder( CItemModelPanel* pItemPanel ) const
{
	if ( pItemPanel->HasItem() && ( cl_showbackpackrarities.GetInt() > 0 || m_bForceShowBackpackRarities )
				   && ( cl_showbackpackrarities.GetInt() < 2 || pItemPanel->GetItem()->IsMarketable() ) )
	{
		uint8 nRarity = pItemPanel->GetItem()->GetItemDefinition()->GetRarity();
		if ( ( nRarity != k_unItemRarity_Any ) && ( pItemPanel->GetItem()->GetItemQuality() != AE_SELFMADE ) )
		{
			// translate this quality to rarity
			return nRarity + AE_RARITY_DEFAULT;
		}

		return pItemPanel->GetItem()->GetItemQuality();
	}

	return 0;
}