1871 lines
72 KiB
C++
1871 lines
72 KiB
C++
#include "../resources/resource.h"
|
||
#include "app.h"
|
||
#include "history_preview.h"
|
||
#include "ui_scroll.h"
|
||
#include "configuration.h"
|
||
#include "ocr.h"
|
||
#include "richtext.h"
|
||
#include "ui_geometry.h"
|
||
#include "diagnostics.h"
|
||
#include <algorithm>
|
||
#include <commctrl.h>
|
||
#include <commdlg.h>
|
||
#include <map>
|
||
#include <richedit.h>
|
||
#include <set>
|
||
#include <shellapi.h>
|
||
#include <sstream>
|
||
|
||
namespace ks
|
||
{
|
||
namespace
|
||
{
|
||
constexpr UINT ResultsMessage = WM_APP + 40, PreviewMessage = WM_APP + 41;
|
||
int scale(HWND w, int n)
|
||
{
|
||
return MulDiv(n, (int)GetDpiForWindow(w), 96);
|
||
}
|
||
HFONT font(HWND w)
|
||
{
|
||
return CreateFontW(-scale(w, 14), 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
|
||
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, DEFAULT_PITCH,
|
||
L"Segoe UI");
|
||
}
|
||
struct WindowLayout
|
||
{
|
||
int width{}, height{}, x{}, y{};
|
||
bool scrolling{}, arranging{}, history{};
|
||
int wheelRemainder{}, horizontalWheelRemainder{};
|
||
std::vector<std::pair<HWND, RECT>> controls; // Original 96-DPI geometry; never rescale rounded pixels.
|
||
HWND stretch{}, bottomLeft{}, bottomRight{}, details{};
|
||
bool autoOptions{};
|
||
};
|
||
WindowLayout *windowLayoutState(HWND w)
|
||
{
|
||
return reinterpret_cast<WindowLayout *>(GetPropW(w, L"WindowLayout"));
|
||
}
|
||
RECT workArea(RECT rect)
|
||
{
|
||
MONITORINFO monitor{sizeof(monitor)};
|
||
GetMonitorInfoW(MonitorFromRect(&rect, MONITOR_DEFAULTTONEAREST), &monitor);
|
||
return monitor.rcWork;
|
||
}
|
||
void fitToMonitor(HWND w, RECT rect)
|
||
{
|
||
rect = fitWindowRect(rect, workArea(rect));
|
||
SetWindowPos(w, nullptr, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
|
||
SWP_NOACTIVATE | SWP_NOZORDER);
|
||
}
|
||
void arrangeWindow(HWND w)
|
||
{
|
||
auto *layout = windowLayoutState(w);
|
||
if (!layout || !layout->scrolling || layout->arranging) return;
|
||
layout->arranging = true;
|
||
// Showing either scrollbar can make the other necessary. Let the client size settle.
|
||
for (int pass = 0; pass < 3; ++pass)
|
||
{
|
||
RECT client{};
|
||
GetClientRect(w, &client);
|
||
SCROLLINFO horizontal{sizeof(horizontal), SIF_RANGE | SIF_PAGE | SIF_POS,
|
||
0, scale(w, layout->width) - 1, (UINT)client.right, layout->x};
|
||
SCROLLINFO vertical{sizeof(vertical), SIF_RANGE | SIF_PAGE | SIF_POS,
|
||
0, scale(w, layout->height) - 1, (UINT)client.bottom, layout->y};
|
||
layout->x = SetScrollInfo(w, SB_HORZ, &horizontal, TRUE);
|
||
layout->y = SetScrollInfo(w, SB_VERT, &vertical, TRUE);
|
||
}
|
||
RECT client{}; GetClientRect(w, &client);
|
||
bool expandable = layout->history || layout->stretch || layout->autoOptions;
|
||
int extraWidth = expandable ? std::max(0, int(client.right) - scale(w, layout->width)) : 0;
|
||
int extraHeight = expandable ? std::max(0, int(client.bottom) - scale(w, layout->height)) : 0;
|
||
struct Move { HWND child; RECT rect; };
|
||
std::vector<Move> moves;
|
||
for (const auto &[child, r] : layout->controls)
|
||
{
|
||
int id = GetDlgCtrlID(child);
|
||
RECT next{scale(w, r.left) - layout->x,
|
||
scale(w, r.top) - layout->y + ((id >= 110 && id <= 114) || id == 116 ? extraHeight : 0)};
|
||
next.right = next.left + scale(w, r.right - r.left) + (id == 101 || id == 102 ? extraWidth : 0);
|
||
next.bottom = next.top + scale(w, r.bottom - r.top) + (id == 102 ? extraHeight : 0);
|
||
if (child == layout->stretch)
|
||
{
|
||
next.right += extraWidth;
|
||
next.bottom += extraHeight;
|
||
}
|
||
if (child == layout->details)
|
||
{
|
||
next.right += extraWidth;
|
||
OffsetRect(&next, 0, extraHeight);
|
||
}
|
||
if (child == layout->bottomLeft || child == layout->bottomRight)
|
||
OffsetRect(&next, child == layout->bottomRight ? extraWidth : 0, extraHeight);
|
||
if (layout->autoOptions)
|
||
{
|
||
if (r.top >= 396) OffsetRect(&next, 0, extraHeight);
|
||
if (r.top == 302 || r.top == 328 || (id >= 401 && id <= 403))
|
||
{
|
||
int column = id >= 401 && id <= 403 ? id - 401 : (r.left - 18) / 178;
|
||
int leftExtra = extraWidth * column / 3;
|
||
OffsetRect(&next, leftExtra, 0);
|
||
next.right += extraWidth * (column + 1) / 3 - leftExtra;
|
||
if (r.top == 328) next.bottom += extraHeight;
|
||
}
|
||
else if (r.top == 474 || r.top == 500)
|
||
{
|
||
bool rightColumn = r.left >= 290;
|
||
OffsetRect(&next, rightColumn ? extraWidth / 2 : 0, 0);
|
||
next.right += rightColumn ? extraWidth - extraWidth / 2 : extraWidth / 2;
|
||
}
|
||
else if (id == 406 || id == 410 || id == IDOK || id == IDCANCEL)
|
||
OffsetRect(&next, extraWidth, 0);
|
||
else if (r.right - r.left >= 500)
|
||
next.right += extraWidth;
|
||
}
|
||
RECT current{}; GetWindowRect(child, ¤t);
|
||
MapWindowPoints(nullptr, w, reinterpret_cast<POINT *>(¤t), 2);
|
||
if (!EqualRect(¤t, &next)) moves.push_back({child, next});
|
||
}
|
||
if (!moves.empty())
|
||
{
|
||
auto batch = BeginDeferWindowPos((int)moves.size());
|
||
for (const auto &move : moves)
|
||
{
|
||
if (!batch) break;
|
||
auto r = move.rect;
|
||
batch = DeferWindowPos(batch, move.child, nullptr, r.left, r.top, r.right-r.left, r.bottom-r.top,
|
||
SWP_NOACTIVATE | SWP_NOZORDER);
|
||
}
|
||
if (!batch || !EndDeferWindowPos(batch))
|
||
for (const auto &move : moves)
|
||
{
|
||
auto r = move.rect;
|
||
SetWindowPos(move.child, nullptr, r.left, r.top, r.right-r.left, r.bottom-r.top,
|
||
SWP_NOACTIVATE | SWP_NOZORDER);
|
||
}
|
||
}
|
||
layout->arranging = false;
|
||
}
|
||
void scrollWindow(HWND w, WindowLayout *layout, bool horizontal, int requested)
|
||
{
|
||
SCROLLINFO info{sizeof(info), SIF_RANGE | SIF_PAGE};
|
||
GetScrollInfo(w, horizontal ? SB_HORZ : SB_VERT, &info);
|
||
int next = std::clamp(requested, info.nMin, std::max(info.nMin, info.nMax - std::max(0, (int)info.nPage - 1)));
|
||
int &position = horizontal ? layout->x : layout->y;
|
||
if (position == next) return;
|
||
position = next;
|
||
arrangeWindow(w);
|
||
}
|
||
void revealControl(HWND child)
|
||
{
|
||
HWND parent = GetParent(child);
|
||
auto *layout = windowLayoutState(parent);
|
||
if (!layout || !layout->scrolling) return;
|
||
RECT r{}, client{};
|
||
GetWindowRect(child, &r);
|
||
MapWindowPoints(nullptr, parent, reinterpret_cast<POINT *>(&r), 2);
|
||
GetClientRect(parent, &client);
|
||
if (r.left < 0) layout->x += r.left;
|
||
else if (r.right > client.right) layout->x += r.right - client.right;
|
||
if (r.top < 0) layout->y += r.top;
|
||
else if (r.bottom > client.bottom) layout->y += r.bottom - client.bottom;
|
||
arrangeWindow(parent);
|
||
}
|
||
LRESULT CALLBACK scrollChildProc(HWND w, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR)
|
||
{
|
||
if (msg == WM_SETFOCUS) revealControl(w);
|
||
if (msg == WM_NCDESTROY) RemoveWindowSubclass(w, scrollChildProc, 2);
|
||
return DefSubclassProc(w, msg, wp, lp);
|
||
}
|
||
void resizeForDpi(HWND, WPARAM, LPARAM);
|
||
LRESULT CALLBACK layoutProc(HWND w, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR)
|
||
{
|
||
auto *layout = windowLayoutState(w);
|
||
if (!layout) return DefSubclassProc(w, msg, wp, lp);
|
||
if (msg == WM_DPICHANGED)
|
||
{
|
||
resizeForDpi(w, wp, lp);
|
||
return 0;
|
||
}
|
||
if (msg == WM_SIZE) arrangeWindow(w);
|
||
if (msg == WM_DISPLAYCHANGE || msg == WM_SETTINGCHANGE || (msg == WM_SHOWWINDOW && wp))
|
||
{
|
||
RECT rect{};
|
||
GetWindowRect(w, &rect);
|
||
fitToMonitor(w, rect);
|
||
arrangeWindow(w);
|
||
}
|
||
if (layout->scrolling && (msg == WM_VSCROLL || msg == WM_HSCROLL))
|
||
{
|
||
bool vertical = msg == WM_VSCROLL;
|
||
SCROLLINFO info{sizeof(info), SIF_ALL};
|
||
GetScrollInfo(w, vertical ? SB_VERT : SB_HORZ, &info);
|
||
int position = vertical ? layout->y : layout->x;
|
||
switch (LOWORD(wp))
|
||
{
|
||
case SB_LINEUP: position -= scale(w, 32); break;
|
||
case SB_LINEDOWN: position += scale(w, 32); break;
|
||
case SB_PAGEUP: position -= (int)info.nPage; break;
|
||
case SB_PAGEDOWN: position += (int)info.nPage; break;
|
||
case SB_TOP: position = 0; break;
|
||
case SB_BOTTOM: position = info.nMax; break;
|
||
case SB_THUMBTRACK: case SB_THUMBPOSITION: position = info.nTrackPos; break;
|
||
}
|
||
scrollWindow(w, layout, !vertical, position);
|
||
return 0;
|
||
}
|
||
if (layout->scrolling && (msg == WM_MOUSEWHEEL || msg == WM_MOUSEHWHEEL))
|
||
{
|
||
bool horizontal = msg == WM_MOUSEHWHEEL || (GET_KEYSTATE_WPARAM(wp) & MK_SHIFT);
|
||
int &remainder = horizontal ? layout->horizontalWheelRemainder : layout->wheelRemainder;
|
||
remainder += GET_WHEEL_DELTA_WPARAM(wp);
|
||
int steps = remainder / WHEEL_DELTA;
|
||
remainder %= WHEEL_DELTA;
|
||
if (steps)
|
||
scrollWindow(w, layout, horizontal, (horizontal ? layout->x : layout->y) +
|
||
steps * scale(w, 48) * (msg == WM_MOUSEHWHEEL ? 1 : -1));
|
||
return 0;
|
||
}
|
||
if (msg == WM_NCDESTROY)
|
||
{
|
||
RemovePropW(w, L"WindowLayout");
|
||
RemoveWindowSubclass(w, layoutProc, 2);
|
||
delete layout;
|
||
}
|
||
return DefSubclassProc(w, msg, wp, lp);
|
||
}
|
||
HWND control(HWND parent, const wchar_t *cls, const wchar_t *title, DWORD style, int id, int x, int y,
|
||
int width, int height)
|
||
{
|
||
HWND w = CreateWindowExW(wcscmp(cls, L"EDIT") == 0 ? WS_EX_CLIENTEDGE : 0, cls, title,
|
||
WS_CHILD | WS_VISIBLE | style, scale(parent, x), scale(parent, y),
|
||
scale(parent, width), scale(parent, height), parent, (HMENU)(INT_PTR)id,
|
||
GetModuleHandleW(nullptr), nullptr);
|
||
SendMessageW(w, WM_SETFONT, (WPARAM)GetPropW(parent, L"Font"), TRUE);
|
||
if(wcscmp(cls,L"LISTBOX")==0 || wcscmp(cls,WC_LISTVIEWW)==0 ||
|
||
wcscmp(cls,L"COMBOBOX")==0 || (wcscmp(cls,L"EDIT")==0 && (style&ES_MULTILINE)))
|
||
enableWheelBatching(w,wcscmp(cls,L"LISTBOX")==0);
|
||
if (auto *layout = windowLayoutState(parent); layout && layout->scrolling)
|
||
{
|
||
layout->controls.push_back({w, {x, y, x + width, y + height}});
|
||
SetWindowSubclass(w, scrollChildProc, 2, 0);
|
||
arrangeWindow(parent);
|
||
}
|
||
return w;
|
||
}
|
||
void label(HWND w, const wchar_t *text, int x, int y, int width = 200)
|
||
{
|
||
control(w, L"STATIC", text, 0, 0, x, y, width, 22);
|
||
}
|
||
void button(HWND w, const wchar_t *text, int id, int x, int y, int width = 100)
|
||
{
|
||
control(w, L"BUTTON", text, WS_TABSTOP | BS_PUSHBUTTON, id, x, y, width, 28);
|
||
}
|
||
HWND edit(HWND w, int id, int x, int y, int width, int height = 25, DWORD style = ES_AUTOHSCROLL)
|
||
{
|
||
auto c = control(w, L"EDIT", L"", WS_TABSTOP | style, id, x, y, width, height);
|
||
SendMessageW(c, EM_SETLIMITTEXT, 1024 * 1024, 0);
|
||
return c;
|
||
}
|
||
LRESULT CALLBACK hotkeyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR data)
|
||
{
|
||
auto *app = (App *)data;
|
||
if (msg == WM_SETFOCUS)
|
||
{
|
||
app->setHotkeyCapture(w);
|
||
SendMessageW(w, EM_SETSEL, 0, -1);
|
||
}
|
||
if (msg == WM_KILLFOCUS || msg == WM_NCDESTROY)
|
||
{
|
||
if (app->hotkeyCapture == w)
|
||
app->setHotkeyCapture(nullptr);
|
||
}
|
||
if (msg == CaptureHotkeyMessage)
|
||
{
|
||
UINT mods = (UINT)lp;
|
||
if ((wp == VK_TAB && (mods == 0 || mods == MOD_SHIFT)) || (wp == VK_ESCAPE && mods == 0))
|
||
{
|
||
SetFocus(GetNextDlgTabItem(GetParent(w), w, mods == MOD_SHIFT));
|
||
return 0;
|
||
}
|
||
if ((wp == VK_BACK || wp == VK_DELETE) && mods == 0)
|
||
{
|
||
SetWindowTextW(w, L"");
|
||
return 0;
|
||
}
|
||
auto text = Hotkey{mods, (UINT)wp}.format();
|
||
if (!text.empty())
|
||
{
|
||
SetWindowTextW(w, text.c_str());
|
||
SendMessageW(w, EM_SETSEL, 0, -1);
|
||
}
|
||
return 0;
|
||
}
|
||
if (msg == WM_CHAR || msg == WM_SYSCHAR || msg == WM_PASTE || msg == WM_CUT)
|
||
return 0;
|
||
return DefSubclassProc(w, msg, wp, lp);
|
||
}
|
||
[[maybe_unused]] void hotkeyEdit(App &app, HWND w, int id, int x, int y, int width)
|
||
{
|
||
HWND field = edit(w, id, x, y, width, 25, ES_AUTOHSCROLL | ES_READONLY);
|
||
SendMessageW(field, EM_SETCUEBANNER, FALSE, (LPARAM)L"Click, then press a shortcut");
|
||
SetWindowSubclass(field, hotkeyProc, 1, (DWORD_PTR)&app);
|
||
}
|
||
[[maybe_unused]] void checkbox(HWND w, const wchar_t *text, int id, int x, int y, int width = 300)
|
||
{
|
||
control(w, L"BUTTON", text, WS_TABSTOP | BS_AUTOCHECKBOX, id, x, y, width, 24);
|
||
}
|
||
std::wstring value(HWND w, int id)
|
||
{
|
||
HWND c = GetDlgItem(w, id);
|
||
int n = GetWindowTextLengthW(c);
|
||
std::wstring text(n + 1, L'\0');
|
||
GetWindowTextW(c, text.data(), n + 1);
|
||
text.resize(n);
|
||
return text;
|
||
}
|
||
[[maybe_unused]] void value(HWND w, int id, const std::wstring &text)
|
||
{
|
||
SetDlgItemTextW(w, id, text.c_str());
|
||
}
|
||
[[maybe_unused]] bool checked(HWND w, int id)
|
||
{
|
||
return IsDlgButtonChecked(w, id) == BST_CHECKED;
|
||
}
|
||
[[maybe_unused]] void check(HWND w, int id, bool yes)
|
||
{
|
||
CheckDlgButton(w, id, yes ? BST_CHECKED : BST_UNCHECKED);
|
||
}
|
||
void error(HWND w, const std::exception &e)
|
||
{
|
||
MessageBoxW(w, wide(e.what()).c_str(), L"KSwitcher", MB_OK | MB_ICONWARNING);
|
||
}
|
||
HWND makeWindow(App &app, const wchar_t *cls, const wchar_t *title, WNDPROC proc, int width, int height,
|
||
DWORD extra = 0, bool resizable = true)
|
||
{
|
||
WNDCLASSW wc{};
|
||
wc.hInstance = app.instance;
|
||
wc.lpfnWndProc = proc;
|
||
wc.lpszClassName = cls;
|
||
wc.hCursor = LoadCursorW(nullptr, IDC_ARROW);
|
||
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
|
||
wc.hIcon = LoadIconW(app.instance, MAKEINTRESOURCEW(IDI_KSWITCHER));
|
||
RegisterClassW(&wc);
|
||
UINT dpi = GetDpiForSystem();
|
||
RECT rect{0, 0, MulDiv(width, dpi, 96), MulDiv(height, dpi, 96)};
|
||
DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_CLIPCHILDREN | extra;
|
||
if (resizable) style |= WS_THICKFRAME | WS_MAXIMIZEBOX;
|
||
AdjustWindowRectExForDpi(&rect, style, FALSE, WS_EX_APPWINDOW, dpi);
|
||
POINT cursor{};
|
||
GetCursorPos(&cursor);
|
||
MONITORINFO monitor{sizeof(monitor)};
|
||
GetMonitorInfoW(MonitorFromPoint(cursor, MONITOR_DEFAULTTONEAREST), &monitor);
|
||
HWND w =
|
||
CreateWindowExW(WS_EX_APPWINDOW, cls, title, style, monitor.rcWork.left, monitor.rcWork.top,
|
||
rect.right - rect.left, rect.bottom - rect.top, nullptr, nullptr, app.instance, &app);
|
||
if (!w)
|
||
throw std::runtime_error(utf8(lastError(L"Cannot create native window")));
|
||
// The system DPI may still describe the old primary display. The HWND tells
|
||
// us the actual destination DPI, and must size the frame AND its controls.
|
||
dpi = GetDpiForWindow(w);
|
||
rect = {0, 0, MulDiv(width, dpi, 96), MulDiv(height, dpi, 96)};
|
||
AdjustWindowRectExForDpi(&rect, style, FALSE, WS_EX_APPWINDOW, dpi);
|
||
int outerWidth = rect.right - rect.left, outerHeight = rect.bottom - rect.top;
|
||
int left = monitor.rcWork.left + std::max(0L, (monitor.rcWork.right - monitor.rcWork.left - outerWidth) / 2);
|
||
int top = monitor.rcWork.top + std::max(0L, (monitor.rcWork.bottom - monitor.rcWork.top - outerHeight) / 2);
|
||
SetPropW(w, L"WindowLayout", new WindowLayout{width, height, 0, 0, !(extra & WS_THICKFRAME)});
|
||
SetWindowSubclass(w, layoutProc, 2, 0);
|
||
if(windowLayoutState(w)->scrolling) enableWheelBatching(w);
|
||
RECT initial = fitWindowRect({left, top, left + outerWidth, top + outerHeight}, monitor.rcWork);
|
||
SetWindowPos(w, nullptr, initial.left, initial.top, initial.right - initial.left, initial.bottom - initial.top,
|
||
SWP_NOACTIVATE | SWP_NOZORDER);
|
||
arrangeWindow(w);
|
||
SetWindowTextW(w, localBuildTitle(title).c_str());
|
||
auto smallIcon = (HICON)LoadImageW(app.instance, MAKEINTRESOURCEW(IDI_KSWITCHER), IMAGE_ICON,
|
||
GetSystemMetricsForDpi(SM_CXSMICON, dpi),
|
||
GetSystemMetricsForDpi(SM_CYSMICON, dpi), LR_SHARED);
|
||
SendMessageW(w, WM_SETICON, ICON_SMALL, (LPARAM)smallIcon);
|
||
SetPropW(w, L"Font", font(w));
|
||
SetPropW(w, L"Dpi", (HANDLE)(UINT_PTR)GetDpiForWindow(w));
|
||
return w;
|
||
}
|
||
void resizeForDpi(HWND w, WPARAM wp, LPARAM lp)
|
||
{
|
||
// Creation may send WM_DPICHANGED before controls and the original font exist.
|
||
if (!GetPropW(w, L"Dpi"))
|
||
{
|
||
fitToMonitor(w, *(RECT *)lp);
|
||
return;
|
||
}
|
||
int previous = (int)(UINT_PTR)GetPropW(w, L"Dpi");
|
||
int next = LOWORD(wp);
|
||
if (!previous)
|
||
previous = 96;
|
||
HFONT old = (HFONT)GetPropW(w, L"Font");
|
||
HFONT replacement = font(w);
|
||
struct State
|
||
{
|
||
HWND parent;
|
||
int previous, next;
|
||
HFONT font;
|
||
} state{w, previous, next, replacement};
|
||
auto *layout = windowLayoutState(w);
|
||
if (!layout || !layout->scrolling) EnumChildWindows(
|
||
w,
|
||
[](HWND child, LPARAM data) -> BOOL
|
||
{
|
||
auto &s = *(State *)data;
|
||
if (GetParent(child) != s.parent)
|
||
return TRUE;
|
||
RECT r;
|
||
GetWindowRect(child, &r);
|
||
MapWindowPoints(nullptr, s.parent, (POINT *)&r, 2);
|
||
SetWindowPos(child, nullptr, MulDiv(r.left, s.next, s.previous),
|
||
MulDiv(r.top, s.next, s.previous), MulDiv(r.right - r.left, s.next, s.previous),
|
||
MulDiv(r.bottom - r.top, s.next, s.previous), SWP_NOZORDER);
|
||
SendMessageW(child, WM_SETFONT, (WPARAM)s.font, TRUE);
|
||
return TRUE;
|
||
},
|
||
(LPARAM)&state);
|
||
else
|
||
{
|
||
layout->x = MulDiv(layout->x, next, previous);
|
||
layout->y = MulDiv(layout->y, next, previous);
|
||
for (auto &[child, rect] : layout->controls)
|
||
SendMessageW(child, WM_SETFONT, (WPARAM)replacement, TRUE);
|
||
}
|
||
SetPropW(w, L"Font", replacement);
|
||
SetPropW(w, L"Dpi", (HANDLE)(UINT_PTR)next);
|
||
if (old)
|
||
DeleteObject(old);
|
||
// layoutProc consumes WM_DPICHANGED, so owner-drawn rows must be resized here.
|
||
if (layout && layout->history)
|
||
SendDlgItemMessageW(w, 102, LB_SETITEMHEIGHT, 0, scale(w, 88));
|
||
fitToMonitor(w, *(RECT *)lp);
|
||
arrangeWindow(w);
|
||
}
|
||
[[maybe_unused]] std::filesystem::path pickFile(HWND owner, bool save)
|
||
{
|
||
wchar_t path[32768]{};
|
||
OPENFILENAMEW ofn{sizeof(ofn)};
|
||
ofn.hwndOwner = owner;
|
||
ofn.lpstrFilter = L"Settings (*.json)\0*.json\0All files\0*.*\0";
|
||
ofn.lpstrFile = path;
|
||
ofn.nMaxFile = 32768;
|
||
ofn.lpstrDefExt = L"json";
|
||
ofn.Flags = OFN_EXPLORER | OFN_NOCHANGEDIR | (save ? OFN_OVERWRITEPROMPT : OFN_FILEMUSTEXIST);
|
||
return (save ? GetSaveFileNameW(&ofn) : GetOpenFileNameW(&ofn)) ? std::filesystem::path(path)
|
||
: std::filesystem::path();
|
||
}
|
||
void disposeFont(HWND w)
|
||
{
|
||
auto h = (HFONT)RemovePropW(w, L"Font");
|
||
if (h)
|
||
DeleteObject(h);
|
||
}
|
||
|
||
#ifndef KS_CONFIG_APP
|
||
struct SearchResult
|
||
{
|
||
uint64_t generation;
|
||
std::vector<Entry> items;
|
||
};
|
||
struct PreviewResult
|
||
{
|
||
uint64_t generation;
|
||
std::wstring id;
|
||
Pixels pixels;
|
||
std::string rtf;
|
||
};
|
||
struct HistoryView
|
||
{
|
||
App *app{};
|
||
std::vector<Entry> items;
|
||
uint64_t generation{};
|
||
std::map<std::wstring, Pixels> thumbnails;
|
||
std::map<std::wstring, std::string> richTexts;
|
||
HWND rich{};
|
||
std::set<std::wstring> pending;
|
||
bool scrolling{};
|
||
};
|
||
bool selectedImage(HWND w, HistoryView *v)
|
||
{
|
||
int i=(int)SendDlgItemMessageW(w,102,LB_GETCURSEL,0,0);
|
||
return i>=0 && i<(int)v->items.size() && v->items[i].image;
|
||
}
|
||
void updateHistoryActions(HWND w, HistoryView *v)
|
||
{
|
||
SetDlgItemTextW(w,114,selectedImage(w,v)?L"&Edit image":L"&Open item");
|
||
}
|
||
std::wstring selected(HWND w, HistoryView *v)
|
||
{
|
||
int i = (int)SendDlgItemMessageW(w, 102, LB_GETCURSEL, 0, 0);
|
||
return i >= 0 && i < (int)v->items.size() ? v->items[i].id : L"";
|
||
}
|
||
void search(HWND w, HistoryView *v)
|
||
{
|
||
auto q = value(w, 101);
|
||
auto generation = ++v->generation;
|
||
v->pending.clear();
|
||
auto *app = v->app;
|
||
app->enqueueHistorySearch(
|
||
[w, app, q, generation]
|
||
{
|
||
try
|
||
{
|
||
auto result = new SearchResult{generation, app->history->search(q)};
|
||
if (!PostMessageW(w, ResultsMessage, 0, (LPARAM)result))
|
||
delete result;
|
||
}
|
||
catch (const std::exception &e)
|
||
{
|
||
app->report(wide(e.what()));
|
||
}
|
||
});
|
||
}
|
||
void requestPreview(HWND w, HistoryView *v, const Entry &entry)
|
||
{
|
||
if(v->scrolling) return;
|
||
const auto id = entry.id;
|
||
const bool image = entry.image;
|
||
if (v->thumbnails.contains(id) || v->richTexts.contains(id) || !v->pending.insert(id).second)
|
||
return;
|
||
auto generation = v->generation;
|
||
auto *app = v->app;
|
||
app->enqueue(
|
||
[w, app, id, generation, image]
|
||
{
|
||
auto result = new PreviewResult{generation, id, {}, {}};
|
||
try
|
||
{
|
||
auto clip = app->history->load(id);
|
||
if (image)
|
||
result->pixels = decodeImage(clip, 208, 128);
|
||
else
|
||
result->rtf = richPreview(clip);
|
||
}
|
||
catch (const std::exception &)
|
||
{
|
||
}
|
||
if (!PostMessageW(w, PreviewMessage, 0, (LPARAM)result))
|
||
delete result;
|
||
});
|
||
}
|
||
void drawHistoryRow(HWND w, HistoryView *v, const DRAWITEMSTRUCT &draw)
|
||
{
|
||
if (draw.itemID >= v->items.size())
|
||
return;
|
||
const auto &entry = v->items[draw.itemID];
|
||
const bool selected = (draw.itemState & ODS_SELECTED) != 0;
|
||
HDC dc = draw.hDC;
|
||
int saved = SaveDC(dc);
|
||
auto box = draw.rcItem;
|
||
FillRect(dc, &box, GetSysColorBrush(selected ? COLOR_HIGHLIGHT : COLOR_WINDOW));
|
||
SetBkMode(dc, TRANSPARENT);
|
||
SetTextColor(dc, GetSysColor(selected ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT));
|
||
SelectObject(dc, GetPropW(w, L"Font"));
|
||
RECT icon{box.left + scale(w, 12), box.top + scale(w, 10), box.left + scale(w, 116),
|
||
box.bottom - scale(w, 10)};
|
||
auto thumbnail = v->thumbnails.find(entry.id);
|
||
if (entry.image && thumbnail != v->thumbnails.end() && !thumbnail->second.bgra.empty())
|
||
{
|
||
auto &p = thumbnail->second;
|
||
double ratio =
|
||
std::min(double(icon.right - icon.left) / p.width, double(icon.bottom - icon.top) / p.height);
|
||
int width = int(p.width * ratio), height = int(p.height * ratio);
|
||
BITMAPINFO info{};
|
||
info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
||
info.bmiHeader.biWidth = p.width;
|
||
info.bmiHeader.biHeight = -(LONG)p.height;
|
||
info.bmiHeader.biPlanes = 1;
|
||
info.bmiHeader.biBitCount = 32;
|
||
SetStretchBltMode(dc, HALFTONE);
|
||
StretchDIBits(dc, icon.left + (icon.right - icon.left - width) / 2,
|
||
icon.top + (icon.bottom - icon.top - height) / 2, width, height, 0, 0, p.width,
|
||
p.height, p.bgra.data(), &info, DIB_RGB_COLORS, SRCCOPY);
|
||
}
|
||
else
|
||
{
|
||
FrameRect(dc, &icon, GetSysColorBrush(selected ? COLOR_HIGHLIGHTTEXT : COLOR_3DSHADOW));
|
||
const wchar_t *glyph = entry.image ? L"▧" : entry.files ? L"≡" : L"Aa";
|
||
DrawTextW(dc, glyph, -1, &icon, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
|
||
if (entry.image)
|
||
requestPreview(w, v, entry);
|
||
}
|
||
RECT title{icon.right + scale(w, 14), box.top + scale(w, 10), box.right - scale(w, 14),
|
||
box.bottom - scale(w, 30)};
|
||
auto text = (entry.pinned ? L"★ " : L"") + (entry.image ? L"Image"
|
||
: entry.files ? L"Files"
|
||
: entry.preview);
|
||
bool formatted = false;
|
||
if (!entry.image && !entry.files)
|
||
{
|
||
auto rich = v->richTexts.find(entry.id);
|
||
if (rich != v->richTexts.end() && v->rich && !rich->second.empty())
|
||
{
|
||
setRichText(v->rich, rich->second);
|
||
CHARFORMAT2W format{};
|
||
format.cbSize = sizeof(format);
|
||
format.dwMask = CFM_COLOR;
|
||
format.crTextColor = GetSysColor(selected ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT);
|
||
SendMessageW(v->rich, EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&format);
|
||
SendMessageW(v->rich, EM_SETBKGNDCOLOR, 0,
|
||
GetSysColor(selected ? COLOR_HIGHLIGHT : COLOR_WINDOW));
|
||
FORMATRANGE range{};
|
||
range.hdc = range.hdcTarget = dc;
|
||
range.rc = {MulDiv(title.left, 1440, GetDeviceCaps(dc, LOGPIXELSX)),
|
||
MulDiv(title.top, 1440, GetDeviceCaps(dc, LOGPIXELSY)),
|
||
MulDiv(title.right, 1440, GetDeviceCaps(dc, LOGPIXELSX)),
|
||
MulDiv(title.bottom, 1440, GetDeviceCaps(dc, LOGPIXELSY))};
|
||
range.rcPage = range.rc;
|
||
range.chrg = {0, -1};
|
||
IntersectClipRect(dc, title.left, title.top, title.right, title.bottom);
|
||
SendMessageW(v->rich, EM_FORMATRANGE, TRUE, (LPARAM)&range);
|
||
SendMessageW(v->rich, EM_FORMATRANGE, FALSE, 0);
|
||
// Restore the row clipping before drawing its source label.
|
||
RestoreDC(dc, saved);
|
||
saved = SaveDC(dc);
|
||
SetBkMode(dc, TRANSPARENT);
|
||
SelectObject(dc, GetPropW(w, L"Font"));
|
||
formatted = true;
|
||
}
|
||
else
|
||
requestPreview(w, v, entry);
|
||
}
|
||
if (!formatted)
|
||
DrawTextW(dc, text.c_str(), -1, &title, DT_WORDBREAK | DT_END_ELLIPSIS | DT_NOPREFIX);
|
||
RECT detail{title.left, box.bottom - scale(w, 26), title.right, box.bottom - scale(w, 8)};
|
||
SetTextColor(dc, GetSysColor(selected ? COLOR_HIGHLIGHTTEXT : COLOR_GRAYTEXT));
|
||
auto subtitle = (entry.pinned ? L"★ " : L"") + std::to_wstring(draw.itemID + 1) + L" · " + entry.app;
|
||
DrawTextW(dc, subtitle.c_str(), -1, &detail, DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOPREFIX);
|
||
if (draw.itemState & ODS_FOCUS)
|
||
{
|
||
InflateRect(&box, -2, -2);
|
||
DrawFocusRect(dc, &box);
|
||
}
|
||
RestoreDC(dc, saved);
|
||
}
|
||
LRESULT CALLBACK historyKey(HWND w, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR data)
|
||
{
|
||
HWND parent = (HWND)data;
|
||
if (msg == WM_KEYDOWN)
|
||
{
|
||
if (wp == VK_ESCAPE)
|
||
{
|
||
SendMessageW(parent, WM_CLOSE, 0, 0);
|
||
return 0;
|
||
}
|
||
if (wp == VK_RETURN)
|
||
{
|
||
SendMessageW(parent, WM_COMMAND, (GetKeyState(VK_SHIFT) & 0x8000) ? 111 : 110, 0);
|
||
return 0;
|
||
}
|
||
if (GetKeyState(VK_CONTROL) & 0x8000)
|
||
{
|
||
if (wp >= L'1' && wp <= L'9')
|
||
{
|
||
SendDlgItemMessageW(parent, 102, LB_SETCURSEL, wp - L'1', 0);
|
||
SendMessageW(parent, WM_COMMAND, 110, 0);
|
||
return 0;
|
||
}
|
||
if (wp == L'P')
|
||
{
|
||
SendMessageW(parent, WM_COMMAND, 112, 0);
|
||
return 0;
|
||
}
|
||
if (wp == L'O')
|
||
{
|
||
SendMessageW(parent, WM_COMMAND, 114, 0);
|
||
return 0;
|
||
}
|
||
}
|
||
if (GetDlgCtrlID(w) == 102 && wp == VK_DELETE)
|
||
{
|
||
SendMessageW(parent, WM_COMMAND, 113, 0);
|
||
return 0;
|
||
}
|
||
if (GetDlgCtrlID(w) == 101 && wp == VK_DOWN)
|
||
{
|
||
SetFocus(GetDlgItem(parent, 102));
|
||
return 0;
|
||
}
|
||
}
|
||
return DefSubclassProc(w, msg, wp, lp);
|
||
}
|
||
LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
|
||
{
|
||
auto *v = (HistoryView *)GetWindowLongPtrW(w, GWLP_USERDATA);
|
||
if (msg == WM_NCCREATE)
|
||
{
|
||
auto *app = (App *)((CREATESTRUCTW *)lp)->lpCreateParams;
|
||
v = new HistoryView;
|
||
v->app = app;
|
||
SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR)v);
|
||
return TRUE;
|
||
}
|
||
if (!v)
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
try
|
||
{
|
||
switch (msg)
|
||
{
|
||
case ScrollActivity:
|
||
if((HWND)wp==GetDlgItem(w,102)) {
|
||
v->scrolling=lp!=0;
|
||
if(!v->scrolling) InvalidateRect((HWND)wp,nullptr,FALSE);
|
||
}
|
||
return 0;
|
||
case WM_COMMAND:
|
||
{
|
||
int id = LOWORD(wp);
|
||
if (id == 101 && HIWORD(wp) == EN_CHANGE)
|
||
{
|
||
// Reject an older result even during the debounce interval.
|
||
++v->generation;
|
||
SetTimer(w, 1, 180, nullptr);
|
||
return 0;
|
||
}
|
||
if (id == 102 && HIWORD(wp) == LBN_SELCHANGE)
|
||
{
|
||
updateHistoryActions(w,v);
|
||
return 0;
|
||
}
|
||
if (id == 102 && HIWORD(wp) == LBN_DBLCLK)
|
||
id = 110;
|
||
if (id == 116)
|
||
{
|
||
if (MessageBoxW(w, L"Delete all clipboard history, including pinned items? This also deletes items hidden by the current search.",
|
||
L"Clear history", MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2) == IDYES)
|
||
v->app->clearHistory();
|
||
return 0;
|
||
}
|
||
auto entry = selected(w, v);
|
||
if (id == 110 || id == 111)
|
||
{
|
||
if (!entry.empty())
|
||
v->app->pasteEntry(entry, id == 111);
|
||
return 0;
|
||
}
|
||
if (id == 112 || id == 113)
|
||
{
|
||
if (!entry.empty())
|
||
{
|
||
if (id == 112)
|
||
v->app->history->pin(entry);
|
||
else
|
||
v->app->history->remove(entry);
|
||
search(w, v);
|
||
}
|
||
return 0;
|
||
}
|
||
if (id == 115 && !entry.empty())
|
||
{
|
||
v->app->recognizeEntry(entry);
|
||
return 0;
|
||
}
|
||
if (id == 114 && !entry.empty())
|
||
{
|
||
showEntry(*v->app, entry);
|
||
return 0;
|
||
}
|
||
return 0;
|
||
}
|
||
case WM_TIMER:
|
||
KillTimer(w, 1);
|
||
search(w, v);
|
||
return 0;
|
||
case ResultsMessage:
|
||
{
|
||
std::unique_ptr<SearchResult> result((SearchResult *)lp);
|
||
if (result->generation != v->generation)
|
||
return 0;
|
||
auto old = selected(w, v);
|
||
int top=(int)SendDlgItemMessageW(w,102,LB_GETTOPINDEX,0,0);
|
||
auto topId=top>=0 && top<(int)v->items.size()?v->items[top].id:L"";
|
||
v->items = std::move(result->items);
|
||
SendDlgItemMessageW(w, 102, WM_SETREDRAW, FALSE, 0);
|
||
SendDlgItemMessageW(w, 102, LB_RESETCONTENT, 0, 0);
|
||
int select = 0;
|
||
int restoreTop=0;
|
||
for (size_t i = 0; i < v->items.size(); ++i)
|
||
{
|
||
auto &e = v->items[i];
|
||
auto text = (e.pinned ? L"★ " : L"") + e.preview + L" — " + e.app;
|
||
SendDlgItemMessageW(w, 102, LB_ADDSTRING, 0, (LPARAM)text.c_str());
|
||
if (e.id == old)
|
||
select = (int)i;
|
||
if(e.id==topId) restoreTop=(int)i;
|
||
}
|
||
SendDlgItemMessageW(w, 102, LB_SETCURSEL, select, 0);
|
||
SendDlgItemMessageW(w,102,LB_SETTOPINDEX,restoreTop,0);
|
||
updateHistoryActions(w,v);
|
||
SendDlgItemMessageW(w, 102, WM_SETREDRAW, TRUE, 0);
|
||
InvalidateRect(GetDlgItem(w, 102), nullptr, TRUE);
|
||
return 0;
|
||
}
|
||
case PreviewMessage:
|
||
{
|
||
std::unique_ptr<PreviewResult> result((PreviewResult *)lp);
|
||
if (result->generation != v->generation || !IsWindowVisible(w))
|
||
return 0;
|
||
v->pending.erase(result->id);
|
||
auto list=GetDlgItem(w,102);
|
||
RECT client{}; GetClientRect(list,&client);
|
||
std::set<std::wstring> visible;
|
||
RECT changed{}; bool repaint=false;
|
||
int top=(int)SendMessageW(list,LB_GETTOPINDEX,0,0);
|
||
for(int i=std::max(0,top);i<(int)v->items.size();++i) {
|
||
RECT row{}, intersection{};
|
||
if(SendMessageW(list,LB_GETITEMRECT,i,(LPARAM)&row)==LB_ERR || row.top>=client.bottom) break;
|
||
if(!IntersectRect(&intersection,&row,&client)) continue;
|
||
visible.insert(v->items[i].id);
|
||
if(v->items[i].id==result->id) { changed=intersection; repaint=true; }
|
||
}
|
||
if (!result->rtf.empty())
|
||
v->richTexts[result->id] = std::move(result->rtf);
|
||
else
|
||
v->thumbnails[result->id] = std::move(result->pixels);
|
||
trimHistoryPreviews(v->thumbnails,visible);
|
||
trimHistoryPreviews(v->richTexts,visible);
|
||
if(repaint) InvalidateRect(list,&changed,FALSE);
|
||
return 0;
|
||
}
|
||
case WM_MEASUREITEM:
|
||
if (((MEASUREITEMSTRUCT *)lp)->CtlID == 102)
|
||
{
|
||
((MEASUREITEMSTRUCT *)lp)->itemHeight = scale(w, 88);
|
||
return TRUE;
|
||
}
|
||
break;
|
||
case WM_DRAWITEM:
|
||
if (((DRAWITEMSTRUCT *)lp)->CtlID == 102)
|
||
{
|
||
drawHistoryRow(w, v, *(DRAWITEMSTRUCT *)lp);
|
||
return TRUE;
|
||
}
|
||
break;
|
||
case WM_CONTEXTMENU:
|
||
{
|
||
auto list=GetDlgItem(w,102);
|
||
if((HWND)wp!=list) break;
|
||
POINT p{(short)LOWORD(lp),(short)HIWORD(lp)};
|
||
if(lp!=-1) {
|
||
POINT hit=p; ScreenToClient(list,&hit);
|
||
auto item=SendMessageW(list,LB_ITEMFROMPOINT,0,MAKELPARAM(hit.x,hit.y));
|
||
if(HIWORD(item)) return 0;
|
||
SendMessageW(list,LB_SETCURSEL,LOWORD(item),0);
|
||
updateHistoryActions(w,v);
|
||
} else {
|
||
RECT row{};
|
||
auto index=SendMessageW(list,LB_GETCURSEL,0,0);
|
||
if(index==LB_ERR) return 0;
|
||
SendMessageW(list,LB_GETITEMRECT,index,(LPARAM)&row);
|
||
p={row.left,row.top}; ClientToScreen(list,&p);
|
||
}
|
||
HMENU menu = CreatePopupMenu();
|
||
AppendMenuW(menu, MF_STRING, 110, L"&Paste");
|
||
AppendMenuW(menu, MF_STRING, 111, L"Paste plain &text");
|
||
AppendMenuW(menu, MF_STRING, 112, L"P&in / unpin");
|
||
AppendMenuW(menu, MF_STRING, 113, L"&Delete");
|
||
AppendMenuW(menu, MF_STRING, 114, selectedImage(w,v)?L"&Edit image in screenshot editor":L"&Open full item");
|
||
AppendMenuW(menu, MF_STRING, 115, L"&Copy text from image (OCR)");
|
||
showMenuAccessKeys(menu);
|
||
int cmd = TrackPopupMenu(menu, TPM_RETURNCMD, p.x, p.y, 0, w, nullptr);
|
||
DestroyMenu(menu);
|
||
if (cmd)
|
||
SendMessageW(w, WM_COMMAND, cmd, 0);
|
||
return 0;
|
||
}
|
||
case WM_CLOSE:
|
||
ShowWindow(w, SW_HIDE);
|
||
v->thumbnails.clear();
|
||
v->richTexts.clear();
|
||
if (v->rich)
|
||
SetWindowTextW(v->rich, L"");
|
||
v->pending.clear();
|
||
++v->generation;
|
||
return 0;
|
||
case WM_NCDESTROY:
|
||
disposeFont(w);
|
||
v->app->historyWindow = nullptr;
|
||
delete v;
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
}
|
||
catch (const std::exception &e)
|
||
{
|
||
error(w, e);
|
||
}
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
|
||
#endif
|
||
#ifndef KS_RESIDENT_APP
|
||
struct SettingsView
|
||
{
|
||
App *app{};
|
||
Settings draft;
|
||
std::vector<int> order;
|
||
int selection = -1;
|
||
bool filling{};
|
||
};
|
||
void collectLayout(HWND w, SettingsView *v)
|
||
{
|
||
if (v->selection < 0 || v->selection >= (int)v->order.size())
|
||
return;
|
||
int index = v->order[v->selection];
|
||
auto id = v->app->layouts[index].id;
|
||
auto &cycle = v->draft.cycle;
|
||
std::erase(cycle, id);
|
||
if (checked(w, 230))
|
||
cycle.push_back(id);
|
||
if (v->draft.direct.size() < v->app->layouts.size())
|
||
v->draft.direct.resize(v->app->layouts.size());
|
||
v->draft.direct[index] = value(w, 231);
|
||
}
|
||
void layoutSelection(HWND w, SettingsView *v)
|
||
{
|
||
v->selection = (int)SendDlgItemMessageW(w, 220, LB_GETCURSEL, 0, 0);
|
||
if (v->selection < 0)
|
||
return;
|
||
int i = v->order[v->selection];
|
||
auto &l = v->app->layouts[i];
|
||
check(w, 230, std::find(v->draft.cycle.begin(), v->draft.cycle.end(), l.id) != v->draft.cycle.end());
|
||
EnableWindow(GetDlgItem(w, 230), l.convertible);
|
||
value(w, 231, i < (int)v->draft.direct.size() ? v->draft.direct[i] : L"");
|
||
}
|
||
void fillLayouts(HWND w, SettingsView *v)
|
||
{
|
||
SendDlgItemMessageW(w, 220, LB_RESETCONTENT, 0, 0);
|
||
for (int i : v->order)
|
||
{
|
||
auto &l = v->app->layouts[i];
|
||
bool on = std::find(v->draft.cycle.begin(), v->draft.cycle.end(), l.id) != v->draft.cycle.end();
|
||
auto title = (on ? L"[✓] " : L"[ ] ") + l.name + (l.convertible ? L"" : L" — switch only");
|
||
SendDlgItemMessageW(w, 220, LB_ADDSTRING, 0, (LPARAM)title.c_str());
|
||
}
|
||
SendDlgItemMessageW(w, 220, LB_SETCURSEL, std::max(0, v->selection), 0);
|
||
layoutSelection(w, v);
|
||
}
|
||
void fillSettings(HWND w, SettingsView *v)
|
||
{
|
||
v->filling = true;
|
||
auto &s = v->draft;
|
||
check(w, 201, s.recent);
|
||
check(w, 202, s.switchLayout);
|
||
check(w, 208, s.writeLog);
|
||
check(w, 209, s.screenshotAutoOpenEditor);
|
||
check(w, 203, s.history);
|
||
check(w, 204, s.autostart);
|
||
check(w, 206, s.elevatedAutostart);
|
||
check(w, 205, s.awake);
|
||
check(w, 207, s.autoCorrect);
|
||
value(w, 210, s.toggle);
|
||
value(w, 211, s.casing);
|
||
value(w, 212, s.translit);
|
||
value(w, 213, s.undo);
|
||
value(w, 214, s.clipboard);
|
||
value(w, 215, s.screenshot);
|
||
value(w, 240, std::to_wstring(s.maxItems));
|
||
value(w, 241, std::to_wstring(s.maxMiB));
|
||
value(w, 242, std::to_wstring(s.maxImageMiB));
|
||
std::wstring excluded;
|
||
for (auto &name : s.excluded)
|
||
{
|
||
if (!excluded.empty())
|
||
excluded += L", ";
|
||
excluded += name;
|
||
}
|
||
value(w, 243, excluded);
|
||
v->order.clear();
|
||
for (auto &id : s.cycle)
|
||
for (int i = 0; i < (int)v->app->layouts.size(); ++i)
|
||
if (v->app->layouts[i].id == id)
|
||
v->order.push_back(i);
|
||
for (int i = 0; i < (int)v->app->layouts.size(); ++i)
|
||
if (std::find(v->order.begin(), v->order.end(), i) == v->order.end())
|
||
v->order.push_back(i);
|
||
v->selection = 0;
|
||
fillLayouts(w, v);
|
||
v->filling = false;
|
||
}
|
||
int integer(HWND w, int id)
|
||
{
|
||
auto s = value(w, id);
|
||
size_t n{};
|
||
int v = std::stoi(s, &n);
|
||
if (n != s.size())
|
||
throw std::runtime_error("Enter a whole number for history limits");
|
||
return v;
|
||
}
|
||
Settings collectSettings(HWND w, SettingsView *v)
|
||
{
|
||
collectLayout(w, v);
|
||
auto s = v->draft;
|
||
s.recent = checked(w, 201);
|
||
s.switchLayout = checked(w, 202);
|
||
s.writeLog = checked(w, 208);
|
||
s.screenshotAutoOpenEditor = checked(w, 209);
|
||
s.history = checked(w, 203);
|
||
s.autostart = checked(w, 204);
|
||
s.elevatedAutostart = checked(w, 206);
|
||
s.awake = checked(w, 205);
|
||
s.autoCorrect = checked(w, 207);
|
||
s.toggle = value(w, 210);
|
||
s.casing = value(w, 211);
|
||
s.translit = value(w, 212);
|
||
s.undo = value(w, 213);
|
||
s.clipboard = value(w, 214);
|
||
s.screenshot = value(w, 215);
|
||
s.maxItems = integer(w, 240);
|
||
s.maxMiB = integer(w, 241);
|
||
s.maxImageMiB = integer(w, 242);
|
||
s.excluded.clear();
|
||
std::wistringstream input(value(w, 243));
|
||
std::wstring item;
|
||
while (std::getline(input, item, L','))
|
||
{
|
||
auto first = item.find_first_not_of(L" \t"), last = item.find_last_not_of(L" \t");
|
||
if (first != item.npos)
|
||
s.excluded.push_back(item.substr(first, last - first + 1));
|
||
}
|
||
std::vector<std::wstring> cycle;
|
||
for (int i : v->order)
|
||
{
|
||
auto id = v->app->layouts[i].id;
|
||
if (std::find(s.cycle.begin(), s.cycle.end(), id) != s.cycle.end())
|
||
cycle.push_back(id);
|
||
}
|
||
s.cycle = cycle;
|
||
validateSettings(s);
|
||
return s;
|
||
}
|
||
struct AutoOptionsView
|
||
{
|
||
HWND parent;
|
||
SettingsView *settings;
|
||
};
|
||
std::wstring commaList(const std::vector<std::wstring> &items)
|
||
{
|
||
std::wstring text;
|
||
for (auto &item : items)
|
||
{
|
||
if (!text.empty())
|
||
text += L", ";
|
||
text += item;
|
||
}
|
||
return text;
|
||
}
|
||
std::vector<std::wstring> parseCommaList(const std::wstring &text)
|
||
{
|
||
std::vector<std::wstring> items;
|
||
std::wistringstream input(text);
|
||
std::wstring item;
|
||
while (std::getline(input, item, L','))
|
||
{
|
||
auto first = item.find_first_not_of(L" \t\r\n"), last = item.find_last_not_of(L" \t\r\n");
|
||
if (first != item.npos)
|
||
items.push_back(item.substr(first, last - first + 1));
|
||
}
|
||
return items;
|
||
}
|
||
LRESULT CALLBACK autoOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
|
||
{
|
||
auto *view = (AutoOptionsView *)GetWindowLongPtrW(w, GWLP_USERDATA);
|
||
if (!view)
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
if (msg == WM_COMMAND && LOWORD(wp) == 407)
|
||
{
|
||
auto folder = std::filesystem::path(executable()).parent_path() / L"dictionaries";
|
||
if ((INT_PTR)ShellExecuteW(w, L"open", folder.c_str(), nullptr, nullptr, SW_SHOWNORMAL) <= 32)
|
||
MessageBoxW(w, L"Could not open the dictionary folder.", L"KSwitcher", MB_OK | MB_ICONERROR);
|
||
return 0;
|
||
}
|
||
if (msg == WM_COMMAND && LOWORD(wp) == IDOK)
|
||
{
|
||
try
|
||
{
|
||
auto draft = view->settings->draft;
|
||
auto lengthText = value(w, 410);
|
||
if (lengthText.empty() || lengthText.size() > 2 ||
|
||
lengthText.find_first_not_of(L"0123456789") != lengthText.npos)
|
||
throw std::runtime_error("Minimum word length must be between 1 and 32 letters");
|
||
draft.autoMinLength = std::stoi(lengthText);
|
||
auto rankText = value(w, 406);
|
||
if (rankText.empty() || rankText.find_first_not_of(L"0123456789") != rankText.npos)
|
||
throw std::runtime_error("Enter a non-negative whole number for the frequency rank limit");
|
||
try
|
||
{
|
||
draft.autoMaxRank = std::stoi(rankText);
|
||
}
|
||
catch (...)
|
||
{
|
||
throw std::runtime_error("Frequency rank limit is too large");
|
||
}
|
||
draft.autoLanguages.clear();
|
||
if (checked(w, 401))
|
||
draft.autoLanguages.push_back(L"en");
|
||
if (checked(w, 402))
|
||
draft.autoLanguages.push_back(L"uk");
|
||
if (checked(w, 403))
|
||
draft.autoLanguages.push_back(L"ru");
|
||
draft.autoNever = parseCommaList(value(w, 405));
|
||
for (auto [id, language] : {std::pair{411, L"en"}, {412, L"uk"}, {413, L"ru"}})
|
||
{
|
||
auto text = lower(value(w, id));
|
||
std::replace(text.begin(), text.end(), L'\n', L',');
|
||
auto words = parseCommaList(text);
|
||
std::sort(words.begin(), words.end());
|
||
words.erase(std::unique(words.begin(), words.end()), words.end());
|
||
draft.autoWords[language] = std::move(words);
|
||
}
|
||
draft.autoExcluded = parseCommaList(value(w, 404));
|
||
draft.autoPrefixChars = value(w, 408);
|
||
draft.autoSuffixChars = value(w, 409);
|
||
draft.autoReplace = checked(w, 414);
|
||
draft.autoTypos = checked(w, 415);
|
||
draft.autoReplacements.clear();
|
||
std::wistringstream replacements(lower(value(w, 416)));
|
||
std::wstring line;
|
||
auto trim = [](std::wstring text)
|
||
{
|
||
auto first = text.find_first_not_of(L" \t\r\n");
|
||
return first == text.npos ? std::wstring{} : text.substr(first, text.find_last_not_of(L" \t\r\n") - first + 1);
|
||
};
|
||
while (std::getline(replacements, line))
|
||
{
|
||
if (trim(line).empty()) continue;
|
||
auto equals = line.find(L'=');
|
||
if (equals == line.npos)
|
||
throw std::runtime_error("Enter one replacement per line: typo=correction");
|
||
if (!draft.autoReplacements.emplace(trim(line.substr(0, equals)), trim(line.substr(equals + 1))).second)
|
||
throw std::runtime_error("Each replacement typo must occur only once");
|
||
}
|
||
if (draft.autoLanguages.size() < 2)
|
||
throw std::runtime_error("Select at least two languages");
|
||
validateSettings(draft);
|
||
view->settings->draft.autoLanguages = draft.autoLanguages;
|
||
view->settings->draft.autoNever = draft.autoNever;
|
||
view->settings->draft.autoWords = draft.autoWords;
|
||
view->settings->draft.autoExcluded = draft.autoExcluded;
|
||
view->settings->draft.autoMaxRank = draft.autoMaxRank;
|
||
view->settings->draft.autoMinLength = draft.autoMinLength;
|
||
view->settings->draft.autoPrefixChars = draft.autoPrefixChars;
|
||
view->settings->draft.autoSuffixChars = draft.autoSuffixChars;
|
||
view->settings->draft.autoReplace = draft.autoReplace;
|
||
view->settings->draft.autoTypos = draft.autoTypos;
|
||
view->settings->draft.autoReplacements = std::move(draft.autoReplacements);
|
||
DestroyWindow(w);
|
||
}
|
||
catch (const std::exception &e)
|
||
{
|
||
error(w, e);
|
||
}
|
||
return 0;
|
||
}
|
||
if ((msg == WM_COMMAND && LOWORD(wp) == IDCANCEL) || msg == WM_CLOSE)
|
||
{
|
||
DestroyWindow(w);
|
||
return 0;
|
||
}
|
||
if (msg == WM_DPICHANGED)
|
||
{
|
||
resizeForDpi(w, wp, lp);
|
||
return 0;
|
||
}
|
||
if (msg == WM_NCDESTROY)
|
||
{
|
||
EnableWindow(view->parent, TRUE);
|
||
SetForegroundWindow(view->parent);
|
||
disposeFont(w);
|
||
delete view;
|
||
SetWindowLongPtrW(w, GWLP_USERDATA, 0);
|
||
}
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
void showAutoOptions(HWND parent, SettingsView *v)
|
||
{
|
||
HWND w = makeWindow(*v->app, L"KSwitcher.AutoOptions", L"Automatic correction", autoOptionsProc,
|
||
560, 880);
|
||
windowLayoutState(w)->autoOptions = true;
|
||
SetWindowLongPtrW(w, GWLP_HWNDPARENT, (LONG_PTR)parent);
|
||
SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR) new AutoOptionsView{parent, v});
|
||
label(w, L"Offline dictionaries (only layouts in your cycle are used)", 18, 16, 525);
|
||
checkbox(w, L"&English", 401, 18, 48, 150);
|
||
checkbox(w, L"&Ukrainian", 402, 188, 48, 150);
|
||
checkbox(w, L"&Russian", 403, 358, 48, 150);
|
||
for (auto &lang : v->draft.autoLanguages)
|
||
check(w, lang == L"en" ? 401 : lang == L"uk" ? 402 : 403, true);
|
||
label(w, L"Excluded applications (process names, comma-separated)", 18, 94, 525);
|
||
edit(w, 404, 18, 122, 524, 52, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
|
||
value(w, 404, commaList(v->draft.autoExcluded));
|
||
label(w, L"Never correct these words (comma-separated)", 18, 184, 525);
|
||
edit(w, 405, 18, 212, 524, 52, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
|
||
value(w, 405, commaList(v->draft.autoNever));
|
||
label(w, L"My dictionary: correct words, separated by commas or new lines", 18, 276, 525);
|
||
for (auto [id, language] : {std::pair{411, L"en"}, {412, L"uk"}, {413, L"ru"}})
|
||
{
|
||
int x = 18 + (id - 411) * 178;
|
||
label(w, id == 411 ? L"En&glish" : id == 412 ? L"U&krainian" : L"Ru&ssian", x, 302, 168);
|
||
edit(w, id, x, 328, 168, 56, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL | ES_WANTRETURN);
|
||
auto words = v->draft.autoWords.find(language);
|
||
if (words != v->draft.autoWords.end()) value(w, id, commaList(words->second));
|
||
}
|
||
label(w, L"Frequency rank limit (0 = entire dictionary)", 18, 400, 390);
|
||
edit(w, 406, 420, 396, 122, 26, ES_NUMBER);
|
||
value(w, 406, std::to_wstring(v->draft.autoMaxRank));
|
||
label(w, L"Minimum word length (1–32 letters)", 18, 434, 390);
|
||
edit(w, 410, 420, 430, 122, 26, ES_NUMBER);
|
||
value(w, 410, std::to_wstring(v->draft.autoMinLength));
|
||
label(w, L"Characters before a word", 18, 474, 250);
|
||
label(w, L"Characters after a word", 290, 474, 250);
|
||
edit(w, 408, 18, 500, 252);
|
||
edit(w, 409, 290, 500, 252);
|
||
value(w, 408, v->draft.autoPrefixChars);
|
||
value(w, 409, v->draft.autoSuffixChars);
|
||
label(w, L"Enter punctuation without spaces or separators. These characters are kept.", 18, 530, 525);
|
||
checkbox(w, L"Use custom &replacements (take priority over dictionaries)", 414, 18, 562, 524);
|
||
check(w, 414, v->draft.autoReplace);
|
||
label(w, L"One pair per line: typo=correction (same language, letters only)", 18, 592, 525);
|
||
edit(w, 416, 18, 618, 524, 70, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL | ES_WANTRETURN);
|
||
std::wstring pairs;
|
||
for (const auto &[from, to] : v->draft.autoReplacements) pairs += from + L"=" + to + L"\r\n";
|
||
value(w, 416, pairs);
|
||
checkbox(w, L"Correct spelling &typos using dictionaries (experimental)", 415, 18, 700, 524);
|
||
check(w, 415, v->draft.autoTypos);
|
||
label(w, L"Single edits, 4+ letters; ambiguous words are left unchanged.", 18, 730, 525);
|
||
button(w, L"Open dictionary &folder", 407, 18, 762, 220);
|
||
label(w, L"Click OK, then Save in Settings. Enable automatic correction there.", 18, 800, 525);
|
||
button(w, L"&OK", IDOK, 326, 832, 100);
|
||
button(w, L"&Cancel", IDCANCEL, 440, 832, 100);
|
||
RECT initial{};
|
||
GetWindowRect(w, &initial);
|
||
initial.right += scale(w, 200);
|
||
initial.bottom += scale(w, 140);
|
||
fitToMonitor(w, initial);
|
||
EnableWindow(parent, FALSE);
|
||
showRequestedWindow(w);
|
||
SetForegroundWindow(w);
|
||
}
|
||
struct OcrOptionsView { HWND parent; SettingsView *settings; };
|
||
Settings ocrDraft(HWND w, OcrOptionsView *v)
|
||
{
|
||
auto draft = v->settings->draft;
|
||
draft.useTesseract = checked(w, 501);
|
||
draft.tesseractPath = value(w, 502);
|
||
draft.tesseractLanguages = value(w, 503);
|
||
validateSettings(draft);
|
||
return draft;
|
||
}
|
||
LRESULT CALLBACK ocrOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
|
||
{
|
||
auto *v = reinterpret_cast<OcrOptionsView *>(GetWindowLongPtrW(w, GWLP_USERDATA));
|
||
if (!v) return DefWindowProcW(w, msg, wp, lp);
|
||
if (msg == WM_COMMAND)
|
||
{
|
||
int id = LOWORD(wp);
|
||
try
|
||
{
|
||
if (id == 507)
|
||
{
|
||
if ((INT_PTR)ShellExecuteW(w, L"open", L"https://github.com/UB-Mannheim/tesseract/wiki#tesseract-installer-for-windows",
|
||
nullptr, nullptr, SW_SHOWNORMAL) <= 32)
|
||
throw std::runtime_error("Could not open the Tesseract download page in your browser");
|
||
return 0;
|
||
}
|
||
if (id == 504)
|
||
{
|
||
wchar_t path[32768]{};
|
||
OPENFILENAMEW picker{sizeof(picker)};
|
||
picker.hwndOwner = w; picker.lpstrFile = path; picker.nMaxFile = std::size(path);
|
||
picker.lpstrFilter = L"Tesseract executable (tesseract.exe)\0tesseract.exe\0Executables\0*.exe\0";
|
||
picker.Flags = OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
|
||
if (GetOpenFileNameW(&picker)) value(w, 502, path);
|
||
return 0;
|
||
}
|
||
if (id == 505 || id == IDOK)
|
||
{
|
||
auto draft = ocrDraft(w, v);
|
||
if (id == 505)
|
||
{
|
||
draft.useTesseract = true;
|
||
validateTesseract(draft);
|
||
SetDlgItemTextW(w, 506, (L"Ready: " + draft.tesseractLanguages).c_str());
|
||
return 0;
|
||
}
|
||
validateTesseract(draft);
|
||
v->settings->draft.useTesseract = draft.useTesseract;
|
||
v->settings->draft.tesseractPath = draft.tesseractPath;
|
||
v->settings->draft.tesseractLanguages = draft.tesseractLanguages;
|
||
DestroyWindow(w);
|
||
return 0;
|
||
}
|
||
if (id == IDCANCEL) { DestroyWindow(w); return 0; }
|
||
}
|
||
catch (const std::exception &e) { error(w, e); return 0; }
|
||
}
|
||
if (msg == WM_CLOSE) { DestroyWindow(w); return 0; }
|
||
if (msg == WM_NCDESTROY)
|
||
{
|
||
EnableWindow(v->parent, TRUE);
|
||
SetForegroundWindow(v->parent);
|
||
disposeFont(w); delete v;
|
||
SetWindowLongPtrW(w, GWLP_USERDATA, 0);
|
||
}
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
void showOcrOptions(HWND parent, SettingsView *v)
|
||
{
|
||
HWND w = makeWindow(*v->app, L"KSwitcher.OcrOptions", L"Image text recognition", ocrOptionsProc, 640, 450);
|
||
SetWindowLongPtrW(w, GWLP_HWNDPARENT, (LONG_PTR)parent);
|
||
SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR)new OcrOptionsView{parent, v});
|
||
label(w, L"Windows OCR is used by default. Recognition stays on this computer.", 18, 16, 600);
|
||
checkbox(w, L"&Use optional Tesseract 5 instead of Windows OCR", 501, 18, 48, 600);
|
||
check(w, 501, v->draft.useTesseract);
|
||
label(w, L"Tesseract executable (blank = detect installed location)", 18, 90, 600);
|
||
edit(w, 502, 18, 118, 484);
|
||
value(w, 502, v->draft.tesseractPath);
|
||
button(w, L"&Browse…", 504, 514, 117, 106);
|
||
label(w, L"Languages used together (for example ukr+eng+rus)", 18, 160, 600);
|
||
edit(w, 503, 18, 188, 602);
|
||
value(w, 503, v->draft.tesseractLanguages);
|
||
button(w, L"Check &installation", 505, 18, 228, 180);
|
||
control(w, L"STATIC", L"", 0, 506, 212, 232, 408, 24);
|
||
button(w, L"&Download Tesseract…", 507, 18, 266, 180);
|
||
label(w, L"Opens the Windows installer page in your browser.", 212, 270, 408);
|
||
label(w, L"Changing the engine or languages reprocesses saved images in the background.", 18, 314, 602);
|
||
label(w, L"Click OK here, then Save in Settings to apply. No downloads are automatic.", 18, 344, 602);
|
||
button(w, L"&OK", IDOK, 406, 390, 100);
|
||
button(w, L"&Cancel", IDCANCEL, 520, 390, 100);
|
||
EnableWindow(parent, FALSE);
|
||
showRequestedWindow(w); SetForegroundWindow(w);
|
||
}
|
||
#include "ui_sync.inl"
|
||
bool settingsChanged(HWND w, SettingsView *v)
|
||
{
|
||
try
|
||
{
|
||
return encodeSettings(collectSettings(w, v)) != encodeSettings(v->app->settings);
|
||
}
|
||
catch (const std::exception &)
|
||
{
|
||
// Invalid edits are unsaved changes too. Allow discarding them without
|
||
// requiring the user to repair the fields first.
|
||
return true;
|
||
}
|
||
}
|
||
void closeSettings(HWND w, SettingsView *v)
|
||
{
|
||
if (settingsChanged(w, v))
|
||
{
|
||
int choice = MessageBoxW(w,
|
||
L"You have unsaved settings changes. Save them before closing?\n\n"
|
||
L"Yes: save and close.\nNo: discard changes.\nCancel: keep editing.",
|
||
L"KSwitcher — Unsaved settings", MB_YESNOCANCEL | MB_ICONWARNING | MB_DEFBUTTON3);
|
||
if (choice != IDYES && choice != IDNO)
|
||
return;
|
||
if (choice == IDYES)
|
||
{
|
||
try
|
||
{
|
||
if (v->app->busy)
|
||
throw std::runtime_error("Wait for the current text operation to finish");
|
||
v->app->applySettings(collectSettings(w, v));
|
||
}
|
||
catch (const std::exception &e)
|
||
{
|
||
error(w, e);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
DestroyWindow(w);
|
||
}
|
||
LRESULT CALLBACK settingsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
|
||
{
|
||
if (msg == WM_DPICHANGED)
|
||
{
|
||
resizeForDpi(w, wp, lp);
|
||
return 0;
|
||
}
|
||
auto *v = (SettingsView *)GetWindowLongPtrW(w, GWLP_USERDATA);
|
||
if (msg == WM_NCCREATE)
|
||
{
|
||
auto *app = (App *)((CREATESTRUCTW *)lp)->lpCreateParams;
|
||
v = new SettingsView{app, app->settings};
|
||
SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR)v);
|
||
return TRUE;
|
||
}
|
||
if (!v)
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
try
|
||
{
|
||
switch (msg)
|
||
{
|
||
case WM_COMMAND:
|
||
{
|
||
int id = LOWORD(wp);
|
||
if (id == 220 && HIWORD(wp) == LBN_SELCHANGE && !v->filling)
|
||
{
|
||
collectLayout(w, v);
|
||
layoutSelection(w, v);
|
||
return 0;
|
||
}
|
||
if (id == 256)
|
||
{
|
||
showLogs(*v->app);
|
||
return 0;
|
||
}
|
||
if (id == 257) { showOcrOptions(w, v); return 0; }
|
||
if (id == 258) { showSyncOptions(w, *v->app); return 0; }
|
||
if (id == 230)
|
||
{
|
||
collectLayout(w, v);
|
||
fillLayouts(w, v);
|
||
return 0;
|
||
}
|
||
if (id == 232 || id == 233)
|
||
{
|
||
collectLayout(w, v);
|
||
int next = v->selection + (id == 232 ? -1 : 1);
|
||
if (next >= 0 && next < (int)v->order.size())
|
||
{
|
||
std::swap(v->order[next], v->order[v->selection]);
|
||
v->selection = next;
|
||
fillLayouts(w, v);
|
||
}
|
||
return 0;
|
||
}
|
||
if (id == IDOK)
|
||
{
|
||
if (v->app->busy)
|
||
throw std::runtime_error("Wait for the current text operation to finish");
|
||
v->app->applySettings(collectSettings(w, v));
|
||
DestroyWindow(w);
|
||
return 0;
|
||
}
|
||
if (id == IDCANCEL)
|
||
{
|
||
closeSettings(w, v);
|
||
return 0;
|
||
}
|
||
if (id == 250)
|
||
{
|
||
auto path = pickFile(w, false);
|
||
if (!path.empty())
|
||
{
|
||
v->draft = loadSettings(path, v->app->layouts);
|
||
fillSettings(w, v);
|
||
}
|
||
return 0;
|
||
}
|
||
if (id == 251)
|
||
{
|
||
auto s = collectSettings(w, v);
|
||
auto path = pickFile(w, true);
|
||
if (!path.empty())
|
||
saveSettings(path, s);
|
||
return 0;
|
||
}
|
||
if (id == 255)
|
||
{
|
||
showAutoOptions(w, v);
|
||
return 0;
|
||
}
|
||
if (id == 252)
|
||
{
|
||
showSnippets(*v->app);
|
||
return 0;
|
||
}
|
||
if (id == 253)
|
||
{
|
||
if (v->app->busy)
|
||
throw std::runtime_error("Wait for the current operation");
|
||
v->draft = collectSettings(w, v);
|
||
v->app->reloadLayouts();
|
||
v->draft.direct = v->app->settings.direct;
|
||
fillSettings(w, v);
|
||
return 0;
|
||
}
|
||
if (id == 254)
|
||
{
|
||
if (MessageBoxW(w, L"Delete all clipboard history, including pinned items?", L"Clear history",
|
||
MB_YESNO | MB_ICONWARNING) == IDYES)
|
||
v->app->clearHistory();
|
||
return 0;
|
||
}
|
||
break;
|
||
}
|
||
case WM_CLOSE:
|
||
closeSettings(w, v);
|
||
return 0;
|
||
case WM_NCDESTROY:
|
||
disposeFont(w);
|
||
v->app->settingsWindow = nullptr;
|
||
delete v;
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
}
|
||
catch (const std::exception &e)
|
||
{
|
||
error(w, e);
|
||
}
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
struct SnippetView
|
||
{
|
||
App *app;
|
||
std::vector<Snippet> snippets;
|
||
int selection = -1;
|
||
};
|
||
void updateSnippetEditor(HWND w, SnippetView *v)
|
||
{
|
||
bool selected = v->selection >= 0 && v->selection < (int)v->snippets.size();
|
||
value(w, 302, selected ? v->snippets[v->selection].trigger : L"");
|
||
value(w, 303, selected ? v->snippets[v->selection].text : L"");
|
||
for (int id : {302, 303, 311, 312, 313})
|
||
EnableWindow(GetDlgItem(w, id), selected);
|
||
}
|
||
void fillSnippets(HWND w, SnippetView *v)
|
||
{
|
||
SendDlgItemMessageW(w, 301, LB_RESETCONTENT, 0, 0);
|
||
for (auto &sn : v->snippets)
|
||
SendDlgItemMessageW(w, 301, LB_ADDSTRING, 0, (LPARAM)sn.trigger.c_str());
|
||
if (v->selection >= 0)
|
||
SendDlgItemMessageW(w, 301, LB_SETCURSEL, v->selection, 0);
|
||
updateSnippetEditor(w, v);
|
||
}
|
||
void collectSnippet(HWND w, SnippetView *v)
|
||
{
|
||
if (v->selection >= 0 && v->selection < (int)v->snippets.size())
|
||
{
|
||
auto &snippet = v->snippets[v->selection];
|
||
if (snippet.id.empty()) snippet.id = snippetId(snippet);
|
||
snippet.trigger = value(w, 302);
|
||
snippet.text = value(w, 303);
|
||
}
|
||
}
|
||
LRESULT CALLBACK snippetProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
|
||
{
|
||
if (msg == WM_DPICHANGED)
|
||
{
|
||
resizeForDpi(w, wp, lp);
|
||
return 0;
|
||
}
|
||
auto *v = (SnippetView *)GetWindowLongPtrW(w, GWLP_USERDATA);
|
||
if (msg == WM_NCCREATE)
|
||
{
|
||
auto *app = (App *)((CREATESTRUCTW *)lp)->lpCreateParams;
|
||
v = new SnippetView{app, app->settings.snippets};
|
||
SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR)v);
|
||
return TRUE;
|
||
}
|
||
if (!v)
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
try
|
||
{
|
||
switch (msg)
|
||
{
|
||
case WM_COMMAND:
|
||
{
|
||
int id = LOWORD(wp);
|
||
if (id == 301 && HIWORD(wp) == LBN_SELCHANGE)
|
||
{
|
||
collectSnippet(w, v);
|
||
v->selection = (int)SendDlgItemMessageW(w, 301, LB_GETCURSEL, 0, 0);
|
||
updateSnippetEditor(w, v);
|
||
return 0;
|
||
}
|
||
if (id == 310)
|
||
{
|
||
collectSnippet(w, v);
|
||
v->snippets.push_back({L";new", L"", newSnippetId()});
|
||
v->selection = (int)v->snippets.size() - 1;
|
||
fillSnippets(w, v);
|
||
SetFocus(GetDlgItem(w, 302));
|
||
return 0;
|
||
}
|
||
if (id == 311)
|
||
{
|
||
if (v->selection >= 0)
|
||
{
|
||
v->snippets.erase(v->snippets.begin() + v->selection);
|
||
v->selection = -1;
|
||
fillSnippets(w, v);
|
||
SetFocus(GetDlgItem(w, 301));
|
||
}
|
||
return 0;
|
||
}
|
||
if (id == 312 || id == 313)
|
||
{
|
||
if (v->selection < 0 || v->selection >= (int)v->snippets.size()) return 0;
|
||
SendDlgItemMessageW(w, 303, EM_REPLACESEL, TRUE, (LPARAM)(id == 312 ? L"{cursor}" : L"{enter}"));
|
||
return 0;
|
||
}
|
||
if (id == IDOK)
|
||
{
|
||
collectSnippet(w, v);
|
||
auto s = v->app->settings;
|
||
s.snippets = v->snippets;
|
||
if (v->app->busy)
|
||
throw std::runtime_error("Wait for the current operation");
|
||
v->app->applySettings(s);
|
||
if (v->app->settingsWindow)
|
||
{
|
||
auto *parent = (SettingsView *)GetWindowLongPtrW(v->app->settingsWindow, GWLP_USERDATA);
|
||
parent->draft.snippets = s.snippets;
|
||
}
|
||
DestroyWindow(w);
|
||
return 0;
|
||
}
|
||
if (id == IDCANCEL)
|
||
{
|
||
DestroyWindow(w);
|
||
return 0;
|
||
}
|
||
break;
|
||
}
|
||
case WM_CLOSE:
|
||
DestroyWindow(w);
|
||
return 0;
|
||
case WM_NCDESTROY:
|
||
disposeFont(w);
|
||
v->app->snippetsWindow = nullptr;
|
||
delete v;
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
}
|
||
catch (const std::exception &e)
|
||
{
|
||
error(w, e);
|
||
}
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
#endif
|
||
#ifndef KS_CONFIG_APP
|
||
LRESULT CALLBACK entryProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
|
||
{
|
||
if (msg == WM_SIZE)
|
||
{
|
||
MoveWindow(GetDlgItem(w, 1), 10, 10, LOWORD(lp) - 20, HIWORD(lp) - 20, TRUE);
|
||
return 0;
|
||
}
|
||
if (msg == WM_NCDESTROY)
|
||
disposeFont(w);
|
||
return DefWindowProcW(w, msg, wp, lp);
|
||
}
|
||
#endif
|
||
} // namespace
|
||
#ifndef KS_CONFIG_APP
|
||
void refreshHistory(App &app)
|
||
{
|
||
if (app.historyWindow)
|
||
{
|
||
auto *v = (HistoryView *)GetWindowLongPtrW(app.historyWindow, GWLP_USERDATA);
|
||
search(app.historyWindow, v);
|
||
}
|
||
}
|
||
void showHistory(App &app, bool visible)
|
||
{
|
||
if (!app.history)
|
||
{
|
||
app.report(L"Clipboard history is unavailable. See the log in the data folder.");
|
||
return;
|
||
}
|
||
HWND foreground = GetForegroundWindow();
|
||
if (visible && app.historyWindow && IsWindowVisible(app.historyWindow) && foreground == app.historyWindow)
|
||
{
|
||
auto *v = (HistoryView *)GetWindowLongPtrW(app.historyWindow, GWLP_USERDATA);
|
||
if (v->items.size() > 1)
|
||
app.pasteEntry(v->items[1].id, false);
|
||
return;
|
||
}
|
||
if (foreground != app.window && foreground != app.historyWindow)
|
||
app.pasteTarget = foreground;
|
||
if (!app.historyWindow)
|
||
{
|
||
HWND w = makeWindow(app, L"KSwitcher.History", L"Clipboard history", historyProc, 760, 500);
|
||
app.historyWindow = w;
|
||
windowLayoutState(w)->history = true;
|
||
((HistoryView *)GetWindowLongPtrW(w, GWLP_USERDATA))->rich = createRichText(w, 105, false);
|
||
label(w, L"&Search clipboard history", 16, 12, 500);
|
||
edit(w, 101, 16, 38, 728);
|
||
auto list = control(w, L"LISTBOX", L"",
|
||
WS_TABSTOP | WS_VSCROLL | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | WS_BORDER |
|
||
LBS_OWNERDRAWFIXED | LBS_HASSTRINGS,
|
||
102, 16, 76, 728, 360);
|
||
SendMessageW(list, LB_SETITEMHEIGHT, 0, scale(w, 88));
|
||
button(w, L"&Paste", 110, 16, 452, 90);
|
||
button(w, L"Plain &text", 111, 114, 452, 100);
|
||
button(w, L"P&in / unpin", 112, 222, 452, 110);
|
||
button(w, L"&Delete", 113, 340, 452, 90);
|
||
button(w, L"&Open item", 114, 438, 452, 100);
|
||
button(w, L"Clear &history…", 116, 546, 452, 150);
|
||
SetWindowSubclass(list, historyKey, 1, (DWORD_PTR)w);
|
||
SetWindowSubclass(GetDlgItem(w, 101), historyKey, 1, (DWORD_PTR)w);
|
||
}
|
||
if (!visible) return;
|
||
POINT cursor;
|
||
GetCursorPos(&cursor);
|
||
MONITORINFO monitor{sizeof(monitor)};
|
||
GetMonitorInfoW(MonitorFromPoint(cursor, MONITOR_DEFAULTTONEAREST), &monitor);
|
||
RECT r;
|
||
GetWindowRect(app.historyWindow, &r);
|
||
int x = std::max(monitor.rcWork.left, std::min(cursor.x, monitor.rcWork.right - (r.right - r.left)));
|
||
int y = std::max(monitor.rcWork.top, std::min(cursor.y, monitor.rcWork.bottom - (r.bottom - r.top)));
|
||
SetWindowPos(app.historyWindow, HWND_TOP, x, y, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW);
|
||
SetForegroundWindow(app.historyWindow);
|
||
SetFocus(GetDlgItem(app.historyWindow, 101));
|
||
refreshHistory(app);
|
||
}
|
||
#endif
|
||
#ifndef KS_RESIDENT_APP
|
||
#include "ui_log.inl"
|
||
#else
|
||
void showLogs(App &app) { launchConfiguration(app, false, true); }
|
||
#endif
|
||
#ifndef KS_RESIDENT_APP
|
||
void showSettings(App &app, bool visible)
|
||
{
|
||
if (app.settingsWindow)
|
||
{
|
||
ShowWindow(app.settingsWindow, SW_RESTORE);
|
||
HWND target = app.settingsWindow;
|
||
if (!IsWindowEnabled(target))
|
||
target = GetLastActivePopup(target);
|
||
activateWindow(target);
|
||
return;
|
||
}
|
||
HWND w = makeWindow(app, L"KSwitcher.Settings", L"KSwitcher settings", settingsProc, 780, 660, 0, false);
|
||
app.settingsWindow = w;
|
||
label(w, L"Text conversion", 18, 16);
|
||
checkbox(w, L"Con&vert recently typed text when nothing is selected", 201, 18, 43, 390);
|
||
checkbox(w, L"Switch Windows input &layout after conversion", 202, 18, 70, 390);
|
||
checkbox(w, L"Record clip&board history", 203, 18, 106);
|
||
checkbox(w, L"Start with &Windows", 204, 18, 133);
|
||
checkbox(w, L"Start with Windows as ad&ministrator", 206, 18, 160, 395);
|
||
checkbox(w, L"&Keep screen awake", 205, 18, 184, 210);
|
||
checkbox(w, L"Write lo&g", 208, 240, 184, 160);
|
||
label(w, L"Click a shortcut and press the desired keys", 420, 16, 350);
|
||
const wchar_t *names[] = {L"Next layout", L"Change case", L"Transliterate", L"Undo",
|
||
L"Clipboard history", L"Screen capture"};
|
||
for (int i = 0; i < 6; ++i)
|
||
{
|
||
label(w, names[i], 420, 48 + i * 30, 115);
|
||
hotkeyEdit(app, w, 210 + i, 540, 44 + i * 30, 220);
|
||
}
|
||
checkbox(w, L"Open editor after screen capt&ure", 209, 420, 224, 340);
|
||
checkbox(w, L"Automatic correction (e&xperimental)", 207, 18, 210, 395);
|
||
label(w, L"Layout cycle — top to bottom", 18, 240, 400);
|
||
control(w, L"LISTBOX", L"", WS_TABSTOP | WS_VSCROLL | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | WS_BORDER, 220,
|
||
18, 262, 470, 172);
|
||
button(w, L"Move u&p", 232, 504, 262, 120);
|
||
button(w, L"Move &down", 233, 632, 262, 128);
|
||
checkbox(w, L"&Include in cycle", 230, 504, 300, 240);
|
||
label(w, L"Direct layout shortcut", 504, 332, 240);
|
||
hotkeyEdit(app, w, 231, 504, 356, 256);
|
||
label(w, L"Backspace / Delete clears a shortcut", 504, 382, 256);
|
||
button(w, L"Re&fresh layouts", 253, 504, 408, 150);
|
||
label(w, L"History limits", 18, 444);
|
||
label(w, L"Items", 18, 478, 50);
|
||
edit(w, 240, 70, 474, 90);
|
||
label(w, L"Total MiB", 180, 478, 75);
|
||
edit(w, 241, 260, 474, 90);
|
||
label(w, L"Per item MiB", 370, 478, 100);
|
||
edit(w, 242, 475, 474, 80);
|
||
button(w, L"Clear &history…", 254, 580, 474, 180);
|
||
label(w, L"Exclude applications (process names, comma-separated)", 18, 516, 700);
|
||
edit(w, 243, 18, 544, 742);
|
||
button(w, L"&Auto-correction options…", 255, 18, 575, 240);
|
||
button(w, L"View l&og…", 256, 278, 575, 220);
|
||
button(w, L"OCR op&tions…", 257, 518, 575, 242);
|
||
button(w, L"Impo&rt settings…", 250, 18, 606, 145);
|
||
button(w, L"&Export settings…", 251, 173, 606, 145);
|
||
button(w, L"S&nippets…", 252, 328, 606, 110);
|
||
button(w, L"S&ync...", 258, 448, 606, 90);
|
||
button(w, L"&Save", IDOK, 548, 606, 100);
|
||
button(w, L"&Cancel", IDCANCEL, 660, 606, 100);
|
||
fillSettings(w, (SettingsView *)GetWindowLongPtrW(w, GWLP_USERDATA));
|
||
if (visible)
|
||
{
|
||
showRequestedWindow(w);
|
||
activateWindow(w);
|
||
}
|
||
}
|
||
void showSnippets(App &app)
|
||
{
|
||
if (app.snippetsWindow)
|
||
{
|
||
SetForegroundWindow(app.snippetsWindow);
|
||
return;
|
||
}
|
||
HWND w = makeWindow(app, L"KSwitcher.Snippets", L"Text snippets", snippetProc, 740, 520);
|
||
app.snippetsWindow = w;
|
||
label(w, L"Triggers", 16, 16);
|
||
control(w, L"LISTBOX", L"", WS_TABSTOP | WS_VSCROLL | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | WS_BORDER, 301,
|
||
16, 44, 200, 380);
|
||
button(w, L"&Add", 310, 16, 438, 90);
|
||
button(w, L"&Delete", 311, 116, 438, 100);
|
||
label(w, L"&Trigger (for example ;addr)", 236, 16, 470);
|
||
edit(w, 302, 236, 44, 488);
|
||
label(w, L"&Replacement text", 236, 82, 480);
|
||
edit(w, 303, 236, 110, 488, 270, ES_MULTILINE | ES_WANTRETURN | ES_AUTOVSCROLL | WS_VSCROLL);
|
||
control(w, L"STATIC", L"{cursor}: caret; {enter}: press Enter after insertion.\nUse {{cursor}} / {{enter}} for literal markers.", 0, 0, 236, 392, 488, 36);
|
||
button(w, L"Insert cursor &marker", 312, 236, 430, 190);
|
||
button(w, L"Insert &Enter marker", 313, 436, 430, 190);
|
||
button(w, L"&Save", IDOK, 510, 478, 100);
|
||
button(w, L"&Cancel", IDCANCEL, 624, 478, 100);
|
||
fillSnippets(w, (SnippetView *)GetWindowLongPtrW(w, GWLP_USERDATA));
|
||
showRequestedWindow(w);
|
||
SetForegroundWindow(w);
|
||
}
|
||
#else
|
||
void showSettings(App &app, bool) { launchConfiguration(app); }
|
||
void showSnippets(App &app) { launchConfiguration(app, true); }
|
||
#endif
|
||
#ifndef KS_CONFIG_APP
|
||
void showShortcuts(App &app)
|
||
{
|
||
auto &s = app.settings;
|
||
std::wstring text = L"Next layout: " + s.toggle + L"\nChange case: " + s.casing + L"\nTransliterate: " +
|
||
s.translit + L"\nUndo: " + s.undo + L"\nClipboard history: " + s.clipboard +
|
||
L"\nScreen capture: " + s.screenshot + L"\n";
|
||
for (size_t i = 0; i < std::min(app.layouts.size(), s.direct.size()); ++i)
|
||
if (!s.direct[i].empty())
|
||
text += L"\n" + app.layouts[i].name + L": " + s.direct[i];
|
||
text += L"\n\nHistory: Enter to paste, Shift+Enter for plain text,\nCtrl+1…9 to paste, Ctrl+P to pin, "
|
||
L"Delete to remove,\nCtrl+O to open the full item, Escape to close.";
|
||
MessageBoxW(app.window, text.c_str(), L"Keyboard shortcuts", MB_OK);
|
||
}
|
||
void showEntry(App &app, const std::wstring &id)
|
||
{
|
||
try
|
||
{
|
||
auto clip = app.history->load(id);
|
||
if(std::any_of(clip.formats.begin(),clip.formats.end(),[](const auto &format) {
|
||
return format.id==CF_DIB || format.id==CF_DIBV5 || format.name==L"PNG";
|
||
})) {
|
||
launchScreenshotEditor(app,clip);
|
||
return;
|
||
}
|
||
auto text = clip.text();
|
||
if (text.empty())
|
||
{
|
||
MessageBoxW(app.historyWindow,
|
||
L"This item contains files. Paste it into the "
|
||
L"destination application.",
|
||
L"Clipboard item", MB_OK);
|
||
return;
|
||
}
|
||
HWND w = makeWindow(app, L"KSwitcher.Entry", L"Clipboard item", entryProc, 720, 500,
|
||
WS_THICKFRAME | WS_MAXIMIZEBOX);
|
||
auto field = edit(w, 1, 10, 10, 700, 480, ES_MULTILINE | ES_READONLY | ES_AUTOVSCROLL | WS_VSCROLL);
|
||
SetWindowTextW(field, text.c_str());
|
||
showRequestedWindow(w);
|
||
}
|
||
catch (const std::exception &e)
|
||
{
|
||
error(app.historyWindow, e);
|
||
}
|
||
}
|
||
#endif
|
||
} // namespace ks
|