c/app/filedlg.c · 32884 字节 · 下载原文
/* filedlg.c —— 常用小程序⑨：**打开一个文件看它的头几行**（第 4 层：`ui_*` 图形界面）
* filedlg.c -- Everyday utility #9: **open a file and read its first lines** (layer 4: the `ui_*` interface)
*
* 干什么：一屏一个按钮。「选择文件」走 `ui_dlg_file_open`，拿到的是一个**沙箱相对路径**
* What it does: one button. "Choose a file" goes through `ui_dlg_file_open`, which hands back a
* （返回**字节数**，0 = 取消 / 没权限 / 这一端没有文件选择器），然后用 `fopen`/`fread` 把它读进一块
* **sandbox-relative path** (the return value is the **byte count**; 0 = cancelled / no permission /
* 扁平缓冲，显示**前若干行**与**文件大小**。
* this end has no file picker). The file is then read into one flat buffer with `fopen`/`fread`, and
* the first few lines plus the **file size** are shown.
*
* ## ⚠ 手机上才有 —— 桌面（vmlcli）上「没有文件选择器」才是**正确输出**
* ## ⚠ Phone-only -- on the desktop (vmlcli) "no file picker" is the **correct output**
*
* 桌面脚手架是**无头进程**：没有 GUI 可以弹选择框，`ui_dlg_file_open` 一律返回 0。
* The desktop scaffold is a **headless process**: there is no GUI to open a picker, so
* 而 **0 不是错误** —— 用户点了取消、没给权限、这一端没有该能力，三者都是 0，程序照常继续。
* `ui_dlg_file_open` always returns 0. That **0 is not an error**: a cancel, a missing permission and
* 所以降级分支要**明说**是"这一端没有"，而不是留一块空白。
* a missing capability all look alike, and the program carries on. The degraded branch therefore
* **says** that this end lacks it instead of leaving a blank area.
*
* ## 桌面怎么看到"选了文件"那一半：宿主自带的输入脚本注入，**不用改一行源码**
* ## Seeing the picked-file branch on the desktop: the host's input-script injection, **no source change**
*
* printf '0 file calendar.c\n300 keydown 13\n360 keyup 13\n' > in.txt
* vmlcli filedlg.c --vml-home third_party/vml --input in.txt --timeout 40 --frame filedlg.png
*
* 第一条把"选择器返回的路径"喂给宿主（`CliVmlHost.InjectFile`），后两条**按一下按钮**（回车 13），
* The first line feeds the host the path a picker would return (`CliVmlHost.InjectFile`); the other two
* 于是那个文件真的被读出来、头几行真的被画在屏幕上 —— 换一个路径就是另一份内容。
* press the button (virtual key 13 = Enter), so the file really is read and its first lines really are
* drawn -- with another path you get another file.
*
* ## 踩到的坑（都是这一轮真撞上的，写在这里省得下一个人再撞）
* ## Pitfalls (all hit for real while writing this file; recorded so the next person does not)
*
* ① ⚠ **`fopen` 的第二个参数是 `int`（0 只读），不是 `"r"`** —— `Lib/shared/src/file.c` 的签名是
* ① ⚠ **`fopen`'s second argument is an `int` (0 = read), not `"r"`** -- the signature in
* `int fopen(const char *path, int mode)`，而 `stdio.h` 里声明的却是 `FILE* fopen(const char*,
* `Lib/shared/src/file.c` is `int fopen(const char *path, int mode)`, while `stdio.h` declares
* const char*)`。照 `stdio.h` 写 `fopen(p, "r")`，模式收到一个**指针值**，`#110` 回
* `FILE* fopen(const char*, const char*)`. Writing `fopen(p, "r")` per the header hands a **pointer**
* `-2`（`INVALID_PARAMETER`）**且一个字都不报**（实测）。所以本文件**不 include `stdio.h`**、
* to the mode and `#110` answers `-2` (`INVALID_PARAMETER`) **with no message at all** (measured).
* 自己按真签名声明 —— 顺带避开 `fgets`（那个函数在库里面**没有实现**，链上去会报未定义）。
* This file therefore declares the real signatures itself, which also avoids `fgets` (it has **no
* implementation** in the library and would fail to link).
* ② ✅ **文件大小现在直接用 `Lib/c/file.h` 的 `fsize(handle)`**（2026-10-07 起）：那个包装原先
* ② ✅ **File size now uses `fsize(handle)` from `Lib/c/file.h`** (since 2026-10-07): the wrapper used
* 只是把 `#114` 原样转发、**没把命令号填进寄存器**（实测读到的是垃圾），现已修好 ——
* to forward `#114` without putting the command number in R1 (measured as garbage); it is fixed now —
* 判据见 `Examples/c/test/file_api.c`（逐项核对数值，且注入反证过）。
* criterion: `Examples/c/test/file_api.c` (value-by-value, with a counter-check by injection).
* ③ ⚠ **文件级标量别用负值初值**（本仓刚归档的 E187）：`static int x = -1;` 读到的是 **0**。
* ③ ⚠ **Never give a file-scope scalar a negative initializer** (this repo's E187): `static int x = -1;`
* 所以下面所有哨兵量一律用**正数**（0 = 没有/未知，1 = 有），别拿 -1 当"还没有"。
* reads back as **0**. Every sentinel below is a **positive** number (0 = absent/unknown, 1 = present).
* ④ ⚠ **切行是"原地改字"**：`\n` 换成 `0` 之后，`buf` 同时是"整个文件"和"每行一个串"，
* ④ ⚠ **Splitting lines rewrites the buffer in place**: after every `\n` becomes `0`, one buffer is
* 省掉一整张行表（本仓不许二维数组 / 指针数组）。代价是**切完就回不去了** ——
* both the whole file and a list of strings, with no line table at all (this repo forbids 2-D and
* `\n` 数一遍要放在切之前（见 `splitLines`）。
* pointer arrays). The price is that the split is destructive, so the line count must be taken
* **before** it (see `splitLines`).
* ⑤ ⚠ **"这一端没有"每拍都要重问一次**（与 `level.c` 坑 ② 同源）：`--input` 的事件由另一个线程按
* ⑤ ⚠ **"This end has it" must be re-asked every tick** (same as pitfall 2 in `level.c`): the `--input`
* 时刻投递，程序可能在注入落地之前就点过按钮了。所以按钮**一直可点**，点一次问一次。
* events arrive from another thread on a timer, so the button may be pressed before the injection
* lands. The button therefore stays live and every press asks again.
* ⑥ ⚠ **裁行要裁"拷出来的那一份"，绝不能就地写 0**（这一版第一稿就是这么错的，看图才发现）：
* ⑥ ⚠ **Clip a copy, never write a `0` into the line itself** (the first draft did, and only the
* 太长的行就地截断之后，`lineAt` 从那个 0 往后走会拿到**上一行的尾巴** —— 屏幕上是"从第 2 行起
* picture showed it): once a long line is truncated in place, `lineAt` walks past that `0` and hands
* 每行都串位、后半截是一排空框"（那半截是 UTF-8 的残字节，一个字节画一个空框）。
* back the **tail of the previous line**, so from the second row on every line is shifted and its
* ⇒ 判据：**"行内容串位"+"空框"同时出现**，就是这条。
* second half is a row of empty boxes (each box is one leftover UTF-8 byte). The signature to look
* for is shifted content **and** empty boxes at the same time.
* ⑦ ⚠ **宽度按列数算，不按字符数**：一个汉字占 2 列（3 个字节），按"字符数"截会把 CJK 行切成
* ⑦ ⚠ **Width is counted in columns, not characters**: a CJK glyph is two columns (three bytes), so
* 两倍宽、右边顶出画布。`copyLine` 里按"首字节算 2、续字节算 0"数（见 `weather.c` 的 tty 80 列那条）。
* counting characters makes a CJK line twice as wide and it runs off the canvas. `copyLine` counts
* two for a lead byte and zero for a continuation (the same idea as the 80-column rule in `weather.c`).
* ⑧ ⚠ **截断不许把多字节字符切成半个字节**，而且后果比"最后一个字画错"严重得多：宿主读字符串时
* ⑧ ⚠ **Never cut a multibyte character in half**, and the damage is far worse than one wrong glyph:
* 先验 UTF-8（`VmlHostRuntime.Str`），**整条不合法就整条按 CP437 解** —— 于是**整行**变成乱码
* the host validates UTF-8 first (`VmlHostRuntime.Str`) and decodes the **whole** string as CP437
* （实测：末尾留了个光秃秃的 `E4`，`退出` 那行整行变成 `ΘÇÇσç║`，而它前面的 ASCII 一点事没有，
* when it is invalid, so the **entire line** turns to mojibake (measured: one bare trailing `E4`
* 看着像"这一行的中文坏了"）。
* turned one Chinese word into mojibake while the ASCII around it stayed fine). `copyLine` therefore
* ⇒ `copyLine` 收尾时把末尾那个**不完整的多字节序列整个丢掉**（先回退续字节，再看首字节要求的
* gives back any **incomplete trailing sequence** (back off the continuations, then check how many
* 字节数够不够）。
* bytes the lead byte asked for).
* ⚠ 这个收尾**自己也能写错**（第一版就错了）：判据必须是"**留下的**字节够不够"。
* ⚠ That give-back **has a bug of its own** (the first version had it): the test must ask whether the
* 拿"回退了几次"当字节数，会把一个**完整**的三字节字符砍成光秃秃的首字节，症状与前一条一模一样，
* **kept** bytes are enough. Using "how many times did I back off" instead chops a complete 3-byte
* 而原因正好相反（那次是**砍坏了一个好字符**）。所以两个量要分成两个变量：
* glyph down to a bare lead byte -- same symptom, opposite cause (a good character destroyed).
* `cut` 只用来**找**首字节，`tail` 才是"留下多少"（描述，不引原字，免得这行自己也算中文注释）。
* Two variables, then: `cut` only locates the lead byte, and `tail` is how much we keep.
*
* 版面：尺寸一律从宿主问（`ui_scr_get_w()/_h()`），颜色是真彩 `0xAARRGGBB`，画完必须 `ui_2d_present()`。
* Layout: every size is asked of the host (`ui_scr_get_w()/_h()`), colours are true colour
* 循环**必须有界**（例程要能被自动验收）：空闲 10 秒自己退出，`Esc`/`q` 也退出。
* `0xAARRGGBB`, and the frame must end with `ui_2d_present()`. The loop **must be bounded** (samples
* 写真正的程序时把 `IDLE_EXIT_MS` 去掉即可。
* have to be automatically verifiable): it exits after 10 s of idling, and `Esc`/`q` quits too.
*/
#include <vml_ui.h>
#include <stdlib.h> /* itoa --- digits to text via the library */
#include <file.h> /* fopen 家族的真声明（`int mode`）+ `fsize` —— 本文件不再自己抄一遍 */
#define IDLE_EXIT_MS 10000 /* 空闲 10 秒自己退出（验收用） */
/* idle exit after 10 s (for automated checks) */
#define PATH_CAP 200 /* 宿主写回来的路径缓冲区 */
/* the buffer the host writes the path into */
#define READ_CAP 4096 /* 一次读进多少字节（扁平缓冲，一次读够） */
/* how many bytes we read at once (one flat buffer) */
#define BTN_H 44
#define LINE_H 18 /* 正文行高（字号 13 配 18 不挤） */
/* body line height (font 13 fits comfortably in 18) */
/* ⚠ 这里原先**自己声明** `fopen` 家族（因为 `stdio.h` 的签名是错的、`file.h` 也对不上）。
* 2026-10-07 起 `Lib/c/file.h` 已与实现逐字对齐 ⇒ 直接 `#include <file.h>` 即可，
* 那份手抄的声明连同"不 include stdio.h 免得打架"的顾虑一起删掉。
* These declarations used to be hand-copied because both `stdio.h` and `file.h` disagreed with the
* implementation. Since 2026-10-07 `Lib/c/file.h` matches it verbatim, so `#include <file.h>` does. */
/* 配色（真彩 AA RRGGBB）*/
/* Colours (true colour AA RRGGBB) */
#define C_BG 0xFF0E1218
#define C_BOX 0xFF161B24
#define C_RING 0xFF3C4658
#define C_TITLE 0xFFE8E8F0
#define C_DIM 0xFF8A94A8
#define C_ERR 0xFFFF8A80 /* 没有这项能力 / 读不出来 */
/* capability absent, or unreadable */
#define C_NAME 0xFF6FC3FF /* 文件名 */
/* the file name */
#define C_SIZE 0xFFFFD166 /* 文件大小 */
/* the file size */
#define C_CODE 0xFFB8C4D8 /* 正文那几行 */
/* the body lines */
#define C_BTN 0xFF233046
#define C_BTNHOT 0xFF2F4060
/* ── 全局状态 ───────────────────────────────────────────────────────── */
/* -- Global state -- */
static int SW;
static int SH;
static int g_pad;
static int lang;
static char g_path[PATH_CAP]; /* 宿主写回来的路径（空串 = 还没选）*/
/* the path the host wrote back (empty = nothing chosen yet) */
static char g_buf[READ_CAP]; /* **唯一**的那块缓冲：先是整个文件，切完行就是每行一个串 */
/* the **one** buffer: the whole file first, then one string per line */
static int g_len; /* 真读进来多少字节 */
/* how many bytes were really read */
static int g_lines; /* 缓冲里有几行（切之前数的）*/
/* how many lines the buffer holds (counted before splitting) */
static int g_truncated; /* 1 = 文件比缓冲大，只读了一部分 */
/* 1 = the file is larger than the buffer, so only part was read */
static int g_size; /* 文件大小（字节；0 = 不知道）*/
/* the file size in bytes (0 = unknown) */
static int g_open; /* 1 = 手上有内容可画 */
/* 1 = we hold content to draw */
static int g_missing; /* 1 = 这一端**没有**文件选择器（上一次的结果）*/
/* 1 = this end **has no** file picker (last attempt's result) */
static int g_unreadable; /* 1 = 选了但读不出来 */
/* 1 = chosen but unreadable */
static int g_asked; /* 1 = 至少点过一次按钮 */
/* 1 = the button has been pressed at least once */
/* 版面（画与命中判定**必须用同一份**）*/
/* Layout (drawing and hit testing **must share this one copy**) */
static int boxX;
static int boxY;
static int boxW;
static int boxH;
static int btnX;
static int btnY;
static int btnW;
static int btnH;
static int infoY;
/* ── 系统调用：文件大小 ─────────────────────────────────────────────── */
/* -- Syscall: the file size -- */
/* ⚠ 这里原先手写了一次 `#114 FileControl(handle, 0, 0)`（取文件大小），因为当时库里那个
* `fsize` **没有把命令号填进寄存器**（实测读到垃圾，见文件头坑 ②）。
* 2026-10-07 那个包装已修好（`Lib/shared/src/file.c`，判据 `Examples/c/test/file_api.c`）
* ⇒ 这里改用 `#include <file.h>` 带来的 `fsize(handle)`。
* This used to hand-roll `#114 FileControl(handle, 0, 0)` because the library's `fsize` never put the
* command number into R1 (measuring as garbage). That wrapper was fixed on 2026-10-07, so `fsize` is used. */
/* ── 小工具 ─────────────────────────────────────────────────────────── */
/* -- Small helpers -- */
static char g_i10[16];
static char *numstr(int v) {
itoa(v, g_i10);
return g_i10;
}
static char g_base[64];
static char *baseName(void) {
int i;
int last;
int n;
last = -1;
i = 0;
while (g_path[i] != 0) {
if (g_path[i] == '/') last = i;
i = i + 1;
}
n = 0;
i = last + 1;
while (g_path[i] != 0 && n < 40) { g_base[n] = g_path[i]; i = i + 1; n = n + 1; }
g_base[n] = 0;
return g_base;
}
/* 原地切行：`\n` → `0`，顺手把 `\r` 也抹掉（CRLF 文件的每行末尾会多一个回车，
* Split lines in place: `\n` becomes `0` and `\r` is stripped too (a CRLF file leaves a carriage
* 留着的话行尾会多画一个看不见的方块）。返回实际切成几行。
* return at the end of every line, which renders as a stray box). Returns how many lines were cut.
*/
static int splitLines(char *s, int len) {
int i;
int n;
int start;
n = 0;
start = 0;
for (i = 0; i < len; i++) {
if (s[i] == '\n') {
if (i > start && s[i - 1] == '\r') s[i - 1] = 0;
s[i] = 0;
n = n + 1;
start = i + 1;
}
}
if (len > start) { s[len] = 0; n = n + 1; } /* 最后一行没有换行收尾 */
/* the last line has no trailing newline */
return n;
}
/* 第 n 行（切完之后用）—— 一维缓冲里"往前走 n 个 0"就是第 n 行，不需要行表。
* Line n (after splitting) -- walking past n zero bytes in the flat buffer is all it takes; no line table.
* 扫不到就返回空串（调用方按空行处理）。
* Returns an empty string when it runs out (the caller treats that as a blank line).
*/
static char *lineAt(char *s, int len, int n) {
int i;
int k;
i = 0;
k = 0;
while (k < n) {
while (i < len && s[i] != 0) i = i + 1;
if (i >= len) return s + len;
i = i + 1;
k = k + 1;
}
return s + i;
}
/* 把一行按**显示宽度**拷进 `g_line`（`maxCols` 是列数上限；半角 1 列、全角 2 列）。
* Copy one line into `g_line`, bounded by a **display width** (`maxCols`; half-width glyphs are one
* ⚠ **绝不就地裁剪**（裁的是 `g_buf` 里那一行本身）—— 见文件头坑 ⑥：就地写 0 会把"下一行的起点"
* column and full-width ones are two). **Never clip in place** (never touch the line inside `g_buf`):
* 一起切断，`lineAt` 从那个 0 往后走，拿到的是**上一行的尾巴**，屏幕上表现为"每行都串位、
* see pitfall 6 -- writing a `0` there also cuts off where the next line starts, so `lineAt` walks past
* 后半截还都是空框"（实测就是这一版）。
* it and hands back the **tail of the previous line**, which shows up as shifted lines whose second
* half is a row of empty boxes.
* ⚠ 回退过**续字节**（UTF-8 的 `10xxxxxx`）：切在汉字中间会留半个字符，画出来是一个空框
* ⚠ Back off over **continuation bytes** (`10xxxxxx` in UTF-8): cutting inside a CJK glyph leaves half
* （一个汉字 3 个字节，第 2、3 个都带这个前缀，所以整个字必须吐回去）。
* a character, which renders as an empty box (a CJK glyph is 3 bytes and the 2nd and 3rd both carry
* that prefix, so the whole glyph is given back).
*/
static char g_line[160];
static void copyLine(char *s, int maxCols) {
int i;
int n;
int w;
int cw;
int cut;
int tail;
int need;
int b;
i = 0;
n = 0;
w = 0;
while (s[i] != 0 && n < 150) {
cw = 1;
if ((s[i] & 0x80) != 0) {
cw = ((s[i] & 0xC0) == 0xC0) ? 2 : 0; /* 多字节**首字节**算两列；续字节不另算 */
/* a multibyte **lead** byte is two columns; continuations add nothing */
}
if (cw > 0 && w + cw > maxCols) break;
g_line[n] = s[i];
i = i + 1;
n = n + 1;
w = w + cw;
}
/* ⚠ **收尾必须吐回"半个字"**（见坑 ⑧）：宿主读字符串时先验 UTF-8，**不合法就整条按 CP437 解**
* ⚠ **The tail must give back a half-cut glyph** (pitfall 8): the host validates UTF-8 first and
* ⇒ 末尾留一个光秃秃的**首字节**（`E4` 后面没有续字节），不只是最后一个字画错，
* decodes the **whole string** as CP437 when it is invalid, so a lone **lead byte** at the end
* 而是**整行变成一串乱码**（实测那两个汉字变成四个拉丁字母加符号）。
* (`E4` with its continuations missing) does not just spoil the last glyph: the entire line turns
* into mojibake (measured: two Chinese glyphs became four Latin letters and symbols).
*/
tail = n;
cut = n; /* cut 只用来**找**最后一个字符的首字节，别拿它当"留下多少" */
/* cut only **locates** the last character's lead byte; it is not "how much we keep" */
while (cut > 0 && (g_line[cut - 1] & 0xC0) == 0x80) cut = cut - 1;
if (cut > 0) {
b = g_line[cut - 1] & 0xFF;
need = 1;
if (b >= 0xF0) need = 4;
else if (b >= 0xE0) need = 3;
else if (b >= 0xC0) need = 2;
/* ⚠ 判据是"**留下**的字节够不够"（`n - (cut - 1)` 才是这个字符的字节数）——
* ⚠ The test is whether **the kept bytes** are enough (`n - (cut - 1)` is the character's byte
* 写错成"cut 减了几次"会**把好字符砍掉**：实测 `E2 80 87`（三个字节都齐）被砍成单个 `E2`
* count); getting it wrong **chops a good character**: measured, a complete `E2 80 87` was cut
* ⇒ 整行退化成乱码（见坑 ⑧）。
* down to a bare `E2` and the whole line turned to mojibake (pitfall 8).
*/
if (n - (cut - 1) < need) tail = cut - 1;
}
g_line[tail] = 0;
}
/* ── 选文件并读进来 ─────────────────────────────────────────────────── */
/* -- Choosing a file and reading it in -- */
static void openFile(void) {
int n;
int h;
g_asked = 1;
g_open = 0;
g_missing = 0;
g_unreadable = 0;
g_len = 0;
g_lines = 0;
g_truncated = 0;
g_size = 0;
n = ui_dlg_file_open(g_path, PATH_CAP);
if (n <= 0) {
/* ⚠ **降级分支**：0 = 取消 / 没权限 / 这一端没有选择器，三者不区分（接口就是这么定的）。 */
/* ⚠ **The degraded branch**: 0 means cancelled / no permission / no picker here, and the API
* 界面上按"这一端没有"来说 —— 桌面上确实如此，手机上是用户自己取消。
* does not tell them apart. The UI words it as "this end lacks it", which is exactly the
* desktop's case and reads as a user cancel on the phone. */
g_missing = 1;
g_path[0] = 0;
return;
}
g_path[n] = 0;
h = fopen(g_path, 0);
if (h < 0) {
g_unreadable = 1;
return;
}
g_size = fsize(h); /* ⚠ 读之前先问大小（读完句柄位置就变了）*/
/* ⚠ Ask for the size before reading (reading moves the handle) */
g_len = fread(h, g_buf, READ_CAP - 1);
fclose(h);
if (g_len < 0) g_len = 0;
if (g_len >= READ_CAP - 1) g_truncated = 1;
g_buf[g_len] = 0;
/* ⚠ **切完就回不去了**：所以行数由 `splitLines` 自己数着返回（切之前数一遍也一样，
* ⚠ **The split is destructive**, so `splitLines` counts as it goes (counting beforehand would
* 只是别在切之后再去数一遍 —— 那时缓冲里已经没有 `\n` 了）。
* be equivalent; counting afterwards would find no `\n` left at all).
*/
g_lines = splitLines(g_buf, g_len);
g_open = 1;
}
/* ── 版面 ───────────────────────────────────────────────────────────── */
/* -- Layout -- */
static void layout(void) {
SW = ui_scr_get_w();
SH = ui_scr_get_h();
if (SW <= 0) SW = 360;
if (SH <= 0) SH = 620;
g_pad = SW / 18;
if (g_pad < 10) g_pad = 10;
btnH = BTN_H;
btnW = SW - g_pad * 2;
if (btnW > 280) btnW = 280;
btnX = (SW - btnW) / 2;
btnY = SH - g_pad - btnH;
infoY = btnY - 44; /* 按钮之上两行：文件名 / 大小 */
/* two lines above the button: name / size */
boxX = g_pad;
boxY = g_pad + 42;
boxW = SW - g_pad * 2;
boxH = infoY - boxY - 10;
if (boxH < 80) boxH = 80;
}
/* 正文区能放下几行（**画与"还有多少行没显示"用同一个数**）*/
/* How many body lines fit (the **same number** drives drawing and the "lines left over" note) */
static int maxBodyLines(void) {
int n;
n = (boxH - 20) / LINE_H;
if (n < 1) n = 1;
return n;
}
/* ── 绘制 ───────────────────────────────────────────────────────────── */
/* -- Drawing -- */
static void drawBody(void) {
int i;
int n;
int y;
int maxCols;
char *ln;
char buf[64];
if (g_open == 0) return;
maxCols = (boxW - 24) / 7; /* 字号 13：半角约 7px 一列 ⇒ 列数 = 可用宽 / 7 */
/* font 13: about 7 px per half-width column, so columns = width / 7 */
if (maxCols < 8) maxCols = 8;
n = maxBodyLines();
y = boxY + 12;
for (i = 0; i < n; i++) {
if (i >= g_lines) break;
ln = lineAt(g_buf, g_len, i);
copyLine(ln, maxCols); /* ⚠ **拷出来裁**，不碰 `g_buf` 里的那一行（见坑 ⑥）*/
/* ⚠ Clip **a copy**, never the line inside `g_buf` (pitfall 6) */
if (g_line[0] != 0) ui_2d_text(boxX + 12, y, g_line, C_CODE, 13, VML_ANCHOR_LEFT);
y = y + LINE_H;
}
if (g_lines > n) {
buf[0] = 0;
strcat(buf, lang == 0 ? "还有 " : "and ");
strcat(buf, numstr(g_lines - n));
strcat(buf, lang == 0 ? " 行没显示" : " more lines below");
ui_2d_text(boxX + 12, boxY + boxH - 20, buf, C_DIM, 11, VML_ANCHOR_LEFT);
}
}
static void drawEmpty(void) {
int cy;
cy = boxY + boxH / 2;
if (g_missing != 0) {
ui_2d_text(SW / 2, cy - 24, lang == 0 ? "没有选到文件" : "no file chosen",
C_ERR, 17, VML_ANCHOR_CENTER);
ui_2d_text(SW / 2, cy + 2, lang == 0 ? "（本机没有文件选择器；桌面上返回 0）"
: "(this device has no file picker; the desktop returns 0)",
C_ERR, 12, VML_ANCHOR_CENTER);
ui_2d_text(SW / 2, cy + 26, lang == 0 ? "0 不是错误：照常继续跑" : "0 is not an error: carry on",
C_DIM, 11, VML_ANCHOR_CENTER);
return;
}
if (g_unreadable != 0) {
ui_2d_text(SW / 2, cy - 18, lang == 0 ? "选了，但读不出来" : "chosen, but unreadable",
C_ERR, 17, VML_ANCHOR_CENTER);
ui_2d_text(SW / 2, cy + 8, lang == 0 ? "（文件不存在，或路径落在沙箱之外）"
: "(missing, or the path is outside the sandbox)",
C_DIM, 12, VML_ANCHOR_CENTER);
return;
}
ui_2d_text(SW / 2, cy - 18, lang == 0 ? "点下面的按钮选一个文件" : "press the button to choose a file",
C_DIM, 15, VML_ANCHOR_CENTER);
ui_2d_text(SW / 2, cy + 8, lang == 0 ? "会显示它的头几行与文件大小" : "its first lines and its size will show",
C_DIM, 12, VML_ANCHOR_CENTER);
}
static void drawInfo(void) {
char buf[96];
if (g_open == 0) return;
buf[0] = 0;
strcat(buf, lang == 0 ? "文件：" : "file: ");
strcat(buf, baseName());
ui_2d_text(SW / 2, infoY, buf, C_NAME, 13, VML_ANCHOR_CENTER);
buf[0] = 0;
if (g_truncated != 0) {
strcat(buf, numstr(g_len));
strcat(buf, lang == 0 ? " 字节（只读了开头这些）" : " bytes (only the first part was read)");
} else {
strcat(buf, numstr(g_size));
strcat(buf, lang == 0 ? " 字节 / " : " bytes / ");
strcat(buf, numstr(g_lines));
strcat(buf, lang == 0 ? " 行" : " lines");
}
ui_2d_text(SW / 2, infoY + 20, buf, C_SIZE, 12, VML_ANCHOR_CENTER);
}
static void draw(void) {
ui_2d_clear(C_BG);
ui_2d_text_styled(SW / 2, g_pad, lang == 0 ? "文件选择" : "File dialog",
C_TITLE, 18, VML_ANCHOR_CENTER, VML_FONT_BOLD);
if (g_open != 0) {
ui_2d_text(SW / 2, g_pad + 24, lang == 0 ? "fread 读进一块扁平缓冲，原地切行" : "one flat buffer, split in place",
C_DIM, 11, VML_ANCHOR_CENTER);
} else {
ui_2d_text(SW / 2, g_pad + 24, lang == 0 ? "手机上才有选择器；桌面上会如实报「没有」"
: "phones have the picker; the desktop reports \"absent\"",
C_DIM, 11, VML_ANCHOR_CENTER);
}
ui_2d_rect(boxX, boxY, boxW, boxH, C_BOX, 1, 0, 8);
ui_2d_rect(boxX, boxY, boxW, boxH, C_RING, 0, 1, 8);
if (g_open != 0) drawBody();
else drawEmpty();
drawInfo();
ui_2d_rect(btnX, btnY, btnW, btnH, C_BTN, 1, 0, btnH / 2);
ui_2d_rect(btnX, btnY, btnW, btnH, C_BTNHOT, 0, 1, btnH / 2);
ui_2d_text(SW / 2, btnY + (btnH - 15) / 2,
lang == 0 ? "选择文件 Enter" : "Choose a file Enter",
C_TITLE, 15, VML_ANCHOR_CENTER);
ui_2d_text(SW / 2, SH - 14, lang == 0 ? "回车 / 点按钮选中 Esc / q 退出"
: "Enter or tap to choose Esc / q quits",
C_DIM, 11, VML_ANCHOR_CENTER);
ui_2d_present(); /* ⚠ 不调这句 = 黑屏 */
/* without this call you get a black screen */
}
/* 点在选择按钮里吗（与 `draw` 用的是**同一组**坐标）*/
/* Did the tap land on the choose button (the **same** geometry `draw` uses) */
static int hitButton(int px, int py) {
if (px >= btnX && px < btnX + btnW && py >= btnY && py < btnY + btnH) return 1;
return 0;
}
/* ── 主流程 ─────────────────────────────────────────────────────────── */
/* -- Main flow -- */
int main(void) {
int msg[4];
int t;
int t0;
int done;
lang = ui_scr_get_language();
layout();
ui_win_open_ex(lang == 0 ? "文件选择" : "File dialog",
0, 0, VML_WIN_ROTATABLE, VML_WIN_NO_GAMEPAD);
layout(); /* 开窗之后画布尺寸才是准的，再算一次 */
/* the canvas size is only final after the window opens */
draw();
t0 = ui_time_get_ms();
done = 0;
while (!done && ui_win_is_closed() == 0) {
t = ui_msg_wait(msg, 200);
if (t == VML_MSG_NONE) {
if (ui_time_get_ms() - t0 > IDLE_EXIT_MS) done = 1;
continue;
}
t0 = ui_time_get_ms();
if (t == VML_MSG_KEYDOWN) {
int k = msg[1];
if (k == VML_KEY_ESCAPE || k == 'q' || k == 'Q') done = 1;
else if (k == VML_KEY_ENTER || k == VML_KEY_SPACE) { openFile(); draw(); }
continue;
}
if (t == VML_MSG_TOUCHDOWN || t == VML_MSG_MOUSEDOWN) {
if (hitButton(msg[1], msg[2]) != 0) { openFile(); draw(); }
continue;
}
if (t == VML_MSG_WINDOWORIENT || t == VML_MSG_WINDOWRESIZE) {
layout();
draw();
continue;
}
if (t == VML_MSG_WINDOWCLOSE) done = 1;
}
return 0;
}