1HEADmaster

1 files changed, 2175 insertions, 0 deletions

diff --git a/game/client/econ/store/store_panel.cpp b/game/client/econ/store/store_panel.cpp
new file mode 100644
index 0000000..258a657
--- /dev/null
+++ b/game/client/econ/store/store_panel.cpp
@@ -0,0 +1,2175 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+
+#include "cbase.h"
+#include "store/store_panel.h"
+#include "vgui_controls/PropertySheet.h"
+#include "vgui/IInput.h"
+#include "baseviewport.h"
+#include "iclientmode.h"
+#include "ienginevgui.h"
+#include "econ_item_inventory.h"
+#include <vgui/ILocalize.h>
+#include "econ_item_system.h"
+#include "store_page_new.h"
+#include "store_viewcart.h"
+#include "confirm_dialog.h"
+#include <vgui_controls/AnimationController.h>
+#include "econ_ui.h"
+#include "gc_clientsystem.h"
+#include "steamworks_gamestats.h"
+#include "econ/econ_storecategory.h"
+
+#ifdef TF_CLIENT_DLL
+#include "tf_mapinfo.h"
+#include "c_tf_freeaccount.h"
+#include "tf_hud_statpanel.h"
+#include "rtime.h"
+#include "item_ad_panel.h"
+#include "tf_matchmaking_dashboard.h"
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+
+
+#ifdef TF_CLIENT_DLL
+// Dec 4st 2012
+#define TF_STORE_STAMP_UPSELL_BASELINE 1354579200
+// TEMP VALUE FOR TESTING! Nov 20th 2012
+//#define TF_STORE_STAMP_UPSELL_BASELINE 1353369600
+
+// 15 days
+#define TF_STORE_STAMP_UPSELL_COOLDOWN ( 60 /*sec*/ * 60 /*min*/ * 24 /*hr*/ * 7 /*day*/ )
+// TEMP VALUE FOR TESTING! 1 day
+//#define TF_STORE_STAMP_UPSELL_COOLDOWN ( 60 /*sec*/ * 60 /*min*/ * 24 /*hr*/ )
+
+#define TF_STORE_STAMP_UPSELL_GROUPS 15
+
+ConVar tf_store_stamp_donation_add_timestamp( "tf_store_stamp_donation_add_timestamp", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_ARCHIVE | FCVAR_HIDDEN, "Remember the last time that we offered a stamp donation at checkout." );
+#endif
+
+bool CStorePanel::m_bPricesheetLoaded = false;
+bool CStorePanel::m_bShowWarnings = false;
+
+class CServerNotConnectedToSteamDialog;
+CServerNotConnectedToSteamDialog *OpenServerNotConnectedToSteamDialog( vgui::Panel *pParent );
+
+class CStampUpsellDialog : public CTFGenericConfirmDialog
+{
+	DECLARE_CLASS_SIMPLE( CStampUpsellDialog, CTFGenericConfirmDialog );
+public:
+	CStampUpsellDialog( const char *pTitle, const wchar_t *pTextText, const wchar_t *pTextText2, CSchemaItemDefHandle hMapToken, const char *pItemDefName2 ) 
+		: CTFGenericConfirmDialog( pTitle, pTextText, NULL, NULL, NULL, NULL )
+		, hItemDef( hMapToken ), hItemDef2( pItemDefName2 )
+	{
+		V_wcsncpy( m_wszBuffer2, pTextText2, sizeof( m_wszBuffer2 ) );
+		m_flCreationTime = gpGlobals->curtime;
+	}
+
+	virtual const char *GetResFile() OVERRIDE
+	{
+		return "Resource/UI/StampDonationAdd.res";
+	}
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme ) OVERRIDE
+	{
+		BaseClass::ApplySchemeSettings(pScheme);
+
+		vgui::ImagePanel *pItemImagePanel = dynamic_cast<vgui::ImagePanel *>( FindChildByName( "ItemImagePanel", true ) ); Assert( pItemImagePanel );
+		if ( pItemImagePanel && hItemDef )
+		{
+			pItemImagePanel->SetImage( CFmtStr( "../%s_large", hItemDef->GetInventoryImage() ) );
+		}
+
+		vgui::ImagePanel *pItemImagePanel2 = dynamic_cast<vgui::ImagePanel *>( FindChildByName( "ItemImagePanel2", true ) ); Assert( pItemImagePanel );
+		if ( pItemImagePanel2 && hItemDef2 )
+		{
+			pItemImagePanel2->SetImage( CFmtStr( "../%s_large", hItemDef2->GetInventoryImage() ) );
+		}
+
+		// Now go through the string and find the escape characters telling us where the color changes are
+		ColorizeLabel( static_cast< vgui::Label* >( FindChildByName( "ExplanationLabel" ) ), m_wszBuffer );
+		ColorizeLabel( static_cast< vgui::Label* >( FindChildByName( "ExplanationLabel2" ) ), m_wszBuffer2 );
+
+		CEconItemView itemData;
+		itemData.Init( hItemDef->GetDefinitionIndex(), AE_UNIQUE, AE_USE_SCRIPT_VALUE, true );
+		itemData.SetItemQuantity( 1 );
+		itemData.SetClientItemFlags( kEconItemFlagClient_Preview | kEconItemFlagClient_StoreItem );
+
+		const ECurrency eCurrency = EconUI()->GetStorePanel()->GetCurrency();
+		const econ_store_entry_t *pEntry = EconUI()->GetStorePanel()->GetPriceSheet()->GetEntry( hItemDef->GetDefinitionIndex() );
+		item_price_t unPrice = pEntry->GetCurrentPrice( eCurrency );
+
+		wchar_t wzLocalizedPrice[ kLocalizedPriceSizeInChararacters ];
+		MakeMoneyString( wzLocalizedPrice, ARRAYSIZE( wzLocalizedPrice ), unPrice, EconUI()->GetStorePanel()->GetCurrency() );
+		SetDialogVariable( "price", wzLocalizedPrice );
+
+		Panel *pConfirmButton = FindChildByName( "ConfirmButton" );
+		pConfirmButton->RequestFocus();
+	}
+
+	virtual void OnCommand( const char *command ) OVERRIDE
+	{
+		int nSecondsVisible = gpGlobals->curtime - m_flCreationTime;
+		if ( V_strcmp( command, "add_stamp_to_cart" ) == 0 )
+		{
+			FinishUp();
+			CStorePanel::ConfirmUpsellStamps( true, hItemDef, nSecondsVisible );
+		}
+		else if ( V_strcmp( command, "nope" ) == 0 )
+		{
+			FinishUp();
+			CStorePanel::ConfirmUpsellStamps( false, hItemDef, nSecondsVisible );
+		}
+		else
+		{
+			BaseClass::OnCommand( command );
+		}		
+	}
+
+	virtual void OnKeyCodePressed( vgui::KeyCode code )
+	{
+		// ESC cancels
+		if ( code == KEY_XBUTTON_B )
+		{
+			OnCommand( "nope" );
+		}
+		else
+		{
+			BaseClass::OnKeyCodePressed( code );
+		}
+	}
+
+	void ColorizeLabel( vgui::Label *pLabel, wchar_t *txt )
+	{
+		if ( pLabel )
+		{
+			pLabel->GetTextImage()->ClearColorChangeStream();
+
+			// We change the title's text color to match the colors of the matching model panel backgrounds
+			int iWChars = 0;
+			Color colCustom;
+			while ( txt && *txt )
+			{
+				switch ( *txt )
+				{
+				case 0x01:	// Normal color
+					pLabel->GetTextImage()->AddColorChange( Color(200,80,60,255), iWChars );
+					break;
+				case 0x02:	// Item 1 color
+					pLabel->GetTextImage()->AddColorChange( Color(255,255,255,255), iWChars );
+					break;
+				default:
+					break;
+				}
+				txt++;
+				iWChars++;
+			}
+		}
+	}
+
+	CSchemaItemDefHandle hItemDef;
+	CSchemaItemDefHandle hItemDef2;
+
+	wchar_t m_wszBuffer2[1024];
+	float m_flCreationTime;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A dialog used to show the current state of store communication with steam.
+//-----------------------------------------------------------------------------
+class CStoreStatusDialog : public vgui::EditablePanel
+{
+	DECLARE_CLASS_SIMPLE( CStoreStatusDialog, vgui::EditablePanel );
+
+public:
+	CStoreStatusDialog( vgui::Panel *pParent, const char *pElementName );
+
+	virtual void	ApplySchemeSettings( vgui::IScheme *scheme );
+	virtual void	OnCommand( const char *command );
+	void			UpdateSchemeForVersion();
+	void			ShowStatusUpdate( bool bAllowed, bool bShowOnExit, bool bCancel );
+
+private:
+	bool			m_bShowOnExit;
+	bool			m_bNotifyOnCancel;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+static void ContactSupportConfirm( bool bConfirmed, void *pContext )
+{
+	if ( bConfirmed && steamapicontext && steamapicontext->SteamFriends() )
+	{
+		steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "https://support.steampowered.com/" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CStorePanel::CStorePanel( Panel *parent ) : PropertyDialog(parent, "store_panel")
+, m_CallbackMicroTransactionAuthResponse( this, &CStorePanel::OnMicroTransactionAuthResponse )
+{
+	// Store is parented to the game UI panel
+	vgui::VPANEL gameuiPanel = enginevgui->GetPanel( PANEL_GAMEUIDLL );
+	SetParent( gameuiPanel );
+
+	// We don't want the gameui to delete us, or things get messy
+	SetAutoDelete( false );
+
+	SetMoveable( false );
+	SetSizeable( false );
+
+	vgui::HScheme scheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme");
+	SetScheme(scheme);
+	SetProportional( true );
+
+	ListenForGameEvent( "gameui_hidden" );
+
+	m_unTransactionID = 0;
+	m_bShouldFinalize = false;
+	m_iStartItemDef = 0;
+	m_bAddStartItemDefToCart = false;
+	m_bPreventClosure = false;
+	m_bOGSLogging = false;
+
+	m_iCheckoutAttempts = 0;
+	m_iLastPurchaseAttemptPrice = 0;
+
+	m_eCurrency = k_ECurrencyUSD;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CStorePanel::~CStorePanel()
+{
+	vgui::ivgui()->RemoveTickSignal( GetVPanel() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	LoadControlSettings( CFmtStr( "Resource/UI/econ/store/v%i/StorePanel.res", GetStoreVersion() ) );
+
+	SetOKButtonVisible(false);
+	SetCancelButtonVisible(false);
+
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::PerformLayout( void ) 
+{
+	if ( GetVParent() )
+	{
+		int w,h;
+		vgui::ipanel()->GetSize( GetVParent(), w, h );
+		SetBounds(0,0,w,h);
+	}
+
+#ifdef TF_CLIENT_DLL
+	bool bShowUpsellCheckbox = ( tf_store_stamp_donation_add_timestamp.GetFloat() > 0.0f && HasValidUpsellStamps() );
+	SetControlVisible( "SupportCommunityMapMakersCheckButton", bShowUpsellCheckbox );
+	SetControlVisible( "SupportCommunityMapMakersLabel", bShowUpsellCheckbox );
+#endif
+
+	BaseClass::PerformLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::OnStartShopping( void )
+{
+	// Move to the first tab
+	vgui::Panel *pPage = GetPropertySheet()->GetPage(1);
+	if ( pPage )
+	{
+		GetPropertySheet()->SetActivePage( pPage );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::OnFindAndSelectFeaturedItem( void )
+{
+	const econ_store_entry_t *pEntry = GetFeaturedEntry();
+	if ( !pEntry )
+		return;
+
+	FindAndSelectEntry( pEntry );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::FindAndSelectEntry( const econ_store_entry_t *pEntry )
+{
+	// Find the item in a store page and move to it
+	int iPages = GetPropertySheet()->GetNumPages();
+	for ( int i = 1; i < iPages; i++ )
+	{
+		CStorePage *pPage = dynamic_cast< CStorePage * >( GetPropertySheet()->GetPage(i) );
+		if ( !pPage )
+			continue;
+		
+		if ( pPage->FindAndSelectEntry( pEntry ) )
+		{
+			if ( GetPropertySheet()->GetActivePage() != pPage )
+			{
+				GetPropertySheet()->SetActivePage( pPage );
+			}
+			else
+			{
+				// VGUI doesn't tell the starting active page that it's active, so we post a pageshow to it
+				ivgui()->PostMessage( pPage->GetVPanel(), new KeyValues("PageShow"), GetPropertySheet()->GetVPanel() );
+			}
+			return;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Static store page factory.
+//-----------------------------------------------------------------------------
+CStorePage *CStorePanel::CreateStorePage( const CEconStoreCategoryManager::StoreCategory_t *pPageData )
+{
+	// Default, standard store page.
+	return new CStorePage( this, pPageData );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CStorePanel::ShouldShowDx8PurchaseWarning() const
+{
+	static ConVarRef mat_dxlevel( "mat_dxlevel" );
+	if ( mat_dxlevel.GetInt() >= 90 )
+		return false;
+
+	// List of operations that have features that are not compatible with DX8.
+	const char* cpDX8WarningItems[] = {
+		"Unused Summer 2015 Operation Pass",
+		"Unused Operation Tough Break Pass",
+		NULL
+	};
+
+	for ( int i = 0; cpDX8WarningItems[ i ] != NULL; ++i )
+	{
+		if ( m_Cart.ContainsItemDefinition( ItemSystem()->GetStaticDataForItemByName( cpDX8WarningItems[ i ] )->GetDefinitionIndex() ) )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::OnItemLinkClicked( KeyValues *pParams )
+{
+	// Get the item definition index from the URL
+	const char *pURL = pParams->GetString( "url" );
+	int iItemDef = atoi( pURL + 7 );
+
+	if ( EconUI()->GetStorePanel()->GetPriceSheet() )
+	{
+		// Look up the item definition and see if there is a store remap
+		CEconItemSchema *pSchema = ItemSystem()->GetItemSchema();
+		if ( pSchema )
+		{
+			CEconItemDefinition *pItem = pSchema->GetItemDefinition( iItemDef );
+			if ( pItem )
+			{
+				int iStoreRemap = pItem->GetStoreRemap();
+				if ( iStoreRemap > 0 )
+				{
+					iItemDef = pItem->GetStoreRemap();
+				}
+			}
+		}
+
+		const econ_store_entry_t *pEntry = GetPriceSheet()->GetEntry( iItemDef );
+		if ( pEntry )
+		{
+			FindAndSelectEntry( pEntry );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::ShowPanel(bool bShow)
+{
+	m_bPreventClosure = false;
+
+#ifdef TF_CLIENT_DLL
+	// Keep the MM dashboard on top of us
+	bShow ? GetMMDashboardParentManager()->PushModalFullscreenPopup( this ) 
+		  : GetMMDashboardParentManager()->PopModalFullscreenPopup( this );
+#endif
+
+	if ( bShow )
+	{
+		if ( !m_bOGSLogging )
+		{
+			EconUI()->Gamestats_Store( IE_STORE_ENTERED );
+			m_bOGSLogging = true;
+		}
+
+		ShowStorePanel();
+	}
+	else
+	{
+		if ( m_bOGSLogging )
+		{
+			EconUI()->Gamestats_Store( IE_STORE_EXITED );
+			m_bOGSLogging = false;
+		}
+	}
+
+	SetVisible( bShow );
+
+	if ( bShow && m_bAddStartItemDefToCart )
+	{
+		OpenStoreViewCartPanel();
+		m_bAddStartItemDefToCart = false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::FireGameEvent( IGameEvent *event )
+{
+	const char * type = event->GetName();
+
+	if ( Q_strcmp(type, "gameui_hidden") == 0 )
+	{
+		if ( m_bPreventClosure )
+		{
+			engine->ClientCmd_Unrestricted( "gameui_activate" );
+		}
+		else
+		{
+			ShowPanel( false );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::OnCommand( const char *command )
+{
+	if ( !Q_strnicmp( command, "checkout", 8 ) )
+	{
+		InitiateCheckout( false );
+		return;
+	}
+	else if ( !Q_stricmp( command, "close" ) )
+	{
+		ShowPanel( false );
+
+		// If we're connected to a game server, we also close the game UI.
+		if ( engine->IsInGame() )
+		{
+			engine->ClientCmd_Unrestricted( "gameui_hide" );
+		}
+		
+#ifdef TF_CLIENT_DLL
+		if ( IsFreeTrialAccount() )
+		{
+			InventoryManager()->CheckForRoomAndForceDiscard();
+		}
+#endif
+	}
+	else if ( !Q_stricmp( command, "back" ) )
+	{
+		ShowPanel( true );
+	}
+	else
+	{
+		engine->ClientCmd( const_cast<char *>( command ) );
+	}
+
+	BaseClass::OnCommand( command );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::OnKeyCodeTyped(vgui::KeyCode code)
+{
+	if ( code == KEY_ESCAPE )
+	{
+		if ( !m_bPreventClosure )
+		{
+			ShowPanel( false );
+		}
+	}
+	else
+	{
+		BaseClass::OnKeyCodeTyped( code );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const econ_store_entry_t *CStorePanel::GetFeaturedEntry( void )
+{
+	const CEconStoreCategoryManager::StoreCategory_t *pFeaturedSection = GEconStoreCategoryManager()->GetFeaturedItems();
+	if ( !pFeaturedSection || pFeaturedSection->m_vecEntries.Count() == 0 )
+		return NULL;
+	uint32 idx = MIN( m_StoreSheet.GetFeaturedItemIndex(), (uint32)( pFeaturedSection->m_vecEntries.Count() - 1 ) );
+	return EconUI()->GetStorePanel()->GetPriceSheet()->GetEntry( pFeaturedSection->m_vecEntries[ idx ] );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Asks the GC to send us the price sheet.
+//-----------------------------------------------------------------------------
+void CStorePanel::RequestPricesheet( void )
+{
+	// Create the store panel the first time we request a price sheet
+	EconUI()->CreateStorePanel();
+
+	CGCClientJobGetUserData *pJob = new CGCClientJobGetUserData( GCClientSystem()->GetGCClient(), 0 );
+	pJob->StartJob( NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Asynchronous job for getting the price sheet from the GC
+//-----------------------------------------------------------------------------
+bool CGCClientJobGetUserData::BYieldingRunJob( void *pvStartParam )
+{
+	GCSDK::CProtoBufMsg<CMsgStoreGetUserData> msg( k_EMsgGCStoreGetUserData );
+	GCSDK::CProtoBufMsg<CMsgStoreGetUserDataResponse> msgResponse;
+
+	msg.Body().set_price_sheet_version( m_RTimeVersion );
+	if ( !BYldSendMessageAndGetReply( msg, 10, &msgResponse, k_EMsgGCStoreGetUserDataResponse ) )
+	{
+		// No response from the GC. Show a failure message.
+		if ( CStorePanel::ShouldShowWarnings() )
+		{
+			OpenStoreStatusDialog( NULL, "#StoreUpdate_NoGCResponse", true, false );
+		}
+		return false;
+	}
+
+#ifdef _DEBUG
+	Msg( "CGCClientJobGetUserData - Result: %d\n", msgResponse.Body().result() );
+#endif
+
+	if ( !CStorePanel::CheckMessageResult( (EPurchaseResult)msgResponse.Body().result() ) )
+		return true;
+
+	bool bInitialLoad = !CStorePanel::IsPricesheetLoaded();
+
+	CStorePanel *pStorePanel = EconUI()->GetStorePanel();
+
+	// Create the store panel.
+	if ( bInitialLoad )
+	{
+		// Close the loading status dialog.
+		CloseStoreStatusDialog();
+	}
+	else
+	{
+		pStorePanel->GetPropertySheet()->DeleteAllPages();
+
+		// Indicate to the user what happened.
+		if( pStorePanel->IsVisible() )
+		{
+			OpenStoreStatusDialog( NULL, "#StoreUpdate_NewPriceSheetLoaded", true, false );
+		}
+	}
+
+	// Set the prices & items on the store panel.
+	KeyValuesAD pKVPricesheet( "prices" );
+
+	// Allow a back-door for reading the local price sheet rather than the one from the GC.
+//#define READ_LOCAL_PRICE_SHEET // DO NOT CHECK IN
+#if defined( READ_LOCAL_PRICE_SHEET ) && defined( _DEBUG )
+	pKVPricesheet->LoadFromFile( g_pFullFileSystem, "scripts/items/unencrypted/store.txt", "MOD" );
+#else
+	CUtlBuffer bufRawData( msgResponse.Body().price_sheet().data(), msgResponse.Body().price_sheet().size(), CUtlBuffer::READ_ONLY );
+	pKVPricesheet->ReadAsBinary( bufRawData );
+#endif
+
+	pKVPricesheet->SetInt( "featured_item_index", msgResponse.Body().featured_item_idx() );
+	pKVPricesheet->SetInt( "default_sort_type", msgResponse.Body().default_item_sort() );
+	pStorePanel->LoadPricesheet( &pKVPricesheet );
+
+	// Manually copy over the version number the GC sent down.
+	Assert( pStorePanel->GetPriceSheetForEdit() );
+	pStorePanel->GetPriceSheetForEdit()->SetVersionStamp( msgResponse.Body().price_sheet_version() );
+
+	pStorePanel->ClearPopularItems();
+	for ( int i=0; i<msgResponse.Body().popular_items_size(); ++i )
+	{
+		pStorePanel->AddPopularItem( msgResponse.Body().popular_items(i) );
+	}
+
+	// Store our experiment membership value.
+	EconUI()->SetExperimentValue( msgResponse.Body().experiment_data() ); 
+
+	// Store the currency and country code.
+	if ( msgResponse.Body().currency() == k_ECurrencyInvalid )
+	{
+		// An invalid currency means the user must contact steam support to have their account set up.
+		OpenStoreStatusDialog( NULL, "#StoreUpdate_ContactSupport", true, false );
+		return true;
+	}
+
+	pStorePanel->SetCurrency( (ECurrency)msgResponse.Body().currency() );
+	pStorePanel->SetCountryCode( msgResponse.Body().country().c_str() );
+	// TODO: Also store the steam provided localization code (not implemented yet in the response).
+
+	// Open the store panel.
+ 	if ( !bInitialLoad )
+ 	{
+		// Not an initial load, but store was already up. Re-open it to clean it up.
+		if ( pStorePanel->IsVisible() )
+		{
+ 			pStorePanel->ShowPanel( true );
+		}
+ 	}
+	else
+	{
+#ifndef TF_CLIENT_DLL
+		// First time we've loaded the pricesheet, so open the store. 
+		// You can remove this if you choose to load the pricesheet on game startup (like TF does)
+		EconUI()->OpenStorePanel( 0, false );	
+#endif
+	}
+
+	IGameEvent *event = gameeventmanager->CreateEvent( "store_pricesheet_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CStorePage *CStorePanel::AddPageFromPriceSheet( int iPage )
+{
+	CStorePage* pPage = CreateStorePage( GEconStoreCategoryManager()->GetCategoryFromIndex( iPage ) );
+	pPage->OnPostCreate();
+	pPage->AddActionSignalTarget( this );
+	AddPage( pPage, GEconStoreCategoryManager()->GetCategoryFromIndex( iPage )->m_pchName );	
+
+	if ( iPage == 0 )
+	{
+		pPage->SetVisible( true );
+	}
+
+	return pPage;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Populates the storepanel with data from the GC
+//-----------------------------------------------------------------------------
+bool CStorePanel::LoadPricesheet( KeyValuesAD* pKVPricesheet )
+{
+	// Read the store KV file in, and parse it.
+	Verify( m_StoreSheet.InitFromKV( *pKVPricesheet ) );
+
+	// Add our pages
+	for ( int i = 0; i < GEconStoreCategoryManager()->GetNumCategories(); i++ )
+	{
+		// Skip subcategories
+		if ( GEconStoreCategoryManager()->GetCategoryFromIndex( i )->BIsSubcategory() )
+			continue;
+
+		AddPageFromPriceSheet( i );
+	}
+
+	// Clear the cart, since we may have new items.
+	GetCart()->EmptyCart();
+
+	m_bPricesheetLoaded = true;
+
+	return true;
+}
+
+#ifdef _DEBUG
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::ReAddPage( int iPage )
+{
+	CStorePage *pPage = AddPageFromPriceSheet( iPage );
+	if ( pPage )
+	{
+		pPage->InvalidateLayout( true, true );
+		pPage->SetVisible( true );
+		GetPropertySheet()->SetActivePage( pPage );
+	}
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets currency type.
+//-----------------------------------------------------------------------------
+void CStorePanel::SetCurrency( ECurrency in_currency )
+{
+	// Do any currency related UI work here.
+	m_eCurrency = in_currency;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the country code. Later this will become an enum.
+//-----------------------------------------------------------------------------
+void CStorePanel::SetCountryCode( const char* in_country )
+{
+	V_strcpy_safe( m_rgchCountry, in_country );
+}
+
+bool CStorePanel::ShouldUpsellStamps( void )
+{
+#ifdef TF_CLIENT_DLL
+	bool bForceShow = false;
+
+	CheckButton *pSupportCheckButton = static_cast< CheckButton* >( FindChildByName( "SupportCommunityMapMakersCheckButton" ) );
+	if ( pSupportCheckButton && pSupportCheckButton->IsVisible() && pSupportCheckButton->IsSelected() )
+	{
+		bForceShow = true;
+	}
+
+	CStoreCart *pCart = EconUI()->GetStorePanel()->GetCart();
+	if ( !pCart || pCart->GetNumEntries() <= 0 )
+		return false;
+
+	if ( !bForceShow )
+	{
+		for ( int i = 0; i < pCart->GetNumEntries(); ++i )
+		{
+			cart_item_t *pItem = pCart->GetItem( i );
+			if ( pItem && pItem->pEntry && pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Maps ) )
+			{
+				return false;
+			}
+		}
+	}
+
+	if ( !HasValidUpsellStamps() )
+		return false;
+
+	RTime32 rtCurrentTime = CRTime::RTime32TimeCur();
+	RTime32 rtTimeStamp = tf_store_stamp_donation_add_timestamp.GetInt();
+
+	if ( !bForceShow )
+	{
+		if ( rtTimeStamp > rtCurrentTime )
+		{
+			// Time stamp set ahead of current time
+			// Set it back to the current time and save it
+			tf_store_stamp_donation_add_timestamp.SetValue( (int)rtCurrentTime );
+			engine->ClientCmd_Unrestricted( "host_writeconfig" );
+			return false;
+		}
+
+		AccountID_t nAccountID = steamapicontext->SteamUser()->GetSteamID().GetAccountID();
+		int nGroup = nAccountID % TF_STORE_STAMP_UPSELL_GROUPS;
+		RTime32 nBucketTimeOffset = ( TF_STORE_STAMP_UPSELL_COOLDOWN / TF_STORE_STAMP_UPSELL_GROUPS ) * nGroup;
+		RTime32 nBucketedTimeStamp = ( ( rtTimeStamp / TF_STORE_STAMP_UPSELL_COOLDOWN ) + 1 ) * TF_STORE_STAMP_UPSELL_COOLDOWN;
+		nBucketedTimeStamp = MAX( nBucketedTimeStamp, TF_STORE_STAMP_UPSELL_BASELINE );
+		nBucketedTimeStamp += nBucketTimeOffset;
+
+		if ( rtCurrentTime < nBucketedTimeStamp + TF_STORE_STAMP_UPSELL_COOLDOWN )
+		{
+			return false;
+		}
+	}
+
+	tf_store_stamp_donation_add_timestamp.SetValue( (int)rtCurrentTime );
+	engine->ClientCmd_Unrestricted( "host_writeconfig" );
+
+	return true;
+#else
+	return false;
+#endif
+}
+
+bool CStorePanel::HasValidUpsellStamps( void )
+{
+#ifdef TF_CLIENT_DLL
+	int nTotalDonationLevel = 0;
+
+	for ( int i = 0; i < GetItemSchema()->GetMapCount(); i++ )
+	{
+		const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByIndex( i );
+		if ( pMap->IsCommunityMap() )
+		{
+			int nDonationLevel = MapInfo_GetDonationAmount( steamapicontext->SteamUser()->GetSteamID().GetAccountID(), pMap->pszMapName );
+			nTotalDonationLevel += nDonationLevel;
+
+			// No need to upsell if they've spent $50 on stamps
+			if ( nTotalDonationLevel >= 50 )
+				return false;
+
+			// No need to upsell this map if they've spent more than $15 on it
+			if ( nDonationLevel > 20 )
+				continue;
+
+			// No need to upsell this map if they've played it less than an hour
+			MapStats_t &mapStats = CTFStatPanel::GetMapStats( pMap->GetStatsIdentifier() );
+			int nNumHours = ( mapStats.accumulated.m_iStat[TFMAPSTAT_PLAYTIME] ) / ( 60 /*sec*/ * 60 /*min*/ );
+
+			// No need to upsell this map if they've played it less than 2 hours
+			if ( nNumHours <= 1 )
+				continue;
+
+			int nRelativeDivisor = nNumHours / 4;
+			float flRelativePayoff = ( nRelativeDivisor == 0 ? 0.0f : static_cast< float >( nDonationLevel ) / nRelativeDivisor );
+
+			// No need to upsell this map if they've spend more than $1 per 10 hours
+			if ( flRelativePayoff >= 1.0f )
+				continue;
+
+			return true;
+		}
+	}
+
+	return false;
+#else
+	return false;
+#endif
+}
+
+void CStorePanel::UpsellStamps( void )
+{
+#if defined( TF_CLIENT_DLL )
+	const MapDef_t *pUpsellMap = NULL;
+	float flUpsellRelativePayoff = 1000.0f;
+	int nUpsellNumHours = 0;
+
+	for ( int i = 0; i < GetItemSchema()->GetMapCount(); i++ )
+	{
+		const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByIndex( i );
+		if ( pMap->IsCommunityMap() )
+		{
+			int nDonationLevel = MapInfo_GetDonationAmount( steamapicontext->SteamUser()->GetSteamID().GetAccountID(), pMap->pszMapName );
+
+			MapStats_t &mapStats = CTFStatPanel::GetMapStats( pMap->GetStatsIdentifier() );
+			int nNumHours = ( mapStats.accumulated.m_iStat[TFMAPSTAT_PLAYTIME] ) / ( 60 /*sec*/ * 60 /*min*/ );
+
+			// No need to upsell this map if they've played it less than 2 hours
+			if ( nNumHours <= 1 )
+				continue;
+
+			int nRelativeDivisor = nNumHours / 4;
+			float flRelativePayoff = ( nRelativeDivisor == 0 ? 0.0f : static_cast< float >( nDonationLevel ) / nRelativeDivisor );
+
+			if ( flUpsellRelativePayoff > flRelativePayoff || ( flUpsellRelativePayoff == flRelativePayoff && nUpsellNumHours < nNumHours ) )
+			{
+				pUpsellMap = pMap;
+				flUpsellRelativePayoff = flRelativePayoff;
+				nUpsellNumHours = nNumHours;
+			}
+		}
+	}
+
+	Assert( pUpsellMap );
+	if ( !pUpsellMap )
+	{
+		// Should have returned false from ShouldUpsell long before we got here
+		return;
+	}
+
+	wchar_t *pwchMapName = g_pVGuiLocalize->Find( pUpsellMap->pszMapNameLocKey );
+
+	char szMapHours[ 8 ];
+	V_snprintf( szMapHours, sizeof( szMapHours ), "%i", nUpsellNumHours );
+
+	wchar_t wszMapHours[ 8 ];
+	g_pVGuiLocalize->ConvertANSIToUnicode( szMapHours, wszMapHours, sizeof( wszMapHours ) );
+
+	wchar_t wchDonationDescription[ 512 ];
+	g_pVGuiLocalize->ConstructString_safe( wchDonationDescription, g_pVGuiLocalize->Find( "#Store_ConfirmStampDonationAddText" ), 2, pwchMapName, wszMapHours );
+	
+	CStampUpsellDialog *pDialog = vgui::SETUP_PANEL( new CStampUpsellDialog( "#Store_ConfirmStampDonationAddTitle", 
+		wchDonationDescription, g_pVGuiLocalize->Find( "#Store_ConfirmStampDonationAddText2" ), 
+		pUpsellMap->mapStampDef, "World Traveler" ) );
+
+	if ( pDialog )
+	{
+		pDialog->Show();
+		vgui::surface()->PlaySound( "ui/vote_started.wav" );
+	}
+#else
+	return;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Attempts to begin a checkout.
+//-----------------------------------------------------------------------------
+void CStorePanel::InitiateCheckout( bool bSkipUpsell )
+{
+	// Check for holiday-restricted items and confirm with user before allowing checkout
+	if ( m_Cart.ContainsHolidayRestrictedItems() )
+	{
+		CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#Store_ConfirmHolidayRestrictionCheckoutTitle",  "#Store_ConfirmHolidayRestrictionCheckoutText", "#Store_OK", "#TF_Back", &ConfirmCheckout );
+		if ( pDialog )
+		{
+			pDialog->SetContext( this );
+		}
+		return;
+	}
+	else if ( ShouldShowDx8PurchaseWarning( ) )
+	{
+		CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#Store_ConfirmDx8Summer2015OpPassTitle", "#Store_ConfirmDx8Summer2015OpPassText", "#Store_BuyAnyway", "#Store_NoThanks", &ConfirmCheckout );
+		if ( pDialog )
+		{
+			pDialog->SetContext( this );
+		}
+		return;
+	}
+	else if ( !bSkipUpsell && ShouldUpsellStamps() )
+	{
+		UpsellStamps();
+		return;
+	}
+
+	DoCheckout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+/*static*/ void CStorePanel::ConfirmCheckout( bool bConfirmed, void *pContext )
+{
+	CStorePanel *pStorePanel = ( CStorePanel * )pContext;
+	if ( bConfirmed )
+	{
+		if ( pStorePanel->ShouldUpsellStamps() )
+		{
+			pStorePanel->UpsellStamps();
+			return;
+		}
+		else
+		{
+			pStorePanel->DoCheckout();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+/*static*/ void CStorePanel::ConfirmUpsellStamps( bool bConfirmed, CSchemaItemDefHandle hItemDef, int nSecondsVisible )
+{
+	CStorePanel *pStorePanel = EconUI()->GetStorePanel();
+	if ( bConfirmed )
+	{
+		// Add to cart
+		CStorePage *pPage = dynamic_cast< CStorePage * >( pStorePanel->GetPropertySheet()->GetPage( 3 ) );
+
+		KeyValues *pParams = new KeyValues( "AddItemToCart" );
+		pParams->SetInt( "item_def", hItemDef->GetDefinitionIndex() );
+		pParams->SetInt( "cart_add_type", kCartItem_Purchase );
+		pStorePanel->PostMessage( pPage, pParams );
+
+		pStorePanel->PostMessage( pStorePanel, new KeyValues( "DoCheckout" ), 0.5f );
+	}
+	else
+	{
+		CheckButton *pCheckbox = static_cast< CheckButton* >( pStorePanel->FindChildByName( "SupportCommunityMapMakersCheckButton" ) );
+		if ( pCheckbox )
+		{
+			pCheckbox->SetSelected( false );
+		}
+
+		pStorePanel->DoCheckout();
+	}
+
+#if !defined(NO_STEAM)
+	KeyValues *pKVData = new KeyValues( "TF2StoreStampUpsell" );
+
+	// Create and Send the report
+	// AccountID, AcceptUpsell, CartItemsCount, CartItemsPrice, CartItemsFlags, SecondsVisible, EventTime
+
+	// ID - Auto
+
+	// AcceptUpsell
+	pKVData->SetInt( "AcceptUpsell", bConfirmed ? 1 : 0 );
+
+	// CartItemsCount (up to 100)
+	CStoreCart *pCart = EconUI()->GetStorePanel()->GetCart();
+	pKVData->SetInt( "CartItemsCount", pCart ? clamp( pCart->GetNumEntries(), 0, 100 ) : 0 );
+
+	// CartItemsPriceTotal
+	pKVData->SetInt( "CartItemsPrice", pCart ? pCart->GetTotalPrice() : 0 );
+
+	// CartItemsFlags (8-bits)
+	int nCartItemsFlags = 0;
+	if ( pCart )
+	{
+		for ( int i = 0; i < pCart->GetNumEntries(); ++i )
+		{
+			cart_item_t *pItem = pCart->GetItem( i );
+			if ( !pItem || !pItem->pEntry )
+				continue;
+
+			if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Weapons ) )			nCartItemsFlags |= 0x0001;
+//			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Headgear ) )	nCartItemsFlags |= 0x0002;			// DEPRECATED
+//			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Misc ) )		nCartItemsFlags |= 0x0004;			// DEPRECATED
+			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Tools ) )		nCartItemsFlags |= 0x0008;
+			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Maps ) )		nCartItemsFlags |= 0x0010;
+			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Bundles ) )	nCartItemsFlags |= 0x0020;
+			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_New ) )		nCartItemsFlags |= 0x0040;
+			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Limited ) )	nCartItemsFlags |= 0x0080;
+			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Cosmetics ) )	nCartItemsFlags |= 0x0100;
+			else if ( pItem->pEntry->IsListedInCategory( CEconStoreCategoryManager::k_CategoryID_Taunts ) )		nCartItemsFlags |= 0x0200;
+		}
+	}
+
+	pKVData->SetInt( "CartItemsFlags", nCartItemsFlags );
+
+	// SecondsVisible (up to 2 minutes)
+	pKVData->SetInt( "SecondsVisible", clamp( nSecondsVisible, 0, 120 ) );
+
+	// EventTime
+	pKVData->SetInt( "EventTime", GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
+
+	// Send to DB
+	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
+#endif // !defined(NO_STEAM)
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CStorePanel::DoCheckout()
+{
+	m_iCheckoutAttempts++;
+	EconUI()->Gamestats_Store( IE_STORE_CHECKOUT_ATTEMPT, NULL, NULL, 0, NULL, m_iCheckoutAttempts );
+
+	// Create the checkout job.
+	OpenStoreStatusDialog( NULL, "#StoreCheckout_Loading", true, false, true );
+	CGCClientJobInitPurchase *pJob = new CGCClientJobInitPurchase( GCClientSystem()->GetGCClient() );
+	pJob->StartJob( NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+static void ShowPurchaseInitError( const char *pszError )
+{
+	OpenStoreStatusDialog( NULL, pszError, true, false );
+	EconUI()->Gamestats_Store( IE_STORE_CHECKOUT_FAILURE, NULL, NULL, 0, NULL, EconUI()->GetStorePanel()->GetCheckoutAttempts(), pszError );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Asynchronous job for initiating a checkout from the Steam store.
+//-----------------------------------------------------------------------------
+bool CGCClientJobInitPurchase::BYieldingRunJob( void *pvStartParam )
+{
+	GCSDK::CProtoBufMsg<CMsgGCStorePurchaseInit> msg( k_EMsgGCStorePurchaseInit );
+	GCSDK::CProtoBufMsg<CMsgGCStorePurchaseInitResponse> msgResponse;
+
+	if  ( !EconUI()->GetStorePanel() )
+	{
+		// This won't happen under the normal process of using the UI.
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_Unavailable", true, false );
+		return true;
+	}
+
+	CStoreCart *pCart = EconUI()->GetStorePanel()->GetCart();
+	char uilanguage[ 64 ];
+	uilanguage[0] = 0;
+	engine->GetUILanguage( uilanguage, sizeof( uilanguage ) );
+
+	// Populate the message.
+	msg.Body().set_currency( EconUI()->GetStorePanel()->GetCurrency() );
+	msg.Body().set_country( EconUI()->GetStorePanel()->GetCountryCode() );
+	msg.Body().set_language( PchLanguageToELanguage( uilanguage ) );
+
+	// We need to ensure there are more than 0 items in the cart, but no more than MAX_CART_ITEMS.
+	int total_items = pCart->GetTotalItems();
+	if ( total_items <= 0 )
+	{
+		ShowPurchaseInitError( "#StoreCheckout_NoItems" );
+		return true;
+	}
+
+	if ( total_items > MAX_CART_ITEMS )
+	{
+		ShowPurchaseInitError( "#StoreCheckout_TooManyItems" );
+		return true;
+	}
+
+	// Can the items we want to buy actually fit inside our backpack?
+	// This check will include items that we have discovered, but haven't been revealed to the player yet.
+	// So they will sometimes get this with apparently empty slots in their backpack.
+	if ( !InventoryManager()->GetLocalInventory()->CanPurchaseItems( pCart->GetTotalConcreteItems() ) )
+	{
+		const bool bInventoryIsAtMaxSize = InventoryManager()->GetLocalInventory()->GetMaxItemCount() == MAX_NUM_BACKPACK_SLOTS;
+
+		ShowPurchaseInitError( bInventoryIsAtMaxSize ? "#StoreCheckout_NotEnoughRoom_MaxSize" : "#StoreCheckout_NotEnoughRoom" );
+		return true;
+	}
+
+	// Add the items we are requesting.
+	int totalPrice = 0;
+	for ( int i=0; i<pCart->GetNumEntries(); i++ )
+	{
+		cart_item_t *pCartItem = pCart->GetItem( i );
+
+		CGCStorePurchaseInit_LineItem *pNewLineItem = msg.Body().add_line_items();
+
+		pNewLineItem->set_item_def_id( pCartItem->pEntry->GetItemDefinitionIndex() );
+		pNewLineItem->set_quantity( pCartItem->iQuantity );
+		pNewLineItem->set_purchase_type( pCartItem->eType );
+
+		int itemPrice = pCartItem->iQuantity * pCartItem->pEntry->GetCurrentPrice( EconUI()->GetStorePanel()->GetCurrency() );
+		pNewLineItem->set_cost_in_local_currency( itemPrice );
+
+		totalPrice += itemPrice;
+	}
+	EconUI()->GetStorePanel()->SetLastPurchaseAttemptPrice( totalPrice );
+
+	// Request to init this purchase.
+	if ( !BYldSendMessageAndGetReply( msg, 30, &msgResponse, k_EMsgGCStorePurchaseInitResponse ) )
+	{
+		// No transaction has been initialized. The GC isn't responding, so abort.
+		ShowPurchaseInitError( "#StoreCheckout_Unavailable" );
+		return false;
+	}
+
+#ifdef _DEBUG
+	Msg( "CGCClientJobInitPurchase - Result: %d, TxnID: %llu\n", msgResponse.Body().result(), msgResponse.Body().txn_id());
+#endif
+
+	// If we fail at this point Steam hasn't opened a transaction that we need to worry about.
+	if ( !CStorePanel::CheckMessageResult( (EPurchaseResult)msgResponse.Body().result() ) )
+		return false;
+
+	EconUI()->GetStorePanel()->SetTransactionID( msgResponse.Body().txn_id() );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Immediately add the item corresponding to the item def passed into
+//			the cart and checkout.  This doesn't required opening the store front
+//			so this can be called anywhere.
+//-----------------------------------------------------------------------------
+void CStorePanel::AddToCartAndCheckoutImmediately( item_definition_index_t nDefIndex )
+{
+	if ( GetPriceSheet() && GetCart() && steamapicontext && steamapicontext->SteamUser() )
+	{
+		// Add a the item to the users cart and checkout
+		GetCart()->EmptyCart();
+		AddItemToCartHelper( NULL, nDefIndex, kCartItem_Purchase );
+		DoCheckout();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Cancels a pending transaction, if possible.
+//-----------------------------------------------------------------------------
+void CStorePanel::CheckoutCancel( void )
+{
+	// The player pressed the CANCEL button on the TF2 GAME UI pop-up that appears over
+	// the store interface while they would be occupied with the overlay.
+	//
+	// If they press the CANCEL button on the overlay's authorize dialog a Steam callback 
+	// (OnMicroTransactionAuthResponse) happens not this method.
+	//
+	// We don't expect this to happen! Once the transaction has been finalized we have
+	// a transaction ID and the GC and Steam are already doing the negotiations about
+	// where the money comes from and removing it so we can't back out. Allowing users
+	// to click this button results in a race condition that often results in users
+	// getting their money taken with no items because the GC can't resolve the
+	// "Canceled"/"Succeeded" discrepancy.
+	Assert( GetTransactionID() <= 0 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Attempts to cancel a purchase in progress.
+//-----------------------------------------------------------------------------
+bool CGCClientJobCancelPurchase::BYieldingRunJob( void *pvStartParam )
+{
+	GCSDK::CProtoBufMsg<CMsgGCStorePurchaseCancel> msg( k_EMsgGCStorePurchaseCancel );
+	GCSDK::CProtoBufMsg<CMsgGCStorePurchaseCancelResponse> msgResponse;
+
+	if  ( !EconUI()->GetStorePanel() )
+	{
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_Unavailable", true, false );
+		return false;
+	}
+
+	msg.Body().set_txn_id( m_ulTxnID );
+
+	if ( !BYldSendMessageAndGetReply( msg, 10, &msgResponse, k_EMsgGCStorePurchaseCancelResponse ) )
+	{
+		// No response from the GC. Show a failure message.
+		OpenStoreStatusDialog( NULL, "#StoreUpdate_NoGCResponse", true, false );
+		return false;
+	}
+
+#ifdef _DEBUG
+	Msg( "CGCClientJobCancelPurchase Result: %d\n", msgResponse.Body().result() );
+#endif
+
+	// The current transaction has been canceled with the GC.
+	EconUI()->GetStorePanel()->SetTransactionID( 0 );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when the player completes or cancels an in-progress transaction.
+//-----------------------------------------------------------------------------
+void CStorePanel::OnMicroTransactionAuthResponse( MicroTxnAuthorizationResponse_t *pMicroTxnAuthResponse )
+{
+	Assert( steamapicontext->SteamUserStats() );
+	if ( !steamapicontext->SteamUserStats() )
+		return;
+
+	if ( !pMicroTxnAuthResponse->m_bAuthorized )
+	{
+		const char* pszError = "#StoreCheckout_TransactionCanceled";
+		EconUI()->Gamestats_Store( IE_STORE_CHECKOUT_FAILURE, NULL, NULL, 0, NULL, EconUI()->GetStorePanel()->m_iCheckoutAttempts, pszError );
+		OpenStoreStatusDialog( NULL, pszError, true, false );
+		CGCClientJobCancelPurchase *pJob = new CGCClientJobCancelPurchase( GCClientSystem()->GetGCClient(), GetTransactionID() );
+		pJob->StartJob( NULL );
+		SetTransactionID( 0 );
+	}
+	else
+	{
+		// Replace the existing dialog with one that says "we're finalizing!" and only has an "OK" button.
+		// We let users close this if they want, which can be useful in exceptional circumstances like the
+		// GC crashing, but we don't have them do any work on the GC side -- once the finalization is in
+		// flight we can't take it back.
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_TransactionFinalizing", true, false, false );
+
+		// Finalize the transaction with the GC.
+		m_bShouldFinalize = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Look to see if we should finalize the open transaction.
+//-----------------------------------------------------------------------------
+void CStorePanel::OnTick( void )
+{
+	BaseClass::OnTick();
+
+	if ( m_bShouldFinalize )
+	{
+		m_bShouldFinalize = false;
+		FinalizeTransaction();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStorePanel::FinalizeTransaction( void )
+{
+	// Tell the GC to release the items.
+	CGCClientJobFinalizePurchase *pJob = new CGCClientJobFinalizePurchase( GCClientSystem()->GetGCClient(), GetTransactionID() );
+	pJob->StartJob( NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Tell the GC that the purchase is finalized and we should create the items the player bought.
+// TODO: If something goes wrong here we need to inform the player, but tell them
+// that they MAY have been charged. If STEAM authorized & completed the transaction,
+// but we weren't able to finalize with the GC we won't get our items right away
+// but the player will have been charged.
+//-----------------------------------------------------------------------------
+bool CGCClientJobFinalizePurchase::BYieldingRunJob( void *pvStartParam )
+{
+	GCSDK::CProtoBufMsg<CMsgGCStorePurchaseFinalize> msg( k_EMsgGCStorePurchaseFinalize );
+	GCSDK::CProtoBufMsg<CMsgGCStorePurchaseFinalizeResponse> msgResponse;
+
+	msg.Body().set_txn_id( m_ulTxnID );
+
+	if ( !BYldSendMessageAndGetReply( msg, 10, &msgResponse, k_EMsgGCStorePurchaseFinalizeResponse ) )
+	{
+		// TODO: This is bad! The store might have taken our money, but we weren't able to finalize. How do we handle this?
+		// The message currently says "Unable to confirm success. If successful, your items will be delivered at a later date."
+		// We need to handle this case more gracefully.
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_CompleteButUnfinalized", true, false );
+		// @note Tom Bui & Joe Ludwig: We empty the cart here, just to make sure people don't hit checkout again
+		// and end up with dupes of all their items
+		if ( EconUI()->GetStorePanel() && EconUI()->GetStorePanel()->GetCart() )
+		{
+			EconUI()->GetStorePanel()->GetCart()->EmptyCart();
+		}
+		return false;
+	}
+
+	// Check the message result for errors and handle them.
+	if ( !CStorePanel::CheckMessageResult( (EPurchaseResult)msgResponse.Body().result() ) )
+		return false; 
+
+	EconUI()->Gamestats_Store( IE_STORE_CHECKOUT_SUCCESS, NULL, NULL, 0, NULL, EconUI()->GetStorePanel()->GetCheckoutAttempts(), NULL, EconUI()->GetStorePanel()->GetLastPurchaseAttemptPrice(), EconUI()->GetStorePanel()->GetCurrency()+1 );
+	CStoreCart* cart = EconUI()->GetStorePanel()->GetCart();
+	for ( int i=0; i<cart->GetNumEntries(); ++i )
+	{
+		cart_item_t* item = cart->GetItem( i );
+		if ( !item )
+			continue;
+		EconUI()->Gamestats_Store( IE_STORE_CHECKOUT_ITEM, NULL, NULL, 0, item, EconUI()->GetStorePanel()->GetCheckoutAttempts(), NULL, 0, EconUI()->GetStorePanel()->GetCurrency()+1 );
+	}
+
+#ifdef DEBUG
+	Msg( "CGCClientJobFinalizePurchase Result: %d, Num Items: %i, Purchased Items:\n", msgResponse.Body().result(), msgResponse.Body().item_ids_size() );
+	if ( k_EPurchaseResultOK == msgResponse.Body().result() )
+	{
+		for ( int i = 0; i < msgResponse.Body().item_ids_size(); i++ )
+		{
+			Msg( "\t%llu\n", msgResponse.Body().item_ids(i) );
+		}
+	}
+#endif
+
+	EconUI()->GetStorePanel()->SetMostRecentSuccessfulTransactionID( m_ulTxnID );
+
+	// Transaction complete.
+	EconUI()->GetStorePanel()->SetTransactionID( 0 );
+
+	// Clear the cart.
+	EconUI()->GetStorePanel()->GetCart()->EmptyCart();
+
+	// If we were in the cart view, return to the store page
+	CStoreViewCartPanel *pCartPanel = GetStoreViewCartPanel();
+	if ( pCartPanel && pCartPanel->IsVisible() )
+	{
+		pCartPanel->ShowPanel( false );
+	}
+
+	// Let them know everything went well.
+	OpenStoreStatusDialog( NULL, "#StoreCheckout_TransactionCompleted", true, true );
+
+	EconUI()->GetStorePanel()->PostTransactionCompleted();
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle an error from the GC.
+//-----------------------------------------------------------------------------
+bool CStorePanel::CheckMessageResult( EPurchaseResult msgResult )
+{
+	// Take action on the result code.
+	switch ( msgResult )
+	{
+	case k_EPurchaseResultOK:
+		return true;
+		break;
+
+		// GC / Steam errors: // These can all be combined into a single general unrecoverable error case.
+	case k_EPurchaseResultFail:	// Generic error.
+	case k_EPurchaseResultInvalidParam: // Invalid parameter.
+		if ( CStorePanel::ShouldShowWarnings() )
+		{
+			OpenStoreStatusDialog( NULL, "#StoreCheckout_Unavailable", true, false );
+		}
+		break;
+
+	// Internal error. Default string in English: "Unable to confirm success. If successful, your items will be
+	// delivered at a later date." Basically "something went real bad wrong and we don't know whether you'll get
+	// your items or not".
+	case k_EPurchaseResultInternalError:
+		if ( CStorePanel::ShouldShowWarnings() )
+		{
+			OpenStoreStatusDialog( NULL, "#StoreCheckout_CompleteButUnfinalized", true, false );
+		}
+		break;
+
+	// Is the GC telling us this user does not have enough backpack space?  This check takes into account
+	// any additional backpack space a user might get from upgrading to premium.
+	case k_EPurchaseResultNotEnoughBackpackSpace:
+		if ( CStorePanel::ShouldShowWarnings() )
+		{
+			OpenStoreStatusDialog( NULL, "#StoreCheckout_NotEnoughRoom", true, false );
+		}
+		break;
+
+	case k_EPurchaseResultLimitedQuantityItemsUnavailable:
+		if ( CStorePanel::ShouldShowWarnings() )
+		{
+			OpenStoreStatusDialog( NULL, "#StoreCheckout_LimitedQuantityItemsUnavailable", true, false );
+		}
+		break;
+
+		// errors that should never happen
+	case k_EPurchaseResultNotApproved: // Tried to finalize a transaction that has not yet been approved.
+	case k_EPurchaseResultAlreadyCommitted: // Tried to finalize a transaction that has already been committed.
+	case k_EPurchaseResultWrongCurrency: // Microtransaction's currency does not match user's wallet currency.
+	case k_EPurchaseResultAccountError: // User's account does not exist or is temporarily unavailable.
+	case k_EPurchaseResultTxnNotFound: // Could not find the transaction specified
+	default:
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_InternalError", true, false );
+		break;
+
+	case k_EMicroTxnResultFailedFraudChecks: // Steam thinks this transaction might be fraudulent
+		ShowConfirmDialog( "#StoreCheckout_ContactSupport_Dialog_Title", "#StoreCheckout_ContactSupport", "#StoreCheckout_ContactSupport_Dialog_Btn", "#Cancel", &ContactSupportConfirm );
+		break;
+
+		// User errors:
+	case k_EPurchaseResultUserNotLoggedIn: // User is not logged into Steam.
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_NotLoggedIn", true, false );
+		break;
+	case k_EPurchaseResultInsufficientFunds: // User does not have wallet funds
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_InsufficientFunds", true, false );
+		// This will happen if the user spends the money out of his wallet between funding & finalizing the transaction.
+		break;
+	case k_EPurchaseResultTimedOut: // Time limit for finalization has been exceeded
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_TimedOut", true, false );
+		// TODO: We should find out what happened to the transaction, since it still may be viable.
+		break;
+	case k_EPurchaseResultAcctDisabled: // Steam account is disabled.
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_SteamAccountDisabled", true, false );
+		break;
+	case k_EPurchaseResultAcctCannotPurchase: // Steam account is not allowed to make a purchase
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_SteamAccountNoPurchase", true, false );
+		break;
+
+		// Client state discrepancies:
+	case k_EPurchaseResultOldPriceSheet: // Information on the purchase didn't match the current price sheet
+		OpenStoreStatusDialog( NULL, "#StoreCheckout_OldPriceSheet", false, false );
+
+		// Request a new price sheet. This will clear the store pages and the user's cart.
+		CStorePanel::RequestPricesheet();
+		break;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Shows the store panel.
+//-----------------------------------------------------------------------------
+void CStorePanel::ShowStorePanel( void )
+{
+	GetPropertySheet()->SetVisible( true );
+	m_bShowWarnings = true;
+
+	InvalidateLayout( false, true );
+	Activate();
+
+	if ( !m_bPricesheetLoaded )
+		return;
+
+	bool bStartOnHomePage = true;
+
+	if ( m_bAddStartItemDefToCart )
+	{
+		// Put the specified item in the cart, and go to the cart display screen.
+		GetCart()->EmptyCart();
+
+		CStorePage *pPage = dynamic_cast< CStorePage * >( GetPropertySheet()->GetActivePage() );
+		AddItemToCartHelper( pPage ? pPage->GetPageName() : NULL, m_bAddStartItemDefToCart, kCartItem_Purchase );
+
+		if ( pPage )
+		{
+			pPage->UpdateCart();
+		}
+	}
+	else
+	{
+		if ( m_iStartItemDef == STOREPANEL_SHOW_UPGRADESTEPS )
+		{
+			OpenStoreStatusDialog( NULL, "#TF_Trial_StoreUpgradeExplanation", true, false );
+		}
+		else if ( m_iStartItemDef )
+		{
+			const econ_store_entry_t *pEntry = FindEntryForItemDef( m_iStartItemDef );
+			if ( pEntry )
+			{
+				// !KLUDGE! Post this to a message queue to be handled later, because there
+				// have already been messages posted to scroll to other pages.
+				// VGUI really has a pretty systematic problem of posting WAY too much stuff
+				// to a queue, instead of dispatching it immediately
+				ivgui()->PostMessage( GetVPanel(), new KeyValues("JumpToItem", "ItemDefIndex", m_iStartItemDef), GetVPanel() );
+				//FindAndSelectEntry( pEntry );
+				bStartOnHomePage = false;
+			}
+		}
+
+		CExButton *pCloseButton = dynamic_cast<CExButton*>( FindChildByName("CloseButton") );
+		if ( pCloseButton )
+		{
+			pCloseButton->RequestFocus();
+		}
+	}
+	m_iStartItemDef = 0;
+
+	if ( bStartOnHomePage )
+	{
+		vgui::Panel *pPage = GetPropertySheet()->GetPage(0);
+		if ( pPage )
+		{
+			if ( GetPropertySheet()->GetActivePage() != pPage )
+			{
+				GetPropertySheet()->SetActivePage( pPage );
+			}
+			else
+			{
+				// VGUI doesn't tell the starting active page that it's active, so we post a pageshow to it
+				ivgui()->PostMessage( pPage->GetVPanel(), new KeyValues("PageShow"), GetPropertySheet()->GetVPanel() );
+			}
+		}
+	}
+
+	vgui::Panel *pPage = GetPropertySheet()->GetActivePage();
+	if ( pPage )
+	{
+		pPage->SetVisible( true );
+	}
+
+	// 6/13/2011
+	// Note: We no longer check for new items when the player enters
+	// the store. This is confusing and no longer necessary now that
+	// the notification system lets us push item discoveries to the player.
+	// InventoryManager()->ShowItemsPickedUp( true, false );
+}
+
+void CStorePanel::OnJumpToItem( KeyValues *pParams )
+{
+	const econ_store_entry_t *pEntry = FindEntryForItemDef( pParams->GetInt( "ItemDefIndex", -1 ) );
+	Assert( pEntry );
+	if ( pEntry )
+	{
+		FindAndSelectEntry( pEntry );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void Open_Store( const CCommand &args )
+{
+	int iItemDef = ( args.ArgC() > 1 ) ? atoi(args[1]) : 0;
+	bool bToFeatured = ( ( ( args.ArgC() > 2 ) ? atoi(args[2]) : 0 ) != 0 );
+
+	EconUI()->OpenStorePanel( iItemDef, bToFeatured );	
+}
+ConCommand open_store( "open_store", Open_Store, "Open the in-game store", FCVAR_NONE );
+
+//==================================================================================================
+// CART
+//==================================================================================================
+CStoreCart::CStoreCart( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStoreCart::AddToCart( const econ_store_entry_t *pEntry, const char* pszPageName, ECartItemType eCartItemType )
+{
+	// Steam doesn't allow purchases with more than 256 items in a single transaction
+	if ( GetTotalItems() >= 255 )
+		return;
+
+	if ( pEntry->m_bIsMarketItem )
+	{
+		CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinition( pEntry->GetItemDefinitionIndex() );
+		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 );
+		}
+		return;
+	}
+
+	int iIndex = GetIndexForEntry( pEntry, eCartItemType );
+	if ( iIndex == m_Items.InvalidIndex() )
+	{
+		iIndex = m_Items.AddToTail();
+		m_Items[iIndex].pEntry = pEntry;
+		m_Items[iIndex].iQuantity = 0;
+		m_Items[iIndex].eType = eCartItemType;
+	}
+
+	m_Items[iIndex].iQuantity++;
+
+	EconUI()->Gamestats_Store( IE_STORE_ITEM_ADDED_TO_CART, NULL, pszPageName, 0, &m_Items[iIndex] );
+
+	IGameEvent *event = gameeventmanager->CreateEvent( "cart_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+
+	vgui::surface()->PlaySound( "ui/item_store_add_to_cart.wav" );
+
+	// find the cart button associated with the active page we are using
+	CExButton *pCartButton = dynamic_cast< CExButton * >( EconUI()->GetStorePanel()->GetActivePage()->FindChildByName( "CartButton", true ) );
+	if ( pCartButton )
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( pCartButton->GetParent(), "AddToCartBlink" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStoreCart::RemoveFromCart( int iIndex )
+{
+	if ( iIndex >= 0 && iIndex < m_Items.Count() )
+	{
+		// play item's "drop" sound
+		if ( m_Items[iIndex].pEntry )
+		{
+			CEconItemDefinition *pDef = ItemSystem()->GetStaticDataForItemByDefIndex( m_Items[iIndex].pEntry->GetItemDefinitionIndex() );
+			const char *soundFilename = pDef->GetDefinitionString( "drop_sound", "ui/item_default_drop.wav" );
+
+			vgui::surface()->PlaySound( soundFilename );
+		}
+
+		m_Items[iIndex].iQuantity--;
+
+		EconUI()->Gamestats_Store( IE_STORE_ITEM_REMOVED_FROM_CART, NULL, NULL, 0, &m_Items[iIndex] );
+
+		if ( m_Items[iIndex].iQuantity <= 0 )
+		{
+			m_Items.Remove(iIndex);
+		}
+	}
+
+	IGameEvent *event = gameeventmanager->CreateEvent( "cart_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStoreCart::EmptyCart( void )
+{
+	m_Items.Purge();
+
+	IGameEvent *event = gameeventmanager->CreateEvent( "cart_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CStoreCart::GetIndexForEntry( const econ_store_entry_t *pEntry, ECartItemType eCartItemType ) const
+{
+	FOR_EACH_VEC( m_Items, i )
+	{
+		if ( m_Items[i].pEntry == pEntry && m_Items[i].eType == eCartItemType )
+			return i;
+	}
+	return -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CStoreCart::GetTotalItems( void ) const
+{
+	int iTotal = 0;
+	FOR_EACH_VEC( m_Items, i )
+	{
+		const cart_item_t &item = m_Items[i];
+		iTotal += item.iQuantity;
+	}
+	return iTotal;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	CStoreCart::GetTotalConcreteItems( void ) const
+{
+	int iTotal = 0;
+	FOR_EACH_VEC( m_Items, i )
+	{
+		const cart_item_t &item = m_Items[i];
+#ifdef TF_CLIENT_DLL
+		CEconItemDefinition *pDef = ItemSystem()->GetStaticDataForItemByDefIndex( item.pEntry->GetItemDefinitionIndex() );
+		iTotal += pDef->GetNumConcreteItems() * item.iQuantity;
+#else
+		// Kyle says: this logic is totally wrong but we don't *have* a CStrike
+		//			  economy so I don't feel bad using this to get the build working.
+		iTotal += item.iQuantity;
+#endif
+	}
+	return iTotal;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+item_price_t cart_item_t::GetDisplayPrice() const
+{
+	const float fPriceScale = eType == kCartItem_TryOutUpgrade
+							? GetEconPriceSheet()->GetPreviewPeriodDiscount()
+							: IsRentalCartItemType( eType )
+							? pEntry->GetRentalPriceScale()
+							: 1.0f;
+
+	return (item_price_t)( pEntry->GetCurrentPrice( EconUI()->GetStorePanel()->GetCurrency() ) * fPriceScale ) * iQuantity;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+item_price_t CStoreCart::GetTotalPrice( void ) const
+{
+	item_price_t unTotal = 0;
+	FOR_EACH_VEC( m_Items, i )
+	{
+		unTotal += m_Items[i].GetDisplayPrice();
+	}
+	return unTotal;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CStoreCart::ContainsHolidayRestrictedItems() const
+{
+	FOR_EACH_VEC( m_Items, i )
+	{
+		CEconItemDefinition *pItemDef = ItemSystem()->GetStaticDataForItemByDefIndex( m_Items[i].pEntry->GetItemDefinitionIndex() );
+		if ( !pItemDef )
+			continue;
+
+		// If the string isn't empty, assume it has a restriction
+		if ( pItemDef->GetHolidayRestriction() )
+			return true;
+
+		const bundleinfo_t *pBundle = pItemDef->GetBundleInfo();
+		if ( pBundle )
+		{
+			FOR_EACH_VEC( pBundle->vecItemDefs, j )
+			{
+				if ( pBundle->vecItemDefs[j]->GetHolidayRestriction() )
+					return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CStoreCart::ContainsItemDefinition( item_definition_index_t unItemDef ) const
+{
+	FOR_EACH_VEC( m_Items, i )
+	{
+		if ( m_Items[i].pEntry->GetItemDefinitionIndex() == unItemDef )
+			return true;
+	}
+
+	return false;
+}
+
+//================================================================================================================================
+// STORE STATUS DIALOG
+//================================================================================================================================
+static vgui::DHANDLE<CStoreStatusDialog> g_StoreStatusPanel;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CStoreStatusDialog::CStoreStatusDialog( vgui::Panel *pParent, const char *pElementName ) : BaseClass( pParent, "StoreStatusDialog" )
+{
+	vgui::HScheme scheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme");
+	SetScheme(scheme);
+	SetProportional( true );
+	m_bNotifyOnCancel = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStoreStatusDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	LoadControlSettings( "resource/UI/econ/store/v1/StoreStatusDialog.res" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStoreStatusDialog::OnCommand( const char *command )
+{
+	bool bClose = false;
+
+	if ( !Q_stricmp( command, "close" ) )
+	{
+		bClose = true;
+
+		if ( m_bShowOnExit )
+		{
+			InventoryManager()->ShowItemsPickedUp( true );
+		}
+	}
+	else if ( !Q_stricmp( command, "forceclose" ) )
+	{
+		bClose = true;
+	}
+
+	if ( bClose )
+	{
+		if ( m_bNotifyOnCancel )
+		{
+			EconUI()->GetStorePanel()->CheckoutCancel();
+			m_bNotifyOnCancel = false;
+		}
+
+		m_bShowOnExit = false;
+		TFModalStack()->PopModal( this );
+		SetVisible( false );
+		MarkForDeletion();
+		return;
+	}
+
+	BaseClass::OnCommand( command );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStoreStatusDialog::UpdateSchemeForVersion()
+{
+	InvalidateLayout( false, true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CStoreStatusDialog::ShowStatusUpdate( bool bAllowClose, bool bShowOnExit, bool bCancel )
+{
+	CExButton *pButton = dynamic_cast<CExButton*>( FindChildByName("CloseButton") );
+	if ( pButton )
+	{
+		pButton->SetVisible( bAllowClose );
+		pButton->SetEnabled( bAllowClose );
+		if ( bCancel )
+		{
+			pButton->SetText( "#Store_CANCEL" );
+			m_bNotifyOnCancel = true;
+		}
+		else
+		{
+			pButton->SetText( "#Store_OK" );
+			m_bNotifyOnCancel = false;
+		}
+	}
+
+	m_bShowOnExit = bShowOnExit;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void SetupStoreStatusDialog( vgui::Panel *pParent )
+{
+	// If we parent it to something, we get problems when another panel pops over it, 
+	// because the modal dialog is no longer visible. So prevent parenting status dialogs.
+	pParent = NULL;
+
+	if ( !g_StoreStatusPanel.Get() )
+	{
+		g_StoreStatusPanel = vgui::SETUP_PANEL( new CStoreStatusDialog( pParent, NULL ) );
+	}
+	g_StoreStatusPanel->SetVisible( true );
+	if ( !pParent )
+	{
+		g_StoreStatusPanel->MakePopup();
+	}
+
+	g_StoreStatusPanel->MoveToFront();
+	g_StoreStatusPanel->SetKeyBoardInputEnabled(true);
+	g_StoreStatusPanel->SetMouseInputEnabled(true);
+	TFModalStack()->PushModal( g_StoreStatusPanel );
+}
+
+void OpenStoreStatusDialog( vgui::Panel *pParent, const char *pszText, bool bAllowClose, bool bShowOnExit, bool bCancel )
+{
+	// Figure out who we should be parented to
+	if ( !pParent )
+	{
+		CStoreViewCartPanel *pCartPanel = GetStoreViewCartPanel();
+		if ( pCartPanel && pCartPanel->IsVisible() )
+		{
+			pParent = pCartPanel;
+		}
+		else if ( EconUI()->GetStorePanel() && EconUI()->GetStorePanel()->IsVisible() )
+		{
+			pParent = EconUI()->GetStorePanel();
+		}
+	}
+
+	SetupStoreStatusDialog( pParent );
+	g_StoreStatusPanel->UpdateSchemeForVersion();
+	g_StoreStatusPanel->SetDialogVariable( "updatetext", g_pVGuiLocalize->Find( pszText ) );
+	g_StoreStatusPanel->ShowStatusUpdate( bAllowClose, bShowOnExit, bCancel );
+}
+
+void CloseStoreStatusDialog( void )
+{
+	if ( g_StoreStatusPanel )
+	{
+		g_StoreStatusPanel->OnCommand( "forceclose" );
+	}
+}
+
+#ifdef _DEBUG
+CON_COMMAND( re_add_store_page, "" )
+{
+	CStorePanel *pStorePanel = EconUI()->GetStorePanel();
+	if ( !pStorePanel )
+		return;
+
+	if ( args.ArgC() != 2 )
+	{
+		Warning( "Need a page index argument.\n" );
+		return;
+	}
+
+	pStorePanel->ReAddPage( atoi( args[ 1 ] ) );
+}
+#endif
+
+// these are disabled because they don't work anymore.
+#ifdef ENABLE_TEST_PURCHASE_COMMANDS
+
+//================================================================================================================================
+//================================================================================================================================
+//================================================================================================================================
+// TEST JOBS
+//================================================================================================================================
+//================================================================================================================================
+//================================================================================================================================
+
+
+
+
+CON_COMMAND( store_getuserdata, "Gets the latest pricesheet from the GC" )
+{
+	RTime32 rTimeVersion = 0;
+	if ( args.ArgC() > 1 )
+	{
+		rTimeVersion = V_atoi( args[1] );
+	}
+
+	CGCClientJobTESTGetUserData *pJob = new CGCClientJobTESTGetUserData( GCClientSystem()->GetGCClient(), rTimeVersion );
+	pJob->StartJob( NULL );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Dev-only command and job for initiating a purchase
+//-----------------------------------------------------------------------------
+class CGCClientJobTESTInitPurchase : public GCSDK::CGCClientJob
+{
+public:
+	CGCClientJobTESTInitPurchase( GCSDK::CGCClient *pGCClient ) : GCSDK::CGCClientJob( pGCClient ) {}
+	virtual bool BYieldingRunJob( void *pvStartParam )
+	{
+		GCSDK::CGCMsg<MsgGCStorePurchaseInit_t> msg( k_EMsgGCStorePurchaseInit );
+		GCSDK::CGCMsg<MsgGCStorePurchaseInitResponse_t> msgResponse;
+
+		CStorePanel *pStore = GetStorePanel();
+		if  ( !pStore )
+		{
+			Msg( "store_initpurchase: Store has not been initialized\n" );
+			return false;
+		}
+
+		CStoreCart *pCart = pStore->GetCart();
+
+		msg.Body().m_eCurrency = pStore->GetCurrency();
+		V_strncpy( msg.Body().m_rgchCountry, pStore->GetCountryCode(), sizeof( msg.Body().m_rgchCountry ) );
+		msg.Body().m_eLanguage = steamapicontext->SteamApps() ? PchLanguageToELanguage( steamapicontext->SteamApps()->GetCurrentGameLanguage() ) : k_Lang_English;
+		msg.Body().m_cLineItems = pCart->GetNumEntries();
+
+		// We really should check for zero items here and not let the purchase go through.
+		// Also, GetTotalItems() needs to be < 256
+
+		for ( int i = 0; i < pCart->GetNumEntries(); i++ )
+		{
+			cart_item_t *pCartItem = pCart->GetItem( i );
+			msg.AddUint16Data( pCartItem->pEntry->m_usDefIndex );
+			msg.AddUint8Data( pCartItem->iQuantity );
+			msg.AddUint16Data( pCartItem->iQuantity * pCartItem->pEntry->GetPrice( (ECurrency)msg.Body().m_eCurrency ) );
+		}
+
+		if ( !BYldSendMessageAndGetReply( msg, 10, &msgResponse, k_EMsgGCStorePurchaseInitResponse ) )
+		{
+			Msg( "store_initpurchase: No response from the GC\n" );
+			return false;
+		}
+
+		Msg( "Got response. Result: %d, TxnID: %llu\n", msgResponse.Body().m_eResult, msgResponse.Body().m_unTxnID );
+
+		return true;
+	}
+};
+
+CON_COMMAND( store_initpurchase, "Simulates pressing the checkout button in the store" )
+{
+	CGCClientJobTESTInitPurchase *pJob = new CGCClientJobTESTInitPurchase( GCClientSystem()->GetGCClient() );
+	pJob->StartJob( NULL );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Dev-only command and job for canceling a purchase
+//-----------------------------------------------------------------------------
+class CGCClientJobTESTCancelPurchase : public GCSDK::CGCClientJob
+{
+public:
+	CGCClientJobTESTCancelPurchase( GCSDK::CGCClient *pGCClient, uint64 ulTxnID ) : GCSDK::CGCClientJob( pGCClient ), m_ulTxnID( ulTxnID ) {}
+	virtual bool BYieldingRunJob( void *pvStartParam )
+	{
+		GCSDK::CGCMsg<MsgGCStorePurchaseCancel_t> msg( k_EMsgGCStorePurchaseCancel );
+		GCSDK::CGCMsg<MsgGCStorePurchaseCancelResponse_t> msgResponse;
+
+		msg.Body().m_ulTxnID = m_ulTxnID;
+
+		if ( !BYldSendMessageAndGetReply( msg, 10, &msgResponse, k_EMsgGCStorePurchaseCancelResponse ) )
+		{
+			Msg( "store_cancelpurchase: No response from the GC\n" );
+			return false;
+		}
+
+		Msg( "Got response. Result: %d\n", msgResponse.Body().m_eResult );
+		return true;
+	}
+
+private:
+	uint64 m_ulTxnID;
+};
+
+CON_COMMAND( store_cancelpurchase, "<TxnID> Simulates cancelling a purchase" )
+{
+	
+	if ( args.ArgC() < 2 )
+	{
+		Msg( store_cancelpurchase_command.GetHelpText() );	
+	}
+
+	uint64 ulTxnID;
+	ulTxnID = V_atoui64( args[1] );
+
+	CGCClientJobTESTCancelPurchase *pJob = new CGCClientJobTESTCancelPurchase( GCClientSystem()->GetGCClient(), ulTxnID );
+	pJob->StartJob( NULL );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Dev-only command and job for finalizing a purchase
+//-----------------------------------------------------------------------------
+class CGCClientJobTESTFinalizePurchase : public GCSDK::CGCClientJob
+{
+public:
+	CGCClientJobTESTFinalizePurchase( GCSDK::CGCClient *pGCClient, uint64 ulTxnID ) : GCSDK::CGCClientJob( pGCClient ), m_ulTxnID( ulTxnID ) {}
+	virtual bool BYieldingRunJob( void *pvStartParam )
+	{
+		GCSDK::CGCMsg<MsgGCStorePurchaseFinalize_t> msg( k_EMsgGCStorePurchaseFinalize );
+		GCSDK::CGCMsg<MsgGCStorePurchaseFinalizeResponse_t> msgResponse;
+
+		msg.Body().m_ulTxnID = m_ulTxnID;
+
+		if ( !BYldSendMessageAndGetReply( msg, 10, &msgResponse, k_EMsgGCStorePurchaseFinalizeResponse ) )
+		{
+			Msg( "store_finalizepurchase: No response from the GC\n" );
+			return false;
+		}
+
+		Msg( "Got response. Result: %d, Num Items: %d, Purchased Items:\n", msgResponse.Body().m_eResult, msgResponse.Body().m_cItemIDs );
+		if ( k_EPurchaseResultOK == msgResponse.Body().m_eResult )
+		{
+			for ( uint32 i = 0; i < msgResponse.Body().m_cItemIDs; i++ )
+			{
+				uint64 ulItemID;
+				if ( !msgResponse.BReadUint64Data( &ulItemID ) )
+				{
+					Msg( "Error: Underflow in msgResponse\n" );
+					break;
+				}
+
+				Msg( "\t%llu\n", ulItemID );
+			}
+		}
+
+		return true;
+	}
+
+private:
+	uint64 m_ulTxnID;
+};
+
+CON_COMMAND( store_finalizepurchase, "<TxnID> Simulates finalizing a purchase" )
+{
+
+	if ( args.ArgC() < 2 )
+	{
+		Msg( store_finalizepurchase_command.GetHelpText() );	
+	}
+
+	uint64 ulTxnID;
+	ulTxnID = V_atoui64( args[1] );
+
+	CGCClientJobTESTFinalizePurchase *pJob = new CGCClientJobTESTFinalizePurchase( GCClientSystem()->GetGCClient(), ulTxnID );
+	pJob->StartJob( NULL );
+}
+
+#endif