path: root/tracker/AdminServer/GraphPanel.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================

#include <stdio.h>

#include "GraphPanel.h"

#include <vgui/ISystem.h>
#include <vgui/ISurface.h>
#include <vgui/IVGui.h>
#include <vgui/IScheme.h>
#include <vgui/ILocalize.h>
#include <KeyValues.h>

#include <vgui_controls/Label.h>
#include <vgui_controls/TextEntry.h>
#include <vgui_controls/Button.h>
#include <vgui_controls/ToggleButton.h>
#include <vgui_controls/RadioButton.h>
#include <vgui_controls/ListPanel.h>
#include <vgui_controls/ComboBox.h>
#include <vgui_controls/PHandle.h>
#include <vgui_controls/PropertySheet.h>
#include <vgui_controls/CheckButton.h>

#define max(a,b)            (((a) > (b)) ? (a) : (b))

#define STATS_UPDATE_RATE	5.0f


// colors for the various graph lines+controls
Color CGraphPanel::CGraphsImage::CPUColor= Color(0,255,0,255); // green
Color CGraphPanel::CGraphsImage::FPSColor= Color(255,0,0,255); // red
Color CGraphPanel::CGraphsImage::NetInColor = Color(255,255,0,255); // yellow
Color CGraphPanel::CGraphsImage::NetOutColor = Color(0,255,255,255); // light blue
Color CGraphPanel::CGraphsImage::PlayersColor = Color(255,0,255,255); // purple
Color CGraphPanel::CGraphsImage::PingColor = Color(0,0,0,255); // black
//Color CGraphPanel::CGraphsImage::lineColor = Color(76,88,68,255);

using namespace vgui;

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGraphPanel::CGraphPanel(vgui::Panel *parent, const char *name) : PropertyPage(parent, name)
{
	SetMinimumSize(300,200);

	m_pGraphsPanel = new ImagePanel(this,"Graphs");
	m_pGraphs = new CGraphsImage();
	m_pGraphsPanel->SetImage(m_pGraphs);

	m_pInButton = new CheckButton(this,"InCheck","#Graph_In");
	m_pOutButton = new CheckButton(this,"OutCheck","#Graph_Out");
	m_pFPSButton = new CheckButton(this,"FPSCheck","#Graph_FPS");
	m_pCPUButton = new CheckButton(this,"CPUCheck","#Graph_CPU");
	m_pPINGButton = new CheckButton(this,"PingCheck","#Graph_Ping");
	m_pPlayerButton = new CheckButton(this,"PlayersCheck","#Graph_Players");

	m_pTimeCombo = new ComboBox(this, "TimeCombo",3,false);
	m_pTimeCombo->AddItem("#Graph_Minutes", NULL);
	int defaultItem = m_pTimeCombo->AddItem("#Graph_Hours", NULL);
	m_pTimeCombo->AddItem("#Graph_Day", NULL);
	m_pTimeCombo->ActivateItem(defaultItem);

	m_pVertCombo = new ComboBox(this, "VertCombo",6,false);
	m_pVertCombo->AddItem("#Graph_In", NULL);
	m_pVertCombo->AddItem("#Graph_Out", NULL);
	m_pVertCombo->AddItem("#Graph_FPS", NULL);
	defaultItem = m_pVertCombo->AddItem("#Graph_CPU", NULL);
	m_pVertCombo->AddItem("#Graph_Ping", NULL);
	m_pVertCombo->AddItem("#Graph_Players", NULL);
	m_pVertCombo->ActivateItem(defaultItem);

	// now setup defaults
	m_pCPUButton->SetSelected(true);
	m_pInButton->SetSelected(false);
	m_pOutButton->SetSelected(false);
	m_pFPSButton->SetSelected(false);
	m_pPINGButton->SetSelected(false);

	LoadControlSettings("Admin/GraphPanel.res", "PLATFORM");

	int w,h;
	m_pGraphsPanel->GetSize(w,h);
	m_pGraphs->SaveSize(w,h);
	m_pGraphs->SetDraw(m_pCPUButton->IsSelected(),m_pFPSButton->IsSelected(),
	m_pInButton->IsSelected(),m_pOutButton->IsSelected(),m_pPINGButton->IsSelected(),m_pPlayerButton->IsSelected());

	m_pPINGButton->SetFgColor(m_pGraphs->GetPingColor());
	m_pCPUButton->SetFgColor(m_pGraphs->GetCPUColor());
	m_pFPSButton->SetFgColor(m_pGraphs->GetFPSColor());
	m_pInButton->SetFgColor(m_pGraphs->GetInColor());
	m_pOutButton->SetFgColor(m_pGraphs->GetOutColor());
	m_pPlayerButton->SetFgColor(m_pGraphs->GetPlayersColor());

	ivgui()->AddTickSignal(GetVPanel());
	m_flNextStatsUpdateTime = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGraphPanel::~CGraphPanel()
{

}

void CGraphPanel::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	m_pGraphsPanel->SetBorder(	pScheme->GetBorder("ButtonDepressedBorder"));
	m_pGraphs->SetBgColor(GetSchemeColor("WindowBG", pScheme));
	m_pGraphs->SetAxisColor(Color(76,88,68,255));

}

