tf2/tf2_src/engine/vgui_vprofpanel.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: VGUI scoreboard
//
// $Workfile:     $
// $Date:         $
// $NoKeywords: $
//===========================================================================//

#include "client_pch.h"
#include "vgui_vprofpanel.h"
#include <KeyValues.h>
#include "vgui_budgetpanel.h"
#include "vprof_engine.h"
#include "vprof_record.h"
#include "ivideomode.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

using namespace vgui;

// positions
#define VPROF_INDENT_X			XRES(20)
#define VPROF_INDENT_Y			YRES(10)

// Scoreboard dimensions
#define VPROF_TITLE_SIZE_Y			YRES(22)

#define X_BORDER					XRES(4)
#define Y_BORDER					YRES(4)

static ConVar vprof_verbose( "vprof_verbose", "1", FCVAR_ARCHIVE, "Set to one to show average and peak times" );
static ConVar vprof_unaccounted_limit( "vprof_unaccounted_limit", "0.3", FCVAR_ARCHIVE, 
									  "number of milliseconds that a node must exceed to turn red in the vprof panel" );
static ConVar vprof_warningmsec( "vprof_warningmsec", "10", FCVAR_ARCHIVE, "Above this many milliseconds render the label red to indicate slow code." );

#ifdef VPROF_ENABLED

//-----------------------------------------------------------------------------
// Singleton accessor
//-----------------------------------------------------------------------------
static CVProfPanel *g_pVProfPanel = NULL;
CVProfPanel *GetVProfPanel( void )
{
	return g_pVProfPanel;
}


static void ClearNodeClientData( CVProfNode *pNode )
{
	pNode->SetClientData( -1 );
	if( pNode->GetSibling() )
	{
		ClearNodeClientData( pNode->GetSibling() );
	}
	
	if( pNode->GetChild() )
	{
		ClearNodeClientData( pNode->GetChild() );
	}
}

void CVProfPanel::Reset()
{
	m_pHierarchy->RemoveAll();
	m_RootItem = -1;
	ClearNodeClientData( m_pVProfile->GetRoot() );
}


CON_COMMAND( vprof_expand_all, "Expand the whole vprof tree" )
{
	Msg("VProf expand all.\n");
	GetVProfPanel()->ExpandAll();
}

CON_COMMAND( vprof_collapse_all, "Collapse the whole vprof tree" )
{
	Msg("VProf collapse all.\n");
	GetVProfPanel()->CollapseAll();
}

CON_COMMAND( vprof_expand_group, "Expand a budget group in the vprof tree by name" )
{
	Msg("VProf expand group.\n");
	if ( args.ArgC() >= 2 )
	{
		GetVProfPanel()->ExpandGroup( args[ 1 ] );
	}
}

void IN_VProfDown(void)
{
	GetVProfPanel()->UserCmd_ShowVProf();
}

void IN_VProfUp(void)
{
	GetVProfPanel()->UserCmd_HideVProf();
}

static ConCommand startshowvprof("+showvprof", IN_VProfDown);
static ConCommand endshowvprof("-showvprof", IN_VProfUp);

void ChangeVProfScopeCallback( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	ConVarRef var( pConVar );
	Msg( "VProf setting scope to %s\n", var.GetString( ) );

	if ( g_pVProfPanel )
	{
		g_pVProfPanel->Reset();
	}
}

ConVar vprof_scope( 
	"vprof_scope", 
	"", 
	0, 
	"Set a specific scope to start showing vprof tree",
	0, 0, 0, 0,
	ChangeVProfScopeCallback );

#define PROF_FONT "DefaultFixed"

class CProfileTree : public TreeView
{
	DECLARE_CLASS_SIMPLE( CProfileTree, TreeView );
public:
	CProfileTree( CVProfPanel *parent, const char *panelName );
	~CProfileTree();

	virtual void OnCommand( const char *cmd );

	virtual void InvalidateLayout( bool layoutNow = false, bool reloadScheme = false );

	virtual void ApplySchemeSettings( IScheme *pScheme )
	{
		BaseClass::ApplySchemeSettings( pScheme );
		SetFont( pScheme->GetFont( PROF_FONT ) );
	}

	virtual void SetBgColor( Color color )
	{
		BaseClass::SetBgColor( color );
	}

private:

	Menu		*m_pEditMenu;
	CVProfPanel	*m_pParent;
};

CProfileTree::CProfileTree( CVProfPanel *parent, const char *panelName ) :
	BaseClass( (Panel *)parent, panelName ),
	m_pEditMenu( 0 ),
	m_pParent( parent )
{
}

CProfileTree::~CProfileTree()
{
	delete m_pEditMenu;
}

