Cool_Tools/ExplorerPatcher
1
0
Fork 0
mirror of https://github.com/valinet/ExplorerPatcher.git synced 2024-11-13 18:50:46 +01:00
Code Releases Wiki Activity
master
ExplorerPatcher/ep_weather_host/ep_weather_host.c
Amrsatrio c89705e5e2 Fixed some function calls
2024-09-01 17:54:32 +07:00

1964 lines
78 KiB
C
Raw Permalink Blame History

#include "ep_weather_host.h"
#include "ep_weather_provider_google_html.h"
#include "ep_weather_provider_google_script.h"
#include "ep_weather_error_html.h"
#include <stdio.h>
RTL_OSVERSIONINFOW global_rovi;
DWORD32 global_ubr;
SYSTEMTIME stLastUpdate;
HRESULT STDMETHODCALLTYPE epw_Weather_static_Stub(void* _this)
{
return S_OK;
}
ULONG STDMETHODCALLTYPE epw_Weather_static_AddRefRelease(void* _this)
{
return 1;
}
static DWORD epw_Weather_ReleaseBecauseClientDiedThread(EPWeather* _this)
{
Sleep(5000);
while (_this->lpVtbl->Release(_this));
return 0;
}
static void epw_Weather_SetTextScaleFactorFromRegistry(EPWeather* _this, HKEY hKey, BOOL bRefresh)
{
DWORD dwTextScaleFactor = 100, dwSize = sizeof(DWORD);
if (_this->SHRegGetValueFromHKCUHKLMFunc && _this->SHRegGetValueFromHKCUHKLMFunc(L"SOFTWARE\\Microsoft\\Accessibility", L"TextScaleFactor", SRRF_RT_REG_DWORD, NULL, &dwTextScaleFactor, (LPDWORD)(&dwSize)) != ERROR_SUCCESS)
{
dwTextScaleFactor = 100;
}
if (InterlockedExchange64(&_this->dwTextScaleFactor, dwTextScaleFactor) == dwTextScaleFactor)
{
bRefresh = FALSE;
}
if (hKey == HKEY_CURRENT_USER)
{
if (RegCreateKeyExW(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Accessibility", 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WOW64_64KEY | KEY_WRITE, NULL, &_this->hKCUAccessibility, NULL) == ERROR_SUCCESS)
{
RegNotifyChangeKeyValue(_this->hKCUAccessibility, FALSE, REG_NOTIFY_CHANGE_LAST_SET, _this->hSignalOnAccessibilitySettingsChangedFromHKCU, TRUE);
}
}
else if (hKey == HKEY_LOCAL_MACHINE)
{
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Accessibility", REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WOW64_64KEY | KEY_WRITE, &_this->hKLMAccessibility))
{
RegNotifyChangeKeyValue(_this->hKLMAccessibility, FALSE, REG_NOTIFY_CHANGE_LAST_SET, _this->hSignalOnAccessibilitySettingsChangedFromHKLM, TRUE);
}
}
if (bRefresh)
{
_ep_Weather_StartResize(_this);
}
}
HRESULT STDMETHODCALLTYPE INetworkListManagerEvents_QueryInterface(GenericObjectWithThis* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_INetworkListManagerEvents) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE INetworkListManagerEvents_ConnectivityChanged(GenericObjectWithThis* _this2, NLM_CONNECTIVITY newConnectivity)
{
EPWeather* _this = _this2->_this; // GetWindowLongPtrW(FindWindowW(_T(EPW_WEATHER_CLASSNAME), NULL), GWLP_USERDATA);
if (_this)
{
if ((newConnectivity & (NLM_CONNECTIVITY_IPV4_INTERNET | NLM_CONNECTIVITY_IPV6_INTERNET)) != 0)
{
printf("[Network Events for 0x%p] Internet connection status is: Available.\n", _this);
LONG64 dwUpdateSchedule = InterlockedAdd64(&_this->dwUpdateSchedule, 0);
SetTimer(_this->hWnd, EP_WEATHER_TIMER_REQUEST_REFRESH, EP_WEATHER_TIMER_REQUEST_REFRESH_DELAY, NULL);
//PostMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
SetTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH, dwUpdateSchedule, NULL);
printf("[Network Events for 0x%p] Reinstalled refresh timer.\n", _this);
}
else
{
printf("[Network Events for 0x%p] Internet connection status is: Offline.\n", _this);
KillTimer(_this->hWnd, EP_WEATHER_TIMER_REQUEST_REFRESH);
KillTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH);
printf("[Network Events for 0x%p] Killed refresh timer.\n", _this);
}
}
return S_OK;
}
GenericObjectWithThis* GenericObjectWithThis_MakeAndInitialize(IUnknownVtbl* vtbl, EPWeather* _this, const LPWSTR pName)
{
GenericObjectWithThis* pObj = malloc(sizeof(GenericObjectWithThis));
if (pObj)
{
ULONG cnt = InterlockedIncrement64(&(_this->cbGenericObject));
pObj->lpVtbl = vtbl;
pObj->cbCount = 1;
pObj->pInstance = pObj;
pObj->_this = _this;
pObj->pName = pName;
wprintf(L"[] {%d} Making object { name: \"%s\", _this: 0x%p }\n", cnt, pName, _this);
return pObj;
}
return NULL;
}
ULONG STDMETHODCALLTYPE GenericObjectWithThis_AddRef(GenericObjectWithThis* _this)
{
ULONG cnt = InterlockedIncrement64(&(_this->_this->cbGenericObject));
ULONG value = InterlockedIncrement64(&(_this->cbCount));
wprintf(L"[] {%d} AddRef, new value = %d on { name: \"%s\", _this: 0x%p }\n", cnt, value, _this->pName, _this->_this);
return value;
}
ULONG STDMETHODCALLTYPE GenericObjectWithThis_Release(GenericObjectWithThis* _this)
{
ULONG cnt = InterlockedDecrement64(&(_this->_this->cbGenericObject));
ULONG value = InterlockedDecrement64(&(_this->cbCount));
if (value == 0)
{
wprintf(L"[] {%d} Release with free, new value = %d on { name: \"%s\", _this: 0x%p }\n", cnt, value, _this->pName, _this->_this);
free(_this->pInstance);
return 0;
}
wprintf(L"[] {%d} Release, new value = %d on { name: \"%s\", _this: 0x%p }\n", cnt, value, _this->pName, _this->_this);
return value;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2EnvironmentOptions_QueryInterface(IUnknown* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_ICoreWebView2EnvironmentOptions) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler_QueryInterface(GenericObjectWithThis* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE ICoreWebView2CreateCoreWebView2ControllerCompletedHandler_QueryInterface(GenericObjectWithThis* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_ICoreWebView2CreateCoreWebView2ControllerCompletedHandler) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE ICoreWebView2NavigationStartingEventHandler_QueryInterface(GenericObjectWithThis* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_ICoreWebView2NavigationStartingEventHandler) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE ICoreWebView2NavigationCompletedEventHandler_QueryInterface(GenericObjectWithThis* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_ICoreWebView2NavigationCompletedEventHandler) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE ICoreWebView2PermissionRequestedEventHandler_QueryInterface(GenericObjectWithThis* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_ICoreWebView2PermissionRequestedEventHandler) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE ICoreWebView2CallDevToolsProtocolMethodCompletedHandler_QueryInterface(GenericObjectWithThis* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_ICoreWebView2CallDevToolsProtocolMethodCompletedHandler) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE ICoreWebView2ExecuteScriptCompletedHandler_QueryInterface(GenericObjectWithThis* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_ICoreWebView2ExecuteScriptCompletedHandler) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_get_AdditionalBrowserArguments(ICoreWebView2EnvironmentOptions* _this, LPWSTR* value)
{
*value = CoTaskMemAlloc(82 * sizeof(WCHAR));
if (*value)
{
wcscpy_s(*value, 82, L"--disable-site-isolation-trials --disable-web-security --allow-insecure-localhost");
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_get_Language(ICoreWebView2EnvironmentOptions* _this, LPWSTR* value)
{
*value = CoTaskMemAlloc(6 * sizeof(WCHAR));
if (*value)
{
wcscpy_s(*value, 6, L"en-US");
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_get_TargetCompatibleBrowserVersion(ICoreWebView2EnvironmentOptions* _this, LPWSTR* value)
{
*value = CoTaskMemAlloc(13 * sizeof(WCHAR));
if (*value)
{
wcscpy_s(*value, 13, L"97.0.1072.69");
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_get_AllowSingleSignOnUsingOSPrimaryAccount(ICoreWebView2EnvironmentOptions* _this, BOOL* allow)
{
*allow = TRUE;
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_CreateCoreWebView2EnvironmentCompleted(GenericObjectWithThis* _this, HRESULT hr, ICoreWebView2Environment* pCoreWebView2Environemnt)
{
GenericObjectWithThis* pCoreWebView2CreateCoreWebView2ControllerCompletedHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2CreateCoreWebView2ControllerCompletedHandlerVtbl, _this->_this, L"pCoreWebView2CreateCoreWebView2ControllerCompletedHandler");
if (!pCoreWebView2CreateCoreWebView2ControllerCompletedHandler) return E_FAIL;
HRESULT _hr = pCoreWebView2Environemnt->lpVtbl->CreateCoreWebView2Controller(pCoreWebView2Environemnt, _this->_this->hWnd, pCoreWebView2CreateCoreWebView2ControllerCompletedHandler);
pCoreWebView2CreateCoreWebView2ControllerCompletedHandler->lpVtbl->Release(pCoreWebView2CreateCoreWebView2ControllerCompletedHandler);
return _hr;
}
HRESULT STDMETHODCALLTYPE _epw_Weather_NavigateToError(EPWeather* _this)
{
_ep_Weather_ReboundBrowser(_this, TRUE);
InterlockedExchange64(&_this->bIsNavigatingToError, TRUE);
UINT dpi = GetDpiForWindow(_this->hWnd);
DWORD dwTextScaleFactor = epw_Weather_GetTextScaleFactor(_this);
DWORD dwZoomFactor = epw_Weather_GetZoomFactor(_this);
int ch = MulDiv(MulDiv(MulDiv(EP_WEATHER_HEIGHT_ERROR, dpi, 96), dwTextScaleFactor, 100), dwZoomFactor, 100);
RECT rc;
GetClientRect(_this->hWnd, &rc);
int w = MulDiv(MulDiv(MulDiv(EP_WEATHER_WIDTH, GetDpiForWindow(_this->hWnd), 96), dwTextScaleFactor, 100), dwZoomFactor, 100);
if ((rc.bottom - rc.top != ch) || (rc.right - rc.left != w))
{
RECT rcAdj;
SetRect(&rcAdj, 0, 0, w, ch);
AdjustWindowRectExForDpi(&rcAdj, epw_Weather_GetStyle(_this) & ~WS_OVERLAPPED, epw_Weather_HasMenuBar(_this), epw_Weather_GetExtendedStyle(_this), dpi);
SetWindowPos(_this->hWnd, NULL, 0, 0, rcAdj.right - rcAdj.left, rcAdj.bottom - rcAdj.top, SWP_NOMOVE | SWP_NOSENDCHANGING);
HWND hNotifyWnd = InterlockedAdd64(&_this->hNotifyWnd, 0);
if (hNotifyWnd)
{
InvalidateRect(hNotifyWnd, NULL, TRUE);
}
}
if (_this->pCoreWebView2)
{
LPWSTR wszPageTitle = NULL;
if (SUCCEEDED(_this->pCoreWebView2->lpVtbl->get_DocumentTitle(_this->pCoreWebView2, &wszPageTitle)))
{
BOOL bIsOnErrorPage = !_wcsicmp(wszPageTitle, _T(CLSID_EPWeather_TEXT) L"_ErrorPage");
CoTaskMemFree(wszPageTitle);
if (!bIsOnErrorPage) return _this->pCoreWebView2->lpVtbl->NavigateToString(_this->pCoreWebView2, ep_weather_error_html);
else
{
printf("[Browser] Already on the error page.\n");
return S_OK;
}
}
}
return E_FAIL;
}
HRESULT STDMETHODCALLTYPE _epw_Weather_NavigateToProvider(EPWeather* _this)
{
_ep_Weather_ReboundBrowser(_this, FALSE);
HRESULT hr = S_OK;
LONG64 dwProvider = InterlockedAdd64(&_this->dwProvider, 0);
if (dwProvider == EP_WEATHER_PROVIDER_TEST)
{
}
else if (dwProvider == EP_WEATHER_PROVIDER_GOOGLE)
{
//hr = _this->pCoreWebView2->lpVtbl->Navigate(_this->pCoreWebView2, L"https://google.com");
LPWSTR wszScriptData = malloc(sizeof(WCHAR) * EP_WEATHER_PROVIDER_GOOGLE_HTML_LEN);
if (wszScriptData)
{
swprintf_s(wszScriptData, EP_WEATHER_PROVIDER_GOOGLE_HTML_LEN, L"https://www.google.com/search?hl=%s&q=weather%s%s", _this->wszLanguage, _this->wszTerm[0] ? L" " : L"", _this->wszTerm);
if (_this->pCoreWebView2)
{
hr = _this->pCoreWebView2->lpVtbl->Navigate(_this->pCoreWebView2, wszScriptData);
}
else
{
hr = E_FAIL;
}
if (FAILED(hr))
{
InterlockedExchange64(&_this->bBrowserBusy, FALSE);
}
free(wszScriptData);
}
else
{
hr = E_OUTOFMEMORY;
}
}
return hr;
}
HRESULT STDMETHODCALLTYPE _epw_Weather_ExecuteDataScript(EPWeather* _this)
{
HRESULT hr = S_OK;
LONG64 dwProvider = InterlockedAdd64(&_this->dwProvider, 0);
if (dwProvider == EP_WEATHER_PROVIDER_TEST)
{
}
else if (dwProvider == EP_WEATHER_PROVIDER_GOOGLE)
{
LPWSTR wszScriptData = malloc(sizeof(WCHAR) * EP_WEATHER_PROVIDER_GOOGLE_SCRIPT_LEN);
if (wszScriptData)
{
LONG64 dwIconPack = InterlockedAdd(&_this->dwIconPack, 0);
if (dwIconPack == EP_WEATHER_ICONPACK_MICROSOFT)
{
swprintf_s(wszScriptData, EP_WEATHER_PROVIDER_GOOGLE_SCRIPT_LEN, L"%s%s%s%s%s%s", ep_weather_provider_google_script00, ep_weather_provider_google_script010, ep_weather_provider_google_script011, ep_weather_provider_google_script020, ep_weather_provider_google_script021, ep_weather_provider_google_script03);
}
else if (dwIconPack == EP_WEATHER_ICONPACK_GOOGLE)
{
swprintf_s(wszScriptData, EP_WEATHER_PROVIDER_GOOGLE_SCRIPT_LEN, ep_weather_provider_google_script10);
}
//wprintf(L"%s\n", _this->wszScriptData);
if (_this->pCoreWebView2)
{
GenericObjectWithThis* pCoreWebView2ExecuteScriptCompletedHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2ExecuteScriptCompletedHandlerVtbl, _this, L"pCoreWebView2ExecuteScriptCompletedHandler");
if (!pCoreWebView2ExecuteScriptCompletedHandler) hr = E_FAIL;
else hr = _this->pCoreWebView2->lpVtbl->ExecuteScript(_this->pCoreWebView2, wszScriptData, pCoreWebView2ExecuteScriptCompletedHandler);
}
else
{
hr = E_FAIL;
}
if (FAILED(hr))
{
InterlockedExchange64(&_this->bBrowserBusy, FALSE);
}
free(wszScriptData);
}
else
{
hr = E_OUTOFMEMORY;
}
}
return hr;
}
HRESULT STDMETHODCALLTYPE _ep_Weather_StartResize(EPWeather* _this)
{
_this->cntResizeWindow = 0;
SetTimer(_this->hWnd, EP_WEATHER_TIMER_RESIZE_WINDOW, EP_WEATHER_TIMER_RESIZE_WINDOW_DELAY, NULL);
return S_OK;
}
HRESULT STDMETHODCALLTYPE _ep_Weather_ReboundBrowser(EPWeather* _this, LONG64 dwType)
{
UINT dpi = GetDpiForWindow(_this->hWnd);
RECT bounds;
DWORD dwDevMode = InterlockedAdd64(&_this->dwDevMode, 0);
if (dwType || dwDevMode)
{
GetClientRect(_this->hWnd, &bounds);
}
else
{
DWORD dwTextScaleFactor = epw_Weather_GetTextScaleFactor(_this);
DWORD dwZoomFactor = epw_Weather_GetZoomFactor(_this);
bounds.left = 0 - MulDiv(MulDiv(MulDiv(181, dpi, 96), dwTextScaleFactor, 100), dwZoomFactor, 100);
bounds.top = 0 - MulDiv(MulDiv(MulDiv(152, dpi, 96), dwTextScaleFactor, 100), dwZoomFactor, 100);
bounds.right = MulDiv(MulDiv(MulDiv((!InterlockedAdd64(&_this->dwTextDir, 0) ? 1333 : 705), dpi, 96), dwTextScaleFactor, 100), dwZoomFactor, 100);// 5560;
bounds.bottom = MulDiv(MulDiv(MulDiv(600, dpi, 96), dwTextScaleFactor, 100), dwZoomFactor, 100);// 15600;
}
if (_this->pCoreWebView2Controller)
{
_this->pCoreWebView2Controller->lpVtbl->put_Bounds(_this->pCoreWebView2Controller, bounds);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_CreateCoreWebView2ControllerCompleted(GenericObjectWithThis* _this2, HRESULT hr, ICoreWebView2Controller* pCoreWebView2Controller)
{
EPWeather* _this = _this2->_this; // GetWindowLongPtrW(FindWindowW(_T(EPW_WEATHER_CLASSNAME), NULL), GWLP_USERDATA);
if (!_this->pCoreWebView2Controller)
{
_this->pCoreWebView2Controller = pCoreWebView2Controller;
_this->pCoreWebView2Controller->lpVtbl->get_CoreWebView2(_this->pCoreWebView2Controller, &_this->pCoreWebView2);
_this->pCoreWebView2Controller->lpVtbl->AddRef(_this->pCoreWebView2Controller);
_this->pCoreWebView2Controller->lpVtbl->put_ZoomFactor(_this->pCoreWebView2Controller, InterlockedAdd64(&_this->dwZoomFactor, 0) / 100.0);
}
_ep_Weather_ReboundBrowser(_this, FALSE);
ICoreWebView2Controller2* pCoreWebView2Controller2 = NULL;
_this->pCoreWebView2Controller->lpVtbl->QueryInterface(_this->pCoreWebView2Controller, &IID_ICoreWebView2Controller2, &pCoreWebView2Controller2);
if (pCoreWebView2Controller2)
{
COREWEBVIEW2_COLOR transparent;
transparent.A = 0;
transparent.R = 0;
transparent.G = 0;
transparent.B = 0;
pCoreWebView2Controller2->lpVtbl->put_DefaultBackgroundColor(pCoreWebView2Controller2, transparent);
pCoreWebView2Controller2->lpVtbl->Release(pCoreWebView2Controller2);
}
ICoreWebView2Settings* pCoreWebView2Settings = NULL;
_this->pCoreWebView2->lpVtbl->get_Settings(_this->pCoreWebView2, &pCoreWebView2Settings);
if (pCoreWebView2Settings)
{
ICoreWebView2Settings6* pCoreWebView2Settings6 = NULL;
pCoreWebView2Settings->lpVtbl->QueryInterface(pCoreWebView2Settings, &IID_ICoreWebView2Settings6, &pCoreWebView2Settings6);
if (pCoreWebView2Settings6)
{
DWORD dwDevMode = InterlockedAdd64(&_this->dwDevMode, 0);
pCoreWebView2Settings6->lpVtbl->put_AreDevToolsEnabled(pCoreWebView2Settings6, dwDevMode);
pCoreWebView2Settings6->lpVtbl->put_AreDefaultContextMenusEnabled(pCoreWebView2Settings6, dwDevMode);
pCoreWebView2Settings6->lpVtbl->put_IsStatusBarEnabled(pCoreWebView2Settings6, FALSE);
pCoreWebView2Settings6->lpVtbl->put_IsZoomControlEnabled(pCoreWebView2Settings6, FALSE);
pCoreWebView2Settings6->lpVtbl->put_IsGeneralAutofillEnabled(pCoreWebView2Settings6, FALSE);
pCoreWebView2Settings6->lpVtbl->put_IsPasswordAutosaveEnabled(pCoreWebView2Settings6, FALSE);
pCoreWebView2Settings6->lpVtbl->put_IsPinchZoomEnabled(pCoreWebView2Settings6, FALSE);
pCoreWebView2Settings6->lpVtbl->put_IsSwipeNavigationEnabled(pCoreWebView2Settings6, FALSE);
pCoreWebView2Settings6->lpVtbl->put_AreBrowserAcceleratorKeysEnabled(pCoreWebView2Settings6, dwDevMode);
pCoreWebView2Settings6->lpVtbl->put_AreDefaultScriptDialogsEnabled(pCoreWebView2Settings6, dwDevMode);
pCoreWebView2Settings6->lpVtbl->Release(pCoreWebView2Settings6);
}
pCoreWebView2Settings->lpVtbl->Release(pCoreWebView2Settings);
}
LONG64 dwDarkMode = InterlockedAdd64(&_this->g_darkModeEnabled, 0);
epw_Weather_SetDarkMode(_this, dwDarkMode, FALSE);
_this->pCoreWebView2NavigationStartingEventHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2NavigationStartingEventHandlerVtbl, _this, L"pCoreWebView2NavigationStartingEventHandler");
if (_this->pCoreWebView2NavigationStartingEventHandler)
_this->pCoreWebView2->lpVtbl->add_NavigationStarting(_this->pCoreWebView2, _this->pCoreWebView2NavigationStartingEventHandler, &_this->tkOnNavigationStarting);
_this->pCoreWebView2NavigationCompletedEventHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2NavigationCompletedEventHandlerVtbl, _this, L"pCoreWebView2NavigationCompletedEventHandler");
if (_this->pCoreWebView2NavigationCompletedEventHandler)
_this->pCoreWebView2->lpVtbl->add_NavigationCompleted(_this->pCoreWebView2, _this->pCoreWebView2NavigationCompletedEventHandler, &_this->tkOnNavigationCompleted);
_this->pCoreWebView2PermissionRequestedEventHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2PermissionRequestedEventHandlerVtbl, _this, L"pCoreWebView2PermissionRequestedEventHandler");
if (_this->pCoreWebView2PermissionRequestedEventHandler)
_this->pCoreWebView2->lpVtbl->add_PermissionRequested(_this->pCoreWebView2, _this->pCoreWebView2PermissionRequestedEventHandler, &_this->tkOnPermissionRequested);
_epw_Weather_NavigateToProvider(_this);
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_CallDevToolsProtocolMethodCompleted(GenericObjectWithThis* _this, HRESULT errorCode, LPCWSTR returnObjectAsJson)
{
EPWeather* EPWeather_Instance = _this->_this;
if (EPWeather_Instance && !wcscmp(_this->pName, L"pCoreWebView2CallDevToolsProtocolMethodCompletedHandler_WithRefresh"))
{
wprintf(L"[CallDevToolsProtocolMethodCompleted] 0x%x [[ %s ]]\n", errorCode, returnObjectAsJson);
PostMessageW(EPWeather_Instance->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
LPWSTR uri = NULL;
if (EPWeather_Instance->pCoreWebView2)
{
if (SUCCEEDED(EPWeather_Instance->pCoreWebView2->lpVtbl->get_Source(EPWeather_Instance->pCoreWebView2, &uri)))
{
if (wcscmp(L"about:blank", uri ? uri : L""))
{
SetTimer(EPWeather_Instance->hWnd, EP_WEATHER_TIMER_REQUEST_REFRESH, EP_WEATHER_TIMER_REQUEST_REFRESH_DELAY, NULL);
}
CoTaskMemFree(uri);
}
}
}
_this->lpVtbl->Release(_this);
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_NavigationStarting(GenericObjectWithThis* _this2, ICoreWebView2* pCoreWebView2, ICoreWebView2NavigationStartingEventArgs* pCoreWebView2NavigationStartingEventArgs)
{
EPWeather* _this = _this2->_this; // GetWindowLongPtrW(FindWindowW(_T(EPW_WEATHER_CLASSNAME), NULL), GWLP_USERDATA);
LPWSTR wszUri = NULL;
pCoreWebView2NavigationStartingEventArgs->lpVtbl->get_Uri(pCoreWebView2NavigationStartingEventArgs, &wszUri);
if (wszUri)
{
if (!_wcsicmp(wszUri, L"epweather://refresh"))
{
pCoreWebView2NavigationStartingEventArgs->lpVtbl->put_Cancel(pCoreWebView2NavigationStartingEventArgs, TRUE);
PostMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
}
CoTaskMemFree(wszUri);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_NavigationCompleted(GenericObjectWithThis* _this2, ICoreWebView2* pCoreWebView2, ICoreWebView2NavigationCompletedEventArgs* pCoreWebView2NavigationCompletedEventArgs)
{
COREWEBVIEW2_WEB_ERROR_STATUS dwStatus = COREWEBVIEW2_WEB_ERROR_STATUS_UNKNOWN;
pCoreWebView2NavigationCompletedEventArgs->lpVtbl->get_WebErrorStatus(pCoreWebView2NavigationCompletedEventArgs, &dwStatus);
if (dwStatus == COREWEBVIEW2_WEB_ERROR_STATUS_OPERATION_CANCELED) return S_OK;
EPWeather* _this = _this2->_this; // GetWindowLongPtrW(FindWindowW(_T(EPW_WEATHER_CLASSNAME), NULL), GWLP_USERDATA);
BOOL bIsSuccess = FALSE;
pCoreWebView2NavigationCompletedEventArgs->lpVtbl->get_IsSuccess(pCoreWebView2NavigationCompletedEventArgs, &bIsSuccess);
if (bIsSuccess)
{
BOOL bIsNavigatingToError = InterlockedAdd64(&_this->bIsNavigatingToError, 0);
if (bIsNavigatingToError)
{
InterlockedExchange64(&_this->bIsNavigatingToError, FALSE);
InterlockedExchange64(&_this->bBrowserBusy, FALSE);
}
else
{
//_epw_Weather_ExecuteDataScript(_this);
SetTimer(_this->hWnd, EP_WEATHER_TIMER_EXECUTEDATASCRIPT, EP_WEATHER_TIMER_EXECUTEDATASCRIPT_DELAY, NULL);
}
}
else
{
printf("[Browser] Navigation completed with error, showing error page.\n");
_epw_Weather_NavigateToError(_this);
}
_this->pCoreWebView2Controller->lpVtbl->put_IsVisible(_this->pCoreWebView2Controller, FALSE);
_this->pCoreWebView2Controller->lpVtbl->put_IsVisible(_this->pCoreWebView2Controller, TRUE);
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_ExecuteScriptCompleted(GenericObjectWithThis* _this2, HRESULT hr, LPCWSTR pResultObjectAsJson)
{
EPWeather* _this = _this2->_this; // GetWindowLongPtrW(FindWindowW(_T(EPW_WEATHER_CLASSNAME), NULL), GWLP_USERDATA);
if (_this)
{
BOOL bOk = FALSE;
LONG64 dwProvider = InterlockedAdd64(&_this->dwProvider, 0);
if (dwProvider == EP_WEATHER_PROVIDER_GOOGLE)
{
if (!_wcsicmp(pResultObjectAsJson, L"\"run_part_2\""))
{
//_this->pCoreWebView2->lpVtbl->OpenDevToolsWindow(_this->pCoreWebView2);
//printf("running part 2\n");
//LONG64 bEnabled, dwDarkMode;
//dwDarkMode = InterlockedAdd64(&_this->g_darkModeEnabled, 0);
//epw_Weather_IsDarkMode(_this, dwDarkMode, &bEnabled);
//swprintf_s(_this->wszScriptData, EP_WEATHER_PROVIDER_GOOGLE_SCRIPT_LEN, ep_weather_provider_google_script2, bEnabled ? 1 : 0);
GenericObjectWithThis* pCoreWebView2ExecuteScriptCompletedHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2ExecuteScriptCompletedHandlerVtbl, _this, L"pCoreWebView2ExecuteScriptCompletedHandler");
if (pCoreWebView2ExecuteScriptCompletedHandler) _this->pCoreWebView2->lpVtbl->ExecuteScript(_this->pCoreWebView2, ep_weather_provider_google_script2, pCoreWebView2ExecuteScriptCompletedHandler);
bOk = TRUE;
}
else if (!_wcsicmp(pResultObjectAsJson, L"\"run_part_0\""))
{
LONG64 dwTemperatureUnit = InterlockedAdd64(&_this->dwTemperatureUnit, 0);
LONG64 cbx = InterlockedAdd64(&_this->cbx, 0);
LPWSTR wszScriptData = malloc(sizeof(WCHAR) * EP_WEATHER_PROVIDER_GOOGLE_SCRIPT_LEN);
if (wszScriptData)
{
swprintf_s(wszScriptData, EP_WEATHER_PROVIDER_GOOGLE_SCRIPT_LEN, ep_weather_provider_google_script, dwTemperatureUnit == EP_WEATHER_TUNIT_FAHRENHEIT ? L'F' : L'C', cbx, cbx);
GenericObjectWithThis* pCoreWebView2ExecuteScriptCompletedHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2ExecuteScriptCompletedHandlerVtbl, _this, L"pCoreWebView2ExecuteScriptCompletedHandler");
if (pCoreWebView2ExecuteScriptCompletedHandler) _this->pCoreWebView2->lpVtbl->ExecuteScript(_this->pCoreWebView2, wszScriptData, pCoreWebView2ExecuteScriptCompletedHandler);
free(wszScriptData);
}
bOk = TRUE;
}
else if (!_wcsicmp(pResultObjectAsJson, L"\"run_part_1\""))
{
printf("consent granted\n");
PostMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
SetTimer(_this->hWnd, EP_WEATHER_TIMER_REQUEST_REFRESH, EP_WEATHER_TIMER_REQUEST_REFRESH_DELAY * 5, NULL);
_this2->lpVtbl->Release(_this2);
return S_OK;
}
else
{
//wprintf(L"%s\n", pResultObjectAsJson);
epw_Weather_LockData(_this);
WCHAR* wszTextDir = pResultObjectAsJson + 1;
if (wszTextDir)
{
WCHAR* wszHeight = wcschr(wszTextDir, L'#');
if (wszHeight)
{
wszHeight[0] = 0;
wszHeight++;
InterlockedExchange64(&_this->dwTextDir, wcsstr(wszTextDir, L"rtl"));
WCHAR* wszTemperature = wcschr(wszHeight, L'#');
if (wszTemperature)
{
wszTemperature[0] = 0;
wszTemperature++;
WCHAR* wszUnit = wcschr(wszTemperature, L'#');
if (wszUnit)
{
wszUnit[0] = 0;
wszUnit++;
WCHAR* wszCondition = wcschr(wszUnit, L'#');
if (wszCondition)
{
wszCondition[0] = 0;
wszCondition++;
WCHAR* wszLocation = wcschr(wszCondition, L'#');
if (wszLocation)
{
wszLocation[0] = 0;
wszLocation++;
WCHAR* pImage = wcschr(wszLocation, L'#');
if (pImage)
{
pImage[0] = 0;
pImage++;
WCHAR* pTerm = wcschr(pImage, L'"');
if (pTerm)
{
pTerm[0] = 0;
if (_this->wszTemperature)
{
free(_this->wszTemperature);
}
if (_this->wszUnit)
{
free(_this->wszUnit);
}
if (_this->wszCondition)
{
free(_this->wszCondition);
}
if (_this->pImage)
{
free(_this->pImage);
}
if (_this->wszLocation)
{
free(_this->wszLocation);
}
_this->cbTemperature = (wcslen(wszTemperature) + 1) * sizeof(WCHAR);
_this->wszTemperature = malloc(_this->cbTemperature);
_this->cbUnit = (wcslen(wszUnit) + 1) * sizeof(WCHAR);
_this->wszUnit = malloc(_this->cbUnit);
_this->cbCondition = (wcslen(wszCondition) + 1) * sizeof(WCHAR);
_this->wszCondition = malloc(_this->cbCondition);
_this->cbImage = wcslen(pImage) / 2;
_this->pImage = malloc(_this->cbImage);
_this->cbLocation = (wcslen(wszLocation) + 1) * sizeof(WCHAR);
_this->wszLocation = malloc(_this->cbLocation);
if (_this->wszTemperature && _this->wszUnit && _this->wszCondition && _this->pImage && _this->wszLocation)
{
wcscpy_s(_this->wszTemperature, _this->cbTemperature / 2, wszTemperature);
wcscpy_s(_this->wszUnit, _this->cbUnit / 2, wszUnit);
wcscpy_s(_this->wszCondition, _this->cbCondition / 2, wszCondition);
wcscpy_s(_this->wszLocation, _this->cbLocation / 2, wszLocation);
for (unsigned int i = 0; i < _this->cbImage * 2; i = i + 2)
{
WCHAR tmp[3];
tmp[0] = pImage[i];
tmp[1] = pImage[i + 1];
tmp[2] = 0;
_this->pImage[i / 2] = wcstol(tmp, NULL, 16);
}
bOk = TRUE;
}
int h = _wtoi(wszHeight);
int ch = MulDiv(h, EP_WEATHER_HEIGHT, 367);
UINT dpi = GetDpiForWindow(_this->hWnd);
DWORD dwTextScaleFactor = epw_Weather_GetTextScaleFactor(_this);
DWORD dwZoomFactor = epw_Weather_GetZoomFactor(_this);
ch = MulDiv(MulDiv(MulDiv(ch, dpi, 96), dwTextScaleFactor, 100), dwZoomFactor, 100);
RECT rc;
GetClientRect(_this->hWnd, &rc);
int w = MulDiv(MulDiv(MulDiv(EP_WEATHER_WIDTH, GetDpiForWindow(_this->hWnd), 96), dwTextScaleFactor, 100), dwZoomFactor, 100);
if ((rc.bottom - rc.top != ch) || (rc.right - rc.left != w))
{
RECT rcAdj;
SetRect(&rcAdj, 0, 0, w, ch);
AdjustWindowRectExForDpi(&rcAdj, epw_Weather_GetStyle(_this) & ~WS_OVERLAPPED, epw_Weather_HasMenuBar(_this), epw_Weather_GetExtendedStyle(_this), dpi);
SetWindowPos(_this->hWnd, NULL, 0, 0, rcAdj.right - rcAdj.left, rcAdj.bottom - rcAdj.top, SWP_NOMOVE | SWP_NOSENDCHANGING);
_ep_Weather_ReboundBrowser(_this, FALSE);
HWND hNotifyWnd = InterlockedAdd64(&_this->hNotifyWnd, 0);
if (hNotifyWnd)
{
InvalidateRect(hNotifyWnd, NULL, TRUE);
}
}
}
}
}
}
}
}
}
}
epw_Weather_UnlockData(_this);
}
}
if (!bOk)
{
printf("[General] Navigating to error page.\n");
_epw_Weather_NavigateToError(_this);
}
else
{
GetLocalTime(&stLastUpdate);
HWND hGUI = FindWindowW(L"ExplorerPatcher_GUI_" _T(EP_CLSID), NULL);
if (hGUI) InvalidateRect(hGUI, NULL, TRUE);
InterlockedExchange64(&_this->bBrowserBusy, FALSE);
printf("[General] Fetched data, requesting redraw.\n");
SetTimer(_this->hWnd, EP_WEATHER_TIMER_REQUEST_REPAINT, EP_WEATHER_TIMER_REQUEST_REPAINT_DELAY, NULL);
}
}
_this2->lpVtbl->Release(_this2);
return S_OK;
}
HRESULT STDMETHODCALLTYPE ICoreWebView2_PermissionRequested(GenericObjectWithThis* _this2, ICoreWebView2* pCoreWebView2, ICoreWebView2PermissionRequestedEventArgs* pCoreWebView2PermissionRequestedEventArgs)
{
COREWEBVIEW2_PERMISSION_KIND kind;
pCoreWebView2PermissionRequestedEventArgs->lpVtbl->get_PermissionKind(pCoreWebView2PermissionRequestedEventArgs, &kind);
if (kind == COREWEBVIEW2_PERMISSION_KIND_GEOLOCATION)
{
DWORD r = InterlockedAdd64(&_this2->_this->dwGeolocationMode, 0);
printf("[Permissions] Geolocation permission request: %d\n", r);
pCoreWebView2PermissionRequestedEventArgs->lpVtbl->put_State(pCoreWebView2PermissionRequestedEventArgs, r ? COREWEBVIEW2_PERMISSION_STATE_ALLOW : COREWEBVIEW2_PERMISSION_STATE_DENY);
}
return S_OK;
}
ULONG STDMETHODCALLTYPE epw_Weather_AddRef(EPWeather* _this)
{
ULONG value = InterlockedIncrement64(&(_this->cbCount));
printf("[General] AddRef: %d\n", value);
return value;
}
ULONG STDMETHODCALLTYPE epw_Weather_Release(EPWeather* _this)
{
ULONG value = InterlockedDecrement64(&(_this->cbCount));
printf("[General] Release: %d\n", value);
if (value == 0)
{
if (_this->hMainThread)
{
if (_this->hSignalExitMainThread)
{
SetEvent(_this->hSignalExitMainThread);
printf("[General] Waiting for main thread to exit.\n");
WaitForSingleObject(_this->hMainThread, INFINITE);
}
CloseHandle(_this->hMainThread);
if (_this->hSignalExitMainThread)
{
CloseHandle(_this->hSignalExitMainThread);
}
}
if (_this->hInitializeEvent)
{
CloseHandle(_this->hInitializeEvent);
}
if (_this->hMutexData)
{
CloseHandle(_this->hMutexData);
}
if (_this->hUxtheme)
{
FreeLibrary(_this->hUxtheme);
}
if (_this->hShlwapi)
{
FreeLibrary(_this->hShlwapi);
}
if (_this->hKCUAccessibility)
{
RegCloseKey(_this->hKCUAccessibility);
}
if (_this->hKLMAccessibility)
{
RegCloseKey(_this->hKLMAccessibility);
}
if (_this->hSignalOnAccessibilitySettingsChangedFromHKCU)
{
CloseHandle(_this->hSignalOnAccessibilitySettingsChangedFromHKCU);
}
if (_this->hSignalOnAccessibilitySettingsChangedFromHKLM)
{
CloseHandle(_this->hSignalOnAccessibilitySettingsChangedFromHKLM);
}
if (_this->hSignalKillSwitch)
{
CloseHandle(_this->hSignalKillSwitch);
}
FREE(_this);
LONG dwOutstandingObjects = InterlockedDecrement(&epw_OutstandingObjects);
LONG dwOutstandingLocks = InterlockedAdd(&epw_LockCount, 0);
if (!dwOutstandingObjects && !dwOutstandingLocks)
{
}
printf("[General] Outstanding objects: %d, outstanding locks: %d\n", dwOutstandingObjects, dwOutstandingLocks);
#if defined(DEBUG) | defined(_DEBUG)
printf("\nDumping memory leaks:\n");
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDOUT);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDOUT);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDOUT);
_CrtDumpMemoryLeaks();
printf("Memory dump complete.\n\n");
#endif
//TerminateProcess(GetCurrentProcess(), 0);
return(0);
}
return value;
}
HRESULT STDMETHODCALLTYPE epw_Weather_QueryInterface(EPWeather* _this, REFIID riid, void** ppv)
{
if (!IsEqualIID(riid, &IID_IEPWeather) &&
!IsEqualIID(riid, &IID_IUnknown))
{
*ppv = 0;
return(E_NOINTERFACE);
}
*ppv = _this;
_this->lpVtbl->AddRef(_this);
return(NOERROR);
}
HRESULT STDMETHODCALLTYPE epw_Weather_About(EPWeather* _this, HWND hWnd)
{
HRESULT hr = NOERROR;
if (SUCCEEDED(hr))
{
hr = !_this ? (E_NOINTERFACE) : hr;
}
if (SUCCEEDED(hr))
{
wchar_t text[MAX_PATH];
DWORD dwLeftMost = 0;
DWORD dwSecondLeft = 0;
DWORD dwSecondRight = 0;
DWORD dwRightMost = 0;
QueryVersionInfo(epw_hModule, VS_VERSION_INFO, &dwLeftMost, &dwSecondLeft, &dwSecondRight, &dwRightMost);
swprintf_s(text, MAX_PATH, L"ExplorerPatcher Weather Host\r\n\r\nVersion %d.%d.%d.%d", dwLeftMost, dwSecondLeft, dwSecondRight, dwRightMost);
MessageBoxW(hWnd, text, _T("ExplorerPatcher Weather Host"), MB_ICONINFORMATION);
}
return hr;
}
LRESULT CALLBACK epw_Weather_WindowProc(_In_ HWND hWnd, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam)
{
EPWeather* _this = NULL;
if (uMsg == WM_CREATE)
{
CREATESTRUCT* pCreate = (CREATESTRUCT*)(lParam);
_this = (int*)(pCreate->lpCreateParams);
SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)_this);
}
else
{
LONG_PTR ptr = GetWindowLongPtrW(hWnd, GWLP_USERDATA);
_this = (EPWeather*)(ptr);
}
if (!_this)
{
return DefWindowProcW(hWnd, uMsg, wParam, lParam);
}
if (uMsg == WM_TIMER && wParam == EP_WEATHER_TIMER_REQUEST_REPAINT)
{
HWND hNotifyWnd = InterlockedAdd64(&_this->hNotifyWnd, 0);
printf("[Timer Repaint] Request posted to window %x.\n", hNotifyWnd);
if (hNotifyWnd)
{
InvalidateRect(hNotifyWnd, NULL, TRUE);
//Sleep(100);
//InvalidateRect(hNotifyWnd, NULL, TRUE);
}
KillTimer(_this->hWnd, EP_WEATHER_TIMER_REQUEST_REPAINT);
return 0;
}
else if (uMsg == WM_TIMER && wParam == EP_WEATHER_TIMER_REQUEST_REFRESH)
{
KillTimer(_this->hWnd, EP_WEATHER_TIMER_REQUEST_REFRESH);
return SendMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
}
else if (uMsg == WM_TIMER && wParam == EP_WEATHER_TIMER_SCHEDULE_REFRESH)
{
if (SendMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0))
{
printf("[Timer Scheduled Refresh] Browser is busy, waiting a minute and retrying...\n");
KillTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH);
SetTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH, 1000 * 60, NULL);
}
else
{
KillTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH);
LONG64 dwUpdateSchedule = InterlockedAdd64(&_this->dwUpdateSchedule, 0);
printf("[Timer Scheduled Refresh] Fetching data, sleeping for %lld more ms.\n", dwUpdateSchedule);
SetTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH, dwUpdateSchedule, NULL);
}
return 0;
}
else if (uMsg == WM_TIMER && wParam == EP_WEATHER_TIMER_RESIZE_WINDOW)
{
LPWSTR uri = NULL;
if (_this->pCoreWebView2)
{
_this->pCoreWebView2->lpVtbl->get_Source(_this->pCoreWebView2, &uri);
}
DWORD dwTextScaleFactor = epw_Weather_GetTextScaleFactor(_this);
DWORD dwZoomFactor = epw_Weather_GetZoomFactor(_this);
UINT dpi = GetDpiForWindow(_this->hWnd);
RECT rcAdj;
SetRect(&rcAdj, 0, 0, MulDiv(MulDiv(MulDiv(EP_WEATHER_WIDTH, dpi, 96), dwTextScaleFactor, 100), dwZoomFactor, 100), MulDiv(MulDiv(MulDiv((!wcscmp(L"about:blank", uri ? uri : L"") ? EP_WEATHER_HEIGHT_ERROR : EP_WEATHER_HEIGHT), dpi, 96), dwTextScaleFactor, 100), dwZoomFactor, 100));
AdjustWindowRectExForDpi(&rcAdj, epw_Weather_GetStyle(_this) & ~WS_OVERLAPPED, epw_Weather_HasMenuBar(_this), epw_Weather_GetExtendedStyle(_this), dpi);
SetWindowPos(_this->hWnd, NULL, 0, 0, rcAdj.right - rcAdj.left, rcAdj.bottom - rcAdj.top, SWP_NOMOVE | SWP_NOSENDCHANGING);
CoTaskMemFree(uri);
if (_this->cntResizeWindow == 7)
{
_this->cntResizeWindow = 0;
KillTimer(_this->hWnd, EP_WEATHER_TIMER_RESIZE_WINDOW);
}
else
{
_this->cntResizeWindow++;
}
return 0;
}
else if (uMsg == WM_TIMER && wParam == EP_WEATHER_TIMER_EXECUTEDATASCRIPT)
{
_epw_Weather_ExecuteDataScript(_this);
KillTimer(_this->hWnd, EP_WEATHER_TIMER_EXECUTEDATASCRIPT);
return 0;
}
else if (uMsg == EP_WEATHER_WM_REBOUND_BROWSER)
{
LPWSTR uri = NULL;
if (_this->pCoreWebView2)
{
_this->pCoreWebView2->lpVtbl->get_Source(_this->pCoreWebView2, &uri);
}
_ep_Weather_ReboundBrowser(_this, !wcscmp(L"about:blank", uri ? uri : L""));
CoTaskMemFree(uri);
return 0;
}
else if (uMsg == EP_WEATHER_WM_FETCH_DATA)
{
INT64 bWasBrowserBusy = InterlockedCompareExchange64(&_this->bBrowserBusy, TRUE, FALSE);
if (!bWasBrowserBusy)
{
return _epw_Weather_NavigateToProvider(_this);
}
return HRESULT_FROM_WIN32(ERROR_BUSY);
}
else if (uMsg == EP_WEATHER_WM_SET_BROWSER_THEME)
{
if (_this->pCoreWebView2)
{
GenericObjectWithThis* pCoreWebView2CallDevToolsProtocolMethodCompletedHandler = NULL;
if (lParam)
{
pCoreWebView2CallDevToolsProtocolMethodCompletedHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2CallDevToolsProtocolMethodCompletedHandlerVtbl, _this, L"pCoreWebView2CallDevToolsProtocolMethodCompletedHandler_WithRefresh");
}
else
{
pCoreWebView2CallDevToolsProtocolMethodCompletedHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2CallDevToolsProtocolMethodCompletedHandlerVtbl, _this, L"pCoreWebView2CallDevToolsProtocolMethodCompletedHandler");
}
if (wParam)
{
printf("[SetDarkMode] 1\n");
_this->pCoreWebView2->lpVtbl->CallDevToolsProtocolMethod(_this->pCoreWebView2, L"Emulation.setEmulatedMedia", L"{\"features\": [ { \"name\": \"prefers-color-scheme\", \"value\": \"dark\" }]}", pCoreWebView2CallDevToolsProtocolMethodCompletedHandler);
//_this->pCoreWebView2->lpVtbl->CallDevToolsProtocolMethod(_this->pCoreWebView2, L"Emulation.setAutoDarkModeOverride", L"{\"enabled\": true}", &EPWeather_ICoreWebView2CallDevToolsProtocolMethodCompletedHandler);
}
else
{
printf("[SetDarkMode] 0\n");
_this->pCoreWebView2->lpVtbl->CallDevToolsProtocolMethod(_this->pCoreWebView2, L"Emulation.setEmulatedMedia", L"{\"features\": [ { \"name\": \"prefers-color-scheme\", \"value\": \"light\" }]}", pCoreWebView2CallDevToolsProtocolMethodCompletedHandler);
//_this->pCoreWebView2->lpVtbl->CallDevToolsProtocolMethod(_this->pCoreWebView2, L"Emulation.setAutoDarkModeOverride", L"{\"enabled\": false}", &EPWeather_ICoreWebView2CallDevToolsProtocolMethodCompletedHandler);
}
return S_OK;
}
}
else if (uMsg == EP_WEATHER_WM_SETDEVMODE)
{
if (_this->pCoreWebView2)
{
ICoreWebView2Settings* pCoreWebView2Settings = NULL;
_this->pCoreWebView2->lpVtbl->get_Settings(_this->pCoreWebView2, &pCoreWebView2Settings);
if (pCoreWebView2Settings)
{
ICoreWebView2Settings6* pCoreWebView2Settings6 = NULL;
pCoreWebView2Settings->lpVtbl->QueryInterface(pCoreWebView2Settings, &IID_ICoreWebView2Settings6, &pCoreWebView2Settings6);
if (pCoreWebView2Settings6)
{
pCoreWebView2Settings6->lpVtbl->put_AreDevToolsEnabled(pCoreWebView2Settings6, wParam);
pCoreWebView2Settings6->lpVtbl->put_AreDefaultContextMenusEnabled(pCoreWebView2Settings6, wParam);
pCoreWebView2Settings6->lpVtbl->put_AreBrowserAcceleratorKeysEnabled(pCoreWebView2Settings6, wParam);
pCoreWebView2Settings6->lpVtbl->put_AreDefaultScriptDialogsEnabled(pCoreWebView2Settings6, wParam);
pCoreWebView2Settings6->lpVtbl->Release(pCoreWebView2Settings6);
LONG dwStyle = epw_Weather_GetStyle(_this);
if (!GetLastError())
{
if (wParam) dwStyle |= WS_SIZEBOX;
else dwStyle &= ~WS_SIZEBOX;
SetWindowLongW(_this->hWnd, GWL_STYLE, dwStyle);
}
PostMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
}
pCoreWebView2Settings->lpVtbl->Release(pCoreWebView2Settings);
}
}
}
else if (uMsg == EP_WEATHER_WM_SETZOOMFACTOR)
{
if (_this->pCoreWebView2Controller)
{
_this->pCoreWebView2Controller->lpVtbl->put_ZoomFactor(_this->pCoreWebView2Controller, wParam / 100.0);
_ep_Weather_StartResize(_this);
}
}
else if (uMsg == WM_CLOSE || (uMsg == WM_KEYUP && wParam == VK_ESCAPE) || (uMsg == WM_ACTIVATEAPP && wParam == FALSE && GetAncestor(GetForegroundWindow(), GA_ROOT) != _this->hWnd))
{
epw_Weather_Hide(_this);
return 0;
}
else if (uMsg == WM_WINDOWPOSCHANGING)
{
if (IsWindowVisible(hWnd))
{
LONG64 dwDevMode = InterlockedAdd64(&_this->dwDevMode, 0);
WINDOWPOS* pwp = (WINDOWPOS*)lParam;
pwp->flags |= (!dwDevMode ? (SWP_NOMOVE | SWP_NOSIZE) : 0);
if (dwDevMode)
{
_ep_Weather_ReboundBrowser(_this, TRUE);
}
}
return 0;
}
else if (uMsg == WM_SETTINGCHANGE)
{
if (IsColorSchemeChangeMessage(lParam))
{
MARGINS marGlassInset;
if (!IsHighContrast())
{
marGlassInset.cxLeftWidth = -1; // -1 means the whole window
marGlassInset.cxRightWidth = -1;
marGlassInset.cyBottomHeight = -1;
marGlassInset.cyTopHeight = -1;
}
else
{
marGlassInset.cxLeftWidth = 0;
marGlassInset.cxRightWidth = 0;
marGlassInset.cyBottomHeight = 0;
marGlassInset.cyTopHeight = 0;
}
LONG64 dwDarkMode = InterlockedAdd64(&_this->g_darkModeEnabled, 0);
if (IsWindows11())
{
if (!IsDwmExtendFrameIntoClientAreaBrokenInThisBuild())
{
DwmExtendFrameIntoClientArea(_this->hWnd, &marGlassInset);
}
BOOL value = (IsThemeActive() && !IsHighContrast()) ? 1 : 0;
SetMicaMaterialForThisWindow(_this->hWnd, value);
}
else
{
int s = 0;
if (global_rovi.dwBuildNumber < 18985)
{
s = -1;
}
DwmSetWindowAttribute(_this->hWnd, DWMWA_USE_IMMERSIVE_DARK_MODE + s, &dwDarkMode, sizeof(LONG64));
}
if (!dwDarkMode)
{
epw_Weather_SetDarkMode(_this, dwDarkMode, TRUE);
}
return 0;
}
}
else if (uMsg == WM_DPICHANGED)
{
//UINT dpiX = LOWORD(wParam);
//UINT dpiY = HIWORD(wParam);
//DWORD dwTextScaleFactor = epw_Weather_GetTextScaleFactor(_this);
//DWORD dwZoomFactor = epw_Weather_GetZoomFactor(_this);
//RECT rcAdj;
//SetRect(&rcAdj, 0, 0, MulDiv(MulDiv(MulDiv(EP_WEATHER_WIDTH, dpiX, 96), dwTextScaleFactor, 100), dwZoomFactor, 100), MulDiv(MulDiv(MulDiv(EP_WEATHER_HEIGHT, dpiY, 96), dwTextScaleFactor, 100), dwZoomFactor, 100));
//AdjustWindowRectExForDpi(&rcAdj, epw_Weather_GetStyle(_this) & ~WS_OVERLAPPED, epw_Weather_HasMenuBar(_this), epw_Weather_GetExtendedStyle(_this), dpiX);
RECT* rc = lParam;
SetWindowPos(_this->hWnd, NULL, rc->left, rc->top, rc->right - rc->left, rc->bottom - rc->top, 0);
return 0;
}
else if (uMsg == WM_PAINT && !IsWindows11())
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
if (ps.fErase)
{
LONG64 bEnabled, dwDarkMode;
dwDarkMode = InterlockedAdd64(&_this->g_darkModeEnabled, 0);
epw_Weather_IsDarkMode(_this, dwDarkMode, &bEnabled);
COLORREF oldcr = SetBkColor(hdc, bEnabled ? RGB(0, 0, 0) : RGB(255, 255, 255));
ExtTextOutW(hdc, 0, 0, ETO_OPAQUE, &ps.rcPaint, L"", 0, 0);
SetBkColor(hdc, oldcr);
}
EndPaint(hWnd, &ps);
return 0;
}
/*BOOL bIsRunningWithoutVisualStyle = !IsThemeActive() || IsHighContrast();
if (uMsg == WM_CREATE)
{
if (bIsRunningWithoutVisualStyle)
{
SetRectEmpty(&_this->rcBorderThickness);
if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_THICKFRAME)
{
AdjustWindowRectEx(&_this->rcBorderThickness, GetWindowLongPtr(hWnd, GWL_STYLE) & ~WS_CAPTION, FALSE, NULL);
_this->rcBorderThickness.left *= -1;
_this->rcBorderThickness.top *= -1;
}
else if (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_BORDER)
{
SetRect(&_this->rcBorderThickness, 1, 1, 1, 1);
}
SetWindowPos(hWnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
}
}
else if (uMsg == WM_NCCALCSIZE)
{
if (bIsRunningWithoutVisualStyle)
{
if (lParam)
{
NCCALCSIZE_PARAMS* sz = (NCCALCSIZE_PARAMS*)lParam;
sz->rgrc[0].left += _this->rcBorderThickness.left;
sz->rgrc[0].right -= _this->rcBorderThickness.right;
sz->rgrc[0].bottom -= _this->rcBorderThickness.bottom;
return 0;
}
}
}
else if (uMsg == WM_NCHITTEST)
{
if (bIsRunningWithoutVisualStyle)
{
LRESULT lRes = DefWindowProcW(hWnd, uMsg, wParam, lParam);
if (lRes == HTCLIENT)
{
POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
ScreenToClient(hWnd, &pt);
if (pt.y < _this->rcBorderThickness.top)
{
return HTTOP;
}
else
{
return HTCAPTION;
}
}
else
{
return lRes;
}
}
}
else if (uMsg == WM_NCACTIVATE)
{
if (bIsRunningWithoutVisualStyle)
{
return 0;
}
}*/
return DefWindowProcW(hWnd, uMsg, wParam, lParam);
}
HRESULT STDMETHODCALLTYPE epw_Weather_IsDarkMode(EPWeather* _this, LONG64 dwDarkMode, LONG64* bEnabled)
{
BOOL bIsCompositionEnabled = TRUE;
DwmIsCompositionEnabled(&bIsCompositionEnabled);
if (!dwDarkMode)
{
RTL_OSVERSIONINFOW rovi;
*bEnabled = bIsCompositionEnabled && ((global_rovi.dwBuildNumber < 18985) ? TRUE : (ShouldSystemUseDarkMode ? ShouldSystemUseDarkMode() : FALSE)) && !IsHighContrast();
}
else
{
*bEnabled = dwDarkMode - 1;
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetDarkMode(EPWeather* _this, LONG64 dwDarkMode, LONG64 bRefresh)
{
LONG64 bEnabled;
epw_Weather_IsDarkMode(_this, dwDarkMode, &bEnabled);
InterlockedExchange64(&_this->g_darkModeEnabled, dwDarkMode);
if ((dwDarkMode == 2 && bEnabled) || (dwDarkMode == 1 && !bEnabled) || !dwDarkMode)
{
RefreshImmersiveColorPolicyState();
if (_this->hWnd)
{
AllowDarkModeForWindow(_this->hWnd, bEnabled);
int s = 0;
if (global_rovi.dwBuildNumber < 18985)
{
s = -1;
}
DwmSetWindowAttribute(_this->hWnd, DWMWA_USE_IMMERSIVE_DARK_MODE + s, &bEnabled, sizeof(BOOL));
//InvalidateRect(_this->hWnd, NULL, FALSE);
PostMessageW(_this->hWnd, EP_WEATHER_WM_SET_BROWSER_THEME, bEnabled, bRefresh);
}
return S_OK;
}
return E_FAIL;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetGeolocationMode(EPWeather* _this, LONG64 dwGeolocationMode)
{
InterlockedExchange64(&_this->dwGeolocationMode, dwGeolocationMode);
PostMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetWindowCornerPreference(EPWeather* _this, LONG64 dwWindowCornerPreference)
{
InterlockedExchange64(&_this->dwWindowCornerPreference, dwWindowCornerPreference);
INT preference = dwWindowCornerPreference;
if (_this->hWnd)
{
DwmSetWindowAttribute(_this->hWnd, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference));
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetDevMode(EPWeather* _this, LONG64 dwDevMode, LONG64 bRefresh)
{
InterlockedExchange64(&_this->dwDevMode, dwDevMode);
if (bRefresh)
{
PostMessageW(_this->hWnd, EP_WEATHER_WM_SETDEVMODE, dwDevMode, 0);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetIconPack(EPWeather* _this, LONG64 dwIconPack, LONG64 bRefresh)
{
InterlockedExchange64(&_this->dwIconPack, dwIconPack);
if (bRefresh)
{
PostMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetZoomFactor(EPWeather* _this, LONG64 dwZoomFactor)
{
InterlockedExchange64(&_this->dwZoomFactor, dwZoomFactor);
PostMessageW(_this->hWnd, EP_WEATHER_WM_SETZOOMFACTOR, dwZoomFactor, 0);
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_GetLastUpdateTime(EPWeather* _this, LPSYSTEMTIME lpLastUpdateTime)
{
*lpLastUpdateTime = stLastUpdate;
return S_OK;
}
DWORD WINAPI epw_Weather_MainThread(EPWeather* _this)
{
HRESULT hr = S_OK;
BOOL bShouldReleaseBecauseClientDied = FALSE;
SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
_this->hrLastError = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
if (FAILED(_this->hrLastError))
{
goto cleanup;
}
_this->hrLastError = CoCreateInstance(
&CLSID_TaskbarList,
NULL,
CLSCTX_INPROC,
&IID_ITaskbarList,
(LPVOID*)&_this->pTaskList
);
if (FAILED(_this->hrLastError))
{
goto cleanup;
}
WNDCLASSW wc;
ZeroMemory(&wc, sizeof(WNDCLASSW));
wc.style = CS_DBLCLKS;
wc.lpfnWndProc = epw_Weather_WindowProc;
wc.hInstance = epw_hModule;
wc.hbrBackground = IsWindows11() ? (HBRUSH)GetStockObject(BLACK_BRUSH) : NULL;
wc.lpszClassName = _T(EPW_WEATHER_CLASSNAME);
wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
if (!RegisterClassW(&wc))
{
//_this->hrLastError = HRESULT_FROM_WIN32(GetLastError());
//goto cleanup;
}
DWORD dwDevMode = InterlockedAdd64(&_this->dwDevMode, 0);
DWORD dwStyle = WS_CAPTION | (dwDevMode ? WS_SIZEBOX : 0);
DWORD dwExStyle = 0;
RECT rc = _this->rc;
AdjustWindowRectExForDpi(&rc, dwStyle, FALSE, dwExStyle, _this->dpiXInitial);
_this->hWnd = CreateWindowExW(dwExStyle, _T(EPW_WEATHER_CLASSNAME), L"", WS_OVERLAPPED | dwStyle, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, epw_hModule, _this); // 1030, 630
if (!_this->hWnd)
{
_this->hrLastError = HRESULT_FROM_WIN32(GetLastError());
goto cleanup;
}
SetPropW(_this->hWnd, L"valinet.ExplorerPatcher.ShellManagedWindow", TRUE);
_this->hrLastError = _this->pTaskList->lpVtbl->DeleteTab(_this->pTaskList, _this->hWnd);
if (FAILED(_this->hrLastError))
{
goto cleanup;
}
WCHAR wszWorkFolder[MAX_PATH];
ZeroMemory(wszWorkFolder, MAX_PATH * sizeof(WCHAR));
SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, wszWorkFolder);
wcscat_s(wszWorkFolder, MAX_PATH, L"\\ExplorerPatcher\\ep_weather_host");
BOOL bRet = CreateDirectoryW(wszWorkFolder, NULL);
if (!(bRet || (!bRet && GetLastError() == ERROR_ALREADY_EXISTS)))
{
_this->hrLastError = HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
goto cleanup;
}
LONG64 dwDarkMode = InterlockedAdd64(&_this->g_darkModeEnabled, 0);
if (IsWindows11())
{
if (!IsHighContrast())
{
if (!IsDwmExtendFrameIntoClientAreaBrokenInThisBuild())
{
MARGINS marGlassInset = { -1, -1, -1, -1 }; // -1 means the whole window
DwmExtendFrameIntoClientArea(_this->hWnd, &marGlassInset);
}
BOOL value = 1;
SetMicaMaterialForThisWindow(_this->hWnd, TRUE);
}
}
else
{
int s = 0;
if (global_rovi.dwBuildNumber < 18985)
{
s = -1;
}
DwmSetWindowAttribute(_this->hWnd, DWMWA_USE_IMMERSIVE_DARK_MODE + s, &dwDarkMode, sizeof(LONG64));
}
epw_Weather_SetDarkMode(_this, dwDarkMode, FALSE);
InterlockedExchange64(&_this->bBrowserBusy, TRUE);
GenericObjectWithThis* pCoreWebView2CreateCoreWebView2EnvironmentCompletedHandler =
GenericObjectWithThis_MakeAndInitialize(&EPWeather_ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandlerVtbl, _this, L"pCoreWebView2CreateCoreWebView2EnvironmentCompletedHandler");
if (!pCoreWebView2CreateCoreWebView2EnvironmentCompletedHandler) goto cleanup;
#if !defined(_M_ARM64EC)
_this->hrLastError = CreateCoreWebView2EnvironmentWithOptions(NULL, wszWorkFolder, &EPWeather_ICoreWebView2EnvironmentOptions, pCoreWebView2CreateCoreWebView2EnvironmentCompletedHandler);
#else
_this->hrLastError = E_NOTIMPL;
#endif
pCoreWebView2CreateCoreWebView2EnvironmentCompletedHandler->lpVtbl->Release(pCoreWebView2CreateCoreWebView2EnvironmentCompletedHandler);
if (FAILED(_this->hrLastError)) goto cleanup;
INetworkListManager* spManager = NULL;
IConnectionPointContainer* spConnectionPoints = NULL;
IConnectionPoint* spConnectionPoint = NULL;
IUnknown* spSink = NULL;
DWORD dwCookie = 0;
GenericObjectWithThis* pNetworkListManager =
GenericObjectWithThis_MakeAndInitialize(&INetworkListManagerEvents_Vtbl, _this, L"pNetworkListManager");
if (pNetworkListManager)
{
if (SUCCEEDED(hr = CoCreateInstance(&CLSID_NetworkListManager, NULL, CLSCTX_ALL, &IID_INetworkListManager, &spManager) && spManager))
{
if (SUCCEEDED(hr = spManager->lpVtbl->QueryInterface(spManager, &IID_IConnectionPointContainer, &spConnectionPoints)))
{
if (SUCCEEDED(hr = spConnectionPoints->lpVtbl->FindConnectionPoint(spConnectionPoints, &IID_INetworkListManagerEvents, &spConnectionPoint)))
{
if (SUCCEEDED(hr = pNetworkListManager->lpVtbl->QueryInterface(pNetworkListManager, &IID_IUnknown, &spSink)))
{
if (SUCCEEDED(hr = spConnectionPoint->lpVtbl->Advise(spConnectionPoint, spSink, &dwCookie)))
{
}
}
}
}
}
}
LONG64 dwUpdateSchedule = InterlockedAdd64(&_this->dwUpdateSchedule, 0);
SetTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH, dwUpdateSchedule, NULL);
SetEvent(_this->hInitializeEvent);
MSG msg;
while (TRUE)
{
DWORD dwRes = MsgWaitForMultipleObjects(EP_WEATHER_NUM_SIGNALS, &_this->hSignalExitMainThread, FALSE, INFINITE, QS_ALLINPUT);
if (dwRes == WAIT_OBJECT_0 || dwRes == WAIT_ABANDONED_0 + 1)
{
if (dwRes == WAIT_ABANDONED_0 + 1)
{
printf("[General] Client has died.\n");
if (OpenEventW(READ_CONTROL, FALSE, _T(EP_SETUP_EVENTNAME)))
{
printf("[General] Servicing is in progress, terminating...\n");
TerminateProcess(GetCurrentProcess(), 0);
}
bShouldReleaseBecauseClientDied = TRUE;
}
PostQuitMessage(0);
}
else if (dwRes == WAIT_OBJECT_0 + EP_WEATHER_NUM_SIGNALS)
{
BOOL bRet = 0, bQuit = FALSE;
while (bRet = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT)
{
bQuit = TRUE;
break;
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if (bQuit)
{
_this->pCoreWebView2Controller->lpVtbl->Close(_this->pCoreWebView2Controller);
break;
}
}
else if (dwRes == WAIT_OBJECT_0 + 2)
{
epw_Weather_SetTextScaleFactorFromRegistry(_this, HKEY_CURRENT_USER, TRUE);
}
else if (dwRes == WAIT_OBJECT_0 + 3)
{
epw_Weather_SetTextScaleFactorFromRegistry(_this, HKEY_LOCAL_MACHINE, TRUE);
}
}
if (SUCCEEDED(hr))
{
spConnectionPoint->lpVtbl->Unadvise(spConnectionPoint, dwCookie);
}
if (spSink)
{
spSink->lpVtbl->Release(spSink);
}
if (spConnectionPoint)
{
spConnectionPoint->lpVtbl->Release(spConnectionPoint);
}
if (spConnectionPoints)
{
spConnectionPoints->lpVtbl->Release(spConnectionPoints);
}
if (spManager)
{
spManager->lpVtbl->Release(spManager);
}
if (pNetworkListManager)
{
pNetworkListManager->lpVtbl->Release(pNetworkListManager);
}
cleanup:
if (_this->tkOnNavigationStarting.value)
{
_this->pCoreWebView2->lpVtbl->remove_NavigationStarting(_this->pCoreWebView2, _this->tkOnNavigationStarting);
}
if (_this->pCoreWebView2NavigationStartingEventHandler)
{
_this->pCoreWebView2NavigationStartingEventHandler->lpVtbl->Release(_this->pCoreWebView2NavigationStartingEventHandler);
}
if (_this->tkOnNavigationCompleted.value)
{
_this->pCoreWebView2->lpVtbl->remove_NavigationCompleted(_this->pCoreWebView2, _this->tkOnNavigationCompleted);
}
if (_this->pCoreWebView2NavigationCompletedEventHandler)
{
_this->pCoreWebView2NavigationCompletedEventHandler->lpVtbl->Release(_this->pCoreWebView2NavigationCompletedEventHandler);
}
if (_this->tkOnPermissionRequested.value)
{
_this->pCoreWebView2->lpVtbl->remove_PermissionRequested(_this->pCoreWebView2, _this->tkOnPermissionRequested);
}
if (_this->pCoreWebView2PermissionRequestedEventHandler)
{
_this->pCoreWebView2PermissionRequestedEventHandler->lpVtbl->Release(_this->pCoreWebView2PermissionRequestedEventHandler);
}
if (_this->pCoreWebView2)
{
_this->pCoreWebView2->lpVtbl->Release(_this->pCoreWebView2);
}
if (_this->pCoreWebView2Controller)
{
_this->pCoreWebView2Controller->lpVtbl->Release(_this->pCoreWebView2Controller);
}
if (_this->wszTemperature)
{
free(_this->wszTemperature);
}
if (_this->wszUnit)
{
free(_this->wszUnit);
}
if (_this->wszCondition)
{
free(_this->wszCondition);
}
if (_this->pImage)
{
free(_this->pImage);
}
if (_this->wszLocation)
{
free(_this->wszLocation);
}
if (_this->hWnd)
{
DestroyWindow(_this->hWnd);
}
if (_this->pTaskList)
{
_this->pTaskList->lpVtbl->Release(_this->pTaskList);
}
CoUninitialize();
SetEvent(_this->hInitializeEvent);
if (bShouldReleaseBecauseClientDied)
{
SHCreateThread(epw_Weather_ReleaseBecauseClientDiedThread, _this, CTF_NOADDREFLIB, NULL);
}
printf("[General] Exiting main thread.\n");
return 0;
}
HRESULT STDMETHODCALLTYPE epw_Weather_Initialize(EPWeather* _this, WCHAR wszName[MAX_PATH], BOOL bAllocConsole, LONG64 dwProvider, LONG64 cbx, LONG64 cby, LONG64 dwTemperatureUnit, LONG64 dwUpdateSchedule, RECT rc, LONG64 dwDarkMode, LONG64 dwGeolocationMode, HWND* hWnd, LONG64 dwZoomFactor, LONG64 dpiXInitial, LONG64 dpiYInitial)
{
InitializeGlobalVersionAndUBR();
if (bAllocConsole)
{
FILE* conout;
AllocConsole();
freopen_s(
&conout,
"CONOUT$",
"w",
stdout
);
}
if (dwUpdateSchedule < 0)
{
return E_INVALIDARG;
}
InterlockedExchange64(&_this->dwUpdateSchedule, dwUpdateSchedule);
if (dwTemperatureUnit < 0 || dwTemperatureUnit > EP_WEATHER_NUM_TUNITS)
{
return E_INVALIDARG;
}
InterlockedExchange64(&_this->dwTemperatureUnit, dwTemperatureUnit);
if (dwProvider < 0 || dwProvider > EP_WEATHER_NUM_PROVIDERS)
{
return E_INVALIDARG;
}
InterlockedExchange64(&_this->dwProvider, dwProvider);
if (!cbx || !cby)
{
return E_INVALIDARG;
}
InterlockedExchange64(&_this->cbx, cbx);
InterlockedExchange64(&_this->cby, cby);
_this->hSignalKillSwitch = CreateMutexW(NULL, FALSE, wszName);
if (!_this->hSignalKillSwitch || GetLastError() != ERROR_ALREADY_EXISTS)
{
return E_INVALIDARG;
}
InterlockedExchange64(&_this->dwGeolocationMode, dwGeolocationMode);
InterlockedExchange64(&_this->dwZoomFactor, dwZoomFactor);
_this->dpiXInitial = dpiXInitial;
_this->dpiYInitial = dpiYInitial;
_this->hUxtheme = LoadLibraryW(L"uxtheme.dll");
if (_this->hUxtheme)
{
RefreshImmersiveColorPolicyState = GetProcAddress(_this->hUxtheme, (LPCSTR)104);
SetPreferredAppMode = GetProcAddress(_this->hUxtheme, (LPCSTR)135);
AllowDarkModeForWindow = GetProcAddress(_this->hUxtheme, (LPCSTR)133);
ShouldAppsUseDarkMode = GetProcAddress(_this->hUxtheme, (LPCSTR)132);
ShouldSystemUseDarkMode = GetProcAddress(_this->hUxtheme, (LPCSTR)138);
if (ShouldAppsUseDarkMode &&
ShouldSystemUseDarkMode &&
SetPreferredAppMode &&
AllowDarkModeForWindow &&
RefreshImmersiveColorPolicyState
)
{
SetPreferredAppMode(TRUE);
epw_Weather_SetDarkMode(_this, dwDarkMode, FALSE);
}
}
_this->hShlwapi = LoadLibraryW(L"Shlwapi.dll");
if (_this->hShlwapi)
{
_this->SHRegGetValueFromHKCUHKLMFunc = GetProcAddress(_this->hShlwapi, "SHRegGetValueFromHKCUHKLM");
}
_this->hMutexData = CreateMutexW(NULL, FALSE, NULL);
if (!_this->hMutexData)
{
return HRESULT_FROM_WIN32(GetLastError());
}
_this->hInitializeEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
if (!_this->hInitializeEvent)
{
return HRESULT_FROM_WIN32(GetLastError());
}
_this->hSignalExitMainThread = CreateEventW(NULL, FALSE, FALSE, NULL);
if (!_this->hSignalExitMainThread)
{
return HRESULT_FROM_WIN32(GetLastError());
}
_this->hSignalOnAccessibilitySettingsChangedFromHKCU = CreateEventW(NULL, FALSE, FALSE, NULL);
if (!_this->hSignalOnAccessibilitySettingsChangedFromHKCU)
{
return HRESULT_FROM_WIN32(GetLastError());
}
_this->hSignalOnAccessibilitySettingsChangedFromHKLM = CreateEventW(NULL, FALSE, FALSE, NULL);
if (!_this->hSignalOnAccessibilitySettingsChangedFromHKLM)
{
return HRESULT_FROM_WIN32(GetLastError());
}
epw_Weather_SetTextScaleFactorFromRegistry(_this, HKEY_CURRENT_USER, FALSE);
epw_Weather_SetTextScaleFactorFromRegistry(_this, HKEY_LOCAL_MACHINE, FALSE);
_this->rc = rc;
_this->hMainThread = CreateThread(NULL, 0, epw_Weather_MainThread, _this, 0, NULL);
if (!_this->hMainThread)
{
return HRESULT_FROM_WIN32(GetLastError());
}
WaitForSingleObject(_this->hInitializeEvent, INFINITE);
if (FAILED(_this->hrLastError))
{
return _this->hrLastError;
}
*hWnd = _this->hWnd;
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_Show(EPWeather* _this)
{
SetLastError(0);
LONG_PTR dwExStyle = GetWindowLongPtrW(_this->hWnd, GWL_EXSTYLE);
if (!GetLastError())
{
SetWindowLongPtrW(_this->hWnd, GWL_EXSTYLE, WS_EX_TOOLWINDOW | dwExStyle);
}
INT preference = InterlockedAdd64(&_this->dwWindowCornerPreference, 0);
DwmSetWindowAttribute(_this->hWnd, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference));
PostMessageW(_this->hWnd, EP_WEATHER_WM_REBOUND_BROWSER, 0, 0);
ShowWindow(_this->hWnd, SW_SHOW);
_this->pTaskList->lpVtbl->DeleteTab(_this->pTaskList, _this->hWnd);
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_Hide(EPWeather* _this)
{
SetLastError(0);
LONG_PTR dwExStyle = GetWindowLongPtrW(_this->hWnd, GWL_EXSTYLE);
if (!GetLastError())
{
SetWindowLongPtrW(_this->hWnd, GWL_EXSTYLE, ~WS_EX_TOOLWINDOW & dwExStyle);
}
ShowWindow(_this->hWnd, SW_HIDE);
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_GetWindowHandle(EPWeather* _this, HWND* phWnd)
{
*phWnd = _this->hWnd;
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_LockData(EPWeather* _this)
{
DWORD dwRes = WaitForSingleObject(_this->hMutexData, INFINITE);
if (dwRes == WAIT_ABANDONED)
{
return HRESULT_FROM_WIN32(ERROR_ABANDONED_WAIT_0);
}
else if (dwRes == WAIT_FAILED)
{
return HRESULT_FROM_WIN32(GetLastError());
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_GetDataSizes(EPWeather* _this, LPDWORD pcbTemperature, LPDWORD pcbUnit, LPDWORD pcbCondition, LPDWORD pcbImage)
{
*pcbTemperature = _this->cbTemperature;
*pcbUnit = _this->cbUnit;
*pcbCondition = _this->cbCondition;
*pcbImage = _this->cbImage;
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_GetData(EPWeather* _this, DWORD cbTemperature, LPCWSTR wszTemperature, DWORD cbUnit, LPCWSTR wszUnit, DWORD cbCondition, LPCWSTR wszCondition, DWORD cbImage, char* pImage)
{
if (cbTemperature)
{
memcpy_s(wszTemperature, cbTemperature, _this->wszTemperature, _this->cbTemperature);
}
if (cbUnit)
{
memcpy_s(wszUnit, cbUnit, _this->wszUnit, _this->cbUnit);
}
if (cbCondition)
{
memcpy_s(wszCondition, cbCondition, _this->wszCondition, _this->cbCondition);
}
if (cbImage)
{
memcpy_s(pImage, cbImage, _this->pImage, _this->cbImage);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_GetTitle(EPWeather* _this, DWORD cbTitle, LPCWSTR wszTitle, DWORD dwType)
{
WCHAR wszBuffer[MAX_PATH];
ZeroMemory(wszBuffer, MAX_PATH * sizeof(WCHAR));
if (cbTitle)
{
switch (dwType)
{
case EP_WEATHER_VIEW_ICONTEXT:
case EP_WEATHER_VIEW_TEXTONLY:
swprintf_s(wszBuffer, MAX_PATH, L"%s", _this->wszLocation);
break;
case EP_WEATHER_VIEW_ICONTEMP:
case EP_WEATHER_VIEW_TEMPONLY:
swprintf_s(wszBuffer, MAX_PATH, L"%s - %s", _this->wszLocation, _this->wszCondition);
break;
case EP_WEATHER_VIEW_ICONONLY:
swprintf_s(wszBuffer, MAX_PATH, L"%s %s | %s - %s", _this->wszTemperature, _this->wszUnit, _this->wszLocation, _this->wszCondition);
break;
}
memcpy_s(wszTitle, cbTitle, wszBuffer, MAX_PATH);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_UnlockData(EPWeather* _this)
{
if (!ReleaseMutex(_this->hMutexData))
{
return HRESULT_FROM_WIN32(GetLastError());
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_IsInitialized(EPWeather* _this, BOOL* bIsInitialized)
{
*bIsInitialized = _this->hInitializeEvent;
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetNotifyWindow(EPWeather* _this, HWND hWndNotify)
{
InterlockedExchange64(&_this->hNotifyWnd, hWndNotify);
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetTemperatureUnit(EPWeather* _this, LONG64 dwTemperatureUnit)
{
if (dwTemperatureUnit < 0 || dwTemperatureUnit > EP_WEATHER_NUM_TUNITS)
{
return E_INVALIDARG;
}
InterlockedExchange64(&_this->dwTemperatureUnit, dwTemperatureUnit);
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetUpdateSchedule(EPWeather* _this, LONG64 dwUpdateSchedule)
{
if (dwUpdateSchedule < 0)
{
return E_INVALIDARG;
}
LONG64 dwOldUpdateSchedule = InterlockedExchange64(&_this->dwUpdateSchedule, dwUpdateSchedule);
if (dwOldUpdateSchedule != dwUpdateSchedule)
{
KillTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH);
SetTimer(_this->hWnd, EP_WEATHER_TIMER_SCHEDULE_REFRESH, dwUpdateSchedule, NULL);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetTerm(EPWeather* _this, DWORD cbTerm, LPCWSTR wszTerm)
{
if (cbTerm)
{
memcpy_s(_this->wszTerm, sizeof(WCHAR) * MAX_PATH, wszTerm, cbTerm);
}
else
{
ZeroMemory(&_this->wszTerm, sizeof(WCHAR) * MAX_PATH);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetLanguage(EPWeather* _this, DWORD cbLanguage, LPCWSTR wszLanguage)
{
if (cbLanguage)
{
memcpy_s(_this->wszLanguage, sizeof(WCHAR) * MAX_PATH, wszLanguage, cbLanguage);
}
else
{
ZeroMemory(&_this->wszLanguage, sizeof(WCHAR) * MAX_PATH);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_SetIconSize(EPWeather* _this, LONG64 cbx, LONG64 cby)
{
DWORD dwOldX = InterlockedAdd64(&_this->cbx, 0);
DWORD dwOldY = InterlockedAdd64(&_this->cby, 0);
if (dwOldX != cbx)
{
InterlockedExchange64(&_this->cbx, cbx);
InterlockedExchange64(&_this->cby, cby);
PostMessageW(_this->hWnd, EP_WEATHER_WM_FETCH_DATA, 0, 0);
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE epw_Weather_GetIconSize(EPWeather* _this, LONG64* cbx, LONG64* cby)
{
if (cbx) *cbx = InterlockedAdd64(&_this->cbx, 0);
if (cby) *cby = InterlockedAdd64(&_this->cby, 0);
return S_OK;
}
View Git Blame Copy Permalink