diff --git a/CMakeLists.txt b/CMakeLists.txt index 5ab6fa3..8c1d9be 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,5 @@ cmake_minimum_required(VERSION 3.24) -project(KSwitcher VERSION 0.6.34 LANGUAGES CXX RC) +project(KSwitcher VERSION 0.6.35 LANGUAGES CXX RC) if(NOT WIN32) message(FATAL_ERROR "KSwitcher uses native Windows APIs") endif() @@ -65,6 +65,15 @@ else() target_link_options(KSwitcherOcrTests PRIVATE -static -static-libgcc -static-libstdc++) endif() enable_testing() +add_executable(KSwitcherDictionaryTests tests/dictionary.cpp) +target_link_libraries(KSwitcherDictionaryTests PRIVATE kscore psapi) +if(MSVC) + set_property(TARGET KSwitcherDictionaryTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") +else() + target_link_options(KSwitcherDictionaryTests PRIVATE -static -static-libgcc -static-libstdc++) +endif() +add_test(NAME dictionary-regressions COMMAND KSwitcherDictionaryTests) +set_tests_properties(dictionary-regressions PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") add_test(NAME sync-regressions COMMAND KSwitcherSyncTests) add_test(NAME native-regressions COMMAND KSwitcherTests) add_test(NAME scroll-regressions COMMAND KSwitcherScrollTests) diff --git a/README.md b/README.md index f3e3c34..7674650 100644 --- a/README.md +++ b/README.md @@ -627,7 +627,12 @@ support automatic correction. Dictionary recognition is heuristic, not an unders subtitle vocabulary is incomplete, and uncommon names or jargon can need personal exceptions. No network service or language model is used. The three dictionary files occupy about 2.6 MB on disk; -the English/Ukrainian lookup data uses less than 3 MiB of RAM and is loaded on first automatic check. +the bundled EN/UK/RU lookup payload uses about 0.90 MiB of RAM. When automatic correction is enabled, +selected dictionaries are loaded before typing and shared by the input predictor and worker. +Words are stored in compact indexed blocks; all words and frequency ranks are retained, and editable +UTF-8 dictionary files keep the same format. Custom dictionaries can use more memory. +`build.ps1 -Test` checks every bundled word/rank and measures lookup speed; CMake exposes the same +check as `dictionary-regressions`. The payload figure excludes the rest of the process and allocator overhead. Keep `dictionaries/` beside the executable when copying the app. These word lists derive from [FrequencyWords](https://github.com/hermitdave/FrequencyWords) and are separately licensed under CC BY-SA 4.0; attribution, pinned source revision and license are in `dictionaries/`. diff --git a/Release/KSwitcher-win-x64.zip b/Release/KSwitcher-win-x64.zip index 185d15d..3c699f7 100644 Binary files a/Release/KSwitcher-win-x64.zip and b/Release/KSwitcher-win-x64.zip differ diff --git a/Release/README.md b/Release/README.md index 9c3d821..c186a77 100644 --- a/Release/README.md +++ b/Release/README.md @@ -1,14 +1,18 @@ # Latest Windows release -## v0.6.34 — 2026-11-04 +## v0.6.35 — 2026-11-04 ## Changes -- Screenshot editing now uses the four-direction move cursor for both endpoints of lines/arrows, bounding-box shape handles and number-radius handles. The cursor no longer suggests that a horizontal or vertical line endpoint is restricted to one axis. -- Object bodies, arrow labels and triangle vertices continue to use the same four-direction cursor. Thickness handles retain directional resize cursors perpendicular to the line; rotation handles retain the hand cursor. -- This changes cursor feedback only. Dragging, snapping, circle proportions, undo/redo, shortcuts, defaults and dialog access-key behavior are unchanged. The v0.6.33 unsaved-settings warning and visible menu access letters remain included. +- Reduced resident memory: the input predictor and correction worker share immutable dictionaries. Compact indexed blocks retain all 140,939 bundled words and their frequency ranks while reducing the EN/UK/RU lookup payload from approximately 3.06 MiB per copy to 0.90 MiB shared. Custom UTF-8 dictionary files, duplicate handling, frequency limits and personal dictionaries remain compatible. +- Closing clipboard history releases its duplicate row list and Windows list strings, retains selection/scroll identifiers for reopening, and rejects late search results and timers. Preview caches now have payload budgets of 1 MiB for thumbnails and 256 KiB for formatted text, plus the existing item-count limit. Visible entries are retained even if an unusually large viewport exceeds a budget. +- PNG decoding reads the existing input buffer without making another full PNG copy. DIB decoding allocates its temporary BMP buffer once at the required size. +- Idle maintenance releases diagnostic context older than 30 seconds and expired Undo text after its existing two-minute eligibility window, without interrupting an active operation. Completed sync buffers are released on success, failure and stale responses; unresolved conflicts remain available. +- No shortcut, default, on-disk history format or screenshot-editing behavior changed. The v0.6.34 four-direction movement cursors remain included. ## Validation -The full `build.ps1 -Stage -Test` run passed: 105 sync checks, shared wheel batching, 483 native regressions, 551 input/UI checks at 96 DPI, screenshot editor UI checks (including free-movement cursor feedback across drawing tools and horizontal/vertical thickness cursors), PNG saving, isolated screenshot registration, 48 updater regressions and updater progress UI checks. All three executable versions and all 12 package manifest file sizes/SHA-256 hashes were verified; the package contains no personal data. +The full `build.ps1 -Stage -Test` suite covers complete bundled dictionary word/rank equivalence, malformed/custom dictionary boundaries, 105 sync checks, shared wheel batching, 304 native regressions, 559 input/UI checks, screenshot editor UI and PNG saving, isolated screenshot registration, 48 updater regressions and updater progress UI checks. Cache assertions now run once outside the exception helper rather than being repeated inside it. All three executable versions and all 12 package manifest file sizes/SHA-256 hashes were verified; no personal data is packaged. + +Controlled local measurements of the final dictionary step, after equal restart/wait periods with three dictionaries enabled, reduced private resident memory from 7.08 to 4.65 MiB and private committed memory from 8.34 to 5.70 MiB. These compare consecutive development builds, not the published v0.6.34 with the full cumulative change. Randomized lookup tests were approximately 20% faster. Results depend on settings, workload, Windows and allocator state; these are not fixed memory limits. The 0.90 MiB dictionary figure excludes process/allocator overhead. ## Upgrade Choose **Update** in the tray menu. Legacy v0.3.0–v0.4.1 clients first receive the v0.4.2 compatibility bridge, then the current full release. v0.2.3 and earlier require manual installation. diff --git a/Release/SHA256SUMS.txt b/Release/SHA256SUMS.txt index 3ae5d31..5b43f2e 100644 --- a/Release/SHA256SUMS.txt +++ b/Release/SHA256SUMS.txt @@ -1 +1 @@ -c7f004ecd9d0f1032356060191ca3ca9fca458df434d3e5908c5d9b038f95acc KSwitcher-win-x64.zip +6e36a582eec59b3cc4f0f9d6b3e05cd699371c05cae30a95c6eae51a838f7bfe KSwitcher-win-x64.zip diff --git a/build.ps1 b/build.ps1 index 293db93..dda3a32 100644 --- a/build.ps1 +++ b/build.ps1 @@ -41,6 +41,10 @@ try { if ($LASTEXITCODE) { throw 'Screenshot link failed' } Copy-Item -LiteralPath $screenshotPath -Destination build/release/KSwitcher.Screenshot.exe -Force if ($Test) { + & $compiler @common tests/dictionary.cpp build/core.o build/platform.o build/autocorrect.o @libs -lpsapi -static -s -o build/KSwitcherDictionaryTests.exe + if ($LASTEXITCODE) { throw 'Dictionary test build failed' } + & .\build\KSwitcherDictionaryTests.exe + if ($LASTEXITCODE) { throw 'Dictionary tests failed' } & $compiler @common tests/sync.cpp build/core.o build/platform.o build/storage.o build/sync.o build/ocr.o @libs -static -s -o build/KSwitcherSyncTests.exe if ($LASTEXITCODE) { throw 'Sync test build failed' } & .\build\KSwitcherSyncTests.exe diff --git a/resources/app.rc b/resources/app.rc index 4f29ffb..402d88b 100644 --- a/resources/app.rc +++ b/resources/app.rc @@ -9,8 +9,8 @@ IDC_SCREENSHOT_PENCIL CURSOR "icons/lucide/pencil.cur" 1 RT_MANIFEST "app.manifest" 201 RCDATA "update.ps1" 1 VERSIONINFO - FILEVERSION 0,6,34,0 - PRODUCTVERSION 0,6,34,0 + FILEVERSION 0,6,35,0 + PRODUCTVERSION 0,6,35,0 FILEOS VOS_NT_WINDOWS32 FILETYPE VFT_APP BEGIN @@ -20,7 +20,7 @@ BEGIN BEGIN VALUE "FileDescription", "KSwitcher — native keyboard and clipboard utility" VALUE "ProductName", "KSwitcher" - VALUE "FileVersion", "0.6.34" + VALUE "FileVersion", "0.6.35" END END BLOCK "VarFileInfo" diff --git a/src/app.cpp b/src/app.cpp index 608b05e..6232a56 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -1,4 +1,5 @@ #include "app.h" +#include #include "../vendor/json.hpp" #include "../resources/resource.h" #include "ocr.h" @@ -642,7 +643,7 @@ void App::applySettings(const Settings &requested) ++inputVersion; if (busy) diagnosticEvent(L"Input context changed: settings applied version=" + std::to_wstring(inputVersion.load())); } - // Clear on the worker so the next check reloads edits to dictionary files. + // 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); @@ -703,6 +704,13 @@ void App::resetInput() 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) { @@ -1166,9 +1174,11 @@ void App::transform(int command, int snippet) if (!config.autoCorrect || recent.window != target || recent.overflow || recent.keys.empty() || recent.keys.back() != L' ' || hint < 0) return; - autoCorrector.configure(std::filesystem::path(executable()).parent_path() / - L"dictionaries", - config.autoLanguages); + { + 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)); @@ -1883,6 +1893,7 @@ LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) case WM_TIMER: if (wp == 6) { + app->releaseIdleMemory(GetTickCount64()); app->pollSync(); return 0; } diff --git a/src/app.h b/src/app.h index f5b8f43..19d5918 100644 --- a/src/app.h +++ b/src/app.h @@ -86,6 +86,7 @@ class App private: friend struct InputRegressionAccess; + void releaseIdleMemory(ULONGLONG now); HHOOK keyboardHook{}, mouseHook{}; std::mutex jobsMutex; std::condition_variable jobsReady; diff --git a/src/app_sync.inl b/src/app_sync.inl index 6b25abf..f662c96 100644 --- a/src/app_sync.inl +++ b/src/app_sync.inl @@ -46,7 +46,7 @@ std::wstring App::syncCommand(int action, const std::vector &choices syncDone.store(true); }); } - catch (...) { syncRunning = false; throw; } + catch (...) { syncRunning = false; Bytes().swap(syncSnapshot); syncResult = {}; throw; } return syncStatus; } void App::pollSync() @@ -57,25 +57,28 @@ void App::pollSync() { if (busy) return; syncWorker.join(); + // Own completed payloads locally so every return/exception releases them. + auto result = std::exchange(syncResult, SyncResult{}); + auto snapshot = std::exchange(syncSnapshot, Bytes{}); syncRunning = false; syncDone = false; - syncStatus = syncResult.status; - if (syncResult.success) + syncStatus = result.status; + if (result.success) { - if (loadSyncConfig(data) != syncConnection || encodeSettings(settings) != syncSnapshot) + if (loadSyncConfig(data) != syncConnection || encodeSettings(settings) != snapshot) { syncStatus = L"Local settings or connection changed during sync. Checking again shortly."; nextSync = GetTickCount64() + 2000; return; } - auto next = restoreSyncSettings(syncResult.settings, settings, layouts, syncConnection.keepLocalLayouts); - if (encodeSettings(next) != syncSnapshot) + auto next = restoreSyncSettings(result.settings, settings, layouts, syncConnection.keepLocalLayouts); + if (encodeSettings(next) != snapshot) { - atomicWrite(data / L"settings-before-sync.bin", protect(syncSnapshot)); + atomicWrite(data / L"settings-before-sync.bin", protect(snapshot)); applySettings(next); } - saveSyncBase(data, syncConnection, syncResult.base.empty() ? syncResult.settings : syncResult.base); - pendingSyncConflicts = syncResult.conflicts; + saveSyncBase(data, syncConnection, result.base.empty() ? result.settings : result.base); + pendingSyncConflicts = std::move(result.conflicts); conflictConnection = syncConnection; SYSTEMTIME time{}; GetLocalTime(&time); wchar_t stamp[32]{}; @@ -84,8 +87,8 @@ void App::pollSync() } // Back off after errors (including bad credentials) instead of repeatedly // hitting userpass lockout. The explicit Sync button remains available. - syncRetryAfter = syncResult.success ? 0 : GetTickCount64() + 15 * 60000; - nextSync = syncResult.success ? GetTickCount64() + SyncIntervalMs : syncRetryAfter; + syncRetryAfter = result.success ? 0 : GetTickCount64() + 15 * 60000; + nextSync = result.success ? GetTickCount64() + SyncIntervalMs : syncRetryAfter; } if (!syncRunning && GetTickCount64() >= nextSync) { diff --git a/src/autocorrect.cpp b/src/autocorrect.cpp index a720066..81d1810 100644 --- a/src/autocorrect.cpp +++ b/src/autocorrect.cpp @@ -42,82 +42,160 @@ bool safeAutoWord(const std::wstring &word, int minimumLength) auto small = lower(word); return word == small || (word.substr(1) == small.substr(1) && word != upper(word)); } -std::string_view AutoCorrector::Dictionary::word(size_t index) const +namespace { +constexpr size_t DictionaryBlockWords = 32; +} +std::string_view AutoCorrector::Dictionary::word(size_t block) const { - auto start = offsets[index]; - auto end = bytes.find('\t', start); - return std::string_view(bytes).substr(start, end - start); + size_t start = offsets[block]; + // Every block starts with a complete word (zero shared prefix). + size_t length = static_cast(bytes[start++]) & 15; + if (length == 15) length = static_cast(bytes[start++]); + return std::string_view(bytes).substr(start, length); } AutoCorrector::Dictionary::Dictionary(const std::filesystem::path &path) { - auto raw = readFile(path, 2 * 1024 * 1024); - bytes.assign(raw.begin(), raw.end()); - for (size_t start = 0; start < bytes.size();) + const auto raw = readFile(path, 2 * 1024 * 1024); + const std::string_view source(reinterpret_cast(raw.data()), raw.size()); + std::vector lines; + lines.reserve(std::count(source.begin(), source.end(), '\n') + 1); + for (size_t start = 0; start < source.size();) { - auto end = bytes.find('\n', start); - if (end == bytes.npos) - end = bytes.size(); - auto tab = bytes.find('\t', start); - if (tab == bytes.npos || tab >= end || tab == start || tab - start > 160) + auto end = source.find('\n', start); + if (end == source.npos) end = source.size(); + auto tab = source.find('\t', start); + if (tab == source.npos || tab >= end || tab == start || tab - start > 160) throw std::runtime_error("Invalid auto-correction dictionary"); int rank{}; - auto rankEnd = end > tab + 1 && bytes[end - 1] == '\r' ? end - 1 : end; - auto parse = std::from_chars(bytes.data() + tab + 1, bytes.data() + rankEnd, rank); - if (parse.ec != std::errc() || parse.ptr != bytes.data() + rankEnd || rank <= 0) + auto rankEnd = end > tab + 1 && source[end - 1] == '\r' ? end - 1 : end; + auto parse = std::from_chars(source.data() + tab + 1, source.data() + rankEnd, rank); + if (parse.ec != std::errc() || parse.ptr != source.data() + rankEnd || rank <= 0) throw std::runtime_error("Invalid dictionary rank"); - offsets.push_back((uint32_t)start); + lines.push_back(static_cast(start)); start = end + 1; } - if (offsets.empty()) - throw std::runtime_error("Empty auto-correction dictionary"); - auto entry = [&](uint32_t offset) { return std::string_view(bytes).substr(offset, bytes.find('\t', offset) - offset); }; - auto frequency = [&](uint32_t offset) - { + if (lines.empty()) throw std::runtime_error("Empty auto-correction dictionary"); + auto entry = [&](uint32_t offset) { return source.substr(offset, source.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); + std::from_chars(source.data() + start, source.data() + source.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(); + std::sort(lines.begin(), lines.end(), [&](uint32_t a, uint32_t b) { + return entry(a) == entry(b) ? frequency(a) < frequency(b) : entry(a) < entry(b); + }); + lines.erase(std::unique(lines.begin(), lines.end(), [&](uint32_t a, uint32_t b) { + return entry(a) == entry(b); + }), lines.end()); + offsets.reserve((lines.size() + DictionaryBlockWords - 1) / DictionaryBlockWords); + std::string_view previous; + // Allocate the packed payload exactly once. Geometric growth and a final + // shrink otherwise leave discarded buffers in the resident process heap. + size_t packedSize = 0; + for (size_t i = 0; i < lines.size(); ++i) + { + auto current = entry(lines[i]); + size_t prefix = 0; + if (i % DictionaryBlockWords != 0) + while (prefix < std::min(previous.size(), current.size()) && previous[prefix] == current[prefix]) ++prefix; + auto suffix = current.size() - prefix; + packedSize += 1 + (prefix >= 15) + (suffix >= 15) + suffix + 2; + auto rank = static_cast(frequency(lines[i])); + if (rank >= 65535) + do { ++packedSize; rank >>= 7; } while (rank); + previous = current; + } + bytes.reserve(packedSize); + previous = {}; + for (size_t i = 0; i < lines.size(); ++i) + { + auto current = entry(lines[i]); + size_t prefix = 0; + if (i % DictionaryBlockWords == 0) + offsets.push_back(static_cast(bytes.size())); + else + while (prefix < std::min(previous.size(), current.size()) && previous[prefix] == current[prefix]) ++prefix; + size_t suffix = current.size() - prefix; + bytes.push_back(static_cast((std::min(prefix, size_t(15)) << 4) | std::min(suffix, size_t(15)))); + if (prefix >= 15) bytes.push_back(static_cast(prefix)); + if (suffix >= 15) bytes.push_back(static_cast(suffix)); + bytes.append(current.substr(prefix)); + auto rank = static_cast(frequency(lines[i])); + auto shortRank = std::min(rank, uint32_t(65535)); + bytes.push_back(static_cast(shortRank & 255)); + bytes.push_back(static_cast(shortRank >> 8)); + if (rank >= 65535) + do { + auto next = rank & 127; + rank >>= 7; + bytes.push_back(static_cast(next | (rank ? 128 : 0))); + } while (rank); + previous = current; + } } int AutoCorrector::Dictionary::rank(const std::wstring &text) const { auto key = utf8(lower(text)); size_t begin = 0, end = offsets.size(); + // Find the last block whose first word is <= the search key. while (begin < end) { auto mid = begin + (end - begin) / 2; - if (word(mid) < key) - begin = mid + 1; - else - end = mid; + if (word(mid) <= key) begin = mid + 1; + else end = mid; } - if (begin == offsets.size() || word(begin) != key) - return 0; - auto start = offsets[begin] + word(begin).size() + 1; - int rank{}; - std::from_chars(bytes.data() + start, bytes.data() + bytes.size(), rank); - return rank; + if (!begin) return 0; + size_t block = begin - 1; + size_t at = offsets[block]; + const size_t limit = begin < offsets.size() ? offsets[begin] : bytes.size(); + char decoded[160]; // The loader validates lengths; lookup never allocates a decoded word. + while (at < limit) + { + auto lengths = static_cast(bytes[at++]); + size_t prefix = lengths >> 4, suffix = lengths & 15; + if (prefix == 15) prefix = static_cast(bytes[at++]); + if (suffix == 15) suffix = static_cast(bytes[at++]); + memcpy(decoded + prefix, bytes.data() + at, suffix); + at += suffix; + uint32_t rank = static_cast(bytes[at]) | + (uint32_t(static_cast(bytes[at + 1])) << 8); + at += 2; + if (rank == 65535) { + rank = 0; + uint32_t shift = 0; + unsigned char part; + do { + part = static_cast(bytes[at++]); + rank |= uint32_t(part & 127) << shift; + shift += 7; + } while (part & 128); + } + auto compared = std::string_view(decoded, size_t(prefix) + suffix).compare(key); + if (compared == 0) return static_cast(rank); + if (compared > 0) return 0; + } + return 0; } void AutoCorrector::configure(const std::filesystem::path &folder, const std::vector &wanted) { if (languages == wanted) return; - std::map next; + std::map> next; for (auto &lang : wanted) { if (lang != L"en" && lang != L"uk" && lang != L"ru") throw std::runtime_error("Unsupported dictionary language"); - next.emplace(lang, Dictionary(folder / (lang + L".txt"))); + next.emplace(lang, std::make_shared(folder / (lang + L".txt"))); } dictionaries = std::move(next); languages = wanted; } +void AutoCorrector::shareDictionaries(const AutoCorrector &source) +{ + dictionaries = source.dictionaries; + languages = source.languages; +} void AutoCorrector::reject(std::wstring word, const Settings &settings) { while (!word.empty() && openingDelimiter(word.front(), settings)) @@ -132,7 +210,7 @@ size_t AutoCorrector::memoryBytes() const { size_t bytes = 0; for (auto &[language, d] : dictionaries) - bytes += d.bytes.capacity() + d.offsets.capacity() * sizeof(uint32_t); + bytes += d->bytes.capacity() + d->offsets.capacity() * sizeof(uint32_t); return bytes; } std::optional AutoCorrector::suggest(const std::wstring &typed, int source, @@ -191,7 +269,7 @@ std::optional AutoCorrector::suggest(const std::wstring &typed, }; // Valid words from either selected language are never changed. for (auto &[language, d] : dictionaries) - if (d.rank(word) || personal(language, word)) + if (d->rank(word) || personal(language, word)) return {}; std::optional candidate; std::optional matchedText; @@ -211,7 +289,7 @@ std::optional 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 = personal(dictionary->first, converted) ? 1 : dictionary->second.rank(converted); + int rank = personal(dictionary->first, converted) ? 1 : dictionary->second->rank(converted); if (!rank) continue; if (matchedText && *matchedText != converted) @@ -233,7 +311,7 @@ std::optional AutoCorrector::suggest(const std::wstring &typed, auto consider = [&](const std::wstring &text) { if (text == small || text == found || text.size() < 4 || text.size() > 32) return true; - int rank = personalTargets.contains(text) ? 1 : dictionaries.at(sourceLanguage).rank(text); + int rank = personalTargets.contains(text) ? 1 : dictionaries.at(sourceLanguage)->rank(text); if (!rank) return true; if (!found.empty()) return false; found = text; diff --git a/src/autocorrect.h b/src/autocorrect.h index 3357863..adcc227 100644 --- a/src/autocorrect.h +++ b/src/autocorrect.h @@ -1,6 +1,7 @@ #pragma once #include "platform.h" #include +#include #include #include namespace ks @@ -18,23 +19,30 @@ int matchAutoInput(const Run &, const std::wstring &, const std::vector bool autoCorrectionAllowed(HWND, const Settings &); class AutoCorrector { + friend struct AutoCorrectorRegressionAccess; struct Dictionary { + // Front-coded UTF-8 words in independently searchable blocks of 32. + // Prefix/suffix lengths share a byte (15 escapes to a full byte length). + // Ranks use two bytes; 65535 escapes to a varint for larger custom ranks. std::string bytes; std::vector offsets; std::string_view word(size_t) const; explicit Dictionary(const std::filesystem::path &); int rank(const std::wstring &) const; }; - std::map dictionaries; + std::map> dictionaries; std::vector languages; std::set rejected; public: void configure(const std::filesystem::path &, const std::vector &); + // Share immutable dictionary storage, keeping each consumer's undo rejections private. + void shareDictionaries(const AutoCorrector &); std::optional suggest(const std::wstring &, int source, const std::vector &, const Settings &) const; void reject(std::wstring word, const Settings & = {}); + // Referenced dictionary payload, including shared storage (do not sum across consumers). size_t memoryBytes() const; }; } // namespace ks diff --git a/src/history_preview.h b/src/history_preview.h index 69a8373..f83a328 100644 --- a/src/history_preview.h +++ b/src/history_preview.h @@ -4,14 +4,28 @@ #include namespace ks { +inline constexpr size_t HistoryThumbnailBudget = 1024 * 1024; +inline constexpr size_t HistoryRichTextBudget = 256 * 1024; // Keep the visible working set even in unusually tall windows. Never evict a // visible preview to admit another visible preview: that creates a paint loop. +template +void trimHistoryPreviews(std::map &cache, + const std::set &visible, size_t limit, + size_t byteLimit, Weight weight) +{ + size_t bytes = 0; + for (const auto &[id, value] : cache) bytes += weight(value); + for(auto it=cache.begin(); (cache.size()>limit || bytes>byteLimit) && it!=cache.end();) + if(!visible.contains(it->first)) { + bytes -= weight(it->second); + it=cache.erase(it); + } + else ++it; +} template void trimHistoryPreviews(std::map &cache, const std::set &visible, size_t limit=32) { - for(auto it=cache.begin(); cache.size()>limit && it!=cache.end();) - if(!visible.contains(it->first)) it=cache.erase(it); - else ++it; + trimHistoryPreviews(cache, visible, limit, 0, [](const T &) { return size_t{}; }); } } diff --git a/src/ocr.cpp b/src/ocr.cpp index d76bfb7..6636605 100644 --- a/src/ocr.cpp +++ b/src/ocr.cpp @@ -123,13 +123,16 @@ struct OcrStatics : IInspectable Pixels decodeImage(const Clip &clip, UINT maxWidth, UINT maxHeight) { Bytes encoded; + const Bytes *input = &encoded; for (const auto &f : clip.formats) if (f.name == L"PNG") { - encoded = f.data; + input = &f.data; break; } - if (encoded.empty()) + if (input->empty()) + { + input = &encoded; for (const auto &f : clip.formats) if ((f.id == CF_DIB || f.id == CF_DIBV5) && f.data.size() >= 40) { @@ -146,19 +149,21 @@ Pixels decodeImage(const Clip &clip, UINT maxWidth, UINT maxHeight) file.bfType = 0x4d42; file.bfSize = (DWORD)(sizeof(file) + f.data.size()); file.bfOffBits = (DWORD)offset; - encoded.resize(sizeof(file)); + encoded.resize(sizeof(file) + f.data.size()); memcpy(encoded.data(), &file, sizeof(file)); - encoded.insert(encoded.end(), f.data.begin(), f.data.end()); + memcpy(encoded.data() + sizeof(file), f.data.data(), f.data.size()); break; } - if (encoded.empty()) + } + if (input->empty()) throw std::runtime_error("This clipboard item has no supported image"); Com wic; check(CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (void **)wic.out())); Com stream; check(wic->CreateStream(stream.out())); - check(stream->InitializeFromMemory(encoded.data(), (DWORD)encoded.size())); + // WIC decoding only reads the stream. The clip outlives every WIC object here. + check(stream->InitializeFromMemory(const_cast(input->data()), (DWORD)input->size())); Com decoder; check(wic->CreateDecoderFromStream(stream.p, nullptr, WICDecodeMetadataCacheOnLoad, decoder.out())); Com frame; diff --git a/src/platform.cpp b/src/platform.cpp index 4510526..c9a9e8a 100644 --- a/src/platform.cpp +++ b/src/platform.cpp @@ -604,10 +604,25 @@ std::recursive_mutex logGate; bool loggingEnabled = false; DiagnosticBuffer diagnosticBuffer; } +size_t DiagnosticBuffer::expire(ULONGLONG now) +{ + size_t removed = 0; + while (!entries.empty() && now - entries.front().first > 30000) + { + entries.pop_front(); + ++removed; + } + return removed; +} +void expireDiagnostics(ULONGLONG now) +{ + std::lock_guard lock(logGate); + diagnosticBuffer.expire(now); +} std::wstring DiagnosticBuffer::record(const std::wstring &message, bool problem, ULONGLONG now) { - while (!entries.empty() && (entries.size() >= 128 || now - entries.front().first > 30000)) - entries.pop_front(); + expire(now); + while (entries.size() >= 128) entries.pop_front(); entries.emplace_back(now, message); if (!problem) return {}; diff --git a/src/platform.h b/src/platform.h index 4825490..95fe26d 100644 --- a/src/platform.h +++ b/src/platform.h @@ -72,10 +72,12 @@ class DiagnosticBuffer { std::deque> entries; public: + size_t expire(ULONGLONG now); std::wstring record(const std::wstring &message, bool problem, ULONGLONG now); void clear() { entries.clear(); } }; void setLoggingEnabled(bool enabled); +void expireDiagnostics(ULONGLONG now); void diagnosticEvent(const std::wstring &message, bool problem = false); void diagnosticOperation(const std::string &json); std::wstring readDiagnosticLog(bool previous); diff --git a/src/ui.cpp b/src/ui.cpp index 17459d7..08fe627 100644 --- a/src/ui.cpp +++ b/src/ui.cpp @@ -479,12 +479,14 @@ struct HistoryView { App *app{}; std::vector items; + std::wstring rememberedSelection, rememberedTop; uint64_t generation{}; std::map thumbnails; std::map richTexts; HWND rich{}; std::set pending; bool scrolling{}; + bool closed{}; }; bool selectedImage(HWND w, HistoryView *v) { @@ -502,6 +504,7 @@ std::wstring selected(HWND w, HistoryView *v) } void search(HWND w, HistoryView *v) { + v->closed = false; auto q = value(w, 101); auto generation = ++v->generation; v->pending.clear(); @@ -770,6 +773,7 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp) } case WM_TIMER: KillTimer(w, 1); + if (v->closed) return 0; search(w, v); return 0; case ResultsMessage: @@ -778,8 +782,10 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp) if (result->generation != v->generation) return 0; auto old = selected(w, v); + if (old.empty()) old = v->rememberedSelection; int top=(int)SendDlgItemMessageW(w,102,LB_GETTOPINDEX,0,0); auto topId=top>=0 && top<(int)v->items.size()?v->items[top].id:L""; + if (topId.empty()) topId = v->rememberedTop; v->items = std::move(result->items); SendDlgItemMessageW(w, 102, WM_SETREDRAW, FALSE, 0); SendDlgItemMessageW(w, 102, LB_RESETCONTENT, 0, 0); @@ -823,8 +829,10 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp) v->richTexts[result->id] = std::move(result->rtf); else v->thumbnails[result->id] = std::move(result->pixels); - trimHistoryPreviews(v->thumbnails,visible); - trimHistoryPreviews(v->richTexts,visible); + trimHistoryPreviews(v->thumbnails,visible,32,HistoryThumbnailBudget, + [](const Pixels &p) { return p.bgra.capacity(); }); + trimHistoryPreviews(v->richTexts,visible,32,HistoryRichTextBudget, + [](const std::string &s) { return s.capacity(); }); if(repaint) InvalidateRect(list,&changed,FALSE); return 0; } @@ -875,14 +883,23 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp) return 0; } case WM_CLOSE: + { + v->rememberedSelection = selected(w, v); + int top = (int)SendDlgItemMessageW(w,102,LB_GETTOPINDEX,0,0); + v->rememberedTop = top >= 0 && top < (int)v->items.size() ? v->items[top].id : L""; + KillTimer(w, 1); + v->closed = true; + ++v->generation; // Discard search/preview results queued before closing. ShowWindow(w, SW_HIDE); + SendDlgItemMessageW(w,102,LB_RESETCONTENT,0,0); + std::vector().swap(v->items); v->thumbnails.clear(); v->richTexts.clear(); if (v->rich) SetWindowTextW(v->rich, L""); v->pending.clear(); - ++v->generation; return 0; + } case WM_NCDESTROY: disposeFont(w); v->app->historyWindow = nullptr; diff --git a/src/update.h b/src/update.h index 8e5fb7b..833c7d1 100644 --- a/src/update.h +++ b/src/update.h @@ -2,7 +2,7 @@ #include "platform.h" namespace ks { -inline constexpr wchar_t AppVersion[] = L"0.6.34"; +inline constexpr wchar_t AppVersion[] = L"0.6.35"; inline constexpr UINT UpdateMessage = WM_APP + 7; inline constexpr UINT UpdateCheckIntervalMs = 6 * 60 * 60 * 1000; inline constexpr UINT UpdateNotificationRetryMs = 5 * 60 * 1000; diff --git a/tests/dictionary.cpp b/tests/dictionary.cpp new file mode 100644 index 0000000..f4cae90 --- /dev/null +++ b/tests/dictionary.cpp @@ -0,0 +1,85 @@ +#include "autocorrect.h" +#include +#include +#include +#include +#include +#include +namespace ks { +struct AutoCorrectorRegressionAccess { + static int rank(const AutoCorrector &c,const std::wstring &lang,const std::wstring &word) { + return c.dictionaries.at(lang)->rank(word); + } + static std::vector ranks(const std::filesystem::path &path,const std::vector &words) { + AutoCorrector::Dictionary d(path); + std::vector values;for(const auto &word:words)values.push_back(d.rank(word));return values; + } +}; +} +int main(int argc,char **argv) { + try { + auto start=std::chrono::steady_clock::now(); + ks::AutoCorrector c;c.configure(L"dictionaries",{L"en",L"uk",L"ru"}); + PROCESS_MEMORY_COUNTERS_EX m{}; + GetProcessMemoryInfo(GetCurrentProcess(),reinterpret_cast(&m),sizeof(m)); + std::cout<<"dictionary_bytes="< expected; + for(std::string line;std::getline(input,line);) { + auto tab=line.find('\t');auto word=ks::wide(line.substr(0,tab));auto rank=std::stoi(line.substr(tab+1)); + auto [it,added]=expected.emplace(word,rank);if(!added)it->second=std::min(it->second,rank); + } + if(expected.empty())throw std::runtime_error("Missing benchmark dictionary"); + for(auto &[word,rank]:expected) { + if(ks::AutoCorrectorRegressionAccess::rank(c,lang,word)!=rank)throw std::runtime_error("Dictionary rank differs from source"); + if(ks::AutoCorrectorRegressionAccess::rank(c,lang,word+L"~")!=0)throw std::runtime_error("False dictionary hit"); + queries.push_back({lang,word,rank});queries.push_back({lang,word+L"~",0}); + } + } + std::mt19937 random(42);std::shuffle(queries.begin(),queries.end(),random); + uint64_t checksum=0,expected=0; + for(auto &q:queries)expected+=q.rank; + start=std::chrono::steady_clock::now(); + for(int pass=0;pass<5;++pass)for(auto &q:queries)checksum+=ks::AutoCorrectorRegressionAccess::rank(c,q.language,q.word); + auto ms=std::chrono::duration(std::chrono::steady_clock::now()-start).count(); + if(checksum!=expected*5)throw std::runtime_error("Lookup checksum mismatch"); + std::cout<<"verified_words="< words; + std::vector expectedRanks; + for(int i=129;i>=0;--i) { + auto word=L"prefix_"+std::to_wstring(i); + text+=ks::utf8(word)+"\t"+std::to_string(i+1)+"\n"; + words.push_back(word);expectedRanks.push_back(i+1); + } + text+=std::string(160,'x')+"\t2147483647"; // Maximum length/rank, no final newline. + words.insert(words.end(),{std::wstring(160,L'x'),L"DUPLICATE",L"",L"prefix_",L"zzzz"}); + expectedRanks.insert(expectedRanks.end(),{2147483647,2,0,0,0}); + for(auto rank:{65534,65535,65536}) { + auto word=std::wstring(159,L'x')+wchar_t(L'y'+rank-65534); + text+="\n"+ks::utf8(word)+"\t"+std::to_string(rank); + words.push_back(word);expectedRanks.push_back(rank); + } + put(text); + if(ks::AutoCorrectorRegressionAccess::ranks(fixture,words)!=expectedRanks) + throw std::runtime_error("Block boundaries, duplicate ranks or maximum values failed"); + for(const auto &invalid:std::vector{"","missing-tab","x\t0","x\t-1","x\t2147483648",std::string(161,'x')+"\t1","\t1","x\t1bad"}) { + put(invalid);bool rejected=false; + try {ks::AutoCorrectorRegressionAccess::ranks(fixture,{L"x"});}catch(const std::runtime_error &){rejected=true;} + if(!rejected)throw std::runtime_error("Invalid dictionary was accepted"); + } + const bool baseline=argc==2 && std::string(argv[1])=="--baseline"; + if(!baseline && c.memoryBytes()>=1536*1024)throw std::runtime_error("Bundled dictionaries exceed compact memory budget"); + std::cout<<"Passed complete dictionary equivalence and format regressions\n"; + return 0; + }catch(const std::exception&e){std::cerr<at=100; + a.releaseIdleMemory(120100); + if (!a.last) return false; + a.busy=true; + a.releaseIdleMemory(120101); + if (!a.last) { a.busy=false; return false; } + a.busy=false; + a.releaseIdleMemory(120101); + return !a.last; + } + static bool releasedSync(const App &a) { + return a.syncSnapshot.capacity()==0 && a.syncResult.settings.capacity()==0 && + a.syncResult.base.capacity()==0 && a.syncResult.conflicts.capacity()==0; + } + static bool completedSync(App &a, int mode) { + sampleConflicts(a); + auto conflicts=encodeSyncConflicts(a.pendingSyncConflicts); + a.syncConnection=loadSyncConfig(a.data); + a.syncSnapshot=encodeSettings(a.settings); + a.syncResult={mode!=1,sharedSyncSettings(a.settings),2,L"test"}; + a.syncResult.base=a.syncResult.settings; + a.syncResult.conflicts=a.pendingSyncConflicts; + if(mode==2) a.syncResult.settings={1,2,3}; // Decode exception after joining. + a.syncWorker=std::thread([]{}); + a.syncRunning=true; a.syncDone=true; a.busy=true; + a.pollSync(); + bool retained=!a.syncSnapshot.empty() && a.syncRunning; + a.busy=false; a.pollSync(); + return retained && releasedSync(a) && !a.syncRunning && + encodeSyncConflicts(a.pendingSyncConflicts)==conflicts; + } static inline bool delivery = true; static inline int notifications = 0; static bool notify(const std::wstring &) { ++notifications; return delivery; } @@ -44,6 +76,7 @@ struct InputRegressionAccess { a.syncRunning=true; a.syncDone=true; a.pollSync(); return encodeSettings(a.settings)==before && !a.syncRunning && + releasedSync(a) && !std::filesystem::exists(a.data/L"sync-base.bin"); } static bool syncBackoff(App &a) { @@ -791,6 +824,10 @@ int main(int argc, char **argv) { require(IsWindowEnabled(app.settingsWindow),"closing sync restores parent"); require(ks::InputRegressionAccess::staleSync(app,false),"in-flight sync cannot overwrite newer local edits"); require(ks::InputRegressionAccess::staleSync(app,true),"disconnect discards in-flight downloaded profile"); + require(ks::InputRegressionAccess::idleUndo(app),"idle cleanup retains available/busy Undo and frees expired Undo"); + for(int mode=0;mode<3;++mode) + require(ks::InputRegressionAccess::completedSync(app,mode), + "completed, failed and invalid sync release buffers but preserve conflict choices"); require(ks::InputRegressionAccess::syncBackoff(app),"saving settings preserves authentication error backoff"); SendMessageW(app.settingsWindow,WM_COMMAND,255,0); auto autoOptions=FindWindowW(L"KSwitcher.AutoOptions",nullptr); @@ -902,6 +939,25 @@ int main(int argc, char **argv) { SetDlgItemTextW(history,101,L""); require(pumpUntil(2),"clearing search restores history"); require(GetFocus()==originalFocus,"history search preserves focus"); + SendDlgItemMessageW(history,102,LB_SETCURSEL,1,0); + ks::refreshHistory(app); // A result may still be in flight when closing. + SendMessageW(history,WM_CLOSE,0,0); + SendMessageW(history,WM_TIMER,1,0); // KillTimer cannot retract a posted timer message. + require(pumpUntil(0),"closing history releases list strings"); + auto until=GetTickCount64()+250; + while(GetTickCount64()