void CProfileTree::InvalidateLayout( bool layoutNow, bool reloadScheme )
{
	BaseClass::InvalidateLayout( layoutNow, reloadScheme );
	if ( GetParent() )
	{
		GetParent()->InvalidateLayout( layoutNow, reloadScheme );
	}
}

void CProfileTree::OnCommand( const char *cmd )
{
	// Relay to parent
	GetParent()->OnCommand( cmd );
}

CProfileHierarchyPanel::ColumnPanels_t::ColumnPanels_t() :
	treeViewItem( -1 )
{
}

CProfileHierarchyPanel::ColumnPanels_t::ColumnPanels_t( const ColumnPanels_t& src )
{
	treeViewItem = src.treeViewItem;
	int c = src.m_Columns.Count();
	for ( int i = 0; i < c; ++i )
	{
		PanelEntry_t pe;
		pe.dataname = src.m_Columns[ i ].dataname;
		pe.label = src.m_Columns[ i ].label;

		m_Columns.AddToTail( pe );
	}
}

void CProfileHierarchyPanel::ColumnPanels_t::AddColumn( int index, const char *name, vgui::Label *label )
{
	m_Columns.EnsureCount( index + 1 );

	m_Columns[ index ].label = label;
	m_Columns[ index ].dataname = name;
}

void CProfileHierarchyPanel::ColumnPanels_t::Refresh( KeyValues *kv )
{
	VPROF( "CProfileHierarchyPanel::ColumnPanels_t" );

	int c = m_Columns.Count();
	for ( int i = 0; i < c; ++i )
	{
		vgui::Label *label = m_Columns[ i ].label;
		if ( !label )
			continue;

		const char *name = m_Columns[ i ].dataname.String();
		if ( name && name[ 0 ] )
		{
			const char *value = kv->GetString( name, "" );
			if ( value )
			{
				if ( !value[ 0 ] )
				{
					label->SetText( "" );
					label->SetVisible( false );
				}
				else
				{
					label->SetVisible( true );
					label->SetText( value );
				}
			}
			else
			{
				label->SetVisible( false );
			}
		}
	}
}


CProfileHierarchyPanel::CProfileHierarchyPanel(vgui::Panel *parent, const char *panelName)
 : BaseClass(parent,panelName),
	m_Panels( 0, 0, PanelsLessFunc )
{
}

CProfileHierarchyPanel::~CProfileHierarchyPanel()
{
}

void CProfileHierarchyPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	//SetProportional( true );
	BaseClass::ApplySchemeSettings( pScheme );
	m_itemFont = pScheme->GetFont( PROF_FONT );
	SetTitleBarInfo( m_itemFont, 20 );
	SetBgColor( Color(0, 0, 0, 176) );
	(( CProfileTree *)GetTree())->SetBgColor( Color( 0, 0, 0, 176 ) );
}

void CProfileHierarchyPanel::SetItemColors( int id, const Color& fg, const Color& bg )
{
	VPROF( "CProfileHierarchyPanel::SetItemColors" );
	GetTree()->SetItemFgColor( id, fg );
	GetTree()->SetItemBgColor( id, bg );
	ColumnPanels_t search;
	search.treeViewItem = id;
	int idx = m_Panels.Find( search );
	if ( idx == m_Panels.InvalidIndex() )
	{
		return;
	}
	ColumnPanels_t& info = m_Panels[ idx ];
	int c = info.m_Columns.Count();
	for ( int i = 0; i < c; ++i )
	{
		Label *label = info.m_Columns[ i ].label;
		if ( !label )
			continue;
		label->SetFgColor( fg );
		label->SetBgColor( bg );
	}
}

void CProfileHierarchyPanel::SetItemColumnColors( int id, int col, const Color& fg, const Color& bg )
{
	VPROF( "CProfileHierarchyPanel::SetItemColumnColors" );
	ColumnPanels_t search;
	search.treeViewItem = id;
	int idx = m_Panels.Find( search );
	if ( idx == m_Panels.InvalidIndex() )
	{
		return;
	}
	ColumnPanels_t& info = m_Panels[ idx ];
	int c = info.m_Columns.Count();
	if ( col < 0 || col >= c )
		return;

	Label *label = info.m_Columns[ col ].label;
	if ( !label )
		return;

	label->SetFgColor( fg );
	label->SetBgColor( bg );
}

void CProfileHierarchyPanel::ModifyItem( KeyValues *data, int itemIndex )
{
	GetTree()->SetItemFgColor( itemIndex, GetFgColor() );
	GetTree()->SetItemBgColor( itemIndex, GetBgColor() );

	ColumnPanels_t search;
	search.treeViewItem = itemIndex;
	int idx = m_Panels.Find( search );
	if ( idx == m_Panels.InvalidIndex() )
	{
		Assert( 0 );
		return;
	}

	ColumnPanels_t& info = m_Panels[ idx ];
	info.Refresh( data );
}

