rainmeter-studio/Library/MeterBitmap.cpp

478 lines
10 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 "MeterBitmap.h"
#include "Measure.h"
#include "Error.h"
#include "Rainmeter.h"
#include "System.h"
2009-02-10 18:37:48 +00:00
using namespace Gdiplus;
extern CRainmeter* Rainmeter;
/*
** CMeterBitmap
**
** The constructor
**
*/
2011-02-15 16:26:54 +00:00
CMeterBitmap::CMeterBitmap(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
2011-02-07 09:38:27 +00:00
m_Image(L"BitmapImage", NULL, true),
m_NeedsReload(false),
m_ZeroFrame(false),
m_FrameCount(1),
m_TransitionFrameCount(),
m_Align(ALIGN_LEFT),
m_Extend(false),
m_Separation(),
m_Digits(),
m_Value(),
m_TransitionStartTicks(),
m_TransitionStartValue()
2009-02-10 18:37:48 +00:00
{
}
/*
** ~CMeterBitmap
**
** The destructor
**
*/
CMeterBitmap::~CMeterBitmap()
{
}
/*
** Initialize
**
** Load the image and get the dimensions of the meter from it.
**
*/
void CMeterBitmap::Initialize()
{
CMeter::Initialize();
// Load the bitmaps if defined
2011-03-29 19:21:57 +00:00
if (!m_ImageName.empty())
2009-02-10 18:37:48 +00:00
{
m_Image.LoadImage(m_ImageName, m_NeedsReload);
if (m_Image.IsLoaded())
2009-02-10 18:37:48 +00:00
{
Bitmap* bitmap = m_Image.GetImage();
m_W = bitmap->GetWidth();
m_H = bitmap->GetHeight();
2011-03-29 19:21:57 +00:00
if (m_H > m_W)
{
m_H = m_H / m_FrameCount;
}
else
{
m_W = m_W / m_FrameCount;
}
2009-02-10 18:37:48 +00:00
}
}
else if (m_Image.IsLoaded())
{
m_Image.DisposeImage();
2009-02-10 18:37:48 +00:00
}
}
/*
** HitTest
**
** Checks if the given point is inside the meter.
**
*/
bool CMeterBitmap::HitTest(int x, int y)
{
if (m_Extend)
{
// Calc the number of numbers
int numOfNums = 0;
if (m_Digits > 0)
{
numOfNums = m_Digits;
}
else
{
int tmpValue = (int)m_Value;
tmpValue = max(0, tmpValue); // Only positive integers are supported
int realFrames = (m_FrameCount / (m_TransitionFrameCount + 1));
2009-02-10 18:37:48 +00:00
do
{
2010-03-30 22:37:05 +00:00
++numOfNums;
if (realFrames == 1)
2009-02-10 18:37:48 +00:00
{
tmpValue /= 2;
}
else
{
tmpValue /= realFrames;
2009-02-10 18:37:48 +00:00
}
}
while (tmpValue > 0);
2009-02-10 18:37:48 +00:00
}
Rect rect(GetX(), GetY(), m_W * numOfNums + (numOfNums - 1) * m_Separation, m_H);
if (m_Align == ALIGN_CENTER)
{
rect.Offset(-rect.Width / 2, 0);
}
else if (m_Align == ALIGN_RIGHT)
{
rect.Offset(-rect.Width, 0);
}
if (rect.Contains(x, y))
{
return true;
}
return false;
}
else
{
return CMeter::HitTest(x, y);
}
}
/*
** ReadConfig
**
** Read the meter-specific configs from the ini-file.
**
*/
2011-02-15 16:26:54 +00:00
void CMeterBitmap::ReadConfig(CConfigParser& parser, const WCHAR* section)
2009-02-10 18:37:48 +00:00
{
// Store the current values so we know if the image needs to be updated
std::wstring oldImageName = m_ImageName;
int oldW = m_W;
int oldH = m_H;
2009-02-10 18:37:48 +00:00
// Read common configs
2011-02-15 16:26:54 +00:00
CMeter::ReadConfig(parser, section);
2009-02-10 18:37:48 +00:00
2009-09-04 16:37:51 +00:00
m_ImageName = parser.ReadString(section, L"BitmapImage", L"");
2010-11-25 22:00:34 +00:00
if (!m_ImageName.empty())
{
2011-11-28 14:13:20 +00:00
m_MeterWindow->MakePathAbsolute(m_ImageName);
// Read tinting configs
m_Image.ReadConfig(parser, section);
}
else
{
m_Image.ClearConfigFlags();
2010-11-25 22:00:34 +00:00
}
2009-02-10 18:37:48 +00:00
2009-09-04 16:37:51 +00:00
m_FrameCount = parser.ReadInt(section, L"BitmapFrames", 1);
m_ZeroFrame = 0!=parser.ReadInt(section, L"BitmapZeroFrame", 0);
2009-02-10 18:37:48 +00:00
2009-09-04 16:37:51 +00:00
m_Separation = parser.ReadInt(section, L"BitmapSeparation", 0);
m_Extend = 0!=parser.ReadInt(section, L"BitmapExtend", 0);
m_Digits = parser.ReadInt(section, L"BitmapDigits", 0);
2009-02-10 18:37:48 +00:00
2009-09-04 16:37:51 +00:00
m_TransitionFrameCount = parser.ReadInt(section, L"BitmapTransitionFrames", 0);
2011-11-16 16:47:20 +00:00
const WCHAR* align = parser.ReadString(section, L"BitmapAlign", L"LEFT").c_str();
if (_wcsicmp(align, L"LEFT") == 0)
2009-02-10 18:37:48 +00:00
{
m_Align = ALIGN_LEFT;
}
2011-11-16 16:47:20 +00:00
else if (_wcsicmp(align, L"RIGHT") == 0)
2009-02-10 18:37:48 +00:00
{
m_Align = ALIGN_RIGHT;
}
2011-11-16 16:47:20 +00:00
else if (_wcsicmp(align, L"CENTER") == 0)
2009-02-10 18:37:48 +00:00
{
m_Align = ALIGN_CENTER;
}
else
{
2011-11-16 16:47:20 +00:00
std::wstring error = L"BitmapAlign=";
error += align;
2011-11-09 09:27:06 +00:00
error += L" is not valid in [";
2010-11-25 15:34:49 +00:00
error += m_Name;
2011-11-09 09:27:06 +00:00
error += L"]";
throw CError(error);
2009-02-10 18:37:48 +00:00
}
if (m_Initialized)
{
m_NeedsReload = (wcscmp(oldImageName.c_str(), m_ImageName.c_str()) != 0);
if (m_NeedsReload ||
m_Image.IsConfigsChanged())
{
Initialize(); // Reload the image
}
else
{
// Reset to old dimensions
m_W = oldW;
m_H = oldH;
}
}
2009-02-10 18:37:48 +00:00
}
/*
** Update
**
** Updates the value(s) from the measures.
**
*/
bool CMeterBitmap::Update()
{
if (CMeter::Update() && m_Measure)
{
double value = (m_Extend) ? m_Measure->GetValue() : m_Measure->GetRelativeValue();
if (m_TransitionFrameCount > 0)
{
int realFrames = m_FrameCount / (m_TransitionFrameCount + 1);
if ((int)(value * realFrames) != (int)(m_Value * realFrames))
{
m_TransitionStartValue = m_Value;
m_TransitionStartTicks = CSystem::GetTickCount64();
}
else
{
m_TransitionStartTicks = 0;
}
2009-02-10 18:37:48 +00:00
}
m_Value = value;
return true;
}
return false;
}
/*
** HasActiveTransition
**
** Returns true if the meter has active transition animation.
**
*/
bool CMeterBitmap::HasActiveTransition()
{
if (m_TransitionStartTicks > 0)
{
2009-02-10 18:37:48 +00:00
return true;
}
return false;
}
/*
** Draw
**
** Draws the meter on the double buffer
**
*/
bool CMeterBitmap::Draw(Graphics& graphics)
2009-02-10 18:37:48 +00:00
{
2011-03-29 19:21:57 +00:00
if (!CMeter::Draw(graphics)) return false;
2009-02-10 18:37:48 +00:00
int newY, newX;
2011-03-29 19:21:57 +00:00
if (m_FrameCount == 0 || !m_Image.IsLoaded()) return false; // Unable to continue
Bitmap* bitmap = m_Image.GetImage();
2009-02-10 18:37:48 +00:00
int x = GetX();
int y = GetY();
if (m_Extend)
{
int value = (int)m_Value;
value = max(0, value); // Only positive integers are supported
int transitionValue = (int)m_TransitionStartValue;
transitionValue = max(0, transitionValue); // Only positive integers are supported
2009-02-10 18:37:48 +00:00
// Calc the number of numbers
int numOfNums = 0;
if (m_Digits > 0)
{
numOfNums = m_Digits;
}
else
{
int tmpValue = value;
2009-02-10 18:37:48 +00:00
do
{
2010-03-30 22:37:05 +00:00
++numOfNums;
2009-02-10 18:37:48 +00:00
if (m_FrameCount == 1)
{
tmpValue /= 2;
}
else
{
tmpValue /= m_FrameCount;
}
}
while (tmpValue > 0);
2009-02-10 18:37:48 +00:00
}
// Blit the images
int offset;
if (m_Align == ALIGN_RIGHT)
{
offset = 0;
}
else if (m_Align == ALIGN_CENTER)
{
offset = numOfNums * (m_W + m_Separation) / 2;
}
else
{
offset = numOfNums * (m_W + m_Separation);
}
do
{
offset = offset - (m_W + m_Separation);
Rect r(x + offset, y, m_W, m_H);
int realFrames = (m_FrameCount / (m_TransitionFrameCount + 1));
int frame = (value % realFrames) * (m_TransitionFrameCount + 1);
// If transition is ongoing the pick the correct frame
if (m_TransitionStartTicks > 0)
{
int diffTicks = (int)(CSystem::GetTickCount64() - m_TransitionStartTicks);
int range = ((value % realFrames) - (transitionValue % realFrames)) * (m_TransitionFrameCount + 1);
if (range < 0)
{
range += m_FrameCount;
}
int frameAdjustment = range * diffTicks / ((m_TransitionFrameCount + 1) * m_MeterWindow->GetTransitionUpdate());
if (frameAdjustment > range)
{
m_TransitionStartTicks = 0; // The transition is over. Draw with the real value.
}
else
{
frame = (transitionValue % realFrames) * (m_TransitionFrameCount + 1);
frame += frameAdjustment;
frame %= m_FrameCount;
}
}
// LogWithArgs(LOG_DEBUG, L"[%u] Value: %f Frame: %i (Transition = %s)", GetTickCount(), m_Value, frame, m_TransitionStartTicks > 0 ? L"true" : L"false");
2011-03-29 19:21:57 +00:00
if (bitmap->GetHeight() > bitmap->GetWidth())
2009-02-10 18:37:48 +00:00
{
newX = 0;
newY = m_H * frame;
2009-02-10 18:37:48 +00:00
}
else
{
newX = m_W * frame;
2009-02-10 18:37:48 +00:00
newY = 0;
}
graphics.DrawImage(bitmap, r, newX, newY, m_W, m_H, UnitPixel);
2009-02-10 18:37:48 +00:00
if (m_FrameCount == 1)
{
value /= 2;
transitionValue /= 2;
2009-02-10 18:37:48 +00:00
}
else
{
value /= realFrames;
transitionValue /= realFrames;
2009-02-10 18:37:48 +00:00
}
2010-03-30 22:37:05 +00:00
--numOfNums;
}
while (numOfNums > 0);
2009-02-10 18:37:48 +00:00
}
else
{
int frame = 0;
int realFrames = (m_FrameCount / (m_TransitionFrameCount + 1));
2009-02-10 18:37:48 +00:00
if (m_ZeroFrame)
{
// Use the first frame only if the value is zero
if (m_Value > 0)
{
frame = (int)(m_Value * (realFrames - 1)) * (m_TransitionFrameCount + 1);
2009-02-10 18:37:48 +00:00
}
}
else
{
// Select the correct frame linearly
frame = (int)(m_Value * realFrames) * (m_TransitionFrameCount + 1);
2009-02-10 18:37:48 +00:00
}
// If transition is ongoing the pick the correct frame
if (m_TransitionStartTicks > 0)
{
int diffTicks = (int)(CSystem::GetTickCount64() - m_TransitionStartTicks);
if (diffTicks > ((m_TransitionFrameCount + 1) * m_MeterWindow->GetTransitionUpdate()))
{
m_TransitionStartTicks = 0; // The transition is over. Draw with the real value.
}
else
{
double range = (m_Value - m_TransitionStartValue);
double adjustment = range * diffTicks / ((m_TransitionFrameCount + 1) * m_MeterWindow->GetTransitionUpdate());
double frameAdjustment = adjustment * m_FrameCount;
frame = (int)(m_TransitionStartValue * realFrames) * (m_TransitionFrameCount + 1);
frame += (int)frameAdjustment;
frame %= m_FrameCount;
frame = max(0, frame);
}
}
// LogWithArgs(LOG_DEBUG, L"[%u] Value: %f Frame: %i (Transition = %s)", GetTickCount(), m_Value, frame, m_TransitionStartTicks > 0 ? L"true" : L"false");
2011-03-29 19:21:57 +00:00
if (bitmap->GetHeight() > bitmap->GetWidth())
2009-02-10 18:37:48 +00:00
{
newX = 0;
newY = frame * m_H;
}
else
{
newX = frame * m_W;
newY = 0;
}
// Blit the image
Rect r(x, y, m_W, m_H);
graphics.DrawImage(bitmap, r, newX, newY, m_W, m_H, UnitPixel);
2009-02-10 18:37:48 +00:00
}
return true;
}