hrynco/hrynco-kswitcher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 55 Wiki Activity

Release v0.6.35: reduce resident memory and compact shared dictionaries

Browse Source
This commit is contained in:
Anatolii Hrynchuk
2026-11-04 14:08:05 +02:00
parent 004fee4976
commit d13e9849a7
21 changed files with 469 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/app.cpp
+15 -4
View File
@@ -1,4 +1,5 @@
#include "app.h"
#include <utility>
#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;
}
src/app.h
+1
View File
@@ -86,6 +86,7 @@ class App
private:
friend struct InputRegressionAccess;
void releaseIdleMemory(ULONGLONG now);
HHOOK keyboardHook{}, mouseHook{};
std::mutex jobsMutex;
std::condition_variable jobsReady;
src/app_sync.inl
+14 -11
View File
@@ -46,7 +46,7 @@ std::wstring App::syncCommand(int action, const std::vector<SyncChoice> &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)
{
src/autocorrect.cpp
+122 -44
View File
@@ -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<unsigned char>(bytes[start++]) & 15;
if (length == 15) length = static_cast<unsigned char>(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<const char *>(raw.data()), raw.size());
std::vector<uint32_t> 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<uint32_t>(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<uint32_t>(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<uint32_t>(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<char>((std::min(prefix, size_t(15)) << 4) | std::min(suffix, size_t(15))));
if (prefix >= 15) bytes.push_back(static_cast<char>(prefix));
if (suffix >= 15) bytes.push_back(static_cast<char>(suffix));
bytes.append(current.substr(prefix));
auto rank = static_cast<uint32_t>(frequency(lines[i]));
auto shortRank = std::min(rank, uint32_t(65535));
bytes.push_back(static_cast<char>(shortRank & 255));
bytes.push_back(static_cast<char>(shortRank >> 8));
if (rank >= 65535)
do {
auto next = rank & 127;
rank >>= 7;
bytes.push_back(static_cast<char>(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<unsigned char>(bytes[at++]);
size_t prefix = lengths >> 4, suffix = lengths & 15;
if (prefix == 15) prefix = static_cast<unsigned char>(bytes[at++]);
if (suffix == 15) suffix = static_cast<unsigned char>(bytes[at++]);
memcpy(decoded + prefix, bytes.data() + at, suffix);
at += suffix;
uint32_t rank = static_cast<unsigned char>(bytes[at]) |
(uint32_t(static_cast<unsigned char>(bytes[at + 1])) << 8);
at += 2;
if (rank == 65535) {
rank = 0;
uint32_t shift = 0;
unsigned char part;
do {
part = static_cast<unsigned char>(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<int>(rank);
if (compared > 0) return 0;
}
return 0;
}
void AutoCorrector::configure(const std::filesystem::path &folder, const std::vector<std::wstring> &wanted)
{
if (languages == wanted)
return;
std::map<std::wstring, Dictionary> next;
std::map<std::wstring, std::shared_ptr<const Dictionary>> 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<const Dictionary>(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<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed, int source,
@@ -191,7 +269,7 @@ std::optional<AutoSuggestion> 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<AutoSuggestion> candidate;
std::optional<std::wstring> matchedText;
@@ -211,7 +289,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 = 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<AutoSuggestion> 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;
src/autocorrect.h
+9 -1
View File
@@ -1,6 +1,7 @@
#pragma once
#include "platform.h"
#include <map>
#include <memory>
#include <set>
#include <string_view>
namespace ks
@@ -18,23 +19,30 @@ int matchAutoInput(const Run &, const std::wstring &, const std::vector<Layout>
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<uint32_t> offsets;
std::string_view word(size_t) const;
explicit Dictionary(const std::filesystem::path &);
int rank(const std::wstring &) const;
};
std::map<std::wstring, Dictionary> dictionaries;
std::map<std::wstring, std::shared_ptr<const Dictionary>> dictionaries;
std::vector<std::wstring> languages;
std::set<std::wstring> rejected;
public:
void configure(const std::filesystem::path &, const std::vector<std::wstring> &);
// Share immutable dictionary storage, keeping each consumer's undo rejections private.
void shareDictionaries(const AutoCorrector &);
std::optional<AutoSuggestion> suggest(const std::wstring &, int source, const std::vector<Layout> &,
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
src/history_preview.h
+17 -3
View File
@@ -4,14 +4,28 @@
#include <string>
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<class T, class Weight>
void trimHistoryPreviews(std::map<std::wstring,T> &cache,
const std::set<std::wstring> &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<class T>
void trimHistoryPreviews(std::map<std::wstring,T> &cache,
const std::set<std::wstring> &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{}; });
}
}
src/ocr.cpp
+11 -6
View File
@@ -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<IWICImagingFactory> wic;
check(CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory,
(void **)wic.out()));
Com<IWICStream> 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<BYTE *>(input->data()), (DWORD)input->size()));
Com<IWICBitmapDecoder> decoder;
check(wic->CreateDecoderFromStream(stream.p, nullptr, WICDecodeMetadataCacheOnLoad, decoder.out()));
Com<IWICBitmapFrameDecode> frame;
src/platform.cpp
+17 -2
View File
@@ -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 {};
src/platform.h
+2
View File
@@ -72,10 +72,12 @@ class DiagnosticBuffer
{
std::deque<std::pair<ULONGLONG, std::wstring>> 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);
src/ui.cpp
+20 -3
View File
@@ -479,12 +479,14 @@ struct HistoryView
{
App *app{};
std::vector<Entry> items;
std::wstring rememberedSelection, rememberedTop;
uint64_t generation{};
std::map<std::wstring, Pixels> thumbnails;
std::map<std::wstring, std::string> richTexts;
HWND rich{};
std::set<std::wstring> pending;
bool scrolling{};
bool 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<Entry>().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;
src/update.h
+1 -1
View File
@@ -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;