Public Access
twislaandClaude Opus 5.5
b7aed8e91c
The Storage App browses the SD card: folders first with sizes and dates, three sorts, one item at a time with a clipboard (c, x, v), rename, delete after counting what's inside, new folder, details. A listing holds 256 entries and says when a folder has more. FileOps does the card's work for the App and the console alike, one operation at a time on the storage task in turns of about 150 ms, so Logs and Captures are still written during a long copy. A copy shows progress, can be cancelled (what it wrote is taken back) and compares sizes after. The read-only rules are checked there: the firmware's top-level folders, /gemini/cache, and files being written (a Track, a Capture, an upload, today's IRC Logs). A listing reads the folder straight from FatFs: through the Arduino File, 329 entries took over two seconds. Viewers by type: text read a screen at a time whatever the file's size (logs open at the end), a hex dump, a Capture's packets as the LoRa Scanner lists them, a Track's summary, and an Update File checked as an install would check it, without writing anything. Tab shows any file as hex or text. Settings > Storage is gone: usage, Storage Clean-up and Erase are the App's Maintenance, behind a warning. The Storage Warning points there. The Clock sets the system time whatever its source, so files are dated correctly with a GNSS Fix alone (Q137). Console: cp, mv, mkdir, du, cancel; rm takes folders and follows the rules; ls shows dates; Debug Builds get `sd fill`. 424 host tests. Checked on the device: docs/milestones/F1.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EhqxQ49eCju4CzKYNjZzwT
51 lines
1.8 KiB
C++
51 lines
1.8 KiB
C++
#pragma once
|
|
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace roro::files {
|
|
|
|
// A text file of any size, shown a screen at a time (F1, Q134): only the part on screen is read,
|
|
// through `read`, about a kilobyte at once. Lines wrap at spaces, `cols` characters wide. Going
|
|
// back a line means finding where the paragraph before started and wrapping it again, so a file
|
|
// reads the same whichever way it was scrolled.
|
|
class TextPager {
|
|
public:
|
|
// Reads up to `len` bytes at `offset`; returns how many it got.
|
|
using ReadAt = std::function<size_t(uint32_t offset, uint8_t* into, size_t len)>;
|
|
|
|
TextPager(ReadAt read, uint32_t size, int cols, int rows);
|
|
|
|
void toStart() { top_ = 0; }
|
|
void toEnd(); // the last line at the bottom of the screen
|
|
void down(int lines = 1);
|
|
void up(int lines = 1);
|
|
|
|
std::vector<std::string> lines(); // what's on screen: tabs as spaces, control characters as dots
|
|
uint32_t top() const { return top_; }
|
|
uint32_t size() const { return size_; }
|
|
bool atEnd(); // the file's last line is on screen
|
|
int percent() const { return size_ ? static_cast<int>(static_cast<uint64_t>(top_) * 100 / size_) : 0; }
|
|
|
|
private:
|
|
static constexpr size_t kBlock = 1024; // read at once
|
|
static constexpr uint32_t kLookBack = 1024; // how far back a paragraph's start is looked for
|
|
|
|
const uint8_t* bytes(uint32_t at, size_t& len); // what's cached from `at` on
|
|
int byteAt(uint32_t at); // -1 past the end
|
|
uint32_t nextLine(uint32_t at, std::string* text); // where the line after the one at `at` starts
|
|
uint32_t lineBefore(uint32_t at);
|
|
|
|
ReadAt read_;
|
|
uint32_t size_;
|
|
int cols_, rows_;
|
|
uint32_t top_ = 0;
|
|
std::vector<uint8_t> cache_;
|
|
uint32_t cacheAt_ = 0;
|
|
};
|
|
|
|
} // namespace roro::files
|