tf2/tf2_src/gameui/matchmaking/dialogmenu.cpp

//========= 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;
}