Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

2382 lines
69 KiB

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