2383 lines
69 KiB
C++
2383 lines
69 KiB
C++
//========= 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;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|