rainmeter-studio/Library/Meter.cpp

/*
  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.
*/

#pragma warning(disable: 4996)

#include "Error.h"
#include "Meter.h"
#include "MeterBitmap.h"
#include "MeterBar.h"
#include "MeterHistogram.h"
#include "MeterString.h"
#include "MeterImage.h"
#include "MeterLine.h"
#include "MeterRoundLine.h"
#include "MeterRotator.h"
#include "MeterButton.h"
#include "Measure.h"
#include "Rainmeter.h"

using namespace Gdiplus;

int CMeter::c_OldX = 0;
int CMeter::c_OldY = 0;

/*
** CMeter
**
** The constructor
**
*/
CMeter::CMeter(CMeterWindow* meterWindow)
{
	m_Measure = NULL;
	m_X = 0;
	m_Y = 0;
	m_W = 0;
	m_H = 0;
	m_RelativeMeter = NULL;
	m_Hidden = false;
	m_SolidBevel = BEVELTYPE_NONE;
	m_MouseOver = false;
	m_UpdateDivider = 1;
	m_UpdateCounter = 0;
	m_RelativeX = POSITION_ABSOLUTE;
	m_RelativeY = POSITION_ABSOLUTE;
	m_MeterWindow = NULL;
	m_SolidAngle = 0.0;
	m_MeterWindow = meterWindow;
	m_AntiAlias = false;
	m_DynamicVariables = false;
	m_Initialized = false;
}

/*
** ~CMeter
**
** The destructor
**
*/
CMeter::~CMeter()
{
}

/*
** Initialize
**
** Initializes the meter. The base implementation just stores the pointer.
** Usually this method is overwritten by the inherited classes, which load
** bitmaps and such things during initialization.
**
*/
void CMeter::Initialize()
{
	m_Initialized = true;
}

/*
** GetX
**
** Returns the X-position of the meter.
**
*/
int CMeter::GetX(bool abs)
{
	if (m_RelativeX != POSITION_ABSOLUTE && m_MeterWindow)
	{
		if (m_RelativeMeter == NULL)
		{
			std::list<CMeter*>& meters = m_MeterWindow->GetMeters();
			std::list<CMeter*>::iterator iter = meters.begin();

			// Find this meter
			for ( ; iter != meters.end(); iter++)
			{
				if (*iter == this && iter != meters.begin())
				{
					iter--;
					m_RelativeMeter = (*iter);
					if (m_RelativeX == POSITION_RELATIVE_TL)
					{
						return m_RelativeMeter->GetX(true) + m_X;
					}
					else
					{
						return m_RelativeMeter->GetX(true) + m_RelativeMeter->GetW() + m_X;
					}
				}
			}
		}
		else
		{
			if (m_RelativeX == POSITION_RELATIVE_TL)
			{
				return m_RelativeMeter->GetX(true) + m_X;
			}
			else
			{
				return m_RelativeMeter->GetX(true) + m_RelativeMeter->GetW() + m_X;
			}
		}
	}
	return m_X; 
}

/*
** GetY
**
** Returns the Y-position of the meter.
**
*/
int CMeter::GetY(bool abs)
{
	if (m_RelativeY != POSITION_ABSOLUTE && m_MeterWindow)
	{
		if (m_RelativeMeter == NULL)
		{
			std::list<CMeter*>& meters = m_MeterWindow->GetMeters();
			std::list<CMeter*>::iterator iter = meters.begin();

			// Find this meter
			for ( ; iter != meters.end(); iter++)
			{
				if (*iter == this && iter != meters.begin())
				{
					iter--;
					m_RelativeMeter = (*iter);
					if (m_RelativeY == POSITION_RELATIVE_TL)
					{
						return m_RelativeMeter->GetY() + m_Y;
					}
					else
					{
						return m_RelativeMeter->GetY() + m_RelativeMeter->GetH() + m_Y;
					}
				}
			}
		}
		else
		{
			if (m_RelativeY == POSITION_RELATIVE_TL)
			{
				return m_RelativeMeter->GetY() + m_Y;
			}
			else
			{
				return m_RelativeMeter->GetY() + m_RelativeMeter->GetH() + m_Y;
			}
		}
	}
	return m_Y; 
}

