1HEADmaster

1 files changed, 3427 insertions, 0 deletions

diff --git a/game/client/tf/tf_hud_mainmenuoverride.cpp b/game/client/tf/tf_hud_mainmenuoverride.cpp
new file mode 100644
index 0000000..3d52a78
--- /dev/null
+++ b/game/client/tf/tf_hud_mainmenuoverride.cpp
@@ -0,0 +1,3427 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "tf_hud_mainmenuoverride.h"
+#include "ienginevgui.h"
+#include "tf_viewport.h"
+#include "clientmode_tf.h"
+#include "confirm_dialog.h"
+#include <vgui/ILocalize.h>
+#include "tf_controls.h"
+#include "tf_gamerules.h"
+#include "tf_statsummary.h"
+#include "rtime.h"
+#include "tf_gcmessages.h"
+#include "econ_notifications.h"
+#include "c_tf_freeaccount.h"
+#include "econ_gcmessages.h"
+#include "econ_item_inventory.h"
+#include "gcsdk/gcclient.h"
+#include "gcsdk/gcclientjob.h"
+#include "econ_item_system.h"
+#include <vgui_controls/AnimationController.h>
+#include "store/store_panel.h"
+#include "gc_clientsystem.h"
+#include <vgui_controls/ScrollBarSlider.h>
+#include "filesystem.h"
+#include "tf_hud_disconnect_prompt.h"
+#include "tf_gc_client.h"
+#include "sourcevr/isourcevirtualreality.h"
+#include "materialsystem/imaterialsystem.h"
+#include "materialsystem/materialsystem_config.h"
+#include "tf_warinfopanel.h"
+#include "quest_log_panel.h"
+#include "tf_item_inventory.h"
+#include "quest_log_panel.h"
+#include "econ_quests.h"
+#include "tf_streams.h"
+#include "tf_matchmaking_shared.h"
+#include "tf_lobby_container_frame_comp.h"
+#include "tf_lobby_container_frame_mvm.h"
+#include "tf_lobby_container_frame_casual.h"
+
+#include "replay/ireplaysystem.h"
+#include "replay/ienginereplay.h"
+#include "replay/vgui/replayperformanceeditor.h"
+#include "materialsystem/itexture.h"
+#include "imageutils.h"
+#include "icommandline.h"
+#include "vgui/ISystem.h"
+#include "report_player_dialog.h"
+
+#ifdef SAXXYMAINMENU_ENABLED
+#include "tf_hud_saxxycontest.h"
+#endif
+
+#include "c_tf_gamestats.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+void AddSubKeyNamed( KeyValues *pKeys, const char *pszName );
+
+extern const char *g_sImagesBlue[];
+extern int EconWear_ToIntCategory( float flWear );
+
+void cc_tf_safemode_toggle( IConVar *pConVar, const char *pOldString, float flOldValue )
+{
+	CHudMainMenuOverride *pMMOverride = (CHudMainMenuOverride*)( gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE ) );
+	if ( pMMOverride )
+	{
+		pMMOverride->InvalidateLayout();
+	}
+}
+
+ConVar tf_recent_achievements( "tf_recent_achievements", "0", FCVAR_ARCHIVE );
+ConVar tf_training_has_prompted_for_training( "tf_training_has_prompted_for_training", "0", FCVAR_ARCHIVE, "Whether the user has been prompted for training" );
+ConVar tf_training_has_prompted_for_offline_practice( "tf_training_has_prompted_for_offline_practice", "0", FCVAR_ARCHIVE, "Whether the user has been prompted to try offline practice." );
+ConVar tf_training_has_prompted_for_forums( "tf_training_has_prompted_for_forums", "0", FCVAR_ARCHIVE, "Whether the user has been prompted to view the new user forums." );
+ConVar tf_training_has_prompted_for_options( "tf_training_has_prompted_for_options", "0", FCVAR_ARCHIVE, "Whether the user has been prompted to view the TF2 advanced options." );
+ConVar tf_training_has_prompted_for_loadout( "tf_training_has_prompted_for_loadout", "0", FCVAR_ARCHIVE, "Whether the user has been prompted to equip something in their loadout." );
+ConVar cl_ask_bigpicture_controller_opt_out( "cl_ask_bigpicture_controller_opt_out", "0", FCVAR_ARCHIVE, "Whether the user has opted out of being prompted for controller support in Big Picture." );
+ConVar cl_mainmenu_operation_motd_start( "cl_mainmenu_operation_motd_start", "0", FCVAR_ARCHIVE | FCVAR_HIDDEN );
+ConVar cl_mainmenu_operation_motd_reset( "cl_mainmenu_operation_motd_reset", "0", FCVAR_ARCHIVE | FCVAR_HIDDEN );
+ConVar cl_mainmenu_safemode( "cl_mainmenu_safemode", "0", FCVAR_NONE, "Enable safe mode", cc_tf_safemode_toggle );
+ConVar cl_mainmenu_updateglow( "cl_mainmenu_updateglow", "1", FCVAR_ARCHIVE | FCVAR_HIDDEN );
+
+void cc_promotional_codes_button_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
+{
+	IViewPortPanel *pMMOverride = ( gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE ) );
+	if ( pMMOverride )
+	{
+		( (CHudMainMenuOverride*)pMMOverride )->UpdatePromotionalCodes();
+	}
+}
+ConVar cl_promotional_codes_button_show( "cl_promotional_codes_button_show", "1", FCVAR_ARCHIVE, "Toggles the 'View Promotional Codes' button in the main menu for players that have used the 'RIFT Well Spun Hat Claim Code'.", cc_promotional_codes_button_changed );
+
+extern bool Training_IsComplete();
+
+//-----------------------------------------------------------------------------
+// Callback to launch the lobby UI
+//-----------------------------------------------------------------------------
+static void CL_OpenMatchmakingLobby( const CCommand &args )
+{
+	if ( GTFGCClientSystem()->GetMatchmakingUIState() != eMatchmakingUIState_InGame )
+	{
+		const char *arg1 = "";
+		if ( args.ArgC() > 1 )
+		{
+			arg1 = args[1];
+		}
+
+		// Make sure we are connected to steam, or they are going to be disappointed
+		if ( steamapicontext == NULL
+			|| steamapicontext->SteamUtils() == NULL
+			|| steamapicontext->SteamMatchmakingServers() == NULL
+			|| steamapicontext->SteamUser() == NULL
+			|| !steamapicontext->SteamUser()->BLoggedOn()
+		) {
+			Warning( "Steam not properly initialized or connected.\n" );
+			ShowMessageBox( "#TF_MM_GenericFailure_Title", "#TF_MM_GenericFailure", "#GameUI_OK" );
+			return;
+		}
+
+		// Make sure we have a GC connection
+		if ( !GCClientSystem()->BConnectedtoGC() )
+		{
+			Warning( "Not connected to GC.\n" );
+			ShowMessageBox( "#TF_MM_NoGC_Title", "#TF_MM_NoGC", "#GameUI_OK" );
+			return;
+		}
+
+		// If we're idle, use our argument to start matchmaking.
+		if ( GTFGCClientSystem()->GetMatchmakingUIState() == eMatchmakingUIState_Inactive )
+		{
+			TF_MatchmakingMode mode = TF_Matchmaking_LADDER;
+			if ( FStrEq( args[1], "mvm" ) )
+			{
+				mode = TF_Matchmaking_MVM;
+			}
+			else if ( FStrEq( args[1], "ladder" ) )
+			{
+				mode = TF_Matchmaking_LADDER;
+			}
+			else if ( FStrEq( args[1], "casual" ) )
+			{
+				mode = TF_Matchmaking_CASUAL;
+			}
+
+			GTFGCClientSystem()->BeginMatchmaking( mode );
+		}
+	}
+
+	CHudMainMenuOverride* pMMOverride = (CHudMainMenuOverride*)( gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE ) );
+	if ( pMMOverride )
+	{
+		switch( GTFGCClientSystem()->GetSearchMode() )
+		{
+		case TF_Matchmaking_MVM:
+			pMMOverride->OpenMvMMMPanel();
+			break;
+
+		case TF_Matchmaking_LADDER:
+			pMMOverride->OpenCompMMPanel();
+			break;
+
+		case TF_Matchmaking_CASUAL:
+			pMMOverride->OpenCasualMMPanel();
+
+		default:
+			return;
+		}
+	}
+}
+
+static ConCommand openmatchmakinglobby_command( "OpenMatchmakingLobby", &CL_OpenMatchmakingLobby, "Activates the matchmaking lobby." );
+
+static void CL_ReloadMMPanels( const CCommand &args )
+{
+	CHudMainMenuOverride* pMMOverride = (CHudMainMenuOverride*)( gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE ) );
+	if ( pMMOverride )
+	{
+		pMMOverride->ReloadMMPanels();
+	}
+}
+ConCommand reload_mm_panels( "reload_mm_panels", &CL_ReloadMMPanels );
+
+//-----------------------------------------------------------------------------
+// Purpose: Prompt the user and ask if they really want to start training (if they are in a game)
+//-----------------------------------------------------------------------------
+class CTFConfirmTrainingDialog : public CConfirmDialog
+{
+	DECLARE_CLASS_SIMPLE( CTFConfirmTrainingDialog, CConfirmDialog );
+public:
+	CTFConfirmTrainingDialog( const char *pText, const char *pTitle, vgui::Panel *parent ) : BaseClass(parent), m_pText( pText ), m_pTitle( pTitle ) {}
+
+	virtual const wchar_t *GetText()
+	{
+		return g_pVGuiLocalize->Find( m_pText );
+	}
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
+	{
+		BaseClass::ApplySchemeSettings( pScheme );
+
+		// Set the X to be bright, and the rest dull
+		if ( m_pConfirmButton )
+		{
+			m_pConfirmButton->SetText( "#TF_Training_Prompt_ConfirmButton" );
+		}
+		if ( m_pCancelButton )
+		{
+			m_pCancelButton->SetText( "#TF_Training_Prompt_CancelButton" );
+		}
+
+		CExLabel *pTitle = dynamic_cast< CExLabel* >( FindChildByName( "TitleLabel" ) );
+		if ( pTitle )
+		{
+			pTitle->SetText( m_pTitle );
+		}
+	}
+protected:
+	const char *m_pText;
+	const char *m_pTitle;
+};
+
+class CCompetitiveAccessInfoPanel : public EditablePanel, public CLocalSteamSharedObjectListener
+{
+	DECLARE_CLASS_SIMPLE( CCompetitiveAccessInfoPanel, EditablePanel );
+public:
+	CCompetitiveAccessInfoPanel( Panel* pParent, const char* pszName )
+		: EditablePanel( pParent, pszName )
+	{
+		m_pPhoneButton = NULL;
+		m_pPremiumButton = NULL;
+		m_pPhoneCheckImage = NULL;
+		m_pPremiumCheckImage = NULL;
+	}
+
+	virtual void ApplySchemeSettings( IScheme *pScheme ) OVERRIDE
+	{
+		BaseClass::ApplySchemeSettings( pScheme );
+		LoadControlSettings( "resource/ui/CompetitiveAccessInfo.res" );
+
+		m_pPhoneButton = FindControl< CExImageButton >( "PhoneButton", true );
+		m_pPremiumButton = FindControl< CExImageButton >( "PremiumButton", true );
+		m_pPhoneCheckImage = FindControl< ImagePanel >( "PhoneCheckImage", true );
+		m_pPremiumCheckImage = FindControl< ImagePanel >( "PremiumCheckImage", true );
+	}
+
+	virtual void PerformLayout() OVERRIDE
+	{
+		BaseClass::PerformLayout();
+
+		bool bIsFreeAccount = IsFreeTrialAccount();
+		if ( m_pPremiumButton )
+		{
+			m_pPremiumButton->SetEnabled( bIsFreeAccount );
+		}
+		if ( m_pPremiumCheckImage )
+		{
+			m_pPremiumCheckImage->SetVisible( !bIsFreeAccount );
+		}
+
+		bool bIsPhoneVerified = GTFGCClientSystem()->BIsPhoneVerified();
+		bool bIsPhoneIdentifying = GTFGCClientSystem()->BIsPhoneIdentifying();
+		bool bPhoneReady = bIsPhoneVerified && bIsPhoneIdentifying;
+		if ( m_pPhoneButton )
+		{
+			m_pPhoneButton->SetEnabled( !bPhoneReady );
+		}
+		if ( m_pPhoneCheckImage )
+		{
+			m_pPhoneCheckImage->SetVisible( bPhoneReady );
+		}
+	}
+
+	virtual void OnCommand(  const char *command ) OVERRIDE
+	{
+		if ( FStrEq( command, "close" ) )
+		{
+			SetVisible( false );
+			return;
+		}
+		else if ( FStrEq( command, "addphone" ) )
+		{
+			if ( steamapicontext && steamapicontext->SteamFriends() )
+			{
+				steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "https://support.steampowered.com/kb_article.php?ref=8625-WRAH-9030#addphone" );
+			}
+			return;
+		}
+		else if ( FStrEq( command, "addpremium" ) )
+		{
+			if ( steamapicontext && steamapicontext->SteamFriends() )
+			{
+				steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "https://steamcommunity.com/sharedfiles/filedetails/?id=143430756" );
+			}
+			return;
+		}
+
+		BaseClass::OnCommand( command );
+	}
+
+	virtual void SOCreated( const CSteamID & steamIDOwner, const CSharedObject *pObject, ESOCacheEvent eEvent ) OVERRIDE
+	{
+		if ( pObject->GetTypeID() != CEconGameAccountClient::k_nTypeID )
+			return;
+
+		if ( GTFGCClientSystem()->BHasCompetitiveAccess() )
+		{
+			SetVisible( false );
+		}
+		else
+		{
+			InvalidateLayout();
+		}
+	}
+
+	virtual void SOUpdated( const CSteamID & steamIDOwner, const CSharedObject *pObject, ESOCacheEvent eEvent ) OVERRIDE
+	{
+		if ( pObject->GetTypeID() != CEconGameAccountClient::k_nTypeID )
+			return;
+
+		if ( GTFGCClientSystem()->BHasCompetitiveAccess() )
+		{
+			SetVisible( false );
+		}
+		else
+		{
+			InvalidateLayout();
+		}
+	}
+
+private:
+	CExImageButton	*m_pPhoneButton;
+	CExImageButton	*m_pPremiumButton;
+	ImagePanel		*m_pPhoneCheckImage;
+	ImagePanel		*m_pPremiumCheckImage;
+};
+DECLARE_BUILD_FACTORY( CCompetitiveAccessInfoPanel );
+
+class CMainMenuPlayListEntry : public EditablePanel
+{
+	DECLARE_CLASS_SIMPLE( CMainMenuPlayListEntry, EditablePanel );
+public:
+
+	enum EDisabledStates_t
+	{
+		NOT_DISABLED = 0,
+		DISABLED_NO_COMP_ACCESS,
+		DISABLED_NO_GC,
+		DISABLED_MATCH_RUNNING,
+
+		NUM_DISABLED_STATES
+	};
+
+	CMainMenuPlayListEntry( Panel* pParent, const char* pszName )
+		: EditablePanel( pParent, pszName )
+	{
+		m_pToolTip = NULL;
+	}
+
+	~CMainMenuPlayListEntry()
+	{
+		if (m_pToolTip != NULL)
+		{
+			delete m_pToolTip;
+			m_pToolTip = NULL;
+		}
+	}
+
+	virtual void ApplySchemeSettings( IScheme *pScheme ) OVERRIDE
+	{
+		BaseClass::ApplySchemeSettings( pScheme );
+		LoadControlSettings( "resource/ui/MainMenuPlayListEntry.res" );
+
+		CExImageButton *pLockImage = FindControl< CExImageButton >("LockImage");
+		if (pLockImage)
+		{
+			EditablePanel *pToolTipPanel = FindControl< EditablePanel >("TooltipPanel");
+			if (pToolTipPanel)
+			{
+				m_pToolTip = new CTFTextToolTip(this);
+				m_pToolTip->SetEmbeddedPanel(pToolTipPanel);
+				pToolTipPanel->MakePopup(false, true);
+				pToolTipPanel->SetKeyBoardInputEnabled(false);
+				pToolTipPanel->SetMouseInputEnabled(false);
+				m_pToolTip->SetText("#TF_Competitive_Requirements");
+				m_pToolTip->SetTooltipDelay(0);
+				pLockImage->SetTooltip(m_pToolTip, "#TF_Competitive_Requirements");
+			}
+		}
+
+		SetDisabledReason( NOT_DISABLED );
+	}
+
+	virtual void ApplySettings( KeyValues *inResourceData ) OVERRIDE
+	{
+		BaseClass::ApplySettings( inResourceData );
+
+		m_strImageName = inResourceData->GetString( "image_name" );
+		m_strButtonCommand = inResourceData->GetString( "button_command" );
+		m_strButtonToken = inResourceData->GetString( "button_token" );
+		m_strDescToken = inResourceData->GetString( "desc_token" );
+	}
+
+	void SetDisabledReason( EDisabledStates_t eReason )
+	{
+		static const DisabledStateDesc_t s_DisabledStates[] = { { NULL,								NULL,				NULL }				// NOT_DISABLED
+															  , { "#TF_Competitive_Requirements",	"comp_access_info", "locked_icon" }		// DISABLED_NO_COMP_ACCESS
+															  , { "#TF_MM_NoGC",					NULL,				"gc_dc"		}		// DISABLED_NO_GC
+															  , { "#TF_Competitive_MatchRunning",			NULL,				NULL } };			// DISABLED_MATCH_RUNNING
+
+		COMPILE_TIME_ASSERT( ARRAYSIZE( s_DisabledStates ) == NUM_DISABLED_STATES );
+
+		const DisabledStateDesc_t& stateDisabled = s_DisabledStates[ eReason ];
+
+		SetControlEnabled( "ModeButton", stateDisabled.m_pszLocToken == NULL );
+		SetControlVisible( "LockImage", stateDisabled.m_pszLocToken != NULL );
+
+		CExImageButton *pLockImage = FindControl< CExImageButton >("LockImage");
+		if ( pLockImage )
+		{
+			if ( stateDisabled.m_pszImageName )
+			{
+				pLockImage->SetSubImage( stateDisabled.m_pszImageName );
+			}
+
+			// Button behavior
+			pLockImage->SetEnabled( stateDisabled.m_pszButtonCommand != NULL );
+			pLockImage->SetCommand( stateDisabled.m_pszButtonCommand );
+			pLockImage->GetImage()->SetVisible( stateDisabled.m_pszImageName != NULL );
+
+			m_pToolTip->SetText( stateDisabled.m_pszLocToken );
+			pLockImage->SetTooltip( m_pToolTip, stateDisabled.m_pszLocToken );
+			m_pToolTip->PerformLayout();
+		}
+	}
+
+	virtual void PerformLayout() OVERRIDE
+	{
+		BaseClass::PerformLayout();
+
+		ImagePanel* pModeImage = FindControl< ImagePanel >( "ModeImage" );
+		if ( pModeImage )
+		{
+			pModeImage->SetImage( m_strImageName );
+		}
+
+		Button* pButton = FindControl< Button >( "ModeButton" );
+		if ( pButton )
+		{
+			pButton->SetCommand( m_strButtonCommand );
+		}
+
+		Label* pLabel = FindControl< Label >( "ModeButton" );
+		if ( pLabel )
+		{
+			pLabel->SetText( m_strButtonToken );
+		}
+		pLabel = FindControl< Label >( "DescLabel" );
+		if ( pLabel )
+		{
+			pLabel->SetText( m_strDescToken );
+		}
+		pLabel = FindControl< Label >( "DescLabelShadow" );
+		if ( pLabel )
+		{
+			pLabel->SetText( m_strDescToken );
+		}
+	}
+
+	
+
+private:
+
+	struct DisabledStateDesc_t
+	{
+		const char* m_pszLocToken;
+		const char* m_pszButtonCommand;
+		const char* m_pszImageName;
+	};
+
+	CUtlString m_strImageName;
+	CUtlString m_strButtonCommand;
+	CUtlString m_strButtonToken;
+	CUtlString m_strDescToken;
+
+	CTFTextToolTip *m_pToolTip;
+};
+
+DECLARE_BUILD_FACTORY( CMainMenuPlayListEntry );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudMainMenuOverride::CHudMainMenuOverride( IViewPort *pViewPort ) : BaseClass( NULL, PANEL_MAINMENUOVERRIDE )
+{
+	// We don't want the gameui to delete us, or things get messy
+	SetAutoDelete( false );
+	SetVisible( true );
+
+	m_bPlayListExpanded = false;
+	m_pVRModeButton = NULL;
+	m_pVRModeBackground = NULL;
+
+	m_pButtonKV = NULL;
+	m_pQuitButton = NULL;
+	m_pDisconnectButton = NULL;
+	m_pBackToReplaysButton = NULL;
+	m_pStoreHasNewItemsImage = NULL;
+
+	m_nLastMOTDRequestAt = 0;
+	m_nLastMOTDRequestLanguage = k_Lang_English;
+	m_bReloadedAllMOTDs = false;
+	m_iCurrentMOTD = -1;
+	m_bInitMOTD = false;
+
+	m_pMOTDPanel = NULL;
+	m_pMOTDShowPanel = NULL;
+	m_pMOTDURLButton = NULL;
+	m_pMOTDNextButton = NULL;
+	m_pMOTDPrevButton = NULL;
+	m_iNotiPanelWide = 0;
+
+	m_pFeaturedItemPanel = NULL;//new CItemModelPanel( m_pStoreSpecialPanel, "FeaturedItemModelPanel" );
+	m_bReapplyButtonKVs = false;
+
+	m_pMouseOverItemPanel = vgui::SETUP_PANEL( new CItemModelPanel( this, "mouseoveritempanel" ) );
+	m_pMouseOverTooltip = new CItemModelPanelToolTip( this );
+	m_pMouseOverTooltip->SetupPanels( this, m_pMouseOverItemPanel );
+	
+	m_pMOTDHeaderLabel = NULL;
+	m_pMOTDHeaderIcon = NULL;
+	m_pMOTDTitleLabel = NULL;
+	m_pMOTDTitleImageContainer = NULL;
+	m_pMOTDTitleImage = NULL;
+	m_hTitleLabelFont = vgui::INVALID_FONT;
+
+	m_pQuestLogButton = new EditablePanel( this, "QuestLogButton" );
+
+#ifdef STAGING_ONLY
+	m_bGeneratingIcons = false;
+	m_pIconData = NULL;
+#endif
+
+	m_bHaveNewMOTDs = false;
+	m_bMOTDShownAtStartup = false;
+
+	m_pCharacterImagePanel = NULL;
+	m_iCharacterImageIdx = -1;
+
+#ifdef SAXXYMAINMENU_ENABLED
+	m_pSaxxyAwardsPanel = NULL;
+	m_pSaxxySettings = NULL;
+#endif
+
+	m_pWarLandingPage = new CWarLandingPanel( this, "WarPanel" );
+
+	m_flCheckTrainingAt = 0;
+	m_bWasInTraining = false;
+	m_flLastWarNagTime = 0.f;
+
+	ScheduleItemCheck();
+
+ 	m_pToolTip = new CMainMenuToolTip( this );
+ 	m_pToolTipEmbeddedPanel = new vgui::EditablePanel( this, "TooltipPanel" );
+	m_pToolTipEmbeddedPanel->MakePopup( false, true );
+	m_pToolTipEmbeddedPanel->SetKeyBoardInputEnabled( false );
+	m_pToolTipEmbeddedPanel->SetMouseInputEnabled( false );
+ 	m_pToolTip->SetEmbeddedPanel( m_pToolTipEmbeddedPanel );
+	m_pToolTip->SetTooltipDelay( 0 );
+
+	ListenForGameEvent( "gc_connected" );
+	ListenForGameEvent( "item_schema_initialized" );
+	ListenForGameEvent( "store_pricesheet_updated" );
+	ListenForGameEvent( "inventory_updated" );
+	ListenForGameEvent( "gameui_activated" );
+	ListenForGameEvent( "party_updated" );
+
+	// Create our MOTD scrollable section
+	m_pMOTDPanel = new vgui::EditablePanel( this, "MOTD_Panel" );
+	m_pMOTDPanel->SetVisible( true );
+	m_pMOTDTextPanel = new vgui::EditablePanel( this, "MOTD_TextPanel" );
+	m_pMOTDTextScroller = new vgui::ScrollableEditablePanel( m_pMOTDPanel, m_pMOTDTextPanel, "MOTD_TextScroller" );
+	
+	m_pMOTDTextScroller->GetScrollbar()->SetAutohideButtons( true );
+	m_pMOTDTextScroller->GetScrollbar()->SetPaintBorderEnabled( false );
+	m_pMOTDTextScroller->GetScrollbar()->SetPaintBackgroundEnabled( false );
+	m_pMOTDTextScroller->GetScrollbar()->GetButton(0)->SetPaintBorderEnabled( false );
+	m_pMOTDTextScroller->GetScrollbar()->GetButton(0)->SetPaintBackgroundEnabled( false );
+	m_pMOTDTextScroller->GetScrollbar()->GetButton(1)->SetPaintBorderEnabled( false );
+	m_pMOTDTextScroller->GetScrollbar()->GetButton(1)->SetPaintBackgroundEnabled( false );
+	m_pMOTDTextScroller->GetScrollbar()->SetAutoResize( PIN_TOPRIGHT, AUTORESIZE_DOWN, -24, 0, -16, 0 );
+
+	m_pMOTDTextLabel = NULL;
+
+	m_pNotificationsShowPanel = NULL;
+	m_pNotificationsPanel = new vgui::EditablePanel( this, "Notifications_Panel" );
+	m_pNotificationsControl = NotificationQueue_CreateMainMenuUIElement( m_pNotificationsPanel, "Notifications_Control" );
+	m_pNotificationsScroller = new vgui::ScrollableEditablePanel( m_pNotificationsPanel, m_pNotificationsControl, "Notifications_Scroller" );
+
+	m_iNumNotifications = 0;
+
+	m_pFeaturedItemMouseOverPanel = new CItemModelPanel( this, "FeaturedItemMouseOverItemPanel" );
+	m_pFeaturedItemToolTip = new CSimplePanelToolTip( this );
+	m_pFeaturedItemToolTip->SetControlledPanel( m_pFeaturedItemMouseOverPanel );
+
+	m_pBackground = new vgui::ImagePanel( this, "Background" );
+	m_pEventPromoContainer = new EditablePanel( this, "EventPromo" );
+	m_pSafeModeContainer = new EditablePanel( this, "SafeMode" );
+
+	// Cause the quest UI to be created
+	GetQuestLog();
+
+	m_bStabilizedInitialLayout = false;
+
+	m_bBackgroundUsesCharacterImages = true;
+
+	m_pWatchStreamsPanel = new CTFStreamListPanel( this, "StreamListPanel" );
+
+	vgui::ivgui()->AddTickSignal( GetVPanel(), 50 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudMainMenuOverride::~CHudMainMenuOverride( void )
+{
+	C_CTFGameStats::ImmediateWriteInterfaceEvent( "interface_close", "main_menu_override" );
+
+	if ( GetClientModeTFNormal()->GameUI() )
+	{
+		GetClientModeTFNormal()->GameUI()->SetMainMenuOverride( NULL );
+	}
+
+	if ( m_pButtonKV )
+	{
+		m_pButtonKV->deleteThis();
+		m_pButtonKV = NULL;
+	}
+
+	// Stop Animation Sequences
+	if ( m_pNotificationsShowPanel )
+	{
+		g_pClientMode->GetViewportAnimationController()->CancelAnimationsForPanel( m_pNotificationsShowPanel );
+	}
+
+	vgui::ivgui()->RemoveTickSignal( GetVPanel() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Override painting traversal to suppress main menu painting if we're not ready to show yet
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::PaintTraverse( bool Repaint, bool allowForce )
+{
+	// Ugly hack: disable painting until we're done screwing around with updating the layout during initialization.
+	// Use -menupaintduringinit command line parameter to reinstate old behavior
+	if ( m_bStabilizedInitialLayout || CommandLine()->CheckParm("-menupaintduringinit") )
+	{
+		BaseClass::PaintTraverse( Repaint, allowForce );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::OnTick()
+{
+	if ( m_iNumNotifications != NotificationQueue_GetNumNotifications() )
+	{
+		m_iNumNotifications = NotificationQueue_GetNumNotifications();
+		UpdateNotifications();
+		CheckForNewQuests();
+	}
+	else if ( m_pNotificationsPanel->IsVisible() )
+	{
+		AdjustNotificationsPanelHeight();
+	}
+
+	static bool s_bRanOnce = false;
+	if ( !s_bRanOnce )
+	{
+		s_bRanOnce = true; 
+		if ( char const *szConnectAdr = CommandLine()->ParmValue( "+connect" ) )
+		{
+			Msg( "Executing deferred connect command: %s\n", szConnectAdr );
+			engine->ExecuteClientCmd( CFmtStr( "connect %s -%s\n", szConnectAdr, "ConnectStringOnCommandline" ) );
+		}
+	}
+
+	// See if its time to nag about joining the war
+	float flTimeSinceWarNag = Plat_FloatTime() - m_flLastWarNagTime;
+	if ( !m_bPlayListExpanded && m_pHighlightAnims[ MMHA_WAR ] && ( flTimeSinceWarNag > 300.f || m_flLastWarNagTime == 0.f ) )
+	{
+		// Make sure our SOCache is ready
+		GCSDK::CGCClientSharedObjectCache *pSOCache = NULL;
+		if ( steamapicontext && steamapicontext->SteamUser() )
+		{
+			CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
+			pSOCache = GCClientSystem()->GetSOCache( steamID );
+		}
+
+		// Need to be initialized.  If we're not, we'll get false positives
+		// when we actually go to look for our war data
+		if ( pSOCache && pSOCache->BIsInitialized() )
+		{
+			m_flLastWarNagTime = Plat_FloatTime();
+
+			// Get war data
+			const CWarDefinition* pWarDef = GetItemSchema()->GetWarDefinitionByIndex( PYRO_VS_HEAVY_WAR_DEF_INDEX );
+			CWarData *pWarData = GetLocalPlayerWarData( pWarDef->GetDefIndex() );
+			war_side_t nAffiliation = INVALID_WAR_SIDE;
+			if ( pWarData )
+			{
+				// Get affiliation if they have one.
+				nAffiliation = pWarData->Obj().affiliation();
+			}
+
+			// They haven't joined the war!  Nag 'em
+			if ( nAffiliation == INVALID_WAR_SIDE && pWarDef->IsActive() )
+			{
+				StartHighlightAnimation( MMHA_WAR );
+			}
+		}
+	}
+
+
+#ifdef STAGING_ONLY
+	if ( m_bGeneratingIcons )
+	{
+		GenerateIconsThink();
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::AttachToGameUI( void )
+{
+	C_CTFGameStats::ImmediateWriteInterfaceEvent( "interface_open",	"main_menu_override" );
+
+	if ( GetClientModeTFNormal()->GameUI() )
+	{
+		GetClientModeTFNormal()->GameUI()->SetMainMenuOverride( GetVPanel() );
+	}
+
+	SetKeyBoardInputEnabled( true );
+	SetMouseInputEnabled( true );
+	SetCursor(dc_arrow);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+ConVar tf_last_store_pricesheet_version( "tf_last_store_pricesheet_version", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE | FCVAR_DONTRECORD | FCVAR_HIDDEN );
+
+void CHudMainMenuOverride::FireGameEvent( IGameEvent *event )
+{
+	const char * type = event->GetName();
+
+	if ( FStrEq( type, "gameui_activated" ) )
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "MMenu_PlayList_Collapse_Immediate", false );
+		m_bPlayListExpanded = false;
+		return;
+	}
+	if ( Q_strcmp( type, "gc_connected" ) == 0 )
+	{
+		char uilanguage[ 64 ];
+		uilanguage[0] = 0;
+		engine->GetUILanguage( uilanguage, sizeof( uilanguage ) );
+
+		//V_strcpy_safe( uilanguage, "german" );
+
+		ELanguage nCurLang = PchLanguageToELanguage( uilanguage );
+
+		// If we've changed language from when we last requested, we ask for all MOTDs again.
+		if ( nCurLang != m_nLastMOTDRequestLanguage )
+		{
+			m_nLastMOTDRequestAt = 0;
+			m_nLastMOTDRequestLanguage = nCurLang;
+			m_bReloadedAllMOTDs = true;
+		}
+
+		// Ask the GC for the MOTD
+		GCSDK::CGCMsg<MsgGCMOTDRequest_t> msg( k_EMsgGCMOTDRequest );
+		msg.Body().m_eLanguage = nCurLang;
+		msg.Body().m_nLastMOTDRequest = m_nLastMOTDRequestAt;
+		GCClientSystem()->BSendMessage( msg );
+
+		// Roll our last asked time forward here. It won't get written to our
+		// cache file if we don't get a response from the GC.
+		CRTime cTimeHack;
+		m_nLastMOTDRequestAt = CRTime::RTime32TimeCur();
+
+		// Load the store info, so we can display the current special
+		CStorePanel::RequestPricesheet();
+		CheckForNewQuests();
+		UpdatePlaylistEntries();
+	}
+	else if ( Q_strcmp( type, "item_schema_initialized" ) == 0 )
+	{
+		// Tell the schema to load its MOTD block from our clientside cache file
+		CUtlVector< CUtlString > vecErrors;
+		KeyValues *pEntriesKV = new KeyValues( "motd_entries");
+		if ( pEntriesKV->LoadFromFile( g_pFullFileSystem, GC_MOTD_CACHE_FILE ) )
+		{
+			// Extract our last MOTD request time
+			const char *pszTime = pEntriesKV->GetString( "last_request_time", NULL );
+			m_nLastMOTDRequestAt = ( pszTime && pszTime[0] ) ? CRTime::RTime32FromString(pszTime) : 0;
+
+			const char *pszLang = pEntriesKV->GetString( "last_request_language", NULL );
+			m_nLastMOTDRequestLanguage = ( pszLang && pszLang[0] ) ? PchLanguageToELanguage(pszLang) : k_Lang_English;
+
+			// Parse the entries
+			GetMOTDManager().BInitMOTDEntries( pEntriesKV, &vecErrors );
+			GetMOTDManager().PurgeUnusedMOTDEntries( pEntriesKV );
+		}
+	}
+	else if ( Q_strcmp( type, "store_pricesheet_updated" ) == 0 )
+	{
+		// If the contents of the store have changed since the last time we went in and/or launched
+		// the game, change the button color so that players know there's new content available.
+		if ( EconUI() &&
+			 EconUI()->GetStorePanel() &&
+			 EconUI()->GetStorePanel()->GetPriceSheet() )
+		{
+			const CEconStorePriceSheet *pPriceSheet = EconUI()->GetStorePanel()->GetPriceSheet();
+
+			// The cvar system can't deal with integers that lose data when represented as floating point
+			// numbers. We don't really care about supreme accuracy for detecting changes -- worst case if
+			// we change the price sheet almost exactly 18 hours apart, some subset of players won't get the
+			// "new!" label and that's fine.
+			const uint32 unPriceSheetVersion = (uint32)pPriceSheet->GetVersionStamp() & 0xffff;
+
+			if ( unPriceSheetVersion != (uint32)tf_last_store_pricesheet_version.GetInt() )
+			{
+				tf_last_store_pricesheet_version.SetValue( (int)unPriceSheetVersion );
+
+				if ( m_pStoreHasNewItemsImage )
+				{
+					m_pStoreHasNewItemsImage->SetVisible( true );
+				}
+			}
+		}
+
+		// might as well do this here too
+		UpdatePromotionalCodes();
+
+		LoadCharacterImageFile();
+
+		if ( NeedsToChooseMostHelpfulFriend() )
+		{
+			NotifyNeedsToChooseMostHelpfulFriend();
+		}
+	}
+	else if ( FStrEq( "inventory_updated", type ) )
+	{
+		CheckForNewQuests();
+	}
+	else if ( FStrEq( "party_updated", type ) )
+	{
+		UpdatePlaylistEntries();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::ApplySettings( KeyValues *inResourceData )
+{
+	BaseClass::ApplySettings( inResourceData );
+
+	KeyValues *pItemKV = inResourceData->FindKey( "button_kv" );
+	if ( pItemKV )
+	{
+		if ( m_pButtonKV )
+		{
+			m_pButtonKV->deleteThis();
+		}
+		m_pButtonKV = new KeyValues("button_kv");
+		pItemKV->CopySubkeys( m_pButtonKV );
+		
+		m_bReapplyButtonKVs = true;
+	}
+
+#ifdef SAXXYMAINMENU_ENABLED
+	KeyValues *pSaxxySettings = inResourceData->FindKey( "SaxxySettings" );
+	if ( pSaxxySettings )
+	{
+		if ( m_pSaxxySettings )
+		{
+			m_pSaxxySettings->deleteThis();
+		}
+		m_pSaxxySettings = pSaxxySettings->MakeCopy();
+
+		if ( m_pSaxxyAwardsPanel )
+		{
+			m_pSaxxyAwardsPanel->ApplySettings( m_pSaxxySettings );
+		}
+	}
+#endif
+
+	m_bPlayListExpanded = false;
+
+	UpdatePlaylistEntries();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::ApplySchemeSettings( IScheme *scheme )
+{
+	// We need to re-hook ourselves up to the TF client scheme, because the GameUI will try to change us their its scheme
+	vgui::HScheme pScheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme");
+	SetScheme(pScheme);
+	SetProportional( true );
+
+	m_pFeaturedItemMouseOverPanel->InvalidateLayout( true, true );
+	m_bBackgroundUsesCharacterImages = true;
+
+	bool bHolidayActive = false;
+	KeyValues *pConditions = NULL;
+	const char *pszHoliday = UTIL_GetActiveHolidayString();
+	if ( pszHoliday && pszHoliday[0] )
+	{
+		pConditions = new KeyValues( "conditions" );
+
+		char szCondition[64];
+		Q_snprintf( szCondition, sizeof( szCondition ), "if_%s", pszHoliday );
+		AddSubKeyNamed( pConditions, szCondition );
+
+		if ( FStrEq( pszHoliday, "halloween" ) )
+		{
+			// for Halloween we also want to pick a random background
+			int nBackground = RandomInt( 0, 4 );
+			AddSubKeyNamed( pConditions, CFmtStr( "if_halloween_%d", nBackground ) );
+			if ( ( nBackground == 3 ) || ( nBackground == 4 ) )
+			{
+				m_bBackgroundUsesCharacterImages = false;
+			}
+		}
+
+		bHolidayActive = true;
+	}
+
+	if ( !bHolidayActive )
+	{
+		FOR_EACH_MAP_FAST( GetItemSchema()->GetOperationDefinitions(), iOperation )
+		{
+			CEconOperationDefinition *pOperation = GetItemSchema()->GetOperationDefinitions()[iOperation];
+			if ( !pOperation || !pOperation->IsActive() || !pOperation->IsCampaign() )
+				continue;
+
+			if ( !pConditions )
+				pConditions = new KeyValues( "conditions" );
+
+			AddSubKeyNamed( pConditions, "if_operation" );
+			break;
+		}
+	}
+
+	if ( !pConditions )
+	{
+		pConditions = new KeyValues( "conditions" );
+	}
+
+	// Put in ratio condition
+	float aspectRatio = engine->GetScreenAspectRatio();
+	AddSubKeyNamed( pConditions, aspectRatio >= 1.6 ? "if_wider" : "if_taller" );
+
+	RemoveAllMenuEntries();
+
+	LoadControlSettings( "resource/UI/MainMenuOverride.res", NULL, NULL, pConditions );
+
+	BaseClass::ApplySchemeSettings( vgui::scheme()->GetIScheme(pScheme) );
+
+	if ( pConditions )
+	{
+		pConditions->deleteThis();
+	}
+
+	m_pQuitButton = dynamic_cast<CExButton*>( FindChildByName("QuitButton") );
+	m_pDisconnectButton = dynamic_cast<CExButton*>( FindChildByName("DisconnectButton") );
+	m_pBackToReplaysButton = dynamic_cast<CExButton*>( FindChildByName("BackToReplaysButton") );
+	m_pStoreHasNewItemsImage = dynamic_cast<ImagePanel*>( FindChildByName( "StoreHasNewItemsImage", true ) );
+
+	{
+		Panel *pButton = FindChildByName( "VRModeButton" );
+		if( pButton )
+		{
+			m_pVRModeButton = dynamic_cast< CExButton *>( pButton->GetChild( 0 ) );
+		}
+	}
+	m_pVRModeBackground = FindChildByName( "VRBGPanel" );
+
+	bool bShowVR = materials->GetCurrentConfigForVideoCard().m_nVRModeAdapter == materials->GetCurrentAdapter();
+	if ( m_pVRModeBackground )
+	{
+		m_pVRModeBackground->SetVisible( bShowVR );
+	}
+
+	m_bIsDisconnectText = true;
+
+	// Tell all the MOTD buttons that we want their messages
+	m_pMOTDPrevButton = dynamic_cast<CExImageButton*>( m_pMOTDPanel->FindChildByName("MOTD_PrevButton") );
+	m_pMOTDNextButton = dynamic_cast<CExImageButton*>( m_pMOTDPanel->FindChildByName("MOTD_NextButton") );
+	m_pMOTDURLButton = dynamic_cast<CExButton*>( m_pMOTDPanel->FindChildByName("MOTD_URLButton") );
+
+	// m_pNotificationsShowPanel shows number of unread notifications. Pressing it pops up the first notification.
+	m_pNotificationsShowPanel = dynamic_cast<vgui::EditablePanel*>( FindChildByName("Notifications_ShowButtonPanel") );
+
+	m_iNotiPanelWide = m_pNotificationsPanel->GetWide();
+
+	// m_pMOTDShowPanel shows that the player has an unread MOTD. Pressing it pops up the MOTD.
+	m_pMOTDShowPanel = dynamic_cast<vgui::EditablePanel*>( FindChildByName("MOTD_ShowButtonPanel") );
+
+	vgui::EditablePanel* pHeaderContainer = dynamic_cast<vgui::EditablePanel*>( m_pMOTDPanel->FindChildByName( "MOTD_HeaderContainer" ) );
+	if ( pHeaderContainer )
+	{
+		m_pMOTDHeaderLabel = dynamic_cast<vgui::Label*>( pHeaderContainer->FindChildByName( "MOTD_HeaderLabel" ) );
+	}
+
+	m_pMOTDHeaderIcon = dynamic_cast<vgui::ImagePanel*>( m_pMOTDPanel->FindChildByName("MOTD_HeaderIcon") );
+
+	m_pMOTDTitleLabel = dynamic_cast<vgui::Label*>( m_pMOTDPanel->FindChildByName("MOTD_TitleLabel") );
+	if ( m_pMOTDTitleLabel )
+	{
+		m_hTitleLabelFont = m_pMOTDTitleLabel->GetFont();
+	}
+	
+	m_pMOTDTextLabel = dynamic_cast<vgui::Label*>( m_pMOTDTextPanel->FindChildByName( "MOTD_TextLabel" ) );
+	
+	m_pMOTDTitleImageContainer = dynamic_cast<vgui::EditablePanel*>( m_pMOTDPanel->FindChildByName("MOTD_TitleImageContainer") );
+	if ( m_pMOTDTitleImageContainer )
+	{
+		m_pMOTDTitleImage = dynamic_cast<vgui::ImagePanel*>( m_pMOTDTitleImageContainer->FindChildByName("MOTD_TitleImage") );
+	}
+
+	m_pNotificationsScroller->GetScrollbar()->SetAutohideButtons( true );
+	m_pNotificationsScroller->GetScrollbar()->SetPaintBorderEnabled( false );
+	m_pNotificationsScroller->GetScrollbar()->SetPaintBackgroundEnabled( false );
+	m_pNotificationsScroller->GetScrollbar()->GetButton(0)->SetPaintBorderEnabled( false );
+	m_pNotificationsScroller->GetScrollbar()->GetButton(0)->SetPaintBackgroundEnabled( false );
+	m_pNotificationsScroller->GetScrollbar()->GetButton(1)->SetPaintBorderEnabled( false );
+	m_pNotificationsScroller->GetScrollbar()->GetButton(1)->SetPaintBackgroundEnabled( false );
+
+	// Add tooltips for various buttons
+	CExImageButton *pImageButton = dynamic_cast<CExImageButton *>( FindChildByName("CommentaryButton") );
+	if ( pImageButton )
+	{
+		pImageButton->SetTooltip( m_pToolTip, "#MMenu_Tooltip_Commentary" );
+	}
+	pImageButton = dynamic_cast<CExImageButton *>( FindChildByName("CoachPlayersButton") );
+	if ( pImageButton )
+	{
+		pImageButton->SetTooltip( m_pToolTip, "#MMenu_Tooltip_Coach" );
+	}
+	pImageButton = dynamic_cast<CExImageButton *>( FindChildByName("ReportBugButton") );
+	if ( pImageButton )
+	{
+		pImageButton->SetTooltip( m_pToolTip, "#MMenu_Tooltip_ReportBug" );
+	}
+	pImageButton = dynamic_cast<CExImageButton *>( FindChildByName("AchievementsButton") );
+	if ( pImageButton )
+	{
+		pImageButton->SetTooltip( m_pToolTip, "#MMenu_Tooltip_Achievements" );
+	}
+	pImageButton = dynamic_cast<CExImageButton *>( FindChildByName("NewUserForumsButton") );
+	if ( pImageButton )
+	{
+		pImageButton->SetTooltip( m_pToolTip, "#MMenu_Tooltip_NewUserForum" );
+	}
+	pImageButton = dynamic_cast<CExImageButton *>( FindChildByName("ReplayButton") );
+	if ( pImageButton )
+	{
+		pImageButton->SetTooltip( m_pToolTip, "#MMenu_Tooltip_Replay" );
+	}
+	pImageButton = dynamic_cast<CExImageButton *>( FindChildByName("WorkshopButton") );
+	if ( pImageButton )
+	{
+		pImageButton->SetTooltip( m_pToolTip, "#MMenu_Tooltip_Workshop" );
+	}
+	
+	// Highlights
+	m_pHighlightAnims[ MMHA_TUTORIAL ]		= FindControl< CExplanationPopup >( "TutorialHighlight" );
+	m_pHighlightAnims[ MMHA_PRACTICE ]		= FindControl< CExplanationPopup >( "PracticeHighlight" );
+	m_pHighlightAnims[ MMHA_NEWUSERFORUM ]	= FindControl< CExplanationPopup >( "NewUserForumHighlight" );
+	m_pHighlightAnims[ MMHA_OPTIONS ]		= FindControl< CExplanationPopup >( "OptionsHighlightPanel" );
+	m_pHighlightAnims[ MMHA_LOADOUT ]		= FindControl< CExplanationPopup >( "LoadoutHighlightPanel" );
+	m_pHighlightAnims[ MMHA_STORE ]			= FindControl< CExplanationPopup >( "StoreHighlightPanel" );
+	m_pHighlightAnims[ MMHA_WAR ]			= FindControl< CExplanationPopup >( "WarHighlightPanel" );
+
+	m_pCompetitiveAccessInfo = dynamic_cast<vgui::EditablePanel*>( FindChildByName("CompetitiveAccessInfoPanel") );
+
+	LoadCharacterImageFile();
+
+	RemoveAllMenuEntries();
+	LoadMenuEntries();
+	
+	UpdateNotifications();
+	UpdatePromotionalCodes();
+
+	ScheduleTrainingCheck( false );
+
+	PerformKeyRebindings();
+	CheckForNewQuests();
+
+	// Asking for these will create them if they dont already exist.
+	GetCasualLobbyPanel()->InvalidateLayout( false, true );
+	GetCompLobbyPanel()->InvalidateLayout( false, true );
+	GetMvMLobbyPanel()->InvalidateLayout( false, true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::LoadCharacterImageFile( void )
+{
+	if ( !m_bBackgroundUsesCharacterImages )
+		return;
+
+	m_pCharacterImagePanel = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "TFCharacterImage" ) );
+	if ( m_pCharacterImagePanel )
+	{
+		KeyValues *pCharacterFile = new KeyValues( "CharacterBackgrounds" );
+
+		if ( pCharacterFile->LoadFromFile( g_pFullFileSystem, "scripts/CharacterBackgrounds.txt" ) )
+		{
+			CUtlVector<KeyValues *> vecUseableCharacters;
+
+			const char* pszActiveWarName = NULL;
+			const WarDefinitionMap_t& mapWars = GetItemSchema()->GetWarDefinitions();
+			FOR_EACH_MAP_FAST( mapWars, i )
+			{
+				const CWarDefinition* pWarDef = mapWars[i];
+				if ( pWarDef->IsActive() )
+				{
+					pszActiveWarName = pWarDef->GetDefName();
+					break;
+				}
+			}
+
+			// Count the number of possible characters.
+			FOR_EACH_SUBKEY( pCharacterFile, pCharacter )
+			{
+				EHoliday eHoliday = (EHoliday)UTIL_GetHolidayForString( pCharacter->GetString( "holiday_restriction" ) );
+				const char* pszAssociatedWar = pCharacter->GetString( "war_restriction" );	
+
+				int iWeight = 1;
+
+				// If a War is active, that's all we want to show.  If not, then bias towards holidays
+				if ( pszActiveWarName != NULL )
+				{
+					if ( !FStrEq( pszAssociatedWar, pszActiveWarName ) )
+					{
+						iWeight = 0;
+					}
+				}
+				else if ( eHoliday != kHoliday_None )
+				{
+					iWeight = UTIL_IsHolidayActive( eHoliday ) ? 6 : 0;
+				}
+
+				for ( int i = 0; i < iWeight; i++ )
+				{
+					vecUseableCharacters.AddToTail( pCharacter );
+				}
+			}
+
+			// Pick a character at random.
+			if ( m_iCharacterImageIdx < 0 && vecUseableCharacters.Count() > 0 )
+			{
+				m_iCharacterImageIdx = rand() % vecUseableCharacters.Count();
+			}
+
+			// Make sure we found a character we can use.
+			if ( vecUseableCharacters.IsValidIndex( m_iCharacterImageIdx ) )
+			{
+				KeyValues *pCharacter = vecUseableCharacters[m_iCharacterImageIdx];
+
+				if ( IsFreeTrialAccount( ) && m_pHighlightAnims[ MMHA_STORE ] && !m_bPlayListExpanded )
+				{
+					const char* text = pCharacter->GetString( "store_text" );
+					if ( text )
+					{
+						m_pHighlightAnims[ MMHA_STORE ]->SetDialogVariable( "highlighttext", g_pVGuiLocalize->Find( text ) );
+						StartHighlightAnimation( MMHA_STORE );
+					}
+				}
+
+				const char* image_name = pCharacter->GetString( "image" );
+				m_pCharacterImagePanel->SetImage( image_name );
+			}
+		}
+
+		pCharacterFile->deleteThis();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::LoadMenuEntries( void )
+{
+	KeyValues *datafile = new KeyValues("GameMenu");
+	datafile->UsesEscapeSequences( true );	// VGUI uses escape sequences
+	bool bLoaded = datafile->LoadFromFile( g_pFullFileSystem, "Resource/GameMenu.res", "custom_mod" );
+	if ( !bLoaded )
+	{
+		bLoaded = datafile->LoadFromFile( g_pFullFileSystem, "Resource/GameMenu.res", "vgui" );
+		if ( !bLoaded )
+		{
+			// only allow to load loose files when using insecure mode
+			if ( CommandLine()->FindParm( "-insecure" ) )
+			{
+				bLoaded = datafile->LoadFromFile( g_pFullFileSystem, "Resource/GameMenu.res" );
+			}
+		}
+	}
+
+	for (KeyValues *dat = datafile->GetFirstSubKey(); dat != NULL; dat = dat->GetNextKey())
+	{
+		const char *label = dat->GetString("label", "<unknown>");
+		const char *cmd = dat->GetString("command", NULL);
+		const char *name = dat->GetName();
+		int iStyle = dat->GetInt("style", 0 );
+
+		if ( !cmd || !cmd[0] )
+		{
+			int iIdx = m_pMMButtonEntries.AddToTail();
+			m_pMMButtonEntries[iIdx].pPanel = NULL;
+			m_pMMButtonEntries[iIdx].bOnlyInGame = dat->GetBool( "OnlyInGame" );
+			m_pMMButtonEntries[iIdx].bOnlyInReplay = dat->GetBool( "OnlyInReplay" );
+			m_pMMButtonEntries[iIdx].bOnlyAtMenu = dat->GetBool( "OnlyAtMenu" );
+			m_pMMButtonEntries[iIdx].bOnlyVREnabled = dat->GetBool( "OnlyWhenVREnabled" );
+			m_pMMButtonEntries[iIdx].iStyle = iStyle;
+			continue;
+		}
+
+		// Create the new editable panel (first, see if we have one already)
+		vgui::EditablePanel *pPanel = dynamic_cast<vgui::EditablePanel *>( FindChildByName( name, true ) );
+		if ( !pPanel )
+		{
+			Assert( false );	// We don't want to do this anymore.  We need an actual hierarchy so things can slide
+								// around when the play buttin is pressed and the play options expand
+			pPanel = new vgui::EditablePanel( this, name );
+		}
+		else
+		{
+			// It already exists in our .res file. Note that it's a custom button.
+			iStyle = MMBS_CUSTOM;
+		}
+
+		if ( pPanel )
+		{
+			if ( m_pButtonKV && iStyle != MMBS_CUSTOM )
+			{
+				pPanel->ApplySettings( m_pButtonKV );
+			} 
+
+			int iIdx = m_pMMButtonEntries.AddToTail();
+			m_pMMButtonEntries[iIdx].pPanel = pPanel;
+			m_pMMButtonEntries[iIdx].bOnlyInGame = dat->GetBool( "OnlyInGame" );
+			m_pMMButtonEntries[iIdx].bOnlyInReplay = dat->GetBool( "OnlyInReplay" );
+			m_pMMButtonEntries[iIdx].bOnlyAtMenu = dat->GetBool( "OnlyAtMenu" );
+			m_pMMButtonEntries[iIdx].bOnlyVREnabled = dat->GetBool( "OnlyWhenVREnabled" );
+			m_pMMButtonEntries[iIdx].iStyle = iStyle;
+			m_pMMButtonEntries[iIdx].pszImage = dat->GetString( "subimage" );
+			m_pMMButtonEntries[iIdx].pszTooltip = dat->GetString( "tooltip", NULL );
+
+			// Tell the button that we'd like messages from it
+			CExImageButton *pButton = dynamic_cast<CExImageButton*>( pPanel->FindChildByName("SubButton") );
+			if ( pButton )
+			{
+				if ( m_pMMButtonEntries[iIdx].pszTooltip )
+				{
+					pButton->SetTooltip( m_pToolTip, m_pMMButtonEntries[iIdx].pszTooltip );
+				}
+
+				pButton->SetText( label );
+				pButton->SetCommand( cmd );
+				pButton->SetMouseInputEnabled( true );
+				pButton->AddActionSignalTarget( GetVPanel() );
+
+				if ( m_pMMButtonEntries[iIdx].pszImage && m_pMMButtonEntries[iIdx].pszImage[0] )
+				{
+					pButton->SetSubImage( m_pMMButtonEntries[iIdx].pszImage );
+				}
+			}
+		}
+
+		OnUpdateMenu();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::RemoveAllMenuEntries( void )
+{
+	FOR_EACH_VEC_BACK( m_pMMButtonEntries, i )
+	{
+		if ( m_pMMButtonEntries[i].pPanel )
+		{
+			// Manually remove anything that's not going to be removed automatically
+			if ( m_pMMButtonEntries[i].pPanel->IsBuildModeDeletable() == false )
+			{
+				m_pMMButtonEntries[i].pPanel->MarkForDeletion();
+			}
+		}
+	}
+	m_pMMButtonEntries.Purge();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::PerformLayout( void )
+{
+	BaseClass::PerformLayout();
+
+	bool bFirstButton = true;
+
+	int iYPos = m_iButtonY;
+	FOR_EACH_VEC( m_pMMButtonEntries, i )
+	{
+		bool bIsVisible = (m_pMMButtonEntries[i].pPanel ? m_pMMButtonEntries[i].pPanel->IsVisible() : m_pMMButtonEntries[i].bIsVisible);
+		if ( !bIsVisible )
+			continue;
+
+		if ( bFirstButton && m_pMMButtonEntries[i].pPanel != NULL )
+		{
+			m_pMMButtonEntries[i].pPanel->NavigateTo();
+			bFirstButton = false;
+		}
+
+		// Don't reposition it if it's a custom button
+		if ( m_pMMButtonEntries[i].iStyle == MMBS_CUSTOM )
+			continue;
+
+		// If we're a spacer, just leave a blank and move on
+		if ( m_pMMButtonEntries[i].pPanel == NULL )
+		{
+			iYPos += YRES(20);
+			continue;
+		}
+
+		m_pMMButtonEntries[i].pPanel->SetPos( (GetWide() * 0.5) + m_iButtonXOffset, iYPos );
+		iYPos += m_pMMButtonEntries[i].pPanel->GetTall() + m_iButtonYDelta;
+	}
+
+	if ( m_pFeaturedItemMouseOverPanel->IsVisible() )
+	{
+		m_pFeaturedItemMouseOverPanel->SetVisible( false );
+	}
+
+	if ( m_pEventPromoContainer && m_pSafeModeContainer )
+	{
+		m_pEventPromoContainer->SetVisible( !cl_mainmenu_safemode.GetBool() );
+		m_pSafeModeContainer->SetVisible( cl_mainmenu_safemode.GetBool() );
+		if ( cl_mainmenu_safemode.GetBool() )
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_pSafeModeContainer, "MMenu_SafeMode_Blink" );
+		}
+		else
+		{
+			g_pClientMode->GetViewportAnimationController()->CancelAnimationsForPanel( m_pSafeModeContainer );
+		}
+	}
+
+	// Make the glows behind the update buttons pulse
+	if ( m_pEventPromoContainer && cl_mainmenu_updateglow.GetInt() )
+	{
+		EditablePanel* pUpdateBackground = m_pEventPromoContainer->FindControl< EditablePanel >( "Background", true );	
+		if ( pUpdateBackground )
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( pUpdateBackground, "MMenu_UpdateButton_StartGlow" );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::OnUpdateMenu( void )
+{
+	// The dumb gameui.dll basepanel calls this every damn frame it's visible.
+	// So try and do the least amount of work if nothing has changed.
+
+	bool bSomethingChanged = false;
+	bool bInGame = engine->IsInGame();
+#if defined( REPLAY_ENABLED )
+	bool bInReplay = g_pEngineClientReplay->IsPlayingReplayDemo();
+#else
+	bool bInReplay = false;
+#endif
+	bool bIsVREnabled = materials->GetCurrentConfigForVideoCard().m_nVRModeAdapter == materials->GetCurrentAdapter();
+
+	// First, reapply any KVs we have to reapply
+	if ( m_bReapplyButtonKVs )
+	{
+		m_bReapplyButtonKVs = false;
+
+		if ( m_pButtonKV )
+		{
+			FOR_EACH_VEC( m_pMMButtonEntries, i )
+			{
+				if ( m_pMMButtonEntries[i].iStyle != MMBS_CUSTOM && m_pMMButtonEntries[i].pPanel )
+				{
+					m_pMMButtonEntries[i].pPanel->ApplySettings( m_pButtonKV );
+				}
+			}
+		}
+	}
+
+	// Hide the character if we're in game.
+	if ( bInGame || bInReplay )
+	{
+		if ( m_pCharacterImagePanel && m_pCharacterImagePanel->IsVisible() )
+		{
+			m_pCharacterImagePanel->SetVisible( false );
+		}
+	}
+	else if ( !bInGame && !bInReplay )
+	{
+		if ( m_pCharacterImagePanel && !m_pCharacterImagePanel->IsVisible() )
+		{
+			m_pCharacterImagePanel->SetVisible( true );
+		}
+	}
+
+	// Position the entries
+	FOR_EACH_VEC( m_pMMButtonEntries, i )
+	{
+		bool shouldBeVisible = true;
+		if ( m_pMMButtonEntries[i].bOnlyInGame && !bInGame )
+		{
+			shouldBeVisible = false;
+		}
+		else if ( m_pMMButtonEntries[i].bOnlyInReplay && !bInReplay )
+		{
+			shouldBeVisible = false;
+		}
+		else if ( m_pMMButtonEntries[i].bOnlyAtMenu && (bInGame || bInReplay) )
+		{
+			shouldBeVisible = false;
+		}
+		else if ( m_pMMButtonEntries[i].bOnlyVREnabled && ( !bIsVREnabled || ShouldForceVRActive() ) )
+		{
+			shouldBeVisible = false;
+		}
+
+		// Set the right visibility
+		bool bIsVisible = (m_pMMButtonEntries[i].pPanel ? m_pMMButtonEntries[i].pPanel->IsVisible() : m_pMMButtonEntries[i].bIsVisible);
+		if ( bIsVisible != shouldBeVisible )
+		{
+			m_pMMButtonEntries[i].bIsVisible = shouldBeVisible;
+			if ( m_pMMButtonEntries[i].pPanel )
+			{
+				m_pMMButtonEntries[i].pPanel->SetVisible( shouldBeVisible );
+			}
+			bSomethingChanged = true;
+		}
+	}
+
+	if ( m_pQuitButton && m_pDisconnectButton && m_pBackToReplaysButton )
+	{
+		bool bShowQuit = !( bInGame || bInReplay );
+		bool bShowDisconnect = bInGame && !bInReplay;
+		
+		if ( m_pQuitButton->IsVisible() != bShowQuit )
+		{
+			m_pQuitButton->SetVisible( bShowQuit );
+		}
+
+		if ( m_pBackToReplaysButton->IsVisible() != bInReplay )
+		{
+			m_pBackToReplaysButton->SetVisible( bInReplay );
+		}
+
+		if ( m_pDisconnectButton->IsVisible() != bShowDisconnect )
+		{
+			m_pDisconnectButton->SetVisible( bShowDisconnect );
+		}
+
+		if ( bShowDisconnect )
+		{
+			bool bIsDisconnectText = GTFGCClientSystem()->GetCurrentServerAbandonStatus() != k_EAbandonGameStatus_AbandonWithPenalty;
+			if ( m_bIsDisconnectText != bIsDisconnectText )
+			{
+				m_bIsDisconnectText = bIsDisconnectText;
+				m_pDisconnectButton->SetText( m_bIsDisconnectText ? "#GameUI_GameMenu_Disconnect" : "#TF_MM_Rejoin_Abandon" );
+			}
+		}
+	}
+
+	if ( m_pBackground )
+	{
+		if ( cl_mainmenu_operation_motd_reset.GetBool() && cl_mainmenu_operation_motd_start.GetBool() )
+		{
+			cl_mainmenu_operation_motd_start.SetValue( 0 );
+			cl_mainmenu_operation_motd_reset.SetValue( 0 );
+		}
+
+		if ( !cl_mainmenu_operation_motd_start.GetInt() )
+		{
+			char sztime[k_RTimeRenderBufferSize];
+			CRTime::RTime32ToString( CRTime::RTime32TimeCur(), sztime );
+			cl_mainmenu_operation_motd_start.SetValue( sztime );
+		}
+
+		bool bShouldBeVisible = bInGame == false;
+		if ( m_pBackground->IsVisible() != bShouldBeVisible )
+		{
+			m_pBackground->SetVisible( bShouldBeVisible );
+
+			// Always show this on startup when we have a new campaign
+			if ( m_bStabilizedInitialLayout && bShouldBeVisible && ( m_bHaveNewMOTDs || !m_bMOTDShownAtStartup ) )
+			{
+				RTime32 rtFirstLaunchTime = CRTime::RTime32FromString( cl_mainmenu_operation_motd_start.GetString() );
+				RTime32 rtThreeDaysFromStart = CRTime::RTime32DateAdd( rtFirstLaunchTime, 7, k_ETimeUnitDay );
+				if ( m_bHaveNewMOTDs || CRTime::RTime32TimeCur() < rtThreeDaysFromStart )
+				{
+					SetMOTDVisible( true );
+					m_bMOTDShownAtStartup = true;
+				}
+			}
+		}
+	} 
+
+	if ( bSomethingChanged )
+	{
+		InvalidateLayout();
+
+		ScheduleItemCheck();
+	}
+
+	if ( !bInGame && m_flCheckTrainingAt && m_flCheckTrainingAt < engine->Time() )
+	{
+		m_flCheckTrainingAt = 0;
+		CheckTrainingStatus();
+	}
+
+	if ( !bInGame && m_flCheckUnclaimedItems && m_flCheckUnclaimedItems < engine->Time() )
+	{
+		m_flCheckUnclaimedItems = 0;
+		CheckUnclaimedItems();
+	}
+
+#ifdef SAXXYMAINMENU_ENABLED
+	const bool bSaxxyShouldBeVisible = !bInGame && !bInReplay;
+	if ( !m_pSaxxyAwardsPanel && bSaxxyShouldBeVisible )
+	{
+		m_pSaxxyAwardsPanel = new CSaxxyAwardsPanel( this, "SaxxyPanel" );
+
+		if ( m_pSaxxySettings )
+		{
+			m_pSaxxyAwardsPanel->ApplySettings( m_pSaxxySettings );
+		}
+
+		m_pSaxxyAwardsPanel->InvalidateLayout( true, true );
+	}
+	else if ( m_pSaxxyAwardsPanel && !bSaxxyShouldBeVisible )
+	{
+		m_pSaxxyAwardsPanel->MarkForDeletion();
+		m_pSaxxyAwardsPanel = NULL;
+	}
+#endif
+
+	if ( m_pVRModeButton && m_pVRModeButton->IsVisible() )
+	{
+		if( UseVR() )
+			m_pVRModeButton->SetText( "#MMenu_VRMode_Deactivate" );
+		else
+			m_pVRModeButton->SetText( "#MMenu_VRMode_Activate" );
+	}
+
+	if ( !IsLayoutInvalid() )
+	{
+		m_bStabilizedInitialLayout = true;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check to see if we need to hound the player about unclaimed items.
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::CheckUnclaimedItems()
+{
+	// Only do this if we don't have a notification about unclaimed items already.
+	for ( int i=0; i<NotificationQueue_GetNumNotifications(); i++ )
+	{
+		CEconNotification* pNotification = NotificationQueue_Get( i );
+		if ( pNotification )
+		{
+			if ( !Q_strcmp( pNotification->GetUnlocalizedText(), "TF_HasNewItems") )
+			{
+				return;
+			}
+		}
+	}
+
+	// Only provide a notification if there are items to pick up.
+	if ( TFInventoryManager()->GetNumItemPickedUpItems() == 0 )
+		return;
+
+	TFInventoryManager()->GetLocalTFInventory()->NotifyHasNewItems();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::OnConfirm( KeyValues *pParams )
+{
+	if ( pParams->GetBool( "confirmed" ) )
+	{
+		engine->ClientCmd_Unrestricted( "disconnect" );
+		GetClientModeTFNormal()->GameUI()->SendMainMenuCommand( "engine training_showdlg" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::UpdateMOTD( bool bNewMOTDs )
+{	
+	if ( m_bInitMOTD == false )
+	{
+		m_pMOTDPanel->InvalidateLayout( true, true );
+		m_bInitMOTD = true;	
+	}
+
+	if ( bNewMOTDs )
+	{
+		m_bHaveNewMOTDs = true;
+		m_iCurrentMOTD = -1;		
+	}
+
+	int iCount = GetMOTDManager().GetNumMOTDs();
+	if ( !iCount || m_iCurrentMOTD < 0 )
+	{
+		m_iCurrentMOTD = (iCount-1);
+	}
+
+	// If we don't have an MOTD selected, show the most recent one
+	CMOTDEntryDefinition *pMOTD = GetMOTDManager().GetMOTDByIndex( m_iCurrentMOTD );
+	if ( pMOTD )
+	{
+		char uilanguage[ 64 ];
+		uilanguage[0] = 0;
+		engine->GetUILanguage( uilanguage, sizeof( uilanguage ) );
+		ELanguage nCurLang = PchLanguageToELanguage( uilanguage );
+
+		RTime32 nTime = pMOTD->GetPostTime();
+		wchar_t wzDate[64];
+
+		char rgchDateBuf[ 128 ];
+		BGetLocalFormattedDate( nTime, rgchDateBuf, sizeof( rgchDateBuf ) );
+
+		// Start with the day ("Aug 21")
+		CRTime cTime( nTime );
+		g_pVGuiLocalize->ConvertANSIToUnicode( rgchDateBuf, wzDate, sizeof( wzDate ) );
+
+		m_pMOTDPanel->SetDialogVariable( "motddate", wzDate );
+
+		// Header Color and text
+		if ( m_pMOTDHeaderLabel )
+		{
+			m_pMOTDHeaderLabel->SetText( pMOTD->GetHeaderTitle(nCurLang) );
+			int iHeaderType = pMOTD->GetHeaderType();
+			switch ( iHeaderType ) 
+			{
+			case 0:
+				m_pMOTDHeaderLabel->SetBgColor( Color ( 183, 108, 58, 255 ) );
+				break;
+			case 1:
+				m_pMOTDHeaderLabel->SetBgColor( Color ( 141, 178, 61, 255 ) );
+				break;
+			default:
+				m_pMOTDHeaderLabel->SetBgColor( Color ( 183, 108, 58, 255 ) );
+				break;
+			}
+		}
+
+		if ( m_pMOTDHeaderIcon )
+		{
+			// Header Class icon
+			if (  pMOTD->GetHeaderIcon() == NULL || Q_strcmp( pMOTD->GetHeaderIcon(), "" ) == 0)
+			{
+				m_pMOTDHeaderIcon->SetVisible(false);
+			}
+			else
+			{
+				m_pMOTDHeaderIcon->SetVisible(true);
+				m_pMOTDHeaderIcon->SetImage( pMOTD->GetHeaderIcon() );
+			}
+		}
+
+		// Set the Title and change font until it fits
+		// title
+		int iTitleWide = 0;
+		int iTitleTall = 0;
+
+		int iLabelWide = 0;
+		int iLabelTall = 0;
+
+		wchar_t wszText[512];
+		g_pVGuiLocalize->ConvertANSIToUnicode( pMOTD->GetTitle(nCurLang), wszText, sizeof( wszText ) );
+
+		if ( m_hTitleLabelFont != vgui::INVALID_FONT )
+		{
+			surface()->GetTextSize( m_hTitleLabelFont, wszText, iTitleWide, iTitleTall );
+		}
+
+		if ( m_pMOTDTitleLabel )
+		{
+			m_pMOTDTitleLabel->GetSize( iLabelWide, iLabelTall );
+
+			if ( iTitleWide > iLabelWide )
+			{
+				IScheme *pScheme = scheme()->GetIScheme( m_pMOTDTitleLabel->GetScheme() );
+
+				int hMediumBoldFont = pScheme->GetFont( "HudFontMediumBold" );
+				surface()->GetTextSize( hMediumBoldFont, wszText, iTitleWide, iTitleTall );
+				if ( iTitleWide > iLabelWide )
+				{
+					m_pMOTDTitleLabel->SetFont( pScheme->GetFont( "HudFontMediumSmallBold" ) );
+				}
+				else
+				{
+					m_pMOTDTitleLabel->SetFont( hMediumBoldFont );
+				}
+			}
+			else 
+			{
+				if ( m_hTitleLabelFont != vgui::INVALID_FONT )
+				{
+					m_pMOTDTitleLabel->SetFont( m_hTitleLabelFont );
+				}
+			}
+		}
+		m_pMOTDPanel->SetDialogVariable( "motdtitle", pMOTD->GetTitle(nCurLang) );
+
+		// Body Text
+		m_pMOTDTextPanel->SetDialogVariable( "motdtext", pMOTD->GetText(nCurLang) );	
+
+		// Image
+		const char* pszImage = pMOTD->GetImage();
+
+		if ( m_pMOTDTitleImage )
+		{
+			m_pMOTDTitleImage->SetShouldScaleImage( false );
+			if ( pszImage == NULL || Q_strcmp( pszImage, "" ) == 0 || Q_strcmp( pszImage, "class_icons/filter_all_on") == 0 )
+			{
+				m_pMOTDTitleImage->SetImage( "../logo/new_tf2_logo" );
+			}
+			else 
+			{
+				m_pMOTDTitleImage->SetImage( pszImage );
+			}
+
+			IImage *pImage = m_pMOTDTitleImage->GetImage();
+			int iContentWide = 0;
+			int iContentTall = 0;
+			if ( m_pMOTDTitleImageContainer )
+			{	
+				m_pMOTDTitleImageContainer->GetSize( iContentWide, iContentTall );
+			}
+
+			int iImgWide;
+			int iImgTall;
+			pImage->GetSize( iImgWide, iImgTall );
+
+			// get the size of the content
+			// perform a uniform scale along the horizontal
+			float fImageScale = MIN( (float)iContentWide / (float)iImgWide, 1.0f );
+			float fScaledTall = iImgTall * fImageScale;
+			float fScaledWide = iImgWide * fImageScale;
+			pImage->SetSize( fScaledWide, fScaledTall );
+
+			// reposition the image so that its centered
+			m_pMOTDTitleImage->SetPos( (iContentWide - fScaledWide) / 2, (iContentTall - fScaledTall) / 2 );
+		}
+
+		// We need to resize our text label to fit all the text
+		if ( m_pMOTDTextLabel )
+		{
+			m_pMOTDTextLabel->InvalidateLayout( true );
+
+			int wide, tall;
+			m_pMOTDTextLabel->GetContentSize(wide, tall);
+			m_pMOTDTextLabel->SetSize( m_pMOTDTextPanel->GetWide(), tall );
+			m_pMOTDTextPanel->SetSize( m_pMOTDTextPanel->GetWide(), m_pMOTDTextLabel->GetTall() );
+		}
+		
+		if ( m_pMOTDURLButton )
+		{
+			const char *pszURL = pMOTD->GetURL();
+			m_pMOTDURLButton->SetVisible( (pszURL && pszURL[0]) );
+		}
+		if ( m_pMOTDPrevButton )
+		{
+			m_pMOTDPrevButton->SetEnabled( m_iCurrentMOTD > 0 );
+			m_pMOTDPrevButton->SetSubImage( m_iCurrentMOTD > 0 ? "blog_back" : "blog_back_disabled" );
+		}
+		if ( m_pMOTDNextButton )
+		{
+			m_pMOTDNextButton->SetEnabled( m_iCurrentMOTD < (iCount-1) );
+			m_pMOTDNextButton->SetSubImage( m_iCurrentMOTD < (iCount-1) ? "blog_forward" : "blog_forward_disabled" );
+		}
+
+		// Move our scrollbar to the top.
+		m_pMOTDTextScroller->InvalidateLayout();
+		m_pMOTDTextScroller->Repaint();
+		m_pMOTDTextScroller->GetScrollbar()->SetValue( 0 );	
+		m_pMOTDTextScroller->GetScrollbar()->SetVisible( m_pMOTDTextPanel->GetTall() > m_pMOTDTextScroller->GetScrollbar()->GetTall() );
+		m_pMOTDTextScroller->GetScrollbar()->InvalidateLayout();
+		m_pMOTDTextScroller->GetScrollbar()->Repaint();
+	}
+	else
+	{
+		// Hide the MOTD, and the button to show it.
+		SetMOTDVisible( false );
+
+		if ( m_pMOTDShowPanel )
+		{
+			m_pMOTDShowPanel->SetVisible( false );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::SetMOTDButtonVisible( bool bVisible )
+{
+	if ( bVisible && m_pMOTDPanel && m_pMOTDPanel->IsVisible() )
+		return;
+
+	if ( m_pMOTDShowPanel )
+	{
+		// Show the notifications show panel button if we have new notifications.
+		m_pMOTDShowPanel->SetVisible( bVisible );
+
+		if ( bVisible && m_bHaveNewMOTDs )
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_pMOTDShowPanel, "HasMOTDBlink" );
+		}
+		else
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_pMOTDShowPanel, "HasMOTDBlinkStop" );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::SetMOTDVisible( bool bVisible )
+{
+	m_pMOTDPanel->SetVisible( bVisible );
+
+	if ( bVisible )
+	{
+		// Ensure the text is correct.
+		UpdateMOTD( false ); 
+
+		// Clear MOTD button.
+		SetMOTDButtonVisible( true );
+		SetNotificationsPanelVisible( false );
+		SetQuestLogVisible( false );
+		SetWatchStreamVisible( false );
+		//SetNotificationsButtonVisible( false );
+
+		// Consider new MOTDs as having been viewed.
+		m_bHaveNewMOTDs = false;
+	}
+	else
+	{
+		SetMOTDButtonVisible( true );
+		UpdateNotifications();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::SetQuestLogVisible( bool bVisible )
+{
+	GetQuestLog()->ShowPanel( bVisible );
+
+	if ( bVisible )
+	{
+		SetMOTDVisible( false );
+		SetNotificationsPanelVisible( false );
+		SetWatchStreamVisible( false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::SetWatchStreamVisible( bool bVisible )
+{
+	m_pWatchStreamsPanel->SetVisible( bVisible );
+
+	if ( bVisible )
+	{
+		SetMOTDVisible( false );
+		SetNotificationsPanelVisible( false );
+		SetQuestLogVisible( false );
+	}
+}
+
+bool CHudMainMenuOverride::CheckAndWarnForPREC( void )
+{
+	enum check_state
+	{
+		INVALID,
+		FOUND, 
+		NOT_FOUND,
+	};
+
+	static check_state s_state = INVALID;
+	if ( s_state == INVALID )
+	{
+		s_state = NOT_FOUND;
+
+		ICvar::Iterator iter( g_pCVar ); 
+		for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() )
+		{  
+			ConCommandBase *cmd = iter.Get();
+			if ( cmd )
+			{
+				if ( !Q_strncmp( cmd->GetName(), "prec_", 5 ) )
+				{
+					s_state = FOUND;
+					break;
+				}
+			}
+		} 
+	}
+
+	if ( s_state == FOUND )
+	{
+		ShowMessageBox( "#TF_Incompatible_AddOn", "#TF_PREC_Loaded" );
+	}
+
+	return ( s_state == FOUND );
+}
+
+void CHudMainMenuOverride::OpenMvMMMPanel()
+{
+	if ( CheckAndWarnForPREC() )
+		return;
+
+	GetMvMLobbyPanel()->ShowPanel( true );
+}
+
+void CHudMainMenuOverride::OpenCompMMPanel()
+{
+	if ( CheckAndWarnForPREC() )
+		return;
+
+	GetCompLobbyPanel()->ShowPanel( true );
+}
+
+void CHudMainMenuOverride::OpenCasualMMPanel()
+{
+	if ( CheckAndWarnForPREC() )
+		return;
+
+	GetCasualLobbyPanel()->ShowPanel( true );
+}
+
+CLobbyContainerFrame_Comp* CHudMainMenuOverride::GetCompLobbyPanel()
+{
+	static CLobbyContainerFrame_Comp* pCompPanel = NULL;
+	if ( pCompPanel == NULL )
+	{
+		pCompPanel = SETUP_PANEL( new CLobbyContainerFrame_Comp() );
+	}
+
+	return pCompPanel;
+}
+
+CLobbyContainerFrame_MvM* CHudMainMenuOverride::GetMvMLobbyPanel()
+{
+	static CLobbyContainerFrame_MvM* pMvMPanel = NULL;
+	if ( pMvMPanel == NULL )
+	{
+		pMvMPanel = SETUP_PANEL( new CLobbyContainerFrame_MvM() );
+	}
+
+	return pMvMPanel;
+}
+
+CLobbyContainerFrame_Casual* CHudMainMenuOverride::GetCasualLobbyPanel()
+{
+	static CLobbyContainerFrame_Casual* pCasualPanel = NULL;
+	if ( pCasualPanel == NULL )
+	{
+		pCasualPanel = SETUP_PANEL( new CLobbyContainerFrame_Casual() );
+	}
+
+	return pCasualPanel;
+}
+
+void CHudMainMenuOverride::ReloadMMPanels()
+{
+	if ( GetCasualLobbyPanel()->IsVisible() )
+	{
+		GetCasualLobbyPanel()->InvalidateLayout( true, true );
+		GetCasualLobbyPanel()->ShowPanel( true );
+	}
+
+	if ( GetCompLobbyPanel()->IsVisible() )
+	{
+		GetCompLobbyPanel()->InvalidateLayout( true, true );
+		GetCompLobbyPanel()->ShowPanel( true );
+	}
+
+	if ( GetMvMLobbyPanel()->IsVisible() )
+	{
+		GetMvMLobbyPanel()->InvalidateLayout( true, true );
+		GetMvMLobbyPanel()->ShowPanel( true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::UpdateNotifications()
+{
+	int iNumNotifications = NotificationQueue_GetNumNotifications();
+
+	wchar_t wszNumber[16]=L"";
+	V_swprintf_safe( wszNumber, L"%i", iNumNotifications );
+	wchar_t wszText[1024]=L"";
+	g_pVGuiLocalize->ConstructString_safe( wszText, g_pVGuiLocalize->Find( "#MMenu_Notifications_Show" ), 1, wszNumber );
+
+	m_pNotificationsPanel->SetDialogVariable( "notititle", wszText );
+
+	bool bHasNotifications = iNumNotifications != 0;
+
+	if ( m_pNotificationsShowPanel )
+	{
+		SetNotificationsButtonVisible( bHasNotifications );
+
+		bool bBlinkNotifications = bHasNotifications && m_pNotificationsShowPanel->IsVisible();
+		if ( bBlinkNotifications )
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_pNotificationsShowPanel, "HasNotificationsBlink" );
+		}
+		else
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_pNotificationsShowPanel, "HasNotificationsBlinkStop" );
+		}
+	}
+
+	if ( !bHasNotifications )
+	{
+		SetNotificationsButtonVisible( false );
+		SetNotificationsPanelVisible( false );
+	}
+
+	AdjustNotificationsPanelHeight();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::SetNotificationsButtonVisible( bool bVisible )
+{
+	if ( bVisible && ( m_pNotificationsPanel && m_pNotificationsPanel->IsVisible() ) )
+		return;
+
+	if ( m_pNotificationsShowPanel )
+	{
+		// Show the notifications show panel button if we have new notifications.
+		m_pNotificationsShowPanel->SetVisible( bVisible );
+
+		// Set the notification count variable.
+		if ( m_pNotificationsShowPanel )
+		{
+			m_pNotificationsShowPanel->SetDialogVariable( "noticount", NotificationQueue_GetNumNotifications() );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::SetNotificationsPanelVisible( bool bVisible )
+{
+	if ( m_pNotificationsPanel )
+	{
+		bool bHasNotifications = NotificationQueue_GetNumNotifications() != 0;
+
+		if ( bHasNotifications )
+		{
+			UpdateNotifications();
+		}
+
+		m_pNotificationsPanel->SetVisible( bVisible );
+
+		if ( bVisible )
+		{
+			m_pNotificationsScroller->InvalidateLayout();
+			m_pNotificationsScroller->GetScrollbar()->InvalidateLayout();
+			m_pNotificationsScroller->GetScrollbar()->SetValue( 0 );
+
+			SetMOTDVisible( false );
+			SetQuestLogVisible( false );
+			SetWatchStreamVisible( false );
+
+			m_pNotificationsShowPanel->SetVisible( false );
+
+			m_pNotificationsControl->OnTick();
+			m_pNotificationsControl->PerformLayout();
+			AdjustNotificationsPanelHeight();
+
+			// Faster updating while open.
+			vgui::ivgui()->RemoveTickSignal( GetVPanel() );
+			vgui::ivgui()->AddTickSignal( GetVPanel(), 5 );
+		}
+		else
+		{
+			// Clear all notifications.
+			if ( bHasNotifications )
+			{
+				SetNotificationsButtonVisible( true );
+			}
+
+			// Slower updating while closed.
+			vgui::ivgui()->RemoveTickSignal( GetVPanel() );
+			vgui::ivgui()->AddTickSignal( GetVPanel(), 250 );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::AdjustNotificationsPanelHeight()
+{
+	// Fit to our contents, which may change without notifying us.
+	int iNotiTall = m_pNotificationsControl->GetTall();
+	if ( iNotiTall > m_pNotificationsScroller->GetTall() )
+		iNotiTall = m_pNotificationsScroller->GetTall();
+	int iTargetTall = YRES(40) + iNotiTall;
+	if ( m_pNotificationsPanel->GetTall() != iTargetTall )
+		m_pNotificationsPanel->SetTall( iTargetTall );
+
+	// Adjust visibility of the slider buttons and our width, as contents change.
+	if ( m_pNotificationsScroller )
+	{
+		if ( m_pNotificationsScroller->GetScrollbar()->GetSlider() && 
+			m_pNotificationsScroller->GetScrollbar()->GetSlider()->IsSliderVisible() )
+		{
+			m_pNotificationsPanel->SetWide( m_iNotiPanelWide +  m_pNotificationsScroller->GetScrollbar()->GetSlider()->GetWide() );
+			m_pNotificationsScroller->GetScrollbar()->SetScrollbarButtonsVisible( true );
+		}
+		else
+		{
+			m_pNotificationsPanel->SetWide( m_iNotiPanelWide );
+			m_pNotificationsScroller->GetScrollbar()->SetScrollbarButtonsVisible( false );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::UpdatePromotionalCodes( void )
+{
+	// should we show the promo codes button?
+	vgui::Panel *pPromoCodesButton = FindChildByName( "ShowPromoCodesButton" );
+	if ( pPromoCodesButton )
+	{
+		bool bShouldBeVisible = false;
+		if ( steamapicontext && steamapicontext->SteamUser() )
+		{
+			CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
+			GCSDK::CGCClientSharedObjectCache *pSOCache = GCClientSystem()->GetSOCache( steamID );
+			if ( pSOCache )
+			{
+				GCSDK::CGCClientSharedObjectTypeCache *pTypeCache = pSOCache->FindTypeCache( k_EEconTypeClaimCode );
+				bShouldBeVisible = pTypeCache != NULL && pTypeCache->GetCount() != 0;
+			}
+		}
+
+		// The promo code button collides with the VR mode button. Turn off the promo code button 
+		// in that case since the people who deliberately enabled VR are much more likely to want that
+		// than to claim their Well Spun Hat in Rift.
+		bool bShowVR = materials->GetCurrentConfigForVideoCard().m_nVRModeAdapter == materials->GetCurrentAdapter();
+		if( bShowVR )
+		{
+			bShouldBeVisible = false;
+		}
+
+		// has the player turned off this button?
+		if ( !cl_promotional_codes_button_show.GetBool() )
+		{
+			bShouldBeVisible = false;
+		}
+
+		if ( pPromoCodesButton->IsVisible() != bShouldBeVisible )
+		{
+			pPromoCodesButton->SetVisible( bShouldBeVisible );
+		}
+
+		if ( m_pVRModeBackground )
+		{
+			m_pVRModeBackground->SetVisible( bShouldBeVisible || bShowVR );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHudMainMenuOverride::IsVisible( void )
+{
+	/*
+	// Only draw whenever the main menu is visible
+	if ( GetClientModeTFNormal()->GameUI() && steamapicontext && steamapicontext->SteamFriends() )
+		return GetClientModeTFNormal()->GameUI()->IsMainMenuVisible();
+	return BaseClass::IsVisible();
+	*/
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::StartHighlightAnimation( mm_highlight_anims iAnim )
+{
+	vgui::surface()->PlaySound( "ui/hint.wav" );
+
+	if ( m_pHighlightAnims[ iAnim ] )
+	{
+		m_pHighlightAnims[ iAnim ]->Popup();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::HideHighlight( mm_highlight_anims iAnim )
+{
+	if ( m_pHighlightAnims[ iAnim ] )
+	{
+		m_pHighlightAnims[ iAnim ]->Hide( 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::TogglePlayListMenu( void )
+{
+	if ( m_bPlayListExpanded )
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "MMenu_PlayList_Collapse", false );
+	}
+	else
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "MMenu_PlayList_Expand", false );
+		UpdatePlaylistEntries();
+	}
+
+	// These all rely on the playlist being in a specific state.  If we're 
+	// toggling, then there's no guarantees anything is where we think it is anymore
+	HideHighlight( MMHA_TUTORIAL );
+	HideHighlight( MMHA_PRACTICE );
+	HideHighlight( MMHA_LOADOUT );
+	HideHighlight( MMHA_STORE );
+	HideHighlight( MMHA_WAR );
+
+	m_bPlayListExpanded = !m_bPlayListExpanded;
+
+	CheckTrainingStatus();
+}
+
+void PromptOrFireCommand( const char* pszCommand )
+{
+	if ( engine->IsInGame()  )
+	{
+		CTFDisconnectConfirmDialog *pDialog = BuildDisconnectConfirmDialog();
+		if ( pDialog )
+		{
+			pDialog->Show();
+			pDialog->AddConfirmCommand( pszCommand );
+		}
+	}
+	else
+	{
+		engine->ClientCmd_Unrestricted( pszCommand );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Make the glows behind the update buttons stop pulsing
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::StopUpdateGlow()
+{
+	// Dont ever glow again
+	if ( cl_mainmenu_updateglow.GetInt() )
+	{
+		cl_mainmenu_updateglow.SetValue( 0 );
+		engine->ClientCmd_Unrestricted( "host_writeconfig" );
+	}
+
+	if ( m_pEventPromoContainer )
+	{
+		EditablePanel* pUpdateBackground = m_pEventPromoContainer->FindControl< EditablePanel >( "Background", true );	
+		if ( pUpdateBackground )
+		{
+			g_pClientMode->GetViewportAnimationController()->StopAnimationSequence( pUpdateBackground, "MMenu_UpdateButton_StartGlow" );
+			pUpdateBackground->SetControlVisible( "ViewDetailsGlow", false, true );
+			pUpdateBackground->SetControlVisible( "ViewWarButtonGlow", false, true );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::OnCommand( const char *command )
+{
+	C_CTFGameStats::ImmediateWriteInterfaceEvent( "on_command(main_menu_override)", command );
+
+	if ( FStrEq( "toggle_play_menu", command ) )
+	{
+		TogglePlayListMenu();
+		return;
+	}
+	else if ( FStrEq( "play_competitive", command ) )
+	{
+		// Defaulting to 6v6
+		GTFGCClientSystem()->SetLadderType( k_nMatchGroup_Ladder_6v6 );
+		PromptOrFireCommand( "OpenMatchmakingLobby ladder" ); 
+		return;
+	}
+	else if ( FStrEq( "play_casual", command ) )
+	{
+		// Defaulting to 12v12
+		GTFGCClientSystem()->SetLadderType( k_nMatchGroup_Casual_12v12 );
+		PromptOrFireCommand( "OpenMatchmakingLobby casual" ); 
+		return;
+	}
+	else if ( FStrEq( "play_mvm", command ) ) 
+	{
+		PromptOrFireCommand( "OpenMatchmakingLobby mvm" ); 
+		return;
+	}
+	else if ( FStrEq( "play_quickplay", command ) )
+	{
+		PromptOrFireCommand( "OpenQuickplayDialog" ); 
+		return;
+	}
+	else if ( FStrEq( "play_training", command ) )
+	{
+		HideHighlight( MMHA_TUTORIAL );
+
+		if ( engine->IsInGame() )
+		{
+			const char *pText = "#TF_Training_Prompt";
+			const char *pTitle = "#TF_Training_Prompt_Title";
+			if ( TFGameRules() && TFGameRules()->IsInTraining() )
+			{
+				pTitle = "#TF_Training_Restart_Title";				
+				pText = "#TF_Training_Restart_Text";
+			}
+			CTFConfirmTrainingDialog *pConfirm = vgui::SETUP_PANEL( new CTFConfirmTrainingDialog( pText, pTitle, this ) );
+			if ( pConfirm )
+			{
+				pConfirm->Show();
+			}
+		}
+		else
+		{
+			GetClientModeTFNormal()->GameUI()->SendMainMenuCommand( "engine training_showdlg" );
+		}
+	}
+	else if ( Q_strnicmp( command, "soundentry", 10 ) == 0 )
+	{
+		PlaySoundEntry( command + 11 );
+		return;
+	}
+	else if ( !Q_stricmp( command, "motd_viewurl" ) )
+	{
+		CMOTDEntryDefinition *pMOTD = GetMOTDManager().GetMOTDByIndex( m_iCurrentMOTD );
+		if ( pMOTD )
+		{
+			const char *pszURL = pMOTD->GetURL();
+			if ( pszURL && pszURL[0] )
+			{
+				if ( steamapicontext && steamapicontext->SteamFriends() )
+				{
+					steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( pszURL );
+				}
+			}
+		}
+		return;
+	}
+	else if ( !Q_stricmp( command, "view_newuser_forums" ) )
+	{
+		HideHighlight( MMHA_NEWUSERFORUM );
+
+		if ( steamapicontext && steamapicontext->SteamFriends() )
+		{
+			steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "http://forums.steampowered.com/forums/forumdisplay.php?f=906" );
+		}
+		return;
+	}
+	else if ( !Q_stricmp( command, "opentf2options" ) )
+	{
+		HideHighlight( MMHA_OPTIONS );
+
+		GetClientModeTFNormal()->GameUI()->SendMainMenuCommand( "engine opentf2options" );
+	}
+	else if ( !Q_stricmp( command, "motd_prev" ) )
+	{
+		if ( m_iCurrentMOTD > 0 )
+		{
+			m_iCurrentMOTD--;
+			UpdateMOTD( false );
+		}
+		return;
+	}
+	else if ( !Q_stricmp( command, "motd_next" ) )
+	{
+		if ( m_iCurrentMOTD < (GetMOTDManager().GetNumMOTDs()-1) )
+		{
+			m_iCurrentMOTD++;
+			UpdateMOTD( false );
+		}
+		return;
+	}
+	else if ( !Q_stricmp( command, "motd_show" ) )
+	{
+		SetMOTDVisible( !m_pMOTDPanel->IsVisible() );
+	}
+	else if ( !Q_stricmp( command, "motd_hide" ) )
+	{
+		SetMOTDVisible( false );
+	}
+	else if ( !Q_stricmp( command, "noti_show" ) )
+	{
+		SetNotificationsPanelVisible( true );
+	}
+	else if ( !Q_stricmp( command, "noti_hide" ) )
+	{
+		SetNotificationsPanelVisible( false );
+	}
+	else if ( !Q_stricmp( command, "notifications_update" ) )
+	{
+		// force visible if 
+		if ( NotificationQueue_GetNumNotifications() != 0 )
+		{
+			SetNotificationsButtonVisible( true );
+		}
+		else
+		{
+			UpdateNotifications();
+		}
+	}
+	else if ( !Q_stricmp( command, "test_anim" ) )
+	{
+		InvalidateLayout( true, true ); 
+
+		StartHighlightAnimation( MMHA_TUTORIAL );
+		StartHighlightAnimation( MMHA_PRACTICE );
+		StartHighlightAnimation( MMHA_NEWUSERFORUM );
+		StartHighlightAnimation( MMHA_OPTIONS );
+		StartHighlightAnimation( MMHA_STORE );
+		StartHighlightAnimation( MMHA_LOADOUT );
+		StartHighlightAnimation( MMHA_WAR );
+	}
+	else if ( !Q_stricmp( command, "offlinepractice" ) )
+	{
+		HideHighlight( MMHA_PRACTICE );
+
+		GetClientModeTFNormal()->GameUI()->SendMainMenuCommand( "engine training_showdlg" );
+	}
+	else if ( !Q_stricmp( command, "buyfeatured" ) )
+	{
+		GetClientModeTFNormal()->GameUI()->SendMainMenuCommand( VarArgs("engine open_store %d 1", m_pFeaturedItemPanel ? m_pFeaturedItemPanel->GetItem()->GetItemDefIndex() : 0 ) );
+	}
+	else if ( !Q_stricmp( command, "armory_open" ) )
+	{
+		GetClientModeTFNormal()->GameUI()->SendMainMenuCommand( "engine open_charinfo_armory" );
+	}
+	else if ( !Q_stricmp( command, "engine disconnect" ) && engine->IsInGame() && TFGameRules() && ( TFGameRules()->IsMannVsMachineMode() || TFGameRules()->IsCompetitiveMode() ) )
+	{
+		// If we're playing MvM, "New Game" should take us back to MvM matchmaking
+		CTFDisconnectConfirmDialog *pDialog = BuildDisconnectConfirmDialog();
+		if ( pDialog )
+		{
+			pDialog->Show();
+		}
+		return;
+	}
+	else if ( !Q_stricmp( command, "callvote" ) )
+	{
+		GetClientModeTFNormal()->GameUI()->SendMainMenuCommand( "engine callvote" );
+		if ( GetClientModeTFNormal()->GameUI() )
+		{
+			GetClientModeTFNormal()->GameUI()->SendMainMenuCommand(  "ResumeGame" );
+		}
+		return;
+	}
+	else if ( !Q_stricmp( command, "showpromocodes" ) )
+	{
+		if ( steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUtils() )
+		{
+			CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
+			switch ( GetUniverse() )
+			{
+			case k_EUniversePublic: steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( CFmtStr1024( "http://steamcommunity.com/profiles/%llu/promocodes/tf2", steamID.ConvertToUint64() ) ); break;
+			case k_EUniverseBeta:	steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( CFmtStr1024( "http://beta.steamcommunity.com/profiles/%llu/promocodes/tf2", steamID.ConvertToUint64() ) ); break;
+			case k_EUniverseDev:	steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( CFmtStr1024( "http://localhost/community/profiles/%llu/promocodes/tf2", steamID.ConvertToUint64() ) ); break;
+			}
+		}
+	}
+	else if ( !Q_stricmp( command, "exitreplayeditor" ) )
+	{
+ #if defined( REPLAY_ENABLED )
+		CReplayPerformanceEditorPanel *pEditor = ReplayUI_GetPerformanceEditor();
+		if ( !pEditor )
+			return;
+
+		pEditor->Exit_ShowDialogs();
+#endif // REPLAY_ENABLED
+	}
+	else if ( FStrEq( "showcomic", command ) )
+	{
+		if ( m_pWarLandingPage )
+		{
+			m_pWarLandingPage->InvalidateLayout( true, true );
+			m_pWarLandingPage->SetVisible( true );
+		}
+	}
+	else if ( FStrEq( "questlog", command ) )
+	{
+		SetQuestLogVisible( !GetQuestLog()->IsVisible() );
+	}
+	else if ( FStrEq( "watch_stream", command ) )
+	{
+		SetWatchStreamVisible( !m_pWatchStreamsPanel->IsVisible() );
+	}
+	else if ( FStrEq( "view_update_page", command ) )
+	{
+		StopUpdateGlow();
+
+		if ( steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUtils() && steamapicontext->SteamUtils()->IsOverlayEnabled() )
+		{
+			CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
+			switch ( GetUniverse() )
+			{
+			case k_EUniversePublic: steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "http://www.teamfortress.com/meetyourmatch" ); break;
+			case k_EUniverseBeta:	// Fall through
+			case k_EUniverseDev:	steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "http://csham.valvesoftware.com/tf.com/meetyourmatch" ); break;
+			}
+		}
+		else
+		{
+			OpenStoreStatusDialog( NULL, "#MMenu_OverlayRequired", true, false );
+		}
+		return;
+	}
+	else if ( FStrEq( "view_update_comic", command ) )
+	{
+		if ( steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUtils() && steamapicontext->SteamUtils()->IsOverlayEnabled() )
+		{
+			CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
+			switch ( GetUniverse() )
+			{
+			case k_EUniversePublic: steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "http://www.teamfortress.com/gargoyles_and_gravel" ); break;
+			case k_EUniverseBeta:	// Fall through
+			case k_EUniverseDev:	steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "http://www.teamfortress.com/gargoyles_and_gravel" ); break;
+			}
+		}
+		else
+		{
+			OpenStoreStatusDialog( NULL, "#MMenu_OverlayRequired", true, false );
+		}
+		return;
+	}
+	else if ( FStrEq( "view_war", command ) )
+	{
+		HideHighlight( MMHA_WAR );
+		StopUpdateGlow();
+
+		m_pWarLandingPage->InvalidateLayout( true, true );
+		m_pWarLandingPage->SetVisible( true );
+
+		return;
+	}
+	else if ( FStrEq( "comp_access_info", command ) )
+	{
+		if ( m_pCompetitiveAccessInfo )
+		{
+			m_pCompetitiveAccessInfo->SetVisible( true );
+		}
+	}
+	else if ( FStrEq( "OpenReportPlayerDialog", command ) )
+	{
+		if ( !m_hReportPlayerDialog.Get() )
+			{
+				m_hReportPlayerDialog = vgui::SETUP_PANEL( new CReportPlayerDialog( this ) );
+				int x, y, ww, wt, wide, tall;
+				vgui::surface()->GetWorkspaceBounds( x, y, ww, wt );
+				m_hReportPlayerDialog->GetSize(wide, tall);
+
+				// Center it, keeping requested size
+				m_hReportPlayerDialog->SetPos(x + ((ww - wide) / 2), y + ((wt - tall) / 2));
+			}
+			m_hReportPlayerDialog->Activate();
+	}
+	else
+	{
+		// Pass it on to GameUI main menu
+		if ( GetClientModeTFNormal()->GameUI() )
+		{
+			GetClientModeTFNormal()->GameUI()->SendMainMenuCommand( command );
+			return;
+		}
+	}
+
+	BaseClass::OnCommand( command );
+}
+
+void CHudMainMenuOverride::OnKeyCodePressed( KeyCode code )
+{
+	if ( code == KEY_XBUTTON_B && engine->IsInGame() )
+	{
+		OnCommand( "ResumeGame" );
+	}
+	else
+	{
+		BaseClass::OnKeyCodePressed(code);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::CheckTrainingStatus( void )
+{
+	bool bNeedsTraining = tf_training_has_prompted_for_training.GetInt() <= 0;
+	bool bNeedsPractice = tf_training_has_prompted_for_offline_practice.GetInt() <= 0;
+	bool bShowForum = tf_training_has_prompted_for_forums.GetInt() <= 0;
+	bool bShowOptions = tf_training_has_prompted_for_options.GetInt() <= 0;
+	bool bWasInTraining = m_bWasInTraining;
+	m_bWasInTraining = false;
+
+	bool bShowLoadout = false;
+	if ( tf_training_has_prompted_for_loadout.GetInt() <= 0 )
+	{
+		// See if we have any items in our inventory.
+		int iNumItems = TFInventoryManager()->GetLocalTFInventory()->GetItemCount();
+		if ( iNumItems > 0 )
+		{
+			bShowLoadout = true;
+		}
+	}
+
+	if ( bShowLoadout && !m_bPlayListExpanded )
+	{
+		tf_training_has_prompted_for_loadout.SetValue( 1 );
+		StartHighlightAnimation( MMHA_LOADOUT );
+	}
+	else if ( bNeedsTraining && m_bPlayListExpanded )
+	{
+		tf_training_has_prompted_for_training.SetValue( 1 );
+
+		if ( m_pHighlightAnims[ MMHA_TUTORIAL ] )
+		{
+			if ( UTIL_HasLoadedAnyMap() )
+			{
+				m_pHighlightAnims[ MMHA_TUTORIAL ]->SetDialogVariable( "highlighttext", g_pVGuiLocalize->Find( "#MMenu_TutorialHighlight_Title2" ) );
+			}
+			else
+			{
+				m_pHighlightAnims[ MMHA_TUTORIAL ]->SetDialogVariable( "highlighttext", g_pVGuiLocalize->Find( "#MMenu_TutorialHighlight_Title" ) );
+			}
+		}
+
+		StartHighlightAnimation( MMHA_TUTORIAL );
+	}
+	else if ( bWasInTraining && Training_IsComplete() == false && tf_training_has_prompted_for_training.GetInt() < 2 && m_bPlayListExpanded)
+	{
+		tf_training_has_prompted_for_training.SetValue( 2 );
+
+		if ( m_pHighlightAnims[ MMHA_TUTORIAL ] )
+		{
+			m_pHighlightAnims[ MMHA_TUTORIAL ]->SetDialogVariable( "highlighttext", g_pVGuiLocalize->Find( "#MMenu_TutorialHighlight_Title3" ) );
+		}
+
+		StartHighlightAnimation( MMHA_TUTORIAL );
+	}
+	else if ( bNeedsPractice && m_bPlayListExpanded )
+	{
+		tf_training_has_prompted_for_offline_practice.SetValue( 1 );
+		StartHighlightAnimation( MMHA_PRACTICE );
+	}
+	else if ( bShowForum )
+	{
+		tf_training_has_prompted_for_forums.SetValue( 1 );
+		StartHighlightAnimation( MMHA_NEWUSERFORUM );
+	}
+	else if ( bShowOptions )
+	{
+		tf_training_has_prompted_for_options.SetValue( 1 );
+		StartHighlightAnimation( MMHA_OPTIONS );
+	}
+}
+
+void CHudMainMenuOverride::CheckForNewQuests( void )
+{
+	CUtlVector< CEconItemView * > questItems;
+	TFInventoryManager()->GetAllQuestItems( &questItems );
+
+	ImagePanel *pImage = m_pQuestLogButton->FindControl< ImagePanel >( "SubImage", true );
+	if ( pImage )
+	{
+		if ( questItems.Count() > 0 )
+		{
+			pImage->SetImage( "button_quests" );
+		}
+		else
+		{
+			pImage->SetImage( "button_quests_disabled" );
+		}
+	}
+
+	EditablePanel *pNotiPanel = m_pQuestLogButton->FindControl< EditablePanel >( "NotificationsContainer", true );
+	if ( pNotiPanel )
+	{
+		// how many quests are unidentified?
+		int iUnidentified = 0;
+		FOR_EACH_VEC( questItems, i )
+		{
+			if ( IsQuestItemUnidentified( questItems[i]->GetSOCData() ) )
+			{
+				iUnidentified++;
+			}
+		}
+
+		pNotiPanel->SetDialogVariable( "noticount", iUnidentified );
+		pNotiPanel->SetVisible( iUnidentified > 0 );
+	}
+}
+
+void CHudMainMenuOverride::UpdatePlaylistEntries( void )
+{
+	CMainMenuPlayListEntry::EDisabledStates_t eDisabledState = CMainMenuPlayListEntry::NOT_DISABLED;
+
+	CTFParty* pParty = GTFGCClientSystem()->GetParty();
+	if ( ( pParty && pParty->BOffline() ) || !GTFGCClientSystem()->BConnectedtoGC() || GTFGCClientSystem()->BHasOutstandingMatchmakingPartyMessage() )
+	{
+		eDisabledState = CMainMenuPlayListEntry::DISABLED_NO_GC;
+	}
+
+	// If we have a live match, and a we're not in it, but we should be in,
+	// dont let the user click the MM UI buttons.  GTFGCClientSystem::Update() will nag them 
+	// to rejoin their match or abandon.
+	if ( pParty && pParty->GetState() == CSOTFParty_State_IN_MATCH )
+	{
+		eDisabledState = CMainMenuPlayListEntry::DISABLED_MATCH_RUNNING;
+	}
+
+	CMainMenuPlayListEntry* pEntry = FindControl< CMainMenuPlayListEntry >( "CasualEntry", true );
+	if ( pEntry )
+	{
+		pEntry->SetDisabledReason( eDisabledState );
+	}
+
+	pEntry = FindControl< CMainMenuPlayListEntry >( "MvMEntry", true );
+	if ( pEntry )
+	{
+		pEntry->SetDisabledReason( eDisabledState );
+	}
+
+	pEntry = FindControl< CMainMenuPlayListEntry >( "CompetitiveEntry", true );
+	if ( pEntry )
+	{
+		// Only check competitive access last
+		if ( eDisabledState == CMainMenuPlayListEntry::NOT_DISABLED )
+		{
+			eDisabledState = !GTFGCClientSystem()->BHasCompetitiveAccess() ? CMainMenuPlayListEntry::DISABLED_NO_COMP_ACCESS : eDisabledState;
+		}
+		pEntry->SetDisabledReason( eDisabledState );
+	}
+}
+
+void CHudMainMenuOverride::SOEvent( const CSharedObject* pObject )
+{
+	if ( pObject->GetTypeID() == CEconGameAccountClient::k_nTypeID )
+	{
+		UpdatePlaylistEntries();
+	}
+
+	if ( pObject->GetTypeID() != CEconItem::k_nTypeID )
+		return;
+
+	CEconItem *pEconItem = (CEconItem *)pObject;
+
+	// If the item is a competitive pass - update the main menu lock
+	// From _items_main.txt
+	const item_definition_index_t kCompetitivePassID = 1167;
+	if ( pEconItem->GetItemDefIndex() == kCompetitivePassID )
+	{
+		CHudMainMenuOverride *pMMPanel = (CHudMainMenuOverride*)gViewPortInterface->FindPanelByName(PANEL_MAINMENUOVERRIDE);
+		if (pMMPanel)
+		{
+			pMMPanel->UpdatePlaylistEntries();
+		}
+	}
+
+}
+
+
+
+#define REMAP_COMMAND( oldCommand, newCommand ) \
+	const char *pszKey##oldCommand = engine->Key_LookupBindingExact(#oldCommand); \
+	const char *pszNewKey##oldCommand = engine->Key_LookupBindingExact(#newCommand); \
+	if ( pszKey##oldCommand && !pszNewKey##oldCommand ) \
+	{ \
+		Msg( "Rebinding key %s to new command " #newCommand ".\n", pszKey##oldCommand ); \
+		engine->ClientCmd_Unrestricted( VarArgs( "bind \"%s\" \"" #newCommand "\"\n", pszKey##oldCommand ) ); \
+	}
+
+//-----------------------------------------------------------------------------
+// Purpose: Rebinds any binds for old commands to their new commands.
+//-----------------------------------------------------------------------------
+void CHudMainMenuOverride::PerformKeyRebindings( void )
+{
+	REMAP_COMMAND( inspect, +inspect );
+	REMAP_COMMAND( taunt, +taunt );
+	REMAP_COMMAND( use_action_slot_item, +use_action_slot_item );
+	REMAP_COMMAND( use_action_slot_item_server, +use_action_slot_item_server );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: GC Msg handler to receive the MOTD request response
+//-----------------------------------------------------------------------------
+class CGCMOTDRequestResponse : public GCSDK::CGCClientJob
+{
+public:
+	CGCMOTDRequestResponse( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
+
+	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
+	{
+		GCSDK::CGCMsg<MsgGCMOTDRequestResponse_t> msg( pNetPacket );
+
+		// No new entries?
+		if ( !msg.Body().m_nEntries )
+			return true;
+
+		// No main menu panel?
+		CHudMainMenuOverride *pMMPanel = (CHudMainMenuOverride*)gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE );
+		if ( !pMMPanel )
+			return true;
+
+		// Get our local language
+		char uilanguage[ 64 ];
+		uilanguage[0] = 0;
+		engine->GetUILanguage( uilanguage, sizeof( uilanguage ) );
+
+		//V_strcpy_safe( uilanguage, "german" );
+
+		KeyValues *pEntriesKV = new KeyValues( "motd_entries");
+
+		// Try and load the cache file. If we fail, we'll just create a new one.
+		if ( !pMMPanel->ReloadedAllMOTDs() )
+		{
+			pEntriesKV->LoadFromFile( g_pFullFileSystem, GC_MOTD_CACHE_FILE );
+		}
+
+		bool bNewMOTDs = false;
+
+		// Store the time & language we last checked.
+		char rtime_buf[k_RTimeRenderBufferSize];
+		pEntriesKV->SetString( "last_request_time", CRTime::RTime32ToString( pMMPanel->GetLastMOTDRequestTime(), rtime_buf ) );
+		pEntriesKV->SetString( "last_request_language", GetLanguageShortName( pMMPanel->GetLastMOTDRequestLanguage() ) );
+
+		// Read in the entries one by one, and insert them into our keyvalues structure.
+		for ( int i = 0; i < msg.Body().m_nEntries; i++ )
+		{
+			char pchMsgString[2048];
+
+			if ( !msg.BReadStr( pchMsgString, Q_ARRAYSIZE( pchMsgString ) ) )
+				return false;
+
+			// If there's already an entry with this index, overwrite the data
+			KeyValues *pNewEntry = pEntriesKV->FindKey( pchMsgString );
+			if ( !pNewEntry )
+			{
+				pNewEntry = new KeyValues( pchMsgString );
+				pEntriesKV->AddSubKey( pNewEntry );
+			}
+			pNewEntry->SetName( pchMsgString );
+
+			RTime32 iTime;
+			if ( !msg.BReadUintData( &iTime ) )
+				return false;
+			pNewEntry->SetString( "post_time", CRTime::RTime32ToString(iTime, rtime_buf) );
+
+			if ( !msg.BReadStr( pchMsgString, Q_ARRAYSIZE( pchMsgString ) ) )
+				return false;
+			pNewEntry->SetString( VarArgs("title_%s", uilanguage), pchMsgString );
+
+			if ( !msg.BReadStr( pchMsgString, Q_ARRAYSIZE( pchMsgString ) ) )
+				return false;
+			pNewEntry->SetString( VarArgs("text_%s", uilanguage), pchMsgString );
+
+			if ( !msg.BReadStr( pchMsgString, Q_ARRAYSIZE( pchMsgString ) ) )
+				return false;
+			pNewEntry->SetString( "url", pchMsgString );
+
+			if ( !msg.BReadStr( pchMsgString, Q_ARRAYSIZE( pchMsgString ) ) )
+				return false;
+			pNewEntry->SetString( "image", pchMsgString );
+
+			int iHeadertype;
+			if ( !msg.BReadIntData( &iHeadertype ) )
+				return false;
+			pNewEntry->SetString( "header_type", CFmtStr( "%d", iHeadertype ).Access() );
+
+			if ( !msg.BReadStr( pchMsgString, Q_ARRAYSIZE( pchMsgString ) ) )
+				return false;
+			pNewEntry->SetString( VarArgs("header_%s", uilanguage), pchMsgString );
+
+			if ( !msg.BReadStr( pchMsgString, Q_ARRAYSIZE( pchMsgString ) ) )
+				return false;
+			pNewEntry->SetString( "header_icon", pchMsgString );
+
+			bNewMOTDs = true;
+		}
+
+		// Tell the schema to reload its MOTD block
+		CUtlVector< CUtlString > vecErrors;
+		pMMPanel->GetMOTDManager().BInitMOTDEntries( pEntriesKV, &vecErrors );
+		pMMPanel->GetMOTDManager().PurgeUnusedMOTDEntries( pEntriesKV );
+
+		// Save out our cache
+		pEntriesKV->SaveToFile( g_pFullFileSystem, GC_MOTD_CACHE_FILE );
+
+		// And tell the main menu to refresh the MOTD.
+		//pMMPanel->SetMOTDVisible( bNewMOTDs ); HACK!  Temporarily turn this off!
+		pMMPanel->UpdateMOTD( bNewMOTDs );
+		return true;
+	}
+};
+
+GC_REG_JOB( GCSDK::CGCClient, CGCMOTDRequestResponse, "CGCMOTDRequestResponse", k_EMsgGCMOTDRequestResponse, GCSDK::k_EServerTypeGCClient );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMainMenuToolTip::PerformLayout()
+{
+	if ( !ShouldLayout() )
+		return;
+
+	_isDirty = false;
+
+	// Resize our text labels to fit.
+	int iW = 0;
+	int iH = 0;
+	for (int i = 0; i < m_pEmbeddedPanel->GetChildCount(); i++)
+	{
+		vgui::Label *pLabel = dynamic_cast<vgui::Label*>( m_pEmbeddedPanel->GetChild(i) );
+		if ( !pLabel )
+			continue;
+
+		// Only checking to see if we have any text
+		char szTmp[2];
+		pLabel->GetText( szTmp, sizeof(szTmp) );
+		if ( !szTmp[0] )
+			continue;
+
+		pLabel->InvalidateLayout(true);
+
+		int iX, iY;
+		pLabel->GetPos( iX, iY );
+		iW = MAX( iW, ( pLabel->GetWide() + (iX * 2) ) );
+
+		if ( iH == 0 )
+		{
+			iH += MAX( iH, pLabel->GetTall() + (iY * 2) );
+		}
+		else
+		{
+			iH += MAX( iH, pLabel->GetTall() );
+		}
+	}
+	m_pEmbeddedPanel->SetSize( iW, iH );
+
+	m_pEmbeddedPanel->SetVisible(true);
+
+	PositionWindow( m_pEmbeddedPanel );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMainMenuToolTip::HideTooltip()
+{
+	if ( m_pEmbeddedPanel )
+	{
+		m_pEmbeddedPanel->SetVisible(false);
+	}
+
+	BaseTooltip::HideTooltip();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMainMenuToolTip::SetText(const char *pszText) 
+{ 
+	if ( m_pEmbeddedPanel )
+	{
+		_isDirty = true;
+
+		if ( pszText && pszText[0] == '#' )
+		{
+			m_pEmbeddedPanel->SetDialogVariable( "tiptext", g_pVGuiLocalize->Find( pszText ) );
+		}
+		else
+		{
+			m_pEmbeddedPanel->SetDialogVariable( "tiptext", pszText );
+		}
+		m_pEmbeddedPanel->SetDialogVariable( "tipsubtext", "" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reload the .res file
+//-----------------------------------------------------------------------------
+#if defined( STAGING_ONLY )
+ConVar tf_icon_festive( "tf_icon_festive", 0 );
+CON_COMMAND( mainmenu_refresh, "" )
+{
+	CHudMainMenuOverride *pMMPanel = (CHudMainMenuOverride*)gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE );
+	if ( !pMMPanel )
+		return;
+
+	pMMPanel->InvalidateLayout( true, true );
+}
+
+CON_COMMAND( create_icons, "Generate 512 x 512 Paint Kit Item Icons for SteamMarket, Specify min and max itemdef ranges if desired" )
+{
+	tf_icon_festive.SetValue( false );
+	CHudMainMenuOverride *pMMPanel = (CHudMainMenuOverride*)gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE );
+	if ( !pMMPanel )
+		return;
+
+	int min = args.ArgC() > 1 ? atoi( args[1] ) : -1;
+	int max = args.ArgC() > 2 ? atoi( args[2] ) : -1;
+
+	pMMPanel->GenerateIcons( false, min, max );
+}
+
+CON_COMMAND( create_icons_large, "Generate 1024 x 1024 Paint Kit Item Icons for Testing, Specify min and max itemdef ranges if desired" )
+{
+	tf_icon_festive.SetValue( false );
+	CHudMainMenuOverride *pMMPanel = (CHudMainMenuOverride*)gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE );
+	if ( !pMMPanel )
+		return;
+
+	int min = args.ArgC() > 1 ? atoi( args[1] ) : -1;
+	int max = args.ArgC() > 2 ? atoi( args[2] ) : -1;;
+
+	pMMPanel->GenerateIcons( true, min, max );
+}
+
+CON_COMMAND( create_icons_festive, "" )
+{
+	tf_icon_festive.SetValue( true );
+
+	CHudMainMenuOverride *pMMPanel = (CHudMainMenuOverride*)gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE );
+	if ( !pMMPanel )
+		return;
+
+	int min = args.ArgC() > 1 ? atoi( args[1] ) : -1;
+	int max = args.ArgC() > 2 ? atoi( args[2] ) : -1;
+
+	pMMPanel->GenerateIcons( false, min, max );
+}
+
+//-----------------------------------------------------------------------------
+void BuildPaintkitItemInventoryImagePath( char *pchOutfile, int nMaxPath, const CTFItemDefinition *pItemDef, int iWear, bool bLargeTestIcons )
+{
+//	CUtlString strDefName( pItemDef->GetDefinitionName() );
+	//strDefName = strDefName.Replace( ' ', '_' );
+	//strDefName.ToLower();
+//	const char *pchDefName = strDefName;
+
+	bool bIsPaintkitItem = pItemDef->GetCustomPainkKitDefinition() != NULL;
+	const char *pchOutputFolder;
+	if ( bIsPaintkitItem )
+	{
+		pchOutputFolder = bLargeTestIcons ? "resource/econ/generated_icons/LargeTest/" : "scripts/items/unencrypted/icons/generated_paintkit_icons/";
+	}
+	else
+	{
+		pchOutputFolder = "scripts/items/unencrypted/icons/generated_item_icons/";
+	}
+
+//	const char *pWear = bIsPaintkitItem ? CFmtStr( "_wear%d", iWear ) : "";
+	char fname[ MAX_PATH ];
+	V_FileBase( pItemDef->GetInventoryImage(), fname, sizeof(fname) );
+
+	if ( tf_icon_festive.GetBool() == true )
+	{
+		V_snprintf( pchOutfile, nMaxPath, "%s%s_festive.png",
+			pchOutputFolder,
+			fname
+		);
+	}
+	else
+	{
+		V_snprintf( pchOutfile, nMaxPath, "%s%s.png",
+			pchOutputFolder,
+			fname
+		);
+	}
+}
+//-----------------------------------------------------------------------------
+bool SaveImageIconAsPng( CEconItemView *pItem, ITexture *pInputTexture, const char *pszFilePath )
+{
+	bool bRet = false;
+	ITexture *pTexture = materials->FindTexture( "_rt_FullFrameFB1", TEXTURE_GROUP_RENDER_TARGET );
+
+	if ( !pTexture )
+		return bRet;
+
+	// If this is 3 4, we're only generating the actual composite texture for SFM
+	ConVarRef r_texcomp_dump( "r_texcomp_dump" );
+	if ( r_texcomp_dump.GetInt() == 4 )
+	{
+		return true;	
+	}
+
+	if ( pTexture->GetImageFormat() == IMAGE_FORMAT_RGBA8888 ||
+		pTexture->GetImageFormat() == IMAGE_FORMAT_ABGR8888 ||
+		pTexture->GetImageFormat() == IMAGE_FORMAT_ARGB8888 ||
+		pTexture->GetImageFormat() == IMAGE_FORMAT_BGRA8888 ||
+		pTexture->GetImageFormat() == IMAGE_FORMAT_BGRX8888 )
+	{
+		int width = Min( pInputTexture->GetActualWidth(), pTexture->GetActualWidth() );
+		int height = Min( pInputTexture->GetActualHeight(), pTexture->GetActualHeight() );
+		Rect_t SrcRect = { 0, 0, width, height };
+		Rect_t DstRect = SrcRect;
+
+		if ( ( width > 0 ) && ( height > 0 ) )
+		{
+			void *pixelValue = malloc( width * height * sizeof( RGBA8888_t ) );
+
+			if ( pixelValue )
+			{
+				CMatRenderContextPtr pRenderContext( materials );
+
+				pRenderContext->PushRenderTargetAndViewport( pTexture, 0, 0, width, height );
+				pRenderContext->CopyTextureToRenderTargetEx( 0, pInputTexture, &SrcRect, &DstRect );
+
+				pRenderContext->ReadPixels( 0, 0, width, height, (unsigned char *)pixelValue, pInputTexture->GetImageFormat() );
+
+				CUtlBuffer outBuffer;
+				ImgUtl_WriteRGBAAsPNGToBuffer( reinterpret_cast<const unsigned char *>( pixelValue ), width, height, outBuffer );
+
+				FileHandle_t hFileOut = g_pFullFileSystem->Open( pszFilePath, "wb" );
+				if ( hFileOut != FILESYSTEM_INVALID_HANDLE )
+				{
+					Msg( "Saved.. %s\n", pszFilePath );
+					g_pFullFileSystem->Write( outBuffer.Base(), outBuffer.TellPut(), hFileOut );
+					g_pFullFileSystem->Close( hFileOut );
+					bRet = true;
+				}
+
+				// restore our previous state
+				pRenderContext->PopRenderTargetAndViewport();
+
+				free( pixelValue );
+			}
+		}
+	}
+	return bRet;
+}
+//-----------------------------------------------------------------------------
+extern ConVar tf_paint_kit_force_wear;
+
+ConVar tf_paint_kit_icon_generating_index( "tf_paint_kit_icon_generating_index", 0 );
+
+void StartNextImage( CEconItemView *pItemData, CEmbeddedItemModelPanel *pItemModelPanel, const CUtlVector< item_definition_index_t > &vecItemDef, float flCurrentWear )
+{
+	// Init the item
+	item_definition_index_t iDefIndex = vecItemDef[ tf_paint_kit_icon_generating_index.GetInt() ];
+	pItemData->Init( iDefIndex, AE_PAINTKITWEAPON, AE_USE_SCRIPT_VALUE, true );
+	pItemData->SetWeaponSkinBase( NULL );
+	pItemData->SetWeaponSkinBaseCompositor( NULL );
+
+	bool bIsPaintkitItem = pItemData->GetCustomPainkKitDefinition() != NULL;
+	if ( bIsPaintkitItem )
+	{
+		// Set up the wear
+		static CSchemaAttributeDefHandle pAttrDef_TextureWear( "set_item_texture_wear" );
+		pItemData->GetAttributeList()->SetRuntimeAttributeValue( pAttrDef_TextureWear, flCurrentWear );
+
+		Msg( "Force Setting PaintKit Wear for Icon Generation : Wear Level %d", tf_paint_kit_force_wear.GetInt() );
+	}
+	else
+	{
+		// force use_model_cache_icon
+		static CSchemaAttributeDefHandle pAttrDef_UseModelCacheIcon( "use_model_cache_icon" );
+		uint32 unUseModelCacheIcon = 1;
+		pItemData->GetAttributeList()->SetRuntimeAttributeValue( pAttrDef_UseModelCacheIcon, unUseModelCacheIcon );
+	}
+
+	// Add festive attr if enabled
+	if ( tf_icon_festive.GetBool() == true )
+	{
+		static CSchemaAttributeDefHandle pAttrDef_IsFestivized( "is_festivized" );
+		pItemData->GetAttributeList()->SetRuntimeAttributeValue( pAttrDef_IsFestivized, 1 );
+	}
+	//int iWear = EconWear_ToIntCategory( flCurrentWear );
+
+	// Force set convar for wear
+	//tf_paint_kit_force_wear.SetValue( iWear );
+	
+	// force image generation to use high res
+	pItemData->SetWeaponSkinUseHighRes( true );
+
+	pItemModelPanel->SetItem( pItemData );
+	pItemModelPanel->InvalidateLayout( true, true );
+}
+
+extern ConVar tf_paint_kit_generating_icons;
+void CHudMainMenuOverride::GenerateIconsThink()
+{
+	CEmbeddedItemModelPanel *pItemModelPanel = dynamic_cast<CEmbeddedItemModelPanel *>( FindChildByName( "icon_generator" ) );
+	if ( !pItemModelPanel )
+		return;
+
+	ITexture *pIcon = pItemModelPanel->GetCachedGeneratedIcon();
+	if ( !pIcon )
+		return;
+
+	Msg( "Saving.. [%d] - %s\n", m_pIconData->GetItemDefIndex(), m_pIconData->GetItemDefinition()->GetDefinitionName() );
+
+	// Generate filepath
+	char outfile[ MAX_PATH ];
+	BuildPaintkitItemInventoryImagePath( outfile, sizeof(outfile), m_pIconData->GetItemDefinition(), tf_paint_kit_force_wear.GetInt(), m_bGeneratingLargeTestIcons );
+	SaveImageIconAsPng( m_pIconData, pIcon, outfile );
+
+	// Generate next step
+	while ( true )
+	{
+		int iIndex = tf_paint_kit_icon_generating_index.GetInt();
+		iIndex++;
+
+		// Increment Index, if index is greater, increment wear
+		if ( iIndex >= m_vecIconDefs.Count() )
+		{
+			iIndex = 0;
+			if ( tf_paint_kit_force_wear.GetInt() == 5 )
+			{
+				// reset bg color
+				SetBgColor( Color( 0, 0, 0, 0 ) );
+				m_bGeneratingIcons = false;
+				Msg( "Icon Generating Completed" );
+				tf_paint_kit_generating_icons.SetValue( 0 );
+				tf_paint_kit_icon_generating_index.SetValue( 0 );
+				return;
+			}
+			else
+			{
+				tf_paint_kit_force_wear.SetValue( tf_paint_kit_force_wear.GetInt() + 1 );
+			}
+		}
+
+		tf_paint_kit_icon_generating_index.SetValue( iIndex );
+
+		// only render non-paintkit item one time
+		if ( tf_paint_kit_force_wear.GetInt() > 0 )
+		{
+			// search for the next paintkit item to draw
+			 item_definition_index_t iDefIndex = m_vecIconDefs[ tf_paint_kit_icon_generating_index.GetInt() ];
+			CEconItemView temp;
+			temp.Init( iDefIndex, AE_PAINTKITWEAPON, AE_USE_SCRIPT_VALUE, true );
+			if ( temp.GetCustomPainkKitDefinition() )
+			{
+				// draw this one
+				break;
+			}
+		}
+	}
+
+	// start next item, other wise increment wear and go again
+	delete m_pIconData;
+	m_pIconData = new CEconItemView;
+	StartNextImage( m_pIconData, pItemModelPanel, m_vecIconDefs, 0.2f );
+}
+
+ConVar tf_icon_bgcolor_override( "tf_icon_bgcolor_override", "" );
+ConVar tf_icon_allow_all_items( "tf_icon_allow_all_items", "0" );
+void CHudMainMenuOverride::GenerateIcons( bool bLarge, int min /*= -1*/, int max /*= -1*/ )
+{
+	CEmbeddedItemModelPanel *pItemModelPanel = dynamic_cast<CEmbeddedItemModelPanel *>( FindChildByName("icon_generator") );
+	if ( !pItemModelPanel )
+		return;
+
+	const char *pszBGColor = tf_icon_bgcolor_override.GetString();
+	if ( pszBGColor && *pszBGColor )
+	{
+		color32 bgcolor;
+		UTIL_StringToColor32( &bgcolor, pszBGColor );
+		SetBgColor( Color( bgcolor.r, bgcolor.g, bgcolor.b, 255 ) );
+	}
+
+
+	const char *pchOutputFolder = bLarge ? "resource/econ/generated_icons/LargeTest/" : "scripts/items/unencrypted/icons/generated_paintkit_icons";
+	g_pFullFileSystem->CreateDirHierarchy( pchOutputFolder, NULL );
+
+	pItemModelPanel->SetTall( 1024 );
+	pItemModelPanel->SetWide( 1024 );
+	//pItemModelPanel->SetZPos( 1000 );
+
+	pItemModelPanel->SetInventoryImageType( CEmbeddedItemModelPanel::IMAGETYPE_LARGE );
+	pItemModelPanel->SetVisible( true );
+	pItemModelPanel->m_bOfflineIconGeneration = true;
+
+	int rtSize = bLarge ? 1024 : 512;
+
+	// Create a larger render target
+	materials->OverrideRenderTargetAllocation( true );
+
+	materials->CreateNamedRenderTargetTextureEx2( 
+		"offline_icon_generation", 
+		rtSize, rtSize, 
+		RT_SIZE_DEFAULT, 
+		materials->GetBackBufferFormat(), 
+		MATERIAL_RT_DEPTH_SHARED, 
+		TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT, 
+		0 );
+	materials->OverrideRenderTargetAllocation( false );
+
+	// Populate list of item icons
+	m_vecIconDefs.RemoveAll();
+	const CEconItemSchema::SortedItemDefinitionMap_t &mapItems = GetItemSchema()->GetSortedItemDefinitionMap();
+
+	int nPaintkitItems = 0;
+	int nNormalItems = 0;
+
+	FOR_EACH_MAP( mapItems, idxItem )
+	{
+		CEconItemDefinition *pItem = mapItems[idxItem];
+		CTFItemDefinition *pTFDef = (CTFItemDefinition *)pItem;
+		item_definition_index_t iDefIndex = pTFDef->GetDefinitionIndex();
+		
+		// skip numbers below min
+		if ( min != -1 && iDefIndex < min )
+			continue;
+
+		// skip numbers if above.  do not 'break;' since mapItems may NOT be in defindex order
+		if ( max != -1 && iDefIndex > max )
+			continue;
+
+		if ( pTFDef->GetCustomPainkKitDefinition() )
+		{
+			m_vecIconDefs.AddToTail( iDefIndex );
+
+			nPaintkitItems++;
+		}
+		else if ( tf_icon_allow_all_items.GetBool() )
+		{
+			m_vecIconDefs.AddToTail( iDefIndex );
+
+			nNormalItems++;
+		}
+	}
+
+	if ( !m_vecIconDefs.Count() )
+	{
+		Msg( "Didn't find any valid itemdefs to generate icons for" );
+		return;
+	}
+
+	Msg( "Found %d Valid Item defs. %d normal items and %d paintkit items\n", m_vecIconDefs.Count(), nNormalItems, nPaintkitItems );
+	
+	int nNumGeneratingIcons = nNormalItems + nPaintkitItems * 5;
+	Msg( "Generating Icons for %d Items and 5 Wear Levels for each paintkit items (%d icons total)\n", m_vecIconDefs.Count(), nNumGeneratingIcons );
+
+
+	// Starting conditions
+	tf_paint_kit_force_wear.SetValue( 1 );
+	tf_paint_kit_generating_icons.SetValue( 1 );
+
+	// Create a dummy item
+	m_pIconData = new CEconItemView;
+	StartNextImage( m_pIconData, pItemModelPanel, m_vecIconDefs, 0.2 );
+
+	m_bGeneratingIcons = true;
+	m_bGeneratingLargeTestIcons = bLarge;
+}
+#endif
+
+
+
+