mirror of
https://github.com/chibicitiberiu/rainmeter-studio.git
synced 2024-02-24 04:33:31 +00:00
cc3ad487a7
This change brings the order of monitors close to the order of "Display Properties" due to using EnumDisplayDevices and EnumDisplaySettings instead of EnumDisplayMonitors. (If EnumDisplayDevices failed, EnumDisplayMonitors is used as before.) ----- * Added the "Display Monitor" submenu in [Skins Menu]-[Position]. These menus convert the present position to the relative position from the specified monitor. (But the meter window doesn't move to the specified monitor area immediately. Only converts.) - "Use default: Primary monitor" removes the @-directive from WindowX/Y. - @0(@1, @2, ...) adds the specified monitor number to WindowX/Y. @0 means "The Virtual Screen". (http://msdn.microsoft.com/en-us/library/dd145136%28VS.85%29.aspx) - If "Auto-select based on window position" is checked, the WindowX and WindowY "@n" settings are made automatically based on the position of the meter's window. If a monitor is selected directly using "Display Monitor" in the Rainmeter / skin context menu, this menu is unchecked. This setting can be manually made in either the [Rainmeter] (all configs) or individual config sections of Rainmeter.ini. AutoSelectScreen If set to 1, the WindowX and WindowY "@n" settings are made automatically based on the position of the meter's window. If a monitor is selected directly using "Display Monitor" in the Rainmeter / skin context menu, this setting is reset to 0. ----- * Added the variables for multiple display monitors and the virtual screen. All X/Y positions are represented in the virtual screen coordinates. The following variables are for the virtual screen. #VSCREENAREAX# is the X-position of the left-side of the virtual screen. #VSCREENAREAY# is the Y-position of the top-side of the virtual screen. #VSCREENAREAWIDTH# is the width of the virtual screen. #VSCREENAREAHEIGHT# is the height of the virtual screen. The following variables are for the PRESENT monitor. Note that these variables automatically change by the WindowX and WindowY "@n" settings. If "@n" is not set, these variables return the value of the primary monitor. #WORKAREAX# is the X-position of the left-side of the work area. #WORKAREAY# is the Y-position of the top-side of the work area. #WORKAREAWIDTH# is the width of the work area. #WORKAREAHEIGHT# is the height of the work area. #SCREENAREAX# is the X-position of the left-side of the monitor screen. #SCREENAREAY# is the Y-position of the top-side of the monitor screen. #SCREENAREAWIDTH# is the width of the display resolution. #SCREENAREAHEIGHT# is the height of the display resolution. The following variables are for the PRIMARY monitor. #PWORKAREAX# is the X-position of the left-side of the work area. #PWORKAREAY# is the Y-position of the top-side of the work area. #PWORKAREAWIDTH# is the width of the work area. #PWORKAREAHEIGHT# is the height of the work area. #PSCREENAREAX# is the X-position of the left-side of the monitor screen. (maybe, always 0) #PSCREENAREAY# is the Y-position of the top-side of the monitor screen. (maybe, always 0) #PSCREENAREAWIDTH# is the width of the display resolution. #PSCREENAREAHEIGHT# is the height of the display resolution. The following variables are for the SPECIFIED monitor. (@n = @1, @2, ...) #WORKAREAX@n# is the X-position of the left-side of the work area. #WORKAREAY@n# is the Y-position of the top-side of the work area. #WORKAREAWIDTH@n# is the width of the work area. #WORKAREAHEIGHT@n# is the height of the work area. #SCREENAREAX@n# is the X-position of the left-side of the monitor screen. #SCREENAREAY@n# is the Y-position of the top-side of the monitor screen. #SCREENAREAWIDTH@n# is the width of the display resolution. #SCREENAREAHEIGHT@n# is the height of the display resolution. ----- * Other related changes: - Fixed the problem that the primary monitor isn't recognized correctly. - Fixed the problem that the information of the multiple display monitors is refreshed excessively. - For DynamicVariables, when display setting or workarea size has been changed, all variables are now updated to apply changed WORKAREA/SCREENAREA variables. - Fixed the problem that the "On Desktop" window isn't dragged correctly when the top-left corner of the virtual screen has negative coordinates. - Changed the way to stick the "On Desktop" window. ("SysListView32/FolderView" is used instead of "Progman/Program Manager".) ----- * Other changes: - When the meter window is draggable and isn't dragged, LeftMouseUpAction is now executed. - Added MouseDoubleClickAction (LeftMouseDoubleClickAction, RightMouseDoubleClickAction, MiddleMouseDoubleClickAction). If MouseDoubleClickAction is empty when mouse button is double-clicked, MouseDownAction is executed instead. - Fixed the problem that the Meter's hit-test code checks outside the area. - Changed the way to set the #CURRENTCONFIG#. (CMeterWindow::GetSkinName() is now used instead of parsing the path.)
2456 lines
63 KiB
C++
2456 lines
63 KiB
C++
/*
|
|
Copyright (C) 2001 Kimmo Pekkola
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "StdAfx.h"
|
|
#include "Rainmeter.h"
|
|
#include "Error.h"
|
|
#include "AboutDialog.h"
|
|
#include "MeasureNet.h"
|
|
#include "MeterString.h"
|
|
#include "Resource.h"
|
|
#include "UpdateCheck.h"
|
|
#include <assert.h>
|
|
#include <time.h>
|
|
#include <commctrl.h>
|
|
#include <gdiplus.h>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <shlobj.h>
|
|
|
|
using namespace Gdiplus;
|
|
|
|
CRainmeter* Rainmeter; // The module
|
|
|
|
bool CRainmeter::c_DummyLitestep=false;
|
|
std::wstring CRainmeter::c_CmdLine;
|
|
|
|
/*
|
|
** ParseString
|
|
**
|
|
** Splits the given string into substrings
|
|
**
|
|
*/
|
|
std::vector<std::wstring> ParseString(LPCTSTR str)
|
|
{
|
|
std::vector<std::wstring> result;
|
|
if (str)
|
|
{
|
|
std::wstring arg = str;
|
|
|
|
// Split the argument between first space.
|
|
// Or if string is in quotes, the after the second quote.
|
|
|
|
size_t quotePos = arg.find(L"\"");
|
|
size_t spacePos = arg.find(L" ");
|
|
while (quotePos != std::wstring::npos || spacePos != std::wstring::npos)
|
|
{
|
|
size_t endPos = 0;
|
|
std::wstring newStr;
|
|
|
|
if (spacePos == std::wstring::npos) spacePos = arg.size() - 1;
|
|
|
|
if (quotePos == 0)
|
|
{
|
|
arg.erase(0, 1); // Eat the quote
|
|
|
|
// Find the second quote
|
|
quotePos = arg.find(L"\"");
|
|
endPos = quotePos;
|
|
newStr = arg.substr(0, endPos);
|
|
arg.erase(0, endPos + 1);
|
|
}
|
|
else
|
|
{
|
|
endPos = spacePos;
|
|
newStr = arg.substr(0, endPos);
|
|
arg.erase(0, endPos + 1);
|
|
}
|
|
|
|
if (newStr.size() > 0)
|
|
{
|
|
result.push_back(newStr);
|
|
}
|
|
|
|
quotePos = arg.find(L"\"");
|
|
spacePos = arg.find(L" ");
|
|
}
|
|
|
|
if (arg.size() > 0)
|
|
{
|
|
result.push_back(arg);
|
|
}
|
|
|
|
// Strip the quotes from all strings
|
|
for (size_t i = 0; i < result.size(); i++)
|
|
{
|
|
size_t pos = result[i].find(L"\"");
|
|
while (pos != std::wstring::npos)
|
|
{
|
|
result[i].erase(result[i].begin() + pos, result[i].begin() + pos + 1);
|
|
pos = result[i].find(L"\"");
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
** initModuleEx
|
|
**
|
|
** This is called when the plugin is initialized
|
|
**
|
|
*/
|
|
int initModuleEx(HWND ParentWnd, HINSTANCE dllInst, LPCSTR szPath)
|
|
{
|
|
int Result=1;
|
|
|
|
try
|
|
{
|
|
Rainmeter=new CRainmeter;
|
|
|
|
if(Rainmeter)
|
|
{
|
|
Result=Rainmeter->Initialize(ParentWnd, dllInst, szPath);
|
|
}
|
|
|
|
}
|
|
catch(CError& error)
|
|
{
|
|
MessageBox(ParentWnd, error.GetString().c_str(), APPNAME, MB_OK | MB_TOPMOST | MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
/*
|
|
** quitModule
|
|
**
|
|
** This is called when the plugin quits.
|
|
**
|
|
*/
|
|
void quitModule(HINSTANCE dllInst)
|
|
{
|
|
if(Rainmeter)
|
|
{
|
|
Rainmeter->Quit(dllInst);
|
|
delete Rainmeter;
|
|
Rainmeter = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Initialize
|
|
**
|
|
** Init Rainmeter
|
|
**
|
|
*/
|
|
void Initialize(bool DummyLS, LPCTSTR CmdLine)
|
|
{
|
|
CRainmeter::SetDummyLitestep(DummyLS);
|
|
CRainmeter::SetCommandLine(CmdLine);
|
|
}
|
|
|
|
|
|
/*
|
|
** ReadConfigString
|
|
**
|
|
** Reads a config string. Used by the plugins.
|
|
**
|
|
*/
|
|
LPCTSTR ReadConfigString(LPCTSTR section, LPCTSTR key, LPCTSTR defValue)
|
|
{
|
|
if (Rainmeter)
|
|
{
|
|
CConfigParser* parser = Rainmeter->GetCurrentParser();
|
|
if (parser)
|
|
{
|
|
return parser->ReadString(section, key, defValue, false).c_str();
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
** BangWithArgs
|
|
**
|
|
** Parses Bang args
|
|
**
|
|
*/
|
|
void BangWithArgs(BANGCOMMAND bang, const WCHAR* arg, size_t numOfArgs)
|
|
{
|
|
if(Rainmeter)
|
|
{
|
|
std::vector<std::wstring> subStrings = ParseString(arg);
|
|
std::wstring config;
|
|
std::wstring argument;
|
|
|
|
// Don't include the config name from the arg if there is one
|
|
for (size_t i = 0; i < numOfArgs; i++)
|
|
{
|
|
if (i != 0) argument += L" ";
|
|
if (i < subStrings.size())
|
|
{
|
|
argument += subStrings[i];
|
|
}
|
|
}
|
|
|
|
if (subStrings.size() >= numOfArgs)
|
|
{
|
|
if (subStrings.size() > numOfArgs)
|
|
{
|
|
config = subStrings[numOfArgs];
|
|
}
|
|
|
|
if ((!config.empty()) && (config != L"*"))
|
|
{
|
|
// Config defined, so bang only that
|
|
CMeterWindow* meterWindow = Rainmeter->GetMeterWindow(config);
|
|
|
|
if (meterWindow)
|
|
{
|
|
if (bang == BANG_LSHOOK)
|
|
{
|
|
// LsHook is a special case
|
|
meterWindow->RunBang(bang, arg);
|
|
}
|
|
else
|
|
{
|
|
meterWindow->RunBang(bang, argument.c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::wstring dbg;
|
|
dbg = L"Unknown config name: " + config;
|
|
LSLog(LOG_DEBUG, APPNAME, dbg.c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No config defined -> apply to all.
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = Rainmeter->GetAllMeterWindows().begin();
|
|
|
|
for (; iter != Rainmeter->GetAllMeterWindows().end(); iter++)
|
|
{
|
|
((*iter).second)->RunBang(bang, argument.c_str());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugLog(L"Incorrect number of arguments for the bang!");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** RainmeterHide
|
|
**
|
|
** Callback for the !RainmeterHide bang
|
|
**
|
|
*/
|
|
void RainmeterHide(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_HIDE, ConvertToWide(arg).c_str(), 0);
|
|
}
|
|
|
|
/*
|
|
** RainmeterShow
|
|
**
|
|
** Callback for the !RainmeterShow bang
|
|
**
|
|
*/
|
|
void RainmeterShow(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_SHOW, ConvertToWide(arg).c_str(), 0);
|
|
}
|
|
|
|
/*
|
|
** RainmeterToggle
|
|
**
|
|
** Callback for the !RainmeterToggle bang
|
|
**
|
|
*/
|
|
void RainmeterToggle(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_TOGGLE, ConvertToWide(arg).c_str(), 0);
|
|
}
|
|
|
|
/*
|
|
** RainmeterHideMeter
|
|
**
|
|
** Callback for the !RainmeterHideMeter bang
|
|
**
|
|
*/
|
|
void RainmeterHideMeter(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_HIDEMETER, ConvertToWide(arg).c_str(), 1);
|
|
}
|
|
|
|
/*
|
|
** RainmeterShowMeter
|
|
**
|
|
** Callback for the !RainmeterShowMeter bang
|
|
**
|
|
*/
|
|
void RainmeterShowMeter(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_SHOWMETER, ConvertToWide(arg).c_str(), 1);
|
|
}
|
|
|
|
/*
|
|
** RainmeterToggleMeter
|
|
**
|
|
** Callback for the !RainmeterToggleMeter bang
|
|
**
|
|
*/
|
|
void RainmeterToggleMeter(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_TOGGLEMETER, ConvertToWide(arg).c_str(), 1);
|
|
}
|
|
|
|
/*
|
|
** RainmeterHideMeasure
|
|
**
|
|
** Callback for the !RainmeterHideMeasure bang
|
|
**
|
|
*/
|
|
void RainmeterDisableMeasure(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_DISABLEMEASURE, ConvertToWide(arg).c_str(), 1);
|
|
}
|
|
|
|
/*
|
|
** RainmeterShowMeasure
|
|
**
|
|
** Callback for the !RainmeterShowMeasure bang
|
|
**
|
|
*/
|
|
void RainmeterEnableMeasure(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_ENABLEMEASURE, ConvertToWide(arg).c_str(), 1);
|
|
}
|
|
|
|
/*
|
|
** RainmeterToggleMeasure
|
|
**
|
|
** Callback for the !RainmeterToggleMeasure bang
|
|
**
|
|
*/
|
|
void RainmeterToggleMeasure(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_TOGGLEMEASURE, ConvertToWide(arg).c_str(), 1);
|
|
}
|
|
|
|
/*
|
|
** RainmeterRefresh
|
|
**
|
|
** Callback for the !RainmeterRefresh bang
|
|
**
|
|
*/
|
|
void RainmeterRefresh(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_REFRESH, ConvertToWide(arg).c_str(), 0);
|
|
}
|
|
|
|
/*
|
|
** RainmeterRedraw
|
|
**
|
|
** Callback for the !RainmeterRedraw bang
|
|
**
|
|
*/
|
|
void RainmeterRedraw(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_REDRAW, ConvertToWide(arg).c_str(), 0);
|
|
}
|
|
|
|
/*
|
|
** RainmeterActivateConfig
|
|
**
|
|
** Callback for the !RainmeterActivateConfig bang
|
|
**
|
|
*/
|
|
void RainmeterActivateConfig(HWND, const char* arg)
|
|
{
|
|
if (Rainmeter)
|
|
{
|
|
std::vector<std::wstring> subStrings = ParseString(ConvertToWide(arg).c_str());
|
|
|
|
if (subStrings.size() > 1)
|
|
{
|
|
const std::vector<CRainmeter::CONFIG>& configs = Rainmeter->GetAllConfigs();
|
|
|
|
for (size_t i = 0; i < configs.size(); i++)
|
|
{
|
|
if (wcsnicmp(configs[i].config.c_str(), subStrings[0].c_str(), configs[i].config.length()) == 0)
|
|
{
|
|
for (size_t j = 0; j < configs[i].iniFiles.size(); j++)
|
|
{
|
|
if (wcsnicmp(configs[i].iniFiles[j].c_str(), subStrings[1].c_str(), configs[i].iniFiles[j].length()) == 0)
|
|
{
|
|
Rainmeter->ActivateConfig(i, j);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DebugLog(L"No such config: \"%s\" \"%s\"", subStrings[0].c_str(), subStrings[1].c_str());
|
|
}
|
|
else
|
|
{
|
|
// If we got this far, something went wrong
|
|
DebugLog(L"Cannot parse parameters for !RainmeterActivateConfig");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** RainmeterDeactivateConfig
|
|
**
|
|
** Callback for the !RainmeterDeactivateConfig bang
|
|
**
|
|
*/
|
|
void RainmeterDeactivateConfig(HWND, const char* arg)
|
|
{
|
|
if (Rainmeter)
|
|
{
|
|
std::vector<std::wstring> subStrings = ParseString(ConvertToWide(arg).c_str());
|
|
|
|
if (subStrings.size() > 0)
|
|
{
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = Rainmeter->GetAllMeterWindows().begin();
|
|
for (; iter != Rainmeter->GetAllMeterWindows().end(); iter++)
|
|
{
|
|
CMeterWindow* mw = ((*iter).second);
|
|
if (wcsicmp(subStrings[0].c_str(), mw->GetSkinName().c_str()) == 0)
|
|
{
|
|
Rainmeter->DeactivateConfig(mw, -1); // -1 = Deactivate all ini-files
|
|
return;
|
|
}
|
|
}
|
|
DebugLog(L"The config is not active: \"%s\"", subStrings[0].c_str());
|
|
}
|
|
else
|
|
{
|
|
DebugLog(L"Unable to parse the arguments for !RainmeterDeactivateConfig");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** RainmeterToggleConfig
|
|
**
|
|
** Callback for the !RainmeterToggleConfig bang
|
|
**
|
|
*/
|
|
void RainmeterToggleConfig(HWND, const char* arg)
|
|
{
|
|
if (Rainmeter)
|
|
{
|
|
std::vector<std::wstring> subStrings = ParseString(ConvertToWide(arg).c_str());
|
|
|
|
if (subStrings.size() >= 2)
|
|
{
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = Rainmeter->GetAllMeterWindows().begin();
|
|
for (; iter != Rainmeter->GetAllMeterWindows().end(); iter++)
|
|
{
|
|
CMeterWindow* mw = ((*iter).second);
|
|
if (wcsicmp(subStrings[0].c_str(), mw->GetSkinName().c_str()) == 0)
|
|
{
|
|
Rainmeter->DeactivateConfig(mw, -1); // -1 = Deactivate all ini-files
|
|
return;
|
|
}
|
|
}
|
|
|
|
// If the config wasn't active, activate it
|
|
RainmeterActivateConfig(NULL, arg);
|
|
}
|
|
else
|
|
{
|
|
DebugLog(L"Unable to parse the arguments for !RainmeterToggleConfig");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** RainmeterMove
|
|
**
|
|
** Callback for the !RainmeterMove bang
|
|
**
|
|
*/
|
|
void RainmeterMove(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_MOVE, ConvertToWide(arg).c_str(), 2);
|
|
}
|
|
|
|
/*
|
|
** RainmeterZPos
|
|
**
|
|
** Callback for the !RainmeterZPos bang
|
|
**
|
|
*/
|
|
void RainmeterZPos(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_ZPOS, ConvertToWide(arg).c_str(), 1);
|
|
}
|
|
|
|
/*
|
|
** RainmeterLsHook
|
|
**
|
|
** Callback for the !RainmeterLsHook bang
|
|
**
|
|
*/
|
|
void RainmeterLsHook(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_LSHOOK, ConvertToWide(arg).c_str(), 0);
|
|
}
|
|
|
|
/*
|
|
** RainmeterAbout
|
|
**
|
|
** Callback for the !RainmeterAbout bang
|
|
**
|
|
*/
|
|
void RainmeterAbout(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_ABOUT, ConvertToWide(arg).c_str(), 0);
|
|
}
|
|
|
|
/*
|
|
** RainmeterResetStats
|
|
**
|
|
** Callback for the !RainmeterResetStats bang
|
|
**
|
|
*/
|
|
void RainmeterResetStats(HWND, const char* arg)
|
|
{
|
|
if (Rainmeter)
|
|
{
|
|
Rainmeter->ResetStats();
|
|
}
|
|
}
|
|
|
|
/*
|
|
** RainmeterMoveMeter
|
|
**
|
|
** Callback for the !RainmeterMoveMeter bang
|
|
**
|
|
*/
|
|
void RainmeterMoveMeter(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_MOVEMETER, ConvertToWide(arg).c_str(), 3);
|
|
}
|
|
|
|
/*
|
|
** RainmeterPluginBang
|
|
**
|
|
** Callback for the !RainmeterPluginBang bang
|
|
**
|
|
*/
|
|
void RainmeterPluginBang(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_PLUGIN, ConvertToWide(arg).c_str(), 1);
|
|
}
|
|
|
|
/*
|
|
** RainmeterQuit
|
|
**
|
|
** Callback for the !RainmeterQuit bang
|
|
**
|
|
*/
|
|
void RainmeterQuit(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_QUIT, ConvertToWide(arg).c_str(), 0);
|
|
}
|
|
|
|
/*
|
|
** RainmeterSetVariable
|
|
**
|
|
** Callback for the !RainmeterSetVariable bang
|
|
**
|
|
*/
|
|
void RainmeterSetVariable(HWND, const char* arg)
|
|
{
|
|
BangWithArgs(BANG_SETVARIABLE, ConvertToWide(arg).c_str(), 2);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------------
|
|
//
|
|
// The class starts here
|
|
//
|
|
// -----------------------------------------------------------------------------------------------
|
|
|
|
GlobalConfig CRainmeter::c_GlobalConfig;
|
|
|
|
/*
|
|
** CRainmeter
|
|
**
|
|
** Constructor
|
|
**
|
|
*/
|
|
CRainmeter::CRainmeter()
|
|
{
|
|
c_GlobalConfig.netInSpeed = 0;
|
|
c_GlobalConfig.netOutSpeed = 0;
|
|
|
|
m_DesktopWorkAreaChanged = false;
|
|
m_DesktopWorkArea.left = m_DesktopWorkArea.top = m_DesktopWorkArea.right = m_DesktopWorkArea.bottom = 0;
|
|
|
|
m_CheckUpdate = FALSE;
|
|
|
|
m_Instance = NULL;
|
|
m_CurrentParser = NULL;
|
|
|
|
m_TrayWindow = NULL;
|
|
|
|
m_ConfigEditor = L"Notepad";
|
|
|
|
INITCOMMONCONTROLSEX initCtrls;
|
|
initCtrls.dwSize = sizeof(INITCOMMONCONTROLSEX);
|
|
initCtrls.dwICC = ICC_TAB_CLASSES;
|
|
InitCommonControlsEx(&initCtrls);
|
|
|
|
// Initialize GDI+.
|
|
GdiplusStartupInput gdiplusStartupInput;
|
|
GdiplusStartup(&m_GDIplusToken, &gdiplusStartupInput, NULL);
|
|
}
|
|
|
|
/*
|
|
** ~CRainmeter
|
|
**
|
|
** Destructor
|
|
**
|
|
*/
|
|
CRainmeter::~CRainmeter()
|
|
{
|
|
// Change the work area back
|
|
if (m_DesktopWorkAreaChanged)
|
|
{
|
|
SystemParametersInfo(SPI_SETWORKAREA, 0, &m_DesktopWorkArea, 0);
|
|
}
|
|
|
|
while (m_Meters.size() > 0)
|
|
{
|
|
DeleteMeterWindow((*m_Meters.begin()).second, false); // This removes the window from the vector
|
|
}
|
|
|
|
if (m_TrayWindow) delete m_TrayWindow;
|
|
|
|
WriteStats(true);
|
|
|
|
CMeterString::FreeFontCache();
|
|
|
|
GdiplusShutdown(m_GDIplusToken);
|
|
}
|
|
|
|
/*
|
|
** ExecuteBang
|
|
**
|
|
** Runs a bang command. This is called from the main application
|
|
** when a command is given as a command line argument.
|
|
**
|
|
*/
|
|
void ExecuteBang(LPCTSTR szBang)
|
|
{
|
|
if (Rainmeter) Rainmeter->ExecuteCommand(szBang, NULL);
|
|
}
|
|
|
|
/*
|
|
** Initialize
|
|
**
|
|
** The main initialization function for the module.
|
|
** May throw CErrors !!!!
|
|
**
|
|
*/
|
|
int CRainmeter::Initialize(HWND Parent, HINSTANCE Instance, LPCSTR szPath)
|
|
{
|
|
int Result=0;
|
|
|
|
if(Parent==NULL || Instance==NULL)
|
|
{
|
|
throw CError(CError::ERROR_NULL_PARAMETER, __LINE__, __FILE__);
|
|
}
|
|
|
|
m_Instance = Instance;
|
|
WCHAR tmpName[MAX_LINE_LENGTH];
|
|
GetModuleFileName(m_Instance, tmpName, MAX_LINE_LENGTH);
|
|
|
|
// Remove the module's name from the path
|
|
WCHAR* pos = wcsrchr(tmpName, L'\\');
|
|
if(pos)
|
|
{
|
|
*(pos + 1) = L'\0';
|
|
}
|
|
else
|
|
{
|
|
tmpName[0] = L'\0';
|
|
}
|
|
|
|
if(!c_DummyLitestep) InitalizeLitestep();
|
|
|
|
bool bDefaultIniLocation = false;
|
|
|
|
m_Path = tmpName;
|
|
if (c_CmdLine.empty())
|
|
{
|
|
m_IniFile = m_Path + L"Rainmeter.ini";
|
|
|
|
// If the ini file doesn't exist in the program folder store it to the %APPDATA% instead so that things work better in Vista/Win7
|
|
if (_waccess(m_IniFile.c_str(), 0) == -1)
|
|
{
|
|
m_IniFile = L"%APPDATA%\\Rainmeter\\Rainmeter.ini";
|
|
ExpandEnvironmentVariables(m_IniFile);
|
|
bDefaultIniLocation = true;
|
|
|
|
// If the ini file doesn't exist in the %APPDATA% either, create a default rainmeter.ini file.
|
|
if (_waccess(m_IniFile.c_str(), 0) == -1)
|
|
{
|
|
CreateDefaultConfigFile(m_IniFile);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The command line defines the location of Rainmeter.ini (or whatever it calls it).
|
|
std::wstring iniFile = c_CmdLine;
|
|
if (iniFile[0] == L'\"' && iniFile[iniFile.length() - 1] == L'\"')
|
|
{
|
|
iniFile = iniFile.substr(1, iniFile.length() - 2);
|
|
}
|
|
|
|
ExpandEnvironmentVariables(iniFile);
|
|
|
|
if (iniFile[iniFile.length() - 1] == L'\\')
|
|
{
|
|
iniFile += L"Rainmeter.ini";
|
|
}
|
|
else if (iniFile.substr(iniFile.length() - 4) != L".ini")
|
|
{
|
|
iniFile += L"\\Rainmeter.ini";
|
|
}
|
|
|
|
m_IniFile = iniFile;
|
|
|
|
// If the ini file doesn't exist in the %APPDATA% either, create a default rainmeter.ini file.
|
|
if (_waccess(m_IniFile.c_str(), 0) == -1)
|
|
{
|
|
CreateDefaultConfigFile(m_IniFile);
|
|
}
|
|
bDefaultIniLocation = true;
|
|
}
|
|
|
|
m_PluginPath = tmpName;
|
|
m_PluginPath += L"Plugins\\";
|
|
m_SkinPath = m_Path + L"Skins\\";
|
|
|
|
// Read the skin folder from the ini file
|
|
WCHAR tmpSz[MAX_LINE_LENGTH];
|
|
if (GetPrivateProfileString(L"Rainmeter", L"SkinPath", L"", tmpSz, MAX_LINE_LENGTH, m_IniFile.c_str()) > 0)
|
|
{
|
|
m_SkinPath = tmpSz;
|
|
ExpandEnvironmentVariables(m_SkinPath);
|
|
}
|
|
else if (bDefaultIniLocation)
|
|
{
|
|
// If the skin path is not defined in the rainmeter.ini file use My Documents/Rainmeter/Skins
|
|
TCHAR szPath[MAX_PATH] = {0};
|
|
HRESULT hr = SHGetFolderPath(NULL, CSIDL_MYDOCUMENTS, NULL, SHGFP_TYPE_CURRENT, szPath);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Make the folders if they don't exist yet
|
|
m_SkinPath = szPath;
|
|
m_SkinPath += L"\\Rainmeter";
|
|
CreateDirectory(m_SkinPath.c_str(), NULL);
|
|
m_SkinPath += L"\\Skins";
|
|
DWORD result = CreateDirectory(m_SkinPath.c_str(), NULL);
|
|
m_SkinPath += L"\\";
|
|
if (result != 0)
|
|
{
|
|
// The folder was created successfully which means that it wasn't available yet.
|
|
// Copy the default skin to the Skins folder
|
|
std::wstring strFrom(m_Path + L"Skins\\" + L"*.*");
|
|
std::wstring strTo(m_SkinPath);
|
|
CopyFiles(strFrom, strTo);
|
|
|
|
// This shouldn't be copied
|
|
std::wstring strNote = strTo + L"Read me before copying skins to here.txt";
|
|
DeleteFile(strNote.c_str());
|
|
|
|
// Copy also the themes to the %APPDATA%
|
|
strFrom = std::wstring(m_Path + L"Themes\\" + L"*.*");
|
|
strTo = std::wstring(GetSettingsPath() + L"Themes");
|
|
CreateDirectory(strTo.c_str(), NULL);
|
|
strTo += L"\\";
|
|
CopyFiles(strFrom, strTo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugLog(L"Unable to get the My Documents location.");
|
|
}
|
|
}
|
|
WritePrivateProfileString(L"Rainmeter", L"SkinPath", m_SkinPath.c_str(), m_IniFile.c_str());
|
|
|
|
// Set the log file location
|
|
m_LogFile = m_IniFile;
|
|
size_t posExt = m_LogFile.find(L".ini");
|
|
if (posExt != std::wstring::npos)
|
|
{
|
|
m_LogFile.replace(posExt, 4, L".log");
|
|
}
|
|
else
|
|
{
|
|
m_LogFile += L".log"; // Append the extension so that we don't accidentally overwrite the ini file
|
|
}
|
|
|
|
if (!c_DummyLitestep)
|
|
{
|
|
char tmpSz[MAX_LINE_LENGTH];
|
|
|
|
// Check if step.rc has overrides these values
|
|
if (GetRCString("RainmeterIniFile", tmpSz, NULL, MAX_LINE_LENGTH - 1))
|
|
{
|
|
m_IniFile = ConvertToWide(tmpSz);
|
|
}
|
|
|
|
if (GetRCString("RainmeterSkinPath", tmpSz, NULL, MAX_LINE_LENGTH - 1))
|
|
{
|
|
m_SkinPath = ConvertToWide(tmpSz);
|
|
}
|
|
|
|
if (GetRCString("RainmeterPluginPath", tmpSz, NULL, MAX_LINE_LENGTH - 1))
|
|
{
|
|
m_PluginPath = ConvertToWide(tmpSz);
|
|
}
|
|
|
|
if (!m_SkinPath.empty() && m_SkinPath[m_SkinPath.size() - 1] != L'\\')
|
|
{
|
|
m_SkinPath += L"\\";
|
|
}
|
|
}
|
|
|
|
DebugLog(L"Path: %s", m_Path.c_str());
|
|
DebugLog(L"IniFile: %s", m_IniFile.c_str());
|
|
DebugLog(L"SkinPath: %s", m_SkinPath.c_str());
|
|
DebugLog(L"PluginPath: %s", m_PluginPath.c_str());
|
|
|
|
// Test that the Rainmeter.ini file is writable
|
|
TestSettingsFile(bDefaultIniLocation);
|
|
|
|
// If the skin folder is somewhere else than in the program path
|
|
if (wcsnicmp(m_Path.c_str(), m_SkinPath.c_str(), m_Path.size()) != 0)
|
|
{
|
|
CheckSkinVersions();
|
|
}
|
|
|
|
// Tray must exist before configs are read
|
|
m_TrayWindow = new CTrayWindow(m_Instance);
|
|
|
|
ScanForConfigs(m_SkinPath);
|
|
ScanForThemes(GetSettingsPath() + L"Themes");
|
|
|
|
if(m_ConfigStrings.empty())
|
|
{
|
|
std::wstring error = L"There are no available skins at:\n" + m_SkinPath;
|
|
MessageBox(NULL, error.c_str(), L"Rainmeter", MB_OK | MB_ICONERROR);
|
|
}
|
|
|
|
ReadGeneralSettings(m_IniFile);
|
|
|
|
if (m_CheckUpdate)
|
|
{
|
|
CheckUpdate();
|
|
}
|
|
|
|
ResetStats();
|
|
ReadStats();
|
|
|
|
if (_waccess(m_IniFile.c_str(), 0) == -1)
|
|
{
|
|
m_TrayWindow->ShowBalloonHelp();
|
|
}
|
|
|
|
// Change the work area if necessary
|
|
if (m_DesktopWorkAreaChanged)
|
|
{
|
|
RECT rc;
|
|
rc = m_DesktopWorkArea;
|
|
SystemParametersInfo(SPI_GETWORKAREA, 0, &m_DesktopWorkArea, 0); // Store the old value
|
|
SystemParametersInfo(SPI_SETWORKAREA, 0, &rc, 0);
|
|
}
|
|
|
|
// If we're running as Litestep's plugin, register the !bangs
|
|
if(!c_DummyLitestep)
|
|
{
|
|
int Msgs[] = { LM_GETREVID, 0 };
|
|
// Register RevID message to Litestep
|
|
if (m_TrayWindow && m_TrayWindow->GetWindow()) ::SendMessage(GetLitestepWnd(), LM_REGISTERMESSAGE, (WPARAM)m_TrayWindow->GetWindow(), (LPARAM)Msgs);
|
|
|
|
AddBangCommand("!RainmeterRefresh", RainmeterRefresh);
|
|
AddBangCommand("!RainmeterRedraw", RainmeterRedraw);
|
|
AddBangCommand("!RainmeterHide", RainmeterHide);
|
|
AddBangCommand("!RainmeterShow", RainmeterShow);
|
|
AddBangCommand("!RainmeterToggle", RainmeterToggle);
|
|
AddBangCommand("!RainmeterHideMeter", RainmeterHideMeter);
|
|
AddBangCommand("!RainmeterShowMeter", RainmeterShowMeter);
|
|
AddBangCommand("!RainmeterToggleMeter", RainmeterToggleMeter);
|
|
AddBangCommand("!RainmeterDisableMeasure", RainmeterDisableMeasure);
|
|
AddBangCommand("!RainmeterEnableMeasure", RainmeterEnableMeasure);
|
|
AddBangCommand("!RainmeterToggleMeasure", RainmeterToggleMeasure);
|
|
AddBangCommand("!RainmeterActivateConfig", RainmeterActivateConfig);
|
|
AddBangCommand("!RainmeterToggleConfig", RainmeterToggleConfig);
|
|
AddBangCommand("!RainmeterDeactivateConfig", RainmeterDeactivateConfig);
|
|
AddBangCommand("!RainmeterMove", RainmeterMove);
|
|
AddBangCommand("!RainmeterZPos", RainmeterZPos);
|
|
AddBangCommand("!RainmeterLsBoxHook", RainmeterLsHook);
|
|
AddBangCommand("!RainmeterAbout", RainmeterAbout);
|
|
AddBangCommand("!RainmeterResetStats", RainmeterResetStats);
|
|
AddBangCommand("!RainmeterMoveMeter", RainmeterMoveMeter);
|
|
AddBangCommand("!RainmeterPluginBang", RainmeterPluginBang);
|
|
AddBangCommand("!RainmeterQuit", RainmeterQuit);
|
|
AddBangCommand("!RainmeterSetVariable", RainmeterSetVariable);
|
|
}
|
|
|
|
// Create meter windows for active configs
|
|
for (size_t i = 0; i < m_ConfigStrings.size(); i++)
|
|
{
|
|
if (m_ConfigStrings[i].active > 0 && m_ConfigStrings[i].active <= (int)m_ConfigStrings[i].iniFiles.size())
|
|
{
|
|
ActivateConfig(i, m_ConfigStrings[i].active - 1);
|
|
}
|
|
}
|
|
|
|
return Result; // Alles OK
|
|
}
|
|
|
|
/*
|
|
** CheckSkinVersions
|
|
**
|
|
** Checks if any of the skins in the program folder are newer than in the skin folder.
|
|
**
|
|
*/
|
|
void CRainmeter::CheckSkinVersions()
|
|
{
|
|
// List all skins in the program folder
|
|
std::wstring strMainSkinsPath = m_Path + L"Skins\\";
|
|
std::vector<CONFIGMENU> menu;
|
|
ScanForConfigsRecursive(strMainSkinsPath, L"", 0, menu, true);
|
|
|
|
for (size_t i = 0; i < menu.size(); i++)
|
|
{
|
|
// DebugLog(L"%s", menu[i].name.c_str());
|
|
|
|
// Read the version files
|
|
std::wstring strNewVersionFile = strMainSkinsPath + menu[i].name + L"\\version";
|
|
std::wstring strCurrentVersionFile = m_SkinPath + menu[i].name + L"\\version";
|
|
|
|
std::string strVersion;
|
|
std::wstring strVersionNew;
|
|
std::wstring strVersionCurrent;
|
|
std::wstring strVersionInIni;
|
|
|
|
std::ifstream newFile(strNewVersionFile.c_str(), std::ios_base::in);
|
|
if (getline(newFile, strVersion))
|
|
{
|
|
strVersionNew = ConvertToWide(strVersion.c_str());
|
|
// DebugLog(L"New: %s", strVersionNew.c_str());
|
|
|
|
// Compare with the version entry in the Rainmeter.ini
|
|
WCHAR tmpSz[MAX_LINE_LENGTH] = {0};
|
|
GetPrivateProfileString(menu[i].name.c_str(), L"Version", L"", tmpSz, MAX_LINE_LENGTH, m_IniFile.c_str());
|
|
strVersionInIni = tmpSz;
|
|
|
|
// DebugLog(L"In Ini: %s", strVersionInIni.c_str());
|
|
|
|
// Compare with the version file in the skin folder
|
|
std::ifstream currentFile(strCurrentVersionFile.c_str(), std::ios_base::in);
|
|
if (getline(currentFile, strVersion))
|
|
{
|
|
strVersionCurrent = ConvertToWide(strVersion.c_str());
|
|
// DebugLog(L"Current: %s", strVersionCurrent.c_str());
|
|
}
|
|
}
|
|
|
|
// If the skin doesn't define a version file no need to do anything
|
|
if (!strVersionNew.empty())
|
|
{
|
|
// Compare the version files
|
|
if (CompareVersions(strVersionNew, strVersionInIni) == 1 &&
|
|
CompareVersions(strVersionNew, strVersionCurrent) == 1)
|
|
{
|
|
// Check if the old skin exists at all
|
|
struct _stat64i32 s;
|
|
std::wstring strSkinPath = m_SkinPath + menu[i].name;
|
|
if (_wstat(strSkinPath.c_str(), &s) == 0)
|
|
{
|
|
std::wstring strMessage = L"The config called \"" + menu[i].name + L"\" is newer\nthan the one you are currently using.\n\n";
|
|
strMessage += L"New config: " + (strVersionNew.empty() ? L"Unknown" : strVersionNew) + L"\n";
|
|
strMessage += L"Current config: " + (strVersionCurrent.empty() ? L"Unknown" : strVersionCurrent) + L"\n";
|
|
strMessage += L"\n";
|
|
strMessage += L"Do you want to upgrade it?";
|
|
strMessage += L"\n\n";
|
|
strMessage += L"(If you select 'Yes' your old config\nwill be moved to the 'Backup' folder)";
|
|
|
|
if (IDYES == MessageBox(NULL, strMessage.c_str(), APPNAME, MB_YESNO | MB_ICONQUESTION))
|
|
{
|
|
// Make sure that the folder exists
|
|
CreateDirectory(std::wstring(m_SkinPath + L"Backup").c_str(), NULL);
|
|
|
|
// Check for illegal characters from the version number
|
|
if (strVersionCurrent.find_first_of(L"\\/\"*:?<>|") == std::wstring::npos)
|
|
{
|
|
std::wstring strTarget = m_SkinPath + L"Backup\\" + menu[i].name + L"-" + strVersionCurrent;
|
|
if (CopyFiles(m_SkinPath + menu[i].name, strTarget, true)) // Move the folder to "backup"
|
|
{
|
|
// Upgrade the skin
|
|
CopyFiles(strMainSkinsPath + menu[i].name, m_SkinPath);
|
|
|
|
// TODO: Temporary 'fix': If this was Enigma upgrade the themes too
|
|
if (menu[i].name == L"Enigma")
|
|
{
|
|
std::wstring strMainThemes = m_Path + L"Themes";
|
|
std::wstring strCurrentThemes = GetSettingsPath();
|
|
CopyFiles(strMainThemes, strCurrentThemes);
|
|
}
|
|
// End of temporary 'fix'
|
|
}
|
|
else
|
|
{
|
|
std::wstring strMessage = L"Failed to upgrade the config.\nUnable to backup the current config.";
|
|
MessageBox(NULL, strMessage.c_str(), APPNAME, MB_OK | MB_ICONERROR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::wstring strMessage = L"Failed to upgrade the config.\nThe version number contains illegal characters.";
|
|
MessageBox(NULL, strMessage.c_str(), APPNAME, MB_OK | MB_ICONERROR);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::wstring strMessage = L"A new version of config called \"" + menu[i].name + L"\" is available\n";
|
|
strMessage += L"Do you want to add it to your skin library?";
|
|
if (IDYES == MessageBox(NULL, strMessage.c_str(), APPNAME, MB_YESNO | MB_ICONQUESTION))
|
|
{
|
|
CopyFiles(strMainSkinsPath + menu[i].name, m_SkinPath);
|
|
}
|
|
}
|
|
|
|
// Even if the user doesn't want to upgrade mark it to the Rainmeter.ini so we don't ask the upgrade question again
|
|
WritePrivateProfileString(menu[i].name.c_str(), L"Version", strVersionNew.c_str(), m_IniFile.c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** CompareVersions
|
|
**
|
|
** Compares two version strings. Returns 0 if they are equal, 1 if A > B and -1 if A < B.
|
|
**
|
|
*/
|
|
int CRainmeter::CompareVersions(std::wstring strA, std::wstring strB)
|
|
{
|
|
if (strA.empty() && strB.empty()) return 0;
|
|
if (strA.empty()) return -1;
|
|
if (strB.empty()) return 1;
|
|
|
|
std::vector<std::wstring> arrayA = CConfigParser::Tokenize(strA, L".");
|
|
std::vector<std::wstring> arrayB = CConfigParser::Tokenize(strB, L".");
|
|
|
|
size_t len = max(arrayA.size(), arrayB.size());
|
|
for (size_t i = 0; i < len; i++)
|
|
{
|
|
int a = 0;
|
|
int b = 0;
|
|
|
|
if (i < arrayA.size())
|
|
{
|
|
a = _wtoi(arrayA[i].c_str());
|
|
}
|
|
if (i < arrayB.size())
|
|
{
|
|
b = _wtoi(arrayB[i].c_str());
|
|
}
|
|
|
|
if (a > b) return 1;
|
|
if (a < b) return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** CopyFiles
|
|
**
|
|
** Copies files and folders from one location to another.
|
|
**
|
|
*/
|
|
bool CRainmeter::CopyFiles(std::wstring strFrom, std::wstring strTo, bool bMove)
|
|
{
|
|
// The strings must end with double nul
|
|
strFrom.append(L"0");
|
|
strFrom[strFrom.size() - 1] = L'\0';
|
|
strTo.append(L"0");
|
|
strTo[strTo.size() - 1] = L'\0';
|
|
|
|
SHFILEOPSTRUCT fo = {0};
|
|
fo.wFunc = bMove ? FO_MOVE : FO_COPY;
|
|
fo.pFrom = strFrom.c_str();
|
|
fo.pTo = strTo.c_str();
|
|
fo.fFlags = FOF_NO_UI | FOF_NOCONFIRMATION | FOF_ALLOWUNDO;
|
|
|
|
int result = SHFileOperation(&fo);
|
|
if (result != 0)
|
|
{
|
|
DebugLog(L"Unable to copy files from %s to %s (%i)", strFrom.c_str(), strTo.c_str(), result);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
** CreateDefaultConfigFile
|
|
**
|
|
** Creates the default Rainmeter.ini file. The CPU tray meter and Tranquil/System-C config
|
|
** are enabled.
|
|
**
|
|
*/
|
|
void CRainmeter::CreateDefaultConfigFile(std::wstring strFile)
|
|
{
|
|
size_t pos = strFile.find_last_of(L'\\');
|
|
if (pos != std::wstring::npos)
|
|
{
|
|
std::wstring strPath(strFile.begin(), strFile.begin() + pos);
|
|
CreateDirectory(strPath.c_str(), NULL);
|
|
}
|
|
|
|
std::wstring defaultIni = GetPath() + L"Default.ini";
|
|
if (_waccess(defaultIni.c_str(), 0) == -1)
|
|
{
|
|
// The default.ini wasn't found -> create new
|
|
std::ofstream out(strFile.c_str(), std::ios::out);
|
|
if (out)
|
|
{
|
|
out << std::string("[Rainmeter]\n\n[TrayMeasure]\nMeasure=CPU\n\n[Tranquil\\System]\nActive=1\n");
|
|
out.close();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CopyFiles(defaultIni, GetIniFile());
|
|
}
|
|
}
|
|
|
|
void CRainmeter::ReloadSettings()
|
|
{
|
|
ScanForConfigs(m_SkinPath);
|
|
ScanForThemes(GetSettingsPath() + L"Themes");
|
|
ReadGeneralSettings(m_IniFile);
|
|
}
|
|
|
|
void CRainmeter::ActivateConfig(int configIndex, int iniIndex)
|
|
{
|
|
if (configIndex >= 0 && configIndex < (int)m_ConfigStrings.size())
|
|
{
|
|
WCHAR buffer[256];
|
|
std::wstring skinIniFile = m_ConfigStrings[configIndex].iniFiles[iniIndex];
|
|
std::wstring skinConfig = m_ConfigStrings[configIndex].config;
|
|
std::wstring skinPath = m_ConfigStrings[configIndex].path;
|
|
|
|
// Verify that the config is not already active
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = m_Meters.find(skinConfig);
|
|
if (iter != m_Meters.end())
|
|
{
|
|
if (((*iter).second)->GetSkinIniFile() == skinIniFile)
|
|
{
|
|
DebugLog(L"MeterWindow \"%s\" is already active.", skinConfig.c_str());
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// Deactivate the existing config
|
|
DeactivateConfig((*iter).second, configIndex);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
m_ConfigStrings[configIndex].active = iniIndex + 1;
|
|
|
|
wsprintf(buffer, L"%i", iniIndex + 1);
|
|
WritePrivateProfileString(skinConfig.c_str(), L"Active", buffer, m_IniFile.c_str());
|
|
|
|
CreateMeterWindow(skinPath, skinConfig, skinIniFile);
|
|
}
|
|
catch(CError& error)
|
|
{
|
|
MessageBox(NULL, error.GetString().c_str(), APPNAME, MB_OK | MB_TOPMOST | MB_ICONEXCLAMATION);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CRainmeter::DeactivateConfig(CMeterWindow* meterWindow, int configIndex)
|
|
{
|
|
if (configIndex >= 0 && configIndex < (int)m_ConfigStrings.size())
|
|
{
|
|
m_ConfigStrings[configIndex].active = 0; // Deactivate the config
|
|
}
|
|
else
|
|
{
|
|
// Deactive all
|
|
for(size_t i = 0; i < m_ConfigStrings.size(); i++)
|
|
{
|
|
m_ConfigStrings[i].active = 0;
|
|
}
|
|
}
|
|
|
|
if (meterWindow)
|
|
{
|
|
// Disable the config in the ini-file
|
|
WritePrivateProfileString(meterWindow->GetSkinName().c_str(), L"Active", L"0", m_IniFile.c_str());
|
|
|
|
return DeleteMeterWindow(meterWindow, true);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CRainmeter::CreateMeterWindow(std::wstring path, std::wstring config, std::wstring iniFile)
|
|
{
|
|
CMeterWindow* mw = new CMeterWindow(path, config, iniFile);
|
|
|
|
if (mw)
|
|
{
|
|
m_Meters[config] = mw;
|
|
mw->Initialize(*this);
|
|
}
|
|
}
|
|
|
|
void CRainmeter::ClearDeleteLaterList()
|
|
{
|
|
while (!m_DelayDeleteList.empty())
|
|
{
|
|
CMeterWindow* meterWindow = m_DelayDeleteList.front();
|
|
delete meterWindow;
|
|
|
|
// Remove from the delete later list
|
|
m_DelayDeleteList.remove(meterWindow);
|
|
|
|
// Remove from the meter window list if it is still there
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = m_Meters.begin();
|
|
for (; iter != m_Meters.end(); iter++)
|
|
{
|
|
if ((*iter).second == meterWindow)
|
|
{
|
|
m_Meters.erase(iter);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CRainmeter::DeleteMeterWindow(CMeterWindow* meterWindow, bool bLater)
|
|
{
|
|
if (bLater)
|
|
{
|
|
m_DelayDeleteList.push_back(meterWindow);
|
|
meterWindow->FadeWindow(meterWindow->GetAlphaValue(), 0); // Fade out the window
|
|
}
|
|
else
|
|
{
|
|
m_DelayDeleteList.remove(meterWindow); // Remove the window from the delete later list if it is there
|
|
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = m_Meters.begin();
|
|
|
|
for (; iter != m_Meters.end(); iter++)
|
|
{
|
|
if (meterWindow == NULL)
|
|
{
|
|
// Delete all meter windows
|
|
delete (*iter).second;
|
|
}
|
|
else if ((*iter).second == meterWindow)
|
|
{
|
|
delete meterWindow;
|
|
m_Meters.erase(iter);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (meterWindow == NULL)
|
|
{
|
|
m_Meters.clear();
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
CMeterWindow* CRainmeter::GetMeterWindow(const std::wstring& config)
|
|
{
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = m_Meters.begin();
|
|
|
|
for (; iter != m_Meters.end(); iter++)
|
|
{
|
|
if ((*iter).first == config)
|
|
{
|
|
return (*iter).second;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
/*
|
|
** Quit
|
|
**
|
|
** Called when the module quits
|
|
**
|
|
*/
|
|
void CRainmeter::Quit(HINSTANCE dllInst)
|
|
{
|
|
// If we're running as Litestep's plugin, unregister the !bangs
|
|
if(!c_DummyLitestep)
|
|
{
|
|
int Msgs[] = { LM_GETREVID, 0 };
|
|
// Unregister RevID message
|
|
if (m_TrayWindow && m_TrayWindow->GetWindow()) ::SendMessage(GetLitestepWnd(), LM_UNREGISTERMESSAGE, (WPARAM)m_TrayWindow->GetWindow(), (LPARAM)Msgs);
|
|
|
|
RemoveBangCommand("!RainmeterRefresh");
|
|
RemoveBangCommand("!RainmeterRedraw");
|
|
RemoveBangCommand("!RainmeterHide");
|
|
RemoveBangCommand("!RainmeterShow");
|
|
RemoveBangCommand("!RainmeterToggle");
|
|
RemoveBangCommand("!RainmeterHideMeter");
|
|
RemoveBangCommand("!RainmeterShowMeter");
|
|
RemoveBangCommand("!RainmeterToggleMeter");
|
|
RemoveBangCommand("!RainmeterHideMeasure");
|
|
RemoveBangCommand("!RainmeterShowMeasure");
|
|
RemoveBangCommand("!RainmeterToggleMeasure");
|
|
RemoveBangCommand("!RainmeterActivateConfig");
|
|
RemoveBangCommand("!RainmeterDeactivateConfig");
|
|
RemoveBangCommand("!RainmeterToggleConfig");
|
|
RemoveBangCommand("!RainmeterMove");
|
|
RemoveBangCommand("!RainmeterZPos");
|
|
RemoveBangCommand("!RainmeterLsBoxHook");
|
|
RemoveBangCommand("!RainmeterAbout");
|
|
RemoveBangCommand("!RainmeterResetStats");
|
|
RemoveBangCommand("!RainmeterMoveMeter");
|
|
RemoveBangCommand("!RainmeterPluginBang");
|
|
RemoveBangCommand("!RainmeterQuit");
|
|
RemoveBangCommand("!RainmeterSetVariable");
|
|
}
|
|
}
|
|
|
|
/*
|
|
** ScanForConfigs
|
|
**
|
|
** Scans all the subfolders and locates the ini-files.
|
|
*/
|
|
void CRainmeter::ScanForConfigs(std::wstring& path)
|
|
{
|
|
m_ConfigStrings.clear();
|
|
m_ConfigMenu.clear();
|
|
|
|
ScanForConfigsRecursive(path, L"", 0, m_ConfigMenu, false);
|
|
}
|
|
|
|
int CRainmeter::ScanForConfigsRecursive(std::wstring& path, std::wstring base, int index, std::vector<CONFIGMENU>& menu, bool DontRecurse)
|
|
{
|
|
WIN32_FIND_DATA fileData; // Data structure describes the file found
|
|
WIN32_FIND_DATA fileDataIni; // Data structure describes the file found
|
|
HANDLE hSearch; // Search handle returned by FindFirstFile
|
|
HANDLE hSearchIni; // Search handle returned by FindFirstFile
|
|
|
|
if (!base.empty())
|
|
{
|
|
// Scan for ini-files
|
|
CONFIG config;
|
|
config.path = path;
|
|
config.config = base;
|
|
config.active = false;
|
|
|
|
// Scan all .ini files from the subfolder
|
|
std::wstring inis = path;
|
|
inis += base;
|
|
inis += L"\\*.ini";
|
|
hSearchIni = FindFirstFile(inis.c_str(), &fileDataIni);
|
|
|
|
do
|
|
{
|
|
if(hSearchIni == INVALID_HANDLE_VALUE) break; // No more files found
|
|
|
|
CONFIGMENU menuItem;
|
|
menuItem.name = fileDataIni.cFileName;
|
|
menuItem.index = m_ConfigStrings.size();
|
|
menu.push_back(menuItem);
|
|
|
|
config.iniFiles.push_back(fileDataIni.cFileName);
|
|
config.commands.push_back(ID_CONFIG_FIRST + index++);
|
|
|
|
} while (FindNextFile(hSearchIni, &fileDataIni));
|
|
|
|
if (!config.iniFiles.empty())
|
|
{
|
|
m_ConfigStrings.push_back(config);
|
|
}
|
|
FindClose(hSearchIni);
|
|
|
|
base += L"\\";
|
|
}
|
|
|
|
// Scan for folders
|
|
std::wstring files = path + base + L"*";
|
|
hSearch = FindFirstFile(files.c_str(), &fileData);
|
|
do
|
|
{
|
|
if(hSearch == INVALID_HANDLE_VALUE) break; // No more files found
|
|
|
|
if(fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY &&
|
|
!(wcscmp(L"Backup", fileData.cFileName) == 0 && base.empty()) && // Skip the backup folder
|
|
wcscmp(L".", fileData.cFileName) != 0 &&
|
|
wcscmp(L"..", fileData.cFileName) != 0)
|
|
{
|
|
CONFIGMENU menuItem;
|
|
menuItem.name = fileData.cFileName;
|
|
menuItem.index = -1;
|
|
menu.push_back(menuItem);
|
|
|
|
if (!DontRecurse)
|
|
{
|
|
std::vector<CONFIGMENU>::iterator iter = menu.end() - 1;
|
|
index = ScanForConfigsRecursive(path, base + fileData.cFileName, index, (*iter).children, false);
|
|
}
|
|
}
|
|
} while(FindNextFile(hSearch, &fileData));
|
|
|
|
FindClose(hSearch);
|
|
|
|
return index;
|
|
}
|
|
|
|
/*
|
|
** ScanForThemes
|
|
**
|
|
** Scans the given folder for themes
|
|
*/
|
|
void CRainmeter::ScanForThemes(std::wstring& path)
|
|
{
|
|
m_Themes.clear();
|
|
|
|
WIN32_FIND_DATA fileData; // Data structure describes the file found
|
|
HANDLE hSearch; // Search handle returned by FindFirstFile
|
|
|
|
// Scan for folders
|
|
std::wstring folders = path + L"\\*";
|
|
hSearch = FindFirstFile(folders.c_str(), &fileData);
|
|
do
|
|
{
|
|
if(hSearch == INVALID_HANDLE_VALUE) break; // No more files found
|
|
|
|
if(fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY &&
|
|
wcscmp(L".", fileData.cFileName) != 0 &&
|
|
wcscmp(L"..", fileData.cFileName) != 0)
|
|
{
|
|
m_Themes.push_back(fileData.cFileName);
|
|
}
|
|
} while(FindNextFile(hSearch, &fileData));
|
|
|
|
FindClose(hSearch);
|
|
}
|
|
|
|
void CRainmeter::SaveSettings()
|
|
{
|
|
// Just one setting for writing at the moment
|
|
WritePrivateProfileString(L"Rainmeter", L"CheckUpdate", m_CheckUpdate ? L"1" : L"0" , m_IniFile.c_str());
|
|
}
|
|
|
|
BOOL CRainmeter::ExecuteBang(const std::wstring& bang, const std::wstring& arg, CMeterWindow* meterWindow)
|
|
{
|
|
if (wcsicmp(bang.c_str(), L"!RainmeterRefresh") == 0)
|
|
{
|
|
BangWithArgs(BANG_REFRESH, arg.c_str(), 0);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterRefreshApp") == 0)
|
|
{
|
|
// Read skins and settings
|
|
Rainmeter->ReloadSettings();
|
|
// Refresh all
|
|
RainmeterRefresh(m_TrayWindow->GetWindow(), NULL);
|
|
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterRedraw") == 0)
|
|
{
|
|
BangWithArgs(BANG_REDRAW, arg.c_str(), 0);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterHide") == 0)
|
|
{
|
|
BangWithArgs(BANG_HIDE, arg.c_str(), 0);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterShow") == 0)
|
|
{
|
|
BangWithArgs(BANG_SHOW, arg.c_str(), 0);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterToggle") == 0)
|
|
{
|
|
BangWithArgs(BANG_TOGGLE, arg.c_str(), 0);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterHideMeter") == 0)
|
|
{
|
|
BangWithArgs(BANG_HIDEMETER, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterShowMeter") == 0)
|
|
{
|
|
BangWithArgs(BANG_SHOWMETER, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterToggleMeter") == 0)
|
|
{
|
|
BangWithArgs(BANG_TOGGLEMETER, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterDisableMeasure") == 0)
|
|
{
|
|
BangWithArgs(BANG_DISABLEMEASURE, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterEnableMeasure") == 0)
|
|
{
|
|
BangWithArgs(BANG_ENABLEMEASURE, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterToggleMeasure") == 0)
|
|
{
|
|
BangWithArgs(BANG_TOGGLEMEASURE, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterActivateConfig") == 0)
|
|
{
|
|
RainmeterActivateConfig(NULL, ConvertToAscii(arg.c_str()).c_str());
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterDeactivateConfig") == 0)
|
|
{
|
|
RainmeterDeactivateConfig(NULL, ConvertToAscii(arg.c_str()).c_str());
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterToggleConfig") == 0)
|
|
{
|
|
RainmeterToggleConfig(NULL, ConvertToAscii(arg.c_str()).c_str());
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterMove") == 0)
|
|
{
|
|
BangWithArgs(BANG_MOVE, arg.c_str(), 2);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterChangeZPos") == 0) // For backwards compatibility
|
|
{
|
|
BangWithArgs(BANG_ZPOS, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterZPos") == 0)
|
|
{
|
|
BangWithArgs(BANG_ZPOS, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterAbout") == 0)
|
|
{
|
|
BangWithArgs(BANG_ABOUT, arg.c_str(), 0);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterResetStats") == 0)
|
|
{
|
|
RainmeterResetStats(NULL, NULL);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterMoveMeter") == 0)
|
|
{
|
|
BangWithArgs(BANG_MOVEMETER, arg.c_str(), 3);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterPluginBang") == 0)
|
|
{
|
|
BangWithArgs(BANG_PLUGIN, arg.c_str(), 1);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterSetVariable") == 0)
|
|
{
|
|
BangWithArgs(BANG_SETVARIABLE, arg.c_str(), 2);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterLsBoxHook") == 0)
|
|
{
|
|
// Nothing to do here (this works only with Litestep)
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!RainmeterQuit") == 0)
|
|
{
|
|
BangWithArgs(BANG_QUIT, arg.c_str(), 0);
|
|
}
|
|
else if (wcsicmp(bang.c_str(), L"!Execute") == 0)
|
|
{
|
|
// Special case for multibang execution
|
|
std::wstring::size_type start = std::wstring::npos;
|
|
std::wstring::size_type end = std::wstring::npos;
|
|
int count = 0;
|
|
for (size_t i = 0; i < arg.size(); i++)
|
|
{
|
|
if (arg[i] == L'[')
|
|
{
|
|
if (count == 0)
|
|
{
|
|
start = i;
|
|
}
|
|
count++;
|
|
}
|
|
else if (arg[i] == L']')
|
|
{
|
|
count--;
|
|
|
|
if (count == 0 && start != std::wstring::npos)
|
|
{
|
|
end = i;
|
|
|
|
std::wstring command = arg.substr(start + 1, end - (start + 1));
|
|
// trim leading whitespace
|
|
std::wstring::size_type notwhite = command.find_first_not_of(L" \t\n");
|
|
command.erase(0, notwhite);
|
|
ExecuteCommand(command.c_str(), meterWindow);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::wstring error = L"Unknown !bang: ";
|
|
error += bang;
|
|
MessageBox(NULL, error.c_str(), L"Rainmeter", MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
** ParseCommand
|
|
**
|
|
** Replaces the measure names with the actual text values.
|
|
**
|
|
*/
|
|
std::wstring CRainmeter::ParseCommand(const WCHAR* command, CMeterWindow* meterWindow)
|
|
{
|
|
std::wstring strCommand = command;
|
|
|
|
if (wcsnicmp(L"!execute", command, 8) == 0)
|
|
{
|
|
return strCommand;
|
|
}
|
|
|
|
// Find the [measures]
|
|
size_t start = 0, end = 0;
|
|
while (start != std::wstring::npos && end != std::wstring::npos)
|
|
{
|
|
start = strCommand.find(L'[', start);
|
|
if (start != std::wstring::npos)
|
|
{
|
|
end = strCommand.find(L']', start);
|
|
if (end != std::wstring::npos)
|
|
{
|
|
std::wstring measureName = strCommand.substr(start + 1, end - (start + 1));
|
|
if (!measureName.empty())
|
|
{
|
|
// Ignore bangs
|
|
if (measureName[0] == L'!')
|
|
{
|
|
start = end + 1;
|
|
}
|
|
else
|
|
{
|
|
if (meterWindow)
|
|
{
|
|
std::list<CMeasure*>::iterator iter = meterWindow->GetMeasures().begin();
|
|
for( ; iter != meterWindow->GetMeasures().end(); iter++)
|
|
{
|
|
if (wcsicmp((*iter)->GetName(), measureName.c_str()) == 0)
|
|
{
|
|
std::wstring value = (*iter)->GetStringValue(false, 1, 0, false);
|
|
strCommand.replace(start, (end - start) + 1, value);
|
|
start += value.length();
|
|
break;
|
|
}
|
|
}
|
|
if (iter == meterWindow->GetMeasures().end())
|
|
{
|
|
DebugLog(L"No such measure [%s] for execute string: %s", measureName.c_str(), command);
|
|
start = end + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return strCommand;
|
|
}
|
|
|
|
/*
|
|
** ExecuteCommand
|
|
**
|
|
** Runs the given command or bang
|
|
**
|
|
*/
|
|
void CRainmeter::ExecuteCommand(const WCHAR* command, CMeterWindow* meterWindow)
|
|
{
|
|
if (command == NULL) return;
|
|
|
|
std::wstring strCommand = ParseCommand(command, meterWindow);
|
|
|
|
if (!strCommand.empty())
|
|
{
|
|
// Check for build-ins
|
|
if (wcsncmp(L"PLAY ", strCommand.c_str(), 5) == 0)
|
|
{
|
|
BOOL ret = PlaySound(strCommand.c_str() + 5, NULL, SND_FILENAME);
|
|
return;
|
|
}
|
|
else if (wcsncmp(L"PLAYSTOP", strCommand.c_str(), 8) == 0)
|
|
{
|
|
PlaySound(NULL, NULL, SND_PURGE);
|
|
return;
|
|
}
|
|
else if (wcsncmp(L"PLAYLOOP ", strCommand.c_str(), 9) == 0)
|
|
{
|
|
PlaySound(strCommand.c_str() + 9, NULL, SND_ASYNC | SND_FILENAME | SND_LOOP | SND_NODEFAULT);
|
|
return;
|
|
}
|
|
|
|
// Run the command
|
|
if(strCommand.c_str()[0] == L'!' && Rainmeter->GetDummyLitestep())
|
|
{
|
|
if (meterWindow)
|
|
{
|
|
// Fake WM_COPY to deliver bangs
|
|
COPYDATASTRUCT CopyDataStruct;
|
|
CopyDataStruct.cbData = (DWORD)((wcslen(command) + 1) * sizeof(WCHAR));
|
|
CopyDataStruct.dwData = 1;
|
|
CopyDataStruct.lpData = (void*)strCommand.c_str();
|
|
meterWindow->OnCopyData(NULL, (LPARAM)&CopyDataStruct);
|
|
}
|
|
else
|
|
{
|
|
std::wstring bang, arg;
|
|
size_t pos = strCommand.find(L' ');
|
|
if (pos != std::wstring::npos)
|
|
{
|
|
bang = strCommand.substr(0, pos);
|
|
strCommand.erase(0, pos + 1);
|
|
arg = strCommand;
|
|
}
|
|
else
|
|
{
|
|
bang = strCommand;
|
|
}
|
|
ExecuteBang(bang, arg, meterWindow);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This can run bangs also
|
|
LSExecute(NULL, strCommand.c_str(), SW_SHOWNORMAL);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** ReadGeneralSettings
|
|
**
|
|
** Reads the general settings from the Rainmeter.ini file
|
|
**
|
|
*/
|
|
void CRainmeter::ReadGeneralSettings(std::wstring& iniFile)
|
|
{
|
|
CConfigParser parser;
|
|
parser.Initialize(iniFile.c_str(), this);
|
|
|
|
if (m_TrayWindow)
|
|
{
|
|
m_TrayWindow->ReadConfig(parser);
|
|
}
|
|
|
|
c_GlobalConfig.netInSpeed = parser.ReadFloat(L"Rainmeter", L"NetInSpeed", c_GlobalConfig.netInSpeed);
|
|
c_GlobalConfig.netOutSpeed = parser.ReadFloat(L"Rainmeter", L"NetOutSpeed", c_GlobalConfig.netOutSpeed);
|
|
|
|
m_ConfigEditor = parser.ReadString(L"Rainmeter", L"ConfigEditor", m_ConfigEditor.c_str());
|
|
if (!m_ConfigEditor.empty() && m_ConfigEditor[0] != L'\"')
|
|
{
|
|
m_ConfigEditor.insert(0,L"\"");
|
|
m_ConfigEditor.append(L"\"");
|
|
}
|
|
|
|
m_TrayExecuteL = parser.ReadString(L"Rainmeter", L"TrayExecuteL", m_TrayExecuteL.c_str());
|
|
m_TrayExecuteR = parser.ReadString(L"Rainmeter", L"TrayExecuteR", m_TrayExecuteR.c_str());
|
|
m_TrayExecuteM = parser.ReadString(L"Rainmeter", L"TrayExecuteM", m_TrayExecuteM.c_str());
|
|
m_TrayExecuteDL = parser.ReadString(L"Rainmeter", L"TrayExecuteDL", m_TrayExecuteDL.c_str());
|
|
m_TrayExecuteDR = parser.ReadString(L"Rainmeter", L"TrayExecuteDR", m_TrayExecuteDR.c_str());
|
|
m_TrayExecuteDM = parser.ReadString(L"Rainmeter", L"TrayExecuteDM", m_TrayExecuteDM.c_str());
|
|
|
|
m_CheckUpdate = parser.ReadInt(L"Rainmeter", L"CheckUpdate", m_CheckUpdate);
|
|
|
|
std::wstring area = parser.ReadString(L"Rainmeter", L"DesktopWorkArea", L"");
|
|
if (!area.empty())
|
|
{
|
|
swscanf(area.c_str(), L"%i,%i,%i,%i", &m_DesktopWorkArea.left, &m_DesktopWorkArea.top,
|
|
&m_DesktopWorkArea.right, &m_DesktopWorkArea.bottom);
|
|
m_DesktopWorkAreaChanged = true;
|
|
}
|
|
|
|
// Check which configs are active
|
|
if (!c_DummyLitestep)
|
|
{
|
|
char tmpSz[MAX_LINE_LENGTH];
|
|
std::wstring skinName;
|
|
std::wstring skinIni = L"Rainmeter.ini";
|
|
|
|
// Check if step.rc has overrides these values
|
|
if (GetRCString("RainmeterCurrentConfig", tmpSz, "", MAX_LINE_LENGTH - 1))
|
|
{
|
|
skinName = ConvertToWide(tmpSz);
|
|
}
|
|
|
|
if (GetRCString("RainmeterCurrentConfigIni", tmpSz, "Rainmeter.ini", MAX_LINE_LENGTH - 1))
|
|
{
|
|
skinIni = ConvertToWide(tmpSz);
|
|
}
|
|
|
|
if (!skinName.empty())
|
|
{
|
|
if (!SetActiveConfig(skinName, skinIni))
|
|
{
|
|
std::wstring error;
|
|
error = L"The selected config (L" + skinName + L"\\" + skinIni + L") cannot be found.";
|
|
MessageBox(NULL, error.c_str(), L"Rainmeter", MB_OK);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < m_ConfigStrings.size(); i++)
|
|
{
|
|
int active = parser.ReadInt(m_ConfigStrings[i].config.c_str(), L"Active", 0);
|
|
|
|
// Make sure there is a ini file available
|
|
if (active > 0 && active <= (int)m_ConfigStrings[i].iniFiles.size())
|
|
{
|
|
m_ConfigStrings[i].active = active;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** SetActiveConfig
|
|
**
|
|
** Makes the given config active. If the config cannot be found this returns false.
|
|
*/
|
|
bool CRainmeter::SetActiveConfig(std::wstring& skinName, std::wstring& skinIni)
|
|
{
|
|
for (size_t i = 0; i < m_ConfigStrings.size(); i++)
|
|
{
|
|
m_ConfigStrings[i].active = 0; // Disable all other configs
|
|
|
|
if (skinName == m_ConfigStrings[i].config)
|
|
{
|
|
for (size_t j = 0; j < m_ConfigStrings[i].iniFiles.size(); j++)
|
|
{
|
|
if (skinIni == m_ConfigStrings[i].iniFiles[j])
|
|
{
|
|
m_ConfigStrings[i].active = j + 1;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
** Refresh
|
|
**
|
|
** Refreshes Rainmeter. If argument is given the config is refreshed
|
|
** otherwise all active meters are refreshed
|
|
*/
|
|
void CRainmeter::Refresh(const WCHAR* arg)
|
|
{
|
|
std::wstring config, iniFile;
|
|
|
|
try
|
|
{
|
|
if (arg != NULL && wcslen(arg) > 0)
|
|
{
|
|
std::wstring config = arg;
|
|
CMeterWindow* meterWindow = GetMeterWindow(config);
|
|
meterWindow->Refresh(false);
|
|
}
|
|
else
|
|
{
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = m_Meters.begin();
|
|
|
|
// Refresh all
|
|
for (; iter != m_Meters.end(); iter++)
|
|
{
|
|
(*iter).second->Refresh(false);
|
|
}
|
|
}
|
|
}
|
|
catch(CError& error)
|
|
{
|
|
MessageBox(NULL, error.GetString().c_str(), APPNAME, MB_OK | MB_TOPMOST | MB_ICONEXCLAMATION);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** ReadStats
|
|
**
|
|
** Reads the statistics from the ini-file
|
|
**
|
|
*/
|
|
void CRainmeter::ReadStats()
|
|
{
|
|
WCHAR tmpSz[MAX_LINE_LENGTH];
|
|
|
|
if(GetPrivateProfileString(L"Statistics", L"Since", L"", tmpSz, MAX_LINE_LENGTH, m_IniFile.c_str()) > 0)
|
|
{
|
|
m_StatsDate = tmpSz;
|
|
}
|
|
|
|
// Only Net measure has stats at the moment
|
|
CMeasureNet::ReadStats(m_IniFile);
|
|
}
|
|
|
|
/*
|
|
** WriteStats
|
|
**
|
|
** Writes the statistics to the ini-file. If bForce is false the stats are written only once per minute.
|
|
**
|
|
*/
|
|
void CRainmeter::WriteStats(bool bForce)
|
|
{
|
|
static DWORD lastWrite = 0;
|
|
|
|
if (bForce || (lastWrite + 1000 * 60 < GetTickCount()))
|
|
{
|
|
lastWrite = GetTickCount();
|
|
|
|
// Write the date for statistics
|
|
WritePrivateProfileString(L"Statistics", L"Since", m_StatsDate.c_str(), m_IniFile.c_str());
|
|
|
|
// Only Net measure has stats at the moment
|
|
CMeasureNet::WriteStats(m_IniFile);
|
|
|
|
WritePrivateProfileString(NULL, NULL, NULL, m_IniFile.c_str());
|
|
}
|
|
}
|
|
|
|
/*
|
|
** ResetStats
|
|
**
|
|
** Clears the statistics
|
|
**
|
|
*/
|
|
void CRainmeter::ResetStats()
|
|
{
|
|
// Set the stats-date string
|
|
struct tm *newtime;
|
|
time_t long_time;
|
|
time(&long_time);
|
|
newtime = localtime(&long_time);
|
|
m_StatsDate = _wasctime(newtime);
|
|
m_StatsDate.resize(m_StatsDate.size() - 1);
|
|
|
|
// Only Net measure has stats at the moment
|
|
CMeasureNet::ResetStats();
|
|
}
|
|
|
|
|
|
/*
|
|
** IsNT
|
|
**
|
|
** Checks which OS you are running
|
|
**
|
|
*/
|
|
PLATFORM CRainmeter::IsNT()
|
|
{
|
|
// Check if you are running a real OS
|
|
|
|
OSVERSIONINFO osvi;
|
|
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
|
|
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
|
|
if(!GetVersionEx((OSVERSIONINFO*)&osvi))
|
|
{
|
|
// Something's wrong, lets assime Win9x
|
|
return PLATFORM_9X;
|
|
}
|
|
|
|
if(osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
// You got NT
|
|
if(osvi.dwMajorVersion <= 4) return PLATFORM_NT4;
|
|
if(osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0) return PLATFORM_2K;
|
|
return PLATFORM_XP;
|
|
}
|
|
|
|
return PLATFORM_9X; // Wintendo alert!
|
|
}
|
|
|
|
/*
|
|
** ShowContextMenu
|
|
**
|
|
** Opens the context menu in given coordinates.
|
|
**
|
|
*/
|
|
void CRainmeter::ShowContextMenu(POINT pos, CMeterWindow* meterWindow)
|
|
{
|
|
// Show context menu, if no actions were executed
|
|
HMENU menu = LoadMenu(m_Instance, MAKEINTRESOURCE(IDR_CONTEXT_MENU));
|
|
|
|
if(menu)
|
|
{
|
|
HMENU configMenu = NULL;
|
|
|
|
HMENU subMenu = GetSubMenu(menu, 0);
|
|
if(subMenu)
|
|
{
|
|
if (!GetDummyLitestep())
|
|
{
|
|
// Disable Quit if ran as a Litestep plugin
|
|
EnableMenuItem(subMenu, ID_CONTEXT_QUIT, MF_BYCOMMAND | MF_GRAYED);
|
|
EnableMenuItem(subMenu, ID_CONTEXT_SHOWLOGFILE, MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
|
|
HMENU configMenu = CreateConfigMenu(m_ConfigMenu);
|
|
if (configMenu)
|
|
{
|
|
AppendMenu(configMenu, MF_SEPARATOR, 0, NULL);
|
|
AppendMenu(configMenu, 0, ID_CONTEXT_OPENSKINSFOLDER, L"Open Skins\' Folder");
|
|
AppendMenu(configMenu, 0, ID_CONTEXT_MANAGESKINS, L"Manage Skins...");
|
|
|
|
InsertMenu(subMenu, 3, MF_BYPOSITION | MF_POPUP, (UINT_PTR)configMenu, L"Configs");
|
|
}
|
|
|
|
HMENU themeMenu = CreateThemeMenu();
|
|
if (themeMenu)
|
|
{
|
|
InsertMenu(subMenu, 4, MF_BYPOSITION | MF_POPUP, (UINT_PTR)themeMenu, L"Themes");
|
|
InsertMenu(subMenu, 5, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
|
|
}
|
|
|
|
if (meterWindow)
|
|
{
|
|
HMENU skinMenu = CreateSkinMenu(meterWindow, 0);
|
|
InsertMenu(subMenu, 10, MF_BYPOSITION | MF_POPUP, (UINT_PTR)skinMenu, L"Skin Menu");
|
|
}
|
|
else
|
|
{
|
|
// Create a menu for all active configs
|
|
std::map<std::wstring, CMeterWindow*>::iterator iter = Rainmeter->GetAllMeterWindows().begin();
|
|
|
|
int index = 0;
|
|
for (; iter != Rainmeter->GetAllMeterWindows().end(); iter++)
|
|
{
|
|
CMeterWindow* mw = ((*iter).second);
|
|
HMENU skinMenu = CreateSkinMenu(mw, index);
|
|
InsertMenu(subMenu, 10, MF_BYPOSITION | MF_POPUP, (UINT_PTR)skinMenu, mw->GetSkinName().c_str());
|
|
index++;
|
|
}
|
|
}
|
|
|
|
|
|
TrackPopupMenu(
|
|
subMenu,
|
|
TPM_RIGHTBUTTON | TPM_LEFTALIGN,
|
|
pos.x,
|
|
pos.y,
|
|
0,
|
|
meterWindow ? meterWindow->GetWindow() : m_TrayWindow->GetWindow(),
|
|
NULL
|
|
);
|
|
}
|
|
|
|
DestroyMenu(menu);
|
|
}
|
|
}
|
|
|
|
|
|
HMENU CRainmeter::CreateConfigMenu(std::vector<CONFIGMENU>& configMenuData)
|
|
{
|
|
HMENU configMenu = NULL;
|
|
|
|
if (configMenuData.size() > 0)
|
|
{
|
|
configMenu = CreatePopupMenu();
|
|
|
|
for (size_t i = 0; i < configMenuData.size(); i++)
|
|
{
|
|
if (configMenuData[i].index == -1)
|
|
{
|
|
HMENU submenu = CreateConfigMenu(configMenuData[i].children);
|
|
if (submenu)
|
|
{
|
|
InsertMenu(configMenu, i, MF_BYPOSITION | MF_POPUP, (UINT_PTR)submenu, configMenuData[i].name.c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CONFIG& config = m_ConfigStrings[configMenuData[i].index];
|
|
InsertMenu(configMenu, i, MF_BYPOSITION, config.commands[i], configMenuData[i].name.c_str());
|
|
|
|
if (config.active == i + 1)
|
|
{
|
|
CheckMenuItem(configMenu, i, MF_BYPOSITION | MF_CHECKED);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return configMenu;
|
|
}
|
|
|
|
HMENU CRainmeter::CreateThemeMenu()
|
|
{
|
|
HMENU themeMenu = CreatePopupMenu();
|
|
|
|
for (size_t i = 0; i < m_Themes.size(); i++)
|
|
{
|
|
AppendMenu(themeMenu, 0, ID_THEME_FIRST + i, m_Themes[i].c_str());
|
|
}
|
|
|
|
if (!m_Themes.empty())
|
|
{
|
|
AppendMenu(themeMenu, MF_SEPARATOR, 0, NULL);
|
|
}
|
|
|
|
AppendMenu(themeMenu, 0, ID_CONTEXT_MANAGETHEMES, L"Manage Themes...");
|
|
|
|
return themeMenu;
|
|
}
|
|
|
|
HMENU CRainmeter::CreateSkinMenu(CMeterWindow* meterWindow, int index)
|
|
{
|
|
HMENU skinMenu = LoadMenu(m_Instance, MAKEINTRESOURCE(IDR_SKIN_MENU));
|
|
|
|
if (skinMenu)
|
|
{
|
|
HMENU subSkinMenu = GetSubMenu(skinMenu, 0);
|
|
RemoveMenu(skinMenu, 0, MF_BYPOSITION);
|
|
DestroyMenu(skinMenu);
|
|
skinMenu = subSkinMenu;
|
|
}
|
|
|
|
if (skinMenu)
|
|
{
|
|
// Tick the position
|
|
HMENU posMenu = GetSubMenu(skinMenu, 0);
|
|
if (posMenu)
|
|
{
|
|
switch(meterWindow->GetWindowZPosition())
|
|
{
|
|
case ZPOSITION_ONDESKTOP:
|
|
CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_ONDESKTOP, MF_BYCOMMAND | MF_CHECKED);
|
|
break;
|
|
|
|
case ZPOSITION_ONBOTTOM:
|
|
CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_BOTTOM, MF_BYCOMMAND | MF_CHECKED);
|
|
break;
|
|
|
|
case ZPOSITION_ONTOP:
|
|
CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_TOPMOST, MF_BYCOMMAND | MF_CHECKED);
|
|
break;
|
|
|
|
case ZPOSITION_ONTOPMOST:
|
|
CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_VERYTOPMOST, MF_BYCOMMAND | MF_CHECKED);
|
|
break;
|
|
|
|
default:
|
|
CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_NORMAL, MF_BYCOMMAND | MF_CHECKED);
|
|
}
|
|
|
|
if(meterWindow->GetXFromRight()) CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_FROMRIGHT, MF_BYCOMMAND | MF_CHECKED);
|
|
if(meterWindow->GetYFromBottom()) CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_FROMBOTTOM, MF_BYCOMMAND | MF_CHECKED);
|
|
if(meterWindow->GetXPercentage()) CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_XPERCENTAGE, MF_BYCOMMAND | MF_CHECKED);
|
|
if(meterWindow->GetYPercentage()) CheckMenuItem(posMenu, ID_CONTEXT_SKINMENU_YPERCENTAGE, MF_BYCOMMAND | MF_CHECKED);
|
|
|
|
if (!c_DummyLitestep)
|
|
{
|
|
EnableMenuItem(posMenu, ID_CONTEXT_SKINMENU_ONDESKTOP, MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
|
|
HMENU monitorMenu = CreateMonitorMenu(meterWindow);
|
|
if (monitorMenu)
|
|
{
|
|
InsertMenu(posMenu, 0, MF_BYPOSITION | MF_POPUP, (UINT_PTR)monitorMenu, L"Display Monitor");
|
|
InsertMenu(posMenu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
|
|
}
|
|
}
|
|
|
|
// Tick the transparency
|
|
if (!meterWindow->GetNativeTransparency())
|
|
{
|
|
EnableMenuItem(skinMenu, 1, MF_BYPOSITION | MF_GRAYED);
|
|
EnableMenuItem(skinMenu, ID_CONTEXT_SKINMENU_CLICKTHROUGH, MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
else
|
|
{
|
|
HMENU alphaMenu = GetSubMenu(skinMenu, 1);
|
|
if (alphaMenu)
|
|
{
|
|
int value = (int)(10 - (meterWindow->GetAlphaValue() / 255.0) * 10.0);
|
|
value = min(9, value);
|
|
value = max(0, value);
|
|
CheckMenuItem(alphaMenu, value, MF_BYPOSITION | MF_CHECKED);
|
|
|
|
if (meterWindow->GetWindowHide() == HIDEMODE_FADEIN)
|
|
{
|
|
CheckMenuItem(alphaMenu, ID_CONTEXT_SKINMENU_TRANSPARENCY_FADEIN, MF_BYCOMMAND | MF_CHECKED);
|
|
EnableMenuItem(alphaMenu, ID_CONTEXT_SKINMENU_TRANSPARENCY_FADEOUT, MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
else if (meterWindow->GetWindowHide() == HIDEMODE_FADEOUT)
|
|
{
|
|
CheckMenuItem(alphaMenu, ID_CONTEXT_SKINMENU_TRANSPARENCY_FADEOUT, MF_BYCOMMAND | MF_CHECKED);
|
|
EnableMenuItem(alphaMenu, ID_CONTEXT_SKINMENU_TRANSPARENCY_FADEIN, MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
else if (meterWindow->GetWindowHide() == HIDEMODE_HIDE)
|
|
{
|
|
EnableMenuItem(alphaMenu, ID_CONTEXT_SKINMENU_TRANSPARENCY_FADEIN, MF_BYCOMMAND | MF_GRAYED);
|
|
EnableMenuItem(alphaMenu, ID_CONTEXT_SKINMENU_TRANSPARENCY_FADEOUT, MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tick the configs
|
|
if (meterWindow->GetWindowHide() == HIDEMODE_HIDE)
|
|
{
|
|
CheckMenuItem(skinMenu, ID_CONTEXT_SKINMENU_HIDEONMOUSE, MF_BYCOMMAND | MF_CHECKED);
|
|
}
|
|
else if (meterWindow->GetWindowHide() != HIDEMODE_NONE)
|
|
{
|
|
EnableMenuItem(skinMenu, ID_CONTEXT_SKINMENU_HIDEONMOUSE, MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
|
|
if (meterWindow->GetSnapEdges())
|
|
{
|
|
CheckMenuItem(skinMenu, ID_CONTEXT_SKINMENU_SNAPTOEDGES, MF_BYCOMMAND | MF_CHECKED);
|
|
}
|
|
|
|
if (meterWindow->GetSavePosition())
|
|
{
|
|
CheckMenuItem(skinMenu, ID_CONTEXT_SKINMENU_REMEMBERPOSITION, MF_BYCOMMAND | MF_CHECKED);
|
|
}
|
|
|
|
if (meterWindow->GetWindowDraggable())
|
|
{
|
|
CheckMenuItem(skinMenu, ID_CONTEXT_SKINMENU_DRAGGABLE, MF_BYCOMMAND | MF_CHECKED);
|
|
}
|
|
|
|
if (meterWindow->GetClickThrough())
|
|
{
|
|
CheckMenuItem(skinMenu, ID_CONTEXT_SKINMENU_CLICKTHROUGH, MF_BYCOMMAND | MF_CHECKED);
|
|
}
|
|
|
|
if (meterWindow->GetKeepOnScreen())
|
|
{
|
|
CheckMenuItem(skinMenu, ID_CONTEXT_SKINMENU_KEEPONSCREEN, MF_BYCOMMAND | MF_CHECKED);
|
|
}
|
|
|
|
// Add the name of the Skin to the menu and disable the item
|
|
InsertMenu(skinMenu, 0, MF_BYPOSITION, 0, meterWindow->GetSkinName().c_str());
|
|
InsertMenu(skinMenu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
|
|
SetMenuDefaultItem(skinMenu, 0, MF_BYPOSITION);
|
|
EnableMenuItem(skinMenu, 0, MF_BYPOSITION | MF_GRAYED);
|
|
|
|
ChangeSkinIndex(skinMenu, index);
|
|
}
|
|
|
|
return skinMenu;
|
|
}
|
|
|
|
HMENU CRainmeter::CreateMonitorMenu(CMeterWindow* meterWindow)
|
|
{
|
|
WCHAR buffer[256];
|
|
std::wstring item;
|
|
UINT flags;
|
|
|
|
HMENU monitorMenu = CreatePopupMenu();
|
|
|
|
bool screenDefined = meterWindow->GetXScreenDefined();
|
|
int screenIndex = meterWindow->GetXScreen();
|
|
|
|
// for the "Primary monitor"
|
|
flags = 0;
|
|
if (!screenDefined)
|
|
{
|
|
flags |= MF_CHECKED;
|
|
}
|
|
AppendMenu(monitorMenu, flags, ID_CONTEXT_SKINMENU_MONITOR_PRIMARY, L"Use default: Primary monitor");
|
|
|
|
// for the "Virtual screen" (@0)
|
|
flags = 0;
|
|
if (screenDefined && screenIndex == 0)
|
|
{
|
|
flags |= MF_CHECKED;
|
|
}
|
|
AppendMenu(monitorMenu, flags, ID_MONITOR_FIRST, L"@0: Virtual screen");
|
|
|
|
// for the "Specified monitor" (@n)
|
|
if (CMeterWindow::GetMonitorCount() > 0)
|
|
{
|
|
AppendMenu(monitorMenu, MF_SEPARATOR, 0, NULL);
|
|
|
|
const MULTIMONITOR_INFO& multimonInfo = CMeterWindow::GetMultiMonitorInfo();
|
|
const std::vector<MONITOR_INFO>& monitors = multimonInfo.monitors;
|
|
|
|
for (size_t i = 0; i < monitors.size(); i++)
|
|
{
|
|
wsprintf(buffer, L"@%i: ", i + 1);
|
|
item = buffer;
|
|
|
|
flags = 0;
|
|
if (screenDefined && screenIndex == (int)i + 1)
|
|
{
|
|
flags |= MF_CHECKED;
|
|
}
|
|
|
|
size_t len = wcslen(monitors[i].monitorName);
|
|
if (len > 32)
|
|
{
|
|
item += std::wstring(monitors[i].monitorName, 32);
|
|
item += L"...";
|
|
}
|
|
else
|
|
{
|
|
item += monitors[i].monitorName;
|
|
}
|
|
|
|
if (!monitors[i].active)
|
|
{
|
|
flags |= MF_GRAYED;
|
|
}
|
|
|
|
AppendMenu(monitorMenu, flags, ID_MONITOR_FIRST + i + 1, item.c_str());
|
|
}
|
|
}
|
|
|
|
AppendMenu(monitorMenu, MF_SEPARATOR, 0, NULL);
|
|
|
|
flags = 0;
|
|
if (meterWindow->GetAutoSelectScreen())
|
|
{
|
|
flags |= MF_CHECKED;
|
|
}
|
|
AppendMenu(monitorMenu, flags, ID_CONTEXT_SKINMENU_MONITOR_AUTOSELECT, L"Auto-select based on window position");
|
|
|
|
return monitorMenu;
|
|
}
|
|
|
|
void CRainmeter::ChangeSkinIndex(HMENU menu, int index)
|
|
{
|
|
int count = GetMenuItemCount(menu);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
HMENU subMenu = GetSubMenu(menu, i);
|
|
if (subMenu)
|
|
{
|
|
ChangeSkinIndex(subMenu, index);
|
|
}
|
|
else
|
|
{
|
|
WCHAR buffer[256];
|
|
GetMenuString(menu, i, buffer, 256, MF_BYPOSITION);
|
|
UINT id = GetMenuItemID(menu, i);
|
|
UINT flags = GetMenuState(menu, i, MF_BYPOSITION);
|
|
ModifyMenu(menu, i, MF_BYPOSITION | flags, id | (index << 16), buffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CRainmeter::TestSettingsFile(bool bDefaultIniLocation)
|
|
{
|
|
WritePrivateProfileString(L"Rainmeter", L"WriteTest", L"TRUE", m_IniFile.c_str());
|
|
WritePrivateProfileString(NULL, NULL, NULL, m_IniFile.c_str()); // FLUSH
|
|
|
|
WCHAR tmpSz[5];
|
|
bool bSuccess = (GetPrivateProfileString(L"Rainmeter", L"WriteTest", L"", tmpSz, 5, m_IniFile.c_str()) > 0);
|
|
if (bSuccess)
|
|
{
|
|
bSuccess = (wcscmp(L"TRUE", tmpSz) == 0);
|
|
WritePrivateProfileString(L"Rainmeter", L"WriteTest", NULL, m_IniFile.c_str());
|
|
}
|
|
if (!bSuccess)
|
|
{
|
|
DebugLog(L"The rainmeter.ini file is NOT writable.");
|
|
|
|
std::wstring error;
|
|
error += L"The Rainmeter.ini file is not writable. This means that the\n";
|
|
error += L"application will not be able to save any settings permanently.\n\n";
|
|
|
|
if (!bDefaultIniLocation)
|
|
{
|
|
std::wstring strTarget = L"%APPDATA%\\Rainmeter\\";
|
|
ExpandEnvironmentVariables(strTarget);
|
|
|
|
error += L"You should quit Rainmeter and move the settings file from\n\n";
|
|
error += m_IniFile;
|
|
error += L"\n\nto\n\n";
|
|
error += strTarget;
|
|
error += L"\n\nAlternatively you can also just remove the file and\n";
|
|
error += L"it will be automatically recreated to the correct location\n";
|
|
error += L"when Rainmeter is restarted the next time (you\'ll lose your\n";
|
|
error += L"current settings though).\n";
|
|
}
|
|
else
|
|
{
|
|
error += L"Make sure that the settings file is not set as read-only and\n";
|
|
error += L"it is located in a folder where you have write permissions.\n\n";
|
|
error += L"The settings file is located at:\n";
|
|
error += m_IniFile;
|
|
}
|
|
|
|
MessageBox(NULL, error.c_str(), L"Rainmeter", MB_OK | MB_ICONERROR);
|
|
}
|
|
else
|
|
{
|
|
DebugLog(L"The rainmeter.ini file is writable.");
|
|
}
|
|
}
|
|
|
|
std::wstring CRainmeter::ExtractPath(const std::wstring& strFilePath)
|
|
{
|
|
size_t pos = strFilePath.rfind(L"\\");
|
|
if (pos != std::wstring::npos)
|
|
{
|
|
return strFilePath.substr(0, pos + 1);
|
|
}
|
|
return L".";
|
|
}
|
|
|
|
void CRainmeter::ExpandEnvironmentVariables(std::wstring& strPath)
|
|
{
|
|
if (strPath.find(L'%') != std::wstring::npos)
|
|
{
|
|
WCHAR buffer[4096]; // lets hope the buffer is large enough...
|
|
|
|
// Expand the environment variables
|
|
DWORD ret = ExpandEnvironmentStrings(strPath.c_str(), buffer, 4096);
|
|
if (ret != 0 && ret < 4096)
|
|
{
|
|
strPath = buffer;
|
|
}
|
|
else
|
|
{
|
|
DebugLog(L"Unable to expand the environment strings for string: %s", strPath.c_str());
|
|
}
|
|
}
|
|
}
|