/*
** HitTest
**
** Checks if the given point is inside the meter.
**
*/
bool CMeter::HitTest(int x, int y)
{
	if (x >= GetX() && x <= GetX() + GetW() && y >= GetY() && y <= GetY() + GetH())
	{
		return true;
	}
	return false;
}

/*
** ReadConfig
**
** Reads the meter-specific configs from the ini-file. The base implementation
** reads the common settings for all meters. The inherited classes must call 
** the base implementation if they overwrite this method.
**
*/
void CMeter::ReadConfig(const WCHAR* section)
{
	CConfigParser& parser = m_MeterWindow->GetParser();

	m_StyleName = parser.ReadString(section, L"MeterStyle", L"");

	const std::wstring& x = parser.ReadString(section, L"X", L"0");
	if (x.size() > 0)
	{
		m_X = _wtoi(x.c_str());
		if (x[x.size() - 1] == L'r')
		{
			m_RelativeX = POSITION_RELATIVE_TL;
		}
		else if (x[x.size() - 1] == L'R')
		{
			m_RelativeX = POSITION_RELATIVE_BR;
		}
		else
		{
			m_X = (int)parser.ReadFormula(section, L"X", 0.0);
		}
	}

	const std::wstring& y = parser.ReadString(section, L"Y", L"0");
	if (y.size() > 0)
	{
		m_Y = _wtoi(y.c_str());
		if (y[y.size() - 1] == L'r')
		{
			m_RelativeY = POSITION_RELATIVE_TL;
		}
		else if (y[y.size() - 1] == L'R')
		{
			m_RelativeY = POSITION_RELATIVE_BR;
		}
		else
		{
			m_Y = (int)parser.ReadFormula(section, L"Y", 0.0);
		}
	}


	m_W = (int)parser.ReadFormula(section, L"W", (int)parser.ReadFormula(m_StyleName.c_str(), L"W", 1.0));
	m_H = (int)parser.ReadFormula(section, L"H", (int)parser.ReadFormula(m_StyleName.c_str(), L"H", 1.0));

	m_Hidden = 0!=parser.ReadInt(section, L"Hidden", 0!=parser.ReadInt(m_StyleName.c_str(), L"Hidden", 0));
	m_SolidBevel = (BEVELTYPE)parser.ReadInt(section, L"BevelType", (BEVELTYPE)parser.ReadInt(m_StyleName.c_str(), L"BevelType", m_SolidBevel));

	m_SolidColor = parser.ReadColor(section, L"SolidColor", parser.ReadColor(m_StyleName.c_str(), L"SolidColor", Color(0, 0, 0, 0)));
	m_SolidColor2 = parser.ReadColor(section, L"SolidColor2", parser.ReadColor(m_StyleName.c_str(), L"SolidColor2", m_SolidColor));
	m_SolidAngle = (Gdiplus::REAL)parser.ReadFloat(section, L"GradientAngle", (Gdiplus::REAL)parser.ReadFloat(m_StyleName.c_str(), L"GradientAngle", 0.0));

	m_RightMouseDownAction = parser.ReadString(section, L"RightMouseDownAction", parser.ReadString(m_StyleName.c_str(), L"RightMouseDownAction", L"").c_str(),true,true);
	m_LeftMouseDownAction = parser.ReadString(section, L"LeftMouseDownAction", parser.ReadString(m_StyleName.c_str(), L"LeftMouseDownAction", L"").c_str(),true,true);
	m_RightMouseUpAction = parser.ReadString(section, L"RightMouseUpAction", parser.ReadString(m_StyleName.c_str(), L"RightMouseUpAction", L"").c_str(),true,true);
	m_LeftMouseUpAction = parser.ReadString(section, L"LeftMouseUpAction", parser.ReadString(m_StyleName.c_str(), L"LeftMouseUpAction", L"").c_str(),true,true);
	m_MouseOverAction = parser.ReadString(section, L"MouseOverAction", parser.ReadString(m_StyleName.c_str(), L"MouseOverAction", L"").c_str(),true,true);
	m_MouseLeaveAction = parser.ReadString(section, L"MouseLeaveAction", parser.ReadString(m_StyleName.c_str(), L"MouseLeaveAction", L"").c_str(),true,true);

	m_MeasureName = parser.ReadString(section, L"MeasureName", parser.ReadString(m_StyleName.c_str(), L"MeasureName", L"").c_str(),true,true);

	m_UpdateDivider = parser.ReadInt(section, L"UpdateDivider", parser.ReadInt(m_StyleName.c_str(), L"UpdateDivider", 1));
	m_UpdateCounter = m_UpdateDivider;
	m_AntiAlias = 0!=parser.ReadInt(section, L"AntiAlias", 0!=parser.ReadInt(m_StyleName.c_str(), L"AntiAlias", 0));
	m_DynamicVariables = 0!=parser.ReadInt(section, L"DynamicVariables", 0!=parser.ReadInt(m_StyleName.c_str(), L"DynamicVariables", 0));

	std::vector<Gdiplus::REAL> matrix = parser.ReadFloats(section, L"TransformationMatrix");
	if (matrix.size() == 6)
	{
		m_Transformation.SetElements(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
	}
	else if (!matrix.empty())
	{
		DebugLog(L"The transformation matrix has incorrect number of values:", parser.ReadString(section, L"TransformationMatrix", L"").c_str());
	}

/* Are these necessary?
	if (m_W == 0 || m_H == 0)
	{
        throw CError(std::wstring(L"The meter ") + section + L" has zero dimensions.", __LINE__, __FILE__);
	}
*/
}

/*
** BindMeasure
**
** Binds this meter to the given measure. The same measure can be bound to
** several meters but one meter and only be bound to one measure.
**
*/
void CMeter::BindMeasure(std::list<CMeasure*>& measures)
{
	// The meter is not bound to anything
	if (m_MeasureName.empty())
	{
	    throw CError(std::wstring(L"The meter [") + m_Name + L"] is not bound to anything!", __LINE__, __FILE__);
	}

	// Go through the list and check it there is a measure for us
	std::list<CMeasure*>::iterator i = measures.begin();
	for( ; i != measures.end(); i++)
	{
		if(_wcsicmp((*i)->GetName(), m_MeasureName.c_str()) == 0)
		{
			m_Measure = (*i);
			return;
		}
	}

    // Error :)
    throw CError(std::wstring(L"The meter [") + m_Name + L"] cannot be bound with [" + m_MeasureName + L"]!", __LINE__, __FILE__);
}

/*
** Create
**
** Creates the given meter. This is the factory method for the meters.
** If new meters are implemented this method needs to be updated.
**
*/
CMeter* CMeter::Create(const WCHAR* meter, CMeterWindow* meterWindow)
{
	if(_wcsicmp(L"HISTOGRAM", meter) == 0)
	{
		return new CMeterHistogram(meterWindow);
	} 
	else if(_wcsicmp(L"STRING", meter) == 0)
	{
		return new CMeterString(meterWindow);
	} 
	else if(_wcsicmp(L"BAR", meter) == 0)
	{
		return new CMeterBar(meterWindow);
	} 
	else if(_wcsicmp(L"BITMAP", meter) == 0)
	{
		return new CMeterBitmap(meterWindow);
	} 
	else if(_wcsicmp(L"IMAGE", meter) == 0)
	{
		return new CMeterImage(meterWindow);
	} 
	else if(_wcsicmp(L"LINE", meter) == 0)
	{
		return new CMeterLine(meterWindow);
	} 
	else if(_wcsicmp(L"ROUNDLINE", meter) == 0)
	{
		return new CMeterRoundLine(meterWindow);
	} 
	else if(_wcsicmp(L"ROTATOR", meter) == 0)
	{
		return new CMeterRotator(meterWindow);
	} 
	else if(_wcsicmp(L"BUTTON", meter) == 0)
	{
		return new CMeterButton(meterWindow);
	} 

    // Error
    throw CError(std::wstring(L"No such meter: ") + meter, __LINE__, __FILE__);

	return NULL;
}

/*
** Update
**
** Updates the value(s) from the measures. Derived classes should
** only update if this returns true;
*/
bool CMeter::Update()
{
	// Only update the meter's value when the divider is equal to the counter
	m_UpdateCounter++;
	if (m_UpdateCounter < m_UpdateDivider) return false;
	m_UpdateCounter = 0;

	return true;
}

/*
** Draw
**
** Draws the solid background & bevel if such are defined
*/
bool CMeter::Draw(Graphics& graphics)
{
	if (IsHidden()) return false;

	if (m_AntiAlias)
	{
		graphics.SetInterpolationMode(InterpolationModeBicubic);
		graphics.SetSmoothingMode(SmoothingModeHighQuality);
		graphics.SetPixelOffsetMode(PixelOffsetModeHighQuality);
	}
	else
	{
		graphics.SetInterpolationMode(InterpolationModeDefault);
		graphics.SetSmoothingMode(SmoothingModeNone);
		graphics.SetPixelOffsetMode(PixelOffsetModeDefault);
	}

	if (m_SolidColor.GetA() != 0 || m_SolidColor2.GetA() != 0)
	{
		int x = GetX();
		int y = GetY();

		if (m_SolidColor.GetValue() == m_SolidColor2.GetValue())
		{
			SolidBrush solid(m_SolidColor);
			graphics.FillRectangle(&solid, x, y, m_W, m_H);
		}
		else
		{
			Rect r(x, y, m_W, m_H);
			LinearGradientBrush gradient(r, m_SolidColor, m_SolidColor2, m_SolidAngle, TRUE);
			graphics.FillRectangle(&gradient, r);
		}
	}

	if (m_SolidBevel != BEVELTYPE_NONE)
	{
		int x = GetX();
		int y = GetY();

		Pen light(Color(255, 255, 255, 255));
		Pen dark(Color(255, 0, 0, 0));

		if (m_SolidBevel == BEVELTYPE_DOWN)
		{
			light.SetColor(Color(255, 0, 0, 0));
			dark.SetColor(Color(255, 255, 255, 255));
		}

		// The bevel is drawn outside the meter
		Rect rect(x - 2, y - 2, m_W + 4, m_H + 4);	
		DrawBevel(graphics, rect, light, dark);
	}

	return true;
}

/*
** DrawBevel
**
** Draws a bevel inside the given area
*/
void CMeter::DrawBevel(Graphics& graphics, Rect& rect, Pen& light, Pen& dark)
{
	int l = rect.GetLeft();
	int r = rect.GetRight() - 1;
	int t = rect.GetTop();
	int b = rect.GetBottom() - 1;

	graphics.DrawLine(&light, l,     t,     l,     b);
	graphics.DrawLine(&light, l,     t,     r,     t);
	graphics.DrawLine(&light, l + 1, t + 1, l + 1, b - 1);
	graphics.DrawLine(&light, l + 1, t + 1, r - 1, l + 1);
	graphics.DrawLine(&dark,  l,     b,     r,     b);
	graphics.DrawLine(&dark,  r,     t,     r,     b);
	graphics.DrawLine(&dark,  l + 1, b - 1, r - 1, b - 1);
	graphics.DrawLine(&dark,  r - 1, t + 1, r - 1, b - 1);
}