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.
 
 
 
 
 
 

1524 lines
44 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Multi-purpose menu for matchmaking dialogs, navigable with the xbox controller.
//
//=============================================================================//
#include "engine/imatchmaking.h"
#include "GameUI_Interface.h"
#include "vgui_controls/Label.h"
#include "vgui_controls/ImagePanel.h"
#include "vgui/ILocalize.h"
#include "vgui/ISurface.h"
#include "KeyValues.h"
#include "dialogmenu.h"
#include "BasePanel.h"
#include "vgui_controls/ImagePanel.h"
#include "iachievementmgr.h" // for iachievement abstract class in CAchievementItem
#include "achievementsdialog.h" // for helper functions used by both pc and xbox achievements
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------
// Base class representing a generic menu item. Supports two text labels,
// where the first label is the "action" text and the second is an optional
// description of the action.
//-----------------------------------------------------------------------
CMenuItem::CMenuItem( CDialogMenu *pParent, const char *pTitle, const char *pDescription )
: BaseClass( pParent, "MenuItem" )
{
// Quiet "parent not sized yet" spew
SetSize( 10, 10 );
m_pParent = pParent;
m_bEnabled = true;
m_nDisabledAlpha = 30;
m_pTitle = new vgui::Label( this, "MenuItemText", pTitle );
m_pDescription = NULL;
if ( pDescription )
{
m_pDescription = new vgui::Label( this, "MenuItemDesc", pDescription );
}
}
CMenuItem::~CMenuItem()
{
delete m_pTitle;
delete m_pDescription;
}
//-----------------------------------------------------------------------
// Update colors according to enabled/disabled state
//-----------------------------------------------------------------------
void CMenuItem::PerformLayout()
{
BaseClass::PerformLayout();
}
//-----------------------------------------------------------------------
// Setup margins and calculate the total menu item size
//-----------------------------------------------------------------------
void CMenuItem::ApplySettings( KeyValues *pSettings )
{
BaseClass::ApplySettings( pSettings );
m_nBottomMargin = pSettings->GetInt( "bottommargin", 0 );
m_nRightMargin = pSettings->GetInt( "rightmargin", 0 );
int x, y;
m_pTitle->GetPos( x, y );
m_pTitle->SizeToContents();
int bgTall = y + m_pTitle->GetTall() + m_nBottomMargin;
int textWide = m_pTitle->GetWide();
if ( m_pDescription )
{
m_pDescription->SizeToContents();
m_pDescription->GetPos( x, y );
bgTall = y + m_pDescription->GetTall() + m_nBottomMargin;
textWide = max( textWide, m_pDescription->GetWide() );
}
int bgWide = x + textWide + m_nRightMargin;
SetSize( bgWide, bgTall );
}
//-----------------------------------------------------------------------
// Setup colors and fonts
//-----------------------------------------------------------------------
void CMenuItem::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
SetPaintBackgroundType( 2 );
m_BgColor = pScheme->GetColor( "MatchmakingMenuItemBackground", Color( 46, 43, 42, 255 ) );
m_BgColorActive = pScheme->GetColor( "MatchmakingMenuItemBackgroundActive", Color( 150, 71, 0, 255 ) );
m_pTitle->SetFgColor( pScheme->GetColor( "MatchmakingMenuItemTitleColor", Color( 0, 0, 0, 255 ) ) );
if ( m_pDescription )
{
m_pDescription->SetFgColor( pScheme->GetColor( "MatchmakingMenuItemDescriptionColor", Color( 0, 0, 0, 255 ) ) );
}
KeyValues *pKeys = BasePanel()->GetConsoleControlSettings()->FindKey( "MenuItem.res" );
ApplySettings( pKeys );
}
//-----------------------------------------------------------------------
// Set an item as having input focus
//-----------------------------------------------------------------------
void CMenuItem::SetFocus( const bool bActive )
{
if ( bActive )
{
SetBgColor( m_BgColorActive );
}
else
{
SetBgColor( m_BgColor );
}
}
//-----------------------------------------------------------------------
// Set an item as having input focus
//-----------------------------------------------------------------------
void CMenuItem::SetEnabled( bool bEnabled )
{
if ( bEnabled )
{
SetAlpha( 255 );
}
else
{
SetAlpha( m_nDisabledAlpha );
}
m_bEnabled = bEnabled;
}
//-----------------------------------------------------------------------
// Set a column as having focus
//-----------------------------------------------------------------------
void CMenuItem::SetActiveColumn( int col )
{
// do nothing
}
//-----------------------------------------------------------------------
// Set an item as having input focus
//-----------------------------------------------------------------------
bool CMenuItem::IsEnabled()
{
return m_bEnabled;
}
//-----------------------------------------------------------------------
// Perform any special actions when an item is "clicked"
//-----------------------------------------------------------------------
void CMenuItem::OnClick()
{
// do nothing - derived classes implement this
}
//-----------------------------------------------------------------------
// CCommandItem
//
// Menu item that issues a command when clicked.
//-----------------------------------------------------------------------
CCommandItem::CCommandItem( CDialogMenu *pParent, const char *pTitleLabel, const char *pDescLabel, const char *pCommand )
: BaseClass( pParent, pTitleLabel, pDescLabel )
{
Q_strncpy( m_szCommand, pCommand, MAX_COMMAND_LEN );
}
CCommandItem::~CCommandItem()
{
// do nothing
}
void CCommandItem::OnClick()
{
GetParent()->OnCommand( m_szCommand );
vgui::surface()->PlaySound( "UI/buttonclick.wav" );
}
void CCommandItem::SetFocus(const bool bActive )
{
BaseClass::SetFocus( bActive );
if ( bActive == true && m_bHasFocus == false )
{
vgui::surface()->PlaySound( "UI/buttonclickrelease.wav" );
}
m_bHasFocus = bActive;
}
//-----------------------------------------------------------------------
// CPlayerItem
//
// Menu item to display a player in the lobby.
//-----------------------------------------------------------------------
CPlayerItem::CPlayerItem( CDialogMenu *pParent, const char *pTitleLabel, int64 nId, byte bVoice, bool bReady )
: BaseClass( pParent, pTitleLabel, NULL, "ShowGamerCard" )
{
m_pVoiceIcon = new vgui::Label( this, "voiceicon", "" );
m_pReadyIcon = new vgui::Label( this, "readyicon", "" );
m_nId = nId;
m_bVoice = bVoice;
m_bReady = bReady;
}
CPlayerItem::~CPlayerItem()
{
delete m_pVoiceIcon;
delete m_pReadyIcon;
}
void CPlayerItem::PerformLayout()
{
BaseClass::PerformLayout();
const char *pVoice = "";
if ( m_bVoice == 2 )
{
pVoice = "#TF_Icon_Voice";
}
else if ( m_bVoice == 1 )
{
pVoice = "#TF_Icon_Voice_Idle";
}
m_pVoiceIcon->SetText( pVoice );
m_pReadyIcon->SetText( m_bReady ? "#TF_Icon_Ready" : "#TF_Icon_NotReady" );
int x, y;
m_pReadyIcon->GetPos( x, y );
m_pReadyIcon->SetPos( GetWide() - m_pReadyIcon->GetWide() - m_nRightMargin, y );
}
void CPlayerItem::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
KeyValues *pKeys = BasePanel()->GetConsoleControlSettings()->FindKey( "PlayerItem.res" );
ApplySettings( pKeys );
}
void CPlayerItem::OnClick()
{
BaseClass::OnClick();
}
//-----------------------------------------------------------------------
// CBrowserItem
//
// Menu item used to display session search results.
//-----------------------------------------------------------------------
CBrowserItem::CBrowserItem( CDialogMenu *pParent, const char *pHost, const char *pPlayers, const char *pScenario, const char *pPing )
: BaseClass( pParent, pHost, NULL, "SelectSession" )
{
m_pPlayers = new vgui::Label( this, "players", pPlayers );
m_pScenario = new vgui::Label( this, "scenario", pScenario );
m_pPing = new vgui::Label( this, "ping", pPing );
}
CBrowserItem::~CBrowserItem()
{
delete m_pPlayers;
delete m_pScenario;
delete m_pPing;
}
void CBrowserItem::PerformLayout()
{
BaseClass::PerformLayout();
int x, y, wide, tall;
m_pPing->GetBounds( x, y, wide, tall );
m_pScenario->SizeToContents();
int sx, sy;
m_pScenario->GetPos( sx, sy );
m_pScenario->SetPos( x - m_pScenario->GetWide() - m_nRightMargin, sy );
SetSize( x + wide, GetTall() );
}
void CBrowserItem::ApplySettings( KeyValues *pSettings )
{
BaseClass::ApplySettings( pSettings );
}
void CBrowserItem::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
Color fgcolor = pScheme->GetColor( "MatchmakingMenuItemDescriptionColor", Color( 64, 64, 64, 255 ) );
m_pPlayers->SetFgColor( fgcolor );
m_pScenario->SetFgColor( fgcolor );
m_pPing->SetContentAlignment( vgui::Label::a_center );
KeyValues *pKeys = BasePanel()->GetConsoleControlSettings()->FindKey( "BrowserItem.res" );
ApplySettings( pKeys );
SetFocus( false );
}
//-----------------------------------------------------------------------
// COptionsItem
//
// Menu item used to present a list of options for the player to select
// from, such as "choose a map" or "number of rounds".
//-----------------------------------------------------------------------
COptionsItem::COptionsItem( CDialogMenu *pParent, const char *pLabel )
: BaseClass( pParent, pLabel, NULL )
{
m_nActiveOption = m_Options.InvalidIndex();
m_nOptionsXPos = 0;
m_nMaxOptionWidth = 0;
m_szOptionsFont[0] = '\0';
m_hOptionsFont = vgui::INVALID_FONT;
m_pLeftArrow = new vgui::Label( this, "LeftArrow", "" );
m_pRightArrow = new vgui::Label( this, "RightArrow", "" );
}
COptionsItem::~COptionsItem()
{
m_OptionLabels.PurgeAndDeleteElements();
delete m_pLeftArrow;
delete m_pRightArrow;
}
void COptionsItem::PerformLayout()
{
BaseClass::PerformLayout();
int optionWide = max( m_nOptionsMinWide, GetWide() - m_nOptionsXPos - m_pRightArrow->GetWide() - m_nOptionsLeftMargin );
int optionTall = GetTall();
for ( int i = 0; i < m_OptionLabels.Count(); ++i )
{
vgui::Label *pOption = m_OptionLabels[i];
pOption->SetBounds( m_nOptionsXPos, 0, optionWide, optionTall );
}
int lx, ly;
m_pLeftArrow->GetPos( lx, ly );
m_pLeftArrow->SetPos( m_nOptionsXPos - m_nArrowGap - m_pLeftArrow->GetWide(), ly );
int rx, ry;
m_pRightArrow->GetPos( rx, ry );
m_pRightArrow->SetPos( m_nOptionsXPos + optionWide + m_nArrowGap, ry );
m_pLeftArrow->SetAlpha( 255 );
m_pRightArrow->SetAlpha( 255 );
if ( m_nActiveOption == 0 )
{
m_pLeftArrow->SetAlpha( 32 );
}
else if ( m_nActiveOption == m_OptionLabels.Count() - 1 )
{
m_pRightArrow->SetAlpha( 32 );
}
}
void COptionsItem::ApplySettings( KeyValues *pSettings )
{
BaseClass::ApplySettings( pSettings );
m_nOptionsXPos = pSettings->GetInt( "optionsxpos", 0 );
m_nOptionsMinWide = pSettings->GetInt( "optionsminwide", 0 );
m_nOptionsLeftMargin = pSettings->GetInt( "optionsleftmargin", 0 );
m_nArrowGap = pSettings->GetInt( "arrowgap", 0 );
Q_strncpy( m_szOptionsFont, pSettings->GetString( "optionsfont", "Default" ), sizeof( m_szOptionsFont ) );
}
void COptionsItem::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
SetPaintBackgroundEnabled( false );
m_pTitle->SetFgColor( pScheme->GetColor( "MatchmakingMenuItemTitleColor", Color( 200, 184, 151, 255 ) ) );
KeyValues *pKeys = BasePanel()->GetConsoleControlSettings()->FindKey( "OptionsItem.res" );
ApplySettings( pKeys );
m_hOptionsFont = pScheme->GetFont( m_szOptionsFont );
}
void COptionsItem::SetFocus( const bool bActive )
{
if ( bActive )
{
for ( int i = 0; i < m_OptionLabels.Count(); ++i )
{
m_OptionLabels[i]->SetBgColor( m_BgColorActive );
}
}
else
{
for ( int i = 0; i < m_OptionLabels.Count(); ++i )
{
m_OptionLabels[i]->SetBgColor( m_BgColor );
}
}
}
void COptionsItem::AddOption( const char *pLabelText, const sessionProperty_t& option )
{
// Add a new option to this item's list of options
m_Options.AddToTail( option );
int idx = m_OptionLabels.AddToTail( new vgui::Label( this, "Option Value", pLabelText ) );
vgui::Label *pOption = m_OptionLabels[idx];
// Check for a format string
if ( Q_stristr( pLabelText, "Fmt" ) )
{
wchar_t wszString[64];
wchar_t wzNumber[8];
wchar_t *wzFmt = g_pVGuiLocalize->Find( pLabelText );
g_pVGuiLocalize->ConvertANSIToUnicode( option.szValue, wzNumber, sizeof( wzNumber ) );
g_pVGuiLocalize->ConstructString( wszString, sizeof( wszString ), wzFmt, 1, wzNumber );
pOption->SetText( wszString );
}
SETUP_PANEL( pOption );
pOption->SetPaintBackgroundType( 2 );
pOption->SetFont( m_hOptionsFont );
pOption->SetBgColor( Color( 46, 43, 42, 255 ) );
pOption->SetFgColor( m_pTitle ? m_pTitle->GetFgColor() : Color( 200, 184, 151, 255 ) );
pOption->SetTextInset( m_nOptionsLeftMargin, 0 );
pOption->SetContentAlignment( vgui::Label::a_southwest );
pOption->SizeToContents();
int wide = max( m_nOptionsMinWide, pOption->GetWide() );
pOption->SetBounds( m_nOptionsXPos, 0, wide, GetTall() );
m_nMaxOptionWidth = max( wide, m_nMaxOptionWidth );
SetWide( m_nOptionsXPos + m_nMaxOptionWidth + m_nOptionsLeftMargin * 2 + m_nArrowGap * 2 + m_pRightArrow->GetWide() );
}
//-----------------------------------------------------------------------
// Return the session property associated with the current active option
//-----------------------------------------------------------------------
const sessionProperty_t &COptionsItem::GetActiveOption()
{
return m_Options[m_nActiveOption];
}
//-----------------------------------------------------------------------
// Return the index of the current active option
//-----------------------------------------------------------------------
int COptionsItem::GetActiveOptionIndex()
{
return m_nActiveOption;
}
//-----------------------------------------------------------------------
// Sets which option currently has focus
//-----------------------------------------------------------------------
void COptionsItem::SetOptionFocus( unsigned int idx )
{
unsigned int itemCt = (unsigned int)m_OptionLabels.Count();
if ( idx > itemCt )
return;
m_nActiveOption = idx;
for ( unsigned int i = 0; i < itemCt; ++i )
{
vgui::Label *pLabel = m_OptionLabels[i];
const bool bVisible = ( i == idx );
pLabel->SetVisible( bVisible );
}
InvalidateLayout();
}
//-----------------------------------------------------------------------
// Move focus to the next option - does not wrap
//-----------------------------------------------------------------------
void COptionsItem::SetOptionFocusNext()
{
if ( m_nActiveOption + 1 < m_OptionLabels.Count() )
{
SetOptionFocus( m_nActiveOption + 1 );
}
else
{
vgui::surface()->PlaySound( "player/suit_denydevice.wav" );
}
}
//-----------------------------------------------------------------------
// Move focus to the previous option - does not wrap
//-----------------------------------------------------------------------
void COptionsItem::SetOptionFocusPrev()
{
if ( m_nActiveOption > 0 )
{
SetOptionFocus( m_nActiveOption - 1 );
}
else
{
vgui::surface()->PlaySound( "player/suit_denydevice.wav" );
}
}
//-----------------------------------------------------------------------
// CAchievementItem
//
// Menu item used to present an achievement - including image, title,
// description, points and unlock date. Clicking the item opens another
// dialog with additional information about the achievement.
//-----------------------------------------------------------------------
CAchievementItem::CAchievementItem( CDialogMenu *pParent, const wchar_t *pName, const wchar_t *pDesc, uint points, bool bUnlocked, IAchievement* pSourceAchievement )
: BaseClass( pParent, "", "" )
{
// Title and description were returned as results of a system query,
// and are therefore already localized.
m_pTitle->SetText( pName );
if ( IsX360() )
{
wchar_t buf[120];
// Get the screen size
int wide, tall;
vgui::surface()->GetScreenSize(wide, tall);
unsigned int iWrapLen;
if ( tall <= 480 )
{
iWrapLen = 50;
}
else
{
iWrapLen = 65;
}
// let's do some wrapping on this label
wcsncpy( buf, pDesc, sizeof(buf) / sizeof( wchar_t ) );
if ( wcslen(buf) > iWrapLen )
{
int iPos = iWrapLen;
while ( iPos > 0 && buf[iPos] != L' ' )
{
iPos--;
}
if ( iPos > 0 && buf[iPos] == L' ' )
{
buf[iPos] = L'\n';
}
}
m_pDescription->SetText( buf );
}
else
{
m_pDescription->SetText( pDesc );
}
m_pSourceAchievement = pSourceAchievement;
m_pPercentageBarBackground = SETUP_PANEL( new vgui::ImagePanel( this, "PercentageBarBackground" ) );
m_pPercentageBar = SETUP_PANEL( new vgui::ImagePanel( this, "PercentageBar" ) );
m_pPercentageText = SETUP_PANEL( new vgui::Label( this, "PercentageText", "" ) );
// Set the status icons
m_pLockedIcon = SETUP_PANEL( new vgui::ImagePanel( this, "lockedicon" ) );
m_pUnlockedIcon = SETUP_PANEL( new vgui::ImagePanel( this, "unlockedicon" ) );
// Gamerscore number
if ( IsX360() )
{
wchar_t *wzFormat = g_pVGuiLocalize->Find( "#GameUI_Achievement_Points" ); // "%s1G"
wchar_t wzPoints[10];
V_snwprintf( wzPoints, ARRAYSIZE( wzPoints ), L"%d", points );
wchar_t wzPointsLayout[10];
g_pVGuiLocalize->ConstructString( wzPointsLayout, sizeof( wzPointsLayout ), wzFormat, 1, wzPoints );
m_pPoints = new vgui::Label( this, "Points", wzPointsLayout );
}
// Achievement image
m_pImage = new vgui::ImagePanel( this, "icon" );
}
CAchievementItem::~CAchievementItem()
{
delete m_pImage;
delete m_pPoints;
delete m_pLockedIcon;
delete m_pUnlockedIcon;
delete m_pPercentageBarBackground;
delete m_pPercentageBar;
delete m_pPercentageText;
}
void CAchievementItem::PerformLayout()
{
BaseClass::PerformLayout();
int x, y;
m_pPoints->SizeToContents();
m_pPoints->GetPos( x, y );
x = GetWide() - m_pPoints->GetWide() - m_nRightMargin;
m_pPoints->SetPos( x, y );
}
void CAchievementItem::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
KeyValues*pKeys = BasePanel()->GetConsoleControlSettings()->FindKey( "AchievementItem.res" );
ApplySettings( pKeys );
m_pImage->SetBgColor( Color( 32, 32, 32, 255 ) );
m_pImage->SetFgColor( Color( 32, 32, 32, 255 ) );
m_pImage->SetPaintBackgroundEnabled( true );
m_pPoints->SetFgColor( pScheme->GetColor( "MatchmakingMenuItemDescriptionColor", Color( 64, 64, 64, 255 ) ) );
// Set icon image
LoadAchievementIcon( m_pImage, m_pSourceAchievement );
// Percentage completion bar (for progressive achievements)
UpdateProgressBar( this, m_pSourceAchievement, m_clrProgressBar );
if ( m_pSourceAchievement && m_pSourceAchievement->IsAchieved() )
{
m_pLockedIcon->SetVisible( false );
m_pUnlockedIcon->SetVisible ( true );
m_pImage->SetVisible( true );
}
else
{
m_pLockedIcon->SetVisible( true );
m_pUnlockedIcon->SetVisible( false );
m_pImage->SetVisible( false );
}
}
//-----------------------------------------------------------------------
// CSectionedItem
//
// Menu item used to display some number of data entries, which are arranged
// into columns. Supports scrolling through columns horizontally with the
// ability to "lock" columns so they don't scroll
//-----------------------------------------------------------------------
CSectionedItem::CSectionedItem( CDialogMenu *pParent, const char **ppEntries, int ct )
: BaseClass( pParent, "", NULL, "SelectSession" )
{
m_bHeader = false;
for ( int i = 0; i < ct; ++i )
{
AddSection( ppEntries[i], m_pParent->GetColumnAlignment( i ) );
}
}
CSectionedItem::~CSectionedItem()
{
ClearSections();
}
void CSectionedItem::ClearSections()
{
for ( int i = 0; i < m_Sections.Count(); ++i )
{
section_s &sec = m_Sections[i];
delete sec.pLabel;
}
}
void CSectionedItem::PerformLayout()
{
BaseClass::PerformLayout();
int tall = GetTall();
for ( int i = 0; i < m_Sections.Count(); ++i )
{
vgui::Label *pLabel = m_Sections[i].pLabel;
if ( !m_bHeader )
{
pLabel->SetFont( m_pParent->GetColumnFont(i) );
pLabel->SetFgColor( m_pParent->GetColumnColor(i) );
}
pLabel->SetBounds( m_pParent->GetColumnXPos(i), 0, m_pParent->GetColumnWide(i), tall );
pLabel->SetTextInset( 10, m_bHeader ? 5 : m_pParent->GetColumnYPos(i) ); // only use ypos for the y-inset if we're not a header
}
}
void CSectionedItem::ApplySettings( KeyValues *pResourceData )
{
BaseClass::ApplySettings( pResourceData );
}
void CSectionedItem::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
KeyValues *pKeys = BasePanel()->GetConsoleControlSettings()->FindKey( "SectionedItem.res" );
ApplySettings( pKeys );
int iLast = m_Sections.Count() -1;
SetWide( m_pParent->GetColumnXPos(iLast) + m_pParent->GetColumnWide(iLast) );
}
void CSectionedItem::AddSection( const char *pText, int align )
{
section_s sec;
sec.pLabel = new vgui::Label( this, "Section", pText );
SETUP_PANEL( sec.pLabel );
sec.pLabel->SetContentAlignment( (vgui::Label::Alignment)align );
sec.pLabel->SetTextInset( 10, 0 );
sec.pLabel->SetBgColor( Color( 209, 112, 52, 128 ) );
m_Sections.AddToTail( sec );
}
void CSectionedItem::SetActiveColumn( int col )
{
for ( int i = 0; i < m_Sections.Count(); ++i )
{
m_Sections[i].pLabel->SetPaintBackgroundEnabled( i == col );
}
}
//--------------------------------------------------------------------------------------
// Generic menu for Xbox 360 matchmaking dialogs. Contains a list of CMenuItems arranged
// vertically. The user can navigate the list using the controller and click on any
// item. A clicked item may send a command to the dialog and the dialog responds accordingly.
//--------------------------------------------------------------------------------------
CDialogMenu::CDialogMenu() : BaseClass( NULL, "DialogMenu" )
{
// Quiet "parent not sized yet" spew
SetSize( 100, 100 );
m_pParent = NULL;
m_pHeader = NULL;
m_bUseFilter = false;
m_bHasHeader = false;
m_nItemSpacing = 0;
m_nMinWide = 0;
m_nActive = -1;
m_nActiveColumn = -1;
m_nBaseRowIdx = 0;
m_nBaseColumnIdx = 0;
m_iUnlocked = 0;
m_nMaxVisibleItems = 1000; // arbitrarily large
m_nMaxVisibleColumns = 1000;// arbitrarily large
}
CDialogMenu::~CDialogMenu()
{
m_MenuItems.PurgeAndDeleteElements();
delete m_pHeader;
}
void CDialogMenu::SetParent( CBaseDialog *pParent )
{
BaseClass::SetParent( pParent );
m_pParent = pParent;
}
//--------------------------------------------------------------------------------------
// Set a filter to use when reading in menu item keyvalues
//--------------------------------------------------------------------------------------
void CDialogMenu::SetFilter( const char *pFilter )
{
if ( pFilter )
{
Q_strncpy( m_szFilter, pFilter, sizeof( m_szFilter ) );
m_bUseFilter = true;
}
else
{
m_bUseFilter = false;
}
}
//--------------------------------------------------------------------------------------
// Add a new menu item to the item array
//--------------------------------------------------------------------------------------
CMenuItem *CDialogMenu::AddItemInternal( CMenuItem *pItem )
{
int idx = m_MenuItems.AddToTail( pItem );
SETUP_PANEL( pItem );
return m_MenuItems[idx];
}
//--------------------------------------------------------------------------------------
// Add a new menu item of some type that derives from CMenuItem
//--------------------------------------------------------------------------------------
CCommandItem *CDialogMenu::AddCommandItem( const char *pTitleLabel, const char *pDescLabel, const char *pCommand )
{
return (CCommandItem*)AddItemInternal( new CCommandItem( this, pTitleLabel, pDescLabel, pCommand ) );
}
CBrowserItem *CDialogMenu::AddBrowserItem( const char *pHost, const char *pPlayers, const char *pScenario, const char *pPing )
{
// Results are added to the menu at runtime, so the layout needs to be updated after each addition.
CBrowserItem *pItem = (CBrowserItem*)AddItemInternal( new CBrowserItem( this, pHost, pPlayers, pScenario, pPing ) );
PerformLayout();
return pItem;
}
COptionsItem *CDialogMenu::AddOptionsItem( const char *pLabel )
{
return (COptionsItem*)AddItemInternal( new COptionsItem( this, pLabel ) );
}
CAchievementItem *CDialogMenu::AddAchievementItem( const wchar_t *pName, const wchar_t *pDesc, uint points, bool bUnlocked, IAchievement* pSourceAchievement )
{
return (CAchievementItem*)AddItemInternal( new CAchievementItem( this, pName, pDesc, points, bUnlocked, pSourceAchievement ) );
}
CSectionedItem *CDialogMenu::AddSectionedItem( const char **ppEntries, int ct )
{
CSectionedItem *pItem = (CSectionedItem*)AddItemInternal( new CSectionedItem( this, ppEntries, ct ) );
PerformLayout();
return pItem;
}
CPlayerItem *CDialogMenu::AddPlayerItem( const char *pTitleLabel, int64 nId, byte bVoice, bool bReady )
{
// Players are added to the lobby at runtime, so the layout needs to be updated after each addition.
CPlayerItem *pItem = (CPlayerItem*)AddItemInternal( new CPlayerItem( this, pTitleLabel, nId, bVoice, bReady ) );
PerformLayout();
return pItem;
}
void CDialogMenu::RemovePlayerItem( int idx )
{
delete m_MenuItems[idx];
m_MenuItems.Remove( idx );
PerformLayout();
}
void CDialogMenu::ClearItems()
{
m_MenuItems.PurgeAndDeleteElements();
InvalidateLayout();
}
//--------------------------------------------------------------------------------------
// Set the size an position of all the menu items
//--------------------------------------------------------------------------------------
void CDialogMenu::PerformLayout()
{
BaseClass::PerformLayout();
// Position the menu items and set their width
int yPos = 0;
int wide = GetWide();
if ( m_bHasHeader )
{
yPos = 40;
m_pHeader->SetPos( 0, 0 );
m_pHeader->SetWide( wide );
m_pHeader->PerformLayout();
}
for ( int i = 0; i < m_MenuItems.Count(); ++i )
{
CMenuItem *pItem = m_MenuItems[i];
pItem->SetPos( 0, yPos );
pItem->SetWide( wide );
pItem->SetActiveColumn( m_nActiveColumn );
pItem->PerformLayout();
if ( i < m_nBaseRowIdx || i > m_nBaseRowIdx + m_nMaxVisibleItems - 1 )
{
pItem->SetVisible( false );
}
else
{
pItem->SetVisible( true );
yPos += pItem->GetTall() + m_nItemSpacing;
}
}
// Reset the focus to update background colors of all menu items
SetFocus( m_nActive );
SetTall( yPos );
}
//--------------------------------------------------------------------------------------
// Parse the res file for menu items to build out the dialog menu.
//--------------------------------------------------------------------------------------
void CDialogMenu::ApplySettings( KeyValues *pResourceData )
{
BaseClass::ApplySettings( pResourceData );
m_nItemSpacing = pResourceData->GetInt( "itemspacing", 2 );
m_nMinWide = pResourceData->GetInt( "minwide", 0 );
m_nActiveColumn = pResourceData->GetInt( "activecolumn", -1 );
m_nMaxVisibleItems = pResourceData->GetInt( "maxvisibleitems", 1000 ); // arbitrarily large
m_nMaxVisibleColumns = pResourceData->GetInt( "maxvisiblecolumns", 1000 ); // arbitrarily large
KeyValues *pColumnData = pResourceData->FindKey( "Columns" );
if ( pColumnData )
{
int xPos = 0;
int idx = 0;
const char *ppHeader[MAX_COLUMNS];
for ( KeyValues *pColumn = pColumnData->GetFirstSubKey(); pColumn != NULL; pColumn = pColumn->GetNextKey() )
{
if ( !Q_stricmp( pColumn->GetName(), "Column" ) )
{
columninfo_s col;
col.bSortDown = true;
col.xpos = pColumn->GetInt( "xpos", xPos );
col.ypos = pColumn->GetInt( "ypos", 0 );
col.wide = pColumn->GetInt( "wide", 0 );
col.align = pColumn->GetInt( "align", 3 ); // west by default
col.bLocked = pColumn->GetInt( "locked", 0 );
col.hFont = m_pScheme->GetFont( pColumn->GetString( "font", "default" ) );
col.color = m_pScheme->GetColor( pColumn->GetString( "fgcolor" ), Color( 0, 0, 0, 255 ) );
ppHeader[idx++] = pColumn->GetString( "header", "" );
xPos = col.xpos + col.wide;
m_Columns.AddToTail( col );
if ( col.bLocked )
{
m_nBaseColumnIdx = idx;
m_iUnlocked = idx;
}
}
}
m_bHasHeader = true;
m_pHeader = new CSectionedItem( this, ppHeader, idx );
m_pHeader->m_bHeader = true;
SETUP_PANEL( m_pHeader );
m_pHeader->SetPaintBackgroundEnabled( false );
vgui::HFont headerFont = m_pScheme->GetFont( pColumnData->GetString( "headerfont", "default" ) );
Color headerColor = m_pScheme->GetColor( pColumnData->GetString( "headerfgcolor" ), Color( 0, 0, 0, 255 ) );
for ( int i = 0; i < idx; ++i )
{
vgui::Label *pLabel = m_pHeader->m_Sections[i].pLabel;
pLabel->SetFont( headerFont );
pLabel->SetFgColor( headerColor );
pLabel->SetPaintBackgroundEnabled( false );
}
}
for ( KeyValues *pMenuData = pResourceData->GetFirstSubKey(); pMenuData != NULL; pMenuData = pMenuData->GetNextKey() )
{
// See if we should skip over this block
if ( m_bUseFilter )
{
if ( pMenuData->GetInt( m_szFilter, 0 ) == 0 )
continue;
}
// Give our parent a chance to change the properties of this item
m_pParent->OverrideMenuItem( pMenuData );
if ( !Q_stricmp( pMenuData->GetName(), "CommandItem" ) )
{
// New Command Item
const char *label = pMenuData->GetString( "label", "<unknown>" );
const char *description = pMenuData->GetString( "description", NULL );
const char *command = pMenuData->GetString( "command", "<unknown>" );
AddCommandItem( label, description, command );
}
else if ( !Q_stricmp( pMenuData->GetName(), "OptionsItem" ) )
{
// New Options Item
COptionsItem *pItem = AddOptionsItem( pMenuData->GetString( "label", "<unknown>" ) );
// ID and ValueType and the same for all option values
const char *pID = pMenuData->GetString( "id", "NULL" );
const char *pValueType = pMenuData->GetString( "valuetype", NULL );
// Add all the options
for ( KeyValues *pValue = pMenuData->GetFirstSubKey(); pValue != NULL; pValue = pValue->GetNextKey() )
{
if ( !Q_stricmp( pValue->GetName(), "Option" ) )
{
sessionProperty_t prop;
prop.nType = SESSION_CONTEXT;
Q_strncpy( prop.szID, pID, sizeof( prop.szID ) );
Q_strncpy( prop.szValue, pValue->GetString( "value", "NULL" ), sizeof( prop.szValue ) );
if ( pValueType )
{
// Only session properties have a type
prop.nType = SESSION_PROPERTY;
Q_strncpy( prop.szValueType, pValueType, sizeof( prop.szValueType ) );
}
const char *pLabel = pValue->GetString( "label", "<unknown>" );
pItem->AddOption( pLabel, prop );
}
}
// Add range items after the specified items
if ( pMenuData->GetInt( "userange" ) )
{
// Options are an implicit range of integers
int nStart = pMenuData->GetInt( "rangelow" );
int nEnd = pMenuData->GetInt( "rangehigh" );
int nInterval = pMenuData->GetInt( "interval", 1 );
// Prevent total destruction from a bad resource file
if ( nEnd < nStart )
{
nEnd = nStart;
}
for ( int i = nStart; i <= nEnd; i += nInterval )
{
sessionProperty_t prop;
prop.nType = SESSION_PROPERTY;
Q_strncpy( prop.szID, pID, sizeof( prop.szID ) );
Q_strncpy( prop.szValueType, pValueType, sizeof( prop.szValueType ) );
Q_snprintf( prop.szValue, sizeof(prop.szValue), "%d", i );
pItem->AddOption( prop.szValue, prop );
}
}
// Set the default active option
int active = pMenuData->GetInt( "activeoption", 0 );
pItem->SetOptionFocus( active );
// Notify our parent that each option has been set to its current setting
KeyValues *kv = new KeyValues( "MenuItemChanged", "item", GetItemCount() - 1 );
PostActionSignal( kv );
}
}
// Calculate the final menu size according to the widest menu item
int wide = m_nMinWide;
for ( int i = 0; i < m_MenuItems.Count(); ++i )
{
wide = max( wide, m_MenuItems[i]->GetWide() );
}
SetWide( wide );
}
//--------------------------------------------------------------------------------------
// Cache off the scheme
//--------------------------------------------------------------------------------------
void CDialogMenu::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
m_pScheme = pScheme;
}
//--------------------------------------------------------------------------------------
// Give focus (highlights) a particular menu item by index
//--------------------------------------------------------------------------------------
void CDialogMenu::SetFocus( int idx )
{
int itemCt = (unsigned int)m_MenuItems.Count();
if ( idx >= itemCt )
return;
for ( int i = 0; i < itemCt; ++i )
{
m_MenuItems[i]->SetFocus( i == idx );
}
m_nActive = idx;
if ( m_nActive >= 0 && m_nActive < m_nBaseRowIdx )
{
m_nBaseRowIdx = m_nActive;
}
else if ( m_nActive > m_nBaseRowIdx + m_nMaxVisibleItems - 1 )
{
m_nBaseRowIdx = m_nActive - ( m_nMaxVisibleItems - 1 );
}
}
//--------------------------------------------------------------------------------------
// Sort the menu items according to the selected column
//--------------------------------------------------------------------------------------
void CDialogMenu::SortMenuItems()
{
if ( !m_bHasHeader )
return;
// Simple bubble sort
char szBufferOne[32];
char szBufferTwo[32];
bool bSortDown = GetColumnSortType( m_nActiveColumn );
for ( int i = 1; i <= m_MenuItems.Count(); ++i )
{
for ( int j = 0; j < m_MenuItems.Count() - i; ++j )
{
((CSectionedItem*)m_MenuItems[j])->m_Sections[m_nActiveColumn].pLabel->GetText( szBufferOne, sizeof( szBufferOne ) );
((CSectionedItem*)m_MenuItems[j+1])->m_Sections[m_nActiveColumn].pLabel->GetText( szBufferTwo, sizeof( szBufferTwo ) );
int diff = Q_stricmp( szBufferOne, szBufferTwo );
bool bSwap = bSortDown ? diff > 0 : diff < 0;
if ( bSwap )
{
CMenuItem *pTemp = m_MenuItems[j+1];
m_MenuItems[j+1] = m_MenuItems[j];
m_MenuItems[j] = pTemp;
m_pParent->SwapMenuItems( j, j+1 );
}
}
}
InvalidateLayout();
}
//--------------------------------------------------------------------------------------
// Move item focus to the next item in the menu - supports wrapping
//--------------------------------------------------------------------------------------
void CDialogMenu::SetFocusNext()
{
if ( m_MenuItems.Count() )
{
int iNewIndex = ( m_nActive + 1 ) % m_MenuItems.Count();
int i = 0;
bool bSet = false;
while ( i < m_MenuItems.Count() )
{
if ( m_MenuItems[iNewIndex]->IsEnabled() )
{
SetFocus( iNewIndex );
bSet = true;
break;
}
iNewIndex = ( iNewIndex + 1 ) % m_MenuItems.Count();
i++;
}
InvalidateLayout();
}
}
//--------------------------------------------------------------------------------------
// Move item focus to the previous item in the menu - supports wrapping
//--------------------------------------------------------------------------------------
void CDialogMenu::SetFocusPrev()
{
if ( m_MenuItems.Count() )
{
int iNewIndex = m_nActive - 1;
if ( iNewIndex < 0 )
iNewIndex = m_MenuItems.Count() - 1;
int i = 0;
bool bSet = false;
while ( i < m_MenuItems.Count() )
{
if ( m_MenuItems[iNewIndex]->IsEnabled() )
{
SetFocus( iNewIndex );
bSet = true;
break;
}
if ( --iNewIndex < 0 )
iNewIndex = m_MenuItems.Count() - 1;
i++;
}
InvalidateLayout();
}
}
//--------------------------------------------------------------------------------------
// For OptionsItems: Move focus to the next option in the menu item - does not wrap
//--------------------------------------------------------------------------------------
void CDialogMenu::SetOptionFocusNext()
{
COptionsItem *pItem = dynamic_cast< COptionsItem* >( GetItem( m_nActive ) );
if ( pItem )
{
pItem->SetOptionFocusNext();
KeyValues *kv = new KeyValues( "MenuItemChanged", "item", m_nActive );
PostActionSignal( kv );
}
}
//--------------------------------------------------------------------------------------
// For OptionsItems: Move focus to the previous option in the menu item - does not wrap
//--------------------------------------------------------------------------------------
void CDialogMenu::SetOptionFocusPrev()
{
COptionsItem *pItem = dynamic_cast< COptionsItem* >( GetItem( m_nActive ) );
if ( pItem )
{
pItem->SetOptionFocusPrev();
KeyValues *kv = new KeyValues( "MenuItemChanged", "item", m_nActive );
PostActionSignal( kv );
}
}
//--------------------------------------------------------------------------------------
// For OptionsItems: Update the base index for the columns
//--------------------------------------------------------------------------------------
void CDialogMenu::UpdateBaseColumnIndex()
{
if ( m_iUnlocked + m_nActiveColumn - m_nBaseColumnIdx >= m_nMaxVisibleColumns )
{
m_nBaseColumnIdx = m_iUnlocked + m_nActiveColumn - m_nMaxVisibleColumns + 1;
}
else if ( m_nActiveColumn - m_nBaseColumnIdx < 0 )
{
m_nBaseColumnIdx = m_nActiveColumn;
}
}
//--------------------------------------------------------------------------------------
// For menus with sectioned columns - move focus to the next column
//--------------------------------------------------------------------------------------
void CDialogMenu::SetColumnFocusNext()
{
if ( m_nActiveColumn == -1 )
return;
if ( m_Columns.Count() )
{
int iNewColumn = m_nActiveColumn + 1;
if ( iNewColumn >= m_Columns.Count() )
return;
m_nActiveColumn = iNewColumn;
UpdateBaseColumnIndex();
InvalidateLayout();
}
}
//--------------------------------------------------------------------------------------
// For menus with sectioned columns - move focus to the next column
//--------------------------------------------------------------------------------------
void CDialogMenu::SetColumnFocusPrev()
{
if ( m_nActiveColumn == -1 )
return;
if ( m_Columns.Count() )
{
int iNewColumn = m_nActiveColumn - 1;
if ( iNewColumn < 0 || m_Columns[iNewColumn].bLocked )
return;
m_nActiveColumn = iNewColumn;
UpdateBaseColumnIndex();
InvalidateLayout();
}
}
//--------------------------------------------------------------------------------------
// For OptionsItems: Lets the dialog find out which option is currently selected
//--------------------------------------------------------------------------------------
int CDialogMenu::GetActiveOptionIndex( int nMenuItemIdx )
{
int retval = -1;
COptionsItem *pItem = dynamic_cast< COptionsItem* >( GetItem( nMenuItemIdx ) );
if ( pItem )
{
retval = pItem->GetActiveOptionIndex();
}
return retval;
}
//-----------------------------------------------------------------------
// Return the index of the current active menu item
//-----------------------------------------------------------------------
int CDialogMenu::GetActiveItemIndex()
{
return m_nActive;
}
//-----------------------------------------------------------------------
// Return the index of the current active menu column
//-----------------------------------------------------------------------
int CDialogMenu::GetActiveColumnIndex()
{
return m_nActiveColumn;
}
//-----------------------------------------------------------------------
// Return the number of menu items
//-----------------------------------------------------------------------
int CDialogMenu::GetItemCount()
{
return m_MenuItems.Count();
}
//-----------------------------------------------------------------------
// Return the number of visible menu items
//-----------------------------------------------------------------------
int CDialogMenu::GetVisibleItemCount()
{
return min( GetItemCount(), m_nMaxVisibleItems );
}
//-----------------------------------------------------------------------
// Return the number of visible menu columns
//-----------------------------------------------------------------------
int CDialogMenu::GetVisibleColumnCount()
{
return m_nMaxVisibleColumns;
}
//-----------------------------------------------------------------------
// Return the index of the first unlocked column
//-----------------------------------------------------------------------
int CDialogMenu::GetFirstUnlockedColumnIndex()
{
return m_iUnlocked;
}
//-----------------------------------------------------------------------
// Return the first visible index in the menu
//-----------------------------------------------------------------------
int CDialogMenu::GetBaseRowIndex()
{
return m_nBaseRowIdx;
}
//-----------------------------------------------------------------------
// Set the first visible index in the menu
//-----------------------------------------------------------------------
void CDialogMenu::SetBaseRowIndex( int idx )
{
m_nBaseRowIdx = idx;
}
//-----------------------------------------------------------------------
// Return the specified menu item
//-----------------------------------------------------------------------
CMenuItem *CDialogMenu::GetItem( int idx )
{
if ( m_MenuItems.IsValidIndex( idx ) )
{
return m_MenuItems[idx];
}
return NULL;
}
//-----------------------------------------------------------------------
// Return the specified column xpos
//-----------------------------------------------------------------------
int CDialogMenu::GetColumnXPos( int idx )
{
// Compensate for scrolling offsets
columninfo_s &col = m_Columns[idx];
int xpos;
if ( col.bLocked )
{
xpos = m_Columns[idx].xpos;
}
else
{
int trueIdx = m_iUnlocked + idx - m_nBaseColumnIdx;
if ( trueIdx < m_iUnlocked )
{
// Put it offscreen
xpos = -100 - col.wide;
}
else
{
xpos = m_Columns[trueIdx].xpos;
}
}
return xpos;
}
//-----------------------------------------------------------------------
// Return the specified column ypos
//-----------------------------------------------------------------------
int CDialogMenu::GetColumnYPos( int idx )
{
return m_Columns[idx].ypos;
}
//-----------------------------------------------------------------------
// Return the specified column width
//-----------------------------------------------------------------------
int CDialogMenu::GetColumnWide( int idx )
{
return m_Columns[idx].wide;
}
//-----------------------------------------------------------------------
// Return the specified column alignment
//-----------------------------------------------------------------------
int CDialogMenu::GetColumnAlignment( int idx )
{
return m_Columns[idx].align;
}
//-----------------------------------------------------------------------
// Return the specified column font
//-----------------------------------------------------------------------
HFont CDialogMenu::GetColumnFont( int idx )
{
return m_Columns[idx].hFont;
}
//-----------------------------------------------------------------------
// Return the specified column fgcolor
//-----------------------------------------------------------------------
Color CDialogMenu::GetColumnColor( int idx )
{
return m_Columns[idx].color;
}
//-----------------------------------------------------------------------
// Return the specified column fgcolor
//-----------------------------------------------------------------------
bool CDialogMenu::GetColumnSortType( int idx )
{
bool bSortDown = m_Columns[idx].bSortDown;
m_Columns[idx].bSortDown = !bSortDown;
return bSortDown;
}
//--------------------------------------------------------------------------------------
// Receive the command from a clicked menu item and forwards it to the parent dialog
//--------------------------------------------------------------------------------------
void CDialogMenu::OnCommand( const char *pCommand )
{
GetParent()->OnCommand( pCommand );
}
//--------------------------------------------------------------------------------------
// Update the menu state according to controller input.
// Returns whether or not the keycode was handled by the menu.
//--------------------------------------------------------------------------------------
bool CDialogMenu::HandleKeyCode( vgui::KeyCode code )
{
switch( code )
{
case KEY_XBUTTON_DOWN:
case KEY_XSTICK1_DOWN:
case STEAMCONTROLLER_DPAD_DOWN:
SetFocusNext();
break;
case KEY_XBUTTON_UP:
case KEY_XSTICK1_UP:
case STEAMCONTROLLER_DPAD_UP:
SetFocusPrev();
break;
case KEY_XBUTTON_LEFT:
case KEY_XSTICK1_LEFT:
case STEAMCONTROLLER_DPAD_LEFT:
SetOptionFocusPrev();
SetColumnFocusPrev();
break;
case KEY_XBUTTON_RIGHT:
case KEY_XSTICK1_RIGHT:
case STEAMCONTROLLER_DPAD_RIGHT:
SetOptionFocusNext();
SetColumnFocusNext();
break;
case KEY_XBUTTON_A:
case STEAMCONTROLLER_A:
if ( m_MenuItems.Count() && m_nActive >= 0 )
{
m_MenuItems[m_nActive]->OnClick();
}
break;
case KEY_XBUTTON_Y:
case STEAMCONTROLLER_Y:
SortMenuItems();
break;
default:
// Not handled
return false;
}
return true;
}