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