//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "econ_notifications.h"
#include "hudelement.h"
#include "iclientmode.h"
#include "ienginevgui.h"
#include "vgui_avatarimage.h"
#include "vgui_controls/Controls.h"
#include "vgui_controls/EditablePanel.h"
#include "vgui_controls/TextImage.h"
#include "vgui/ILocalize.h"
#include "vgui/ISurface.h"
#include "vgui/IVGui.h"
#include "rtime.h"
#include "econ_controls.h"
#include "hud_basechat.h"
#include "hud_vote.h"
#include "inputsystem/iinputsystem.h"
#include "iinput.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
//-----------------------------------------------------------------------------
ConVar cl_notifications_show_ingame( "cl_notifications_show_ingame", "1", FCVAR_ARCHIVE, "Whether notifications should show up in-game." );
ConVar cl_notifications_max_num_visible( "cl_notifications_max_num_visible", "3", FCVAR_ARCHIVE, "How many notifications are visible in-game." );
ConVar cl_notifications_move_time( "cl_notifications_move_time", "0.5", FCVAR_ARCHIVE, "How long it takes for a notification to move." );
// notification queue holds all the notifications
class CEconNotificationQueue
{
public:
CEconNotificationQueue();
~CEconNotificationQueue();
int AddNotification( CEconNotification *pNotification );
void RemoveAllNotifications();
void RemoveNotification( int iID );
void RemoveNotification( CEconNotification *pNotification );
void RemoveNotifications( NotificationFilterFunc func );
int CountNotifications( NotificationFilterFunc func );
void VisitNotifications( CEconNotificationVisitor &visitor );
CEconNotification *GetNotification( int iID );
CEconNotification *GetNotificationByIndex( int idx );
void Update();
bool HasItems() { return m_vecNotifications.Count() != 0; }
const CUtlVector< CEconNotification *> &GetItems() { return m_vecNotifications; }
private:
int m_iIDGenerator;
CUtlVector< CEconNotification *> m_vecNotifications;
};
static CEconNotificationQueue g_notificationQueue;
CEconNotificationQueue::CEconNotificationQueue()
: m_iIDGenerator(0)
{
}
CEconNotificationQueue::~CEconNotificationQueue()
{
}
int CEconNotificationQueue::AddNotification( CEconNotification *pNotification )
{
int iID = ++m_iIDGenerator;
pNotification->m_iID = iID;
m_vecNotifications.AddToTail( pNotification );
return iID;
}
void CEconNotificationQueue::RemoveAllNotifications()
{
m_vecNotifications.PurgeAndDeleteElements();
}
void CEconNotificationQueue::RemoveNotification( int iID )
{
FOR_EACH_VEC( m_vecNotifications, i )
{
CEconNotification *pNotification = m_vecNotifications[i];
if ( pNotification->GetID() == iID )
{
delete pNotification;
m_vecNotifications.Remove( i );
return;
}
}
}
void CEconNotificationQueue::RemoveNotification( CEconNotification *pNotification )
{
if ( pNotification )
{
RemoveNotification( pNotification->GetID() );
}
}
void CEconNotificationQueue::RemoveNotifications( NotificationFilterFunc func )
{
for ( int i = 0; i < m_vecNotifications.Count(); ++i)
{
CEconNotification *pNotification = m_vecNotifications[i];
if ( func( pNotification ) )
{
pNotification->MarkForDeletion();
}
}
}
int CEconNotificationQueue::CountNotifications( NotificationFilterFunc func )
{
int nResult = 0;
for ( int i = 0; i < m_vecNotifications.Count(); ++i)
{
CEconNotification *pNotification = m_vecNotifications[i];
if ( func( pNotification ) )
{
++nResult;
}
}
return nResult;
}
void CEconNotificationQueue::VisitNotifications( CEconNotificationVisitor &visitor )
{
for ( int i = 0; i < m_vecNotifications.Count(); ++i )
{
CEconNotification *pNotification = m_vecNotifications[i];
visitor.Visit( *pNotification );
}
}
CEconNotification *CEconNotificationQueue::GetNotification( int iID )
{
FOR_EACH_VEC( m_vecNotifications, i )
{
CEconNotification *pNotification = m_vecNotifications[i];
if ( pNotification->GetID() == iID )
{
return pNotification;
}
}
return NULL;
}
CEconNotification *CEconNotificationQueue::GetNotificationByIndex( int idx )
{
if ( idx < 0 || idx >= m_vecNotifications.Count() )
{
Assert( !"Invalid index passed to GetNotificationByIndex" );
return NULL;
}
return m_vecNotifications[idx];
}
void CEconNotificationQueue::Update()
{
float flNowTime = engine->Time();
for ( int i = 0; i < m_vecNotifications.Count(); )
{
CEconNotification *pNotification = m_vecNotifications[i];
if ( pNotification->GetIsInUse() == false && pNotification->GetExpireTime() >= 0 && pNotification->GetExpireTime() < flNowTime )
{
pNotification->Expired();
delete pNotification;
m_vecNotifications.Remove( i );
continue;
}
pNotification->UpdateTick();
++i;
}
}
//-----------------------------------------------------------------------------
static void ColorizeText( CEconNotification *pNotification, CExLabel *pControl, const wchar_t* wszText )
{
static wchar_t wszStrippedText[2048];
if ( pControl == NULL )
return;
pControl->GetTextImage()->ClearColorChangeStream();
if ( wszText == NULL )
{
pControl->SetText( L"" );
return;
}
Color newColor = pControl->GetFgColor();
int endIdx = 0;
int insertIdx = 0;
bool bContinue = true;
while ( bContinue )
{
bool bSetColor = false;
switch ( wszText[endIdx] )
{
case 0:
bContinue = false;
break;
case COLOR_NORMAL:
case COLOR_USEOLDCOLORS:
newColor = pControl->GetFgColor();
bSetColor = true;
break;
case COLOR_PLAYERNAME:
newColor = g_ColorYellow;
bSetColor = true;
break;
case COLOR_LOCATION:
newColor = g_ColorDarkGreen;
bSetColor = true;
break;
case COLOR_ACHIEVEMENT:
{
vgui::IScheme *pSourceScheme = vgui::scheme()->GetIScheme( vgui::scheme()->GetScheme( "SourceScheme" ) );
if ( pSourceScheme )
{
newColor = pSourceScheme->GetColor( "SteamLightGreen", pControl->GetBgColor() );
}
else
{
newColor = pControl->GetFgColor();
}
bSetColor = true;
}
break;
case COLOR_CUSTOM:
newColor = pControl->GetFgColor();
KeyValues *pKeyValues = pNotification->GetKeyValues();
if ( pKeyValues )
{
KeyValues* pColor = pKeyValues->FindKey( "custom_color" );
if ( pColor )
{
newColor = pColor->GetColor();
}
}
bSetColor = true;
break;
}
if ( bSetColor )
{
pControl->GetTextImage()->AddColorChange( newColor, insertIdx );
}
else
{
wszStrippedText[insertIdx++] = wszText[endIdx];
}
++endIdx;
}
pControl->SetText( wszStrippedText );
}
// generic "toast" for notifications
class CGenericNotificationToast : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CGenericNotificationToast, vgui::EditablePanel );
public:
CGenericNotificationToast( vgui::Panel *parent, int iNotificationID, bool bMainMenu );
virtual ~CGenericNotificationToast();
virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
virtual void PerformLayout();
protected:
int m_iNotificationID;
vgui::Panel *m_pAvatarBG;
CAvatarImagePanel *m_pAvatar;
bool m_bMainMenu;
};
CGenericNotificationToast::CGenericNotificationToast( vgui::Panel *parent, int iNotificationID, bool bMainMenu )
: BaseClass( parent, "GenericNotificationToast" )
, m_iNotificationID( iNotificationID )
, m_pAvatar( NULL )
, m_pAvatarBG( NULL )
, m_bMainMenu( bMainMenu )
{
}
CGenericNotificationToast::~CGenericNotificationToast()
{
}
void CGenericNotificationToast::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
CEconNotification *pNotification = NotificationQueue_Get( m_iNotificationID );
bool bHighPriority = pNotification && pNotification->BHighPriority();
KeyValues *pConditions = NULL;
if ( bHighPriority )
{
pConditions = new KeyValues( "conditions" );
if ( bHighPriority )
{
KeyValues *pSubKey = new KeyValues( "if_high_priority" );
pConditions->AddSubKey( pSubKey );
}
}
if ( m_bMainMenu )
{
LoadControlSettings( "Resource/UI/Econ/GenericNotificationToastMainMenu.res", NULL, NULL, pConditions );
}
else
{
LoadControlSettings( "Resource/UI/Econ/GenericNotificationToast.res", NULL, NULL, pConditions );
}
if ( pConditions )
{
pConditions->deleteThis();
}
m_pAvatar = dynamic_cast< CAvatarImagePanel *>( FindChildByName("AvatarImage") );
m_pAvatarBG = FindChildByName("AvatarBGPanel");
if ( pNotification )
{
if ( pNotification->GetSteamID() == CSteamID() )
{
ColorizeText( pNotification, dynamic_cast< CExLabel* >( FindChildByName( "TextLabel" ) ), pNotification->GetText() );
}
else
{
ColorizeText( pNotification, dynamic_cast< CExLabel* >( FindChildByName( "AvatarTextLabel" ) ), pNotification->GetText() );
}
}
}
void CGenericNotificationToast::PerformLayout()
{
BaseClass::PerformLayout();
CSteamID steamID;
CEconNotification *pNotification = NotificationQueue_Get( m_iNotificationID );
if ( pNotification )
{
steamID = pNotification->GetSteamID();
}
int iMinHeight = 0;
if ( m_pAvatar )
{
if ( steamID != CSteamID() )
{
m_pAvatar->SetVisible( true );
m_pAvatar->SetShouldDrawFriendIcon( false );
m_pAvatar->SetPlayer( steamID, k_EAvatarSize64x64 );
// make sure there's a minimum height
// note we use iY to ensure that there's a buffer below too
int iX, iY, iWidth, iHeight;
m_pAvatar->GetBounds( iX, iY, iWidth, iHeight );
iMinHeight = 2 * iY + iHeight;
}
else
{
m_pAvatar->SetVisible( false );
m_pAvatar->ClearAvatar();
}
}
if ( m_pAvatarBG )
{
m_pAvatarBG->SetVisible( m_pAvatar != NULL && m_pAvatar->IsVisible() );
}
const char *pTextLabelName = steamID != CSteamID() ? "AvatarTextLabel" : "TextLabel";
CExLabel* pText = dynamic_cast< CExLabel *>( FindChildByName( pTextLabelName ) );
if ( pText )
{
pText->SetVisible( true );
pText->InvalidateLayout( true, false );
int iWidth, iHeight;
pText->GetSize( iWidth, iHeight );
int iContentWidth, iContentHeight;
pText->GetContentSize( iContentWidth, iContentHeight );
pText->SetSize( iWidth, iContentHeight );
int iDelta = iContentHeight - iHeight;
// resize ourselves to fit
int iContainerWidth, iContainerHeight;
GetSize( iContainerWidth, iContainerHeight );
SetSize( iContainerWidth, MAX( iContainerHeight + iDelta, iMinHeight ) );
}
}
//-----------------------------------------------------------------------------
class CNotificationToastControl : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CNotificationToastControl, vgui::EditablePanel );
public:
CNotificationToastControl( vgui::EditablePanel *pParent, vgui::EditablePanel *pNotificationToast, int iNotificationID, bool bAddControls )
: BaseClass( pParent, bAddControls ? "NotificationToastControl" : "NotificationToastContainer" )
, m_pChild( pNotificationToast )
, m_iNotificationID( iNotificationID )
, m_bAddControls( bAddControls )
, m_pTriggerButton( NULL )
, m_pAcceptButton( NULL )
, m_pDeclineButton( NULL )
, m_iOverrideHeight( 0 )
{
m_pChild->SetParent( this );
}
virtual ~CNotificationToastControl()
{
}
virtual void ApplySchemeSettings( vgui::IScheme *scheme )
{
CEconNotification *pNotification = g_notificationQueue.GetNotification( m_iNotificationID );
// It is not entirely clear why pNotification is allowed to be NULL. Weapon switching
// with pyro was causing crashes because of pNotification being NULL, and there were
// previously existing checks, but it's not clear why.
CEconNotification::EType eNotificationType = pNotification ? pNotification->NotificationType() \
: CEconNotification::eType_Basic;
bool bHighPriority = pNotification && pNotification->BHighPriority();
bool bCanDelete = false;
bool bCanAcceptDecline = false;
bool bCanTrigger = false;
bool bOneButton = false;
switch ( eNotificationType )
{
case CEconNotification::eType_AcceptDecline:
bCanAcceptDecline = true;
break;
case CEconNotification::eType_Basic:
bCanDelete = true;
bOneButton = true;
break;
case CEconNotification::eType_MustTrigger:
bCanTrigger = true;
bOneButton = true;
break;
case CEconNotification::eType_Trigger:
bCanTrigger = true;
bCanDelete = true;
break;
default:
Assert( !"Unhandled enum type" );
}
KeyValues *pConditions = NULL;
if ( bOneButton || bHighPriority )
{
pConditions = new KeyValues( "conditions" );
if ( bOneButton )
{
KeyValues *pSubKey = new KeyValues( "if_one_button" );
pConditions->AddSubKey( pSubKey );
}
if ( bHighPriority )
{
KeyValues *pSubKey = new KeyValues( "if_high_priority" );
pConditions->AddSubKey( pSubKey );
}
}
if ( m_bAddControls )
{
LoadControlSettings( "Resource/UI/Econ/NotificationToastControl.res", NULL, NULL, pConditions );
}
else
{
LoadControlSettings( "Resource/UI/Econ/NotificationToastContainer.res", NULL, NULL, pConditions );
}
if ( pConditions )
{
pConditions->deleteThis();
}
BaseClass::ApplySchemeSettings( scheme );
GetSize( m_iOriginalWidth, m_iOriginalHeight );
CExButton *pDeleteButton = dynamic_cast< CExButton *>( FindChildByName( "DeleteButton" ) );
if ( pDeleteButton && bCanDelete )
{
pDeleteButton->AddActionSignalTarget( this );
pDeleteButton->SetVisible ( pNotification != NULL );
}
if ( pNotification == NULL )
return;
if ( bCanAcceptDecline )
{
m_pAcceptButton = dynamic_cast< CExButton * >( FindChildByName( "AcceptButton" ) );
m_pDeclineButton = dynamic_cast< CExButton * >( FindChildByName( "DeclineButton" ) );
if ( m_pAcceptButton && m_pDeclineButton )
{
m_pAcceptButton->AddActionSignalTarget( this );
m_pDeclineButton->AddActionSignalTarget( this );
m_pAcceptButton->SetVisible( true );
m_pDeclineButton->SetVisible( true );
int posX, posY;
m_pAcceptButton->GetPos( posX, posY );
m_iButtonOffsetY = GetTall() - posY;
}
}
if ( bCanTrigger )
{
m_pTriggerButton = dynamic_cast< CExButton *>( FindChildByName( "TriggerButton" ) );
if ( m_pTriggerButton )
{
m_pTriggerButton->AddActionSignalTarget( this );
m_pTriggerButton->SetVisible( true );
int posX, posY;
m_pTriggerButton->GetPos( posX, posY );
m_iButtonOffsetY = GetTall() - posY;
}
}
}
virtual void PerformLayout()
{
BaseClass::PerformLayout();
m_pChild->PerformLayout();
int iWidth, iHeight;
m_pChild->GetSize( iWidth, iHeight );
// position control buttons
if ( iHeight + m_iButtonOffsetY > m_iOriginalHeight )
{
if ( m_pAcceptButton && m_pDeclineButton )
{
int posX, posY;
m_pAcceptButton->GetPos( posX, posY );
// int newPosY = iHeight;
// iHeight += m_iButtonOffsetY;
// m_pAcceptButton->SetPos( posX, newPosY );
// m_pDeclineButton->GetPos( posX, posY );
// m_pDeclineButton->SetPos( posX, newPosY );
}
else if ( m_pTriggerButton )
{
int posX, posY;
m_pTriggerButton->GetPos( posX, posY );
// posY = iHeight;
// iHeight += m_iButtonOffsetY;
// m_pTriggerButton->SetPos( posX, posY );
}
}
// position help label
CEconNotification *pNotification = g_notificationQueue.GetNotification( m_iNotificationID );
CExLabel *pHelpLabel = dynamic_cast< CExLabel* >( FindChildByName( "HelpTextLabel" ) );
if ( pHelpLabel )
{
if ( pNotification )
{
const wchar_t *pszText = NULL;
const char *pszTextKey = pNotification->GetUnlocalizedHelpText();
if ( pszTextKey )
{
pszText = g_pVGuiLocalize->Find( pszTextKey );
}
if ( pszText )
{
wchar_t wzFinal[512] = L"";
if ( ::input->IsSteamControllerActive() )
{
UTIL_ReplaceKeyBindings( pszText, 0, wzFinal, sizeof( wzFinal ), GAME_ACTION_SET_FPSCONTROLS );
}
else
{
UTIL_ReplaceKeyBindings( pszText, 0, wzFinal, sizeof( wzFinal ) );
}
ColorizeText( pNotification, pHelpLabel, wzFinal );
}
}
pHelpLabel->InvalidateLayout( true, false );
int posX, posY;
pHelpLabel->GetPos( posX, posY );
int iContentWidth, iContentHeight;
pHelpLabel->GetContentSize( iContentWidth, iContentHeight );
int iLabelWidth, iLabelHeight;
pHelpLabel->GetSize( iLabelWidth, iLabelHeight );
int iTextInsetX, iTextInsetY;
pHelpLabel->GetTextInset( &iTextInsetX, &iTextInsetY );
pHelpLabel->SetSize( iLabelWidth, iContentHeight + iTextInsetY );
posY = iHeight;
pHelpLabel->SetPos( posX, posY - iTextInsetY );
iHeight += iContentHeight + iTextInsetY;
}
// resize ourselves to fit the child height wise
int iContainerHeight = MAX( m_iOriginalHeight, iHeight );
SetSize( m_iOriginalWidth, m_iOverrideHeight != 0 ? m_iOverrideHeight : iContainerHeight );
}
virtual void OnCommand( const char *command )
{
CEconNotification *pNotification = g_notificationQueue.GetNotification( m_iNotificationID );
if ( pNotification != NULL )
{
if ( !Q_strncmp( command, "delete", ARRAYSIZE( "delete" ) ) )
{
pNotification->Deleted();
g_notificationQueue.RemoveNotification( m_iNotificationID );
return;
}
else if ( !Q_strncmp( command, "trigger", ARRAYSIZE( "trigger" ) ) )
{
pNotification->Trigger();
}
else if ( !Q_strncmp( command, "accept", ARRAYSIZE( "accept" ) ) )
{
pNotification->Accept();
}
else if ( !Q_strncmp( command, "decline", ARRAYSIZE( "decline" ) ) )
{
pNotification->Decline();
}
else
{
BaseClass::OnCommand( command );
}
}
else
{
BaseClass::OnCommand( command );
}
}
int GetOverrideHeight() const
{
return m_iOverrideHeight;
}
void SetOverrideHeight( int iHeight )
{
m_iOverrideHeight = iHeight;
}
private:
vgui::EditablePanel* m_pChild;
vgui::Panel* m_pTriggerButton;
vgui::Panel* m_pAcceptButton;
vgui::Panel* m_pDeclineButton;
int m_iNotificationID;
int m_iOriginalWidth;
int m_iOriginalHeight;
int m_iButtonOffsetY;
int m_iOverrideHeight;
bool m_bAddControls;
};
//-----------------------------------------------------------------------------
struct NotificationUIInfo_t
{
CNotificationToastControl *m_pPanel;
int m_iStartPosX;
int m_iStartPosY;
};
// notification queue panel that is a HUD element
// this is the visualization of the notifications while in game
class CNotificationQueuePanel : public CHudElement, public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CNotificationQueuePanel, vgui::EditablePanel );
public:
CNotificationQueuePanel( const char *pElementName )
: CHudElement( pElementName )
, BaseClass( NULL, "NotificationQueuePanel" )
, m_mapNotificationPanels( DefLessFunc(int) )
, m_flInvalidateTime( 0.0f )
, m_bInvalidated( false )
{
vgui::Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
SetHiddenBits( HIDEHUD_MISCSTATUS );
}
virtual ~CNotificationQueuePanel()
{
}
virtual bool ShouldDraw( void )
{
if ( !CHudElement::ShouldDraw() )
{
return false;
}
if ( engine->IsPlayingDemo() )
{
return false;
}
if ( cl_notifications_show_ingame.GetInt() == 0 )
{
return false;
}
CHudVote *pHudVote = GET_HUDELEMENT( CHudVote );
if ( pHudVote && pHudVote->IsVoteUIActive() )
{
return false;
}
return m_mapNotificationPanels.Count() > 0 || g_notificationQueue.HasItems();
}
virtual void PerformLayout( void )
{
BaseClass::PerformLayout();
// Get filtered list of only the notifications that show some in-game content
CUtlVector< CEconNotification *> notifications;
GetNotifications( notifications );
const float flMoveTime = cl_notifications_move_time.GetFloat();
float lerpPercentage = flMoveTime > 0 ? clamp( ( flMoveTime - m_flInvalidateTime ) / flMoveTime, 0.0f, 1.0f ) : 1.0f;
float flCurrTime = engine->Time();
// move the notifications around
const int kMaxVisibleNotifications = cl_notifications_max_num_visible.GetInt();
int iPosY = MIN( notifications.Count() - 1, kMaxVisibleNotifications - 1 ) * m_iOverlapOffset_Y;
int iPosX = MIN( notifications.Count() - 1, kMaxVisibleNotifications - 1 ) * m_iOverlapOffset_X;
int zpos = 100;
int iPreviousHeight = 0;
for ( int i = 0; i < notifications.Count(); ++i )
{
CEconNotification *pNotification = notifications[i];
int mapIdx = m_mapNotificationPanels.Find( pNotification->GetID() );
if ( m_mapNotificationPanels.IsValidIndex( mapIdx ) == false || pNotification->GetInGameLifeTime() < flCurrTime )
{
continue;
}
NotificationUIInfo_t &info = m_mapNotificationPanels[mapIdx];
CNotificationToastControl *pPanel = info.m_pPanel;
if ( pPanel )
{
if ( pPanel->IsVisible() == false )
{
pPanel->SetVisible( true );
}
if ( i == 0 && pPanel->GetOverrideHeight() != 0 )
{
pPanel->SetOverrideHeight( 0 );
pPanel->InvalidateLayout( true, false );
}
int iPanelX;
int iPanelY;
pPanel->GetPos( iPanelX, iPanelY );
if ( m_bInvalidated )
{
info.m_iStartPosX = iPanelX;
info.m_iStartPosY = iPanelY;
}
int iNewPosX = iPosX;
int iNewPosY = iPosY;
iNewPosX = Lerp( lerpPercentage, info.m_iStartPosX, iNewPosX );
iNewPosY = Lerp( lerpPercentage, info.m_iStartPosY, iNewPosY );
pPanel->SetPos( iNewPosX, iNewPosY );
pPanel->SetZPos( --zpos );
bool bStoppedMoving = iNewPosX == iPanelX && iNewPosY == iPosY;
// only show panels that are more than we want visible if they are moving
if ( i > kMaxVisibleNotifications - 1 )
{
if ( bStoppedMoving )
{
pPanel->SetVisible( false );
}
continue;
}
// don't poke out underneath if we are visible and stopped moving
if ( i != 0 && pPanel->GetOverrideHeight() == 0 && bStoppedMoving )
{
pPanel->SetOverrideHeight( MIN( pPanel->GetTall(), iPreviousHeight ) );
pPanel->InvalidateLayout( true, false );
}
iPreviousHeight = pPanel->GetTall();
iPosY = MAX( 0, iPosY - m_iOverlapOffset_Y );
iPosX = MAX( 0, iPosX - m_iOverlapOffset_X );
}
}
m_bInvalidated = false;
SetTall( ScreenHeight() - m_iOriginalY );
}
virtual void ApplySchemeSettings( vgui::IScheme *scheme )
{
LoadControlSettings( "Resource/UI/Econ/NotificationQueuePanel.res" );
GetBounds( m_iOriginalX, m_iOriginalY, m_iOriginalWidth, m_iOriginalHeight );
BaseClass::ApplySchemeSettings( scheme );
}
virtual void OnThink()
{
BaseClass::OnThink();
if ( IsVisible() == false )
{
return;
}
// Get filtered list of only the notifications that show some in-game content
CUtlVector< CEconNotification *> notifications;
GetNotifications( notifications );
float flCurrTime = engine->Time();
// check to see if we have a panel for each notification
int i = 0;
for ( i = 0; i < notifications.Count(); ++i )
{
CEconNotification *pNotification = notifications[i];
int mapIdx = m_mapNotificationPanels.Find( pNotification->GetID() );
if ( m_mapNotificationPanels.IsValidIndex( mapIdx ) == false || pNotification->GetInGameLifeTime() < flCurrTime )
{
m_bInvalidated = true;
// create the panel and add it to the UI
// have it slide from the bottom
CNotificationToastControl *pControl = NULL;
int iPosX = 0, iPosY = 0;
vgui::EditablePanel *pPanel = pNotification->CreateUIElement( false );
if ( pPanel )
{
pControl = new CNotificationToastControl( this, pPanel, pNotification->GetID(), false );
pControl->GetPos( iPosX, iPosY );
pControl->SetPos( iPosX, ScreenHeight() );
iPosY = ScreenHeight();
}
NotificationUIInfo_t info = { pControl, iPosX, iPosY };
m_mapNotificationPanels.Insert( pNotification->GetID(), info );
}
}
// now check to see if we have panels and there is no matching notification
i = m_mapNotificationPanels.FirstInorder();
while ( m_mapNotificationPanels.IsValidIndex( i ) )
{
int idx = i;
i = m_mapNotificationPanels.NextInorder( i );
int iID = m_mapNotificationPanels.Key( idx );
CEconNotification *pNotification = g_notificationQueue.GetNotification( iID );
if ( pNotification == NULL || pNotification->GetInGameLifeTime() < flCurrTime )
{
// fade here, cause we don't really want to re-layout
NotificationUIInfo_t &info = m_mapNotificationPanels[idx];
vgui::EditablePanel *pPanel = info.m_pPanel;
if ( pPanel )
{
pPanel->MarkForDeletion();
}
m_mapNotificationPanels.RemoveAt( idx );
m_bInvalidated = true;
}
}
if ( m_bInvalidated )
{
m_flInvalidateTime = MAX( cl_notifications_move_time.GetFloat(), 0.0f );
}
if ( m_flInvalidateTime > 0 )
{
m_flInvalidateTime -= gpGlobals->frametime;
InvalidateLayout( true, false );
}
}
protected:
typedef CUtlMap< int, NotificationUIInfo_t > tNotificationPanels;
tNotificationPanels m_mapNotificationPanels;
int m_iOriginalX;
int m_iOriginalY;
int m_iOriginalWidth;
int m_iOriginalHeight;
float m_flInvalidateTime;
bool m_bInvalidated;
CPanelAnimationVar( int, m_iVisibleBuffer, "buffer_between_visible", "5" );
CPanelAnimationVar( int, m_iOverlapOffset_X, "overlap_offset_x", "10" );
CPanelAnimationVar( int, m_iOverlapOffset_Y, "overlap_offset_y", "10" );
void GetNotifications(CUtlVector< CEconNotification *> ¬ifications )
{
const CUtlVector< CEconNotification *> &allNotifications = g_notificationQueue.GetItems();
for (int i = 0 ; i < allNotifications.Count() ; ++i )
{
CEconNotification *pNotification = allNotifications[i];
if ( pNotification->BShowInGameElements() )
{
notifications.AddToTail( pNotification );
}
}
}
};
DECLARE_HUDELEMENT( CNotificationQueuePanel );
//-----------------------------------------------------------------------------
CEconNotification::CEconNotification()
: m_pText("")
, m_pSoundFilename( NULL )
, m_flExpireTime( engine->Time() + 10.0f )
, m_pKeyValues( NULL )
, m_bInUse( false )
, m_steamID()
{
}
CEconNotification::~CEconNotification()
{
if ( m_pKeyValues )
{
m_pKeyValues->deleteThis();
}
}
void CEconNotification::SetText( const char *pText )
{
m_pText = pText;
}
void CEconNotification::AddStringToken( const char* pToken, const wchar_t* pValue )
{
if ( m_pKeyValues == NULL )
{
m_pKeyValues = new KeyValues( "CEconNotification" );
}
m_pKeyValues->SetWString( pToken, pValue );
}
void CEconNotification::SetKeyValues( KeyValues *pKeyValues )
{
if ( m_pKeyValues != NULL )
{
m_pKeyValues->deleteThis();
}
m_pKeyValues = pKeyValues->MakeCopy();
}
KeyValues *CEconNotification::GetKeyValues() const
{
return m_pKeyValues;
}
const wchar_t *CEconNotification::GetText()
{
g_pVGuiLocalize->ConstructString_safe( m_wszBuffer, m_pText, m_pKeyValues );
return m_wszBuffer;
}
int CEconNotification::GetID() const
{
return m_iID;
}
void CEconNotification::SetLifetime( float flSeconds )
{
m_flExpireTime = engine->Time() + flSeconds;
}
float CEconNotification::GetExpireTime() const
{
return m_flExpireTime;
}
float CEconNotification::GetInGameLifeTime() const
{
return m_flExpireTime; // default's to passed in time unless otherwise set (for derived classes)
}
void CEconNotification::SetIsInUse( bool bInUse)
{
m_bInUse = bInUse;
}
bool CEconNotification::GetIsInUse() const
{
return m_bInUse;
}
void CEconNotification::SetSteamID( const CSteamID &steamID )
{
m_steamID = steamID;
}
const CSteamID &CEconNotification::GetSteamID() const
{
return m_steamID;
}
void CEconNotification::MarkForDeletion()
{
// to be deleted ASAP
m_flExpireTime = 0.0f;
}
CEconNotification::EType CEconNotification::NotificationType()
{
return eType_Basic;
}
bool CEconNotification::BHighPriority()
{
return false;
}
void CEconNotification::Trigger()
{
}
void CEconNotification::Accept()
{
}
void CEconNotification::Decline()
{
}
void CEconNotification::Deleted()
{
}
void CEconNotification::Expired()
{
}
vgui::EditablePanel *CEconNotification::CreateUIElement( bool bMainMenu ) const
{
CGenericNotificationToast *pToast = new CGenericNotificationToast( NULL, m_iID, bMainMenu );
return pToast;
}
const char *CEconNotification::GetUnlocalizedHelpText()
{
switch ( NotificationType() )
{
case eType_AcceptDecline:
return "#Notification_AcceptOrDecline_Help";
case eType_MustTrigger:
case eType_Trigger:
return "#Notification_CanTrigger_Help";
default:
Assert( !"Unhandled enum value" );
// ---v
case eType_Basic:
return "#Notification_Remove_Help";
}
}
//-----------------------------------------------------------------------------
class CMainMenuNotificationsControl : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CMainMenuNotificationsControl, vgui::EditablePanel );
public:
CMainMenuNotificationsControl( vgui::EditablePanel *pParent, const char *pElementName )
: BaseClass( pParent, pElementName )
, m_mapNotificationPanels( DefLessFunc(int) )
, m_iNumItems( 0 )
{
vgui::ivgui()->AddTickSignal( GetVPanel(), 250 );
}
virtual ~CMainMenuNotificationsControl()
{
vgui::ivgui()->RemoveTickSignal( GetVPanel() );
}
virtual void PerformLayout( void )
{
BaseClass::PerformLayout();
const CUtlVector< CEconNotification *> ¬ifications = g_notificationQueue.GetItems();
// position the notifications around
// grow down
int iTotalHeight = 0;
const int kBuffer = 5;
for ( int i = 0; i < notifications.Count(); ++i )
{
CEconNotification *pNotification = notifications[i];
int mapIdx = m_mapNotificationPanels.Find( pNotification->GetID() );
if ( m_mapNotificationPanels.IsValidIndex( mapIdx ) == false )
{
continue;
}
NotificationUIInfo_t &info = m_mapNotificationPanels[mapIdx];
vgui::EditablePanel *pPanel = info.m_pPanel;
if ( pPanel )
{
int iPanelX;
int iPanelY;
int iWidth;
int iHeight;
pPanel->GetBounds( iPanelX, iPanelY, iWidth, iHeight );
int iNewPosX = iPanelX;
int iNewPosY = iTotalHeight;
pPanel->SetPos( iNewPosX, iNewPosY );
iTotalHeight += iHeight + kBuffer;
}
}
int iWidth, iHeight;
GetSize( iWidth, iHeight );
SetSize( iWidth, iTotalHeight );
if ( iTotalHeight != iHeight )
{
GetParent()->InvalidateLayout( false, false );
}
}
virtual void OnTick()
{
if ( m_iNumItems != g_notificationQueue.GetItems().Count() )
{
m_iNumItems = g_notificationQueue.GetItems().Count();
PostActionSignal( new KeyValues("Command", "command", "notifications_update" ) );
}
}
virtual void OnThink()
{
BaseClass::OnThink();
if ( IsVisible() == false )
{
return;
}
const CUtlVector< CEconNotification *> ¬ifications = g_notificationQueue.GetItems();
bool bInvalidated = false;
// check to see if we have a panel for each notification
int i = 0;
for ( i = 0; i < notifications.Count(); ++i )
{
CEconNotification *pNotification = notifications[i];
int mapIdx = m_mapNotificationPanels.Find( pNotification->GetID() );
if ( m_mapNotificationPanels.IsValidIndex( mapIdx ) == false )
{
bInvalidated = true;
CNotificationToastControl *pControl = NULL;
vgui::EditablePanel *pPanel = pNotification->CreateUIElement( true );
if ( pPanel )
{
pControl = new CNotificationToastControl( this, pPanel, pNotification->GetID(), true );
}
NotificationUIInfo_t info = { pControl, 0, 0 };
m_mapNotificationPanels.Insert( pNotification->GetID(), info );
}
}
// now check to see if we have panels and there is no matching notification
i = m_mapNotificationPanels.FirstInorder();
while ( m_mapNotificationPanels.IsValidIndex( i ) )
{
int idx = i;
i = m_mapNotificationPanels.NextInorder( i );
int iID = m_mapNotificationPanels.Key( idx );
if ( g_notificationQueue.GetNotification( iID ) == NULL )
{
NotificationUIInfo_t &info = m_mapNotificationPanels[idx];
vgui::EditablePanel *pPanel = info.m_pPanel;
if ( pPanel )
{
pPanel->MarkForDeletion();
}
m_mapNotificationPanels.RemoveAt( idx );
bInvalidated = true;
}
}
if ( bInvalidated )
{
InvalidateLayout( true, false );
}
}
protected:
typedef CUtlMap< int, NotificationUIInfo_t > tNotificationPanels;
tNotificationPanels m_mapNotificationPanels;
int m_iNumItems;
};
// Show in UI
class CNotificationsPresentPanel : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CNotificationsPresentPanel, vgui::EditablePanel );
public:
CNotificationsPresentPanel( vgui::Panel *pParent, const char* pElementName ) : vgui::EditablePanel( pParent, "NotificationsPresentPanel" )
{
SetMouseInputEnabled( true );
}
virtual ~CNotificationsPresentPanel()
{
}
virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "Resource/UI/Econ/NotificationsPresentPanel.res" );
for ( int i = 0; i < GetChildCount(); i++ )
{
vgui::Panel *pChild = GetChild( i );
pChild->SetMouseInputEnabled( false );
}
}
virtual void OnMousePressed(vgui::MouseCode code)
{
if ( code != MOUSE_LEFT )
return;
PostActionSignal( new KeyValues("Close") );
// audible feedback
const char *soundFilename = "ui/buttonclick.wav";
vgui::surface()->PlaySound( soundFilename );
}
};
DECLARE_BUILD_FACTORY( CNotificationsPresentPanel );
//-----------------------------------------------------------------------------
// External interface for the notification queue
int NotificationQueue_Add( CEconNotification *pNotification )
{
if ( !engine->IsInGame() || (cl_notifications_show_ingame.GetBool() && pNotification->BShowInGameElements()) )
{
vgui::surface()->PlaySound( pNotification->GetSoundFilename() );
}
return g_notificationQueue.AddNotification( pNotification );
}
CEconNotification *NotificationQueue_Get( int iID )
{
return g_notificationQueue.GetNotification( iID );
}
CEconNotification *NotificationQueue_GetByIndex( int idx )
{
return g_notificationQueue.GetNotificationByIndex( idx );
}
void NotificationQueue_RemoveAll()
{
g_notificationQueue.RemoveAllNotifications();
}
void NotificationQueue_Remove( int iID )
{
g_notificationQueue.RemoveNotification( iID );
}
void NotificationQueue_Remove( CEconNotification *pNotification )
{
g_notificationQueue.RemoveNotification( pNotification );
}
void NotificationQueue_Remove( NotificationFilterFunc func )
{
g_notificationQueue.RemoveNotifications( func );
}
int NotificationQueue_Count( NotificationFilterFunc func )
{
return g_notificationQueue.CountNotifications( func );
}
void NotificationQueue_Visit( CEconNotificationVisitor &visitor )
{
g_notificationQueue.VisitNotifications( visitor );
}
void NotificationQueue_Update()
{
g_notificationQueue.Update();
}
int NotificationQueue_GetNumNotifications()
{
return g_notificationQueue.GetItems().Count();
}
vgui::EditablePanel* NotificationQueue_CreateMainMenuUIElement( vgui::EditablePanel *pParent, const char *pElementName )
{
CMainMenuNotificationsControl *pControl = new CMainMenuNotificationsControl( pParent, pElementName );
pControl->AddActionSignalTarget( pParent );
return pControl;
}
//-----------------------------------------------------------------------------
CON_COMMAND( cl_trigger_first_notification, "Tries to accept/trigger the first notification" )
{
const CUtlVector< CEconNotification *> ¬ifications = g_notificationQueue.GetItems();
if ( notifications.Count() > 0 )
{
CEconNotification *pNotification = notifications[0];
switch ( pNotification->NotificationType() )
{
case CEconNotification::eType_AcceptDecline:
pNotification->Accept();
break;
case CEconNotification::eType_MustTrigger:
case CEconNotification::eType_Trigger:
pNotification->Trigger();
case CEconNotification::eType_Basic:
break;
default:
Assert( !"Unhandled enum value" );
}
}
}
CON_COMMAND( cl_decline_first_notification, "Tries to decline/remove the first notification" )
{
const CUtlVector< CEconNotification *> ¬ifications = g_notificationQueue.GetItems();
if ( notifications.Count() > 0 )
{
CEconNotification *pNotification = notifications[0];
switch ( pNotification->NotificationType() )
{
case CEconNotification::eType_AcceptDecline:
pNotification->Decline();
break;
case CEconNotification::eType_MustTrigger:
break; // YOU MUUUSSTTTTT
case CEconNotification::eType_Trigger:
case CEconNotification::eType_Basic:
pNotification->Deleted();
pNotification->MarkForDeletion();
break;
default:
Assert( !"Unhandled enum value" );
}
}
}
#ifdef _DEBUG
#include "confirm_dialog.h"
class CTFTestNotification : public CEconNotification
{
public:
CTFTestNotification( const char* pText, EType eType )
: CEconNotification()
, m_pText( pText )
, m_eType( eType )
{
}
virtual EType NotificationType() OVERRIDE { return m_eType; }
virtual void Trigger() OVERRIDE
{
ShowMessageBox( "", m_pText, "#GameUI_OK" );
MarkForDeletion();
}
virtual void Accept() OVERRIDE
{
ShowMessageBox( "Accept", m_pText, "#GameUI_OK" );
MarkForDeletion();
}
virtual void Decline() OVERRIDE
{
ShowMessageBox( "Decline", m_pText, "#GameUI_OK" );
MarkForDeletion();
}
private:
const char *m_pText;
EType m_eType;
};
CON_COMMAND( cl_add_notification, "Adds a notification" )
{
if ( args.ArgC() >= 2 )
{
CEconNotification::EType eType = CEconNotification::eType_Basic;
if ( args.ArgC() >= 5 )
{
eType = (CEconNotification::EType)atoi( args[4] );
}
CEconNotification *pNotification = new CTFTestNotification( args[1], eType );
pNotification->SetText( args[1] );
if ( args.ArgC() >= 3 )
{
int iLifetime = atoi( args[2] );
pNotification->SetLifetime( iLifetime );
}
if ( args.ArgC() >= 4 )
{
if ( steamapicontext && steamapicontext->SteamUser() )
{
pNotification->SetSteamID( steamapicontext->SteamUser()->GetSteamID() );
}
}
int id = NotificationQueue_Add( pNotification );
Msg( "Added notification %d\n", id);
}
}
#endif