Release v0.6.10: preserve typing during correction and add personal dictionaries

2026-10-29 22:44:08 +02:00
parent 5c786e12a9
commit 8b5f632ad7
20 changed files with 362 additions and 35 deletions
@@ -598,6 +598,27 @@ bool App::handleKeyboard(const KBDLLHOOKSTRUCT &key, bool down, UINT mods)
    // 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))
@@ -640,6 +661,41 @@ bool App::handleKeyboard(const KBDLLHOOKSTRUCT &key, bool down, UINT mods)
        return true;
    return false;
 }
+bool App::beginTypingDeferral(HWND target, uint64_t version)
+{
+    std::lock_guard lock(stateMutex);
+    if (inputVersion != version || GetForegroundWindow() != target || !modifiersReleased())
+        return false;
+    typingTarget = target;
+    return true;
+}
+void App::replayTyping()
+{
+    std::vector<INPUT> inputs;
+    HWND target;
+    {
+        std::lock_guard lock(stateMutex);
+        target = typingTarget;
+        typingTarget = nullptr;
+        inputs.swap(deferredTyping);
+    }
+    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 &&
@@ -762,11 +818,16 @@ void App::transform(int command, int snippet)
            struct BusyReset
            {
                std::atomic<bool> &b;
+                HWND window;
+                bool deferred{};
                ~BusyReset()
                {
-                    b = false;
+                    if (deferred)
+                        PostMessageW(window, ReplayTypingMessage, 0, 0);
+                    else
+                        b = false;
                }
-            } reset{busy};
+            } reset{busy, window};
            auto start = GetTickCount64();
            std::wstring reason = L"cancelled-before-selection";
            std::wstring text, result, expected;
@@ -849,6 +910,21 @@ void App::transform(int command, int snippet)
                        return;
                }
                reason = L"clipboard-snapshot";
