mirror of
https://github.com/chibicitiberiu/rainmeter-studio.git
synced 2024-02-24 04:33:31 +00:00
477 lines
10 KiB
C++
477 lines
10 KiB
C++
/*
|
|
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "StdAfx.h"
|
|
#include "MeterLine.h"
|
|
#include "Measure.h"
|
|
#include "Error.h"
|
|
|
|
using namespace Gdiplus;
|
|
|
|
/*
|
|
** The constructor
|
|
**
|
|
*/
|
|
CMeterLine::CMeterLine(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
|
|
m_Autoscale(false),
|
|
m_HorizontalLines(false),
|
|
m_Flip(false),
|
|
m_LineWidth(1.0),
|
|
m_HorizontalColor(Color::Black),
|
|
m_CurrentPos(),
|
|
m_GraphStartLeft(false),
|
|
m_GraphHorizontalOrientation(false)
|
|
{
|
|
}
|
|
|
|
/*
|
|
** The destructor
|
|
**
|
|
*/
|
|
CMeterLine::~CMeterLine()
|
|
{
|
|
}
|
|
|
|
/*
|
|
** create the buffer for the lines
|
|
**
|
|
*/
|
|
void CMeterLine::Initialize()
|
|
{
|
|
CMeter::Initialize();
|
|
|
|
size_t colorsSize = m_Colors.size();
|
|
size_t allValuesSize = m_AllValues.size();
|
|
size_t num = (allValuesSize > 0) ? m_AllValues[0].size() : 0;
|
|
int maxSize = m_GraphHorizontalOrientation ? m_H : m_W;
|
|
|
|
if (colorsSize != allValuesSize)
|
|
{
|
|
if (colorsSize > allValuesSize)
|
|
{
|
|
for (size_t i = allValuesSize; i < colorsSize; ++i)
|
|
{
|
|
m_AllValues.push_back(std::vector<double>());
|
|
|
|
if (maxSize > 0)
|
|
{
|
|
m_AllValues.back().assign(maxSize, 0.0);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_AllValues.resize(colorsSize);
|
|
}
|
|
}
|
|
|
|
if (maxSize < 0 || num != (size_t)maxSize)
|
|
{
|
|
if (m_CurrentPos >= maxSize) m_CurrentPos = 0;
|
|
|
|
num = (maxSize < 0) ? 0 : maxSize;
|
|
for (size_t i = 0; i < allValuesSize; ++i)
|
|
{
|
|
if (num != m_AllValues[i].size())
|
|
{
|
|
m_AllValues[i].resize(num, 0.0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Read the options specified in the ini file.
|
|
**
|
|
*/
|
|
void CMeterLine::ReadOptions(CConfigParser& parser, const WCHAR* section)
|
|
{
|
|
WCHAR tmpName[64];
|
|
|
|
// Store the current number of lines so we know if the buffer needs to be updated
|
|
int oldLineCount = (int)m_Colors.size();
|
|
int oldW = m_W;
|
|
|
|
CMeter::ReadOptions(parser, section);
|
|
|
|
int lineCount = parser.ReadInt(section, L"LineCount", 1);
|
|
|
|
m_Colors.clear();
|
|
m_ScaleValues.clear();
|
|
|
|
for (int i = 0; i < lineCount; ++i)
|
|
{
|
|
if (i == 0)
|
|
{
|
|
wcsncpy_s(tmpName, L"LineColor", _TRUNCATE);
|
|
}
|
|
else
|
|
{
|
|
_snwprintf_s(tmpName, _TRUNCATE, L"LineColor%i", i + 1);
|
|
}
|
|
|
|
m_Colors.push_back(parser.ReadColor(section, tmpName, Color::White));
|
|
|
|
if (i == 0)
|
|
{
|
|
wcsncpy_s(tmpName, L"Scale", _TRUNCATE);
|
|
}
|
|
else
|
|
{
|
|
_snwprintf_s(tmpName, _TRUNCATE, L"Scale%i", i + 1);
|
|
}
|
|
|
|
m_ScaleValues.push_back(parser.ReadFloat(section, tmpName, 1.0));
|
|
}
|
|
|
|
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);
|
|
ARGB color = parser.ReadColor(section, L"HorizontalColor", Color::Black); // This is left here for backwards compatibility
|
|
m_HorizontalColor = parser.ReadColor(section, L"HorizontalLineColor", color); // This is what it should be
|
|
|
|
if (m_Initialized &&
|
|
(oldLineCount != lineCount || oldW != m_W))
|
|
{
|
|
Initialize();
|
|
}
|
|
|
|
const WCHAR* graph = parser.ReadString(section, L"GraphStart", L"RIGHT").c_str();
|
|
if (_wcsicmp(graph, L"RIGHT") == 0)
|
|
{
|
|
m_GraphStartLeft = false;
|
|
}
|
|
else if (_wcsicmp(graph, L"LEFT") == 0)
|
|
{
|
|
m_GraphStartLeft = true;
|
|
}
|
|
else
|
|
{
|
|
LogWithArgs(LOG_ERROR, L"StartFrom=%s is not valid in [%s]", graph, m_Name.c_str());
|
|
}
|
|
|
|
graph = parser.ReadString(section, L"GraphOrientation", L"VERTICAL").c_str();
|
|
if (_wcsicmp(graph, L"VERTICAL") == 0)
|
|
{
|
|
// Restart graph
|
|
if (m_GraphHorizontalOrientation)
|
|
{
|
|
m_GraphHorizontalOrientation = false;
|
|
m_AllValues.clear();
|
|
Initialize();
|
|
m_CurrentPos = 0;
|
|
}
|
|
else
|
|
{
|
|
m_GraphHorizontalOrientation = false;
|
|
}
|
|
}
|
|
else if (_wcsicmp(graph, L"HORIZONTAL") == 0)
|
|
{
|
|
// Restart graph
|
|
if (!m_GraphHorizontalOrientation)
|
|
{
|
|
m_GraphHorizontalOrientation = true;
|
|
m_AllValues.clear();
|
|
Initialize();
|
|
m_CurrentPos = 0;
|
|
}
|
|
else
|
|
{
|
|
m_GraphHorizontalOrientation = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogWithArgs(LOG_ERROR, L"GraphOrientation=%s is not valid in [%s]", graph, m_Name.c_str());
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Updates the value(s) from the measures.
|
|
**
|
|
*/
|
|
bool CMeterLine::Update()
|
|
{
|
|
if (CMeter::Update() && !m_Measures.empty())
|
|
{
|
|
int maxSize = m_GraphHorizontalOrientation ? m_H : m_W;
|
|
|
|
if (maxSize > 0)
|
|
{
|
|
int counter = 0;
|
|
std::vector<CMeasure*>::const_iterator i = m_Measures.begin();
|
|
for ( ; i != m_Measures.end(); ++i)
|
|
{
|
|
double value = (*i)->GetValue();
|
|
|
|
m_AllValues[counter][m_CurrentPos] = value;
|
|
++counter;
|
|
}
|
|
|
|
++m_CurrentPos;
|
|
if (m_CurrentPos >= maxSize) m_CurrentPos = 0;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
** Draws the meter on the double buffer
|
|
**
|
|
*/
|
|
bool CMeterLine::Draw(Graphics& graphics)
|
|
{
|
|
int maxSize = m_GraphHorizontalOrientation ? m_H : m_W;
|
|
if (!CMeter::Draw(graphics) || maxSize <= 0) return false;
|
|
|
|
double maxValue = 0.0;
|
|
int counter = 0;
|
|
|
|
// Find the maximum value
|
|
if (m_Autoscale)
|
|
{
|
|
double newValue = 0;
|
|
std::vector< std::vector<double> >::const_iterator i = m_AllValues.begin();
|
|
counter = 0;
|
|
for (; i != m_AllValues.end(); ++i)
|
|
{
|
|
double scale = m_ScaleValues[counter];
|
|
std::vector<double>::const_iterator j = (*i).begin();
|
|
for (; j != (*i).end(); ++j)
|
|
{
|
|
double val = (*j) * scale;
|
|
newValue = max(newValue, val);
|
|
}
|
|
++counter;
|
|
}
|
|
|
|
// Scale the value up to nearest power of 2
|
|
if (newValue > DBL_MAX / 2.0)
|
|
{
|
|
maxValue = DBL_MAX;
|
|
}
|
|
else
|
|
{
|
|
maxValue = 2.0;
|
|
while (maxValue < newValue)
|
|
{
|
|
maxValue *= 2.0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!m_Measures.empty())
|
|
{
|
|
double maxValue = m_Measures[0]->GetMaxValue();
|
|
|
|
std::vector<CMeasure*>::const_iterator i = m_Measures.begin();
|
|
for (; i != m_Measures.end(); ++i)
|
|
{
|
|
double val = (*i)->GetMaxValue();
|
|
maxValue = max(maxValue, val);
|
|
}
|
|
}
|
|
|
|
if (maxValue == 0.0)
|
|
{
|
|
maxValue = 1.0;
|
|
}
|
|
}
|
|
|
|
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;
|
|
for (int j = 0; j < numOfLines; ++j)
|
|
{
|
|
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
|
|
|
|
if (m_GraphHorizontalOrientation)
|
|
{
|
|
const REAL W = m_W - 1.0f;
|
|
counter = 0;
|
|
std::vector< std::vector<double> >::const_iterator i = m_AllValues.begin();
|
|
for (; i != m_AllValues.end(); ++i)
|
|
{
|
|
// Draw a line
|
|
REAL X, oldX;
|
|
|
|
const double scale = m_ScaleValues[counter] * W / maxValue;
|
|
|
|
int pos = m_CurrentPos;
|
|
|
|
oldX = (REAL)((*i)[pos] * scale);
|
|
oldX = min(oldX, W);
|
|
oldX = max(oldX, 0.0f);
|
|
oldX = x + (m_GraphStartLeft ? oldX : W - oldX);
|
|
|
|
// Cache all lines
|
|
GraphicsPath path;
|
|
|
|
if (!m_Flip)
|
|
{
|
|
for (int j = y + 1, R = y + m_H; j < R; ++j)
|
|
{
|
|
++pos;
|
|
if (pos >= m_H) pos = 0;
|
|
|
|
X = (REAL)((*i)[pos] * scale);
|
|
X = min(X, W);
|
|
X = max(X, 0.0f);
|
|
X = x + (m_GraphStartLeft ? X : W - X);
|
|
|
|
path.AddLine(oldX, (REAL)(j - 1), X, (REAL)j);
|
|
|
|
oldX = X;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int j = y + m_H, R = y + 1; j > R; --j)
|
|
{
|
|
++pos;
|
|
if (pos >= m_H) pos = 0;
|
|
|
|
X = (REAL)((*i)[pos] * scale);
|
|
X = min(X, W);
|
|
X = max(X, 0.0f);
|
|
X = x + (m_GraphStartLeft ? X : W - X);
|
|
|
|
path.AddLine(oldX, (REAL)(j - 1), X, (REAL)(j - 2));
|
|
|
|
oldX = X;
|
|
}
|
|
}
|
|
|
|
// Draw cached lines
|
|
Pen pen(m_Colors[counter], (REAL)m_LineWidth);
|
|
pen.SetLineJoin(LineJoinBevel);
|
|
graphics.DrawPath(&pen, &path);
|
|
|
|
++counter;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const REAL H = m_H - 1.0f;
|
|
counter = 0;
|
|
std::vector< std::vector<double> >::const_iterator i = m_AllValues.begin();
|
|
for (; i != m_AllValues.end(); ++i)
|
|
{
|
|
// Draw a line
|
|
REAL Y, oldY;
|
|
|
|
const double scale = m_ScaleValues[counter] * H / maxValue;
|
|
|
|
int pos = m_CurrentPos;
|
|
|
|
oldY = (REAL)((*i)[pos] * scale);
|
|
oldY = min(oldY, H);
|
|
oldY = max(oldY, 0.0f);
|
|
oldY = y + (m_Flip ? oldY : H - oldY);
|
|
|
|
// Cache all lines
|
|
GraphicsPath path;
|
|
|
|
if (!m_GraphStartLeft)
|
|
{
|
|
for (int j = x + 1, R = x + m_W; j < R; ++j)
|
|
{
|
|
++pos;
|
|
if (pos >= m_W) pos = 0;
|
|
|
|
Y = (REAL)((*i)[pos] * scale);
|
|
Y = min(Y, H);
|
|
Y = max(Y, 0.0f);
|
|
Y = y + (m_Flip ? Y : H - Y);
|
|
|
|
path.AddLine((REAL)(j - 1), oldY, (REAL)j, Y);
|
|
|
|
oldY = Y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int j = x + m_W, R = x + 1; j > R; --j)
|
|
{
|
|
++pos;
|
|
if (pos >= m_W) pos = 0;
|
|
|
|
Y = (REAL)((*i)[pos] * scale);
|
|
Y = min(Y, H);
|
|
Y = max(Y, 0.0f);
|
|
Y = y + (m_Flip ? Y : H - Y);
|
|
|
|
path.AddLine((REAL)(j - 1), oldY, (REAL)(j - 2), Y);
|
|
|
|
oldY = Y;
|
|
}
|
|
}
|
|
|
|
// Draw cached lines
|
|
Pen pen(m_Colors[counter], (REAL)m_LineWidth);
|
|
pen.SetLineJoin(LineJoinBevel);
|
|
graphics.DrawPath(&pen, &path);
|
|
|
|
++counter;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
** Overwritten method to handle the other measure bindings.
|
|
**
|
|
*/
|
|
void CMeterLine::BindMeasures(CConfigParser& parser, const WCHAR* section)
|
|
{
|
|
if (BindPrimaryMeasure(parser, section, false))
|
|
{
|
|
BindSecondaryMeasures(parser, section);
|
|
}
|
|
}
|