int CProfileHierarchyPanel::AddItem( KeyValues *data, int parentItemIndex, ColumnPanels_t& columnPanels )
{
	int itemIndex = GetTree()->AddItem( data, parentItemIndex );
	columnPanels.treeViewItem = itemIndex;
	
	ColumnPanels_t search;
	search.treeViewItem = itemIndex;

	int idx = m_Panels.Find( search );
	if ( idx == m_Panels.InvalidIndex() )
	{
		m_Panels.Insert( columnPanels );

		int c = columnPanels.m_Columns.Count();
		for ( int i = 0; i < c; ++i )
		{
			if ( columnPanels.m_Columns[ i ].label )
			{
				columnPanels.m_Columns[ i ].label->SetParent( this );
			}
		}
	}

	ModifyItem( data, itemIndex );

	return itemIndex;
}

void CProfileHierarchyPanel::PostChildPaint()
{
}

void CProfileHierarchyPanel::PerformLayout()
{
	VPROF( "CProfileHierarchyPanel::PerformLayout" );
	BaseClass::PerformLayout();

	// Assume all invisible at first
	HideAll();

	int tall = GetTall();

	int rowheight = GetTree()->GetRowHeight();
	int top, visitems;
	bool hbarVisible = false;
	GetTree()->GetVBarInfo( top, visitems, hbarVisible );

	int offset = -top * rowheight;

	int numColumns = GetNumColumns();
	// Now position column panels into the correct spot
	int rows = GetNumRows();
	for ( int row = 0; row < rows; ++row )
	{
		int tvi = GetTreeItemAtRow( row );

		for ( int col = 0; col < numColumns; ++col )
		{
			int left, right, bottom;
			GetGridElementBounds( col, row, left, top, right, bottom );

			ColumnPanels_t search;
			search.treeViewItem = tvi;

			int idx = m_Panels.Find( search );
			if ( idx != m_Panels.InvalidIndex() )
			{
				ColumnPanels_t& info = m_Panels[ idx ];

				if ( col >= info.m_Columns.Count() )
					continue;

				vgui::Label *p = info.m_Columns[ col ].label;
				if ( !p )
				{
					continue;
				}
				
				bool vis = ( top + offset - 20 ) >= 0 && ( bottom + offset ) < tall;

				p->SetParent( vis ? this : NULL );
				p->SetVisible( vis );
				p->SetBounds( left, top + offset, right - left, bottom - top );
				p->InvalidateLayout();
			}
			else
			{
				Assert( 0 );
			}
		}
	}
}

void CProfileHierarchyPanel::HideAll()
{
	for ( int i = m_Panels.FirstInorder(); i != m_Panels.InvalidIndex(); i = m_Panels.NextInorder( i ) )
	{
		ColumnPanels_t& info = m_Panels[ i ];
		int c = info.m_Columns.Count();
		for ( int j = 0 ; j < c; ++j )
		{
			Label *panel = info.m_Columns[ j ].label;
			if ( !panel )
			{
				continue;
			}
			panel->SetVisible( false );
		}
	}
}

void CProfileHierarchyPanel::RemoveAll()
{
	GetTree()->RemoveAll();

	for ( int i = m_Panels.FirstInorder(); i != m_Panels.InvalidIndex(); i = m_Panels.NextInorder( i ) )
	{
		ColumnPanels_t& info = m_Panels[ i ];
		int c = info.m_Columns.Count();
		for ( int j = 0 ; j < c; ++j )
		{
			delete info.m_Columns[ j ].label;
		}
		info.m_Columns.RemoveAll();
	}
	m_Panels.RemoveAll();
	InvalidateLayout();
}

void CProfileHierarchyPanel::ExpandItem(int itemIndex, bool bExpand)
{
	GetTree()->ExpandItem( itemIndex, bExpand );
}

bool CProfileHierarchyPanel::IsItemExpanded( int itemIndex )
{
	return GetTree()->IsItemExpanded( itemIndex );
}

KeyValues *CProfileHierarchyPanel::GetItemData(int itemIndex)
{
	return GetTree()->GetItemData( itemIndex );
}