//-----------------------------------------------------------------------------
// Purpose: Activates the page
//-----------------------------------------------------------------------------
void CGraphPanel::OnPageShow()
{
	BaseClass::OnPageShow();
}

//-----------------------------------------------------------------------------
// Purpose: Hides the page
//-----------------------------------------------------------------------------
void CGraphPanel::OnPageHide()
{
	BaseClass::OnPageHide();
}

//-----------------------------------------------------------------------------
// Purpose: called every frame to update stats page
//-----------------------------------------------------------------------------
void CGraphPanel::OnTick()
{
	if (m_flNextStatsUpdateTime > system()->GetFrameTime())
		return;

	m_flNextStatsUpdateTime = (float)system()->GetFrameTime() + STATS_UPDATE_RATE;
	RemoteServer().RequestValue(this, "stats");	
}

//-----------------------------------------------------------------------------
// Purpose: tells the image about the new size
//-----------------------------------------------------------------------------
void CGraphPanel::PerformLayout()
{
	BaseClass::PerformLayout();
	int w,h,x,y;
	m_pGraphsPanel->GetBounds(x,y,w,h);

	m_pGraphs->SaveSize(w,h); // tell the image about the resize

	// push the mid axis label to the middle of the image
	Label *entry = dynamic_cast<Label *>(FindChildByName("AxisMid"));
	if (entry)
	{
		int entry_x,entry_y;
		entry->GetPos(entry_x,entry_y);
		entry->SetPos(entry_x,y+(h/2)-8);
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handles stats command returns
//-----------------------------------------------------------------------------
void CGraphPanel::OnServerDataResponse(const char *value, const char *response)
{
	if (!stricmp(value, "stats"))
	{
		// parse the stats out of the response
		Points_t p;
		float uptime, users;
		sscanf(response, "%f %f %f %f %f %f %f", &p.cpu, &p.in, &p.out, &uptime, &users, &p.fps, &p.players);
		p.cpu = p.cpu / 100; // its given as a value between 0<x<100, we want 0<x<1
		p.ping = 0;
		p.time = (float)system()->GetCurrentTime();
		m_pGraphs->AddPoint(p);

		// days:hours:minutes:seconds
		char timeText[64];
		_snprintf(timeText, sizeof(timeText), "%i", (int)p.players);
		SetControlString("TotalUsersLabel", timeText);

		// mark the vert combo has changed to force it to update graph ranges
		m_pVertCombo->GetText(timeText, 64);
		OnTextChanged(m_pVertCombo, timeText);
	}
}

//-----------------------------------------------------------------------------
// Purpose: the paint routine for the graph image. Handles the layout and drawing of the graph image
//-----------------------------------------------------------------------------
void CGraphPanel::CGraphsImage::Paint()
{
	int x,y;
	float distPoints; // needs to be a float, rounding errors cause problems with lots of points
	int bottom=5; // be 5 pixels above the bottom
	int left=2;

	int *pCpuX=NULL, *pCpuY=NULL;
	int *pInX=NULL, *pInY=NULL;
	int *pOutX=NULL, *pOutY=NULL;
	int *pFPSX=NULL, *pFPSY=NULL;
	int *pPingX=NULL, *pPingY=NULL;
	int *pPlayersX=NULL, *pPlayersY=NULL;

	GetSize(x,y);

	SetColor(bgColor);
	SetBkColor(bgColor);
	DrawFilledRect(0,0,x,y);

	y-=4; // borders
	x-=4;


	if(!cpu && !fps && !net_i && !net_o && !ping && !players) // no graphs selected
		return; 

	if(points.Count()<2)
		return; // not enough points yet...

	if(x<=200 || y<=100) 
		return; // to small


	distPoints= static_cast<float>(x)/static_cast<float>(points.Count()-1);
	if(distPoints<=0)
	{
		distPoints=1;
	}

	SetColor(lineColor);
	SetBkColor(lineColor);
	//DrawLine(4,5,x,5);
	DrawLine(4,y/2,x,y/2);
	//DrawLine(4,y,x,y);

	float RangePing=maxPing;
	float RangeFPS=maxFPS;
	float Range=0;
	float RangePlayers=maxPlayers;


	if(ping)
	{
		RangePing+=static_cast<float>(maxPing*0.1); // don't let the top of the range touch the top of the panel

		if(RangePing<=1) 
		{ // don't let the zero be at the top of the screen
			RangePing=1.0;
		}
		pPingX = new int[points.Count()];
		pPingY = new int[points.Count()];
	}

	if(cpu)
	{
		pCpuX = new int[points.Count()];
		pCpuY = new int[points.Count()];
	}
	
	if(fps)
	{			
		RangeFPS+=static_cast<float>(maxFPS*0.1); // don't let the top of the range touch the top of the panel

		if(RangeFPS<=1) 
		{ // don't let the zero be at the top of the screen
			RangeFPS=1.0;
		}
		pFPSX = new int[points.Count()];
		pFPSY = new int[points.Count()];
	}

	if(net_i)
	{
	
		// put them on a common scale, base it at zero 
		Range = max(maxIn,maxOut);
			
		Range+=static_cast<float>(Range*0.1); // don't let the top of the range touch the top of the panel

		if(Range<=1) 
		{ // don't let the zero be at the top of the screen
			Range=1.0;
		}

		pInX = new int[points.Count()];
		pInY = new int[points.Count()];
	}

	if(net_o)
	{
		// put them on a common scale, base it at zero 
		Range = max(maxIn,maxOut);
			
		Range+=static_cast<float>(Range*0.1); // don't let the top of the range touch the top of the panel

		if(Range<=1) 
		{ // don't let the zero be at the top of the screen
			Range=1.0;
		}

		pOutX = new int[points.Count()];
		pOutY = new int[points.Count()];
	}

	if(players)
	{
		RangePlayers+=static_cast<float>(maxPlayers*0.1); // don't let the top of the range touch the top of the panel

		pPlayersX = new int[points.Count()];
		pPlayersY = new int[points.Count()];
	}

	for(int i=0;i<points.Count();i++)
	// draw the graphs, left to right
	{
	
		if(cpu) 
		{
			pCpuX[i] = left+static_cast<int>(i*distPoints);
			pCpuY[i] = static_cast<int>((1-points[i].cpu)*y);
		}
	
		if(net_i)
		{
			pInX[i] = left+static_cast<int>(i*distPoints);
			pInY[i] = static_cast<int>(( (Range-points[i].in)/Range)*y-bottom);
		}
		
		if(net_o)
		{
			pOutX[i] = left+static_cast<int>(i*distPoints);
			pOutY[i] = static_cast<int>(((Range-points[i].out)/Range)*y-bottom);
		}

		if(fps)
		{
			pFPSX[i] = left+static_cast<int>(i*distPoints);
			pFPSY[i] = static_cast<int>(( (RangeFPS-points[i].fps)/RangeFPS)*y-bottom);
		}

		if(ping)
		{
			pPingX[i] = left+static_cast<int>(i*distPoints);
			pPingY[i] = static_cast<int>(( (RangePing-points[i].ping)/RangePing)*y-bottom);
		}

		if(players)
		{
			pPlayersX[i] = left+static_cast<int>(i*distPoints);
			pPlayersY[i] = static_cast<int>(( (RangePlayers-points[i].players)/RangePlayers)*y-bottom);
		}

	
	}
	// we use DrawPolyLine, its much, much, much more efficient than calling lots of DrawLine()'s

	if(cpu)
	{
		SetColor(CPUColor); // green
		DrawPolyLine(pCpuX, pCpuY, points.Count());	
		delete [] pCpuX;
		delete [] pCpuY;
	} 

	if(net_i) 
	{
		SetColor(NetInColor); // red
		DrawPolyLine(pInX, pInY, points.Count());	
		delete [] pInX;
		delete [] pInY;
	}
	if(net_o)
	{
		SetColor(NetOutColor); //yellow
		DrawPolyLine(pOutX, pOutY, points.Count());	
		delete [] pOutX;
		delete [] pOutY;
	}
	if(fps)
	{
		SetColor(FPSColor);
		DrawPolyLine(pFPSX, pFPSY, points.Count());	
		delete [] pFPSX;
		delete [] pFPSY;
	}

	if(ping)
	{
		SetColor(PingColor);
		DrawPolyLine(pPingX, pPingY, points.Count());	
		delete [] pPingX;
		delete [] pPingY;
	}

	if(players)
	{
		SetColor(PlayersColor);
		DrawPolyLine(pPlayersX, pPlayersY, points.Count());	
		delete [] pPlayersX;
		delete [] pPlayersY;
	}
}  


//-----------------------------------------------------------------------------
// Purpose: constructor for the graphs image
//-----------------------------------------------------------------------------
CGraphPanel::CGraphsImage::CGraphsImage(): vgui::Image(), points()
{
	maxIn=maxOut=minIn=minOut=minFPS=maxFPS=minPing=maxPing=0;
	net_i=net_o=fps=cpu=ping=players=false;
	numAvgs=0;
	memset(&avgPoint,0x0,sizeof(Points_t));
}

//-----------------------------------------------------------------------------
// Purpose: sets which graph to draw, true means draw it
//-----------------------------------------------------------------------------
void CGraphPanel::CGraphsImage::SetDraw(bool cpu_in,bool fps_in,bool net_in,bool net_out,bool ping_in,bool players_in)
{
	cpu=cpu_in;
	fps=fps_in;
	net_i=net_in;
	net_o=net_out;
	ping=ping_in;
	players=players_in;
}

//-----------------------------------------------------------------------------
// Purpose: used to average points over a period of time
//-----------------------------------------------------------------------------
void CGraphPanel::CGraphsImage::AvgPoint(Points_t p)
{
	avgPoint.cpu += p.cpu;
	avgPoint.fps += p.fps;
	avgPoint.in += p.in;
	avgPoint.out += p.out;
	avgPoint.ping += p.ping;
	avgPoint.players += p.players;
	numAvgs++;
}


//-----------------------------------------------------------------------------
// Purpose: updates the current bounds of the points based on this new point
//-----------------------------------------------------------------------------
void CGraphPanel::CGraphsImage::CheckBounds(Points_t p)
{
	if(p.in>maxIn)
	{
		maxIn=avgPoint.in;
	}
	if(p.out>maxOut)
	{
		maxOut=avgPoint.out;
	}

	if(p.in<minIn)
	{
		minIn=avgPoint.in;
	}
	if(p.out<minOut)
	{
		minOut=avgPoint.out;
	}

	if(p.fps>maxFPS)
	{
		maxFPS=avgPoint.fps;
	}
	if(p.fps<minFPS)
	{
		minFPS=avgPoint.fps;
	}

	if(p.ping>maxPing)
	{
		maxPing=avgPoint.ping;
	}
	if(p.ping<minPing)
	{
		minPing=avgPoint.ping;
	}

	if(p.players>maxPlayers)
	{
		maxPlayers=avgPoint.players;
	}
	if(p.players<minPlayers)
	{
		minPlayers=avgPoint.players;
	}
	
}

//-----------------------------------------------------------------------------
// Purpose: adds a point to the graph image. 
//-----------------------------------------------------------------------------
bool CGraphPanel::CGraphsImage::AddPoint(Points_t p)
{
	int x,y;
	bool recalcBounds=false;

	GetSize(x,y);
	
	if(avgPoint.cpu>1)  // cpu is a percent !
	{
		return false;
	}

	if(timeBetween==SECONDS) // most recent minute
	{
		while(points.Count() && (p.time-points[0].time)>60)
		{
			points.Remove(0);
		}
	}
	else if(timeBetween==HOURS) // most recent hour
	{
		while(points.Count() && (p.time-points[0].time)>60*60)
		{
			points.Remove(0);
		}
	} 
	else if ( timeBetween==MINUTES) // most recent day
	{
			while(points.Count() && (p.time-points[0].time)>60*60*24)
		{
			points.Remove(0);
		}
	}

	AvgPoint(p);
	// now work out the average of all the values
	avgPoint.cpu /= numAvgs;
	avgPoint.fps /= numAvgs;
	avgPoint.in  /= numAvgs;
	avgPoint.out /= numAvgs;
	avgPoint.ping /= numAvgs;
	avgPoint.players /= numAvgs;
	avgPoint.time = p.time;
	numAvgs=0;

	int k=0;

	if(x!=0 && points.Count()> x/2) 
	// there are more points than pixels so thin them out
	{
		while(points.Count()> x/2)
		{
			// check that the bounds don't move
			if(points[0].in==maxIn ||
				points[0].out==maxOut ||
				points[0].fps==maxFPS ||
				points[0].ping==maxPing ||
				points[0].players==maxPlayers)
			{
				recalcBounds=true;
			}
			points.Remove(k); // remove the head node
			k+=2;
			if(k>points.Count()) 
			{
				k=0;
			}
		}
	}

	if(recalcBounds) 
	{
		for(int i=0;i<points.Count();i++)
		{
			CheckBounds(points[i]);
		}
	}


	CheckBounds(avgPoint);

	points.AddToTail(avgPoint);
	
	memset(&avgPoint,0x0,sizeof(Points_t));

	return true;
}

void CGraphPanel::CGraphsImage::SetScale(intervals time)
{
	timeBetween=time;

	// scale is reset so remove all the points
	points.RemoveAll();

	// and reset the maxes
	maxIn=maxOut=minIn=minOut=minFPS=maxFPS=minPing=maxPing=maxPlayers=minPlayers=0;

}


//-----------------------------------------------------------------------------
// Purpose: clear button handler, clears the current points
//-----------------------------------------------------------------------------
void CGraphPanel::OnClearButton()
{
	m_pGraphs->RemovePoints();
}

//-----------------------------------------------------------------------------
// Purpose: passes the state of the check buttons (for graph line display) through to the graph image
//-----------------------------------------------------------------------------
void CGraphPanel::OnCheckButton()
{
	m_pGraphs->SetDraw(m_pCPUButton->IsSelected(), m_pFPSButton->IsSelected(), m_pInButton->IsSelected(), m_pOutButton->IsSelected(), m_pPINGButton->IsSelected(), m_pPlayerButton->IsSelected());
}

//-----------------------------------------------------------------------------
// Purpose:Handles the scale radio buttons, passes the scale to use through to the graph image
//-----------------------------------------------------------------------------
void CGraphPanel::OnTextChanged(Panel *panel, const char *text)
{
	if (panel == m_pTimeCombo)
	{
		if (strstr(text, "Hour"))
		{
			m_pGraphs->SetScale(MINUTES);
		}
		else if (strstr(text, "Day"))
		{
			m_pGraphs->SetScale(HOURS);
		}
		else
		{
			m_pGraphs->SetScale(SECONDS);
		}
	}
	else if (panel == m_pVertCombo)
	{
		float maxVal, minVal;
		char minText[20], midText[20], maxText[20];

		if (strstr(text, "CPU"))
		{
			SetAxisLabels(m_pGraphs->GetCPUColor(), "100%", "50%", "0%");
		}
		else if (strstr(text, "FPS"))
		{
			m_pGraphs->GetFPSLimits(maxVal, minVal);
			sprintf(maxText,"%0.2f", maxVal);
			sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
			sprintf(minText,"%0.2f", minVal);
			SetAxisLabels(m_pGraphs->GetFPSColor(), maxText, midText, minText);
		}
		else if (strstr(text, "In"))
		{
			m_pGraphs->GetInLimits(maxVal, minVal);
			sprintf(maxText,"%0.2f", maxVal);
			sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
			sprintf(minText,"%0.2f", minVal);

			SetAxisLabels(m_pGraphs->GetInColor(), maxText, midText, minText);
		}
		else if (strstr(text, "Out"))
		{
			m_pGraphs->GetOutLimits(maxVal, minVal);
			sprintf(maxText,"%0.2f", maxVal);
			sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
			sprintf(minText,"%0.2f", minVal);
			SetAxisLabels(m_pGraphs->GetOutColor(), maxText, midText, minText);
		}
		else if (strstr(text, "Ping"))
		{
			m_pGraphs->GetPingLimits(maxVal, minVal);
			sprintf(maxText,"%0.2f", maxVal);
			sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
			sprintf(minText,"%0.2f", minVal);
			SetAxisLabels(m_pGraphs->GetPingColor(), maxText, midText, minText);
		}
		else if (strstr(text, "Players"))
		{
			m_pGraphs->GetPlayerLimits(maxVal, minVal);
			sprintf(maxText,"%0.2f", maxVal);
			sprintf(midText,"%0.2f", (maxVal - minVal) / 2);
			sprintf(minText,"%0.2f", minVal);

			SetAxisLabels(m_pGraphs->GetPlayersColor(), maxText, midText, minText);
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGraphPanel::SetAxisLabels(Color c, char *max, char *mid, char *min)
{
	Label *lab;
	lab= GetLabel("AxisMax");
	if(lab)
	{
		lab->SetFgColor(c);
		lab->SetText(max);
	}
	lab = GetLabel("AxisMid");
	if(lab)
	{
		lab->SetFgColor(c);
		lab->SetText(mid);
	}
	lab = GetLabel("AxisMin");
	if(lab)
	{
		lab->SetFgColor(c);
		lab->SetText(min);
	}
}

Label *CGraphPanel::GetLabel(const char *name)
{
	Label *lab = dynamic_cast<Label *>(FindChildByName(name));
	return lab;
}