rainmeter-studio/Library/MeterLine.cpp

381 lines
7.8 KiB
C++
Raw Normal View History

2009-02-10 18:37:48 +00:00
/*
Copyright (C) 2001 Kimmo Pekkola
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "StdAfx.h"
2009-02-10 18:37:48 +00:00
#include "MeterLine.h"
#include "Measure.h"
#include "Error.h"
using namespace Gdiplus;
/*
** CMeterLine
**
** The constructor
**
*/
CMeterLine::CMeterLine(CMeterWindow* meterWindow) : CMeter(meterWindow),
m_HorizontalColor(Color::Black)
2009-02-10 18:37:48 +00:00
{
m_Autoscale = false;
m_HorizontalLines = false;
m_CurrentPos = 0;
m_Flip = false;
m_LineWidth = 1.0;
}
/*
** ~CMeterLine
**
** The destructor
**
*/
CMeterLine::~CMeterLine()
{
}
/*
** Initialize
**
** create the buffer for the lines
**
*/
void CMeterLine::Initialize()
{
CMeter::Initialize();
if (m_Colors.size() != m_AllValues.size())
2009-02-10 18:37:48 +00:00
{
if (m_Colors.size() > m_AllValues.size())
{
size_t num = (!m_AllValues.empty()) ? m_AllValues[0].size() : 0;
2010-03-30 22:37:05 +00:00
for (size_t i = m_AllValues.size(), end = m_Colors.size(); i < end; ++i)
{
m_AllValues.push_back(std::vector<double>());
if (num > 0)
{
m_AllValues.back().assign(num, 0);
}
}
}
else
{
m_AllValues.resize(m_Colors.size());
}
2009-02-10 18:37:48 +00:00
}
}
/*
** ReadConfig
**
** Read the meter-specific configs from the ini-file.
**
*/
void CMeterLine::ReadConfig(const WCHAR* section)
{
2010-09-13 20:06:52 +00:00
WCHAR tmpName[64];
2009-02-10 18:37:48 +00:00
// Store the current number of lines so we know if the buffer needs to be updated
int oldLineCount = (int)m_Colors.size();
2009-02-10 18:37:48 +00:00
// Read common configs
CMeter::ReadConfig(section);
CConfigParser& parser = m_MeterWindow->GetParser();
2009-09-04 16:37:51 +00:00
int lineCount = parser.ReadInt(section, L"LineCount", 1);
2009-02-10 18:37:48 +00:00
m_Colors.clear();
m_ScaleValues.clear();
m_MeasureNames.clear();
for (int i = 0; i < lineCount; ++i)
2009-02-10 18:37:48 +00:00
{
if (i == 0)
{
wcscpy(tmpName, L"LineColor");
}
else
{
swprintf(tmpName, L"LineColor%i", i + 1);
}
2009-09-04 16:37:51 +00:00
m_Colors.push_back(parser.ReadColor(section, tmpName, Color::White));
2009-02-10 18:37:48 +00:00
if (i == 0)
{
wcscpy(tmpName, L"Scale");
}
else
{
swprintf(tmpName, L"Scale%i", i + 1);
}
2009-09-04 16:37:51 +00:00
m_ScaleValues.push_back(parser.ReadFloat(section, tmpName, 1.0));
2009-02-10 18:37:48 +00:00
if (i != 0)
{
swprintf(tmpName, L"MeasureName%i", i + 1);
2009-09-04 16:37:51 +00:00
m_MeasureNames.push_back(parser.ReadString(section, tmpName, L""));
2009-02-10 18:37:48 +00:00
}
}
2009-09-04 16:37:51 +00:00
m_Flip = 0!=parser.ReadInt(section, L"Flip", 0);
m_Autoscale = 0!=parser.ReadInt(section, L"AutoScale", 0);
m_LineWidth = parser.ReadFloat(section, L"LineWidth", 1.0);
m_HorizontalLines = 0!=parser.ReadInt(section, L"HorizontalLines", 0);
m_HorizontalColor = parser.ReadColor(section, L"HorizontalColor", Color::Black); // This is left here for backwards compatibility
m_HorizontalColor = parser.ReadColor(section, L"HorizontalLineColor", m_HorizontalColor); // This is what it should be
if (m_Initialized &&
oldLineCount != lineCount)
{
Initialize();
}
2009-02-10 18:37:48 +00:00
}
/*
** Update
**
** Updates the value(s) from the measures.
**
*/
bool CMeterLine::Update()
{
if (CMeter::Update() && m_Measure)
{
// Collect the values
if (!m_Measure->IsDisabled())
{
double value = m_Measure->GetValue();
2009-02-14 10:11:28 +00:00
if ((int)m_AllValues[0].size() < m_W)
2009-02-10 18:37:48 +00:00
{
m_AllValues[0].push_back(value);
}
else
{
m_AllValues[0][m_CurrentPos] = value;
}
}
int counter = 1;
2010-03-30 22:37:05 +00:00
std::vector<CMeasure*>::const_iterator i = m_Measures.begin();
for ( ; i != m_Measures.end(); ++i)
2009-02-10 18:37:48 +00:00
{
double value = (*i)->GetValue();
2009-02-14 10:11:28 +00:00
if ((int)m_AllValues[counter].size() < m_W)
2009-02-10 18:37:48 +00:00
{
m_AllValues[counter].push_back(value);
}
else
{
m_AllValues[counter][m_CurrentPos] = value;
}
2010-03-30 22:37:05 +00:00
++counter;
2009-02-10 18:37:48 +00:00
}
2010-03-30 22:37:05 +00:00
++m_CurrentPos;
2009-02-10 18:37:48 +00:00
if (m_CurrentPos >= m_W)
{
m_CurrentPos = 0;
}
return true;
}
return false;
}
/*
** Draw
**
** Draws the meter on the double buffer
**
*/
bool CMeterLine::Draw(Graphics& graphics)
2009-02-10 18:37:48 +00:00
{
if(!CMeter::Draw(graphics)) return false;
2009-02-10 18:37:48 +00:00
double maxValue = 0.0;
int counter = 0;
// Find the maximum value
if (m_Autoscale)
{
double newValue = 0;
2010-03-30 22:37:05 +00:00
std::vector< std::vector<double> >::const_iterator i = m_AllValues.begin();
2009-02-10 18:37:48 +00:00
counter = 0;
2010-03-30 22:37:05 +00:00
for (; i != m_AllValues.end(); ++i)
2009-02-10 18:37:48 +00:00
{
double scale = m_ScaleValues[counter];
2010-03-30 22:37:05 +00:00
std::vector<double>::const_iterator j = (*i).begin();
for (; j != (*i).end(); ++j)
2009-02-10 18:37:48 +00:00
{
double val = (*j) * scale;
newValue = max(newValue, val);
2009-02-10 18:37:48 +00:00
}
2010-03-30 22:37:05 +00:00
++counter;
2009-02-10 18:37:48 +00:00
}
// Scale the value up to nearest power of 2
if (newValue > DBL_MAX / 2.0)
2009-02-10 18:37:48 +00:00
{
maxValue = DBL_MAX;
}
else
{
maxValue = 2.0;
while (maxValue < newValue)
{
maxValue *= 2.0;
}
2009-02-10 18:37:48 +00:00
}
}
else
{
if (m_Measure)
{
maxValue = m_Measure->GetMaxValue();
2010-03-30 22:37:05 +00:00
std::vector<CMeasure*>::const_iterator i = m_Measures.begin();
for (; i != m_Measures.end(); ++i)
2009-02-10 18:37:48 +00:00
{
double val = (*i)->GetMaxValue();
maxValue = max(maxValue, val);
2009-02-10 18:37:48 +00:00
}
}
if (maxValue == 0.0)
{
maxValue = 1.0;
}
2009-02-10 18:37:48 +00:00
}
int x = GetX();
int y = GetY();
// Draw the horizontal lines
if (m_HorizontalLines)
{
// Calc the max number of lines we should draw
int maxLines = m_H / 4; // one line per 4 pixels is max
int numOfLines;
// Check the highest power of 2 that fits in maxLines
int power = 2;
while(power < maxLines)
{
power *= 2;
}
numOfLines = ((int)maxValue % power) + 1;
Pen pen(m_HorizontalColor);
REAL Y;
2010-03-30 22:37:05 +00:00
for (int j = 0; j < numOfLines; ++j)
2009-02-10 18:37:48 +00:00
{
Y = (REAL)((j + 1) * m_H / (numOfLines + 1));
Y = y + m_H - Y - 1;
graphics.DrawLine(&pen, (REAL)x, Y, (REAL)(x + m_W - 1), Y); // GDI+
}
}
// Draw all the lines
counter = 0;
2010-03-30 22:37:05 +00:00
std::vector< std::vector<double> >::const_iterator i = m_AllValues.begin();
for (; i != m_AllValues.end(); ++i)
2009-02-10 18:37:48 +00:00
{
// Draw a line
REAL Y = 0.0f;
REAL oldY = 0.0f;
REAL H = m_H - 1.0f;
2010-03-30 22:37:05 +00:00
double scale = m_ScaleValues[counter] * H / maxValue;
int pos = m_CurrentPos;
2010-03-30 22:37:05 +00:00
int size = (int)(*i).size();
2009-02-10 18:37:48 +00:00
Pen pen(m_Colors[counter], (REAL)m_LineWidth);
for (int j = x, R = x + m_W; j < R; ++j)
2009-02-10 18:37:48 +00:00
{
if (pos >= m_W) pos = 0;
2010-03-30 22:37:05 +00:00
if (pos < size)
2009-02-10 18:37:48 +00:00
{
Y = (REAL)((*i)[pos] * scale);
Y = min(Y, H);
Y = max(Y, 0.0f);
2009-02-10 18:37:48 +00:00
}
else
{
Y = 0.0f;
2009-02-10 18:37:48 +00:00
}
Y = (m_Flip) ? y + Y : y + H - Y;
2009-02-10 18:37:48 +00:00
if (j != x)
2009-02-10 18:37:48 +00:00
{
graphics.DrawLine(&pen, (REAL)(j - 1), oldY, (REAL)j, Y); // GDI+
2009-02-10 18:37:48 +00:00
}
oldY = Y;
2010-03-30 22:37:05 +00:00
++pos;
2009-02-10 18:37:48 +00:00
}
2010-03-30 22:37:05 +00:00
++counter;
2009-02-10 18:37:48 +00:00
}
return true;
}
/*
** BindMeasure
**
** Overwritten method to handle the other measure bindings.
**
*/
void CMeterLine::BindMeasure(std::list<CMeasure*>& measures)
{
CMeter::BindMeasure(measures);
2010-03-30 22:37:05 +00:00
std::vector<std::wstring>::const_iterator j = m_MeasureNames.begin();
for (; j != m_MeasureNames.end(); ++j)
2009-02-10 18:37:48 +00:00
{
// Go through the list and check it there is a secondary measure for us
2010-03-30 22:37:05 +00:00
std::list<CMeasure*>::const_iterator i = measures.begin();
for( ; i != measures.end(); ++i)
2009-02-10 18:37:48 +00:00
{
if(_wcsicmp((*i)->GetName(), (*j).c_str()) == 0)
{
m_Measures.push_back(*i);
break;
}
}
if (i == measures.end())
{
throw CError(std::wstring(L"The meter [") + m_Name + L"] cannot be bound with [" + (*j) + L"]!", __LINE__, __FILE__);
}
}
CMeter::SetAllMeasures(m_Measures);
2009-02-10 18:37:48 +00:00
}