Mirrors/PowerToys
1
0
Fork 0
mirror of https://github.com/microsoft/PowerToys.git synced 2025-12-16 19:57:57 +01:00
Code Issues Packages Projects Releases Wiki Activity

Removed get_res_string_wchar and used the get_resource_string() function instead which returns a wstring typecast into wchar*

Browse Source
This commit is contained in:
Alekhya Kommuru
2020-01-17 11:06:57 -08:00
parent bde0e0b86a
commit df1c6b9b0b
5 changed files with 436 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
src/common/common.cpp
View File

@@ -7,87 +7,115 @@
#include <sddl.h> #include <sddl.h>
#include "version.h" #include "version.h"
std::optional<RECT> get_button_pos(HWND hwnd) { std::optional<RECT> get_button_pos(HWND hwnd)
{
RECT button; RECT button;
if (DwmGetWindowAttribute(hwnd, DWMWA_CAPTION_BUTTON_BOUNDS, &button, sizeof(RECT)) == S_OK) { if (DwmGetWindowAttribute(hwnd, DWMWA_CAPTION_BUTTON_BOUNDS, &button, sizeof(RECT)) == S_OK)
{
return button; return button;
} else { }
else
{
return {}; return {};
} }
} }
std::optional<RECT> get_window_pos(HWND hwnd) { std::optional<RECT> get_window_pos(HWND hwnd)
{
RECT window; RECT window;
if (DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &window, sizeof(window)) == S_OK) { if (DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &window, sizeof(window)) == S_OK)
{
return window; return window;
} else { }
else
{
return {}; return {};
} }
} }
std::optional<POINT> get_mouse_pos() { std::optional<POINT> get_mouse_pos()
{
POINT point; POINT point;
if (GetCursorPos(&point) == 0) { if (GetCursorPos(&point) == 0)
{
return {}; return {};
} else { }
else
{
return point; return point;
} }
} }
WindowAndProcPath get_filtered_base_window_and_path(HWND window) { WindowAndProcPath get_filtered_base_window_and_path(HWND window)
{
return hwnd_cache.get_window_and_path(window); return hwnd_cache.get_window_and_path(window);
} }
HWND get_filtered_active_window() { HWND get_filtered_active_window()
{
return hwnd_cache.get_window(GetForegroundWindow()); return hwnd_cache.get_window(GetForegroundWindow());
} }
int width(const RECT& rect) { int width(const RECT& rect)
{
return rect.right - rect.left; return rect.right - rect.left;
} }
int height(const RECT& rect) { int height(const RECT& rect)
{
return rect.bottom - rect.top; return rect.bottom - rect.top;
} }
bool operator<(const RECT& lhs, const RECT& rhs) { bool operator<(const RECT& lhs, const RECT& rhs)
{
auto lhs_tuple = std::make_tuple(lhs.left, lhs.right, lhs.top, lhs.bottom); auto lhs_tuple = std::make_tuple(lhs.left, lhs.right, lhs.top, lhs.bottom);
auto rhs_tuple = std::make_tuple(rhs.left, rhs.right, rhs.top, rhs.bottom); auto rhs_tuple = std::make_tuple(rhs.left, rhs.right, rhs.top, rhs.bottom);
return lhs_tuple < rhs_tuple; return lhs_tuple < rhs_tuple;
} }
RECT keep_rect_inside_rect(const RECT& small_rect, const RECT& big_rect) { RECT keep_rect_inside_rect(const RECT& small_rect, const RECT& big_rect)
{
RECT result = small_rect; RECT result = small_rect;
if ((result.right - result.left) > (big_rect.right - big_rect.left)) { if ((result.right - result.left) > (big_rect.right - big_rect.left))
{
// small_rect is too big horizontally. resize it. // small_rect is too big horizontally. resize it.
result.right = big_rect.right; result.right = big_rect.right;
result.left = big_rect.left; result.left = big_rect.left;
} else { }
if (result.right > big_rect.right) { else
{
if (result.right > big_rect.right)
{
// move the rect left. // move the rect left.
result.left -= result.right - big_rect.right; result.left -= result.right - big_rect.right;
result.right -= result.right - big_rect.right; result.right -= result.right - big_rect.right;
} }
if (result.left < big_rect.left) { if (result.left < big_rect.left)
{
// move the rect right. // move the rect right.
result.right += big_rect.left - result.left; result.right += big_rect.left - result.left;
result.left += big_rect.left - result.left; result.left += big_rect.left - result.left;
} }
} }
if ((result.bottom - result.top) > (big_rect.bottom - big_rect.top)) { if ((result.bottom - result.top) > (big_rect.bottom - big_rect.top))
{
// small_rect is too big vertically. resize it. // small_rect is too big vertically. resize it.
result.bottom = big_rect.bottom; result.bottom = big_rect.bottom;
result.top = big_rect.top; result.top = big_rect.top;
} else { }
if (result.bottom > big_rect.bottom) { else
{
if (result.bottom > big_rect.bottom)
{
// move the rect up. // move the rect up.
result.top -= result.bottom - big_rect.bottom; result.top -= result.bottom - big_rect.bottom;
result.bottom -= result.bottom - big_rect.bottom; result.bottom -= result.bottom - big_rect.bottom;
} }
if (result.top < big_rect.top) { if (result.top < big_rect.top)
{
// move the rect down. // move the rect down.
result.bottom += big_rect.top - result.top; result.bottom += big_rect.top - result.top;
result.top += big_rect.top - result.top; result.top += big_rect.top - result.top;
@@ -96,16 +124,19 @@ RECT keep_rect_inside_rect(const RECT& small_rect, const RECT& big_rect) {
return result; return result;
} }
int run_message_loop() { int run_message_loop()
{
MSG msg; MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) { while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
} }
return static_cast<int>(msg.wParam); return static_cast<int>(msg.wParam);
} }
void show_last_error_message(LPCWSTR lpszFunction, DWORD dw) { void show_last_error_message(LPCWSTR lpszFunction, DWORD dw)
{
// Retrieve the system error message for the error code // Retrieve the system error message for the error code
LPWSTR lpMsgBuf = NULL; LPWSTR lpMsgBuf = NULL;
if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
@@ -115,14 +146,19 @@ void show_last_error_message(LPCWSTR lpszFunction, DWORD dw) {
dw, dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
lpMsgBuf, lpMsgBuf,
0, NULL) > 0) { 0,
NULL) > 0)
{
// Display the error message and exit the process // Display the error message and exit the process
LPWSTR lpDisplayBuf = (LPWSTR)LocalAlloc(LMEM_ZEROINIT, (lstrlenW(lpMsgBuf) + lstrlenW(lpszFunction) + 40) * sizeof(WCHAR)); LPWSTR lpDisplayBuf = (LPWSTR)LocalAlloc(LMEM_ZEROINIT, (lstrlenW(lpMsgBuf) + lstrlenW(lpszFunction) + 40) * sizeof(WCHAR));
if (lpDisplayBuf != NULL) { if (lpDisplayBuf != NULL)
{
StringCchPrintfW(lpDisplayBuf, StringCchPrintfW(lpDisplayBuf,
LocalSize(lpDisplayBuf) / sizeof(WCHAR), LocalSize(lpDisplayBuf) / sizeof(WCHAR),
L"%s failed with error %d: %s", L"%s failed with error %d: %s",
lpszFunction, dw, lpMsgBuf); lpszFunction,
dw,
lpMsgBuf);
MessageBoxW(NULL, (LPCTSTR)lpDisplayBuf, L"Error", MB_OK); MessageBoxW(NULL, (LPCTSTR)lpDisplayBuf, L"Error", MB_OK);
LocalFree(lpDisplayBuf); LocalFree(lpDisplayBuf);
} }
@@ -130,24 +166,29 @@ void show_last_error_message(LPCWSTR lpszFunction, DWORD dw) {
} }
} }
WindowState get_window_state(HWND hwnd) { WindowState get_window_state(HWND hwnd)
{
WINDOWPLACEMENT placement; WINDOWPLACEMENT placement;
placement.length = sizeof(WINDOWPLACEMENT); placement.length = sizeof(WINDOWPLACEMENT);
if (GetWindowPlacement(hwnd, &placement) == 0) { if (GetWindowPlacement(hwnd, &placement) == 0)
{
return UNKNONW; return UNKNONW;
} }
if (placement.showCmd == SW_MINIMIZE || placement.showCmd == SW_SHOWMINIMIZED || IsIconic(hwnd)) { if (placement.showCmd == SW_MINIMIZE || placement.showCmd == SW_SHOWMINIMIZED || IsIconic(hwnd))
{
return MINIMIZED; return MINIMIZED;
} }
if (placement.showCmd == SW_MAXIMIZE || placement.showCmd == SW_SHOWMAXIMIZED) { if (placement.showCmd == SW_MAXIMIZE || placement.showCmd == SW_SHOWMAXIMIZED)
{
return MAXIMIZED; return MAXIMIZED;
} }
auto rectp = get_window_pos(hwnd); auto rectp = get_window_pos(hwnd);
if (!rectp) { if (!rectp)
{
return UNKNONW; return UNKNONW;
} }
@@ -161,44 +202,57 @@ WindowState get_window_state(HWND hwnd) {
bool top_right = monitor.rcWork.top == rect.top && monitor.rcWork.right == rect.right; bool top_right = monitor.rcWork.top == rect.top && monitor.rcWork.right == rect.right;
bool bottom_right = monitor.rcWork.bottom == rect.bottom && monitor.rcWork.right == rect.right; bool bottom_right = monitor.rcWork.bottom == rect.bottom && monitor.rcWork.right == rect.right;
if (top_left && bottom_left) return SNAPED_LEFT; if (top_left && bottom_left)
if (top_left) return SNAPED_TOP_LEFT; return SNAPED_LEFT;
if (bottom_left) return SNAPED_BOTTOM_LEFT; if (top_left)
if (top_right && bottom_right) return SNAPED_RIGHT; return SNAPED_TOP_LEFT;
if (top_right) return SNAPED_TOP_RIGHT; if (bottom_left)
if (bottom_right) return SNAPED_BOTTOM_RIGHT; return SNAPED_BOTTOM_LEFT;
if (top_right && bottom_right)
return SNAPED_RIGHT;
if (top_right)
return SNAPED_TOP_RIGHT;
if (bottom_right)
return SNAPED_BOTTOM_RIGHT;
return RESTORED; return RESTORED;
} }
bool is_process_elevated() { bool is_process_elevated()
{
HANDLE token = nullptr; HANDLE token = nullptr;
bool elevated = false; bool elevated = false;
if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) { if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
{
TOKEN_ELEVATION elevation; TOKEN_ELEVATION elevation;
DWORD size; DWORD size;
if (GetTokenInformation(token, TokenElevation, &elevation, sizeof(elevation), &size)) { if (GetTokenInformation(token, TokenElevation, &elevation, sizeof(elevation), &size))
{
elevated = (elevation.TokenIsElevated != 0); elevated = (elevation.TokenIsElevated != 0);
} }
} }
if (token) { if (token)
{
CloseHandle(token); CloseHandle(token);
} }
return elevated; return elevated;
} }
bool drop_elevated_privileges() { bool drop_elevated_privileges()
{
HANDLE token = nullptr; HANDLE token = nullptr;
LPCTSTR lpszPrivilege = SE_SECURITY_NAME; LPCTSTR lpszPrivilege = SE_SECURITY_NAME;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_DEFAULT | WRITE_OWNER, &token)) { if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_DEFAULT | WRITE_OWNER, &token))
{
return false; return false;
} }
PSID medium_sid = NULL; PSID medium_sid = NULL;
if (!::ConvertStringSidToSid(SDDL_ML_MEDIUM, &medium_sid)) { if (!::ConvertStringSidToSid(SDDL_ML_MEDIUM, &medium_sid))
{
return false; return false;
} }
@@ -214,13 +268,16 @@ bool drop_elevated_privileges() {
return result; return result;
} }
std::wstring get_process_path(DWORD pid) noexcept { std::wstring get_process_path(DWORD pid) noexcept
{
auto process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, TRUE, pid); auto process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, TRUE, pid);
std::wstring name; std::wstring name;
if (process != INVALID_HANDLE_VALUE) { if (process != INVALID_HANDLE_VALUE)
{
name.resize(MAX_PATH); name.resize(MAX_PATH);
DWORD name_length = static_cast<DWORD>(name.length()); DWORD name_length = static_cast<DWORD>(name.length());
if (QueryFullProcessImageNameW(process, 0, (LPWSTR)name.data(), &name_length) == 0) { if (QueryFullProcessImageNameW(process, 0, (LPWSTR)name.data(), &name_length) == 0)
{
name_length = 0; name_length = 0;
} }
name.resize(name_length); name.resize(name_length);
@@ -229,7 +286,8 @@ std::wstring get_process_path(DWORD pid) noexcept {
return name; return name;
} }
bool run_elevated(const std::wstring& file, const std::wstring& params) { bool run_elevated(const std::wstring& file, const std::wstring& params)
{
SHELLEXECUTEINFOW exec_info = { 0 }; SHELLEXECUTEINFOW exec_info = { 0 };
exec_info.cbSize = sizeof(SHELLEXECUTEINFOW); exec_info.cbSize = sizeof(SHELLEXECUTEINFOW);
exec_info.lpVerb = L"runas"; exec_info.lpVerb = L"runas";
@@ -240,28 +298,35 @@ bool run_elevated(const std::wstring& file, const std::wstring& params) {
exec_info.lpDirectory = 0; exec_info.lpDirectory = 0;
exec_info.hInstApp = 0; exec_info.hInstApp = 0;
if (ShellExecuteExW(&exec_info)) { if (ShellExecuteExW(&exec_info))
{
return exec_info.hProcess != nullptr; return exec_info.hProcess != nullptr;
} else { }
else
{
return false; return false;
} }
} }
bool run_non_elevated(const std::wstring& file, const std::wstring& params) { bool run_non_elevated(const std::wstring& file, const std::wstring& params)
{
auto executable_args = file; auto executable_args = file;
if (!params.empty()) { if (!params.empty())
{
executable_args += L" " + params; executable_args += L" " + params;
} }
HWND hwnd = GetShellWindow(); HWND hwnd = GetShellWindow();
if (!hwnd) { if (!hwnd)
{
return false; return false;
} }
DWORD pid; DWORD pid;
GetWindowThreadProcessId(hwnd, &pid); GetWindowThreadProcessId(hwnd, &pid);
winrt::handle process{ OpenProcess(PROCESS_CREATE_PROCESS, FALSE, pid) }; winrt::handle process{ OpenProcess(PROCESS_CREATE_PROCESS, FALSE, pid) };
if (!process) { if (!process)
{
return false; return false;
} }
@@ -271,7 +336,8 @@ bool run_non_elevated(const std::wstring& file, const std::wstring& params) {
auto pproc_buffer = std::make_unique<char[]>(size); auto pproc_buffer = std::make_unique<char[]>(size);
auto pptal = reinterpret_cast<PPROC_THREAD_ATTRIBUTE_LIST>(pproc_buffer.get()); auto pptal = reinterpret_cast<PPROC_THREAD_ATTRIBUTE_LIST>(pproc_buffer.get());
if (!InitializeProcThreadAttributeList(pptal, 1, 0, &size)) { if (!InitializeProcThreadAttributeList(pptal, 1, 0, &size))
{
return false; return false;
} }
@@ -282,7 +348,8 @@ bool run_non_elevated(const std::wstring& file, const std::wstring& params) {
&process_handle, &process_handle,
sizeof(process_handle), sizeof(process_handle),
nullptr, nullptr,
nullptr)) { nullptr))
{
return false; return false;
} }
@@ -301,18 +368,22 @@ bool run_non_elevated(const std::wstring& file, const std::wstring& params) {
nullptr, nullptr,
&siex.StartupInfo, &siex.StartupInfo,
&process_info); &process_info);
if (process_info.hProcess) { if (process_info.hProcess)
{
CloseHandle(process_info.hProcess); CloseHandle(process_info.hProcess);
} }
if (process_info.hThread) { if (process_info.hThread)
{
CloseHandle(process_info.hThread); CloseHandle(process_info.hThread);
} }
return succedded; return succedded;
} }
bool run_same_elevation(const std::wstring& file, const std::wstring& params) { bool run_same_elevation(const std::wstring& file, const std::wstring& params)
{
auto executable_args = file; auto executable_args = file;
if (!params.empty()) { if (!params.empty())
{
executable_args += L" " + params; executable_args += L" " + params;
} }
STARTUPINFO si = { 0 }; STARTUPINFO si = { 0 };
@@ -327,46 +398,56 @@ bool run_same_elevation(const std::wstring& file, const std::wstring& params) {
nullptr, nullptr,
&si, &si,
&pi); &pi);
if (pi.hProcess) { if (pi.hProcess)
{
CloseHandle(pi.hProcess); CloseHandle(pi.hProcess);
} }
if (pi.hThread) { if (pi.hThread)
{
CloseHandle(pi.hThread); CloseHandle(pi.hThread);
} }
return succedded; return succedded;
} }
std::wstring get_process_path(HWND window) noexcept
std::wstring get_process_path(HWND window) noexcept { {
const static std::wstring app_frame_host = L"ApplicationFrameHost.exe"; const static std::wstring app_frame_host = L"ApplicationFrameHost.exe";
DWORD pid{}; DWORD pid{};
GetWindowThreadProcessId(window, &pid); GetWindowThreadProcessId(window, &pid);
auto name = get_process_path(pid); auto name = get_process_path(pid);
if (name.length() >= app_frame_host.length() && if (name.length() >= app_frame_host.length() &&
name.compare(name.length() - app_frame_host.length(), app_frame_host.length(), app_frame_host) == 0) { name.compare(name.length() - app_frame_host.length(), app_frame_host.length(), app_frame_host) == 0)
{
// It is a UWP app. We will enumarate the windows and look for one created // It is a UWP app. We will enumarate the windows and look for one created
// by something with a different PID // by something with a different PID
DWORD new_pid = pid; DWORD new_pid = pid;
EnumChildWindows(window, [](HWND hwnd, LPARAM param) -> BOOL { EnumChildWindows(
window, [](HWND hwnd, LPARAM param) -> BOOL {
auto new_pid_ptr = reinterpret_cast<DWORD*>(param); auto new_pid_ptr = reinterpret_cast<DWORD*>(param);
DWORD pid; DWORD pid;
GetWindowThreadProcessId(hwnd, &pid); GetWindowThreadProcessId(hwnd, &pid);
if (pid != *new_pid_ptr) { if (pid != *new_pid_ptr)
{
*new_pid_ptr = pid; *new_pid_ptr = pid;
return FALSE; return FALSE;
} else { }
else
{
return TRUE; return TRUE;
} }
}, reinterpret_cast<LPARAM>(&new_pid)); },
reinterpret_cast<LPARAM>(&new_pid));
// If we have a new pid, get the new name. // If we have a new pid, get the new name.
if (new_pid != pid) { if (new_pid != pid)
{
return get_process_path(new_pid); return get_process_path(new_pid);
} }
} }
return name; return name;
} }
std::wstring get_product_version() { std::wstring get_product_version()
{
static std::wstring version = std::to_wstring(VERSION_MAJOR) + static std::wstring version = std::to_wstring(VERSION_MAJOR) +
L"." + std::to_wstring(VERSION_MINOR) + L"." + std::to_wstring(VERSION_MINOR) +
L"." + std::to_wstring(VERSION_REVISION) + L"." + std::to_wstring(VERSION_REVISION) +
@@ -375,35 +456,20 @@ std::wstring get_product_version() {
return version; return version;
} }
std::wstring get_resource_string(UINT resource_id, HINSTANCE instance, const wchar_t* fallback) { std::wstring get_resource_string(UINT resource_id, HINSTANCE instance, const wchar_t* fallback)
{
wchar_t* text_ptr; wchar_t* text_ptr;
auto length = LoadStringW(instance, resource_id, reinterpret_cast<wchar_t*>(&text_ptr), 0); auto length = LoadStringW(instance, resource_id, reinterpret_cast<wchar_t*>(&text_ptr), 0);
if (length == 0) { if (length == 0)
{
return fallback; return fallback;
} else { }
else
{
return { text_ptr, static_cast<std::size_t>(length) }; return { text_ptr, static_cast<std::size_t>(length) };
} }
} }
// function to return the string as a to a wchar_t* (to enable localization in cases where the return type did not accept wstring)
wchar_t* get_resource_string_wchar(UINT resource_id, HINSTANCE instance)
{
wchar_t* text_ptr;
unsigned int length = LoadStringW(instance, resource_id, reinterpret_cast<wchar_t*>(&text_ptr), 0);
std::wstring res_string = { *reinterpret_cast<wchar_t**>(&text_ptr), length };
length++;
if (length > 1)
{
wchar_t* tmp_res_ptr;
tmp_res_ptr = new wchar_t[length];
wmemcpy(tmp_res_ptr, res_string.c_str(), length);
return tmp_res_ptr;
}
return (wchar_t*)L"test";
}
std::wstring get_module_filename(HMODULE mod) std::wstring get_module_filename(HMODULE mod)
{ {
wchar_t buffer[MAX_PATH + 1]; wchar_t buffer[MAX_PATH + 1];

18
src/common/common.h
View File

@@ -14,7 +14,8 @@ std::optional<POINT> get_mouse_pos();
// Gets active window, filtering out all "non standard" windows like the taskbar, etc. // Gets active window, filtering out all "non standard" windows like the taskbar, etc.
HWND get_filtered_active_window(); HWND get_filtered_active_window();
// Gets window ancestor (usualy the window we want to do stuff with), filtering out all "non standard" windows like the taskbar, etc. and provide the app process path // Gets window ancestor (usualy the window we want to do stuff with), filtering out all "non standard" windows like the taskbar, etc. and provide the app process path
struct WindowAndProcPath { struct WindowAndProcPath
{
HWND hwnd = nullptr; HWND hwnd = nullptr;
std::wstring process_path; std::wstring process_path;
}; };
@@ -32,7 +33,8 @@ int run_message_loop();
void show_last_error_message(LPCWSTR lpszFunction, DWORD dw); void show_last_error_message(LPCWSTR lpszFunction, DWORD dw);
enum WindowState { enum WindowState
{
UNKNONW, UNKNONW,
MINIMIZED, MINIMIZED,
MAXIMIZED, MAXIMIZED,
@@ -78,15 +80,3 @@ std::wstring get_resource_string(UINT resource_id, HINSTANCE instance, const wch
// extern "C" IMAGE_DOS_HEADER __ImageBase; // extern "C" IMAGE_DOS_HEADER __ImageBase;
// is added to the .cpp file. // is added to the .cpp file.
#define GET_RESOURCE_STRING(resource_id) get_resource_string(resource_id, reinterpret_cast<HINSTANCE>(&__ImageBase), L#resource_id) #define GET_RESOURCE_STRING(resource_id) get_resource_string(resource_id, reinterpret_cast<HINSTANCE>(&__ImageBase), L#resource_id)
// Function which takes a pointer ptr and allocates space before populating it with the string from the resource table
// using this approach as wstring cannot be cast to PCWSTR without allocating space
// hence, we have to malloc and free the pointer after each use
wchar_t* get_resource_string_wchar(UINT resource_id, HINSTANCE instance);
// Wrapper for getting a string from the resource file.
// Requires that
// extern "C" IMAGE_DOS_HEADER __ImageBase;
// is added to the .cpp file.
// used when the return type must be a wchar_t* instead of a wstring.
#define GET_RES_STRING_WCHAR(resource_id) get_resource_string_wchar(resource_id, reinterpret_cast<HINSTANCE>(&__ImageBase))

4
src/modules/powerrename/dll/PowerRenameExt.cpp
View File

@@ -197,8 +197,8 @@ DWORD WINAPI CPowerRenameMenu::s_PowerRenameUIThreadProc(_In_ void* pData)
HRESULT __stdcall CPowerRenameMenu::GetTitle(IShellItemArray* /*psiItemArray*/, LPWSTR* ppszName) HRESULT __stdcall CPowerRenameMenu::GetTitle(IShellItemArray* /*psiItemArray*/, LPWSTR* ppszName)
{ {
app_name = GET_RES_STRING_WCHAR(IDS_POWERRENAME); app_name = GET_RESOURCE_STRING(IDS_POWERRENAME);
return SHStrDup(app_name, ppszName); return SHStrDup(app_name.c_str(), ppszName);
} }
HRESULT __stdcall CPowerRenameMenu::GetIcon(IShellItemArray* /*psiItemArray*/, LPWSTR* ppszIcon) HRESULT __stdcall CPowerRenameMenu::GetIcon(IShellItemArray* /*psiItemArray*/, LPWSTR* ppszIcon)

2
src/modules/powerrename/dll/PowerRenameExt.h
View File

@@ -71,5 +71,5 @@ private:
std::atomic<long> m_refCount = 1; std::atomic<long> m_refCount = 1;
HBITMAP m_hbmpIcon = nullptr; HBITMAP m_hbmpIcon = nullptr;
CComPtr<IDataObject> m_spdo; CComPtr<IDataObject> m_spdo;
wchar_t* app_name; std::wstring app_name;
}; };

11
src/modules/powerrename/dll/dllmain.cpp
View File

@@ -161,14 +161,14 @@ class PowerRenameModule : public PowertoyModuleIface
private: private:
// Enabled by default // Enabled by default
bool m_enabled = true; bool m_enabled = true;
wchar_t* app_name; std::wstring app_name;
public: public:
// Return the display name of the powertoy, this will be cached // Return the display name of the powertoy, this will be cached
virtual PCWSTR get_name() override virtual PCWSTR get_name() override
{ {
app_name = GET_RES_STRING_WCHAR(IDS_POWERRENAME); app_name = GET_RESOURCE_STRING(IDS_POWERRENAME);
return app_name; return app_name.c_str();
} }
// Enable the powertoy // Enable the powertoy
@@ -303,10 +303,7 @@ public:
init_settings(); init_settings();
} }
~PowerRenameModule() ~PowerRenameModule(){};
{
delete app_name;
}
}; };
extern "C" __declspec(dllexport) PowertoyModuleIface* __cdecl powertoy_create() extern "C" __declspec(dllexport) PowertoyModuleIface* __cdecl powertoy_create()