tf2/tf2_src/gameui/GameUI_Interface.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements all the functions exported by the GameUI dll
//
// $NoKeywords: $
//===========================================================================//

#ifdef WIN32
#if !defined( _X360 )
#include <windows.h>
#endif
#include <io.h>
#include <direct.h>
#elif defined( POSIX )
#include <sys/time.h>
#else
#error
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <tier0/dbg.h>

#ifdef SendMessage
#undef SendMessage
#endif
																
#include "filesystem.h"
#include "GameUI_Interface.h"
#include "Sys_Utils.h"
#include "string.h"
#include "tier0/icommandline.h"

// interface to engine
#include "EngineInterface.h"

#include "replay/ienginereplay.h"
#include "replay/ireplaysystem.h"

#include "VGuiSystemModuleLoader.h"
#include "bitmap/tgaloader.h"

#include "GameConsole.h"
#include "LoadingDialog.h"
#include "CDKeyEntryDialog.h"
#include "ModInfo.h"
#include "game/client/IGameClientExports.h"
#include "materialsystem/imaterialsystem.h"
#include "engine/imatchmaking.h"
#include "ixboxsystem.h"
#include "iachievementmgr.h"
#include "IGameUIFuncs.h"
#include <ienginevgui.h>
#include "steam/steam_api.h"
#include "BonusMapsDatabase.h"
#include "BonusMapsDialog.h"
#include "sourcevr/isourcevirtualreality.h"

// vgui2 interface
// note that GameUI project uses ..\vgui2\include, not ..\utils\vgui\include
#include "BasePanel.h"

#include <vgui/Cursor.h>
#include <KeyValues.h>
#include <vgui/ILocalize.h>
#include <vgui/IPanel.h>
#include <vgui/IScheme.h>
#include <vgui/IVGui.h>
#include <vgui/ISystem.h>
#include <vgui/ISurface.h>
#include <vgui_controls/Menu.h>
#include <vgui_controls/PHandle.h>
#include "tier3/tier3.h"
#include "tier0/vcrmode.h"
#include "matsys_controls/matsyscontrols.h"
#include "steam/steam_api.h"

#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#endif

#include "tier0/dbg.h"
#include "engine/IEngineSound.h"

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

IGameUIFuncs *gameuifuncs = NULL;
IEngineVGui *enginevguifuncs = NULL;
IMatchmaking *matchmaking = NULL;
IXboxSystem *xboxsystem = NULL;		// 360 only
vgui::ISurface *enginesurfacefuncs = NULL;
IVEngineClient *engine = NULL;
IEngineSound *enginesound = NULL;
IAchievementMgr *achievementmgr = NULL;
IEngineClientReplay *g_pEngineClientReplay = NULL;
ISourceVirtualReality *g_pSourceVR = NULL;

static CSteamAPIContext g_SteamAPIContext;
CSteamAPIContext *steamapicontext = &g_SteamAPIContext;

static CBasePanel *staticPanel = NULL;

class CGameUI;
CGameUI *g_pGameUI = NULL;

class CLoadingDialog;
vgui::DHANDLE<CLoadingDialog> g_hLoadingDialog;
vgui::VPANEL g_hLoadingBackgroundDialog = NULL;

static CGameUI g_GameUI;
static WHANDLE g_hMutex = NULL;
static WHANDLE g_hWaitMutex = NULL;

static IGameClientExports *g_pGameClientExports = NULL;
IGameClientExports *GameClientExports()
{
	return g_pGameClientExports;
}

//-----------------------------------------------------------------------------
// Purpose: singleton accessor
//-----------------------------------------------------------------------------
CGameUI &GameUI()
{
	return g_GameUI;
}

EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CGameUI, IGameUI, GAMEUI_INTERFACE_VERSION, g_GameUI);

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGameUI::CGameUI()
{
	g_pGameUI = this;
	m_bTryingToLoadFriends = false;
	m_iFriendsLoadPauseFrames = 0;
	m_iGameIP = 0;
	m_iGameConnectionPort = 0;
	m_iGameQueryPort = 0;
	m_bActivatedUI = false;
	m_szPreviousStatusText[0] = 0;
	m_bIsConsoleUI = false;
	m_bHasSavedThisMenuSession = false;
	m_bOpenProgressOnStart = false;
}

