twisla/roro9stack
Public Access
1
0
Fork 0
Code Issues 48 Pull Requests Actions Packages Releases 16 Activity

Gemini: read big pages from the card as you scroll (Q88)

Browse Source 
A page larger than memory allows is now windowed instead of cut: one
pass over its file (cache or Saved Page) counts lines, indexes every
64th (offset, and the preformatted state there in bit 31: about 1 KB
for a 1 MB page) and loads the first window. Scrolling near either end
reads the next or previous window on the Gemini task; the line on top
of the screen stays put, the scrollbar follows the whole page, and Tab
at a window's edge pages on instead of wrapping. Window budgets count
the memory the old window gives back.

Display pages alternate between two cache files so the one on screen
is never overwritten by the next fetch; jobs use a third.

On the device, Cosmos with IRC connected: 226 of 419 lines at first,
then lines 192-419, back to 64 and 0 while scrolling. `key space` added
to the console's key command.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EhqxQ49eCju4CzKYNjZzwT
This commit is contained in:
twisla
2026-10-05 01:44:01 +02:00
co-authored by Claude Opus 5.5
parent fd306d5013
commit 9ca9a16de8
6 changed files with 259 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/apps/gemini_app.cpp
+72 -7
View File
@@ -96,9 +96,18 @@ void GeminiApp::navigate(const std::string& target, bool remember, bool preferSa
void GeminiApp::show(GeminiPage&& page) {
page_ = std::move(page);
windowLoading_ = false;
analyse();
topRow_ = hscroll_ = 0;
selected_ = -1;
}
void GeminiApp::analyse() {
types_.clear();
links_.clear();
bool pre = false;
// A window may start inside a preformatted block: the index says (bit 31).
size_t entry = page_.windowStart / GeminiService::kIndexEvery;
bool pre = page_.windowed && entry < page_.lineIndex.size() && (page_.lineIndex[entry] & 0x80000000u);
for (size_t i = 0; i < page_.text.lineCount(); i++) {
LineType t = parseGemLine(page_.text.line(i), pre).type;
if (page_.header.mimeType() != "text/gemini") t = LineType::Preformatted; // other text/*: as is
@@ -106,14 +115,41 @@ void GeminiApp::show(GeminiPage&& page) {
if (t == LineType::Link) links_.push_back(i);
}
layoutDirty_ = true;
topRow_ = hscroll_ = 0;
selected_ = -1;
requestRedraw();
}
size_t GeminiApp::topLine() const {
if (firstRow_.size() < 2) return page_.windowStart;
size_t i = std::upper_bound(firstRow_.begin(), firstRow_.end() - 1, static_cast<uint32_t>(topRow_)) - firstRow_.begin();
return page_.windowStart + (i > 0 ? i - 1 : 0);
}
void GeminiApp::requestWindow(size_t firstLine) {
if (windowLoading_ || !gemini_.loadWindow(page_, firstLine)) return;
windowLoading_ = true;
keepLine_ = static_cast<long>(topLine());
status_ = "Reading from the card...";
statusMs_ = millis();
}
// A new window of the same page: same URL, history and position, other lines.
void GeminiApp::applyWindow(GeminiPage&& window) {
windowLoading_ = false;
status_.clear();
page_.text = std::move(window.text);
page_.windowStart = window.windowStart;
page_.lineIndex = std::move(window.lineIndex);
selected_ = -1;
analyse();
}
void GeminiApp::update(uint32_t nowMs) {
GeminiPage result;
if (gemini_.takeResult(result)) {
bool got = gemini_.takeResult(result);
if (got && !result.windowOf.empty()) {
windowLoading_ = false;
if (result.windowOf == page_.backing) applyWindow(std::move(result)); // else: we've moved on
} else if (got) {
loading_ = false;
std::string url = result.url;
switch (result.outcome) {
@@ -222,11 +258,30 @@ void GeminiApp::layout(Canvas& c) {
void GeminiApp::scrollTo(int row) {
int total = firstRow_.empty() ? 0 : static_cast<int>(firstRow_.back());
// A windowed page: near either end of the window, read the next part from the card. The new
// window starts a block before the line on top, so what's on screen stays.
const size_t block = GeminiService::kIndexEvery;
if (row + rowsOnScreen() > total - 2 && moreBelow()) {
size_t line = topLine();
requestWindow(line >= block ? line - line % block : 0);
} else if (row < 0 && moreAbove()) {
size_t line = topLine();
size_t back = page_.text.lineCount() / 2; // about half a window above
requestWindow(line > back ? line - back : 0);
}
topRow_ = std::max(0, std::min(row, std::max(0, total - rowsOnScreen())));
requestRedraw();
}
void GeminiApp::selectLink(int direction) {
// A windowed page: past the window's last (or first) link, page on instead of wrapping.
int last = static_cast<int>(links_.size()) - 1;
if ((direction > 0 && moreBelow() && (links_.empty() || selected_ == last)) ||
(direction < 0 && moreAbove() && (links_.empty() || selected_ == 0))) {
selected_ = -1;
scrollTo(topRow_ + direction * (rowsOnScreen() - 1));
return;
}
if (links_.empty()) return;
int count = static_cast<int>(links_.size());
if (selected_ < 0) {
@@ -371,6 +426,11 @@ void GeminiApp::draw(Canvas& c) {
scrollTo(restoreRow_);
restoreRow_ = -1;
}
if (keepLine_ >= 0 && !windowLoading_) { // a new window: back to the line that was on top
long local = keepLine_ - static_cast<long>(page_.windowStart);
if (local >= 0 && local < static_cast<long>(page_.text.lineCount())) topRow_ = firstRow_[local];
keepLine_ = -1;
}
}
// The URL bar: what's shown, or what's loading, or a passing message.
@@ -404,10 +464,15 @@ void GeminiApp::draw(Canvas& c) {
c.drawString(("Cut short: " + page_.truncatedWhy).substr(0, 47).c_str(), kMargin,
y0 + (row - topRow_) * theme::kLineHeight + 2);
}
// Scroll position, on the right edge.
// Scroll position, on the right edge: over the whole page, also when only a window is in memory.
int total = static_cast<int>(firstRow_.back());
if (total > rows) {
int h = area.h - kUrlBar, barH = std::max(6, h * rows / total);
int h = area.h - kUrlBar;
if (page_.windowed && page_.totalLines > 0) {
int barH = std::max(6, static_cast<int>(h * page_.text.lineCount() / page_.totalLines / 3));
int y = static_cast<int>((h - barH) * topLine() / std::max<size_t>(1, page_.totalLines - 1));
c.fillRect(area.w - 2, y0 + y, 2, barH, theme::kMuted);
} else if (total > rows) {
int barH = std::max(6, h * rows / total);
c.fillRect(area.w - 2, y0 + (h - barH) * topRow_ / std::max(1, total - rows), 2, barH, theme::kMuted);
}