chibicitiberiu/rainmeter-studio
1
0
Fork 0
mirror of https://github.com/chibicitiberiu/rainmeter-studio.git synced 2024-02-24 04:33:31 +00:00
Code Issues Releases Wiki Activity

Remove "C" prefix in class names

Browse Source
This commit is contained in:
Birunthan Mohanathas
2013-05-31 17:18:52 +03:00
parent 4332cea3d0
commit da9384cfad
126 changed files with 2114 additions and 2116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
Common/Dialog.cpp
View File

@@ -20,13 +20,13 @@
#include <Commctrl.h>
#include <Uxtheme.h>
HWND CDialog::c_ActiveDialogWindow = NULL;
HWND Dialog::c_ActiveDialogWindow = NULL;
//
// CBaseDialog
// BaseDialog
//
CBaseDialog::CBaseDialog() :
BaseDialog::BaseDialog() :
m_Window()
{
}
@@ -35,7 +35,7 @@ CBaseDialog::CBaseDialog() :
** Create (if not already) and show the dialog.
**
*/
void CBaseDialog::Show(const WCHAR* title, short x, short y, short w, short h, DWORD style, DWORD exStyle, HWND parent, bool modeless)
void BaseDialog::Show(const WCHAR* title, short x, short y, short w, short h, DWORD style, DWORD exStyle, HWND parent, bool modeless)
{
if (m_Window)
{
@@ -98,16 +98,16 @@ void CBaseDialog::Show(const WCHAR* title, short x, short y, short w, short h, D
delete [] dt;
}
void CBaseDialog::CreateControls(const ControlTemplate::Control* cts, UINT ctCount, HFONT font, ControlTemplate::GetStringFunc getString)
void BaseDialog::CreateControls(const ControlTemplate::Control* cts, UINT ctCount, HFONT font, ControlTemplate::GetStringFunc getString)
{
ControlTemplate::CreateControls(cts, ctCount, m_Window, font, getString);
}
INT_PTR CALLBACK CBaseDialog::InitialDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK BaseDialog::InitialDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (uMsg == WM_INITDIALOG)
{
CBaseDialog* dialog = (CBaseDialog*)lParam;
BaseDialog* dialog = (BaseDialog*)lParam;
dialog->m_Window = hWnd;
SetWindowLongPtr(hWnd, DWLP_USER, (LONG_PTR)dialog);
SetWindowLongPtr(hWnd, DWLP_DLGPROC, (LONG_PTR)MainDlgProc);
@@ -117,17 +117,17 @@ INT_PTR CALLBACK CBaseDialog::InitialDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam
return FALSE;
}
INT_PTR CALLBACK CBaseDialog::MainDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK BaseDialog::MainDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CBaseDialog* dialog = (CBaseDialog*)GetWindowLongPtr(hWnd, DWLP_USER);
BaseDialog* dialog = (BaseDialog*)GetWindowLongPtr(hWnd, DWLP_USER);
return dialog->HandleMessage(uMsg, wParam, lParam);
}
//
// CDialog
// Dialog
//
CDialog::CDialog() : CBaseDialog(),
Dialog::Dialog() : BaseDialog(),
m_Font(),
m_FontBold()
{
@@ -140,25 +140,25 @@ CDialog::CDialog() : CBaseDialog(),
m_FontBold = CreateFontIndirect(&ncm.lfMenuFont);
}
CDialog::~CDialog()
Dialog::~Dialog()
{
DestroyWindow(m_Window);
DeleteObject(m_Font);
DeleteObject(m_FontBold);
}
void CDialog::ShowDialogWindow(const WCHAR* title, short x, short y, short w, short h, DWORD style, DWORD exStyle, HWND parent, bool modeless)
void Dialog::ShowDialogWindow(const WCHAR* title, short x, short y, short w, short h, DWORD style, DWORD exStyle, HWND parent, bool modeless)
{
Show(title, x, y, w, h, style, exStyle, parent, modeless);
}
INT_PTR CDialog::OnActivate(WPARAM wParam, LPARAM lParam)
INT_PTR Dialog::OnActivate(WPARAM wParam, LPARAM lParam)
{
c_ActiveDialogWindow = wParam ? m_Window : NULL;
return FALSE;
}
bool CDialog::HandleMessage(MSG& msg)
bool Dialog::HandleMessage(MSG& msg)
{
if (c_ActiveDialogWindow)
{
@@ -175,12 +175,12 @@ bool CDialog::HandleMessage(MSG& msg)
** Subclass button control to draw arrow on the right.
**
*/
void CDialog::SetMenuButton(HWND button)
void Dialog::SetMenuButton(HWND button)
{
SetWindowSubclass(button, MenuButtonProc, NULL, NULL);
}
LRESULT CALLBACK CDialog::MenuButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
LRESULT CALLBACK Dialog::MenuButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
LRESULT result = DefSubclassProc(hWnd, uMsg, wParam, lParam);
@@ -227,15 +227,15 @@ LRESULT CALLBACK CDialog::MenuButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LP
}
//
// CTab
// Tab
//
CDialog::CTab::CTab() : CBaseDialog(),
Dialog::Tab::Tab() : BaseDialog(),
m_Initialized(false)
{
}
void CDialog::CTab::CreateTabWindow(short x, short y, short w, short h, HWND owner)
void Dialog::Tab::CreateTabWindow(short x, short y, short w, short h, HWND owner)
{
const DWORD style = DS_CONTROL | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS;
const DWORD exStyle = WS_EX_CONTROLPARENT;
@@ -244,12 +244,12 @@ void CDialog::CTab::CreateTabWindow(short x, short y, short w, short h, HWND own
EnableThemeDialogTexture(m_Window, ETDT_ENABLETAB);
}
CDialog::CTab::~CTab()
Dialog::Tab::~Tab()
{
DestroyWindow(m_Window);
}
void CDialog::CTab::Activate()
void Dialog::Tab::Activate()
{
if (!m_Initialized)
{

24
Common/Dialog.h
View File

@@ -22,15 +22,15 @@
#include <Windows.h>
#include "ControlTemplate.h"
// Shared base class for CDialog and CTab.
class CBaseDialog
// Shared base class for Dialog and Tab.
class BaseDialog
{
public:
HWND GetControl(WORD id) { return GetDlgItem(m_Window, id); }
protected:
CBaseDialog();
virtual ~CBaseDialog() {}
BaseDialog();
virtual ~BaseDialog() {}
void Show(const WCHAR* title, short x, short y, short w, short h, DWORD style, DWORD exStyle, HWND parent, bool modeless);
@@ -41,13 +41,13 @@ protected:
HWND m_Window;
private:
CBaseDialog(const CBaseDialog& r);
BaseDialog(const BaseDialog& r);
static INT_PTR CALLBACK InitialDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
static INT_PTR CALLBACK MainDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
};
class CDialog : public CBaseDialog
class Dialog : public BaseDialog
{
public:
HWND GetWindow() { return m_Window; }
@@ -55,7 +55,7 @@ public:
static bool HandleMessage(MSG& msg);
protected:
class CTab : public CBaseDialog
class Tab : public BaseDialog
{
public:
HWND GetWindow() { return m_Window; }
@@ -66,16 +66,16 @@ protected:
virtual void Resize(int w, int h) {}
protected:
CTab();
virtual ~CTab();
Tab();
virtual ~Tab();
void CreateTabWindow(short x, short y, short w, short h, HWND owner);
bool m_Initialized;
};
CDialog();
virtual ~CDialog();
Dialog();
virtual ~Dialog();
void ShowDialogWindow(const WCHAR* title, short x, short y, short w, short h, DWORD style, DWORD exStyle, HWND parent, bool modeless = true);
@@ -87,7 +87,7 @@ protected:
HFONT m_FontBold;
private:
CDialog(const CDialog& r);
Dialog(const Dialog& r);
static LRESULT CALLBACK MenuButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData);

176
Library/CommandHandler.cpp
View File

@@ -28,11 +28,11 @@
#include "TrayWindow.h"
#include "resource.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
namespace {
typedef void (* BangHandlerFunc)(std::vector<std::wstring>& args, CMeterWindow* skin);
typedef void (* BangHandlerFunc)(std::vector<std::wstring>& args, MeterWindow* skin);
struct BangInfo
{
@@ -123,25 +123,25 @@ const BangInfo s_GroupBangs[] =
// Bangs that are to be handled using a custom handler function.
const CustomBangInfo s_CustomBangs[] =
{
{ Bang::ActivateConfig, L"ActivateConfig", CCommandHandler::DoActivateSkinBang },
{ Bang::DeactivateConfig, L"DeactivateConfig", CCommandHandler::DoDeactivateSkinBang },
{ Bang::ToggleConfig, L"ToggleConfig", CCommandHandler::DoToggleSkinBang },
{ Bang::WriteKeyValue, L"WriteKeyValue", CCommandHandler::DoWriteKeyValueBang },
{ Bang::LoadLayout, L"LoadLayout", CCommandHandler::DoLoadLayoutBang },
{ Bang::SetClip, L"SetClip", CCommandHandler::DoSetClipBang },
{ Bang::SetWallpaper, L"SetWallpaper", CCommandHandler::DoSetWallpaperBang },
{ Bang::About, L"About", CCommandHandler::DoAboutBang },
{ Bang::Manage, L"Manage", CCommandHandler::DoManageBang },
{ Bang::SkinMenu, L"SkinMenu", CCommandHandler::DoSkinMenuBang },
{ Bang::TrayMenu, L"TrayMenu", CCommandHandler::DoTrayMenuBang },
{ Bang::ResetStats, L"ResetStats", CCommandHandler::DoResetStatsBang },
{ Bang::Log, L"Log", CCommandHandler::DoLogBang },
{ Bang::RefreshApp, L"RefreshApp", CCommandHandler::DoRefreshApp },
{ Bang::Quit, L"Quit", CCommandHandler::DoQuitBang },
{ Bang::LsBoxHook, L"LsBoxHook", CCommandHandler::DoLsBoxHookBang }
{ Bang::ActivateConfig, L"ActivateConfig", CommandHandler::DoActivateSkinBang },
{ Bang::DeactivateConfig, L"DeactivateConfig", CommandHandler::DoDeactivateSkinBang },
{ Bang::ToggleConfig, L"ToggleConfig", CommandHandler::DoToggleSkinBang },
{ Bang::WriteKeyValue, L"WriteKeyValue", CommandHandler::DoWriteKeyValueBang },
{ Bang::LoadLayout, L"LoadLayout", CommandHandler::DoLoadLayoutBang },
{ Bang::SetClip, L"SetClip", CommandHandler::DoSetClipBang },
{ Bang::SetWallpaper, L"SetWallpaper", CommandHandler::DoSetWallpaperBang },
{ Bang::About, L"About", CommandHandler::DoAboutBang },
{ Bang::Manage, L"Manage", CommandHandler::DoManageBang },
{ Bang::SkinMenu, L"SkinMenu", CommandHandler::DoSkinMenuBang },
{ Bang::TrayMenu, L"TrayMenu", CommandHandler::DoTrayMenuBang },
{ Bang::ResetStats, L"ResetStats", CommandHandler::DoResetStatsBang },
{ Bang::Log, L"Log", CommandHandler::DoLogBang },
{ Bang::RefreshApp, L"RefreshApp", CommandHandler::DoRefreshApp },
{ Bang::Quit, L"Quit", CommandHandler::DoQuitBang },
{ Bang::LsBoxHook, L"LsBoxHook", CommandHandler::DoLsBoxHookBang }
};
void DoBang(const BangInfo& bangInfo, std::vector<std::wstring>& args, CMeterWindow* skin)
void DoBang(const BangInfo& bangInfo, std::vector<std::wstring>& args, MeterWindow* skin)
{
const size_t argsCount = args.size();
if (argsCount >= bangInfo.argCount)
@@ -158,7 +158,7 @@ void DoBang(const BangInfo& bangInfo, std::vector<std::wstring>& args, CMeterWin
const std::wstring& folderPath = args[bangInfo.argCount];
if (!folderPath.empty() && (folderPath.length() != 1 || folderPath[0] != L'*'))
{
CMeterWindow* skin = Rainmeter->GetMeterWindow(folderPath);
MeterWindow* skin = g_Rainmeter->GetMeterWindow(folderPath);
if (skin)
{
skin->DoBang(bangInfo.bang, args);
@@ -172,7 +172,7 @@ void DoBang(const BangInfo& bangInfo, std::vector<std::wstring>& args, CMeterWin
}
// No skin defined -> apply to all.
for (const auto& ip : Rainmeter->GetAllMeterWindows())
for (const auto& ip : g_Rainmeter->GetAllMeterWindows())
{
ip.second->DoBang(bangInfo.bang, args);
}
@@ -201,17 +201,17 @@ void DoBang(const BangInfo& bangInfo, std::vector<std::wstring>& args, CMeterWin
}
}
void DoGroupBang(const BangInfo& bangInfo, std::vector<std::wstring>& args, CMeterWindow* skin)
void DoGroupBang(const BangInfo& bangInfo, std::vector<std::wstring>& args, MeterWindow* skin)
{
if (args.size() > bangInfo.argCount)
{
std::multimap<int, CMeterWindow*> windows;
Rainmeter->GetMeterWindowsByLoadOrder(windows, args[bangInfo.argCount]);
std::multimap<int, MeterWindow*> windows;
g_Rainmeter->GetMeterWindowsByLoadOrder(windows, args[bangInfo.argCount]);
// Remove extra parameters (including group).
args.resize(bangInfo.argCount);
std::multimap<int, CMeterWindow*>::const_iterator iter = windows.begin();
std::multimap<int, MeterWindow*>::const_iterator iter = windows.begin();
for (const auto& ip : windows)
{
DoBang(bangInfo, args, ip.second);
@@ -229,7 +229,7 @@ void DoGroupBang(const BangInfo& bangInfo, std::vector<std::wstring>& args, CMet
** Parses and executes the given command.
**
*/
void CCommandHandler::ExecuteCommand(const WCHAR* command, CMeterWindow* skin, bool multi)
void CommandHandler::ExecuteCommand(const WCHAR* command, MeterWindow* skin, bool multi)
{
if (command[0] == L'!') // Bang
{
@@ -373,7 +373,7 @@ void CCommandHandler::ExecuteCommand(const WCHAR* command, CMeterWindow* skin, b
** Runs the given bang.
**
*/
void CCommandHandler::ExecuteBang(const WCHAR* name, std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::ExecuteBang(const WCHAR* name, std::vector<std::wstring>& args, MeterWindow* skin)
{
for (const auto& bangInfo : s_Bangs)
{
@@ -409,7 +409,7 @@ void CCommandHandler::ExecuteBang(const WCHAR* name, std::vector<std::wstring>&
** Parses and runs the given command.
**
*/
void CCommandHandler::RunCommand(std::wstring command)
void CommandHandler::RunCommand(std::wstring command)
{
std::wstring args;
@@ -450,7 +450,7 @@ void CCommandHandler::RunCommand(std::wstring command)
** Runs a file with the given arguments.
**
*/
void CCommandHandler::RunFile(const WCHAR* file, const WCHAR* args)
void CommandHandler::RunFile(const WCHAR* file, const WCHAR* args)
{
SHELLEXECUTEINFO si = {sizeof(SHELLEXECUTEINFO)};
si.lpVerb = L"open";
@@ -464,7 +464,7 @@ void CCommandHandler::RunFile(const WCHAR* file, const WCHAR* args)
}
else
{
std::wstring dir = CRainmeter::ExtractPath(file);
std::wstring dir = Rainmeter::ExtractPath(file);
si.lpDirectory = dir.c_str();
si.lpParameters = args;
si.fMask = SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI;
@@ -476,7 +476,7 @@ void CCommandHandler::RunFile(const WCHAR* file, const WCHAR* args)
** Splits strings into parts.
**
*/
std::vector<std::wstring> CCommandHandler::ParseString(LPCTSTR str, CConfigParser* parser)
std::vector<std::wstring> CommandHandler::ParseString(LPCTSTR str, ConfigParser* parser)
{
std::vector<std::wstring> result;
@@ -574,28 +574,28 @@ std::vector<std::wstring> CCommandHandler::ParseString(LPCTSTR str, CConfigParse
return result;
}
void CCommandHandler::DoActivateSkinBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoActivateSkinBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (args.size() == 1)
{
int index = Rainmeter->FindSkinFolderIndex(args[0]);
int index = g_Rainmeter->FindSkinFolderIndex(args[0]);
if (index != -1)
{
const CRainmeter::SkinFolder& skinFolder = Rainmeter->m_SkinFolders[index];
const Rainmeter::SkinFolder& skinFolder = g_Rainmeter->m_SkinFolders[index];
if (!(skinFolder.active == 1 && skinFolder.files.size() == 1))
{
// Activate the next index.
Rainmeter->ActivateSkin(index, (skinFolder.active < skinFolder.files.size()) ? skinFolder.active : 0);
g_Rainmeter->ActivateSkin(index, (skinFolder.active < skinFolder.files.size()) ? skinFolder.active : 0);
}
return;
}
}
else if (args.size() > 1)
{
std::pair<int, int> indexes = Rainmeter->GetMeterWindowIndex(args[0], args[1]);
std::pair<int, int> indexes = g_Rainmeter->GetMeterWindowIndex(args[0], args[1]);
if (indexes.first != -1 && indexes.second != -1)
{
Rainmeter->ActivateSkin(indexes.first, indexes.second);
g_Rainmeter->ActivateSkin(indexes.first, indexes.second);
return;
}
}
@@ -603,11 +603,11 @@ void CCommandHandler::DoActivateSkinBang(std::vector<std::wstring>& args, CMeter
LogError(L"!ActivateConfig: Invalid parameters");
}
void CCommandHandler::DoDeactivateSkinBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoDeactivateSkinBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (!args.empty())
{
skin = Rainmeter->GetMeterWindow(args[0]);
skin = g_Rainmeter->GetMeterWindow(args[0]);
if (!skin)
{
LogWarningF(L"!DeactivateConfig: \"%s\" not active", args[0].c_str());
@@ -617,7 +617,7 @@ void CCommandHandler::DoDeactivateSkinBang(std::vector<std::wstring>& args, CMet
if (skin)
{
Rainmeter->DeactivateSkin(skin, -1);
g_Rainmeter->DeactivateSkin(skin, -1);
}
else
{
@@ -625,14 +625,14 @@ void CCommandHandler::DoDeactivateSkinBang(std::vector<std::wstring>& args, CMet
}
}
void CCommandHandler::DoToggleSkinBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoToggleSkinBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (args.size() >= 2)
{
CMeterWindow* skin = Rainmeter->GetMeterWindow(args[0]);
MeterWindow* skin = g_Rainmeter->GetMeterWindow(args[0]);
if (skin)
{
Rainmeter->DeactivateSkin(skin, -1);
g_Rainmeter->DeactivateSkin(skin, -1);
return;
}
@@ -645,15 +645,15 @@ void CCommandHandler::DoToggleSkinBang(std::vector<std::wstring>& args, CMeterWi
}
}
void CCommandHandler::DoDeactivateSkinGroupBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoDeactivateSkinGroupBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (!args.empty())
{
std::multimap<int, CMeterWindow*> windows;
Rainmeter->GetMeterWindowsByLoadOrder(windows, args[0]);
std::multimap<int, MeterWindow*> windows;
g_Rainmeter->GetMeterWindowsByLoadOrder(windows, args[0]);
for (const auto& ip : windows)
{
Rainmeter->DeactivateSkin(ip.second, -1);
g_Rainmeter->DeactivateSkin(ip.second, -1);
}
}
else
@@ -662,7 +662,7 @@ void CCommandHandler::DoDeactivateSkinGroupBang(std::vector<std::wstring>& args,
}
}
void CCommandHandler::DoLoadLayoutBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoLoadLayoutBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (args.size() == 1)
{
@@ -672,21 +672,21 @@ void CCommandHandler::DoLoadLayoutBang(std::vector<std::wstring>& args, CMeterWi
std::wstring command = L"!LoadLayout \"";
command += args[0];
command += L'"';
Rainmeter->DelayedExecuteCommand(command.c_str());
g_Rainmeter->DelayedExecuteCommand(command.c_str());
}
else
{
// Not called from a skin (or called with delay).
Rainmeter->LoadLayout(args[0]);
g_Rainmeter->LoadLayout(args[0]);
}
}
}
void CCommandHandler::DoSetClipBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoSetClipBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (!args.empty())
{
CSystem::SetClipboardText(args[0]);
System::SetClipboardText(args[0]);
}
else
{
@@ -694,7 +694,7 @@ void CCommandHandler::DoSetClipBang(std::vector<std::wstring>& args, CMeterWindo
}
}
void CCommandHandler::DoSetWallpaperBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoSetWallpaperBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
const size_t argsSize = args.size();
if (argsSize >= 1 && argsSize <= 2)
@@ -707,7 +707,7 @@ void CCommandHandler::DoSetWallpaperBang(std::vector<std::wstring>& args, CMeter
skin->MakePathAbsolute(file);
}
CSystem::SetWallpaper(file, style);
System::SetWallpaper(file, style);
}
else
{
@@ -715,21 +715,21 @@ void CCommandHandler::DoSetWallpaperBang(std::vector<std::wstring>& args, CMeter
}
}
void CCommandHandler::DoAboutBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow)
void CommandHandler::DoAboutBang(std::vector<std::wstring>& args, MeterWindow* meterWindow)
{
CDialogAbout::Open(args.empty() ? L"" : args[0].c_str());
DialogAbout::Open(args.empty() ? L"" : args[0].c_str());
}
void CCommandHandler::DoManageBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow)
void CommandHandler::DoManageBang(std::vector<std::wstring>& args, MeterWindow* meterWindow)
{
CDialogManage::Open(args.empty() ? L"" : args[0].c_str());
DialogManage::Open(args.empty() ? L"" : args[0].c_str());
}
void CCommandHandler::DoSkinMenuBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoSkinMenuBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (!args.empty())
{
skin = Rainmeter->GetMeterWindow(args[0]);
skin = g_Rainmeter->GetMeterWindow(args[0]);
if (!skin)
{
LogWarningF(L"!SkinMenu: \"%s\" not active", args[0].c_str());
@@ -739,8 +739,8 @@ void CCommandHandler::DoSkinMenuBang(std::vector<std::wstring>& args, CMeterWind
if (skin)
{
POINT pos = CSystem::GetCursorPosition();
Rainmeter->ShowContextMenu(pos, skin);
POINT pos = System::GetCursorPosition();
g_Rainmeter->ShowContextMenu(pos, skin);
}
else
{
@@ -748,18 +748,18 @@ void CCommandHandler::DoSkinMenuBang(std::vector<std::wstring>& args, CMeterWind
}
}
void CCommandHandler::DoTrayMenuBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoTrayMenuBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
POINT pos = CSystem::GetCursorPosition();
Rainmeter->ShowContextMenu(pos, NULL);
POINT pos = System::GetCursorPosition();
g_Rainmeter->ShowContextMenu(pos, NULL);
}
void CCommandHandler::DoResetStatsBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow)
void CommandHandler::DoResetStatsBang(std::vector<std::wstring>& args, MeterWindow* meterWindow)
{
Rainmeter->ResetStats();
g_Rainmeter->ResetStats();
}
void CCommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (args.size() == 3 && skin)
{
@@ -786,8 +786,8 @@ void CCommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, CMete
return;
}
if (_wcsnicmp(iniFile, Rainmeter->m_SkinPath.c_str(), Rainmeter->m_SkinPath.size()) != 0 &&
_wcsnicmp(iniFile, Rainmeter->m_SettingsPath.c_str(), Rainmeter->m_SettingsPath.size()) != 0)
if (_wcsnicmp(iniFile, g_Rainmeter->m_SkinPath.c_str(), g_Rainmeter->m_SkinPath.size()) != 0 &&
_wcsnicmp(iniFile, g_Rainmeter->m_SettingsPath.c_str(), g_Rainmeter->m_SettingsPath.size()) != 0)
{
LogErrorF(L"!WriteKeyValue: Illegal path: %s", iniFile);
return;
@@ -809,8 +809,8 @@ void CCommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, CMete
}
// Avoid "IniFileMapping"
CSystem::UpdateIniFileMappingList();
std::wstring strIniWrite = CSystem::GetTemporaryFile(strIniFile);
System::UpdateIniFileMappingList();
std::wstring strIniWrite = System::GetTemporaryFile(strIniFile);
if (strIniWrite.size() == 1 && strIniWrite[0] == L'?') // error occurred
{
return;
@@ -820,14 +820,14 @@ void CCommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, CMete
if (temporary)
{
if (Rainmeter->GetDebug())
if (g_Rainmeter->GetDebug())
{
LogDebugF(L"!WriteKeyValue: Writing to: %s (Temp: %s)", iniFile, strIniWrite.c_str());
}
}
else
{
if (Rainmeter->GetDebug())
if (g_Rainmeter->GetDebug())
{
LogDebugF(L"!WriteKeyValue: Writing to: %s", iniFile);
}
@@ -850,7 +850,7 @@ void CCommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, CMete
{
WCHAR buffer[256];
int len = _snwprintf_s(buffer, _TRUNCATE, L"%.5f", value);
CMeasure::RemoveTrailingZero(buffer, len);
Measure::RemoveTrailingZero(buffer, len);
write = WritePrivateProfileString(section, key, buffer, iniWrite);
}
@@ -868,7 +868,7 @@ void CCommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, CMete
WritePrivateProfileString(NULL, NULL, NULL, iniWrite); // FLUSH
// Copy the file back.
if (!CSystem::CopyFiles(strIniWrite, strIniFile))
if (!System::CopyFiles(strIniWrite, strIniFile))
{
LogErrorF(L"!WriteKeyValue: Failed to copy temporary file to original filepath: %s (Temp: %s)", iniFile, iniWrite);
}
@@ -879,7 +879,7 @@ void CCommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, CMete
}
// Remove the temporary file.
CSystem::RemoveFile(strIniWrite);
System::RemoveFile(strIniWrite);
}
else
{
@@ -890,25 +890,25 @@ void CCommandHandler::DoWriteKeyValueBang(std::vector<std::wstring>& args, CMete
}
}
void CCommandHandler::DoLogBang(std::vector<std::wstring>& args, CMeterWindow* skin)
void CommandHandler::DoLogBang(std::vector<std::wstring>& args, MeterWindow* skin)
{
if (!args.empty())
{
CLogger::Level level = CLogger::Level::Notice;
Logger::Level level = Logger::Level::Notice;
if (args.size() > 1)
{
const WCHAR* type = args[1].c_str();
if (_wcsicmp(type, L"ERROR") == 0)
{
level = CLogger::Level::Error;
level = Logger::Level::Error;
}
else if (_wcsicmp(type, L"WARNING") == 0)
{
level = CLogger::Level::Warning;
level = Logger::Level::Warning;
}
else if (_wcsicmp(type, L"DEBUG") == 0)
{
level = CLogger::Level::Debug;
level = Logger::Level::Debug;
}
else if (_wcsicmp(type, L"NOTICE") != 0)
{
@@ -917,23 +917,23 @@ void CCommandHandler::DoLogBang(std::vector<std::wstring>& args, CMeterWindow* s
}
}
CLogger::GetInstance().Log(level, args[0].c_str());
Logger::GetInstance().Log(level, args[0].c_str());
}
}
void CCommandHandler::DoRefreshApp(std::vector<std::wstring>& args, CMeterWindow* meterWindow)
void CommandHandler::DoRefreshApp(std::vector<std::wstring>& args, MeterWindow* meterWindow)
{
// Refresh needs to be delayed since it crashes if done during Update().
PostMessage(Rainmeter->m_Window, WM_RAINMETER_DELAYED_REFRESH_ALL, NULL, NULL);
PostMessage(g_Rainmeter->m_Window, WM_RAINMETER_DELAYED_REFRESH_ALL, NULL, NULL);
}
void CCommandHandler::DoQuitBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow)
void CommandHandler::DoQuitBang(std::vector<std::wstring>& args, MeterWindow* meterWindow)
{
// Quit needs to be delayed since it crashes if done during Update().
PostMessage(Rainmeter->GetTrayWindow()->GetWindow(), WM_COMMAND, MAKEWPARAM(IDM_QUIT, 0), NULL);
PostMessage(g_Rainmeter->GetTrayWindow()->GetWindow(), WM_COMMAND, MAKEWPARAM(IDM_QUIT, 0), NULL);
}
void CCommandHandler::DoLsBoxHookBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow)
void CommandHandler::DoLsBoxHookBang(std::vector<std::wstring>& args, MeterWindow* meterWindow)
{
// Deprecated.
}

46
Library/CommandHandler.h
View File

@@ -23,8 +23,8 @@
#include <string>
#include <vector>
class CConfigParser;
class CMeterWindow;
class ConfigParser;
class MeterWindow;
enum class Bang
{
@@ -108,34 +108,34 @@ enum class Bang
};
// Parses and executes commands and bangs.
class CCommandHandler
class CommandHandler
{
public:
void ExecuteCommand(const WCHAR* command, CMeterWindow* skin, bool multi = true);
void ExecuteBang(const WCHAR* name, std::vector<std::wstring>& args, CMeterWindow* skin);
void ExecuteCommand(const WCHAR* command, MeterWindow* skin, bool multi = true);
void ExecuteBang(const WCHAR* name, std::vector<std::wstring>& args, MeterWindow* skin);
static void RunCommand(std::wstring command);
static void RunFile(const WCHAR* file, const WCHAR* args = NULL);
static std::vector<std::wstring> ParseString(const WCHAR* str, CConfigParser* parser = NULL);
static std::vector<std::wstring> ParseString(const WCHAR* str, ConfigParser* parser = NULL);
static void DoActivateSkinBang(std::vector<std::wstring>& args, CMeterWindow* skin);
static void DoDeactivateSkinBang(std::vector<std::wstring>& args, CMeterWindow* skin);
static void DoToggleSkinBang(std::vector<std::wstring>& args, CMeterWindow* skin);
static void DoDeactivateSkinGroupBang(std::vector<std::wstring>& args, CMeterWindow* skin);
static void DoLoadLayoutBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoSetClipBang(std::vector<std::wstring>& args, CMeterWindow* skin);
static void DoSetWallpaperBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoAboutBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoManageBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoSkinMenuBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoTrayMenuBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoResetStatsBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoWriteKeyValueBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoLogBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoRefreshApp(std::vector<std::wstring>& args, CMeterWindow* skin);
static void DoQuitBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoLsBoxHookBang(std::vector<std::wstring>& args, CMeterWindow* meterWindow);
static void DoActivateSkinBang(std::vector<std::wstring>& args, MeterWindow* skin);
static void DoDeactivateSkinBang(std::vector<std::wstring>& args, MeterWindow* skin);
static void DoToggleSkinBang(std::vector<std::wstring>& args, MeterWindow* skin);
static void DoDeactivateSkinGroupBang(std::vector<std::wstring>& args, MeterWindow* skin);
static void DoLoadLayoutBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoSetClipBang(std::vector<std::wstring>& args, MeterWindow* skin);
static void DoSetWallpaperBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoAboutBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoManageBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoSkinMenuBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoTrayMenuBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoResetStatsBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoWriteKeyValueBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoLogBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoRefreshApp(std::vector<std::wstring>& args, MeterWindow* skin);
static void DoQuitBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
static void DoLsBoxHookBang(std::vector<std::wstring>& args, MeterWindow* meterWindow);
};
#endif

144
Library/ConfigParser.cpp
View File

@@ -26,17 +26,17 @@
#include "Meter.h"
#include "resource.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
using namespace Gdiplus;
std::unordered_map<std::wstring, std::wstring> CConfigParser::c_MonitorVariables;
std::unordered_map<std::wstring, std::wstring> ConfigParser::c_MonitorVariables;
/*
** The constructor
**
*/
CConfigParser::CConfigParser() :
ConfigParser::ConfigParser() :
m_LastReplaced(false),
m_LastDefaultUsed(false),
m_LastValueDefined(false),
@@ -49,11 +49,11 @@ CConfigParser::CConfigParser() :
** The destructor
**
*/
CConfigParser::~CConfigParser()
ConfigParser::~ConfigParser()
{
}
void CConfigParser::Initialize(const std::wstring& filename, CMeterWindow* meterWindow, LPCTSTR skinSection, const std::wstring* resourcePath)
void ConfigParser::Initialize(const std::wstring& filename, MeterWindow* meterWindow, LPCTSTR skinSection, const std::wstring* resourcePath)
{
m_MeterWindow = meterWindow;
@@ -75,7 +75,7 @@ void CConfigParser::Initialize(const std::wstring& filename, CMeterWindow* meter
SetBuiltInVariables(filename, resourcePath, meterWindow);
ResetMonitorVariables(meterWindow);
CSystem::UpdateIniFileMappingList();
System::UpdateIniFileMappingList();
ReadIniFile(filename, skinSection);
ReadVariables();
@@ -86,20 +86,20 @@ void CConfigParser::Initialize(const std::wstring& filename, CMeterWindow* meter
m_SectionInsertPos = m_Sections.end();
}
void CConfigParser::SetBuiltInVariables(const std::wstring& filename, const std::wstring* resourcePath, CMeterWindow* meterWindow)
void ConfigParser::SetBuiltInVariables(const std::wstring& filename, const std::wstring* resourcePath, MeterWindow* meterWindow)
{
auto insertVariable = [&](const WCHAR* name, std::wstring value)
{
return m_BuiltInVariables.insert(std::make_pair(name, value));
};
insertVariable(L"PROGRAMPATH", Rainmeter->GetPath());
insertVariable(L"PROGRAMDRIVE", Rainmeter->GetDrive());
insertVariable(L"SETTINGSPATH", Rainmeter->GetSettingsPath());
insertVariable(L"SKINSPATH", Rainmeter->GetSkinPath());
insertVariable(L"PLUGINSPATH", Rainmeter->GetPluginPath());
insertVariable(L"CURRENTPATH", CRainmeter::ExtractPath(filename));
insertVariable(L"ADDONSPATH", Rainmeter->GetAddonPath());
insertVariable(L"PROGRAMPATH", g_Rainmeter->GetPath());
insertVariable(L"PROGRAMDRIVE", g_Rainmeter->GetDrive());
insertVariable(L"SETTINGSPATH", g_Rainmeter->GetSettingsPath());
insertVariable(L"SKINSPATH", g_Rainmeter->GetSkinPath());
insertVariable(L"PLUGINSPATH", g_Rainmeter->GetPluginPath());
insertVariable(L"CURRENTPATH", Rainmeter::ExtractPath(filename));
insertVariable(L"ADDONSPATH", g_Rainmeter->GetAddonPath());
if (meterWindow)
{
@@ -122,7 +122,7 @@ void CConfigParser::SetBuiltInVariables(const std::wstring& filename, const std:
** Sets all user-defined variables.
**
*/
void CConfigParser::ReadVariables()
void ConfigParser::ReadVariables()
{
std::list<std::wstring>::const_iterator iter = m_ListVariables.begin();
for ( ; iter != m_ListVariables.end(); ++iter)
@@ -131,13 +131,13 @@ void CConfigParser::ReadVariables()
}
}
void CConfigParser::SetVariable(std::wstring strVariable, const std::wstring& strValue)
void ConfigParser::SetVariable(std::wstring strVariable, const std::wstring& strValue)
{
StrToUpperC(strVariable);
m_Variables[strVariable] = strValue;
}
void CConfigParser::SetBuiltInVariable(const std::wstring& strVariable, const std::wstring& strValue)
void ConfigParser::SetBuiltInVariable(const std::wstring& strVariable, const std::wstring& strValue)
{
m_BuiltInVariables[strVariable] = strValue;
}
@@ -146,7 +146,7 @@ void CConfigParser::SetBuiltInVariable(const std::wstring& strVariable, const st
** Gets a value for the variable. Returns NULL if not found.
**
*/
const std::wstring* CConfigParser::GetVariable(const std::wstring& strVariable)
const std::wstring* ConfigParser::GetVariable(const std::wstring& strVariable)
{
const std::wstring strTmp = StrToUpper(strVariable);
@@ -179,7 +179,7 @@ const std::wstring* CConfigParser::GetVariable(const std::wstring& strVariable)
** The selector is stripped from strVariable.
**
*/
bool CConfigParser::GetSectionVariable(std::wstring& strVariable, std::wstring& strValue)
bool ConfigParser::GetSectionVariable(std::wstring& strVariable, std::wstring& strValue)
{
size_t colonPos = strVariable.find_last_of(L':');
if (colonPos == std::wstring::npos)
@@ -196,7 +196,7 @@ bool CConfigParser::GetSectionVariable(std::wstring& strVariable, std::wstring&
if (isKeySelector)
{
// [Meter:X], [Meter:Y], [Meter:W], [Meter:H]
CMeter* meter = m_MeterWindow->GetMeter(strVariable);
Meter* meter = m_MeterWindow->GetMeter(strVariable);
if (meter)
{
WCHAR buffer[32];
@@ -284,7 +284,7 @@ bool CConfigParser::GetSectionVariable(std::wstring& strVariable, std::wstring&
}
}
CMeasure* measure = m_MeterWindow->GetMeasure(strVariable);
Measure* measure = m_MeterWindow->GetMeasure(strVariable);
if (measure)
{
int scale = 1;
@@ -364,7 +364,7 @@ bool CConfigParser::GetSectionVariable(std::wstring& strVariable, std::wstring&
return false;
}
void CConfigParser::ResetMonitorVariables(CMeterWindow* meterWindow)
void ConfigParser::ResetMonitorVariables(MeterWindow* meterWindow)
{
// Set the SCREENAREA/WORKAREA variables
if (c_MonitorVariables.empty())
@@ -380,7 +380,7 @@ void CConfigParser::ResetMonitorVariables(CMeterWindow* meterWindow)
** Sets new values for the SCREENAREA/WORKAREA variables.
**
*/
void CConfigParser::SetMultiMonitorVariables(bool reset)
void ConfigParser::SetMultiMonitorVariables(bool reset)
{
auto setMonitorVariable = [&](const WCHAR* variable, const WCHAR* value)
{
@@ -392,8 +392,8 @@ void CConfigParser::SetMultiMonitorVariables(bool reset)
reset = true; // Set all variables
}
const size_t numOfMonitors = CSystem::GetMonitorCount(); // intentional
const MultiMonitorInfo& monitorsInfo = CSystem::GetMultiMonitorInfo();
const size_t numOfMonitors = System::GetMonitorCount(); // intentional
const MultiMonitorInfo& monitorsInfo = System::GetMultiMonitorInfo();
const std::vector<MonitorInfo>& monitors = monitorsInfo.monitors;
WCHAR buffer[32];
@@ -482,12 +482,12 @@ void CConfigParser::SetMultiMonitorVariables(bool reset)
** Sets new SCREENAREA/WORKAREA variables for present monitor.
**
*/
void CConfigParser::SetAutoSelectedMonitorVariables(CMeterWindow* meterWindow)
void ConfigParser::SetAutoSelectedMonitorVariables(MeterWindow* meterWindow)
{
if (meterWindow)
{
const int numOfMonitors = (int)CSystem::GetMonitorCount();
const MultiMonitorInfo& monitorsInfo = CSystem::GetMultiMonitorInfo();
const int numOfMonitors = (int)System::GetMonitorCount();
const MultiMonitorInfo& monitorsInfo = System::GetMultiMonitorInfo();
const std::vector<MonitorInfo>& monitors = monitorsInfo.monitors;
WCHAR buffer[32];
@@ -566,11 +566,11 @@ void CConfigParser::SetAutoSelectedMonitorVariables(CMeterWindow* meterWindow)
** Replaces environment and internal variables in the given string.
**
*/
bool CConfigParser::ReplaceVariables(std::wstring& result)
bool ConfigParser::ReplaceVariables(std::wstring& result)
{
bool replaced = false;
CRainmeter::ExpandEnvironmentVariables(result);
Rainmeter::ExpandEnvironmentVariables(result);
if (c_MonitorVariables.empty())
{
@@ -633,7 +633,7 @@ bool CConfigParser::ReplaceVariables(std::wstring& result)
** Replaces measures in the given string.
**
*/
bool CConfigParser::ReplaceMeasures(std::wstring& result)
bool ConfigParser::ReplaceMeasures(std::wstring& result)
{
bool replaced = false;
@@ -661,7 +661,7 @@ bool CConfigParser::ReplaceMeasures(std::wstring& result)
{
std::wstring var = result.substr(si, end - si);
CMeasure* measure = GetMeasure(var);
Measure* measure = GetMeasure(var);
if (measure)
{
const WCHAR* value = measure->GetStringOrFormattedValue(AUTOSCALE_OFF, 1, -1, false);
@@ -698,7 +698,7 @@ bool CConfigParser::ReplaceMeasures(std::wstring& result)
return replaced;
}
const std::wstring& CConfigParser::ReadString(LPCTSTR section, LPCTSTR key, LPCTSTR defValue, bool bReplaceMeasures)
const std::wstring& ConfigParser::ReadString(LPCTSTR section, LPCTSTR key, LPCTSTR defValue, bool bReplaceMeasures)
{
static std::wstring result;
@@ -764,7 +764,7 @@ const std::wstring& CConfigParser::ReadString(LPCTSTR section, LPCTSTR key, LPCT
}
else
{
CRainmeter::ExpandEnvironmentVariables(result);
Rainmeter::ExpandEnvironmentVariables(result);
}
if (bReplaceMeasures && ReplaceMeasures(result))
@@ -777,19 +777,19 @@ const std::wstring& CConfigParser::ReadString(LPCTSTR section, LPCTSTR key, LPCT
return result;
}
bool CConfigParser::IsKeyDefined(LPCTSTR section, LPCTSTR key)
bool ConfigParser::IsKeyDefined(LPCTSTR section, LPCTSTR key)
{
ReadString(section, key, L"", false);
return !m_LastDefaultUsed;
}
bool CConfigParser::IsValueDefined(LPCTSTR section, LPCTSTR key)
bool ConfigParser::IsValueDefined(LPCTSTR section, LPCTSTR key)
{
ReadString(section, key, L"", false);
return m_LastValueDefined;
}
void CConfigParser::AddMeasure(CMeasure* pMeasure)
void ConfigParser::AddMeasure(Measure* pMeasure)
{
if (pMeasure)
{
@@ -797,9 +797,9 @@ void CConfigParser::AddMeasure(CMeasure* pMeasure)
}
}
CMeasure* CConfigParser::GetMeasure(const std::wstring& name)
Measure* ConfigParser::GetMeasure(const std::wstring& name)
{
std::unordered_map<std::wstring, CMeasure*>::const_iterator iter = m_Measures.find(StrToUpper(name));
std::unordered_map<std::wstring, Measure*>::const_iterator iter = m_Measures.find(StrToUpper(name));
if (iter != m_Measures.end())
{
return (*iter).second;
@@ -808,7 +808,7 @@ CMeasure* CConfigParser::GetMeasure(const std::wstring& name)
return NULL;
}
std::vector<Gdiplus::REAL> CConfigParser::ReadFloats(LPCTSTR section, LPCTSTR key)
std::vector<Gdiplus::REAL> ConfigParser::ReadFloats(LPCTSTR section, LPCTSTR key)
{
std::vector<Gdiplus::REAL> result;
const std::wstring& str = ReadString(section, key, L"");
@@ -834,7 +834,7 @@ std::vector<Gdiplus::REAL> CConfigParser::ReadFloats(LPCTSTR section, LPCTSTR ke
return result;
}
int CConfigParser::ReadInt(LPCTSTR section, LPCTSTR key, int defValue)
int ConfigParser::ReadInt(LPCTSTR section, LPCTSTR key, int defValue)
{
const std::wstring& result = ReadString(section, key, L"");
@@ -866,7 +866,7 @@ int CConfigParser::ReadInt(LPCTSTR section, LPCTSTR key, int defValue)
return defValue;
}
uint32_t CConfigParser::ReadUInt(LPCTSTR section, LPCTSTR key, uint32_t defValue)
uint32_t ConfigParser::ReadUInt(LPCTSTR section, LPCTSTR key, uint32_t defValue)
{
const std::wstring& result = ReadString(section, key, L"");
@@ -898,7 +898,7 @@ uint32_t CConfigParser::ReadUInt(LPCTSTR section, LPCTSTR key, uint32_t defValue
return defValue;
}
uint64_t CConfigParser::ReadUInt64(LPCTSTR section, LPCTSTR key, uint64_t defValue)
uint64_t ConfigParser::ReadUInt64(LPCTSTR section, LPCTSTR key, uint64_t defValue)
{
const std::wstring& result = ReadString(section, key, L"");
@@ -930,7 +930,7 @@ uint64_t CConfigParser::ReadUInt64(LPCTSTR section, LPCTSTR key, uint64_t defVal
return defValue;
}
double CConfigParser::ReadFloat(LPCTSTR section, LPCTSTR key, double defValue)
double ConfigParser::ReadFloat(LPCTSTR section, LPCTSTR key, double defValue)
{
const std::wstring& result = ReadString(section, key, L"");
@@ -963,7 +963,7 @@ double CConfigParser::ReadFloat(LPCTSTR section, LPCTSTR key, double defValue)
}
// Returns true if the formula was read successfully, false for failure.
bool CConfigParser::ParseFormula(const std::wstring& formula, double* resultValue)
bool ConfigParser::ParseFormula(const std::wstring& formula, double* resultValue)
{
// Formulas must be surrounded by parenthesis
if (!formula.empty() && formula[0] == L'(' && formula[formula.size() - 1] == L')')
@@ -982,21 +982,21 @@ bool CConfigParser::ParseFormula(const std::wstring& formula, double* resultValu
return false;
}
ARGB CConfigParser::ReadColor(LPCTSTR section, LPCTSTR key, ARGB defValue)
ARGB ConfigParser::ReadColor(LPCTSTR section, LPCTSTR key, ARGB defValue)
{
const std::wstring& result = ReadString(section, key, L"");
return (m_LastDefaultUsed) ? defValue : ParseColor(result.c_str());
}
Rect CConfigParser::ReadRect(LPCTSTR section, LPCTSTR key, const Rect& defValue)
Rect ConfigParser::ReadRect(LPCTSTR section, LPCTSTR key, const Rect& defValue)
{
const std::wstring& result = ReadString(section, key, L"");
return (m_LastDefaultUsed) ? defValue : ParseRect(result.c_str());
}
RECT CConfigParser::ReadRECT(LPCTSTR section, LPCTSTR key, const RECT& defValue)
RECT ConfigParser::ReadRECT(LPCTSTR section, LPCTSTR key, const RECT& defValue)
{
const std::wstring& result = ReadString(section, key, L"");
@@ -1018,7 +1018,7 @@ RECT CConfigParser::ReadRECT(LPCTSTR section, LPCTSTR key, const RECT& defValue)
**
** Modified from http://www.digitalpeer.com/id/simple
*/
std::vector<std::wstring> CConfigParser::Tokenize(const std::wstring& str, const std::wstring& delimiters)
std::vector<std::wstring> ConfigParser::Tokenize(const std::wstring& str, const std::wstring& delimiters)
{
std::vector<std::wstring> tokens;
@@ -1056,7 +1056,7 @@ std::vector<std::wstring> CConfigParser::Tokenize(const std::wstring& str, const
** If the given string is invalid format or causes overflow/underflow, returns given default value.
**
*/
double CConfigParser::ParseDouble(LPCTSTR string, double defValue)
double ConfigParser::ParseDouble(LPCTSTR string, double defValue)
{
assert(string);
@@ -1089,7 +1089,7 @@ double CConfigParser::ParseDouble(LPCTSTR string, double defValue)
** If the given string is invalid format or causes overflow/underflow, returns given default value.
**
*/
int CConfigParser::ParseInt(LPCTSTR string, int defValue)
int ConfigParser::ParseInt(LPCTSTR string, int defValue)
{
assert(string);
@@ -1122,7 +1122,7 @@ int CConfigParser::ParseInt(LPCTSTR string, int defValue)
** If the given string is invalid format or causes overflow/underflow, returns given default value.
**
*/
uint32_t CConfigParser::ParseUInt(LPCTSTR string, uint32_t defValue)
uint32_t ConfigParser::ParseUInt(LPCTSTR string, uint32_t defValue)
{
assert(string);
@@ -1155,7 +1155,7 @@ uint32_t CConfigParser::ParseUInt(LPCTSTR string, uint32_t defValue)
** If the given string is invalid format or causes overflow/underflow, returns given default value.
**
*/
uint64_t CConfigParser::ParseUInt64(LPCTSTR string, uint64_t defValue)
uint64_t ConfigParser::ParseUInt64(LPCTSTR string, uint64_t defValue)
{
assert(string);
@@ -1198,22 +1198,22 @@ bool ParseInt4(LPCTSTR string, T& v1, T& v2, T& v3, T& v4)
token = wcstok(parseSz, L",");
if (token)
{
v1 = CConfigParser::ParseInt(token, 0);
v1 = ConfigParser::ParseInt(token, 0);
token = wcstok(NULL, L",");
if (token)
{
v2 = CConfigParser::ParseInt(token, 0);
v2 = ConfigParser::ParseInt(token, 0);
token = wcstok(NULL, L",");
if (token)
{
v3 = CConfigParser::ParseInt(token, 0);
v3 = ConfigParser::ParseInt(token, 0);
token = wcstok(NULL, L",");
if (token)
{
v4 = CConfigParser::ParseInt(token, 0);
v4 = ConfigParser::ParseInt(token, 0);
}
}
}
@@ -1231,7 +1231,7 @@ bool ParseInt4(LPCTSTR string, T& v1, T& v2, T& v3, T& v4)
** hex-value.
**
*/
ARGB CConfigParser::ParseColor(LPCTSTR string)
ARGB ConfigParser::ParseColor(LPCTSTR string)
{
int R = 255, G = 255, B = 255, A = 255;
@@ -1261,7 +1261,7 @@ ARGB CConfigParser::ParseColor(LPCTSTR string)
** The rect can be supplied as four comma separated values (X/Y/Width/Height).
**
*/
Rect CConfigParser::ParseRect(LPCTSTR string)
Rect ConfigParser::ParseRect(LPCTSTR string)
{
Rect r;
ParseInt4(string, r.X, r.Y, r.Width, r.Height);
@@ -1273,7 +1273,7 @@ Rect CConfigParser::ParseRect(LPCTSTR string)
** The rect can be supplied as four comma separated values (left/top/right/bottom).
**
*/
RECT CConfigParser::ParseRECT(LPCTSTR string)
RECT ConfigParser::ParseRECT(LPCTSTR string)
{
RECT r = {0};
ParseInt4(string, r.left, r.top, r.right, r.bottom);
@@ -1284,11 +1284,11 @@ RECT CConfigParser::ParseRECT(LPCTSTR string)
** Reads the given ini file and fills the m_Values and m_Keys maps.
**
*/
void CConfigParser::ReadIniFile(const std::wstring& iniFile, LPCTSTR skinSection, int depth)
void ConfigParser::ReadIniFile(const std::wstring& iniFile, LPCTSTR skinSection, int depth)
{
if (depth > 100) // Is 100 enough to assume the include loop never ends?
{
Rainmeter->ShowMessage(NULL, GetString(ID_STR_INCLUDEINFINITELOOP), MB_OK | MB_ICONERROR);
g_Rainmeter->ShowMessage(NULL, GetString(ID_STR_INCLUDEINFINITELOOP), MB_OK | MB_ICONERROR);
return;
}
@@ -1300,16 +1300,16 @@ void CConfigParser::ReadIniFile(const std::wstring& iniFile, LPCTSTR skinSection
}
// Avoid "IniFileMapping"
std::wstring iniRead = CSystem::GetTemporaryFile(iniFile);
std::wstring iniRead = System::GetTemporaryFile(iniFile);
bool temporary = (!iniRead.empty() && (iniRead.size() != 1 || iniRead[0] != L'?'));
if (temporary)
{
if (Rainmeter->GetDebug()) LogDebugF(L"Reading file: %s (Temp: %s)", iniFile.c_str(), iniRead.c_str());
if (g_Rainmeter->GetDebug()) LogDebugF(L"Reading file: %s (Temp: %s)", iniFile.c_str(), iniRead.c_str());
}
else
{
if (Rainmeter->GetDebug()) LogDebugF(L"Reading file: %s", iniFile.c_str());
if (g_Rainmeter->GetDebug()) LogDebugF(L"Reading file: %s", iniFile.c_str());
iniRead = iniFile;
}
@@ -1333,7 +1333,7 @@ void CConfigParser::ReadIniFile(const std::wstring& iniFile, LPCTSTR skinSection
if (res == 0) // File not found
{
delete [] items;
if (temporary) CSystem::RemoveFile(iniRead);
if (temporary) System::RemoveFile(iniRead);
return;
}
if (res < itemsSize - 2) // Fits in the buffer
@@ -1446,10 +1446,10 @@ void CConfigParser::ReadIniFile(const std::wstring& iniFile, LPCTSTR skinSection
value.assign(sep, clen);
ReadVariables();
ReplaceVariables(value);
if (!CSystem::IsAbsolutePath(value))
if (!System::IsAbsolutePath(value))
{
// Relative to the ini folder
value.insert(0, CRainmeter::ExtractPath(iniFile));
value.insert(0, Rainmeter::ExtractPath(iniFile));
}
if (resetInsertPos)
@@ -1504,14 +1504,14 @@ void CConfigParser::ReadIniFile(const std::wstring& iniFile, LPCTSTR skinSection
}
delete [] items;
if (temporary) CSystem::RemoveFile(iniRead);
if (temporary) System::RemoveFile(iniRead);
}
/*
** Sets the value for the key under the given section.
**
*/
void CConfigParser::SetValue(const std::wstring& strSection, const std::wstring& strKey, const std::wstring& strValue)
void ConfigParser::SetValue(const std::wstring& strSection, const std::wstring& strKey, const std::wstring& strValue)
{
// LogDebugF(L"[%s] %s=%s (size: %i)", strSection.c_str(), strKey.c_str(), strValue.c_str(), (int)m_Values.size());
@@ -1528,7 +1528,7 @@ void CConfigParser::SetValue(const std::wstring& strSection, const std::wstring&
** Deletes the value for the key under the given section.
**
*/
void CConfigParser::DeleteValue(const std::wstring& strSection, const std::wstring& strKey)
void ConfigParser::DeleteValue(const std::wstring& strSection, const std::wstring& strKey)
{
std::wstring strTmp;
strTmp.reserve(strSection.size() + 1 + strKey.size());
@@ -1547,7 +1547,7 @@ void CConfigParser::DeleteValue(const std::wstring& strSection, const std::wstri
** Returns the value for the key under the given section.
**
*/
const std::wstring& CConfigParser::GetValue(const std::wstring& strSection, const std::wstring& strKey, const std::wstring& strDefault)
const std::wstring& ConfigParser::GetValue(const std::wstring& strSection, const std::wstring& strKey, const std::wstring& strDefault)
{
std::wstring strTmp;
strTmp.reserve(strSection.size() + 1 + strKey.size());

30
Library/ConfigParser.h
View File

@@ -30,21 +30,21 @@
#include <cstdint>
#include <gdiplus.h>
class CRainmeter;
class CMeterWindow;
class CMeasure;
class CMeter;
class Rainmeter;
class MeterWindow;
class Measure;
class Meter;
class CConfigParser
class ConfigParser
{
public:
CConfigParser();
~CConfigParser();
ConfigParser();
~ConfigParser();
void Initialize(const std::wstring& filename, CMeterWindow* meterWindow = NULL, LPCTSTR skinSection = NULL, const std::wstring* resourcePath = NULL);
void Initialize(const std::wstring& filename, MeterWindow* meterWindow = NULL, LPCTSTR skinSection = NULL, const std::wstring* resourcePath = NULL);
void AddMeasure(CMeasure* pMeasure);
CMeasure* GetMeasure(const std::wstring& name);
void AddMeasure(Measure* pMeasure);
Measure* GetMeasure(const std::wstring& name);
const std::wstring* GetVariable(const std::wstring& strVariable);
void SetVariable(std::wstring strVariable, const std::wstring& strValue);
@@ -64,7 +64,7 @@ public:
bool GetLastKeyDefined() { return !m_LastDefaultUsed; }
bool GetLastValueDefined() { return m_LastValueDefined; }
void ResetMonitorVariables(CMeterWindow* meterWindow = NULL);
void ResetMonitorVariables(MeterWindow* meterWindow = NULL);
const std::wstring& ReadString(LPCTSTR section, LPCTSTR key, LPCTSTR defValue, bool bReplaceMeasures = true);
bool IsKeyDefined(LPCTSTR section, LPCTSTR key);
@@ -98,13 +98,13 @@ public:
static void UpdateWorkareaVariables() { SetMultiMonitorVariables(false); }
private:
void SetBuiltInVariables(const std::wstring& filename, const std::wstring* resourcePath, CMeterWindow* meterWindow);
void SetBuiltInVariables(const std::wstring& filename, const std::wstring* resourcePath, MeterWindow* meterWindow);
void ReadVariables();
void ReadIniFile(const std::wstring& iniFile, LPCTSTR skinSection = NULL, int depth = 0);
void SetAutoSelectedMonitorVariables(CMeterWindow* meterWindow);
void SetAutoSelectedMonitorVariables(MeterWindow* meterWindow);
bool GetSectionVariable(std::wstring& strVariable, std::wstring& strValue);
@@ -118,7 +118,7 @@ private:
static std::wstring StrToUpper(const WCHAR* str) { std::wstring strTmp(str); StrToUpperC(strTmp); return strTmp; }
static std::wstring& StrToUpperC(std::wstring& str) { _wcsupr(&str[0]); return str; }
std::unordered_map<std::wstring, CMeasure*> m_Measures;
std::unordered_map<std::wstring, Measure*> m_Measures;
std::vector<std::wstring> m_StyleTemplate;
@@ -138,7 +138,7 @@ private:
std::unordered_map<std::wstring, std::wstring> m_BuiltInVariables;
std::unordered_map<std::wstring, std::wstring> m_Variables;
CMeterWindow* m_MeterWindow;
MeterWindow* m_MeterWindow;
static std::unordered_map<std::wstring, std::wstring> c_MonitorVariables;
};

24
Library/Dialog.cpp
View File

@@ -19,14 +19,14 @@
#include "StdAfx.h"
#include "Dialog.h"
HWND CDialog::c_ActiveDialogWindow = NULL;
HWND CDialog::c_ActiveTabWindow = NULL;
HWND Dialog::c_ActiveDialogWindow = NULL;
HWND Dialog::c_ActiveTabWindow = NULL;
/*
** Constructor.
**
*/
CDialog::CDialog(HWND wnd) :
Dialog::Dialog(HWND wnd) :
m_Window(wnd),
m_Font(),
m_FontBold()
@@ -44,13 +44,13 @@ CDialog::CDialog(HWND wnd) :
** Destructor.
**
*/
CDialog::~CDialog()
Dialog::~Dialog()
{
DeleteObject(m_Font);
DeleteObject(m_FontBold);
}
INT_PTR CDialog::OnActivate(WPARAM wParam, LPARAM lParam)
INT_PTR Dialog::OnActivate(WPARAM wParam, LPARAM lParam)
{
if (wParam)
{
@@ -69,12 +69,12 @@ INT_PTR CDialog::OnActivate(WPARAM wParam, LPARAM lParam)
** Sets dialog font to UI font.
**
*/
void CDialog::SetDialogFont(HWND window)
void Dialog::SetDialogFont(HWND window)
{
EnumChildWindows(window, SetFontProc, (WPARAM)m_Font);
}
BOOL CALLBACK CDialog::SetFontProc(HWND hWnd, LPARAM lParam)
BOOL CALLBACK Dialog::SetFontProc(HWND hWnd, LPARAM lParam)
{
SendMessage(hWnd, WM_SETFONT, (WPARAM)lParam, 0);
return TRUE;
@@ -84,12 +84,12 @@ BOOL CALLBACK CDialog::SetFontProc(HWND hWnd, LPARAM lParam)
** Subclass button control to draw arrow on the right.
**
*/
void CDialog::SetMenuButton(HWND button)
void Dialog::SetMenuButton(HWND button)
{
SetWindowSubclass(button, MenuButtonProc, NULL, NULL);
}
LRESULT CALLBACK CDialog::MenuButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
LRESULT CALLBACK Dialog::MenuButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
LRESULT result = DefSubclassProc(hWnd, uMsg, wParam, lParam);
@@ -139,7 +139,7 @@ LRESULT CALLBACK CDialog::MenuButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LP
** Constructor.
**
*/
CDialog::CTab::CTab(HINSTANCE instance, HWND owner, WORD tabId, DLGPROC tabProc) :
Dialog::Tab::Tab(HINSTANCE instance, HWND owner, WORD tabId, DLGPROC tabProc) :
m_Window(CreateDialog(instance, MAKEINTRESOURCE(tabId), owner, tabProc)),
m_Initialized(false)
{
@@ -150,7 +150,7 @@ CDialog::CTab::CTab(HINSTANCE instance, HWND owner, WORD tabId, DLGPROC tabProc)
** Destructor.
**
*/
CDialog::CTab::~CTab()
Dialog::Tab::~Tab()
{
DestroyWindow(m_Window);
}
@@ -159,7 +159,7 @@ CDialog::CTab::~CTab()
** Activates the tab.
**
*/
void CDialog::CTab::Activate()
void Dialog::Tab::Activate()
{
c_ActiveTabWindow = m_Window;

12
Library/Dialog.h
View File

@@ -19,7 +19,7 @@
#ifndef __DIALOG_H__
#define __DIALOG_H__
class CDialog
class Dialog
{
public:
HWND GetWindow() { return m_Window; }
@@ -28,7 +28,7 @@ public:
static HWND GetActiveTabWindow() { return c_ActiveTabWindow; }
protected:
class CTab
class Tab
{
public:
HWND GetWindow() { return m_Window; }
@@ -39,15 +39,15 @@ protected:
virtual void Resize(int w, int h) {}
protected:
CTab(HINSTANCE instance, HWND owner, WORD tabId, DLGPROC tabProc);
virtual ~CTab();
Tab(HINSTANCE instance, HWND owner, WORD tabId, DLGPROC tabProc);
virtual ~Tab();
HWND m_Window;
bool m_Initialized;
};
CDialog(HWND wnd);
virtual ~CDialog();
Dialog(HWND wnd);
virtual ~Dialog();
virtual HWND GetActiveWindow() { return m_Window; }

162
Library/DialogAbout.cpp
View File

@@ -26,16 +26,16 @@
#include "DialogAbout.h"
#include "../Version.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
WINDOWPLACEMENT CDialogAbout::c_WindowPlacement = {0};
CDialogAbout* CDialogAbout::c_Dialog = NULL;
WINDOWPLACEMENT DialogAbout::c_WindowPlacement = {0};
DialogAbout* DialogAbout::c_Dialog = NULL;
/*
** Constructor.
**
*/
CDialogAbout::CDialogAbout() : CDialog()
DialogAbout::DialogAbout() : Dialog()
{
}
@@ -43,7 +43,7 @@ CDialogAbout::CDialogAbout() : CDialog()
** Destructor.
**
*/
CDialogAbout::~CDialogAbout()
DialogAbout::~DialogAbout()
{
}
@@ -51,11 +51,11 @@ CDialogAbout::~CDialogAbout()
** Opens the About dialog.
**
*/
void CDialogAbout::Open(int tab)
void DialogAbout::Open(int tab)
{
if (!c_Dialog)
{
c_Dialog = new CDialogAbout();
c_Dialog = new DialogAbout();
}
c_Dialog->ShowDialogWindow(
@@ -63,7 +63,7 @@ void CDialogAbout::Open(int tab)
0, 0, 400, 210,
DS_CENTER | WS_POPUP | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME,
WS_EX_APPWINDOW | WS_EX_CONTROLPARENT | ((*GetString(ID_STR_ISRTL) == L'1') ? WS_EX_LAYOUTRTL : 0),
Rainmeter->GetWindow());
g_Rainmeter->GetWindow());
// Fake WM_NOTIFY to change tab
NMHDR nm;
@@ -78,7 +78,7 @@ void CDialogAbout::Open(int tab)
** Opens the About dialog by tab name.
**
*/
void CDialogAbout::Open(const WCHAR* name)
void DialogAbout::Open(const WCHAR* name)
{
int tab = 0;
@@ -106,7 +106,7 @@ void CDialogAbout::Open(const WCHAR* name)
** Shows log if dialog isn't already open.
**
*/
void CDialogAbout::ShowAboutLog()
void DialogAbout::ShowAboutLog()
{
if (!c_Dialog)
{
@@ -114,7 +114,7 @@ void CDialogAbout::ShowAboutLog()
}
}
void CDialogAbout::AddLogItem(CLogger::Level level, LPCWSTR time, LPCWSTR message)
void DialogAbout::AddLogItem(Logger::Level level, LPCWSTR time, LPCWSTR message)
{
if (c_Dialog && c_Dialog->m_TabLog.IsInitialized())
{
@@ -122,7 +122,7 @@ void CDialogAbout::AddLogItem(CLogger::Level level, LPCWSTR time, LPCWSTR messag
}
}
void CDialogAbout::UpdateSkins()
void DialogAbout::UpdateSkins()
{
if (c_Dialog && c_Dialog->m_TabSkins.IsInitialized())
{
@@ -130,7 +130,7 @@ void CDialogAbout::UpdateSkins()
}
}
void CDialogAbout::UpdateMeasures(CMeterWindow* meterWindow)
void DialogAbout::UpdateMeasures(MeterWindow* meterWindow)
{
if (c_Dialog && c_Dialog->m_TabSkins.IsInitialized())
{
@@ -138,7 +138,7 @@ void CDialogAbout::UpdateMeasures(CMeterWindow* meterWindow)
}
}
CDialog::CTab& CDialogAbout::GetActiveTab()
Dialog::Tab& DialogAbout::GetActiveTab()
{
int sel = TabCtrl_GetCurSel(GetControl(Id_Tab));
if (sel == 0)
@@ -159,7 +159,7 @@ CDialog::CTab& CDialogAbout::GetActiveTab()
}
}
INT_PTR CDialogAbout::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
@@ -225,7 +225,7 @@ INT_PTR CDialogAbout::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
return FALSE;
}
INT_PTR CDialogAbout::OnInitDialog(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::OnInitDialog(WPARAM wParam, LPARAM lParam)
{
static const ControlTemplate::Control s_Controls[] =
{
@@ -264,9 +264,9 @@ INT_PTR CDialogAbout::OnInitDialog(WPARAM wParam, LPARAM lParam)
if (Platform::IsAtLeastWinVista())
{
item = m_TabLog.GetControl(CTabLog::Id_ItemsListView);
item = m_TabLog.GetControl(TabLog::Id_ItemsListView);
SetWindowTheme(item, L"explorer", NULL);
item = m_TabSkins.GetControl(CTabSkins::Id_ItemsListView);
item = m_TabSkins.GetControl(TabSkins::Id_ItemsListView);
SetWindowTheme(item, L"explorer", NULL);
}
@@ -280,7 +280,7 @@ INT_PTR CDialogAbout::OnInitDialog(WPARAM wParam, LPARAM lParam)
return TRUE;
}
INT_PTR CDialogAbout::OnCommand(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::OnCommand(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
@@ -295,7 +295,7 @@ INT_PTR CDialogAbout::OnCommand(WPARAM wParam, LPARAM lParam)
return TRUE;
}
INT_PTR CDialogAbout::OnNotify(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::OnNotify(WPARAM wParam, LPARAM lParam)
{
LPNMHDR nm = (LPNMHDR)lParam;
switch (nm->idFrom)
@@ -330,7 +330,7 @@ INT_PTR CDialogAbout::OnNotify(WPARAM wParam, LPARAM lParam)
** Constructor.
**
*/
CDialogAbout::CTabLog::CTabLog() : CTab(),
DialogAbout::TabLog::TabLog() : Tab(),
m_Error(true),
m_Warning(true),
m_Notice(true),
@@ -338,9 +338,9 @@ CDialogAbout::CTabLog::CTabLog() : CTab(),
{
}
void CDialogAbout::CTabLog::Create(HWND owner)
void DialogAbout::TabLog::Create(HWND owner)
{
CTab::CreateTabWindow(15, 30, 370, 148, owner);
Tab::CreateTabWindow(15, 30, 370, 148, owner);
static const ControlTemplate::Control s_Controls[] =
{
@@ -368,7 +368,7 @@ void CDialogAbout::CTabLog::Create(HWND owner)
** Called when tab is displayed.
**
*/
void CDialogAbout::CTabLog::Initialize()
void DialogAbout::TabLog::Initialize()
{
// Add columns to the list view
HWND item = GetControl(Id_ItemsListView);
@@ -409,7 +409,7 @@ void CDialogAbout::CTabLog::Initialize()
ListView_InsertColumn(item, 2, &lvc);
// Add stored entires
for (const auto& entry : CLogger::GetInstance().GetEntries())
for (const auto& entry : Logger::GetInstance().GetEntries())
{
AddItem(entry.level, entry.timestamp.c_str(), entry.message.c_str());
}
@@ -433,7 +433,7 @@ void CDialogAbout::CTabLog::Initialize()
** Resizes window and repositions controls.
**
*/
void CDialogAbout::CTabLog::Resize(int w, int h)
void DialogAbout::TabLog::Resize(int w, int h)
{
SetWindowPos(m_Window, NULL, 0, 0, w, h, SWP_NOMOVE | SWP_NOZORDER);
@@ -466,7 +466,7 @@ void CDialogAbout::CTabLog::Resize(int w, int h)
** Adds item to log.
**
*/
void CDialogAbout::CTabLog::AddItem(CLogger::Level level, LPCWSTR time, LPCWSTR message)
void DialogAbout::TabLog::AddItem(Logger::Level level, LPCWSTR time, LPCWSTR message)
{
WCHAR buffer[32];
LVITEM vitem;
@@ -478,25 +478,25 @@ void CDialogAbout::CTabLog::AddItem(CLogger::Level level, LPCWSTR time, LPCWSTR
switch (level)
{
case CLogger::Level::Error:
case Logger::Level::Error:
if (!m_Error) return;
item = GetControl(Id_ErrorCheckBox);
vitem.iImage = 0;
break;
case CLogger::Level::Warning:
case Logger::Level::Warning:
if (!m_Warning) return;
item = GetControl(Id_WarningCheckBox);
vitem.iImage = 1;
break;
case CLogger::Level::Notice:
case Logger::Level::Notice:
if (!m_Notice) return;
item = GetControl(Id_NoticeCheckBox);
vitem.iImage = 2;
break;
case CLogger::Level::Debug:
case Logger::Level::Debug:
if (!m_Debug) return;
item = GetControl(Id_DebugCheckBox);
vitem.iImage = I_IMAGENONE;
@@ -514,7 +514,7 @@ void CDialogAbout::CTabLog::AddItem(CLogger::Level level, LPCWSTR time, LPCWSTR
}
}
INT_PTR CDialogAbout::CTabLog::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabLog::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
@@ -528,7 +528,7 @@ INT_PTR CDialogAbout::CTabLog::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lP
return FALSE;
}
INT_PTR CDialogAbout::CTabLog::OnCommand(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabLog::OnCommand(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
@@ -567,7 +567,7 @@ INT_PTR CDialogAbout::CTabLog::OnCommand(WPARAM wParam, LPARAM lParam)
return 0;
}
INT_PTR CDialogAbout::CTabLog::OnNotify(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabLog::OnNotify(WPARAM wParam, LPARAM lParam)
{
LPNMHDR nm = (LPNMHDR)lParam;
switch (nm->code)
@@ -583,7 +583,7 @@ INT_PTR CDialogAbout::CTabLog::OnNotify(WPARAM wParam, LPARAM lParam)
{
std::wstring tmpSz(512, L'0');
ListView_GetItemText(nm->hwndFrom, sel, 2, &tmpSz[0], 512);
CSystem::SetClipboardText(tmpSz);
System::SetClipboardText(tmpSz);
}
}
}
@@ -606,14 +606,14 @@ INT_PTR CDialogAbout::CTabLog::OnNotify(WPARAM wParam, LPARAM lParam)
** Constructor.
**
*/
CDialogAbout::CTabSkins::CTabSkins() : CTab(),
DialogAbout::TabSkins::TabSkins() : Tab(),
m_SkinWindow()
{
}
void CDialogAbout::CTabSkins::Create(HWND owner)
void DialogAbout::TabSkins::Create(HWND owner)
{
CTab::CreateTabWindow(15, 30, 370, 148, owner);
Tab::CreateTabWindow(15, 30, 370, 148, owner);
static const ControlTemplate::Control s_Controls[] =
{
@@ -628,7 +628,7 @@ void CDialogAbout::CTabSkins::Create(HWND owner)
CreateControls(s_Controls, _countof(s_Controls), c_Dialog->m_Font, GetString);
}
void CDialogAbout::CTabSkins::Initialize()
void DialogAbout::TabSkins::Initialize()
{
// Add columns to the list view
HWND item = GetControl(Id_ItemsListView);
@@ -672,7 +672,7 @@ void CDialogAbout::CTabSkins::Initialize()
** Resizes window and repositions controls.
**
*/
void CDialogAbout::CTabSkins::Resize(int w, int h)
void DialogAbout::TabSkins::Resize(int w, int h)
{
SetWindowPos(m_Window, NULL, 0, 0, w, h, SWP_NOMOVE | SWP_NOZORDER);
@@ -694,7 +694,7 @@ void CDialogAbout::CTabSkins::Resize(int w, int h)
** Updates the list of skins.
**
*/
void CDialogAbout::CTabSkins::UpdateSkinList()
void DialogAbout::TabSkins::UpdateSkinList()
{
// Delete all entries
HWND item = GetControl(Id_SkinsListBox);
@@ -702,8 +702,8 @@ void CDialogAbout::CTabSkins::UpdateSkinList()
// Add entries for each skin
std::wstring::size_type maxLength = 0;
const std::map<std::wstring, CMeterWindow*>& windows = Rainmeter->GetAllMeterWindows();
std::map<std::wstring, CMeterWindow*>::const_iterator iter = windows.begin();
const std::map<std::wstring, MeterWindow*>& windows = g_Rainmeter->GetAllMeterWindows();
std::map<std::wstring, MeterWindow*>::const_iterator iter = windows.begin();
bool found = false;
for ( ; iter != windows.end(); ++iter)
{
@@ -748,7 +748,7 @@ void CDialogAbout::CTabSkins::UpdateSkinList()
** Updates the list of measures and values.
**
*/
void CDialogAbout::CTabSkins::UpdateMeasureList(CMeterWindow* meterWindow)
void DialogAbout::TabSkins::UpdateMeasureList(MeterWindow* meterWindow)
{
if (!meterWindow)
{
@@ -756,8 +756,8 @@ void CDialogAbout::CTabSkins::UpdateMeasureList(CMeterWindow* meterWindow)
HWND item = GetControl(Id_SkinsListBox);
int selected = (int)SendMessage(item, LB_GETCURSEL, NULL, NULL);
const std::map<std::wstring, CMeterWindow*>& windows = Rainmeter->GetAllMeterWindows();
std::map<std::wstring, CMeterWindow*>::const_iterator iter = windows.begin();
const std::map<std::wstring, MeterWindow*>& windows = g_Rainmeter->GetAllMeterWindows();
std::map<std::wstring, MeterWindow*>::const_iterator iter = windows.begin();
while (selected && iter != windows.end())
{
++iter;
@@ -783,8 +783,8 @@ void CDialogAbout::CTabSkins::UpdateMeasureList(CMeterWindow* meterWindow)
lvi.lParam = 0;
lvi.iGroupId = 0;
const std::vector<CMeasure*>& measures = m_SkinWindow->GetMeasures();
std::vector<CMeasure*>::const_iterator j = measures.begin();
const std::vector<Measure*>& measures = m_SkinWindow->GetMeasures();
std::vector<Measure*>::const_iterator j = measures.begin();
for ( ; j != measures.end(); ++j)
{
lvi.pszText = (WCHAR*)(*j)->GetName();
@@ -799,10 +799,10 @@ void CDialogAbout::CTabSkins::UpdateMeasureList(CMeterWindow* meterWindow)
}
WCHAR buffer[256];
CMeasure::GetScaledValue(AUTOSCALE_ON, 1, (*j)->GetMinValue(), buffer, _countof(buffer));
Measure::GetScaledValue(AUTOSCALE_ON, 1, (*j)->GetMinValue(), buffer, _countof(buffer));
std::wstring range = buffer;
range += L" - ";
CMeasure::GetScaledValue(AUTOSCALE_ON, 1, (*j)->GetMaxValue(), buffer, _countof(buffer));
Measure::GetScaledValue(AUTOSCALE_ON, 1, (*j)->GetMaxValue(), buffer, _countof(buffer));
range += buffer;
ListView_SetItemText(item, lvi.iItem, 1, (WCHAR*)range.c_str());
@@ -862,7 +862,7 @@ void CDialogAbout::CTabSkins::UpdateMeasureList(CMeterWindow* meterWindow)
SendMessage(item, WM_SETREDRAW, TRUE, 0);
}
int CALLBACK CDialogAbout::CTabSkins::ListSortProc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
int CALLBACK DialogAbout::TabSkins::ListSortProc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
// Measures
if (!lParam1 && !lParam2) return 0;
@@ -873,7 +873,7 @@ int CALLBACK CDialogAbout::CTabSkins::ListSortProc(LPARAM lParam1, LPARAM lParam
return wcscmp((const WCHAR*)lParam1, (const WCHAR*)lParam2);
}
INT_PTR CDialogAbout::CTabSkins::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabSkins::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
@@ -887,7 +887,7 @@ INT_PTR CDialogAbout::CTabSkins::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM
return FALSE;
}
INT_PTR CDialogAbout::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
@@ -905,7 +905,7 @@ INT_PTR CDialogAbout::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
return 0;
}
INT_PTR CDialogAbout::CTabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
{
LPNMHDR nm = (LPNMHDR)lParam;
switch (nm->code)
@@ -920,7 +920,7 @@ INT_PTR CDialogAbout::CTabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
{
std::wstring tmpSz(512, L'0');
ListView_GetItemText(nm->hwndFrom, sel, 2, &tmpSz[0], 512);
CSystem::SetClipboardText(tmpSz);
System::SetClipboardText(tmpSz);
}
}
}
@@ -939,13 +939,13 @@ INT_PTR CDialogAbout::CTabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
//
// -----------------------------------------------------------------------------------------------
CDialogAbout::CTabPlugins::CTabPlugins() : CTab()
DialogAbout::TabPlugins::TabPlugins() : Tab()
{
}
void CDialogAbout::CTabPlugins::Create(HWND owner)
void DialogAbout::TabPlugins::Create(HWND owner)
{
CTab::CreateTabWindow(15, 30, 370, 148, owner);
Tab::CreateTabWindow(15, 30, 370, 148, owner);
static const ControlTemplate::Control s_Controls[] =
{
@@ -957,7 +957,7 @@ void CDialogAbout::CTabPlugins::Create(HWND owner)
CreateControls(s_Controls, _countof(s_Controls), c_Dialog->m_Font, GetString);
}
void CDialogAbout::CTabPlugins::Initialize()
void DialogAbout::TabPlugins::Initialize()
{
// Add columns to the list view
HWND item = GetControl(Id_ItemsListView);
@@ -1054,7 +1054,7 @@ void CDialogAbout::CTabPlugins::Initialize()
// Try old calling GetPluginVersion/GetPluginAuthor for backwards compatibility
DWORD err = 0;
HMODULE dll = CSystem::RmLoadLibrary(path, &err);
HMODULE dll = System::RmLoadLibrary(path, &err);
if (dll)
{
ListView_InsertItem(item, &vitem);
@@ -1090,10 +1090,10 @@ void CDialogAbout::CTabPlugins::Initialize()
FindClose(hSearch);
};
findPlugins(Rainmeter->GetPluginPath());
if (Rainmeter->HasUserPluginPath())
findPlugins(g_Rainmeter->GetPluginPath());
if (g_Rainmeter->HasUserPluginPath())
{
findPlugins(Rainmeter->GetUserPluginPath());
findPlugins(g_Rainmeter->GetUserPluginPath());
}
m_Initialized = true;
@@ -1103,7 +1103,7 @@ void CDialogAbout::CTabPlugins::Initialize()
** Resizes window and repositions controls.
**
*/
void CDialogAbout::CTabPlugins::Resize(int w, int h)
void DialogAbout::TabPlugins::Resize(int w, int h)
{
SetWindowPos(m_Window, NULL, 0, 0, w, h, SWP_NOMOVE | SWP_NOZORDER);
@@ -1127,13 +1127,13 @@ void CDialogAbout::CTabPlugins::Resize(int w, int h)
** Constructor.
**
*/
CDialogAbout::CTabVersion::CTabVersion() : CTab()
DialogAbout::TabVersion::TabVersion() : Tab()
{
}
void CDialogAbout::CTabVersion::Create(HWND owner)
void DialogAbout::TabVersion::Create(HWND owner)
{
CTab::CreateTabWindow(15, 30, 370, 148, owner);
Tab::CreateTabWindow(15, 30, 370, 148, owner);
// FIXME: Temporary hack.
short buttonWidth = (short)_wtoi(GetString(ID_STR_NUM_BUTTONWIDTH));
@@ -1169,7 +1169,7 @@ void CDialogAbout::CTabVersion::Create(HWND owner)
CreateControls(s_Controls, _countof(s_Controls), c_Dialog->m_Font, GetString);
}
void CDialogAbout::CTabVersion::Initialize()
void DialogAbout::TabVersion::Initialize()
{
HWND item = GetControl(Id_AppIcon);
HICON icon = GetIcon(IDI_RAINMETER, true);
@@ -1181,15 +1181,15 @@ void CDialogAbout::CTabVersion::Initialize()
SetWindowText(item, tmpSz);
item = GetControl(Id_PathLabel);
std::wstring text = L"Path: " + Rainmeter->GetPath();
std::wstring text = L"Path: " + g_Rainmeter->GetPath();
SetWindowText(item, text.c_str());
item = GetControl(Id_IniFileLabel);
text = L"IniFile: " + Rainmeter->GetIniFile();
text = L"IniFile: " + g_Rainmeter->GetIniFile();
SetWindowText(item, text.c_str());
item = GetControl(Id_SkinPathLabel);
text = L"SkinPath: " + Rainmeter->GetSkinPath();
text = L"SkinPath: " + g_Rainmeter->GetSkinPath();
SetWindowText(item, text.c_str());
m_Initialized = true;
@@ -1199,12 +1199,12 @@ void CDialogAbout::CTabVersion::Initialize()
** Resizes window and repositions controls.
**
*/
void CDialogAbout::CTabVersion::Resize(int w, int h)
void DialogAbout::TabVersion::Resize(int w, int h)
{
SetWindowPos(m_Window, NULL, 0, 0, w, h, SWP_NOMOVE | SWP_NOZORDER);
}
INT_PTR CDialogAbout::CTabVersion::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabVersion::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
@@ -1218,7 +1218,7 @@ INT_PTR CDialogAbout::CTabVersion::HandleMessage(UINT uMsg, WPARAM wParam, LPARA
return FALSE;
}
INT_PTR CDialogAbout::CTabVersion::OnCommand(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabVersion::OnCommand(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
@@ -1228,12 +1228,12 @@ INT_PTR CDialogAbout::CTabVersion::OnCommand(WPARAM wParam, LPARAM lParam)
int len = _snwprintf_s(tmpSz, _TRUNCATE, L"%s%s r%i %s (%s)", APPVERSION, revision_beta ? L" beta" : L"", revision_number, APPBITS, APPDATE);
std::wstring text(tmpSz, len);
text += L"\nPath: ";
text += Rainmeter->GetPath();
text += g_Rainmeter->GetPath();
text += L"\nIniFile: ";
text += Rainmeter->GetIniFile();
text += g_Rainmeter->GetIniFile();
text += L"\nSkinPath: ";
text += Rainmeter->GetSkinPath();
CSystem::SetClipboardText(text);
text += g_Rainmeter->GetSkinPath();
System::SetClipboardText(text);
}
break;
@@ -1244,7 +1244,7 @@ INT_PTR CDialogAbout::CTabVersion::OnCommand(WPARAM wParam, LPARAM lParam)
return 0;
}
INT_PTR CDialogAbout::CTabVersion::OnNotify(WPARAM wParam, LPARAM lParam)
INT_PTR DialogAbout::TabVersion::OnNotify(WPARAM wParam, LPARAM lParam)
{
LPNMHDR nm = (LPNMHDR)lParam;
switch (nm->code)
@@ -1252,11 +1252,11 @@ INT_PTR CDialogAbout::CTabVersion::OnNotify(WPARAM wParam, LPARAM lParam)
case NM_CLICK:
if (nm->idFrom == Id_HomeLink)
{
CCommandHandler::RunFile(L"http://rainmeter.net");
CommandHandler::RunFile(L"http://rainmeter.net");
}
else if (nm->idFrom == Id_HomeLink)
{
CCommandHandler::RunFile(L"http://gnu.org/licenses");
CommandHandler::RunFile(L"http://gnu.org/licenses");
}
break;

46
Library/DialogAbout.h
View File

@@ -23,21 +23,21 @@
#include "Logger.h"
#include "MeterWindow.h"
class CDialogAbout : public CDialog
class DialogAbout : public Dialog
{
public:
CDialogAbout();
virtual ~CDialogAbout();
DialogAbout();
virtual ~DialogAbout();
static CDialog* GetDialog() { return c_Dialog; }
static Dialog* GetDialog() { return c_Dialog; }
static void Open(int tab = 0);
static void Open(const WCHAR* name);
static void ShowAboutLog();
static void AddLogItem(CLogger::Level level, LPCWSTR time, LPCWSTR message);
static void AddLogItem(Logger::Level level, LPCWSTR time, LPCWSTR message);
static void UpdateSkins();
static void UpdateMeasures(CMeterWindow* meterWindow);
static void UpdateMeasures(MeterWindow* meterWindow);
protected:
virtual INT_PTR HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
@@ -47,7 +47,7 @@ protected:
private:
// Log tab
class CTabLog : public CTab
class TabLog : public Tab
{
public:
enum Id
@@ -59,13 +59,13 @@ private:
Id_DebugCheckBox
};
CTabLog();
TabLog();
void Create(HWND owner);
virtual void Initialize();
virtual void Resize(int w, int h);
void AddItem(CLogger::Level level, LPCWSTR time, LPCWSTR message);
void AddItem(Logger::Level level, LPCWSTR time, LPCWSTR message);
protected:
virtual INT_PTR HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
@@ -80,7 +80,7 @@ private:
};
// Measures tab
class CTabSkins : public CTab
class TabSkins : public Tab
{
public:
enum Id
@@ -89,14 +89,14 @@ private:
Id_ItemsListView
};
CTabSkins();
TabSkins();
void Create(HWND owner);
virtual void Initialize();
virtual void Resize(int w, int h);
void UpdateSkinList();
void UpdateMeasureList(CMeterWindow* meterWindow);
void UpdateMeasureList(MeterWindow* meterWindow);
protected:
virtual INT_PTR HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
@@ -106,11 +106,11 @@ private:
private:
static int CALLBACK ListSortProc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
CMeterWindow* m_SkinWindow;
MeterWindow* m_SkinWindow;
};
// Plugins tab
class CTabPlugins : public CTab
class TabPlugins : public Tab
{
public:
enum Id
@@ -118,7 +118,7 @@ private:
Id_ItemsListView = 100
};
CTabPlugins();
TabPlugins();
void Create(HWND owner);
virtual void Initialize();
@@ -130,7 +130,7 @@ private:
};
// Version tab
class CTabVersion : public CTab
class TabVersion : public Tab
{
public:
enum Id
@@ -145,7 +145,7 @@ private:
Id_CopyButton
};
CTabVersion();
TabVersion();
void Create(HWND owner);
virtual void Initialize();
@@ -163,15 +163,15 @@ private:
Id_Tab = 100
};
CTab& GetActiveTab();
Tab& GetActiveTab();
CTabLog m_TabLog;
CTabSkins m_TabSkins;
CTabPlugins m_TabPlugins;
CTabVersion m_TabVersion;
TabLog m_TabLog;
TabSkins m_TabSkins;
TabPlugins m_TabPlugins;
TabVersion m_TabVersion;
static WINDOWPLACEMENT c_WindowPlacement;
static CDialogAbout* c_Dialog;
static DialogAbout* c_Dialog;
};
#endif

274
Library/DialogManage.cpp
View File

@@ -29,16 +29,16 @@
#include "../Version.h"
#include <Commdlg.h>
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
WINDOWPLACEMENT CDialogManage::c_WindowPlacement = {0};
CDialogManage* CDialogManage::c_Dialog = NULL;
WINDOWPLACEMENT DialogManage::c_WindowPlacement = {0};
DialogManage* DialogManage::c_Dialog = NULL;
/*
** Constructor.
**
*/
CDialogManage::CDialogManage() : CDialog()
DialogManage::DialogManage() : Dialog()
{
}
@@ -46,7 +46,7 @@ CDialogManage::CDialogManage() : CDialog()
** Destructor.
**
*/
CDialogManage::~CDialogManage()
DialogManage::~DialogManage()
{
}
@@ -54,7 +54,7 @@ CDialogManage::~CDialogManage()
** Opens the Manage dialog by tab name.
**
*/
void CDialogManage::Open(const WCHAR* name)
void DialogManage::Open(const WCHAR* name)
{
int tab = 0;
@@ -78,11 +78,11 @@ void CDialogManage::Open(const WCHAR* name)
** Opens the Manage dialog.
**
*/
void CDialogManage::Open(int tab)
void DialogManage::Open(int tab)
{
if (!c_Dialog)
{
c_Dialog = new CDialogManage();
c_Dialog = new DialogManage();
}
c_Dialog->ShowDialogWindow(
@@ -90,7 +90,7 @@ void CDialogManage::Open(int tab)
0, 0, 500, 322,
DS_CENTER | WS_POPUP | WS_MINIMIZEBOX | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME,
WS_EX_APPWINDOW | WS_EX_CONTROLPARENT | ((*GetString(ID_STR_ISRTL) == L'1') ? WS_EX_LAYOUTRTL : 0),
Rainmeter->GetWindow());
g_Rainmeter->GetWindow());
// Fake WM_NOTIFY to change tab
NMHDR nm;
@@ -105,7 +105,7 @@ void CDialogManage::Open(int tab)
** Opens the Manage dialog Skins tab with skin selected.
**
*/
void CDialogManage::OpenSkin(CMeterWindow* meterWindow)
void DialogManage::OpenSkin(MeterWindow* meterWindow)
{
Open();
@@ -114,7 +114,7 @@ void CDialogManage::OpenSkin(CMeterWindow* meterWindow)
std::wstring name = meterWindow->GetFolderPath() + L'\\';
name += meterWindow->GetFileName();
HWND item = c_Dialog->m_TabSkins.GetControl(CTabSkins::Id_SkinsTreeView);
HWND item = c_Dialog->m_TabSkins.GetControl(TabSkins::Id_SkinsTreeView);
c_Dialog->m_TabSkins.SelectTreeItem(item, TreeView_GetRoot(item), name.c_str());
}
}
@@ -123,7 +123,7 @@ void CDialogManage::OpenSkin(CMeterWindow* meterWindow)
** Updates Skins tab.
**
*/
void CDialogManage::UpdateSkins(CMeterWindow* meterWindow, bool deleted)
void DialogManage::UpdateSkins(MeterWindow* meterWindow, bool deleted)
{
if (c_Dialog && c_Dialog->m_TabSkins.IsInitialized())
{
@@ -131,7 +131,7 @@ void CDialogManage::UpdateSkins(CMeterWindow* meterWindow, bool deleted)
}
}
CDialog::CTab& CDialogManage::GetActiveTab()
Dialog::Tab& DialogManage::GetActiveTab()
{
int sel = TabCtrl_GetCurSel(GetControl(Id_Tab));
if (sel == 0)
@@ -148,7 +148,7 @@ CDialog::CTab& CDialogManage::GetActiveTab()
}
}
INT_PTR CDialogManage::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
@@ -181,7 +181,7 @@ INT_PTR CDialogManage::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
return FALSE;
}
INT_PTR CDialogManage::OnInitDialog(WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::OnInitDialog(WPARAM wParam, LPARAM lParam)
{
// FIXME: Temporary hack.
short buttonWidth = (short)_wtoi(GetString(ID_STR_NUM_BUTTONWIDTH));
@@ -230,13 +230,13 @@ INT_PTR CDialogManage::OnInitDialog(WPARAM wParam, LPARAM lParam)
item = GetControl(Id_CloseButton);
SendMessage(m_Window, WM_NEXTDLGCTL, (WPARAM)item, TRUE);
item = m_TabSkins.GetControl(CTabSkins::Id_FileLabel);
item = m_TabSkins.GetControl(TabSkins::Id_FileLabel);
SendMessage(item, WM_SETFONT, (WPARAM)m_FontBold, 0);
if (Platform::IsAtLeastWinVista())
{
// Use arrows instead of plus/minus in the tree for Vista+
item = m_TabSkins.GetControl(CTabSkins::Id_SkinsTreeView);
item = m_TabSkins.GetControl(TabSkins::Id_SkinsTreeView);
SetWindowTheme(item, L"explorer", NULL);
}
@@ -251,20 +251,20 @@ INT_PTR CDialogManage::OnInitDialog(WPARAM wParam, LPARAM lParam)
return FALSE;
}
INT_PTR CDialogManage::OnCommand(WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::OnCommand(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
case Id_RefreshAllButton:
Rainmeter->RefreshAll();
g_Rainmeter->RefreshAll();
break;
case Id_EditSettingsButton:
Rainmeter->EditSettings();
g_Rainmeter->EditSettings();
break;
case Id_OpenLogButton:
CDialogAbout::Open();
DialogAbout::Open();
break;
case Id_CloseButton:
@@ -275,7 +275,7 @@ INT_PTR CDialogManage::OnCommand(WPARAM wParam, LPARAM lParam)
{
std::wstring url = L"http://docs.rainmeter.net/manual/user-interface/manage#";
CTab& tab = GetActiveTab();
Tab& tab = GetActiveTab();
if (&tab == &m_TabSkins)
{
url += L"Skins";
@@ -301,7 +301,7 @@ INT_PTR CDialogManage::OnCommand(WPARAM wParam, LPARAM lParam)
return TRUE;
}
INT_PTR CDialogManage::OnNotify(WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::OnNotify(WPARAM wParam, LPARAM lParam)
{
LPNMHDR nm = (LPNMHDR)lParam;
switch (nm->idFrom)
@@ -335,16 +335,16 @@ INT_PTR CDialogManage::OnNotify(WPARAM wParam, LPARAM lParam)
** Constructor.
**
*/
CDialogManage::CTabSkins::CTabSkins() : CTab(),
DialogManage::TabSkins::TabSkins() : Tab(),
m_SkinWindow(),
m_HandleCommands(false),
m_IgnoreUpdate(false)
{
}
void CDialogManage::CTabSkins::Create(HWND owner)
void DialogManage::TabSkins::Create(HWND owner)
{
CTab::CreateTabWindow(15, 30, 470, 260, owner);
Tab::CreateTabWindow(15, 30, 470, 260, owner);
// FIXME: Temporary hack.
short labelWidth = (short)_wtoi(GetString(ID_STR_NUM_LABELWIDTH));
@@ -466,7 +466,7 @@ void CDialogManage::CTabSkins::Create(HWND owner)
CreateControls(s_Controls, _countof(s_Controls), c_Dialog->m_Font, GetString);
}
void CDialogManage::CTabSkins::Initialize()
void DialogManage::TabSkins::Initialize()
{
BUTTON_SPLITINFO bsi;
bsi.mask = BCSIF_SIZE;
@@ -474,10 +474,10 @@ void CDialogManage::CTabSkins::Initialize()
bsi.size.cy = 14;
HWND item = GetControl(Id_ActiveSkinsButton);
CDialog::SetMenuButton(item);
Dialog::SetMenuButton(item);
item = GetControl(Id_DisplayMonitorButton);
CDialog::SetMenuButton(item);
Dialog::SetMenuButton(item);
// Load folder/.ini icons from shell32
HIMAGELIST hImageList = ImageList_Create(16, 16, ILC_COLOR32, 2, 10);
@@ -531,7 +531,7 @@ void CDialogManage::CTabSkins::Initialize()
** Updates metadata and settings when changed.
**
*/
void CDialogManage::CTabSkins::Update(CMeterWindow* meterWindow, bool deleted)
void DialogManage::TabSkins::Update(MeterWindow* meterWindow, bool deleted)
{
if (meterWindow)
{
@@ -572,14 +572,14 @@ void CDialogManage::CTabSkins::Update(CMeterWindow* meterWindow, bool deleted)
tvi.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvi.item.iImage = tvi.item.iSelectedImage = 0;
if (!Rainmeter->m_SkinFolders.empty())
if (!g_Rainmeter->m_SkinFolders.empty())
{
PopulateTree(item, tvi);
}
}
}
void CDialogManage::CTabSkins::SetControls()
void DialogManage::TabSkins::SetControls()
{
WCHAR buffer[64];
@@ -610,7 +610,7 @@ void CDialogManage::CTabSkins::SetControls()
EnableWindow(item, TRUE);
item = GetControl(Id_DraggableCheckBox);
if (Rainmeter->GetDisableDragging())
if (g_Rainmeter->GetDisableDragging())
{
EnableWindow(item, FALSE);
Button_SetCheck(item, BST_UNCHECKED);
@@ -650,7 +650,7 @@ void CDialogManage::CTabSkins::SetControls()
item = GetControl(Id_LoadOrderEdit);
EnableWindow(item, TRUE);
_itow_s(Rainmeter->GetLoadOrder(m_SkinFolderPath), buffer, 10);
_itow_s(g_Rainmeter->GetLoadOrder(m_SkinFolderPath), buffer, 10);
SetWindowText(item, buffer);
item = GetControl(Id_OnHoverDropDownList);
@@ -663,7 +663,7 @@ void CDialogManage::CTabSkins::SetControls()
}
}
void CDialogManage::CTabSkins::DisableControls(bool clear)
void DialogManage::TabSkins::DisableControls(bool clear)
{
HWND item = GetControl(Id_LoadButton);
SetWindowText(item, GetString(ID_STR_LOAD));
@@ -753,7 +753,7 @@ void CDialogManage::CTabSkins::DisableControls(bool clear)
ComboBox_SetCurSel(item, -1);
}
void CDialogManage::CTabSkins::ReadSkin()
void DialogManage::TabSkins::ReadSkin()
{
HWND item = GetControl(Id_FileLabel);
SetWindowText(item, m_SkinFileName.c_str());
@@ -763,10 +763,10 @@ void CDialogManage::CTabSkins::ReadSkin()
item = GetControl(Id_EditButton);
EnableWindow(item, TRUE);
std::wstring file = Rainmeter->GetSkinPath() + m_SkinFolderPath;
std::wstring file = g_Rainmeter->GetSkinPath() + m_SkinFolderPath;
file += L'\\';
file += m_SkinFileName;
m_SkinWindow = Rainmeter->GetMeterWindowByINI(file);
m_SkinWindow = g_Rainmeter->GetMeterWindowByINI(file);
if (!m_SkinWindow)
{
DisableControls();
@@ -854,7 +854,7 @@ void CDialogManage::CTabSkins::ReadSkin()
delete [] buffer;
}
std::wstring CDialogManage::CTabSkins::GetTreeSelectionPath(HWND tree)
std::wstring DialogManage::TabSkins::GetTreeSelectionPath(HWND tree)
{
WCHAR buffer[MAX_PATH];
@@ -881,14 +881,14 @@ std::wstring CDialogManage::CTabSkins::GetTreeSelectionPath(HWND tree)
** Populates the treeview with folders and skins.
**
*/
int CDialogManage::CTabSkins::PopulateTree(HWND tree, TVINSERTSTRUCT& tvi, int index)
int DialogManage::TabSkins::PopulateTree(HWND tree, TVINSERTSTRUCT& tvi, int index)
{
int initialLevel = Rainmeter->m_SkinFolders[index].level;
int initialLevel = g_Rainmeter->m_SkinFolders[index].level;
const size_t max = Rainmeter->m_SkinFolders.size();
const size_t max = g_Rainmeter->m_SkinFolders.size();
while (index < max)
{
const CRainmeter::SkinFolder& skinFolder = Rainmeter->m_SkinFolders[index];
const Rainmeter::SkinFolder& skinFolder = g_Rainmeter->m_SkinFolders[index];
if (skinFolder.level != initialLevel)
{
return index - 1;
@@ -903,7 +903,7 @@ int CDialogManage::CTabSkins::PopulateTree(HWND tree, TVINSERTSTRUCT& tvi, int i
// Add subfolders
if ((index + 1) < max &&
Rainmeter->m_SkinFolders[index + 1].level == initialLevel + 1)
g_Rainmeter->m_SkinFolders[index + 1].level == initialLevel + 1)
{
index = PopulateTree(tree, tvi, index + 1);
}
@@ -928,7 +928,7 @@ int CDialogManage::CTabSkins::PopulateTree(HWND tree, TVINSERTSTRUCT& tvi, int i
** Selects an item in the treeview.
**
*/
void CDialogManage::CTabSkins::SelectTreeItem(HWND tree, HTREEITEM item, LPCWSTR name)
void DialogManage::TabSkins::SelectTreeItem(HWND tree, HTREEITEM item, LPCWSTR name)
{
WCHAR buffer[MAX_PATH];
TVITEM tvi = {0};
@@ -978,7 +978,7 @@ void CDialogManage::CTabSkins::SelectTreeItem(HWND tree, HTREEITEM item, LPCWSTR
}
}
INT_PTR CDialogManage::CTabSkins::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::TabSkins::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
@@ -992,7 +992,7 @@ INT_PTR CDialogManage::CTabSkins::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM
return FALSE;
}
INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::TabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
{
if (!m_HandleCommands)
{
@@ -1007,9 +1007,9 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
HMENU menu = CreatePopupMenu();
// Add active skins to menu
std::map<std::wstring, CMeterWindow*>::const_iterator iter = Rainmeter->GetAllMeterWindows().begin();
std::map<std::wstring, MeterWindow*>::const_iterator iter = g_Rainmeter->GetAllMeterWindows().begin();
int index = 0;
for ( ; iter != Rainmeter->GetAllMeterWindows().end(); ++iter)
for ( ; iter != g_Rainmeter->GetAllMeterWindows().end(); ++iter)
{
std::wstring name = ((*iter).second)->GetFolderPath() + L'\\';
name += ((*iter).second)->GetFileName();
@@ -1040,8 +1040,8 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
case Id_CreateSkinPackageButton:
{
std::wstring file = Rainmeter->GetPath() + L"SkinInstaller.exe";
CCommandHandler::RunFile(file.c_str(), L"/Packager");
std::wstring file = g_Rainmeter->GetPath() + L"SkinInstaller.exe";
CommandHandler::RunFile(file.c_str(), L"/Packager");
}
break;
@@ -1050,11 +1050,11 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
if (!m_SkinWindow)
{
// Skin not active, load
std::pair<int, int> indexes = Rainmeter->GetMeterWindowIndex(m_SkinFolderPath, m_SkinFileName);
std::pair<int, int> indexes = g_Rainmeter->GetMeterWindowIndex(m_SkinFolderPath, m_SkinFileName);
if (indexes.first != -1 && indexes.second != -1)
{
m_HandleCommands = false;
Rainmeter->ActivateSkin(indexes.first, indexes.second);
g_Rainmeter->ActivateSkin(indexes.first, indexes.second);
m_HandleCommands = true;
// Fake selection change to update controls
@@ -1068,7 +1068,7 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
else
{
m_HandleCommands = false;
Rainmeter->DeactivateSkin(m_SkinWindow, -1);
g_Rainmeter->DeactivateSkin(m_SkinWindow, -1);
}
}
break;
@@ -1081,7 +1081,7 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
break;
case Id_EditButton:
Rainmeter->EditSkinFile(m_SkinFolderPath, m_SkinFileName);
g_Rainmeter->EditSkinFile(m_SkinFolderPath, m_SkinFileName);
break;
case Id_XPositionEdit:
@@ -1148,22 +1148,22 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
// Reset selection
Edit_SetSel((HWND)lParam, LOWORD(sel), HIWORD(sel));
WritePrivateProfileString(m_SkinFolderPath.c_str(), L"LoadOrder", buffer, Rainmeter->GetIniFile().c_str());
std::pair<int, int> indexes = Rainmeter->GetMeterWindowIndex(m_SkinWindow);
WritePrivateProfileString(m_SkinFolderPath.c_str(), L"LoadOrder", buffer, g_Rainmeter->GetIniFile().c_str());
std::pair<int, int> indexes = g_Rainmeter->GetMeterWindowIndex(m_SkinWindow);
if (indexes.first != -1)
{
Rainmeter->SetLoadOrder(indexes.first, value);
g_Rainmeter->SetLoadOrder(indexes.first, value);
std::multimap<int, CMeterWindow*> windows;
Rainmeter->GetMeterWindowsByLoadOrder(windows);
std::multimap<int, MeterWindow*> windows;
g_Rainmeter->GetMeterWindowsByLoadOrder(windows);
CSystem::PrepareHelperWindow();
System::PrepareHelperWindow();
// Reorder window z-position to reflect load order
std::multimap<int, CMeterWindow*>::const_iterator iter = windows.begin();
std::multimap<int, MeterWindow*>::const_iterator iter = windows.begin();
for ( ; iter != windows.end(); ++iter)
{
CMeterWindow* mw = (*iter).second;
MeterWindow* mw = (*iter).second;
mw->ChangeZPos(mw->GetWindowZPosition(), true);
}
}
@@ -1185,7 +1185,7 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
HMENU menu = MenuTemplate::CreateMenu(s_Menu, _countof(s_Menu), GetString);
if (menu)
{
Rainmeter->CreateMonitorMenu(menu, m_SkinWindow);
g_Rainmeter->CreateMonitorMenu(menu, m_SkinWindow);
RECT r;
GetWindowRect((HWND)lParam, &r);
@@ -1269,17 +1269,17 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
case IDM_MANAGESKINSMENU_OPENFOLDER:
{
HWND tree = GetControl(Id_SkinsTreeView);
Rainmeter->OpenSkinFolder(GetTreeSelectionPath(tree));
g_Rainmeter->OpenSkinFolder(GetTreeSelectionPath(tree));
}
break;
default:
if (wParam >= ID_CONFIG_FIRST && wParam <= ID_CONFIG_LAST)
{
std::map<std::wstring, CMeterWindow*>::const_iterator iter = Rainmeter->GetAllMeterWindows().begin();
std::map<std::wstring, MeterWindow*>::const_iterator iter = g_Rainmeter->GetAllMeterWindows().begin();
int index = (int)wParam - ID_CONFIG_FIRST;
int i = 0;
for ( ; iter != Rainmeter->GetAllMeterWindows().end(); ++iter)
for ( ; iter != g_Rainmeter->GetAllMeterWindows().end(); ++iter)
{
if (i == index)
{
@@ -1311,7 +1311,7 @@ INT_PTR CDialogManage::CTabSkins::OnCommand(WPARAM wParam, LPARAM lParam)
return 0;
}
INT_PTR CDialogManage::CTabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::TabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
{
LPNMHDR nm = (LPNMHDR)lParam;
switch (nm->code)
@@ -1319,7 +1319,7 @@ INT_PTR CDialogManage::CTabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
case NM_CLICK:
if (nm->idFrom == Id_AddMetadataLink)
{
std::wstring file = Rainmeter->GetSkinPath() + m_SkinFolderPath;
std::wstring file = g_Rainmeter->GetSkinPath() + m_SkinFolderPath;
file += L'\\';
file += m_SkinFileName;
const WCHAR* str = L"\r\n" // Hack to add below [Rainmeter].
@@ -1345,7 +1345,7 @@ INT_PTR CDialogManage::CTabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
case NM_RCLICK:
if (nm->idFrom == Id_SkinsTreeView)
{
POINT pt = CSystem::GetCursorPosition();
POINT pt = System::GetCursorPosition();
TVHITTESTINFO ht;
ht.pt = pt;
@@ -1490,13 +1490,13 @@ INT_PTR CDialogManage::CTabSkins::OnNotify(WPARAM wParam, LPARAM lParam)
** Constructor.
**
*/
CDialogManage::CTabLayouts::CTabLayouts() : CTab()
DialogManage::TabLayouts::TabLayouts() : Tab()
{
}
void CDialogManage::CTabLayouts::Create(HWND owner)
void DialogManage::TabLayouts::Create(HWND owner)
{
CTab::CreateTabWindow(15, 30, 470, 260, owner);
Tab::CreateTabWindow(15, 30, 470, 260, owner);
static const ControlTemplate::Control s_Controls[] =
{
@@ -1545,10 +1545,10 @@ void CDialogManage::CTabLayouts::Create(HWND owner)
CreateControls(s_Controls, _countof(s_Controls), c_Dialog->m_Font, GetString);
}
void CDialogManage::CTabLayouts::Initialize()
void DialogManage::TabLayouts::Initialize()
{
HWND item = GetControl(Id_List);
const std::vector<std::wstring>& layouts = Rainmeter->GetAllLayouts();
const std::vector<std::wstring>& layouts = g_Rainmeter->GetAllLayouts();
for (int i = 0, isize = layouts.size(); i < isize; ++i)
{
ListBox_AddString(item, layouts[i].c_str());
@@ -1557,7 +1557,7 @@ void CDialogManage::CTabLayouts::Initialize()
m_Initialized = true;
}
INT_PTR CDialogManage::CTabLayouts::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::TabLayouts::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
@@ -1568,7 +1568,7 @@ INT_PTR CDialogManage::CTabLayouts::HandleMessage(UINT uMsg, WPARAM wParam, LPAR
return FALSE;
}
INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::TabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
@@ -1611,7 +1611,7 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
item = GetControl(Id_EditButton);
EnableWindow(item, TRUE);
const std::vector<std::wstring>& layouts = Rainmeter->GetAllLayouts();
const std::vector<std::wstring>& layouts = g_Rainmeter->GetAllLayouts();
item = GetControl(Id_List);
int sel = ListBox_GetCurSel(item);
@@ -1628,7 +1628,7 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
Edit_GetText(item, buffer, MAX_PATH);
std::wstring layout = buffer;
std::wstring path = Rainmeter->GetLayoutPath();
std::wstring path = g_Rainmeter->GetLayoutPath();
CreateDirectory(path.c_str(), 0);
path += layout;
@@ -1636,7 +1636,7 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
if (alreadyExists)
{
std::wstring text = GetFormattedString(ID_STR_THEMEALREADYEXISTS, layout.c_str());
if (Rainmeter->ShowMessage(m_Window, text.c_str(), MB_ICONWARNING | MB_YESNO) != IDYES)
if (g_Rainmeter->ShowMessage(m_Window, text.c_str(), MB_ICONWARNING | MB_YESNO) != IDYES)
{
// Cancel
break;
@@ -1653,10 +1653,10 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
item = GetControl(Id_SaveEmptyThemeCheckBox);
if (Button_GetCheck(item) != BST_CHECKED)
{
if (!CSystem::CopyFiles(Rainmeter->GetIniFile(), path))
if (!System::CopyFiles(g_Rainmeter->GetIniFile(), path))
{
std::wstring text = GetFormattedString(ID_STR_THEMESAVEFAIL, path.c_str());
Rainmeter->ShowMessage(m_Window, text.c_str(), MB_OK | MB_ICONERROR);
g_Rainmeter->ShowMessage(m_Window, text.c_str(), MB_OK | MB_ICONERROR);
break;
}
@@ -1664,7 +1664,7 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
item = GetControl(Id_ExcludeUnusedSkinsCheckBox);
if (Button_GetCheck(item) == BST_CHECKED)
{
CConfigParser parser;
ConfigParser parser;
parser.Initialize(path);
// Remove sections with Active=0
@@ -1687,7 +1687,7 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
{
std::wstring::size_type pos = path.find_last_of(L'\\');
path.replace(pos + 1, path.length() - pos - 1, L"Wallpaper.bmp");
CSystem::CopyFiles((std::wstring)buffer, path);
System::CopyFiles((std::wstring)buffer, path);
}
}
}
@@ -1698,7 +1698,7 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
if (file == INVALID_HANDLE_VALUE)
{
std::wstring text = GetFormattedString(ID_STR_THEMESAVEFAIL, path.c_str());
Rainmeter->ShowMessage(m_Window, text.c_str(), MB_OK | MB_ICONERROR);
g_Rainmeter->ShowMessage(m_Window, text.c_str(), MB_OK | MB_ICONERROR);
break;
}
@@ -1710,7 +1710,7 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
item = GetControl(Id_List);
ListBox_AddString(item, layout.c_str());
Rainmeter->ScanForLayouts();
g_Rainmeter->ScanForLayouts();
}
}
break;
@@ -1719,7 +1719,7 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
{
HWND item = GetControl(Id_List);
int sel = ListBox_GetCurSel(item);
Rainmeter->LoadLayout(Rainmeter->m_Layouts[sel]);
g_Rainmeter->LoadLayout(g_Rainmeter->m_Layouts[sel]);
}
break;
@@ -1727,13 +1727,13 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
{
HWND item = GetControl(Id_List);
int sel = ListBox_GetCurSel(item);
const std::vector<std::wstring>& layouts = Rainmeter->GetAllLayouts();
const std::vector<std::wstring>& layouts = g_Rainmeter->GetAllLayouts();
std::wstring args = L"\"" + Rainmeter->GetLayoutPath();
std::wstring args = L"\"" + g_Rainmeter->GetLayoutPath();
args += layouts[sel];
args += L"\\Rainmeter.ini";
args += L'"';
CCommandHandler::RunFile(Rainmeter->GetSkinEditor().c_str(), args.c_str());
CommandHandler::RunFile(g_Rainmeter->GetSkinEditor().c_str(), args.c_str());
}
break;
@@ -1741,19 +1741,19 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
{
HWND item = GetControl(Id_List);
int sel = ListBox_GetCurSel(item);
std::vector<std::wstring>& layouts = const_cast<std::vector<std::wstring>&>(Rainmeter->GetAllLayouts());
std::vector<std::wstring>& layouts = const_cast<std::vector<std::wstring>&>(g_Rainmeter->GetAllLayouts());
std::wstring text = GetFormattedString(ID_STR_THEMEDELETE, layouts[sel].c_str());
if (Rainmeter->ShowMessage(m_Window, text.c_str(), MB_ICONQUESTION | MB_YESNO) != IDYES)
if (g_Rainmeter->ShowMessage(m_Window, text.c_str(), MB_ICONQUESTION | MB_YESNO) != IDYES)
{
// Cancel
break;
}
std::wstring folder = Rainmeter->GetLayoutPath();
std::wstring folder = g_Rainmeter->GetLayoutPath();
folder += layouts[sel];
if (CSystem::RemoveFolder(folder))
if (System::RemoveFolder(folder))
{
ListBox_DeleteString(item, sel);
@@ -1792,13 +1792,13 @@ INT_PTR CDialogManage::CTabLayouts::OnCommand(WPARAM wParam, LPARAM lParam)
** Constructor.
**
*/
CDialogManage::CTabSettings::CTabSettings() : CTab()
DialogManage::TabSettings::TabSettings() : Tab()
{
}
void CDialogManage::CTabSettings::Create(HWND owner)
void DialogManage::TabSettings::Create(HWND owner)
{
CTab::CreateTabWindow(15, 30, 470, 260, owner);
Tab::CreateTabWindow(15, 30, 470, 260, owner);
// FIXME: Temporary hack.
short buttonWidth = (short)_wtoi(GetString(ID_STR_NUM_BUTTONWIDTH));
@@ -1856,12 +1856,12 @@ void CDialogManage::CTabSettings::Create(HWND owner)
CreateControls(s_Controls, _countof(s_Controls), c_Dialog->m_Font, GetString);
}
void CDialogManage::CTabSettings::Initialize()
void DialogManage::TabSettings::Initialize()
{
// Scan for languages
HWND item = GetControl(Id_LanguageDropDownList);
std::wstring files = Rainmeter->GetPath() + L"Languages\\*.dll";
std::wstring files = g_Rainmeter->GetPath() + L"Languages\\*.dll";
WIN32_FIND_DATA fd;
HANDLE hSearch = FindFirstFile(files.c_str(), &fd);
if (hSearch != INVALID_HANDLE_VALUE)
@@ -1886,7 +1886,7 @@ void CDialogManage::CTabSettings::Initialize()
int index = ComboBox_AddString(item, text.c_str());
ComboBox_SetItemData(item, index, (LPARAM)lcid);
if (lcid == Rainmeter->GetResourceLCID())
if (lcid == g_Rainmeter->GetResourceLCID())
{
ComboBox_SetCurSel(item, index);
}
@@ -1898,24 +1898,24 @@ void CDialogManage::CTabSettings::Initialize()
FindClose(hSearch);
}
Button_SetCheck(GetControl(Id_CheckForUpdatesCheckBox), !Rainmeter->GetDisableVersionCheck());
Button_SetCheck(GetControl(Id_LockSkinsCheckBox), Rainmeter->GetDisableDragging());
Button_SetCheck(GetControl(Id_LogToFileCheckBox), CLogger::GetInstance().IsLogToFile());
Button_SetCheck(GetControl(Id_VerboseLoggingCheckbox), Rainmeter->GetDebug());
Button_SetCheck(GetControl(Id_CheckForUpdatesCheckBox), !g_Rainmeter->GetDisableVersionCheck());
Button_SetCheck(GetControl(Id_LockSkinsCheckBox), g_Rainmeter->GetDisableDragging());
Button_SetCheck(GetControl(Id_LogToFileCheckBox), Logger::GetInstance().IsLogToFile());
Button_SetCheck(GetControl(Id_VerboseLoggingCheckbox), g_Rainmeter->GetDebug());
BOOL isLogFile = (_waccess(CLogger::GetInstance().GetLogFilePath().c_str(), 0) != -1);
BOOL isLogFile = (_waccess(Logger::GetInstance().GetLogFilePath().c_str(), 0) != -1);
EnableWindow(GetControl(Id_ShowLogFileButton), isLogFile);
EnableWindow(GetControl(Id_DeleteLogFileButton), isLogFile);
Edit_SetText(GetControl(Id_EditorEdit), Rainmeter->GetSkinEditor().c_str());
Edit_SetText(GetControl(Id_EditorEdit), g_Rainmeter->GetSkinEditor().c_str());
bool iconEnabled = Rainmeter->GetTrayWindow()->IsTrayIconEnabled();
bool iconEnabled = g_Rainmeter->GetTrayWindow()->IsTrayIconEnabled();
Button_SetCheck(GetControl(Id_ShowTrayIconCheckBox), iconEnabled);
m_Initialized = true;
}
INT_PTR CDialogManage::CTabSettings::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::TabSettings::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
@@ -1926,7 +1926,7 @@ INT_PTR CDialogManage::CTabSettings::HandleMessage(UINT uMsg, WPARAM wParam, LPA
return FALSE;
}
INT_PTR CDialogManage::CTabSettings::OnCommand(WPARAM wParam, LPARAM lParam)
INT_PTR DialogManage::TabSettings::OnCommand(WPARAM wParam, LPARAM lParam)
{
if (!m_Initialized)
{
@@ -1940,66 +1940,66 @@ INT_PTR CDialogManage::CTabSettings::OnCommand(WPARAM wParam, LPARAM lParam)
{
int sel = ComboBox_GetCurSel((HWND)lParam);
LCID lcid = (LCID)ComboBox_GetItemData((HWND)lParam, sel);
if (lcid != Rainmeter->m_ResourceLCID)
if (lcid != g_Rainmeter->m_ResourceLCID)
{
WCHAR buffer[16];
_ultow(lcid, buffer, 10);
WritePrivateProfileString(L"Rainmeter", L"Language", buffer, Rainmeter->GetIniFile().c_str());
WritePrivateProfileString(L"Rainmeter", L"Language", buffer, g_Rainmeter->GetIniFile().c_str());
std::wstring resource = Rainmeter->GetPath() + L"Languages\\";
std::wstring resource = g_Rainmeter->GetPath() + L"Languages\\";
resource += buffer;
resource += L".dll";
FreeLibrary(Rainmeter->m_ResourceInstance);
Rainmeter->m_ResourceInstance = LoadLibraryEx(resource.c_str(), NULL, DONT_RESOLVE_DLL_REFERENCES | LOAD_LIBRARY_AS_DATAFILE);
Rainmeter->m_ResourceLCID = lcid;
FreeLibrary(g_Rainmeter->m_ResourceInstance);
g_Rainmeter->m_ResourceInstance = LoadLibraryEx(resource.c_str(), NULL, DONT_RESOLVE_DLL_REFERENCES | LOAD_LIBRARY_AS_DATAFILE);
g_Rainmeter->m_ResourceLCID = lcid;
if (CDialogAbout::GetDialog())
if (DialogAbout::GetDialog())
{
int sel = TabCtrl_GetCurSel(CDialogAbout::GetDialog()->GetControl(CDialogManage::Id_Tab));
SendMessage(CDialogAbout::GetDialog()->GetWindow(), WM_CLOSE, 0, 0);
int sel = TabCtrl_GetCurSel(DialogAbout::GetDialog()->GetControl(DialogManage::Id_Tab));
SendMessage(DialogAbout::GetDialog()->GetWindow(), WM_CLOSE, 0, 0);
if (sel == 0)
{
Rainmeter->DelayedExecuteCommand(L"!About");
g_Rainmeter->DelayedExecuteCommand(L"!About");
}
else if (sel == 1)
{
Rainmeter->DelayedExecuteCommand(L"!About Skins");
g_Rainmeter->DelayedExecuteCommand(L"!About Skins");
}
else if (sel == 2)
{
Rainmeter->DelayedExecuteCommand(L"!About Plugins");
g_Rainmeter->DelayedExecuteCommand(L"!About Plugins");
}
else //if (sel == 3)
{
Rainmeter->DelayedExecuteCommand(L"!About Version");
g_Rainmeter->DelayedExecuteCommand(L"!About Version");
}
}
SendMessage(c_Dialog->GetWindow(), WM_CLOSE, 0, 0);
Rainmeter->DelayedExecuteCommand(L"!Manage Settings");
g_Rainmeter->DelayedExecuteCommand(L"!Manage Settings");
}
}
break;
case Id_CheckForUpdatesCheckBox:
Rainmeter->SetDisableVersionCheck(!Rainmeter->GetDisableVersionCheck());
g_Rainmeter->SetDisableVersionCheck(!g_Rainmeter->GetDisableVersionCheck());
break;
case Id_LockSkinsCheckBox:
Rainmeter->SetDisableDragging(!Rainmeter->GetDisableDragging());
g_Rainmeter->SetDisableDragging(!g_Rainmeter->GetDisableDragging());
break;
case Id_ResetStatisticsButton:
Rainmeter->ResetStats();
g_Rainmeter->ResetStats();
break;
case Id_ShowLogFileButton:
Rainmeter->ShowLogFile();
g_Rainmeter->ShowLogFile();
break;
case Id_DeleteLogFileButton:
CLogger::GetInstance().DeleteLogFile();
if (_waccess(CLogger::GetInstance().GetLogFilePath().c_str(), 0) == -1)
Logger::GetInstance().DeleteLogFile();
if (_waccess(Logger::GetInstance().GetLogFilePath().c_str(), 0) == -1)
{
Button_SetCheck(GetControl(Id_LogToFileCheckBox), BST_UNCHECKED);
EnableWindow(GetControl(Id_ShowLogFileButton), FALSE);
@@ -2008,14 +2008,14 @@ INT_PTR CDialogManage::CTabSettings::OnCommand(WPARAM wParam, LPARAM lParam)
break;
case Id_LogToFileCheckBox:
if (CLogger::GetInstance().IsLogToFile())
if (Logger::GetInstance().IsLogToFile())
{
CLogger::GetInstance().StopLogFile();
Logger::GetInstance().StopLogFile();
}
else
{
CLogger::GetInstance().StartLogFile();
if (_waccess(CLogger::GetInstance().GetLogFilePath().c_str(), 0) != -1)
Logger::GetInstance().StartLogFile();
if (_waccess(Logger::GetInstance().GetLogFilePath().c_str(), 0) != -1)
{
EnableWindow(GetControl(Id_ShowLogFileButton), TRUE);
EnableWindow(GetControl(Id_DeleteLogFileButton), TRUE);
@@ -2024,7 +2024,7 @@ INT_PTR CDialogManage::CTabSettings::OnCommand(WPARAM wParam, LPARAM lParam)
break;
case Id_VerboseLoggingCheckbox:
Rainmeter->SetDebug(!Rainmeter->GetDebug());
g_Rainmeter->SetDebug(!g_Rainmeter->GetDebug());
break;
case Id_EditorEdit:
@@ -2033,7 +2033,7 @@ INT_PTR CDialogManage::CTabSettings::OnCommand(WPARAM wParam, LPARAM lParam)
WCHAR buffer[MAX_PATH];
if (GetWindowText((HWND)lParam, buffer, _countof(buffer)) > 0)
{
Rainmeter->SetSkinEditor(buffer);
g_Rainmeter->SetSkinEditor(buffer);
}
}
break;
@@ -2043,7 +2043,7 @@ INT_PTR CDialogManage::CTabSettings::OnCommand(WPARAM wParam, LPARAM lParam)
WCHAR buffer[MAX_PATH];
buffer[0] = L'\0';
std::wstring editor = Rainmeter->GetSkinEditor();
std::wstring editor = g_Rainmeter->GetSkinEditor();
editor = editor.substr(0, editor.find_last_of(L"/\\")).c_str();
OPENFILENAME ofn = { sizeof(OPENFILENAME) };
@@ -2067,7 +2067,7 @@ INT_PTR CDialogManage::CTabSettings::OnCommand(WPARAM wParam, LPARAM lParam)
break;
case Id_ShowTrayIconCheckBox:
Rainmeter->GetTrayWindow()->SetTrayIcon(!Rainmeter->GetTrayWindow()->IsTrayIconEnabled());
g_Rainmeter->GetTrayWindow()->SetTrayIcon(!g_Rainmeter->GetTrayWindow()->IsTrayIconEnabled());
break;
default:

38
Library/DialogManage.h
View File

@@ -22,19 +22,19 @@
#include "../Common/Dialog.h"
#include "resource.h"
class CDialogManage : public CDialog
class DialogManage : public Dialog
{
public:
CDialogManage();
virtual ~CDialogManage();
DialogManage();
virtual ~DialogManage();
static CDialog* GetDialog() { return c_Dialog; }
static Dialog* GetDialog() { return c_Dialog; }
static void Open(const WCHAR* name);
static void Open(int tab = 0);
static void OpenSkin(CMeterWindow* meterWindow);
static void OpenSkin(MeterWindow* meterWindow);
static void UpdateSkins(CMeterWindow* meterWindow, bool deleted = false);
static void UpdateSkins(MeterWindow* meterWindow, bool deleted = false);
protected:
virtual INT_PTR HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
@@ -44,7 +44,7 @@ protected:
private:
// Skins tab
class CTabSkins : public CTab
class TabSkins : public Tab
{
public:
enum Id
@@ -77,12 +77,12 @@ private:
Id_EditButton = IDM_MANAGESKINSMENU_EDIT
};
CTabSkins();
TabSkins();
void Create(HWND owner);
virtual void Initialize();
void Update(CMeterWindow* meterWindow, bool deleted);
void Update(MeterWindow* meterWindow, bool deleted);
static void SelectTreeItem(HWND tree, HTREEITEM item, LPCWSTR name);
@@ -101,13 +101,13 @@ private:
std::wstring m_SkinFileName;
std::wstring m_SkinFolderPath;
CMeterWindow* m_SkinWindow;
MeterWindow* m_SkinWindow;
bool m_HandleCommands;
bool m_IgnoreUpdate;
};
// Layouts tab
class CTabLayouts : public CTab
class TabLayouts : public Tab
{
public:
enum Id
@@ -123,7 +123,7 @@ private:
Id_NameLabel
};
CTabLayouts();
TabLayouts();
void Create(HWND owner);
virtual void Initialize();
@@ -134,7 +134,7 @@ private:
};
// Settings tab
class CTabSettings : public CTab
class TabSettings : public Tab
{
public:
enum Id
@@ -152,7 +152,7 @@ private:
Id_ShowTrayIconCheckBox
};
CTabSettings();
TabSettings();
void Create(HWND owner);
virtual void Initialize();
@@ -172,14 +172,14 @@ private:
Id_HelpButton
};
CTab& GetActiveTab();
Tab& GetActiveTab();
CTabSkins m_TabSkins;
CTabLayouts m_TabLayouts;
CTabSettings m_TabSettings;
TabSkins m_TabSkins;
TabLayouts m_TabLayouts;
TabSettings m_TabSettings;
static WINDOWPLACEMENT c_WindowPlacement;
static CDialogManage* c_Dialog;
static DialogManage* c_Dialog;
};
#endif

44
Library/Export.cpp
View File

@@ -25,7 +25,7 @@
#define NULLCHECK(str) { if ((str) == NULL) { (str) = L""; } }
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
static std::wstring g_Buffer;
@@ -34,8 +34,8 @@ LPCWSTR __stdcall RmReadString(void* rm, LPCWSTR option, LPCWSTR defValue, BOOL
NULLCHECK(option);
NULLCHECK(defValue);
CMeasurePlugin* measure = (CMeasurePlugin*)rm;
CConfigParser& parser = measure->GetMeterWindow()->GetParser();
MeasurePlugin* measure = (MeasurePlugin*)rm;
ConfigParser& parser = measure->GetMeterWindow()->GetParser();
return parser.ReadString(measure->GetName(), option, defValue, (bool)replaceMeasures).c_str();
}
@@ -43,8 +43,8 @@ double __stdcall RmReadFormula(void* rm, LPCWSTR option, double defValue)
{
NULLCHECK(option);
CMeasurePlugin* measure = (CMeasurePlugin*)rm;
CConfigParser& parser = measure->GetMeterWindow()->GetParser();
MeasurePlugin* measure = (MeasurePlugin*)rm;
ConfigParser& parser = measure->GetMeterWindow()->GetParser();
return parser.ReadFloat(measure->GetName(), option, defValue);
}
@@ -52,7 +52,7 @@ LPCWSTR __stdcall RmPathToAbsolute(void* rm, LPCWSTR relativePath)
{
NULLCHECK(relativePath);
CMeasurePlugin* measure = (CMeasurePlugin*)rm;
MeasurePlugin* measure = (MeasurePlugin*)rm;
g_Buffer = relativePath;
measure->GetMeterWindow()->MakePathAbsolute(g_Buffer);
return g_Buffer.c_str();
@@ -60,7 +60,7 @@ LPCWSTR __stdcall RmPathToAbsolute(void* rm, LPCWSTR relativePath)
void* __stdcall RmGet(void* rm, int type)
{
CMeasurePlugin* measure = (CMeasurePlugin*)rm;
MeasurePlugin* measure = (MeasurePlugin*)rm;
switch (type)
{
@@ -76,19 +76,19 @@ void* __stdcall RmGet(void* rm, int type)
case RMG_SETTINGSFILE:
{
return (void*)Rainmeter->GetDataFile().c_str();
return (void*)g_Rainmeter->GetDataFile().c_str();
}
case RMG_SKINNAME:
{
CMeterWindow* window = measure->GetMeterWindow();
MeterWindow* window = measure->GetMeterWindow();
if (!window) break;
return (void*)window->GetFolderPath().c_str();
}
case RMG_SKINWINDOWHANDLE:
{
CMeterWindow* window = measure->GetMeterWindow();
MeterWindow* window = measure->GetMeterWindow();
if (!window) break;
return (void*)window->GetWindow();
}
@@ -99,11 +99,11 @@ void* __stdcall RmGet(void* rm, int type)
void __stdcall RmExecute(void* skin, LPCWSTR command)
{
CMeterWindow* mw = (CMeterWindow*)skin;
MeterWindow* mw = (MeterWindow*)skin;
if (command)
{
// WM_RAINMETER_EXECUTE used instead of ExecuteCommand for thread-safety
SendMessage(Rainmeter->GetWindow(), WM_RAINMETER_EXECUTE, (WPARAM)mw, (LPARAM)command);
SendMessage(g_Rainmeter->GetWindow(), WM_RAINMETER_EXECUTE, (WPARAM)mw, (LPARAM)command);
}
}
@@ -112,9 +112,9 @@ BOOL LSLog(int nLevel, LPCWSTR unused, LPCWSTR pszMessage)
NULLCHECK(pszMessage);
// Ignore Level::Debug messages from plugins unless in debug mode
if (nLevel != (int)CLogger::Level::Debug || Rainmeter->GetDebug())
if (nLevel != (int)Logger::Level::Debug || g_Rainmeter->GetDebug())
{
CLogger::GetInstance().Log((CLogger::Level)nLevel, pszMessage);
Logger::GetInstance().Log((Logger::Level)nLevel, pszMessage);
}
return TRUE;
@@ -127,7 +127,7 @@ LPCWSTR ReadConfigString(LPCWSTR section, LPCWSTR option, LPCWSTR defValue)
NULLCHECK(option);
NULLCHECK(defValue);
CConfigParser* parser = Rainmeter->GetCurrentParser();
ConfigParser* parser = g_Rainmeter->GetCurrentParser();
if (parser)
{
return parser->ReadString(section, option, defValue, false).c_str();
@@ -148,7 +148,7 @@ LPCWSTR PluginBridge(LPCWSTR command, LPCWSTR data)
if (_wcsicmp(command, L"GetConfig") == 0)
{
CMeterWindow* meterWindow = Rainmeter->GetMeterWindowByINI(data);
MeterWindow* meterWindow = g_Rainmeter->GetMeterWindowByINI(data);
if (meterWindow)
{
g_Buffer = L"\"";
@@ -161,13 +161,13 @@ LPCWSTR PluginBridge(LPCWSTR command, LPCWSTR data)
}
else if (_wcsicmp(command, L"GetWindow") == 0)
{
std::vector<std::wstring> subStrings = CCommandHandler::ParseString(data);
std::vector<std::wstring> subStrings = CommandHandler::ParseString(data);
if (subStrings.size() >= 1)
{
const std::wstring& config = subStrings[0];
CMeterWindow* meterWindow = Rainmeter->GetMeterWindow(config);
MeterWindow* meterWindow = g_Rainmeter->GetMeterWindow(config);
if (meterWindow)
{
WCHAR buf1[64];
@@ -181,13 +181,13 @@ LPCWSTR PluginBridge(LPCWSTR command, LPCWSTR data)
}
else if (_wcsicmp(command, L"GetVariable") == 0)
{
std::vector<std::wstring> subStrings = CCommandHandler::ParseString(data);
std::vector<std::wstring> subStrings = CommandHandler::ParseString(data);
if (subStrings.size() >= 2)
{
const std::wstring& config = subStrings[0];
CMeterWindow* meterWindow = Rainmeter->GetMeterWindow(config);
MeterWindow* meterWindow = g_Rainmeter->GetMeterWindow(config);
if (meterWindow)
{
const std::wstring& variable = subStrings[1];
@@ -204,11 +204,11 @@ LPCWSTR PluginBridge(LPCWSTR command, LPCWSTR data)
}
else if (_wcsicmp(command, L"SetVariable") == 0)
{
std::vector<std::wstring> subStrings = CCommandHandler::ParseString(data);
std::vector<std::wstring> subStrings = CommandHandler::ParseString(data);
if (subStrings.size() == 3)
{
CMeterWindow* meterWindow = Rainmeter->GetMeterWindow(subStrings[0]);
MeterWindow* meterWindow = g_Rainmeter->GetMeterWindow(subStrings[0]);
if (meterWindow)
{
meterWindow->SetVariable(subStrings[1], subStrings[2]);

10
Library/Group.cpp
View File

@@ -20,7 +20,7 @@
#include "Group.h"
#include "ConfigParser.h"
void CGroup::InitializeGroup(const std::wstring& groups)
void Group::InitializeGroup(const std::wstring& groups)
{
if (wcscmp(groups.c_str(), m_OldGroups.c_str()) != 0)
{
@@ -29,7 +29,7 @@ void CGroup::InitializeGroup(const std::wstring& groups)
if (!groups.empty())
{
std::vector<std::wstring> vGroups = CConfigParser::Tokenize(groups, L"|");
std::vector<std::wstring> vGroups = ConfigParser::Tokenize(groups, L"|");
for (auto iter = vGroups.begin(); iter != vGroups.end(); ++iter)
{
m_Groups.insert(CreateGroup(*iter));
@@ -38,18 +38,18 @@ void CGroup::InitializeGroup(const std::wstring& groups)
}
}
bool CGroup::BelongsToGroup(const std::wstring& group) const
bool Group::BelongsToGroup(const std::wstring& group) const
{
return (m_Groups.find(VerifyGroup(group)) != m_Groups.end());
}
std::wstring& CGroup::CreateGroup(std::wstring& str) const
std::wstring& Group::CreateGroup(std::wstring& str) const
{
_wcsupr(&str[0]);
return str;
}
std::wstring CGroup::VerifyGroup(const std::wstring& str) const
std::wstring Group::VerifyGroup(const std::wstring& str) const
{
std::wstring strTmp;

6
Library/Group.h
View File

@@ -22,15 +22,15 @@
#include <string>
#include <unordered_set>
class __declspec(novtable) CGroup
class __declspec(novtable) Group
{
public:
virtual ~CGroup() {}
virtual ~Group() {}
bool BelongsToGroup(const std::wstring& group) const;
protected:
CGroup() {}
Group() {}
void InitializeGroup(const std::wstring& groups);

4
Library/Litestep.cpp
View File

@@ -22,7 +22,7 @@
#include "DialogAbout.h"
#include "System.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
UINT GetUniqueID()
{
@@ -33,7 +33,7 @@ UINT GetUniqueID()
WCHAR* GetString(UINT id)
{
LPWSTR pData;
int len = LoadString(Rainmeter->GetResourceInstance(), id, (LPWSTR)&pData, 0);
int len = LoadString(g_Rainmeter->GetResourceInstance(), id, (LPWSTR)&pData, 0);
return len ? pData : L"";
}

46
Library/Logger.cpp
View File

@@ -24,7 +24,7 @@
#include "System.h"
#include "resource.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
namespace {
@@ -32,26 +32,26 @@ const size_t MAX_LOG_ENTIRES = 20;
} // namespace
CLogger::CLogger() :
Logger::Logger() :
m_LogToFile(false)
{
CSystem::InitializeCriticalSection(&m_CsLog);
CSystem::InitializeCriticalSection(&m_CsLogDelay);
System::InitializeCriticalSection(&m_CsLog);
System::InitializeCriticalSection(&m_CsLogDelay);
}
CLogger::~CLogger()
Logger::~Logger()
{
DeleteCriticalSection(&m_CsLog);
DeleteCriticalSection(&m_CsLogDelay);
}
CLogger& CLogger::GetInstance()
Logger& Logger::GetInstance()
{
static CLogger s_CLogger;
return s_CLogger;
static Logger s_Logger;
return s_Logger;
}
void CLogger::StartLogFile()
void Logger::StartLogFile()
{
const WCHAR* filePath = m_LogFilePath.c_str();
if (_waccess(filePath, 0) == -1)
@@ -65,7 +65,7 @@ void CLogger::StartLogFile()
else
{
const std::wstring text = GetFormattedString(ID_STR_LOGFILECREATEFAIL, filePath);
Rainmeter->ShowMessage(NULL, text.c_str(), MB_OK | MB_ICONERROR);
g_Rainmeter->ShowMessage(NULL, text.c_str(), MB_OK | MB_ICONERROR);
SetLogToFile(false);
return;
}
@@ -74,34 +74,34 @@ void CLogger::StartLogFile()
SetLogToFile(true);
}
void CLogger::StopLogFile()
void Logger::StopLogFile()
{
SetLogToFile(false);
}
void CLogger::DeleteLogFile()
void Logger::DeleteLogFile()
{
const WCHAR* filePath = m_LogFilePath.c_str();
if (_waccess(filePath, 0) != -1)
{
const std::wstring text = GetFormattedString(ID_STR_LOGFILEDELETE, filePath);
const int res = Rainmeter->ShowMessage(NULL, text.c_str(), MB_YESNO | MB_ICONQUESTION);
const int res = g_Rainmeter->ShowMessage(NULL, text.c_str(), MB_YESNO | MB_ICONQUESTION);
if (res == IDYES)
{
SetLogToFile(false);
CSystem::RemoveFile(m_LogFilePath);
System::RemoveFile(m_LogFilePath);
}
}
}
void CLogger::SetLogToFile(bool logToFile)
void Logger::SetLogToFile(bool logToFile)
{
m_LogToFile = logToFile;
WritePrivateProfileString(
L"Rainmeter", L"Logging", logToFile ? L"1" : L"0", Rainmeter->GetIniFile().c_str());
L"Rainmeter", L"Logging", logToFile ? L"1" : L"0", g_Rainmeter->GetIniFile().c_str());
}
void CLogger::LogInternal(Level level, ULONGLONG timestamp, const WCHAR* msg)
void Logger::LogInternal(Level level, ULONGLONG timestamp, const WCHAR* msg)
{
WCHAR timestampSz[128];
size_t len = _snwprintf_s(
@@ -121,11 +121,11 @@ void CLogger::LogInternal(Level level, ULONGLONG timestamp, const WCHAR* msg)
m_Entries.pop_front();
}
CDialogAbout::AddLogItem(level, timestampSz, msg);
DialogAbout::AddLogItem(level, timestampSz, msg);
WriteToLogFile(entry);
}
void CLogger::WriteToLogFile(Entry& entry)
void Logger::WriteToLogFile(Entry& entry)
{
#ifndef _DEBUG
if (!m_LogToFile) return;
@@ -166,7 +166,7 @@ void CLogger::WriteToLogFile(Entry& entry)
}
}
void CLogger::Log(Level level, const WCHAR* msg)
void Logger::Log(Level level, const WCHAR* msg)
{
struct DelayedEntry
{
@@ -176,8 +176,8 @@ void CLogger::Log(Level level, const WCHAR* msg)
};
static std::list<DelayedEntry> s_DelayedEntries;
static ULONGLONG s_StartTime = CSystem::GetTickCount64();
ULONGLONG elapsed = CSystem::GetTickCount64() - s_StartTime;
static ULONGLONG s_StartTime = System::GetTickCount64();
ULONGLONG elapsed = System::GetTickCount64() - s_StartTime;
if (TryEnterCriticalSection(&m_CsLog))
{
@@ -211,7 +211,7 @@ void CLogger::Log(Level level, const WCHAR* msg)
}
}
void CLogger::LogF(Level level, const WCHAR* format, ...)
void Logger::LogF(Level level, const WCHAR* format, ...)
{
WCHAR* buffer = new WCHAR[1024];
va_list args;

14
Library/Logger.h
View File

@@ -24,7 +24,7 @@
#include <list>
// Singleton class to handle and store log messages and control the log file.
class CLogger
class Logger
{
public:
enum class Level
@@ -42,7 +42,7 @@ public:
std::wstring message;
};
static CLogger& GetInstance();
static Logger& GetInstance();
void SetLogFilePath(std::wstring path) { m_LogFilePath = path; }
@@ -66,8 +66,8 @@ private:
// Appends |entry| to the log file.
void WriteToLogFile(Entry& entry);
CLogger();
~CLogger();
Logger();
~Logger();
bool m_LogToFile;
std::wstring m_LogFilePath;
@@ -82,13 +82,13 @@ private:
#define RM_LOGGER_DEFINE_LOG_FUNCTION(name) \
inline void Log ## name(const WCHAR* msg) \
{ \
CLogger::GetInstance().Log(CLogger::Level::name, msg); \
Logger::GetInstance().Log(Logger::Level::name, msg); \
} \
/* \
template<typename... Args> \
inline void Log ## name ## F(const WCHAR* format, Args... args) \
{ \
GetInstance().LogF(CLogger::Level::name, args...); \
GetInstance().LogF(Logger::Level::name, args...); \
}
*/
@@ -99,7 +99,7 @@ RM_LOGGER_DEFINE_LOG_FUNCTION(Debug)
// FIXME: Temporary solution until VS support variadic templates.
#define RM_LOGGER_LOGF_HELPER(name, format, ...) \
CLogger::GetInstance().LogF(CLogger::Level::name, format, __VA_ARGS__)
Logger::GetInstance().LogF(Logger::Level::name, format, __VA_ARGS__)
#define LogErrorF(format, ...) RM_LOGGER_LOGF_HELPER(Error, format, __VA_ARGS__)
#define LogWarningF(format, ...) RM_LOGGER_LOGF_HELPER(Warning, format, __VA_ARGS__)
#define LogNoticeF(format, ...) RM_LOGGER_LOGF_HELPER(Notice, format, __VA_ARGS__)

2
Library/MathParser.cpp
View File

@@ -247,7 +247,7 @@ const WCHAR* MathParser::CheckedParse(const WCHAR* formula, double* result)
return error;
}
const WCHAR* MathParser::Parse(const WCHAR* formula, CMeasureCalc* calc, double* result)
const WCHAR* MathParser::Parse(const WCHAR* formula, MeasureCalc* calc, double* result)
{
static WCHAR errorBuffer[128];

4
Library/MathParser.h
View File

@@ -21,13 +21,13 @@
#ifndef __MATHPARSER_H__
#define __MATHPARSER_H__
class CMeasureCalc;
class MeasureCalc;
namespace MathParser
{
const WCHAR* Check(const WCHAR* formula);
const WCHAR* CheckedParse(const WCHAR* formula, double* result);
const WCHAR* Parse(const WCHAR* formula, CMeasureCalc* calc, double* result);
const WCHAR* Parse(const WCHAR* formula, MeasureCalc* calc, double* result);
bool IsDelimiter(WCHAR ch);
};

86
Library/Measure.cpp
View File

@@ -63,13 +63,13 @@ static const double g_TblScale[2][4] = {
const int MEDIAN_SIZE = 3;
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** The constructor
**
*/
CMeasure::CMeasure(CMeterWindow* meterWindow, const WCHAR* name) : CSection(meterWindow, name),
Measure::Measure(MeterWindow* meterWindow, const WCHAR* name) : Section(meterWindow, name),
m_Invert(false),
m_LogMaxValue(false),
m_MinValue(),
@@ -96,7 +96,7 @@ CMeasure::CMeasure(CMeterWindow* meterWindow, const WCHAR* name) : CSection(mete
** The destructor
**
*/
CMeasure::~CMeasure()
Measure::~Measure()
{
delete m_OldValue;
}
@@ -105,7 +105,7 @@ CMeasure::~CMeasure()
** Initializes the measure.
**
*/
void CMeasure::Initialize()
void Measure::Initialize()
{
m_Initialized = true;
}
@@ -115,11 +115,11 @@ void CMeasure::Initialize()
** call this base implementation if they overwrite this method.
**
*/
void CMeasure::ReadOptions(CConfigParser& parser, const WCHAR* section)
void Measure::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
bool oldOnChangeActionEmpty = m_OnChangeAction.empty();
CSection::ReadOptions(parser, section);
Section::ReadOptions(parser, section);
// Clear substitutes to prevent from being added more than once.
if (!m_Substitute.empty())
@@ -173,7 +173,7 @@ void CMeasure::ReadOptions(CConfigParser& parser, const WCHAR* section)
}
}
void CMeasure::Disable()
void Measure::Disable()
{
m_Disabled = true;
@@ -181,7 +181,7 @@ void CMeasure::Disable()
m_MeterWindow->GetParser().SetValue(m_Name, L"Disabled", L"1");
}
void CMeasure::Enable()
void Measure::Enable()
{
m_Disabled = false;
@@ -192,7 +192,7 @@ void CMeasure::Enable()
/*
** Substitues text using a straight find and replace method
*/
bool CMeasure::MakePlainSubstitute(std::wstring& str, size_t index)
bool Measure::MakePlainSubstitute(std::wstring& str, size_t index)
{
size_t start = 0, pos;
@@ -213,7 +213,7 @@ bool CMeasure::MakePlainSubstitute(std::wstring& str, size_t index)
/*
** Substitutes part of the text
*/
const WCHAR* CMeasure::CheckSubstitute(const WCHAR* buffer)
const WCHAR* Measure::CheckSubstitute(const WCHAR* buffer)
{
static std::wstring str;
@@ -338,7 +338,7 @@ const WCHAR* CMeasure::CheckSubstitute(const WCHAR* buffer)
** Reads the buffer for "Name":"Value"-pairs separated with comma and
** fills the map with the parsed data.
*/
bool CMeasure::ParseSubstitute(std::wstring buffer)
bool Measure::ParseSubstitute(std::wstring buffer)
{
if (buffer.empty()) return true;
@@ -373,7 +373,7 @@ bool CMeasure::ParseSubstitute(std::wstring buffer)
** If not, the separators are ' ', '\t', ',' and ':'. Whitespaces are removed
** and buffer _will_ be modified.
*/
std::wstring CMeasure::ExtractWord(std::wstring& buffer)
std::wstring Measure::ExtractWord(std::wstring& buffer)
{
std::wstring::size_type end, len = buffer.size();
std::wstring ret;
@@ -435,7 +435,7 @@ std::wstring CMeasure::ExtractWord(std::wstring& buffer)
return ret;
}
bool CMeasure::Update()
bool Measure::Update()
{
if (!m_Disabled)
{
@@ -501,7 +501,7 @@ bool CMeasure::Update()
if (!m_IfEqualCommitted)
{
m_IfEqualCommitted = true; // To avoid infinite loop from !Update
Rainmeter->ExecuteCommand(m_IfEqualAction.c_str(), m_MeterWindow);
g_Rainmeter->ExecuteCommand(m_IfEqualAction.c_str(), m_MeterWindow);
}
}
else
@@ -517,7 +517,7 @@ bool CMeasure::Update()
if (!m_IfAboveCommitted)
{
m_IfAboveCommitted = true; // To avoid infinite loop from !Update
Rainmeter->ExecuteCommand(m_IfAboveAction.c_str(), m_MeterWindow);
g_Rainmeter->ExecuteCommand(m_IfAboveAction.c_str(), m_MeterWindow);
}
}
else
@@ -533,7 +533,7 @@ bool CMeasure::Update()
if (!m_IfBelowCommitted)
{
m_IfBelowCommitted = true; // To avoid infinite loop from !Update
Rainmeter->ExecuteCommand(m_IfBelowAction.c_str(), m_MeterWindow);
g_Rainmeter->ExecuteCommand(m_IfBelowAction.c_str(), m_MeterWindow);
}
}
else
@@ -574,7 +574,7 @@ bool CMeasure::Update()
** Returns the value of the measure.
**
*/
double CMeasure::GetValue()
double Measure::GetValue()
{
// Invert if so requested
if (m_Invert)
@@ -589,7 +589,7 @@ double CMeasure::GetValue()
** Returns the relative value of the measure (0.0 - 1.0).
**
*/
double CMeasure::GetRelativeValue()
double Measure::GetRelativeValue()
{
double range = GetValueRange();
@@ -612,7 +612,7 @@ double CMeasure::GetRelativeValue()
** Returns the value range.
**
*/
double CMeasure::GetValueRange()
double Measure::GetValueRange()
{
return m_MaxValue - m_MinValue;
}
@@ -622,7 +622,7 @@ double CMeasure::GetValueRange()
** string value that is not based on m_Value.
**
*/
const WCHAR* CMeasure::GetStringValue()
const WCHAR* Measure::GetStringValue()
{
return NULL;
}
@@ -631,7 +631,7 @@ const WCHAR* CMeasure::GetStringValue()
** Returns the unformatted string value if the measure has one or a formatted value otherwise.
**
*/
const WCHAR* CMeasure::GetStringOrFormattedValue(AUTOSCALE autoScale, double scale, int decimals, bool percentual)
const WCHAR* Measure::GetStringOrFormattedValue(AUTOSCALE autoScale, double scale, int decimals, bool percentual)
{
const WCHAR* stringValue = GetStringValue();
return stringValue ? stringValue : GetFormattedValue(autoScale, scale, decimals, percentual);
@@ -646,7 +646,7 @@ const WCHAR* CMeasure::GetStringOrFormattedValue(AUTOSCALE autoScale, double sca
** decimals Number of decimals used in the value. If -1, get rid of ".00000" for dynamic variables.
** percentual Return the value as % from the maximum value.
*/
const WCHAR* CMeasure::GetFormattedValue(AUTOSCALE autoScale, double scale, int decimals, bool percentual)
const WCHAR* Measure::GetFormattedValue(AUTOSCALE autoScale, double scale, int decimals, bool percentual)
{
static WCHAR buffer[128];
WCHAR format[32];
@@ -681,7 +681,7 @@ const WCHAR* CMeasure::GetFormattedValue(AUTOSCALE autoScale, double scale, int
return CheckSubstitute(buffer);
}
void CMeasure::GetScaledValue(AUTOSCALE autoScale, int decimals, double theValue, WCHAR* buffer, size_t sizeInWords)
void Measure::GetScaledValue(AUTOSCALE autoScale, int decimals, double theValue, WCHAR* buffer, size_t sizeInWords)
{
WCHAR format[32];
double value = 0;
@@ -726,7 +726,7 @@ void CMeasure::GetScaledValue(AUTOSCALE autoScale, int decimals, double theValue
_snwprintf_s(buffer, sizeInWords, _TRUNCATE, format, value);
}
void CMeasure::RemoveTrailingZero(WCHAR* str, int strLen)
void Measure::RemoveTrailingZero(WCHAR* str, int strLen)
{
--strLen;
while (strLen >= 0)
@@ -752,7 +752,7 @@ void CMeasure::RemoveTrailingZero(WCHAR* str, int strLen)
** If execute parameter is set to false, only updates old value with current value.
**
*/
void CMeasure::DoChangeAction(bool execute)
void Measure::DoChangeAction(bool execute)
{
if (!m_OnChangeAction.empty() && m_ValueAssigned)
{
@@ -765,13 +765,13 @@ void CMeasure::DoChangeAction(bool execute)
if (!m_OldValue)
{
m_OldValue = new CMeasureValueSet(newValue, newStringValue);
m_OldValue = new MeasureValueSet(newValue, newStringValue);
}
else if (execute)
{
if (m_OldValue->IsChanged(newValue, newStringValue))
{
Rainmeter->ExecuteCommand(m_OnChangeAction.c_str(), m_MeterWindow);
g_Rainmeter->ExecuteCommand(m_OnChangeAction.c_str(), m_MeterWindow);
}
}
else
@@ -786,65 +786,65 @@ void CMeasure::DoChangeAction(bool execute)
** If new measures are implemented this method needs to be updated.
**
*/
CMeasure* CMeasure::Create(const WCHAR* measure, CMeterWindow* meterWindow, const WCHAR* name)
Measure* Measure::Create(const WCHAR* measure, MeterWindow* meterWindow, const WCHAR* name)
{
// Comparison is caseinsensitive
if (_wcsicmp(L"CPU", measure) == 0)
{
return new CMeasureCPU(meterWindow, name);
return new MeasureCPU(meterWindow, name);
}
else if (_wcsicmp(L"Memory", measure) == 0)
{
return new CMeasureMemory(meterWindow, name);
return new MeasureMemory(meterWindow, name);
}
else if (_wcsicmp(L"NetIn", measure) == 0)
{
return new CMeasureNetIn(meterWindow, name);
return new MeasureNetIn(meterWindow, name);
}
else if (_wcsicmp(L"NetOut", measure) == 0)
{
return new CMeasureNetOut(meterWindow, name);
return new MeasureNetOut(meterWindow, name);
}
else if (_wcsicmp(L"NetTotal", measure) == 0)
{
return new CMeasureNetTotal(meterWindow, name);
return new MeasureNetTotal(meterWindow, name);
}
else if (_wcsicmp(L"PhysicalMemory", measure) == 0)
{
return new CMeasurePhysicalMemory(meterWindow, name);
return new MeasurePhysicalMemory(meterWindow, name);
}
else if (_wcsicmp(L"SwapMemory", measure) == 0)
{
return new CMeasureVirtualMemory(meterWindow, name);
return new MeasureVirtualMemory(meterWindow, name);
}
else if (_wcsicmp(L"FreeDiskSpace", measure) == 0)
{
return new CMeasureDiskSpace(meterWindow, name);
return new MeasureDiskSpace(meterWindow, name);
}
else if (_wcsicmp(L"Uptime", measure) == 0)
{
return new CMeasureUptime(meterWindow, name);
return new MeasureUptime(meterWindow, name);
}
else if (_wcsicmp(L"Time", measure) == 0)
{
return new CMeasureTime(meterWindow, name);
return new MeasureTime(meterWindow, name);
}
else if (_wcsicmp(L"Plugin", measure) == 0)
{
return new CMeasurePlugin(meterWindow, name);
return new MeasurePlugin(meterWindow, name);
}
else if (_wcsicmp(L"Registry", measure) == 0)
{
return new CMeasureRegistry(meterWindow, name);
return new MeasureRegistry(meterWindow, name);
}
else if (_wcsicmp(L"Calc", measure) == 0)
{
return new CMeasureCalc(meterWindow, name);
return new MeasureCalc(meterWindow, name);
}
else if (_wcsicmp(L"Script", measure) == 0)
{
return new CMeasureScript(meterWindow, name);
return new MeasureScript(meterWindow, name);
}
LogErrorF(L"Measure=%s is not valid in [%s]", measure, name);
@@ -856,7 +856,7 @@ CMeasure* CMeasure::Create(const WCHAR* measure, CMeterWindow* meterWindow, cons
** Executes a custom bang.
**
*/
void CMeasure::Command(const std::wstring& command)
void Measure::Command(const std::wstring& command)
{
LogWarningF(L"!CommandMeasure: Not supported by [%s]", m_Name.c_str());
}

24
Library/Measure.h
View File

@@ -37,10 +37,10 @@ enum AUTOSCALE
AUTOSCALE_ON = AUTOSCALE_1024
};
class CMeasureValueSet
class MeasureValueSet
{
public:
CMeasureValueSet(double val, const WCHAR* str) : m_Value(val), m_StringValue(str) {}
MeasureValueSet(double val, const WCHAR* str) : m_Value(val), m_StringValue(str) {}
void Set(double val, const WCHAR* str) { m_Value = val; m_StringValue = str; }
bool IsChanged(double val, const WCHAR* str) { if (m_Value != val || wcscmp(m_StringValue.c_str(), str) != 0) { Set(val, str); return true; } return false; }
private:
@@ -48,16 +48,16 @@ private:
std::wstring m_StringValue;
};
class CMeter;
class CMeterWindow;
class CConfigParser;
class Meter;
class MeterWindow;
class ConfigParser;
class __declspec(novtable) CMeasure : public CSection
class __declspec(novtable) Measure : public Section
{
public:
virtual ~CMeasure();
virtual ~Measure();
void ReadOptions(CConfigParser& parser) { ReadOptions(parser, GetName()); }
void ReadOptions(ConfigParser& parser) { ReadOptions(parser, GetName()); }
virtual void Initialize();
bool Update();
@@ -84,12 +84,12 @@ public:
const std::wstring& GetOnChangeAction() { return m_OnChangeAction; }
void DoChangeAction(bool execute = true);
static CMeasure* Create(const WCHAR* measure, CMeterWindow* meterWindow, const WCHAR* name);
static Measure* Create(const WCHAR* measure, MeterWindow* meterWindow, const WCHAR* name);
protected:
CMeasure(CMeterWindow* meterWindow, const WCHAR* name);
Measure(MeterWindow* meterWindow, const WCHAR* name);
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue() = 0;
bool ParseSubstitute(std::wstring buffer);
@@ -126,7 +126,7 @@ protected:
bool m_Initialized;
std::wstring m_OnChangeAction;
CMeasureValueSet* m_OldValue;
MeasureValueSet* m_OldValue;
bool m_ValueAssigned;
};

22
Library/MeasureCPU.cpp
View File

@@ -38,9 +38,9 @@ typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
#define Li2Double(x) ((double)((x).QuadPart))
#define Ft2Double(x) ((double)((x).dwHighDateTime) * 4.294967296E9 + (double)((x).dwLowDateTime))
FPNTQSI CMeasureCPU::c_NtQuerySystemInformation = NULL;
int CMeasureCPU::c_NumOfProcessors = 0;
ULONG CMeasureCPU::c_BufferSize = 0;
FPNTQSI MeasureCPU::c_NtQuerySystemInformation = NULL;
int MeasureCPU::c_NumOfProcessors = 0;
ULONG MeasureCPU::c_BufferSize = 0;
// ntdll!NtQuerySystemInformation (NT specific!)
//
@@ -64,7 +64,7 @@ ULONG CMeasureCPU::c_BufferSize = 0;
** The constructor
**
*/
CMeasureCPU::CMeasureCPU(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureCPU::MeasureCPU(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_Processor(),
m_OldTime()
{
@@ -75,7 +75,7 @@ CMeasureCPU::CMeasureCPU(CMeterWindow* meterWindow, const WCHAR* name) : CMeasur
** The destructor
**
*/
CMeasureCPU::~CMeasureCPU()
MeasureCPU::~MeasureCPU()
{
}
@@ -83,9 +83,9 @@ CMeasureCPU::~CMeasureCPU()
** Read the options specified in the ini file.
**
*/
void CMeasureCPU::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureCPU::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
int processor = parser.ReadInt(section, L"Processor", 0);
@@ -106,7 +106,7 @@ void CMeasureCPU::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the current CPU utilization value.
**
*/
void CMeasureCPU::UpdateValue()
void MeasureCPU::UpdateValue()
{
if (m_Processor == 0)
{
@@ -194,7 +194,7 @@ void CMeasureCPU::UpdateValue()
** Calculates the current CPU utilization value.
**
*/
void CMeasureCPU::CalcUsage(double idleTime, double systemTime)
void MeasureCPU::CalcUsage(double idleTime, double systemTime)
{
// CurrentCpuUsage% = 100 - ((IdleTime / SystemTime) * 100)
double dbCpuUsage = 100.0 - ((idleTime - m_OldTime[0]) / (systemTime - m_OldTime[1])) * 100.0;
@@ -207,7 +207,7 @@ void CMeasureCPU::CalcUsage(double idleTime, double systemTime)
m_OldTime[1] = systemTime;
}
void CMeasureCPU::InitializeStatic()
void MeasureCPU::InitializeStatic()
{
c_NtQuerySystemInformation = (FPNTQSI)GetProcAddress(GetModuleHandle(L"ntdll"), "NtQuerySystemInformation");
@@ -216,6 +216,6 @@ void CMeasureCPU::InitializeStatic()
c_NumOfProcessors = (int)systemInfo.dwNumberOfProcessors;
}
void CMeasureCPU::FinalizeStatic()
void MeasureCPU::FinalizeStatic()
{
}

10
Library/MeasureCPU.h
View File

@@ -23,19 +23,19 @@
typedef LONG (WINAPI *FPNTQSI)(UINT, PVOID, ULONG, PULONG);
class CMeasureCPU : public CMeasure
class MeasureCPU : public Measure
{
public:
CMeasureCPU(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureCPU();
MeasureCPU(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureCPU();
virtual UINT GetTypeID() { return TypeID<CMeasureCPU>(); }
virtual UINT GetTypeID() { return TypeID<MeasureCPU>(); }
static void InitializeStatic();
static void FinalizeStatic();
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

22
Library/MeasureCalc.cpp
View File

@@ -21,13 +21,13 @@
#include "Rainmeter.h"
#include "MathParser.h"
bool CMeasureCalc::c_RandSeeded = false;
bool MeasureCalc::c_RandSeeded = false;
/*
** The constructor
**
*/
CMeasureCalc::CMeasureCalc(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureCalc::MeasureCalc(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_ParseError(false),
m_LowBound(),
m_HighBound(100),
@@ -46,7 +46,7 @@ CMeasureCalc::CMeasureCalc(CMeterWindow* meterWindow, const WCHAR* name) : CMeas
** The destructor
**
*/
CMeasureCalc::~CMeasureCalc()
MeasureCalc::~MeasureCalc()
{
}
@@ -54,7 +54,7 @@ CMeasureCalc::~CMeasureCalc()
** Updates the calculation
**
*/
void CMeasureCalc::UpdateValue()
void MeasureCalc::UpdateValue()
{
const WCHAR* errMsg = MathParser::Parse(m_Formula.c_str(), this, &m_Value);
if (errMsg != NULL)
@@ -75,9 +75,9 @@ void CMeasureCalc::UpdateValue()
** Read the options specified in the ini file.
**
*/
void CMeasureCalc::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureCalc::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
// Store the current values so we know if the value needs to be updated
int oldLowBound = m_LowBound;
@@ -115,7 +115,7 @@ void CMeasureCalc::ReadOptions(CConfigParser& parser, const WCHAR* section)
** This replaces the word Random in the formula with a random number
**
*/
void CMeasureCalc::FormulaReplace()
void MeasureCalc::FormulaReplace()
{
size_t start = 0, pos;
do
@@ -145,11 +145,11 @@ void CMeasureCalc::FormulaReplace()
while (pos != std::wstring::npos);
}
bool CMeasureCalc::GetMeasureValue(const WCHAR* str, int len, double* value)
bool MeasureCalc::GetMeasureValue(const WCHAR* str, int len, double* value)
{
const std::vector<CMeasure*>& measures = m_MeterWindow->GetMeasures();
const std::vector<Measure*>& measures = m_MeterWindow->GetMeasures();
std::vector<CMeasure*>::const_iterator iter = measures.begin();
std::vector<Measure*>::const_iterator iter = measures.begin();
for ( ; iter != measures.end(); ++iter)
{
if ((*iter)->GetOriginalName().length() == len &&
@@ -174,7 +174,7 @@ bool CMeasureCalc::GetMeasureValue(const WCHAR* str, int len, double* value)
return false;
}
int CMeasureCalc::GetRandom()
int MeasureCalc::GetRandom()
{
double range = (m_HighBound - m_LowBound) + 1;
srand((unsigned)rand());

10
Library/MeasureCalc.h
View File

@@ -21,18 +21,18 @@
#include "Measure.h"
class CMeasureCalc : public CMeasure
class MeasureCalc : public Measure
{
public:
CMeasureCalc(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureCalc();
MeasureCalc(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureCalc();
virtual UINT GetTypeID() { return TypeID<CMeasureCalc>(); }
virtual UINT GetTypeID() { return TypeID<MeasureCalc>(); }
bool GetMeasureValue(const WCHAR* str, int len, double* value);
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

14
Library/MeasureDiskSpace.cpp
View File

@@ -38,7 +38,7 @@ enum DRIVETYPE
** The constructor
**
*/
CMeasureDiskSpace::CMeasureDiskSpace(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureDiskSpace::MeasureDiskSpace(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_Type(false),
m_Total(false),
m_Label(false),
@@ -52,7 +52,7 @@ CMeasureDiskSpace::CMeasureDiskSpace(CMeterWindow* meterWindow, const WCHAR* nam
** The destructor
**
*/
CMeasureDiskSpace::~CMeasureDiskSpace()
MeasureDiskSpace::~MeasureDiskSpace()
{
}
@@ -60,7 +60,7 @@ CMeasureDiskSpace::~CMeasureDiskSpace()
** Updates the current disk free space value.
**
*/
void CMeasureDiskSpace::UpdateValue()
void MeasureDiskSpace::UpdateValue()
{
if (!m_Drive.empty())
{
@@ -164,7 +164,7 @@ void CMeasureDiskSpace::UpdateValue()
** Returns the time as string.
**
*/
const WCHAR* CMeasureDiskSpace::GetStringValue()
const WCHAR* MeasureDiskSpace::GetStringValue()
{
return (m_Type || m_Label) ? CheckSubstitute(m_StringValue.c_str()) : NULL;
}
@@ -173,11 +173,11 @@ const WCHAR* CMeasureDiskSpace::GetStringValue()
** Read the options specified in the ini file.
**
*/
void CMeasureDiskSpace::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureDiskSpace::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
double oldMaxValue = m_MaxValue;
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
m_Drive = parser.ReadString(section, L"Drive", L"C:\\");
if (m_Drive.empty())
@@ -188,7 +188,7 @@ void CMeasureDiskSpace::ReadOptions(CConfigParser& parser, const WCHAR* section)
m_OldTotalBytes = 0;
m_StringValue.clear();
}
else if (!CSystem::IsPathSeparator(m_Drive[m_Drive.length() - 1])) // E.g. "C:"
else if (!System::IsPathSeparator(m_Drive[m_Drive.length() - 1])) // E.g. "C:"
{
m_Drive += L'\\'; // A trailing backslash is required.
}

10
Library/MeasureDiskSpace.h
View File

@@ -21,18 +21,18 @@
#include "Measure.h"
class CMeasureDiskSpace : public CMeasure
class MeasureDiskSpace : public Measure
{
public:
CMeasureDiskSpace(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureDiskSpace();
MeasureDiskSpace(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureDiskSpace();
virtual UINT GetTypeID() { return TypeID<CMeasureDiskSpace>(); }
virtual UINT GetTypeID() { return TypeID<MeasureDiskSpace>(); }
virtual const WCHAR* GetStringValue();
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

10
Library/MeasureMemory.cpp
View File

@@ -24,7 +24,7 @@
** The constructor
**
*/
CMeasureMemory::CMeasureMemory(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureMemory::MeasureMemory(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_Total(false)
{
MEMORYSTATUSEX stat;
@@ -37,7 +37,7 @@ CMeasureMemory::CMeasureMemory(CMeterWindow* meterWindow, const WCHAR* name) : C
** The destructor
**
*/
CMeasureMemory::~CMeasureMemory()
MeasureMemory::~MeasureMemory()
{
}
@@ -45,7 +45,7 @@ CMeasureMemory::~CMeasureMemory()
** Updates the current total memory value.
**
*/
void CMeasureMemory::UpdateValue()
void MeasureMemory::UpdateValue()
{
MEMORYSTATUSEX stat;
stat.dwLength = sizeof(MEMORYSTATUSEX);
@@ -66,10 +66,10 @@ void CMeasureMemory::UpdateValue()
** Read the options specified in the ini file.
**
*/
void CMeasureMemory::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureMemory::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
double oldMaxValue = m_MaxValue;
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
m_MaxValue = oldMaxValue;
m_Total = (1 == parser.ReadInt(section, L"Total", 0));

10
Library/MeasureMemory.h
View File

@@ -21,16 +21,16 @@
#include "Measure.h"
class CMeasureMemory : public CMeasure
class MeasureMemory : public Measure
{
public:
CMeasureMemory(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureMemory();
MeasureMemory(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureMemory();
virtual UINT GetTypeID() { return TypeID<CMeasureMemory>(); }
virtual UINT GetTypeID() { return TypeID<MeasureMemory>(); }
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

58
Library/MeasureNet.cpp
View File

@@ -21,21 +21,21 @@
#include "Rainmeter.h"
#include "System.h"
BYTE* CMeasureNet::c_Table = NULL;
UINT CMeasureNet::c_NumOfTables = 0;
std::vector<ULONG64> CMeasureNet::c_StatValues;
std::vector<ULONG64> CMeasureNet::c_OldStatValues;
BYTE* MeasureNet::c_Table = NULL;
UINT MeasureNet::c_NumOfTables = 0;
std::vector<ULONG64> MeasureNet::c_StatValues;
std::vector<ULONG64> MeasureNet::c_OldStatValues;
FPGETIFTABLE2 CMeasureNet::c_GetIfTable2 = NULL;
FPFREEMIBTABLE CMeasureNet::c_FreeMibTable = NULL;
FPGETIFTABLE2 MeasureNet::c_GetIfTable2 = NULL;
FPFREEMIBTABLE MeasureNet::c_FreeMibTable = NULL;
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** The constructor. This is the base class for the net-meters.
**
*/
CMeasureNet::CMeasureNet(CMeterWindow* meterWindow, const WCHAR* name, NET type) : CMeasure(meterWindow, name),
MeasureNet::MeasureNet(MeterWindow* meterWindow, const WCHAR* name, NET type) : Measure(meterWindow, name),
m_Net(type),
m_Interface(),
m_Octets(),
@@ -48,7 +48,7 @@ CMeasureNet::CMeasureNet(CMeterWindow* meterWindow, const WCHAR* name, NET type)
** The destructor
**
*/
CMeasureNet::~CMeasureNet()
MeasureNet::~MeasureNet()
{
}
@@ -56,7 +56,7 @@ CMeasureNet::~CMeasureNet()
** Reads the tables for all net interfaces
**
*/
void CMeasureNet::UpdateIFTable()
void MeasureNet::UpdateIFTable()
{
bool logging = false;
@@ -78,7 +78,7 @@ void CMeasureNet::UpdateIFTable()
logging = true;
}
if (Rainmeter->GetDebug() && logging)
if (g_Rainmeter->GetDebug() && logging)
{
LogDebug(L"------------------------------");
LogDebugF(L"* NETWORK-INTERFACE: Count=%i", c_NumOfTables);
@@ -171,7 +171,7 @@ void CMeasureNet::UpdateIFTable()
logging = true;
}
if (Rainmeter->GetDebug() && logging)
if (g_Rainmeter->GetDebug() && logging)
{
LogDebug(L"------------------------------");
LogDebugF(L"* NETWORK-INTERFACE: Count=%i", c_NumOfTables);
@@ -226,7 +226,7 @@ void CMeasureNet::UpdateIFTable()
** the net-parameter informs which inherited class called this method.
**
*/
ULONG64 CMeasureNet::GetNetOctets(NET net)
ULONG64 MeasureNet::GetNetOctets(NET net)
{
ULONG64 value = 0;
@@ -343,7 +343,7 @@ ULONG64 CMeasureNet::GetNetOctets(NET net)
** Returns the stats value of the interface
**
*/
ULONG64 CMeasureNet::GetNetStatsValue(NET net)
ULONG64 MeasureNet::GetNetStatsValue(NET net)
{
ULONG64 value = 0;
size_t statsSize = c_StatValues.size() / 2;
@@ -414,7 +414,7 @@ ULONG64 CMeasureNet::GetNetStatsValue(NET net)
** Updates the current value.
**
*/
void CMeasureNet::UpdateValue()
void MeasureNet::UpdateValue()
{
if (c_Table == NULL) return;
@@ -455,9 +455,9 @@ void CMeasureNet::UpdateValue()
** Read the options specified in the ini file.
**
*/
void CMeasureNet::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureNet::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
double value;
const WCHAR* netName = NULL;
@@ -465,17 +465,17 @@ void CMeasureNet::ReadOptions(CConfigParser& parser, const WCHAR* section)
if (m_Net == NET_IN)
{
netName = L"NetInSpeed";
value = Rainmeter->GetGlobalOptions().netInSpeed;
value = g_Rainmeter->GetGlobalOptions().netInSpeed;
}
else if (m_Net == NET_OUT)
{
netName = L"NetOutSpeed";
value = Rainmeter->GetGlobalOptions().netOutSpeed;
value = g_Rainmeter->GetGlobalOptions().netOutSpeed;
}
else // if (m_Net == NET_TOTAL)
{
netName = L"NetTotalSpeed";
value = Rainmeter->GetGlobalOptions().netInSpeed + Rainmeter->GetGlobalOptions().netOutSpeed;
value = g_Rainmeter->GetGlobalOptions().netInSpeed + g_Rainmeter->GetGlobalOptions().netOutSpeed;
}
double maxValue = parser.ReadFloat(section, L"MaxValue", -1);
@@ -493,7 +493,7 @@ void CMeasureNet::ReadOptions(CConfigParser& parser, const WCHAR* section)
m_Cumulative = 0!=parser.ReadInt(section, L"Cumulative", 0);
if (m_Cumulative)
{
Rainmeter->SetNetworkStatisticsTimer();
g_Rainmeter->SetNetworkStatisticsTimer();
}
if (maxValue == 0.0)
@@ -516,7 +516,7 @@ void CMeasureNet::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the statistics.
**
*/
void CMeasureNet::UpdateStats()
void MeasureNet::UpdateStats()
{
if (c_Table)
{
@@ -574,7 +574,7 @@ void CMeasureNet::UpdateStats()
** Resets the statistics.
**
*/
void CMeasureNet::ResetStats()
void MeasureNet::ResetStats()
{
c_StatValues.clear();
}
@@ -583,11 +583,11 @@ void CMeasureNet::ResetStats()
** Reads statistics.
**
*/
void CMeasureNet::ReadStats(const std::wstring& iniFile, std::wstring& statsDate)
void MeasureNet::ReadStats(const std::wstring& iniFile, std::wstring& statsDate)
{
WCHAR buffer[48];
CConfigParser parser;
ConfigParser parser;
parser.Initialize(iniFile, NULL, L"Statistics");
const std::wstring& date = parser.ReadString(L"Statistics", L"Since", L"", false);
@@ -639,7 +639,7 @@ void CMeasureNet::ReadStats(const std::wstring& iniFile, std::wstring& statsDate
** Writes statistics.
**
*/
void CMeasureNet::WriteStats(const WCHAR* iniFile, const std::wstring& statsDate)
void MeasureNet::WriteStats(const WCHAR* iniFile, const std::wstring& statsDate)
{
WCHAR buffer[48];
int len;
@@ -689,7 +689,7 @@ void CMeasureNet::WriteStats(const WCHAR* iniFile, const std::wstring& statsDate
** Prepares in order to use the new APIs which are available on Vista or newer.
**
*/
void CMeasureNet::InitializeStatic()
void MeasureNet::InitializeStatic()
{
if (Platform::IsAtLeastWinVista())
{
@@ -707,7 +707,7 @@ void CMeasureNet::InitializeStatic()
}
}
if (Rainmeter->GetDebug())
if (g_Rainmeter->GetDebug())
{
UpdateIFTable();
}
@@ -717,7 +717,7 @@ void CMeasureNet::InitializeStatic()
** Frees the resources.
**
*/
void CMeasureNet::FinalizeStatic()
void MeasureNet::FinalizeStatic()
{
if (c_GetIfTable2)
{

10
Library/MeasureNet.h
View File

@@ -27,10 +27,10 @@
typedef NETIO_STATUS (NETIOAPI_API_ * FPGETIFTABLE2)(PMIB_IF_TABLE2* Table);
typedef VOID (NETIOAPI_API_ * FPFREEMIBTABLE)(PVOID Memory);
class CMeasureNet : public CMeasure
class MeasureNet : public Measure
{
public:
virtual UINT GetTypeID() { return TypeID<CMeasureNet>(); }
virtual UINT GetTypeID() { return TypeID<MeasureNet>(); }
static void UpdateIFTable();
@@ -50,10 +50,10 @@ protected:
NET_TOTAL
};
CMeasureNet(CMeterWindow* meterWindow, const WCHAR* name, NET type);
virtual ~CMeasureNet();
MeasureNet(MeterWindow* meterWindow, const WCHAR* name, NET type);
virtual ~MeasureNet();
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

4
Library/MeasureNetIn.cpp
View File

@@ -23,7 +23,7 @@
** The constructor
**
*/
CMeasureNetIn::CMeasureNetIn(CMeterWindow* meterWindow, const WCHAR* name) : CMeasureNet(meterWindow, name, NET_IN)
MeasureNetIn::MeasureNetIn(MeterWindow* meterWindow, const WCHAR* name) : MeasureNet(meterWindow, name, NET_IN)
{
}
@@ -31,6 +31,6 @@ CMeasureNetIn::CMeasureNetIn(CMeterWindow* meterWindow, const WCHAR* name) : CMe
** The destructor
**
*/
CMeasureNetIn::~CMeasureNetIn()
MeasureNetIn::~MeasureNetIn()
{
}

6
Library/MeasureNetIn.h
View File

@@ -21,11 +21,11 @@
#include "MeasureNet.h"
class CMeasureNetIn : public CMeasureNet
class MeasureNetIn : public MeasureNet
{
public:
CMeasureNetIn(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureNetIn();
MeasureNetIn(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureNetIn();
};
#endif

4
Library/MeasureNetOut.cpp
View File

@@ -23,7 +23,7 @@
** The constructor
**
*/
CMeasureNetOut::CMeasureNetOut(CMeterWindow* meterWindow, const WCHAR* name) : CMeasureNet(meterWindow, name, NET_OUT)
MeasureNetOut::MeasureNetOut(MeterWindow* meterWindow, const WCHAR* name) : MeasureNet(meterWindow, name, NET_OUT)
{
}
@@ -31,6 +31,6 @@ CMeasureNetOut::CMeasureNetOut(CMeterWindow* meterWindow, const WCHAR* name) : C
** The destructor
**
*/
CMeasureNetOut::~CMeasureNetOut()
MeasureNetOut::~MeasureNetOut()
{
}

6
Library/MeasureNetOut.h
View File

@@ -21,11 +21,11 @@
#include "MeasureNet.h"
class CMeasureNetOut : public CMeasureNet
class MeasureNetOut : public MeasureNet
{
public:
CMeasureNetOut(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureNetOut();
MeasureNetOut(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureNetOut();
};
#endif

4
Library/MeasureNetTotal.cpp
View File

@@ -23,7 +23,7 @@
** The constructor
**
*/
CMeasureNetTotal::CMeasureNetTotal(CMeterWindow* meterWindow, const WCHAR* name) : CMeasureNet(meterWindow, name, NET_TOTAL)
MeasureNetTotal::MeasureNetTotal(MeterWindow* meterWindow, const WCHAR* name) : MeasureNet(meterWindow, name, NET_TOTAL)
{
}
@@ -31,6 +31,6 @@ CMeasureNetTotal::CMeasureNetTotal(CMeterWindow* meterWindow, const WCHAR* name)
** The destructor
**
*/
CMeasureNetTotal::~CMeasureNetTotal()
MeasureNetTotal::~MeasureNetTotal()
{
}

6
Library/MeasureNetTotal.h
View File

@@ -21,11 +21,11 @@
#include "MeasureNet.h"
class CMeasureNetTotal : public CMeasureNet
class MeasureNetTotal : public MeasureNet
{
public:
CMeasureNetTotal(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureNetTotal();
MeasureNetTotal(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureNetTotal();
};
#endif

10
Library/MeasurePhysicalMemory.cpp
View File

@@ -24,7 +24,7 @@
** The constructor
**
*/
CMeasurePhysicalMemory::CMeasurePhysicalMemory(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasurePhysicalMemory::MeasurePhysicalMemory(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_Total(false)
{
MEMORYSTATUSEX stat;
@@ -37,7 +37,7 @@ CMeasurePhysicalMemory::CMeasurePhysicalMemory(CMeterWindow* meterWindow, const
** The destructor
**
*/
CMeasurePhysicalMemory::~CMeasurePhysicalMemory()
MeasurePhysicalMemory::~MeasurePhysicalMemory()
{
}
@@ -45,7 +45,7 @@ CMeasurePhysicalMemory::~CMeasurePhysicalMemory()
** Updates the current physical memory value.
**
*/
void CMeasurePhysicalMemory::UpdateValue()
void MeasurePhysicalMemory::UpdateValue()
{
if (!m_Total)
{
@@ -61,10 +61,10 @@ void CMeasurePhysicalMemory::UpdateValue()
** Read the options specified in the ini file.
**
*/
void CMeasurePhysicalMemory::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasurePhysicalMemory::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
double oldMaxValue = m_MaxValue;
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
m_MaxValue = oldMaxValue;
m_Total = (1 == parser.ReadInt(section, L"Total", 0));

10
Library/MeasurePhysicalMemory.h
View File

@@ -21,16 +21,16 @@
#include "Measure.h"
class CMeasurePhysicalMemory : public CMeasure
class MeasurePhysicalMemory : public Measure
{
public:
CMeasurePhysicalMemory(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasurePhysicalMemory();
MeasurePhysicalMemory(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasurePhysicalMemory();
virtual UINT GetTypeID() { return TypeID<CMeasurePhysicalMemory>(); }
virtual UINT GetTypeID() { return TypeID<MeasurePhysicalMemory>(); }
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

32
Library/MeasurePlugin.cpp
View File

@@ -23,13 +23,13 @@
#include "System.h"
#include "Error.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** The constructor
**
*/
CMeasurePlugin::CMeasurePlugin(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasurePlugin::MeasurePlugin(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_Plugin(),
m_ReloadFunc(),
m_ID(),
@@ -45,7 +45,7 @@ CMeasurePlugin::CMeasurePlugin(CMeterWindow* meterWindow, const WCHAR* name) : C
** The destructor
**
*/
CMeasurePlugin::~CMeasurePlugin()
MeasurePlugin::~MeasurePlugin()
{
if (m_Plugin)
{
@@ -70,7 +70,7 @@ CMeasurePlugin::~CMeasurePlugin()
** Gets the current value from the plugin
**
*/
void CMeasurePlugin::UpdateValue()
void MeasurePlugin::UpdateValue()
{
if (m_UpdateFunc)
{
@@ -91,7 +91,7 @@ void CMeasurePlugin::UpdateValue()
}
// Reset to default
CSystem::ResetWorkingDirectory();
System::ResetWorkingDirectory();
}
}
@@ -99,11 +99,11 @@ void CMeasurePlugin::UpdateValue()
** Reads the options and loads the plugin
**
*/
void CMeasurePlugin::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasurePlugin::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
static UINT id = 0;
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
if (m_Initialized)
{
@@ -129,17 +129,17 @@ void CMeasurePlugin::ReadOptions(CConfigParser& parser, const WCHAR* section)
}
// First try from program path
std::wstring pluginFile = Rainmeter->GetPluginPath();
std::wstring pluginFile = g_Rainmeter->GetPluginPath();
pluginFile += pluginName;
m_Plugin = CSystem::RmLoadLibrary(pluginFile.c_str());
m_Plugin = System::RmLoadLibrary(pluginFile.c_str());
if (!m_Plugin)
{
if (Rainmeter->HasUserPluginPath())
if (g_Rainmeter->HasUserPluginPath())
{
// Try from settings path
pluginFile = Rainmeter->GetUserPluginPath();
pluginFile = g_Rainmeter->GetUserPluginPath();
pluginFile += pluginName;
m_Plugin = CSystem::RmLoadLibrary(pluginFile.c_str());
m_Plugin = System::RmLoadLibrary(pluginFile.c_str());
}
if (!m_Plugin)
{
@@ -204,7 +204,7 @@ void CMeasurePlugin::ReadOptions(CConfigParser& parser, const WCHAR* section)
// Reset to default
SetDllDirectory(L"");
CSystem::ResetWorkingDirectory();
System::ResetWorkingDirectory();
++id;
}
@@ -213,7 +213,7 @@ void CMeasurePlugin::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Gets the string value from the plugin.
**
*/
const WCHAR* CMeasurePlugin::GetStringValue()
const WCHAR* MeasurePlugin::GetStringValue()
{
if (m_GetStringFunc)
{
@@ -237,7 +237,7 @@ const WCHAR* CMeasurePlugin::GetStringValue()
** Sends a bang to the plugin
**
*/
void CMeasurePlugin::Command(const std::wstring& command)
void MeasurePlugin::Command(const std::wstring& command)
{
if (m_ExecuteBangFunc)
{
@@ -253,6 +253,6 @@ void CMeasurePlugin::Command(const std::wstring& command)
}
else
{
CMeasure::Command(command);
Measure::Command(command);
}
}

10
Library/MeasurePlugin.h
View File

@@ -36,19 +36,19 @@ typedef double (*NEWUPDATE)(void*);
typedef LPCWSTR (*NEWGETSTRING)(void*);
typedef void (*NEWEXECUTEBANG)(void*, LPCWSTR);
class CMeasurePlugin : public CMeasure
class MeasurePlugin : public Measure
{
public:
CMeasurePlugin(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasurePlugin();
MeasurePlugin(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasurePlugin();
virtual UINT GetTypeID() { return TypeID<CMeasurePlugin>(); }
virtual UINT GetTypeID() { return TypeID<MeasurePlugin>(); }
virtual const WCHAR* GetStringValue();
virtual void Command(const std::wstring& command);
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

12
Library/MeasureRegistry.cpp
View File

@@ -25,7 +25,7 @@
** The constructor
**
*/
CMeasureRegistry::CMeasureRegistry(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureRegistry::MeasureRegistry(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_RegKey(),
m_HKey(HKEY_CURRENT_USER)
{
@@ -36,7 +36,7 @@ CMeasureRegistry::CMeasureRegistry(CMeterWindow* meterWindow, const WCHAR* name)
** The destructor
**
*/
CMeasureRegistry::~CMeasureRegistry()
MeasureRegistry::~MeasureRegistry()
{
if (m_RegKey) RegCloseKey(m_RegKey);
}
@@ -45,7 +45,7 @@ CMeasureRegistry::~CMeasureRegistry()
** Gets the current value from the registry
**
*/
void CMeasureRegistry::UpdateValue()
void MeasureRegistry::UpdateValue()
{
if (m_RegKey != NULL)
{
@@ -104,9 +104,9 @@ void CMeasureRegistry::UpdateValue()
** Read the options specified in the ini file.
**
*/
void CMeasureRegistry::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureRegistry::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
const WCHAR* keyname = parser.ReadString(section, L"RegHKey", L"HKEY_CURRENT_USER").c_str();
if (_wcsicmp(keyname, L"HKEY_CURRENT_USER") == 0)
@@ -157,7 +157,7 @@ void CMeasureRegistry::ReadOptions(CConfigParser& parser, const WCHAR* section)
** value to string as normal.
**
*/
const WCHAR* CMeasureRegistry::GetStringValue()
const WCHAR* MeasureRegistry::GetStringValue()
{
return !m_StringValue.empty() ? CheckSubstitute(m_StringValue.c_str()) : NULL;
}

10
Library/MeasureRegistry.h
View File

@@ -21,18 +21,18 @@
#include "Measure.h"
class CMeasureRegistry : public CMeasure
class MeasureRegistry : public Measure
{
public:
CMeasureRegistry(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureRegistry();
MeasureRegistry(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureRegistry();
virtual UINT GetTypeID() { return TypeID<CMeasureRegistry>(); }
virtual UINT GetTypeID() { return TypeID<MeasureRegistry>(); }
virtual const WCHAR* GetStringValue();
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

24
Library/MeasureScript.cpp
View File

@@ -28,7 +28,7 @@ const char* g_GetStringFunctionName = "GetStringValue";
** The constructor
**
*/
CMeasureScript::CMeasureScript(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureScript::MeasureScript(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_HasUpdateFunction(false),
m_HasGetStringFunction(false),
m_ValueType(LUA_TNIL)
@@ -40,13 +40,13 @@ CMeasureScript::CMeasureScript(CMeterWindow* meterWindow, const WCHAR* name) : C
** The destructor
**
*/
CMeasureScript::~CMeasureScript()
MeasureScript::~MeasureScript()
{
UninitializeLuaScript();
LuaManager::Finalize();
}
void CMeasureScript::UninitializeLuaScript()
void MeasureScript::UninitializeLuaScript()
{
m_LuaScript.Uninitialize();
@@ -58,7 +58,7 @@ void CMeasureScript::UninitializeLuaScript()
** Runs the function "Update()" in the script.
**
*/
void CMeasureScript::UpdateValue()
void MeasureScript::UpdateValue()
{
if (m_HasUpdateFunction)
{
@@ -76,7 +76,7 @@ void CMeasureScript::UpdateValue()
** Returns the value as a string.
**
*/
const WCHAR* CMeasureScript::GetStringValue()
const WCHAR* MeasureScript::GetStringValue()
{
return (m_ValueType == LUA_TSTRING) ? CheckSubstitute(m_StringValue.c_str()) : NULL;
}
@@ -85,9 +85,9 @@ const WCHAR* CMeasureScript::GetStringValue()
** Read the options specified in the ini file.
**
*/
void CMeasureScript::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureScript::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
std::wstring scriptFile = parser.ReadString(section, L"ScriptFile", L"");
if (!scriptFile.empty())
@@ -116,13 +116,13 @@ void CMeasureScript::ReadOptions(CConfigParser& parser, const WCHAR* section)
lua_rawgeti(L, LUA_GLOBALSINDEX, m_LuaScript.GetRef());
*(CMeterWindow**)lua_newuserdata(L, sizeof(CMeterWindow*)) = m_MeterWindow;
lua_getglobal(L, "CMeterWindow");
*(MeterWindow**)lua_newuserdata(L, sizeof(MeterWindow*)) = m_MeterWindow;
lua_getglobal(L, "MeterWindow");
lua_setmetatable(L, -2);
lua_setfield(L, -2, "SKIN");
*(CMeasure**)lua_newuserdata(L, sizeof(CMeasure*)) = this;
lua_getglobal(L, "CMeasure");
*(Measure**)lua_newuserdata(L, sizeof(Measure*)) = this;
lua_getglobal(L, "Measure");
lua_setmetatable(L, -2);
lua_setfield(L, -2, "SELF");
@@ -179,7 +179,7 @@ void CMeasureScript::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Executes a custom bang.
**
*/
void CMeasureScript::Command(const std::wstring& command)
void MeasureScript::Command(const std::wstring& command)
{
std::string str = StringUtil::Narrow(command);
m_LuaScript.RunString(str.c_str());

10
Library/MeasureScript.h
View File

@@ -21,13 +21,13 @@
#include "lua/LuaScript.h"
#include "MeterWindow.h"
class CMeasureScript : public CMeasure
class MeasureScript : public Measure
{
public:
CMeasureScript(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureScript();
MeasureScript(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureScript();
virtual UINT GetTypeID() { return TypeID<CMeasureScript>(); }
virtual UINT GetTypeID() { return TypeID<MeasureScript>(); }
virtual const WCHAR* GetStringValue();
virtual void Command(const std::wstring& command);
@@ -35,7 +35,7 @@ public:
void UninitializeLuaScript();
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

16
Library/MeasureTime.cpp
View File

@@ -37,7 +37,7 @@ int GetYearDay(int year, int month, int day)
** The constructor
**
*/
CMeasureTime::CMeasureTime(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureTime::MeasureTime(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_DeltaTime(),
m_Time(),
m_TimeStamp(-1)
@@ -53,7 +53,7 @@ CMeasureTime::CMeasureTime(CMeterWindow* meterWindow, const WCHAR* name) : CMeas
** The destructor
**
*/
CMeasureTime::~CMeasureTime()
MeasureTime::~MeasureTime()
{
}
@@ -62,7 +62,7 @@ CMeasureTime::~CMeasureTime()
** This function is a wrapper function for wcsftime.
**
*/
void CMeasureTime::TimeToString(WCHAR* buf, size_t bufLen, const WCHAR* format, const struct tm* time)
void MeasureTime::TimeToString(WCHAR* buf, size_t bufLen, const WCHAR* format, const struct tm* time)
{
if (bufLen > 0)
{
@@ -81,7 +81,7 @@ void CMeasureTime::TimeToString(WCHAR* buf, size_t bufLen, const WCHAR* format,
}
}
void CMeasureTime::FillCurrentTime()
void MeasureTime::FillCurrentTime()
{
if (m_TimeStamp < 0.0)
{
@@ -105,7 +105,7 @@ void CMeasureTime::FillCurrentTime()
** Updates the current time
**
*/
void CMeasureTime::UpdateValue()
void MeasureTime::UpdateValue()
{
FillCurrentTime();
@@ -163,7 +163,7 @@ void CMeasureTime::UpdateValue()
** Returns the time as string.
**
*/
const WCHAR* CMeasureTime::GetStringValue()
const WCHAR* MeasureTime::GetStringValue()
{
static WCHAR tmpSz[MAX_LINE_LENGTH];
struct tm today;
@@ -216,9 +216,9 @@ const WCHAR* CMeasureTime::GetStringValue()
** Read the options specified in the ini file.
**
*/
void CMeasureTime::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureTime::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
m_Format = parser.ReadString(section, L"Format", L"");

10
Library/MeasureTime.h
View File

@@ -21,18 +21,18 @@
#include "Measure.h"
class CMeasureTime : public CMeasure
class MeasureTime : public Measure
{
public:
CMeasureTime(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureTime();
MeasureTime(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureTime();
virtual UINT GetTypeID() { return TypeID<CMeasureTime>(); }
virtual UINT GetTypeID() { return TypeID<MeasureTime>(); }
virtual const WCHAR* GetStringValue();
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

14
Library/MeasureUptime.cpp
View File

@@ -25,7 +25,7 @@
** The constructor
**
*/
CMeasureUptime::CMeasureUptime(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureUptime::MeasureUptime(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_AddDaysToHours(false)
{
}
@@ -34,7 +34,7 @@ CMeasureUptime::CMeasureUptime(CMeterWindow* meterWindow, const WCHAR* name) : C
** The destructor
**
*/
CMeasureUptime::~CMeasureUptime()
MeasureUptime::~MeasureUptime()
{
}
@@ -42,9 +42,9 @@ CMeasureUptime::~CMeasureUptime()
** Read the options specified in the ini file.
**
*/
void CMeasureUptime::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureUptime::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
m_Format = parser.ReadString(section, L"Format", L"%4!i!d %3!i!:%2!02i!");
@@ -62,9 +62,9 @@ void CMeasureUptime::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the current uptime
**
*/
void CMeasureUptime::UpdateValue()
void MeasureUptime::UpdateValue()
{
ULONGLONG ticks = CSystem::GetTickCount64();
ULONGLONG ticks = System::GetTickCount64();
m_Value = (double)(__int64)(ticks / 1000);
}
@@ -72,7 +72,7 @@ void CMeasureUptime::UpdateValue()
** Returns the uptime as string.
**
*/
const WCHAR* CMeasureUptime::GetStringValue()
const WCHAR* MeasureUptime::GetStringValue()
{
static WCHAR buffer[MAX_LINE_LENGTH];

10
Library/MeasureUptime.h
View File

@@ -21,18 +21,18 @@
#include "Measure.h"
class CMeasureUptime : public CMeasure
class MeasureUptime : public Measure
{
public:
CMeasureUptime(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureUptime();
MeasureUptime(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureUptime();
virtual UINT GetTypeID() { return TypeID<CMeasureUptime>(); }
virtual UINT GetTypeID() { return TypeID<MeasureUptime>(); }
virtual const WCHAR* GetStringValue();
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

10
Library/MeasureVirtualMemory.cpp
View File

@@ -24,7 +24,7 @@
** The constructor
**
*/
CMeasureVirtualMemory::CMeasureVirtualMemory(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
MeasureVirtualMemory::MeasureVirtualMemory(MeterWindow* meterWindow, const WCHAR* name) : Measure(meterWindow, name),
m_Total(false)
{
MEMORYSTATUSEX stat;
@@ -37,7 +37,7 @@ CMeasureVirtualMemory::CMeasureVirtualMemory(CMeterWindow* meterWindow, const WC
** The destructor
**
*/
CMeasureVirtualMemory::~CMeasureVirtualMemory()
MeasureVirtualMemory::~MeasureVirtualMemory()
{
}
@@ -45,7 +45,7 @@ CMeasureVirtualMemory::~CMeasureVirtualMemory()
** Updates the current virtual memory value.
**
*/
void CMeasureVirtualMemory::UpdateValue()
void MeasureVirtualMemory::UpdateValue()
{
MEMORYSTATUSEX stat;
stat.dwLength = sizeof(MEMORYSTATUSEX);
@@ -66,10 +66,10 @@ void CMeasureVirtualMemory::UpdateValue()
** Read the options specified in the ini file.
**
*/
void CMeasureVirtualMemory::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeasureVirtualMemory::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
double oldMaxValue = m_MaxValue;
CMeasure::ReadOptions(parser, section);
Measure::ReadOptions(parser, section);
m_MaxValue = oldMaxValue;
m_Total = (1 == parser.ReadInt(section, L"Total", 0));

10
Library/MeasureVirtualMemory.h
View File

@@ -21,16 +21,16 @@
#include "Measure.h"
class CMeasureVirtualMemory : public CMeasure
class MeasureVirtualMemory : public Measure
{
public:
CMeasureVirtualMemory(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeasureVirtualMemory();
MeasureVirtualMemory(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeasureVirtualMemory();
virtual UINT GetTypeID() { return TypeID<CMeasureVirtualMemory>(); }
virtual UINT GetTypeID() { return TypeID<MeasureVirtualMemory>(); }
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void UpdateValue();
private:

72
Library/Meter.cpp
View File

@@ -34,13 +34,13 @@
using namespace Gdiplus;
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** The constructor
**
*/
CMeter::CMeter(CMeterWindow* meterWindow, const WCHAR* name) : CSection(meterWindow, name),
Meter::Meter(MeterWindow* meterWindow, const WCHAR* name) : Section(meterWindow, name),
m_X(),
m_Y(),
m_W(0),
@@ -70,7 +70,7 @@ CMeter::CMeter(CMeterWindow* meterWindow, const WCHAR* name) : CSection(meterWin
** The destructor
**
*/
CMeter::~CMeter()
Meter::~Meter()
{
delete m_Transformation;
@@ -85,7 +85,7 @@ CMeter::~CMeter()
** classes, which load bitmaps and such things during initialization.
**
*/
void CMeter::Initialize()
void Meter::Initialize()
{
m_Initialized = true;
}
@@ -94,7 +94,7 @@ void CMeter::Initialize()
** Returns the X-position of the meter.
**
*/
int CMeter::GetX(bool abs)
int Meter::GetX(bool abs)
{
if (m_RelativeX != POSITION_ABSOLUTE && m_RelativeMeter)
{
@@ -114,7 +114,7 @@ int CMeter::GetX(bool abs)
** Returns the Y-position of the meter.
**
*/
int CMeter::GetY(bool abs)
int Meter::GetY(bool abs)
{
if (m_RelativeY != POSITION_ABSOLUTE && m_RelativeMeter)
{
@@ -130,7 +130,7 @@ int CMeter::GetY(bool abs)
return m_Y;
}
void CMeter::SetX(int x)
void Meter::SetX(int x)
{
m_X = x;
m_RelativeX = POSITION_ABSOLUTE;
@@ -141,7 +141,7 @@ void CMeter::SetX(int x)
m_MeterWindow->GetParser().SetValue(m_Name, L"X", buffer);
}
void CMeter::SetY(int y)
void Meter::SetY(int y)
{
m_Y = y;
m_RelativeY = POSITION_ABSOLUTE;
@@ -156,7 +156,7 @@ void CMeter::SetY(int y)
** Returns a RECT containing the dimensions of the meter within the MeterWindow
**
*/
RECT CMeter::GetMeterRect()
RECT Meter::GetMeterRect()
{
RECT meterRect;
@@ -173,7 +173,7 @@ RECT CMeter::GetMeterRect()
** This function doesn't check Hidden state, so check it before calling this function if needed.
**
*/
bool CMeter::HitTest(int x, int y)
bool Meter::HitTest(int x, int y)
{
int p;
return (x >= (p = GetX()) && x < p + m_W && y >= (p = GetY()) && y < p + m_H);
@@ -183,7 +183,7 @@ bool CMeter::HitTest(int x, int y)
** Shows the meter and tooltip.
**
*/
void CMeter::Show()
void Meter::Show()
{
m_Hidden = false;
@@ -203,7 +203,7 @@ void CMeter::Show()
** Hides the meter and tooltip.
**
*/
void CMeter::Hide()
void Meter::Hide()
{
m_Hidden = true;
@@ -221,7 +221,7 @@ void CMeter::Hide()
** call this base implementation if they overwrite this method.
**
*/
void CMeter::ReadOptions(CConfigParser& parser, const WCHAR* section)
void Meter::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
// The MeterStyle defines a template where the values are read if the meter doesn't have it itself
const std::wstring& style = parser.ReadString(section, L"MeterStyle", L"");
@@ -230,7 +230,7 @@ void CMeter::ReadOptions(CConfigParser& parser, const WCHAR* section)
parser.SetStyleTemplate(style);
}
CSection::ReadOptions(parser, section);
Section::ReadOptions(parser, section);
BindMeasures(parser, section);
@@ -360,7 +360,7 @@ void CMeter::ReadOptions(CConfigParser& parser, const WCHAR* section)
** several meters but one meter and only be bound to one measure.
**
*/
void CMeter::BindMeasures(CConfigParser& parser, const WCHAR* section)
void Meter::BindMeasures(ConfigParser& parser, const WCHAR* section)
{
BindPrimaryMeasure(parser, section, false);
}
@@ -370,43 +370,43 @@ void CMeter::BindMeasures(CConfigParser& parser, const WCHAR* section)
** If new meters are implemented this method needs to be updated.
**
*/
CMeter* CMeter::Create(const WCHAR* meter, CMeterWindow* meterWindow, const WCHAR* name)
Meter* Meter::Create(const WCHAR* meter, MeterWindow* meterWindow, const WCHAR* name)
{
if (_wcsicmp(L"STRING", meter) == 0)
{
return new CMeterString(meterWindow, name);
return new MeterString(meterWindow, name);
}
else if (_wcsicmp(L"IMAGE", meter) == 0)
{
return new CMeterImage(meterWindow, name);
return new MeterImage(meterWindow, name);
}
else if (_wcsicmp(L"HISTOGRAM", meter) == 0)
{
return new CMeterHistogram(meterWindow, name);
return new MeterHistogram(meterWindow, name);
}
else if (_wcsicmp(L"BAR", meter) == 0)
{
return new CMeterBar(meterWindow, name);
return new MeterBar(meterWindow, name);
}
else if (_wcsicmp(L"BITMAP", meter) == 0)
{
return new CMeterBitmap(meterWindow, name);
return new MeterBitmap(meterWindow, name);
}
else if (_wcsicmp(L"LINE", meter) == 0)
{
return new CMeterLine(meterWindow, name);
return new MeterLine(meterWindow, name);
}
else if (_wcsicmp(L"ROUNDLINE", meter) == 0)
{
return new CMeterRoundLine(meterWindow, name);
return new MeterRoundLine(meterWindow, name);
}
else if (_wcsicmp(L"ROTATOR", meter) == 0)
{
return new CMeterRotator(meterWindow, name);
return new MeterRotator(meterWindow, name);
}
else if (_wcsicmp(L"BUTTON", meter) == 0)
{
return new CMeterButton(meterWindow, name);
return new MeterButton(meterWindow, name);
}
LogErrorF(L"Meter=%s is not valid in [%s]", meter, name);
@@ -418,7 +418,7 @@ CMeter* CMeter::Create(const WCHAR* meter, CMeterWindow* meterWindow, const WCHA
** Updates the value(s) from the measures. Derived classes should
** only update if this returns true;
*/
bool CMeter::Update()
bool Meter::Update()
{
// Only update the meter's value when the divider is equal to the counter
return UpdateCounter();
@@ -429,13 +429,13 @@ bool CMeter::Update()
** BindMeasures() implementations.
**
*/
bool CMeter::BindPrimaryMeasure(CConfigParser& parser, const WCHAR* section, bool optional)
bool Meter::BindPrimaryMeasure(ConfigParser& parser, const WCHAR* section, bool optional)
{
m_Measures.clear();
const std::wstring& measureName = parser.ReadString(section, L"MeasureName", L"");
CMeasure* measure = parser.GetMeasure(measureName);
Measure* measure = parser.GetMeasure(measureName);
if (measure)
{
m_Measures.push_back(measure);
@@ -453,7 +453,7 @@ bool CMeter::BindPrimaryMeasure(CConfigParser& parser, const WCHAR* section, boo
** Reads and binds secondary measures (MeasureName2 - MeasureNameN).
**
*/
void CMeter::BindSecondaryMeasures(CConfigParser& parser, const WCHAR* section)
void Meter::BindSecondaryMeasures(ConfigParser& parser, const WCHAR* section)
{
if (!m_Measures.empty())
{
@@ -464,7 +464,7 @@ void CMeter::BindSecondaryMeasures(CConfigParser& parser, const WCHAR* section)
{
_snwprintf_s(tmpName, _TRUNCATE, L"MeasureName%i", i);
const std::wstring& measureName = parser.ReadString(section, tmpName, L"");
CMeasure* measure = parser.GetMeasure(measureName);
Measure* measure = parser.GetMeasure(measureName);
if (measure)
{
m_Measures.push_back(measure);
@@ -488,7 +488,7 @@ void CMeter::BindSecondaryMeasures(CConfigParser& parser, const WCHAR* section)
** Replaces %1, %2, ... with the corresponding measure value.
**
*/
bool CMeter::ReplaceMeasures(std::wstring& str, AUTOSCALE autoScale, double scale, int decimals, bool percentual)
bool Meter::ReplaceMeasures(std::wstring& str, AUTOSCALE autoScale, double scale, int decimals, bool percentual)
{
bool replaced = false;
@@ -525,10 +525,10 @@ bool CMeter::ReplaceMeasures(std::wstring& str, AUTOSCALE autoScale, double scal
/*
** Does the initial construction of the ToolTip for the meter
*/
void CMeter::CreateToolTip(CMeterWindow* meterWindow)
void Meter::CreateToolTip(MeterWindow* meterWindow)
{
HWND hMeterWindow = m_MeterWindow->GetWindow();
HINSTANCE hInstance = Rainmeter->GetInstance();
HINSTANCE hInstance = g_Rainmeter->GetInstance();
DWORD style = WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP;
if (m_ToolTipType)
@@ -565,7 +565,7 @@ void CMeter::CreateToolTip(CMeterWindow* meterWindow)
/*
** Updates the ToolTip to match new values
*/
void CMeter::UpdateToolTip()
void Meter::UpdateToolTip()
{
HWND hwndTT = m_ToolTipHandle;
@@ -640,7 +640,7 @@ void CMeter::UpdateToolTip()
/*
** Draws the solid background & bevel if such are defined
*/
bool CMeter::Draw(Gfx::Canvas& canvas)
bool Meter::Draw(Gfx::Canvas& canvas)
{
if (IsHidden()) return false;
@@ -712,7 +712,7 @@ bool CMeter::Draw(Gfx::Canvas& canvas)
/*
** Draws a bevel inside the given area
*/
void CMeter::DrawBevel(Graphics& graphics, const Rect& rect, const Pen& light, const Pen& dark)
void Meter::DrawBevel(Graphics& graphics, const Rect& rect, const Pen& light, const Pen& dark)
{
int l = rect.GetLeft();
int r = rect.GetRight() - 1;

32
Library/Meter.h
View File

@@ -29,14 +29,14 @@
#include "Section.h"
#include "Measure.h"
class CMeasure;
class Measure;
class __declspec(novtable) CMeter : public CSection
class __declspec(novtable) Meter : public Section
{
public:
virtual ~CMeter();
virtual ~Meter();
void ReadOptions(CConfigParser& parser) { ReadOptions(parser, GetName()); parser.ClearStyleTemplate(); }
void ReadOptions(ConfigParser& parser) { ReadOptions(parser, GetName()); parser.ClearStyleTemplate(); }
virtual void Initialize();
virtual bool Update();
@@ -54,15 +54,15 @@ public:
void SetX(int x);
void SetY(int y);
void SetRelativeMeter(CMeter* meter) { m_RelativeMeter = meter; }
void SetRelativeMeter(Meter* meter) { m_RelativeMeter = meter; }
const CMouse& GetMouse() { return m_Mouse; }
const Mouse& GetMouse() { return m_Mouse; }
bool HasMouseAction() { return m_HasMouseAction; }
const std::wstring& GetToolTipText() { return m_ToolTipText; }
bool HasToolTip() { return m_ToolTipHandle != NULL; }
void CreateToolTip(CMeterWindow* meterWindow);
void CreateToolTip(MeterWindow* meterWindow);
void UpdateToolTip();
void Hide();
@@ -76,7 +76,7 @@ public:
void SetMouseOver(bool over) { m_MouseOver = over; }
bool IsMouseOver() { return m_MouseOver; }
static CMeter* Create(const WCHAR* meter, CMeterWindow* meterWindow, const WCHAR* name);
static Meter* Create(const WCHAR* meter, MeterWindow* meterWindow, const WCHAR* name);
static void DrawBevel(Gdiplus::Graphics& graphics, const Gdiplus::Rect& rect, const Gdiplus::Pen& light, const Gdiplus::Pen& dark);
@@ -102,19 +102,19 @@ protected:
POSITION_RELATIVE_BR
};
CMeter(CMeterWindow* meterWindow, const WCHAR* name);
Meter(MeterWindow* meterWindow, const WCHAR* name);
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(ConfigParser& parser, const WCHAR* section);
virtual bool IsFixedSize(bool overwrite = false) { return true; }
bool BindPrimaryMeasure(CConfigParser& parser, const WCHAR* section, bool optional);
void BindSecondaryMeasures(CConfigParser& parser, const WCHAR* section);
bool BindPrimaryMeasure(ConfigParser& parser, const WCHAR* section, bool optional);
void BindSecondaryMeasures(ConfigParser& parser, const WCHAR* section);
bool ReplaceMeasures(std::wstring& str, AUTOSCALE autoScale = AUTOSCALE_ON, double scale = 1.0, int decimals = 0, bool percentual = false);
std::vector<CMeasure*> m_Measures;
std::vector<Measure*> m_Measures;
int m_X;
int m_Y;
int m_W;
@@ -122,7 +122,7 @@ protected:
bool m_Hidden;
bool m_WDefined;
bool m_HDefined;
CMeter* m_RelativeMeter;
Meter* m_RelativeMeter;
Gdiplus::Matrix* m_Transformation;
@@ -135,7 +135,7 @@ protected:
HWND m_ToolTipHandle;
CMouse m_Mouse;
Mouse m_Mouse;
bool m_HasMouseAction;
bool m_MouseOver;

22
Library/MeterBar.cpp
View File

@@ -26,13 +26,13 @@
using namespace Gdiplus;
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** The constructor
**
*/
CMeterBar::CMeterBar(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterBar::MeterBar(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_Image(L"BarImage"),
m_NeedsReload(false),
m_Color(Color::Green),
@@ -47,7 +47,7 @@ CMeterBar::CMeterBar(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(mete
** The destructor
**
*/
CMeterBar::~CMeterBar()
MeterBar::~MeterBar()
{
}
@@ -56,9 +56,9 @@ CMeterBar::~CMeterBar()
** of the meter from it.
**
*/
void CMeterBar::Initialize()
void MeterBar::Initialize()
{
CMeter::Initialize();
Meter::Initialize();
// Load the bitmaps if defined
if (!m_ImageName.empty())
@@ -83,14 +83,14 @@ void CMeterBar::Initialize()
** Read the options specified in the ini file.
**
*/
void CMeterBar::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterBar::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
// 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;
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
m_Color = parser.ReadColor(section, L"BarColor", Color::Green);
@@ -147,9 +147,9 @@ void CMeterBar::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterBar::Update()
bool MeterBar::Update()
{
if (CMeter::Update() && !m_Measures.empty())
if (Meter::Update() && !m_Measures.empty())
{
m_Value = m_Measures[0]->GetRelativeValue();
return true;
@@ -161,9 +161,9 @@ bool CMeterBar::Update()
** Draws the meter on the double buffer
**
*/
bool CMeterBar::Draw(Gfx::Canvas& canvas)
bool MeterBar::Draw(Gfx::Canvas& canvas)
{
if (!CMeter::Draw(canvas)) return false;
if (!Meter::Draw(canvas)) return false;
int x = GetX();
int y = GetY();

12
Library/MeterBar.h
View File

@@ -22,20 +22,20 @@
#include "Meter.h"
#include "TintedImage.h"
class CMeterBar : public CMeter
class MeterBar : public Meter
{
public:
CMeterBar(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterBar();
MeterBar(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterBar();
virtual UINT GetTypeID() { return TypeID<CMeterBar>(); }
virtual UINT GetTypeID() { return TypeID<MeterBar>(); }
virtual void Initialize();
virtual bool Update();
virtual bool Draw(Gfx::Canvas& canvas);
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual bool IsFixedSize(bool overwrite = false) { return m_ImageName.empty(); }
@@ -46,7 +46,7 @@ private:
VERTICAL
};
CTintedImage m_Image;
TintedImage m_Image;
std::wstring m_ImageName;
bool m_NeedsReload;

36
Library/MeterBitmap.cpp
View File

@@ -26,13 +26,13 @@
using namespace Gdiplus;
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** The constructor
**
*/
CMeterBitmap::CMeterBitmap(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterBitmap::MeterBitmap(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_Image(L"BitmapImage", NULL, true),
m_NeedsReload(false),
m_ZeroFrame(false),
@@ -52,7 +52,7 @@ CMeterBitmap::CMeterBitmap(CMeterWindow* meterWindow, const WCHAR* name) : CMete
** The destructor
**
*/
CMeterBitmap::~CMeterBitmap()
MeterBitmap::~MeterBitmap()
{
}
@@ -60,9 +60,9 @@ CMeterBitmap::~CMeterBitmap()
** Load the image and get the dimensions of the meter from it.
**
*/
void CMeterBitmap::Initialize()
void MeterBitmap::Initialize()
{
CMeter::Initialize();
Meter::Initialize();
// Load the bitmaps if defined
if (!m_ImageName.empty())
@@ -96,7 +96,7 @@ void CMeterBitmap::Initialize()
** Checks if the given point is inside the meter.
**
*/
bool CMeterBitmap::HitTest(int x, int y)
bool MeterBitmap::HitTest(int x, int y)
{
if (m_Extend)
{
@@ -147,7 +147,7 @@ bool CMeterBitmap::HitTest(int x, int y)
}
else
{
return CMeter::HitTest(x, y);
return Meter::HitTest(x, y);
}
}
@@ -155,14 +155,14 @@ bool CMeterBitmap::HitTest(int x, int y)
** Read the options specified in the ini file.
**
*/
void CMeterBitmap::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterBitmap::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
// 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;
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
m_ImageName = parser.ReadString(section, L"BitmapImage", L"");
if (!m_ImageName.empty())
@@ -226,11 +226,11 @@ void CMeterBitmap::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterBitmap::Update()
bool MeterBitmap::Update()
{
if (CMeter::Update() && !m_Measures.empty())
if (Meter::Update() && !m_Measures.empty())
{
CMeasure* measure = m_Measures[0];
Measure* measure = m_Measures[0];
double value = (m_Extend) ? measure->GetValue() : measure->GetRelativeValue();
if (m_TransitionFrameCount > 0)
@@ -239,7 +239,7 @@ bool CMeterBitmap::Update()
if ((int)(value * realFrames) != (int)(m_Value * realFrames))
{
m_TransitionStartValue = m_Value;
m_TransitionStartTicks = CSystem::GetTickCount64();
m_TransitionStartTicks = System::GetTickCount64();
}
else
{
@@ -258,7 +258,7 @@ bool CMeterBitmap::Update()
** Returns true if the meter has active transition animation.
**
*/
bool CMeterBitmap::HasActiveTransition()
bool MeterBitmap::HasActiveTransition()
{
if (m_TransitionStartTicks > 0)
{
@@ -271,9 +271,9 @@ bool CMeterBitmap::HasActiveTransition()
** Draws the meter on the double buffer
**
*/
bool CMeterBitmap::Draw(Gfx::Canvas& canvas)
bool MeterBitmap::Draw(Gfx::Canvas& canvas)
{
if (!CMeter::Draw(canvas)) return false;
if (!Meter::Draw(canvas)) return false;
int newY, newX;
@@ -343,7 +343,7 @@ bool CMeterBitmap::Draw(Gfx::Canvas& canvas)
// If transition is ongoing the pick the correct frame
if (m_TransitionStartTicks > 0)
{
int diffTicks = (int)(CSystem::GetTickCount64() - m_TransitionStartTicks);
int diffTicks = (int)(System::GetTickCount64() - m_TransitionStartTicks);
int range = ((value % realFrames) - (transitionValue % realFrames)) * (m_TransitionFrameCount + 1);
if (range < 0)
@@ -413,7 +413,7 @@ bool CMeterBitmap::Draw(Gfx::Canvas& canvas)
// If transition is ongoing the pick the correct frame
if (m_TransitionStartTicks > 0)
{
int diffTicks = (int)(CSystem::GetTickCount64() - m_TransitionStartTicks);
int diffTicks = (int)(System::GetTickCount64() - m_TransitionStartTicks);
if (diffTicks > ((m_TransitionFrameCount + 1) * m_MeterWindow->GetTransitionUpdate()))
{

12
Library/MeterBitmap.h
View File

@@ -22,13 +22,13 @@
#include "Meter.h"
#include "TintedImage.h"
class CMeterBitmap : public CMeter
class MeterBitmap : public Meter
{
public:
CMeterBitmap(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterBitmap();
MeterBitmap(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterBitmap();
virtual UINT GetTypeID() { return TypeID<CMeterBitmap>(); }
virtual UINT GetTypeID() { return TypeID<MeterBitmap>(); }
virtual bool HitTest(int x, int y);
@@ -38,10 +38,10 @@ public:
virtual bool HasActiveTransition();
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
private:
CTintedImage m_Image;
TintedImage m_Image;
std::wstring m_ImageName;
bool m_NeedsReload;

34
Library/MeterButton.cpp
View File

@@ -23,7 +23,7 @@
#include "Error.h"
#include "../Common/Gfx/Canvas.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
using namespace Gdiplus;
@@ -38,7 +38,7 @@ enum BUTTON_STATE
** The constructor
**
*/
CMeterButton::CMeterButton(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterButton::MeterButton(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_Image(L"ButtonImage", NULL, true),
m_NeedsReload(false),
m_Bitmaps(),
@@ -52,7 +52,7 @@ CMeterButton::CMeterButton(CMeterWindow* meterWindow, const WCHAR* name) : CMete
** The destructor
**
*/
CMeterButton::~CMeterButton()
MeterButton::~MeterButton()
{
for (int i = 0; i < BUTTON_FRAMES; ++i)
{
@@ -64,9 +64,9 @@ CMeterButton::~CMeterButton()
** Load the image and get the dimensions of the meter from it.
**
*/
void CMeterButton::Initialize()
void MeterButton::Initialize()
{
CMeter::Initialize();
Meter::Initialize();
for (int i = 0; i < BUTTON_FRAMES; ++i)
{
@@ -127,14 +127,14 @@ void CMeterButton::Initialize()
** Read the options specified in the ini file.
**
*/
void CMeterButton::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterButton::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
// 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;
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
m_ImageName = parser.ReadString(section, L"ButtonImage", L"");
if (!m_ImageName.empty())
@@ -173,18 +173,18 @@ void CMeterButton::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterButton::Update()
bool MeterButton::Update()
{
return CMeter::Update();
return Meter::Update();
}
/*
** Draws the meter on the double buffer
**
*/
bool CMeterButton::Draw(Gfx::Canvas& canvas)
bool MeterButton::Draw(Gfx::Canvas& canvas)
{
if (!CMeter::Draw(canvas)) return false;
if (!Meter::Draw(canvas)) return false;
if (m_Bitmaps[m_State] == NULL) return false; // Unable to continue
@@ -205,7 +205,7 @@ bool CMeterButton::Draw(Gfx::Canvas& canvas)
** Overridden method. The meters need not to be bound on anything
**
*/
void CMeterButton::BindMeasures(CConfigParser& parser, const WCHAR* section)
void MeterButton::BindMeasures(ConfigParser& parser, const WCHAR* section)
{
BindPrimaryMeasure(parser, section, true);
}
@@ -214,7 +214,7 @@ void CMeterButton::BindMeasures(CConfigParser& parser, const WCHAR* section)
** Checks if the given point is inside the button.
**
*/
bool CMeterButton::HitTest2(int px, int py, bool checkAlpha)
bool MeterButton::HitTest2(int px, int py, bool checkAlpha)
{
int x = GetX();
int y = GetY();
@@ -253,13 +253,13 @@ bool CMeterButton::HitTest2(int px, int py, bool checkAlpha)
return false;
}
bool CMeterButton::MouseUp(POINT pos, bool execute)
bool MeterButton::MouseUp(POINT pos, bool execute)
{
if (m_State == BUTTON_STATE_DOWN)
{
if (execute && m_Clicked && m_Focus && HitTest2(pos.x, pos.y, true))
{
Rainmeter->ExecuteCommand(m_Command.c_str(), m_MeterWindow);
g_Rainmeter->ExecuteCommand(m_Command.c_str(), m_MeterWindow);
}
m_State = BUTTON_STATE_NORMAL;
m_Clicked = false;
@@ -270,7 +270,7 @@ bool CMeterButton::MouseUp(POINT pos, bool execute)
return false;
}
bool CMeterButton::MouseDown(POINT pos)
bool MeterButton::MouseDown(POINT pos)
{
if (m_Focus && HitTest2(pos.x, pos.y, true))
{
@@ -281,7 +281,7 @@ bool CMeterButton::MouseDown(POINT pos)
return false;
}
bool CMeterButton::MouseMove(POINT pos)
bool MeterButton::MouseMove(POINT pos)
{
if (m_Clicked)
{

14
Library/MeterButton.h
View File

@@ -24,13 +24,13 @@
#define BUTTON_FRAMES 3
class CMeterButton : public CMeter
class MeterButton : public Meter
{
public:
CMeterButton(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterButton();
MeterButton(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterButton();
virtual UINT GetTypeID() { return TypeID<CMeterButton>(); }
virtual UINT GetTypeID() { return TypeID<MeterButton>(); }
virtual void Initialize();
virtual bool Update();
@@ -43,15 +43,15 @@ public:
void SetFocus(bool f) { m_Focus = f; }
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(ConfigParser& parser, const WCHAR* section);
virtual bool IsFixedSize(bool overwrite = false) { return overwrite; }
private:
bool HitTest2(int px, int py, bool checkAlpha);
CTintedImage m_Image;
TintedImage m_Image;
std::wstring m_ImageName;
bool m_NeedsReload;

44
Library/MeterHistogram.cpp
View File

@@ -25,17 +25,17 @@
using namespace Gdiplus;
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
CTintedImageHelper_DefineOptionArray(CMeterHistogram::c_PrimaryOptionArray, L"Primary");
CTintedImageHelper_DefineOptionArray(CMeterHistogram::c_SecondaryOptionArray, L"Secondary");
CTintedImageHelper_DefineOptionArray(CMeterHistogram::c_BothOptionArray, L"Both");
TintedImageHelper_DefineOptionArray(MeterHistogram::c_PrimaryOptionArray, L"Primary");
TintedImageHelper_DefineOptionArray(MeterHistogram::c_SecondaryOptionArray, L"Secondary");
TintedImageHelper_DefineOptionArray(MeterHistogram::c_BothOptionArray, L"Both");
/*
** The constructor
**
*/
CMeterHistogram::CMeterHistogram(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterHistogram::MeterHistogram(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_PrimaryColor(Color::Green),
m_SecondaryColor(Color::Red),
m_OverlapColor(Color::Yellow),
@@ -64,7 +64,7 @@ CMeterHistogram::CMeterHistogram(CMeterWindow* meterWindow, const WCHAR* name) :
** The destructor
**
*/
CMeterHistogram::~CMeterHistogram()
MeterHistogram::~MeterHistogram()
{
DisposeBuffer();
}
@@ -73,7 +73,7 @@ CMeterHistogram::~CMeterHistogram()
** Disposes the buffers.
**
*/
void CMeterHistogram::DisposeBuffer()
void MeterHistogram::DisposeBuffer()
{
// Reset current position
m_MeterPos = 0;
@@ -90,7 +90,7 @@ void CMeterHistogram::DisposeBuffer()
** Creates the buffers.
**
*/
void CMeterHistogram::CreateBuffer()
void MeterHistogram::CreateBuffer()
{
DisposeBuffer();
@@ -111,11 +111,11 @@ void CMeterHistogram::CreateBuffer()
** Or create the brushes if solid color histogram is used.
**
*/
void CMeterHistogram::Initialize()
void MeterHistogram::Initialize()
{
CMeter::Initialize();
Meter::Initialize();
CMeasure* secondaryMeasure = (m_Measures.size() >= 2) ? m_Measures[1] : NULL;
Measure* secondaryMeasure = (m_Measures.size() >= 2) ? m_Measures[1] : NULL;
// A sanity check
if (secondaryMeasure && !m_PrimaryImageName.empty() && (m_OverlapImageName.empty() || m_SecondaryImageName.empty()))
@@ -193,7 +193,7 @@ void CMeterHistogram::Initialize()
** Read the options specified in the ini file.
**
*/
void CMeterHistogram::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterHistogram::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
// Store the current values so we know if the image needs to be updated
std::wstring oldPrimaryImageName = m_PrimaryImageName;
@@ -203,7 +203,7 @@ void CMeterHistogram::ReadOptions(CConfigParser& parser, const WCHAR* section)
int oldH = m_H;
bool oldGraphHorizontalOrientation = m_GraphHorizontalOrientation;
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
m_PrimaryColor = parser.ReadColor(section, L"PrimaryColor", Color::Green);
m_SecondaryColor = parser.ReadColor(section, L"SecondaryColor", Color::Red);
@@ -323,16 +323,16 @@ void CMeterHistogram::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterHistogram::Update()
bool MeterHistogram::Update()
{
if (CMeter::Update() && !m_Measures.empty())
if (Meter::Update() && !m_Measures.empty())
{
int maxSize = m_GraphHorizontalOrientation ? m_H : m_W;
if (maxSize > 0) // m_PrimaryValues is not NULL
{
CMeasure* measure = m_Measures[0];
CMeasure* secondaryMeasure = (m_Measures.size() >= 2) ? m_Measures[1] : NULL;
Measure* measure = m_Measures[0];
Measure* secondaryMeasure = (m_Measures.size() >= 2) ? m_Measures[1] : NULL;
// Gather values
m_PrimaryValues[m_MeterPos] = measure->GetValue();
@@ -411,15 +411,15 @@ bool CMeterHistogram::Update()
** Draws the meter on the double buffer
**
*/
bool CMeterHistogram::Draw(Gfx::Canvas& canvas)
bool MeterHistogram::Draw(Gfx::Canvas& canvas)
{
if (!CMeter::Draw(canvas) ||
if (!Meter::Draw(canvas) ||
(m_Measures.size() >= 1 && !m_PrimaryValues) ||
(m_Measures.size() >= 2 && !m_SecondaryValues)) return false;
Gdiplus::Graphics& graphics = canvas.BeginGdiplusContext();
CMeasure* secondaryMeasure = (m_Measures.size() >= 2) ? m_Measures[1] : NULL;
Measure* secondaryMeasure = (m_Measures.size() >= 2) ? m_Measures[1] : NULL;
GraphicsPath primaryPath;
GraphicsPath secondaryPath;
@@ -645,7 +645,7 @@ bool CMeterHistogram::Draw(Gfx::Canvas& canvas)
** Overwritten method to handle the secondary measure binding.
**
*/
void CMeterHistogram::BindMeasures(CConfigParser& parser, const WCHAR* section)
void MeterHistogram::BindMeasures(ConfigParser& parser, const WCHAR* section)
{
if (BindPrimaryMeasure(parser, section, false))
{
@@ -656,7 +656,7 @@ void CMeterHistogram::BindMeasures(CConfigParser& parser, const WCHAR* section)
secondaryMeasure = &parser.ReadString(section, L"SecondaryMeasureName", L"");
}
CMeasure* measure = parser.GetMeasure(*secondaryMeasure);
Measure* measure = parser.GetMeasure(*secondaryMeasure);
if (measure)
{
m_Measures.push_back(measure);

24
Library/MeterHistogram.h
View File

@@ -22,21 +22,21 @@
#include "Meter.h"
#include "TintedImage.h"
class CMeterHistogram : public CMeter
class MeterHistogram : public Meter
{
public:
CMeterHistogram(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterHistogram();
MeterHistogram(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterHistogram();
virtual UINT GetTypeID() { return TypeID<CMeterHistogram>(); }
virtual UINT GetTypeID() { return TypeID<MeterHistogram>(); }
virtual void Initialize();
virtual bool Update();
virtual bool Draw(Gfx::Canvas& canvas);
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(ConfigParser& parser, const WCHAR* section);
virtual bool IsFixedSize(bool overwrite = false) { return m_PrimaryImageName.empty(); }
@@ -56,9 +56,9 @@ private:
std::wstring m_SecondaryImageName;
std::wstring m_OverlapImageName;
CTintedImage m_PrimaryImage;
CTintedImage m_SecondaryImage;
CTintedImage m_OverlapImage;
TintedImage m_PrimaryImage;
TintedImage m_SecondaryImage;
TintedImage m_OverlapImage;
bool m_PrimaryNeedsReload;
bool m_SecondaryNeedsReload;
@@ -77,9 +77,9 @@ private:
bool m_GraphStartLeft;
bool m_GraphHorizontalOrientation;
static const WCHAR* c_PrimaryOptionArray[CTintedImage::OptionCount];
static const WCHAR* c_SecondaryOptionArray[CTintedImage::OptionCount];
static const WCHAR* c_BothOptionArray[CTintedImage::OptionCount];
static const WCHAR* c_PrimaryOptionArray[TintedImage::OptionCount];
static const WCHAR* c_SecondaryOptionArray[TintedImage::OptionCount];
static const WCHAR* c_BothOptionArray[TintedImage::OptionCount];
};
#endif

28
Library/MeterImage.cpp
View File

@@ -24,7 +24,7 @@
#include "System.h"
#include "../Common/Gfx/Canvas.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
using namespace Gdiplus;
@@ -32,7 +32,7 @@ using namespace Gdiplus;
** The constructor
**
*/
CMeterImage::CMeterImage(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterImage::MeterImage(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_NeedsRedraw(false),
m_DrawMode(DRAWMODE_NONE),
m_ScaleMargins()
@@ -43,7 +43,7 @@ CMeterImage::CMeterImage(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(
** The destructor
**
*/
CMeterImage::~CMeterImage()
MeterImage::~MeterImage()
{
}
@@ -51,9 +51,9 @@ CMeterImage::~CMeterImage()
** Load the image and get the dimensions of the meter from it.
**
*/
void CMeterImage::Initialize()
void MeterImage::Initialize()
{
CMeter::Initialize();
Meter::Initialize();
if (m_Measures.empty() && !m_DynamicVariables && !m_ImageName.empty())
{
@@ -68,7 +68,7 @@ void CMeterImage::Initialize()
** Loads the image from disk
**
*/
void CMeterImage::LoadImage(const std::wstring& imageName, bool bLoadAlways)
void MeterImage::LoadImage(const std::wstring& imageName, bool bLoadAlways)
{
m_Image.LoadImage(imageName, bLoadAlways);
@@ -106,14 +106,14 @@ void CMeterImage::LoadImage(const std::wstring& imageName, bool bLoadAlways)
** Read the options specified in the ini file.
**
*/
void CMeterImage::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterImage::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
m_Path = parser.ReadString(section, L"Path", L"");
if (!m_Path.empty())
{
if (!CSystem::IsPathSeparator(m_Path[m_Path.length() - 1]))
if (!System::IsPathSeparator(m_Path[m_Path.length() - 1]))
{
m_Path += L'\\';
}
@@ -161,9 +161,9 @@ void CMeterImage::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterImage::Update()
bool MeterImage::Update()
{
if (CMeter::Update())
if (Meter::Update())
{
if (!m_Measures.empty() || m_DynamicVariables)
{
@@ -215,9 +215,9 @@ bool CMeterImage::Update()
** Draws the meter on the double buffer
**
*/
bool CMeterImage::Draw(Gfx::Canvas& canvas)
bool MeterImage::Draw(Gfx::Canvas& canvas)
{
if (!CMeter::Draw(canvas)) return false;
if (!Meter::Draw(canvas)) return false;
if (m_Image.IsLoaded())
{
@@ -371,7 +371,7 @@ bool CMeterImage::Draw(Gfx::Canvas& canvas)
** Overridden method. The Image meters need not to be bound on anything
**
*/
void CMeterImage::BindMeasures(CConfigParser& parser, const WCHAR* section)
void MeterImage::BindMeasures(ConfigParser& parser, const WCHAR* section)
{
if (BindPrimaryMeasure(parser, section, true))
{

14
Library/MeterImage.h
View File

@@ -22,21 +22,21 @@
#include "Meter.h"
#include "TintedImage.h"
class CMeterImage : public CMeter
class MeterImage : public Meter
{
public:
CMeterImage(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterImage();
MeterImage(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterImage();
virtual UINT GetTypeID() { return TypeID<CMeterImage>(); }
virtual UINT GetTypeID() { return TypeID<MeterImage>(); }
virtual void Initialize();
virtual bool Update();
virtual bool Draw(Gfx::Canvas& canvas);
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(ConfigParser& parser, const WCHAR* section);
virtual bool IsFixedSize(bool overwrite = false) { return overwrite ? true : m_ImageNameResult.empty(); }
@@ -51,7 +51,7 @@ private:
void LoadImage(const std::wstring& imageName, bool bLoadAlways);
CTintedImage m_Image;
TintedImage m_Image;
std::wstring m_ImageName;
std::wstring m_ImageNameResult; // Image name as absolute path
std::wstring m_Path;

22
Library/MeterLine.cpp
View File

@@ -28,7 +28,7 @@ using namespace Gdiplus;
** The constructor
**
*/
CMeterLine::CMeterLine(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterLine::MeterLine(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_Autoscale(false),
m_HorizontalLines(false),
m_Flip(false),
@@ -44,7 +44,7 @@ CMeterLine::CMeterLine(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(me
** The destructor
**
*/
CMeterLine::~CMeterLine()
MeterLine::~MeterLine()
{
}
@@ -52,9 +52,9 @@ CMeterLine::~CMeterLine()
** create the buffer for the lines
**
*/
void CMeterLine::Initialize()
void MeterLine::Initialize()
{
CMeter::Initialize();
Meter::Initialize();
size_t colorsSize = m_Colors.size();
size_t allValuesSize = m_AllValues.size();
@@ -100,7 +100,7 @@ void CMeterLine::Initialize()
** Read the options specified in the ini file.
**
*/
void CMeterLine::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterLine::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
WCHAR tmpName[64];
@@ -109,7 +109,7 @@ void CMeterLine::ReadOptions(CConfigParser& parser, const WCHAR* section)
int oldSize = m_GraphHorizontalOrientation ? m_H : m_W;
bool oldGraphHorizontalOrientation = m_GraphHorizontalOrientation;
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
int lineCount = parser.ReadInt(section, L"LineCount", 1);
@@ -192,9 +192,9 @@ void CMeterLine::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterLine::Update()
bool MeterLine::Update()
{
if (CMeter::Update() && !m_Measures.empty())
if (Meter::Update() && !m_Measures.empty())
{
int maxSize = m_GraphHorizontalOrientation ? m_H : m_W;
@@ -219,10 +219,10 @@ bool CMeterLine::Update()
** Draws the meter on the double buffer
**
*/
bool CMeterLine::Draw(Gfx::Canvas& canvas)
bool MeterLine::Draw(Gfx::Canvas& canvas)
{
int maxSize = m_GraphHorizontalOrientation ? m_H : m_W;
if (!CMeter::Draw(canvas) || maxSize <= 0) return false;
if (!Meter::Draw(canvas) || maxSize <= 0) return false;
Gdiplus::Graphics& graphics = canvas.BeginGdiplusContext();
@@ -441,7 +441,7 @@ bool CMeterLine::Draw(Gfx::Canvas& canvas)
** Overwritten method to handle the other measure bindings.
**
*/
void CMeterLine::BindMeasures(CConfigParser& parser, const WCHAR* section)
void MeterLine::BindMeasures(ConfigParser& parser, const WCHAR* section)
{
if (BindPrimaryMeasure(parser, section, false))
{

12
Library/MeterLine.h
View File

@@ -21,21 +21,21 @@
#include "Meter.h"
class CMeterLine : public CMeter
class MeterLine : public Meter
{
public:
CMeterLine(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterLine();
MeterLine(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterLine();
virtual UINT GetTypeID() { return TypeID<CMeterLine>(); }
virtual UINT GetTypeID() { return TypeID<MeterLine>(); }
virtual void Initialize();
virtual bool Update();
virtual bool Draw(Gfx::Canvas& canvas);
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(ConfigParser& parser, const WCHAR* section);
private:
std::vector<Gdiplus::Color> m_Colors;

24
Library/MeterRotator.cpp
View File

@@ -29,13 +29,13 @@ using namespace Gdiplus;
#define PI (3.14159265358979323846)
#define CONVERT_TO_DEGREES(X) ((X) * (180.0 / PI))
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** The constructor
**
*/
CMeterRotator::CMeterRotator(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterRotator::MeterRotator(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_NeedsReload(false),
m_OffsetX(),
m_OffsetY(),
@@ -50,7 +50,7 @@ CMeterRotator::CMeterRotator(CMeterWindow* meterWindow, const WCHAR* name) : CMe
** The destructor
**
*/
CMeterRotator::~CMeterRotator()
MeterRotator::~MeterRotator()
{
}
@@ -58,9 +58,9 @@ CMeterRotator::~CMeterRotator()
** Load the image.
**
*/
void CMeterRotator::Initialize()
void MeterRotator::Initialize()
{
CMeter::Initialize();
Meter::Initialize();
// Load the bitmaps if defined
if (!m_ImageName.empty())
@@ -77,12 +77,12 @@ void CMeterRotator::Initialize()
** Read the options specified in the ini file.
**
*/
void CMeterRotator::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterRotator::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
// Store the current values so we know if the image needs to be updated
std::wstring oldImageName = m_ImageName;
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
m_ImageName = parser.ReadString(section, L"ImageName", L"");
if (!m_ImageName.empty())
@@ -121,11 +121,11 @@ void CMeterRotator::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterRotator::Update()
bool MeterRotator::Update()
{
if (CMeter::Update() && !m_Measures.empty())
if (Meter::Update() && !m_Measures.empty())
{
CMeasure* measure = m_Measures[0];
Measure* measure = m_Measures[0];
if (m_ValueRemainder > 0)
{
LONGLONG time = (LONGLONG)measure->GetValue();
@@ -146,9 +146,9 @@ bool CMeterRotator::Update()
** Draws the meter on the double buffer
**
*/
bool CMeterRotator::Draw(Gfx::Canvas& canvas)
bool MeterRotator::Draw(Gfx::Canvas& canvas)
{
if (!CMeter::Draw(canvas)) return false;
if (!Meter::Draw(canvas)) return false;
Gdiplus::Graphics& graphics = canvas.BeginGdiplusContext();

12
Library/MeterRotator.h
View File

@@ -22,23 +22,23 @@
#include "Meter.h"
#include "TintedImage.h"
class CMeterRotator : public CMeter
class MeterRotator : public Meter
{
public:
CMeterRotator(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterRotator();
MeterRotator(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterRotator();
virtual UINT GetTypeID() { return TypeID<CMeterRotator>(); }
virtual UINT GetTypeID() { return TypeID<MeterRotator>(); }
virtual void Initialize();
virtual bool Update();
virtual bool Draw(Gfx::Canvas& canvas);
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
private:
CTintedImage m_Image;
TintedImage m_Image;
std::wstring m_ImageName;
bool m_NeedsReload;

20
Library/MeterRoundLine.cpp
View File

@@ -31,7 +31,7 @@ using namespace Gdiplus;
** The constructor
**
*/
CMeterRoundLine::CMeterRoundLine(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterRoundLine::MeterRoundLine(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_Solid(false),
m_LineWidth(1.0),
m_LineLength(20.0),
@@ -53,7 +53,7 @@ CMeterRoundLine::CMeterRoundLine(CMeterWindow* meterWindow, const WCHAR* name) :
** The destructor
**
*/
CMeterRoundLine::~CMeterRoundLine()
MeterRoundLine::~MeterRoundLine()
{
}
@@ -61,9 +61,9 @@ CMeterRoundLine::~CMeterRoundLine()
** Read the options specified in the ini file.
**
*/
void CMeterRoundLine::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterRoundLine::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
m_LineWidth = parser.ReadFloat(section, L"LineWidth", 1.0);
m_LineLength = parser.ReadFloat(section, L"LineLength", 20.0);
@@ -85,9 +85,9 @@ void CMeterRoundLine::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterRoundLine::Update()
bool MeterRoundLine::Update()
{
if (CMeter::Update())
if (Meter::Update())
{
if (m_Measures.empty())
{
@@ -95,7 +95,7 @@ bool CMeterRoundLine::Update()
return true;
}
CMeasure* measure = m_Measures[0];
Measure* measure = m_Measures[0];
if (m_ValueRemainder > 0)
{
LONGLONG time = (LONGLONG)measure->GetValue();
@@ -117,9 +117,9 @@ bool CMeterRoundLine::Update()
** Draws the meter on the double buffer
**
*/
bool CMeterRoundLine::Draw(Gfx::Canvas& canvas)
bool MeterRoundLine::Draw(Gfx::Canvas& canvas)
{
if (!CMeter::Draw(canvas)) return false;
if (!Meter::Draw(canvas)) return false;
Gdiplus::Graphics& graphics = canvas.BeginGdiplusContext();
@@ -176,7 +176,7 @@ bool CMeterRoundLine::Draw(Gfx::Canvas& canvas)
** Overridden method. The roundline meters need not to be bound on anything
**
*/
void CMeterRoundLine::BindMeasures(CConfigParser& parser, const WCHAR* section)
void MeterRoundLine::BindMeasures(ConfigParser& parser, const WCHAR* section)
{
BindPrimaryMeasure(parser, section, true);
}

12
Library/MeterRoundLine.h
View File

@@ -21,20 +21,20 @@
#include "Meter.h"
class CMeterRoundLine : public CMeter
class MeterRoundLine : public Meter
{
public:
CMeterRoundLine(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterRoundLine();
MeterRoundLine(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterRoundLine();
virtual UINT GetTypeID() { return TypeID<CMeterRoundLine>(); }
virtual UINT GetTypeID() { return TypeID<MeterRoundLine>(); }
virtual bool Update();
virtual bool Draw(Gfx::Canvas& canvas);
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(ConfigParser& parser, const WCHAR* section);
private:
bool m_Solid;

42
Library/MeterString.cpp
View File

@@ -28,7 +28,7 @@ using namespace Gdiplus;
#define PI (3.14159265f)
#define CONVERT_TO_DEGREES(X) ((X) * (180.0f / PI))
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
void StringToUpper(std::wstring& str)
{
@@ -63,7 +63,7 @@ void StringToProper(std::wstring& str)
** The constructor
**
*/
CMeterString::CMeterString(CMeterWindow* meterWindow, const WCHAR* name) : CMeter(meterWindow, name),
MeterString::MeterString(MeterWindow* meterWindow, const WCHAR* name) : Meter(meterWindow, name),
m_Color(Color::White),
m_EffectColor(Color::Black),
m_AutoScale(AUTOSCALE_OFF),
@@ -88,7 +88,7 @@ CMeterString::CMeterString(CMeterWindow* meterWindow, const WCHAR* name) : CMete
** The destructor
**
*/
CMeterString::~CMeterString()
MeterString::~MeterString()
{
delete m_TextFormat;
m_TextFormat = NULL;
@@ -98,9 +98,9 @@ CMeterString::~CMeterString()
** Returns the X-coordinate of the meter
**
*/
int CMeterString::GetX(bool abs)
int MeterString::GetX(bool abs)
{
int x = CMeter::GetX();
int x = Meter::GetX();
if (!abs)
{
@@ -123,9 +123,9 @@ int CMeterString::GetX(bool abs)
** Returns the Y-coordinate of the meter
**
*/
int CMeterString::GetY(bool abs)
int MeterString::GetY(bool abs)
{
int y = CMeter::GetY();
int y = Meter::GetY();
if (!abs)
{
@@ -148,9 +148,9 @@ int CMeterString::GetY(bool abs)
** Create the font that is used to draw the text.
**
*/
void CMeterString::Initialize()
void MeterString::Initialize()
{
CMeter::Initialize();
Meter::Initialize();
m_TextFormat->SetProperties(
m_FontFace.c_str(),
@@ -164,14 +164,14 @@ void CMeterString::Initialize()
** Read the options specified in the ini file.
**
*/
void CMeterString::ReadOptions(CConfigParser& parser, const WCHAR* section)
void MeterString::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
// Store the current font values so we know if the font needs to be updated
std::wstring oldFontFace = m_FontFace;
int oldFontSize = m_FontSize;
TEXTSTYLE oldStyle = m_Style;
CMeter::ReadOptions(parser, section);
Meter::ReadOptions(parser, section);
m_Color = parser.ReadColor(section, L"FontColor", Color::Black);
m_EffectColor = parser.ReadColor(section, L"FontEffectColor", Color::Black);
@@ -348,9 +348,9 @@ void CMeterString::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the value(s) from the measures.
**
*/
bool CMeterString::Update()
bool MeterString::Update()
{
if (CMeter::Update())
if (Meter::Update())
{
int decimals = (m_NumOfDecimals != -1) ? m_NumOfDecimals : (m_NoDecimals && (m_Percentual || m_AutoScale == AUTOSCALE_OFF)) ? 0 : 1;
@@ -414,9 +414,9 @@ bool CMeterString::Update()
** Draws the meter on the double buffer
**
*/
bool CMeterString::Draw(Gfx::Canvas& canvas)
bool MeterString::Draw(Gfx::Canvas& canvas)
{
if (!CMeter::Draw(canvas)) return false;
if (!Meter::Draw(canvas)) return false;
return DrawString(canvas, NULL);
}
@@ -425,7 +425,7 @@ bool CMeterString::Draw(Gfx::Canvas& canvas)
** Draws the string or calculates it's size
**
*/
bool CMeterString::DrawString(Gfx::Canvas& canvas, RectF* rect)
bool MeterString::DrawString(Gfx::Canvas& canvas, RectF* rect)
{
if (!m_TextFormat->IsInitialized()) return false;
@@ -585,7 +585,7 @@ bool CMeterString::DrawString(Gfx::Canvas& canvas, RectF* rect)
** Overridden method. The string meters need not to be bound on anything
**
*/
void CMeterString::BindMeasures(CConfigParser& parser, const WCHAR* section)
void MeterString::BindMeasures(ConfigParser& parser, const WCHAR* section)
{
if (BindPrimaryMeasure(parser, section, true))
{
@@ -597,7 +597,7 @@ void CMeterString::BindMeasures(CConfigParser& parser, const WCHAR* section)
** Static helper to log all installed font families.
**
*/
void CMeterString::EnumerateInstalledFontFamilies()
void MeterString::EnumerateInstalledFontFamilies()
{
INT fontCount;
InstalledFontCollection fontCollection;
@@ -647,9 +647,9 @@ void CMeterString::EnumerateInstalledFontFamilies()
}
}
void CMeterString::InitializeStatic()
void MeterString::InitializeStatic()
{
if (Rainmeter->GetDebug())
if (g_Rainmeter->GetDebug())
{
LogDebug(L"------------------------------");
LogDebug(L"* Font families:");
@@ -658,6 +658,6 @@ void CMeterString::InitializeStatic()
}
}
void CMeterString::FinalizeStatic()
void MeterString::FinalizeStatic()
{
}

12
Library/MeterString.h
View File

@@ -23,13 +23,13 @@
#include "Measure.h"
#include <unordered_map>
class CMeterString : public CMeter
class MeterString : public Meter
{
public:
CMeterString(CMeterWindow* meterWindow, const WCHAR* name);
virtual ~CMeterString();
MeterString(MeterWindow* meterWindow, const WCHAR* name);
virtual ~MeterString();
virtual UINT GetTypeID() { return TypeID<CMeterString>(); }
virtual UINT GetTypeID() { return TypeID<MeterString>(); }
virtual int GetX(bool abs = false);
virtual int GetY(bool abs = false);
@@ -46,8 +46,8 @@ public:
static void FinalizeStatic();
protected:
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
virtual void BindMeasures(ConfigParser& parser, const WCHAR* section);
virtual bool IsFixedSize(bool overwrite = false) { return overwrite; }

504
Library/MeterWindow.cpp
View File

File diff suppressed because it is too large Load Diff

40
Library/MeterWindow.h
View File

@@ -99,9 +99,9 @@ enum RESIZEMODE
RESIZEMODE_RESET
};
class CRainmeter;
class CMeasure;
class CMeter;
class Rainmeter;
class Measure;
class Meter;
namespace Gfx {
class Canvas;
@@ -109,11 +109,11 @@ class FontCollection;
class TextFormat;
}
class CMeterWindow : public CGroup
class MeterWindow : public Group
{
public:
CMeterWindow(const std::wstring& folderPath, const std::wstring& file);
~CMeterWindow();
MeterWindow(const std::wstring& folderPath, const std::wstring& file);
~MeterWindow();
void Initialize();
@@ -154,7 +154,7 @@ public:
Gfx::Canvas& GetCanvas() { return *m_Canvas; }
HWND GetWindow() { return m_Window; }
CConfigParser& GetParser() { return m_Parser; }
ConfigParser& GetParser() { return m_Parser; }
const std::wstring& GetFolderPath() { return m_FolderPath; }
const std::wstring& GetFileName() { return m_FileName; }
@@ -162,8 +162,8 @@ public:
std::wstring GetRootPath();
std::wstring GetResourcesPath();
const std::vector<CMeasure*>& GetMeasures() { return m_Measures; }
const std::vector<CMeter*>& GetMeters() { return m_Meters; }
const std::vector<Measure*>& GetMeasures() { return m_Measures; }
const std::vector<Meter*>& GetMeters() { return m_Meters; }
ZPOSITION GetWindowZPosition() { return m_WindowZPosition; }
bool GetXPercentage() { return m_WindowXPercentage; }
@@ -196,16 +196,16 @@ public:
bool IsClosing() { return m_State == STATE_CLOSING; }
const CMouse& GetMouse() { return m_Mouse; }
const Mouse& GetMouse() { return m_Mouse; }
void MakePathAbsolute(std::wstring& path);
Gfx::FontCollection* GetFontCollection() { return m_FontCollection; }
CMeter* GetMeter(const std::wstring& meterName);
CMeasure* GetMeasure(const std::wstring& measureName) { return m_Parser.GetMeasure(measureName); }
Meter* GetMeter(const std::wstring& meterName);
Measure* GetMeasure(const std::wstring& measureName) { return m_Parser.GetMeasure(measureName); }
friend class CDialogManage;
friend class DialogManage;
protected:
static LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
@@ -277,13 +277,13 @@ private:
bool HitTest(int x, int y);
void SnapToWindow(CMeterWindow* window, LPWINDOWPOS wp);
void SnapToWindow(MeterWindow* window, LPWINDOWPOS wp);
void MapCoordsToScreen(int& x, int& y, int w, int h);
void WindowToScreen();
void ScreenToWindow();
void PostUpdate(bool bActiveTransition);
bool UpdateMeasure(CMeasure* measure, bool force);
bool UpdateMeter(CMeter* meter, bool& bActiveTransition, bool force);
bool UpdateMeasure(Measure* measure, bool force);
bool UpdateMeter(Meter* meter, bool& bActiveTransition, bool force);
void Update(bool refresh);
void UpdateWindow(int alpha, bool reset, bool canvasBeginDrawCalled = false);
void UpdateWindowTransparency(int alpha);
@@ -321,14 +321,14 @@ private:
Gfx::Canvas* m_Canvas;
CConfigParser m_Parser;
ConfigParser m_Parser;
Gdiplus::Bitmap* m_Background;
SIZE m_BackgroundSize;
HWND m_Window;
CMouse m_Mouse;
Mouse m_Mouse;
bool m_MouseOver;
bool m_MouseInputRegistered;
bool m_HasMouseScrollAction;
@@ -404,8 +404,8 @@ private:
bool m_Hidden;
RESIZEMODE m_ResizeWindow;
std::vector<CMeasure*> m_Measures;
std::vector<CMeter*> m_Meters;
std::vector<Measure*> m_Measures;
std::vector<Meter*> m_Meters;
const std::wstring m_FolderPath;
const std::wstring m_FileName;

16
Library/Mouse.cpp
View File

@@ -23,19 +23,19 @@
#include "Logger.h"
#include "Mouse.h"
CMouse::CMouse(CMeterWindow* meterWindow, CMeter* meter) : m_MeterWindow(meterWindow), m_Meter(meter),
Mouse::Mouse(MeterWindow* meterWindow, Meter* meter) : m_MeterWindow(meterWindow), m_Meter(meter),
m_CursorType(MOUSECURSOR_HAND),
m_CustomCursor(),
m_CursorState(true)
{
}
CMouse::~CMouse()
Mouse::~Mouse()
{
DestroyCustomCursor();
}
void CMouse::ReadOptions(CConfigParser& parser, const WCHAR* section)
void Mouse::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
DestroyCustomCursor();
@@ -135,7 +135,7 @@ void CMouse::ReadOptions(CConfigParser& parser, const WCHAR* section)
}
}
HCURSOR CMouse::GetCursor() const
HCURSOR Mouse::GetCursor() const
{
LPCWSTR name = IDC_ARROW;
switch (m_CursorType)
@@ -177,14 +177,14 @@ HCURSOR CMouse::GetCursor() const
return LoadCursor(NULL, name);
}
std::wstring CMouse::GetActionCommand(MOUSEACTION action) const
std::wstring Mouse::GetActionCommand(MOUSEACTION action) const
{
std::wstring command = m_MouseActions[action];
ReplaceMouseVariables(command);
return command;
}
void CMouse::DestroyCustomCursor()
void Mouse::DestroyCustomCursor()
{
if (m_CustomCursor)
{
@@ -193,7 +193,7 @@ void CMouse::DestroyCustomCursor()
}
}
void CMouse::ReplaceMouseVariables(std::wstring& result) const
void Mouse::ReplaceMouseVariables(std::wstring& result) const
{
// Check for variables ($VAR$)
size_t start = 0, end;
@@ -244,7 +244,7 @@ void CMouse::ReplaceMouseVariables(std::wstring& result) const
while (loop);
}
std::wstring CMouse::GetMouseVariable(const std::wstring& variable) const
std::wstring Mouse::GetMouseVariable(const std::wstring& variable) const
{
std::wstring result;
LPCWSTR var = variable.c_str();

12
Library/Mouse.h
View File

@@ -60,13 +60,13 @@ enum MOUSECURSOR
MOUSECURSOR_CUSTOM
};
class CMouse
class Mouse
{
public:
CMouse(CMeterWindow* meterWindow, CMeter* meter = NULL);
~CMouse();
Mouse(MeterWindow* meterWindow, Meter* meter = NULL);
~Mouse();
void ReadOptions(CConfigParser& parser, const WCHAR* section);
void ReadOptions(ConfigParser& parser, const WCHAR* section);
MOUSECURSOR GetCursorType() const { return m_CursorType; }
HCURSOR GetCursor() const;
@@ -142,8 +142,8 @@ private:
HCURSOR m_CustomCursor;
bool m_CursorState;
CMeterWindow* m_MeterWindow;
CMeter* m_Meter;
MeterWindow* m_MeterWindow;
Meter* m_Meter;
};
#endif

314
Library/Rainmeter.cpp
View File

File diff suppressed because it is too large Load Diff

62
Library/Rainmeter.h
View File

@@ -53,10 +53,10 @@ struct GlobalOptions
double netOutSpeed;
};
class CConfigParser;
class CTrayWindow;
class ConfigParser;
class TrayWindow;
class CRainmeter
class Rainmeter
{
public:
struct SkinFolder
@@ -90,8 +90,8 @@ public:
}
};
CRainmeter();
~CRainmeter();
Rainmeter();
~Rainmeter();
int Initialize(LPCWSTR iniPath, LPCWSTR layout);
bool IsAlreadyRunning();
@@ -99,22 +99,22 @@ public:
void SetNetworkStatisticsTimer();
CConfigParser* GetCurrentParser() { return m_CurrentParser; }
void SetCurrentParser(CConfigParser* parser) { m_CurrentParser = parser; }
ConfigParser* GetCurrentParser() { return m_CurrentParser; }
void SetCurrentParser(ConfigParser* parser) { m_CurrentParser = parser; }
CTrayWindow* GetTrayWindow() { return m_TrayWindow; }
TrayWindow* GetTrayWindow() { return m_TrayWindow; }
bool HasMeterWindow(const CMeterWindow* meterWindow) const;
bool HasMeterWindow(const MeterWindow* meterWindow) const;
CMeterWindow* GetMeterWindow(const std::wstring& folderPath);
CMeterWindow* GetMeterWindowByINI(const std::wstring& ini_searching);
MeterWindow* GetMeterWindow(const std::wstring& folderPath);
MeterWindow* GetMeterWindowByINI(const std::wstring& ini_searching);
std::pair<int, int> GetMeterWindowIndex(const std::wstring& folderPath, const std::wstring& file);
std::pair<int, int> GetMeterWindowIndex(CMeterWindow* meterWindow) { return GetMeterWindowIndex(meterWindow->GetFolderPath(), meterWindow->GetFileName()); }
std::pair<int, int> GetMeterWindowIndex(MeterWindow* meterWindow) { return GetMeterWindowIndex(meterWindow->GetFolderPath(), meterWindow->GetFileName()); }
std::pair<int, int> GetMeterWindowIndex(UINT menuCommand);
CMeterWindow* GetMeterWindow(HWND hwnd);
void GetMeterWindowsByLoadOrder(std::multimap<int, CMeterWindow*>& windows, const std::wstring& group = std::wstring());
std::map<std::wstring, CMeterWindow*>& GetAllMeterWindows() { return m_MeterWindows; }
MeterWindow* GetMeterWindow(HWND hwnd);
void GetMeterWindowsByLoadOrder(std::multimap<int, MeterWindow*>& windows, const std::wstring& group = std::wstring());
std::map<std::wstring, MeterWindow*>& GetAllMeterWindows() { return m_MeterWindows; }
std::wstring GetFolderPath(int folderIndex);
int FindSkinFolderIndex(const std::wstring& folderPath);
@@ -122,12 +122,12 @@ public:
const std::vector<SkinFolder>& GetFolders() { return m_SkinFolders; }
const std::vector<std::wstring>& GetAllLayouts() { return m_Layouts; }
void RemoveMeterWindow(CMeterWindow* meterWindow);
void AddUnmanagedMeterWindow(CMeterWindow* meterWindow);
void RemoveUnmanagedMeterWindow(CMeterWindow* meterWindow);
void RemoveMeterWindow(MeterWindow* meterWindow);
void AddUnmanagedMeterWindow(MeterWindow* meterWindow);
void RemoveUnmanagedMeterWindow(MeterWindow* meterWindow);
void ActivateSkin(int folderIndex, int fileIndex);
void DeactivateSkin(CMeterWindow* meterWindow, int folderIndex, bool save = true);
void DeactivateSkin(MeterWindow* meterWindow, int folderIndex, bool save = true);
void ToggleSkin(int folderIndex, int fileIndex);
const std::wstring& GetPath() { return m_Path; }
@@ -196,15 +196,15 @@ public:
int ShowMessage(HWND parent, const WCHAR* text, UINT type);
bool IsMenuActive() { return m_MenuActive; }
void ShowContextMenu(POINT pos, CMeterWindow* meterWindow);
void ShowContextMenu(POINT pos, MeterWindow* meterWindow);
const std::wstring& GetTrayExecuteR() { return m_TrayExecuteR; }
const std::wstring& GetTrayExecuteM() { return m_TrayExecuteM; }
const std::wstring& GetTrayExecuteDR() { return m_TrayExecuteDR; }
const std::wstring& GetTrayExecuteDM() { return m_TrayExecuteDM; }
void ExecuteBang(const WCHAR* bang, std::vector<std::wstring>& args, CMeterWindow* meterWindow);
void ExecuteCommand(const WCHAR* command, CMeterWindow* meterWindow, bool multi = true);
void ExecuteBang(const WCHAR* bang, std::vector<std::wstring>& args, MeterWindow* meterWindow);
void ExecuteCommand(const WCHAR* command, MeterWindow* meterWindow, bool multi = true);
void DelayedExecuteCommand(const WCHAR* command);
void RefreshAll();
@@ -215,8 +215,8 @@ public:
static std::wstring ExtractPath(const std::wstring& strFilePath);
static void ExpandEnvironmentVariables(std::wstring& strPath);
friend class CCommandHandler;
friend class CDialogManage;
friend class CommandHandler;
friend class DialogManage;
private:
static LRESULT CALLBACK MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
@@ -232,7 +232,7 @@ private:
void SetLoadOrder(int folderIndex, int order);
int GetLoadOrder(const std::wstring& folderPath);
void UpdateDesktopWorkArea(bool reset);
HMENU CreateSkinMenu(CMeterWindow* meterWindow, int index, HMENU menu);
HMENU CreateSkinMenu(MeterWindow* meterWindow, int index, HMENU menu);
void ChangeSkinIndex(HMENU subMenu, int index);
int ScanForSkinsRecursive(const std::wstring& path, std::wstring base, int index, UINT level);
@@ -240,18 +240,18 @@ private:
int CreateAllSkinsMenuRecursive(HMENU skinMenu, int index);
void CreateLayoutMenu(HMENU layoutMenu);
void CreateMonitorMenu(HMENU monitorMenu, CMeterWindow* meterWindow);
void CreateMonitorMenu(HMENU monitorMenu, MeterWindow* meterWindow);
void CreateOptionsFile();
void CreateDataFile();
void CreateComponentFolders(bool defaultIniLocation);
void TestSettingsFile(bool bDefaultIniLocation);
CTrayWindow* m_TrayWindow;
TrayWindow* m_TrayWindow;
std::vector<SkinFolder> m_SkinFolders;
std::multimap<int, int> m_SkinOrders;
std::map<std::wstring, CMeterWindow*> m_MeterWindows;
std::list<CMeterWindow*> m_UnmanagedMeterWindows;
std::map<std::wstring, MeterWindow*> m_MeterWindows;
std::list<MeterWindow*> m_UnmanagedMeterWindows;
std::vector<std::wstring> m_Layouts;
std::wstring m_Path;
@@ -292,9 +292,9 @@ private:
std::wstring m_SkinEditor;
CCommandHandler m_CommandHandler;
CommandHandler m_CommandHandler;
CConfigParser* m_CurrentParser;
ConfigParser* m_CurrentParser;
HWND m_Window;

14
Library/RawString.h
View File

@@ -21,37 +21,37 @@
#include <windows.h>
class CRawString
class RawString
{
public:
CRawString() :
RawString() :
m_String()
{
}
CRawString(const WCHAR* str) :
RawString(const WCHAR* str) :
m_String(str_alloc(str))
{
}
CRawString(const CRawString& rhs) :
RawString(const RawString& rhs) :
m_String(str_alloc(rhs.c_str()))
{
}
~CRawString()
~RawString()
{
clear();
}
CRawString& operator=(const WCHAR* rhs)
RawString& operator=(const WCHAR* rhs)
{
clear();
m_String = str_alloc(rhs);
return *this;
}
CRawString& operator=(const CRawString& rhs)
RawString& operator=(const RawString& rhs)
{
if (&rhs != this)
{

14
Library/Section.cpp
View File

@@ -21,13 +21,13 @@
#include "ConfigParser.h"
#include "Rainmeter.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** The constructor
**
*/
CSection::CSection(CMeterWindow* meterWindow, const WCHAR* name) : m_MeterWindow(meterWindow), m_Name(name),
Section::Section(MeterWindow* meterWindow, const WCHAR* name) : m_MeterWindow(meterWindow), m_Name(name),
m_DynamicVariables(false),
m_UpdateDivider(1),
m_UpdateCounter(1)
@@ -38,7 +38,7 @@ CSection::CSection(CMeterWindow* meterWindow, const WCHAR* name) : m_MeterWindow
** The destructor
**
*/
CSection::~CSection()
Section::~Section()
{
}
@@ -47,7 +47,7 @@ CSection::~CSection()
** call this base implementation if they overwrite this method.
**
*/
void CSection::ReadOptions(CConfigParser& parser, const WCHAR* section)
void Section::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
int updateDivider = parser.ReadInt(section, L"UpdateDivider", 1);
if (updateDivider != m_UpdateDivider)
@@ -67,7 +67,7 @@ void CSection::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Updates the counter value
**
*/
bool CSection::UpdateCounter()
bool Section::UpdateCounter()
{
++m_UpdateCounter;
if (m_UpdateCounter < m_UpdateDivider) return false;
@@ -80,10 +80,10 @@ bool CSection::UpdateCounter()
** Execute OnUpdateAction if action is set
**
*/
void CSection::DoUpdateAction()
void Section::DoUpdateAction()
{
if (!m_OnUpdateAction.empty())
{
Rainmeter->ExecuteCommand(m_OnUpdateAction.c_str(), m_MeterWindow);
g_Rainmeter->ExecuteCommand(m_OnUpdateAction.c_str(), m_MeterWindow);
}
}

16
Library/Section.h
View File

@@ -23,13 +23,13 @@
#include <string>
#include "Group.h"
class CMeterWindow;
class CConfigParser;
class MeterWindow;
class ConfigParser;
class __declspec(novtable) CSection : public CGroup
class __declspec(novtable) Section : public Group
{
public:
virtual ~CSection();
virtual ~Section();
virtual UINT GetTypeID() = 0;
@@ -46,12 +46,12 @@ public:
const std::wstring& GetOnUpdateAction() { return m_OnUpdateAction; }
void DoUpdateAction();
CMeterWindow* GetMeterWindow() { return m_MeterWindow; }
MeterWindow* GetMeterWindow() { return m_MeterWindow; }
protected:
CSection(CMeterWindow* meterWindow, const WCHAR* name);
Section(MeterWindow* meterWindow, const WCHAR* name);
virtual void ReadOptions(CConfigParser& parser, const WCHAR* section);
virtual void ReadOptions(ConfigParser& parser, const WCHAR* section);
bool UpdateCounter();
@@ -63,7 +63,7 @@ protected:
std::wstring m_OnUpdateAction;
CMeterWindow* m_MeterWindow;
MeterWindow* m_MeterWindow;
};
#endif

118
Library/System.cpp
View File

@@ -42,26 +42,26 @@ enum INTERVAL
INTERVAL_RESUME = 1000
};
MultiMonitorInfo CSystem::c_Monitors = { 0 };
MultiMonitorInfo System::c_Monitors = { 0 };
HWND CSystem::c_Window = NULL;
HWND CSystem::c_HelperWindow = NULL;
HWND System::c_Window = NULL;
HWND System::c_HelperWindow = NULL;
HWINEVENTHOOK CSystem::c_WinEventHook = NULL;
HWINEVENTHOOK System::c_WinEventHook = NULL;
bool CSystem::c_ShowDesktop = false;
bool System::c_ShowDesktop = false;
std::wstring CSystem::c_WorkingDirectory;
std::wstring System::c_WorkingDirectory;
std::vector<std::wstring> CSystem::c_IniFileMappings;
std::vector<std::wstring> System::c_IniFileMappings;
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
/*
** Creates a helper window to detect changes in the system.
**
*/
void CSystem::Initialize(HINSTANCE instance)
void System::Initialize(HINSTANCE instance)
{
WNDCLASS wc = {0};
wc.lpfnWndProc = (WNDPROC)WndProc;
@@ -123,7 +123,7 @@ void CSystem::Initialize(HINSTANCE instance)
** Destroys a window.
**
*/
void CSystem::Finalize()
void System::Finalize()
{
KillTimer(c_Window, TIMER_SHOWDESKTOP);
KillTimer(c_Window, TIMER_RESUME);
@@ -159,7 +159,7 @@ BOOL CALLBACK MyInfoEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonit
info.cbSize = sizeof(MONITORINFOEX);
GetMonitorInfo(hMonitor, &info);
if (Rainmeter->GetDebug())
if (g_Rainmeter->GetDebug())
{
LogDebug(info.szDevice);
LogDebugF(L" Flags : %s(0x%08X)", (info.dwFlags & MONITORINFOF_PRIMARY) ? L"PRIMARY " : L"", info.dwFlags);
@@ -225,7 +225,7 @@ BOOL CALLBACK MyInfoEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonit
** Returns the number of monitors.
**
*/
size_t CSystem::GetMonitorCount()
size_t System::GetMonitorCount()
{
if (c_Monitors.monitors.empty())
{
@@ -238,10 +238,10 @@ size_t CSystem::GetMonitorCount()
** Sets the multi-monitor information.
**
*/
void CSystem::SetMultiMonitorInfo()
void System::SetMultiMonitorInfo()
{
std::vector<MonitorInfo>& monitors = c_Monitors.monitors;
bool logging = Rainmeter->GetDebug();
bool logging = g_Rainmeter->GetDebug();
c_Monitors.vsT = GetSystemMetrics(SM_YVIRTUALSCREEN);
c_Monitors.vsL = GetSystemMetrics(SM_XVIRTUALSCREEN);
@@ -509,7 +509,7 @@ void CSystem::SetMultiMonitorInfo()
** Updates the workarea information.
**
*/
void CSystem::UpdateWorkareaInfo()
void System::UpdateWorkareaInfo()
{
std::vector<MonitorInfo>& monitors = c_Monitors.monitors;
@@ -529,7 +529,7 @@ void CSystem::UpdateWorkareaInfo()
(*iter).work = info.rcWork;
if (Rainmeter->GetDebug())
if (g_Rainmeter->GetDebug())
{
LogDebugF(L"WorkArea@%i : L=%i, T=%i, R=%i, B=%i (W=%i, H=%i)",
i,
@@ -544,7 +544,7 @@ void CSystem::UpdateWorkareaInfo()
** Finds the Default Shell's window.
**
*/
HWND CSystem::GetDefaultShellWindow()
HWND System::GetDefaultShellWindow()
{
static HWND c_ShellW = NULL; // cache
HWND ShellW = GetShellWindow();
@@ -576,7 +576,7 @@ HWND CSystem::GetDefaultShellWindow()
** If the WorkerW window is not active, returns NULL.
**
*/
HWND CSystem::GetWorkerW()
HWND System::GetWorkerW()
{
static HWND c_DefView = NULL; // cache
HWND ShellW = GetDefaultShellWindow();
@@ -627,14 +627,14 @@ HWND CSystem::GetWorkerW()
** ZPOSITION_BOTTOM, or ZPOSITION_NORMAL.
**
*/
HWND CSystem::GetBackmostTopWindow()
HWND System::GetBackmostTopWindow()
{
HWND winPos = c_HelperWindow;
// Skip all ZPOSITION_ONDESKTOP, ZPOSITION_BOTTOM, and ZPOSITION_NORMAL windows
while (winPos = ::GetNextWindow(winPos, GW_HWNDPREV))
{
CMeterWindow* wnd = Rainmeter->GetMeterWindow(winPos);
MeterWindow* wnd = g_Rainmeter->GetMeterWindow(winPos);
if (!wnd ||
(wnd->GetWindowZPosition() != ZPOSITION_NORMAL &&
wnd->GetWindowZPosition() != ZPOSITION_ONDESKTOP &&
@@ -651,7 +651,7 @@ HWND CSystem::GetBackmostTopWindow()
** Checks whether the given windows belong to the same process.
**
*/
bool CSystem::BelongToSameProcess(HWND hwndA, HWND hwndB)
bool System::BelongToSameProcess(HWND hwndA, HWND hwndB)
{
DWORD procAId = 0, procBId = 0;
@@ -667,24 +667,24 @@ bool CSystem::BelongToSameProcess(HWND hwndA, HWND hwndB)
*/
BOOL CALLBACK MyEnumWindowsProc(HWND hwnd, LPARAM lParam)
{
bool logging = Rainmeter->GetDebug() && DEBUG_VERBOSE;
bool logging = g_Rainmeter->GetDebug() && DEBUG_VERBOSE;
const int classLen = _countof(METERWINDOW_CLASS_NAME) + (DEBUG_VERBOSE ? 32 : 1);
WCHAR className[classLen];
CMeterWindow* Window;
MeterWindow* Window;
WCHAR flag;
if (GetClassName(hwnd, className, classLen) > 0 &&
wcscmp(className, METERWINDOW_CLASS_NAME) == 0 &&
(Window = Rainmeter->GetMeterWindow(hwnd)))
(Window = g_Rainmeter->GetMeterWindow(hwnd)))
{
ZPOSITION zPos = Window->GetWindowZPosition();
if (zPos == ZPOSITION_ONDESKTOP ||
(zPos == ZPOSITION_NORMAL && Rainmeter->IsNormalStayDesktop()) ||
(zPos == ZPOSITION_NORMAL && g_Rainmeter->IsNormalStayDesktop()) ||
zPos == ZPOSITION_ONBOTTOM)
{
if (lParam)
{
((std::vector<CMeterWindow*>*)lParam)->push_back(Window);
((std::vector<MeterWindow*>*)lParam)->push_back(Window);
}
if (logging) flag = L'+';
@@ -704,7 +704,7 @@ BOOL CALLBACK MyEnumWindowsProc(HWND hwnd, LPARAM lParam)
{
if (logging)
{
flag = (hwnd == CSystem::GetHelperWindow()) ? L'o' : ' ';
flag = (hwnd == System::GetHelperWindow()) ? L'o' : ' ';
LogDebugF(L"%c [%c] 0x%p : %s", flag, IsWindowVisible(hwnd) ? L'V' : L'H', hwnd, className);
}
}
@@ -716,10 +716,10 @@ BOOL CALLBACK MyEnumWindowsProc(HWND hwnd, LPARAM lParam)
** Arranges the meter window in Z-order.
**
*/
void CSystem::ChangeZPosInOrder()
void System::ChangeZPosInOrder()
{
bool logging = Rainmeter->GetDebug() && DEBUG_VERBOSE;
std::vector<CMeterWindow*> windowsInZOrder;
bool logging = g_Rainmeter->GetDebug() && DEBUG_VERBOSE;
std::vector<MeterWindow*> windowsInZOrder;
if (logging) LogDebug(L"1: ----- BEFORE -----");
@@ -729,7 +729,7 @@ void CSystem::ChangeZPosInOrder()
auto resetZPos = [&](ZPOSITION zpos)
{
// Reset ZPos in Z-order (Bottom)
std::vector<CMeterWindow*>::const_iterator iter = windowsInZOrder.begin();
std::vector<MeterWindow*>::const_iterator iter = windowsInZOrder.begin();
for ( ; iter != windowsInZOrder.end(); ++iter)
{
if ((*iter)->GetWindowZPosition() == zpos)
@@ -739,7 +739,7 @@ void CSystem::ChangeZPosInOrder()
}
};
if (Rainmeter->IsNormalStayDesktop())
if (g_Rainmeter->IsNormalStayDesktop())
{
resetZPos(ZPOSITION_NORMAL);
}
@@ -764,9 +764,9 @@ void CSystem::ChangeZPosInOrder()
** Moves the helper window to the reference position.
**
*/
void CSystem::PrepareHelperWindow(HWND WorkerW)
void System::PrepareHelperWindow(HWND WorkerW)
{
bool logging = Rainmeter->GetDebug() && DEBUG_VERBOSE;
bool logging = g_Rainmeter->GetDebug() && DEBUG_VERBOSE;
SetWindowPos(c_Window, HWND_BOTTOM, 0, 0, 0, 0, ZPOS_FLAGS); // always on bottom
@@ -834,7 +834,7 @@ void CSystem::PrepareHelperWindow(HWND WorkerW)
** Changes the "Show Desktop" state.
**
*/
bool CSystem::CheckDesktopState(HWND WorkerW)
bool System::CheckDesktopState(HWND WorkerW)
{
HWND hwnd = NULL;
@@ -849,7 +849,7 @@ bool CSystem::CheckDesktopState(HWND WorkerW)
{
c_ShowDesktop = !c_ShowDesktop;
if (Rainmeter->GetDebug())
if (g_Rainmeter->GetDebug())
{
LogDebugF(L"System: \"Show %s\" has been detected.",
c_ShowDesktop ? L"desktop" : L"open windows");
@@ -876,7 +876,7 @@ bool CSystem::CheckDesktopState(HWND WorkerW)
** The event hook procedure
**
*/
void CALLBACK CSystem::MyWinEventProc(HWINEVENTHOOK hWinEventHook, DWORD event, HWND hwnd, LONG idObject, LONG idChild, DWORD dwEventThread, DWORD dwmsEventTime)
void CALLBACK System::MyWinEventProc(HWINEVENTHOOK hWinEventHook, DWORD event, HWND hwnd, LONG idObject, LONG idChild, DWORD dwEventThread, DWORD dwmsEventTime)
{
if (event == EVENT_SYSTEM_FOREGROUND)
{
@@ -914,7 +914,7 @@ void CALLBACK CSystem::MyWinEventProc(HWINEVENTHOOK hWinEventHook, DWORD event,
** The window procedure
**
*/
LRESULT CALLBACK CSystem::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT CALLBACK System::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (hWnd != c_Window)
{
@@ -944,10 +944,10 @@ LRESULT CALLBACK CSystem::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lP
case TIMER_RESUME:
KillTimer(hWnd, TIMER_RESUME);
if (Rainmeter->IsRedrawable())
if (g_Rainmeter->IsRedrawable())
{
std::map<std::wstring, CMeterWindow*>::const_iterator iter = Rainmeter->GetAllMeterWindows().begin();
for ( ; iter != Rainmeter->GetAllMeterWindows().end(); ++iter)
std::map<std::wstring, MeterWindow*>::const_iterator iter = g_Rainmeter->GetAllMeterWindows().begin();
for ( ; iter != g_Rainmeter->GetAllMeterWindows().end(); ++iter)
{
(*iter).second->RedrawWindow();
}
@@ -959,7 +959,7 @@ LRESULT CALLBACK CSystem::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lP
case WM_DISPLAYCHANGE:
LogNotice(L"System: Display settings changed");
ClearMultiMonitorInfo();
CConfigParser::ClearMultiMonitorVariables();
ConfigParser::ClearMultiMonitorVariables();
case WM_SETTINGCHANGE:
if (uMsg == WM_DISPLAYCHANGE || (/*uMsg == WM_SETTINGCHANGE &&*/ wParam == SPI_SETWORKAREA))
{
@@ -967,12 +967,12 @@ LRESULT CALLBACK CSystem::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lP
{
LogNotice(L"System: Work area changed");
UpdateWorkareaInfo();
CConfigParser::UpdateWorkareaVariables();
ConfigParser::UpdateWorkareaVariables();
}
// Deliver WM_DISPLAYCHANGE / WM_SETTINGCHANGE message to all meter windows
std::map<std::wstring, CMeterWindow*>::const_iterator iter = Rainmeter->GetAllMeterWindows().begin();
for ( ; iter != Rainmeter->GetAllMeterWindows().end(); ++iter)
std::map<std::wstring, MeterWindow*>::const_iterator iter = g_Rainmeter->GetAllMeterWindows().begin();
for ( ; iter != g_Rainmeter->GetAllMeterWindows().end(); ++iter)
{
PostMessage((*iter).second->GetWindow(), WM_METERWINDOW_DELAYED_MOVE, (WPARAM)uMsg, (LPARAM)0);
}
@@ -999,7 +999,7 @@ LRESULT CALLBACK CSystem::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lP
** In XP, returns the predictive value due to the 32bit limitation.
**
*/
ULONGLONG CSystem::GetTickCount64()
ULONGLONG System::GetTickCount64()
{
typedef ULONGLONG (WINAPI * FPGETTICKCOUNT64)();
static FPGETTICKCOUNT64 c_GetTickCount64 = (FPGETTICKCOUNT64)GetProcAddress(GetModuleHandle(L"kernel32"), "GetTickCount64");
@@ -1022,7 +1022,7 @@ ULONGLONG CSystem::GetTickCount64()
** Gets the cursor position in last message retrieved by GetMessage().
**
*/
POINT CSystem::GetCursorPosition()
POINT System::GetCursorPosition()
{
DWORD pos = GetMessagePos();
POINT pt = { GET_X_LPARAM(pos), GET_Y_LPARAM(pos) };
@@ -1033,7 +1033,7 @@ POINT CSystem::GetCursorPosition()
** Checks if file is writable.
**
*/
bool CSystem::IsFileWritable(LPCWSTR file)
bool System::IsFileWritable(LPCWSTR file)
{
HANDLE hFile = CreateFile(file, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hFile == INVALID_HANDLE_VALUE)
@@ -1051,7 +1051,7 @@ bool CSystem::IsFileWritable(LPCWSTR file)
** Avoids loading a DLL from current directory.
**
*/
HMODULE CSystem::RmLoadLibrary(LPCWSTR lpLibFileName, DWORD* dwError)
HMODULE System::RmLoadLibrary(LPCWSTR lpLibFileName, DWORD* dwError)
{
// Remove current directory from DLL search path
SetDllDirectory(L"");
@@ -1071,7 +1071,7 @@ HMODULE CSystem::RmLoadLibrary(LPCWSTR lpLibFileName, DWORD* dwError)
** Resets working directory to default.
**
*/
void CSystem::ResetWorkingDirectory()
void System::ResetWorkingDirectory()
{
WCHAR directory[MAX_PATH] = {0};
GetCurrentDirectory(MAX_PATH, directory);
@@ -1088,7 +1088,7 @@ void CSystem::ResetWorkingDirectory()
** For more details: http://stackoverflow.com/questions/804848/critical-sections-leaking-memory-on-vista-win2008/
**
*/
void CSystem::InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
void System::InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
typedef BOOL (WINAPI * FPINITCRITEX)(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount, DWORD Flags);
static FPINITCRITEX InitializeCriticalSectionEx = Platform::IsAtLeastWinVista() ?
@@ -1109,7 +1109,7 @@ void CSystem::InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
** Sets clipboard text to given string.
**
*/
void CSystem::SetClipboardText(const std::wstring& text)
void System::SetClipboardText(const std::wstring& text)
{
if (OpenClipboard(NULL))
{
@@ -1138,7 +1138,7 @@ void CSystem::SetClipboardText(const std::wstring& text)
** Sets the system wallpapar.
**
*/
void CSystem::SetWallpaper(const std::wstring& wallpaper, const std::wstring& style)
void System::SetWallpaper(const std::wstring& wallpaper, const std::wstring& style)
{
if (!wallpaper.empty())
{
@@ -1151,7 +1151,7 @@ void CSystem::SetWallpaper(const std::wstring& wallpaper, const std::wstring& st
Bitmap* bitmap = Bitmap::FromFile(wallpaper.c_str());
if (bitmap && bitmap->GetLastStatus() == Ok)
{
std::wstring file = Rainmeter->GetSettingsPath() + L"Wallpaper.bmp";
std::wstring file = g_Rainmeter->GetSettingsPath() + L"Wallpaper.bmp";
const CLSID bmpClsid = { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } };
if (bitmap->Save(file.c_str(), &bmpClsid) == Ok)
@@ -1214,7 +1214,7 @@ void CSystem::SetWallpaper(const std::wstring& wallpaper, const std::wstring& st
** Copies files and folders from one location to another.
**
*/
bool CSystem::CopyFiles(std::wstring from, std::wstring to, bool bMove)
bool System::CopyFiles(std::wstring from, std::wstring to, bool bMove)
{
// If given "from" path ends with path separator, remove it (Workaround for XP: error code 1026)
size_t len;
@@ -1249,7 +1249,7 @@ bool CSystem::CopyFiles(std::wstring from, std::wstring to, bool bMove)
** Removes a file even if a file is read-only.
**
*/
bool CSystem::RemoveFile(const std::wstring& file)
bool System::RemoveFile(const std::wstring& file)
{
DWORD attr = GetFileAttributes(file.c_str());
if (attr == -1 || (attr & FILE_ATTRIBUTE_READONLY))
@@ -1265,7 +1265,7 @@ bool CSystem::RemoveFile(const std::wstring& file)
** Recursively removes folder.
**
*/
bool CSystem::RemoveFolder(std::wstring folder)
bool System::RemoveFolder(std::wstring folder)
{
// The strings must end with double nul
folder.append(1, L'\0');
@@ -1292,7 +1292,7 @@ bool CSystem::RemoveFolder(std::wstring folder)
** Retrieves the "IniFileMapping" entries from Registry.
**
*/
void CSystem::UpdateIniFileMappingList()
void System::UpdateIniFileMappingList()
{
static ULONGLONG s_LastWriteTime = 0;
@@ -1358,7 +1358,7 @@ void CSystem::UpdateIniFileMappingList()
** Note that a temporary file must be deleted by caller.
**
*/
std::wstring CSystem::GetTemporaryFile(const std::wstring& iniFile)
std::wstring System::GetTemporaryFile(const std::wstring& iniFile)
{
std::wstring temporary;

2
Library/System.h
View File

@@ -43,7 +43,7 @@ struct MultiMonitorInfo
std::vector<MonitorInfo> monitors;
};
class CSystem
class System
{
public:
static void Initialize(HINSTANCE instance);

28
Library/TintedImage.cpp
View File

@@ -127,7 +127,7 @@ std::unordered_map<std::wstring, ImageCachePool::ImageCache*> ImageCachePool::c_
#define CONVERT_TO_RADIANS(X) ((X) * (PI / 180.0f))
// GrayScale Matrix
const Gdiplus::ColorMatrix CTintedImage::c_GreyScaleMatrix = {
const Gdiplus::ColorMatrix TintedImage::c_GreyScaleMatrix = {
0.299f, 0.299f, 0.299f, 0.0f, 0.0f,
0.587f, 0.587f, 0.587f, 0.0f, 0.0f,
0.114f, 0.114f, 0.114f, 0.0f, 0.0f,
@@ -135,7 +135,7 @@ const Gdiplus::ColorMatrix CTintedImage::c_GreyScaleMatrix = {
0.0f, 0.0f, 0.0f, 0.0f, 1.0f
};
const Gdiplus::ColorMatrix CTintedImage::c_IdentityMatrix = {
const Gdiplus::ColorMatrix TintedImage::c_IdentityMatrix = {
1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
@@ -143,7 +143,7 @@ const Gdiplus::ColorMatrix CTintedImage::c_IdentityMatrix = {
0.0f, 0.0f, 0.0f, 0.0f, 1.0f
};
CTintedImageHelper_DefineOptionArray(CTintedImage::c_DefaultOptionArray, L"");
TintedImageHelper_DefineOptionArray(TintedImage::c_DefaultOptionArray, L"");
/*
** The constructor.
@@ -151,7 +151,7 @@ CTintedImageHelper_DefineOptionArray(CTintedImage::c_DefaultOptionArray, L"");
** If disableTransform is true, ImageCrop and ImageRotate are ignored.
**
*/
CTintedImage::CTintedImage(const WCHAR* name, const WCHAR** optionArray, bool disableTransform) : m_DisableTransform(disableTransform),
TintedImage::TintedImage(const WCHAR* name, const WCHAR** optionArray, bool disableTransform) : m_DisableTransform(disableTransform),
m_Name(name ? name : L"Image"),
m_OptionArray(optionArray ? optionArray : c_DefaultOptionArray),
m_Bitmap(),
@@ -173,7 +173,7 @@ CTintedImage::CTintedImage(const WCHAR* name, const WCHAR** optionArray, bool di
** The destructor
**
*/
CTintedImage::~CTintedImage()
TintedImage::~TintedImage()
{
DisposeImage();
@@ -184,7 +184,7 @@ CTintedImage::~CTintedImage()
** Disposes the image buffers.
**
*/
void CTintedImage::DisposeImage()
void TintedImage::DisposeImage()
{
delete m_BitmapTint;
m_BitmapTint = NULL;
@@ -202,7 +202,7 @@ void CTintedImage::DisposeImage()
** Loads the image from file handle
**
*/
Bitmap* CTintedImage::LoadImageFromFileHandle(HANDLE fileHandle, DWORD fileSize, HGLOBAL* phBuffer)
Bitmap* TintedImage::LoadImageFromFileHandle(HANDLE fileHandle, DWORD fileSize, HGLOBAL* phBuffer)
{
HGLOBAL hBuffer = ::GlobalAlloc(GMEM_MOVEABLE, fileSize);
if (hBuffer)
@@ -310,7 +310,7 @@ Bitmap* CTintedImage::LoadImageFromFileHandle(HANDLE fileHandle, DWORD fileSize,
** Loads the image from disk
**
*/
void CTintedImage::LoadImage(const std::wstring& imageName, bool bLoadAlways)
void TintedImage::LoadImage(const std::wstring& imageName, bool bLoadAlways)
{
// Load the bitmap if defined
if (!imageName.empty())
@@ -426,7 +426,7 @@ void CTintedImage::LoadImage(const std::wstring& imageName, bool bLoadAlways)
** This will apply the cropping.
**
*/
void CTintedImage::ApplyCrop()
void TintedImage::ApplyCrop()
{
if (m_Crop.Width >= 0 && m_Crop.Height >= 0)
{
@@ -483,7 +483,7 @@ void CTintedImage::ApplyCrop()
** This will apply the Greyscale matrix and the color tinting.
**
*/
void CTintedImage::ApplyTint()
void TintedImage::ApplyTint()
{
bool useColorMatrix = !CompareColorMatrix(m_ColorMatrix, &c_IdentityMatrix);
@@ -529,7 +529,7 @@ void CTintedImage::ApplyTint()
** Note that the returned bitmap image must be freed by caller.
**
*/
Bitmap* CTintedImage::TurnGreyscale(Bitmap* source)
Bitmap* TintedImage::TurnGreyscale(Bitmap* source)
{
ImageAttributes ImgAttr;
ImgAttr.SetColorMatrix(&c_GreyScaleMatrix, ColorMatrixFlagsDefault, ColorAdjustTypeBitmap);
@@ -548,7 +548,7 @@ Bitmap* CTintedImage::TurnGreyscale(Bitmap* source)
** This will apply the flipping and rotating.
**
*/
void CTintedImage::ApplyTransform()
void TintedImage::ApplyTransform()
{
if (m_Rotate != 0.0f)
{
@@ -615,7 +615,7 @@ void CTintedImage::ApplyTransform()
** Read the meter-specific options from the ini-file.
**
*/
void CTintedImage::ReadOptions(CConfigParser& parser, const WCHAR* section)
void TintedImage::ReadOptions(ConfigParser& parser, const WCHAR* section)
{
// Store the current values so we know if the image needs to be tinted or transformed
Rect oldCrop = m_Crop;
@@ -792,7 +792,7 @@ void CTintedImage::ReadOptions(CConfigParser& parser, const WCHAR* section)
** Compares the two given color matrices.
**
*/
bool CTintedImage::CompareColorMatrix(const Gdiplus::ColorMatrix* a, const Gdiplus::ColorMatrix* b)
bool TintedImage::CompareColorMatrix(const Gdiplus::ColorMatrix* a, const Gdiplus::ColorMatrix* b)
{
for (int i = 0; i < 5; ++i)
{

14
Library/TintedImage.h
View File

@@ -27,8 +27,8 @@
** Helper macro to define an array of option names. A prefix must be given.
**
*/
#define CTintedImageHelper_DefineOptionArray(name, prefix) \
const WCHAR* (name)[CTintedImage::OptionCount] = { \
#define TintedImageHelper_DefineOptionArray(name, prefix) \
const WCHAR* (name)[TintedImage::OptionCount] = { \
prefix L"ImageCrop", \
prefix L"Greyscale", \
prefix L"ImageTint", \
@@ -43,9 +43,9 @@
prefix L"UseExifOrientation" \
};
class CConfigParser;
class ConfigParser;
class CTintedImage
class TintedImage
{
public:
enum OptionIndex
@@ -66,10 +66,10 @@ public:
OptionCount
};
CTintedImage(const WCHAR* name = L"Image", const WCHAR** optionArray = c_DefaultOptionArray, bool disableTransform = false);
~CTintedImage();
TintedImage(const WCHAR* name = L"Image", const WCHAR** optionArray = c_DefaultOptionArray, bool disableTransform = false);
~TintedImage();
void ReadOptions(CConfigParser& parser, const WCHAR* section);
void ReadOptions(ConfigParser& parser, const WCHAR* section);
bool IsLoaded() { return (m_Bitmap != NULL); }
bool IsTinted() { return (m_BitmapTint != NULL); }

126
Library/TrayWindow.cpp
View File

@@ -48,11 +48,11 @@ enum INTERVAL
const UINT WM_TASKBARCREATED = ::RegisterWindowMessage(L"TaskbarCreated");
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
using namespace Gdiplus;
CTrayWindow::CTrayWindow() :
TrayWindow::TrayWindow() :
m_Icon(),
m_Measure(),
m_MeterType(TRAY_METER_TYPE_HISTOGRAM),
@@ -67,7 +67,7 @@ CTrayWindow::CTrayWindow() :
{
}
CTrayWindow::~CTrayWindow()
TrayWindow::~TrayWindow()
{
KillTimer(m_Window, TIMER_ADDTRAYICON);
KillTimer(m_Window, TIMER_TRAYMEASURE);
@@ -85,11 +85,11 @@ CTrayWindow::~CTrayWindow()
if (m_Window) DestroyWindow(m_Window);
}
void CTrayWindow::Initialize()
void TrayWindow::Initialize()
{
WNDCLASS wc = {0};
wc.lpfnWndProc = (WNDPROC)WndProc;
wc.hInstance = Rainmeter->GetInstance();
wc.hInstance = g_Rainmeter->GetInstance();
wc.lpszClassName = L"RainmeterTrayClass";
wc.hIcon = GetIcon(IDI_RAINMETER);
@@ -112,7 +112,7 @@ void CTrayWindow::Initialize()
SetWindowPos(m_Window, HWND_BOTTOM, 0, 0, 0, 0, ZPOS_FLAGS);
}
bool CTrayWindow::AddTrayIcon()
bool TrayWindow::AddTrayIcon()
{
NOTIFYICONDATA tnid = {sizeof(NOTIFYICONDATA)};
tnid.hWnd = m_Window;
@@ -125,7 +125,7 @@ bool CTrayWindow::AddTrayIcon()
return (Shell_NotifyIcon(NIM_ADD, &tnid) || GetLastError() != ERROR_TIMEOUT);
}
bool CTrayWindow::IsTrayIconReady()
bool TrayWindow::IsTrayIconReady()
{
NOTIFYICONDATA tnid = {sizeof(NOTIFYICONDATA)};
tnid.hWnd = m_Window;
@@ -134,7 +134,7 @@ bool CTrayWindow::IsTrayIconReady()
return Shell_NotifyIcon(NIM_MODIFY, &tnid);
}
void CTrayWindow::TryAddTrayIcon()
void TrayWindow::TryAddTrayIcon()
{
if (IsTrayIconReady())
{
@@ -156,7 +156,7 @@ void CTrayWindow::TryAddTrayIcon()
}
}
void CTrayWindow::CheckTrayIcon()
void TrayWindow::CheckTrayIcon()
{
if (IsTrayIconReady() || AddTrayIcon())
{
@@ -164,7 +164,7 @@ void CTrayWindow::CheckTrayIcon()
}
}
void CTrayWindow::RemoveTrayIcon()
void TrayWindow::RemoveTrayIcon()
{
NOTIFYICONDATA tnid = {sizeof(NOTIFYICONDATA)};
tnid.hWnd = m_Window;
@@ -180,7 +180,7 @@ void CTrayWindow::RemoveTrayIcon()
}
}
void CTrayWindow::ModifyTrayIcon(double value)
void TrayWindow::ModifyTrayIcon(double value)
{
if (m_Icon)
{
@@ -199,7 +199,7 @@ void CTrayWindow::ModifyTrayIcon(double value)
Shell_NotifyIcon(NIM_MODIFY, &tnid);
}
HICON CTrayWindow::CreateTrayIcon(double value)
HICON TrayWindow::CreateTrayIcon(double value)
{
if (m_Measure != NULL)
{
@@ -296,7 +296,7 @@ HICON CTrayWindow::CreateTrayIcon(double value)
return GetIcon(IDI_TRAY);
}
void CTrayWindow::ShowNotification(TRAY_NOTIFICATION id, const WCHAR* title, const WCHAR* text)
void TrayWindow::ShowNotification(TRAY_NOTIFICATION id, const WCHAR* title, const WCHAR* text)
{
if (m_Notification == TRAY_NOTIFICATION_NONE)
{
@@ -322,28 +322,28 @@ void CTrayWindow::ShowNotification(TRAY_NOTIFICATION id, const WCHAR* title, con
}
}
void CTrayWindow::ShowWelcomeNotification()
void TrayWindow::ShowWelcomeNotification()
{
ShowNotification(TRAY_NOTIFICATION_WELCOME, GetString(ID_STR_WELCOME), GetString(ID_STR_CLICKTOMANAGE));
}
void CTrayWindow::ShowUpdateNotification(const WCHAR* newVersion)
void TrayWindow::ShowUpdateNotification(const WCHAR* newVersion)
{
std::wstring text = GetFormattedString(ID_STR_CLICKTODOWNLOAD, newVersion);
ShowNotification(TRAY_NOTIFICATION_UPDATE, GetString(ID_STR_UPDATEAVAILABLE), text.c_str());
}
void CTrayWindow::SetTrayIcon(bool enabled)
void TrayWindow::SetTrayIcon(bool enabled)
{
enabled ? TryAddTrayIcon() : RemoveTrayIcon();
m_IconEnabled = enabled;
// Save to Rainmeter.ini.
const std::wstring& iniFile = Rainmeter->GetIniFile();
const std::wstring& iniFile = g_Rainmeter->GetIniFile();
WritePrivateProfileString(L"Rainmeter", L"TrayIcon", enabled ? NULL : L"0", iniFile.c_str());
}
void CTrayWindow::ReadOptions(CConfigParser& parser)
void TrayWindow::ReadOptions(ConfigParser& parser)
{
// Clear old Settings
KillTimer(m_Window, TIMER_ADDTRAYICON);
@@ -372,16 +372,16 @@ void CTrayWindow::ReadOptions(CConfigParser& parser)
if (!measureName.empty())
{
CConfigParser* oldParser = Rainmeter->GetCurrentParser();
Rainmeter->SetCurrentParser(&parser);
ConfigParser* oldParser = g_Rainmeter->GetCurrentParser();
g_Rainmeter->SetCurrentParser(&parser);
m_Measure = CMeasure::Create(measureName.c_str(), NULL, L"TrayMeasure");
m_Measure = Measure::Create(measureName.c_str(), NULL, L"TrayMeasure");
if (m_Measure)
{
m_Measure->ReadOptions(parser);
}
Rainmeter->SetCurrentParser(oldParser);
g_Rainmeter->SetCurrentParser(oldParser);
}
const WCHAR* type = parser.ReadString(L"TrayMeasure", L"TrayMeter", m_Measure ? L"HISTOGRAM" : L"NONE").c_str();
@@ -404,7 +404,7 @@ void CTrayWindow::ReadOptions(CConfigParser& parser)
// Load the bitmaps if defined
if (!imageName.empty())
{
imageName.insert(0, Rainmeter->GetSkinPath());
imageName.insert(0, g_Rainmeter->GetSkinPath());
const WCHAR* imagePath = imageName.c_str();
if (_wcsicmp(imagePath + (imageName.size() - 4), L".ico") == 0)
{
@@ -457,9 +457,9 @@ void CTrayWindow::ReadOptions(CConfigParser& parser)
}
}
LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT CALLBACK TrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CTrayWindow* tray = Rainmeter->GetTrayWindow();
TrayWindow* tray = g_Rainmeter->GetTrayWindow();
switch (uMsg)
{
@@ -467,51 +467,51 @@ LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
switch (wParam)
{
case IDM_MANAGE:
CDialogManage::Open();
DialogManage::Open();
break;
case IDM_ABOUT:
CDialogAbout::Open();
DialogAbout::Open();
break;
case IDM_SHOW_HELP:
CCommandHandler::RunFile(RAINMETER_HELP);
CommandHandler::RunFile(RAINMETER_HELP);
break;
case IDM_NEW_VERSION:
CCommandHandler::RunFile(RAINMETER_OFFICIAL);
CommandHandler::RunFile(RAINMETER_OFFICIAL);
break;
case IDM_REFRESH:
PostMessage(Rainmeter->GetWindow(), WM_RAINMETER_DELAYED_REFRESH_ALL, (WPARAM)NULL, (LPARAM)NULL);
PostMessage(g_Rainmeter->GetWindow(), WM_RAINMETER_DELAYED_REFRESH_ALL, (WPARAM)NULL, (LPARAM)NULL);
break;
case IDM_SHOWLOGFILE:
Rainmeter->ShowLogFile();
g_Rainmeter->ShowLogFile();
break;
case IDM_STARTLOG:
CLogger::GetInstance().StartLogFile();
Logger::GetInstance().StartLogFile();
break;
case IDM_STOPLOG:
CLogger::GetInstance().StopLogFile();
Logger::GetInstance().StopLogFile();
break;
case IDM_DELETELOGFILE:
CLogger::GetInstance().DeleteLogFile();
Logger::GetInstance().DeleteLogFile();
break;
case IDM_DEBUGLOG:
Rainmeter->SetDebug(!Rainmeter->GetDebug());
g_Rainmeter->SetDebug(!g_Rainmeter->GetDebug());
break;
case IDM_DISABLEDRAG:
Rainmeter->SetDisableDragging(!Rainmeter->GetDisableDragging());
g_Rainmeter->SetDisableDragging(!g_Rainmeter->GetDisableDragging());
break;
case IDM_EDITCONFIG:
Rainmeter->EditSettings();
g_Rainmeter->EditSettings();
break;
case IDM_QUIT:
@@ -519,7 +519,7 @@ LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
break;
case IDM_OPENSKINSFOLDER:
Rainmeter->OpenSkinFolder();
g_Rainmeter->OpenSkinFolder();
break;
default:
@@ -530,35 +530,35 @@ LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
{
int pos = mID - ID_THEME_FIRST;
const std::vector<std::wstring>& layouts = Rainmeter->GetAllLayouts();
const std::vector<std::wstring>& layouts = g_Rainmeter->GetAllLayouts();
if (pos >= 0 && pos < (int)layouts.size())
{
Rainmeter->LoadLayout(layouts[pos]);
g_Rainmeter->LoadLayout(layouts[pos]);
}
}
else if (mID >= ID_CONFIG_FIRST && mID <= ID_CONFIG_LAST)
{
std::pair<int, int> indexes = Rainmeter->GetMeterWindowIndex(mID);
std::pair<int, int> indexes = g_Rainmeter->GetMeterWindowIndex(mID);
if (indexes.first != -1 && indexes.second != -1)
{
Rainmeter->ToggleSkin(indexes.first, indexes.second);
g_Rainmeter->ToggleSkin(indexes.first, indexes.second);
}
}
else
{
// Forward the message to correct window
int index = (int)(wParam >> 16);
const std::map<std::wstring, CMeterWindow*>& windows = Rainmeter->GetAllMeterWindows();
const std::map<std::wstring, MeterWindow*>& windows = g_Rainmeter->GetAllMeterWindows();
if (index < (int)windows.size())
{
std::map<std::wstring, CMeterWindow*>::const_iterator iter = windows.begin();
std::map<std::wstring, MeterWindow*>::const_iterator iter = windows.begin();
for ( ; iter != windows.end(); ++iter)
{
--index;
if (index < 0)
{
CMeterWindow* meterWindow = (*iter).second;
MeterWindow* meterWindow = (*iter).second;
SendMessage(meterWindow->GetWindow(), WM_COMMAND, mID, NULL);
break;
}
@@ -579,19 +579,19 @@ LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
switch (uMouseMsg)
{
case WM_MBUTTONDOWN:
bang = Rainmeter->GetTrayExecuteM().c_str();
bang = g_Rainmeter->GetTrayExecuteM().c_str();
break;
case WM_RBUTTONDOWN:
bang = Rainmeter->GetTrayExecuteR().c_str();
bang = g_Rainmeter->GetTrayExecuteR().c_str();
break;
case WM_MBUTTONDBLCLK:
bang = Rainmeter->GetTrayExecuteDM().c_str();
bang = g_Rainmeter->GetTrayExecuteDM().c_str();
break;
case WM_RBUTTONDBLCLK:
bang = Rainmeter->GetTrayExecuteDR().c_str();
bang = g_Rainmeter->GetTrayExecuteDR().c_str();
break;
default:
@@ -602,7 +602,7 @@ LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
if (*bang &&
!IsCtrlKeyDown()) // Ctrl is pressed, so only run default action
{
Rainmeter->ExecuteCommand(bang, NULL);
g_Rainmeter->ExecuteCommand(bang, NULL);
tray->m_TrayContextMenuEnabled = (uMouseMsg != WM_RBUTTONDOWN);
break;
}
@@ -617,24 +617,24 @@ LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
case WM_RBUTTONUP:
if (tray->m_TrayContextMenuEnabled)
{
POINT pos = CSystem::GetCursorPosition();
Rainmeter->ShowContextMenu(pos, NULL);
POINT pos = System::GetCursorPosition();
g_Rainmeter->ShowContextMenu(pos, NULL);
}
break;
case WM_LBUTTONUP:
case WM_LBUTTONDBLCLK:
CDialogManage::Open();
DialogManage::Open();
break;
case NIN_BALLOONUSERCLICK:
if (tray->m_Notification == TRAY_NOTIFICATION_WELCOME)
{
CDialogManage::Open();
DialogManage::Open();
}
else if (tray->m_Notification == TRAY_NOTIFICATION_UPDATE)
{
CCommandHandler::RunFile(RAINMETER_OFFICIAL);
CommandHandler::RunFile(RAINMETER_OFFICIAL);
}
tray->m_Notification = TRAY_NOTIFICATION_NONE;
break;
@@ -662,32 +662,32 @@ LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
switch (wParam)
{
case RAINMETER_QUERY_ID_SKINS_PATH:
sendCopyData(Rainmeter->GetSkinPath());
sendCopyData(g_Rainmeter->GetSkinPath());
return 0;
case RAINMETER_QUERY_ID_SETTINGS_PATH:
sendCopyData(Rainmeter->GetSettingsPath());
sendCopyData(g_Rainmeter->GetSettingsPath());
return 0;
case RAINMETER_QUERY_ID_PLUGINS_PATH:
sendCopyData(Rainmeter->GetPluginPath());
sendCopyData(g_Rainmeter->GetPluginPath());
return 0;
case RAINMETER_QUERY_ID_PROGRAM_PATH:
sendCopyData(Rainmeter->GetPath());
sendCopyData(g_Rainmeter->GetPath());
return 0;
case RAINMETER_QUERY_ID_LOG_PATH:
sendCopyData(CLogger::GetInstance().GetLogFilePath());
sendCopyData(Logger::GetInstance().GetLogFilePath());
return 0;
case RAINMETER_QUERY_ID_CONFIG_EDITOR:
sendCopyData(Rainmeter->GetSkinEditor());
sendCopyData(g_Rainmeter->GetSkinEditor());
return 0;
case RAINMETER_QUERY_ID_IS_DEBUGGING:
{
BOOL debug = Rainmeter->GetDebug();
BOOL debug = g_Rainmeter->GetDebug();
SendMessage((HWND)lParam, WM_QUERY_RAINMETER_RETURN, (WPARAM)hWnd, (LPARAM)debug);
}
return 0;
@@ -701,7 +701,7 @@ LRESULT CALLBACK CTrayWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
if (cds->dwData == RAINMETER_QUERY_ID_SKIN_WINDOWHANDLE)
{
LPCWSTR folderPath = (LPCWSTR)cds->lpData;
CMeterWindow* mw = Rainmeter->GetMeterWindow(folderPath);
MeterWindow* mw = g_Rainmeter->GetMeterWindow(folderPath);
return (mw) ? (LRESULT)mw->GetWindow() : NULL;
}
}

14
Library/TrayWindow.h
View File

@@ -33,18 +33,18 @@ enum TRAY_METER_TYPE
TRAY_METER_TYPE_BITMAP
};
class CConfigParser;
class CMeasure;
class ConfigParser;
class Measure;
class CTrayWindow
class TrayWindow
{
public:
CTrayWindow();
~CTrayWindow();
TrayWindow();
~TrayWindow();
void Initialize();
void ReadOptions(CConfigParser& parser);
void ReadOptions(ConfigParser& parser);
HWND GetWindow() { return m_Window; }
bool IsTrayIconEnabled() { return m_IconEnabled; }
void SetTrayIcon(bool enabled);
@@ -75,7 +75,7 @@ private:
HICON m_Icon;
HWND m_Window;
CMeasure* m_Measure;
Measure* m_Measure;
TRAY_METER_TYPE m_MeterType;
Gdiplus::Color m_Color1;

8
Library/UpdateCheck.cpp
View File

@@ -22,7 +22,7 @@
#include "TrayWindow.h"
#include "../Version.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
void CheckVersion(void* dummy)
{
@@ -71,17 +71,17 @@ void CheckVersion(void* dummy)
if (availableVersion > RAINMETER_VERSION ||
(revision_beta && availableVersion == RAINMETER_VERSION))
{
Rainmeter->SetNewVersion();
g_Rainmeter->SetNewVersion();
WCHAR buffer[32];
const WCHAR* dataFile = Rainmeter->GetDataFile().c_str();
const WCHAR* dataFile = g_Rainmeter->GetDataFile().c_str();
GetPrivateProfileString(L"Rainmeter", L"LastCheck", L"0", buffer, _countof(buffer), dataFile);
// Show tray notification only once per new version
int lastVersion = parseVersion(buffer);
if (availableVersion > lastVersion)
{
Rainmeter->GetTrayWindow()->ShowUpdateNotification(version);
g_Rainmeter->GetTrayWindow()->ShowUpdateNotification(version);
WritePrivateProfileString(L"Rainmeter", L"LastCheck", version, dataFile);
}
}

12
Library/lua/glue/LuaMeasure.cpp
View File

@@ -24,7 +24,7 @@
#define DECLARE_SELF(L) \
void* selfData = lua_touserdata(L, 1); \
if (!selfData) return 0; \
CMeasure* self = *(CMeasure**)selfData;
Measure* self = *(Measure**)selfData;
static int GetName(lua_State* L)
{
@@ -37,8 +37,8 @@ static int GetName(lua_State* L)
static int GetOption(lua_State* L)
{
DECLARE_SELF(L)
CMeterWindow* meterWindow = self->GetMeterWindow();
CConfigParser& parser = meterWindow->GetParser();
MeterWindow* meterWindow = self->GetMeterWindow();
ConfigParser& parser = meterWindow->GetParser();
std::wstring strTmp = LuaManager::ToWide(L, 2);
strTmp = parser.ReadString(self->GetName(), strTmp.c_str(), LuaManager::ToWide(L, 3).c_str());
@@ -50,8 +50,8 @@ static int GetOption(lua_State* L)
static int GetNumberOption(lua_State* L)
{
DECLARE_SELF(L)
CMeterWindow* meterWindow = self->GetMeterWindow();
CConfigParser& parser = meterWindow->GetParser();
MeterWindow* meterWindow = self->GetMeterWindow();
ConfigParser& parser = meterWindow->GetParser();
std::wstring strTmp = LuaManager::ToWide(L, 2);
double value = parser.ReadFloat(self->GetName(), strTmp.c_str(), lua_tonumber(L, 3));
@@ -150,7 +150,7 @@ void LuaManager::RegisterMeasure(lua_State* L)
{ NULL, NULL }
};
luaL_register(L, "CMeasure", functions);
luaL_register(L, "Measure", functions);
lua_pushvalue(L, -1);
lua_setfield(L, -2, "__index");
lua_pop(L, 1);

12
Library/lua/glue/LuaMeter.cpp
View File

@@ -24,7 +24,7 @@
#define DECLARE_SELF(L) \
void* selfData = lua_touserdata(L, 1); \
if (!selfData) return 0; \
CMeter* self = *(CMeter**)selfData;
Meter* self = *(Meter**)selfData;
static int GetName(lua_State* L)
{
@@ -37,8 +37,8 @@ static int GetName(lua_State* L)
static int GetOption(lua_State* L)
{
DECLARE_SELF(L)
CMeterWindow* meterWindow = self->GetMeterWindow();
CConfigParser& parser = meterWindow->GetParser();
MeterWindow* meterWindow = self->GetMeterWindow();
ConfigParser& parser = meterWindow->GetParser();
std::wstring strTmp = LuaManager::ToWide(L, 2);
strTmp = parser.ReadString(self->GetName(), strTmp.c_str(), L"");
@@ -137,9 +137,9 @@ static int Show(lua_State* L)
static int SetText(lua_State* L)
{
DECLARE_SELF(L)
if (self->GetTypeID() == TypeID<CMeterString>())
if (self->GetTypeID() == TypeID<MeterString>())
{
CMeterString* string = (CMeterString*)self;
MeterString* string = (MeterString*)self;
std::wstring str = LuaManager::ToWide(L, 2);
string->SetText(str.c_str());
}
@@ -167,7 +167,7 @@ void LuaManager::RegisterMeter(lua_State* L)
{ NULL, NULL }
};
luaL_register(L, "CMeter", functions);
luaL_register(L, "Meter", functions);
lua_pushvalue(L, -1);
lua_setfield(L, -2, "__index");
lua_pop(L, 1);

24
Library/lua/glue/LuaMeterWindow.cpp
View File

@@ -22,17 +22,17 @@
#include "../../MeterWindow.h"
#include "../../MeterString.h"
extern CRainmeter* Rainmeter;
extern Rainmeter* g_Rainmeter;
#define DECLARE_SELF(L) \
void* selfData = lua_touserdata(L, 1); \
if (!selfData) return 0; \
CMeterWindow* self = *(CMeterWindow**)selfData;
MeterWindow* self = *(MeterWindow**)selfData;
static int Bang(lua_State* L)
{
DECLARE_SELF(L)
CConfigParser& parser = self->GetParser();
ConfigParser& parser = self->GetParser();
std::wstring bang = LuaManager::ToWide(L, 2);
@@ -40,7 +40,7 @@ static int Bang(lua_State* L)
if (top == 2) // 1 argument
{
parser.ReplaceVariables(bang);
Rainmeter->ExecuteCommand(bang.c_str(), self);
g_Rainmeter->ExecuteCommand(bang.c_str(), self);
}
else
{
@@ -56,7 +56,7 @@ static int Bang(lua_State* L)
args.push_back(tmpSz);
}
Rainmeter->ExecuteBang(bangSz, args, self);
g_Rainmeter->ExecuteBang(bangSz, args, self);
}
}
@@ -68,11 +68,11 @@ static int GetMeter(lua_State* L)
DECLARE_SELF(L)
const std::wstring meterName = LuaManager::ToWide(L, 2);
CMeter* meter = self->GetMeter(meterName);
Meter* meter = self->GetMeter(meterName);
if (meter)
{
*(CMeter**)lua_newuserdata(L, sizeof(CMeter*)) = meter;
lua_getglobal(L, "CMeter");
*(Meter**)lua_newuserdata(L, sizeof(Meter*)) = meter;
lua_getglobal(L, "Meter");
lua_setmetatable(L, -2);
}
else
@@ -88,11 +88,11 @@ static int GetMeasure(lua_State* L)
DECLARE_SELF(L)
const std::wstring measureName = LuaManager::ToWide(L, 2);
CMeasure* measure = self->GetMeasure(measureName);
Measure* measure = self->GetMeasure(measureName);
if (measure)
{
*(CMeasure**)lua_newuserdata(L, sizeof(CMeasure*)) = measure;
lua_getglobal(L, "CMeasure");
*(Measure**)lua_newuserdata(L, sizeof(Measure*)) = measure;
lua_getglobal(L, "Measure");
lua_setmetatable(L, -2);
}
else
@@ -231,7 +231,7 @@ void LuaManager::RegisterMeterWindow(lua_State* L)
{ NULL, NULL }
};
luaL_register(L, "CMeterWindow", functions);
luaL_register(L, "MeterWindow", functions);
lua_pushvalue(L, -1);
lua_setfield(L, -2, "__index");
lua_pop(L, 1);

14
Plugins/PluginAdvancedCPU/AdvancedCPU.cpp
View File

@@ -30,12 +30,12 @@
struct MeasureData
{
std::vector<CRawString> includes;
std::vector<CRawString> excludes;
CRawString includesCache;
CRawString excludesCache;
std::vector<RawString> includes;
std::vector<RawString> excludes;
RawString includesCache;
RawString excludesCache;
int topProcess;
CRawString topProcessName;
RawString topProcessName;
LONGLONG topProcessValue;
MeasureData() :
@@ -47,7 +47,7 @@ struct MeasureData
struct ProcessValues
{
CRawString name;
RawString name;
LONGLONG oldValue;
LONGLONG newValue;
bool found;
@@ -58,7 +58,7 @@ std::vector<ProcessValues> g_Processes;
void UpdateProcesses();
void SplitName(WCHAR* names, std::vector<CRawString>& splittedNames)
void SplitName(WCHAR* names, std::vector<RawString>& splittedNames)
{
WCHAR* token = wcstok(names, L";");
while (token != NULL)

4
Plugins/PluginFolderInfo/FolderInfo.cpp
View File

@@ -90,7 +90,7 @@ void CFolderInfo::Update()
void CFolderInfo::CalculateSize()
{
std::list<CRawString> folderQueue;
std::list<RawString> folderQueue;
folderQueue.push_back(m_Path.c_str());
WCHAR searchPattern[MAX_PATH + 10];
@@ -100,7 +100,7 @@ void CFolderInfo::CalculateSize()
HANDLE findHandle;
while (!folderQueue.empty())
{
const CRawString& ref = folderQueue.front();
const RawString& ref = folderQueue.front();
wsprintf(searchPattern, L"%s%s", ref.c_str(), L"\\*.*");
findHandle = FindFirstFile(searchPattern, &findData);

2
Plugins/PluginFolderInfo/FolderInfo.h
View File

@@ -56,7 +56,7 @@ private:
UINT m_InstanceCount;
void* m_Skin;
CRawString m_Path;
RawString m_Path;
bool m_IncludeSubFolders;
bool m_IncludeHiddenFiles;
bool m_IncludeSystemFiles;

14
Plugins/PluginNowPlaying/Internet.cpp
View File

@@ -19,13 +19,13 @@
#include "StdAfx.h"
#include "Internet.h"
HINTERNET CInternet::c_NetHandle = NULL;
HINTERNET Internet::c_NetHandle = NULL;
/*
** Initialize internet handle and crtical section.
**
*/
void CInternet::Initialize()
void Internet::Initialize()
{
c_NetHandle = InternetOpen(L"Rainmeter NowPlaying.dll",
INTERNET_OPEN_TYPE_PRECONFIG,
@@ -43,7 +43,7 @@ void CInternet::Initialize()
** Close handles and delete critical section.
**
*/
void CInternet::Finalize()
void Internet::Finalize()
{
if (c_NetHandle) InternetCloseHandle(c_NetHandle);
}
@@ -52,7 +52,7 @@ void CInternet::Finalize()
** Downloads given url and returns it as a string.
**
*/
std::wstring CInternet::DownloadUrl(const std::wstring& url, int codepage)
std::wstring Internet::DownloadUrl(const std::wstring& url, int codepage)
{
// From WebParser.cpp
std::wstring result;
@@ -148,7 +148,7 @@ std::wstring CInternet::DownloadUrl(const std::wstring& url, int codepage)
** Encode reserved characters.
**
*/
std::wstring CInternet::EncodeUrl(const std::wstring& url)
std::wstring Internet::EncodeUrl(const std::wstring& url)
{
// Based on http://www.zedwood.com/article/111/cpp-urlencode-function
const WCHAR* urlChars = L" !*'();:@&=+$,/?#[]";
@@ -176,7 +176,7 @@ std::wstring CInternet::EncodeUrl(const std::wstring& url)
** Decodes numeric references.
**
*/
void CInternet::DecodeReferences(std::wstring& str)
void Internet::DecodeReferences(std::wstring& str)
{
// From WebParser.cpp
std::wstring::size_type start = 0;
@@ -246,7 +246,7 @@ void CInternet::DecodeReferences(std::wstring& str)
** Convert multibyte string to wide string.
**
*/
std::wstring CInternet::ConvertToWide(LPCSTR str, int codepage)
std::wstring Internet::ConvertToWide(LPCSTR str, int codepage)
{
std::wstring szWide;

2
Plugins/PluginNowPlaying/Internet.h
View File

@@ -19,7 +19,7 @@
#ifndef __INTERNET_H__
#define __INTERNET_H__
class CInternet
class Internet
{
public:
static void Initialize();

26
Plugins/PluginNowPlaying/Lyrics.cpp
View File

@@ -25,10 +25,10 @@
** Download lyrics from various serivces.
**
*/
bool CLyrics::GetFromInternet(const std::wstring& artist, const std::wstring& title, std::wstring& out)
bool Lyrics::GetFromInternet(const std::wstring& artist, const std::wstring& title, std::wstring& out)
{
std::wstring encArtist = CInternet::EncodeUrl(artist);
std::wstring encTitle = CInternet::EncodeUrl(title);
std::wstring encArtist = Internet::EncodeUrl(artist);
std::wstring encTitle = Internet::EncodeUrl(title);
bool found = GetFromWikia(encArtist, encTitle, out) ||
GetFromLYRDB(encArtist, encTitle, out) ||
@@ -41,7 +41,7 @@ bool CLyrics::GetFromInternet(const std::wstring& artist, const std::wstring& ti
** Download lyrics from LyricWiki.
**
*/
bool CLyrics::GetFromWikia(const std::wstring& artist, const std::wstring& title, std::wstring& data)
bool Lyrics::GetFromWikia(const std::wstring& artist, const std::wstring& title, std::wstring& data)
{
bool ret = false;
@@ -49,7 +49,7 @@ bool CLyrics::GetFromWikia(const std::wstring& artist, const std::wstring& title
url += L"&song=";
url += title;
data = CInternet::DownloadUrl(url, CP_UTF8);
data = Internet::DownloadUrl(url, CP_UTF8);
if (!data.empty())
{
// First we get the URL to the actual wiki page
@@ -61,7 +61,7 @@ bool CLyrics::GetFromWikia(const std::wstring& artist, const std::wstring& title
url.assign(data, 0, pos);
// Fetch the wiki page
data = CInternet::DownloadUrl(url, CP_UTF8);
data = Internet::DownloadUrl(url, CP_UTF8);
if (!data.empty())
{
pos = data.find(L"'lyricbox'");
@@ -72,7 +72,7 @@ bool CLyrics::GetFromWikia(const std::wstring& artist, const std::wstring& title
data.erase(0, pos);
pos = data.find(L"<!");
data.resize(pos);
CInternet::DecodeReferences(data);
Internet::DecodeReferences(data);
pos = data.find(L"[...]");
if (pos != std::wstring::npos)
@@ -115,7 +115,7 @@ bool CLyrics::GetFromWikia(const std::wstring& artist, const std::wstring& title
** Download lyrics from LYRDB.
**
*/
bool CLyrics::GetFromLYRDB(const std::wstring& artist, const std::wstring& title, std::wstring& data)
bool Lyrics::GetFromLYRDB(const std::wstring& artist, const std::wstring& title, std::wstring& data)
{
bool ret = false;
@@ -132,7 +132,7 @@ bool CLyrics::GetFromLYRDB(const std::wstring& artist, const std::wstring& title
std::wstring url = L"http://webservices.lyrdb.com/lookup.php?q=" + query;
url += L"&for=match&agent=RainmeterNowPlaying";
data = CInternet::DownloadUrl(url, CP_ACP);
data = Internet::DownloadUrl(url, CP_ACP);
if (!data.empty())
{
pos = data.find(L"\\");
@@ -142,7 +142,7 @@ bool CLyrics::GetFromLYRDB(const std::wstring& artist, const std::wstring& title
url.assign(data, 0, pos);
url.insert(0, L"http://webservices.lyrdb.com/getlyr.php?q=");
data = CInternet::DownloadUrl(url, CP_ACP);
data = Internet::DownloadUrl(url, CP_ACP);
if (!data.empty())
{
ret = true;
@@ -157,14 +157,14 @@ bool CLyrics::GetFromLYRDB(const std::wstring& artist, const std::wstring& title
** Download lyrics from Letras.
**
*/
bool CLyrics::GetFromLetras(const std::wstring& artist, const std::wstring& title, std::wstring& data)
bool Lyrics::GetFromLetras(const std::wstring& artist, const std::wstring& title, std::wstring& data)
{
bool ret = false;
std::wstring url = L"http://letras.terra.com.br/winamp.php?musica=" + title;
url += L"&artista=";
url += artist;
data = CInternet::DownloadUrl(url, CP_ACP);
data = Internet::DownloadUrl(url, CP_ACP);
if (!data.empty())
{
std::wstring::size_type pos = data.find(L"\"letra\"");
@@ -177,7 +177,7 @@ bool CLyrics::GetFromLetras(const std::wstring& artist, const std::wstring& titl
pos = data.find(L"</p>");
data.resize(pos);
CInternet::DecodeReferences(data);
Internet::DecodeReferences(data);
while ((pos = data.find(L"<br/>"), pos) != std::wstring::npos)
{

2
Plugins/PluginNowPlaying/Lyrics.h
View File

@@ -19,7 +19,7 @@
#ifndef __LYRICS_H__
#define __LYRICS_H__
class CLyrics
class Lyrics
{
public:
static bool GetFromInternet(const std::wstring& artist, const std::wstring& title, std::wstring& out);

32
Plugins/PluginNowPlaying/NowPlaying.cpp
View File

@@ -53,7 +53,7 @@ PLUGIN_EXPORT void Initialize(void** data, void* rm)
if (!g_Initialized)
{
CInternet::Initialize();
Internet::Initialize();
g_Initialized = true;
}
}
@@ -116,7 +116,7 @@ PLUGIN_EXPORT void Reload(void* data, void* rm, double* maxValue)
{
// ParentMeasure is created when PlayerName is an actual player (and not a reference)
ParentMeasure* parent = measure->parent;
CPlayer* oldPlayer = NULL;
Player* oldPlayer = NULL;
if (parent)
{
if (parent->data != data)
@@ -139,11 +139,11 @@ PLUGIN_EXPORT void Reload(void* data, void* rm, double* maxValue)
if (_wcsicmp(L"AIMP", str) == 0)
{
parent->player = CPlayerAIMP::Create();
parent->player = PlayerAIMP::Create();
}
else if (_wcsicmp(L"CAD", str) == 0)
{
parent->player = CPlayerCAD::Create();
parent->player = PlayerCAD::Create();
}
else if (_wcsicmp(L"foobar2000", str) == 0)
{
@@ -157,32 +157,32 @@ PLUGIN_EXPORT void Reload(void* data, void* rm, double* maxValue)
}
}
parent->player = CPlayerCAD::Create();
parent->player = PlayerCAD::Create();
}
else if (_wcsicmp(L"iTunes", str) == 0)
{
parent->player = CPlayerITunes::Create();
parent->player = PlayerITunes::Create();
}
else if (_wcsicmp(L"MediaMonkey", str) == 0)
{
parent->player = CPlayerWinamp::Create(WA_MEDIAMONKEY);
parent->player = PlayerWinamp::Create(WA_MEDIAMONKEY);
}
else if (_wcsicmp(L"Spotify", str) == 0)
{
parent->player = CPlayerSpotify::Create();
parent->player = PlayerSpotify::Create();
}
else if (_wcsicmp(L"WinAmp", str) == 0)
{
parent->player = CPlayerWinamp::Create(WA_WINAMP);
parent->player = PlayerWinamp::Create(WA_WINAMP);
}
else if (_wcsicmp(L"WMP", str) == 0)
{
parent->player = CPlayerWMP::Create();
parent->player = PlayerWMP::Create();
}
else
{
// Default to WLM
parent->player = CPlayerWLM::Create();
parent->player = PlayerWLM::Create();
if (_wcsicmp(L"WLM", str) != 0)
{
@@ -302,7 +302,7 @@ PLUGIN_EXPORT double Update(void* data)
ParentMeasure* parent = measure->parent;
if (!parent) return 0.0;
CPlayer* player = parent->player;
Player* player = parent->player;
// Only allow parent measure to update
if (parent->data == data)
@@ -367,7 +367,7 @@ PLUGIN_EXPORT LPCWSTR GetString(void* data)
ParentMeasure* parent = measure->parent;
if (!parent) return NULL;
const CPlayer* player = parent->player;
const Player* player = parent->player;
static WCHAR buffer[32];
switch (measure->type)
@@ -444,7 +444,7 @@ PLUGIN_EXPORT void Finalize(void* data)
ParentMeasure* parent = measure->parent;
if (parent)
{
CPlayer* player = parent->player;
Player* player = parent->player;
if (--parent->measureCount == 0)
{
player->RemoveInstance();
@@ -455,7 +455,7 @@ PLUGIN_EXPORT void Finalize(void* data)
if (g_ParentMeasures.empty())
{
CInternet::Finalize();
Internet::Finalize();
}
}
}
@@ -469,7 +469,7 @@ PLUGIN_EXPORT void ExecuteBang(void* data, LPCWSTR args)
ParentMeasure* parent = measure->parent;
if (!parent) return;
CPlayer* player = parent->player;
Player* player = parent->player;
if (!player->IsInitialized())
{

2
Plugins/PluginNowPlaying/NowPlaying.h
View File

@@ -33,7 +33,7 @@ struct ParentMeasure
disableLeadingZero(false)
{}
CPlayer* player;
Player* player;
void* data;
void* skin;
LPCWSTR ownerName;

Some files were not shown because too many files have changed in this diff Show More