//-----------------------------------------------------------------------------
// Purpose: Create the VProf panel
//-----------------------------------------------------------------------------
CVProfPanel::CVProfPanel( vgui::Panel *pParent, const char *pElementName ) 
 :	vgui::Frame( pParent, pElementName )
{
	m_pVProfile = g_pVProfileForDisplay;

	Assert( g_pVProfPanel == NULL );
	g_pVProfPanel = this;

	m_RootItem = -1;
	m_fShowVprofHeld = false;

	int x = VPROF_INDENT_X;
	int y = VPROF_INDENT_Y;
	int wide = videomode->GetModeStereoWidth() - x * 2;
	int tall = videomode->GetModeStereoHeight() - y * 2;
	SetBgColor(Color(0, 0, 0, 175));

	// Initialize the top title.
#ifdef VPROF_ENABLED
	SetTitle("VProf", false);
#else
	SetTitle("** VProf is not enabled **", false);
#endif

	SetZPos( 1002 );

	CProfileTree *profileTree = new CProfileTree( this, "ProfileTree" );

	m_pHierarchy = new CProfileHierarchyPanel( this, "Hierarchy" );

	m_pHierarchy->SetTreeView( profileTree );
	m_pHierarchy->SetNumColumns( 3 );

	int treewide = wide - 780;
	m_pHierarchy->SetColumnInfo( 0, "Tree", treewide );

	m_pHierarchy->SetColumnInfo( 1, "Group", 120 );
	m_pHierarchy->SetColumnInfo( 2, "Data", 180 );

	// Treeview of the hierarchical calls
	m_pHierarchy->SetBounds(X_BORDER, VPROF_TITLE_SIZE_Y, wide - X_BORDER*2, tall - Y_BORDER*2 - VPROF_TITLE_SIZE_Y);
	m_pHierarchy->SetParent(this);
	m_pHierarchy->SetPaintBorderEnabled( false );
	m_pHierarchy->SetPaintBackgroundEnabled( false );

	SETUP_PANEL( m_pHierarchy );
	SETUP_PANEL( profileTree );

	// Mode selection used to populate the tree view + lists
	m_pVProfCategory = new ComboBox(this, "CategoryCombo", 5, false);
	m_pVProfCategory->AddItem( "All Categories", NULL );
	m_pVProfCategory->AddActionSignalTarget( this );
	m_pVProfCategory->ActivateItem( 0 );

	m_pVProfSort = new ComboBox( this, "SortCombo", 5, false );
	m_pVProfSort->AddItem( "By Time", NULL );
	m_pVProfSort->AddItem( "By Name", NULL );
	m_pVProfSort->AddItem( "By Budget Group", NULL );
	m_pVProfSort->AddActionSignalTarget( this );
	m_pVProfSort->ActivateItem( 0 );

	m_nLastBudgetGroupCount = 0;
	m_nCurrentBudgetGroup = -1;

	m_pHierarchicalView = new vgui::CheckButton( this, "HierarchicalViewSelection", "" );	
	m_pHierarchicalView->AddActionSignalTarget( this );
	m_pHierarchicalView->SetSelected( true );
	m_bHierarchicalView = true;

	m_pRedoSort = new vgui::Button( this, "RedoSorting", "", this, "redosort" );

	m_pVerbose = new vgui::CheckButton( this, "VerboseCheckbox", "" );	
	m_pVerbose->AddActionSignalTarget( this );
	m_pVerbose->SetSelected( vprof_verbose.GetBool() );


	// Setup the playback controls.
	m_pPlaybackLabel = new vgui::Label( this, "PlaybackLabel", "" );
	m_pPlaybackLabel->SetBgColor( Color( 0, 0, 0, 200 ) );
	m_pPlaybackLabel->SetPaintBackgroundEnabled( true );
	
	m_pStepForward = new vgui::Button( this, "StepForward", "", this, "StepForward" );
	m_pStepBack = new vgui::Button( this, "StepBack", "", this, "StepBack" );
	m_pGotoButton = new vgui::Button( this, "GotoButton", "", this, "GotoButton" );
	
	m_pPlaybackScroll = new vgui::ScrollBar( this, "PlaybackScroll", false );
	m_pPlaybackScroll->SetRange( 0, 1000 );
	m_pPlaybackScroll->SetRangeWindow( 30 );
	m_pPlaybackScroll->AddActionSignalTarget( this );
	
	m_iLastPlaybackTick = -1;


	LoadControlSettings("Resource\\VProfPanel.res");

	SetBounds( x, y, wide, tall );

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


CVProfPanel::~CVProfPanel( void )
{
	Assert( g_pVProfPanel == this );
	g_pVProfPanel = NULL;
}

#define DATA_FMT_STR "%-30.30s %-30.30s %-45.45s %-10.10s"
void CVProfPanel::PerformLayout()
{
	BaseClass::PerformLayout();

	int w, h;
	GetSize( w, h );

	int topoffset = 95;
	int inset = 10;

	m_pHierarchy->SetBounds( inset, topoffset, w - 2 * inset, h - inset - topoffset );

	int treewide = w - 900 - 20;
	treewide = max( treewide, 240 );
	m_pHierarchy->SetColumnInfo( 0, "Tree", treewide );

	m_pHierarchy->SetColumnInfo( 1, "Group", 125 );
	char header[ 512 ];
	Q_snprintf( header, sizeof( header ), DATA_FMT_STR,
		"Frame Calls + Time + NoChild",
		"Avg Calls   + Time + NoChild",
		"Sum Calls   + Time + NoChild + Peak",
		"L2Miss" );

	m_pHierarchy->SetColumnInfo( 2, header, 775, CTreeViewListControl::CI_HEADER_LEFTALIGN );
}

//-----------------------------------------------------------------------------
// Scheme settings!
//-----------------------------------------------------------------------------
void CVProfPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{			 
	BaseClass::ApplySchemeSettings( pScheme );

	IBorder *border = pScheme->GetBorder( "ToolTipBorder" );
	SetBorder(border);

	SetBgColor(Color(0, 0, 0, 175));
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *command - 
//-----------------------------------------------------------------------------
void CVProfPanel::Close()
{
	UserCmd_HideVProf();
	BaseClass::Close();
}
			  

//-----------------------------------------------------------------------------
// Is it visible?
//-----------------------------------------------------------------------------
void CVProfPanel::OnTick()
{
	BaseClass::OnTick();
	
	// Did the CVProfile we're using switch behind our back?
	if ( g_pVProfileForDisplay != m_pVProfile )
	{
		Reset();
		m_pVProfile = g_pVProfileForDisplay;

		bool bVisible = false;
#ifndef _XBOX
		if ( VProfRecord_IsPlayingBack() )
		{
			bVisible = true;
			m_iLastPlaybackTick = -1;
		}
#endif
		m_pStepForward->SetVisible( bVisible );
		m_pStepBack->SetVisible( bVisible );
		m_pPlaybackLabel->SetVisible( bVisible );
		m_pPlaybackScroll->SetVisible( bVisible );
		m_pGotoButton->SetVisible( bVisible );
	}
#ifndef _XBOX
	if ( VProfRecord_IsPlayingBack() )
	{
		// Update the playback tick.
		int iCur = VProfPlayback_GetCurrentTick();
		if ( iCur != m_iLastPlaybackTick )
		{
			char str[512];
			Q_snprintf( str, sizeof( str ), "VPROF playback (tick %d, %d%%)", iCur, (int)(VProfPlayback_GetCurrentPercent() * 100) );
			m_pPlaybackLabel->SetText( str );
		}
	}
#endif
	SetVisible( m_fShowVprofHeld != 0 );

	m_pRedoSort->SetVisible( !m_bHierarchicalView );
}

// 0  = By Time
// 1 = By "Text"
// 2 = By "group" then by "text"
static int g_nSortType = -1;
//-----------------------------------------------------------------------------
// Visualization changed 
//-----------------------------------------------------------------------------
void CVProfPanel::OnTextChanged( KeyValues *data )
{
	Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
	vgui::ComboBox *pBox = dynamic_cast<vgui::ComboBox *>( pPanel );

	if( pBox == m_pVProfCategory ) 
	{
		// The -1 here is for the 'All Categories' item
		m_nCurrentBudgetGroup = pBox->GetActiveItem() - 1;

		// NOTE: We have to reset the tree view so that it 
		// is populated with only the ones we want (need to eliminate everything
		// that's not appropriate)
		Reset();
		return;
	}
	if ( pBox == m_pVProfSort )
	{
		g_nSortType = pBox->GetActiveItem();
		Reset();
		return;
	}
}



//-----------------------------------------------------------------------------
// Sort function for hierarchical data
//-----------------------------------------------------------------------------
bool ChildCostSortFunc(KeyValues *pNode1, KeyValues *pNode2)
{
	switch ( g_nSortType )
	{
	default:
	case 0:
	case -1:
		{
			float flTime1 = pNode1->GetFloat( "Time", -1.0f );
			float flTime2 = pNode2->GetFloat( "Time", -1.0f );
			return (flTime1 > flTime2);
		}
	case 1:
		{
			const char *t1 = pNode1->GetString( "Text", "" );
			const char *t2 = pNode2->GetString( "Text", "" );
			if( Q_stricmp( t1, t2 ) <= 0 )
				return true;
			return false;
		}
		break;
	case 2:
		{
			const char *g1 = pNode1->GetString( "group", "" );
			const char *g2 = pNode2->GetString( "group", "" );
			int val = Q_stricmp( g1, g2 );
			if( val < 0 )
				return true;
			
			if ( val > 0 )
				return false;

			const char *t1 = pNode1->GetString( "Text", "" );
			const char *t2 = pNode2->GetString( "Text", "" );
			if( Q_stricmp( t1, t2 ) <= 0 )
				return true;
			return false;
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Changes the visualization method for vprof data 
//-----------------------------------------------------------------------------
void CVProfPanel::OnCheckButtonChecked(Panel *panel)
{
	if ( panel == m_pHierarchicalView )
	{
		bool bSelected = m_pHierarchicalView->IsSelected() ? 1 : 0;
		if ( bSelected != m_bHierarchicalView )
		{
			m_bHierarchicalView = bSelected;
			m_pHierarchy->GetTree()->SetSortFunc( m_bHierarchicalView ? NULL : ChildCostSortFunc );
			m_pRedoSort->SetVisible( !m_bHierarchicalView );
			Reset();
		}
		return;
	}

	if ( panel == m_pVerbose )
	{
		vprof_verbose.SetValue( m_pVerbose->IsSelected() ? 1 : 0 );
		return;
	}
}


//-----------------------------------------------------------------------------
// Methods related to expand/collapse in hierarchy
//-----------------------------------------------------------------------------
void CVProfPanel::ExpandAll( void )
{
	int count = m_pHierarchy->GetTree()->GetHighestItemID();
	int i;
	for( i = 0; i < count; i++ )
	{
		if( m_pHierarchy->GetTree()->IsItemIDValid( i ) )
		{
			m_pHierarchy->GetTree()->ExpandItem( i, true );
		}
	}
}

void CVProfPanel::CollapseAll( void )
{
	int count = m_pHierarchy->GetTree()->GetHighestItemID();
	int i;
	for( i = 1; i < count; i++ )
	{
		if( m_pHierarchy->GetTree()->IsItemIDValid( i ) )
		{
			m_pHierarchy->GetTree()->ExpandItem( i, false );
		}
	}
}

void CVProfPanel::ExpandGroupRecursive( int nBudgetGroupID, CVProfNode *pNode )
{
	if( !pNode )
	{
		return;
	}
	if( pNode->GetBudgetGroupID() == nBudgetGroupID )
	{
		CVProfNode *pTempNode = pNode;
		while( pTempNode )
		{
			if( pTempNode->GetParent() )
			{
				int id = pTempNode->GetParent()->GetClientData();
				m_pHierarchy->ExpandItem( id, true );
			}
			pTempNode = pTempNode->GetParent();
		}
	}

	ExpandGroupRecursive( nBudgetGroupID, pNode->GetChild() );
	ExpandGroupRecursive( nBudgetGroupID, pNode->GetSibling() );
}

void CVProfPanel::ExpandGroup( const char *pGroupName )
{
	int groupID = m_pVProfile->BudgetGroupNameToBudgetGroupID( pGroupName );
	ExpandGroupRecursive( groupID, m_pVProfile->GetRoot() );
}

class CVProfLabel : public Label
{
	DECLARE_CLASS_SIMPLE( CVProfLabel, Label );
public:

	CVProfLabel( Panel *parent, const char *panelName ) :
		BaseClass( parent, panelName, "" )
	{
		//SetPaintBackgroundEnabled( false );
	}

	virtual void ApplySchemeSettings( IScheme *pScheme )
	{
		BaseClass::ApplySchemeSettings( pScheme );
		SetFont( pScheme->GetFont( PROF_FONT ) );
		SetBgColor( Color( 0, 0, 0, 255 ) );
	}
};

Label *AllocateVprofLabel( const char *panelName )
{
	CVProfLabel *l = new CVProfLabel( NULL, panelName );
	l->SetContentAlignment( Label::a_west );
	return l;
}

void CVProfPanel::AddColumns( CProfileHierarchyPanel::ColumnPanels_t& cp )
{
	cp.AddColumn( 1, "group", AllocateVprofLabel( "group" ) );
	cp.AddColumn( 2, "data", AllocateVprofLabel( "data" ) );
}


//-----------------------------------------------------------------------------
// Populate the tree
//-----------------------------------------------------------------------------
int CVProfPanel::UpdateVProfTreeEntry( KeyValues *pKeyValues, CVProfNode *pNode, int parent )
{
	VPROF( "UpdateVProfTreeEntry" );

	CFmtStrN<1024> msg;
	double curTimeLessChildren = pNode->GetCurTimeLessChildren();
	double avgLessChildren = ( pNode->GetTotalCalls() > 0 ) ? pNode->GetTotalTimeLessChildren() / (double)pNode->GetTotalCalls() : 0;

	pKeyValues->SetString( "Text", pNode->GetName() );
	pKeyValues->SetString( "group", m_pVProfile->GetBudgetGroupName( pNode->GetBudgetGroupID() ) );

	CFmtStrN< 256 > frame;
	CFmtStrN< 256 > avgstr;
	CFmtStrN< 256 > sum;
	CFmtStrN< 256 > l2miss;

	frame.sprintf( "[%4d] %7.2f %7.2f", pNode->GetCurCalls(), pNode->GetCurTime(), curTimeLessChildren );
	
	
	pKeyValues->SetString( "frame", msg );

	if( vprof_verbose.GetBool() )
	{											 
		double avgCalls = ( m_pVProfile->NumFramesSampled() > 0 ) ? (double)pNode->GetTotalCalls() / (double)m_pVProfile->NumFramesSampled() : 0;
		double avg = ( m_pVProfile->NumFramesSampled() > 0 ) ? (double)pNode->GetTotalTime() / (double)m_pVProfile->NumFramesSampled() : 0;
		double avgLessChildrenVerbose = ( m_pVProfile->NumFramesSampled() > 0 ) ? (double)pNode->GetTotalTimeLessChildren() / (double)m_pVProfile->NumFramesSampled() : 0;

		avgstr.sprintf( "[%6.2f] %6.3f %6.3f", avgCalls, avg, avgLessChildrenVerbose );
		sum.sprintf( "[%7d] %9.2f %9.2f %8.2fp", pNode->GetTotalCalls(), pNode->GetTotalTime(), pNode->GetTotalTimeLessChildren(), pNode->GetPeakTime() );
	}

	if ( m_pVProfile->UsePME() )
	{
		l2miss.sprintf( "%5d", pNode->GetL2CacheMisses() );
	}

	msg.sprintf( DATA_FMT_STR,
		(const char *)frame,
		(const char *)avgstr,
		(const char *)sum,
		(const char *)l2miss );
	pKeyValues->SetString( "data", msg );

	pKeyValues->SetFloat( "Time", avgLessChildren );

	// Add or modify a line in the hierarchy
	int id = pNode->GetClientData();
	if ( id == -1 )
	{
		CProfileHierarchyPanel::ColumnPanels_t cp;
		AddColumns(  cp );
		id = m_pHierarchy->AddItem( pKeyValues, parent, cp ) ;
		pNode->SetClientData( id );
	}
	else
	{
		VPROF( "UpdateVProfTreeEntry:Modify" );
		m_pHierarchy->ModifyItem( pKeyValues, id );
	}

	// Apply color to the item
	int r,g,b,a;
	m_pVProfile->GetBudgetGroupColor( pNode->GetBudgetGroupID(), r, g, b, a );
	m_pHierarchy->SetItemColors( id, Color( r, g, b, a ), Color( 0, 0, 0, 255 ) );

	if( pNode->GetBudgetGroupID() == VPROF_BUDGET_GROUP_ID_UNACCOUNTED )
	{
		if ( curTimeLessChildren > vprof_unaccounted_limit.GetFloat() )
		{
			m_pHierarchy->SetItemColors( id, Color( 255, 0, 0, 255 ), Color( 0, 0, 0, 255 ) );
		}
	}

	if ( pNode->GetCurTime() > vprof_warningmsec.GetFloat() ||
		 curTimeLessChildren > vprof_warningmsec.GetFloat() )
	{
		m_pHierarchy->SetItemColumnColors( id, 2, Color( 255, 0, 0, 255 ), Color( 63, 0, 0, 255 ) );
	}
	return id;
}

//-----------------------------------------------------------------------------
// Populate the tree
//-----------------------------------------------------------------------------
void CVProfPanel::FillTree( KeyValues *pKeyValues, CVProfNode *pNode, int parent )
{
#ifdef VPROF_ENABLED

	bool fIsRoot = ( pNode == m_pVProfile->GetRoot() );
	if ( fIsRoot )
	{
		if( pNode->GetChild() )
		{
			FillTree( pKeyValues, pNode->GetChild(), parent );
		}
		return;
	}

	int id = parent;
	if (( m_nCurrentBudgetGroup < 0 ) || ( pNode->GetBudgetGroupID() == m_nCurrentBudgetGroup )) 
	{
		id = UpdateVProfTreeEntry( pKeyValues, pNode, parent );
	}

	if( pNode->GetSibling() )
	{
		FillTree( pKeyValues, pNode->GetSibling(), parent );
	}
	
	if( pNode->GetChild() )
	{
		FillTree( pKeyValues, pNode->GetChild(), m_bHierarchicalView ? id : parent );
	}
#endif
}


//-----------------------------------------------------------------------------
// Populates the budget group combo box
//-----------------------------------------------------------------------------
void CVProfPanel::PopulateBudgetGroupComboBox()
{
	int nBudgetGroupCount = m_pVProfile->GetNumBudgetGroups();
	while( m_nLastBudgetGroupCount < nBudgetGroupCount )
	{
		m_pVProfCategory->AddItem( m_pVProfile->GetBudgetGroupName(m_nLastBudgetGroupCount), NULL );
		++m_nLastBudgetGroupCount;
	}
}


//-----------------------------------------------------------------------------
// Populates the tree
//-----------------------------------------------------------------------------
void CVProfPanel::UpdateProfile( float filteredtime )
{
#ifdef VPROF_ENABLED
	//ExecuteDeferredOp();
	if (IsVisible())
	{
		PopulateBudgetGroupComboBox();

		SetTitle( CFmtStr( "VProf (%s) --  %d frames sampled", 
									   m_pVProfile->IsEnabled() ?  "running" : "not running",
										   m_pVProfile->NumFramesSampled() ), false );

		// It's important to cache bEnabled since calling pause can disable.
		bool bEnabled = m_pVProfile->IsEnabled();
		if( bEnabled )
		{
			m_pVProfile->Pause();
		}

		KeyValues * pVal = new KeyValues("");
		
		if ( !m_pHierarchy->GetTree()->GetItemCount() )
		{
			pVal->SetString( "Text", "Call tree" );
			CProfileHierarchyPanel::ColumnPanels_t cp;
			AddColumns( cp );
			m_RootItem = m_pHierarchy->AddItem( pVal, -1, cp );
			m_pHierarchy->SetItemColors( m_RootItem, Color( 255, 255, 255, 255 ), Color( 0, 0, 0, 255 ) );
			m_pHierarchy->ExpandItem( m_RootItem, true );
		}

		m_pHierarchy->ExpandItem( m_RootItem, true );

		const char *pScope = vprof_scope.GetString();
		CVProfNode *pStartNode = ( pScope[0] == 0 ) ? m_pVProfile->GetRoot()  : m_pVProfile->FindNode(m_pVProfile->GetRoot(), pScope );
		
		if ( pStartNode )
		{
			FillTree( pVal, pStartNode, m_RootItem );
		}
		
		pVal->deleteThis();

		if( bEnabled )
		{
			m_pVProfile->Resume();
		}
	}

	if ( m_pVProfile->IsEnabled() )
	{
		Assert( m_pVProfile->AtRoot() );
		
		if ( GetBudgetPanel()->IsBudgetPanelShown() )
			GetBudgetPanel()->SnapshotVProfHistory( filteredtime );

		WriteRemoteVProfData(); // send out the vprof data to remote endpoints
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CVProfPanel::UserCmd_ShowVProf( void )
{
	m_fShowVprofHeld = true;

	SetVisible( true );
	// This is hacky . . need to at least remember the previous value to set it back.
	ConVarRef cl_mouseenable( "cl_mouseenable" );
	if ( cl_mouseenable.IsValid() )
	{
		cl_mouseenable.SetValue( 0 );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CVProfPanel::UserCmd_HideVProf( void )
{
	m_fShowVprofHeld = false;

	SetVisible( false );

	// This is hacky . . need to at least remember the previous value to set it back.
	ConVarRef cl_mouseenable( "cl_mouseenable" );
	if ( cl_mouseenable.IsValid() )
	{
		cl_mouseenable.SetValue( 1 );
	}
}


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

void CVProfPanel::Paint()
{
	m_pVProfile->Pause();
	BaseClass::Paint();
	m_pVProfile->Resume();
}


void CVProfPanel::OnCommand( const char *pCommand )
{
#ifndef _XBOX
	if ( !Q_stricmp( pCommand, "StepForward" ) )
	{
		VProfPlayback_Step();
	}
	else if ( !Q_stricmp( pCommand, "StepBack" ) )
	{
		int shouldReset = VProfPlayback_StepBack();
		if ( shouldReset == 2 )
		{
			Reset();
		}
	}
	else if ( !Q_stricmp( pCommand, "GotoButton" ) )
	{
		int shouldReset = VProfPlayback_SeekToPercent( (float)m_pPlaybackScroll->GetValue() / 1000.0 );
		if ( shouldReset == 2 )
		{
			Reset();
		}
	}
	else if ( !Q_stricmp( pCommand, "redosort" ) )
	{
		//
		Assert( !m_bHierarchicalView );
		Reset();
	}
#endif
}

#endif