agrynco
14f33012a3
Add mouse button actions and application profiles, with volume controls and per-monitor settings layout fixes.
2826 lines
122 KiB
C++
2826 lines
122 KiB
C++
#include "app.h"
|
|
#include <utility>
|
|
#include "../vendor/json.hpp"
|
|
#include "../resources/resource.h"
|
|
#include "ocr.h"
|
|
#include "lan_clipboard_image.h"
|
|
#include "configuration.h"
|
|
#include "diagnostics.h"
|
|
#include "paste_probe.h"
|
|
#include "utilities.h"
|
|
#include "screenshot_notifications.h"
|
|
#include <algorithm>
|
|
#include <commctrl.h>
|
|
#include <set>
|
|
|
|
namespace ks
|
|
{
|
|
#include "app_sync.inl"
|
|
App *App::current = nullptr;
|
|
#include "app_history.inl"
|
|
namespace
|
|
{
|
|
const char *transformCommandName(int command)
|
|
{
|
|
return command == Toggle ? "Convert / cycle" : command >= Direct ? "Convert / direct" :
|
|
command == Case ? "Change case" : command == Translit ? "Transliterate" :
|
|
command == Undo ? "Undo" : "Automatic / snippet";
|
|
}
|
|
ULONG_PTR snippetReplayMarker()
|
|
{
|
|
static const char marker{};
|
|
return reinterpret_cast<ULONG_PTR>(&marker);
|
|
}
|
|
std::vector<std::pair<int, std::wstring>> shortcuts(const Settings &s)
|
|
{
|
|
std::vector<std::pair<int, std::wstring>> out{{Toggle, s.toggle},
|
|
{Case, s.casing},
|
|
{Translit, s.translit},
|
|
{Undo, s.undo},
|
|
{ShowHistory, s.clipboard},
|
|
{Screenshot, s.screenshot}};
|
|
for (size_t i = 0; i < s.direct.size(); ++i)
|
|
out.emplace_back(Direct + (int)i, s.direct[i]);
|
|
return out;
|
|
}
|
|
size_t caretSteps(std::wstring text)
|
|
{
|
|
size_t n = 0;
|
|
for (size_t i = 0; i < text.size(); ++i)
|
|
{
|
|
if (text[i] == L'\r' && i + 1 < text.size() && text[i + 1] == L'\n')
|
|
++i;
|
|
else if (text[i] >= 0xd800 && text[i] <= 0xdbff && i + 1 < text.size() && text[i + 1] >= 0xdc00 &&
|
|
text[i + 1] <= 0xdfff)
|
|
++i;
|
|
++n;
|
|
}
|
|
return n;
|
|
}
|
|
std::wstring newlines(std::wstring text)
|
|
{
|
|
std::wstring out;
|
|
for (size_t i = 0; i < text.size(); ++i)
|
|
{
|
|
if (text[i] == L'\r' && i + 1 < text.size() && text[i + 1] == L'\n')
|
|
continue;
|
|
out += text[i];
|
|
}
|
|
return out;
|
|
}
|
|
// Every transaction checks input, foreground and clipboard ownership before replacing text.
|
|
class Transaction
|
|
{
|
|
App &app;
|
|
HWND target;
|
|
uint64_t version;
|
|
ClipboardSnapshot snapshot;
|
|
DWORD expected{};
|
|
bool captured{};
|
|
mutable bool invalidLogged{};
|
|
unsigned copyNumber{};
|
|
std::wstring adopted;
|
|
Bytes adoptedFormats;
|
|
bool trustedContentsObserved{};
|
|
std::unique_ptr<PasteProbe> selectionProof;
|
|
std::wstring provenSelection;
|
|
bool farSnippet{};
|
|
size_t farSelectedSteps{};
|
|
|
|
public:
|
|
Transaction(App &a, HWND t, uint64_t v, bool farEditor = false)
|
|
: app(a), target(t), version(v), farSnippet(farEditor)
|
|
{
|
|
app.suspended = true;
|
|
try
|
|
{
|
|
for (unsigned attempt = 0; ; ++attempt)
|
|
{
|
|
expected = GetClipboardSequenceNumber();
|
|
try
|
|
{
|
|
snapshot.capture(app.window, expected);
|
|
if (expected != GetClipboardSequenceNumber())
|
|
throw std::runtime_error("Clipboard changed while taking snapshot");
|
|
break;
|
|
}
|
|
catch (...)
|
|
{
|
|
// No selection or clipboard write has happened yet. Recapture
|
|
// the latest clipboard after a concurrent publisher settles.
|
|
if (attempt >= 2 || !valid() || expected == GetClipboardSequenceNumber())
|
|
throw;
|
|
diagnosticEvent(L"Snapshot retry: clipboard changed during capture");
|
|
Sleep(20);
|
|
}
|
|
}
|
|
captured = true;
|
|
}
|
|
catch (...)
|
|
{
|
|
app.suspended = false;
|
|
throw;
|
|
}
|
|
}
|
|
~Transaction()
|
|
{
|
|
if (farSnippet) finishSelection(false);
|
|
if (captured && GetClipboardSequenceNumber() == expected)
|
|
try
|
|
{
|
|
app.ownSequence = snapshot.restore(app.window, expected);
|
|
}
|
|
catch (...)
|
|
{
|
|
app.report(L"Could not restore clipboard; the copied text remains available.");
|
|
}
|
|
app.suspended = false;
|
|
}
|
|
bool valid() const
|
|
{
|
|
auto foreground = GetForegroundWindow();
|
|
auto currentVersion = app.inputVersion.load();
|
|
bool ok = target && IsWindow(target) && foreground == target && currentVersion == version;
|
|
if (!ok && !invalidLogged)
|
|
{
|
|
invalidLogged = true;
|
|
diagnosticEvent(L"Context invalid: target=" + std::to_wstring((uintptr_t)target) +
|
|
L" alive=" + std::to_wstring(IsWindow(target)) + L" foreground=" +
|
|
std::to_wstring((uintptr_t)foreground) + L" expectedVersion=" + std::to_wstring(version) +
|
|
L" currentVersion=" + std::to_wstring(currentVersion));
|
|
}
|
|
return ok;
|
|
}
|
|
void check()
|
|
{
|
|
if (GetClipboardSequenceNumber() != expected)
|
|
{
|
|
auto now = GetClipboardSequenceNumber();
|
|
auto current = readClipboard(app.window, 32 * 1024 * 1024, ClipboardRead::Selection);
|
|
const bool sameContents = selectionClipboardIdentity(current) == adoptedFormats;
|
|
if (adopted.empty() || (!trustedContentsObserved && !ownsClipboard(target)) ||
|
|
!sameContents || GetClipboardSequenceNumber() != now)
|
|
{
|
|
diagnosticEvent(L"Clipboard check rejected: expectedSequence=" + std::to_wstring(expected) +
|
|
L" readSequence=" + std::to_wstring(now) + L" currentSequence=" +
|
|
std::to_wstring(GetClipboardSequenceNumber()) + L" owner=" +
|
|
std::to_wstring((uintptr_t)GetClipboardOwner()) + L" sameContents=" +
|
|
std::to_wstring(sameContents) + L" expectedText=" + diagnosticText(adopted) +
|
|
L" currentText=" + diagnosticText(current.text()));
|
|
throw std::runtime_error("Operation cancelled: another application changed the clipboard");
|
|
}
|
|
expected = now;
|
|
}
|
|
}
|
|
void write(const Clip &c)
|
|
{
|
|
check();
|
|
adopted.clear();
|
|
adoptedFormats.clear();
|
|
trustedContentsObserved = false;
|
|
// These are temporary transaction contents, not a user's clipboard entry.
|
|
// In particular, do not invite the Windows history service to read our
|
|
// sentinel while the target editor is trying to open the clipboard.
|
|
auto temporary = c;
|
|
const std::wstring exclusion = L"ExcludeClipboardContentFromMonitorProcessing";
|
|
temporary.formats.push_back({RegisterClipboardFormatW(exclusion.c_str()), exclusion, Bytes{0}});
|
|
app.ownSequence = expected = writeClipboard(app.window, temporary);
|
|
// A concurrent writer can win immediately after CloseClipboard, before we read its sequence.
|
|
// Never adopt that writer's sequence as our own and paste its content.
|
|
if (GetClipboardOwner() != app.window)
|
|
throw std::runtime_error("Clipboard changed immediately after writing");
|
|
auto text = c.text();
|
|
if ((!text.empty() && readClipboard(app.window, 32 * 1024 * 1024, ClipboardRead::Selection).text() != text) ||
|
|
GetClipboardSequenceNumber() != expected)
|
|
throw std::runtime_error("Clipboard changed while verifying our write");
|
|
}
|
|
std::wstring copy()
|
|
{
|
|
const auto started = GetTickCount64();
|
|
const auto number = ++copyNumber;
|
|
if (!valid())
|
|
return {};
|
|
const auto sentinel = L"\x2063KSwitcher-" + std::to_wstring(GetTickCount64());
|
|
write(textClip(sentinel));
|
|
DWORD before = expected;
|
|
diagnosticEvent(L"Copy begin number=" + std::to_wstring(number) + L" sentinelSequence=" +
|
|
std::to_wstring(before) + L" target=" + std::to_wstring((uintptr_t)target) +
|
|
L" sentinel=" + diagnosticText(sentinel));
|
|
if (!valid() || !chord(farSnippet ? VK_INSERT : L'C', MOD_CONTROL))
|
|
{
|
|
diagnosticEvent(L"Copy failed: context changed or simulated Ctrl+C blocked");
|
|
return {};
|
|
}
|
|
ULONGLONG deadline = GetTickCount64() + 2000;
|
|
ULONGLONG retryAt = GetTickCount64() + 250;
|
|
unsigned attempts = 1;
|
|
DWORD changed = before;
|
|
ULONGLONG stable = 0;
|
|
bool changedAgain = false;
|
|
std::optional<Bytes> observedTargetCopy;
|
|
while (GetTickCount64() < deadline)
|
|
{
|
|
if (!valid())
|
|
return {};
|
|
DWORD now = GetClipboardSequenceNumber();
|
|
if (now != changed)
|
|
{
|
|
diagnosticEvent(L"Copy sequence number=" + std::to_wstring(number) + L" from=" +
|
|
std::to_wstring(changed) + L" to=" + std::to_wstring(now) + L" elapsedMs=" +
|
|
std::to_wstring(GetTickCount64() - started) + L" owner=" +
|
|
std::to_wstring((uintptr_t)GetClipboardOwner()));
|
|
changedAgain |= changed != before;
|
|
changed = now;
|
|
stable = GetTickCount64();
|
|
// Clipboard synchronizers can republish a legitimate copy under
|
|
// their own HWND. Record provenance before that handoff; an
|
|
// unobserved or altered foreign copy must still be rejected.
|
|
if (ownsClipboard(target))
|
|
{
|
|
auto candidate = readClipboard(app.window, 32 * 1024 * 1024, ClipboardRead::Selection);
|
|
if (GetClipboardSequenceNumber() == now && ownsClipboard(target) && !candidate.text().empty())
|
|
{
|
|
observedTargetCopy = selectionClipboardIdentity(candidate);
|
|
diagnosticEvent(L"Copy: target-owned selection observed number=" + std::to_wstring(number));
|
|
}
|
|
}
|
|
}
|
|
if (changed != before && GetTickCount64() - stable >= 60)
|
|
break;
|
|
// Native editors can silently drop Ctrl+C if another process has
|
|
// the clipboard open. Retry only while our sentinel is untouched;
|
|
// never overwrite a copy result or another application's content.
|
|
if (changed == before && attempts < 3 && GetTickCount64() >= retryAt &&
|
|
!GetOpenClipboardWindow())
|
|
{
|
|
check();
|
|
if (!valid() || GetClipboardSequenceNumber() != before)
|
|
return {};
|
|
if (!chord(farSnippet ? VK_INSERT : L'C', MOD_CONTROL))
|
|
return {};
|
|
diagnosticEvent(L"Copy retry: clipboard unchanged after Ctrl+C number=" + std::to_wstring(number) +
|
|
L" attempt=" + std::to_wstring(attempts + 1) + L" elapsedMs=" + std::to_wstring(GetTickCount64() - started));
|
|
++attempts;
|
|
retryAt = GetTickCount64() + 250;
|
|
}
|
|
Sleep(10);
|
|
}
|
|
if (changed == before || !valid())
|
|
{
|
|
diagnosticEvent(L"Copy end number=" + std::to_wstring(number) + L" attempts=" +
|
|
std::to_wstring(attempts) + L" elapsedMs=" + std::to_wstring(GetTickCount64() - started) +
|
|
L" sequence=" + std::to_wstring(GetClipboardSequenceNumber()) + L" clipboardOpenBy=" +
|
|
std::to_wstring((uintptr_t)GetOpenClipboardWindow()));
|
|
diagnosticEvent(changed == before ? L"Copy failed: clipboard timeout (2000 ms)" :
|
|
L"Copy failed: context changed");
|
|
return {};
|
|
}
|
|
const bool targetOwned = ownsClipboard(target);
|
|
auto clip = readClipboard(app.window, 32 * 1024 * 1024, ClipboardRead::Selection);
|
|
const auto formats = selectionClipboardIdentity(clip);
|
|
const bool verifiedRelay = observedTargetCopy && *observedTargetCopy == formats;
|
|
if (((GetClipboardOwner() ? !targetOwned : changedAgain) && !verifiedRelay) ||
|
|
changed != GetClipboardSequenceNumber())
|
|
{
|
|
diagnosticEvent(L"Copy rejected: observedTarget=" + std::to_wstring(observedTargetCopy.has_value()) +
|
|
L" verifiedRelay=" + std::to_wstring(verifiedRelay) + L" expectedSequence=" +
|
|
std::to_wstring(changed) + L" currentSequence=" + std::to_wstring(GetClipboardSequenceNumber()) +
|
|
L" owner=" + std::to_wstring((uintptr_t)GetClipboardOwner()) + L" targetText=" +
|
|
diagnosticText(observedTargetCopy ? decodeClip(*observedTargetCopy).text() : L"") +
|
|
L" currentText=" + diagnosticText(clip.text()));
|
|
throw std::runtime_error("Operation cancelled: copy did not belong to the target application");
|
|
}
|
|
if (!targetOwned && verifiedRelay)
|
|
diagnosticEvent(L"Copy: identical target selection republished by clipboard synchronizer");
|
|
expected = changed;
|
|
auto text = clip.text();
|
|
diagnosticEvent(L"Copy result number=" + std::to_wstring(number) + L" attempts=" +
|
|
std::to_wstring(attempts) + L" elapsedMs=" + std::to_wstring(GetTickCount64() - started) +
|
|
L" text=" + diagnosticText(text));
|
|
adopted = text;
|
|
adoptedFormats = formats;
|
|
trustedContentsObserved = targetOwned || verifiedRelay;
|
|
check();
|
|
for (auto &f : clip.formats)
|
|
{
|
|
if (f.name == L"VisualStudioEditorOperationsLineCutCopyClipboardTag" ||
|
|
f.name == L"MSDEVLineSelect")
|
|
{
|
|
diagnosticEvent(L"Copy rejected: editor copied line without selection");
|
|
return {};
|
|
}
|
|
if (f.name == L"vscode-editor-data")
|
|
{
|
|
std::string json(f.data.begin(), f.data.end());
|
|
if (json.find("\"isFromEmptySelection\":true") != json.npos ||
|
|
json.find("\"isFromEmptySelection\": true") != json.npos)
|
|
{
|
|
diagnosticEvent(L"Copy rejected: editor reported empty selection");
|
|
return {};
|
|
}
|
|
}
|
|
}
|
|
selectionProof.reset();
|
|
provenSelection.clear();
|
|
// Viber and some other editors omit trailing ASCII spaces from Ctrl+C.
|
|
// Recover only from a real selection, never from the recorded keys alone.
|
|
if (valid() && !text.empty() && text.size() < 8192 && text.back() != L' ')
|
|
{
|
|
auto proof = std::make_unique<PasteProbe>(true, target);
|
|
auto selected = proof->read(1, false);
|
|
if (selected && selected->size() > text.size() && selected->starts_with(text) &&
|
|
selected->find_first_not_of(L' ', text.size()) == std::wstring::npos && valid())
|
|
{
|
|
diagnosticEvent(L"Copy: trailing spaces verified via accessibility copied=" +
|
|
diagnosticText(text) + L" selected=" + diagnosticText(*selected));
|
|
text = *selected;
|
|
provenSelection = text;
|
|
selectionProof = std::move(proof);
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
bool recoveredSelection() const { return selectionProof != nullptr; }
|
|
bool select(size_t n)
|
|
{
|
|
if (farSnippet)
|
|
{
|
|
if (n > 4096 || farSelectedSteps) return false;
|
|
for (size_t i = 0; i < n; ++i)
|
|
{
|
|
if (!valid() || !chord(VK_LEFT, MOD_ALT | MOD_SHIFT)) return false;
|
|
++farSelectedSteps;
|
|
}
|
|
return valid();
|
|
}
|
|
return selectPrevious(n, [&] { return valid(); });
|
|
}
|
|
bool finishSelection(bool atStart)
|
|
{
|
|
if (!farSnippet) return valid() && chord(atStart ? VK_LEFT : VK_RIGHT);
|
|
if (!farSelectedSteps) return valid();
|
|
if (atStart)
|
|
{
|
|
// Far arrows move one character, rather than collapsing a selection
|
|
// to its edge. Move into the nonempty selected range and back.
|
|
if (!valid() || !chord(VK_RIGHT)) return false;
|
|
farSelectedSteps = 0;
|
|
return valid() && chord(VK_LEFT);
|
|
}
|
|
while (farSelectedSteps && valid())
|
|
{
|
|
if (!chord(VK_RIGHT, MOD_ALT | MOD_SHIFT)) return false;
|
|
--farSelectedSteps;
|
|
}
|
|
return !farSelectedSteps && valid();
|
|
}
|
|
std::optional<std::wstring> readFarSnippet(size_t count)
|
|
{
|
|
if (!farSnippet || !count || !select(count)) return {};
|
|
auto observed = copy();
|
|
if (!finishSelection(false) || observed.empty()) return {};
|
|
return observed;
|
|
}
|
|
std::wstring copyRange(size_t count, const std::wstring &wordCandidate,
|
|
const std::function<bool(const std::wstring &)> &matches,
|
|
const std::function<bool(const std::wstring &)> &suffixMatches = {})
|
|
{
|
|
// WebView word boundaries are only candidates; exact verification is mandatory.
|
|
diagnosticEvent(L"Selection begin steps=" + std::to_wstring(count) + L" expected=" + diagnosticText(wordCandidate));
|
|
GUITHREADINFO gui{sizeof(gui)};
|
|
if (GetGUIThreadInfo(GetWindowThreadProcessId(target, nullptr), &gui))
|
|
{
|
|
wchar_t cls[128]{};
|
|
GetClassNameW(gui.hwndFocus, cls, 128);
|
|
std::wstring offsets = L"unavailable";
|
|
if (_wcsicmp(cls, L"Edit") == 0)
|
|
{
|
|
DWORD_PTR range{};
|
|
if (SendMessageTimeoutW(gui.hwndFocus, EM_GETSEL, 0, 0,
|
|
SMTO_ABORTIFHUNG | SMTO_BLOCK, 25, &range) && (DWORD)range != 0xffffffff)
|
|
offsets = std::to_wstring(LOWORD(range)) + L"," + std::to_wstring(HIWORD(range));
|
|
}
|
|
diagnosticEvent(L"Selection editor class=" + std::wstring(cls) + L" focus=" +
|
|
std::to_wstring((uintptr_t)gui.hwndFocus) + L" caretWindow=" + std::to_wstring((uintptr_t)gui.hwndCaret) +
|
|
L" caretRect=" + std::to_wstring(gui.rcCaret.left) + L"," + std::to_wstring(gui.rcCaret.top) +
|
|
L"," + std::to_wstring(gui.rcCaret.right) + L"," + std::to_wstring(gui.rcCaret.bottom) +
|
|
L" layout=" + std::to_wstring((uintptr_t)windowLayout(target)) + L" selectionOffsets=" + offsets);
|
|
}
|
|
else diagnosticEvent(L"Selection editor: focus/caret/selection unavailable");
|
|
if (needsSelectionDelay(target) && !wordCandidate.empty() &&
|
|
std::all_of(wordCandidate.begin(), wordCandidate.end(),
|
|
[](wchar_t c) { return letter(c) || iswdigit(c); }))
|
|
{
|
|
if (!valid() || !chord(VK_LEFT, MOD_CONTROL | MOD_SHIFT))
|
|
return {};
|
|
Sleep(25);
|
|
auto text = copy();
|
|
diagnosticEvent(L"Selection word-boundary match=" + std::to_wstring(matches(text)) + L" copied=" + diagnosticText(text));
|
|
if (valid() && matches(text))
|
|
{
|
|
diagnosticEvent(L"Selection: verified word boundary");
|
|
return text;
|
|
}
|
|
if (!valid() || !chord(VK_RIGHT))
|
|
return {};
|
|
Sleep(25);
|
|
}
|
|
auto text = select(count) ? copy() : std::wstring{};
|
|
diagnosticEvent(L"Selection initial match=" + std::to_wstring(matches(text)) + L" copied=" + diagnosticText(text));
|
|
// Chromium editors can apply only part of a burst of Shift+Left events.
|
|
// Extend only a verified suffix; never replace a partial or unrelated range.
|
|
if (valid() && !matches(text) && !text.empty() &&
|
|
(suffixMatches ? suffixMatches(text) : newlines(wordCandidate).ends_with(newlines(text))) &&
|
|
caretSteps(text) < count)
|
|
{
|
|
const auto missing = count - caretSteps(text);
|
|
diagnosticEvent(L"Selection: extending verified suffix by " + std::to_wstring(missing));
|
|
for (size_t i = 0; i < missing; ++i)
|
|
{
|
|
if (!valid() || !chord(VK_LEFT, MOD_SHIFT))
|
|
return {};
|
|
diagnosticEvent(L"Selection recovery Shift+Left sent=" + std::to_wstring(i + 1) + L" total=" + std::to_wstring(missing));
|
|
Sleep(25);
|
|
}
|
|
text = copy();
|
|
diagnosticEvent(L"Selection: suffix recovery match=" + std::to_wstring(matches(text)) + L" copied=" + diagnosticText(text));
|
|
}
|
|
return text;
|
|
}
|
|
bool paste(const Clip &clip)
|
|
{
|
|
if (selectionProof)
|
|
{
|
|
auto selected = selectionProof->read(1, false);
|
|
if (!selected || *selected != provenSelection || !valid())
|
|
{
|
|
diagnosticEvent(L"Paste cancelled: recovered selection changed or unavailable");
|
|
return false;
|
|
}
|
|
}
|
|
if (!valid())
|
|
return false;
|
|
write(clip);
|
|
// Our verified payload is also trusted across an identical relay. The
|
|
// sentinel written by copy() deliberately does not get this allowance.
|
|
if (clip.formats.size() == 1 && clip.formats.front().id == CF_UNICODETEXT)
|
|
{
|
|
adopted = clip.text();
|
|
adoptedFormats = selectionClipboardIdentity(clip);
|
|
trustedContentsObserved = true;
|
|
}
|
|
// Viber's Qt editor observes clipboard changes asynchronously. Give it
|
|
// a chance to discard the data object from Ctrl+C before requesting paste.
|
|
// Recheck ownership and input below; never retry a possibly applied paste.
|
|
if (lower(processName(target)) == L"viber")
|
|
{
|
|
Sleep(75);
|
|
diagnosticEvent(L"Paste: Viber clipboard notification settling interval completed");
|
|
}
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
check();
|
|
if (!valid())
|
|
return false;
|
|
}
|
|
if (!chord(farSnippet ? VK_INSERT : L'V', farSnippet ? MOD_SHIFT : MOD_CONTROL))
|
|
throw std::runtime_error("Windows blocked simulated input; check application privilege levels");
|
|
// The selected trigger was replaced. Do not restore its old caret range
|
|
// if clipboard verification below subsequently rejects a concurrent copy.
|
|
if (farSnippet) farSelectedSteps = 0;
|
|
Sleep(300);
|
|
// A clipboard synchronizer may replace our payload after Ctrl+V is
|
|
// queued but before the editor consumes it. Do not run snippet actions
|
|
// (especially Enter) after such a race.
|
|
check();
|
|
return true;
|
|
}
|
|
bool nativeSelectionIs(const std::wstring &original) const
|
|
{
|
|
if (!valid()) return false;
|
|
GUITHREADINFO gui{sizeof(gui)};
|
|
if (!GetGUIThreadInfo(GetWindowThreadProcessId(target, nullptr), &gui) || !gui.hwndFocus) return false;
|
|
wchar_t cls[32]{};
|
|
GetClassNameW(gui.hwndFocus, cls, 32);
|
|
if (_wcsicmp(cls, L"Edit") != 0 ||
|
|
(GetWindowLongPtrW(gui.hwndFocus, GWL_STYLE) & (ES_PASSWORD | ES_READONLY))) return false;
|
|
auto query = [&](UINT message, WPARAM wp, LPARAM lp, DWORD_PTR &result)
|
|
{
|
|
return SendMessageTimeoutW(gui.hwndFocus, message, wp, lp,
|
|
SMTO_ABORTIFHUNG | SMTO_BLOCK, 100, &result) != 0;
|
|
};
|
|
DWORD_PTR range{}, length{}, copied{};
|
|
if (!query(EM_GETSEL, 0, 0, range) || (DWORD)range == 0xffffffff ||
|
|
size_t(HIWORD(range) - LOWORD(range)) != original.size() ||
|
|
!query(WM_GETTEXTLENGTH, 0, 0, length) || length > 65534 || HIWORD(range) > length) return false;
|
|
std::wstring content(length + 1, L'\0');
|
|
if (!query(WM_GETTEXT, content.size(), (LPARAM)content.data(), copied) || copied != length) return false;
|
|
DWORD_PTR after{};
|
|
GUITHREADINFO focused{sizeof(focused)};
|
|
return query(EM_GETSEL, 0, 0, after) && after == range && valid() &&
|
|
GetGUIThreadInfo(GetWindowThreadProcessId(target, nullptr), &focused) && focused.hwndFocus == gui.hwndFocus &&
|
|
content.substr(LOWORD(range), original.size()) == original;
|
|
}
|
|
};
|
|
} // namespace
|
|
App::App(HINSTANCE h, bool test, const std::filesystem::path &dataRoot, HWND service)
|
|
: historyService(service), instance(h), smoke(test)
|
|
{
|
|
updateNotifier = notifyUpdateAvailable;
|
|
current = this;
|
|
data = dataRoot.empty() ? dataDirectory() : dataRoot;
|
|
std::filesystem::create_directories(data);
|
|
layouts = readLayouts();
|
|
try
|
|
{
|
|
settings = loadSettings(data / L"settings.json", layouts);
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
settings = loadSettings(data / L"missing-defaults.json", layouts);
|
|
registrationWarning = L"Settings were not loaded: " + wide(e.what());
|
|
}
|
|
setLoggingEnabled(settings.writeLog);
|
|
if (settings.autoCorrect && !historyService)
|
|
try { autoPredictor.configure(std::filesystem::path(executable()).parent_path() / L"dictionaries", settings.autoLanguages); }
|
|
catch (const std::exception &e)
|
|
{
|
|
settings.autoCorrect = false;
|
|
registrationWarning += L"\nAutomatic correction unavailable: " + wide(e.what());
|
|
}
|
|
try
|
|
{
|
|
history = std::make_unique<History>(data / L"history");
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
registrationWarning += L"\nHistory is unavailable: " + wide(e.what());
|
|
settings.history = false;
|
|
}
|
|
}
|
|
App::~App()
|
|
{
|
|
lanService.reset();
|
|
stopBrowserChatMonitor();
|
|
if (auto host = historyController(historyProcess)) PostMessageW(host, WM_CLOSE, 0, 0);
|
|
if (historyProcess) CloseHandle(historyProcess);
|
|
if (notificationRegistration) CloseHandle(notificationRegistration);
|
|
if (syncWorker.joinable()) syncWorker.join();
|
|
if (updateWorker.joinable())
|
|
updateWorker.join();
|
|
if (keyboardHook)
|
|
UnhookWindowsHookEx(keyboardHook);
|
|
if (mouseHook)
|
|
UnhookWindowsHookEx(mouseHook);
|
|
{
|
|
std::lock_guard lock(jobsMutex);
|
|
stop = true;
|
|
jobs.clear();
|
|
pendingHistorySearch = {};
|
|
}
|
|
jobsReady.notify_all();
|
|
historySearchReady.notify_all();
|
|
historyOcrReady.notify_all();
|
|
if (historyOcrWorker.joinable())
|
|
historyOcrWorker.join();
|
|
if (historySearchWorker.joinable())
|
|
historySearchWorker.join();
|
|
if (worker.joinable())
|
|
worker.join();
|
|
RemoveClipboardFormatListener(window);
|
|
NOTIFYICONDATAW icon{sizeof(icon)};
|
|
icon.hWnd = window;
|
|
icon.uID = 1;
|
|
Shell_NotifyIconW(NIM_DELETE, &icon);
|
|
SetThreadExecutionState(ES_CONTINUOUS);
|
|
current = nullptr;
|
|
}
|
|
void App::enqueue(std::function<void()> job)
|
|
{
|
|
{
|
|
std::lock_guard lock(jobsMutex);
|
|
if (stop)
|
|
return;
|
|
jobs.push_back(std::move(job));
|
|
}
|
|
jobsReady.notify_one();
|
|
}
|
|
void App::enqueueHistorySearch(std::function<void()> job)
|
|
{
|
|
{
|
|
std::lock_guard lock(jobsMutex);
|
|
if (stop) return;
|
|
// Only the latest query matters. Clipboard capture and OCR must not delay it.
|
|
pendingHistorySearch = std::move(job);
|
|
if (!historySearchWorker.joinable())
|
|
historySearchWorker = std::thread([this]
|
|
{
|
|
for (;;)
|
|
{
|
|
std::function<void()> searchJob;
|
|
{
|
|
std::unique_lock lock(jobsMutex);
|
|
historySearchReady.wait(lock, [&] { return stop || bool(pendingHistorySearch); });
|
|
if (stop) return;
|
|
searchJob = std::move(pendingHistorySearch);
|
|
pendingHistorySearch = {};
|
|
}
|
|
try { searchJob(); }
|
|
catch (const std::exception &e) { report(wide(e.what())); }
|
|
}
|
|
});
|
|
}
|
|
historySearchReady.notify_one();
|
|
}
|
|
void App::scheduleHistoryOcr(const Settings &config)
|
|
{
|
|
{
|
|
std::lock_guard lock(jobsMutex);
|
|
if (stop || !history || !config.history) return;
|
|
historyOcrSettings = config;
|
|
historyOcrRequested = true;
|
|
if (!historyOcrWorker.joinable())
|
|
historyOcrWorker = std::thread([this]
|
|
{
|
|
for (;;)
|
|
{
|
|
Settings config;
|
|
{
|
|
std::unique_lock lock(jobsMutex);
|
|
historyOcrReady.wait(lock, [&] { return stop || historyOcrRequested; });
|
|
if (stop) return;
|
|
historyOcrRequested = false;
|
|
config = historyOcrSettings;
|
|
}
|
|
for (const auto &entry : history->entries())
|
|
{
|
|
{ std::lock_guard lock(jobsMutex); if (stop) return; }
|
|
auto profile = ocrProfile(config);
|
|
if (!entry.image || (entry.ocrState != 1 && entry.ocrProfile == profile)) continue;
|
|
try
|
|
{
|
|
auto text = history->recognizeImage(entry.id, config, [this, &profile] {
|
|
std::lock_guard lock(jobsMutex);
|
|
return stop || ocrProfile(historyOcrSettings) != profile;
|
|
});
|
|
std::lock_guard lock(jobsMutex);
|
|
if (stop || ocrProfile(historyOcrSettings) != profile) continue;
|
|
if (history->saveOcr(entry.id, text, config))
|
|
PostMessageW(window, HistoryMessage, 0, 0);
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
// Automatic OCR never changes the clipboard or opens error dialogs.
|
|
log(L"History OCR: " + wide(e.what()));
|
|
try {
|
|
std::lock_guard lock(jobsMutex);
|
|
if (!stop && ocrProfile(historyOcrSettings) == profile)
|
|
history->saveOcr(entry.id, std::nullopt, config);
|
|
}
|
|
catch (const std::exception &saveError) { log(L"History OCR save: " + wide(saveError.what())); }
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
historyOcrReady.notify_one();
|
|
}
|
|
void App::report(const std::wstring &text)
|
|
{
|
|
log(text);
|
|
PostMessageW(window, ErrorMessage, 0, (LPARAM) new std::wstring(text));
|
|
}
|
|
void App::addTray()
|
|
{
|
|
NOTIFYICONDATAW icon{sizeof(icon)};
|
|
icon.hWnd = window;
|
|
icon.uID = 1;
|
|
icon.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
|
|
icon.uCallbackMessage = TrayMessage;
|
|
icon.hIcon = (HICON)LoadImageW(instance, MAKEINTRESOURCEW(IDI_KSWITCHER), IMAGE_ICON,
|
|
GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED);
|
|
wcscpy_s(icon.szTip, localBuildTitle(L"KSwitcher — keyboard layouts & clipboard").c_str());
|
|
Shell_NotifyIconW(NIM_ADD, &icon);
|
|
icon.uVersion = NOTIFYICON_VERSION_4;
|
|
Shell_NotifyIconW(NIM_SETVERSION, &icon);
|
|
}
|
|
bool App::registerHotkeys(const Settings &s, bool rollback)
|
|
{
|
|
std::vector<std::pair<int, Hotkey>> bindings;
|
|
for (auto &[id, text] : shortcuts(s))
|
|
{
|
|
auto key = Hotkey::parse(text);
|
|
if (key && key->key)
|
|
bindings.emplace_back(id, *key);
|
|
}
|
|
if (!bindings.empty() && !keyboardHook)
|
|
{
|
|
if (!rollback)
|
|
registrationWarning = L"Keyboard interception could not start.";
|
|
return false;
|
|
}
|
|
hookBindings = std::move(bindings);
|
|
return true;
|
|
}
|
|
|
|
Bytes App::lanCommand(const Bytes &command)
|
|
{
|
|
if (!lanService) lanService = std::make_unique<LanService>(data,window);
|
|
auto reply = lanService->command(command);
|
|
if (lanService->inputEnabled()) SetTimer(window, 7, 10, nullptr);
|
|
else KillTimer(window, 7);
|
|
if (lanService->takeInputChange()) resetLanInput();
|
|
return reply;
|
|
}
|
|
void App::applySettings(const Settings &requested)
|
|
{
|
|
Settings s = requested;
|
|
std::set<std::wstring> present, removed(s.snippetTombstones.begin(), s.snippetTombstones.end());
|
|
removed.insert(settings.snippetTombstones.begin(), settings.snippetTombstones.end());
|
|
for (auto &snippet : s.snippets) { snippet.id = snippetId(snippet); present.insert(snippet.id); }
|
|
for (const auto &snippet : settings.snippets)
|
|
if (!present.contains(snippetId(snippet))) removed.insert(snippetId(snippet));
|
|
for (const auto &id : present) removed.erase(id);
|
|
s.snippetTombstones.assign(removed.begin(), removed.end());
|
|
bool autostartChanged = false;
|
|
AutoCorrector predictor;
|
|
validateSettings(s);
|
|
validateTesseract(s);
|
|
if (s.autoCorrect)
|
|
{
|
|
predictor.configure(std::filesystem::path(executable()).parent_path() / L"dictionaries", s.autoLanguages);
|
|
}
|
|
if (!registerHotkeys(s))
|
|
{
|
|
registerHotkeys(settings, true);
|
|
throw std::runtime_error(utf8(registrationWarning));
|
|
}
|
|
try
|
|
{
|
|
if (s.autostart != settings.autostart || s.elevatedAutostart != settings.elevatedAutostart)
|
|
{
|
|
setAutostart(s.autostart, s.elevatedAutostart);
|
|
autostartChanged = true;
|
|
}
|
|
saveSettings(data / L"settings.json", s);
|
|
}
|
|
catch (...)
|
|
{
|
|
try
|
|
{
|
|
if (autostartChanged)
|
|
setAutostart(settings.autostart, settings.elevatedAutostart);
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
registerHotkeys(settings, true);
|
|
throw;
|
|
}
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
settings = s;
|
|
autoPredictor = std::move(predictor);
|
|
setLoggingEnabled(s.writeLog);
|
|
run.reset();
|
|
last.reset();
|
|
++inputVersion;
|
|
if (busy) diagnosticEvent(L"Input context changed: settings applied version=" + std::to_wstring(inputVersion.load()));
|
|
}
|
|
// Release the worker's old snapshot; the next check shares the freshly loaded predictor.
|
|
enqueue([this] { autoCorrector.configure({}, {}); });
|
|
scheduleHistoryOcr(s);
|
|
nextSync = std::max(GetTickCount64() + 2000, syncRetryAfter);
|
|
SetThreadExecutionState(ES_CONTINUOUS |
|
|
(settings.awake ? (ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED) : 0));
|
|
}
|
|
void App::reloadLayouts()
|
|
{
|
|
auto latest = readLayouts();
|
|
Settings s = settings;
|
|
std::vector<std::wstring> direct(latest.size());
|
|
for (size_t i = 0; i < latest.size(); ++i)
|
|
for (size_t j = 0; j < layouts.size(); ++j)
|
|
if (latest[i].id == layouts[j].id && j < s.direct.size())
|
|
direct[i] = s.direct[j];
|
|
s.direct = direct;
|
|
s.directIds.clear();
|
|
for (auto &layout : latest)
|
|
s.directIds.push_back(layout.id);
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
layouts = std::move(latest);
|
|
settings = s;
|
|
run.reset();
|
|
last.reset();
|
|
++inputVersion;
|
|
if (busy) diagnosticEvent(L"Input context changed: layouts reloaded version=" + std::to_wstring(inputVersion.load()));
|
|
}
|
|
registerHotkeys(settings);
|
|
}
|
|
void App::clearHistory()
|
|
{
|
|
if (historyService) { remoteHistory("clear"); history->reload(); return; }
|
|
if (busy) throw std::runtime_error("Wait for the current operation to finish.");
|
|
if (history) history->clear();
|
|
if (historyWindow) refreshHistory(*this);
|
|
}
|
|
void App::setHotkeyCapture(HWND field)
|
|
{
|
|
hotkeyCapture = field;
|
|
hotkeyCaptureProcess = 0;
|
|
if (field) GetWindowThreadProcessId(field, &hotkeyCaptureProcess);
|
|
}
|
|
bool App::isHotkey(DWORD key, UINT mods)
|
|
{
|
|
for (auto &[id, text] : shortcuts(settings))
|
|
{
|
|
auto h = Hotkey::parse(text);
|
|
if (h && h->key == key && h->modifiers == mods)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
void App::resetLanInput()
|
|
{
|
|
// Releases may have been consumed on another desktop. Do not retain local
|
|
// shortcut/chat latches across an ownership handoff.
|
|
hotkeyHook = {};
|
|
chatSwitchHook = {};
|
|
pendingMouseClicks = {};
|
|
mouseActions.clear();
|
|
resetInput();
|
|
}
|
|
void App::resetInput()
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
++inputVersion;
|
|
if (busy) diagnosticEvent(L"Input context changed: reset version=" + std::to_wstring(inputVersion.load()));
|
|
run.reset();
|
|
last.reset();
|
|
}
|
|
void App::releaseIdleMemory(ULONGLONG now)
|
|
{
|
|
expireDiagnostics(now);
|
|
std::lock_guard lock(stateMutex);
|
|
// Match the Undo eligibility deadline; never discard an available operation.
|
|
if (!busy && last && now - last->at > 120000) last.reset();
|
|
}
|
|
void App::clearLog(bool previous) { clearDiagnosticLog(previous); }
|
|
void App::keyboard(const KBDLLHOOKSTRUCT &k, UINT mods)
|
|
{
|
|
if (ownKeyboardInput(k))
|
|
return;
|
|
DWORD vk = k.vkCode;
|
|
if (vk == VK_SHIFT || vk == VK_CONTROL || vk == VK_MENU ||
|
|
vk == VK_LSHIFT || vk == VK_RSHIFT || vk == VK_LCONTROL || vk == VK_RCONTROL || vk == VK_LMENU ||
|
|
vk == VK_RMENU || vk == VK_LWIN || vk == VK_RWIN)
|
|
return;
|
|
std::lock_guard lock(stateMutex);
|
|
if (isHotkey(vk, mods))
|
|
return;
|
|
++inputVersion;
|
|
if (busy) diagnosticEvent(L"Input context changed: keyboard vk=" + std::to_wstring(vk) +
|
|
L" modifiers=" + std::to_wstring(mods) + L" injected=" + std::to_wstring((k.flags & LLKHF_INJECTED) != 0) +
|
|
L" version=" + std::to_wstring(inputVersion.load()));
|
|
last.reset();
|
|
HWND fg = GetForegroundWindow();
|
|
HKL layout = windowLayout(fg);
|
|
if (mods & (MOD_CONTROL | MOD_ALT | MOD_WIN))
|
|
{
|
|
run.reset();
|
|
return;
|
|
}
|
|
if (vk == VK_BACK)
|
|
{
|
|
run.backspace(fg, GetTickCount64());
|
|
return;
|
|
}
|
|
bool shift = (mods & MOD_SHIFT) != 0;
|
|
// VK_PACKET carries UTF-16 in scanCode, not a physical key position.
|
|
DWORD scan = vk == VK_PACKET ? 0 : k.scanCode;
|
|
if (!scan && vk != VK_PACKET)
|
|
scan = MapVirtualKeyExW(vk, MAPVK_VK_TO_VSC_EX, layout);
|
|
wchar_t ch = vk == VK_SPACE ? L' ' : physicalKey(scan, shift);
|
|
if (ch && letter(ch) && (GetKeyState(VK_CAPITAL) & 1))
|
|
ch = shift ? lower(std::wstring(1, ch))[0] : upper(std::wstring(1, ch))[0];
|
|
if (!ch)
|
|
{
|
|
run.reset();
|
|
return;
|
|
}
|
|
run.record(ch, fg, layout, GetTickCount64());
|
|
if (settings.autoCorrect && !snippetTyping && k.dwExtraInfo != snippetReplayMarker() &&
|
|
mods == 0 && ch == L' ' && run.keys.size() >= (size_t)settings.autoMinLength + 1 &&
|
|
run.keys.size() <= 41 && !busy && !run.overflow)
|
|
{
|
|
for (int source = 0; source < (int)layouts.size(); ++source)
|
|
if (layouts[source].handle == layout)
|
|
{
|
|
std::wstring predicted;
|
|
for (wchar_t key : run.keys)
|
|
predicted += key == L' ' ? L' ' : layouts[source].at(physicalLayout().code(key));
|
|
if (autoPredictor.suggest(predicted, source, layouts, settings))
|
|
{
|
|
// Reserve the transaction before the next physical key arrives.
|
|
// The delimiter itself passes through; subsequent input is queued.
|
|
typingTarget = fg;
|
|
autoPending = true;
|
|
busy = true;
|
|
if (!PostMessageW(window, AutoCorrectMessage, (WPARAM)inputVersion.load(), 0))
|
|
{
|
|
typingTarget = nullptr;
|
|
autoPending = false;
|
|
busy = false;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (busy || settings.snippets.empty())
|
|
return;
|
|
auto keys = lower(run.keys);
|
|
auto snippetProcess = processName(fg);
|
|
for (int priority : {2, 1})
|
|
for (size_t i = 0; i < settings.snippets.size(); ++i)
|
|
{
|
|
auto &sn = settings.snippets[i];
|
|
if (snippetAppPriority(sn, snippetProcess) != priority) continue;
|
|
std::vector<std::wstring> variants{lower(sn.trigger)};
|
|
for (auto &l : layouts)
|
|
{
|
|
bool valid = true;
|
|
std::wstring normalized;
|
|
for (wchar_t c : sn.trigger)
|
|
{
|
|
auto p = physicalLayout().at(l.code(c));
|
|
if (!p)
|
|
{
|
|
valid = false;
|
|
break;
|
|
}
|
|
normalized += p;
|
|
}
|
|
if (valid)
|
|
variants.push_back(lower(normalized));
|
|
}
|
|
for (auto &trigger : variants)
|
|
if (keys.size() >= trigger.size() && keys.ends_with(trigger))
|
|
{
|
|
// Keep subsequent typing out of the selection/paste transaction.
|
|
typingTarget = fg;
|
|
snippetPending = (int)i;
|
|
snippetTyping = true;
|
|
busy = true;
|
|
if (!PostMessageW(window, SnippetMessage, (WPARAM)i, (LPARAM)inputVersion.load()))
|
|
{
|
|
typingTarget = nullptr;
|
|
snippetPending = -1;
|
|
snippetTyping = false;
|
|
busy = false;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
void App::refreshChatContext()
|
|
{
|
|
HWND target = GetForegroundWindow();
|
|
chatWindow = target;
|
|
activeChatTitle = chatTitle(target);
|
|
activeChat = windowLanguageProfileKey(settings, target);
|
|
}
|
|
void App::switchChatLayout(bool reverse)
|
|
{
|
|
HWND target = chatWindow;
|
|
auto key = activeChat;
|
|
if (!target || target != GetForegroundWindow() || key.empty() ||
|
|
windowLanguageProfileKey(settings, target) != key || busy.exchange(true)) return;
|
|
auto cycle = chatCycle(settings, key, layouts);
|
|
auto available = layouts;
|
|
resetInput();
|
|
enqueue([this, target, key, cycle, available, reverse, profileSettings = settings]
|
|
{
|
|
struct Reset { std::atomic<bool> &busy; ~Reset() { busy = false; } } reset{busy};
|
|
auto valid = [&] { return GetForegroundWindow() == target && windowLanguageProfileKey(profileSettings, target) == key; };
|
|
if (key.starts_with(L"telegram-web\n") && readChromeChat(target) != key) return;
|
|
if (!valid()) return;
|
|
auto next = nextChatLayout(cycle, available, windowLayout(target), reverse);
|
|
if (next) switchWindowLayout(target, next, valid);
|
|
});
|
|
}
|
|
bool App::handleKeyboard(const KBDLLHOOKSTRUCT &key, bool down, UINT mods)
|
|
{
|
|
// Filter before capture, hotkey latching and typing history. External injected
|
|
// down AND up events use exactly the same path as physical keyboard input.
|
|
if (ownKeyboardInput(key) || installingUpdate)
|
|
return false;
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
if (typingTarget && GetForegroundWindow() == typingTarget)
|
|
{
|
|
INPUT input{};
|
|
input.type = INPUT_KEYBOARD;
|
|
input.ki.wVk = static_cast<WORD>(key.vkCode);
|
|
input.ki.wScan = static_cast<WORD>(key.scanCode);
|
|
input.ki.dwFlags = (down ? 0 : KEYEVENTF_KEYUP) |
|
|
((key.flags & LLKHF_EXTENDED) ? KEYEVENTF_EXTENDEDKEY : 0);
|
|
if (key.vkCode == VK_PACKET)
|
|
{
|
|
input.ki.wVk = 0;
|
|
input.ki.dwFlags |= KEYEVENTF_UNICODE;
|
|
}
|
|
// Replay as ordinary input so tracking and shortcuts see it once,
|
|
// after the replacement and layout switch have finished.
|
|
deferredTyping.push_back(input);
|
|
return true;
|
|
}
|
|
}
|
|
DWORD captureProcess{};
|
|
if (hotkeyCapture) GetWindowThreadProcessId(hotkeyCapture, &captureProcess);
|
|
if (hotkeyCapture && (!captureProcess || captureProcess != hotkeyCaptureProcess))
|
|
setHotkeyCapture(nullptr);
|
|
if (hotkeyCapture && GetForegroundWindow() == GetAncestor(hotkeyCapture, GA_ROOT))
|
|
{
|
|
bool modifier = key.vkCode == VK_CONTROL || key.vkCode == VK_SHIFT || key.vkCode == VK_MENU ||
|
|
key.vkCode == VK_LCONTROL || key.vkCode == VK_RCONTROL || key.vkCode == VK_LSHIFT ||
|
|
key.vkCode == VK_RSHIFT || key.vkCode == VK_LMENU || key.vkCode == VK_RMENU ||
|
|
key.vkCode == VK_LWIN || key.vkCode == VK_RWIN;
|
|
if (!modifier)
|
|
{
|
|
if (!down)
|
|
hotkeyHook.update(key.vkCode, false, 0, {});
|
|
if (down)
|
|
{
|
|
if (mods & MOD_WIN)
|
|
chord(0xE8);
|
|
PostMessageW(hotkeyCapture, CaptureHotkeyMessage, key.vkCode, mods);
|
|
}
|
|
return 1; // Record the chord without executing a global shortcut or typing into an editor.
|
|
}
|
|
}
|
|
bool chatEnabled = false;
|
|
if (down && ChatSwitchHook::candidate(key.vkCode, mods) && (!settings.chatCycles.empty() || !settings.appLanguageSets.empty()) &&
|
|
!isHotkey(key.vkCode, mods))
|
|
{
|
|
refreshChatContext();
|
|
chatEnabled = !activeChat.empty();
|
|
}
|
|
const int chatAction = chatSwitchHook.update(key.vkCode, down, mods, chatEnabled);
|
|
if (chatAction)
|
|
{
|
|
if (chatAction > 0)
|
|
{
|
|
chord(0xE8); // Suppress the shell's bare Alt/Win action.
|
|
switchChatLayout(chatAction == 2); // Captures this chat before another keyboard event.
|
|
}
|
|
return true;
|
|
}
|
|
if (down)
|
|
{
|
|
auto action = hotkeyHook.update(key.vkCode, true, mods, hookBindings);
|
|
if (action > 0)
|
|
{
|
|
// Tell the shell that Win participated in a chord, preventing Start
|
|
// from opening on Win-up after we consumed V. 0xE8 is unassigned.
|
|
if (mods & (MOD_WIN | MOD_ALT))
|
|
chord(0xE8);
|
|
PostMessageW(window, WM_HOTKEY, action, 0);
|
|
}
|
|
if (action != 0)
|
|
return 1;
|
|
keyboard(key, mods);
|
|
}
|
|
else if (hotkeyHook.update(key.vkCode, false, 0, hookBindings) != 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
bool App::beginTypingDeferral(HWND target, uint64_t version, bool snippet)
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
if (inputVersion != version || GetForegroundWindow() != target || !modifiersReleased())
|
|
return false;
|
|
typingTarget = target;
|
|
snippetTyping = snippet;
|
|
return true;
|
|
}
|
|
void App::replayTyping()
|
|
{
|
|
std::vector<INPUT> inputs;
|
|
HWND target;
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
target = typingTarget;
|
|
typingTarget = nullptr;
|
|
autoPending = false;
|
|
snippetPending = -1;
|
|
inputs.swap(deferredTyping);
|
|
if (snippetTyping)
|
|
for (auto &input : inputs)
|
|
input.ki.dwExtraInfo = snippetReplayMarker();
|
|
snippetTyping = false;
|
|
}
|
|
busy = false;
|
|
if (inputs.empty())
|
|
return;
|
|
if (GetForegroundWindow() != target)
|
|
{
|
|
resetInput();
|
|
report(L"Typing during correction was not replayed because the active window changed.");
|
|
return;
|
|
}
|
|
// Runs on the hook thread: no physical key can pass between releasing the
|
|
// gate and submitting the entire ordered batch to the Windows input queue.
|
|
if (SendInput(static_cast<UINT>(inputs.size()), inputs.data(), sizeof(INPUT)) != inputs.size())
|
|
{
|
|
resetInput();
|
|
report(L"Windows could not replay all typing buffered during correction.");
|
|
}
|
|
}
|
|
LRESULT CALLBACK App::keyProc(int code, WPARAM wp, LPARAM lp)
|
|
{
|
|
if (code == HC_ACTION && current && current->lanService &&
|
|
(wp == WM_KEYDOWN || wp == WM_SYSKEYDOWN || wp == WM_KEYUP || wp == WM_SYSKEYUP))
|
|
{
|
|
bool consumed = current->lanService->keyboard(*(KBDLLHOOKSTRUCT *)lp, wp == WM_KEYDOWN || wp == WM_SYSKEYDOWN);
|
|
if (current->lanService->takeInputChange()) current->resetLanInput();
|
|
if (consumed) return 1; // Forwarded keys must not reach local hotkeys/snippets or other routers.
|
|
}
|
|
// MWB suppresses source-machine events that it forwards elsewhere. Let
|
|
// downstream hooks route the event before tracking it or starting a snippet.
|
|
// Call the chain exactly once; a local event can still be consumed below.
|
|
const auto routed = CallNextHookEx(nullptr, code, wp, lp);
|
|
return keyboardAfterHooks(code, wp, lp, routed);
|
|
}
|
|
LRESULT App::keyboardAfterHooks(int code, WPARAM wp, LPARAM lp, LRESULT routed)
|
|
{
|
|
if (routed) return routed;
|
|
if (code == HC_ACTION && current &&
|
|
(wp == WM_KEYDOWN || wp == WM_SYSKEYDOWN || wp == WM_KEYUP || wp == WM_SYSKEYUP))
|
|
{
|
|
// The current event has not updated asynchronous state yet; the preceding
|
|
// modifier events (including MWB input) have. Own events must still reach Windows.
|
|
UINT mods = 0;
|
|
if (GetAsyncKeyState(VK_CONTROL) & 0x8000) mods |= MOD_CONTROL;
|
|
if (GetAsyncKeyState(VK_MENU) & 0x8000) mods |= MOD_ALT;
|
|
if (GetAsyncKeyState(VK_SHIFT) & 0x8000) mods |= MOD_SHIFT;
|
|
if ((GetAsyncKeyState(VK_LWIN) | GetAsyncKeyState(VK_RWIN)) & 0x8000) mods |= MOD_WIN;
|
|
if (current->handleKeyboard(*(KBDLLHOOKSTRUCT *)lp,
|
|
wp == WM_KEYDOWN || wp == WM_SYSKEYDOWN, mods))
|
|
return 1;
|
|
}
|
|
return routed;
|
|
}
|
|
constexpr UINT MouseActionMessage = WM_APP + 79;
|
|
constexpr UINT MouseVolumeReleasedMessage = WM_APP + 80;
|
|
constexpr UINT_PTR MouseClickTimer = 9;
|
|
constexpr UINT_PTR FirstMouseVolumeTimer = 10;
|
|
|
|
namespace
|
|
{
|
|
constexpr wchar_t VolumeIndicatorClass[] = L"KSwitcher.VolumeIndicator";
|
|
constexpr UINT_PTR VolumeIndicatorTimer = 1;
|
|
constexpr WORD VolumeIndicatorMuted = 1, VolumeIndicatorHeld = 2;
|
|
|
|
void paintVolumeIndicator(HWND w)
|
|
{
|
|
PAINTSTRUCT paint{};
|
|
const auto dc = BeginPaint(w, &paint);
|
|
RECT bounds{};
|
|
GetClientRect(w, &bounds);
|
|
FillRect(dc, &bounds, GetSysColorBrush(COLOR_WINDOW));
|
|
FrameRect(dc, &bounds, GetSysColorBrush(COLOR_WINDOWFRAME));
|
|
const int dpi = static_cast<int>(GetDpiForWindow(w));
|
|
const int padding = MulDiv(8, dpi, 96);
|
|
const int captionHeight = MulDiv(26, dpi, 96);
|
|
const auto state = GetWindowLongPtrW(w, GWLP_USERDATA);
|
|
const int percent = LOWORD(state);
|
|
const bool muted = (HIWORD(state) & VolumeIndicatorMuted) != 0;
|
|
RECT track{padding, padding, bounds.right - padding, bounds.bottom - captionHeight};
|
|
FillRect(dc, &track, GetSysColorBrush(COLOR_3DFACE));
|
|
RECT fill = track;
|
|
fill.top = fill.bottom - MulDiv(fill.bottom - fill.top, percent, 100);
|
|
FillRect(dc, &fill, GetSysColorBrush(muted ? COLOR_GRAYTEXT : COLOR_HIGHLIGHT));
|
|
RECT caption{0, track.bottom, bounds.right, bounds.bottom};
|
|
const auto text = muted ? std::wstring(L"Mute") : std::to_wstring(percent) + L"%";
|
|
const auto font = CreateFontW(-MulDiv(12, dpi, 96), 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
|
|
DEFAULT_CHARSET, 0, 0, 0, 0, L"Segoe UI");
|
|
const auto previous = font ? SelectObject(dc, font) : nullptr;
|
|
SetBkMode(dc, TRANSPARENT);
|
|
SetTextColor(dc, GetSysColor(COLOR_WINDOWTEXT));
|
|
DrawTextW(dc, text.c_str(), -1, &caption, DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_NOPREFIX);
|
|
if (previous) SelectObject(dc, previous);
|
|
if (font) DeleteObject(font);
|
|
EndPaint(w, &paint);
|
|
}
|
|
|
|
LRESULT CALLBACK volumeIndicatorProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
|
|
{
|
|
switch (msg)
|
|
{
|
|
case WM_PAINT: paintVolumeIndicator(w); return 0;
|
|
case WM_NCHITTEST: return HTTRANSPARENT;
|
|
case WM_MOUSEACTIVATE: return MA_NOACTIVATE;
|
|
case WM_TIMER:
|
|
if (wp == VolumeIndicatorTimer)
|
|
{
|
|
KillTimer(w, VolumeIndicatorTimer);
|
|
if (!(HIWORD(GetWindowLongPtrW(w, GWLP_USERDATA)) & VolumeIndicatorHeld))
|
|
ShowWindow(w, SW_HIDE);
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
return DefWindowProcW(w, msg, wp, lp);
|
|
}
|
|
|
|
void setVolumeIndicatorHold(HWND indicator, bool held)
|
|
{
|
|
const auto state = GetWindowLongPtrW(indicator, GWLP_USERDATA);
|
|
const WORD flags = (HIWORD(state) & VolumeIndicatorMuted) | (held ? VolumeIndicatorHeld : 0);
|
|
SetWindowLongPtrW(indicator, GWLP_USERDATA, MAKELPARAM(LOWORD(state), flags));
|
|
if (held) KillTimer(indicator, VolumeIndicatorTimer);
|
|
else SetTimer(indicator, VolumeIndicatorTimer, 1000, nullptr);
|
|
}
|
|
|
|
void showVolumeIndicator(HWND owner, HINSTANCE instance, POINT point, SystemVolume volume, bool held)
|
|
{
|
|
MONITORINFO monitor{sizeof(monitor)};
|
|
const auto targetMonitor = MonitorFromPoint(point, MONITOR_DEFAULTTONEAREST);
|
|
if (!GetMonitorInfoW(targetMonitor, &monitor)) return;
|
|
const auto &area = monitor.rcWork;
|
|
auto indicator = reinterpret_cast<HWND>(GetPropW(owner, VolumeIndicatorClass));
|
|
if (!indicator)
|
|
{
|
|
WNDCLASSW type{};
|
|
type.lpfnWndProc = volumeIndicatorProc;
|
|
type.hInstance = instance;
|
|
type.lpszClassName = VolumeIndicatorClass;
|
|
RegisterClassW(&type);
|
|
indicator = CreateWindowExW(WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW | WS_EX_TOPMOST |
|
|
WS_EX_LAYERED | WS_EX_TRANSPARENT, VolumeIndicatorClass, L"Volume",
|
|
WS_POPUP, area.left, area.top, 1, 1, owner, nullptr, instance, nullptr);
|
|
if (!indicator) return;
|
|
if (!SetPropW(owner, VolumeIndicatorClass, indicator) ||
|
|
!SetLayeredWindowAttributes(indicator, 0, 255, LWA_ALPHA))
|
|
{
|
|
RemovePropW(owner, VolumeIndicatorClass);
|
|
DestroyWindow(indicator);
|
|
return;
|
|
}
|
|
}
|
|
// Place the window on the destination monitor before querying its DPI.
|
|
if (MonitorFromWindow(indicator, MONITOR_DEFAULTTONEAREST) != targetMonitor)
|
|
SetWindowPos(indicator, nullptr, area.left, area.top, 0, 0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW);
|
|
const int dpi = static_cast<int>(GetDpiForWindow(indicator));
|
|
const int width = MulDiv(48, dpi, 96);
|
|
const int height = MulDiv(132, dpi, 96);
|
|
const int margin = MulDiv(16, dpi, 96);
|
|
SetWindowLongPtrW(indicator, GWLP_USERDATA, MAKELPARAM(volume.percent, volume.muted ? VolumeIndicatorMuted : 0));
|
|
setVolumeIndicatorHold(indicator, held);
|
|
SetWindowPos(indicator, HWND_TOPMOST, area.right - width - margin, area.bottom - height - margin,
|
|
width, height, SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
|
InvalidateRect(indicator, nullptr, FALSE);
|
|
}
|
|
}
|
|
|
|
void App::queueMouseAction(MousePress press)
|
|
{
|
|
if (press.action.type == MouseActionType::Standard) return;
|
|
mouseActions.push_back(std::move(press));
|
|
PostMessageW(window, MouseActionMessage, 0, 0);
|
|
}
|
|
|
|
void App::flushMouseClicks()
|
|
{
|
|
ULONGLONG next = 0;
|
|
const auto now = GetTickCount64();
|
|
for (auto &press : pendingMouseClicks)
|
|
{
|
|
if (!press.target) continue;
|
|
const auto deadline = press.started + GetDoubleClickTime();
|
|
if (now >= deadline)
|
|
{
|
|
queueMouseAction(std::exchange(press, {}));
|
|
}
|
|
else if (!next || deadline < next) next = deadline;
|
|
}
|
|
if (next) SetTimer(window, MouseClickTimer, static_cast<UINT>(next - now), nullptr);
|
|
else KillTimer(window, MouseClickTimer);
|
|
}
|
|
|
|
void App::beginMouseVolume(int button)
|
|
{
|
|
const auto &press = mousePresses[button];
|
|
if (!press.waitForSecond) queueMouseAction(press);
|
|
const UINT delay = press.waitForSecond ? std::max(MouseVolumeHoldDelay, GetDoubleClickTime()) : MouseVolumeHoldDelay;
|
|
SetTimer(window, FirstMouseVolumeTimer + button, delay, nullptr);
|
|
}
|
|
|
|
void App::repeatMouseVolume(int button)
|
|
{
|
|
const auto timer = FirstMouseVolumeTimer + button;
|
|
auto &press = mousePresses[button];
|
|
if (!press.held || !isMouseVolumeStep(press.action.type) ||
|
|
busy || suspended || installingUpdate || hotkeyCapture || !modifiersReleased() ||
|
|
!IsWindow(press.target) || (!press.action.applications.empty() && press.target != GetForegroundWindow()))
|
|
{
|
|
KillTimer(window, timer);
|
|
return;
|
|
}
|
|
const auto elapsed = GetTickCount64() - press.started;
|
|
const UINT delay = press.waitForSecond ? std::max(MouseVolumeHoldDelay, GetDoubleClickTime()) : MouseVolumeHoldDelay;
|
|
if (elapsed < delay) return;
|
|
press.waitForSecond = false;
|
|
queueMouseAction(press);
|
|
SetTimer(window, timer, mouseVolumeRepeatInterval(elapsed), nullptr);
|
|
}
|
|
|
|
bool App::volumeButtonHeld() const
|
|
{
|
|
return std::any_of(mousePresses.begin(), mousePresses.end(), [](const MousePress &press)
|
|
{
|
|
return press.held && !press.waitForSecond && isMouseVolumeStep(press.action.type);
|
|
});
|
|
}
|
|
|
|
void App::dispatchMouseActions()
|
|
{
|
|
std::deque<MousePress> actions;
|
|
actions.swap(mouseActions);
|
|
if (busy || suspended || installingUpdate || hotkeyCapture || !modifiersReleased())
|
|
{
|
|
if (!actions.empty()) log(L"Mouse action skipped while input was unavailable.");
|
|
return;
|
|
}
|
|
for (const auto &press : actions)
|
|
{
|
|
if (!IsWindow(press.target)) continue;
|
|
const auto &action = press.action;
|
|
switch (action.type)
|
|
{
|
|
case MouseActionType::Standard: break;
|
|
case MouseActionType::Shortcut:
|
|
if (press.target != GetForegroundWindow())
|
|
log(L"Mouse shortcut skipped because the active window changed.");
|
|
else if (!chord(static_cast<WORD>(action.shortcut.key), action.shortcut.modifiers))
|
|
log(L"Windows did not accept all input for the mouse shortcut.");
|
|
else
|
|
log(L"Windows accepted input for the mouse shortcut.");
|
|
break;
|
|
case MouseActionType::Back:
|
|
case MouseActionType::Forward:
|
|
PostMessageW(press.target, WM_APPCOMMAND, reinterpret_cast<WPARAM>(press.target),
|
|
MAKELPARAM(0, FAPPCOMMAND_MOUSE | (action.type == MouseActionType::Back ?
|
|
APPCOMMAND_BROWSER_BACKWARD : APPCOMMAND_BROWSER_FORWARD)));
|
|
break;
|
|
case MouseActionType::VolumeUp:
|
|
case MouseActionType::VolumeDown:
|
|
case MouseActionType::Mute:
|
|
if (const auto volume = changeSystemVolume(action.type, action.volumeStep))
|
|
showVolumeIndicator(window, instance, press.point, *volume, volumeButtonHeld());
|
|
else log(L"Mouse action could not change or read system volume.");
|
|
break;
|
|
case MouseActionType::Launch:
|
|
if (!launchThroughExplorer(action.executable))
|
|
log(L"Mouse action could not launch " + action.executable);
|
|
else
|
|
log(L"Mouse action launched " + std::filesystem::path(action.executable).filename().wstring());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
LRESULT CALLBACK App::mouseProc(int code, WPARAM wp, LPARAM lp)
|
|
{
|
|
if (code == HC_ACTION && current)
|
|
{
|
|
auto &app = *current;
|
|
const auto &mouse = *reinterpret_cast<const MSLLHOOKSTRUCT *>(lp);
|
|
const int button = mouse.flags & LLMHF_INJECTED ? -1 : mouseButton(UINT(wp), HIWORD(mouse.mouseData));
|
|
const bool down = mouseButtonDown(UINT(wp));
|
|
if (button >= 0 && app.mousePresses[button].held)
|
|
{
|
|
auto &active = app.mousePresses[button];
|
|
const bool consumed = active.action.type != MouseActionType::Standard;
|
|
if (!down)
|
|
{
|
|
auto press = std::exchange(active, {});
|
|
if (isMouseVolumeStep(press.action.type))
|
|
{
|
|
KillTimer(app.window, FirstMouseVolumeTimer + button);
|
|
PostMessageW(app.window, MouseVolumeReleasedMessage, 0, 0);
|
|
}
|
|
if (press.waitForSecond)
|
|
{
|
|
app.pendingMouseClicks[button] = std::move(press);
|
|
app.flushMouseClicks();
|
|
}
|
|
else if (!isMouseVolumeStep(press.action.type)) app.queueMouseAction(std::move(press));
|
|
}
|
|
if (consumed) return 1;
|
|
}
|
|
if (app.lanService)
|
|
{
|
|
const bool mouseActionHeld = std::any_of(app.mousePresses.begin(), app.mousePresses.end(),
|
|
[](const MousePress &press) { return press.held; });
|
|
bool consumed = app.lanService->mouse(UINT(wp), mouse,
|
|
!app.busy && !app.suspended && !app.hotkeyCapture && !mouseActionHeld);
|
|
if (app.lanService->takeInputChange()) app.resetLanInput();
|
|
if (consumed) return 1;
|
|
}
|
|
if (button >= 0 && down && !app.settings.mouseBindings.empty() && !app.busy && !app.suspended &&
|
|
!app.installingUpdate && !app.hotkeyCapture && modifiersReleased())
|
|
{
|
|
const auto hit = WindowFromPoint(mouse.pt);
|
|
const auto target = GetAncestor(hit, GA_ROOT);
|
|
const auto name = target ? mouseApplicationName(target) : L"";
|
|
wchar_t windowClass[64]{};
|
|
if (target && name == L"explorer") GetClassNameW(target, windowClass, std::size(windowClass));
|
|
const bool ownWindow = name == L"kswitcher" || name == L"kswitcher.config";
|
|
const bool shellSurface = target == GetShellWindow() || wcscmp(windowClass, L"Progman") == 0 ||
|
|
wcscmp(windowClass, L"WorkerW") == 0 || wcscmp(windowClass, L"Shell_TrayWnd") == 0 ||
|
|
wcscmp(windowClass, L"Shell_SecondaryTrayWnd") == 0;
|
|
const auto *global = mouseBinding(app.settings, GlobalMouseProfile, button);
|
|
const bool globalLaunch = button >= 2 && global && global->type == MouseActionType::Launch &&
|
|
mouseActionApplies(*global, name);
|
|
const bool restricted = ownWindow || shellSurface || name.empty();
|
|
const bool testButton = name == L"kswitcher.config" && hit == GetDlgItem(target, 737);
|
|
const auto *fallback = restricted ? effectiveMouseAction(app.settings, L"", button, false) : nullptr;
|
|
const auto *restrictedAction = isMouseVolumeAction(fallback) ? fallback : globalLaunch ? global : nullptr;
|
|
const bool eligible = target && !testButton && (!restricted || (button >= 2 && restrictedAction)) &&
|
|
(button >= 2 || target == GetForegroundWindow());
|
|
if (eligible)
|
|
{
|
|
const bool foreground = target == GetForegroundWindow();
|
|
bool singleScoped{}, doubleScoped{};
|
|
auto *single = restricted ? restrictedAction :
|
|
effectiveMouseAction(app.settings, name, button, foreground, &singleScoped);
|
|
auto *doubleClick = !restricted && button < 3 ?
|
|
effectiveMouseAction(app.settings, name, 5 + button, foreground, &doubleScoped) : nullptr;
|
|
if (!foreground)
|
|
{
|
|
if (single && single->type == MouseActionType::Shortcut) single = nullptr;
|
|
if (doubleClick && doubleClick->type == MouseActionType::Shortcut) doubleClick = nullptr;
|
|
}
|
|
const auto now = GetTickCount64();
|
|
auto &pending = app.pendingMouseClicks[button];
|
|
const bool second = doubleClick && pending.target == target &&
|
|
doubleMouseClick(pending.point, mouse.pt, now - pending.started);
|
|
if (second) pending = {};
|
|
else if (pending.target) app.queueMouseAction(std::exchange(pending, {}));
|
|
const auto *action = second ? doubleClick : single;
|
|
if (action || doubleClick)
|
|
app.mousePresses[button] = {target, mouse.pt, now, action ? *action : MouseAction{},
|
|
true, doubleClick && !second};
|
|
if (action)
|
|
{
|
|
if (second ? doubleScoped : singleScoped) app.mousePresses[button].action.applications.insert(name);
|
|
if (isMouseVolumeStep(action->type))
|
|
app.beginMouseVolume(button);
|
|
app.resetInput();
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
// Remote clicks invalidate a typing range just like local clicks.
|
|
if (down || wp == WM_MOUSEWHEEL || wp == WM_MOUSEHWHEEL)
|
|
{
|
|
if (app.busy) diagnosticEvent(L"Input context changed: mouse message=" + std::to_wstring(wp));
|
|
app.resetInput();
|
|
}
|
|
}
|
|
return CallNextHookEx(nullptr, code, wp, lp);
|
|
}
|
|
void App::dispatch(int command)
|
|
{
|
|
if (installingUpdate)
|
|
return;
|
|
try
|
|
{
|
|
if (command == 23) { checkUpdate(true); return; }
|
|
if (command == Screenshot)
|
|
{
|
|
if (!busy) { resetInput(); launchScreenshot(*this); }
|
|
return;
|
|
}
|
|
if (command == ShowHistory)
|
|
{
|
|
showHistory(*this);
|
|
return;
|
|
}
|
|
if (command == 20)
|
|
{
|
|
showSettings(*this);
|
|
return;
|
|
}
|
|
if (command == 22)
|
|
{
|
|
showLogs(*this);
|
|
return;
|
|
}
|
|
if (command == 21)
|
|
{
|
|
showSnippets(*this);
|
|
return;
|
|
}
|
|
if (command == 99)
|
|
{
|
|
PostMessageW(window, WM_CLOSE, 0, 0);
|
|
return;
|
|
}
|
|
transform(command);
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
report(wide(e.what()));
|
|
}
|
|
}
|
|
void App::transform(int command, int snippet)
|
|
{
|
|
if (installingUpdate) return;
|
|
const auto attempt = ++transformAttempt;
|
|
const auto requestedAt = GetTickCount64();
|
|
HWND target = GetForegroundWindow();
|
|
const bool manual = command != AutoCorrect && snippet < 0;
|
|
if (manual)
|
|
{
|
|
const auto currentVersion = inputVersion.load();
|
|
repeatAttempts = target == previousAttemptWindow && command == previousAttemptCommand &&
|
|
currentVersion == previousAttemptVersion &&
|
|
requestedAt - previousAttemptAt < 10000
|
|
? repeatAttempts + 1 : 1;
|
|
previousAttemptWindow = target;
|
|
previousAttemptCommand = command;
|
|
previousAttemptVersion = currentVersion;
|
|
previousAttemptAt = requestedAt;
|
|
diagnosticEvent(L"Transform request id=" + std::to_wstring(attempt) + L" command=" +
|
|
std::to_wstring(command) + L" process=" + processName(target) +
|
|
L" window=" + std::to_wstring(reinterpret_cast<uintptr_t>(target)) +
|
|
L" version=" + std::to_wstring(currentVersion) +
|
|
L" repeat=" + std::to_wstring(repeatAttempts));
|
|
}
|
|
const bool preDeferred = (command == AutoCorrect && autoPending) ||
|
|
(snippet >= 0 && snippetPending == snippet);
|
|
if (busy.exchange(true) && !preDeferred)
|
|
{
|
|
if (manual)
|
|
{
|
|
diagnosticEvent(L"Transform outcome id=" + std::to_wstring(attempt) + L" reason=busy");
|
|
try
|
|
{
|
|
DiagnosticJson record{{"attempt", std::to_string(attempt)}, {"process", utf8(processName(target))},
|
|
{"command", transformCommandName(command)}, {"source", "Unknown"}, {"target", "Unknown"},
|
|
{"outcome", "busy"}, {"verification", "not-attempted"}, {"problem", true},
|
|
{"elapsedMs", GetTickCount64() - requestedAt}};
|
|
diagnosticOperation(record.dump());
|
|
}
|
|
catch (...) {}
|
|
}
|
|
return;
|
|
}
|
|
if (preDeferred)
|
|
{
|
|
autoPending = false;
|
|
snippetPending = -1;
|
|
}
|
|
Run recent;
|
|
std::optional<LastTransform> previous;
|
|
Settings config;
|
|
std::vector<Layout> available;
|
|
uint64_t version;
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
recent = run;
|
|
previous = last;
|
|
config = settings;
|
|
available = layouts;
|
|
version = inputVersion;
|
|
}
|
|
const auto requestedChat = config.chatCycles.empty() ? L"" : windowChatKey(target);
|
|
enqueue(
|
|
[this, target, recent, previous, config, available, version, command, snippet, attempt, manual, requestedAt, preDeferred, requestedChat]() mutable
|
|
{
|
|
struct BusyReset
|
|
{
|
|
std::atomic<bool> &b;
|
|
HWND window;
|
|
bool deferred{};
|
|
~BusyReset()
|
|
{
|
|
if (deferred)
|
|
PostMessageW(window, ReplayTypingMessage, 0, 0);
|
|
else
|
|
b = false;
|
|
}
|
|
} reset{busy, window, preDeferred};
|
|
auto effectiveChat = requestedChat;
|
|
if (lower(processName(target)) == L"chrome") effectiveChat = readChromeChat(target);
|
|
config.cycle = chatCycle(config, languageProfileKey(config, target, effectiveChat), available);
|
|
auto start = GetTickCount64();
|
|
std::wstring reason = L"cancelled-before-selection";
|
|
std::wstring text, result, expected, actual, verification = L"not-attempted";
|
|
int hint = -1, to = command >= Direct ? command - Direct : -1;
|
|
if (manual)
|
|
{
|
|
std::wstring layoutIds;
|
|
for (const auto &layout : available)
|
|
{
|
|
layoutIds += layout.id + L",";
|
|
if (layout.handle == recent.layout)
|
|
for (wchar_t key : recent.keys)
|
|
expected += key == L' ' ? L' ' : layout.at(physicalLayout().code(key));
|
|
}
|
|
diagnosticEvent(L"Transform context id=" + std::to_wstring(attempt) +
|
|
L" layouts=" + layoutIds + L" physicalKeys=" + diagnosticText(recent.keys) +
|
|
L" trackedExpected=" + diagnosticText(expected));
|
|
}
|
|
struct Audit
|
|
{
|
|
App &app;
|
|
HWND target;
|
|
uint64_t version, attempt;
|
|
ULONGLONG start;
|
|
bool enabled;
|
|
std::wstring &reason;
|
|
std::wstring &text, &result, &expected;
|
|
std::wstring &actual, &verification;
|
|
int &hint, &to;
|
|
int command;
|
|
const std::vector<Layout> &layouts;
|
|
~Audit()
|
|
{
|
|
if (enabled)
|
|
try
|
|
{
|
|
auto layout = [&](int index) { return index >= 0 && index < (int)layouts.size()
|
|
? utf8(layouts[index].name + L" (" + layouts[index].id + L")") : std::string("Unknown"); };
|
|
auto bounded = [](const std::wstring &value) { return utf8(value.substr(0, 4096)); };
|
|
DiagnosticJson record{{"attempt", std::to_string(attempt)}, {"process", utf8(processName(target))},
|
|
{"command", transformCommandName(command)}, {"source", layout(text.empty() ? hint : detect(text, layouts, hint))}, {"target", layout(to)},
|
|
{"outcome", utf8(reason)}, {"verification", utf8(verification)},
|
|
{"problem", reason != L"Paste verified" && reason != L"layout-only" &&
|
|
!(command == 0 && reason == L"paste-sent-unverified")},
|
|
{"elapsedMs", GetTickCount64() - start}, {"foregroundSame", GetForegroundWindow() == target},
|
|
{"inputSame", app.inputVersion.load() == version}, {"original", bounded(text)},
|
|
{"expected", bounded(verification == L"selection-mismatch" ? expected : result)}, {"actual", bounded(actual)},
|
|
{"selectionExpected", bounded(expected)},
|
|
{"originalUnits", text.size()}, {"expectedUnits", (verification == L"selection-mismatch" ? expected : result).size()}, {"actualUnits", actual.size()},
|
|
{"textTruncated", text.size() > 4096 || result.size() > 4096 || actual.size() > 4096 || expected.size() > 4096}};
|
|
diagnosticOperation(record.dump(-1, ' ', true, DiagnosticJson::error_handler_t::replace));
|
|
}
|
|
catch (...) {} // Logging must never abort a completed input transaction.
|
|
}
|
|
} audit{*this, target, version, attempt, requestedAt, manual || snippet >= 0, reason, text, result, expected,
|
|
actual, verification, hint, to, command, available};
|
|
try
|
|
{
|
|
auto valid = [&]
|
|
{ return GetForegroundWindow() == target && inputVersion.load() == version; };
|
|
for (int i = 0; i < 8 && !modifiersReleased(); ++i)
|
|
Sleep(10);
|
|
if (!modifiersReleased() && command == AutoCorrect)
|
|
return;
|
|
if (!modifiersReleased())
|
|
releaseModifiers();
|
|
if (!valid())
|
|
return;
|
|
for (int i = 0; i < (int)available.size(); ++i)
|
|
if (available[i].handle == windowLayout(target))
|
|
hint = i;
|
|
reason = L"invalid-target-layout";
|
|
if (to >= (int)available.size())
|
|
return;
|
|
if (to >= 0 && !available[to].convertible)
|
|
{
|
|
reason = switchWindowLayout(target, available[to].handle, valid)
|
|
? L"layout-only" : L"layout-switch-failed";
|
|
return;
|
|
}
|
|
if (command == AutoCorrect)
|
|
{
|
|
if (!config.autoCorrect || recent.window != target || recent.overflow ||
|
|
recent.keys.empty() || recent.keys.back() != L' ' || hint < 0)
|
|
return;
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
if (inputVersion.load() != version) return;
|
|
autoCorrector.shareDictionaries(autoPredictor);
|
|
}
|
|
std::wstring predicted;
|
|
for (wchar_t key : recent.keys)
|
|
predicted += key == L' ' ? L' ' : available[hint].at(physicalLayout().code(key));
|
|
expected = predicted;
|
|
if (!autoCorrector.suggest(predicted, hint, available, config) ||
|
|
!autoCorrectionAllowed(target, config) || !valid())
|
|
return;
|
|
}
|
|
reason = L"clipboard-snapshot";
|
|
if (command == AutoCorrect || snippet >= 0)
|
|
{
|
|
if (!beginTypingDeferral(target, version, snippet >= 0))
|
|
return;
|
|
reset.deferred = true;
|
|
}
|
|
// Collapse a temporary selection on every failed auto-correction,
|
|
// including clipboard exceptions, before queued typing is replayed.
|
|
const bool farSnippet = snippet >= 0 && lower(processName(target)) == L"far";
|
|
bool autoSelected = false;
|
|
struct SelectionReset
|
|
{
|
|
bool &selected;
|
|
std::function<bool()> valid;
|
|
bool farEditor;
|
|
~SelectionReset() { if (selected && !farEditor && valid()) chord(VK_RIGHT); }
|
|
} selectionReset{autoSelected, valid, farSnippet};
|
|
Transaction tx(*this, target, version, farSnippet);
|
|
reason = L"selection-unavailable";
|
|
diagnosticEvent(L"Transform target=" + processName(target) + L" command=" + std::to_wstring(command) +
|
|
L" recent=" + std::to_wstring(config.recent) + L" keys=" +
|
|
std::to_wstring(recent.keys.size()) + L" sameWindow=" +
|
|
std::to_wstring(recent.window == target) + L" overflow=" +
|
|
std::to_wstring(recent.overflow) + L" ageMs=" +
|
|
std::to_wstring(recent.at ? start - recent.at : 0) +
|
|
L" id=" + std::to_wstring(attempt));
|
|
bool automatic = false;
|
|
if (command == AutoCorrect)
|
|
{
|
|
// The editor must select the complete previous word. Unlike manual
|
|
// conversion, automatic correction must never fall back to a suffix.
|
|
if (!tx.valid() || !chord(VK_LEFT, MOD_CONTROL | MOD_SHIFT))
|
|
return;
|
|
autoSelected = true;
|
|
Sleep(25);
|
|
text = tx.copy();
|
|
// Editors may split hj,bnm at the comma. Extend only a verified
|
|
// suffix of the tracked input, and still require a complete match.
|
|
for (int i = 0; i < 3 && tx.valid() &&
|
|
matchAutoInput(recent, text, available, physicalLayout(), config) < 0 &&
|
|
(autoClosingSelection(text, config) ||
|
|
(!text.empty() && text.size() < expected.size() && expected.ends_with(text))); ++i)
|
|
{
|
|
if (!chord(VK_LEFT, MOD_CONTROL | MOD_SHIFT))
|
|
break;
|
|
Sleep(25);
|
|
text = tx.copy();
|
|
}
|
|
hint = matchAutoInput(recent, text, available, physicalLayout(), config);
|
|
auto suggestion = autoCorrector.suggest(text, hint, available, config);
|
|
if (!suggestion || !tx.valid() || !autoCorrectionAllowed(target, config))
|
|
{
|
|
if (tx.valid())
|
|
{
|
|
chord(VK_RIGHT);
|
|
autoSelected = false;
|
|
}
|
|
return;
|
|
}
|
|
to = suggestion->target;
|
|
result = suggestion->text;
|
|
automatic = true;
|
|
}
|
|
else if (command == Undo)
|
|
{
|
|
if (previous)
|
|
expected = previous->result;
|
|
reason = L"undo-unavailable";
|
|
if (!previous || previous->window != target || previous->version != version ||
|
|
GetTickCount64() - previous->at > 120000)
|
|
return;
|
|
text = tx.copyRange(caretSteps(previous->result), previous->result,
|
|
[&](const std::wstring &candidate)
|
|
{ return newlines(candidate) == newlines(previous->result); });
|
|
if (newlines(text) != newlines(previous->result))
|
|
{
|
|
reason = L"undo-verification-mismatch";
|
|
actual = text;
|
|
verification = L"selection-mismatch";
|
|
if (tx.valid())
|
|
chord(VK_RIGHT);
|
|
return;
|
|
}
|
|
result = previous->original;
|
|
if (previous->autoCorrected)
|
|
{
|
|
to = previous->sourceLayout;
|
|
}
|
|
automatic = true;
|
|
}
|
|
else if (snippet >= 0)
|
|
{
|
|
if (snippet >= (int)config.snippets.size() || recent.window != target)
|
|
return;
|
|
const auto &sn = config.snippets[snippet];
|
|
if (!snippetAppPriority(sn, processName(target))) return;
|
|
if (recent.keys.size() < sn.trigger.size())
|
|
return;
|
|
result = parseTemplate(sn.text).text;
|
|
// A multiline clipboard paste can execute a console command
|
|
// before readback. Only explicit, verified {enter} may do so.
|
|
if (farSnippet && (result.empty() || result.find_first_of(L"\r\n") != result.npos ||
|
|
caretSteps(result) > 4096))
|
|
{
|
|
reason = L"far-snippet-template-unsupported";
|
|
return;
|
|
}
|
|
Run tail = recent;
|
|
tail.keys = tail.keys.substr(tail.keys.size() - sn.trigger.size());
|
|
autoSelected = true;
|
|
reason = L"snippet-verification-mismatch";
|
|
if (farSnippet)
|
|
{
|
|
if (!tx.select(sn.trigger.size())) return;
|
|
text = tx.copy();
|
|
}
|
|
else
|
|
text = tx.copyRange(sn.trigger.size(), tail.keys,
|
|
[&](const std::wstring &candidate) { return tail.match(candidate, available, physicalLayout()) >= 0; },
|
|
[&](const std::wstring &candidate) { return tail.matchSuffix(candidate, available, physicalLayout()) >= 0; });
|
|
if (tail.match(text, available, physicalLayout()) < 0)
|
|
return;
|
|
automatic = true;
|
|
}
|
|
else if (config.recent && recent.window == target && !recent.keys.empty() && !recent.overflow)
|
|
{
|
|
text =
|
|
tx.copyRange(recent.keys.size(), recent.keys, [&](const std::wstring &candidate)
|
|
{ return recent.match(candidate, available, physicalLayout()) >= 0; },
|
|
[&](const std::wstring &candidate)
|
|
{ return recent.matchSuffix(candidate, available, physicalLayout()) >= 0; });
|
|
hint = recent.match(text, available, physicalLayout());
|
|
diagnosticEvent(L"Recent verification copied=" + std::to_wstring(text.size()) + L" keys=" +
|
|
std::to_wstring(recent.keys.size()) + L" match=" + std::to_wstring(hint));
|
|
if (hint < 0)
|
|
{
|
|
actual = text;
|
|
verification = L"selection-mismatch";
|
|
reason = text.empty() ? L"recent-copy-empty" : L"recent-verification-mismatch";
|
|
if (tx.valid())
|
|
chord(VK_RIGHT);
|
|
return;
|
|
}
|
|
automatic = true;
|
|
}
|
|
else if (config.recent && previous && previous->window == target &&
|
|
previous->version == version)
|
|
{
|
|
expected = previous->result;
|
|
diagnosticEvent(L"Previous result expected=" + diagnosticText(expected));
|
|
text = tx.copyRange(caretSteps(previous->result), previous->result,
|
|
[&](const std::wstring &candidate)
|
|
{ return newlines(candidate) == newlines(previous->result); });
|
|
if (newlines(text) != newlines(previous->result))
|
|
{
|
|
actual = text;
|
|
verification = L"selection-mismatch";
|
|
reason = L"previous-result-verification-mismatch";
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
last.reset();
|
|
run.reset();
|
|
}
|
|
if (tx.valid())
|
|
chord(VK_RIGHT);
|
|
return;
|
|
}
|
|
hint = previous->layout;
|
|
automatic = true;
|
|
}
|
|
else
|
|
text = tx.copy();
|
|
reason = L"context-changed-after-copy";
|
|
if (!tx.valid())
|
|
return;
|
|
if (text.empty())
|
|
{
|
|
reason = L"copy-empty";
|
|
if (to >= 0 && config.switchLayout)
|
|
switchWindowLayout(target, available[to].handle, valid);
|
|
return;
|
|
}
|
|
if (command != Undo && command != AutoCorrect && snippet < 0)
|
|
{
|
|
if (command == Case)
|
|
result = cycleCase(text);
|
|
else if (command == Translit)
|
|
result = transliterate(text);
|
|
else
|
|
{
|
|
if (command == Toggle)
|
|
{
|
|
std::vector<int> cycle;
|
|
for (auto &id : config.cycle)
|
|
for (int i = 0; i < (int)available.size(); ++i)
|
|
if (available[i].id == id && available[i].convertible)
|
|
cycle.push_back(i);
|
|
if (cycle.empty())
|
|
{
|
|
reason = L"cycle-has-no-layouts";
|
|
if (automatic && tx.valid())
|
|
chord(VK_RIGHT);
|
|
return;
|
|
}
|
|
to = nextConversionLayout(text, available, cycle, hint);
|
|
}
|
|
result = convertTo(text, available, to, hint);
|
|
}
|
|
}
|
|
bool sent = false;
|
|
const bool requireReadback = tx.recoveredSelection() || snippet >= 0;
|
|
PasteProbe probe(!farSnippet && ((config.writeLog && manual) || requireReadback) && result != text, text, target);
|
|
if (requireReadback && !farSnippet && result != text && probe.status != L"ready")
|
|
{
|
|
verification = probe.status;
|
|
reason = snippet >= 0 ? L"snippet-verification-unavailable" : L"recovered-selection-unavailable";
|
|
std::lock_guard lock(stateMutex);
|
|
last.reset();
|
|
run.reset();
|
|
return;
|
|
}
|
|
diagnosticEvent(L"Conversion source=" + std::to_wstring(hint) + L" target=" + std::to_wstring(to) +
|
|
L" changed=" + std::to_wstring(result != text));
|
|
if (result != text)
|
|
sent = tx.paste(textClip(result));
|
|
else if (automatic && tx.valid())
|
|
tx.finishSelection(false);
|
|
if (requireReadback && result != text && !sent)
|
|
{
|
|
reason = snippet >= 0 ? L"snippet-paste-cancelled" : L"recovered-selection-paste-cancelled";
|
|
std::lock_guard lock(stateMutex);
|
|
last.reset();
|
|
run.reset();
|
|
return;
|
|
}
|
|
if (sent || result == text)
|
|
autoSelected = false;
|
|
reason = result == text ? L"conversion-unchanged" :
|
|
sent ? L"paste-sent-unverified" : L"paste-cancelled";
|
|
if (manual && result == text)
|
|
{
|
|
reason = L"Conversion unchanged";
|
|
verification = L"calculated-result-equals-original";
|
|
}
|
|
if (sent && ((manual && config.writeLog) || requireReadback))
|
|
{
|
|
verification = probe.status;
|
|
if (tx.valid())
|
|
{
|
|
auto observed = farSnippet ? tx.readFarSnippet(caretSteps(result)) :
|
|
probe.read((int)caretSteps(result));
|
|
// A native Edit may silently ignore Ctrl+V while the clipboard is busy.
|
|
// Retry once only with fresh native proof that the exact original range
|
|
// is still selected. Never retry an unknown or changed editor state.
|
|
if (!farSnippet && observed && newlines(*observed) == newlines(text) && tx.nativeSelectionIs(text))
|
|
{
|
|
diagnosticEvent(L"Paste retry: native Edit still selects the unchanged original");
|
|
if (tx.paste(textClip(result)) && tx.valid())
|
|
observed = probe.read((int)caretSteps(result));
|
|
else
|
|
observed.reset();
|
|
}
|
|
verification = farSnippet ? (observed ? L"read-back-via-far-clipboard" :
|
|
L"far-readback-unavailable") : probe.status;
|
|
if (observed && tx.valid())
|
|
{
|
|
actual = *observed;
|
|
reason = conversionReadbackOutcome(newlines(actual), newlines(text), newlines(result));
|
|
if (newlines(actual) != newlines(result))
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
last.reset();
|
|
run.reset();
|
|
diagnosticEvent(L"Paste rejected by readback: previous result cleared; layout not switched");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
reason = L"Paste not verified";
|
|
if (requireReadback)
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
last.reset();
|
|
run.reset();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else verification = L"context-changed-after-paste";
|
|
}
|
|
if (sent && !tx.valid())
|
|
reason = L"context-changed-after-paste";
|
|
if (sent && command == Undo && previous && previous->autoCorrected)
|
|
autoCorrector.reject(previous->original, config);
|
|
if (tx.valid() && (sent || automatic))
|
|
{
|
|
std::lock_guard lock(stateMutex);
|
|
run.reset();
|
|
if (command == Undo || snippet >= 0)
|
|
last.reset();
|
|
else
|
|
last = LastTransform{target, text, result, to >= 0 ? to : hint,
|
|
GetTickCount64(), version, hint, command == AutoCorrect};
|
|
}
|
|
if (snippet >= 0 && sent && tx.valid())
|
|
{
|
|
tx.check();
|
|
auto t = parseTemplate(config.snippets[snippet].text);
|
|
if (!t.suffix.empty())
|
|
{
|
|
if (!tx.select(caretSteps(t.suffix))) return;
|
|
auto suffix = tx.copy();
|
|
if (!tx.valid()) return;
|
|
if (newlines(suffix) != newlines(t.suffix))
|
|
{
|
|
tx.finishSelection(false);
|
|
return;
|
|
}
|
|
if (!tx.finishSelection(true)) return;
|
|
}
|
|
// Action markers run after insertion and cursor placement,
|
|
// before any physical typing buffered during expansion.
|
|
for (int i = 0; i < t.enters && tx.valid(); ++i)
|
|
{
|
|
tx.check();
|
|
if (!chord(VK_RETURN)) break;
|
|
}
|
|
}
|
|
if (to >= 0 && config.switchLayout && tx.valid() && (sent || result == text))
|
|
{
|
|
bool switched = switchWindowLayout(target, available[to].handle, valid);
|
|
diagnosticEvent(L"Layout switch confirmed=" + std::to_wstring(switched));
|
|
if (!switched)
|
|
reason += L";layout-switch-failed";
|
|
}
|
|
diagnosticEvent(L"Text operation completed in " + std::to_wstring(GetTickCount64() - start) + L" ms");
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
reason = L"exception:" + wide(e.what());
|
|
report(wide(e.what()));
|
|
}
|
|
});
|
|
}
|
|
void App::pasteEntry(std::wstring id, bool plain)
|
|
{
|
|
if (historyService) { remoteHistory("paste", id, plain); return; }
|
|
if (installingUpdate) return;
|
|
if (!history || busy.exchange(true))
|
|
return;
|
|
HWND target = pasteTarget;
|
|
if (historyWindow)
|
|
SendMessageW(historyWindow, WM_CLOSE, 0, 0);
|
|
activateWindow(target);
|
|
auto version = inputVersion.load();
|
|
enqueue(
|
|
[this, id, plain, target, version]
|
|
{
|
|
struct Reset
|
|
{
|
|
std::atomic<bool> &b;
|
|
~Reset()
|
|
{
|
|
b = false;
|
|
}
|
|
} reset{busy};
|
|
try
|
|
{
|
|
// Foreground activation crosses a process boundary when the
|
|
// history UI closes. Let the destination finish activation,
|
|
// while retaining the same input-version cancellation guard.
|
|
for (int i = 0; i < 20 && inputVersion == version &&
|
|
(!modifiersReleased() || GetForegroundWindow() != target); ++i)
|
|
Sleep(10);
|
|
if (!modifiersReleased() || GetForegroundWindow() != target || inputVersion != version)
|
|
{
|
|
log(L"History paste cancelled before transaction: foreground=" +
|
|
std::to_wstring(GetForegroundWindow() == target) + L" modifiers=" +
|
|
std::to_wstring(modifiersReleased()) + L" expectedVersion=" + std::to_wstring(version) +
|
|
L" actualVersion=" + std::to_wstring(inputVersion.load()));
|
|
return;
|
|
}
|
|
auto clip = history->load(id);
|
|
if (plain)
|
|
{
|
|
auto text = clip.text();
|
|
if (text.empty())
|
|
return;
|
|
clip = textClip(text);
|
|
}
|
|
Transaction tx(*this, target, version);
|
|
log(tx.paste(clip) ? L"History paste: simulated paste completed" : L"History paste cancelled before simulated paste");
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
report(wide(e.what()));
|
|
}
|
|
});
|
|
}
|
|
namespace {
|
|
Clip sharedClipboard(Clip clip)
|
|
{
|
|
// File handles/paths and application-private formats are local to their PC.
|
|
std::erase_if(clip.formats,[](const Format &f){return !(
|
|
(f.name.empty()&&(f.id==CF_UNICODETEXT||f.id==CF_TEXT||f.id==CF_LOCALE||f.id==CF_DIB||f.id==CF_DIBV5))||
|
|
f.name==L"PNG"||f.name==L"HTML Format"||f.name==L"Rich Text Format");});
|
|
return clip;
|
|
}
|
|
}
|
|
void App::publishClipboard(Clip clip,const std::wstring &app)
|
|
{
|
|
clip=sharedClipboard(std::move(clip));if(clip.formats.empty())return;
|
|
auto originalSize=clip.size();
|
|
clip=lan::compactClipboardImage(std::move(clip));
|
|
auto packet=new LanClipboard{{},{},utf8(app),encodeClip(clip)};
|
|
log(L"LAN clipboard queued: original="+std::to_wstring(originalSize)+L" bytes, wire="+std::to_wstring(packet->data.size())+L" bytes");
|
|
if(!PostMessageW(window,LanClipboardPublishMessage,0,reinterpret_cast<LPARAM>(packet)))delete packet;
|
|
}
|
|
void App::receiveClipboard()
|
|
{
|
|
if(!lanService)return;
|
|
auto packets=lanService->takeClipboard();auto config=settings;
|
|
for(auto &packet:packets)enqueue([this,packet=std::move(packet),config]{
|
|
try {
|
|
auto clip=sharedClipboard(decodeClip(packet.data));if(clip.formats.empty())return;
|
|
auto sequence=GetClipboardSequenceNumber();
|
|
if(!suspended&&(sequence==packet.sequence||sequence==lanSequence.load())){
|
|
const std::wstring marker=L"KSwitcher.LAN.Clipboard";
|
|
auto active=lan::clipboardImageForPaste(clip);
|
|
active.formats.push_back({RegisterClipboardFormatW(marker.c_str()),marker,Bytes{1}});
|
|
ownSequence=lanSequence=writeClipboardGuarded(window,active,sequence);
|
|
log(L"LAN clipboard activated: "+std::to_wstring(packet.data.size())+L" bytes");
|
|
}
|
|
if(config.history&&history){history->add(clip,wide(packet.app),config,packet.peer,wide(packet.name));
|
|
scheduleHistoryOcr(config);PostMessageW(window,HistoryMessage,0,0);}
|
|
}catch(const std::exception &e){log(L"LAN clipboard receive: "+wide(e.what()));}
|
|
});
|
|
}
|
|
void App::captureHistory()
|
|
{
|
|
DWORD sequence = GetClipboardSequenceNumber();
|
|
if (suspended || sequence == ownSequence || !history ||
|
|
GetTickCount64() < pauseUntil)
|
|
return;
|
|
const bool share=lanService&&lanService->clipboardEnabled();
|
|
if(!settings.history&&!share)return;
|
|
Settings config = settings;
|
|
enqueue(
|
|
[this, sequence, config, share]
|
|
{
|
|
try
|
|
{
|
|
if (suspended || sequence != GetClipboardSequenceNumber() || sequence == ownSequence)
|
|
return;
|
|
UINT exclude = RegisterClipboardFormatW(L"ExcludeClipboardContentFromMonitorProcessing"),
|
|
ignore = RegisterClipboardFormatW(L"Clipboard Viewer Ignore");
|
|
if (IsClipboardFormatAvailable(exclude) || IsClipboardFormatAvailable(ignore) ||
|
|
IsClipboardFormatAvailable(RegisterClipboardFormatW(L"KSwitcher.LAN.Clipboard")))
|
|
return;
|
|
auto owner = GetClipboardOwner();
|
|
auto app = processName(owner ? owner : GetForegroundWindow());
|
|
for (auto &name : config.excluded)
|
|
if (lower(name) == lower(app))
|
|
return;
|
|
if(!config.history){
|
|
auto clip=readClipboard(window,(size_t)config.maxImageMiB*1024*1024,ClipboardRead::All,sequence);
|
|
for(const auto &f:clip.formats)if(f.name==L"CanIncludeInClipboardHistory"&&f.data.size()>=4&&!f.data[0]&&!f.data[1]&&!f.data[2]&&!f.data[3])return;
|
|
if(sequence==GetClipboardSequenceNumber())publishClipboard(std::move(clip),app);
|
|
return;
|
|
}
|
|
if (IsClipboardFormatAvailable(CF_DIB) || IsClipboardFormatAvailable(CF_DIBV5) ||
|
|
IsClipboardFormatAvailable(CF_BITMAP) ||
|
|
IsClipboardFormatAvailable(RegisterClipboardFormatW(L"PNG")))
|
|
{
|
|
if (history->captureImage(sequence, app, config))
|
|
{
|
|
auto entries=history->entries();
|
|
if(share&&!entries.empty())publishClipboard(history->load(entries.front().id),app);
|
|
scheduleHistoryOcr(config);
|
|
PostMessageW(window, HistoryMessage, 0, 0);
|
|
}
|
|
return;
|
|
}
|
|
auto clip = readClipboard(window, (size_t)config.maxImageMiB * 1024 * 1024,
|
|
ClipboardRead::WithoutImages, sequence);
|
|
if (sequence != GetClipboardSequenceNumber())
|
|
return;
|
|
for (auto &f : clip.formats)
|
|
if (f.name == L"CanIncludeInClipboardHistory" && f.data.size() >= 4 && !f.data[0] &&
|
|
!f.data[1] && !f.data[2] && !f.data[3])
|
|
return;
|
|
history->add(clip, app, config);
|
|
if(share)publishClipboard(clip,app);
|
|
scheduleHistoryOcr(config);
|
|
PostMessageW(window, HistoryMessage, 0, 0);
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
log(L"History capture: " + wide(e.what()));
|
|
}
|
|
});
|
|
}
|
|
void App::recognizeEntry(std::wstring id)
|
|
{
|
|
if (historyService) { remoteHistory("ocr", id); return; }
|
|
if (!history || busy.exchange(true))
|
|
return;
|
|
auto sequence = GetClipboardSequenceNumber();
|
|
Settings config = settings;
|
|
enqueue(
|
|
[this, id, sequence, config]
|
|
{
|
|
struct Reset
|
|
{
|
|
std::atomic<bool> &b;
|
|
~Reset()
|
|
{
|
|
b = false;
|
|
}
|
|
} reset{busy};
|
|
try
|
|
{
|
|
auto cached = history->ocrText(id, ocrProfile(config));
|
|
auto text = cached ? *cached : history->recognizeImage(id, config, [this] {
|
|
std::lock_guard lock(jobsMutex); return stop;
|
|
});
|
|
if (!cached) history->saveOcr(id, text, config);
|
|
if (text.empty())
|
|
{
|
|
report(L"No text was found in the image.");
|
|
return;
|
|
}
|
|
auto clip = textClip(text);
|
|
if (config.history)
|
|
history->add(clip, L"Windows OCR", config);
|
|
if (GetClipboardSequenceNumber() == sequence)
|
|
ownSequence = writeClipboard(window, clip);
|
|
else
|
|
report(L"The clipboard changed during OCR. Recognized text is available in history.");
|
|
PostMessageW(window, HistoryMessage, 0, 0);
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
report(wide(e.what()));
|
|
}
|
|
});
|
|
}
|
|
void App::trayMenu()
|
|
{
|
|
constexpr int utilityCommandBase = 1000;
|
|
std::error_code utilitiesError;
|
|
auto utilities = discoverUtilities(std::filesystem::path(executable()).parent_path() / L"tools", utilitiesError);
|
|
if (utilities.size() > 50000) utilities.resize(50000);
|
|
HMENU menu = CreatePopupMenu();
|
|
AppendMenuW(menu, MF_STRING, 10, L"Clipboard &history");
|
|
AppendMenuW(menu, MF_STRING, 24, L"&Capture screen region…");
|
|
AppendMenuW(menu, MF_STRING, 11, L"&Settings…");
|
|
SetMenuDefaultItem(menu, 11, FALSE);
|
|
AppendMenuW(menu, MF_STRING, 12, L"S&nippets…");
|
|
AppendMenuW(menu, MF_STRING, 13, L"&Keyboard shortcuts…");
|
|
HMENU utilityMenu = CreatePopupMenu();
|
|
for (size_t i = 0; i < utilities.size(); ++i)
|
|
AppendMenuW(utilityMenu, MF_STRING, utilityCommandBase + i, utilityMenuLabel(utilities[i]).c_str());
|
|
if (utilities.empty())
|
|
AppendMenuW(utilityMenu, MF_STRING | MF_GRAYED, 0,
|
|
utilitiesError ? L"Cannot read tools folder" : L"No utilities in tools folder");
|
|
AppendMenuW(menu, MF_POPUP, (UINT_PTR)utilityMenu, L"&Tools");
|
|
AppendMenuW(menu, MF_SEPARATOR, 0, nullptr);
|
|
AppendMenuW(menu, MF_STRING | (settings.awake ? MF_CHECKED : 0), 14, L"Keep screen a&wake");
|
|
HMENU pause = CreatePopupMenu();
|
|
AppendMenuW(pause, MF_STRING, 20, L"&Resume");
|
|
AppendMenuW(pause, MF_STRING, 21, L"&10 minutes");
|
|
AppendMenuW(pause, MF_STRING, 22, L"1 &hour");
|
|
AppendMenuW(pause, MF_STRING, 23, L"&Until restart");
|
|
AppendMenuW(menu, MF_POPUP, (UINT_PTR)pause, L"&Pause clipboard history");
|
|
AppendMenuW(menu, MF_STRING, 15, L"&Open data folder");
|
|
AppendMenuW(menu, MF_STRING, 18, L"View &log…");
|
|
AppendMenuW(menu, MF_STRING | (updateRunning ? MF_GRAYED : 0), 19,
|
|
updateRunning ? L"&Update (checking / preparing…)" :
|
|
availableUpdate.empty() ? L"&Update" : L"&Update (new version available)");
|
|
AppendMenuW(menu, MF_SEPARATOR, 0, nullptr);
|
|
AppendMenuW(menu, MF_STRING, 16, L"&About KSwitcher");
|
|
AppendMenuW(menu, MF_STRING, 17, L"E&xit");
|
|
POINT pt;
|
|
GetCursorPos(&pt);
|
|
pasteTarget = GetForegroundWindow();
|
|
SetForegroundWindow(window);
|
|
showMenuAccessKeys(menu);
|
|
int cmd = TrackPopupMenu(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON, pt.x, pt.y, 0, window, nullptr);
|
|
DestroyMenu(menu);
|
|
PostMessageW(window, WM_NULL, 0, 0);
|
|
try
|
|
{
|
|
if (cmd >= utilityCommandBase && size_t(cmd - utilityCommandBase) < utilities.size())
|
|
{
|
|
const auto &path = utilities[cmd - utilityCommandBase];
|
|
auto command = L"\"" + path.wstring() + L"\"";
|
|
STARTUPINFOW startup{sizeof(startup)};
|
|
PROCESS_INFORMATION process{};
|
|
if (!CreateProcessW(path.c_str(), command.data(), nullptr, nullptr, FALSE, 0, nullptr,
|
|
path.parent_path().c_str(), &startup, &process))
|
|
throw std::runtime_error(utf8(lastError(L"Cannot start utility " + path.filename().wstring())));
|
|
AllowSetForegroundWindow(process.dwProcessId);
|
|
CloseHandle(process.hThread);
|
|
CloseHandle(process.hProcess);
|
|
return;
|
|
}
|
|
switch (cmd)
|
|
{
|
|
case 24:
|
|
dispatch(Screenshot);
|
|
break;
|
|
case 10:
|
|
showHistory(*this);
|
|
break;
|
|
case 11:
|
|
showSettings(*this);
|
|
break;
|
|
case 12:
|
|
showSnippets(*this);
|
|
break;
|
|
case 13:
|
|
showShortcuts(*this);
|
|
break;
|
|
case 14:
|
|
{
|
|
auto s = settings;
|
|
s.awake = !s.awake;
|
|
applySettings(s);
|
|
break;
|
|
}
|
|
case 15:
|
|
ShellExecuteW(window, L"open", data.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
|
|
break;
|
|
case 16:
|
|
MessageBoxW(window,
|
|
(std::wstring(L"KSwitcher ") + AppVersion + L"\nNative C++ / Win32 keyboard and clipboard utility\n\nBased on "
|
|
L"Typlo by bitcodepro. MIT license.\nHistory is encrypted for your Windows "
|
|
L"account.\nNo .NET, WebView or graphics framework.").c_str(),
|
|
L"About KSwitcher", MB_OK);
|
|
break;
|
|
case 17:
|
|
PostMessageW(window, WM_CLOSE, 0, 0);
|
|
break;
|
|
case 18:
|
|
showLogs(*this);
|
|
break;
|
|
case 19:
|
|
checkUpdate(true);
|
|
break;
|
|
case 20:
|
|
pauseUntil = 0;
|
|
break;
|
|
case 21:
|
|
pauseUntil = GetTickCount64() + 600000;
|
|
break;
|
|
case 22:
|
|
pauseUntil = GetTickCount64() + 3600000;
|
|
break;
|
|
case 23:
|
|
pauseUntil = ~ULONGLONG{};
|
|
break;
|
|
}
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
report(wide(e.what()));
|
|
}
|
|
}
|
|
void App::checkUpdate(bool interactive, bool install, const std::wstring &version)
|
|
{
|
|
if (updateRunning) return;
|
|
if (install && FindWindowW(L"KSwitcher.Config", nullptr))
|
|
{
|
|
report(L"Close the configurator before installing an update.");
|
|
return;
|
|
}
|
|
if (install && busy)
|
|
{
|
|
report(L"Wait for the current text operation to finish, then select Update again.");
|
|
return;
|
|
}
|
|
if (updateWorker.joinable()) updateWorker.join();
|
|
updateRunning = true;
|
|
installingUpdate = install;
|
|
updateWorker = std::thread([this, interactive, install, version]
|
|
{
|
|
auto result = std::make_unique<UpdateResult>();
|
|
try { *result = runUpdate(install, version, interactive); }
|
|
catch (const std::exception &e) { result->state = L"error"; result->error = wide(e.what()); }
|
|
result->interactive = interactive;
|
|
result->install = install;
|
|
if (PostMessageW(window, UpdateMessage, 0, reinterpret_cast<LPARAM>(result.get()))) result.release();
|
|
});
|
|
}
|
|
LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
|
|
{
|
|
auto *app = current;
|
|
if (!app)
|
|
return DefWindowProcW(hwnd, msg, wp, lp);
|
|
if (app->historyService) {
|
|
if (msg == HistoryHostShow || msg == HistoryHostRefresh) {
|
|
try {
|
|
app->history->reload();
|
|
if (msg == HistoryHostShow) showHistory(*app);
|
|
else if (IsWindowVisible(app->historyWindow)) refreshHistory(*app);
|
|
} catch (const std::exception &e) { app->report(wide(e.what())); }
|
|
return 0;
|
|
}
|
|
if (msg == WM_TIMER) {
|
|
if (!IsWindow(app->historyService)) PostMessageW(hwnd, WM_CLOSE, 0, 0);
|
|
return 0;
|
|
}
|
|
if (msg == WM_CLOSE) {
|
|
EnumThreadWindows(GetCurrentThreadId(), [](HWND child, LPARAM) -> BOOL {
|
|
wchar_t name[64]{}; GetClassNameW(child, name, 64);
|
|
if (std::wstring(name) == L"KSwitcher.Entry" || std::wstring(name) == L"KSwitcher.History")
|
|
DestroyWindow(child);
|
|
return TRUE;
|
|
}, 0);
|
|
DestroyWindow(hwnd);
|
|
return 0;
|
|
}
|
|
if (msg == WM_DESTROY) { PostQuitMessage(0); return 0; }
|
|
if (msg == ErrorMessage) {
|
|
std::unique_ptr<std::wstring> text(reinterpret_cast<std::wstring *>(lp));
|
|
MessageBoxW(app->historyWindow, text->c_str(), L"Clipboard history", MB_OK | MB_ICONWARNING);
|
|
return 0;
|
|
}
|
|
}
|
|
if (!app->historyService && msg == app->taskbarCreated && app->taskbarCreated)
|
|
{
|
|
app->addTray();
|
|
return 0;
|
|
}
|
|
switch (msg)
|
|
{
|
|
case UpdateMessage:
|
|
{
|
|
std::unique_ptr<UpdateResult> result(reinterpret_cast<UpdateResult *>(lp));
|
|
if (app->updateWorker.joinable()) app->updateWorker.join();
|
|
app->updateRunning = false;
|
|
app->installingUpdate = false;
|
|
log(L"Update check: " + result->state + (result->version.empty() ? L"" : L" " + result->version) +
|
|
(result->error.empty() ? L"" : L"; " + result->error));
|
|
if (result->state == L"prepared")
|
|
{
|
|
// The helper has verified and staged the package; it waits for process exit.
|
|
DestroyWindow(hwnd);
|
|
}
|
|
else if (result->state == L"available")
|
|
{
|
|
app->availableUpdate = result->version;
|
|
if (result->interactive)
|
|
{
|
|
auto prompt = L"Install KSwitcher " + result->version +
|
|
L"?\n\nThe program will close and restart. Settings, history and existing dictionaries are preserved.";
|
|
if (MessageBoxW(hwnd, prompt.c_str(), L"KSwitcher Update", MB_YESNO | MB_ICONQUESTION) == IDYES)
|
|
app->checkUpdate(true, true, result->version);
|
|
}
|
|
else if (app->notifiedUpdate != result->version)
|
|
{
|
|
if (app->updateNotifier(result->version))
|
|
{
|
|
app->notifiedUpdate = result->version;
|
|
log(L"Update notification submitted to Windows: " + result->version);
|
|
}
|
|
else
|
|
{
|
|
log(L"Update notification failed; retrying in 5 minutes: " + result->version);
|
|
SetTimer(hwnd, 5, UpdateNotificationRetryMs, nullptr);
|
|
}
|
|
}
|
|
}
|
|
else if (result->state == L"current")
|
|
{
|
|
app->availableUpdate.clear();
|
|
if (result->interactive)
|
|
MessageBoxW(hwnd, (std::wstring(L"No newer stable release is available.\nInstalled version: ") + AppVersion).c_str(),
|
|
L"KSwitcher Update", MB_OK | MB_ICONINFORMATION);
|
|
}
|
|
else if (result->interactive)
|
|
MessageBoxW(hwnd, (L"Update failed.\n\n" + result->error).c_str(), L"KSwitcher Update", MB_OK | MB_ICONERROR);
|
|
else
|
|
diagnosticEvent(L"Background update check failed: " + result->error);
|
|
return 0;
|
|
}
|
|
case WM_HOTKEY:
|
|
app->dispatch((int)wp);
|
|
return 0;
|
|
case MouseActionMessage:
|
|
app->dispatchMouseActions();
|
|
return 0;
|
|
case MouseVolumeReleasedMessage:
|
|
if (const auto indicator = reinterpret_cast<HWND>(GetPropW(hwnd, VolumeIndicatorClass)))
|
|
setVolumeIndicatorHold(indicator, app->volumeButtonHeld());
|
|
return 0;
|
|
case WM_POWERBROADCAST:
|
|
if (wp == PBT_APMSUSPEND && app->lanService)
|
|
{
|
|
app->lanService->cancelInput();
|
|
app->resetInput();
|
|
}
|
|
return TRUE;
|
|
case ReplayTypingMessage:
|
|
app->replayTyping();
|
|
return 0;
|
|
case TrayMessage:
|
|
if (LOWORD(lp) == NIN_BALLOONUSERCLICK)
|
|
showLogs(*app);
|
|
else if (LOWORD(lp) == WM_CONTEXTMENU)
|
|
app->trayMenu();
|
|
else if (LOWORD(lp) == WM_LBUTTONDBLCLK)
|
|
// The shell still owns the mouse gesture on the second button-down.
|
|
// Activate after release, so the tray cannot take focus back on button-up.
|
|
SetTimer(hwnd, 4, 50, nullptr);
|
|
else if (LOWORD(lp) == NIN_KEYSELECT)
|
|
app->dispatch(20); // Settings is the tray's default action.
|
|
return 0;
|
|
case WM_CLIPBOARDUPDATE:
|
|
app->captureHistory();
|
|
return 0;
|
|
case AutoCorrectMessage:
|
|
if (app->autoPending)
|
|
{
|
|
if (!app->installingUpdate && !app->snippetTyping && app->settings.autoCorrect && app->inputVersion.load() == (uint64_t)wp)
|
|
app->transform(AutoCorrect);
|
|
else
|
|
app->replayTyping();
|
|
}
|
|
return 0;
|
|
case SnippetMessage:
|
|
if (app->snippetPending == (int)wp)
|
|
{
|
|
if (!app->installingUpdate && app->inputVersion.load() == (uint64_t)lp)
|
|
app->transform(0, (int)wp);
|
|
else
|
|
app->replayTyping();
|
|
}
|
|
return 0;
|
|
case HistoryMessage:
|
|
if (app->historyWindow && IsWindowVisible(app->historyWindow))
|
|
refreshHistory(*app);
|
|
return 0;
|
|
case ErrorMessage:
|
|
{
|
|
std::unique_ptr<std::wstring> text((std::wstring *)lp);
|
|
NOTIFYICONDATAW icon{sizeof(icon)};
|
|
icon.hWnd = hwnd;
|
|
icon.uID = 1;
|
|
icon.uFlags = NIF_INFO;
|
|
wcsncpy_s(icon.szInfo, text->c_str(), _TRUNCATE);
|
|
wcscpy_s(icon.szInfoTitle, L"KSwitcher");
|
|
icon.dwInfoFlags = NIIF_WARNING;
|
|
Shell_NotifyIconW(NIM_MODIFY, &icon);
|
|
return 0;
|
|
}
|
|
case WM_COPYDATA:
|
|
{
|
|
auto *data = (COPYDATASTRUCT *)lp;
|
|
if (data && data->dwData == HistoryRequest) return app->historyRequest((HWND)wp, *data);
|
|
if (data && data->dwData >= ConfigRead && data->dwData < ConfigEnd)
|
|
{
|
|
if (app->installingUpdate) return FALSE;
|
|
return configurationRequest(*app, (HWND)wp, *data);
|
|
}
|
|
if (data && data->dwData == 1 && data->cbData == sizeof(int))
|
|
{
|
|
int cmd;
|
|
memcpy(&cmd, data->lpData, sizeof(cmd));
|
|
app->dispatch(cmd);
|
|
}
|
|
return TRUE;
|
|
}
|
|
case LanClipboardPublishMessage:
|
|
{
|
|
std::unique_ptr<LanClipboard> packet(reinterpret_cast<LanClipboard*>(lp));
|
|
try{if(app->lanService)app->lanService->publishClipboard(std::move(packet->data),packet->app);}
|
|
catch(const std::exception &e){log(L"LAN clipboard send: "+wide(e.what()));}
|
|
return 0;
|
|
}
|
|
case LanClipboardReadyMessage: app->receiveClipboard();return 0;
|
|
case LanInputReadyMessage:
|
|
if(app->lanService&&app->lanService->tickInput(!app->busy&&!app->suspended&&!app->hotkeyCapture))app->resetLanInput();
|
|
return 0;
|
|
case WM_TIMER:
|
|
if (wp == MouseClickTimer) { app->flushMouseClicks(); return 0; }
|
|
if (wp >= FirstMouseVolumeTimer && wp < FirstMouseVolumeTimer + std::size(MouseButtonNames))
|
|
{
|
|
app->repeatMouseVolume(static_cast<int>(wp - FirstMouseVolumeTimer));
|
|
return 0;
|
|
}
|
|
if (wp == 8)
|
|
{
|
|
if (app->settings.appLanguageSets.empty() || app->busy || app->installingUpdate) return 0;
|
|
app->refreshChatContext();
|
|
if (!app->activeChat.starts_with(L"app\n")) return 0;
|
|
auto cycle = chatCycle(app->settings, app->activeChat, app->layouts);
|
|
auto current = windowLayout(app->chatWindow);
|
|
bool allowed = std::any_of(app->layouts.begin(), app->layouts.end(), [&](const Layout &layout) {
|
|
return layout.handle == current && std::find(cycle.begin(), cycle.end(), layout.id) != cycle.end();
|
|
});
|
|
if (!allowed) app->switchChatLayout(false);
|
|
return 0;
|
|
}
|
|
|
|
if (wp == 7)
|
|
{
|
|
if (app->lanService)
|
|
{
|
|
// suspended also guards clipboard/text transactions (correction,
|
|
// conversion, snippets). Those must not disconnect remote input.
|
|
// Actual system suspension is handled by WM_POWERBROADCAST.
|
|
if (app->lanService->tickInput(!app->busy && !app->suspended && !app->hotkeyCapture)) app->resetLanInput();
|
|
}
|
|
return 0;
|
|
}
|
|
if (wp == 6)
|
|
{
|
|
if (app->notificationRegistration && WaitForSingleObject(app->notificationRegistration, 0) == WAIT_OBJECT_0)
|
|
{
|
|
DWORD code = ERROR_GEN_FAILURE;
|
|
GetExitCodeProcess(app->notificationRegistration, &code);
|
|
if (code) log(L"Screenshot notification registration helper failed: " + std::to_wstring(code));
|
|
CloseHandle(app->notificationRegistration);
|
|
app->notificationRegistration = nullptr;
|
|
}
|
|
app->releaseIdleMemory(GetTickCount64());
|
|
app->pollSync();
|
|
return 0;
|
|
}
|
|
if (wp == 5)
|
|
{
|
|
// After the initial 5-second check, repeat while the resident stays open.
|
|
// Rearm even when a check is already running or the previous one failed.
|
|
SetTimer(hwnd, 5, UpdateCheckIntervalMs, nullptr);
|
|
app->checkUpdate(false);
|
|
return 0;
|
|
}
|
|
if (wp == 4)
|
|
{
|
|
if (GetAsyncKeyState(VK_LBUTTON) & 0x8000)
|
|
return 0;
|
|
KillTimer(hwnd, 4);
|
|
app->dispatch(20);
|
|
return 0;
|
|
}
|
|
if (wp == 2)
|
|
{
|
|
PostMessageW(hwnd, WM_CLOSE, 0, 0);
|
|
return 0;
|
|
}
|
|
if (app->settings.awake)
|
|
{
|
|
LASTINPUTINFO idle{sizeof(idle)};
|
|
if (GetLastInputInfo(&idle) && DWORD(GetTickCount() - idle.dwTime) >= 180000)
|
|
chord(VK_F15);
|
|
}
|
|
return 0;
|
|
case WM_CLOSE:
|
|
if (app->updateRunning)
|
|
{
|
|
app->report(L"Wait for the update check or preparation to finish before exiting.");
|
|
return 0;
|
|
}
|
|
if (app->busy)
|
|
{
|
|
app->report(L"Wait for the current text operation to finish before exiting.");
|
|
return 0;
|
|
}
|
|
DestroyWindow(hwnd);
|
|
return 0;
|
|
case WM_DESTROY:
|
|
if (auto config = FindWindowW(L"KSwitcher.Config", nullptr);
|
|
config && configurationPeer(config, L"KSwitcher.Config.exe"))
|
|
PostMessageW(config, WM_CLOSE, 0, 0);
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
default:
|
|
return DefWindowProcW(hwnd, msg, wp, lp);
|
|
}
|
|
}
|
|
int App::execute()
|
|
{
|
|
INITCOMMONCONTROLSEX controls{sizeof(controls), ICC_STANDARD_CLASSES | ICC_LISTVIEW_CLASSES};
|
|
InitCommonControlsEx(&controls);
|
|
WNDCLASSW cls{};
|
|
cls.hInstance = instance;
|
|
cls.lpfnWndProc = windowProc;
|
|
cls.lpszClassName = historyService ? HistoryHostClass : L"KSwitcher.Main";
|
|
cls.hIcon = LoadIconW(instance, MAKEINTRESOURCEW(IDI_KSWITCHER));
|
|
RegisterClassW(&cls);
|
|
window = CreateWindowExW(WS_EX_TOOLWINDOW, cls.lpszClassName, L"KSwitcher", WS_POPUP, 0, 0, 0, 0, nullptr,
|
|
nullptr, instance, nullptr);
|
|
if (!window)
|
|
throw std::runtime_error("Cannot create message window");
|
|
taskbarCreated = RegisterWindowMessageW(L"TaskbarCreated");
|
|
worker = std::thread(
|
|
[this]
|
|
{
|
|
CoInitializeEx(nullptr, COINIT_MULTITHREADED);
|
|
for (;;)
|
|
{
|
|
std::function<void()> job;
|
|
{
|
|
std::unique_lock lock(jobsMutex);
|
|
jobsReady.wait(lock, [&] { return stop || !jobs.empty(); });
|
|
if (stop)
|
|
break;
|
|
job = std::move(jobs.front());
|
|
jobs.pop_front();
|
|
}
|
|
try
|
|
{
|
|
job();
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
report(wide(e.what()));
|
|
}
|
|
}
|
|
CoUninitialize();
|
|
});
|
|
if (historyService) {
|
|
try {
|
|
auto bytes = unprotect(readFile(data / L"history-view.bin", 4 * 1024 * 1024));
|
|
auto state = HistoryJson::parse(bytes);
|
|
historySelection = wide(state.value("selection", std::string{}));
|
|
historyTop = wide(state.value("top", std::string{}));
|
|
historyQuery = wide(state.value("query", std::string{}));
|
|
historyPinnedOnly = state.value("pinnedOnly", false);
|
|
historyComputers = state.value("computers",std::vector<std::string>{});
|
|
} catch (...) {}
|
|
showHistory(*this);
|
|
remoteHistory("ready", std::to_wstring(reinterpret_cast<uintptr_t>(historyWindow)));
|
|
SetTimer(window, 1, 1000, nullptr);
|
|
MSG message{};
|
|
while (GetMessageW(&message, nullptr, 0, 0) > 0) {
|
|
if (message.message == WM_KEYDOWN && message.wParam == VK_ESCAPE && historyWindow &&
|
|
(message.hwnd == historyWindow || IsChild(historyWindow, message.hwnd))) {
|
|
SendMessageW(historyWindow, WM_CLOSE, 0, 0);
|
|
continue;
|
|
}
|
|
if (historyWindow && message.message == WM_SYSCHAR && IsDialogMessageW(historyWindow, &message)) continue;
|
|
TranslateMessage(&message); DispatchMessageW(&message);
|
|
}
|
|
return int(message.wParam);
|
|
}
|
|
keyboardHook = SetWindowsHookExW(WH_KEYBOARD_LL, keyProc, instance, 0);
|
|
mouseHook = SetWindowsHookExW(WH_MOUSE_LL, mouseProc, instance, 0);
|
|
registerHotkeys(settings);
|
|
if (!keyboardHook || !mouseHook)
|
|
report(L"Input tracking could not start. Automatic recent-text conversion is unavailable.");
|
|
AddClipboardFormatListener(window);
|
|
// Resume pending OCR, including older images without a saved OCR state.
|
|
scheduleHistoryOcr(settings);
|
|
addTray();
|
|
if (!smoke) startBrowserChatMonitor();
|
|
if (!smoke && std::filesystem::exists(data / L"lan-pairing.bin"))
|
|
try { lanService = std::make_unique<LanService>(data,window); }
|
|
catch (const std::exception &e) { report(L"LAN module: " + wide(e.what())); }
|
|
if (lanService && lanService->inputEnabled()) SetTimer(window, 7, 10, nullptr);
|
|
SetTimer(window, 1, 60000, nullptr);
|
|
if (!smoke) SetTimer(window, 6, 1000, nullptr);
|
|
if (!smoke) SetTimer(window, 8, 250, nullptr);
|
|
SetThreadExecutionState(ES_CONTINUOUS |
|
|
(settings.awake ? (ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED) : 0));
|
|
if (!registrationWarning.empty())
|
|
report(registrationWarning);
|
|
if (smoke)
|
|
SetTimer(window, 2, 10000, nullptr);
|
|
else
|
|
SetTimer(window, 5, 5000, nullptr);
|
|
if (keyboardHook && mouseHook && confirmUpdatedStartup(updateStartupEvent))
|
|
log(std::wstring(L"Update completed; running version ") + AppVersion);
|
|
if (startCommand)
|
|
PostMessageW(window, WM_HOTKEY, startCommand, 0);
|
|
try { notificationRegistration = startScreenshotNotificationRegistration(); }
|
|
catch(const std::exception &e) { log(L"Screenshot notification registration: "+wide(e.what())); }
|
|
auto screenshotActivation=startScreenshotActivationListener();
|
|
MSG msg;
|
|
while (GetMessageW(&msg, nullptr, 0, 0) > 0)
|
|
{
|
|
if (settingsWindow && !IsWindowEnabled(settingsWindow))
|
|
{
|
|
HWND popup = GetLastActivePopup(settingsWindow);
|
|
if (popup != settingsWindow && IsDialogMessageW(popup, &msg))
|
|
continue;
|
|
}
|
|
// Preserve history-specific Enter/Shift+Enter and Ctrl+digit handling.
|
|
if (!isolateHistory && historyWindow && msg.message == WM_SYSCHAR && IsDialogMessageW(historyWindow, &msg))
|
|
continue;
|
|
if (settingsWindow && IsDialogMessageW(settingsWindow, &msg))
|
|
continue;
|
|
if (snippetsWindow && IsDialogMessageW(snippetsWindow, &msg))
|
|
continue;
|
|
if (logWindow && IsDialogMessageW(logWindow, &msg))
|
|
continue;
|
|
TranslateMessage(&msg);
|
|
DispatchMessageW(&msg);
|
|
}
|
|
if(screenshotActivation) CoRevokeClassObject(screenshotActivation);
|
|
return (int)msg.wParam;
|
|
}
|
|
} // namespace ks
|