{
- "version": "2.4.1.0",
- "versionPage": "https://github.com/lx-s/WinMute/releases/"
+ "version": 1,
+ "stable": {
+ "version": "2.4.1.0",
+ "downloadUrl": "https://github.com/lx-s/WinMute/releases/"
+ },
+ "beta": {
+ "version": "2.9.0.0",
+ "downloadUrl": "https://github.com/lx-s/WinMute/releases/"
+ }
}
"general.error.audio-service-shutdown.text": "WinMute is not able to recover from that condition.\nPlease try to restart the program.",
"popup.update-available.title": "WinMute {} is available!",
"popup.update-available.text": "Your current version is {}.\nClick on this message to open the download page.",
+ "popup.update-available-beta.title": "WinMute Beta {} is available!",
+ "popup.update-available-beta.text": "Your current version is {}.\nClick on this message to open the beta-download page.",
"popup.error.update-check-failed.title": "Update check failed.",
"pupup.error.update-check-failed.text": "Unable to check for a new version.\nPlease check/enable logging for further details.",
"popup.remote-session-detected.title": "Remote Session detected",
"settings.bluetooth.add-edit.edit-title": "Edit Bluetooth device",
"settings.bluetooth.add-edit.device-name-label": "Bluetooth device name:",
"settings.general.run-on-startup": "Run WinMute when this user logs on",
- "settings.general.check-for-updates-on-start": "Check for updates on startup",
+ "settings.general.check-for-updates-on-start": "Check for new updates on startup",
+ "settings.general.check-for-beta-updates-on-start": "Also check for new beta versions",
"settings.general.enable-logging": "Enable logging",
"settings.general.btn-open-log-file": "Open log file...",
"settings.general.select-language-label": "Language",
HDWP hdwp = BeginDeferWindowPos(static_cast<int>(tabs.size()));
if (hdwp == nullptr) {
- PrintWindowsError(L"BeginDeferWindowPos", GetLastError());
+ ShowWindowsError(L"BeginDeferWindowPos", GetLastError());
} else {
for (auto hTab : tabs) {
HDWP newHdwp = DeferWindowPos(
tabCtrlRect.bottom - tabCtrlRect.top,
0);
if (newHdwp == nullptr) {
- PrintWindowsError(L"DeferWindowPos", GetLastError());
+ ShowWindowsError(L"DeferWindowPos", GetLastError());
break;
} else {
hdwp = newHdwp;
const BLUETOOTH_FIND_RADIO_PARAMS bfrp = { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) };
HBLUETOOTH_RADIO_FIND hRadiosFind = BluetoothFindFirstRadio(&bfrp, &btHandle);
if (hRadiosFind == nullptr) {
- log.WriteWindowsError(L"BluetoothFindFirstRadio", GetLastError());
+ log.LogWinError(L"BluetoothFindFirstRadio", GetLastError());
return false;
}
CloseHandle(btHandle);
if (devNotify == nullptr) {
- log.WriteWindowsError(L"RegisterDeviceNotification", GetLastError());
+ log.LogWinError(L"RegisterDeviceNotification", GetLastError());
} else {
notificationHandles_.push_back(devNotify);
}
} while (BluetoothFindNextRadio(hRadiosFind, &btHandle));
const DWORD dwLastError = GetLastError();
if (dwLastError != ERROR_NO_MORE_ITEMS) {
- log.WriteWindowsError(L"BluetoothFindNextRadio", GetLastError());
+ log.LogWinError(L"BluetoothFindNextRadio", GetLastError());
UnloadRadioNotifications();
} else {
success = true;
if (useDeviceList_) {
auto pos = std::find(begin(deviceNames_), end(deviceNames_), inRangeInfo->deviceInfo.name);
if (pos == end(deviceNames_)) {
- log.Write(L"Bluetooth device \"%S\" not in list.", inRangeInfo->deviceInfo.name);
+ log.LogInfo(L"Bluetooth device \"%S\" not in list.", inRangeInfo->deviceInfo.name);
return BluetoothStatus::Unknown;
}
}
if ((inRangeInfo->deviceInfo.flags & BDIF_CONNECTED) && !(inRangeInfo->previousDeviceFlags & BDIF_CONNECTED)) {
- log.Write(L"Bluetooth Audio device \"%S\" connected.", inRangeInfo->deviceInfo.name);
+ log.LogInfo(L"Bluetooth Audio device \"%S\" connected.", inRangeInfo->deviceInfo.name);
return BluetoothStatus::Connected;
} else if (!(inRangeInfo->deviceInfo.flags & BDIF_CONNECTED) && (inRangeInfo->previousDeviceFlags & BDIF_CONNECTED)) {
- log.Write(L"Bluetooth Audio device \"%S\" disconnected.", inRangeInfo->deviceInfo.name);
+ log.LogInfo(L"Bluetooth Audio device \"%S\" disconnected.", inRangeInfo->deviceInfo.name);
return BluetoothStatus::Disconnected;
}
return BluetoothStatus::Unknown;
{
if (notifyParent_ && pwstrDeviceId != nullptr) {
const auto deviceName = GetFriendlyDeviceName(pwstrDeviceId);
- WMLog::GetInstance().GetInstance().Write(L"Device \"%s\" added", deviceName.c_str());
+ WMLog::GetInstance().GetInstance().LogInfo(L"Device \"%s\" added", deviceName.c_str());
notifyParent_->ShouldReInit();
}
return S_OK;
{
if (notifyParent_ && pwstrDeviceId != nullptr) {
const auto deviceName = GetFriendlyDeviceName(pwstrDeviceId);
- WMLog::GetInstance().GetInstance().Write(L"Device \"%s\" removed", deviceName.c_str());
+ WMLog::GetInstance().GetInstance().LogInfo(L"Device \"%s\" removed", deviceName.c_str());
notifyParent_->ShouldReInit();
}
return S_OK;
if (notify && notifyParent_) {
// TODO: Check if output device
const auto deviceName = GetFriendlyDeviceName(pwstrDeviceId);
- WMLog::GetInstance().GetInstance().Write(
+ WMLog::GetInstance().GetInstance().LogInfo(
L"Device \"%s\" status changed to %s",
deviceName.c_str(),
what.c_str());
wndClass.hInstance = hglobInstance;
wndClass.lpszClassName = MUTECONTROL_CLASS_NAME;
if (!RegisterClassExW(&wndClass)) {
- WMLog::GetInstance().WriteWindowsError(L"RegisterClassEx");
+ WMLog::GetInstance().LogWinError(L"RegisterClassEx");
return false;
}
hMuteCtrlWnd_ = CreateWindowEx(
hglobInstance,
this);
if (hMuteCtrlWnd_ == nullptr) {
- WMLog::GetInstance().WriteWindowsError(L"CreateWindowEx");
+ WMLog::GetInstance().LogWinError(L"CreateWindowEx");
UnregisterClassW(MUTECONTROL_CLASS_NAME, hglobInstance);
return false;
}
void MuteControl::SetMute(bool mute)
{
- WMLog::GetInstance().Write(L"Manual muting: %s", mute ? L"on" : L"off");
+ WMLog::GetInstance().LogInfo(L"Manual muting: %s", mute ? L"on" : L"off");
winAudio_->SetMute(mute);
}
);
if (alreadySaved) {
- WMLog::GetInstance().Write(L"Muting event already active. Skipping status save");
+ WMLog::GetInstance().LogInfo(L"Muting event already active. Skipping status save");
} else {
- WMLog::GetInstance().Write(L"Saving mute status");
+ WMLog::GetInstance().LogInfo(L"Saving mute status");
winAudio_->SaveMuteStatus();
}
}
if (magic != MUTE_DELAY_MAGIC_VALUE || delayedMuteTimerId_ == 0) {
return;
}
- WMLog::GetInstance().Write(L"Muting workstation after delay");
+ WMLog::GetInstance().LogInfo(L"Muting workstation after delay");
ShowNotification(
WMi18n::GetInstance().GetTranslationW("popup.muting-workstation-after-delay.title"),
WMi18n::GetInstance().GetTranslationW("popup.muting-workstation-after-delay.text"));
muteDelaySeconds_ * 1000,
DelayedMuteTimerProc);
if (delayedMuteTimerId_ == 0) {
- WMLog::GetInstance().WriteWindowsError(L"SetTimer", GetLastError());
+ WMLog::GetInstance().LogWinError(L"SetTimer", GetLastError());
}
return delayedMuteTimerId_ != 0;
}
{
WMLog& log = WMLog::GetInstance();
if (!restoreVolume_) {
- log.Write(L"Volume Restore has been disabled");
+ log.LogInfo(L"Volume Restore has been disabled");
return;
}
const bool restore = !std::any_of(
}
);
if (!restore) {
- log.Write(L"Skipping restore since other mute event is currently active");
+ log.LogInfo(L"Skipping restore since other mute event is currently active");
} else if (delayedMuteTimerId_ != 0) {
KillTimer(hMuteCtrlWnd_, delayedMuteTimerId_);
delayedMuteTimerId_ = 0;
- log.Write(L"Skipping restore, since delayed mute was not triggered yet");
+ log.LogInfo(L"Skipping restore, since delayed mute was not triggered yet");
} else {
- log.Write(L"Restoring previous mute state");
+ log.LogInfo(L"Restoring previous mute state");
ShowNotification(
WMi18n::GetInstance().GetTranslationW("popup.volume-restored.title"),
WMi18n::GetInstance().GetTranslationW("popup.volume-restored.text"));
muteConfig_[type].active = active;
if (muteConfig_[type].shouldMute) {
if (muteDelaySeconds_ == 0) {
- WMLog::GetInstance().Write(L"Muting workstation");
+ WMLog::GetInstance().LogInfo(L"Muting workstation");
ShowNotification(
WMi18n::GetInstance().GetTranslationW("popup.muting-workstation.title"),
WMi18n::GetInstance().GetTranslationW("popup.muting-workstation.text"));
winAudio_->SetMute(true);
} else {
- WMLog::GetInstance().Write(L"Starting delayed mute timer...");
+ WMLog::GetInstance().LogInfo(L"Starting delayed mute timer...");
StartDelayedMute();
}
}
void MuteControl::NotifyWorkstationLock(bool active)
{
- WMLog::GetInstance().Write(L"Mute Event: Workstation Lock %s",
+ WMLog::GetInstance().LogInfo(L"Mute Event: Workstation Lock %s",
active ? L"start" : L"stop");
NotifyRestoreCondition(MuteTypeWorkstationLock, active);
}
void MuteControl::NotifyRemoteSession(bool active)
{
- WMLog::GetInstance().Write(L"Mute Event: Remote Session %s",
+ WMLog::GetInstance().LogInfo(L"Mute Event: Remote Session %s",
active ? L"start" : L"stop");
NotifyRestoreCondition(MuteTypeRemoteSession, active);
}
void MuteControl::NotifyDisplayStandby(bool active)
{
if (displayWasOffOnce_ || active) {
- WMLog::GetInstance().Write(L"Mute Event: Display Standby %s",
+ WMLog::GetInstance().LogInfo(L"Mute Event: Display Standby %s",
active ? L"start" : L"stop");
NotifyRestoreCondition(MuteTypeDisplayStandby, active);
displayWasOffOnce_ = true;
void MuteControl::NotifyBluetoothConnected(bool connected)
{
- WMLog::GetInstance().Write(
+ WMLog::GetInstance().LogInfo(
L"Mute Event: Bluetooth audio device %s",
connected ? L"connected" : L"disconnected");
NotifyRestoreCondition(MuteTypeBluetoothDisconnect, !connected, true);
void MuteControl::NotifyLogout()
{
- WMLog::GetInstance().Write(L"Mute Event: Logout start");
+ WMLog::GetInstance().LogInfo(L"Mute Event: Logout start");
if (muteConfig_[MuteTypeLogout].shouldMute) {
winAudio_->SetMute(true);
}
void MuteControl::NotifySuspend(bool /*active*/)
{
- WMLog::GetInstance().Write(L"Mute Event: Suspend start");
+ WMLog::GetInstance().LogInfo(L"Mute Event: Suspend start");
if (muteConfig_[MuteTypeSuspend].shouldMute) {
winAudio_->SetMute(true);
}
void MuteControl::NotifyShutdown()
{
- WMLog::GetInstance().Write(L"Mute Event: Shutdown start");
+ WMLog::GetInstance().LogInfo(L"Mute Event: Shutdown start");
if (muteConfig_[MuteTypeShutdown].shouldMute) {
winAudio_->SetMute(true);
}
{
if (active) {
SaveMuteStatus();
- WMLog::GetInstance().Write(L"Mute Event: Quiet Hours startet");
+ WMLog::GetInstance().LogInfo(L"Mute Event: Quiet Hours startet");
winAudio_->SaveMuteStatus();
winAudio_->SetMute(true);
} else {
- WMLog::GetInstance().Write(L"Mute Event: Quiet Hours ended");
+ WMLog::GetInstance().LogInfo(L"Mute Event: Quiet Hours ended");
RestoreVolume();
}
}
end.wHour = static_cast<WORD>((qhEnd_ - end.wMinute - end.wSecond) / 3600);
if (IsQuietHours(&now, &start, &end)) {
- WMLog::GetInstance().Write(L"Mute: On | Quiet hours have already started");
+ WMLog::GetInstance().LogInfo(L"Mute: On | Quiet hours have already started");
SendMessage(hParent_, WM_WINMUTE_QUIETHOURS_START, 0, 0);
} else {
int timerQhStart = GetDiffMillseconds(&start, &now);
HDWP hdwp = BeginDeferWindowPos(tabCount);
if (hdwp == nullptr) {
- PrintWindowsError(L"BeginDeferWindowPos", GetLastError());
+ ShowWindowsError(L"BeginDeferWindowPos", GetLastError());
} else {
for (int i = 0; i < tabCount; ++i) {
HDWP newHdwp = DeferWindowPos(
tabCtrlRect.bottom - tabCtrlRect.top,
0);
if (newHdwp == nullptr) {
- PrintWindowsError(L"DeferWindowPos", GetLastError());
+ ShowWindowsError(L"DeferWindowPos", GetLastError());
break;
} else {
hdwp = newHdwp;
btdi.dwSize = sizeof(btdi);
HBLUETOOTH_DEVICE_FIND hBtDevFind = BluetoothFindFirstDevice(&bfrp, &btdi);
if (hBtDevFind == nullptr) {
- log.WriteWindowsError(L"BluetoothFindFirstDevice", GetLastError());
+ log.LogWinError(L"BluetoothFindFirstDevice", GetLastError());
} else {
do {
if (GET_COD_MAJOR(btdi.ulClassofDevice) == COD_MAJOR_AUDIO) {
for (const auto &lang : dlgData.langModules) {
const auto itemId = SendMessage(hLanguageList, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>(lang.langName.c_str()));
if (itemId == CB_ERR || itemId == CB_ERRSPACE) {
- WMLog::GetInstance().Write(L"Failed to add language %ls to language selector", lang.langName.c_str());
+ WMLog::GetInstance().LogError(L"Failed to add language %ls to language selector", lang.langName.c_str());
} else {
ComboBox_SetItemData(hLanguageList, itemId, lang.fileName.c_str());
}
i18n.SetItemText(hDlg, IDC_SELECT_LANGUAGE_LABEL, "settings.general.select-language-label");
i18n.SetItemText(hDlg, IDC_RUNONSTARTUP, "settings.general.run-on-startup");
i18n.SetItemText(hDlg, IDC_CHECK_FOR_UPDATES_ON_STARTUP, "settings.general.check-for-updates-on-start");
+ i18n.SetItemText(hDlg, IDC_CHECK_FOR_BETA_UPDATES, "settings.general.check-for-beta-updates-on-start");
i18n.SetItemText(hDlg, IDC_ENABLELOGGING, "settings.general.enable-logging");
i18n.SetItemText(hDlg, IDC_OPENLOG, "settings.general.btn-open-log-file");
}
case WM_INITDIALOG: {
HWND hAutostart = GetDlgItem(hDlg, IDC_RUNONSTARTUP);
HWND hUpdateCheck = GetDlgItem(hDlg, IDC_CHECK_FOR_UPDATES_ON_STARTUP);
+ HWND hBetaUpdateCheck = GetDlgItem(hDlg, IDC_CHECK_FOR_BETA_UPDATES);
HWND hLogging = GetDlgItem(hDlg, IDC_ENABLELOGGING);
HWND hOpenLog = GetDlgItem(hDlg, IDC_OPENLOG);
enabled = !!dlgData->settings->QueryValue(SettingsKey::CHECK_FOR_UPDATE);
Button_SetCheck(hUpdateCheck, enabled ? BST_CHECKED : BST_UNCHECKED);
+ EnableWindow(hBetaUpdateCheck, enabled);
+ enabled = !!dlgData->settings->QueryValue(SettingsKey::CHECK_FOR_BETA_UPDATE);
+ Button_SetCheck(hBetaUpdateCheck, enabled ? BST_CHECKED : BST_UNCHECKED);
+
enabled = !!dlgData->settings->QueryValue(SettingsKey::LOGGING_ENABLED);
Button_SetCheck(hLogging, enabled ? BST_CHECKED : BST_UNCHECKED);
Button_Enable(hOpenLog, enabled);
SendMessageW(GetDlgItem(hDlg, IDC_LOGFILEPATH), WM_SETTEXT, 0,
reinterpret_cast<LPARAM>(L""));
}
+ } else if (LOWORD(wParam) == IDC_CHECK_FOR_UPDATES_ON_STARTUP) {
+ const int enabled = Button_GetCheck(GetDlgItem(hDlg, IDC_CHECK_FOR_UPDATES_ON_STARTUP));
+ EnableWindow(GetDlgItem(hDlg, IDC_CHECK_FOR_BETA_UPDATES), enabled);
} else if (LOWORD(wParam) == IDC_OPENLOG) {
WMLog& log = WMLog::GetInstance();
const std::wstring filePath = log.GetLogFilePath().c_str();
HWND hAutostart = GetDlgItem(hDlg, IDC_RUNONSTARTUP);
HWND hLogging = GetDlgItem(hDlg, IDC_ENABLELOGGING);
HWND hUpdateCheck = GetDlgItem(hDlg, IDC_CHECK_FOR_UPDATES_ON_STARTUP);
+ HWND hBetaUpdateCheck = GetDlgItem(hDlg, IDC_CHECK_FOR_BETA_UPDATES);
const int enableLog = Button_GetCheck(hLogging) == BST_CHECKED;
dlgData->settings->SetValue(SettingsKey::LOGGING_ENABLED, enableLog);
const int enableUpdateCheck = Button_GetCheck(hUpdateCheck) == BST_CHECKED;
dlgData->settings->SetValue(SettingsKey::CHECK_FOR_UPDATE, enableUpdateCheck);
+ const int enableBetaUpdateCheck = Button_GetCheck(hBetaUpdateCheck) == BST_CHECKED;
+ dlgData->settings->SetValue(SettingsKey::CHECK_FOR_BETA_UPDATE, enableBetaUpdateCheck);
+
if (Button_GetCheck(hAutostart) == BST_CHECKED) {
dlgData->settings->EnableAutostart(true);
} else {
for (UINT i = 0; i < epCount; ++i) {
IMMDevicePtr device = nullptr;
if (FAILED(audioEndpoints->Item(i, &device))) {
- log.Write(L"Failed to get audio endpoint #%d", i);
+ log.LogError(L"Failed to get audio endpoint #%d", i);
continue;
}
IPropertyStorePtr propStore = nullptr;
if (FAILED(device->OpenPropertyStore(STGM_READ, &propStore))) {
- log.Write(L"Failed to open property store for audio endpoint #%d", i);
+ log.LogError(L"Failed to open property store for audio endpoint #%d", i);
continue;
}
PROPVARIANT value;
PropVariantInit(&value);
if (FAILED(propStore->GetValue(PKEY_Device_FriendlyName, &value))) {
- log.Write(L"Failed to get device name for audio endpoint #%d", i);
+ log.LogError(L"Failed to get device name for audio endpoint #%d", i);
continue;
}
hDlg,
Settings_ManageEndpointsDlgProc,
reinterpret_cast<LPARAM>(settings)) == 0) {
- PrintWindowsError(L"DialogBoxParam", GetLastError());
+ ShowWindowsError(L"DialogBoxParam", GetLastError());
}
}
return 0;
i18n.SetItemText(hDlg, IDC_WIFI_INTRO, "settings.wifi.intro");
i18n.SetItemText(hDlg, IDC_ENABLE_WIFI_MUTE, "settings.wifi.enable");
- i18n.SetItemText(hDlg, IDC_IS_PERMITLIST, "settings.wifi.mute-when-not-in-list");
i18n.SetItemText(hDlg, IDC_WIFI_ADD, "settings.btn-add");
i18n.SetItemText(hDlg, IDC_WIFI_EDIT, "settings.btn-edit");
i18n.SetItemText(hDlg, IDC_WIFI_REMOVE, "settings.btn-remove");
{
}
+bool UpdateChecker::ParseVersionInfo(const nlohmann::json &json, UpdateVersionInfo &versInfo) const
+{
+ WMLog &log = WMLog::GetInstance();
+ if (!json.contains("version") && !json.contains("downloadUrl")) {
+ log.LogError(L"Missing json fields in update file");
+ return false;
+ }
+ versInfo.version = ConvertStringToWideString(json["version"]);;
+ versInfo.downloadUrl = ConvertStringToWideString(json["downloadUrl"]);
+ return true;
+}
+
bool UpdateChecker::ParseVersionFile(
const std::string &fileContents,
UpdateInfo &updateInfo) const
{
// Structure
// {
- // "version": "2.4.1.0",
- // "versionPage" : "https://github.com/lx-s/WinMute/releases/"
+ // "version": 1,
+ // "stable" : {
+ // "version": "2.4.1.0",
+ // "download_page" : "https://github.com/lx-s/WinMute/releases/"
+ // },
+ // "beta" : {
+ // "version": "2.4.1.0",
+ // "download_page" : "https://github.com/lx-s/WinMute/releases/"
+ // }
// }
WMLog &log = WMLog::GetInstance();
try {
auto json = nlohmann::json::parse(fileContents);
- if (!json.contains("version") && !json.contains("versionPage")) {
- log.Write(L"Missing json fields in update file");
+ if (!json.contains("version")) {
+ log.LogError(L"Missing update-file version");
+ return false;
+ }
+ const auto file_version = json["version"];
+ if (!file_version.is_number() || file_version.get<int>() != 1) {
+ log.LogError(L"Update file has incompatible version number");
+ return false;
+ }
+ if (!json.contains("stable") || !json.contains("beta")) {
+ log.LogError(L"Missing stable and/or beta fields");
return false;
}
- updateInfo.newVersion = ConvertStringToWideString(json["version"]);
- updateInfo.versionPageUrl = ConvertStringToWideString(json["versionPage"]);
+ const auto stableInfo = json["stable"];
+ const auto betaInfo = json["beta"];
+
+ if (!stableInfo.is_structured() || !betaInfo.is_structured()) {
+ log.LogError(L"Missing stable and/or beta fields");
+ return false;
+ }
+
+ if (!ParseVersionInfo(stableInfo, updateInfo.stable) ||
+ !ParseVersionInfo(betaInfo, updateInfo.beta)) {
+ log.LogError(L"Failed to parse stable and/or beta fields");
+ return false;
+ }
+
} catch (const nlohmann::json::parse_error &pe) {
- log.Write(L"Failed to parse update: %S", pe.what());
+ log.LogError(L"Failed to parse update: %S", pe.what());
return false;
}
return true;
std::vector<int> curVersParsed;
WMLog &log = WMLog::GetInstance();
if (!ParseVersion(newVers, newVersParsed)) {
- log.Write(L"Failed to parse new version string \"%s\"", newVers.c_str());
+ log.LogError(L"Failed to parse new version string \"%s\"", newVers.c_str());
return std::nullopt;
} else if (!ParseVersion(curVers, curVersParsed)) {
- log.Write(L"Failed to parse current version string \"%s\"", curVers.c_str());
+ log.LogError(L"Failed to parse current version string \"%s\"", curVers.c_str());
return std::nullopt;
} else if (newVersParsed.size() != curVersParsed.size()) {
- log.Write(L"Version format mismatch \"%s\" / \"%s\"", curVers.c_str(), newVers.c_str());
+ log.LogError(L"Version format mismatch \"%s\" / \"%s\"", curVers.c_str(), newVers.c_str());
return std::nullopt;
}
for (size_t i = 0; i < newVersParsed.size(); ++i) {
return false;
}
- const auto shouldUpdate = IsVersionGreater(updateInfo.newVersion, updateInfo.currentVersion);
- if (!shouldUpdate) {
+ const auto shouldUpdateStable = IsVersionGreater(updateInfo.stable.version, updateInfo.currentVersion);
+ const auto shouldUpdateBeta = IsVersionGreater(updateInfo.beta.version, updateInfo.currentVersion);
+ if (!shouldUpdateStable || !shouldUpdateBeta) {
return false;
}
- updateInfo.shouldUpdate = *shouldUpdate;
-
+ updateInfo.stable.shouldUpdate = *shouldUpdateStable;
+ updateInfo.beta.shouldUpdate = *shouldUpdateBeta;
return true;
}
updateUrl.dwHostNameLength = (DWORD)-1;
updateUrl.dwUrlPathLength = (DWORD)-1;
if (!WinHttpCrackUrl(UPDATE_FILE_URL, 0, 0, &updateUrl)) {
- log.WriteWindowsError(L"WinHttpCrackUrl", GetLastError());
+ log.LogWinError(L"WinHttpCrackUrl", GetLastError());
return false;
}
WINHTTP_NO_PROXY_BYPASS,
WINHTTP_FLAG_SECURE_DEFAULTS);
if (hSession == nullptr) {
- log.WriteWindowsError(L"WinHttpOpen", GetLastError());
+ log.LogWinError(L"WinHttpOpen", GetLastError());
return false;
}
(updateUrl.nScheme == INTERNET_SCHEME_HTTPS) ? INTERNET_DEFAULT_HTTPS_PORT : INTERNET_DEFAULT_HTTP_PORT,
0);
if (hConnect == nullptr) {
- log.WriteWindowsError(L"WinHttpConnect", GetLastError());
+ log.LogWinError(L"WinHttpConnect", GetLastError());
return false;
}
WINHTTP_FLAG_REFRESH | WINHTTP_FLAG_SECURE);
if (hRequest == nullptr) {
- log.WriteWindowsError(L"WinHttpConnect", GetLastError());
+ log.LogWinError(L"WinHttpConnect", GetLastError());
return false;
}
bool result = WinHttpSendRequest(
- hRequest,
- WINHTTP_NO_ADDITIONAL_HEADERS,
- 0,
- WINHTTP_NO_REQUEST_DATA,
- 0,
- 0,
- 0);
+ hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0,
+ WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
if (!result) {
- log.WriteWindowsError(L"WinHttpSendRequest", GetLastError());
+ log.LogWinError(L"WinHttpSendRequest", GetLastError());
return false;
}
result = WinHttpReceiveResponse(hRequest, nullptr);
if (!result) {
- log.WriteWindowsError(L"WinHttpReceiveResponse", GetLastError());
+ log.LogWinError(L"WinHttpReceiveResponse", GetLastError());
return false;
}
&statusCodeSize,
WINHTTP_NO_HEADER_INDEX);
if (!result) {
- log.WriteWindowsError(L"WinHttpQueryHeaders(WINHTTP_QUERY_STATUS_CODE)", GetLastError());
+ log.LogWinError(L"WinHttpQueryHeaders(WINHTTP_QUERY_STATUS_CODE)", GetLastError());
return false;
} else if (statusCode != HTTP_STATUS_OK) {
- log.Write(L"Update-Server returned HTTP %d", HTTP_STATUS_OK);
+ log.LogError(L"Update-Server returned HTTP %d", HTTP_STATUS_OK);
return false;
}
for (;;) {
DWORD availBytes = 0;
if (!WinHttpQueryDataAvailable(hRequest, &availBytes)) {
- log.WriteWindowsError(L"WinHttpQueryDataAvailable", GetLastError());
+ log.LogWinError(L"WinHttpQueryDataAvailable", GetLastError());
return false;
}
if (availBytes == 0) {
std::string chunk(availBytes, ' ');
DWORD byRead = 0;
if (!WinHttpReadData(hRequest, reinterpret_cast<LPVOID>(&chunk[0]), availBytes, &byRead)) {
- log.WriteWindowsError(L"WinHttpReadData", GetLastError());
+ log.LogWinError(L"WinHttpReadData", GetLastError());
return false;
}
fileContents.append(chunk.begin(), chunk.begin() + byRead);
const DWORD thisExePathSize = ARRAY_SIZE(thisExePath);
const DWORD thisPathLen = GetModuleFileNameW(nullptr, thisExePath, thisExePathSize);
if (thisPathLen == 0 || (thisPathLen == thisExePathSize && GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
- WMLog::GetInstance().WriteWindowsError(L"GetModuleFileNameW", ERROR_INSUFFICIENT_BUFFER);
+ WMLog::GetInstance().LogWinError(L"GetModuleFileNameW", ERROR_INSUFFICIENT_BUFFER);
return false;
}
fs::path updateDisableFile{ thisExePath };
ON_STARTUP = 1,
};
+struct UpdateVersionInfo {
+ std::wstring version;
+ std::wstring downloadUrl;
+ bool shouldUpdate = false;
+};
+
struct UpdateInfo {
std::wstring currentVersion;
- std::wstring newVersion;
- std::wstring versionPageUrl;
- bool shouldUpdate;
+ UpdateVersionInfo stable;
+ UpdateVersionInfo beta;
};
class UpdateChecker {
bool ParseVersionFile(const std::string &fileContents, UpdateInfo& updateInfo) const;
std::optional<bool> IsVersionGreater(const std::wstring &newVers, const std::wstring &curVers) const;
bool ParseVersion(const std::wstring &vers, std::vector<int>& parsedVers) const;
+ bool ParseVersionInfo(const nlohmann::json &json, UpdateVersionInfo &versInfo) const;
};
#include "Common.h"
-void PrintWindowsError(const wchar_t *functionName, DWORD lastError)
+void ShowWindowsError(const wchar_t *functionName, DWORD lastError)
{
// Retrieve the system error message for the last-error code
if (lastError == -1) {
hr = audioEndpoints->Item(i, &device);
if (FAILED(hr)) {
- log.Write(L"Failed to get audio endpoint #%d", i);
+ log.LogError(L"Failed to get audio endpoint #%d", i);
continue;
}
hr = device->OpenPropertyStore(STGM_READ, &propStore);
if (FAILED(hr)) {
- log.Write(L"Failed to open property store for audio endpoint #%d", i);
+ log.LogError(L"Failed to open property store for audio endpoint #%d", i);
continue;
}
PropVariantInit(&value);
hr = propStore->GetValue(PKEY_Device_FriendlyName, &value);
if (FAILED(hr)) {
- log.Write(L"Failed to get device name for audio endpoint #%d", i);
+ log.LogError(L"Failed to get device name for audio endpoint #%d", i);
continue;
}
- log.Write(L"Found audio endpoint \"%s\"", value.pwszVal);
+ log.LogInfo(L"Found audio endpoint \"%s\"", value.pwszVal);
StringCchCopy(ep->deviceName,
sizeof(ep->deviceName)/sizeof(ep->deviceName[0]),
value.pwszVal);
if (FAILED(device->Activate(
__uuidof(IAudioSessionManager2), CLSCTX_INPROC_SERVER, nullptr,
reinterpret_cast<LPVOID*>(&sessionManager2)))) {
- log.Write(L"Failed to retrieve audio session manager for \"%s\"",
+ log.LogError(L"Failed to retrieve audio session manager for \"%s\"",
ep->deviceName);
continue;
}
hr = sessionManager2->GetAudioSessionControl(nullptr, 0, &ep->sessionCtrl);
if (FAILED(hr)) {
- log.Write(L"Failed to retrieve audio session manager for \"%s\"",
+ log.LogError(L"Failed to retrieve audio session manager for \"%s\"",
ep->deviceName);
continue;
}
__uuidof(IAudioEndpointVolume), CLSCTX_INPROC_SERVER,
nullptr, reinterpret_cast<LPVOID*>(&ep->endpointVolume));
if (FAILED(hr)) {
- log.Write(L"Failed to active endpoint volume for device \"%s\"",
- ep->deviceName);
+ log.LogError(L"Failed to active endpoint volume for device \"%s\"",
+ ep->deviceName);
continue;
}
endpoints_.push_back(std::move(ep));
__uuidof(MMDeviceEnumerator),
nullptr,
CLSCTX_INPROC_SERVER))) {
- log.Write(L"Failed to create instance of MMDeviceEnumerator");
+ log.LogError(L"Failed to create instance of MMDeviceEnumerator");
return false;
}
for (auto& e : endpoints_) {
BOOL isMuted = FALSE;
if (FAILED(e->endpointVolume->GetMute(&isMuted))) {
- log.Write(L"Failed to get mute status for \"%s\"",
+ log.LogError(
+ L"Failed to get mute status for \"%s\"",
e->deviceName);
allMuted = false;
break;
for (auto& e : endpoints_) {
BOOL isMuted = FALSE;
if (FAILED(e->endpointVolume->GetMute(&isMuted))) {
- log.Write(L"Failed to get mute status for \"%s\"",
- e->deviceName);
+ log.LogError(
+ L"Failed to get mute status for \"%s\"",
+ e->deviceName);
success = false;
} else {
e->wasMuted = isMuted;
}
for (auto& e : endpoints_) {
if (!IsEndpointManaged(e->deviceName)) {
- log.Write(L"Skipping Endpoint %s", e->deviceName);
- continue;
+ log.LogInfo(L"Skipping Endpoint %s", e->deviceName);
+ continue;
}
- log.Write(L"Restoring: Mute %s for \"%s\"",
+ log.LogInfo(L"Restoring: Mute %s for \"%s\"",
(e->wasMuted) ? L"true" : L"false",
e->deviceName);
if (e->wasMuted != true) {
if (FAILED(e->endpointVolume->SetMute(false, nullptr))) {
- log.Write(_T("Failed to restore mute status to %s for \"%s\""),
+ log.LogError(_T("Failed to restore mute status to %s for \"%s\""),
(e->wasMuted) ? L"true" : L"false",
e->deviceName);
success = false;
for (auto& e : endpoints_) {
BOOL isMuted = !mute;
if (!IsEndpointManaged(e->deviceName)) {
- log.Write(L"Skipping Endpoint %s", e->deviceName);
+ log.LogInfo(L"Skipping Endpoint %s", e->deviceName);
continue;
}
if (FAILED(e->endpointVolume->GetMute(&isMuted))) {
- log.Write(L"Failed to get mute status for \"%s\"",
- e->deviceName);
+ log.LogError(
+ L"Failed to get mute status for \"%s\"",
+ e->deviceName);
}
if (!!isMuted != mute) {
if (FAILED(e->endpointVolume->SetMute(mute, nullptr))) {
- log.Write(L"Failed to set mute status to %s for \"%s\"",
- (e->wasMuted) ? L"true" : L"false",
- e->deviceName);
+ log.LogError(
+ L"Failed to set mute status to %s for \"%s\"",
+ (e->wasMuted) ? L"true" : L"false",
+ e->deviceName);
}
}
}
return enabled_;
}
-void WMLog::WriteMessage(const wchar_t* msg)
+void WMLog::WriteMessage(const wchar_t* level, const wchar_t* msg)
{
- struct tm tm = { 0 };
- auto now = std::chrono::system_clock::now();
- auto in_time_t = std::chrono::system_clock::to_time_t(now);
-
- std::wstringstream ss;
- localtime_s(&tm, &in_time_t);
- ss << L"[" << std::put_time(&tm, L"%Y-%m-%d %X") << L"] "
- << msg << L"\n";
- const auto& logStr = ss.str();
+ time_t rawtime;
+ struct tm timeinfo;
+ wchar_t buffer[30];
+
+ time(&rawtime);
+ localtime_s(&timeinfo, &rawtime);
+
+ wcsftime(buffer, ARRAY_SIZE(buffer), L"%Y-%m-%d %H:%M:%S", &timeinfo);
+ const std::wstring logMsg = std::vformat(
+ L"[{} {}]: {}\n",
+ std::make_wformat_args(
+ buffer,
+ level,
+ msg)
+ );
const std::scoped_lock<std::mutex> lock(logMutex_);
- logFile_.write(logStr.c_str(), logStr.length());
+ logFile_.write(logMsg.c_str(), logMsg.length());
logFile_.flush();
}
-void WMLog::Write(_In_z_ _Printf_format_string_ const wchar_t *fmt, ...)
+void WMLog::LogDebug(_In_z_ _Printf_format_string_ const wchar_t *fmt, ...)
+{
+ if (!enabled_) {
+ return;
+ }
+
+ wchar_t buf[1024];
+ va_list ap;
+ va_start(ap, fmt);
+
+ vswprintf_s(buf, fmt, ap);
+ WriteMessage(L"Debug", buf);
+
+ va_end(ap);
+}
+
+void WMLog::LogInfo(_In_z_ _Printf_format_string_ const wchar_t *fmt, ...)
+{
+ if (!enabled_) {
+ return;
+ }
+
+ wchar_t buf[1024];
+ va_list ap;
+ va_start(ap, fmt);
+
+ vswprintf_s(buf, fmt, ap);
+ WriteMessage(L"Info", buf);
+
+ va_end(ap);
+}
+
+void WMLog::LogError(_In_z_ _Printf_format_string_ const wchar_t *fmt, ...)
{
if (!enabled_) {
return;
}
- wchar_t buf[200];
+ wchar_t buf[1024];
va_list ap;
va_start(ap, fmt);
vswprintf_s(buf, fmt, ap);
- WriteMessage(buf);
+ WriteMessage(L"Error", buf);
va_end(ap);
}
-void WMLog::WriteWindowsError(const wchar_t *functionName, DWORD lastError)
+void WMLog::LogWinError(const wchar_t *functionName, DWORD lastError)
{
// Retrieve the system error message for the last-error code
if (lastError == -1) {
functionName,
lastError,
reinterpret_cast<wchar_t *>(lpMsgBuf)));
- WriteMessage(static_cast<const wchar_t*>(lpMsgBuf));
+ WriteMessage(L"Error", static_cast<const wchar_t *>(lpMsgBuf));
LocalFree(lpMsgBuf);
}
public:
static WMLog& GetInstance();
- void Write(_In_z_ _Printf_format_string_ const wchar_t* fmt, ...);
- void WriteWindowsError(const wchar_t *functionName, DWORD errorCode = -1);
+ void LogDebug(_In_z_ _Printf_format_string_ const wchar_t *fmt, ...);
+ void LogInfo(_In_z_ _Printf_format_string_ const wchar_t* fmt, ...);
+ void LogError(_In_z_ _Printf_format_string_ const wchar_t *fmt, ...);
+ void LogWinError(const wchar_t *functionName, DWORD errorCode = -1);
void SetEnabled(bool enable);
bool IsEnabled() const;
WMLog(const WMLog&) = delete;
WMLog& operator=(const WMLog&) = delete;
- void WriteMessage(const wchar_t* msg);
+ void WriteMessage(const wchar_t *level, const wchar_t *msg);
void DeleteLogFile();
std::mutex logMutex_;
case SettingsKey::CHECK_FOR_UPDATE:
keyStr = L"CheckForUpdate";
break;
+ case SettingsKey::CHECK_FOR_BETA_UPDATE:
+ keyStr = L"CheckForBetaUpdate";
+ break;
}
return keyStr;
}
return 0;
case SettingsKey::CHECK_FOR_UPDATE:
return 0;
+ case SettingsKey::CHECK_FOR_BETA_UPDATE:
+ return 0;
}
return 0;
}
regError = RegQueryValueExW(hKey, subKey, nullptr, nullptr, nullptr, &bufSize);
if (regError != ERROR_SUCCESS) {
if (regError != ERROR_FILE_NOT_FOUND) {
- PrintWindowsError(L"RegQueryValueExW", regError);
- log.Write(L"[Registry] Failed to read key \"%s\".", subKey);
+ ShowWindowsError(L"RegQueryValueExW", regError);
+ log.LogError(L"[Registry] Failed to read key \"%s\".", subKey);
}
} else {
bufSize += 1; // Trailing '\0'
regError = RegQueryValueExW(hKey, subKey, nullptr, nullptr,
reinterpret_cast<LPBYTE>(buf), &bufSize);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegQueryValueExW", regError);
- log.Write(L"[Registry] Failed to query value for key \"%s\".", subKey);
+ ShowWindowsError(L"RegQueryValueExW", regError);
+ log.LogError(L"[Registry] Failed to query value for key \"%s\".", subKey);
} else {
success = true;
val = buf;
{
DWORD version = QueryValue(SettingsKey::SETTINGS_VERSION);
if (version != CURRENT_SETTINGS_VERSION) {
- WMLog::GetInstance().Write(L"Unexpected settings version: %d", version);
+ WMLog::GetInstance().LogError(L"Unexpected settings version: %d", version);
}
return true;
}
&hSettingsKey_,
nullptr);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegCreateKeyEx", regError);
+ ShowWindowsError(L"RegCreateKeyEx", regError);
return false;
}
}
&hWifiKey_,
nullptr);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegCreateKeyEx", regError);
+ ShowWindowsError(L"RegCreateKeyEx", regError);
RegCloseKey(hSettingsKey_);
hSettingsKey_ = nullptr;
return false;
&hBluetoothKey_,
nullptr);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegCreateKeyEx", regError);
+ ShowWindowsError(L"RegCreateKeyEx", regError);
RegCloseKey(hWifiKey_);
RegCloseKey(hSettingsKey_);
hSettingsKey_ = nullptr;
&hAudioEndpointsKey_,
nullptr);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegCreateKeyEx", regError);
+ ShowWindowsError(L"RegCreateKeyEx", regError);
RegCloseKey(hWifiKey_);
RegCloseKey(hSettingsKey_);
RegCloseKey(hBluetoothKey_);
samDesired,
&hRunKey);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegOpenKeyEx", regError);
+ ShowWindowsError(L"RegOpenKeyEx", regError);
}
return hRunKey;
}
WMLog& log = WMLog::GetInstance();
wchar_t wmPath[MAX_PATH + 1];
if (GetModuleFileName(nullptr, wmPath, sizeof(wmPath) / sizeof(wmPath[0])) == 0) {
- log.Write(L"Failed to get path of winmute");
+ log.LogError(L"Failed to get path of winmute");
} else {
HKEY hRunKey = OpenAutostartKey(KEY_READ);
if (hRunKey != nullptr) {
std::wstring path;
if (ReadStringFromRegistry(hRunKey, LX_SYSTEMS_AUTOSTART_KEY, path)) {
if (path != wmPath) {
- log.Write(L"Autostart entry has wrong path");
+ log.LogInfo(L"Autostart entry has wrong path");
} else {
isEnabled = true;
}
if (enable) {
wchar_t wmPath[MAX_PATH + 1];
if (GetModuleFileNameW(nullptr, wmPath, sizeof(wmPath) / sizeof(wmPath[0])) == 0) {
- log.Write(L"Failed to get path of winmute");
+ log.LogError(L"Failed to get path of winmute");
} else {
DWORD regError = RegSetKeyValueW(
hRunKey,
wmPath,
(lstrlen(wmPath) + 1) * sizeof(wchar_t));
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegSetKeyValue", regError);
+ ShowWindowsError(L"RegSetKeyValue", regError);
}
}
} else {
DWORD regError = RegDeleteKeyValueW(hRunKey, nullptr, LX_SYSTEMS_AUTOSTART_KEY);
if (regError != ERROR_SUCCESS && regError != ERROR_FILE_NOT_FOUND) {
- PrintWindowsError(L"RegDeleteKeyValue", regError);
+ ShowWindowsError(L"RegDeleteKeyValue", regError);
}
}
RegCloseKey(hRunKey);
&size);
if (regError != ERROR_SUCCESS) {
if (regError != ERROR_FILE_NOT_FOUND) {
- PrintWindowsError(L"RegQueryValueExW", regError);
+ ShowWindowsError(L"RegQueryValueExW", regError);
WMLog &log = WMLog::GetInstance();
- log.Write(L"[Registry] Failed to query value for key \"%s\"", keyStr);
+ log.LogError(L"[Registry] Failed to query value for key \"%s\"", keyStr);
}
return GetDefaultSetting(key);
}
reinterpret_cast<BYTE*>(&value),
sizeof(DWORD));
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegSetValueExW", regError);
+ ShowWindowsError(L"RegSetValueExW", regError);
return false;
}
strValue,
strLen);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegSetValueExW", regError);
+ ShowWindowsError(L"RegSetValueExW", regError);
return false;
}
if (regError == ERROR_NO_MORE_ITEMS) {
break;
} else if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegEnumValue", regError);
+ ShowWindowsError(L"RegEnumValue", regError);
return false;
} else {
regError = RegDeleteValue(hWifiKey_, valueName);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegDeleteValue", regError);
+ ShowWindowsError(L"RegDeleteValue", regError);
return false;
}
}
reinterpret_cast<const BYTE*>(v.c_str()),
static_cast<DWORD>(v.length() + 1) * sizeof(wchar_t));
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegSetValueEx", regError);
+ ShowWindowsError(L"RegSetValueEx", regError);
return false;
}
}
if (regError == ERROR_NO_MORE_ITEMS) {
break;
} else if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegEnumValue", regError);
+ ShowWindowsError(L"RegEnumValue", regError);
return {};
} else {
networks.push_back(dataBuf);
if (regError == ERROR_NO_MORE_ITEMS) {
break;
} else if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegEnumValue", regError);
+ ShowWindowsError(L"RegEnumValue", regError);
return false;
} else {
regError = RegDeleteValue(hBluetoothKey_, valueName);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegDeleteValue", regError);
+ ShowWindowsError(L"RegDeleteValue", regError);
return false;
}
}
reinterpret_cast<const BYTE*>(v.c_str()),
static_cast<DWORD>(v.length() + 1) * sizeof(wchar_t));
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegSetValueEx", regError);
+ ShowWindowsError(L"RegSetValueEx", regError);
return false;
}
}
if (regError == ERROR_NO_MORE_ITEMS) {
break;
} else if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegEnumValue", regError);
+ ShowWindowsError(L"RegEnumValue", regError);
return {};
} else {
devices.push_back(dataBuf);
if (regError == ERROR_NO_MORE_ITEMS) {
break;
} else if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegEnumValue", regError);
+ ShowWindowsError(L"RegEnumValue", regError);
return {};
} else {
devices.push_back(dataBuf);
if (regError == ERROR_NO_MORE_ITEMS) {
break;
} else if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegEnumValue", regError);
+ ShowWindowsError(L"RegEnumValue", regError);
return false;
} else {
regError = RegDeleteValue(hAudioEndpointsKey_, valueName);
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegDeleteValue", regError);
+ ShowWindowsError(L"RegDeleteValue", regError);
return false;
}
}
reinterpret_cast<const BYTE *>(v.c_str()),
static_cast<DWORD>(v.length() + 1) * sizeof(wchar_t));
if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegSetValueEx", regError);
+ ShowWindowsError(L"RegSetValueEx", regError);
return false;
}
}
if (regError == ERROR_NO_MORE_ITEMS) {
break;
} else if (regError != ERROR_SUCCESS) {
- PrintWindowsError(L"RegEnumValue", regError);
+ ShowWindowsError(L"RegEnumValue", regError);
return {};
} else {
devices.push_back(dataBuf);
, LOGGING_ENABLED
, APP_LANGUAGE
, CHECK_FOR_UPDATE
+ , CHECK_FOR_BETA_UPDATE
};
class WMSettings {
WMi18n::~WMi18n() noexcept
{
- UnloadLanguage();
}
WMi18n& WMi18n::GetInstance()
{
wchar_t wmPath[MAX_PATH + 1]{ 0 };
if (GetModuleFileNameW(nullptr, wmPath, MAX_PATH) <= 0) {
- WMLog::GetInstance().WriteWindowsError(L"GetModuleFileNameW", GetLastError());
+ WMLog::GetInstance().LogWinError(L"GetModuleFileNameW", GetLastError());
return std::nullopt;
}
fs::path langPath = wmPath;
langDlls.push_back(langMod);
}
} catch (const nlohmann::json::parse_error &pe) {
- WMLog::GetInstance().Write(L"Failed to parse language file \"%ls\": %S", wfd.cFileName, pe.what());
+ WMLog::GetInstance().LogError(L"Failed to parse language file \"%ls\": %S", wfd.cFileName, pe.what());
}
} while (FindNextFileW(hFindFile, &wfd));
}
const fs::path loadFilePath{ fileName};
*langFilePath /= loadFilePath.filename(); // Sanitize
if (!fs::exists(*langFilePath)) {
- log.Write(L"Language module \"%ls\" does not exist", langFilePath->c_str());
+ log.LogError(L"Language module \"%ls\" does not exist", langFilePath->c_str());
return false;
}
try {
TranslationMap translations_temp;
for (auto it = json_data.begin(); it != json_data.end(); ++it) {
if (it->is_structured()) {
- log.Write(L"Language module \"%ls\" has nested elements", langFilePath->c_str());
+ log.LogError(L"Language module \"%ls\" has nested elements", langFilePath->c_str());
return false;
}
const auto value = ConvertStringToWideString(it.value());
if (value == L"") {
- log.Write(L"Unable to convert language element \"%S\"", it.key().c_str());
+ log.LogError(L"Unable to convert language element \"%S\"", it.key().c_str());
return false;
}
if (translations_temp.contains(it.key())) {
- log.Write(L"Double entry for language key \"%S\" found.", it.key().c_str());
+ log.LogError(L"Double entry for language key \"%S\" found.", it.key().c_str());
return false;
}
translations_temp[it.key()] = value;
}
strings = std::move(translations_temp);
} catch (const nlohmann::json::parse_error &pe) {
- WMLog::GetInstance().Write(
+ log.LogError(
L"Failed to parse language file \"%ls\": %S",
langFilePath->filename().c_str(),
pe.what());
TranslationMap new_lang;
if (!LoadLanguage(fileName, new_lang)) {
- WMLog::GetInstance().Write(L"Failed to load language \"%ls\"", fileName.c_str());
+ WMLog::GetInstance().LogError(L"Failed to load language \"%ls\"", fileName.c_str());
return false;
} else {
UnloadLanguage();
void WMi18n::UnloadLanguage()
{
- if (langMutex_.try_lock()) {
- langMutex_.unlock();
- throw "Lock was not acquired before unloading the language";
- }
loadedLang_.clear();
}
{
const auto text = GetTranslationW(textId);
if (!SetDlgItemTextW(hWnd, dlgItem, text.c_str())) {
- WMLog::GetInstance().WriteWindowsError(L"SetDlgItemTextW", GetLastError());
+ WMLog::GetInstance().LogWinError(L"SetDlgItemTextW", GetLastError());
return false;
}
return true;
{
const auto text = GetTranslationW(textId);
if (!SetWindowTextW(hItem, text.c_str())) {
- WMLog::GetInstance().WriteWindowsError(L"SetDlgItemTextW", GetLastError());
+ WMLog::GetInstance().LogWinError(L"SetDlgItemTextW", GetLastError());
return false;
}
return true;
DWORD wlErr = WlanOpenHandle(vers, nullptr, &vers, &wlanHandle_);
if (wlErr != ERROR_SUCCESS) {
if (wlErr != ERROR_SERVICE_NOT_ACTIVE) {
- PrintWindowsError(L"WlanOpenHandle", wlErr);
+ ShowWindowsError(L"WlanOpenHandle", wlErr);
}
} else {
wlErr = WlanRegisterNotification(
wlanHandle_, WLAN_NOTIFICATION_SOURCE_ACM, TRUE,
::WlanNotificationCallback, this, nullptr, nullptr);
if (wlErr != ERROR_SUCCESS) {
- PrintWindowsError(L"WlanOpenHandle", wlErr);
+ ShowWindowsError(L"WlanOpenHandle", wlErr);
WlanCloseHandle(wlanHandle_, nullptr);
} else {
initialized_ = true;
PWLAN_INTERFACE_INFO_LIST ifList;
DWORD wlanErr = WlanEnumInterfaces(wlanHandle_, nullptr, &ifList);
if (wlanErr != ERROR_SUCCESS) {
- PrintWindowsError(L"WlanEnumInterfaces", wlanErr);
+ ShowWindowsError(L"WlanEnumInterfaces", wlanErr);
} else {
for (; ifList->dwIndex < ifList->dwNumberOfItems; ++ifList->dwIndex) {
PWLAN_AVAILABLE_NETWORK_LIST availList = nullptr;
nullptr,
&availList);
if (wlanErr != ERROR_SUCCESS) {
- PrintWindowsError(L"WlanGetAvailableNetworkList", wlanErr);
+ ShowWindowsError(L"WlanGetAvailableNetworkList", wlanErr);
} else {
for (; availList->dwIndex < availList->dwNumberOfItems; ++availList->dwIndex) {
const PWLAN_AVAILABLE_NETWORK net = &availList->Network[availList->dwIndex];
initComCtrl.dwSize = sizeof(INITCOMMONCONTROLSEX);
initComCtrl.dwICC = ICC_LINK_CLASS;
if (InitCommonControlsEx(&initComCtrl) == FALSE) {
- WMLog::GetInstance().WriteWindowsError(L"InitCommonControlsEx", GetLastError());
+ WMLog::GetInstance().LogWinError(L"InitCommonControlsEx", GetLastError());
return FALSE;
} else if (CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED) != S_OK) {
- WMLog::GetInstance().WriteWindowsError(L"CoInitializeEx", GetLastError());
+ WMLog::GetInstance().LogWinError(L"CoInitializeEx", GetLastError());
return FALSE;
}
return TRUE;
wc.lpszClassName = WINMUTE_CLASS_NAME;
if (!RegisterClassExW(&wc)) {
- PrintWindowsError(L"RegisterClass");
+ ShowWindowsError(L"RegisterClass");
return false;
}
return true;
hWnd_ = CreateWindowExW(WS_EX_TOOLWINDOW, WINMUTE_CLASS_NAME, PROGRAM_NAME,
WS_POPUP, 0, 0, 0, 0, nullptr, 0, hglobInstance, this);
if (hWnd_ == nullptr) {
- PrintWindowsError(L"CreateWindowEx");
+ ShowWindowsError(L"CreateWindowEx");
return false;
}
return true;
if (hTrayMenu_ == nullptr) {
hTrayMenu_ = LoadMenuW(hglobInstance, MAKEINTRESOURCE(IDR_TRAYMENU));
if (hTrayMenu_ == nullptr) {
- PrintWindowsError(L"LoadMenu");
+ ShowWindowsError(L"LoadMenu");
return false;
}
}
#else
WMLog::GetInstance().SetEnabled(settings_.QueryValue(SettingsKey::LOGGING_ENABLED));
#endif
- log.Write(L"Starting new session...");
+ log.LogInfo(L"Starting new session...");
if (!RegisterWindowClass() || !InitWindow()) {
return false;
}
if (!WTSRegisterSessionNotification(hWnd_, NOTIFY_FOR_THIS_SESSION)) {
- PrintWindowsError(L"WTSRegisterSessionNotification");
+ ShowWindowsError(L"WTSRegisterSessionNotification");
return false;
}
if (!RegisterPowerSettingNotification(hWnd_, &GUID_CONSOLE_DISPLAY_STATE, 0)) {
- PrintWindowsError(L"RegisterPowerSettingNotification");
+ ShowWindowsError(L"RegisterPowerSettingNotification");
return false;
}
hTrayIcon_ = LoadIconW(hglobInstance, MAKEINTRESOURCE(IDI_APP));
if (hTrayIcon_ == nullptr) {
- PrintWindowsError(_T("LoadIcon"));
+ ShowWindowsError(_T("LoadIcon"));
return false;
}
trayIcon_.Init(hWnd_, 0, hTrayIcon_, L"WinMute", true);
quietHours_.Init(hWnd_, settings_);
- log.Write(L"WinMute initialized");
+ log.LogInfo(L"WinMute initialized");
if (settings_.QueryValue(SettingsKey::MUTE_ON_RDP)
&& IsCurrentSessionRemoteable()) {
if (log.IsEnabled()) {
std::wstring versionNumber;
GetWinMuteVersion(versionNumber);
- log.Write(L"Starting WinMute %s", versionNumber.c_str());
- log.Write(L"Loading settings:");
- log.Write(L"\tRestore volume: %s", settings_.QueryValue(SettingsKey::RESTORE_AUDIO) ? L"Yes" : L"No");
- log.Write(L"\tMute delay: %d", settings_.QueryValue(SettingsKey::MUTE_DELAY));
- log.Write(L"\tMute on lock: %s", settings_.QueryValue(SettingsKey::MUTE_ON_LOCK) ? L"Yes" : L"No");
- log.Write(L"\tMute on display standby: %s", settings_.QueryValue(SettingsKey::MUTE_ON_DISPLAYSTANDBY) ? L"Yes" : L"No");
- log.Write(L"\tMute on logout: %s", settings_.QueryValue(SettingsKey::MUTE_ON_LOGOUT) ? L"Yes" : L"No");
- log.Write(L"\tMute on suspend: %s", settings_.QueryValue(SettingsKey::MUTE_ON_SUSPEND) ? L"Yes" : L"No");
- log.Write(L"\tMute on shutdown: %s", settings_.QueryValue(SettingsKey::MUTE_ON_SHUTDOWN) ? L"Yes" : L"No");
- log.Write(L"\tShow notifications: %s", settings_.QueryValue(SettingsKey::NOTIFICATIONS_ENABLED) ? L"Yes" : L"No");
- log.Write(L"\tMute on bluetooth: %s", settings_.QueryValue(SettingsKey::MUTE_ON_BLUETOOTH) ? L"Yes" : L"No");
- log.Write(L"\t\tUse devicelist: %s", settings_.QueryValue(SettingsKey::MUTE_ON_BLUETOOTH_DEVICELIST) ? L"Yes" : L"No");
- log.Write(L"\tMute on WLAN: %s", settings_.QueryValue(SettingsKey::MUTE_ON_WLAN) ? L"Yes" : L"No");
- log.Write(L"\t\tUse allowlist: %s", settings_.QueryValue(SettingsKey::MUTE_ON_WLAN_ALLOWLIST) ? L"Yes" : L"No");
- log.Write(L"\tMute specific endpoints only: %s", settings_.QueryValue(SettingsKey::MUTE_INDIVIDUAL_ENDPOINTS) ? L"Yes" : L"No");
+ log.LogInfo(L"Starting WinMute %s", versionNumber.c_str());
+ log.LogInfo(L"Loading settings:");
+ log.LogInfo(L"Check for updates: %s", settings_.QueryValue(SettingsKey::CHECK_FOR_UPDATE) ? L"Yes" : L"No");
+ log.LogInfo(L"\tCheck for beta updates: %s", settings_.QueryValue(SettingsKey::CHECK_FOR_BETA_UPDATE) ? L"Yes" : L"No");
+ log.LogInfo(L"\tRestore volume: %s", settings_.QueryValue(SettingsKey::RESTORE_AUDIO) ? L"Yes" : L"No");
+ log.LogInfo(L"\tMute delay: %d", settings_.QueryValue(SettingsKey::MUTE_DELAY));
+ log.LogInfo(L"\tMute on lock: %s", settings_.QueryValue(SettingsKey::MUTE_ON_LOCK) ? L"Yes" : L"No");
+ log.LogInfo(L"\tMute on display standby: %s", settings_.QueryValue(SettingsKey::MUTE_ON_DISPLAYSTANDBY) ? L"Yes" : L"No");
+ log.LogInfo(L"\tMute on logout: %s", settings_.QueryValue(SettingsKey::MUTE_ON_LOGOUT) ? L"Yes" : L"No");
+ log.LogInfo(L"\tMute on suspend: %s", settings_.QueryValue(SettingsKey::MUTE_ON_SUSPEND) ? L"Yes" : L"No");
+ log.LogInfo(L"\tMute on shutdown: %s", settings_.QueryValue(SettingsKey::MUTE_ON_SHUTDOWN) ? L"Yes" : L"No");
+ log.LogInfo(L"\tShow notifications: %s", settings_.QueryValue(SettingsKey::NOTIFICATIONS_ENABLED) ? L"Yes" : L"No");
+ log.LogInfo(L"\tMute on bluetooth: %s", settings_.QueryValue(SettingsKey::MUTE_ON_BLUETOOTH) ? L"Yes" : L"No");
+ log.LogInfo(L"\t\tUse devicelist: %s", settings_.QueryValue(SettingsKey::MUTE_ON_BLUETOOTH_DEVICELIST) ? L"Yes" : L"No");
+ log.LogInfo(L"\tMute on WLAN: %s", settings_.QueryValue(SettingsKey::MUTE_ON_WLAN) ? L"Yes" : L"No");
+ log.LogInfo(L"\t\tUse allowlist: %s", settings_.QueryValue(SettingsKey::MUTE_ON_WLAN_ALLOWLIST) ? L"Yes" : L"No");
+ log.LogInfo(L"\tMute specific endpoints only: %s", settings_.QueryValue(SettingsKey::MUTE_INDIVIDUAL_ENDPOINTS) ? L"Yes" : L"No");
}
if (!settings_.QueryValue(SettingsKey::MUTE_INDIVIDUAL_ENDPOINTS)) {
void WinMute::CheckForUpdatesAsync(std::unique_ptr<UpdateChecker> updateChecker)
{
+ const bool betaUpdates = settings_.QueryValue(SettingsKey::CHECK_FOR_BETA_UPDATE) != 0;
if (!updateChecker) {
return;
}
trayIcon_.ShowPopup(
i18n_.GetTranslationW("popup.error.update-check-failed.title"),
i18n_.GetTranslationW("popup.error.update-check-failed.text"));
- } else if (updateInfo_.shouldUpdate) {
+ } else if (updateInfo_.beta.shouldUpdate && betaUpdates) {
+ const std::wstring popupTitle = std::vformat(
+ i18n_.GetTranslationW("popup.update-available-beta.title"),
+ std::make_wformat_args(updateInfo_.beta.version));
+ const std::wstring popupText = std::vformat(
+ i18n_.GetTranslationW("popup.update-available-beta.text"),
+ std::make_wformat_args(updateInfo_.currentVersion));
+ trayIcon_.ShowPopup(popupTitle, popupText, WM_WINMUTE_UPDATE_POPUP);
+ } else if (updateInfo_.beta.shouldUpdate) {
const std::wstring popupTitle = std::vformat(
i18n_.GetTranslationW("popup.update-available.title"),
- std::make_wformat_args(updateInfo_.newVersion));
+ std::make_wformat_args(updateInfo_.beta.version));
const std::wstring popupText = std::vformat(
i18n_.GetTranslationW("popup.update-available.text"),
std::make_wformat_args(updateInfo_.currentVersion));
LRESULT WinMute::OnUpdatePopup(HWND hWnd, WPARAM, LPARAM lParam)
{
if (lParam == NIN_BALLOONUSERCLICK) {
- ShellExecuteW(
- hWnd, L"open", updateInfo_.versionPageUrl.c_str(),
- nullptr, nullptr, SW_SHOW);
+ const bool betaUpdates = settings_.QueryValue(SettingsKey::CHECK_FOR_BETA_UPDATE) != 0;
+ if (betaUpdates && updateInfo_.beta.shouldUpdate) {
+ ShellExecuteW(
+ hWnd, L"open", updateInfo_.beta.downloadUrl.c_str(),
+ nullptr, nullptr, SW_SHOW);
+ } else if (updateInfo_.stable.shouldUpdate) {
+ ShellExecuteW(
+ hWnd, L"open", updateInfo_.stable.downloadUrl.c_str(),
+ nullptr, nullptr, SW_SHOW);
+ }
}
return 0;
}
CAPTION "About WinMute"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
- ICON IDI_APP,IDC_STATIC,13,7,20,20,SS_CENTERIMAGE
- LTEXT "WinMute <VersionNumber>",IDC_ABOUT_TITLE,41,7,193,23
+ ICON IDI_APP,IDC_STATIC,13,7,21,20,SS_CENTERIMAGE
+ LTEXT "WinMute <VersionNumber>",IDC_ABOUT_TITLE,45,7,193,23
CONTROL "",IDC_ABOUT_TAB,"SysTabControl32",0x0,7,34,299,202
PUSHBUTTON "OK",IDOK,242,246,64,16
END
CAPTION "Settings"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
+ CONTROL "",IDC_SETTINGS_TAB,"SysTabControl32",0x0,7,7,255,238
DEFPUSHBUTTON "OK",IDOK,158,246,50,14
PUSHBUTTON "Cancel",IDCANCEL,212,246,50,14
- CONTROL "",IDC_SETTINGS_TAB,"SysTabControl32",0x0,7,7,255,238
END
IDD_SETTINGS_GENERAL DIALOGEX 0, 0, 233, 179
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,34,219,17
CONTROL "Check for updates on startup",IDC_CHECK_FOR_UPDATES_ON_STARTUP,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,50,219,17
- CONTROL "Enable logging",IDC_ENABLELOGGING,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,74,219,15
- PUSHBUTTON "Open log file...",IDC_OPENLOG,22,90,104,16
- LTEXT "[log file path]",IDC_LOGFILEPATH,23,110,203,27
+ CONTROL "Also check for beta-updates",IDC_CHECK_FOR_BETA_UPDATES,
+ "Button",BS_AUTOCHECKBOX | WS_TABSTOP,27,65,199,17
+ CONTROL "Enable logging",IDC_ENABLELOGGING,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,98,219,15
+ PUSHBUTTON "Open log file...",IDC_OPENLOG,22,114,104,16
+ LTEXT "[log file path]",IDC_LOGFILEPATH,23,134,203,27
END
IDD_SETTINGS_QUIETHOURS DIALOGEX 0, 0, 246, 198
GROUPBOX "General",IDC_GROUP_GENERAL,7,7,228,61
CONTROL "Show mute event notifications",IDC_SHOWNOTIFICATIONS,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,15,219,18
+ CONTROL "Manage audio endpoints individually",IDC_MANAGE_AUDIO_ENDPOINTS_INDIVIDUALLY,
+ "Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,28,219,18
+ PUSHBUTTON "Manage endpoints...",IDC_MANAGE_ENDPOINTS,26,46,97,15
GROUPBOX "Mute with volume restore, when...",IDC_GROUP_MUTE_WITH_RESTORE,7,71,228,71
CONTROL "... the workstation is locked.",IDC_MUTE_WHEN_WS_LOCKED,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,20,83,207,10
CONTROL "... the screen turns off.",IDC_MUTE_WHEN_SCREEN_OFF,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,20,97,205,10
CONTROL "Restore volume afterwards.",IDC_RESTOREVOLUME,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,112,210,10
+ EDITTEXT IDC_MUTEDELAY,13,124,30,13,ES_RIGHT | ES_AUTOHSCROLL | ES_NUMBER
+ LTEXT "seconds delay before muting.",IDC_DELAY_MUTING_LABEL,47,127,169,8
GROUPBOX "Mute without volume restore, when...",IDC_GROUP_MUTE_WITHOUT_RESTORE,7,145,228,67
CONTROL "... the computer shuts down.",IDC_MUTE_WHEN_SHUTDOWN,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,20,156,207,10
CONTROL "... you log out.",IDC_MUTE_WHEN_LOGOUT,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,20,184,207,10
CONTROL "... when WinMute is started within a RDP session.",IDC_MUTE_WHEN_RDP_SESSION,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,20,198,208,10
- CONTROL "Manage audio endpoints individually",IDC_MANAGE_AUDIO_ENDPOINTS_INDIVIDUALLY,
- "Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,28,219,18
- PUSHBUTTON "Manage endpoints...",IDC_MANAGE_ENDPOINTS,26,46,97,15
- LTEXT "seconds delay before muting.",IDC_DELAY_MUTING_LABEL,47,127,169,8
- EDITTEXT IDC_MUTEDELAY,13,124,30,13,ES_RIGHT | ES_AUTOHSCROLL | ES_NUMBER
END
IDD_SETTINGS_WIFI DIALOGEX 0, 0, 242, 216
STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
- LISTBOX IDC_WIFI_LIST,7,88,166,121,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
- PUSHBUTTON "Add",IDC_WIFI_ADD,179,87,56,16
- PUSHBUTTON "Edit",IDC_WIFI_EDIT,179,106,56,16
- PUSHBUTTON "Remove",IDC_WIFI_REMOVE,179,125,56,16
- PUSHBUTTON "Remove all",IDC_WIFI_REMOVEALL,179,193,56,16
- CONTROL "Enable WLAN based muting",IDC_ENABLE_WIFI_MUTE,"Button",BS_AUTOCHECKBOX | BS_MULTILINE | WS_TABSTOP,7,44,228,14
LTEXT "Description\nDescription\nDescription\nDescription",IDC_WIFI_INTRO,7,7,228,37
+ CONTROL "Enable WLAN based muting",IDC_ENABLE_WIFI_MUTE,"Button",BS_AUTOCHECKBOX | BS_MULTILINE | WS_TABSTOP,7,44,228,14
CONTROL "Mute if connected WLAN is in list",IDC_WLAN_LIST_IS_ALLOWLIST,
"Button",BS_AUTORADIOBUTTON,17,60,209,10
CONTROL "Mute if connected WLAN is not in list",IDC_WLAN_LIST_IS_BLOCKLIST,
"Button",BS_AUTORADIOBUTTON,17,73,207,10
+ LISTBOX IDC_WIFI_LIST,7,88,166,121,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+ PUSHBUTTON "Add",IDC_WIFI_ADD,179,87,56,16
+ PUSHBUTTON "Edit",IDC_WIFI_EDIT,179,106,56,16
+ PUSHBUTTON "Remove",IDC_WIFI_REMOVE,179,125,56,16
+ PUSHBUTTON "Remove all",IDC_WIFI_REMOVEALL,179,193,56,16
END
IDD_SETTINGS_WIFI_ADD DIALOGEX 0, 0, 201, 62
CAPTION "Add WiFi"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
- DEFPUSHBUTTON "Save",IDOK,91,41,50,14
- PUSHBUTTON "Cancel",IDCANCEL,144,41,50,14
LTEXT "SSID/WiFi Name:",IDC_WIFI_NAME_LABEL,7,7,62,14
EDITTEXT IDC_WIFI_NAME,7,20,187,16,ES_AUTOHSCROLL
+ DEFPUSHBUTTON "Save",IDOK,91,41,50,14
+ PUSHBUTTON "Cancel",IDCANCEL,144,41,50,14
END
IDD_SETTINGS_BLUETOOTH DIALOGEX 0, 0, 244, 222
EXSTYLE WS_EX_CONTROLPARENT
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
+ LTEXT "Description\nDescription\nDescription\nDescription\nDescription\nDescription",IDC_BLUETOOTH_DESCRIPTION_LABEL,7,7,230,51
+ CONTROL "Enable Bluetooth based muting",IDC_ENABLE_BLUETOOTH_MUTE,
+ "Button",BS_AUTOCHECKBOX | BS_MULTILINE | WS_TABSTOP,7,62,228,14
+ CONTROL "Enable only for these devices:",IDC_ENABLE_BLUETOOTH_MUTE_DEVICE_LIST,
+ "Button",BS_AUTOCHECKBOX | BS_TOP | BS_MULTILINE | WS_TABSTOP,20,79,215,12
LISTBOX IDC_BLUETOOTH_LIST,7,95,168,120,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
PUSHBUTTON "Add",IDC_BLUETOOTH_ADD,181,94,56,16
PUSHBUTTON "Edit",IDC_BLUETOOTH_EDIT,181,113,56,16
PUSHBUTTON "Remove",IDC_BLUETOOTH_REMOVE,181,132,56,16
PUSHBUTTON "Remove all",IDC_BLUETOOTH_REMOVEALL,181,199,56,16
- CONTROL "Enable Bluetooth based muting",IDC_ENABLE_BLUETOOTH_MUTE,
- "Button",BS_AUTOCHECKBOX | BS_MULTILINE | WS_TABSTOP,7,62,228,14
- CONTROL "Enable only for these devices:",IDC_ENABLE_BLUETOOTH_MUTE_DEVICE_LIST,
- "Button",BS_AUTOCHECKBOX | BS_TOP | BS_MULTILINE | WS_TABSTOP,20,79,215,12
- LTEXT "Description\nDescription\nDescription\nDescription\nDescription\nDescription",IDC_BLUETOOTH_DESCRIPTION_LABEL,7,7,230,51
END
IDD_SETTINGS_BLUETOOTH_ADD DIALOGEX 0, 0, 201, 62
CAPTION "Add Bluetooth device"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
- DEFPUSHBUTTON "Save",IDOK,91,41,50,14
- PUSHBUTTON "Cancel",IDCANCEL,144,41,50,14
LTEXT "Bluetooth device name:",IDC_LABEL_BT_DEVICE_NAME,7,7,187,14
COMBOBOX IDC_BT_DEVICE_NAME,7,22,187,17,CBS_DROPDOWN | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+ DEFPUSHBUTTON "Save",IDOK,91,41,50,14
+ PUSHBUTTON "Cancel",IDCANCEL,144,41,50,14
END
IDD_MANAGE_ENDPOINTS DIALOGEX 0, 0, 241, 200
CAPTION "Manage Endpoints"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
- DEFPUSHBUTTON "Save",IDOK,133,179,50,14
- PUSHBUTTON "Cancel",IDCANCEL,184,179,50,14
- LISTBOX IDC_ENDPOINT_LIST,13,60,156,110,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
- PUSHBUTTON "Add",IDC_ENDPOINT_ADD,175,60,56,16
- PUSHBUTTON "Edit",IDC_ENDPOINT_EDIT,175,78,56,16
- PUSHBUTTON "Remove",IDC_ENDPOINT_REMOVE,175,97,56,16
- PUSHBUTTON "Remove all",IDC_ENDPOINT_REMOVEALL,178,155,56,16
+ GROUPBOX "List behaviour",IDC_GROUP_LIST_BEHAVIOUR,7,7,227,41
CONTROL "Mute only listed endpoints",IDC_ENDPOINT_LIST_IS_ALLOWLIST,
"Button",BS_AUTORADIOBUTTON,13,19,209,10
CONTROL "Mute all but the listed endpoints",IDC_ENDPOINT_LIST_IS_BLOCKLIST,
"Button",BS_AUTORADIOBUTTON,13,32,207,10
- GROUPBOX "List behaviour",IDC_GROUP_LIST_BEHAVIOUR,7,7,227,41
GROUPBOX "Endpoints",IDC_GROUP_ENDPOINTS,7,48,227,128
+ LISTBOX IDC_ENDPOINT_LIST,13,60,156,110,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
+ PUSHBUTTON "Add",IDC_ENDPOINT_ADD,175,60,56,16
+ PUSHBUTTON "Edit",IDC_ENDPOINT_EDIT,175,78,56,16
+ PUSHBUTTON "Remove",IDC_ENDPOINT_REMOVE,175,97,56,16
+ PUSHBUTTON "Remove all",IDC_ENDPOINT_REMOVEALL,178,155,56,16
+ DEFPUSHBUTTON "Save",IDOK,133,179,50,14
+ PUSHBUTTON "Cancel",IDCANCEL,184,179,50,14
END
IDD_MANAGE_ENDPOINTS_ADD DIALOGEX 0, 0, 201, 62
CAPTION "Add Endpoint"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
- DEFPUSHBUTTON "Save",IDOK,91,41,50,14
- PUSHBUTTON "Cancel",IDCANCEL,144,41,50,14
LTEXT "Endpoint name:",IDC_ENDPOINT_NAME_LABEL,7,7,187,14
COMBOBOX IDC_ENDPOINT_NAME,7,22,187,17,CBS_DROPDOWN | CBS_SORT | WS_VSCROLL | WS_TABSTOP
+ DEFPUSHBUTTON "Save",IDOK,91,41,50,14
+ PUSHBUTTON "Cancel",IDCANCEL,144,41,50,14
END
// =============================================================================
// Utility
-void PrintWindowsError(const wchar_t *functionName, DWORD lastError = -1);
+void ShowWindowsError(const wchar_t *functionName, DWORD lastError = -1);
bool GetWinMuteVersion(std::wstring &versNumber);
std::wstring ConvertStringToWideString(const std::string &ansiString);
#define IDC_ENABLE_WIFI_MUTE 1011
#define IDC_ENABLELOGGING 1012
#define IDC_CHECK3 1013
-#define IDC_RUNONSTARTUP2 1013
#define IDC_CHECK_FOR_UPDATES_ON_STARTUP 1013
#define IDC_OPENLOG 1014
#define IDC_LICENSETEXT 1015
+#define IDC_CHECK_FOR_UPDATES_ON_STARTUP2 1015
+#define IDC_CHECK_FOR_BETA_UPDATES 1015
#define IDC_ABOUT_TAB 1016
#define IDC_ABOUTTEXT 1019
#define IDC_TITLE 1020
projects / winmute.git / commitdiff