tf2/tf2_src/game/client/econ/econ_controls.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"

#include "ienginevgui.h"
#include <vgui_controls/ScrollBarSlider.h>
#include "vgui/ILocalize.h"
#include "vgui/ISurface.h"
#include "vgui/IInput.h"
#include "econ_controls.h"
#include "vgui_controls/TextImage.h"
#include "vgui_controls/PropertyPage.h"
#include "econ_item_system.h"
#include "econ_item_tools.h"
#include "iachievementmgr.h"
#include "econ_item_description.h"

#if defined(TF_DLL) || defined(TF_CLIENT_DLL)
#include "tf_shareddefs.h"
#endif

using namespace vgui;

DECLARE_BUILD_FACTORY_DEFAULT_TEXT( CExButton, CExButton );
DECLARE_BUILD_FACTORY_DEFAULT_TEXT( CExImageButton, CExImageButton );
DECLARE_BUILD_FACTORY_DEFAULT_TEXT( CExLabel, CExLabel );
DECLARE_BUILD_FACTORY( CExRichText );
DECLARE_BUILD_FACTORY( CRichTextWithScrollbarBorders );
DECLARE_BUILD_FACTORY( CEconItemDetailsRichText );
DECLARE_BUILD_FACTORY( CExplanationPopup );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool SetChildPanelVisible( vgui::Panel *pParent, const char *pChildName, bool bVisible, bool bSearchForChildRecursively )
{
	vgui::Panel *pPanel = pParent->FindChildByName( pChildName, bSearchForChildRecursively );
	if ( pPanel )
	{
		if ( pPanel->IsVisible() != bVisible )
		{
			pPanel->SetVisible( bVisible );
		}
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool SetChildPanelEnabled( vgui::Panel *pParent, const char *pChildName, bool bEnabled, bool bSearchForChildRecursively )
{
	vgui::Panel *pPanel = pParent->FindChildByName( pChildName, bSearchForChildRecursively );
	if ( pPanel )
	{
		if ( pPanel->IsEnabled() != bEnabled )
		{
			pPanel->SetEnabled( bEnabled );
		}
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool SetChildButtonSelected( vgui::Panel *pParent, const char *pChildName, bool bSelected, bool bSearchForChildRecursively )
{
	vgui::Button *pPanel = dynamic_cast< vgui::Button* >( pParent->FindChildByName( pChildName, bSearchForChildRecursively ) );
	if ( pPanel )
	{
		if ( pPanel->IsSelected() != bSelected )
		{
			pPanel->SetSelected( bSelected );
		}
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool IsChildButtonSelected( vgui::Panel *pParent, const char *pChildName, bool bSearchForChildRecursively )
{
	vgui::Button *pPanel = dynamic_cast< vgui::Button* >( pParent->FindChildByName( pChildName, bSearchForChildRecursively ) );
	if ( pPanel )
	{
		return pPanel->IsSelected();
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool AddChildActionSignalTarget( vgui::Panel *pParent, const char *pChildName, Panel *messageTarget, bool bSearchForChildRecursively )
{
	vgui::Panel *pPanel = pParent->FindChildByName( pChildName, bSearchForChildRecursively );
	if ( pPanel )
	{
		pPanel->AddActionSignalTarget( messageTarget );
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool SetXToRed( vgui::Label *pPanel )
{
	if ( !pPanel )
		return false;

	wchar_t wszConfirmText[256];
	pPanel->GetText( wszConfirmText, sizeof( wszConfirmText ) );

	if ( ( wszConfirmText[0] == L'x' || wszConfirmText[0] == L'X' ) && wszConfirmText[1] == L' ' )
	{
		pPanel->GetTextImage()->ClearColorChangeStream();
		pPanel->GetTextImage()->AddColorChange( Color(200,80,60,255), 0 );
		pPanel->GetTextImage()->AddColorChange( pPanel->GetFgColor(), 1 );
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExButton::CExButton( Panel *parent, const char *name, const char *text, vgui::Panel *pActionSignalTarget, const char *cmd ) : Button( parent, name, text, pActionSignalTarget, cmd )
{
	m_szFont[0] = '\0';
	m_szColor[0] = '\0';
	m_pArmedBorder = NULL;
	m_pDefaultBorderOverride = NULL;
	m_pSelectedBorder = NULL;
	m_pDisabledBorder = NULL;
	m_bbCursorEnterExitEvent = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExButton::CExButton( Panel *parent, const char *name, const wchar_t *wszText, vgui::Panel *pActionSignalTarget, const char *cmd ) : Button( parent, name, wszText, pActionSignalTarget, cmd )
{
	m_szFont[0] = '\0';
	m_szColor[0] = '\0';
	m_pArmedBorder = NULL;
	m_pDefaultBorderOverride = NULL;
	m_pSelectedBorder = NULL;
	m_pDisabledBorder = NULL;
	m_bbCursorEnterExitEvent = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExButton::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	SetFontStr( inResourceData->GetString( "font", "Default" ) );
	SetColorStr( inResourceData->GetString( "fgcolor", "Button.TextColor" ) );

	IScheme *pScheme = scheme()->GetIScheme( GetScheme() );

	const char *pszBorder = inResourceData->GetString( "border_default", "" );
	if ( *pszBorder )
	{
		m_pDefaultBorderOverride = pScheme->GetBorder( pszBorder );
	}

	pszBorder = inResourceData->GetString( "border_armed", "" );
	if ( *pszBorder )
	{
		m_pArmedBorder = pScheme->GetBorder( pszBorder );
	}

	pszBorder = inResourceData->GetString( "border_disabled", "" );
	if ( *pszBorder )
	{
		m_pDisabledBorder = pScheme->GetBorder( pszBorder );
	}

	const char *pszSelectedBorder = inResourceData->GetString( "border_selected", "" );
	if ( *pszSelectedBorder )
	{
		m_pSelectedBorder = pScheme->GetBorder( pszSelectedBorder );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
vgui::IBorder *CExButton::GetBorder(bool depressed, bool armed, bool selected, bool keyfocus)
{
	if ( !IsEnabled() && m_pDisabledBorder )
		return m_pDisabledBorder;

	if ( selected && m_pSelectedBorder )
		return m_pSelectedBorder;

	if ( armed && m_pArmedBorder )
		return m_pArmedBorder;

	if ( m_pDefaultBorderOverride )
		return m_pDefaultBorderOverride;
	
	return BaseClass::GetBorder( depressed, armed, selected, keyfocus );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExButton::SetFontStr( const char *pFont )
{
	V_strcpy_safe( m_szFont, pFont );

	IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
	SetFont( pScheme->GetFont( m_szFont, true ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExButton::SetColorStr( const char *pColor )
{
	V_strcpy_safe( m_szColor, pColor );

	IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
	SetFgColor( pScheme->GetColor( m_szColor, Color( 255, 255, 255, 255 ) ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExButton::OnMouseFocusTicked()
{
	BaseClass::OnMouseFocusTicked();

	if ( m_hMouseTickTarget )
	{
		KeyValues *pMessage = new KeyValues("MouseFocusTicked");
		vgui::ipanel()->SendMessage( m_hMouseTickTarget, pMessage, GetVPanel());
		pMessage->deleteThis();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExButton::OnCursorEntered()
{
	BaseClass::OnCursorEntered();

	if ( m_hMouseTickTarget && m_bbCursorEnterExitEvent )
	{
		KeyValues *pMessage = new KeyValues("CursorEntered");
		vgui::ipanel()->SendMessage( m_hMouseTickTarget, pMessage, GetVPanel());
		pMessage->deleteThis();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExButton::OnCursorExited()
{
	BaseClass::OnCursorExited();

	if ( m_hMouseTickTarget && m_bbCursorEnterExitEvent )
	{
		KeyValues *pMessage = new KeyValues("CursorExited");
		vgui::ipanel()->SendMessage( m_hMouseTickTarget, pMessage, GetVPanel());
		pMessage->deleteThis();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExImageButton::CExImageButton( Panel *parent, const char *name, const char *text, vgui::Panel *pActionSignalTarget, const char *cmd ) : CExButton( parent, name, text, pActionSignalTarget, cmd )
{
	m_ImageDrawColor = Color(255,255,255,255);
	m_ImageArmedColor = Color(255,255,255,255);
	m_ImageDepressedColor = Color(255,255,255,255);
	m_ImageDisabledColor = Color(255,255,255,255);
	m_ImageSelectedColor = Color(255,255,255,255);
	m_pEmbeddedImagePanel = new vgui::ImagePanel( this, "SubImage" );
	m_szImageDefault[0] = '\0';
	m_szImageArmed[0] = '\0';
	m_szImageSelected[0] = '\0';
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExImageButton::CExImageButton( Panel *parent, const char *name, const wchar_t *wszText, vgui::Panel *pActionSignalTarget, const char *cmd ) : CExButton( parent, name, wszText, pActionSignalTarget, cmd )
{
	m_ImageDrawColor = Color(255,255,255,255);
	m_ImageArmedColor = Color(255,255,255,255);
	m_ImageDepressedColor = Color(255,255,255,255);
	m_ImageDisabledColor = Color(255,255,255,255);
	m_ImageSelectedColor = Color(255,255,255,255);
	m_pEmbeddedImagePanel = new vgui::ImagePanel( this, "SubImage" );
	m_szImageDefault[0] = '\0';
	m_szImageArmed[0] = '\0';
	m_szImageSelected[0] = '\0';
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExImageButton::~CExImageButton( void )
{
	m_pEmbeddedImagePanel->MarkForDeletion();
	m_pEmbeddedImagePanel = 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	int r,g,b,a;

	const char *pszDrawColor = inResourceData->GetString("image_drawcolor", "");
	if (*pszDrawColor)
	{
		if (sscanf(pszDrawColor, "%d %d %d %d", &r, &g, &b, &a) >= 3)
		{
			m_ImageDrawColor = Color(r, g, b, a);
		}
	}

	pszDrawColor = inResourceData->GetString("image_armedcolor", "");
	if (*pszDrawColor)
	{
		if (sscanf(pszDrawColor, "%d %d %d %d", &r, &g, &b, &a) >= 3)
		{
			m_ImageArmedColor = Color(r, g, b, a);
		}
	}

	pszDrawColor = inResourceData->GetString("image_depressedcolor", "");
	if (*pszDrawColor)
	{
		if (sscanf(pszDrawColor, "%d %d %d %d", &r, &g, &b, &a) >= 3)
		{
			m_ImageDepressedColor = Color(r, g, b, a);
		}
	}

	pszDrawColor = inResourceData->GetString("image_disabledcolor", "");
	if (*pszDrawColor)
	{
		if (sscanf(pszDrawColor, "%d %d %d %d", &r, &g, &b, &a) >= 3)
		{
			m_ImageDisabledColor = Color(r, g, b, a);
		}
	}

	pszDrawColor = inResourceData->GetString( "image_selectedcolor", "" );
	if (*pszDrawColor)
	{
		if (sscanf(pszDrawColor, "%d %d %d %d", &r, &g, &b, &a) >= 3)
		{
			m_ImageSelectedColor = Color(r, g, b, a);
		}
	}

	KeyValues *pButtonKV = inResourceData->FindKey( "SubImage" );
	if ( pButtonKV )
	{
		m_pEmbeddedImagePanel->ApplySettings( pButtonKV );
	}

	const char *pszImageDefault = inResourceData->GetString("image_default", "");
	if (*pszImageDefault)
	{
		SetImageDefault( pszImageDefault );
	}

	const char *pszImageArmed = inResourceData->GetString("image_armed", "");
	if (*pszImageArmed)
	{
		SetImageArmed( pszImageArmed );
	}

	const char *pszImageSelected = inResourceData->GetString("image_selected", "");
	if (*pszImageSelected)
	{
		SetImageSelected( pszImageSelected );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
Color CExImageButton::GetImageColor( void )
{
	if ( !IsEnabled() )
		return m_ImageDisabledColor;
	if ( IsSelected() )
		return m_ImageSelectedColor;
	if ( IsDepressed() )
		return m_ImageDepressedColor;
	if ( IsArmed() )
		return m_ImageArmedColor;
	return m_ImageDrawColor;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	m_pEmbeddedImagePanel->SetMouseInputEnabled( false );
	m_pEmbeddedImagePanel->SetDrawColor( GetImageColor() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::SetArmed(bool state)
{
	BaseClass::SetArmed( state );

	if ( m_pEmbeddedImagePanel )
	{
		m_pEmbeddedImagePanel->SetDrawColor( GetImageColor() );

		const char *pszImage = state ? m_szImageArmed : m_szImageDefault;
		if ( *pszImage )
		{
			SetSubImage( pszImage );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::SetEnabled(bool state)
{
	BaseClass::SetEnabled( state );

	if ( m_pEmbeddedImagePanel )
	{
		m_pEmbeddedImagePanel->SetDrawColor( GetImageColor() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::SetSelected(bool state)
{
	BaseClass::SetSelected( state );

	if ( m_pEmbeddedImagePanel )
	{
		m_pEmbeddedImagePanel->SetDrawColor( GetImageColor() );

		const char *pszImage = state ? m_szImageSelected : m_szImageDefault;
		if ( *pszImage )
		{
			SetSubImage( pszImage );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::SetSubImage( const char *pszImage )
{
	m_pEmbeddedImagePanel->SetImage( pszImage );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::SetImageDefault( const char *pszImageDefault )
{
	V_strcpy_safe( m_szImageDefault, pszImageDefault );	
	if ( !IsArmed() )
	{
		SetSubImage( pszImageDefault );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::SetImageArmed( const char *pszImageArmed )
{
	V_strcpy_safe( m_szImageArmed, pszImageArmed );
	if ( IsArmed() )
	{
		SetSubImage( m_szImageArmed );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExImageButton::SetImageSelected( const char *pszImageSelected )
{
	V_strcpy_safe( m_szImageSelected, pszImageSelected );
	if ( IsSelected() )
	{
		SetSubImage( m_szImageSelected );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExLabel::CExLabel( Panel *parent, const char *name, const char *text ) : Label( parent, name, text )
{
	m_szColor[0] = '\0';
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExLabel::CExLabel( Panel *parent, const char *name, const wchar_t *wszText ) : Label( parent, name, wszText )
{
	m_szColor[0] = '\0';
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExLabel::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	SetColorStr( inResourceData->GetString( "fgcolor", "Label.TextColor" ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExLabel::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	// Reapply our custom color, so we stomp the base scheme's
	SetColorStr( m_szColor );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExLabel::SetColorStr( const char *pColor )
{
	IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
	SetColorStr( pScheme->GetColor( pColor, Color( 0, 255, 0, 255 ) ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExLabel::SetColorStr( Color cColor )
{
	Q_snprintf( m_szColor, ARRAYSIZE(m_szColor), "%d %d %d %d", cColor.r(), cColor.g(), cColor.b(), cColor.a() );
	SetFgColor( cColor );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExRichText::CExRichText( Panel *parent, const char *name ) : RichText( parent, name )
{
	m_szFont[0] = '\0';
	m_szColor[0] = '\0';
	m_szImageUpArrow[0] = '\0';
	m_szImageDownArrow[0] = '\0';
	m_szImageLine[0] = '\0';
	m_szImageBox[0] = '\0';
	m_bUseImageBorders = false;
	m_pBox = NULL;
	m_pLine = NULL;

	SetCursor(dc_arrow);

	m_pUpArrow = new CExImageButton( this, "UpArrow", "" );
	if ( m_pUpArrow )
	{
		m_pUpArrow->AddActionSignalTarget( _vertScrollBar );
		m_pUpArrow->SetCommand(new KeyValues("ScrollButtonPressed", "index", 0));
		m_pUpArrow->GetImage()->SetShouldScaleImage( true );
		m_pUpArrow->SetFgColor( Color( 255, 255, 255, 255 ) );
		m_pUpArrow->SetAlpha( 255 );
		m_pUpArrow->SetPaintBackgroundEnabled( false );
		m_pUpArrow->SetVisible( false );
	}

	m_pDownArrow = new CExImageButton( this, "DownArrow", "" );
	if ( m_pDownArrow )
	{
		m_pDownArrow->AddActionSignalTarget( _vertScrollBar );
		m_pDownArrow->SetCommand(new KeyValues("ScrollButtonPressed", "index", 1));
		m_pDownArrow->GetImage()->SetShouldScaleImage( true );
		m_pDownArrow->SetFgColor( Color( 255, 255, 255, 255 ) );
		m_pDownArrow->SetAlpha( 255 );
		m_pDownArrow->SetPaintBackgroundEnabled( false );
		m_pDownArrow->SetVisible( false );
	}

	_vertScrollBar->SetOverriddenButtons( m_pUpArrow, m_pDownArrow );
	m_pUpArrow->PassMouseTicksTo( _vertScrollBar );
	m_pDownArrow->PassMouseTicksTo( _vertScrollBar );

	vgui::ivgui()->AddTickSignal( GetVPanel() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::CreateImagePanels( void )
{
	if ( m_pBox || m_pLine )
		return;

	if ( m_bUseImageBorders )
	{
		m_pLine = new vgui::Panel( this, "Line" );
		m_pBox = new vgui::Panel( this, "Box" );
	}
	else
	{
		m_pLine = new vgui::ImagePanel( this, "Line" );
		m_pBox = new vgui::ImagePanel( this, "Box" );

		dynamic_cast<vgui::ImagePanel *>(m_pBox)->SetShouldScaleImage( true );
		dynamic_cast<vgui::ImagePanel *>(m_pLine)->SetShouldScaleImage( true );
	}
	m_pBox->SetVisible( false );
	m_pLine->SetVisible( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	SetFontStr( inResourceData->GetString( "font", "Default" ) );
	SetColorStr( inResourceData->GetString( "fgcolor", "RichText.TextColor" ) );

	SetCustomImage( m_pUpArrow->GetImage(), inResourceData->GetString( "image_up_arrow", "chalkboard_scroll_up" ), m_szImageUpArrow );
	SetCustomImage( m_pDownArrow->GetImage(), inResourceData->GetString( "image_down_arrow", "chalkboard_scroll_down" ), m_szImageDownArrow );
	SetCustomImage( m_pLine, inResourceData->GetString( "image_line", "chalkboard_scroll_line" ), m_szImageLine );
	SetCustomImage( m_pBox, inResourceData->GetString( "image_box", "chalkboard_scroll_box" ), m_szImageBox );

	const char *pszMouseover = inResourceData->GetString( "image_up_arrow_mouseover", NULL );
	if ( pszMouseover )
	{
		m_pUpArrow->SetImageArmed( pszMouseover );
		m_pUpArrow->SetImageDefault( m_szImageUpArrow );
	}
	pszMouseover = inResourceData->GetString( "image_down_arrow_mouseover", NULL );
	if ( pszMouseover )
	{
		m_pDownArrow->SetImageArmed( pszMouseover );
		m_pDownArrow->SetImageDefault( m_szImageDownArrow );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::SetFontStr( const char *pFont )
{
	if ( pFont != m_szFont )
	{
		V_strcpy_safe( m_szFont, pFont );
	}

	IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
	SetFont( pScheme->GetFont( m_szFont, true ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::SetColorStr( const char *pColor )
{
	if ( pColor != m_szColor )
	{
		V_strcpy_safe( m_szColor, pColor );
	}

	IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
	SetFgColor( pScheme->GetColor( m_szColor, Color( 255, 255, 255, 255 ) ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::SetCustomImage( vgui::Panel *pImage, const char *pszImage, char *pszStorage )
{
	if ( pszStorage )
	{
		V_strcpy( pszStorage, pszImage );
	}
	if ( !pImage )
		return;

	if ( m_bUseImageBorders )
	{
		vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
		IBorder *pBorder = pScheme->GetBorder( pszImage );

		if ( pBorder )
		{
			pImage->SetBorder( pBorder );
			return;
		}
	}

	vgui::ImagePanel *pImagePanel = dynamic_cast<vgui::ImagePanel *>(pImage);
	if ( pImagePanel )
	{
		pImagePanel->SetImage( pszImage );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::ApplySchemeSettings( IScheme *pScheme )
{
	CreateImagePanels();

	BaseClass::ApplySchemeSettings( pScheme );

	// Reapply any custom font/color, so we stomp the base scheme's
	SetFontStr( m_szFont );
	SetColorStr( m_szColor );
	SetCustomImage( m_pUpArrow->GetImage(), m_szImageUpArrow, NULL );
	SetCustomImage( m_pDownArrow->GetImage(), m_szImageDownArrow, NULL );
	SetCustomImage( m_pLine, m_szImageLine, NULL );
	SetCustomImage( m_pBox, m_szImageBox, NULL );

	SetBorder( pScheme->GetBorder( "NoBorder" ) );
	SetBgColor( pScheme->GetColor( "Blank", Color( 0,0,0,0 ) ) );
	SetPanelInteractive( false );
	SetUnusedScrollbarInvisible( true );

	if ( m_pDownArrow  )
	{
		m_pDownArrow->SetFgColor( Color( 255, 255, 255, 255 ) );
	}

	if ( m_pUpArrow  )
	{
		m_pUpArrow->SetFgColor( Color( 255, 255, 255, 255 ) );
	}

	SetScrollBarImagesVisible( false );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::PerformLayout()
{
	BaseClass::PerformLayout();

	if ( _vertScrollBar )
	{
		_vertScrollBar->SetZPos( 500 );
		m_pUpArrow->SetZPos( 501 );
		m_pDownArrow->SetZPos( 501 );
		
		// turn off painting the vertical scrollbar
		_vertScrollBar->SetPaintBackgroundEnabled( false );
		_vertScrollBar->SetPaintBorderEnabled( false );
		_vertScrollBar->SetPaintEnabled( false );
		_vertScrollBar->SetScrollbarButtonsVisible( false );
		_vertScrollBar->GetButton(0)->SetMouseInputEnabled( false );
		_vertScrollBar->GetButton(1)->SetMouseInputEnabled( false );
		
		if (  _vertScrollBar->IsVisible() )
		{
			int nMin, nMax;
			_vertScrollBar->GetRange( nMin, nMax );
			_vertScrollBar->SetValue( nMin );

			int nScrollbarWide = _vertScrollBar->GetWide();

			int wide, tall;
			GetSize( wide, tall );

			if ( m_pUpArrow )
			{
				m_pUpArrow->SetBounds( wide - nScrollbarWide, 0, nScrollbarWide, nScrollbarWide );
				m_pUpArrow->GetImage()->SetSize( nScrollbarWide, nScrollbarWide );
			}

			if ( m_pLine )
			{
				m_pLine->SetBounds( wide - nScrollbarWide, nScrollbarWide, nScrollbarWide, tall - ( 2 * nScrollbarWide ) );
			}

			if ( m_pBox )
			{
				m_pBox->SetBounds( wide - nScrollbarWide, nScrollbarWide, nScrollbarWide, nScrollbarWide );
			}

			if ( m_pDownArrow )
			{
				m_pDownArrow->SetBounds( wide - nScrollbarWide, tall - nScrollbarWide, nScrollbarWide, nScrollbarWide );
				m_pDownArrow->GetImage()->SetSize( nScrollbarWide, nScrollbarWide );
			}

			SetScrollBarImagesVisible( false );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::SetText( const wchar_t *text )
{
	wchar_t buffer[2048];
	Q_wcsncpy( buffer, text, sizeof( buffer ) );

	// transform '\r' to ' ' to eliminate double-spacing on line returns
	for ( wchar_t *ch = buffer; *ch != 0; ch++ )
	{
		if ( *ch == '\r' )
		{
			*ch = ' ';
		}
	}

	BaseClass::SetText( buffer );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::SetText( const char *text )
{
	char buffer[2048];
	Q_strncpy( buffer, text, sizeof( buffer ) );

	// transform '\r' to ' ' to eliminate double-spacing on line returns
	for ( char *ch = buffer; *ch != 0; ch++ )
	{
		if ( *ch == '\r' )
		{
			*ch = ' ';
		}
	}

	BaseClass::SetText( buffer );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::SetScrollBarImagesVisible( bool visible )
{
	if ( m_pDownArrow && m_pDownArrow->IsVisible() != visible )
	{
		m_pDownArrow->SetVisible( visible );
		m_pDownArrow->SetEnabled( visible );
	}

	if ( m_pUpArrow && m_pUpArrow->IsVisible() != visible )
	{
		m_pUpArrow->SetVisible( visible );
		m_pUpArrow->SetEnabled( visible );
	}

	if ( m_pLine && m_pLine->IsVisible() != visible )
	{
		m_pLine->SetVisible( visible );
	}

	if ( m_pBox && m_pBox->IsVisible() != visible )
	{
		m_pBox->SetVisible( visible );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExRichText::OnTick()
{
	if ( !IsVisible() )
		return;

	if ( m_pDownArrow && m_pUpArrow && m_pLine && m_pBox )
	{
		if ( _vertScrollBar && _vertScrollBar->IsVisible() )
		{
			// turn on our own images
			SetScrollBarImagesVisible ( true );

			// set the alpha on the up arrow
			int nMin, nMax;
			_vertScrollBar->GetRange( nMin, nMax );
			int nScrollPos = _vertScrollBar->GetValue();
			int nRangeWindow = _vertScrollBar->GetRangeWindow();
			int nBottom = nMax - nRangeWindow;
			if ( nBottom < 0 )
			{
				nBottom = 0;
			}

			// set the alpha on the up arrow
			int nAlpha = ( nScrollPos - nMin <= 0 ) ? 90 : 255;
			m_pUpArrow->SetAlpha( nAlpha );

			// set the alpha on the down arrow
			nAlpha = ( nScrollPos >= nBottom ) ? 90 : 255;
			m_pDownArrow->SetAlpha( nAlpha );

			ScrollBarSlider *pSlider = _vertScrollBar->GetSlider();
			if ( pSlider && pSlider->GetRangeWindow() > 0 )
			{
				int x, y, w, t, min, max;
				m_pLine->GetBounds( x, y, w, t );
				pSlider->GetNobPos( min, max );

				m_pBox->SetBounds( x, y + min, w, ( max - min ) );
			}
		}
		else
		{
			// turn off our images
			SetScrollBarImagesVisible ( false );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Rich text control that knows how to fill itself with information 
//			that describes a specific item definition.
//-----------------------------------------------------------------------------
CEconItemDetailsRichText::CEconItemDetailsRichText( vgui::Panel *parent, const char *panelName )
:	BaseClass( parent, panelName ),
	m_bAllowItemSetLinks( false ),
	m_bLimitedItem( false ),
	m_hLinkFont( INVALID_FONT )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	const char *pszHighlightColor = inResourceData->GetString( "highlight_color", "Orange" );
	const char *pszItemSetColor = inResourceData->GetString( "itemset_color", "Blue" );
	const char *pszLinkColor = inResourceData->GetString( "link_color", "LightOrange" );
	IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
	m_colTextHighlight = pScheme->GetColor( pszHighlightColor, Color( 255, 255, 255, 255 ) );
	m_colItemSet = pScheme->GetColor( pszItemSetColor, Color( 255, 255, 255, 255 ) );
	m_colLink = pScheme->GetColor( pszLinkColor, Color( 255, 255, 255, 255 ) );
	m_hLinkFont = pScheme->GetFont( "Link", true );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	SetUnderlineFont( m_hLinkFont );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::UpdateDetailsForItem( const CEconItemDefinition *pDef )
{
	SetText( "" );

	if ( !m_ToolList.Count() )
	{
		UpdateToolList();
	}

	DataText_AppendStoreFlags( pDef );
	DataText_AppendItemData( pDef );
	DataText_AppendAttributeData( pDef );
	DataText_AppendUsageData( pDef );
	DataText_AppendToolUsage( pDef );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::AddDataText( const char *pszText, bool bAddPostLines, const wchar_t *wpszArg, const wchar_t *wpszArg2, const int *pItemDefIndex )
{
	static wchar_t wszConstructedString[4096];
	static wchar_t wszText[4096];

	if ( pszText[0] != '#' )
	{
		InsertString( pszText );
		return;
	}

	wchar_t *pLocText = g_pVGuiLocalize->Find( pszText );
	if ( wpszArg && pLocText )
	{
		if ( wpszArg2 )
		{
			g_pVGuiLocalize->ConstructString_safe( wszConstructedString, pLocText, 2, wpszArg, wpszArg2 );
		}
		else
		{
			g_pVGuiLocalize->ConstructString_safe( wszConstructedString, pLocText, 1, wpszArg );
		}
		pLocText = wszConstructedString;
	}

	if ( pLocText )
	{
		enum
		{
			STATE_COLOR_NORMAL = 1,
			STATE_COLOR_HINT,
			STATE_COLOR_ITEMSET,
			STATE_LINK_START,
			STATE_LINK_STOP,
		};

		Color color = GetFgColor();
		Color newColor = color;
		int startIdx = 0;
		int endIdx = 0;
		bool bContinue = true;
		bool bInLink = false;
		while ( bContinue )
		{
			bool bSetText = false;
			bool bEnd = false;

			switch ( pLocText[endIdx] )
			{
			case 0:
				bContinue = false;
				bSetText = true;
				bEnd = true;
				break;
			case STATE_COLOR_NORMAL:
				newColor = GetFgColor();
				bSetText = true;
				break;
			case STATE_COLOR_HINT:
				newColor = m_colTextHighlight;
				bSetText = true;
				break;
			case STATE_COLOR_ITEMSET:
				newColor = m_colItemSet;
				bSetText = true;
				break;
			case STATE_LINK_START:
				bInLink = true;
				break;
			}

			if ( startIdx != endIdx )
			{
				if ( bSetText )
				{
					// copy the colored text to wide
					int len = endIdx - startIdx + 1;
					wcsncpy( wszText, pLocText + startIdx, len );
					wszText[len-1] = 0;

					// If the next character isn't the end of a link, insert the string
					if ( bInLink && pItemDefIndex )
					{
						InsertItemLink( wszText, *pItemDefIndex, &color );				
					}
					else
					{
						InsertColorChange( color );
						InsertString( wszText );
					}
					bInLink = false;
					color = newColor;

					// skip past the color change character
					startIdx = endIdx + 1;
				}
			}
			++endIdx;
		}

		if ( bAddPostLines )
		{
			InsertString( L"\n\n" );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::DataText_AppendUsageData( const CEconItemDefinition *pBaseDef )
{
	// Don't show class/slot usage for class/slot tokens
	if ( pBaseDef->GetItemClass() && ( !V_strcmp( pBaseDef->GetItemClass(), "class_token" ) || !V_strcmp( pBaseDef->GetItemClass(), "slot_token" ) ) )
		return;

#if defined(TF_DLL) || defined(TF_CLIENT_DLL)
	const CTFItemDefinition *pDef = dynamic_cast< const CTFItemDefinition *>( pBaseDef );
	if ( !pDef )
		return;

	// Class usage
	if ( pDef->CanBeUsedByAllClasses() )
	{
		if ( pDef->GetBundleInfo() != NULL )
		{
			AddDataText( "#TF_Armory_Item_ClassUsageAllBundle", false );
		}
		else
		{
			AddDataText( "#TF_Armory_Item_ClassUsageAll", false );
		}
		AddDataText( "\n" );
	}
	else
	{
		bool bFirst = true;
		for ( int i = TF_FIRST_NORMAL_CLASS; i < TF_LAST_NORMAL_CLASS; i++ )
		{
			if ( pDef->CanBeUsedByClass(i) )
			{
				if ( bFirst )
				{
					bFirst = false;

					if ( pDef->GetBundleInfo() != NULL )
					{
						AddDataText( "#TF_Armory_Item_ClassUsageBundle", false );
					}
					else
					{
						AddDataText( "#TF_Armory_Item_ClassUsage", false );
					}
				}
				else
				{
					AddDataText( ", " );
				}

				const wchar_t *pwszClassName = g_pVGuiLocalize->Find( g_aPlayerClassNames[i] );
				if ( pwszClassName )
				{
					InsertColorChange( m_colTextHighlight );
					InsertString( pwszClassName );
					InsertColorChange( GetFgColor() );
				}
			}
		}
		if ( !bFirst )
		{
			AddDataText( ".\n" );
		}
	}

	// Slot usage. First, find out if everyone uses it in the same slot, or whether it's used in different slots per class
	bool bHasPerClassSlots = false;
	int iDefaultSlot = pDef->GetDefaultLoadoutSlot();
	for ( int i = TF_FIRST_NORMAL_CLASS; i < TF_LAST_NORMAL_CLASS; i++ )
	{
		if ( !pDef->CanBeUsedByClass(i) )
			continue;

		int iClassSlot = pDef->GetLoadoutSlot(i);
		if ( iClassSlot != iDefaultSlot )
		{
			bHasPerClassSlots = true;
			break;
		}
	}
	// Now print the easy line, or the per-class lines
	if ( !bHasPerClassSlots )
	{
		if ( iDefaultSlot != -1 )
		{
			AddDataText( "#TF_Armory_Item_SlotUsageAll", true, g_pVGuiLocalize->Find( ItemSystem()->GetItemSchema()->GetLoadoutStringsForDisplay( pDef->GetEquipType() )[iDefaultSlot] ) );
		}
	}
	else
	{
		bool bFirst = true;
		for ( int i = TF_FIRST_NORMAL_CLASS; i < TF_LAST_NORMAL_CLASS; i++ )
		{
			if ( !pDef->CanBeUsedByClass(i) )
				continue;

			if ( bFirst )
			{
				bFirst = false;
				AddDataText( "#TF_Armory_Item_SlotUsageClassHeader", false );
			}
			else
			{
				AddDataText( ", " );
			}

			int iClassSlot = pDef->GetLoadoutSlot(i);
			AddDataText( "#TF_Armory_Item_SlotUsageClass", false, g_pVGuiLocalize->Find( ItemSystem()->GetItemSchema()->GetLoadoutStringsForDisplay( pDef->GetEquipType() )[iClassSlot] ), g_pVGuiLocalize->Find( g_aPlayerClassNames[i] ) );
		}
		if ( !bFirst )
		{
			AddDataText( ".\n\n" );
		}
	}
#endif // #if defined(TF_DLL) || defined(TF_CLIENT_DLL)
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::DataText_AppendToolUsage( const CEconItemDefinition *pDef )
{
	// Loop through the tools, and list any that can be applied to this item
	bool bFirstTool = true;
	for ( int i = 0; i < m_ToolList.Count(); i++ )
	{
		const GameItemDefinition_t *pToolDef = dynamic_cast<const GameItemDefinition_t *>( GetItemSchema()->GetItemDefinition( m_ToolList[i] ) );

		if ( !CEconSharedToolSupport::ToolCanApplyToDefinition( pToolDef, dynamic_cast<const GameItemDefinition_t *>( pDef ) ) )
			continue;

		if ( bFirstTool )
		{
			bFirstTool = false;
			AddDataText( "#TF_Armory_Item_ToolUsage", false );
		}
		else
		{
			AddDataText( ", " );
		}

		// Create a link to the item
		{
			// we need an econ item view here for just the item name
			CEconItemView tmpTool;
			tmpTool.Init( m_ToolList[i], AE_USE_SCRIPT_VALUE, AE_USE_SCRIPT_VALUE, true );

			InsertItemLink( tmpTool.GetItemName(), pToolDef->GetDefinitionIndex() );
		}
	}
	if ( !bFirstTool )
	{
		AddDataText( ".\n" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::DataText_AppendStoreFlags( const CEconItemDefinition *pDef )
{
	if ( !ItemSystem() || !ItemSystem()->GetItemSchema() )
		return;

	const bool bHolidayRestriction = pDef->GetHolidayRestriction() != NULL && V_strlen( pDef->GetHolidayRestriction() ) > 0;
	if ( bHolidayRestriction )
	{
		wchar_t *pRestrictedText = g_pVGuiLocalize->Find( "#Store_HolidayRestrictionText" );

		if ( pRestrictedText )
		{
			InsertColorChange( Color( 200, 80, 60, 255 ) );
			InsertString( pRestrictedText );
			InsertString( L".\n\n" );
		}
	}

	if ( m_bLimitedItem )
	{
		wchar_t *pLocText = bHolidayRestriction
						  ? g_pVGuiLocalize->Find( "#TF_Armory_Item_Limited_Holiday" )
						  : g_pVGuiLocalize->Find( "#TF_Armory_Item_Limited" );
		
		if ( pLocText )
		{
			InsertColorChange( Color( 255, 140, 0, 255 ) );
			InsertString ( pLocText );
			InsertString( L"\n\n" );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::DataText_AppendItemData( const CEconItemDefinition *pDef )
{
	if ( !GetItemSchema() )
		return;

	// Start by looking for a specified armory desc string
	const char *pDesc = pDef->GetArmoryDescString();
	if ( pDesc && pDesc[0] )
	{
		const ArmoryStringDict_t &ArmoryItemData = ItemSystem()->GetItemSchema()->GetArmoryDataItems();

		// Tokenize it, and look for localization strings for each token
		CUtlVector< char * > vecArmoryKeys;
		Q_SplitString( pDesc, " ", vecArmoryKeys );
		FOR_EACH_VEC( vecArmoryKeys, i )
		{
			int iIdx = ArmoryItemData.Find( vecArmoryKeys[i] );
			if ( ArmoryItemData.IsValidIndex( iIdx ) )
			{
				const char *pLoc = ArmoryItemData.Element( iIdx ).Get();
				AddDataText( pLoc );
			}
		}
		vecArmoryKeys.PurgeAndDeleteElements();
	}

	// Is this item part of a set?
	if ( pDef->GetItemSetDefinition() )
	{
		DataText_AppendSetData( pDef );
	}

	if ( pDef->GetBundleInfo() != NULL )
	{
		DataText_AppendBundleData( pDef );
	}

	// Does this item type have data associated with it?
	const ArmoryStringDict_t &ArmoryItemTypeData = GetItemSchema()->GetArmoryDataItemTypes();
	int iIdx = ArmoryItemTypeData.Find( pDef->GetItemTypeName() );
	if ( ArmoryItemTypeData.IsValidIndex( iIdx ) )
	{
		const char *pLoc = ArmoryItemTypeData.Element( iIdx ).Get();
		AddDataText( pLoc );
	}

	// Does this item class have data associated with it?
	const ArmoryStringDict_t &ArmoryItemClassData = GetItemSchema()->GetArmoryDataItemClasses();
	iIdx = pDef->GetItemClass() ? ArmoryItemClassData.Find( pDef->GetItemClass() ) : ArmoryItemClassData.InvalidIndex();
	if ( ArmoryItemClassData.IsValidIndex( iIdx ) )
	{
		if ( !pDef->GetDefinitionKey( "hack_disable_armory_type_desc" ) )
		{
			const char *pLoc = ArmoryItemClassData.Element( iIdx ).Get();
			AddDataText( pLoc );
		}
	}

	// Can this item be earned by an achievement?
	const AchievementAward_t *pAchievementAward = GetItemSchema()->GetAchievementRewardByDefIndex( pDef->GetDefinitionIndex() );
	if( pAchievementAward )
	{
		wchar_t *pszAchName = ACHIEVEMENT_LOCALIZED_NAME_FROM_STR( pAchievementAward->m_sNativeName.String() );
		if ( pszAchName )
		{
			AddDataText( "#TF_Armory_Item_AchievementReward", true, pszAchName );
		}
	}

	// Is this a Holiday item?
	if ( pDef->GetHolidayRestriction() )
	{
		AddDataText( "#TF_Armory_Item_HolidayRestriction" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::DataText_AppendBundleData( const CEconItemDefinition *pDef )
{
	bool bFirstItem = true;

	const bundleinfo_t *pBundleInfo = pDef->GetBundleInfo();
	FOR_EACH_VEC( pBundleInfo->vecItemDefs, i )
	{
		CEconItemDefinition *pBundledItem = pBundleInfo->vecItemDefs[i];
		if ( pBundledItem )
		{
			if ( bFirstItem )
			{
				bFirstItem = false;
				AddDataText( "#TF_Armory_Item_Bundle", false );
			}
			else
			{
				AddDataText( ", " );
			}

			CEconItemView bundleItemData;
			bundleItemData.Init( pBundledItem->GetDefinitionIndex(), AE_UNIQUE, AE_USE_SCRIPT_VALUE, true );

			InsertItemLink( bundleItemData.GetItemName(), bundleItemData.GetItemDefIndex() );
		}
	}

	if ( !bFirstItem )
	{
		AddDataText( ".\n\n" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::DataText_AppendAttributeData( const CEconItemDefinition *pDef )
{
	if ( !ItemSystem() || !ItemSystem()->GetItemSchema() )
		return;

	const ArmoryStringDict_t &ArmoryAttribData = ItemSystem()->GetItemSchema()->GetArmoryDataAttributes();

	CVarBitVec m_AttribsShown;
	m_AttribsShown.Resize( ArmoryAttribData.Count() );
	m_AttribsShown.ClearAll();

	const CUtlVector<static_attrib_t> &vecStaticAttribs = pDef->GetStaticAttributes();
	FOR_EACH_VEC( vecStaticAttribs, i )
	{
		const static_attrib_t &attrib = vecStaticAttribs[i];
		CEconItemAttributeDefinition *pAttributeDef = ItemSystem()->GetStaticDataForAttributeByDefIndex( attrib.iDefIndex );
		if ( !pAttributeDef )
			continue;
		if ( pAttributeDef->IsHidden() )
			continue;

		const char *pDesc = pAttributeDef->GetArmoryDescString();
		if ( !pDesc || !pDesc[0] )
			continue;

		// Tokenize it, and look for localization strings for each token
		CUtlVector< char * > vecArmoryKeys;
		Q_SplitString( pDesc, " ", vecArmoryKeys );
		FOR_EACH_VEC( vecArmoryKeys, iKey )
		{
			int iIdx = ArmoryAttribData.Find( vecArmoryKeys[iKey] );
			if ( ArmoryAttribData.IsValidIndex( iIdx ) )
			{
				if ( m_AttribsShown[iIdx] == false )
				{
					const char *pLoc = ArmoryAttribData.Element( iIdx ).Get();
					AddDataText( pLoc );

					m_AttribsShown.Set( iIdx );
				}
			}
		}

		vecArmoryKeys.PurgeAndDeleteElements();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::DataText_AppendSetData( const CEconItemDefinition *pDef )
{
	if ( !ItemSystem() || !ItemSystem()->GetItemSchema() )
		return;

	CEconItemSchema *pSchema = ItemSystem()->GetItemSchema();
	if ( pSchema )
	{
		const CEconItemSetDefinition *pItemSet = pDef->GetItemSetDefinition();
		if ( pItemSet )
		{
			// Does this set provide bonus attributes when completely worn?
			if ( pItemSet->m_iAttributes.Count() > 0 )
			{
				// Used for grabbing display colors.
				vgui::HScheme hScheme = vgui::scheme()->GetScheme( "ClientScheme" );
				vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( hScheme );

				Assert( pScheme );

				// Insert the set description
				wchar_t *pLocText = g_pVGuiLocalize->Find( pItemSet->m_pszLocalizedName );
				AddDataText( "#TF_Armory_Item_InSet", false, pLocText, NULL, m_bAllowItemSetLinks ? &pItemSet->m_iBundleItemDef : NULL );

				for ( int i = 0;  i < pItemSet->m_iAttributes.Count(); i++ )
				{
					const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinition( pItemSet->m_iAttributes[i].m_iAttribDefIndex );
					if ( !pAttrDef )
						continue;

					CEconAttributeDescription AttrDesc( GLocalizationProvider(), pAttrDef, pItemSet->m_iAttributes[i].m_flValue );
					if ( !AttrDesc.GetDescription().IsEmpty() )
					{
						InsertColorChange( pScheme->GetColor( GetColorNameForAttribColor( AttrDesc.GetDefaultColor() ), Color(255, 255, 255, 255) ) );
						AddDataText( "      " );
						InsertString( AttrDesc.GetDescription().Get() );
						AddDataText( "\n" );
					}
				}

				AddDataText( "\n" );
			}
			// This set is visual and provides no additional bonuses when worn completely.
			else
			{
				// Insert the set description
				wchar_t *pLocText = g_pVGuiLocalize->Find( pItemSet->m_pszLocalizedName );
				AddDataText( "#TF_Armory_Item_InSet_NoBonus", false, pLocText, NULL, m_bAllowItemSetLinks ? &pItemSet->m_iBundleItemDef : NULL );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::UpdateToolList( void )
{
	m_ToolList.Purge();

	// Find all the tool types in our items list
	const CEconItemSchema::ToolsItemDefinitionMap_t &mapItemDefs = ItemSystem()->GetItemSchema()->GetToolsItemDefinitionMap();
	FOR_EACH_MAP( mapItemDefs, i )
	{
		const CEconItemDefinition *pDef = mapItemDefs[i];
		if ( !pDef->GetItemClass() )
			continue;

		if ( !pDef->IsTool() )
			continue;

		const IEconTool *pEconTool = pDef->GetEconTool();
		if ( !pEconTool )
			continue;

		if ( !pEconTool->ShouldDisplayAsUseableOnItemsInArmory() )
			continue;

		// Now make sure it doesn't have the same type as an existing tool
		bool bAlreadyFound = false;
		
		FOR_EACH_VEC( m_ToolList, tool )
		{
			CEconItemDefinition *pOtherDef = ItemSystem()->GetStaticDataForItemByDefIndex( m_ToolList[tool] );
			Assert( pOtherDef );
				
			const IEconTool *pOtherEconTool = pOtherDef->GetEconTool();
			Assert( pOtherEconTool );
				
			bAlreadyFound = !V_strcmp( pEconTool->GetTypeName(), pOtherEconTool->GetTypeName() );
			if ( bAlreadyFound )
			{
				break;
			}
		}
		
		if ( !bAlreadyFound )
		{
			m_ToolList.AddToTail( pDef->GetDefinitionIndex() );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDetailsRichText::InsertItemLink( const wchar_t *pwzItemName, int iItemDef, Color *pColorOverride )
{
	char szTmpToolName[256];
	::ILocalize::ConvertUnicodeToANSI(pwzItemName, szTmpToolName, sizeof( szTmpToolName ));
	char szToolStoreURL[256];
	V_snprintf( szToolStoreURL, sizeof( szToolStoreURL ), "<a href=item://%u>%s</a>", iItemDef, szTmpToolName );
	InsertPossibleURLString( szToolStoreURL, pColorOverride ? *pColorOverride : m_colLink, GetFgColor() );
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExplanationPopup::CExplanationPopup(Panel *parent, const char *panelName) : vgui::EditablePanel( parent, panelName )
{
	m_pCallout = new CExplanationPopupCalloutArrow( parent );
	m_pCallout->SetVisible( false );
	m_pCallout->SetAutoDelete( false );

	m_szPrevExplanation[0] = '\0';
	m_szNextExplanation[0] = '\0';
	m_bFinishedPopup = false;

	ListenForGameEvent( "gameui_hidden" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CExplanationPopup::~CExplanationPopup( void )
{
	m_pCallout->MarkForDeletion();
	m_pCallout = NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::OnCommand( const char *command )
{
	if ( !Q_stricmp( command, "close" ) )
	{
		Hide( 0 );
	}
	else if ( !Q_stricmp( command, "nextexplanation" ) )
	{
		Hide( 1 );
	}
	else if ( !Q_stricmp( command, "prevexplanation" ) )
	{
		Hide( -1 );
	}
	else 
	{
		BaseClass::OnCommand( command );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::Hide( int iExplanationDelta ) 
{
	int iPos = m_iPositionInChain;
	const char *pszMoveTo = NULL;
	if ( iExplanationDelta == -1 )
	{
		if ( !m_szPrevExplanation || m_szPrevExplanation[ 0 ] == '\0' )
			return;

		pszMoveTo = m_szPrevExplanation;
		iPos--;
	}
	else if ( iExplanationDelta == 1 )
	{
		if ( !m_szNextExplanation || m_szNextExplanation[ 0 ] == '\0' )
			return;

		pszMoveTo = m_szNextExplanation;
		iPos++;
	}

	SetVisible( false ); 
	m_pCallout->SetVisible( false ); 
	vgui::ivgui()->RemoveTickSignal( GetVPanel() );

	if ( m_bForceClose )
	{
		TFModalStack()->PopModal( this );
	}

	if ( iExplanationDelta == 0 )
	{
		if ( GetParent() )
		{
			GetParent()->NavigateTo();
		}

		return;
	}

	CExplanationPopup *pPopup = dynamic_cast<CExplanationPopup*>( GetParent()->FindChildByName( pszMoveTo ) );
	if ( pPopup )
	{
		pPopup->Popup( iPos, m_iTotalInChain );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::Popup( int iPosition, int iTotalPanels )
{
	// Parent this to our parent. Doing it in our constructor doesn't work because
	// the parent passed in there hasn't been initialized properly.
	m_pCallout->SetParent( GetParent() );
	m_pCallout->SetZPos( GetZPos() - 1 );

	if ( m_bForceClose )
	{
		TFModalStack()->PushModal( this );
	}

	// If they don't specify X,Y,W,H, we start tiny on the callout position
	if ( !m_iStartX && !m_iStartY )
	{
		m_iStartX = m_iCalloutInParentsX;
		m_iStartY = m_iCalloutInParentsY;
	}
	if ( !m_iStartW && !m_iStartH )
	{
		m_iStartW = 1;
		m_iStartH = 1;
	}

	// If we weren't given a position, we're the first in a chain. Figure out
	// how many there are in the total chain.
	m_iPositionInChain = iPosition;
	m_iTotalInChain = iTotalPanels;
	if ( !m_iTotalInChain )
	{
		m_iTotalInChain = 0;
		m_iPositionInChain = 1;
		CExplanationPopup *pPopup = this;
		while ( pPopup )
		{
			m_iTotalInChain++;

			const char *pszNext = pPopup->GetNextExplanation();
			if ( !pszNext[0] )
				break;

			const char *pszPrev = pPopup->GetName();
			pPopup = dynamic_cast<CExplanationPopup*>( GetParent()->FindChildByName( pszNext ) );
			if ( pPopup )
			{
				pPopup->SetPrevExplanation( pszPrev );
			}
		}
	}

	// Now assemble our position label 
	char szTmp[16];
	Q_snprintf(szTmp, 16, "%d/%d", m_iPositionInChain, m_iTotalInChain );
	SetDialogVariable( "explanationnumber", szTmp );

	SetBounds( m_iStartX, m_iStartY, m_iStartW, m_iStartH );
	SetVisible( true );
	vgui::ivgui()->AddTickSignal( GetVPanel() );

	m_flStartTime = Plat_FloatTime();
	m_flEndTime = m_flStartTime + 0.5;
	m_bFinishedPopup = false;

	// If our endX & endW is going to result in us being off the side of the screen, move back on
	if ( m_iEndX < 0 )
	{
		m_iEndX = XRES(5);
	}
	else if ( (m_iEndX + m_iEndW) > ScreenWidth() )
	{
		m_iEndX = ScreenWidth() - m_iEndW - XRES(5);
	}

	// Figure out what side of the bubble we should have the arrow attached to
	m_iCalloutSide = EXC_SIDE_TOP;
	Vector vecCallout( m_iCalloutInParentsX, m_iCalloutInParentsY, 0 );
	Vector vecMins( m_iEndX, m_iEndY, 0 );
	Vector vecMaxs( m_iEndX + m_iEndW, m_iEndY + m_iEndH, 0 );
	Vector vecPoint;
	CalcClosestPointOnAABB( vecMins, vecMaxs, vecCallout, vecPoint );

	if ( vecPoint.x == vecMins.x && vecCallout.x != vecMins.x )
	{
		m_iCalloutSide = EXC_SIDE_LEFT;
	}
	else if ( vecPoint.y == vecMins.y && vecCallout.y != vecMins.y  )
	{
		m_iCalloutSide = EXC_SIDE_TOP;
	}
	else if ( vecPoint.x == vecMaxs.x && vecCallout.x != vecMaxs.x  )
	{
		m_iCalloutSide = EXC_SIDE_RIGHT;
	}
	else
	{
		m_iCalloutSide = EXC_SIDE_BOTTOM;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::OnTick( void )
{
	float flElapsed = Plat_FloatTime() - m_flStartTime;
	float flTotal = m_flEndTime - m_flStartTime;
	float flBias = Bias( RemapValClamped( flElapsed, 0.f, flTotal, 0.f, 1.f ), 0.7f );
	flElapsed = flTotal * flBias;

	if ( flElapsed >= flTotal )
	{
		//vgui::ivgui()->RemoveTickSignal( GetVPanel() );
		if ( !m_bFinishedPopup )
		{
			SetBounds( m_iEndX, m_iEndY, m_iEndW, m_iEndH );
			PositionCallout( 1.0 );
			m_bFinishedPopup = true;
		}

		// If we've lost focus, or been hidden, release our modal lock
		if ( !ipanel()->IsFullyVisible( GetVPanel() ))
		{
			Hide(0);
		}
		return;
	}

	int iExpandW = XRES(30);
	int iExpandH = YRES(30);
	int iExpandedW = m_iEndW + iExpandW;
	int iExpandedH = m_iEndH + iExpandH;
	int iExpandedX = m_iEndX - (iExpandW * 0.5);
	int iExpandedY = m_iEndY - (iExpandH * 0.5);

	int iW, iH, iX, iY;
	float flExpandTime = (flTotal * 0.66);

	PositionCallout( RemapVal( flElapsed, 0, flTotal, 0, 1 ) );

// 	iW = RemapValClamped( flElapsed, 0, flTotal, m_iStartW, m_iEndW );
// 	iH = RemapValClamped( flElapsed, 0, flTotal, m_iStartH, m_iEndH );
// 	iX = RemapValClamped( flElapsed, 0, flTotal, m_iStartX, m_iEndX );
// 	iY = RemapValClamped( flElapsed, 0, flTotal, m_iStartY, m_iEndY );
// 	SetBounds( iX, iY, iW, iH );
// 	return;

	if ( flElapsed < flExpandTime )
	{
		// Expand to greater than the end size
		iW = RemapValClamped( flElapsed, 0, flExpandTime, m_iStartW, iExpandedW );
		iH = RemapValClamped( flElapsed, 0, flExpandTime, m_iStartH, iExpandedH );
		iX = RemapValClamped( flElapsed, 0, flExpandTime, m_iStartX, iExpandedX );
		iY = RemapValClamped( flElapsed, 0, flExpandTime, m_iStartY, iExpandedY );
	}
	else
	{
		// Contract to the end size
		iW = RemapValClamped( flElapsed, flExpandTime, flTotal, iExpandedW, m_iEndW );
		iH = RemapValClamped( flElapsed, flExpandTime, flTotal, iExpandedH, m_iEndH );
		iX = RemapValClamped( flElapsed, flExpandTime, flTotal, iExpandedX, m_iEndX );
		iY = RemapValClamped( flElapsed, flExpandTime, flTotal, iExpandedY, m_iEndY );
	}
	SetBounds( iX, iY, iW, iH );
}

void CExplanationPopup::OnKeyCodeTyped( vgui::KeyCode code )
{
	if ( IsVisible() && m_pCallout && m_pCallout->IsVisible() )
	{
		// swallow all keys
		if ( code == KEY_ESCAPE )
		{
			OnCommand( "close" );
			return;
		}
	}

	BaseClass::OnKeyCodePressed( code );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::OnKeyCodePressed( vgui::KeyCode code )
{
	if ( IsVisible() && m_pCallout && m_pCallout->IsVisible() )
	{
		ButtonCode_t nButtonCode = GetBaseButtonCode( code );

		// swallow all keys
		if ( nButtonCode == KEY_XBUTTON_B )
		{
			OnCommand( "close" );
			return;
		}
		else if ( nButtonCode == KEY_XBUTTON_LEFT || 
				  nButtonCode == KEY_XSTICK1_LEFT ||
				  nButtonCode == KEY_XSTICK2_LEFT ||
				  code == KEY_LEFT )
		{
			OnCommand( "prevexplanation" );
			return;
		}
		else if ( nButtonCode == KEY_XBUTTON_RIGHT || 
				  nButtonCode == KEY_XSTICK1_RIGHT ||
				  nButtonCode == KEY_XSTICK2_RIGHT ||
				  code == KEY_RIGHT )
		{
			OnCommand( "nextexplanation" );
			return;
		}
	}

	BaseClass::OnKeyCodePressed( code );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::PositionCallout( float flElapsed )
{
	// Size and position the callout
	if ( !m_pCallout->IsVisible() )
	{
		m_pCallout->SetVisible( true );
	}

	int iCalloutSize = 20;
	int iIndent = 15;

	int iMyPos[2];
	GetPos( iMyPos[0], iMyPos[1] );
	int iMySize[2];
	iMySize[0] = GetWide();
	iMySize[1] = GetTall();

	int iCalloutPos[2];
	iCalloutPos[0] = m_iCalloutInParentsX;
	iCalloutPos[1] = m_iCalloutInParentsY;

	// We need to figure out the three corners of the callout triangle, in parent space
	int iArrowA[2];
	int iArrowB[2];
	int iW, iH, iX, iY;

	// Determine which axis the arrow's extruding along
	int x = (m_iCalloutSide == EXC_SIDE_TOP || m_iCalloutSide == EXC_SIDE_BOTTOM) ? 0 : 1;
	int y = !x;

	// Figure out where the center will be of the arrow on the edge that the arrow's extruding (ensure it's always somewhat indented from the corners)
	iArrowA[x] = iMyPos[x] + clamp( iCalloutPos[x] - iMyPos[x] - XRES(iCalloutSize * 0.5), XRES(iIndent), iMySize[x] - XRES(iIndent) - XRES(iCalloutSize) );
	iArrowB[x] = iArrowA[x] + XRES(iCalloutSize);
	iArrowA[y] = iMyPos[y] + (( iCalloutPos[y] > iMyPos[y] ) ? iMySize[y] : 0);
	iArrowB[y] = iMyPos[y] + (( iCalloutPos[y] > iMyPos[y] ) ? iMySize[y] : 0);

	// Slide the arrow out towards the callout over time.
	for ( int i = 0; i < 2; i++ )
	{
		iCalloutPos[i] = RemapValClamped( flElapsed, 0, 1, iArrowA[i] + (iArrowB[i] - iArrowA[i]), iCalloutPos[i] );
	}

	// Assemble a bounding box that contains the arrow points
	iX = MIN( MIN( iCalloutPos[0], iArrowA[0] ), iArrowB[0] );
	iW = MAX( MAX( iCalloutPos[0], iArrowA[0] ), iArrowB[0] ) - iX;
	iY = MIN( MIN( iCalloutPos[1], iArrowA[1] ), iArrowB[1] );
	iH = MAX( MAX( iCalloutPos[1], iArrowA[1] ), iArrowB[1] ) - iY;
	m_pCallout->SetBounds( iX, iY, iW+1, iH+1 );

	//Msg("CALLOUT: %d %d, %d %d\n", iX,iY,iW,iH );

	// Tell the callout where its points are, so it can draw the triangle (make sure the triangle is facing the camera)
	if ( m_iCalloutSide == EXC_SIDE_TOP || m_iCalloutSide == EXC_SIDE_RIGHT )
	{
		m_pCallout->SetArrowPoints( iCalloutPos[0]-iX, iCalloutPos[1]-iY, iArrowB[0]-iX, iArrowB[1]-iY, iArrowA[0]-iX, iArrowA[1]-iY );
	}
	else
	{
		m_pCallout->SetArrowPoints( iCalloutPos[0]-iX, iCalloutPos[1]-iY, iArrowA[0]-iX, iArrowA[1]-iY, iArrowB[0]-iX, iArrowB[1]-iY );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopupCalloutArrow::Paint( void )
{
	int x,y;
	vgui::ipanel()->GetAbsPos(GetVPanel(), x,y );

	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->Bind( materials->FindMaterial( "vgui/callout_tail", TEXTURE_GROUP_OTHER ), NULL );
	IMesh *pMesh = pRenderContext->GetDynamicMesh();
	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 1 );

	meshBuilder.Color4ub( 255, 255, 255, 255 );
	meshBuilder.TexCoord2f( 0, 1.0,0.5 );
	meshBuilder.Position3f( x + m_iArrowA[0], y + m_iArrowA[1], 1 );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color4ub( 255, 255, 255, 255 );
	meshBuilder.TexCoord2f( 0, 0,1 );
	meshBuilder.Position3f( x + m_iArrowB[0], y + m_iArrowB[1], 1 );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color4ub( 255, 255, 255, 255 );
	meshBuilder.TexCoord2f( 0, 0,0 );
	meshBuilder.Position3f( x + m_iArrowC[0], y + m_iArrowC[1], 1 );
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();

//  	vgui::surface()->DrawSetColor( Color(0,255,0,255) );
//  	vgui::surface()->DrawLine( m_iArrowA[0], m_iArrowA[1], m_iArrowB[0], m_iArrowB[1] );
//  	vgui::surface()->DrawLine( m_iArrowA[0], m_iArrowA[1], m_iArrowC[0], m_iArrowC[1] );
//  	vgui::surface()->DrawLine( m_iArrowB[0], m_iArrowB[1], m_iArrowC[0], m_iArrowC[1] );
//  	vgui::surface()->DrawOutlinedRect( 0,0, GetWide(), GetTall() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	Q_strncpy( m_szNextExplanation, inResourceData->GetString( "next_explanation", "" ), sizeof( m_szNextExplanation ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::SetPrevExplanation( const char *pszPrev )
{
	m_szPrevExplanation[0] = '\0';
	if ( pszPrev && pszPrev[0] )
	{
		Q_strncpy( m_szPrevExplanation, pszPrev, sizeof( m_szPrevExplanation ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExplanationPopup::FireGameEvent( IGameEvent *event )
{
	const char * type = event->GetName();

	if ( Q_strcmp(type, "gameui_hidden") == 0 )
	{
		if ( IsVisible() )
		{
			Hide( 0 );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CPanelModalStack g_ModalStack;
CPanelModalStack *TFModalStack( void )
{
	return &g_ModalStack;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPanelModalStack::PushModal( vgui::Panel *pDialog )
{
	VPanelHandle hHandle;
	hHandle.Set( pDialog->GetVPanel() );

	FOR_EACH_VEC( m_pDialogs, i )
	{
		if ( m_pDialogs[i] == hHandle )
			return;
	}

	m_pDialogs.AddToHead( hHandle );		

	vgui::input()->SetAppModalSurface( pDialog->GetVPanel() );
	pDialog->RequestFocus();
	pDialog->MoveToFront();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPanelModalStack::PopModal( vgui::Panel *pDialog )
{
	bool bFound = false;
	FOR_EACH_VEC_BACK( m_pDialogs, i )
	{
		if ( m_pDialogs[i].Get() == pDialog->GetVPanel() )
		{
			PopModal( i );
			bFound = true;
		}
	}

	AssertMsg( bFound, "CPanelModalStack::PopModal() failed to find the given dialog." );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPanelModalStack::PopModal( int iIdx )
{
	bool bRecalcLock = false;

	// Only release the modal lock if we had it
	VPANEL hPanel = vgui::input()->GetAppModalSurface();
	if ( !hPanel || m_pDialogs[iIdx].Get() == hPanel )
	{
		bRecalcLock = true;
	}

	m_pDialogs.Remove(iIdx);

	if ( bRecalcLock )
	{
		if ( m_pDialogs.Count() )
		{
			vgui::input()->SetAppModalSurface( m_pDialogs[0] );
		}
		else
		{
			vgui::input()->SetAppModalSurface( NULL );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPanelModalStack::Update( void )
{
	if ( m_pDialogs.Count() <= 0 )
		return;

	// Don't run this logic if the game UI isn't visible
	if ( !enginevgui->IsGameUIVisible() )
		return;

	// Safety check: If the app model surface dialog is in our list, make sure it's usable
	VPANEL hPanel = vgui::input()->GetAppModalSurface();

	FOR_EACH_VEC_BACK( m_pDialogs, i )
	{
		// Pop dialogs that didn't correctly remove themselves on delete
		if ( m_pDialogs[i].Get() == 0 )
		{
			PopModal( i );
			continue;
		}

		if ( m_pDialogs[i].Get() == hPanel )
		{
			Assert( vgui::ipanel()->IsFullyVisible(hPanel) );

			// Backup hack: If our modal window is no longer visible, make it visible
			if ( !vgui::ipanel()->IsFullyVisible(hPanel) )
			{
				vgui::ipanel()->SetVisible( hPanel, true );
				vgui::ipanel()->MoveToFront( hPanel );
				vgui::ipanel()->RequestFocus( hPanel );

				// Make sure all our parents are visible too
				VPANEL hParent = vgui::ipanel()->GetParent( hPanel );
				while ( hParent != INVALID_PANEL )
				{
					vgui::Panel *pParentPanel = vgui::ipanel()->GetPanel(hParent, "ClientDLL");
					if ( !pParentPanel )
						break;

					vgui::ipanel()->SetVisible( hParent, true );
					hParent = vgui::ipanel()->GetParent( hParent );
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
vgui::VPanelHandle CPanelModalStack::Top()
{
	if ( m_pDialogs.Count() == 0 )
	{
		return VPanelHandle();	// Defaults to INVALID_PANEL
	}

	return m_pDialogs[0];
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CPanelModalStack::IsEmpty() const
{
	return m_pDialogs.Count() == 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CGenericWaitingDialog::CGenericWaitingDialog( vgui::Panel *pParent )
	: BaseClass( pParent, "GenericWaitingDialog" )
	, m_bAnimateEllipses(false)
	, m_iNumEllipses(0)	  
{
	if ( pParent == NULL )
	{
		vgui::HScheme scheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme");
		SetScheme(scheme);
		SetProportional( true );
	}
}

void CGenericWaitingDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	
	LoadControlSettings( GetResFile(), GetResFilePathId() );
}

void CGenericWaitingDialog::Close()
{
	OnCommand( "close" );
}

void CGenericWaitingDialog::OnCommand( const char *command )
{
	bool bClose = false;
	
	if ( !Q_stricmp( command, "close" ) )
	{
		bClose = true;
	}
	else if ( !Q_stricmp( command, "user_close" ) )
	{
		OnUserClose();
		bClose = true;
	}
	
	if ( bClose )
	{
		TFModalStack()->PopModal( this );
		SetVisible( false );
		MarkForDeletion();			
		return;
	}	
	
	BaseClass::OnCommand( command );
}

void CGenericWaitingDialog::OnTick( void )
{
	BaseClass::OnTick();
	
	if ( !IsVisible() )
	{
		vgui::ivgui()->RemoveTickSignal( GetVPanel() );
	}
	
	if ( m_bAnimateEllipses )
	{
		m_iNumEllipses = ((m_iNumEllipses+1) % 4);
		
		switch ( m_iNumEllipses )
		{
		case 3: SetDialogVariable( "ellipses", L"..." ); break;
		case 2: SetDialogVariable( "ellipses", L".." ); break;
		case 1: SetDialogVariable( "ellipses", L"." ); break;
		default: SetDialogVariable( "ellipses", L"" ); break;
		}
	}

	if ( m_timer.HasStarted() )
	{
		// @note Tom Bui: showing 0 is weird, so just show nothing...
		int iSecondsRemaining = (int)m_timer.GetRemainingTime();
		if ( iSecondsRemaining == 0 )
		{
			SetDialogVariable( "duration", "" );
		}
		else
		{
			SetDialogVariable( "duration", iSecondsRemaining );
		}
		if ( m_timer.IsElapsed() )
		{
			OnCommand( "close" );
			OnTimeout();
		}
	}
}

void CGenericWaitingDialog::ShowStatusUpdate( bool bAnimateEllipses, bool bAllowClose, float flMaxWaitTime )
{
	CExButton *pButton = dynamic_cast<CExButton*>( FindChildByName("CloseButton") );
	if ( pButton )
	{
		pButton->SetVisible( bAllowClose );
		pButton->SetEnabled( bAllowClose );
	}
	
	m_bAnimateEllipses = bAnimateEllipses;
	if ( flMaxWaitTime > 0 )
	{
		m_timer.Start( flMaxWaitTime );
		SetDialogVariable( "duration", (int)flMaxWaitTime );
	}
	else
	{
		m_timer.Invalidate();
		SetDialogVariable( "duration", L"" );
	}
	
	if ( m_bAnimateEllipses )
	{
		m_iNumEllipses = 0;
	}
	
	if ( flMaxWaitTime > 0 || m_bAnimateEllipses )
	{
		vgui::ivgui()->AddTickSignal( GetVPanel(), 500 );
	}
	
	SetDialogVariable( "ellipses", L"" );
}

void CGenericWaitingDialog::OnTimeout()
{
}

void CGenericWaitingDialog::OnUserClose()
{
}

static vgui::DHANDLE< CGenericWaitingDialog > g_WaitingDialog;

void ShowWaitingDialog( CGenericWaitingDialog *pWaitingDialog, const char* pUpdateText, bool bAnimate, bool bShowCancel, float flMaxDuration )
{
	CloseWaitingDialog();
	if ( pWaitingDialog )
	{
		g_WaitingDialog = vgui::SETUP_PANEL( pWaitingDialog );
		g_WaitingDialog->SetVisible( true );
		g_WaitingDialog->MakePopup();
		g_WaitingDialog->MoveToFront();
		g_WaitingDialog->SetKeyBoardInputEnabled(true);
		g_WaitingDialog->SetMouseInputEnabled(true);
		TFModalStack()->PushModal( g_WaitingDialog );

		if ( pUpdateText != NULL )
		{
			g_WaitingDialog->SetDialogVariable( "updatetext", g_pVGuiLocalize->Find( pUpdateText ) );
		}
		g_WaitingDialog->ShowStatusUpdate( bAnimate, bShowCancel, flMaxDuration );
	}
}

void CloseWaitingDialog()
{
	if ( g_WaitingDialog.Get() )
	{
		g_WaitingDialog->Close();
		g_WaitingDialog = NULL;
	}
}

//-----------------------------------------------------------------------------