d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
197 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: f266efa942
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f266efa942'
${ noResults }
source-engine/gameui/BasePanel.cpp

4864 lines
134 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include <stdio.h>
#include "threadtools.h"
#include "BasePanel.h"
#include "EngineInterface.h"
#include "VGuiSystemModuleLoader.h"
#include "vgui/IInput.h"
#include "vgui/ILocalize.h"
#include "vgui/IPanel.h"
#include "vgui/ISurface.h"
#include "vgui/ISystem.h"
#include "vgui/IVGui.h"
#include "filesystem.h"
#include "GameConsole.h"
#include "GameUI_Interface.h"
#include "vgui_controls/PropertyDialog.h"
#include "vgui_controls/PropertySheet.h"
#include "materialsystem/materialsystem_config.h"
#include "materialsystem/imaterialsystem.h"
#include "sourcevr/isourcevirtualreality.h"
using namespace vgui;
#include "GameConsole.h"
#include "ModInfo.h"
#include "IGameUIFuncs.h"
#include "LoadingDialog.h"
#include "BackgroundMenuButton.h"
#include "vgui_controls/AnimationController.h"
#include "vgui_controls/ImagePanel.h"
#include "vgui_controls/Label.h"
#include "vgui_controls/Menu.h"
#include "vgui_controls/MenuItem.h"
#include "vgui_controls/PHandle.h"
#include "vgui_controls/MessageBox.h"
#include "vgui_controls/QueryBox.h"
#include "vgui_controls/ControllerMap.h"
#include "vgui_controls/KeyRepeat.h"
#include "tier0/icommandline.h"
#include "tier1/convar.h"
#include "NewGameDialog.h"
#include "BonusMapsDialog.h"
#include "LoadGameDialog.h"
#include "SaveGameDialog.h"
#include "OptionsDialog.h"
#include "CreateMultiplayerGameDialog.h"
#include "ChangeGameDialog.h"
#include "BackgroundMenuButton.h"
#include "PlayerListDialog.h"
#include "BenchmarkDialog.h"
#include "LoadCommentaryDialog.h"
#include "ControllerDialog.h"
#include "BonusMapsDatabase.h"
#include "engine/IEngineSound.h"
#include "bitbuf.h"
#include "tier1/fmtstr.h"
#include "inputsystem/iinputsystem.h"
#include "ixboxsystem.h"
#include "matchmaking/matchmakingbasepanel.h"
#include "matchmaking/achievementsdialog.h"
#include "iachievementmgr.h"
#include "UtlSortVector.h"
#include "game/client/IGameClientExports.h"
#include "OptionsSubAudio.h"
#include "hl2orange.spa.h"
#include "CustomTabExplanationDialog.h"
#if defined( _X360 )
#include "xbox/xbox_launch.h"
#else
#include "xbox/xboxstubs.h"
#endif
#include "../engine/imatchmaking.h"
#include "tier1/utlstring.h"
#include "steam/steam_api.h"
#undef MessageBox // Windows helpfully #define's this to MessageBoxA, we're using vgui::MessageBox
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define MAIN_MENU_INDENT_X360 10
ConVar vgui_message_dialog_modal( "vgui_message_dialog_modal", "1", FCVAR_ARCHIVE );
extern vgui::DHANDLE<CLoadingDialog> g_hLoadingDialog;
static CBasePanel *g_pBasePanel = NULL;
static float g_flAnimationPadding = 0.01f;
extern const char *COM_GetModDirectory( void );
extern ConVar x360_audio_english;
extern bool bSteamCommunityFriendsVersion;
static vgui::DHANDLE<vgui::PropertyDialog> g_hOptionsDialog;
//-----------------------------------------------------------------------------
// Purpose: singleton accessor
//-----------------------------------------------------------------------------
CBasePanel *BasePanel()
{
return g_pBasePanel;
}
//-----------------------------------------------------------------------------
// Purpose: hack function to give the module loader access to the main panel handle
// only used in VguiSystemModuleLoader
//-----------------------------------------------------------------------------
VPANEL GetGameUIBasePanel()
{
return BasePanel()->GetVPanel();
}
CGameMenuItem::CGameMenuItem(vgui::Menu *parent, const char *name) : BaseClass(parent, name, "GameMenuItem")
{
m_bRightAligned = false;
}
void CGameMenuItem::ApplySchemeSettings(IScheme *pScheme)
{
BaseClass::ApplySchemeSettings(pScheme);
// make fully transparent
SetFgColor(GetSchemeColor("MainMenu.TextColor", pScheme));
SetBgColor(Color(0, 0, 0, 0));
SetDefaultColor(GetSchemeColor("MainMenu.TextColor", pScheme), Color(0, 0, 0, 0));
SetArmedColor(GetSchemeColor("MainMenu.ArmedTextColor", pScheme), Color(0, 0, 0, 0));
SetDepressedColor(GetSchemeColor("MainMenu.DepressedTextColor", pScheme), Color(0, 0, 0, 0));
SetContentAlignment(Label::a_west);
SetBorder(NULL);
SetDefaultBorder(NULL);
SetDepressedBorder(NULL);
SetKeyFocusBorder(NULL);
vgui::HFont hMainMenuFont = pScheme->GetFont( "MainMenuFont", IsProportional() );
if ( hMainMenuFont )
{
SetFont( hMainMenuFont );
}
else
{
SetFont( pScheme->GetFont( "MenuLarge", IsProportional() ) );
}
SetTextInset(0, 0);
SetArmedSound("UI/buttonrollover.wav");
SetDepressedSound("UI/buttonclick.wav");
SetReleasedSound("UI/buttonclickrelease.wav");
SetButtonActivationType(Button::ACTIVATE_ONPRESSED);
if ( GameUI().IsConsoleUI() )
{
SetArmedColor(GetSchemeColor("MainMenu.ArmedTextColor", pScheme), GetSchemeColor("Button.ArmedBgColor", pScheme));
SetTextInset( MAIN_MENU_INDENT_X360, 0 );
}
if (m_bRightAligned)
{
SetContentAlignment(Label::a_east);
}
}
void CGameMenuItem::PaintBackground()
{
if ( !GameUI().IsConsoleUI() )
{
BaseClass::PaintBackground();
}
else
{
if ( !IsArmed() || !IsVisible() || GetParent()->GetAlpha() < 32 )
return;
int wide, tall;
GetSize( wide, tall );
DrawBoxFade( 0, 0, wide, tall, GetButtonBgColor(), 1.0f, 255, 0, true );
DrawBoxFade( 2, 2, wide - 4, tall - 4, Color( 0, 0, 0, 96 ), 1.0f, 255, 0, true );
}
}
void CGameMenuItem::SetRightAlignedText(bool state)
{
m_bRightAligned = state;
}
//-----------------------------------------------------------------------------
// Purpose: General purpose 1 of N menu
//-----------------------------------------------------------------------------
class CGameMenu : public vgui::Menu
{
public:
DECLARE_CLASS_SIMPLE( CGameMenu, vgui::Menu );
CGameMenu(vgui::Panel *parent, const char *name) : BaseClass(parent, name)
{
if ( GameUI().IsConsoleUI() )
{
// shows graphic button hints
m_pConsoleFooter = new CFooterPanel( parent, "MainMenuFooter" );
int iFixedWidth = 245;
#ifdef _X360
// In low def we need a smaller highlight
XVIDEO_MODE videoMode;
XGetVideoMode( &videoMode );
if ( !videoMode.fIsHiDef )
{
iFixedWidth = 240;
}
else
{
iFixedWidth = 350;
}
#endif
SetFixedWidth( iFixedWidth );
}
else
{
m_pConsoleFooter = NULL;
}
m_hMainMenuOverridePanel = NULL;
}
virtual void ApplySchemeSettings(IScheme *pScheme)
{
BaseClass::ApplySchemeSettings(pScheme);
int height = atoi(pScheme->GetResourceString("MainMenu.MenuItemHeight"));
if( IsProportional() )
height = scheme()->GetProportionalScaledValue( height );
// make fully transparent
SetMenuItemHeight(height);
SetBgColor(Color(0, 0, 0, 0));
SetBorder(NULL);
}
virtual void LayoutMenuBorder()
{
}
void SetMainMenuOverride( vgui::VPANEL panel )
{
m_hMainMenuOverridePanel = panel;
if ( m_hMainMenuOverridePanel )
{
// We've got an override panel. Nuke all our menu items.
DeleteAllItems();
}
}
virtual void SetVisible(bool state)
{
if ( m_hMainMenuOverridePanel )
{
// force to be always visible
ipanel()->SetVisible( m_hMainMenuOverridePanel, true );
// move us to the back instead of going invisible
if ( !state )
{
ipanel()->MoveToBack(m_hMainMenuOverridePanel);
}
}
// force to be always visible
BaseClass::SetVisible(true);
// move us to the back instead of going invisible
if (!state)
{
ipanel()->MoveToBack(GetVPanel());
}
}
virtual int AddMenuItem(const char *itemName, const char *itemText, const char *command, Panel *target, KeyValues *userData = NULL)
{
MenuItem *item = new CGameMenuItem(this, itemName);
item->AddActionSignalTarget(target);
item->SetCommand(command);
item->SetText(itemText);
item->SetUserData(userData);
return BaseClass::AddMenuItem(item);
}
virtual int AddMenuItem(const char *itemName, wchar_t *itemText, const char *command, Panel *target, KeyValues *userData = NULL)
{
MenuItem *item = new CGameMenuItem(this, itemName);
item->AddActionSignalTarget(target);
item->SetCommand(command);
item->SetText(itemText);
item->SetUserData(userData);
return BaseClass::AddMenuItem(item);
}
virtual int AddMenuItem(const char *itemName, const char *itemText, KeyValues *command, Panel *target, KeyValues *userData = NULL)
{
CGameMenuItem *item = new CGameMenuItem(this, itemName);
item->AddActionSignalTarget(target);
item->SetCommand(command);
item->SetText(itemText);
item->SetRightAlignedText(true);
item->SetUserData(userData);
return BaseClass::AddMenuItem(item);
}
virtual void SetMenuItemBlinkingState( const char *itemName, bool state )
{
for (int i = 0; i < GetChildCount(); i++)
{
Panel *child = GetChild(i);
MenuItem *menuItem = dynamic_cast<MenuItem *>(child);
if (menuItem)
{
if ( Q_strcmp( menuItem->GetCommand()->GetString("command", ""), itemName ) == 0 )
{
menuItem->SetBlink( state );
}
}
}
InvalidateLayout();
}
virtual void OnSetFocus()
{
if ( m_hMainMenuOverridePanel )
{
Panel *pMainMenu = ipanel()->GetPanel( m_hMainMenuOverridePanel, "ClientDLL" );
if ( pMainMenu )
{
pMainMenu->PerformLayout();
}
}
BaseClass::OnSetFocus();
}
virtual void OnCommand(const char *command)
{
m_KeyRepeat.Reset();
if (!stricmp(command, "Open"))
{
if ( m_hMainMenuOverridePanel )
{
// force to be always visible
ipanel()->MoveToFront( m_hMainMenuOverridePanel );
ipanel()->RequestFocus( m_hMainMenuOverridePanel );
}
else
{
MoveToFront();
RequestFocus();
}
}
else
{
BaseClass::OnCommand(command);
}
}
virtual void OnKeyCodePressed( KeyCode code )
{
if ( IsX360() )
{
if ( GetAlpha() != 255 )
{
SetEnabled( false );
// inhibit key activity during transitions
return;
}
SetEnabled( true );
if ( code == KEY_XBUTTON_B || code == KEY_XBUTTON_START )
{
if ( GameUI().IsInLevel() )
{
GetParent()->OnCommand( "ResumeGame" );
}
return;
}
}
m_KeyRepeat.KeyDown( code );
int nDir = 0;
switch ( code )
{
case KEY_XBUTTON_UP:
case KEY_XSTICK1_UP:
case KEY_XSTICK2_UP:
case KEY_UP:
case STEAMCONTROLLER_DPAD_UP:
nDir = -1;
break;
case KEY_XBUTTON_DOWN:
case KEY_XSTICK1_DOWN:
case KEY_XSTICK2_DOWN:
case KEY_DOWN:
case STEAMCONTROLLER_DPAD_DOWN:
nDir = 1;
break;
}
if ( nDir != 0 )
{
CUtlSortVector< SortedPanel_t, CSortedPanelYLess > vecSortedButtons;
VguiPanelGetSortedChildButtonList( this, (void*)&vecSortedButtons );
if ( VguiPanelNavigateSortedChildButtonList( (void*)&vecSortedButtons, nDir ) != -1 )
{
// Handled!
return;
}
}
else if ( code == KEY_XBUTTON_A || code == STEAMCONTROLLER_A )
{
CUtlSortVector< SortedPanel_t, CSortedPanelYLess > vecSortedButtons;
VguiPanelGetSortedChildButtonList( this, (void*)&vecSortedButtons );
for ( int i = 0; i < vecSortedButtons.Count(); i++ )
{
if ( vecSortedButtons[ i ].pButton->IsArmed() )
{
vecSortedButtons[ i ].pButton->DoClick();
return;
}
}
}
BaseClass::OnKeyCodePressed( code );
// HACK: Allow F key bindings to operate even here
if ( IsPC() && code >= KEY_F1 && code <= KEY_F12 )
{
// See if there is a binding for the FKey
const char *binding = gameuifuncs->GetBindingForButtonCode( code );
if ( binding && binding[0] )
{
// submit the entry as a console commmand
char szCommand[256];
Q_strncpy( szCommand, binding, sizeof( szCommand ) );
engine->ClientCmd_Unrestricted( szCommand );
}
}
}
void OnKeyCodeReleased( vgui::KeyCode code )
{
m_KeyRepeat.KeyUp( code );
BaseClass::OnKeyCodeReleased( code );
}
void OnThink()
{
vgui::KeyCode code = m_KeyRepeat.KeyRepeated();
if ( code )
{
OnKeyCodeTyped( code );
}
BaseClass::OnThink();
}
virtual void OnKillFocus()
{
BaseClass::OnKillFocus();
if ( m_hMainMenuOverridePanel )
{
// force us to the rear when we lose focus (so it looks like the menu is always on the background)
surface()->MovePopupToBack( m_hMainMenuOverridePanel );
}
else
{
// force us to the rear when we lose focus (so it looks like the menu is always on the background)
surface()->MovePopupToBack(GetVPanel());
}
m_KeyRepeat.Reset();
}
void ShowFooter( bool bShow )
{
if ( m_pConsoleFooter )
{
m_pConsoleFooter->SetVisible( bShow );
}
}
void UpdateMenuItemState( bool isInGame, bool isMultiplayer, bool isInReplay, bool isVREnabled, bool isVRActive )
{
bool isSteam = IsPC() && ( CommandLine()->FindParm("-steam") != 0 );
bool bIsConsoleUI = GameUI().IsConsoleUI();
// disabled save button if we're not in a game
for (int i = 0; i < GetChildCount(); i++)
{
Panel *child = GetChild(i);
MenuItem *menuItem = dynamic_cast<MenuItem *>(child);
if (menuItem)
{
bool shouldBeVisible = true;
// filter the visibility
KeyValues *kv = menuItem->GetUserData();
if (!kv)
continue;
if (!isInGame && kv->GetInt("OnlyInGame") )
{
shouldBeVisible = false;
}
if (!isInReplay && kv->GetInt("OnlyInReplay") )
{
shouldBeVisible = false;
}
else if (!isVREnabled && kv->GetInt("OnlyWhenVREnabled") )
{
shouldBeVisible = false;
}
else if ( ( !isVRActive || ShouldForceVRActive() ) && kv->GetInt( "OnlyWhenVRActive" ) )
{
shouldBeVisible = false;
}
else if (isVRActive && kv->GetInt("OnlyWhenVRInactive") )
{
shouldBeVisible = false;
}
else if (isMultiplayer && kv->GetInt("notmulti"))
{
shouldBeVisible = false;
}
else if (isInGame && !isMultiplayer && kv->GetInt("notsingle"))
{
shouldBeVisible = false;
}
else if (isSteam && kv->GetInt("notsteam"))
{
shouldBeVisible = false;
}
else if ( !bIsConsoleUI && kv->GetInt( "ConsoleOnly" ) )
{
shouldBeVisible = false;
}
// If we're playing back a replay, hide everything else
if ( isInReplay && !kv->GetInt("OnlyInReplay") )
{
shouldBeVisible = false;
}
menuItem->SetVisible( shouldBeVisible );
}
}
if ( !isInGame )
{
// Sort them into their original order
for ( int j = 0; j < GetChildCount() - 2; j++ )
{
MoveMenuItem( j, j + 1 );
}
}
else
{
// Sort them into their in game order
for ( int i = 0; i < GetChildCount(); i++ )
{
for ( int j = i; j < GetChildCount() - 2; j++ )
{
int iID1 = GetMenuID( j );
int iID2 = GetMenuID( j + 1 );
MenuItem *menuItem1 = GetMenuItem( iID1 );
MenuItem *menuItem2 = GetMenuItem( iID2 );
KeyValues *kv1 = menuItem1->GetUserData();
KeyValues *kv2 = menuItem2->GetUserData();
if( !kv1 || !kv2 )
continue;
if ( kv1->GetInt("InGameOrder") > kv2->GetInt("InGameOrder") )
MoveMenuItem( iID2, iID1 );
}
}
}
InvalidateLayout();
if ( m_pConsoleFooter )
{
// update the console footer
const char *pHelpName;
if ( !isInGame )
pHelpName = "MainMenu";
else
pHelpName = "GameMenu";
if ( !m_pConsoleFooter->GetHelpName() || V_stricmp( pHelpName, m_pConsoleFooter->GetHelpName() ) )
{
// game menu must re-establish its own help once it becomes re-active
m_pConsoleFooter->SetHelpNameAndReset( pHelpName );
m_pConsoleFooter->AddNewButtonLabel( "#GameUI_Action", "#GameUI_Icons_A_BUTTON" );
if ( isInGame )
{
m_pConsoleFooter->AddNewButtonLabel( "#GameUI_Close", "#GameUI_Icons_B_BUTTON" );
}
}
}
}
MESSAGE_FUNC_HANDLE( OnCursorEnteredMenuItem, "CursorEnteredMenuItem", menuItem);
private:
CFooterPanel *m_pConsoleFooter;
vgui::CKeyRepeatHandler m_KeyRepeat;
vgui::VPANEL m_hMainMenuOverridePanel;
};
//-----------------------------------------------------------------------------
// Purpose: Respond to cursor entering a menuItem.
//-----------------------------------------------------------------------------
void CGameMenu::OnCursorEnteredMenuItem(VPANEL menuItem)
{
MenuItem *item = static_cast<MenuItem *>(ipanel()->GetPanel(menuItem, GetModuleName()));
KeyValues *pCommand = item->GetCommand();
if ( !pCommand->GetFirstSubKey() )
return;
const char *pszCmd = pCommand->GetFirstSubKey()->GetString();
if ( !pszCmd || !pszCmd[0] )
return;
BaseClass::OnCursorEnteredMenuItem( menuItem );
}
static CBackgroundMenuButton* CreateMenuButton( CBasePanel *parent, const char *panelName, const wchar_t *panelText )
{
CBackgroundMenuButton *pButton = new CBackgroundMenuButton( parent, panelName );
pButton->SetCommand("OpenGameMenu");
pButton->SetText(panelText);
return pButton;
}
bool g_bIsCreatingNewGameMenuForPreFetching = false;
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CBasePanel::CBasePanel() : Panel(NULL, "BaseGameUIPanel")
{
if( NeedProportional() )
SetProportional( true );
g_pBasePanel = this;
m_bLevelLoading = false;
m_eBackgroundState = BACKGROUND_INITIAL;
m_flTransitionStartTime = 0.0f;
m_flTransitionEndTime = 0.0f;
m_flFrameFadeInTime = 0.5f;
m_bRenderingBackgroundTransition = false;
m_bFadingInMenus = false;
m_bEverActivated = false;
m_iGameMenuInset = 24;
m_bPlatformMenuInitialized = false;
m_bHaveDarkenedBackground = false;
m_bHaveDarkenedTitleText = true;
m_bForceTitleTextUpdate = true;
m_BackdropColor = Color(0, 0, 0, 128);
m_pConsoleAnimationController = NULL;
m_pConsoleControlSettings = NULL;
m_bCopyFrameBuffer = false;
m_bUseRenderTargetImage = false;
m_ExitingFrameCount = 0;
m_bXUIVisible = false;
m_bUseMatchmaking = false;
m_bRestartFromInvite = false;
m_bRestartSameGame = false;
m_bUserRefusedSignIn = false;
m_bUserRefusedStorageDevice = false;
m_bWaitingForUserSignIn = false;
m_bWaitingForStorageDeviceHandle = false;
m_bNeedStorageDeviceHandle = false;
m_bStorageBladeShown = false;
m_iStorageID = XBX_INVALID_STORAGE_ID;
m_pAsyncJob = NULL;
m_pStorageDeviceValidatedNotify = NULL;
m_iRenderTargetImageID = -1;
m_iBackgroundImageID = -1;
m_iProductImageID = -1;
m_iLoadingImageID = -1;
if ( GameUI().IsConsoleUI() )
{
m_pConsoleAnimationController = new AnimationController( this );
m_pConsoleAnimationController->SetScriptFile( GetVPanel(), "scripts/GameUIAnimations.txt" );
m_pConsoleAnimationController->SetAutoReloadScript( IsDebug() );
m_pConsoleControlSettings = new KeyValues( "XboxDialogs.res" );
if ( !m_pConsoleControlSettings->LoadFromFile( g_pFullFileSystem, "resource/UI/XboxDialogs.res", "GAME" ) )
{
Error( "Failed to load UI control settings!\n" );
}
else
{
m_pConsoleControlSettings->ProcessResolutionKeys( surface()->GetResolutionKey() );
}
#ifdef _X360
x360_audio_english.SetValue( XboxLaunch()->GetForceEnglish() );
#endif
}
m_pGameMenuButtons.AddToTail( CreateMenuButton( this, "GameMenuButton", ModInfo().GetGameTitle() ) );
m_pGameMenuButtons.AddToTail( CreateMenuButton( this, "GameMenuButton2", ModInfo().GetGameTitle2() ) );
#ifdef CS_BETA
if ( !ModInfo().NoCrosshair() ) // hack to not show the BETA for HL2 or HL1Port
{
m_pGameMenuButtons.AddToTail( CreateMenuButton( this, "BetaButton", L"BETA" ) );
}
#endif // CS_BETA
m_pGameMenu = NULL;
m_pGameLogo = NULL;
m_hMainMenuOverridePanel = NULL;
if ( SteamClient() )
{
HSteamPipe steamPipe = SteamClient()->CreateSteamPipe();
ISteamUtils *pUtils = SteamClient()->GetISteamUtils( steamPipe, "SteamUtils002" );
if ( pUtils )
{
bSteamCommunityFriendsVersion = true;
}
SteamClient()->BReleaseSteamPipe( steamPipe );
}
CreateGameMenu();
CreateGameLogo();
// Bonus maps menu blinks if something has been unlocked since the player last opened the menu
// This is saved as persistant data, and here is where we check for that
CheckBonusBlinkState();
// start the menus fully transparent
SetMenuAlpha( 0 );
if ( GameUI().IsConsoleUI() )
{
// do any costly resource prefetching now....
// force the new dialog to get all of its chapter pics
g_bIsCreatingNewGameMenuForPreFetching = true;
m_hNewGameDialog = new CNewGameDialog( this, false );
m_hNewGameDialog->MarkForDeletion();
g_bIsCreatingNewGameMenuForPreFetching = false;
m_hOptionsDialog_Xbox = new COptionsDialogXbox( this );
m_hOptionsDialog_Xbox->MarkForDeletion();
m_hControllerDialog = new CControllerDialog( this );
m_hControllerDialog->MarkForDeletion();
ArmFirstMenuItem();
m_pConsoleAnimationController->StartAnimationSequence( "InitializeUILayout" );
}
// Record data used for rich presence updates
if ( IsX360() )
{
// Get our active mod directory name
const char *pGameName = CommandLine()->ParmValue( "-game", "hl2" );;
// Set the game we're playing
m_iGameID = CONTEXT_GAME_GAME_HALF_LIFE_2;
m_bSinglePlayer = true;
if ( Q_stristr( pGameName, "episodic" ) )
{
m_iGameID = CONTEXT_GAME_GAME_EPISODE_ONE;
}
else if ( Q_stristr( pGameName, "ep2" ) )
{
m_iGameID = CONTEXT_GAME_GAME_EPISODE_TWO;
}
else if ( Q_stristr( pGameName, "portal" ) )
{
m_iGameID = CONTEXT_GAME_GAME_PORTAL;
}
else if ( Q_stristr( pGameName, "tf" ) )
{
m_iGameID = CONTEXT_GAME_GAME_TEAM_FORTRESS;
m_bSinglePlayer = false;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Xbox 360 - Get the console UI keyvalues to pass to LoadControlSettings()
//-----------------------------------------------------------------------------
KeyValues *CBasePanel::GetConsoleControlSettings( void )
{
return m_pConsoleControlSettings;
}
//-----------------------------------------------------------------------------
// Purpose: Causes the first menu item to be armed
//-----------------------------------------------------------------------------
void CBasePanel::ArmFirstMenuItem( void )
{
UpdateGameMenus();
// Arm the first item in the menu
for ( int i = 0; i < m_pGameMenu->GetItemCount(); ++i )
{
if ( m_pGameMenu->GetMenuItem( i )->IsVisible() )
{
m_pGameMenu->SetCurrentlyHighlightedItem( i );
break;
}
}
}
CBasePanel::~CBasePanel()
{
g_pBasePanel = NULL;
if ( vgui::surface() )
{
if ( m_iRenderTargetImageID != -1 )
{
vgui::surface()->DestroyTextureID( m_iRenderTargetImageID );
m_iRenderTargetImageID = -1;
}
if ( m_iBackgroundImageID != -1 )
{
vgui::surface()->DestroyTextureID( m_iBackgroundImageID );
m_iBackgroundImageID = -1;
}
if ( m_iProductImageID != -1 )
{
vgui::surface()->DestroyTextureID( m_iProductImageID );
m_iProductImageID = -1;
}
if ( m_iLoadingImageID != -1 )
{
vgui::surface()->DestroyTextureID( m_iLoadingImageID );
m_iLoadingImageID = -1;
}
}
}
static const char *g_rgValidCommands[] =
{
"OpenGameMenu",
"OpenConsole",
"OpenPlayerListDialog",
"OpenNewGameDialog",
"OpenLoadGameDialog",
"OpenSaveGameDialog",
"OpenCustomMapsDialog",
"OpenOptionsDialog",
"OpenBenchmarkDialog",
"OpenServerBrowser",
"OpenFriendsDialog",
"OpenLoadDemoDialog",
"OpenCreateMultiplayerGameDialog",
"OpenChangeGameDialog",
"OpenLoadCommentaryDialog",
"Quit",
"QuitNoConfirm",
"ResumeGame",
"Disconnect",
};
static void CC_GameMenuCommand( const CCommand &args )
{
int c = args.ArgC();
if ( c < 2 )
{
Msg( "Usage: gamemenucommand <commandname>\n" );
return;
}
if ( !g_pBasePanel )
{
return;
}
vgui::ivgui()->PostMessage( g_pBasePanel->GetVPanel(), new KeyValues("Command", "command", args[1] ), NULL);
}
static int CC_GameMenuCompletionFunc( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
{
char const *cmdname = "gamemenucommand";
char *substring = (char *)partial;
if ( Q_strstr( partial, cmdname ) )
{
substring = (char *)partial + strlen( cmdname ) + 1;
}
int checklen = Q_strlen( substring );
CUtlRBTree< CUtlString > symbols( 0, 0, UtlStringLessFunc );
int i;
int c = ARRAYSIZE( g_rgValidCommands );
for ( i = 0; i < c; ++i )
{
if ( Q_strnicmp( g_rgValidCommands[ i ], substring, checklen ) )
continue;
CUtlString str;
str = g_rgValidCommands[ i ];
symbols.Insert( str );
// Too many
if ( symbols.Count() >= COMMAND_COMPLETION_MAXITEMS )
break;
}
// Now fill in the results
int slot = 0;
for ( i = symbols.FirstInorder(); i != symbols.InvalidIndex(); i = symbols.NextInorder( i ) )
{
char const *name = symbols[ i ].String();
char buf[ 512 ];
Q_strncpy( buf, name, sizeof( buf ) );
Q_strlower( buf );
Q_snprintf( commands[ slot++ ], COMMAND_COMPLETION_ITEM_LENGTH, "%s %s",
cmdname, buf );
}
return slot;
}
static ConCommand gamemenucommand( "gamemenucommand", CC_GameMenuCommand, "Issue game menu command.", 0, CC_GameMenuCompletionFunc );
//-----------------------------------------------------------------------------
// Purpose: paints the main background image
//-----------------------------------------------------------------------------
void CBasePanel::PaintBackground()
{
if ( !GameUI().IsInLevel() || g_hLoadingDialog.Get() || m_ExitingFrameCount )
{
// not in the game or loading dialog active or exiting, draw the ui background
DrawBackgroundImage();
}
else if ( IsX360() )
{
// only valid during loading from level to level
m_bUseRenderTargetImage = false;
}
if ( m_flBackgroundFillAlpha )
{
int swide, stall;
surface()->GetScreenSize(swide, stall);
surface()->DrawSetColor(0, 0, 0, m_flBackgroundFillAlpha);
surface()->DrawFilledRect(0, 0, swide, stall);
}
}
//-----------------------------------------------------------------------------
// Updates which background state we should be in.
//
// NOTE: These states change at funny times and overlap. They CANNOT be
// used to demarcate exact transitions.
//-----------------------------------------------------------------------------
void CBasePanel::UpdateBackgroundState()
{
if ( m_ExitingFrameCount )
{
// trumps all, an exiting state must own the screen image
// cannot be stopped
SetBackgroundRenderState( BACKGROUND_EXITING );
}
else if ( GameUI().IsInLevel() )
{
SetBackgroundRenderState( BACKGROUND_LEVEL );
}
else if ( GameUI().IsInBackgroundLevel() && !m_bLevelLoading )
{
// 360 guarantees a progress bar
// level loading is truly completed when the progress bar is gone, then transition to main menu
if ( IsPC() || ( IsX360() && !g_hLoadingDialog.Get() ) )
{
SetBackgroundRenderState( BACKGROUND_MAINMENU );
}
}
else if ( m_bLevelLoading )
{
SetBackgroundRenderState( BACKGROUND_LOADING );
}
else if ( m_bEverActivated && m_bPlatformMenuInitialized )
{
SetBackgroundRenderState( BACKGROUND_DISCONNECTED );
}
if ( GameUI().IsConsoleUI() )
{
if ( !m_ExitingFrameCount && !m_bLevelLoading && !g_hLoadingDialog.Get() && GameUI().IsInLevel() )
{
// paused
if ( m_flBackgroundFillAlpha == 0.0f )
m_flBackgroundFillAlpha = 120.0f;
}
else
{
m_flBackgroundFillAlpha = 0;
}
// console ui has completely different menu/dialog/fill/fading behavior
return;
}
// don't evaluate the rest until we've initialized the menus
if ( !m_bPlatformMenuInitialized )
return;
// check for background fill
// fill over the top if we have any dialogs up
int i;
bool bHaveActiveDialogs = false;
bool bIsInLevel = GameUI().IsInLevel();
for ( i = 0; i < GetChildCount(); ++i )
{
VPANEL child = ipanel()->GetChild( GetVPanel(), i );
if ( child
&& ipanel()->IsVisible( child )
&& ipanel()->IsPopup( child )
&& child != m_pGameMenu->GetVPanel() )
{
bHaveActiveDialogs = true;
}
}
// see if the base gameui panel has dialogs hanging off it (engine stuff, console, bug reporter)
VPANEL parent = GetVParent();
for ( i = 0; i < ipanel()->GetChildCount( parent ); ++i )
{
VPANEL child = ipanel()->GetChild( parent, i );
if ( child
&& ipanel()->IsVisible( child )
&& ipanel()->IsPopup( child )
&& child != GetVPanel() )
{
bHaveActiveDialogs = true;
}
}
// check to see if we need to fade in the background fill
bool bNeedDarkenedBackground = (bHaveActiveDialogs || bIsInLevel);
if ( m_bHaveDarkenedBackground != bNeedDarkenedBackground )
{
// fade in faster than we fade out
float targetAlpha, duration;
if ( bNeedDarkenedBackground )
{
// fade in background tint
targetAlpha = m_BackdropColor[3];
duration = m_flFrameFadeInTime;
}
else
{
// fade out background tint
targetAlpha = 0.0f;
duration = 2.0f;
}
m_bHaveDarkenedBackground = bNeedDarkenedBackground;
vgui::GetAnimationController()->RunAnimationCommand( this, "m_flBackgroundFillAlpha", targetAlpha, 0.0f, duration, AnimationController::INTERPOLATOR_LINEAR );
}
// check to see if the game title should be dimmed
// don't transition on level change
if ( m_bLevelLoading )
return;
bool bNeedDarkenedTitleText = bHaveActiveDialogs;
if (m_bHaveDarkenedTitleText != bNeedDarkenedTitleText || m_bForceTitleTextUpdate)
{
float targetTitleAlpha, duration;
if (bHaveActiveDialogs)
{
// fade out title text
duration = m_flFrameFadeInTime;
targetTitleAlpha = 32.0f;
}
else
{
// fade in title text
duration = 2.0f;
targetTitleAlpha = 255.0f;
}
if ( m_pGameLogo )
{
vgui::GetAnimationController()->RunAnimationCommand( m_pGameLogo, "alpha", targetTitleAlpha, 0.0f, duration, AnimationController::INTERPOLATOR_LINEAR );
}
// Msg( "animating title (%d => %d at time %.2f)\n", m_pGameMenuButton->GetAlpha(), (int)targetTitleAlpha, engine->Time());
for ( i=0; i<m_pGameMenuButtons.Count(); ++i )
{
vgui::GetAnimationController()->RunAnimationCommand( m_pGameMenuButtons[i], "alpha", targetTitleAlpha, 0.0f, duration, AnimationController::INTERPOLATOR_LINEAR );
}
m_bHaveDarkenedTitleText = bNeedDarkenedTitleText;
m_bForceTitleTextUpdate = false;
}
}
//-----------------------------------------------------------------------------
// Purpose: sets how the game background should render
//-----------------------------------------------------------------------------
void CBasePanel::SetBackgroundRenderState(EBackgroundState state)
{
if ( state == m_eBackgroundState )
{
return;
}
// apply state change transition
float frametime = engine->Time();
if ( m_eBackgroundState == BACKGROUND_INITIAL && ( state == BACKGROUND_DISCONNECTED || state == BACKGROUND_MAINMENU ) )
{
ConVar* dev_loadtime_mainmenu = cvar->FindVar( "dev_loadtime_mainmenu" );
if (dev_loadtime_mainmenu) {
dev_loadtime_mainmenu->SetValue( frametime );
}
}
m_bRenderingBackgroundTransition = false;
m_bFadingInMenus = false;
CMatchmakingBasePanel *pPanel = GetMatchmakingBasePanel();
if ( pPanel )
{
if ( state == BACKGROUND_LOADING )
{
pPanel->SetVisible( false );
}
else
{
pPanel->SetVisible( true );
}
}
if ( state == BACKGROUND_EXITING )
{
// hide the menus
m_bCopyFrameBuffer = false;
}
else if ( state == BACKGROUND_DISCONNECTED || state == BACKGROUND_MAINMENU )
{
// menu fading
// make the menus visible
m_bFadingInMenus = true;
m_flFadeMenuStartTime = frametime;
m_flFadeMenuEndTime = frametime + 3.0f;
if ( state == BACKGROUND_MAINMENU )
{
// fade background into main menu
m_bRenderingBackgroundTransition = true;
m_flTransitionStartTime = frametime;
m_flTransitionEndTime = frametime + 3.0f;
}
}
else if ( state == BACKGROUND_LOADING )
{
if ( GameUI().IsConsoleUI() )
{
RunAnimationWithCallback( this, "InstantHideMainMenu", new KeyValues( "LoadMap" ) );
}
// hide the menus
SetMenuAlpha( 0 );
}
else if ( state == BACKGROUND_LEVEL )
{
// show the menus
SetMenuAlpha( 255 );
}
m_eBackgroundState = state;
}
void CBasePanel::StartExitingProcess()
{
// must let a non trivial number of screen swaps occur to stabilize image
// ui runs in a constrained state, while shutdown is occurring
m_flTransitionStartTime = engine->Time();
m_flTransitionEndTime = m_flTransitionStartTime + 0.5f;
m_ExitingFrameCount = 30;
g_pInputSystem->DetachFromWindow();
CMatchmakingBasePanel *pPanel = GetMatchmakingBasePanel();
if ( pPanel )
{
pPanel->CloseAllDialogs( false );
}
engine->StartXboxExitingProcess();
}
//-----------------------------------------------------------------------------
// Purpose: Size should only change on first vgui frame after startup
//-----------------------------------------------------------------------------
void CBasePanel::OnSizeChanged( int newWide, int newTall )
{
// Recenter message dialogs
m_MessageDialogHandler.PositionDialogs( newWide, newTall );
if ( m_hMatchmakingBasePanel.Get() )
{
m_hMatchmakingBasePanel->SetBounds( 0, 0, newWide, newTall );
}
}
//-----------------------------------------------------------------------------
// Purpose: notifications
//-----------------------------------------------------------------------------
void CBasePanel::OnLevelLoadingStarted()
{
m_bLevelLoading = true;
m_pGameMenu->ShowFooter( false );
if ( m_hMatchmakingBasePanel.Get() )
{
m_hMatchmakingBasePanel->OnCommand( "LevelLoadingStarted" );
}
if ( IsX360() && m_eBackgroundState == BACKGROUND_LEVEL )
{
// already in a level going to another level
// frame buffer is about to be cleared, copy it off for ui backing purposes
m_bCopyFrameBuffer = true;
}
}
//-----------------------------------------------------------------------------
// Purpose: notification
//-----------------------------------------------------------------------------
void CBasePanel::OnLevelLoadingFinished()
{
m_bLevelLoading = false;
if ( m_hMatchmakingBasePanel.Get() )
{
m_hMatchmakingBasePanel->OnCommand( "LevelLoadingFinished" );
}
}
//-----------------------------------------------------------------------------
// Draws the background image.
//-----------------------------------------------------------------------------
void CBasePanel::DrawBackgroundImage()
{
if ( IsX360() && m_bCopyFrameBuffer )
{
// force the engine to do an image capture ONCE into this image's render target
char filename[MAX_PATH];
surface()->DrawGetTextureFile( m_iRenderTargetImageID, filename, sizeof( filename ) );
engine->CopyFrameBufferToMaterial( filename );
m_bCopyFrameBuffer = false;
m_bUseRenderTargetImage = true;
}
int wide, tall;
GetSize( wide, tall );
float frametime = engine->Time();
// a background transition has a running map underneath it, so fade image out
// otherwise, there is no map and the background image stays opaque
int alpha = 255;
if ( m_bRenderingBackgroundTransition )
{
// goes from [255..0]
alpha = (m_flTransitionEndTime - frametime) / (m_flTransitionEndTime - m_flTransitionStartTime) * 255;
alpha = clamp( alpha, 0, 255 );
}
// an exiting process needs to opaquely cover everything
if ( m_ExitingFrameCount )
{
// goes from [0..255]
alpha = (m_flTransitionEndTime - frametime) / (m_flTransitionEndTime - m_flTransitionStartTime) * 255;
alpha = 255 - clamp( alpha, 0, 255 );
}
int iImageID = m_iBackgroundImageID;
if ( IsX360() )
{
if ( m_ExitingFrameCount )
{
if ( !m_bRestartSameGame )
{
iImageID = m_iProductImageID;
}
}
else if ( m_bUseRenderTargetImage )
{
// the render target image must be opaque, the alpha channel contents are unknown
// it is strictly an opaque background image and never used as an overlay
iImageID = m_iRenderTargetImageID;
alpha = 255;
}
}
surface()->DrawSetColor( 255, 255, 255, alpha );
surface()->DrawSetTexture( iImageID );
surface()->DrawTexturedRect( 0, 0, wide, tall );
if ( IsX360() && m_ExitingFrameCount )
{
// Make invisible when going back to appchooser
m_pGameMenu->CGameMenu::BaseClass::SetVisible( false );
IScheme *pScheme = vgui::scheme()->GetIScheme( vgui::scheme()->GetScheme( "SourceScheme" ) );
HFont hFont = pScheme->GetFont( "ChapterTitle" );
wchar_t *pString = g_pVGuiLocalize->Find( "#GameUI_Loading" );
int textWide, textTall;
surface()->GetTextSize( hFont, pString, textWide, textTall );
surface()->DrawSetTextPos( ( wide - textWide )/2, tall * 0.50f );
surface()->DrawSetTextFont( hFont );
surface()->DrawSetTextColor( 255, 255, 255, alpha );
surface()->DrawPrintText( pString, wcslen( pString ) );
}
// 360 always use the progress bar, TCR Requirement, and never this loading plaque
if ( IsPC() && ( m_bRenderingBackgroundTransition || m_eBackgroundState == BACKGROUND_LOADING ) )
{
// draw the loading image over the top
surface()->DrawSetColor(255, 255, 255, alpha);
surface()->DrawSetTexture(m_iLoadingImageID);
int twide, ttall;
surface()->DrawGetTextureSize(m_iLoadingImageID, twide, ttall);
surface()->DrawTexturedRect(wide - twide, tall - ttall, wide, tall);
}
// update the menu alpha
if ( m_bFadingInMenus )
{
if ( GameUI().IsConsoleUI() )
{
m_pConsoleAnimationController->StartAnimationSequence( "OpenMainMenu" );
m_bFadingInMenus = false;
}
else
{
// goes from [0..255]
alpha = (frametime - m_flFadeMenuStartTime) / (m_flFadeMenuEndTime - m_flFadeMenuStartTime) * 255;
alpha = clamp( alpha, 0, 255 );
m_pGameMenu->SetAlpha( alpha );
if ( alpha == 255 )
{
m_bFadingInMenus = false;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::CreateGameMenu()
{
// load settings from config file
KeyValues *datafile = new KeyValues("GameMenu");
datafile->UsesEscapeSequences( true ); // VGUI uses escape sequences
if (datafile->LoadFromFile( g_pFullFileSystem, "Resource/GameMenu.res" ) )
{
m_pGameMenu = RecursiveLoadGameMenu(datafile);
}
if ( !m_pGameMenu )
{
Error( "Could not load file Resource/GameMenu.res" );
}
else
{
// start invisible
SETUP_PANEL( m_pGameMenu );
m_pGameMenu->SetAlpha( 0 );
}
datafile->deleteThis();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::CreateGameLogo()
{
if ( ModInfo().UseGameLogo() )
{
m_pGameLogo = new CMainMenuGameLogo( this, "GameLogo" );
if ( m_pGameLogo )
{
SETUP_PANEL( m_pGameLogo );
m_pGameLogo->InvalidateLayout( true, true );
// start invisible
m_pGameLogo->SetAlpha( 0 );
}
}
else
{
m_pGameLogo = NULL;
}
}
void CBasePanel::CheckBonusBlinkState()
{
#ifdef _X360
// On 360 if we have a storage device at this point and try to read the bonus data it can't find the bonus file!
return;
#endif
if ( BonusMapsDatabase()->GetBlink() )
{
if ( GameUI().IsConsoleUI() )
SetMenuItemBlinkingState( "OpenNewGameDialog", true ); // Consoles integrate bonus maps menu into the new game menu
else
SetMenuItemBlinkingState( "OpenBonusMapsDialog", true );
}
}
//-----------------------------------------------------------------------------
// Purpose: Checks to see if menu items need to be enabled/disabled
//-----------------------------------------------------------------------------
void CBasePanel::UpdateGameMenus()
{
// check our current state
bool isInGame = GameUI().IsInLevel();
bool isMulti = isInGame && (engine->GetMaxClients() > 1);
bool isInReplay = GameUI().IsInReplay();
bool isVREnabled = materials->GetCurrentConfigForVideoCard().m_nVRModeAdapter == materials->GetCurrentAdapter();
bool isVRActive = UseVR();
// iterate all the menu items
m_pGameMenu->UpdateMenuItemState( isInGame, isMulti, isInReplay, isVREnabled, isVRActive );
if ( m_hMainMenuOverridePanel )
{
vgui::ivgui()->PostMessage( m_hMainMenuOverridePanel, new KeyValues( "UpdateMenu" ), NULL );
}
// position the menu
InvalidateLayout();
m_pGameMenu->SetVisible( true );
}
//-----------------------------------------------------------------------------
// Purpose: sets up the game menu from the keyvalues
// the game menu is hierarchial, so this is recursive
//-----------------------------------------------------------------------------
CGameMenu *CBasePanel::RecursiveLoadGameMenu(KeyValues *datafile)
{
CGameMenu *menu = new CGameMenu(this, datafile->GetName());
wchar_t *pString = g_pVGuiLocalize->Find( "#GameUI_Console" );
if( pString )
menu->AddMenuItem("Console", V_wcsupr(pString), "OpenConsole", this);
else
menu->AddMenuItem("Console", "CONSOLE", "OpenConsole", this);
// loop through all the data adding items to the menu
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->GetString("name", label);
if ( cmd && !Q_stricmp( cmd, "OpenFriendsDialog" ) && bSteamCommunityFriendsVersion )
continue;
menu->AddMenuItem(name, label, cmd, this, dat);
}
return menu;
}
//-----------------------------------------------------------------------------
// Purpose: update the taskbar a frame
//-----------------------------------------------------------------------------
void CBasePanel::RunFrame()
{
InvalidateLayout();
vgui::GetAnimationController()->UpdateAnimations( engine->Time() );
if ( GameUI().IsConsoleUI() )
{
// run the console ui animations
m_pConsoleAnimationController->UpdateAnimations( engine->Time() );
if ( IsX360() && m_ExitingFrameCount && engine->Time() >= m_flTransitionEndTime )
{
if ( m_ExitingFrameCount > 1 )
{
m_ExitingFrameCount--;
if ( m_ExitingFrameCount == 1 )
{
// enough frames have transpired, send the single shot quit command
// If we kicked off this event from an invite, we need to properly setup the restart to account for that
if ( m_bRestartFromInvite )
{
engine->ClientCmd_Unrestricted( "quit_x360 invite" );
}
else if ( m_bRestartSameGame )
{
engine->ClientCmd_Unrestricted( "quit_x360 restart" );
}
else
{
// quits to appchooser
engine->ClientCmd_Unrestricted( "quit_x360\n" );
}
}
}
}
}
UpdateBackgroundState();
if ( !m_bPlatformMenuInitialized )
{
// check to see if the platform is ready to load yet
if ( IsX360() || g_VModuleLoader.IsPlatformReady() )
{
m_bPlatformMenuInitialized = true;
}
}
// Check to see if a pending async task has already finished
if ( m_pAsyncJob && !m_pAsyncJob->m_hThreadHandle )
{
m_pAsyncJob->Completed();
delete m_pAsyncJob;
m_pAsyncJob = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Tells XBox Live our user is in the current game's menu
//-----------------------------------------------------------------------------
void CBasePanel::UpdateRichPresenceInfo()
{
#if defined( _X360 )
// For all other users logged into this console (not primary), set to idle to satisfy cert
for( uint i = 0; i < XUSER_MAX_COUNT; ++i )
{
XUSER_SIGNIN_STATE State = XUserGetSigninState( i );
if( State != eXUserSigninState_NotSignedIn )
{
if ( i != XBX_GetPrimaryUserId() )
{
// Set rich presence as 'idle' for users logged in that can't participate in orange box.
if ( !xboxsystem->UserSetContext( i, X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_IDLE, true ) )
{
Warning( "BasePanel: UserSetContext failed.\n" );
}
}
}
}
if ( !GameUI().IsInLevel() )
{
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), CONTEXT_GAME, m_iGameID, true ) )
{
Warning( "BasePanel: UserSetContext failed.\n" );
}
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_MENU, true ) )
{
Warning( "BasePanel: UserSetContext failed.\n" );
}
if ( m_bSinglePlayer )
{
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_GAME_MODE, CONTEXT_GAME_MODE_SINGLEPLAYER, true ) )
{
Warning( "BasePanel: UserSetContext failed.\n" );
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Lays out the position of the taskbar
//-----------------------------------------------------------------------------
void CBasePanel::PerformLayout()
{
BaseClass::PerformLayout();
// Get the screen size
int wide, tall;
vgui::surface()->GetScreenSize(wide, tall);
// Get the size of the menu
int menuWide, menuTall;
m_pGameMenu->GetSize( menuWide, menuTall );
int idealMenuY = m_iGameMenuPos.y;
if ( idealMenuY + menuTall + m_iGameMenuInset > tall )
{
idealMenuY = tall - menuTall - m_iGameMenuInset;
}
int yDiff = idealMenuY - m_iGameMenuPos.y;
for ( int i=0; i<m_pGameMenuButtons.Count(); ++i )
{
// Get the size of the logo text
//int textWide, textTall;
m_pGameMenuButtons[i]->SizeToContents();
//vgui::surface()->GetTextSize( m_pGameMenuButtons[i]->GetFont(), ModInfo().GetGameTitle(), textWide, textTall );
// place menu buttons above middle of screen
m_pGameMenuButtons[i]->SetPos(m_iGameTitlePos[i].x, m_iGameTitlePos[i].y + yDiff);
//m_pGameMenuButtons[i]->SetSize(textWide + 4, textTall + 4);
}
if ( m_pGameLogo )
{
// move the logo to sit right on top of the menu
m_pGameLogo->SetPos( m_iGameMenuPos.x + m_pGameLogo->GetOffsetX(), idealMenuY - m_pGameLogo->GetTall() + m_pGameLogo->GetOffsetY() );
}
// position self along middle of screen
if ( GameUI().IsConsoleUI() )
{
int posx, posy;
m_pGameMenu->GetPos( posx, posy );
m_iGameMenuPos.x = posx;
}
m_pGameMenu->SetPos(m_iGameMenuPos.x, idealMenuY);
UpdateGameMenus();
}
//-----------------------------------------------------------------------------
// Purpose: Loads scheme information
//-----------------------------------------------------------------------------
void CBasePanel::ApplySchemeSettings(IScheme *pScheme)
{
int i;
BaseClass::ApplySchemeSettings(pScheme);
m_iGameMenuInset = atoi(pScheme->GetResourceString("MainMenu.Inset"));
m_iGameMenuInset *= 2;
IScheme *pClientScheme = vgui::scheme()->GetIScheme( vgui::scheme()->GetScheme( "ClientScheme" ) );
CUtlVector< Color > buttonColor;
if ( pClientScheme )
{
m_iGameTitlePos.RemoveAll();
for ( i=0; i<m_pGameMenuButtons.Count(); ++i )
{
m_pGameMenuButtons[i]->SetFont(pClientScheme->GetFont("ClientTitleFont", true));
m_iGameTitlePos.AddToTail( coord() );
m_iGameTitlePos[i].x = atoi(pClientScheme->GetResourceString( CFmtStr( "Main.Title%d.X", i+1 ) ) );
m_iGameTitlePos[i].x = scheme()->GetProportionalScaledValue( m_iGameTitlePos[i].x );
m_iGameTitlePos[i].y = atoi(pClientScheme->GetResourceString( CFmtStr( "Main.Title%d.Y", i+1 ) ) );
m_iGameTitlePos[i].y = scheme()->GetProportionalScaledValue( m_iGameTitlePos[i].y );
if ( GameUI().IsConsoleUI() )
m_iGameTitlePos[i].x += MAIN_MENU_INDENT_X360;
buttonColor.AddToTail( pClientScheme->GetColor( CFmtStr( "Main.Title%d.Color", i+1 ), Color(255, 255, 255, 255)) );
}
#ifdef CS_BETA
if ( !ModInfo().NoCrosshair() ) // hack to not show the BETA for HL2 or HL1Port
{
m_pGameMenuButtons[m_pGameMenuButtons.Count()-1]->SetFont(pClientScheme->GetFont("BetaFont", true));
}
#endif // CS_BETA
m_iGameMenuPos.x = atoi(pClientScheme->GetResourceString("Main.Menu.X"));
m_iGameMenuPos.x = scheme()->GetProportionalScaledValue( m_iGameMenuPos.x );
m_iGameMenuPos.y = atoi(pClientScheme->GetResourceString("Main.Menu.Y"));
m_iGameMenuPos.y = scheme()->GetProportionalScaledValue( m_iGameMenuPos.y );
m_iGameMenuInset = atoi(pClientScheme->GetResourceString("Main.BottomBorder"));
m_iGameMenuInset = scheme()->GetProportionalScaledValue( m_iGameMenuInset );
}
else
{
for ( i=0; i<m_pGameMenuButtons.Count(); ++i )
{
m_pGameMenuButtons[i]->SetFont(pScheme->GetFont("TitleFont"));
buttonColor.AddToTail( Color( 255, 255, 255, 255 ) );
}
}
for ( i=0; i<m_pGameMenuButtons.Count(); ++i )
{
m_pGameMenuButtons[i]->SetDefaultColor(buttonColor[i], Color(0, 0, 0, 0));
m_pGameMenuButtons[i]->SetArmedColor(buttonColor[i], Color(0, 0, 0, 0));
m_pGameMenuButtons[i]->SetDepressedColor(buttonColor[i], Color(0, 0, 0, 0));
}
m_flFrameFadeInTime = atof(pScheme->GetResourceString("Frame.TransitionEffectTime"));
// work out current focus - find the topmost panel
SetBgColor(Color(0, 0, 0, 0));
m_BackdropColor = pScheme->GetColor("mainmenu.backdrop", Color(0, 0, 0, 128));
char filename[MAX_PATH];
if ( IsX360() )
{
// 360 uses FullFrameFB1 RT for map to map transitioning
if ( m_iRenderTargetImageID == -1 )
{
m_iRenderTargetImageID = surface()->CreateNewTextureID();
surface()->DrawSetTextureFile( m_iRenderTargetImageID, "console/rt_background", false, false );
}
}
int screenWide, screenTall;
surface()->GetScreenSize( screenWide, screenTall );
float aspectRatio = (float)screenWide/(float)screenTall;
bool bIsWidescreen = aspectRatio >= 1.5999f;
// work out which background image to use
if ( IsPC() || !IsX360() )
{
// pc uses blurry backgrounds based on the background level
char background[MAX_PATH];
engine->GetMainMenuBackgroundName( background, sizeof(background) );
Q_snprintf( filename, sizeof( filename ), "console/%s%s", background, ( bIsWidescreen ? "_widescreen" : "" ) );
}
else
{
// 360 uses hi-res game specific backgrounds
char gameName[MAX_PATH];
const char *pGameDir = engine->GetGameDirectory();
V_FileBase( pGameDir, gameName, sizeof( gameName ) );
V_snprintf( filename, sizeof( filename ), "vgui/appchooser/background_%s%s", gameName, ( bIsWidescreen ? "_widescreen" : "" ) );
}
if ( m_iBackgroundImageID == -1 )
{
m_iBackgroundImageID = surface()->CreateNewTextureID();
}
surface()->DrawSetTextureFile( m_iBackgroundImageID, filename, false, false );
if ( IsX360() )
{
// 360 uses a product image during application exit
V_snprintf( filename, sizeof( filename ), "vgui/appchooser/background_orange%s", ( bIsWidescreen ? "_widescreen" : "" ) );
if ( m_iProductImageID == -1 )
{
m_iProductImageID = surface()->CreateNewTextureID();
}
surface()->DrawSetTextureFile( m_iProductImageID, filename, false, false );
}
if ( IsPC() )
{
// load the loading icon
if ( m_iLoadingImageID == -1 )
{
m_iLoadingImageID = surface()->CreateNewTextureID();
surface()->DrawSetTextureFile( m_iLoadingImageID, "Console/startup_loading", false, false );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: message handler for platform menu; activates the selected module
//-----------------------------------------------------------------------------
void CBasePanel::OnActivateModule(int moduleIndex)
{
g_VModuleLoader.ActivateModule(moduleIndex);
}
//-----------------------------------------------------------------------------
// Purpose: Animates menus on gameUI being shown
//-----------------------------------------------------------------------------
void CBasePanel::OnGameUIActivated()
{
// If the load failed, we're going to bail out here
if ( engine->MapLoadFailed() )
{
// Don't display this again until it happens again
engine->SetMapLoadFailed( false );
ShowMessageDialog( MD_LOAD_FAILED_WARNING );
}
if ( !m_bEverActivated )
{
// Layout the first time to avoid focus issues (setting menus visible will grab focus)
UpdateGameMenus();
m_bEverActivated = true;
#if defined( _X360 )
// Open all active containers if we have a valid storage device
if ( XBX_GetPrimaryUserId() != XBX_INVALID_USER_ID && XBX_GetStorageDeviceId() != XBX_INVALID_STORAGE_ID && XBX_GetStorageDeviceId() != XBX_STORAGE_DECLINED )
{
// Open user settings and save game container here
uint nRet = engine->OnStorageDeviceAttached();
if ( nRet != ERROR_SUCCESS )
{
// Invalidate the device
XBX_SetStorageDeviceId( XBX_INVALID_STORAGE_ID );
// FIXME: We don't know which device failed!
// Pop a dialog explaining that the user's data is corrupt
BasePanel()->ShowMessageDialog( MD_STORAGE_DEVICES_CORRUPT );
}
}
// determine if we're starting up because of a cross-game invite
int fLaunchFlags = XboxLaunch()->GetLaunchFlags();
if ( fLaunchFlags & LF_INVITERESTART )
{
XNKID nSessionID;
XboxLaunch()->GetInviteSessionID( &nSessionID );
matchmaking->JoinInviteSessionByID( nSessionID );
}
#endif
// Brute force check to open tf matchmaking ui.
if ( GameUI().IsConsoleUI() )
{
const char *pGame = engine->GetGameDirectory();
if ( !Q_stricmp( Q_UnqualifiedFileName( pGame ), "tf" ) )
{
m_bUseMatchmaking = true;
RunMenuCommand( "OpenMatchmakingBasePanel" );
}
}
}
if ( GameUI().IsConsoleUI() )
{
ArmFirstMenuItem();
}
if ( GameUI().IsInLevel() )
{
if ( !m_bUseMatchmaking )
{
OnCommand( "OpenPauseMenu" );
}
else
{
RunMenuCommand( "OpenMatchmakingBasePanel" );
}
if ( m_hAchievementsDialog.Get() )
{
// Achievement dialog refreshes it's data if the player looks at the pause menu
m_hAchievementsDialog->OnCommand( "OnGameUIActivated" );
}
}
else // not the pause menu, update presence
{
if ( IsX360() )
{
UpdateRichPresenceInfo();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: executes a menu command
//-----------------------------------------------------------------------------
void CBasePanel::RunMenuCommand(const char *command)
{
if ( !Q_stricmp( command, "OpenGameMenu" ) )
{
if ( m_pGameMenu )
{
PostMessage( m_pGameMenu, new KeyValues("Command", "command", "Open") );
}
}
else if ( !Q_stricmp( command, "OpenPlayerListDialog" ) )
{
OnOpenPlayerListDialog();
}
else if ( !Q_stricmp( command, "OpenNewGameDialog" ) )
{
OnOpenNewGameDialog();
}
else if ( !Q_stricmp( command, "OpenConsole" ) )
{
GameConsole().Activate();
}
else if ( !Q_stricmp( command, "OpenLoadGameDialog" ) )
{
if ( !GameUI().IsConsoleUI() )
{
OnOpenLoadGameDialog();
}
else
{
OnOpenLoadGameDialog_Xbox();
}
}
else if ( !Q_stricmp( command, "OpenSaveGameDialog" ) )
{
if ( !GameUI().IsConsoleUI() )
{
OnOpenSaveGameDialog();
}
else
{
OnOpenSaveGameDialog_Xbox();
}
}
else if ( !Q_stricmp( command, "OpenBonusMapsDialog" ) )
{
OnOpenBonusMapsDialog();
}
else if ( !Q_stricmp( command, "OpenOptionsDialog" ) )
{
if ( !GameUI().IsConsoleUI() )
{
OnOpenOptionsDialog();
}
else
{
OnOpenOptionsDialog_Xbox();
}
}
else if ( !Q_stricmp( command, "OpenControllerDialog" ) )
{
if ( GameUI().IsConsoleUI() )
{
OnOpenControllerDialog();
}
}
else if ( !Q_stricmp( command, "OpenBenchmarkDialog" ) )
{
OnOpenBenchmarkDialog();
}
else if ( !Q_stricmp( command, "OpenServerBrowser" ) )
{
OnOpenServerBrowser();
}
else if ( !Q_stricmp( command, "OpenFriendsDialog" ) )
{
OnOpenFriendsDialog();
}
else if ( !Q_stricmp( command, "OpenLoadDemoDialog" ) )
{
OnOpenDemoDialog();
}
else if ( !Q_stricmp( command, "OpenCreateMultiplayerGameDialog" ) )
{
OnOpenCreateMultiplayerGameDialog();
}
else if ( !Q_stricmp( command, "OpenChangeGameDialog" ) )
{
OnOpenChangeGameDialog();
}
else if ( !Q_stricmp( command, "OpenLoadCommentaryDialog" ) )
{
OnOpenLoadCommentaryDialog();
}
else if ( !Q_stricmp( command, "OpenLoadSingleplayerCommentaryDialog" ) )
{
OpenLoadSingleplayerCommentaryDialog();
}
else if ( !Q_stricmp( command, "OpenMatchmakingBasePanel" ) )
{
OnOpenMatchmakingBasePanel();
}
else if ( !Q_stricmp( command, "OpenAchievementsDialog" ) )
{
if ( IsPC() )
{
#ifndef NO_STEAM
if ( !steamapicontext->SteamUser() || !steamapicontext->SteamUser()->BLoggedOn() )
{
vgui::MessageBox *pMessageBox = new vgui::MessageBox("#GameUI_Achievements_SteamRequired_Title", "#GameUI_Achievements_SteamRequired_Message", this);
pMessageBox->DoModal();
return;
}
#endif
OnOpenAchievementsDialog();
}
else
{
OnOpenAchievementsDialog_Xbox();
}
}
//=============================================================================
// HPE_BEGIN:
// [dwenger] Use cs-specific achievements dialog
//=============================================================================
else if ( !Q_stricmp( command, "OpenCSAchievementsDialog" ) )
{
if ( IsPC() )
{
if ( !steamapicontext->SteamUser() || !steamapicontext->SteamUser()->BLoggedOn() )
{
vgui::MessageBox *pMessageBox = new vgui::MessageBox("#GameUI_Achievements_SteamRequired_Title", "#GameUI_Achievements_SteamRequired_Message", this );
pMessageBox->DoModal();
return;
}
OnOpenCSAchievementsDialog();
}
}
//=============================================================================
// HPE_END
//=============================================================================
else if ( !Q_stricmp( command, "AchievementsDialogClosing" ) )
{
if ( IsX360() )
{
if ( m_hAchievementsDialog.Get() )
{
m_hAchievementsDialog->Close();
}
}
}
else if ( !Q_stricmp( command, "Quit" ) )
{
OnOpenQuitConfirmationDialog();
}
else if ( !Q_stricmp( command, "QuitNoConfirm" ) )
{
if ( IsX360() )
{
// start the shutdown process
StartExitingProcess();
}
else
{
//=============================================================================
// HPE_BEGIN:
// [dwenger] Shut down achievements panel
//=============================================================================
if ( GameClientExports() )
{
GameClientExports()->ShutdownAchievementPanel();
}
//=============================================================================
// HPE_END
//=============================================================================
// hide everything while we quit
SetVisible( false );
vgui::surface()->RestrictPaintToSinglePanel( GetVPanel() );
engine->ClientCmd_Unrestricted( "quit\n" );
}
}
else if ( !Q_stricmp( command, "QuitRestartNoConfirm" ) )
{
if ( IsX360() )
{
// start the shutdown process
m_bRestartSameGame = true;
StartExitingProcess();
}
}
else if ( !Q_stricmp( command, "ResumeGame" ) )
{
GameUI().HideGameUI();
}
else if ( !Q_stricmp( command, "Disconnect" ) )
{
if ( IsX360() )
{
OnOpenDisconnectConfirmationDialog();
}
else
{
engine->ClientCmd_Unrestricted( "disconnect" );
}
}
else if ( !Q_stricmp( command, "DisconnectNoConfirm" ) )
{
ConVarRef commentary( "commentary" );
if ( commentary.IsValid() && commentary.GetBool() )
{
engine->ClientCmd_Unrestricted( "disconnect" );
CMatchmakingBasePanel *pBase = GetMatchmakingBasePanel();
if ( pBase )
{
pBase->CloseAllDialogs( false );
pBase->OnCommand( "OpenWelcomeDialog" );
}
}
else
{
// Leave our current session, if we have one
matchmaking->KickPlayerFromSession( 0 );
}
}
else if ( !Q_stricmp( command, "ReleaseModalWindow" ) )
{
vgui::surface()->RestrictPaintToSinglePanel(NULL);
}
else if ( Q_stristr( command, "engine " ) )
{
const char *engineCMD = strstr( command, "engine " ) + strlen( "engine " );
if ( strlen( engineCMD ) > 0 )
{
engine->ClientCmd_Unrestricted( const_cast<char *>( engineCMD ) );
}
}
else if ( !Q_stricmp( command, "ShowSigninUI" ) )
{
m_bWaitingForUserSignIn = true;
xboxsystem->ShowSigninUI( 1, 0 ); // One user, no special flags
}
else if ( !Q_stricmp( command, "ShowDeviceSelector" ) )
{
OnChangeStorageDevice();
}
else if ( !Q_stricmp( command, "SignInDenied" ) )
{
// The user doesn't care, so re-send the command they wanted and mark that we want to skip checking
m_bUserRefusedSignIn = true;
if ( m_strPostPromptCommand.IsEmpty() == false )
{
OnCommand( m_strPostPromptCommand );
}
}
else if ( !Q_stricmp( command, "RequiredSignInDenied" ) )
{
m_strPostPromptCommand = "";
}
else if ( !Q_stricmp( command, "RequiredStorageDenied" ) )
{
m_strPostPromptCommand = "";
}
else if ( !Q_stricmp( command, "StorageDeviceDenied" ) )
{
// The user doesn't care, so re-send the command they wanted and mark that we want to skip checking
m_bUserRefusedStorageDevice = true;
IssuePostPromptCommand();
// Set us as declined
XBX_SetStorageDeviceId( XBX_STORAGE_DECLINED );
m_iStorageID = XBX_INVALID_STORAGE_ID;
if ( m_pStorageDeviceValidatedNotify )
{
*m_pStorageDeviceValidatedNotify = 2;
m_pStorageDeviceValidatedNotify = NULL;
}
}
else if ( !Q_stricmp( command, "clear_storage_deviceID" ) )
{
XBX_SetStorageDeviceId( XBX_STORAGE_DECLINED );
}
else if ( !Q_stricmp( command, "RestartWithNewLanguage" ) )
{
if ( !IsX360() )
{
char szSteamURL[50];
// hide everything while we quit
SetVisible( false );
vgui::surface()->RestrictPaintToSinglePanel( GetVPanel() );
engine->ClientCmd_Unrestricted( "quit\n" );
// Construct Steam URL. Pattern is steam://run/<appid>/<language>. (e.g. Ep1 In French ==> steam://run/380/french)
V_snprintf( szSteamURL, sizeof(szSteamURL), "steam://run/%d/%s", engine->GetAppID(), COptionsSubAudio::GetUpdatedAudioLanguage() );
// Set Steam URL for re-launch in registry. Launcher will check this registry key and exec it in order to re-load the game in the proper language
#if defined( WIN32 ) && !defined( _X360 )
HKEY hKey;
if ( IsPC() && RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\Valve\\Source", NULL, KEY_WRITE, &hKey) == ERROR_SUCCESS )
{
RegSetValueEx( hKey, "Relaunch URL", 0, REG_SZ, (const unsigned char *)szSteamURL, sizeof( szSteamURL ) );
RegCloseKey(hKey);
}
#elif defined( OSX ) || defined( LINUX )
FILE *fp = fopen( "/tmp/hl2_relaunch", "w+" );
if ( fp )
{
fprintf( fp, "%s\n", szSteamURL );
}
fclose( fp );
#elif defined( _X360 )
#else
#error
#endif
}
}
else
{
BaseClass::OnCommand( command);
}
}
//-----------------------------------------------------------------------------
// Purpose: Queue a command to be run when XUI Closes
//-----------------------------------------------------------------------------
void CBasePanel::QueueCommand( const char *pCommand )
{
if ( m_bXUIVisible )
{
m_CommandQueue.AddToTail( CUtlString( pCommand ) );
}
else
{
OnCommand( pCommand );
}
}
//-----------------------------------------------------------------------------
// Purpose: Run all the commands in the queue
//-----------------------------------------------------------------------------
void CBasePanel::RunQueuedCommands()
{
for ( int i = 0; i < m_CommandQueue.Count(); ++i )
{
OnCommand( m_CommandQueue[i] );
}
ClearQueuedCommands();
}
//-----------------------------------------------------------------------------
// Purpose: Clear all queued commands
//-----------------------------------------------------------------------------
void CBasePanel::ClearQueuedCommands()
{
m_CommandQueue.Purge();
}
//-----------------------------------------------------------------------------
// Purpose: Whether this command should cause us to prompt the user if they're not signed in and do not have a storage device
//-----------------------------------------------------------------------------
bool CBasePanel::IsPromptableCommand( const char *command )
{
// Blech!
if ( !Q_stricmp( command, "OpenNewGameDialog" ) ||
!Q_stricmp( command, "OpenLoadGameDialog" ) ||
!Q_stricmp( command, "OpenSaveGameDialog" ) ||
!Q_stricmp( command, "OpenBonusMapsDialog" ) ||
!Q_stricmp( command, "OpenOptionsDialog" ) ||
!Q_stricmp( command, "OpenControllerDialog" ) ||
!Q_stricmp( command, "OpenLoadCommentaryDialog" ) ||
!Q_stricmp( command, "OpenLoadSingleplayerCommentaryDialog" ) ||
!Q_stricmp( command, "OpenAchievementsDialog" ) ||
//=============================================================================
// HPE_BEGIN:
// [dwenger] Use cs-specific achievements dialog
//=============================================================================
!Q_stricmp( command, "OpenCSAchievementsDialog" ) )
//=============================================================================
// HPE_END
//=============================================================================
{
return true;
}
return false;
}
#ifdef _WIN32
//-------------------------
// Purpose: Job wrapper
//-------------------------
static unsigned PanelJobWrapperFn( void *pvContext )
{
CBasePanel::CAsyncJobContext *pAsync = reinterpret_cast< CBasePanel::CAsyncJobContext * >( pvContext );
float const flTimeStart = Plat_FloatTime();
pAsync->ExecuteAsync();
float const flElapsedTime = Plat_FloatTime() - flTimeStart;
if ( flElapsedTime < pAsync->m_flLeastExecuteTime )
{
ThreadSleep( ( pAsync->m_flLeastExecuteTime - flElapsedTime ) * 1000 );
}
ReleaseThreadHandle( ( ThreadHandle_t ) pAsync->m_hThreadHandle );
pAsync->m_hThreadHandle = NULL;
return 0;
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Enqueues a job function to be called on a separate thread
//-----------------------------------------------------------------------------
void CBasePanel::ExecuteAsync( CAsyncJobContext *pAsync )
{
Assert( !m_pAsyncJob );
Assert( pAsync && !pAsync->m_hThreadHandle );
m_pAsyncJob = pAsync;
#ifdef _WIN32
ThreadHandle_t hHandle = CreateSimpleThread( PanelJobWrapperFn, reinterpret_cast< void * >( pAsync ) );
pAsync->m_hThreadHandle = hHandle;
#ifdef _X360
ThreadSetAffinity( hHandle, XBOX_PROCESSOR_3 );
#endif
#else
pAsync->ExecuteAsync();
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Whether this command requires the user be signed in
//-----------------------------------------------------------------------------
bool CBasePanel::CommandRequiresSignIn( const char *command )
{
// Blech again!
if ( !Q_stricmp( command, "OpenAchievementsDialog" ) ||
//=============================================================================
// HPE_BEGIN:
// [dwenger] Use cs-specific achievements dialog
//=============================================================================
!Q_stricmp( command, "OpenCSAchievementsDialog" ) ||
//=============================================================================
// HPE_END
//=============================================================================
!Q_stricmp( command, "OpenLoadGameDialog" ) ||
!Q_stricmp( command, "OpenSaveGameDialog" ) ||
!Q_stricmp( command, "OpenRankingsDialog" ) )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Whether the command requires the user to have a valid storage device
//-----------------------------------------------------------------------------
bool CBasePanel::CommandRequiresStorageDevice( const char *command )
{
// Anything which touches the storage device must prompt
if ( !Q_stricmp( command, "OpenSaveGameDialog" ) ||
!Q_stricmp( command, "OpenLoadGameDialog" ) )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Whether the command requires the user to have a valid profile selected
//-----------------------------------------------------------------------------
bool CBasePanel::CommandRespectsSignInDenied( const char *command )
{
// Anything which touches the user profile must prompt
if ( !Q_stricmp( command, "OpenOptionsDialog" ) ||
!Q_stricmp( command, "OpenControllerDialog" ) )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: A storage device has been connected, update our settings and anything else
//-----------------------------------------------------------------------------
class CAsyncCtxOnDeviceAttached : public CBasePanel::CAsyncJobContext
{
public:
CAsyncCtxOnDeviceAttached();
~CAsyncCtxOnDeviceAttached();
virtual void ExecuteAsync();
virtual void Completed();
uint GetContainerOpenResult( void ) { return m_ContainerOpenResult; }
private:
uint m_ContainerOpenResult;
};
CAsyncCtxOnDeviceAttached::CAsyncCtxOnDeviceAttached() :
CBasePanel::CAsyncJobContext( 3.0f ), // Storage device info for at least 3 seconds
m_ContainerOpenResult( ERROR_SUCCESS )
{
BasePanel()->ShowMessageDialog( MD_CHECKING_STORAGE_DEVICE );
}
CAsyncCtxOnDeviceAttached::~CAsyncCtxOnDeviceAttached()
{
BasePanel()->CloseMessageDialog( 0 );
}
void CAsyncCtxOnDeviceAttached::ExecuteAsync()
{
// Asynchronously do the tasks that don't interact with the command buffer
// Open user settings and save game container here
m_ContainerOpenResult = engine->OnStorageDeviceAttached();
if ( m_ContainerOpenResult != ERROR_SUCCESS )
return;
// Make the QOS system initialized for multiplayer games
if ( !ModInfo().IsSinglePlayerOnly() )
{
#if defined( _X360 )
( void ) matchmaking->GetQosWithLIVE();
#endif
}
}
void CAsyncCtxOnDeviceAttached::Completed()
{
BasePanel()->OnCompletedAsyncDeviceAttached( this );
}
void CBasePanel::OnDeviceAttached( void )
{
ExecuteAsync( new CAsyncCtxOnDeviceAttached );
}
void CBasePanel::OnCompletedAsyncDeviceAttached( CAsyncCtxOnDeviceAttached *job )
{
uint nRet = job->GetContainerOpenResult();
if ( nRet != ERROR_SUCCESS )
{
// Invalidate the device
XBX_SetStorageDeviceId( XBX_INVALID_STORAGE_ID );
// FIXME: We don't know which device failed!
// Pop a dialog explaining that the user's data is corrupt
BasePanel()->ShowMessageDialog( MD_STORAGE_DEVICES_CORRUPT );
}
// First part of the device checking completed asynchronously,
// perform the rest of duties that require to run on main thread.
engine->ReadConfiguration();
engine->ExecuteClientCmd( "refreshplayerstats" );
BonusMapsDatabase()->ReadBonusMapSaveData();
if ( m_hSaveGameDialog_Xbox.Get() )
{
m_hSaveGameDialog_Xbox->OnCommand( "RefreshSaveGames" );
}
if ( m_hLoadGameDialog_Xbox.Get() )
{
m_hLoadGameDialog_Xbox->OnCommand( "RefreshSaveGames" );
}
if ( m_hOptionsDialog_Xbox.Get() )
{
m_hOptionsDialog_Xbox->OnCommand( "RefreshOptions" );
}
if ( m_pStorageDeviceValidatedNotify )
{
*m_pStorageDeviceValidatedNotify = 1;
m_pStorageDeviceValidatedNotify = NULL;
}
// Finish their command
IssuePostPromptCommand();
}
//-----------------------------------------------------------------------------
// Purpose: FIXME: Only TF takes this path...
//-----------------------------------------------------------------------------
bool CBasePanel::ValidateStorageDevice( void )
{
if ( m_bUserRefusedStorageDevice == false )
{
#if defined( _X360 )
if ( XBX_GetStorageDeviceId() == XBX_INVALID_STORAGE_ID )
{
// Try to discover content on the user's storage devices
DWORD nFoundDevice = xboxsystem->DiscoverUserData( XBX_GetPrimaryUserId(), COM_GetModDirectory() );
if ( nFoundDevice == XBX_INVALID_STORAGE_ID )
{
// They don't have a device, so ask for one
ShowMessageDialog( MD_PROMPT_STORAGE_DEVICE );
return false;
}
else
{
// Take this device
XBX_SetStorageDeviceId( nFoundDevice );
OnDeviceAttached();
}
// Fall through
}
#endif
}
return true;
}
bool CBasePanel::ValidateStorageDevice( int *pStorageDeviceValidated )
{
if ( m_pStorageDeviceValidatedNotify )
{
if ( pStorageDeviceValidated != m_pStorageDeviceValidatedNotify )
{
*m_pStorageDeviceValidatedNotify = -1;
m_pStorageDeviceValidatedNotify = NULL;
}
else
{
return false;
}
}
if ( pStorageDeviceValidated )
{
if ( HandleStorageDeviceRequest( "" ) )
return true;
m_pStorageDeviceValidatedNotify = pStorageDeviceValidated;
return false;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Monitor commands for certain necessary cases
// Input : *command - What menu command we're policing
//-----------------------------------------------------------------------------
bool CBasePanel::HandleSignInRequest( const char *command )
{
#ifdef _X360
// If we have a post-prompt command, we're coming back into the call from that prompt
bool bQueuedCall = ( m_strPostPromptCommand.IsEmpty() == false );
XUSER_SIGNIN_INFO info;
bool bValidUser = ( XUserGetSigninInfo( XBX_GetPrimaryUserId(), 0, &info ) == ERROR_SUCCESS );
if ( bValidUser )
return true;
// Queued command means we're returning from a prompt or blade
if ( bQueuedCall )
{
// Blade has returned with nothing
if ( m_bUserRefusedSignIn )
return true;
// User has not denied the storage device, so ask
ShowMessageDialog( MD_PROMPT_SIGNIN );
m_strPostPromptCommand = command;
// Do not run command
return false;
}
else
{
// If the user refused the sign-in and we respect that on this command, we're done
if ( m_bUserRefusedSignIn && CommandRespectsSignInDenied( command ) )
return true;
// If the message is required first, then do that instead
if ( CommandRequiresSignIn( command ) )
{
ShowMessageDialog( MD_PROMPT_SIGNIN_REQUIRED );
m_strPostPromptCommand = command;
return false;
}
// Pop a blade out
xboxsystem->ShowSigninUI( 1, 0 );
m_strPostPromptCommand = command;
m_bWaitingForUserSignIn = true;
m_bUserRefusedSignIn = false;
return false;
}
#endif // _X360
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *command -
//-----------------------------------------------------------------------------
bool CBasePanel::HandleStorageDeviceRequest( const char *command )
{
// If we don't have a valid sign-in, then we do nothing!
if ( m_bUserRefusedSignIn )
return true;
// If we have a valid storage device, there's nothing to prompt for
if ( XBX_GetStorageDeviceId() != XBX_INVALID_STORAGE_ID && XBX_GetStorageDeviceId() != XBX_STORAGE_DECLINED )
return true;
// If we have a post-prompt command, we're coming back into the call from that prompt
bool bQueuedCall = ( m_strPostPromptCommand.IsEmpty() == false );
// Are we returning from a prompt?
if ( bQueuedCall && m_bStorageBladeShown )
{
// User has declined
if ( m_bUserRefusedStorageDevice )
return true;
// Prompt them
ShowMessageDialog( MD_PROMPT_STORAGE_DEVICE );
m_strPostPromptCommand = command;
// Do not run the command
return false;
}
else
{
// If the user refused the sign-in and we respect that on this command, we're done
if ( m_bUserRefusedStorageDevice && CommandRespectsSignInDenied( command ) )
return true;
#if 0 // This attempts to find user data, but may not be cert-worthy even though it's a bit nicer for the user
// Attempt to automatically find a device
DWORD nFoundDevice = xboxsystem->DiscoverUserData( XBX_GetPrimaryUserId(), COM_GetModDirectory() );
if ( nFoundDevice != XBX_INVALID_STORAGE_ID )
{
// Take this device
XBX_SetStorageDeviceId( nFoundDevice );
OnDeviceAttached();
return true;
}
#endif //
// If the message is required first, then do that instead
if ( CommandRequiresStorageDevice( command ) )
{
ShowMessageDialog( MD_PROMPT_STORAGE_DEVICE_REQUIRED );
m_strPostPromptCommand = command;
return false;
}
// This is a misnomer of the first order!
OnChangeStorageDevice();
m_strPostPromptCommand = command;
m_bStorageBladeShown = true;
m_bUserRefusedStorageDevice = false;
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Clear the command we've queued once it has succeeded in being called
//-----------------------------------------------------------------------------
void CBasePanel::ClearPostPromptCommand( const char *pCompletedCommand )
{
if ( !Q_stricmp( m_strPostPromptCommand, pCompletedCommand ) )
{
// All commands are executed, so stop holding this
m_strPostPromptCommand = "";
}
}
//-----------------------------------------------------------------------------
// Purpose: Issue our queued command to either the base panel or the matchmaking panel
//-----------------------------------------------------------------------------
void CBasePanel::IssuePostPromptCommand( void )
{
// The device is valid, so launch any pending commands
if ( m_strPostPromptCommand.IsEmpty() == false )
{
if ( m_bSinglePlayer )
{
OnCommand( m_strPostPromptCommand );
}
else
{
CMatchmakingBasePanel *pMatchMaker = GetMatchmakingBasePanel();
if ( pMatchMaker )
{
pMatchMaker->OnCommand( m_strPostPromptCommand );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: message handler for menu selections
//-----------------------------------------------------------------------------
void CBasePanel::OnCommand( const char *command )
{
if ( GameUI().IsConsoleUI() )
{
#if defined( _X360 )
// See if this is a command we need to intercept
if ( IsPromptableCommand( command ) )
{
// Handle the sign in case
if ( HandleSignInRequest( command ) == false )
return;
// Handle storage
if ( HandleStorageDeviceRequest( command ) == false )
return;
// If we fall through, we'll need to track this again
m_bStorageBladeShown = false;
// Fall through
}
#endif // _X360
RunAnimationWithCallback( this, command, new KeyValues( "RunMenuCommand", "command", command ) );
// Clear our pending command if we just executed it
ClearPostPromptCommand( command );
}
else
{
RunMenuCommand( command );
}
}
//-----------------------------------------------------------------------------
// Purpose: runs an animation sequence, then calls a message mapped function
// when the animation is complete.
//-----------------------------------------------------------------------------
void CBasePanel::RunAnimationWithCallback( vgui::Panel *parent, const char *animName, KeyValues *msgFunc )
{
if ( !m_pConsoleAnimationController )
return;
m_pConsoleAnimationController->StartAnimationSequence( animName );
float sequenceLength = m_pConsoleAnimationController->GetAnimationSequenceLength( animName );
if ( sequenceLength )
{
sequenceLength += g_flAnimationPadding;
}
if ( parent && msgFunc )
{
PostMessage( parent, msgFunc, sequenceLength );
}
}
//-----------------------------------------------------------------------------
// Purpose: trinary choice query "save & quit", "quit", "cancel"
//-----------------------------------------------------------------------------
class CSaveBeforeQuitQueryDialog : public vgui::Frame
{
DECLARE_CLASS_SIMPLE( CSaveBeforeQuitQueryDialog, vgui::Frame );
public:
CSaveBeforeQuitQueryDialog(vgui::Panel *parent, const char *name) : BaseClass(parent, name)
{
LoadControlSettings("resource/SaveBeforeQuitDialog.res");
SetDeleteSelfOnClose(true);
SetSizeable(false);
}
void DoModal()
{
BaseClass::Activate();
input()->SetAppModalSurface(GetVPanel());
MoveToCenterOfScreen();
vgui::surface()->RestrictPaintToSinglePanel(GetVPanel());
GameUI().PreventEngineHideGameUI();
}
void OnKeyCodeTyped(KeyCode code)
{
// ESC cancels
if ( code == KEY_ESCAPE )
{
Close();
}
else
{
BaseClass::OnKeyCodeTyped(code);
}
}
void OnKeyCodePressed(KeyCode code)
{
// ESC cancels
if ( code == KEY_XBUTTON_B || code == STEAMCONTROLLER_B || code == STEAMCONTROLLER_START )
{
Close();
}
else if ( code == KEY_XBUTTON_A || code == STEAMCONTROLLER_A )
{
OnCommand( "SaveAndQuit" );
}
else if ( code == KEY_XBUTTON_X || code == STEAMCONTROLLER_X )
{
OnCommand( "Quit" );
}
else
{
BaseClass::OnKeyCodePressed(code);
}
}
virtual void OnCommand(const char *command)
{
if (!Q_stricmp(command, "Quit"))
{
PostMessage(GetVParent(), new KeyValues("Command", "command", "QuitNoConfirm"));
}
else if (!Q_stricmp(command, "SaveAndQuit"))
{
// find a new name to save
char saveName[128];
CSaveGameDialog::FindSaveSlot( saveName, sizeof(saveName) );
if ( saveName[ 0 ] )
{
// save the game
char sz[ 256 ];
Q_snprintf(sz, sizeof( sz ), "save %s\n", saveName );
engine->ClientCmd_Unrestricted( sz );
}
// quit
PostMessage(GetVParent(), new KeyValues("Command", "command", "QuitNoConfirm"));
}
else if (!Q_stricmp(command, "Cancel"))
{
Close();
}
else
{
BaseClass::OnCommand(command);
}
}
virtual void OnClose()
{
BaseClass::OnClose();
vgui::surface()->RestrictPaintToSinglePanel(NULL);
GameUI().AllowEngineHideGameUI();
}
};
//-----------------------------------------------------------------------------
// Purpose: simple querybox that accepts escape
//-----------------------------------------------------------------------------
class CQuitQueryBox : public vgui::QueryBox
{
DECLARE_CLASS_SIMPLE( CQuitQueryBox, vgui::QueryBox );
public:
CQuitQueryBox(const char *title, const char *info, Panel *parent) : BaseClass( title, info, parent )
{
}
void DoModal( Frame* pFrameOver )
{
BaseClass::DoModal( pFrameOver );
vgui::surface()->RestrictPaintToSinglePanel(GetVPanel());
GameUI().PreventEngineHideGameUI();
}
void OnKeyCodeTyped(KeyCode code)
{
// ESC cancels
if (code == KEY_ESCAPE)
{
Close();
}
else
{
BaseClass::OnKeyCodeTyped(code);
}
}
void OnKeyCodePressed(KeyCode code)
{
// ESC cancels
if (code == KEY_XBUTTON_B || code == STEAMCONTROLLER_B)
{
Close();
}
else
{
BaseClass::OnKeyCodePressed(code);
}
}
virtual void OnClose()
{
BaseClass::OnClose();
vgui::surface()->RestrictPaintToSinglePanel(NULL);
GameUI().AllowEngineHideGameUI();
}
};
//-----------------------------------------------------------------------------
// Purpose: asks user how they feel about quiting
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenQuitConfirmationDialog()
{
if ( GameUI().IsConsoleUI() )
{
if ( !GameUI().HasSavedThisMenuSession() && GameUI().IsInLevel() && engine->GetMaxClients() == 1 )
{
// single player, progress will be lost...
ShowMessageDialog( MD_SAVE_BEFORE_QUIT );
}
else
{
if ( m_bUseMatchmaking )
{
ShowMessageDialog( MD_QUIT_CONFIRMATION_TF );
}
else
{
ShowMessageDialog( MD_QUIT_CONFIRMATION );
}
}
return;
}
if ( GameUI().IsInLevel() && engine->GetMaxClients() == 1 )
{
// prompt for saving current game before quiting
CSaveBeforeQuitQueryDialog *box = new CSaveBeforeQuitQueryDialog(this, "SaveBeforeQuitQueryDialog");
box->DoModal();
}
else
{
// simple ok/cancel prompt
QueryBox *box = new CQuitQueryBox("#GameUI_QuitConfirmationTitle", "#GameUI_QuitConfirmationText", this);
box->SetOKButtonText("#GameUI_Quit");
box->SetOKCommand(new KeyValues("Command", "command", "QuitNoConfirm"));
box->SetCancelCommand(new KeyValues("Command", "command", "ReleaseModalWindow"));
box->AddActionSignalTarget(this);
box->DoModal();
}
}
//-----------------------------------------------------------------------------
// Purpose: asks user how they feel about disconnecting
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenDisconnectConfirmationDialog()
{
// THis is for disconnecting from a multiplayer server
Assert( m_bUseMatchmaking );
Assert( IsX360() );
if ( GameUI().IsConsoleUI() && GameUI().IsInLevel() )
{
if ( engine->GetLocalPlayer() == 1 )
{
ShowMessageDialog( MD_DISCONNECT_CONFIRMATION_HOST );
}
else
{
ShowMessageDialog( MD_DISCONNECT_CONFIRMATION );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenNewGameDialog(const char *chapter )
{
if ( !m_hNewGameDialog.Get() )
{
m_hNewGameDialog = new CNewGameDialog(this, false);
PositionDialog( m_hNewGameDialog );
}
if ( chapter )
{
((CNewGameDialog *)m_hNewGameDialog.Get())->SetSelectedChapter(chapter);
}
((CNewGameDialog *)m_hNewGameDialog.Get())->SetCommentaryMode( false );
m_hNewGameDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenBonusMapsDialog( void )
{
if ( !m_hBonusMapsDialog.Get() )
{
m_hBonusMapsDialog = new CBonusMapsDialog(this);
PositionDialog( m_hBonusMapsDialog );
}
m_hBonusMapsDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenLoadGameDialog()
{
if ( !m_hLoadGameDialog.Get() )
{
m_hLoadGameDialog = new CLoadGameDialog(this);
PositionDialog( m_hLoadGameDialog );
}
m_hLoadGameDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenLoadGameDialog_Xbox()
{
if ( !m_hLoadGameDialog_Xbox.Get() )
{
m_hLoadGameDialog_Xbox = new CLoadGameDialogXbox(this);
PositionDialog( m_hLoadGameDialog_Xbox );
}
m_hLoadGameDialog_Xbox->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenSaveGameDialog()
{
if ( !m_hSaveGameDialog.Get() )
{
m_hSaveGameDialog = new CSaveGameDialog(this);
PositionDialog( m_hSaveGameDialog );
}
m_hSaveGameDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenSaveGameDialog_Xbox()
{
if ( !m_hSaveGameDialog_Xbox.Get() )
{
m_hSaveGameDialog_Xbox = new CSaveGameDialogXbox(this);
PositionDialog( m_hSaveGameDialog_Xbox );
}
m_hSaveGameDialog_Xbox->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenOptionsDialog()
{
if ( !m_hOptionsDialog.Get() )
{
m_hOptionsDialog = new COptionsDialog(this);
g_hOptionsDialog = m_hOptionsDialog;
PositionDialog( m_hOptionsDialog );
}
m_hOptionsDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenOptionsDialog_Xbox()
{
if ( !m_hOptionsDialog_Xbox.Get() )
{
m_hOptionsDialog_Xbox = new COptionsDialogXbox( this );
PositionDialog( m_hOptionsDialog_Xbox );
}
m_hOptionsDialog_Xbox->Activate();
}
//-----------------------------------------------------------------------------
// Purpose: forces any changed options dialog settings to be applied immediately, if it's open
//-----------------------------------------------------------------------------
void CBasePanel::ApplyOptionsDialogSettings()
{
if (m_hOptionsDialog.Get())
{
m_hOptionsDialog->ApplyChanges();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenControllerDialog()
{
if ( !m_hControllerDialog.Get() )
{
m_hControllerDialog = new CControllerDialog( this );
PositionDialog( m_hControllerDialog );
}
m_hControllerDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenBenchmarkDialog()
{
if (!m_hBenchmarkDialog.Get())
{
m_hBenchmarkDialog = new CBenchmarkDialog(this, "BenchmarkDialog");
PositionDialog( m_hBenchmarkDialog );
}
m_hBenchmarkDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenServerBrowser()
{
g_VModuleLoader.ActivateModule("Servers");
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenFriendsDialog()
{
g_VModuleLoader.ActivateModule("Friends");
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenDemoDialog()
{
/* if ( !m_hDemoPlayerDialog.Get() )
{
m_hDemoPlayerDialog = new CDemoPlayerDialog(this);
PositionDialog( m_hDemoPlayerDialog );
}
m_hDemoPlayerDialog->Activate();*/
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenCreateMultiplayerGameDialog()
{
if (!m_hCreateMultiplayerGameDialog.Get())
{
m_hCreateMultiplayerGameDialog = new CCreateMultiplayerGameDialog(this);
PositionDialog(m_hCreateMultiplayerGameDialog);
}
m_hCreateMultiplayerGameDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenChangeGameDialog()
{
#ifdef POSIX
// Alfred says this is old legacy code that allowed you to walk through looking for
// gameinfos and switch and it's not needed anymore. So I'm killing this assert...
#else
if (!m_hChangeGameDialog.Get())
{
m_hChangeGameDialog = new CChangeGameDialog(this);
PositionDialog(m_hChangeGameDialog);
}
m_hChangeGameDialog->Activate();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenPlayerListDialog()
{
if (!m_hPlayerListDialog.Get())
{
m_hPlayerListDialog = new CPlayerListDialog(this);
PositionDialog(m_hPlayerListDialog);
}
m_hPlayerListDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenLoadCommentaryDialog()
{
if (!m_hPlayerListDialog.Get())
{
m_hLoadCommentaryDialog = new CLoadCommentaryDialog(this);
PositionDialog(m_hLoadCommentaryDialog);
}
m_hLoadCommentaryDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OpenLoadSingleplayerCommentaryDialog()
{
if ( !m_hNewGameDialog.Get() )
{
m_hNewGameDialog = new CNewGameDialog(this,true);
PositionDialog( m_hNewGameDialog );
}
((CNewGameDialog *)m_hNewGameDialog.Get())->SetCommentaryMode( true );
m_hNewGameDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenAchievementsDialog()
{
if (!m_hAchievementsDialog.Get())
{
m_hAchievementsDialog = new CAchievementsDialog( this );
PositionDialog(m_hAchievementsDialog);
}
m_hAchievementsDialog->Activate();
}
//=============================================================================
// HPE_BEGIN:
// [dwenger] Use cs-specific achievements dialog
//=============================================================================
void CBasePanel::OnOpenCSAchievementsDialog()
{
if ( GameClientExports() )
{
int screenWide = 0;
int screenHeight = 0;
engine->GetScreenSize( screenWide, screenHeight );
// [smessick] For lower resolutions, open the Steam achievements instead of the CSS achievements screen.
if ( screenWide < GameClientExports()->GetAchievementsPanelMinWidth() )
{
ISteamFriends *friends = steamapicontext->SteamFriends();
if ( friends )
{
friends->ActivateGameOverlay( "Achievements" );
}
}
else
{
// Display the CSS achievements screen.
GameClientExports()->CreateAchievementsPanel( this );
GameClientExports()->DisplayAchievementPanel();
}
}
}
//=============================================================================
// HPE_END
//=============================================================================
void CBasePanel::OnOpenAchievementsDialog_Xbox()
{
if (!m_hAchievementsDialog.Get())
{
m_hAchievementsDialog = new CAchievementsDialog_XBox( this );
PositionDialog(m_hAchievementsDialog);
}
m_hAchievementsDialog->Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnOpenMatchmakingBasePanel()
{
if (!m_hMatchmakingBasePanel.Get())
{
m_hMatchmakingBasePanel = new CMatchmakingBasePanel( this );
int x, y, wide, tall;
GetBounds( x, y, wide, tall );
m_hMatchmakingBasePanel->SetBounds( x, y, wide, tall );
}
if ( m_pGameLogo )
{
m_pGameLogo->SetVisible( false );
}
// Hide the standard game menu
for ( int i = 0; i < m_pGameMenuButtons.Count(); ++i )
{
m_pGameMenuButtons[i]->SetVisible( false );
}
// Hide the BasePanel's button footer
m_pGameMenu->ShowFooter( false );
m_hMatchmakingBasePanel->SetVisible( true );
m_hMatchmakingBasePanel->Activate();
}
//-----------------------------------------------------------------------------
// Purpose: Helper function for this common operation
//-----------------------------------------------------------------------------
CMatchmakingBasePanel *CBasePanel::GetMatchmakingBasePanel()
{
CMatchmakingBasePanel *pBase = NULL;
if ( m_bUseMatchmaking )
{
pBase = dynamic_cast< CMatchmakingBasePanel* >( m_hMatchmakingBasePanel.Get() );
}
return pBase;
}
//-----------------------------------------------------------------------------
// Purpose: moves the game menu button to the right place on the taskbar
//-----------------------------------------------------------------------------
void CBasePanel::PositionDialog(vgui::PHandle dlg)
{
if (!dlg.Get())
return;
int x, y, ww, wt, wide, tall;
vgui::surface()->GetWorkspaceBounds( x, y, ww, wt );
dlg->GetSize(wide, tall);
// Center it, keeping requested size
dlg->SetPos(x + ((ww - wide) / 2), y + ((wt - tall) / 2));
}
//-----------------------------------------------------------------------------
// Purpose: Add an Xbox 360 message dialog to a dialog stack
//-----------------------------------------------------------------------------
void CBasePanel::ShowMessageDialog( const uint nType, vgui::Panel *pOwner )
{
if ( pOwner == NULL )
{
pOwner = this;
}
m_MessageDialogHandler.ShowMessageDialog( nType, pOwner );
}
//-----------------------------------------------------------------------------
// Purpose: Add an Xbox 360 message dialog to a dialog stack
//-----------------------------------------------------------------------------
void CBasePanel::CloseMessageDialog( const uint nType )
{
m_MessageDialogHandler.CloseMessageDialog( nType );
}
//-----------------------------------------------------------------------------
// Purpose: Matchmaking notification from engine
//-----------------------------------------------------------------------------
void CBasePanel::SessionNotification( const int notification, const int param )
{
// This is a job for the matchmaking panel
CMatchmakingBasePanel *pBase = GetMatchmakingBasePanel();
if ( pBase )
{
pBase->SessionNotification( notification, param );
}
}
//-----------------------------------------------------------------------------
// Purpose: System notification from engine
//-----------------------------------------------------------------------------
void CBasePanel::SystemNotification( const int notification )
{
CMatchmakingBasePanel *pBase = GetMatchmakingBasePanel();
if ( pBase )
{
pBase->SystemNotification( notification );
}
if ( notification == SYSTEMNOTIFY_USER_SIGNEDIN )
{
#if defined( _X360 )
// See if it was the active user who signed in
uint state = XUserGetSigninState( XBX_GetPrimaryUserId() );
if ( state != eXUserSigninState_NotSignedIn )
{
// Reset a bunch of state
m_bUserRefusedSignIn = false;
m_bUserRefusedStorageDevice = false;
m_bStorageBladeShown = false;
}
UpdateRichPresenceInfo();
engine->GetAchievementMgr()->DownloadUserData();
engine->GetAchievementMgr()->EnsureGlobalStateLoaded();
#endif
}
else if ( notification == SYSTEMNOTIFY_USER_SIGNEDOUT )
{
#if defined( _X360 )
// See if it was the active user who signed out
uint state = XUserGetSigninState( XBX_GetPrimaryUserId() );
if ( state != eXUserSigninState_NotSignedIn )
{
return;
}
// Invalidate their storage ID
engine->OnStorageDeviceDetached();
m_bUserRefusedStorageDevice = false;
m_bUserRefusedSignIn = false;
m_iStorageID = XBX_INVALID_STORAGE_ID;
engine->GetAchievementMgr()->InitializeAchievements();
m_MessageDialogHandler.CloseAllMessageDialogs();
#endif
if ( GameUI().IsInLevel() )
{
if ( m_pGameLogo )
{
m_pGameLogo->SetVisible( false );
}
// Hide the standard game menu
for ( int i = 0; i < m_pGameMenuButtons.Count(); ++i )
{
m_pGameMenuButtons[i]->SetVisible( false );
}
// Hide the BasePanel's button footer
m_pGameMenu->ShowFooter( false );
QueueCommand( "QuitNoConfirm" );
}
else
{
CloseBaseDialogs();
}
OnCommand( "OpenMainMenu" );
}
else if ( notification == SYSTEMNOTIFY_STORAGEDEVICES_CHANGED )
{
if ( m_hSaveGameDialog_Xbox.Get() )
m_hSaveGameDialog_Xbox->OnCommand( "RefreshSaveGames" );
if ( m_hLoadGameDialog_Xbox.Get() )
m_hLoadGameDialog_Xbox->OnCommand( "RefreshSaveGames" );
// FIXME: This code is incorrect, they do NOT need a storage device, it is only recommended that they do
if ( GameUI().IsInLevel() )
{
// They wanted to use a storage device and are already playing!
// They need a storage device now or we're quitting the game!
m_bNeedStorageDeviceHandle = true;
ShowMessageDialog( MD_STORAGE_DEVICES_NEEDED, this );
}
else
{
ShowMessageDialog( MD_STORAGE_DEVICES_CHANGED, this );
}
}
else if ( notification == SYSTEMNOTIFY_XUIOPENING )
{
m_bXUIVisible = true;
}
else if ( notification == SYSTEMNOTIFY_XUICLOSED )
{
m_bXUIVisible = false;
if ( m_bWaitingForStorageDeviceHandle )
{
DWORD ret = xboxsystem->GetOverlappedResult( m_hStorageDeviceChangeHandle, NULL, true );
if ( ret != ERROR_IO_INCOMPLETE )
{
// Done waiting
xboxsystem->ReleaseAsyncHandle( m_hStorageDeviceChangeHandle );
m_bWaitingForStorageDeviceHandle = false;
// If we selected something, validate it
if ( m_iStorageID != XBX_INVALID_STORAGE_ID )
{
// Check to see if there is enough room on this storage device
if ( xboxsystem->DeviceCapacityAdequate( m_iStorageID, COM_GetModDirectory() ) == false )
{
ShowMessageDialog( MD_STORAGE_DEVICES_TOO_FULL, this );
m_bStorageBladeShown = false; // Show the blade again next time
m_strPostPromptCommand = ""; // Clear the buffer, we can't return
}
else
{
m_bNeedStorageDeviceHandle = false;
// Set the storage device
XBX_SetStorageDeviceId( m_iStorageID );
OnDeviceAttached();
}
}
else
{
if ( m_pStorageDeviceValidatedNotify )
{
*m_pStorageDeviceValidatedNotify = 2;
m_pStorageDeviceValidatedNotify = NULL;
}
else if ( m_bNeedStorageDeviceHandle )
{
// They didn't select a storage device!
// Remind them that they must pick one or the game will shut down
ShowMessageDialog( MD_STORAGE_DEVICES_NEEDED, this );
}
else
{
// Start off the command we queued up
IssuePostPromptCommand();
}
}
}
}
// If we're waiting for the user to sign in, and check if they selected a usable profile
if ( m_bWaitingForUserSignIn )
{
// Done waiting
m_bWaitingForUserSignIn = false;
m_bUserRefusedSignIn = false;
// The UI has closed, so go off and revalidate the state
if ( m_strPostPromptCommand.IsEmpty() == false )
{
// Run the command again
OnCommand( m_strPostPromptCommand );
}
}
RunQueuedCommands();
}
else if ( notification == SYSTEMNOTIFY_INVITE_SHUTDOWN )
{
// Quit the current game without confirmation
m_bRestartFromInvite = true;
m_bXUIVisible = true;
OnCommand( "QuitNoConfirm" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Matchmaking notification that a player's info has changed
//-----------------------------------------------------------------------------
void CBasePanel::UpdatePlayerInfo( uint64 nPlayerId, const char *pName, int nTeam, byte cVoiceState, int nPlayersNeeded, bool bHost )
{
CMatchmakingBasePanel *pBase = GetMatchmakingBasePanel();
if ( pBase )
{
pBase->UpdatePlayerInfo( nPlayerId, pName, nTeam, cVoiceState, nPlayersNeeded, bHost );
}
}
//-----------------------------------------------------------------------------
// Purpose: Matchmaking notification to add a session to the browser
//-----------------------------------------------------------------------------
void CBasePanel::SessionSearchResult( int searchIdx, void *pHostData, XSESSION_SEARCHRESULT *pResult, int ping )
{
CMatchmakingBasePanel *pBase = GetMatchmakingBasePanel();
if ( pBase )
{
pBase->SessionSearchResult( searchIdx, pHostData, pResult, ping );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnChangeStorageDevice( void )
{
if ( m_bWaitingForStorageDeviceHandle == false )
{
m_bWaitingForStorageDeviceHandle = true;
m_hStorageDeviceChangeHandle = xboxsystem->CreateAsyncHandle();
m_iStorageID = XBX_INVALID_STORAGE_ID;
xboxsystem->ShowDeviceSelector( true, &m_iStorageID, &m_hStorageDeviceChangeHandle );
}
}
void CBasePanel::OnCreditsFinished( void )
{
if ( !IsX360() )
{
// valid for 360 only
Assert( 0 );
return;
}
bool bExitToAppChooser = false;
if ( bExitToAppChooser )
{
// unknown state from engine, force to a compliant exiting state
// causes an complete exit out of the game back to the app launcher
SetVisible( true );
m_pGameMenu->SetAlpha( 0 );
StartExitingProcess();
}
else
{
// expecting to transition from the credits back to the background map
// prevent any possibility of using the last transition image
m_bUseRenderTargetImage = false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::OnGameUIHidden()
{
if ( m_hOptionsDialog.Get() )
{
PostMessage( m_hOptionsDialog.Get(), new KeyValues( "GameUIHidden" ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the alpha of the menu panels
//-----------------------------------------------------------------------------
void CBasePanel::SetMenuAlpha(int alpha)
{
if ( GameUI().IsConsoleUI() )
{
// handled by animation, not code
return;
}
m_pGameMenu->SetAlpha(alpha);
if ( m_pGameLogo )
{
m_pGameLogo->SetAlpha( alpha );
}
for ( int i=0; i<m_pGameMenuButtons.Count(); ++i )
{
m_pGameMenuButtons[i]->SetAlpha(alpha);
}
m_bForceTitleTextUpdate = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBasePanel::GetMenuAlpha( void )
{
return m_pGameMenu->GetAlpha();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::SetMainMenuOverride( vgui::VPANEL panel )
{
m_hMainMenuOverridePanel = panel;
if ( m_pGameMenu )
{
m_pGameMenu->SetMainMenuOverride( panel );
}
if ( m_hMainMenuOverridePanel )
{
// Parent it to this panel
ipanel()->SetParent( m_hMainMenuOverridePanel, GetVPanel() );
}
}
//-----------------------------------------------------------------------------
// Purpose: starts the game
//-----------------------------------------------------------------------------
void CBasePanel::FadeToBlackAndRunEngineCommand( const char *engineCommand )
{
KeyValues *pKV = new KeyValues( "RunEngineCommand", "command", engineCommand );
// execute immediately, with no delay
PostMessage( this, pKV, 0 );
}
void CBasePanel::SetMenuItemBlinkingState( const char *itemName, bool state )
{
for (int i = 0; i < GetChildCount(); i++)
{
Panel *child = GetChild(i);
CGameMenu *pGameMenu = dynamic_cast<CGameMenu *>(child);
if ( pGameMenu )
{
pGameMenu->SetMenuItemBlinkingState( itemName, state );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: runs an engine command, used for delays
//-----------------------------------------------------------------------------
void CBasePanel::RunEngineCommand(const char *command)
{
engine->ClientCmd_Unrestricted(command);
}
//-----------------------------------------------------------------------------
// Purpose: runs an animation to close a dialog and cleans up after close
//-----------------------------------------------------------------------------
void CBasePanel::RunCloseAnimation( const char *animName )
{
RunAnimationWithCallback( this, animName, new KeyValues( "FinishDialogClose" ) );
}
//-----------------------------------------------------------------------------
// Purpose: cleans up after a menu closes
//-----------------------------------------------------------------------------
void CBasePanel::FinishDialogClose( void )
{
}
//-----------------------------------------------------------------------------
// Purpose: xbox UI panel that displays button icons and help text for all menus
//-----------------------------------------------------------------------------
CFooterPanel::CFooterPanel( Panel *parent, const char *panelName ) : BaseClass( parent, panelName )
{
SetVisible( true );
SetAlpha( 0 );
m_pHelpName = NULL;
m_pSizingLabel = new vgui::Label( this, "SizingLabel", "" );
m_pSizingLabel->SetVisible( false );
m_nButtonGap = 32;
m_nButtonGapDefault = 32;
m_ButtonPinRight = 100;
m_FooterTall = 80;
int wide, tall;
surface()->GetScreenSize(wide, tall);
if ( tall <= 480 )
{
m_FooterTall = 60;
}
m_ButtonOffsetFromTop = 0;
m_ButtonSeparator = 4;
m_TextAdjust = 0;
m_bPaintBackground = false;
m_bCenterHorizontal = false;
m_szButtonFont[0] = '\0';
m_szTextFont[0] = '\0';
m_szFGColor[0] = '\0';
m_szBGColor[0] = '\0';
}
CFooterPanel::~CFooterPanel()
{
SetHelpNameAndReset( NULL );
delete m_pSizingLabel;
}
//-----------------------------------------------------------------------------
// Purpose: apply scheme settings
//-----------------------------------------------------------------------------
void CFooterPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
m_hButtonFont = pScheme->GetFont( ( m_szButtonFont[0] != '\0' ) ? m_szButtonFont : "GameUIButtons" );
m_hTextFont = pScheme->GetFont( ( m_szTextFont[0] != '\0' ) ? m_szTextFont : "MenuLarge" );
SetFgColor( pScheme->GetColor( m_szFGColor, Color( 255, 255, 255, 255 ) ) );
SetBgColor( pScheme->GetColor( m_szBGColor, Color( 0, 0, 0, 255 ) ) );
int x, y, w, h;
GetParent()->GetBounds( x, y, w, h );
SetBounds( x, h - m_FooterTall, w, m_FooterTall );
}
//-----------------------------------------------------------------------------
// Purpose: apply settings
//-----------------------------------------------------------------------------
void CFooterPanel::ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
// gap between hints
m_nButtonGap = inResourceData->GetInt( "buttongap", 32 );
m_nButtonGapDefault = m_nButtonGap;
m_ButtonPinRight = inResourceData->GetInt( "button_pin_right", 100 );
m_FooterTall = inResourceData->GetInt( "tall", 80 );
m_ButtonOffsetFromTop = inResourceData->GetInt( "buttonoffsety", 0 );
m_ButtonSeparator = inResourceData->GetInt( "button_separator", 4 );
m_TextAdjust = inResourceData->GetInt( "textadjust", 0 );
m_bCenterHorizontal = ( inResourceData->GetInt( "center", 0 ) == 1 );
m_bPaintBackground = ( inResourceData->GetInt( "paintbackground", 0 ) == 1 );
// fonts for text and button
Q_strncpy( m_szTextFont, inResourceData->GetString( "fonttext", "MenuLarge" ), sizeof( m_szTextFont ) );
Q_strncpy( m_szButtonFont, inResourceData->GetString( "fontbutton", "GameUIButtons" ), sizeof( m_szButtonFont ) );
// fg and bg colors
Q_strncpy( m_szFGColor, inResourceData->GetString( "fgcolor", "White" ), sizeof( m_szFGColor ) );
Q_strncpy( m_szBGColor, inResourceData->GetString( "bgcolor", "Black" ), sizeof( m_szBGColor ) );
for ( KeyValues *pButton = inResourceData->GetFirstSubKey(); pButton != NULL; pButton = pButton->GetNextKey() )
{
const char *pName = pButton->GetName();
if ( !Q_stricmp( pName, "button" ) )
{
// Add a button to the footer
const char *pText = pButton->GetString( "text", "NULL" );
const char *pIcon = pButton->GetString( "icon", "NULL" );
AddNewButtonLabel( pText, pIcon );
}
}
InvalidateLayout( false, true ); // force ApplySchemeSettings to run
}
//-----------------------------------------------------------------------------
// Purpose: adds button icons and help text to the footer panel when activating a menu
//-----------------------------------------------------------------------------
void CFooterPanel::AddButtonsFromMap( vgui::Frame *pMenu )
{
SetHelpNameAndReset( pMenu->GetName() );
CControllerMap *pMap = dynamic_cast<CControllerMap*>( pMenu->FindChildByName( "ControllerMap" ) );
if ( pMap )
{
int buttonCt = pMap->NumButtons();
for ( int i = 0; i < buttonCt; ++i )
{
const char *pText = pMap->GetBindingText( i );
if ( pText )
{
AddNewButtonLabel( pText, pMap->GetBindingIcon( i ) );
}
}
}
}
void CFooterPanel::SetStandardDialogButtons()
{
SetHelpNameAndReset( "Dialog" );
AddNewButtonLabel( "#GameUI_Action", "#GameUI_Icons_A_BUTTON" );
AddNewButtonLabel( "#GameUI_Close", "#GameUI_Icons_B_BUTTON" );
}
//-----------------------------------------------------------------------------
// Purpose: Caller must tag the button layout. May support reserved names
// to provide stock help layouts trivially.
//-----------------------------------------------------------------------------
void CFooterPanel::SetHelpNameAndReset( const char *pName )
{
if ( m_pHelpName )
{
free( m_pHelpName );
m_pHelpName = NULL;
}
if ( pName )
{
m_pHelpName = strdup( pName );
}
ClearButtons();
}
//-----------------------------------------------------------------------------
// Purpose: Caller must tag the button layout
//-----------------------------------------------------------------------------
const char *CFooterPanel::GetHelpName()
{
return m_pHelpName;
}
void CFooterPanel::ClearButtons( void )
{
m_ButtonLabels.PurgeAndDeleteElements();
}
//-----------------------------------------------------------------------------
// Purpose: creates a new button label with icon and text
//-----------------------------------------------------------------------------
void CFooterPanel::AddNewButtonLabel( const char *text, const char *icon )
{
ButtonLabel_t *button = new ButtonLabel_t;
Q_strncpy( button->name, text, MAX_PATH );
button->bVisible = true;
// Button icons are a single character
wchar_t *pIcon = g_pVGuiLocalize->Find( icon );
if ( pIcon )
{
button->icon[0] = pIcon[0];
button->icon[1] = '\0';
}
else
{
button->icon[0] = '\0';
}
// Set the help text
wchar_t *pText = g_pVGuiLocalize->Find( text );
if ( pText )
{
wcsncpy( button->text, pText, wcslen( pText ) + 1 );
}
else
{
button->text[0] = '\0';
}
m_ButtonLabels.AddToTail( button );
}
//-----------------------------------------------------------------------------
// Purpose: Shows/Hides a button label
//-----------------------------------------------------------------------------
void CFooterPanel::ShowButtonLabel( const char *name, bool show )
{
for ( int i = 0; i < m_ButtonLabels.Count(); ++i )
{
if ( !Q_stricmp( m_ButtonLabels[ i ]->name, name ) )
{
m_ButtonLabels[ i ]->bVisible = show;
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Changes a button's text
//-----------------------------------------------------------------------------
void CFooterPanel::SetButtonText( const char *buttonName, const char *text )
{
for ( int i = 0; i < m_ButtonLabels.Count(); ++i )
{
if ( !Q_stricmp( m_ButtonLabels[ i ]->name, buttonName ) )
{
wchar_t *wtext = g_pVGuiLocalize->Find( text );
if ( text )
{
wcsncpy( m_ButtonLabels[ i ]->text, wtext, wcslen( wtext ) + 1 );
}
else
{
m_ButtonLabels[ i ]->text[ 0 ] = '\0';
}
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Footer panel background rendering
//-----------------------------------------------------------------------------
void CFooterPanel::PaintBackground( void )
{
if ( !m_bPaintBackground )
return;
BaseClass::PaintBackground();
}
//-----------------------------------------------------------------------------
// Purpose: Footer panel rendering
//-----------------------------------------------------------------------------
void CFooterPanel::Paint( void )
{
// inset from right edge
int wide = GetWide();
int right = wide - m_ButtonPinRight;
// center the text within the button
int buttonHeight = vgui::surface()->GetFontTall( m_hButtonFont );
int fontHeight = vgui::surface()->GetFontTall( m_hTextFont );
int textY = ( buttonHeight - fontHeight )/2 + m_TextAdjust;
if ( textY < 0 )
{
textY = 0;
}
int y = m_ButtonOffsetFromTop;
if ( !m_bCenterHorizontal )
{
// draw the buttons, right to left
int x = right;
for ( int i = 0; i < m_ButtonLabels.Count(); ++i )
{
ButtonLabel_t *pButton = m_ButtonLabels[i];
if ( !pButton->bVisible )
continue;
// Get the string length
m_pSizingLabel->SetFont( m_hTextFont );
m_pSizingLabel->SetText( pButton->text );
m_pSizingLabel->SizeToContents();
int iTextWidth = m_pSizingLabel->GetWide();
if ( iTextWidth == 0 )
x += m_nButtonGap; // There's no text, so remove the gap between buttons
else
x -= iTextWidth;
// Draw the string
vgui::surface()->DrawSetTextFont( m_hTextFont );
vgui::surface()->DrawSetTextColor( GetFgColor() );
vgui::surface()->DrawSetTextPos( x, y + textY );
vgui::surface()->DrawPrintText( pButton->text, wcslen( pButton->text ) );
// Draw the button
// back up button width and a little extra to leave a gap between button and text
x -= ( vgui::surface()->GetCharacterWidth( m_hButtonFont, pButton->icon[0] ) + m_ButtonSeparator );
vgui::surface()->DrawSetTextFont( m_hButtonFont );
vgui::surface()->DrawSetTextColor( 255, 255, 255, 255 );
vgui::surface()->DrawSetTextPos( x, y );
vgui::surface()->DrawPrintText( pButton->icon, 1 );
// back up to next string
x -= m_nButtonGap;
}
}
else
{
// center the buttons (as a group)
int x = wide / 2;
int totalWidth = 0;
int i = 0;
int nButtonCount = 0;
// need to loop through and figure out how wide our buttons and text are (with gaps between) so we can offset from the center
for ( i = 0; i < m_ButtonLabels.Count(); ++i )
{
ButtonLabel_t *pButton = m_ButtonLabels[i];
if ( !pButton->bVisible )
continue;
// Get the string length
m_pSizingLabel->SetFont( m_hTextFont );
m_pSizingLabel->SetText( pButton->text );
m_pSizingLabel->SizeToContents();
totalWidth += vgui::surface()->GetCharacterWidth( m_hButtonFont, pButton->icon[0] );
totalWidth += m_ButtonSeparator;
totalWidth += m_pSizingLabel->GetWide();
nButtonCount++; // keep track of how many active buttons we'll be drawing
}
totalWidth += ( nButtonCount - 1 ) * m_nButtonGap; // add in the gaps between the buttons
x -= ( totalWidth / 2 );
for ( i = 0; i < m_ButtonLabels.Count(); ++i )
{
ButtonLabel_t *pButton = m_ButtonLabels[i];
if ( !pButton->bVisible )
continue;
// Get the string length
m_pSizingLabel->SetFont( m_hTextFont );
m_pSizingLabel->SetText( pButton->text );
m_pSizingLabel->SizeToContents();
int iTextWidth = m_pSizingLabel->GetWide();
// Draw the icon
vgui::surface()->DrawSetTextFont( m_hButtonFont );
vgui::surface()->DrawSetTextColor( 255, 255, 255, 255 );
vgui::surface()->DrawSetTextPos( x, y );
vgui::surface()->DrawPrintText( pButton->icon, 1 );
x += vgui::surface()->GetCharacterWidth( m_hButtonFont, pButton->icon[0] ) + m_ButtonSeparator;
// Draw the string
vgui::surface()->DrawSetTextFont( m_hTextFont );
vgui::surface()->DrawSetTextColor( GetFgColor() );
vgui::surface()->DrawSetTextPos( x, y + textY );
vgui::surface()->DrawPrintText( pButton->text, wcslen( pButton->text ) );
x += iTextWidth + m_nButtonGap;
}
}
}
DECLARE_BUILD_FACTORY( CFooterPanel );
#ifdef _X360
//-----------------------------------------------------------------------------
// Purpose: Reload the resource files on the Xbox 360
//-----------------------------------------------------------------------------
void CBasePanel::Reload_Resources( const CCommand &args )
{
m_pConsoleControlSettings->Clear();
if ( m_pConsoleControlSettings->LoadFromFile( g_pFullFileSystem, "resource/UI/XboxDialogs.res" ) )
{
m_pConsoleControlSettings->ProcessResolutionKeys( surface()->GetResolutionKey() );
}
}
#endif
// X360TBD: Move into a separate module when completed
CMessageDialogHandler::CMessageDialogHandler()
{
m_iDialogStackTop = -1;
}
void CMessageDialogHandler::ShowMessageDialog( int nType, vgui::Panel *pOwner )
{
int iSimpleFrame = 0;
if ( ModInfo().IsSinglePlayerOnly() )
{
iSimpleFrame = MD_SIMPLEFRAME;
}
switch( nType )
{
case MD_SEARCHING_FOR_GAMES:
CreateMessageDialog( MD_CANCEL|MD_RESTRICTPAINT,
NULL,
"#TF_Dlg_SearchingForGames",
NULL,
"CancelOperation",
pOwner,
true );
break;
case MD_CREATING_GAME:
CreateMessageDialog( MD_RESTRICTPAINT,
NULL,
"#TF_Dlg_CreatingGame",
NULL,
NULL,
pOwner,
true );
break;
case MD_SESSION_SEARCH_FAILED:
CreateMessageDialog( MD_YESNO|MD_RESTRICTPAINT,
NULL,
"#TF_Dlg_NoGamesFound",
"ShowSessionOptionsDialog",
"ReturnToMainMenu",
pOwner );
break;
case MD_SESSION_CREATE_FAILED:
CreateMessageDialog( MD_OK,
NULL,
"#TF_Dlg_CreateFailed",
"ReturnToMainMenu",
NULL,
pOwner );
break;
case MD_SESSION_CONNECTING:
CreateMessageDialog( 0,
NULL,
"#TF_Dlg_Connecting",
NULL,
NULL,
pOwner,
true );
break;
case MD_SESSION_CONNECT_NOTAVAILABLE:
CreateMessageDialog( MD_OK,
NULL,
"#TF_Dlg_JoinRefused",
"ReturnToMainMenu",
NULL,
pOwner );
break;
case MD_SESSION_CONNECT_SESSIONFULL:
CreateMessageDialog( MD_OK,
NULL,
"#TF_Dlg_GameFull",
"ReturnToMainMenu",
NULL,
pOwner );
break;
case MD_SESSION_CONNECT_FAILED:
CreateMessageDialog( MD_OK,
NULL,
"#TF_Dlg_JoinFailed",
"ReturnToMainMenu",
NULL,
pOwner );
break;
case MD_LOST_HOST:
CreateMessageDialog( MD_OK|MD_RESTRICTPAINT,
NULL,
"#TF_Dlg_LostHost",
"ReturnToMainMenu",
NULL,
pOwner );
break;
case MD_LOST_SERVER:
CreateMessageDialog( MD_OK|MD_RESTRICTPAINT,
NULL,
"#TF_Dlg_LostServer",
"ReturnToMainMenu",
NULL,
pOwner );
break;
case MD_MODIFYING_SESSION:
CreateMessageDialog( MD_RESTRICTPAINT,
NULL,
"#TF_Dlg_ModifyingSession",
NULL,
NULL,
pOwner,
true );
break;
case MD_SAVE_BEFORE_QUIT:
CreateMessageDialog( MD_YESNO|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_QuitConfirmationTitle",
"#GameUI_Console_QuitWarning",
"QuitNoConfirm",
"CloseQuitDialog_OpenMainMenu",
pOwner );
break;
case MD_QUIT_CONFIRMATION:
CreateMessageDialog( MD_YESNO|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_QuitConfirmationTitle",
"#GameUI_QuitConfirmationText",
"QuitNoConfirm",
"CloseQuitDialog_OpenMainMenu",
pOwner );
break;
case MD_QUIT_CONFIRMATION_TF:
CreateMessageDialog( MD_YESNO|MD_RESTRICTPAINT,
"#GameUI_QuitConfirmationTitle",
"#GameUI_QuitConfirmationText",
"QuitNoConfirm",
"CloseQuitDialog_OpenMatchmakingMenu",
pOwner );
break;
case MD_DISCONNECT_CONFIRMATION:
CreateMessageDialog( MD_YESNO|MD_RESTRICTPAINT,
"",
"#GameUI_DisconnectConfirmationText",
"DisconnectNoConfirm",
"close_dialog",
pOwner );
break;
case MD_DISCONNECT_CONFIRMATION_HOST:
CreateMessageDialog( MD_YESNO|MD_RESTRICTPAINT,
"",
"#GameUI_DisconnectHostConfirmationText",
"DisconnectNoConfirm",
"close_dialog",
pOwner );
break;
case MD_KICK_CONFIRMATION:
CreateMessageDialog( MD_YESNO,
"",
"#TF_Dlg_ConfirmKick",
"KickPlayer",
"close_dialog",
pOwner );
break;
case MD_CLIENT_KICKED:
CreateMessageDialog( MD_OK|MD_RESTRICTPAINT,
"",
"#TF_Dlg_ClientKicked",
"close_dialog",
NULL,
pOwner );
break;
case MD_EXIT_SESSION_CONFIRMATION:
CreateMessageDialog( MD_YESNO,
"",
"#TF_Dlg_ExitSessionText",
"ReturnToMainMenu",
"close_dialog",
pOwner );
break;
case MD_STORAGE_DEVICES_NEEDED:
CreateMessageDialog( MD_YESNO|MD_WARNING|MD_COMMANDAFTERCLOSE|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_Console_StorageRemovedTitle",
"#GameUI_Console_StorageNeededBody",
"ShowDeviceSelector",
"QuitNoConfirm",
pOwner );
break;
case MD_STORAGE_DEVICES_CHANGED:
CreateMessageDialog( MD_YESNO|MD_WARNING|MD_COMMANDAFTERCLOSE|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_Console_StorageRemovedTitle",
"#GameUI_Console_StorageRemovedBody",
"ShowDeviceSelector",
"clear_storage_deviceID",
pOwner );
break;
case MD_STORAGE_DEVICES_TOO_FULL:
CreateMessageDialog( MD_YESNO|MD_WARNING|MD_COMMANDAFTERCLOSE|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_Console_StorageTooFullTitle",
"#GameUI_Console_StorageTooFullBody",
"ShowDeviceSelector",
"StorageDeviceDenied",
pOwner );
break;
case MD_PROMPT_STORAGE_DEVICE:
CreateMessageDialog( MD_YESNO|MD_WARNING|MD_COMMANDAFTERCLOSE|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_Console_NoStorageDeviceSelectedTitle",
"#GameUI_Console_NoStorageDeviceSelectedBody",
"ShowDeviceSelector",
"StorageDeviceDenied",
pOwner );
break;
case MD_PROMPT_STORAGE_DEVICE_REQUIRED:
CreateMessageDialog( MD_YESNO|MD_WARNING|MD_COMMANDAFTERCLOSE|MD_SIMPLEFRAME,
"#GameUI_Console_NoStorageDeviceSelectedTitle",
"#GameUI_Console_StorageDeviceRequiredBody",
"ShowDeviceSelector",
"RequiredStorageDenied",
pOwner );
break;
case MD_PROMPT_SIGNIN:
CreateMessageDialog( MD_YESNO|MD_WARNING|MD_COMMANDAFTERCLOSE|iSimpleFrame,
"#GameUI_Console_NoUserProfileSelectedTitle",
"#GameUI_Console_NoUserProfileSelectedBody",
"ShowSignInUI",
"SignInDenied",
pOwner );
break;
case MD_PROMPT_SIGNIN_REQUIRED:
CreateMessageDialog( MD_YESNO|MD_WARNING|MD_COMMANDAFTERCLOSE|iSimpleFrame,
"#GameUI_Console_NoUserProfileSelectedTitle",
"#GameUI_Console_UserProfileRequiredBody",
"ShowSignInUI",
"RequiredSignInDenied",
pOwner );
break;
case MD_NOT_ONLINE_ENABLED:
CreateMessageDialog( MD_YESNO|MD_WARNING,
"",
"#TF_Dlg_NotOnlineEnabled",
"ShowSigninUI",
"close_dialog",
pOwner );
break;
case MD_NOT_ONLINE_SIGNEDIN:
CreateMessageDialog( MD_YESNO|MD_WARNING,
"",
"#TF_Dlg_NotOnlineSignedIn",
"ShowSigninUI",
"close_dialog",
pOwner );
break;
case MD_DEFAULT_CONTROLS_CONFIRM:
CreateMessageDialog( MD_YESNO|MD_WARNING|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_RestoreDefaults",
"#GameUI_ControllerSettingsText",
"DefaultControls",
"close_dialog",
pOwner );
break;
case MD_AUTOSAVE_EXPLANATION:
CreateMessageDialog( MD_OK|MD_WARNING|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_ConfirmNewGame_Title",
"#GameUI_AutoSave_Console_Explanation",
"StartNewGameNoCommentaryExplanation",
NULL,
pOwner );
break;
case MD_COMMENTARY_EXPLANATION:
CreateMessageDialog( MD_OK|MD_WARNING|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_CommentaryDialogTitle",
"#GAMEUI_Commentary_Console_Explanation",
"StartNewGameNoCommentaryExplanation",
NULL,
pOwner );
break;
case MD_COMMENTARY_EXPLANATION_MULTI:
CreateMessageDialog( MD_OK|MD_WARNING,
"#GameUI_CommentaryDialogTitle",
"#GAMEUI_Commentary_Console_Explanation",
"StartNewGameNoCommentaryExplanation",
NULL,
pOwner );
break;
case MD_COMMENTARY_CHAPTER_UNLOCK_EXPLANATION:
CreateMessageDialog( MD_OK|MD_WARNING|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_CommentaryDialogTitle",
"#GameUI_CommentaryUnlock",
"close_dialog",
NULL,
pOwner );
break;
case MD_SAVE_BEFORE_LANGUAGE_CHANGE:
CreateMessageDialog( MD_YESNO|MD_WARNING|MD_SIMPLEFRAME|MD_COMMANDAFTERCLOSE|MD_RESTRICTPAINT,
"#GameUI_ChangeLanguageRestart_Title",
"#GameUI_ChangeLanguageRestart_Info",
"AcceptVocalsLanguageChange",
"CancelVocalsLanguageChange",
pOwner );
case MD_SAVE_BEFORE_NEW_GAME:
CreateMessageDialog( MD_OKCANCEL|MD_WARNING|iSimpleFrame|MD_COMMANDAFTERCLOSE|MD_RESTRICTPAINT,
"#GameUI_ConfirmNewGame_Title",
"#GameUI_NewGameWarning",
"StartNewGame",
"close_dialog",
pOwner );
break;
case MD_SAVE_BEFORE_LOAD:
CreateMessageDialog( MD_OKCANCEL|MD_WARNING|iSimpleFrame|MD_COMMANDAFTERCLOSE|MD_RESTRICTPAINT,
"#GameUI_ConfirmLoadGame_Title",
"#GameUI_LoadWarning",
"LoadGame",
"LoadGameCancelled",
pOwner );
break;
case MD_DELETE_SAVE_CONFIRM:
CreateMessageDialog( MD_OKCANCEL|MD_WARNING|iSimpleFrame|MD_COMMANDAFTERCLOSE,
"#GameUI_ConfirmDeleteSaveGame_Title",
"#GameUI_ConfirmDeleteSaveGame_Info",
"DeleteGame",
"DeleteGameCancelled",
pOwner );
break;
case MD_SAVE_OVERWRITE:
CreateMessageDialog( MD_OKCANCEL|MD_WARNING|iSimpleFrame|MD_COMMANDAFTERCLOSE,
"#GameUI_ConfirmOverwriteSaveGame_Title",
"#GameUI_ConfirmOverwriteSaveGame_Info",
"SaveGame",
"OverwriteGameCancelled",
pOwner );
break;
case MD_SAVING_WARNING:
CreateMessageDialog( MD_WARNING|iSimpleFrame|MD_COMMANDONFORCECLOSE,
"",
"#GameUI_SavingWarning",
"SaveSuccess",
NULL,
pOwner,
true);
break;
case MD_SAVE_COMPLETE:
CreateMessageDialog( MD_OK|iSimpleFrame|MD_COMMANDAFTERCLOSE,
"#GameUI_ConfirmOverwriteSaveGame_Title",
"#GameUI_GameSaved",
"CloseAndSelectResume",
NULL,
pOwner );
break;
case MD_LOAD_FAILED_WARNING:
CreateMessageDialog( MD_OK |MD_WARNING|iSimpleFrame,
"#GameUI_LoadFailed",
"#GameUI_LoadFailed_Description",
"close_dialog",
NULL,
pOwner );
break;
case MD_OPTION_CHANGE_FROM_X360_DASHBOARD:
CreateMessageDialog( MD_OK|iSimpleFrame|MD_RESTRICTPAINT,
"#GameUI_SettingChangeFromX360Dashboard_Title",
"#GameUI_SettingChangeFromX360Dashboard_Info",
"close_dialog",
NULL,
pOwner );
break;
case MD_STANDARD_SAMPLE:
CreateMessageDialog( MD_OK,
"Standard Dialog",
"This is a standard dialog",
"close_dialog",
NULL,
pOwner );
break;
case MD_WARNING_SAMPLE:
CreateMessageDialog( MD_OK | MD_WARNING,
"#GameUI_Dialog_Warning",
"This is a warning dialog",
"close_dialog",
NULL,
pOwner );
break;
case MD_ERROR_SAMPLE:
CreateMessageDialog( MD_OK | MD_ERROR,
"Error Dialog",
"This is an error dialog",
"close_dialog",
NULL,
pOwner );
break;
case MD_STORAGE_DEVICES_CORRUPT:
CreateMessageDialog( MD_OK | MD_WARNING | iSimpleFrame | MD_RESTRICTPAINT,
"",
"#GameUI_Console_FileCorrupt",
"close_dialog",
NULL,
pOwner );
break;
case MD_CHECKING_STORAGE_DEVICE:
CreateMessageDialog( iSimpleFrame | MD_RESTRICTPAINT,
NULL,
"#GameUI_Dlg_CheckingStorageDevice",
NULL,
NULL,
pOwner,
true );
break;
default:
break;
}
}
void CMessageDialogHandler::CloseAllMessageDialogs()
{
for ( int i = 0; i < MAX_MESSAGE_DIALOGS; ++i )
{
CMessageDialog *pDlg = m_hMessageDialogs[i];
if ( pDlg )
{
vgui::surface()->RestrictPaintToSinglePanel(NULL);
if ( vgui_message_dialog_modal.GetBool() )
{
vgui::input()->ReleaseAppModalSurface();
}
pDlg->Close();
m_hMessageDialogs[i] = NULL;
}
}
}
void CMessageDialogHandler::CloseMessageDialog( const uint nType )
{
int nStackIdx = 0;
if ( nType & MD_WARNING )
{
nStackIdx = DIALOG_STACK_IDX_WARNING;
}
else if ( nType & MD_ERROR )
{
nStackIdx = DIALOG_STACK_IDX_ERROR;
}
CMessageDialog *pDlg = m_hMessageDialogs[nStackIdx];
if ( pDlg )
{
vgui::surface()->RestrictPaintToSinglePanel(NULL);
if ( vgui_message_dialog_modal.GetBool() )
{
vgui::input()->ReleaseAppModalSurface();
}
pDlg->Close();
m_hMessageDialogs[nStackIdx] = NULL;
}
}
void CMessageDialogHandler::CreateMessageDialog( const uint nType, const char *pTitle, const char *pMsg, const char *pCmdA, const char *pCmdB, vgui::Panel *pCreator, bool bShowActivity /*= false*/ )
{
int nStackIdx = 0;
if ( nType & MD_WARNING )
{
nStackIdx = DIALOG_STACK_IDX_WARNING;
}
else if ( nType & MD_ERROR )
{
nStackIdx = DIALOG_STACK_IDX_ERROR;
}
// Can only show one dialog of each type at a time
if ( m_hMessageDialogs[nStackIdx].Get() )
{
Warning( "Tried to create two dialogs of type %d\n", nStackIdx );
return;
}
// Show the new dialog
m_hMessageDialogs[nStackIdx] = new CMessageDialog( BasePanel(), nType, pTitle, pMsg, pCmdA, pCmdB, pCreator, bShowActivity );
m_hMessageDialogs[nStackIdx]->SetControlSettingsKeys( BasePanel()->GetConsoleControlSettings()->FindKey( "MessageDialog.res" ) );
if ( nType & MD_RESTRICTPAINT )
{
vgui::surface()->RestrictPaintToSinglePanel( m_hMessageDialogs[nStackIdx]->GetVPanel() );
}
ActivateMessageDialog( nStackIdx );
}
//-----------------------------------------------------------------------------
// Purpose: Activate a new message dialog
//-----------------------------------------------------------------------------
void CMessageDialogHandler::ActivateMessageDialog( int nStackIdx )
{
int x, y, wide, tall;
vgui::surface()->GetWorkspaceBounds( x, y, wide, tall );
PositionDialog( m_hMessageDialogs[nStackIdx], wide, tall );
uint nType = m_hMessageDialogs[nStackIdx]->GetType();
if ( nType & MD_WARNING )
{
m_hMessageDialogs[nStackIdx]->SetZPos( 75 );
}
else if ( nType & MD_ERROR )
{
m_hMessageDialogs[nStackIdx]->SetZPos( 100 );
}
// Make sure the topmost item on the stack still has focus
int idx = MAX_MESSAGE_DIALOGS - 1;
for ( idx; idx >= nStackIdx; --idx )
{
CMessageDialog *pDialog = m_hMessageDialogs[idx];
if ( pDialog )
{
pDialog->Activate();
if ( vgui_message_dialog_modal.GetBool() )
{
vgui::input()->SetAppModalSurface( pDialog->GetVPanel() );
}
m_iDialogStackTop = idx;
break;
}
}
}
void CMessageDialogHandler::PositionDialogs( int wide, int tall )
{
for ( int i = 0; i < MAX_MESSAGE_DIALOGS; ++i )
{
if ( m_hMessageDialogs[i].Get() )
{
PositionDialog( m_hMessageDialogs[i], wide, tall );
}
}
}
void CMessageDialogHandler::PositionDialog( vgui::PHandle dlg, int wide, int tall )
{
int w, t;
dlg->GetSize(w, t);
dlg->SetPos( (wide - w) / 2, (tall - t) / 2 );
}
//-----------------------------------------------------------------------------
// Purpose: Editable panel that can replace the GameMenuButtons in CBasePanel
//-----------------------------------------------------------------------------
CMainMenuGameLogo::CMainMenuGameLogo( vgui::Panel *parent, const char *name ) : vgui::EditablePanel( parent, name )
{
m_nOffsetX = 0;
m_nOffsetY = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMainMenuGameLogo::ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
m_nOffsetX = inResourceData->GetInt( "offsetX", 0 );
m_nOffsetY = inResourceData->GetInt( "offsetY", 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMainMenuGameLogo::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
KeyValues *pConditions = new KeyValues( "conditions" );
if ( pConditions )
{
char background[MAX_PATH];
engine->GetMainMenuBackgroundName( background, sizeof(background) );
KeyValues *pSubKey = new KeyValues( background );
if ( pSubKey )
{
pConditions->AddSubKey( pSubKey );
}
}
LoadControlSettings( "Resource/GameLogo.res", NULL, NULL, pConditions );
if ( pConditions )
{
pConditions->deleteThis();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePanel::CloseBaseDialogs( void )
{
if ( m_hNewGameDialog.Get() )
m_hNewGameDialog->Close();
if ( m_hAchievementsDialog.Get() )
m_hAchievementsDialog->Close();
if ( m_hBonusMapsDialog.Get() )
m_hBonusMapsDialog->Close();
if ( m_hControllerDialog.Get() )
m_hControllerDialog->Close();
if ( m_hLoadGameDialog_Xbox.Get() )
m_hLoadGameDialog_Xbox->Close();
if ( m_hOptionsDialog_Xbox.Get() )
m_hOptionsDialog_Xbox->Close();
if ( m_hSaveGameDialog_Xbox.Get() )
m_hSaveGameDialog_Xbox->Close();
if ( m_hLoadCommentaryDialog.Get() )
m_hLoadCommentaryDialog->Close();
if ( m_hCreateMultiplayerGameDialog.Get() )
m_hCreateMultiplayerGameDialog->Close();
}
static void CC_GameUIShowDialog( const CCommand &args )
{
int c = args.ArgC();
if ( c < 2 )
{
Msg( "Usage: gamemenucommand <commandname>\n" );
return;
}
GameUI().ShowMessageDialog( atoi(args[1]) );
}
static ConCommand gameui_show_dialog( "gameui_show_dialog", CC_GameUIShowDialog, "Show an arbitrary Dialog.", 0 );
static void CC_GameUIHideDialog( const CCommand &args )
{
int c = args.ArgC();
if ( c < 1 )
{
Msg( "Usage: gamemenucommand <commandname>\n" );
return;
}
GameUI().CloseMessageDialog( 0 );
}
static ConCommand gameui_hide_dialog( "gameui_hide_dialog", CC_GameUIHideDialog, "asdf", 0 );
static void RefreshOptionsDialog( const CCommand &args )
{
if ( g_hOptionsDialog )
{
CBasePanel* pBasePanel = (CBasePanel*) g_hOptionsDialog->GetParent();
g_hOptionsDialog->Close();
delete g_hOptionsDialog.Get();
if ( pBasePanel )
{
pBasePanel->OnOpenOptionsDialog();
COptionsDialog *pOptionsDialog = dynamic_cast<COptionsDialog*>( g_hOptionsDialog.Get() );
if ( pOptionsDialog )
{
pOptionsDialog->GetPropertySheet()->SetActivePage( pOptionsDialog->GetOptionsSubMultiplayer() );
}
}
}
}
static ConCommand refresh_options_dialog( "refresh_options_dialog", RefreshOptionsDialog, "Refresh the options dialog.", 0 );