+                if (command == AutoCorrect)
+                {
+                    if (!beginTypingDeferral(target, version))
+                        return;
+                    reset.deferred = true;
+                }
+                // Collapse a temporary selection on every failed auto-correction,
+                // including clipboard exceptions, before queued typing is replayed.
+                bool autoSelected = false;
+                struct SelectionReset
+                {
+                    bool &selected;
+                    std::function<bool()> valid;
+                    ~SelectionReset() { if (selected && valid()) chord(VK_RIGHT); }
+                } selectionReset{autoSelected, valid};
                Transaction tx(*this, target, version);
                reason = L"selection-unavailable";
                diagnosticEvent(L"Transform target=" + processName(target) + L" command=" + std::to_wstring(command) +
@@ -865,6 +941,7 @@ void App::transform(int command, int snippet)
                    // 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();
                    // Some editors first select only ") ". Extend by whole-word
@@ -881,7 +958,10 @@ void App::transform(int command, int snippet)
                    if (!suggestion || !tx.valid() || !autoCorrectionAllowed(target, config))
                    {
                        if (tx.valid())
+                        {
                            chord(VK_RIGHT);
+                            autoSelected = false;
+                        }
                        return;
                    }
                    to = suggestion->target;
@@ -1018,6 +1098,8 @@ void App::transform(int command, int snippet)
                    sent = tx.paste(textClip(result));
                else if (automatic && tx.valid())
                    chord(VK_RIGHT);
+                if (sent || result == text)
+                    autoSelected = false;
                reason = result == text ? L"conversion-unchanged" :
                         sent ? L"paste-sent-unverified" : L"paste-cancelled";
                if (result == text &&
@@ -1377,6 +1459,9 @@ LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
    case WM_HOTKEY:
        app->dispatch((int)wp);
        return 0;
+    case ReplayTypingMessage:
+        app->replayTyping();
+        return 0;
    case TrayMessage:
        if (LOWORD(lp) == WM_CONTEXTMENU)
            app->trayMenu();
@@ -16,6 +16,7 @@ inline constexpr UINT TrayMessage = WM_APP + 1, ErrorMessage = WM_APP + 2, Histo
 inline constexpr int Toggle = 1, Case = 2, Translit = 3, Undo = 4, ShowHistory = 5, AutoCorrect = 6,
                     Screenshot = 7, Direct = 100;
 inline constexpr UINT AutoCorrectMessage = WM_APP + 6;
+inline constexpr UINT ReplayTypingMessage = WM_APP + 30;
 inline constexpr UINT CaptureHotkeyMessage = WM_APP + 5;
 struct LastTransform
 {
@@ -105,6 +106,10 @@ class App
    int previousAttemptCommand{}, repeatAttempts{};
    std::vector<std::pair<int, Hotkey>> hookBindings;
    HotkeyHook hotkeyHook;
+    HWND typingTarget{};
+    std::vector<INPUT> deferredTyping;
+    bool beginTypingDeferral(HWND, uint64_t);
+    void replayTyping();
    static LRESULT CALLBACK windowProc(HWND, UINT, WPARAM, LPARAM);
    static LRESULT CALLBACK keyProc(int, WPARAM, LPARAM);
    static LRESULT CALLBACK mouseProc(int, WPARAM, LPARAM);
@@ -70,9 +70,18 @@ AutoCorrector::Dictionary::Dictionary(const std::filesystem::path &path)
    }
    if (offsets.empty())
        throw std::runtime_error("Empty auto-correction dictionary");
-    for (size_t i = 1; i < offsets.size(); ++i)
-        if (word(i - 1) >= word(i))
-            throw std::runtime_error("Dictionary must be uniquely sorted");
+    auto entry = [&](uint32_t offset) { return std::string_view(bytes).substr(offset, bytes.find('\t', offset) - offset); };
+    auto frequency = [&](uint32_t offset)
+    {
+        int rank{};
+        auto start = offset + entry(offset).size() + 1;
+        std::from_chars(bytes.data() + start, bytes.data() + bytes.size(), rank);
+        return rank;
+    };
+    std::sort(offsets.begin(), offsets.end(), [&](uint32_t a, uint32_t b)
+              { return entry(a) == entry(b) ? frequency(a) < frequency(b) : entry(a) < entry(b); });
+    offsets.erase(std::unique(offsets.begin(), offsets.end(), [&](uint32_t a, uint32_t b)
+                              { return entry(a) == entry(b); }), offsets.end());
    offsets.shrink_to_fit();
    bytes.shrink_to_fit();
 }
@@ -151,9 +160,16 @@ std::optional<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed,
    auto sourceLanguage = layoutLanguage(layouts[source]);
    if (!dictionaries.contains(sourceLanguage))
        return {};
+    auto personal = [&](const std::wstring &language, const std::wstring &candidate)
+    {
+        auto found = settings.autoWords.find(language);
+        return found != settings.autoWords.end() &&
+            std::any_of(found->second.begin(), found->second.end(), [&](const std::wstring &known)
+                        { return lower(known) == lower(candidate); });
+    };
    // Valid words from either selected language are never changed.
    for (auto &[language, d] : dictionaries)
-        if (d.rank(word))
+        if (d.rank(word) || personal(language, word))
            return {};
    std::optional<AutoSuggestion> candidate;
    int matches = 0;
@@ -168,7 +184,7 @@ std::optional<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed,
        auto converted = convert(word, layouts[source], layouts[i], true);
        if (converted == word || !safeAutoWord(converted, settings.autoMinLength))
            continue;
-        int rank = dictionary->second.rank(converted);
+        int rank = personal(dictionary->first, converted) ? 1 : dictionary->second.rank(converted);
        if (!rank)
            continue;
        if (++matches > 1)
@@ -1,6 +1,7 @@
 #pragma once
 #include <cstdint>
 #include <functional>
+#include <map>
 #include <optional>
 #include <string>
 #include <vector>
@@ -58,6 +59,7 @@ struct Settings
    std::wstring autoSuffixChars = L")]}»”’\".,!?:;";
    std::vector<std::wstring> autoLanguages{L"en", L"uk"};
    std::vector<std::wstring> autoNever;
+    std::map<std::wstring, std::vector<std::wstring>> autoWords;
    std::vector<std::wstring> autoExcluded{
        L"Code", L"rider64",  L"devenv", L"WindowsTerminal", L"cmd",       L"powershell", L"pwsh",
        L"Far",  L"ConEmu64", L"putty",  L"KeePass",         L"KeePassXC", L"1Password",  L"Bitwarden"};
@@ -92,6 +92,17 @@ void validateSettings(const Settings &s)
            throw std::runtime_error("Unsupported auto-correction language");
    if (s.autoNever.size() > 10000 || s.autoExcluded.size() > 1000)
        throw std::runtime_error("Too many auto-correction exceptions");
+    for (const auto &[language, words] : s.autoWords)
+    {
+        std::wstring alphabet = language == L"en" ? L"abcdefghijklmnopqrstuvwxyz" :
+            language == L"uk" ? L"абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" :
+            language == L"ru" ? L"абвгдеёжзийклмнопрстуфхцчшщъыьэюя" : L"";
+        if (alphabet.empty() || words.size() > 10000)
+            throw std::runtime_error("Invalid personal dictionary language or too many words");
+        for (const auto &word : words)
+            if (word.empty() || word.size() > 32 || lower(word).find_first_not_of(alphabet) != word.npos)
+                throw std::runtime_error("Personal words must contain 1-32 letters of their selected language");
+    }
    if (s.maxItems < 10 || s.maxItems > 10000 || s.maxMiB < 1 || s.maxMiB > 2048 || s.maxImageMiB < 1 ||
        s.maxImageMiB > 64)
        throw std::runtime_error("History limits: 10–10000 items, 1–2048 MiB total, 1–64 MiB per image");
@@ -143,6 +154,10 @@ Settings decodeSettings(const Bytes &bytes, const std::vector<Layout> &layouts)
    s.autoMinLength = j.value("autoCorrectMinLength", 3);
    s.autoPrefixChars = str(j, "autoCorrectPrefixChars", s.autoPrefixChars);
    s.autoSuffixChars = str(j, "autoCorrectSuffixChars", s.autoSuffixChars);
+    if (j.contains("autoCorrectWords"))
+        for (auto &[language, words] : j.at("autoCorrectWords").items())
+            for (auto &word : words)
+                s.autoWords[wide(language)].push_back(lower(wide(word.get<std::string>())));
    for (auto pair : {std::pair{"autoCorrectLanguages", &s.autoLanguages},
                      {"autoCorrectNever", &s.autoNever},
                      {"autoCorrectExcludedApps", &s.autoExcluded}})
@@ -229,6 +244,13 @@ Bytes encodeSettings(const Settings &s)
    j["autoCorrectMinLength"] = s.autoMinLength;
    j["autoCorrectPrefixChars"] = utf8(s.autoPrefixChars);
    j["autoCorrectSuffixChars"] = utf8(s.autoSuffixChars);
+    j["autoCorrectWords"] = Json::object();
+    for (const auto &[language, words] : s.autoWords)
+    {
+        auto &items = j["autoCorrectWords"][utf8(language)] = Json::array();
+        for (const auto &word : words)
+            items.push_back(utf8(lower(word)));
+    }
    for (auto pair : {std::pair{"autoCorrectLanguages", &s.autoLanguages},
                      {"autoCorrectNever", &s.autoNever},
                      {"autoCorrectExcludedApps", &s.autoExcluded}})
@@ -1009,6 +1009,15 @@ LRESULT CALLBACK autoOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
            if (checked(w, 403))
                draft.autoLanguages.push_back(L"ru");
            draft.autoNever = parseCommaList(value(w, 405));
+            for (auto [id, language] : {std::pair{411, L"en"}, {412, L"uk"}, {413, L"ru"}})
+            {
+                auto text = lower(value(w, id));
+                std::replace(text.begin(), text.end(), L'\n', L',');
+                auto words = parseCommaList(text);
+                std::sort(words.begin(), words.end());
+                words.erase(std::unique(words.begin(), words.end()), words.end());
+                draft.autoWords[language] = std::move(words);
+            }
            draft.autoExcluded = parseCommaList(value(w, 404));
            draft.autoPrefixChars = value(w, 408);
            draft.autoSuffixChars = value(w, 409);
@@ -1017,6 +1026,7 @@ LRESULT CALLBACK autoOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
            validateSettings(draft);
            view->settings->draft.autoLanguages = draft.autoLanguages;
            view->settings->draft.autoNever = draft.autoNever;
+            view->settings->draft.autoWords = draft.autoWords;
            view->settings->draft.autoExcluded = draft.autoExcluded;
            view->settings->draft.autoMaxRank = draft.autoMaxRank;
            view->settings->draft.autoMinLength = draft.autoMinLength;
@@ -1063,13 +1073,20 @@ void showAutoOptions(HWND parent, SettingsView *v)
    for (auto &lang : v->draft.autoLanguages)
        check(w, lang == L"en" ? 401 : lang == L"uk" ? 402 : 403, true);
    label(w, L"Excluded applications (process names, comma-separated)", 18, 94, 525);
-    edit(w, 404, 18, 122, 524, 84, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
+    edit(w, 404, 18, 122, 524, 52, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
    value(w, 404, commaList(v->draft.autoExcluded));
-    label(w, L"Personal dictionary: never correct these words (comma-separated)", 18, 220, 525);
-    edit(w, 405, 18, 248, 524, 84, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
+    label(w, L"Never correct these words (comma-separated)", 18, 184, 525);
+    edit(w, 405, 18, 212, 524, 52, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
    value(w, 405, commaList(v->draft.autoNever));
-    label(w, L"Corrects after Space and a short pause.", 18, 344, 525);
-    label(w, L"Undo skips this word until KSwitcher restarts.", 18, 366, 525);
+    label(w, L"My dictionary: correct words, separated by commas or new lines", 18, 276, 525);
+    for (auto [id, language] : {std::pair{411, L"en"}, {412, L"uk"}, {413, L"ru"}})
+    {
+        int x = 18 + (id - 411) * 178;
+        label(w, id == 411 ? L"English" : id == 412 ? L"Ukrainian" : L"Russian", x, 302, 168);
+        edit(w, id, x, 328, 168, 56, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL | ES_WANTRETURN);
+        auto words = v->draft.autoWords.find(language);
+        if (words != v->draft.autoWords.end()) value(w, id, commaList(words->second));
+    }
    label(w, L"Frequency rank limit (0 = entire dictionary)", 18, 400, 390);
    edit(w, 406, 420, 396, 122, 26, ES_NUMBER);
    value(w, 406, std::to_wstring(v->draft.autoMaxRank));
@@ -2,7 +2,7 @@
 #include "platform.h"
 namespace ks
 {
-inline constexpr wchar_t AppVersion[] = L"0.6.9";
+inline constexpr wchar_t AppVersion[] = L"0.6.10";
 inline constexpr UINT UpdateMessage = WM_APP + 7;
 inline constexpr UINT UpdateCheckIntervalMs = 6 * 60 * 60 * 1000;
 inline constexpr UINT UpdateNotificationRetryMs = 5 * 60 * 1000;