//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGameUI::~CGameUI()
{
	g_pGameUI = NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Initialization
//-----------------------------------------------------------------------------
void CGameUI::Initialize( CreateInterfaceFn factory )
{
	ConnectTier1Libraries( &factory, 1 );
	ConnectTier2Libraries( &factory, 1 );
	ConVar_Register( FCVAR_CLIENTDLL );
	ConnectTier3Libraries( &factory, 1 );

	enginesound = (IEngineSound *)factory(IENGINESOUND_CLIENT_INTERFACE_VERSION, NULL);
	engine = (IVEngineClient *)factory( VENGINE_CLIENT_INTERFACE_VERSION, NULL );

	steamapicontext->Init();

	ConVarRef var( "gameui_xbox" );
	m_bIsConsoleUI = var.IsValid() && var.GetBool();

	vgui::VGui_InitInterfacesList( "GameUI", &factory, 1 );
	vgui::VGui_InitMatSysInterfacesList( "GameUI", &factory, 1 );

	// load localization file
	g_pVGuiLocalize->AddFile( "Resource/gameui_%language%.txt", "GAME", true );

	// load mod info
	ModInfo().LoadCurrentGameInfo();

	// load localization file for kb_act.lst
	g_pVGuiLocalize->AddFile( "Resource/valve_%language%.txt", "GAME", true );

	enginevguifuncs = (IEngineVGui *)factory( VENGINE_VGUI_VERSION, NULL );
	enginesurfacefuncs = (vgui::ISurface *)factory(VGUI_SURFACE_INTERFACE_VERSION, NULL);
	gameuifuncs = (IGameUIFuncs *)factory( VENGINE_GAMEUIFUNCS_VERSION, NULL );
	matchmaking = (IMatchmaking *)factory( VENGINE_MATCHMAKING_VERSION, NULL );
	xboxsystem = (IXboxSystem *)factory( XBOXSYSTEM_INTERFACE_VERSION, NULL );
	g_pEngineClientReplay = (IEngineClientReplay *)factory( ENGINE_REPLAY_CLIENT_INTERFACE_VERSION, NULL );

	if ( ModInfo().SupportsVR() && CommandLine()->CheckParm( "-vr" ) )
	{
		g_pSourceVR = (ISourceVirtualReality *)factory( SOURCE_VIRTUAL_REALITY_INTERFACE_VERSION, NULL );
	}

	// NOTE: g_pEngineReplay intentionally not checked here
	if ( !enginesurfacefuncs || !gameuifuncs || !enginevguifuncs || !xboxsystem || (IsX360() && !matchmaking) )
	{
		Error( "CGameUI::Initialize() failed to get necessary interfaces\n" );
	}

	// setup base panel
	staticPanel = new CBasePanel();
	staticPanel->SetBounds(0, 0, 400, 300 );
	staticPanel->SetPaintBorderEnabled( false );
	staticPanel->SetPaintBackgroundEnabled( true );
	staticPanel->SetPaintEnabled( false );
	staticPanel->SetVisible( true );
	staticPanel->SetMouseInputEnabled( false );
	staticPanel->SetKeyBoardInputEnabled( false );

	vgui::VPANEL rootpanel = enginevguifuncs->GetPanel( PANEL_GAMEUIDLL );
	staticPanel->SetParent( rootpanel );
}

void CGameUI::PostInit()
{
	if ( IsX360() )
	{
		enginesound->PrecacheSound( "UI/buttonrollover.wav", true, true );
		enginesound->PrecacheSound( "UI/buttonclick.wav", true, true );
		enginesound->PrecacheSound( "UI/buttonclickrelease.wav", true, true );
		enginesound->PrecacheSound( "player/suit_denydevice.wav", true, true );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Sets the specified panel as the background panel for the loading
//		dialog.  If NULL, default background is used.  If you set a panel,
//		it should be full-screen with an opaque background, and must be a VGUI popup.
//-----------------------------------------------------------------------------
void CGameUI::SetLoadingBackgroundDialog( vgui::VPANEL panel )
{
	g_hLoadingBackgroundDialog = panel;
}

void CGameUI::BonusMapUnlock( const char *pchFileName, const char *pchMapName )
{
	if ( !pchFileName || pchFileName[ 0 ] == '\0' || 
		 !pchMapName || pchMapName[ 0 ] == '\0' )
	{
		if ( !g_pBonusMapsDialog )
			return;

		g_pBonusMapsDialog->SetSelectedBooleanStatus( "lock", false );
		return;
	}

	if ( BonusMapsDatabase()->SetBooleanStatus( "lock", pchFileName, pchMapName, false ) )
	{
		BonusMapsDatabase()->RefreshMapData();

		if ( !g_pBonusMapsDialog )
		{
			// It unlocked without the bonus maps menu open, so flash the menu item
			CBasePanel *pBasePanel = BasePanel();
			if ( pBasePanel )
			{
				if ( GameUI().IsConsoleUI() )
				{
					if ( Q_stricmp( pchFileName, "scripts/advanced_chambers" ) == 0 )
					{
						pBasePanel->SetMenuItemBlinkingState( "OpenNewGameDialog", true );
					}
				}
				else
				{
					pBasePanel->SetMenuItemBlinkingState( "OpenBonusMapsDialog", true );
				}
			}

			BonusMapsDatabase()->SetBlink( true );
		}
		else
			g_pBonusMapsDialog->RefreshData();	// Update the open dialog
	}
}

void CGameUI::BonusMapComplete( const char *pchFileName, const char *pchMapName )
{
	if ( !pchFileName || pchFileName[ 0 ] == '\0' || 
		 !pchMapName || pchMapName[ 0 ] == '\0' )
	{
		if ( !g_pBonusMapsDialog )
			return;

		g_pBonusMapsDialog->SetSelectedBooleanStatus( "complete", true );
		BonusMapsDatabase()->RefreshMapData();
		g_pBonusMapsDialog->RefreshData();
		return;
	}

	if ( BonusMapsDatabase()->SetBooleanStatus( "complete", pchFileName, pchMapName, true ) )
	{
		BonusMapsDatabase()->RefreshMapData();

		// Update the open dialog
		if ( g_pBonusMapsDialog )
			g_pBonusMapsDialog->RefreshData();
	}
}

void CGameUI::BonusMapChallengeUpdate( const char *pchFileName, const char *pchMapName, const char *pchChallengeName, int iBest )
{
	if ( !pchFileName || pchFileName[ 0 ] == '\0' || 
		 !pchMapName || pchMapName[ 0 ] == '\0' || 
		 !pchChallengeName || pchChallengeName[ 0 ] == '\0' )
	{
		return;
	}
	else
	{
		if ( BonusMapsDatabase()->UpdateChallengeBest( pchFileName, pchMapName, pchChallengeName, iBest ) )
		{
			// The challenge best changed, so write it to the file
			BonusMapsDatabase()->WriteSaveData();
			BonusMapsDatabase()->RefreshMapData();

			// Update the open dialog
			if ( g_pBonusMapsDialog )
				g_pBonusMapsDialog->RefreshData();
		}
	}
}

void CGameUI::BonusMapChallengeNames( char *pchFileName, char *pchMapName, char *pchChallengeName )
{
	if ( !pchFileName || !pchMapName || !pchChallengeName )
		return;

	BonusMapsDatabase()->GetCurrentChallengeNames( pchFileName, pchMapName, pchChallengeName );
}

void CGameUI::BonusMapChallengeObjectives( int &iBronze, int &iSilver, int &iGold )
{
	BonusMapsDatabase()->GetCurrentChallengeObjectives( iBronze, iSilver, iGold );
}

void CGameUI::BonusMapDatabaseSave( void )
{
	BonusMapsDatabase()->WriteSaveData();
}

int CGameUI::BonusMapNumAdvancedCompleted( void )
{
	return BonusMapsDatabase()->NumAdvancedComplete();
}

void CGameUI::BonusMapNumMedals( int piNumMedals[ 3 ] )
{
	BonusMapsDatabase()->NumMedals( piNumMedals );
}

//-----------------------------------------------------------------------------
// Purpose: connects to client interfaces
//-----------------------------------------------------------------------------
void CGameUI::Connect( CreateInterfaceFn gameFactory )
{
	g_pGameClientExports = (IGameClientExports *)gameFactory(GAMECLIENTEXPORTS_INTERFACE_VERSION, NULL);

	achievementmgr = engine->GetAchievementMgr();

	if (!g_pGameClientExports)
	{
		Error("CGameUI::Initialize() failed to get necessary interfaces\n");
	}

	m_GameFactory = gameFactory;
}

//-----------------------------------------------------------------------------
// Purpose: Callback function; sends platform Shutdown message to specified window
//-----------------------------------------------------------------------------
int __stdcall SendShutdownMsgFunc(WHANDLE hwnd, int lparam)
{
	Sys_PostMessage(hwnd, Sys_RegisterWindowMessage("ShutdownValvePlatform"), 0, 1);
	return 1;
}

//-----------------------------------------------------------------------------
// Purpose: Searches for GameStartup*.mp3 files in the sound/ui folder and plays one
//-----------------------------------------------------------------------------
void CGameUI::PlayGameStartupSound()
{
	if ( IsX360() )
		return;

	if ( CommandLine()->FindParm( "-nostartupsound" ) )
		return;

	FileFindHandle_t fh;

	CUtlVector<char *> fileNames;
	char path[ 512 ];

	bool bHolidayFound = false;

	// only want to run the holiday check for TF2
	const char *pGameName = CommandLine()->ParmValue( "-game", "hl2" );
	if ( ( Q_stricmp( pGameName, "tf" ) == 0 ) || ( Q_stricmp( pGameName, "tf_beta" ) == 0 ) )
	{
		// check for a holiday sound file
		const char *pszHoliday = NULL;
	
		if ( GameClientExports() )
		{
			pszHoliday = GameClientExports()->GetHolidayString();
			if ( pszHoliday && pszHoliday[0] )
			{
				Q_snprintf( path, sizeof( path ), "sound/ui/holiday/gamestartup_%s*.mp3", pszHoliday );
				Q_FixSlashes( path );

				char const *fn = g_pFullFileSystem->FindFirstEx( path, "MOD", &fh );
				{
					if ( fn )
					{
						bHolidayFound = true;
					}
				}
			}
		}
	}

	// only want to do this if we haven't found a holiday file
	if ( !bHolidayFound )
	{
		Q_snprintf( path, sizeof( path ), "sound/ui/gamestartup*.mp3" );
		Q_FixSlashes( path );
	}

	char const *fn = g_pFullFileSystem->FindFirstEx( path, "MOD", &fh );
	if ( fn )
	{
		do
		{
			char ext[ 10 ];
			Q_ExtractFileExtension( fn, ext, sizeof( ext ) );

			if ( !Q_stricmp( ext, "mp3" ) )
			{
				char temp[ 512 ];
				if ( bHolidayFound )
				{
					Q_snprintf( temp, sizeof( temp ), "ui/holiday/%s", fn );
				}
				else
				{
					Q_snprintf( temp, sizeof( temp ), "ui/%s", fn );
				}

				char *found = new char[ strlen( temp ) + 1 ];
				Q_strncpy( found, temp, strlen( temp ) + 1 );

				Q_FixSlashes( found );
				fileNames.AddToTail( found );
			}
	
			fn = g_pFullFileSystem->FindNext( fh );

		} while ( fn );

		g_pFullFileSystem->FindClose( fh );
	}

	// did we find any?
	if ( fileNames.Count() > 0 )
	{
#ifdef WIN32
		SYSTEMTIME SystemTime;
		GetSystemTime( &SystemTime );
		int index = SystemTime.wMilliseconds % fileNames.Count();
#else
		struct timeval tm;
		gettimeofday( &tm, NULL );
		int index = tm.tv_usec/1000 % fileNames.Count();
#endif

		if ( fileNames.IsValidIndex( index ) && fileNames[index] )
		{
			// Play the Saxxy music if we're in saxxy mode.
#if defined( SAXXYMAINMENU_ENABLED )
			bool bIsTF = false;
			const char *pGameDir = engine->GetGameDirectory();
			if ( pGameDir )
			{
				// Is the game TF?
				const int nStrLen = V_strlen( pGameDir );
				bIsTF = nStrLen
					&& nStrLen >= 2 &&
					pGameDir[nStrLen-2] == 't' &&
					pGameDir[nStrLen-1] == 'f';
			}

			// escape chars "*#" make it stream, and be affected by snd_musicvolume
			const char *pSoundFile = bIsTF ? "ui/holiday/gamestartup_saxxy.mp3" : fileNames[index];
#else
			const char *pSoundFile = fileNames[index];
#endif

			char found[ 512 ];
			Q_snprintf( found, sizeof( found ), "play *#%s", pSoundFile );

			engine->ClientCmd_Unrestricted( found );
		}

		fileNames.PurgeAndDeleteElements();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called to setup the game UI
//-----------------------------------------------------------------------------
void CGameUI::Start()
{
	// determine Steam location for configuration
	if ( !FindPlatformDirectory( m_szPlatformDir, sizeof( m_szPlatformDir ) ) )
		return;

	if ( IsPC() )
	{
		// setup config file directory
		char szConfigDir[512];
		Q_strncpy( szConfigDir, m_szPlatformDir, sizeof( szConfigDir ) );
		Q_strncat( szConfigDir, "config", sizeof( szConfigDir ), COPY_ALL_CHARACTERS );

		Msg( "Steam config directory: %s\n", szConfigDir );

		g_pFullFileSystem->AddSearchPath(szConfigDir, "CONFIG");
		g_pFullFileSystem->CreateDirHierarchy("", "CONFIG");

		// user dialog configuration
		vgui::system()->SetUserConfigFile("InGameDialogConfig.vdf", "CONFIG");

		g_pFullFileSystem->AddSearchPath( "platform", "PLATFORM" );
	}

	// localization
	g_pVGuiLocalize->AddFile( "Resource/platform_%language%.txt");
	g_pVGuiLocalize->AddFile( "Resource/vgui_%language%.txt");

	Sys_SetLastError( SYS_NO_ERROR );

	if ( IsPC() )
	{
		if ( !IsPosix() )
		{
			// Alfred says this is really, really old code that does some wacky crap that only
			//  happened in the first version of HL and it's the only game that does this and
			//  it was a steam testing type thing and we don't need to do it on Posix, etc.

			g_hMutex = Sys_CreateMutex( "ValvePlatformUIMutex" );
			g_hWaitMutex = Sys_CreateMutex( "ValvePlatformWaitMutex" );
			if ( g_hMutex == 0 || g_hWaitMutex == 0 || Sys_GetLastError() == SYS_ERROR_INVALID_HANDLE )
			{
				// error, can't get handle to mutex
				if (g_hMutex)
				{
					Sys_ReleaseMutex(g_hMutex);
				}
				if (g_hWaitMutex)
				{
					Sys_ReleaseMutex(g_hWaitMutex);
				}
				g_hMutex = NULL;
				g_hWaitMutex = NULL;
				Error("Steam Error: Could not access Steam, bad mutex\n");
				return;
			}
			unsigned int waitResult = Sys_WaitForSingleObject(g_hMutex, 0);
			if (!(waitResult == SYS_WAIT_OBJECT_0 || waitResult == SYS_WAIT_ABANDONED))
			{
				// mutex locked, need to deactivate Steam (so we have the Friends/ServerBrowser data files)
				// get the wait mutex, so that Steam.exe knows that we're trying to acquire ValveTrackerMutex
				waitResult = Sys_WaitForSingleObject(g_hWaitMutex, 0);
#ifdef WIN32
				if (waitResult == SYS_WAIT_OBJECT_0 || waitResult == SYS_WAIT_ABANDONED)
				{
					Sys_EnumWindows(SendShutdownMsgFunc, 1);
				}
#endif
			}
		}
			
		// Delay playing the startup music until the first frame
		m_bPlayGameStartupSound = true;

		// now we are set up to check every frame to see if we can friends/server browser
		m_bTryingToLoadFriends = true;
		m_iFriendsLoadPauseFrames = 1;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Validates the user has a cdkey in the registry
//-----------------------------------------------------------------------------
void CGameUI::ValidateCDKey()
{
	// this check is disabled, since we have no plans for an offline version of hl2
#if 0
	//!! hack, write out a regkey for now so developers don't have to type it in
	//!! undo this before release
	vgui::system()->SetRegistryString("HKEY_CURRENT_USER\\Software\\Valve\\Source\\Settings\\EncryptedCDKey", "QOgi:JXrJj<Eb8abkESf4Pg;OfofJwDzRsyH>AdjtyPnV[FB");

	// see what's in the registry
	if (!CCDKeyEntryDialog::IsValidWeakCDKeyInRegistry())
	{
		m_hCDKeyEntryDialog = new CCDKeyEntryDialog(NULL, false);
		m_hCDKeyEntryDialog->Activate();
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Finds which directory the platform resides in
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CGameUI::FindPlatformDirectory(char *platformDir, int bufferSize)
{
	platformDir[0] = '\0';

	if ( platformDir[0] == '\0' )
	{
		// we're not under steam, so setup using path relative to game
		if ( IsPC() )
		{
#ifdef WIN32
			if ( ::GetModuleFileName( ( HINSTANCE )GetModuleHandle( NULL ), platformDir, bufferSize ) )
			{
				char *lastslash = strrchr(platformDir, '\\'); // this should be just before the filename
				if ( lastslash )
				{
					*lastslash = 0;
					Q_strncat(platformDir, "\\platform\\", bufferSize, COPY_ALL_CHARACTERS );
					return true;
				}
			}
#else
			if ( getcwd( platformDir, bufferSize ) )
			{
				V_AppendSlash( platformDir, bufferSize );
				Q_strncat(platformDir, "platform", bufferSize, COPY_ALL_CHARACTERS );
				V_AppendSlash( platformDir, bufferSize );
				return true;
			}
#endif			
		}
		else
		{
			// xbox fetches the platform path from exisiting platform search path
			// path to executeable is not correct for xbox remote configuration
			if ( g_pFullFileSystem->GetSearchPath( "PLATFORM", false, platformDir, bufferSize ) )
			{
				char *pSeperator = strchr( platformDir, ';' );
				if ( pSeperator )
					*pSeperator = '\0';
				return true;
			}
		}

		Error( "Unable to determine platform directory\n" );
		return false;
	}

	return (platformDir[0] != 0);
}

//-----------------------------------------------------------------------------
// Purpose: Called to Shutdown the game UI system
//-----------------------------------------------------------------------------
void CGameUI::Shutdown()
{
	// notify all the modules of Shutdown
	g_VModuleLoader.ShutdownPlatformModules();

	// unload the modules them from memory
	g_VModuleLoader.UnloadPlatformModules();

	ModInfo().FreeModInfo();
	
	// release platform mutex
	// close the mutex
	if (g_hMutex)
	{
		Sys_ReleaseMutex(g_hMutex);
	}
	if (g_hWaitMutex)
	{
		Sys_ReleaseMutex(g_hWaitMutex);
	}
	
	BonusMapsDatabase()->WriteSaveData();

	steamapicontext->Clear();
	

	ConVar_Unregister();
	DisconnectTier3Libraries();
	DisconnectTier2Libraries();
	DisconnectTier1Libraries();
}

//-----------------------------------------------------------------------------
// Purpose: just wraps an engine call to activate the gameUI
//-----------------------------------------------------------------------------
void CGameUI::ActivateGameUI()
{
	engine->ExecuteClientCmd("gameui_activate");
}

//-----------------------------------------------------------------------------
// Purpose: just wraps an engine call to hide the gameUI
//-----------------------------------------------------------------------------
void CGameUI::HideGameUI()
{
	engine->ExecuteClientCmd("gameui_hide");
}

//-----------------------------------------------------------------------------
// Purpose: Toggle allowing the engine to hide the game UI with the escape key
//-----------------------------------------------------------------------------
void CGameUI::PreventEngineHideGameUI()
{
	engine->ExecuteClientCmd("gameui_preventescape");
}

//-----------------------------------------------------------------------------
// Purpose: Toggle allowing the engine to hide the game UI with the escape key
//-----------------------------------------------------------------------------
void CGameUI::AllowEngineHideGameUI()
{
	engine->ExecuteClientCmd("gameui_allowescape");
}

//-----------------------------------------------------------------------------
// Purpose: Activate the game UI
//-----------------------------------------------------------------------------
void CGameUI::OnGameUIActivated()
{
	m_bActivatedUI = true;

	// hide/show the main panel to Activate all game ui
	staticPanel->SetVisible( true );

	// pause the server in single player
	if ( engine->GetMaxClients() <= 1 )
	{
		engine->ClientCmd_Unrestricted( "setpause" );
	}

	SetSavedThisMenuSession( false );

	// notify taskbar
	BasePanel()->OnGameUIActivated();

	if ( GameClientExports() )
	{
		const char *pGameName = CommandLine()->ParmValue( "-game", "hl2" );
		// only want to run this for TF2
		if ( ( Q_stricmp( pGameName, "tf" ) == 0 ) || ( Q_stricmp( pGameName, "tf_beta" ) == 0 ) )
		{
			GameClientExports()->OnGameUIActivated();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Hides the game ui, in whatever state it's in
//-----------------------------------------------------------------------------
void CGameUI::OnGameUIHidden()
{
	if ( GameClientExports() )
	{
		const char *pGameName = CommandLine()->ParmValue( "-game", "hl2" );
		// only want to run this for TF2
		if ( ( Q_stricmp( pGameName, "tf" ) == 0 ) || ( Q_stricmp( pGameName, "tf_beta" ) == 0 ) )
		{
			GameClientExports()->OnGameUIHidden();
		}
	}

	// unpause the game when leaving the UI
	if ( engine->GetMaxClients() <= 1 )
	{
		engine->ClientCmd_Unrestricted("unpause");
	}

	BasePanel()->OnGameUIHidden();
}

//-----------------------------------------------------------------------------
// Purpose: paints all the vgui elements
//-----------------------------------------------------------------------------
void CGameUI::RunFrame()
{
	if ( IsX360() && m_bOpenProgressOnStart )
	{
		StartProgressBar();
		m_bOpenProgressOnStart = false;
	}

	// resize the background panel to the screen size
	int wide, tall;
	vgui::surface()->GetScreenSize(wide, tall);
	staticPanel->SetSize(wide,tall);

	// Run frames
	g_VModuleLoader.RunFrame();
	BasePanel()->RunFrame();

	// Play the start-up music the first time we run frame
	if ( IsPC() && m_bPlayGameStartupSound )
	{
		PlayGameStartupSound();
		m_bPlayGameStartupSound = false;
	}

	if ( IsPC() && ( ( IsPosix() && m_bTryingToLoadFriends ) || 
					( m_bTryingToLoadFriends && m_iFriendsLoadPauseFrames-- < 1 && g_hMutex && g_hWaitMutex ) ) )
	{
		// try and load Steam platform files
		unsigned int waitResult = Sys_WaitForSingleObject(g_hMutex, 0);
		if ( IsPosix() || ( waitResult == SYS_WAIT_OBJECT_0 || waitResult == SYS_WAIT_ABANDONED ))
		{
			// we got the mutex, so load Friends/Serverbrowser
			// clear the loading flag
			m_bTryingToLoadFriends = false;
			g_VModuleLoader.LoadPlatformModules(&m_GameFactory, 1, false);

			// release the wait mutex
			if ( !IsPosix() )
				Sys_ReleaseMutex(g_hWaitMutex);

			// notify the game of our game name
			const char *fullGamePath = engine->GetGameDirectory();
			const char *pathSep = strrchr( fullGamePath, '/' );
			if ( !pathSep )
			{
				pathSep = strrchr( fullGamePath, '\\' );
			}
			if ( pathSep )
			{
				KeyValues *pKV = new KeyValues("ActiveGameName" );
				pKV->SetString( "name", pathSep + 1 );
				pKV->SetInt( "appid", engine->GetAppID() );
				KeyValues *modinfo = new KeyValues("ModInfo");
				if ( modinfo->LoadFromFile( g_pFullFileSystem, "gameinfo.txt" ) )
				{
					pKV->SetString( "game", modinfo->GetString( "game", "" ) );
				}
				modinfo->deleteThis();
				
				g_VModuleLoader.PostMessageToAllModules( pKV );
			}

			// notify the ui of a game connect if we're already in a game
			if (m_iGameIP)
			{
				SendConnectedToGameMessage();
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called when the game connects to a server
//-----------------------------------------------------------------------------
void CGameUI::OLD_OnConnectToServer(const char *game, int IP, int port)
{
	// Nobody should use this anymore because the query port and the connection port can be different.
	// Use OnConnectToServer2 instead.
	Assert( false );
	OnConnectToServer2( game, IP, port, port );
}

//-----------------------------------------------------------------------------
// Purpose: Called when the game connects to a server
//-----------------------------------------------------------------------------
void CGameUI::OnConnectToServer2(const char *game, int IP, int connectionPort, int queryPort)
{
	m_iGameIP = IP;
	m_iGameConnectionPort = connectionPort;
	m_iGameQueryPort = queryPort;

	SendConnectedToGameMessage();
}


void CGameUI::SendConnectedToGameMessage()
{
	KeyValues *kv = new KeyValues( "ConnectedToGame" );
	kv->SetInt( "ip", m_iGameIP );
	kv->SetInt( "connectionport", m_iGameConnectionPort );
	kv->SetInt( "queryport", m_iGameQueryPort );

	g_VModuleLoader.PostMessageToAllModules( kv );
}

//-----------------------------------------------------------------------------
// Purpose: Called when the game disconnects from a server
//-----------------------------------------------------------------------------
void CGameUI::OnDisconnectFromServer( uint8 eSteamLoginFailure )
{
	m_iGameIP = 0;
	m_iGameConnectionPort = 0;
	m_iGameQueryPort = 0;

	g_VModuleLoader.PostMessageToAllModules(new KeyValues("DisconnectedFromGame"));

	if ( eSteamLoginFailure == STEAMLOGINFAILURE_NOSTEAMLOGIN )
	{
		if ( g_hLoadingDialog )
		{
			g_hLoadingDialog->DisplayNoSteamConnectionError();
		}
	}
	else if ( eSteamLoginFailure == STEAMLOGINFAILURE_VACBANNED )
	{
		if ( g_hLoadingDialog )
		{
			g_hLoadingDialog->DisplayVACBannedError();
		}
	}
	else if ( eSteamLoginFailure == STEAMLOGINFAILURE_LOGGED_IN_ELSEWHERE )
	{
		if ( g_hLoadingDialog )
		{
			g_hLoadingDialog->DisplayLoggedInElsewhereError();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: activates the loading dialog on level load start
//-----------------------------------------------------------------------------
void CGameUI::OnLevelLoadingStarted( bool bShowProgressDialog )
{
	g_VModuleLoader.PostMessageToAllModules( new KeyValues( "LoadingStarted" ) );

	// notify
	BasePanel()->OnLevelLoadingStarted();

	if ( bShowProgressDialog )
	{
		StartProgressBar();
	}

	// Don't play the start game sound if this happens before we get to the first frame
	m_bPlayGameStartupSound = false;
}

//-----------------------------------------------------------------------------
// Purpose: closes any level load dialog
//-----------------------------------------------------------------------------
void CGameUI::OnLevelLoadingFinished(bool bError, const char *failureReason, const char *extendedReason)
{
	StopProgressBar( bError, failureReason, extendedReason );

	// notify all the modules
	g_VModuleLoader.PostMessageToAllModules( new KeyValues( "LoadingFinished" ) );

	// hide the UI
	HideGameUI();

	// notify
	BasePanel()->OnLevelLoadingFinished();
}

//-----------------------------------------------------------------------------
// Purpose: Updates progress bar
// Output : Returns true if screen should be redrawn
//-----------------------------------------------------------------------------
bool CGameUI::UpdateProgressBar(float progress, const char *statusText)
{
	// if either the progress bar or the status text changes, redraw the screen
	bool bRedraw = false;

	if ( ContinueProgressBar( progress ) )
	{
		bRedraw = true;
	}
		
	if ( SetProgressBarStatusText( statusText ) )
	{
		bRedraw = true;
	}

	return bRedraw;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGameUI::StartProgressBar()
{
	if ( !g_hLoadingDialog.Get() )
	{
		g_hLoadingDialog = new CLoadingDialog(staticPanel);
	}

	// open a loading dialog
	m_szPreviousStatusText[0] = 0;
	g_hLoadingDialog->SetProgressPoint(0.0f);
	g_hLoadingDialog->Open();
}

//-----------------------------------------------------------------------------
// Purpose: returns true if the screen should be updated
//-----------------------------------------------------------------------------
bool CGameUI::ContinueProgressBar( float progressFraction )
{
	if (!g_hLoadingDialog.Get())
		return false;

	g_hLoadingDialog->Activate();
	return g_hLoadingDialog->SetProgressPoint(progressFraction);
}

//-----------------------------------------------------------------------------
// Purpose: stops progress bar, displays error if necessary
//-----------------------------------------------------------------------------
void CGameUI::StopProgressBar(bool bError, const char *failureReason, const char *extendedReason)
{
	if (!g_hLoadingDialog.Get() && bError)
	{
		g_hLoadingDialog = new CLoadingDialog(staticPanel);
	}

	if (!g_hLoadingDialog.Get())
		return;

	if ( !IsX360() && bError )
	{
		// turn the dialog to error display mode
		g_hLoadingDialog->DisplayGenericError(failureReason, extendedReason);
	}
	else
	{
		// close loading dialog
		g_hLoadingDialog->Close();
		g_hLoadingDialog = NULL;
	}
	// should update the background to be in a transition here
}

//-----------------------------------------------------------------------------
// Purpose: sets loading info text
//-----------------------------------------------------------------------------
bool CGameUI::SetProgressBarStatusText(const char *statusText)
{
	if (!g_hLoadingDialog.Get())
		return false;

	if (!statusText)
		return false;

	if (!stricmp(statusText, m_szPreviousStatusText))
		return false;

	g_hLoadingDialog->SetStatusText(statusText);
	Q_strncpy(m_szPreviousStatusText, statusText, sizeof(m_szPreviousStatusText));
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGameUI::SetSecondaryProgressBar(float progress /* range [0..1] */)
{
	if (!g_hLoadingDialog.Get())
		return;

	g_hLoadingDialog->SetSecondaryProgress(progress);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGameUI::SetSecondaryProgressBarText(const char *statusText)
{
	if (!g_hLoadingDialog.Get())
		return;

	g_hLoadingDialog->SetSecondaryProgressText(statusText);
}

//-----------------------------------------------------------------------------
// Purpose: Returns prev settings
//-----------------------------------------------------------------------------
bool CGameUI::SetShowProgressText( bool show )
{
	if (!g_hLoadingDialog.Get())
		return false;

	return g_hLoadingDialog->SetShowProgressText( show );
}


//-----------------------------------------------------------------------------
// Purpose: returns true if we're currently playing the game
//-----------------------------------------------------------------------------
bool CGameUI::IsInLevel()
{
	const char *levelName = engine->GetLevelName();
	if (levelName && levelName[0] && !engine->IsLevelMainMenuBackground())
	{
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: returns true if we're at the main menu and a background level is loaded
//-----------------------------------------------------------------------------
bool CGameUI::IsInBackgroundLevel()
{
	const char *levelName = engine->GetLevelName();
	if (levelName && levelName[0] && engine->IsLevelMainMenuBackground())
	{
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: returns true if we're in a multiplayer game
//-----------------------------------------------------------------------------
bool CGameUI::IsInMultiplayer()
{
	return (IsInLevel() && engine->GetMaxClients() > 1);
}

//-----------------------------------------------------------------------------
// Purpose: returns true if we're playing back a replay
//-----------------------------------------------------------------------------
bool CGameUI::IsInReplay()
{
	return g_pEngineClientReplay && g_pEngineClientReplay->IsPlayingReplayDemo();
}

//-----------------------------------------------------------------------------
// Purpose: returns true if we're console ui
//-----------------------------------------------------------------------------
bool CGameUI::IsConsoleUI()
{
	return m_bIsConsoleUI;
}

//-----------------------------------------------------------------------------
// Purpose: returns true if we've saved without closing the menu
//-----------------------------------------------------------------------------
bool CGameUI::HasSavedThisMenuSession()
{
	return m_bHasSavedThisMenuSession;
}

void CGameUI::SetSavedThisMenuSession( bool bState )
{
	m_bHasSavedThisMenuSession = bState;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGameUI::ShowNewGameDialog( int chapter )
{
	char val[32];
	Q_snprintf( val, sizeof(val), "%d", chapter);
	staticPanel->OnOpenNewGameDialog(val);
}

//-----------------------------------------------------------------------------
// Purpose: Makes the loading background dialog visible, if one has been set
//-----------------------------------------------------------------------------
void CGameUI::ShowLoadingBackgroundDialog()
{
	if ( g_hLoadingBackgroundDialog )
	{
		vgui::ipanel()->SetParent( g_hLoadingBackgroundDialog, staticPanel->GetVPanel() );
		vgui::ipanel()->PerformApplySchemeSettings( g_hLoadingBackgroundDialog );
		vgui::ipanel()->SetVisible( g_hLoadingBackgroundDialog, true );		
		vgui::ipanel()->MoveToFront( g_hLoadingBackgroundDialog );
		vgui::ipanel()->SendMessage( g_hLoadingBackgroundDialog, new KeyValues( "activate" ), staticPanel->GetVPanel() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Hides the loading background dialog, if one has been set
//-----------------------------------------------------------------------------
void CGameUI::HideLoadingBackgroundDialog()
{
	if ( g_hLoadingBackgroundDialog )
	{
		vgui::ipanel()->SetParent( g_hLoadingBackgroundDialog, NULL );
		vgui::ipanel()->SetVisible( g_hLoadingBackgroundDialog, false );		
		vgui::ipanel()->MoveToBack( g_hLoadingBackgroundDialog );
		vgui::ipanel()->SendMessage( g_hLoadingBackgroundDialog, new KeyValues( "deactivate" ), staticPanel->GetVPanel() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Returns whether a loading background dialog has been set
//-----------------------------------------------------------------------------
bool CGameUI::HasLoadingBackgroundDialog()
{
	return ( 0 != g_hLoadingBackgroundDialog );
}

//-----------------------------------------------------------------------------
// Purpose: Xbox 360 calls from engine to GameUI 
//-----------------------------------------------------------------------------
void CGameUI::SessionNotification( const int notification, const int param )
{
	BasePanel()->SessionNotification( notification, param );
}
void CGameUI::SystemNotification( const int notification )
{
	BasePanel()->SystemNotification( notification );
}
void CGameUI::ShowMessageDialog( const uint nType, vgui::Panel *pOwner )
{
	BasePanel()->ShowMessageDialog( nType, pOwner );
}
void CGameUI::CloseMessageDialog( const uint nType )
{
	BasePanel()->CloseMessageDialog( nType );
}
void CGameUI::UpdatePlayerInfo( uint64 nPlayerId, const char *pName, int nTeam, byte cVoiceState, int nPlayersNeeded, bool bHost )
{
	BasePanel()->UpdatePlayerInfo( nPlayerId, pName, nTeam, cVoiceState, nPlayersNeeded, bHost );
}
void CGameUI::SessionSearchResult( int searchIdx, void *pHostData, XSESSION_SEARCHRESULT *pResult, int ping )
{
	BasePanel()->SessionSearchResult( searchIdx, pHostData, pResult, ping );
}
void CGameUI::OnCreditsFinished( void )
{
	BasePanel()->OnCreditsFinished();
}
bool CGameUI::ValidateStorageDevice( int *pStorageDeviceValidated )
{
	return BasePanel()->ValidateStorageDevice( pStorageDeviceValidated );
}

void CGameUI::SetProgressOnStart()
{
	m_bOpenProgressOnStart = true;
}

void CGameUI::OnConfirmQuit( void )
{
	BasePanel()->OnOpenQuitConfirmationDialog();
}

bool CGameUI::IsMainMenuVisible( void )
{
	CBasePanel *pBasePanel = BasePanel();
	if ( pBasePanel )
		return (pBasePanel->IsVisible() && pBasePanel->GetMenuAlpha() > 0 );
	return false;
}

// Client DLL is providing us with a panel that it wants to replace the main menu with
void CGameUI::SetMainMenuOverride( vgui::VPANEL panel )
{
	CBasePanel *pBasePanel = BasePanel();
	if ( pBasePanel )
	{
		pBasePanel->SetMainMenuOverride( panel );
	}
}

// Client DLL is telling us that a main menu command was issued, probably from its custom main menu panel
void CGameUI::SendMainMenuCommand( const char *pszCommand )
{
	CBasePanel *pBasePanel = BasePanel();
	if ( pBasePanel )
	{
		pBasePanel->RunMenuCommand( pszCommand );
	}
}