c/app/notepad.c · 34601 字节 · 下载原文
/* notepad.c —— 常用小程序④：**记事本**（第 4 层：`ui_*` 图形界面）
* notepad.c -- Everyday utility #4: a **notepad** (layer 4: the `ui_*` graphical interface)
*
* 一扇窗口里的纯文本编辑器：**打字 / 退格 / 回车换行 / 光标可见**，`Esc` **保存并退出**，
* A plain text editor in one window: **type, backspace, Enter for a new line, a visible caret**, `Esc`
* 下次运行把上次的内容读回来。同一份源码在手机上（点屏幕 + 软键盘）与桌面上（物理键盘）都跑。
* **saves and quits**, and the next run reads the last session back. One source file runs on the phone
* (touch + soft keyboard) and on the desktop (a physical keyboard) alike.
*
* ## 怎么编辑
* ## How to edit
*
* · 可打印 ASCII（32~126）插到**光标处**；`退格`(8) 删前一个字符；`回车`(13) 换行。
* · Printable ASCII (32-126) goes in **at the caret**; Backspace (8) deletes one character; Enter (13)
* starts a new line.
* · `←`/`→` 挪光标；`Esc`(27) = **保存并退出**。
* · Left/Right move the caret; `Esc` (27) = **save and quit**.
* · 空闲 10 秒也退出，且**走同一条收尾**（见下面第 ⑤ 条）。
* · Ten idle seconds quits too, through **the very same exit path** (pitfall 5 below).
*
* ## 存到哪
* ## Where it saves
*
* **相对路径 `note.txt`** —— 手机上沙箱根 = 工作区（绝对路径会被拒）。
* **The relative path `note.txt`** -- on the phone the sandbox root is the workspace, and absolute
* 桌面上落在**源文件所在目录**（`vmlcli` 按 `WorkDir` 解析）。
* paths are rejected; on the desktop it lands in the **directory of the source file** (`vmlcli`
* derives `WorkDir`).
* 跑法（桌面脚手架，秒级）：
* How to run (desktop scaffolding, seconds):
* dotnet scripts/vmlcli/bin/Release/net10.0/vmlcli.dll Examples/c/app/notepad.c --vml-home third_party/vml
* 手机上在命令行页里敲：
* On the phone, type this in the command-line page:
* vml run examples/c/app/notepad.c
*
* ## 踩过的坑（实测）
* ## Pitfalls (measured in this repo)
*
* ① **打开模式写反 = 把文件清空**：`#110` 的 `mode=1` 是 `FileMode.Create`（**先截断再写**）。
* ① **Swapping the open modes wipes the file**: `#110` with `mode=1` means `FileMode.Create`, which
* **truncates first**.
* 所以"想读内容却传了 1"读到的是**空串**。
* So "meant to read, passed 1" hands back an **empty string**.
* 读=0、写=1，两个常量**各写一次、别共用**。
* Read = 0, write = 1, each written once and never shared.
*
* ② **正文不能"一个字节画一格"**：UTF-8 里一个汉字是 3 个字节。
* ② **The body must not be drawn "one byte per cell"**: one CJK glyph is 3 bytes in UTF-8.
* 实测：逐字节画出来是 `τ □ □ Σ …` 这样一排盒子；**按码点切**才对。
* Measured: drawing byte by byte came out as a row of `τ □ □ Σ` boxes; cutting by **code point**
* (`utf8_len` + `cell_width`) is what works.
*
* ③ **"一格放得下吗"只有一处判据**：画正文与定位光标若各写一套换行规则，就会出现
* ③ **"Does it fit in a cell" has exactly one judge**: two copies of the wrap rule, one for drawing
* "光标停在行尾、字却掉到下一行行首"。
* and one for the caret, produce "the caret sits at the line end while the character lands at the
* start of the next line".
* 共用 `cell_fit`。
* Both go through `cell_fit`.
*
* ④ **回车就是缓冲里的字节 `10`**：`VML_KEY_ENTER` 要自己变成 `10` 再存盘。
* ④ **Enter is nothing but the byte 10 in the buffer**: `VML_KEY_ENTER` has to become a `10` before
* the save.
* 忘了这一步，屏幕上看着换行了、存到文件里的却是一行（下次读回来全挤在一起）。
* Skip it and the screen breaks the line while the file keeps one long line (the next run reads it
* back all run together).
*
* ⑤ **收尾只有一处**：`Esc` / 空闲 10 秒 / 关窗三条路都从循环**之后**那一段出去。
* ⑤ **A single exit**: `Esc`, ten idle seconds and the window's close arrow all leave through the one
* place **after** the loop.
* 把保存写进 `Esc` 那一支 = 另外两条路**悄悄丢内容**。
* Putting the save inside the `Esc` arm would silently lose the text on the other two.
* 本仓 `E169`「谁发起的，就要能被同一处停掉」的同族。
* It is the same family as this repo's `E169`, "whoever starts it must be stoppable in one place".
*
* ⑥ **`ui_2d_text` 的 `y` 是基线，不是"字盒的顶"**：墨迹落在 `y` 的**上方**。
* ⑥ **`ui_2d_text`'s `y` is the baseline, not the top of the glyph box**: the ink sits **above** it.
* 实测（字号 16、`y=58`）：拉丁字母的墨迹在 48..57、汉字在 47..59。
* Measured (size 16, `y=58`): the Latin ink is at 48..57 and the CJK ink at 47..59.
* 按"y 是盒顶"去画光标，光标就落在**自己那一行的下面**（看着像"光标跳到了下一行"）。
* Draw the caret assuming "y is the top" and it lands **below its own line** (it reads as if the
* caret had jumped a line -- measured).
* 纸面也得往上多让一点，不然第一行会顶着框；见 `draw` 里的 `ink`。
* The sheet needs that headroom too, or the first line touches the frame; see `ink` in `draw`.
*
* ⑦ **读进来的 `\r` 要清掉**：本程序写的是 LF。
* ⑦ **Strip the `\r` on the way in**: this program writes LF.
* 但**别人的**文件（Windows 记事本、Git 的 `core.autocrlf`）是 CRLF。
* But files from **someone else** (Windows Notepad, Git's `core.autocrlf`) are CRLF.
* `\r` **看不见，却按"一个字"占掉一格**：实测 CRLF 文件被算成 "18 字"、原样存回 20 字节。
* A `\r` **is invisible yet takes one cell**: measured, a CRLF file counts as "18 characters" and
* saves back as 20 bytes.
* 清掉后是 "16 字" / 18 字节；`ab\r\ncd` 上光标停在 `ab` 右边**一格空位**（见 `strip_cr`）。
* After stripping it is "16 characters" / 18 bytes; on `ab\r\ncd` the caret sits **one empty cell**
* right of `ab` (see `strip_cr`).
*
* ⑧ **`VML_KEY_LEFT/UP/RIGHT/DOWN` = 37/38/39/40，全都落在"可打印 ASCII 32..126"里**。
* ⑧ **`VML_KEY_LEFT/UP/RIGHT/DOWN` are 37/38/39/40, all inside "printable ASCII 32..126".**
* 所以**先判可打印**就会把方向键当成字符插进去：实测连按三下左箭头，正文里多了 3 个 `%`。
* So testing the printable range first types the arrow key in as a character: measured, three Left
* presses left three `%` in the text.
* 而光标一步没动 —— 判 `VML_MSG_KEYDOWN` 时**特殊键一律排在可打印区间之前**。
* The caret did not move at all -- so when handling `VML_MSG_KEYDOWN`, **special keys always come
* before the printable range**.
*
* ## 界面文字跟着宿主语言走
* ## The on-screen text follows the host language
*
* `ui_scr_get_language()`（与 `demo_ui.c`/`calendar.c` 同一套做法）。
* `ui_scr_get_language()`, exactly as `demo_ui.c`/`calendar.c` do it.
*/
#include <vml_ui.h>
#include <stdlib.h> /* itoa --- digits to text via the library */
#include <file.h> /* fopen 家族（真签名 `int mode`）—— 本文件不再自己包汇编 */
#define IDLE_EXIT_MS 10000 /* 空闲这么久就自己退出（例程要能被自动验收）*/
/* Idle this long and it quits (samples must be automatically verifiable). */
#define NOTE_CAP 2048 /* 正文缓冲容量（字节）*/
/* Text buffer capacity (bytes) */
#define NOTE_FILE "note.txt" /* ⚠ 相对路径 */
/* ⚠ A relative path */
/* 配色（真彩 AARRGGBB，第 4 层没有索引色）*/
/* Colours (true colour AARRGGBB; layer 4 has no palette) */
#define C_BG 0xFF101018 /* 窗口底 */
/* window background */
#define C_PAPER 0xFF1A1A24 /* 正文"纸"面 */
/* the sheet the text sits on */
#define C_TITLE 0xFFE8E8F0
#define C_TEXT 0xFFD8DCE8
#define C_DIM 0xFF9AA0B0
#define C_CUR 0xFFFFC64A /* 光标（黄色竖条）*/
/* the caret (a yellow bar) */
#define C_HINT 0xFF7A8090
/* ⚠ 这里原先有一层手写的 `sys_*` 包装（`asm("SYSCALL #110…")` + 全局 `_sysret` 中转）。
* 2026-10-07 起改调库：`#include <file.h>` 带来的 `fopen`/`fread`/`fwrite`/`fclose`
* **返回值就是 syscall 的返回值**，不再需要 `_sysret` 这个中转站。
* The hand-rolled `sys_*` wrappers are gone: the library functions (via `#include <file.h>`) return the
* syscall result directly, so the `_sysret` relay is unnecessary. */
/* ── 正文模型：**一维扁平缓冲** ─────────────────────────────────────── */
/* -- The text model: **one flat buffer** --
* ⚠ 不用二维数组、不用"指针数组"、不取数组元素的地址（`&arr[i]`）—— 这几样在本仓的多语言
* ⚠ No 2-D arrays, no arrays of pointers, no address-of on an array element (`&arr[i]`): those three are
* 前端之间最不稳（例程是要照着移植到 22 门语言的），一律一维 + 扁平下标。
* the least portable forms across this repo's front ends (the samples get ported to 22 languages), so
* everything is one-dimensional with flat indexes. */
char nbuf[NOTE_CAP]; /* 正文；**不保证以 0 结尾**（长度看 `blen`）*/
/* The text; **not guaranteed NUL-terminated** (the length is `blen`). */
int blen = 0; /* 已用字节数 */
/* bytes in use */
int tcur = 0; /* 光标：字节下标 0..blen */
/* caret: a byte index 0..blen */
int tloaded = 0; /* 启动时有没有读到文件（1=读到了）*/
/* whether the file was read at startup */
/* ── 版式（**一律从宿主给的尺寸算**，别写死坐标）───────────────────── */
/* -- Layout (**always computed from the host size**, never hard-coded) -- */
static int SW;
static int SH;
static int lang; /* 0 = 中文，1 = English */
/* 0 = Chinese, 1 = English */
static int g_pad; /* 页边距 */
/* page margin */
static int g_fs; /* 正文字号 */
/* body font size */
static int g_cw; /* **一格的宽**（不是"字体量的宽"）*/
/* the **cell width** (not a measured glyph width) */
static int g_lh; /* 一行的高 */
/* line height */
static int g_x0; /* 正文区左上角 */
/* body origin */
static int g_y0;
static int g_cols; /* 每行几格 */
/* cells per line */
static int g_rows; /* 一屏几行 */
/* lines per screen */
static int g_top; /* 滚到第几个显示行（**光标的显示行**决定它）*/
/* first visible display row */
/* 整数 → 十进制串（`ui_2d_text` 只收字符串，第 4 层没有 `print_int` 那种东西）
* Integer to a decimal string (`ui_2d_text` takes strings only; layer 4 has no `print_int`).
* ⚠ 返回的是**同一个静态缓冲**：别在一个表达式里连着用两次（那要用两次就先 `strcat` 到自己串上）。
* ⚠ It returns **one static buffer**: never use it twice inside a single expression. */
static char numbuf[16];
static char *numstr(int v) {
itoa(v, numbuf);
return numbuf;
}
/* 这个字节起头是几个字节的 UTF-8 序列（认不出按 1 算）/ How many bytes the UTF-8 sequence starting
* here is (unrecognized counts as 1). */
static int utf8_len(int lead) {
if (lead < 0x80) return 1;
if ((lead & 0xE0) == 0xC0) return 2;
if ((lead & 0xF0) == 0xE0) return 3;
if ((lead & 0xF8) == 0xF0) return 4;
return 1;
}
/* 这个字占几格：ASCII 与 2 字节的拉丁扩展各 1 格，CJK/emoji（3、4 字节）占 2 格 —— 全角。
* How many cells this character takes: ASCII and the 2-byte Latin blocks take 1, CJK/emoji (3- and
* 4-byte) take 2 -- they are full width. */
static int cell_width(int lead) {
if (lead < 0x80) return 1;
if ((lead & 0xE0) == 0xC0) return 1;
return 2;
}
/* 从 `*pr` 行的 `*pc` 格放一个占 `w` 格的字：放不下就**软换行**到下一行行首。
* Put one character that takes `w` cells at row `*pr`, column `*pc`: if it does not fit, **soft-wrap**
* to the start of the next row.
* ⚠ **画正文与定位光标必须共用这一处** —— 各写一套，光标就会"停在行尾而字掉到下一行"（见文件头 ③）。
* ⚠ **Drawing and the caret must share this one place** -- two copies and the caret "sits at the end of
* the line while the character lands at the start of the next" (pitfall 3 in the file header). */
static void cell_fit(int *pr, int *pc, int w) {
if (*pc + w > g_cols) { *pr = *pr + 1; *pc = 0; }
}
/* 光标所在的**显示行/列**（走一遍正文得到；`\n` 与软换行都算）
* The **display row/column** of the caret (found by walking the text; `\n` and soft wraps both count). */
static void cursor_rc(int idx, int *orow, int *ocol) {
int r = 0;
int c = 0;
int i = 0;
int ch;
int n;
while (i < idx) {
ch = nbuf[i] & 0xFF;
if (ch == 10) { r = r + 1; c = 0; i = i + 1; continue; }
n = utf8_len(ch);
if (i + n > blen) n = 1; /* 缓冲尾上只剩半个序列（不该发生）*/
/* half a sequence at the tail */
cell_fit(&r, &c, cell_width(ch));
c = c + cell_width(ch);
i = i + n;
}
/* 正好落在一行末尾那一格之外 ⇒ 按下一行行首算 —— 这与"再打一个字会被放到哪儿"是同一个判据 */
/* Exactly past the last cell of a row means the next row's start -- the same judge as "where would
* the next character go". */
cell_fit(&r, &c, 1);
*orow = r;
*ocol = c;
}
/* 行数与字数（只给标题栏看）*/
/* Line and character counts (for the title bar only) */
static int count_lines(void) {
int i;
int n = 1;
for (i = 0; i < blen; i++) if ((nbuf[i] & 0xFF) == 10) n = n + 1;
return n;
}
static int count_chars(void) {
int i = 0;
int n = 0;
int ch;
while (i < blen) {
ch = nbuf[i] & 0xFF;
i = i + utf8_len(ch);
if (ch != 10) n = n + 1; /* 换行不算"字" */
/* a line break is not a "character" */
}
return n;
}
static void layout(void) {
int usable;
int body;
SW = ui_scr_get_w();
SH = ui_scr_get_h();
if (SW <= 0) SW = 480; /* 宿主答不上来时的兜底（开窗也会用同一对数）*/
if (SH <= 0) SH = 640; /* fallback when the host cannot answer (the same pair opens the window) */
g_pad = SW / 20;
if (g_pad < 8) g_pad = 8;
g_fs = SW / 30; /* 字号随宽度走：手机窄屏小一点，桌面大一点 */
if (g_fs < 11) g_fs = 11; /* The font follows the width: smaller on a narrow phone, larger on the desktop. */
if (g_fs > 17) g_fs = 17;
g_cw = g_fs + 2; /* 一格宽 = 字高 + 2px 字距 */
/* one cell = the font height plus 2px of tracking */
g_lh = g_fs + 7; /* 行高（比字高大一半行距，多行看着才不挤）*/
/* line height */
g_y0 = g_pad + 34; /* 标题栏占掉上面一条 */
/* the title bar takes the strip above */
usable = SW - g_pad * 2;
g_cols = usable / g_cw;
if (g_cols < 8) g_cols = 8;
if (g_cols > 40) g_cols = 40; /* 宽窗口下别把一行拉得太长 */
/* do not stretch one line forever on a wide window */
g_x0 = (SW - g_cols * g_cw) / 2; /* 整块水平居中 */
/* centre the block horizontally */
if (g_x0 < g_pad) g_x0 = g_pad;
body = SH - g_pad - 46 - g_y0; /* 底下给两行提示留位置 */
/* two hint lines get the bottom strip */
if (body < g_lh * 3) body = g_lh * 3;
g_rows = body / g_lh;
if (g_rows < 1) g_rows = 1;
}
static void draw(void) {
int crow;
int ccol;
int r;
int c;
int i;
int n;
int w;
int ch;
int y;
int k;
int bar;
int ink;
int ptop;
int pbot;
char u[8];
char tb[64];
/* ① 先算光标在哪一格 —— 滚动要照着它来，所以**必须在画之前**算好 */
/* ① Work out the caret cell **before drawing**: scrolling follows it. */
cursor_rc(tcur, &crow, &ccol);
g_top = 0;
if (crow >= g_rows) g_top = crow - g_rows + 1;
ui_2d_clear(C_BG);
/* ② 标题栏：左边文件名，右边行数 / 字数 */
/* ② Title bar: the file name on the left, line and character counts on the right. */
ui_2d_text_styled(g_pad, g_pad, NOTE_FILE, C_TITLE, g_fs + 3, VML_ANCHOR_LEFT, VML_FONT_BOLD);
tb[0] = 0;
strcat(tb, numstr(count_lines()));
strcat(tb, lang == 0 ? " 行 · " : " lines · ");
strcat(tb, numstr(count_chars()));
strcat(tb, lang == 0 ? " 字" : " chars");
ui_2d_text(SW - g_pad, g_pad + 4, tb, C_DIM, g_fs - 2, VML_ANCHOR_RIGHT);
/* ③ 正文：一块"纸"+ 逐字上格
* ③ The body: a sheet of "paper" plus one character per cell. */
/* ⚠ `ui_2d_text` 给的 y **不是"字盒的顶"而是贴着基线**（实测：字号 16、y=58 时，
* ⚠ The y given to `ui_2d_text` is **not the top of the glyph box but the baseline** (measured:
* 拉丁字母的墨迹在 48..57、汉字在 47..59 —— 都在 y 的**上方**）。
* at size 16 with y=58 the Latin ink sits at 48..57 and CJK ink at 47..59, both **above** y).
* 所以纸面要按"墨迹高出多少"往上让，光标也要跟着往上抬 —— 不然光标会画在自己那一行的
* So the sheet and the caret both have to account for that overhang; otherwise the caret is drawn
* 自己那一行的下面（看着像"光标跳到了下一行"，实测过）。
* below its own line (it reads as if the caret had jumped a line -- measured). */
ink = (g_fs * 3) / 4; /* 墨迹高出 y 的量（字号 16 ⇒ 12）*/
/* the overhang (size 16 => 12) */
ptop = g_y0 - ink - 5;
pbot = g_y0 + (g_rows - 1) * g_lh + g_fs + 6;
ui_2d_rect(g_x0 - 6, ptop, g_cols * g_cw + 12, pbot - ptop, C_PAPER, 1, 0, 8);
r = 0;
c = 0;
i = 0;
while (i < blen) {
ch = nbuf[i] & 0xFF;
if (ch == 10) { r = r + 1; c = 0; i = i + 1; continue; }
/* ⚠ **按码点切，不按字节切**：一个汉字是 3 个字节，逐字节画出来就是 3 个乱码格
* ⚠ **Cut by code point, never by byte**: a CJK character is 3 bytes, so drawing byte by byte
* （实测：`第一行中文` 画成了 `τ □ □ Σ …` 这样一排盒子）。
* yields three mojibake cells (measured: a row of `τ □ □ Σ` boxes came out of it). */
n = utf8_len(ch);
if (i + n > blen) n = 1; /* 末尾只剩半个序列（不该发生）*/
/* half a sequence at the tail */
w = cell_width(ch);
cell_fit(&r, &c, w);
if (r >= g_top && r < g_top + g_rows) {
y = g_y0 + (r - g_top) * g_lh;
k = 0;
while (k < n) { u[k] = nbuf[i + k]; k = k + 1; }
u[n] = 0;
ui_2d_text(g_x0 + c * g_cw, y, u, C_TEXT, g_fs, VML_ANCHOR_LEFT);
}
c = c + w;
i = i + n;
}
/* ④ 空文档给一行欢迎语（**只是占位，不进 `nbuf`** —— 否则第一次退出就会把欢迎语
* ④ An empty document shows a welcome line (**a placeholder only, never put into `nbuf`** --
* 当成用户的内容存进 `note.txt`）。 */
/* otherwise the first exit would save the welcome line into `note.txt` as the user's text.) */
if (blen == 0) {
ui_2d_text(g_x0, g_y0, lang == 0 ? "空白笔记 —— 直接打字" : "empty note - just type",
C_DIM, g_fs, VML_ANCHOR_LEFT);
ui_2d_text(g_x0, g_y0 + g_lh, lang == 0 ? "Esc 保存并退出" : "Esc saves and quits",
C_DIM, g_fs, VML_ANCHOR_LEFT);
}
/* ⑤ 光标：一条竖条，画在**当前字符位置**上（正好在一行末尾时它会落在下一行行首）
* ⑤ The caret: a vertical bar drawn **at the current character position** (at the end of a full row
* it lands at the start of the next one). */
if (crow >= g_top && crow < g_top + g_rows) {
bar = g_fs / 6;
if (bar < 2) bar = 2;
if (bar > 4) bar = 4;
y = g_y0 + (crow - g_top) * g_lh;
ui_2d_rect(g_x0 + ccol * g_cw, y - ink + 1, bar, g_fs + 3, C_CUR, 1, 0, 0);
}
/* ⑥ 底部：操作提示 + 文件状态（第二次启动一眼能看出"上次存的内容读回来了"）*/
/* ⑥ Bottom: the controls and the file state (a second run shows at a glance that the last session
* was read back). */
ui_2d_text(g_pad, SH - g_pad - 32, lang == 0 ? "回车 换行 · 退格 删 · Esc 保存并退出"
: "Enter newline · Backspace delete · Esc save & quit",
C_HINT, g_fs - 3, VML_ANCHOR_LEFT);
tb[0] = 0;
strcat(tb, lang == 0 ? "文件 " : "file ");
strcat(tb, NOTE_FILE);
if (tloaded != 0) {
strcat(tb, lang == 0 ? " 已读取 " : " loaded ");
strcat(tb, numstr(blen));
strcat(tb, lang == 0 ? " 字节" : " bytes");
} else {
strcat(tb, lang == 0 ? " 新建（退出时写入）" : " new (written on exit)");
}
ui_2d_text(g_pad, SH - g_pad - 14, tb, C_HINT, g_fs - 3, VML_ANCHOR_LEFT);
ui_2d_present(); /* ⚠ 不调这句 = 黑屏 */
/* ⚠ without this call you get a black screen */
}
/* ── 文件（⚠ 读用 0、写用 1，见文件头 ①）─────────────────────────── */
/* -- Files (⚠ read = 0, write = 1, see pitfall 1 in the file header) -- */
/* `\r` 一律清掉：本程序自己写的是 LF，可**别人**（Windows 记事本、Git 的 `core.autocrlf`）留下的
* Drop every `\r`: this program writes LF, but files left by **someone else** (Windows Notepad, or Git's
* 文件是 CRLF。`\r` **看不见，但在这个"一个字一格"的模型里照样占掉一格** —— 数数与光标都会把它算进去
* `core.autocrlf`) are CRLF. A `\r` **is invisible yet still takes a cell in this "one character per
* （实测：CRLF 的文件被算成 "18 字"、原样存回 20 字节；`ab\r\ncd` 上光标停在 `ab` 右边一格空位）。
* cell" model** -- both the count and the caret count it (measured: a CRLF file reads as "18 characters"
* 单独的 CR（老 Mac 的换行）也算一次换行 —— 不然整份文件会挤成一行。写回去时统一成 LF。
* and saves back as 20 bytes; on `ab\r\ncd` the caret sits one empty cell right of `ab`). A lone CR (a
* classic-Mac line break) counts as a line break too, otherwise the whole file collapses onto one line.
* Writes go back out as LF only. */
static void strip_cr(void) {
int i = 0;
int o = 0;
int ch;
while (i < blen) {
ch = nbuf[i] & 0xFF;
if (ch == 13) {
if (i + 1 < blen && (nbuf[i + 1] & 0xFF) == 10) { i = i + 1; continue; } /* CRLF ⇒ 只留 LF */
/* CRLF -> keep the LF */
nbuf[o] = 10; /* 光秃秃的 CR ⇒ 当成换行 */
/* a bare CR becomes a line break */
o = o + 1;
i = i + 1;
continue;
}
nbuf[o] = nbuf[i];
o = o + 1;
i = i + 1;
}
blen = o;
}
/* 读回来。返回 1 表示读到了（`blen`/`tcur` 已就位），0 表示"没有这个文件"（保持空文档）。
* Reads it back. Returns 1 when it was read (`blen`/`tcur` are set), 0 for "no such file" (the document
* stays empty). */
static int load_file(void) {
int mode;
int fh;
int n;
mode = 0; /* 0 = 只读（FileMode.Open）—— 写成 1 会先把文件清空 */
/* 0 = read-only (FileMode.Open); a 1 here would truncate the file first */
fh = fopen(NOTE_FILE, mode);
if (fh < 0) return 0; /* 错误码是**负数**（-200 文件不存在 / -202 越界）*/
/* error codes are **negative** */
n = fread(fh, nbuf, NOTE_CAP - 1);
fclose(fh);
if (n < 0) n = 0;
blen = n;
strip_cr(); /* ⚠ 见 `strip_cr`：`\r` 看不见却占一格，光标会浮在文字右边 */
/* ⚠ See `strip_cr`: a `\r` is invisible yet takes a cell, so the caret
floats right of the text. */
nbuf[blen] = 0; /* 存盘时不用它，但调试/打印时省事 */
/* not needed for saving, handy for printing */
tcur = blen; /* 光标停在上次内容的末尾，接着往下打就是追加 */
/* The caret sits at the end, so typing continues where the user left off. */
return 1;
}
/* 写回去。返回写成功的字节数（失败返回 -1）*/
/* Writes it back. Returns the bytes written, or -1. */
static int save_file(void) {
int mode;
int fh;
int w;
mode = 1; /* 1 = 只写（FileMode.Create，**先截断**）—— 所以我们才要整份重写 */
/* 1 = write-only (FileMode.Create, **truncating**) -- hence a full rewrite */
fh = fopen(NOTE_FILE, mode);
if (fh < 0) return -1;
w = fwrite(fh, nbuf, blen);
fclose(fh);
if (w != blen) return -1;
return w;
}
/* ── 编辑 ───────────────────────────────────────────────────────────── */
/* -- Editing -- */
/* 在光标处插一个字节（可打印 ASCII 或 `\n`）。缓冲满了就**丢掉**（记事本不该因为打满而崩）。
* Inserts one byte at the caret (a printable ASCII character or `\n`). A full buffer **drops** the key
* (a notepad must not fall over when it fills up). */
static void insert_ch(int ch) {
int i;
if (blen >= NOTE_CAP - 1) return;
i = blen;
while (i > tcur) { nbuf[i] = nbuf[i - 1]; i = i - 1; }
nbuf[tcur] = (char)ch;
blen = blen + 1;
tcur = tcur + 1;
}
/* 退格：删掉光标**前一个字符**。⚠ 要跨过**整个 UTF-8 序列** —— 只退一个字节会把一个汉字
* Backspace: delete the character **before** the caret. ⚠ It has to step over the **whole UTF-8
* 劈成"前导字节 + 半个身子"，屏幕上是乱码、存盘后文件里也是坏字节（实测）。
* sequence** -- dropping one byte splits a CJK character into "lead byte + half a body", which is
* mojibake on screen and broken bytes in the file (measured). */
static void backspace(void) {
int start;
int n;
int i;
if (tcur <= 0) return;
start = tcur - 1;
while (start > 0 && ((nbuf[start] & 0xFF) & 0xC0) == 0x80) start = start - 1;
n = tcur - start;
i = start;
while (i + n < blen) { nbuf[i] = nbuf[i + n]; i = i + 1; }
blen = blen - n;
tcur = start;
}
/* 光标左移一个**字符**（不是一字节，同理）*/
/* Move the caret one **character** left (not one byte, same reason). */
static void cursor_left(void) {
int i;
if (tcur <= 0) return;
i = tcur - 1;
while (i > 0 && ((nbuf[i] & 0xFF) & 0xC0) == 0x80) i = i - 1;
tcur = i;
}
/* 光标右移一个字符 */
/* Move the caret one character right. */
static void cursor_right(void) {
int n;
if (tcur >= blen) return;
n = utf8_len(nbuf[tcur] & 0xFF);
tcur = tcur + n;
if (tcur > blen) tcur = blen;
}
/* ── 主流程 ─────────────────────────────────────────────────────────── */
/* -- Main flow -- */
int main(void) {
int msg[4];
int t;
int t0;
int done;
int k;
int wrote;
lang = ui_scr_get_language();
/* 开窗：**传 `0, 0`（= 尺寸交给宿主），开窗之后**再取一次尺寸 —— 那次才是**真实画布**
* Open the window: **pass `0, 0` (let the host size it) and take the size again after the open** -- that
* （开窗前的估算**可能不同**：桌面 = 480×640、手机竖屏 ~395×744），窗口与画布才是一套坐标系。
* is the **real canvas** (the pre-open estimate may differ: desktop 480x640, phone portrait about 395x744),
* so window and canvas share one coordinate space. */
layout();
ui_win_open_ex("notepad.c", 0, 0, VML_WIN_ROTATABLE, VML_WIN_NO_GAMEPAD);
layout();
tloaded = load_file();
if (tloaded == 0) { blen = 0; tcur = 0; } /* 没有文件 = 空文档 + 一行欢迎语（见 `draw` ④）*/
/* no file = an empty document plus a welcome line (see `draw` 4) */
print_str("[notepad] ");
print_str(NOTE_FILE);
if (tloaded != 0) {
print_str(lang == 0 ? " 读到 " : " loaded ");
print_int(blen);
print_str(lang == 0 ? " 字节\n" : " bytes\n");
} else {
print_str(lang == 0 ? " 还没有，从空文档开始（内容只能是这个程序的输入）\n"
: " not found, starting empty (content is only what you type here)\n");
}
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; /* 空闲超时（验收用）*/
/* idle timeout */
continue;
}
t0 = ui_time_get_ms();
if (t == VML_MSG_KEYDOWN) {
k = msg[1];
/* ⚠ **顺序是有讲究的：方向键那一支必须在"可打印 ASCII"之前** ——
* ⚠ **The order matters: the arrow-key arms must come before the "printable ASCII" one** --
* `VML_KEY_LEFT/UP/RIGHT/DOWN` = 37/38/39/40，**全都落在 32..126 里**，
* `VML_KEY_LEFT/UP/RIGHT/DOWN` are 37/38/39/40, **all inside 32..126**, so testing the
* 先判可打印的话，按一下左箭头会往正文里**插一个 `%`**（实测：连按三下左箭头，
* printable range first turns one Left press into **a literal `%` in the text** (measured:
* 存下来的文件里多了 3 个 `%`，光标一步没动）。
* three Left presses left three `%` in the saved file and moved the caret not at all). */
if (k == VML_KEY_ESCAPE) { /* Esc = 保存并退出（保存统一在循环外做）*/
done = 1; /* Esc = save and quit (the save happens after the loop) */
} else if (k == VML_KEY_BACKSPACE) {
backspace();
draw();
} else if (k == VML_KEY_ENTER) {
insert_ch(10); /* ⚠ 回车要变成缓冲里的 10，见文件头 ④ */
draw(); /* ⚠ Enter becomes a 10 in the buffer, see pitfall 4 */
} else if (k == VML_KEY_LEFT) {
cursor_left();
draw();
} else if (k == VML_KEY_RIGHT) {
cursor_right();
draw();
} else if (k >= 32 && k <= 126) {
insert_ch(k);
draw();
}
continue;
}
if (t == VML_MSG_WINDOWORIENT || t == VML_MSG_WINDOWRESIZE) {
layout();
draw();
continue;
}
if (t == VML_MSG_WINDOWCLOSE) done = 1;
}
/* ⚠ **收尾只有这一处**：`Esc`、空闲 10 秒、用户点了窗口的返回箭头，三条路都从这里出去。
* ⚠ **This is the only exit**: `Esc`, ten idle seconds and the window's back arrow all leave here.
* 把保存写进 `Esc` 那一支 = 另外两条路悄悄丢内容（文件头 ⑤）。
* Writing the save inside the `Esc` arm would silently lose the text on the other two (header 5). */
wrote = save_file();
print_str(lang == 0 ? "[notepad] 写入 " : "[notepad] wrote ");
print_str(NOTE_FILE);
print_str(" ");
print_int(wrote < 0 ? 0 : wrote);
print_str(lang == 0 ? " 字节，退出\n" : " bytes, quitting\n");
return 0;
}