AskaEth/Unlucky-Launcher
1
0 Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

merge: 解 origin/dev 三处冲突（M182 / M184+M190 / README §14），两边都留

Browse Source 
冲突（都来自别人后来改同一批文件）：
- crates/app-iced/src/platform/mod.rs：保留 M182 的 HostOs / host·linux·macos 分册表 /
  plan_corner_for，同时保留 M196 的 `[`win32::console`]` 落点说明；把 M182 措辞里已经不
  成立的「唯一 unsafe 落点 / 只此一处」改成「两处落点（transparency + console）」
  （unsafe-scope 门禁自 M196 起期望集合就是两处，不改这句文档就是错的）。
  注意：`pub mod console;` 属于 `platform/win32/mod.rs`，本次解冲突时一度被误加到
  `platform/mod.rs`（`cargo check` 立刻报 E0583 文件不存在），已修回。
- .github/workflows/release-build.yml：M190 的「PE 版本资源读回」步、M184 的
  linux-x64 xvfb 冒烟步与首帧上传步**全部逐字保留**；M196 的 PE 子系统门禁作为**兄弟步**
  插在导入表门禁之后（两道 PE 门禁互不替代）。按块比对：dev 的 10 个步骤逐字未变，
  合并后 11 个步骤。
- packaging/README.md：保留 M184 的 §11 补充与 §12 行、M190 的 §14 签名段；§12 里
  check_publish_slots 用 dev 的 11 条版本、另加 M196 的 check_pe_subsystem 行；§15 归位在
  §14 之后。

行数：release-build.yml 合并后 413 行会撞 400 行红线（dev 侧本来 393），故把 M196 那一步
压到 6 行 + 1 空行（说明改由步骤名指路 packaging/README.md §15 与脚本 docstring 承载），
最终正好 400 行。

验证见 mission 报告：cargo check/test/fmt 全绿，两个 PE 门禁在同一批产物上都 exit 0
（子系统 GUI=2 / CLI=3，版本资源的 subsystem 读数同为 2 / 3）。
This commit is contained in:
tower-worker committed 2026-11-09 05:49:38 +08:00
2 parents 26ba1579ab 9bb9855392
commit 1764301cdf
290 files changed
+25857 -2195
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.github/workflows/release-build.yml
+80 -16
View File
@@ -6,6 +6,9 @@ name: Release / build（可复用）
# `matrix.rustflags` → `inputs.rustflags`。
# **M164 改了两步**（只这两步）：① `Windows ARM64 工具链体检` → `工具链取证`（不再 exit 1，判定权交回编译器；
# 理由见该步上方的长注释）；② `cargo build` 步给 arm64 槽位显式备齐 target / `LIB`+`INCLUDE` / arm64 `link.exe`。
# **M184 加了一步**：`linux-x64` 的 xvfb 运行时冒烟（真渲一帧 + `[theme]` / `[backend] final` 日志断言 + 像素判定）——
# 这一档进了 `PUBLISH_SLOTS`，「发出去的包真能跑」从此由 CI 每轮证明；判据只在 `linux-x64` 槽位上跑（arm64 没有
# 对应的运行时证据，不给它加一条没验证过的门禁）。同一轮把 arm64 的失败收尾注解按槽位分支。
# 矩阵**仍由调用方** `release.yml` 的 `plan` job 生成并在外层展开（矩阵不能带 `if`，`strategy` 可读 `needs`），
# 本文件只跑**单个槽位**，不持有槽位表 —— 改槽位只改 `release.yml` 里那一处。
# `env` 必须在被调方重复声明：**被调工作流不继承调用方的 workflow 级 `env`**（CARGO_TERM_COLOR / RUST_BACKTRACE
@@ -203,11 +206,31 @@ jobs:
fi
fi
cargo build --release --locked --bin unlucky-launcher-iced --bin ull
# 产物清单只给 arm64 打：x64（当前唯一在发的槽位）这一步零变化，不额外给它加失败面。
# 产物清单只给 windows-arm64 打：两档已发布的 x64（windows-x64 / linux-x64）这一步零变化，不额外给它们
# 加失败面（linux-x64 的证据在它自己那条 xvfb 运行时冒烟步里）。
if [ "$SLOT" = "windows-arm64" ]; then
ls -l "$BUILD_DIR"/unlucky-launcher-iced* "$BUILD_DIR"/ull* || true
fi
# （M190）版本资源门禁：**读产物字节**，不信构建日志。`build.rs` 里写了 `CompanyName` 不等于
# 它进了 PE——资源在链接期被丢掉、或被后处理覆盖，都只有读回来才看得见。判据（字段值、四段式
# 版本号、FIXEDFILEINFO 的 dwFileVersion）全在 `packaging/check_pe_version.py`，本机可跑。
# 只在 Windows 槽位跑：Linux/macOS 产物没有 PE 头，那边 `build.rs` 整段不执行（见
# `packaging/pe_version.rs` 文件头）。**工具缺失也 fail**：找不到 python 就等于门禁失效。
- name: PE 版本资源读回（CompanyName / ProductName / 版权 / 版本号真的在产物里）
if: runner.os == 'Windows'
shell: bash
env:
BUILD_DIR: ${{ inputs.build_dir }}
run: |
set -euo pipefail
PY=$(command -v python3 || command -v python)
if [ -z "$PY" ]; then echo "::error::找不到 python，PE 版本资源门禁无法运行（门禁不降级）"; exit 1; fi
# 版本号与 Cargo.toml **同源**：`[workspace.package] version = "x.y.z"`。
version=$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)
echo "expect-version=$version"
"$PY" packaging/check_pe_version.py "$BUILD_DIR/unlucky-launcher-iced.exe" "$BUILD_DIR/ull.exe" --expect-version "$version"
- name: Windows 单文件自检（导入表不得出现 VC++ 可再发行 DLL）
if: runner.os == 'Windows'
shell: bash
@@ -259,25 +282,55 @@ jobs:
echo "::error::静态 CRT 未生效：exe 仍动态依赖 VC++ 可再发行包"; exit 1
fi
# M196：**读产物 PE 头的 `Subsystem`**，不读源码。同一个修复 2026-11-01 曾打在已退役的 Slint 树
# （`37d3039` 只改了 `crates/app/src/main.rs`，而 `crates/app` 自 M118 起被 workspace `exclude`、
# 不进发布矩阵），于是「代码里写过」与「产物里有没有」彻底脱钩——双击多一个控制台窗口这个 bug
# 就是这么活到 2026-11-08 的。本步只认那 4 个字节：GUI 产物必须是 WINDOWS_GUI(2)，非 2 即红。
# 反方向一并守：CLI 产物 `ull.exe` 必须仍是 CONSOLE(3)——它靠真控制台做 stdout/stderr，
# 谁把属性抄到它头上，`ull --version | …` 会静默丢输出。守门本体在 packaging/check_pe_subsystem.py
# （零第三方依赖，本地同一份代码可跑；`--self-test` 注入 8 条回归（红 6 / 绿 2）证明它会红）。
- name: PE 子系统门禁（GUI 产物必须 WINDOWS_GUI/2，CLI 产物必须 CONSOLE/3）
- name: PE 子系统门禁（GUI=WINDOWS_GUI/2，CLI=CONSOLE/3；判据与理由见 packaging/README.md §15）
if: runner.os == 'Windows'
shell: bash
run: |
PY=$(command -v python3 || command -v python)
"$PY" packaging/check_pe_subsystem.py --gui "${{ inputs.build_dir }}/unlucky-launcher-iced.exe" --cli "${{ inputs.build_dir }}/ull.exe"
# （M184）linux-x64 的**运行时门禁**：这一档已进 PUBLISH_SLOTS，所以「发出去的包真能开窗渲出一帧」得由 CI 每轮证明，
# 不能只靠一次性的本机验收（证据与实测输出见 `packaging/docs/linux-evidence.md`）。
# **只在 linux-x64 槽位上跑**：判据是按 x64 软渲染实测标定的；`linux-arm64` 上这条链一次都没验过（没有 arm64 的
# xvfb 证据），写成无条件的 `runner.os == 'Linux'` 就等于给一个没验证过的槽位加一条会红的判据——正是 M171 那个
# 「豁免行要单独落」的同类事故。宁可这条只在有证据的槽位上真跑。
- name: Linux x64 运行时冒烟（xvfb 真渲一帧 + 主题/后端日志断言）
if: inputs.slot == 'linux-x64'
shell: bash
env:
BUILD_DIR: ${{ inputs.build_dir }}
run: |
set -euo pipefail
PY=$(command -v python3 || command -v python)
# 读数（含文件字节偏移）直接进日志：红的时候要看的就是这个数，而不是「脚本说不对」。
"$PY" packaging/check_pe_subsystem.py \
--gui "$BUILD_DIR/unlucky-launcher-iced.exe" \
--cli "$BUILD_DIR/ull.exe"
sudo apt-get update
sudo apt-get install -y --no-install-recommends xvfb xauth \
libxkbcommon-x11-0 libx11-6 libxcursor1 libxrandr2 libxi6 libfontconfig1 fonts-dejavu-core
out="$RUNNER_TEMP/linux-smoke"
mkdir -p "$out/data"
log="$out/launcher.log"
# 退出码单独取：`tee` 之后的 `$?` 是 tee 的，管道里 cargo/launcher 的失败会被吞成 0。
set +e
xvfb-run -a --server-args="-screen 0 1280x1024x24" \
"$BUILD_DIR/unlucky-launcher-iced" --software-renderer \
--screenshot "$out/linux-x64-first-frame.png" --data-dir "$out/data" 2>&1 | tee "$log"
code=${PIPESTATUS[0]}
set -e
echo "launcher exit=$code"
# 两条日志断言（两行都是**恒开**的，不依赖 ULL_ACCEPTANCE）：
# `[theme] source=…flavor=…follows_system=…` 证明主题是按预期来源定的（截图通道默认 Light），
# `[backend] final=… result=started` 证明渲染后端真的起来了（而不是起来前就崩了）。
grep -q '^\[theme\] source=' "$log" || { echo "::error::缺少 [theme] 行（主题来源没打印）"; exit 1; }
grep -q '^\[backend\] final=.* result=started' "$log" || { echo "::error::缺少 [backend] final=… result=started（渲染后端没起来）"; exit 1; }
python3 packaging/check_screenshot.py "$out/linux-x64-first-frame.png" --json
ls -l "$out"
exit "$code"
- name: 上传 Linux x64 首帧图（失败也传，人眼复核用）
if: always() && inputs.slot == 'linux-x64'
uses: actions/upload-artifact@v4
with:
name: linux-x64-first-frame
path: ${{ runner.temp }}/linux-smoke/
if-no-files-found: warn
- name: 打包（产物 + SHA256SUMS）
shell: bash
@@ -330,7 +383,18 @@ jobs:
# 「不挡发布」——只剩一句 `Process completed with exit code 1.` 的教训见上面那条体检步骤。
# M164 起本槽位的红**只可能来自真实构建链路**（体检已降级为取证、永不 exit 1），所以这条注解同时也是
# 「arm64 到底能不能编出来」的答案所在：红了就把上面的编译器/链接器原文当根因，别再回去改体检。
# M184：Linux arm64 进来（它现在是 `mode: ci`，tag 推送默认就编），措辞按槽位分支 —— 两个 arm64 都**不在**发布名单里，
# 但理由不同：windows-arm64 等「能不能出 PE」的答案，linux-arm64 等「真机跑不跑得起来」的答案。
- name: arm64 失败收尾注解（红不挡发布）
if: failure() && inputs.slot == 'windows-arm64'
if: failure() && (inputs.slot == 'windows-arm64' || inputs.slot == 'linux-arm64')
shell: bash
run: echo "::error::[arm64] 本槽位已红，失败步骤见本 job 的步骤名（M164 起只会是 cargo build / 链接 / 导入表门禁 / 打包，体检步不再判红）；PUBLISH_SLOTS 当前只有 windows-x64 ⇒ 本次 Release 仍照发 x64，arm64 产物不进 Release"
env:
SLOT: ${{ inputs.slot }}
run: |
set -euo pipefail
if [ "$SLOT" = "linux-arm64" ]; then
reason="本槽位只有构建证据、运行时完全未验（没有 ARM64 真机跑过一帧）"
else
reason="失败步骤见本 job 的步骤名（M164 起只会是 cargo build / 链接 / 导入表门禁 / 打包，体检步不再判红）"
fi
echo "::error::[$SLOT] 本槽位已红：$reason。PUBLISH_SLOTS 当前是 windows-x64 + linux-x64 ⇒ 本次 Release 仍照发那两档，$SLOT 的产物不进 Release"
.github/workflows/release-guard.yml
+18 -1
View File
@@ -20,7 +20,8 @@ name: Release guard
# （M164）同一个 job 还挂**发布名单守卫** `packaging/check_publish_slots.py`：`PUBLISH_SLOTS` 与槽位表/产物
# 必须对得上。PR 阶段跑源码级断言（名单非空、每项都是 `release.yml` 槽位表里的 `mode: ci` 档）——
# 名单里写错一个字此前只会表现为「Release 侧一个也不匹配、齐全性检查红在别处」，根因要翻两层日志；
# `--self-test` 再注入 8 条回归（缺资产 / 拼错 / 声明了 probe 档 / 名单声明了没产物 / 有产物没声明）证明它会红。
# `--self-test` 再注入 11 条回归（缺资产 / 拼错 / 声明了 probe 档 / 名单声明了没产物 / 有产物没声明 /
# `mode: ci` 却没产物 / 声明的 `linux-x64` 构建红了必须拦住发布 / 提前把 `linux-arm64` 写进名单必须红）证明它会红。
# 发布侧那道「产物 ⇄ 名单」的运行时断言在 `release-publish.yml`（同一份脚本，`--dist`）。
#
# （M169）同一个 job 再挂**测试通道守门** `packaging/check_test_source_off.py`：core/cli/presenter/
@@ -67,3 +68,19 @@ jobs:
run: python3 packaging/check_test_source_off.py --self-test
- name: 发布产物不含测试通道（workflow / 打包脚本 / Cargo default 都不许开）
run: python3 packaging/check_test_source_off.py
# M190：签名脚本与 PE 版本资源门禁自己的自检。前者验 RFC 8032 向量（Ed25519 实现错了就发不出
# 能被验过的签名），后者把「口径表 ⇄ pe_version.rs」「四段式版本号换算」对拍，并造一个没有版本
# 资源的假 PE 断言判据**会红**（否则那道门禁对任何输入都绿，等于没有）。
- name: 清单签名脚本自检（RFC 8032 向量 + 信任表标记解析）
run: python3 packaging/sign_manifest.py --self-test
- name: PE 版本资源判据自检（口径表对拍 + 假 PE 必红）
run: python3 packaging/check_pe_version.py --self-test
# M190 r1 复审 P1-1：`.github/workflows/release-build.yml` 的 sed 替换串里混进过一枚裸 0x01
# （本意是 `\1`）。GitHub 解析这种文件会直接失败 ⇒ **整个 run 起不来**，而所有文本扫描型守卫
# 都看不见它（它们把 workflow 读成文本）。这条用**真 YAML 解析器** parse 全部 workflow，
# 外加一条「C0 控制字符」字节判据（两种失败模式各自独立报 `::error file=…,line=…`）。
# PyYAML 在 GitHub runner 上自带；万一缺失，脚本自己装一次，仍失败则红（门禁不降级）。
- name: workflow YAML 自检（注入 0x01 / 坏结构必须红）
run: python3 packaging/check_workflows_yaml.py --self-test
- name: workflow 全部可被真 YAML 解析器 parse（无裸控制字符）
run: python3 packaging/check_workflows_yaml.py
.github/workflows/release-publish.yml
+55 -13
View File
@@ -27,6 +27,14 @@ on:
PUBLISH_TOKEN:
description: "调用方透传 `secrets.GITHUB_TOKEN`（本 job 已声明 contents: write，`gh release` 用它发版）"
required: true
# （M190 r1 复审 P1-2）**必须在这里声明**：可复用工作流只拿得到自己声明过的 secret，调用方
# `release.yml` 按名传了这一个，若被调方不声明，它要么在调用处报错、要么静默求值为空串——
# 两种结局都是「用户已把钥录进 Secret，发布仍在签名步红，而错误文案反过来指控 Secret 没配」。
# `required: false` 是刻意的：缺省为空串，由签名步的 `::error::` + `exit 1` 做 fail-closed
# （与 `release-build.yml` 的 `ULL_MSA_CLIENT_ID` 同一模式），失败信息才和事实一致。
ULL_MANIFEST_SIGNING_KEY:
description: "清单签名私钥（JSON：key_id + seed_hex）；未配置时签名步 fail-closed、不出 Release"
required: false
# 权限取交集：调用方 release.yml 的 release job 与本文件都声明 contents: write，交集才是 write（不声明则被收窄成 read）。
permissions:
@@ -40,18 +48,21 @@ jobs:
contents: write
env:
# ── 发布白名单：唯一决定「哪几个槽位进 Release」的开关（空格分隔，键同 matrix.slot）──
# **M142 起只有 `windows-x64`**：arm64 连试四轮未走通，而齐全性检查是「名单内少一档就 fail」——名字挂着
# arm64 就等于 x64 编成功也发不出去。故把它移出名单：它照留在矩阵里跑取证，**红了不挡发布**。
# （M164）**为什么现在还只有 x64**：arm64 五轮全红其实都红在一个误判的编译前体检步（见 release-build.yml
# 顶部那段），真正的 cargo/link 一次都没跑过；M164 把那个门禁拆了、判定权交回编译器，但「arm64 能不能编出
# PE」只能由**下一 tag 的 CI** 证明，本机没有 ARM64 真机/工具链证不了。在拿到那次绿之前把 arm64 写进来，
# 等于拿 x64 的发布去赌它 —— 同一个事故不演第二遍（tower M164 裁决）。
# **可逆，且只是一行**：那句 CI 真出包之后把键加回这一行（`"windows-x64 windows-arm64"`），齐全性检查与
# SHA256SUMS 自动跟着扩，再同步 README §1/§9 与 release-notes.md 两张表。
# **M184 起是 `windows-x64` + `linux-x64`**：`linux-x64` 已真机验过 —— release 产物在 Linux 真机（WSLg 真窗口）
# 渲出一帧、主题/后端日志齐全，并有一条同槽位的 xvfb 运行时门禁常驻在 `release-build.yml`（证据与实测输出见
# `packaging/docs/linux-evidence.md`）。进名单的代价是「每轮发版都得真出这个包」：齐全性检查是「名单内少一档就 fail」，
# 所以这条名单同时也是「linux-x64 构建红了就挡住整次发布」的闸 —— 与任务要求一致（声明为 ci 就得真能出包）。
# **`linux-arm64` 不在名单里，且这一轮刻意不放**：它只有构建证据，运行时完全没有证据（没有 ARM64 真机跑过一帧，
# 也没有 arm64 的 xvfb 冒烟）。解锁条件 = arm64 真机（或原生 runner）上真跑出一帧 + 主题日志 → 再把键加进这一行。
# 只加进矩阵不加进名单时，它的产物会被下面的裁剪步删掉，但守卫会先打 `::warning::` 明说「未发布、会被裁掉」，
# 不是静默丢弃（这条是任务里点名要验的反方向）。
# `windows-arm64` 同理仍不在名单（M142/M164：它的五轮红全红在误判的体检步，判定权已交回编译器，等下一 tag 的 CI 证）。
# **可逆，且只是一行**：真出包之后把键加进这一行（`"windows-x64 linux-x64 <新键>"`），齐全性检查与 SHA256SUMS
# 自动跟着扩，再同步 README §1/§9 与 release-notes.md 两张表。
# 判据不再靠注释保证：`packaging/check_publish_slots.py`（下面第二个 step 跑它；PR 阶段由 release-guard.yml
# 跑同一份脚本）两个方向都查——声明了缺产物 ⇒ `::error::` + exit 1；有产物但没声明 ⇒ `::warning::` 明说未发布。
# 四档 Linux/macOS 仍未验证，默认连构建都不跑（M139）。
PUBLISH_SLOTS: "windows-x64"
# macOS 两档仍未验证，默认连构建都不跑（M139）。
PUBLISH_SLOTS: "windows-x64 linux-x64"
steps:
- uses: actions/checkout@v4
@@ -63,7 +74,7 @@ jobs:
# （M164）发布名单守卫：**声明了就必须有产物**（名单内某个槽位缺 GUI 或 CLI 就红，少一档不发版），
# 反方向的「产物在、名单没声明」则打 `::warning::` 明说未发布 —— M142 之后那个方向是**静默**的（裁剪步只
# echo 一行 `drop:`，没有注解、也没有非零退出），一个真编出来的 arm64 会被就地 `rm` 掉而没人知道。
# 判据全在 `packaging/check_publish_slots.py`：同一份代码本地可跑，`--self-test` 注入 8 条回归断言每条都红。
# 判据全在 `packaging/check_publish_slots.py`：同一份代码本地可跑，`--self-test` 注入 11 条回归断言该红的红。
# 它跑在**裁剪前**的全量集上（裁剪只删名单外的文件），所以是原来「裁剪后再查」那次检查的严格超集。
- name: 发布名单守卫（声明 ⇒ 必须有产物；有产物没声明 ⇒ 显式未发布）
shell: bash
@@ -87,7 +98,7 @@ jobs:
echo "publish: $base"
;;
*)
echo "drop: $base（$platform_arch 不在发布白名单：四档未验证 / arm64 待下一 tag 验证；仍留在 dist-<slot> artifact 里取证）"
echo "drop: $base（$platform_arch 不在发布白名单：macOS 两档未构建验证 / 两个 arm64 槽位待真机跑一帧；仍留在 dist-<slot> artifact 里取证）"
rm -f "$f"
;;
esac
@@ -128,6 +139,35 @@ jobs:
--asset-base-url "$RELEASE_BASE/$TAG" \
--released-at "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
# （M190）清单签名：**签不上就不发版**。私钥只从仓库 Secret `ULL_MANIFEST_SIGNING_KEY` 进环境变量，
# 本步 `set +x` 且只回显**公钥**（日志里永远不出现私钥）。四条命令任一非零 ⇒ 本步红 ⇒ 不出 Release：
# ① `--self-test`：RFC 8032 向量（签名脚本自己没坏）
# ② `--check-pinned-keyring`：Secret 里的钥**必须**已在 `crates/core/src/update/trust.rs` 钉住
# （签出一份客户端不认的清单，比不发版更糟）
# ③ `--sign`：签的就是上一步落盘的 `dist/manifest.json` 原始字节，产出 `dist/manifest.json.sig`
# 红了的处置见 `packaging/docs/signing.md` §4 那张表（缺什么、怎么补，都写在脚本的 stderr 里）。
- name: 签更新清单（Ed25519；签不上就阻断发布）
shell: bash
env:
ULL_MANIFEST_SIGNING_KEY: ${{ secrets.ULL_MANIFEST_SIGNING_KEY }}
run: |
set -euo pipefail
set +x
PY=$(command -v python3 || command -v python)
if [ -z "$PY" ]; then echo "::error::找不到 python，签名步骤无法运行（签名门禁不降级）"; exit 1; fi
"$PY" packaging/sign_manifest.py --self-test
if [ -z "${ULL_MANIFEST_SIGNING_KEY:-}" ]; then
echo "::error::仓库 Secret ULL_MANIFEST_SIGNING_KEY 没配（或为空）：没有签名私钥就不发版。"
echo "::error::补法见 packaging/docs/signing.md §3：python3 packaging/sign_manifest.py --generate-key，把打印的 JSON 贴进 Secret、把 PinnedKey 那行贴进 crates/core/src/update/trust.rs"
exit 1
fi
"$PY" packaging/sign_manifest.py --check-pinned-keyring
"$PY" packaging/sign_manifest.py --sign dist/manifest.json
# ④ 产出后**用 trust.rs 里钉住的公钥回验一遍**：复现「客户端会怎么判」，而不是信签名脚本
# 自己那句「签好了」。私钥不需要参与，所以这一步跑在同一个环境里也不多一个泄露面。
"$PY" packaging/sign_manifest.py --verify-pinned dist/manifest.json
ls -l dist/manifest.json dist/manifest.json.sig
- name: 生成 Release 说明（支持矩阵模板）
shell: bash
env:
@@ -169,7 +209,9 @@ jobs:
echo "create_mark=(${create_mark[*]:-}) edit_mark=(${edit_mark[*]:-})"
# Windows 单 exe 装不下 LICENSE/NOTICE/README.md，故三份与产物并列挂 Release（条款随包）；`ull` 是独立资产。
# manifest.json 是更新清单（D50）：固定文件名，客户端问 `releases/latest/download/manifest.json`。
assets=(dist/unlucky-launcher_* dist/ull_* dist/manifest.json dist/SHA256SUMS.txt LICENSE NOTICE README.md)
# `manifest.json.sig` 必须与清单一起上传：客户端取清单后取它旁边的签名（`GitHubReleaseSource`
# 拼的地址是 `<产物根>/manifest.json.sig`），漏传等于让所有人都验签失败（M190）。
assets=(dist/unlucky-launcher_* dist/ull_* dist/manifest.json dist/manifest.json.sig dist/SHA256SUMS.txt LICENSE NOTICE README.md)
if gh release view "$TAG" >/dev/null 2>&1; then
# 同 tag 重跑（补丁/重编）：Release 已存在 → 覆盖资产 + 刷新说明，再 `create` 会因已存在而失败。
gh release upload "$TAG" "${assets[@]}" --clobber
.github/workflows/release.yml
+33 -17
View File
@@ -1,13 +1,18 @@
name: Release
# 发布流水线：tag `v*` → **只构建两个 Windows 槽位**（各自原生 `windows-latest` / `windows-11-arm`）→ 单文件产物 +
# SHA256SUMS → artifact + GitHub Release。**push tag 默认创建稳定版**（M163：不带 `--prerelease`，否则
# `releases/latest` 永远 404、自更新通道取不到清单）；同 tag 重跑幂等（覆盖资产与说明、不 create、不碰标记）。
# **构建 ≠ 发布**：只有 `PUBLISH_SLOTS` 里的槽位才进 Release 与 SHA256SUMS ——**M142 起只有 `windows-x64`**（arm64 仍留
# 矩阵里取证、红了不挡 x64 发布）。**M164 的更正**：arm64 那五轮红其实全红在一个误判的编译前体检步（cargo/link 一次
# 都没跑过，见 `release-build.yml` 顶部），该门禁已拆、判定权交回编译器；但「arm64 能不能出 PE」只能由**下一 tag 的
# CI** 证明，故名单仍只列 x64（tower 裁决：不拿 x64 的发布去赌一个没验证过的槽位）。真出包之后把键加回那一行即可。
# 四档 Linux/macOS 从未验证，默认连构建都不跑（M139：省配额、不留红叉）；整表六槽位取证走
# 发布流水线：tag `v*` → **默认构建四个槽位**（原生 `windows-latest` / `windows-11-arm` / `ubuntu-22.04` /
# `ubuntu-22.04-arm`）→ 单文件产物 + SHA256SUMS → artifact + GitHub Release。**push tag 默认创建稳定版**（M163：不带
# `--prerelease`，否则 `releases/latest` 永远 404、自更新通道取不到清单）；同 tag 重跑幂等（覆盖资产与说明、不 create、
# 不碰标记）。
# **构建 ≠ 发布**：只有 `PUBLISH_SLOTS` 里的槽位才进 Release 与 SHA256SUMS ——**M184 起是 `windows-x64` + `linux-x64`**。
# `linux-x64` 本轮翻牌的依据在 `packaging/docs/linux-evidence.md`：x86_64 槽位在 `ubuntu-22.04`（glibc 2.35，与本地
# WSLg 验证同一地板）真编出 release 产物、真开窗渲出一帧，`release-build.yml` 里还有一条同槽位的 xvfb 运行时门禁
# ——「声明为 ci 就必须真能跑出帧」，不是「矩阵里写了就算支持」。
# **`linux-arm64` 本轮只构建、不发布**：它没有任何运行时证据（没有 ARM64 真机跑过一帧，也没有 arm64 的 xvfb 冒烟）。
# 解锁条件写在 `packaging/release-notes.md` 与 `packaging/docs/compliance-support-boundaries.md` §9 ——真机跑一帧之后
# 才把键加进 `PUBLISH_SLOTS`，不拿没跑过的包去发（M184 tower 裁决）。
# `windows-arm64` 仍留矩阵里取证、红了不挡 x64 发布（M142/M164：它那五轮红全红在一个误判的编译前体检步，该门禁已拆，
# 判定权交回编译器）。`macos-*` 两档从未验证，默认连构建都不跑（M139：省配额、不留红叉）；整表六槽位取证走
# `gh workflow run release.yml -f all_slots=true`（槽位表在 `plan`）。
# 名单 ⇄ 产物两个方向都有守卫（M164）：`packaging/check_publish_slots.py`（PR 阶段在 release-guard.yml，发布侧在
# release-publish.yml 的 `--dist` 模式）——声明了缺产物 ⇒ 红；有产物没声明 ⇒ `::warning::` 明说未发布。
@@ -31,7 +36,7 @@ on:
workflow_dispatch:
inputs:
all_slots:
description: "构建全部六个槽位（含未验证的 Linux/macOS 四档）；默认只跑两个 Windows"
description: "构建全部六个槽位（含未验证的 macOS 两档）；默认只跑四个（Windows 两档 + Linux 两档）"
type: boolean
default: false
prerelease:
@@ -58,7 +63,7 @@ jobs:
# M139：矩阵不写死在 `build` 里，改由本 job 按 `inputs.all_slots` 生成 —— 矩阵不能带 `if`，而 `jobs.<id>.strategy`
# 可读 `needs`，故用 `fromJSON(needs.plan.outputs.matrix)`。**槽位表只在下面这一处**，改槽位只改这里。
plan:
name: 选槽位（默认两个 Windows）
name: 选槽位（默认四个：Windows 两档 + Linux 两档）
runs-on: ubuntu-latest
outputs:
matrix: ${{ steps.pick.outputs.matrix }}
@@ -85,11 +90,18 @@ jobs:
# 原生还让 `ull --version` 冒烟真跑，dumpbin 走 Hostarm64 分支。
dict(slot="windows-arm64", os="windows-11-arm", build_dir="target/release",
rustflags="-C target-feature=+crt-static", mode="ci"),
# ↓ 四档**未验证，不纳入 CI**：从未真构建成功、也没在真机跑过，默认一个都不编；`all_slots=true` 时照编
# （将来验证 Linux/macOS 的唯一入口，别删）。真机验过后：mode 改 "ci" + 键加进 PUBLISH_SLOTS +
# 同步 README §1/§9 与 release-notes.md。Linux 固定 22.04 而非 latest：否则 glibc 地板跟着 runner 漂移。
dict(slot="linux-x64", os="ubuntu-22.04", build_dir="target/release", rustflags="", mode="probe"),
dict(slot="linux-arm64", os="ubuntu-22.04-arm", build_dir="target/release", rustflags="", mode="probe"),
# ↓ Linux 两档（M184）：**都改为 `mode: ci`** —— tag 推送默认就编，不再只在 `all_slots=true` 的取证跑里出现。
# Linux 固定 22.04 而非 latest：否则 glibc 地板跟着 runner 漂移（22.04 = glibc 2.35，与本地 WSLg 验证同一地板）。
# 两档的差别只在「有没有运行时证据」，而这件事由 `PUBLISH_SLOTS`（发布侧那一行）决定，不在这里：
# `linux-x64` 已真机验过（release 产物在 WSLg 真窗口渲出一帧 + 同槽位的 xvfb 门禁，证据见
# `packaging/docs/linux-evidence.md`）⇒ 进名单；`linux-arm64` 只有构建、**运行时完全未验**（没有 arm64 真机
# 跑过一帧）⇒ 不进名单，产物照出 artifact 供取证，靠 `check_publish_slots.py` 打 `::warning::` 明说未发布。
# **别把 arm64 直接加进名单**：解锁条件是真机跑一帧，不是「构建绿了」。
dict(slot="linux-x64", os="ubuntu-22.04", build_dir="target/release", rustflags="", mode="ci"),
dict(slot="linux-arm64", os="ubuntu-22.04-arm", build_dir="target/release", rustflags="", mode="ci"),
# ↓ 两档 macOS **未验证，不纳入 CI**：从未真构建成功、也没在真机跑过，默认一个都不编；`all_slots=true` 时照编
# （将来验证 macOS 的唯一入口，别删）。真机验过后：mode 改 "ci" + 键加进 PUBLISH_SLOTS +
# 同步 README §1/§9 与 release-notes.md。
# macOS：latest = arm64；Intel x64 用 macos-15-intel（macos-13 已下线）。
dict(slot="macos-arm64", os="macos-latest", build_dir="target/release", rustflags="", mode="probe"),
dict(slot="macos-x64", os="macos-15-intel", build_dir="target/release", rustflags="", mode="probe"),
@@ -126,8 +138,9 @@ jobs:
release:
name: GitHub Release
needs: build
# `always()` + `!cancelled()`：白名单外的槽位（现在的 `windows-arm64`，以及只在 `all_slots` 取证跑里存在的四档）
# 红了**不能连坐** x64 发布 —— 真正拦发布的是被调方「发布白名单齐全性」那一步：白名单里少任何一个才 fail。
# `always()` + `!cancelled()`：白名单外的槽位（`windows-arm64`、`linux-arm64`，以及只在 `all_slots` 取证跑里
# 存在的 macOS 两档）红了**不能连坐**那两档已发布的 —— 真正拦发布的是被调方「发布白名单齐全性」那一步：
# 白名单里少任何一个才 fail（M184 之后 `linux-x64` 也在白名单里，它红了就该拦）。
# tag 门禁留在这里（不在被调方）：分支 ref 的 dispatch 连发布 job 都不该起。
if: always() && !cancelled() && github.ref_type == 'tag'
# `contents: write` 必须由**调用方**授予：可复用工作流只能收窄权限、不能提权（交集语义）。
@@ -137,3 +150,6 @@ jobs:
secrets:
# 可复用工作流拿不到调用方未显式传入的 secret；`gh release` 用的就是这一枚安装令牌。
PUBLISH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
# （M190）清单签名私钥：被调方 release-publish.yml 用它签 `manifest.json`。没配时是空串，
# 签名步会带着「缺什么、怎么补」的注解当场红（宁可不出 Release，也不出未签名的 Release）。
ULL_MANIFEST_SIGNING_KEY: ${{ secrets.ULL_MANIFEST_SIGNING_KEY }}
Cargo.lock
Generated
+160
View File
@@ -368,6 +368,12 @@ version = "0.23.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
[[package]]
name = "base64ct"
version = "1.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
[[package]]
name = "bit-set"
version = "0.8.0"
@@ -660,6 +666,12 @@ dependencies = [
"crossbeam-utils",
]
[[package]]
name = "const-oid"
version = "0.9.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
[[package]]
name = "convert_case"
version = "0.11.0"
@@ -846,6 +858,33 @@ version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"
[[package]]
name = "curve25519-dalek"
version = "4.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
dependencies = [
"cfg-if",
"cpufeatures 0.2.17",
"curve25519-dalek-derive",
"digest",
"fiat-crypto",
"rustc_version",
"subtle",
"zeroize",
]
[[package]]
name = "curve25519-dalek-derive"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]]
name = "darling"
version = "0.24.1"
@@ -892,6 +931,16 @@ version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be1e0bca6c3637f992fc1cc7cbc52a78c1ef6db076dbf1059c4323d6a2048376"
[[package]]
name = "der"
version = "0.7.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
dependencies = [
"const-oid",
"zeroize",
]
[[package]]
name = "digest"
version = "0.10.7"
@@ -977,6 +1026,30 @@ version = "1.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
[[package]]
name = "ed25519"
version = "2.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
dependencies = [
"pkcs8",
"signature",
]
[[package]]
name = "ed25519-dalek"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70e796c081cee67dc755e1a36a0a172b897fab85fc3f6bc48307991f64e4eca9"
dependencies = [
"curve25519-dalek",
"ed25519",
"serde",
"sha2",
"subtle",
"zeroize",
]
[[package]]
name = "encoding_rs"
version = "0.8.42"
@@ -1094,6 +1167,12 @@ dependencies = [
"simd-adler32",
]
[[package]]
name = "fiat-crypto"
version = "0.2.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
[[package]]
name = "filetime"
version = "0.2.29"
@@ -3087,6 +3166,16 @@ dependencies = [
"futures-io",
]
[[package]]
name = "pkcs8"
version = "0.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
dependencies = [
"der",
"spki",
]
[[package]]
name = "pkg-config"
version = "0.3.34"
@@ -3332,6 +3421,15 @@ dependencies = [
"rand_core 0.9.5",
]
[[package]]
name = "rand_core"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
"getrandom 0.2.17",
]
[[package]]
name = "rand_core"
version = "0.9.5"
@@ -4125,6 +4223,15 @@ dependencies = [
"syn 3.0.9",
]
[[package]]
name = "serde_spanned"
version = "1.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c187e0a369471c550af028cba56d4f4fa2a489ad28151ae95a4d340a2a8b782"
dependencies = [
"serde_core",
]
[[package]]
name = "serde_urlencoded"
version = "0.7.1"
@@ -4188,6 +4295,15 @@ dependencies = [
"libc",
]
[[package]]
name = "signature"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
dependencies = [
"rand_core 0.6.4",
]
[[package]]
name = "simd-adler32"
version = "0.3.10"
@@ -4388,6 +4504,16 @@ dependencies = [
"bitflags 2.13.2",
]
[[package]]
name = "spki"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
dependencies = [
"base64ct",
"der",
]
[[package]]
name = "sse-stream"
version = "0.2.6"
@@ -4738,6 +4864,21 @@ dependencies = [
"tokio",
]
[[package]]
name = "toml"
version = "1.1.0+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8195ca05e4eb728f4ba94f3e3291661320af739c4e43779cbdfae82ab239fcc"
dependencies = [
"indexmap",
"serde_core",
"serde_spanned",
"toml_datetime",
"toml_parser",
"toml_writer",
"winnow",
]
[[package]]
name = "toml_datetime"
version = "1.1.2+spec-1.1.0"
@@ -4768,6 +4909,12 @@ dependencies = [
"winnow",
]
[[package]]
name = "toml_writer"
version = "1.2.0+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "009dbb7700f11c55ef83aebbe4c0e9cf1f1ac0844bd8d6f00dc38f302026e13a"
[[package]]
name = "tower"
version = "0.5.3"
@@ -5007,6 +5154,7 @@ dependencies = [
"unlucky-design",
"unlucky-i18n",
"unlucky-presenter",
"winresource",
]
[[package]]
@@ -5018,12 +5166,14 @@ dependencies = [
"tokio",
"unlucky-agent",
"unlucky-core",
"winresource",
]
[[package]]
name = "unlucky-core"
version = "0.2.3"
dependencies = [
"ed25519-dalek",
"flate2",
"futures-util",
"md-5",
@@ -5968,6 +6118,16 @@ dependencies = [
"memchr",
]
[[package]]
name = "winresource"
version = "0.1.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2bc6d36480b829272a5bdabf08e6dca8004761c1da7e35efef800540c66221b"
dependencies = [
"toml",
"version_check",
]
[[package]]
name = "wit-bindgen"
version = "0.57.1"
Cargo.toml
+7
View File
@@ -71,6 +71,13 @@ md-5 = "0.10"
# 只开 inflate（`deflate-flate2-zlib-rs`，纯 Rust zlib）——解压方向不需要 zopfli 压缩器。
zip = { version = "9", default-features = false, features = ["deflate-flate2-zlib-rs"] }
# M190（core::update::ed25519）：清单签名**验签**用官方实现，不再自写曲线算术。
# M190 r1 复审的裁定：信任锚不许用自写密码学（非规范编码/小阶点/批量验证差异的后果是
# 「验签通过但本不该通过」）。BSD-3-Clause，在 deny.toml 白名单内。
# 只开 `std`（不用 `rand_core`/`batch`/`fast` 这类可选面）：本仓的签名侧在
# `packaging/sign_manifest.py`，二进制里只有「验」这一半。
ed25519-dalek = { version = "2", default-features = false, features = ["std"] }
# M33（core::game::java）：Temurin 的 Linux/macOS 产物只发 `.tar.gz`（Windows 是 `.zip`，
# 复用上面的 zip）。flate2/tar 都是纯 Rust + MIT OR Apache-2.0，白名单内。
flate2 = "1"
README.md
+76 -29
View File
@@ -205,6 +205,31 @@ lists them all: `instances`, `install`, `launch`, `pack import`, `accounts`, `se
`ull update apply`. Debug builds can rehearse the whole chain against a local directory source
(`ULL_UPDATE_DIR`); release builds do not contain that path at all.
### Where the logs are
Everything the launcher writes on its own side lives under `<data root>/logs/`. The settings page has
a **Log folder** row that shows that path with *Open folder* and *Copy path*; the logs page header has
*Open folder* as well. The data root is `<exe folder>/.ULL` in portable mode, `<per-user app data>/ULL`
in standard mode, and `<custom root>/.ULL` in custom mode — the same value the settings page displays
as the launcher data directory.
| Path | What it is |
|---|---|
| `logs/launcher.log` | The launcher's own runtime log: boot probe, font/theme decisions, backend choice, **the named reason when a render backend fails to start**, and every launch attempt (command line facts, spawn result, exit). Rolled over at 1 MiB into `logs/launcher.1.log`, exactly **one** old copy kept, so it cannot grow without bound. |
| `logs/launcher.1.log` | The previous 1 MiB, replaced on the next rollover. |
| `logs/game/<session-id>.jsonl` | One JSONL event stream per launch: the command line (secrets redacted), every stdout/stderr line, exit code. |
| `logs/game/index.jsonl` | The one-line-per-session index the logs page lists. |
| `logs/install.log` | Install pipeline journal, one line per stage. |
| `logs/session-log-location.json` | A record of where session logs live and where they used to live. Rewritten on every start. |
| `data/agent/sessions/game/…` | **Read-only compatibility**: sessions written by older builds. They are still listed and still openable; nothing is moved and nothing is deleted. |
The game's own files are not in there — they sit in the instance's run directory: `logs/latest.log`,
`crash-reports/crash-*.txt`, and `hs_err_pid*.log`. **`crash-reports/` only exists when the JVM lived long
enough to write one.** If a mod, a missing library, or a wrong Java kills the game before Minecraft
initialises, the game never gets that far, and the honest evidence is the session JSONL plus
`launcher.log` — not a crash report. That is how the game behaves, not something the launcher is
hiding.
### Not done yet
This list is the reason to believe the rest. None of it is hidden behind marketing copy.
@@ -216,21 +241,28 @@ This list is the reason to believe the rest. None of it is hidden behind marketi
real `releases/latest/download/manifest.json` was unreadable while `0.2.2` was still a pre-release.
The first observation on the live stable channel happens after `0.2.3` ships.
- **Several buttons are placeholders.** On the instances page: *New instance*, *Import*, *Duplicate*,
*Open folder*, *Delete*. On the logs page: *Open folder*. In the settings frame: *Save*, *Reset
*Open folder*, *Delete*. In the settings frame: *Save*, *Reset
section*, *Add override*. Each writes `[page] 占位动作 …` to stderr and changes nothing — instance
management from the GUI is the instance-wizard work still outstanding, and settings change as you
edit them rather than on a Save.
- **Linux and macOS artifacts are unverified, and this release does not even build them.** The
reference machine is Windows; the `linux-x64`, `linux-arm64`, `macos-arm64` and `macos-x64` slots
sit in the CI matrix but the default release run skips them, and they have never been downloaded and
run end to end. `gh workflow run release.yml -f all_slots=true` builds them for evidence. Treat them
as untested output, not as "supported because the matrix lists them".
- **macOS is not finalised.** It has two rounds of real-device evidence (Apple Silicon), which is why
the build exists — but the menu-bar name, the placement of the three window buttons (macOS puts
them top-left; ours are drawn top-right), and 300s+ steady state still need a real machine. macOS
builds are unsigned, so the first launch needs the Gatekeeper quarantine attribute cleared
(`xattr -d com.apple.quarantine`). The macOS runtime smoke job is a manual `workflow_dispatch`
probe with `continue-on-error`, not a gate.
- **Linux x64 is published, and "published" means "it runs", not "it looks finished".** The release workflow
builds `linux-x64` on a native Ubuntu 22.04 runner by default and ships it, because the release artifact itself
was started under a real display server (WSLg), opened a window, rendered a non-blank frame and printed its
theme/backend lines — and that same check is now a per-slot CI gate on every release
(`packaging/docs/linux-evidence.md` has the raw output). Nobody has yet looked at it on a real desktop
distribution: dragging, resizing, font metrics and CJK shaping on a real desktop session are unverified.
Two things from the Windows list are simply not code paths on Linux, so there is nothing to verify: whole-window
transparency needs a native window handle the app does not have there (`hwnd=none`), and rounded corners are
delegated to the desktop compositor (`corner=policy=system`) instead of being drawn by the app.
`linux-arm64` is built (native `ubuntu-22.04-arm`) but **not** published — no ARM64 machine has ever run it, so
the artifact stays as build evidence only.
- **macOS is not built by the release workflow, and it is not finalised.** It has two rounds of real-device
evidence (Apple Silicon), which is why the build exists at all — but the menu-bar name, the placement of the
three window buttons (macOS puts them top-left; ours are drawn top-right), and 300s+ steady state still need a
real machine. macOS builds are unsigned, so the first launch needs the Gatekeeper quarantine attribute cleared
(`xattr -d com.apple.quarantine`). The macOS runtime smoke job is a manual `workflow_dispatch` probe with
`continue-on-error`, not a gate; `gh workflow run release.yml -f all_slots=true` builds the two slots for
evidence, but they are never published.
- **The content library is cramped at low window heights**, and the window height is not wired into
the page model yet — the page lays itself out for a nominal height rather than the one it gets.
- **Launch-side failure text is not structured.** The tile takes a Chinese sentence straight from the
@@ -253,25 +285,28 @@ Grab the file for your platform from
| Slot | Asset | Shape |
|------|-------|-------|
| `windows-x64` | `unlucky-launcher_<version>_windows_x64.exe` | bare `.exe`, double-click to run |
| `windows-arm64` | `unlucky-launcher_<version>_windows_arm64.exe` | bare `.exe` — **not yet published**, see below |
| `linux-x64` | `unlucky-launcher_<version>_linux_x64.tar.gz` | one archive, one top-level directory — **not yet published** |
| `linux-arm64` | `unlucky-launcher_<version>_linux_arm64.tar.gz` | same — **not yet published** |
| `macos-arm64` | `unlucky-launcher_<version>_macos_arm64.tar.gz` | same — **not yet published** |
| `macos-x64` | `unlucky-launcher_<version>_macos_x64.tar.gz` | same — **not yet published** |
| `linux-x64` | `unlucky-launcher_<version>_linux_x64.tar.gz` | one archive, one top-level directory; glibc 2.35+ and the X11/Wayland + fontconfig stack |
| `windows-arm64` | `unlucky-launcher_<version>_windows_arm64.exe` | bare `.exe` — **built, not published**, see below |
| `linux-arm64` | `unlucky-launcher_<version>_linux_arm64.tar.gz` | same — **built, not published** (no runtime evidence yet) |
| `macos-arm64` | `unlucky-launcher_<version>_macos_arm64.tar.gz` | same — **not built** by the release workflow |
| `macos-x64` | `unlucky-launcher_<version>_macos_x64.tar.gz` | same — **not built** by the release workflow |
| every published slot | `ull_<version>_<platform>_<arch>[.exe]` | bare CLI binary, its own asset |
| all | `SHA256SUMS.txt` | `sha256sum -c` eats it directly |
**This release publishes `windows-x64` and nothing else.** The publish job keeps only the slots named
in `PUBLISH_SLOTS` (`.github/workflows/release-publish.yml`) and deletes every other artifact before
it writes `SHA256SUMS.txt`, so a row marked **not yet published** is a naming rule, not a downloadable
asset. A guard (`packaging/check_publish_slots.py`) watches both directions: a slot named in the list
whose artifacts are missing turns the release red, and artifacts that exist for an unlisted slot get an
explicit "not published" warning instead of being deleted quietly. Of those rows `windows-arm64` is the
one CI still builds — natively, on GitHub's `windows-11-arm` runner (Windows 11 Arm64 + Visual Studio
2026), for evidence. Every ARM64 failure so far came from a pre-build toolchain probe that aborted before
`cargo build` ran; that probe is now evidence-only, so an upcoming CI run is the first real answer to
whether the slot can produce a binary. Its `.exe` stays out of the release until then; the row stays
because the architecture is still supported.
**This release publishes `windows-x64` and `linux-x64`, and nothing else.** The publish job keeps only the slots
named in `PUBLISH_SLOTS` (`.github/workflows/release-publish.yml`) and deletes every other artifact before it
writes `SHA256SUMS.txt`, so a row marked **not published** is a naming rule, not a downloadable asset. A guard
(`packaging/check_publish_slots.py`) watches all three relations: a slot named in the list whose artifacts are
missing turns the release red (that is also what makes a red `linux-x64` build block the release), artifacts that
exist for an unlisted slot get an explicit "not published" warning instead of being deleted quietly, and a
`mode: ci` slot that produced nothing at all warns too — a red slot must never be visible only as a missing row.
Of the unlisted rows, CI builds two. `windows-arm64` is built natively on GitHub's `windows-11-arm` runner
(Windows 11 Arm64 + Visual Studio 2026); every ARM64 failure so far came from a pre-build toolchain probe that
aborted before `cargo build` ran, that probe is now evidence-only, and the next CI run is the first real answer to
whether the slot can produce a binary. `linux-arm64` is built natively on `ubuntu-22.04-arm` (same glibc 2.35 floor
as x64) and is unpublished for a different reason: **nothing has ever run it on ARM64 hardware**. One frame plus the
theme/backend log lines on a real ARM64 machine is the unlock condition; until then the artifact is build evidence.
Each UNIX archive contains the executable plus `LICENSE`, `NOTICE` and `README.md`, in one top-level
directory. Windows ships a bare `.exe` (a single file cannot carry the texts), so those three
@@ -279,6 +314,18 @@ documents are attached to the release next to it — downloading the Windows bin
licence. Download links never carry implementation detail in the name, and the binary inside an
archive is always called `unlucky-launcher`.
On Linux x64 that is the whole install:
```bash
tar -xzf unlucky-launcher_<version>_linux_x64.tar.gz
cd unlucky-launcher_<version>_linux_x64
./unlucky-launcher # add --software-renderer if there is no usable GPU adapter
```
It asks for glibc 2.35+ (the slot is built on Ubuntu 22.04), `libxkbcommon`, `fontconfig` and `libGL`; on
Debian/Ubuntu `sudo apt-get install libxkbcommon0 libfontconfig1 libgl1 libx11-6 libxcursor1 libxrandr2 libxi6`
covers the load-time set, and the bare `ull_<version>_linux_x64` beside the archive needs no display at all.
The two shapes are not duplicates. The GUI binary needs the graphics stack when it opens a window (it
`dlopen`s X11 / Wayland / GL and links `libfontconfig` at load); `ull` needs nothing beyond glibc, so
it runs on a server or a CI container where no window can exist. On Linux that floor is glibc ≥ 2.35
@@ -345,7 +392,7 @@ merge. The macOS probe is not there yet — manual dispatch only, result recorde
|----------|---------|
| `.github/workflows/ci.yml` | fmt + clippy + test + release build (Windows / Linux matrix); Linux runtime smoke (Xvfb, one real frame, PNG asserted non-blank); macOS runtime probe (manual dispatch only) |
| `.github/workflows/guards.yml` | zero-UI guards (`crates/core`, `crates/presenter`, `crates/design`), 400-lines-per-file guard, cargo-deny licence and source guard |
| `.github/workflows/release.yml` | tag `v*` → build both Windows slots (`windows-x64` + `windows-arm64`) on native runners → single-file artifacts + `SHA256SUMS.txt` → GitHub Release (publishes `windows-x64` only; `-f all_slots=true` builds all six slots for evidence) |
| `.github/workflows/release.yml` | tag `v*` → build the four default slots (`windows-x64` + `windows-arm64` + `linux-x64` + `linux-arm64`) on native runners → single-file artifacts + `SHA256SUMS.txt` → GitHub Release (publishes `windows-x64` and `linux-x64`; `linux-x64` also gets a per-slot Xvfb first-frame gate; `-f all_slots=true` builds all six slots for evidence) |
| `.github/workflows/release-guard.yml` | release-marker semantics: push tag ⇒ a **stable** release, dispatch `prerelease=true` ⇒ pre-release; the table lives in `packaging/release_marker.py` and the guard mutation-tests itself |
## Architecture and module map
README.zh-CN.md
+70 -22
View File
@@ -163,6 +163,34 @@ unlucky-launcher --version # CLI，版本 + 系统摘要
点按钮，要么是显式 `ull update apply`。调试构建可以拿本地目录源把整条链演练一遍（`ULL_UPDATE_DIR`）；发布
构建里**不存在**这条路径。
### 日志在哪
启动器自己这一侧写的东西全在 `<数据根>/logs/` 一个目录里。设置页有一行**日志文件夹**，直接显示这个
路径，旁边是 *打开文件夹* 与 *复制路径*；日志页页头也有 *打开文件夹*。
![设置页「通用」分组：日志文件夹一行，显示 D:/ULL-Demo/.ULL/logs，旁边是「打开目录」与「复制路径」两个按钮，下面是解释文案](docs/images/logs-folder-zh.png)
*设置页 → 通用 → 日志文件夹。路径就是当前实际生效的日志根（便携 / 标准 / 自定义三种数据模式各自不同），
打开失败时这一行照样显示，右按钮把路径送进剪贴板。*
数据根按三种模式取值：便携是 `<exe 目录>/.ULL`，标准是 `<用户应用数据目录>/ULL`，自定义是
`<自定义根>/.ULL`——与设置页显示的「启动器数据目录」是同一个值。
| 路径 | 是什么 |
|---|---|
| `logs/launcher.log` | 启动器自己的运行日志：后端探测、字体/主题决策、后端选择、**渲染后端起不来时的具名原因**，以及每一次启动（命令行事实、spawn 结果、退出码）。满 1 MiB 滚成 `logs/launcher.1.log`，**只留一份**旧档，所以它不会无限长大。 |
| `logs/launcher.1.log` | 上一份 1 MiB，下次滚动时被替换。 |
| `logs/game/<session-id>.jsonl` | 每次启动一份 JSONL 事件流：命令行（已脱敏）、每一行 stdout/stderr、退出码。 |
| `logs/game/index.jsonl` | 一会话一行摘要的索引，日志页左栏读的就是它。 |
| `logs/install.log` | 安装流水：每个阶段一行。 |
| `logs/session-log-location.json` | 会话日志现在在哪、以前在哪的记录，每次启动重写。 |
| `data/agent/sessions/game/…` | **只读兼容**：旧版本写下的会话。仍然列得出来、打得开；不搬动、不删除任何一个文件。 |
游戏自己的文件不在这里，而在实例的运行目录里：`logs/latest.log`、`crash-reports/crash-*.txt`、
`hs_err_pid*.log`。**`crash-reports/` 只在 JVM 活到那一步时才存在。** 模组、缺库或 Java 选错把游戏
弄死在 Minecraft 初始化之前时，游戏根本没机会写它——那种时候诚实的证据是会话 JSONL 与
`launcher.log`，不是崩溃报告。这是游戏的行为，不是启动器藏了什么。
### 还没做
这份清单是让人相信上面那些话的理由。没有一条藏在宣传话术后面。
@@ -172,17 +200,22 @@ unlucky-launcher --version # CLI，版本 + 系统摘要
- **更新链路只用本地目录源演练过。** 整条链（清单 → 下载 → SHA256 → 改名/回滚）是拿调试构建 + 夹具跑的，
因为 `0.2.2` 还是预发布期间读不到真实的 `releases/latest/download/manifest.json`。线上稳定通道的第一次
观察要等 `0.2.3` 发出去之后。
- **有一批按钮是占位。** 实例页：*新建实例*、*导入*、*复制*、*打开文件夹*、*删除*。日志页：*打开文件夹*。
- **有一批按钮是占位。** 实例页：*新建实例*、*导入*、*复制*、*打开文件夹*、*删除*。
设置页框架：*保存*、*重置本组*、*添加覆盖*。点下去只往 stderr 写一行 `[page] 占位动作 …`，什么都不改
——图形界面里的实例管理就是还欠着的那块实例向导；设置项是边改边生效，而不是靠「保存」。
- **Linux 与 macOS 产物未验证，而且本版连构建都不跑。** 参考机是 Windows；`linux-x64`、`linux-arm64`、
`macos-arm64`、`macos-x64` 四档只躺在 CI 矩阵里，默认的发布流程会跳过它们，也还没被下载下来端到端跑过；
`gh workflow run release.yml -f all_slots=true` 才编它们来取证。把它们当**未经测试的产出**，而不是
「矩阵里有就算支持」。
- **macOS 未定型。** 有两轮真机证据（Apple Silicon），构建因此存在——但菜单栏显示名、三个窗口按钮的位置
（macOS 习惯在左上，我们自绘在右上）、300s+ 稳态仍需真机复核。macOS 产物未签名，首次启动要自己清掉
Gatekeeper 隔离标记（`xattr -d com.apple.quarantine`）。macOS 运行期冒烟是手动 `workflow_dispatch`
的探针、带 `continue-on-error`，不是门禁。
（日志页与设置页的「打开日志文件夹」**不再**是占位：它真的会打开 `<数据根>/logs`，见[日志在哪](#日志在哪)。）
- **Linux x64 已发布，但「已发布」= 真能跑，不等于观感已定型。** 发布流水线默认就在原生 Ubuntu 22.04 上编
`linux-x64` 并发出去，依据是：release 产物本身在真显示服务（WSLg）下起过窗、渲出一帧非空白画面、主题与渲染
后端的日志行齐全（实测输出见 `packaging/docs/linux-evidence.md`），而且同一条判据已经常驻成发布流水线里
**这个槽位**的门禁。还没人看过的：真实桌面发行版上的拖动/缩放，以及真桌面会话里的字体度量与中文整形。
「整窗透明度」与「圆角」这两条在 Linux 上**根本没有代码路径**（不是未验）：前者要窗口句柄，Linux 上拿不到
（`hwnd=none`）；后者交给桌面合成器（`corner=policy=system`），我们不自己画。
`linux-arm64` 只是**编出来了，没发布**——没有任何 ARM64 机器跑过它一帧，产物只作构建证据留着。
- **macOS 不由发布流水线构建，也未定型。** 有两轮真机证据（Apple Silicon），构建因此存在——但菜单栏显示名、
三个窗口按钮的位置（macOS 习惯在左上，我们自绘在右上）、300s+ 稳态仍需真机复核。macOS 产物未签名，
首次启动要自己清掉 Gatekeeper 隔离标记（`xattr -d com.apple.quarantine`）。macOS 运行期冒烟是手动
`workflow_dispatch` 的探针、带 `continue-on-error`，不是门禁；`gh workflow run release.yml -f all_slots=true`
能编这两档取证，但它们从不发布。
- **内容库页在低窗口高度下会挤**，而且窗口高度还没接进页面模型——这一页按一个名义高度排版，而不是按它
真正拿到的高度。
- **启动侧失败提示未结构化。** 磁贴直接采用启动层抛出的中文句子
@@ -202,22 +235,37 @@ unlucky-launcher --version # CLI，版本 + 系统摘要
| 槽位 | 产物 | 形态 |
|------|------|------|
| `windows-x64` | `unlucky-launcher_<版本>_windows_x64.exe` | 裸 `.exe`，双击即用 |
| `windows-arm64` | `unlucky-launcher_<版本>_windows_arm64.exe` | 裸 `.exe` —— **暂未发布**，见下 |
| `linux-x64` | `unlucky-launcher_<版本>_linux_x64.tar.gz` | 单个归档，解压出一个顶层目录 —— **暂未发布** |
| `linux-arm64` | `unlucky-launcher_<版本>_linux_arm64.tar.gz` | 同上 —— **暂未发布** |
| `macos-arm64` | `unlucky-launcher_<版本>_macos_arm64.tar.gz` | 同上 —— **暂未发布** |
| `macos-x64` | `unlucky-launcher_<版本>_macos_x64.tar.gz` | 同上 —— **暂未发布** |
| `linux-x64` | `unlucky-launcher_<版本>_linux_x64.tar.gz` | 单个归档，解压出一个顶层目录；要 glibc 2.35+ 与 X11/Wayland + fontconfig 那一套 |
| `windows-arm64` | `unlucky-launcher_<版本>_windows_arm64.exe` | 裸 `.exe` —— **编了、不发布**，见下 |
| `linux-arm64` | `unlucky-launcher_<版本>_linux_arm64.tar.gz` | 同上 —— **编了、不发布**（运行时零证据） |
| `macos-arm64` | `unlucky-launcher_<版本>_macos_arm64.tar.gz` | 同上 —— 发布流水线**不构建** |
| `macos-x64` | `unlucky-launcher_<版本>_macos_x64.tar.gz` | 同上 —— 发布流水线**不构建** |
| 每个已发布槽位 | `ull_<版本>_<平台>_<架构>[.exe]` | 裸 CLI 文件，独立资产 |
| 全平台 | `SHA256SUMS.txt` | `sha256sum -c` 可直吃 |
**本版只发布 `windows-x64`。** 发布 job 只留 `PUBLISH_SLOTS` 里点名的槽位
**本版发布 `windows-x64` 与 `linux-x64`，就这两档。** 发布 job 只留 `PUBLISH_SLOTS` 里点名的槽位
（`.github/workflows/release-publish.yml`），其余产物在写 `SHA256SUMS.txt` 之前就被删掉——所以表里标
**暂未发布** 的行是命名规则，不是本版可下载的资产。两个方向都有守卫（`packaging/check_publish_slots.py`）：
名单里点名了却没产物 ⇒ Release 变红；产物在、名单没点名 ⇒ 显式打「未发布」警告，不再静默删掉。
这几行里 `windows-arm64` 是 CI 唯一真跑的那档：在 GitHub 原生 `windows-11-arm`（Windows 11 Arm64 +
Visual Studio 2026）runner 上编来取证。**诚实一句**：此前每一次 arm64 红都红在**编译前的工具链体检**，
`cargo build` 一次都没跑过；M164 把那个体检降级成只取证，所以**下一条 tag 的 CI 才是第一次真正问编译器**。
在那之前它的 `.exe` 不进 Release；行不删是因为架构仍要支持，真出包了就把键加回 `PUBLISH_SLOTS`（一行）。
**不发布** 的行是命名规则，不是本版可下载的资产。三条关系都有守卫（`packaging/check_publish_slots.py`）：
名单里点名了却没产物 ⇒ Release 变红（`linux-x64` 构建红了就挡住整次发布，靠的就是这条）；产物在、名单没点名
⇒ 显式打「未发布」警告，不再静默删掉；`mode: ci` 的槽位本次连产物都没有（那一档红了）⇒ 也打警告。
不发布的行里 CI 真编两档。`windows-arm64` 在 GitHub 原生 `windows-11-arm`（Windows 11 Arm64 + Visual Studio
2026）上编来取证——**诚实一句**：此前每一次 arm64 红都红在**编译前的工具链体检**，`cargo build` 一次都没跑过；
M164 把那个体检降级成只取证，所以**下一条 tag 的 CI 才是第一次真正问编译器**。`linux-arm64` 在原生
`ubuntu-22.04-arm`（与 x64 同 glibc 地板）上编，不发布的理由完全不同：**没有任何 ARM64 机器跑过它**。
解锁条件 = 真机渲出一帧 + 主题/后端日志行，之后才把键加进 `PUBLISH_SLOTS`。
Linux x64 的安装就是解开归档直接跑：
```bash
tar -xzf unlucky-launcher_<版本>_linux_x64.tar.gz
cd unlucky-launcher_<版本>_linux_x64
./unlucky-launcher # 没有可用 GPU 适配器就加 --software-renderer
```
载入期要 glibc 2.35+、`libxkbcommon`、`fontconfig`、`libGL`；Debian/Ubuntu 上
`sudo apt-get install libxkbcommon0 libfontconfig1 libgl1 libx11-6 libxcursor1 libxrandr2 libxi6` 就够。
与归档并列的裸 `ull_<版本>_linux_x64` 连显示都不需要。
UNIX 归档里是二进制加 `LICENSE`、`NOTICE`、`README.md`，都在一个顶层目录下。Windows 发的是裸 `.exe`
（一个文件装不下这三份文本），所以这三份作为并列资产挂在 Release 上——下 Windows 二进制不会把许可条款
@@ -278,7 +326,7 @@ cargo deny check licenses bans sources # 依赖许可（CI 必
|----------|------|
| `.github/workflows/ci.yml` | fmt + clippy + test + release build（Windows / Linux 矩阵）；Linux runtime smoke（Xvfb 真渲染一帧、断言 PNG 非空白）；macOS 运行期探针（仅手动 dispatch） |
| `.github/workflows/guards.yml` | `crates/core` / `crates/presenter` / `crates/design` 零 UI 守门、单文件 ≤400 行守门、cargo-deny 许可与来源守门 |
| `.github/workflows/release.yml` | tag `v*` → 构建两个 Windows 槽位（`windows-x64` + `windows-arm64`，各自原生 runner）→ 单文件产物 + `SHA256SUMS.txt` → GitHub Release（只发布 `windows-x64`；`-f all_slots=true` 才整表六槽位取证） |
| `.github/workflows/release.yml` | tag `v*` → 构建默认四档（`windows-x64` + `windows-arm64` + `linux-x64` + `linux-arm64`，各自原生 runner）→ 单文件产物 + `SHA256SUMS.txt` → GitHub Release（发布 `windows-x64` 与 `linux-x64`；`linux-x64` 另有一条同槽位的 Xvfb 首帧门禁；`-f all_slots=true` 才整表六槽位取证） |
| `.github/workflows/release-guard.yml` | 发布标记语义守门：push tag ⇒ **稳定版**、dispatch `prerelease=true` ⇒ 预发布；标记表在 `packaging/release_marker.py`，守门会对自己做变异自测 |
## 架构与模块地图
crates/app-iced/Cargo.toml
+6
View File
@@ -100,3 +100,9 @@ update-test-source = ["unlucky-presenter/update-test-source", "unlucky-cli/updat
[lints]
workspace = true
# M190：把版本资源写进 PE（Windows「属性 → 详细信息」里的发布者/产品/版权/版本）。
# 只在 windows 目标上真跑（`build.rs` 先看 CARGO_CFG_TARGET_OS，其它平台直接返回），
# 共享口径在 `packaging/pe_version.rs`（两个 bin 各 include 一次，署名不会漂）。
[build-dependencies]
winresource = "0.1"
crates/app-iced/build.rs
+14
View File
@@ -0,0 +1,14 @@
//! `unlucky-launcher-iced` 的 PE 版本资源（M190）。
//!
//! 与 `crates/cli/build.rs` 同一份共享口径（`packaging/pe_version.rs`）：两个产物的
//! CompanyName / ProductName / LegalCopyright / 版本号必须逐字相同。
//!
//! ⚠ 本文件**只**写版本资源，不碰子系统：PE 的 `Subsystem` 由 rustc 的
//! `windows_subsystem` 属性决定（本分支上还没有那个属性，是 M196 的事），版本资源与子系统是两件事。
//! 判据：`packaging/check_pe_version.py` 会把它读到的 `subsystem` 打出来，加资源前后必须一致。
include!("../../packaging/pe_version.rs");
fn main() {
emit_pe_version_resource("unlucky-launcher-iced");
}
crates/app-iced/src/app/appearance.rs
+4 -3
View File
@@ -18,6 +18,7 @@
//! 写它们只能走 schema 白名单指令 `AppCommand::SetSetting`（真 host 用 `SettingStore::set` 落盘）。
//! 其中「标题栏三态」目前**没有 UI 写者**（D37 的接线未落地），所以走 `SetSetting` 的是**三个**键。
use crate::app::diag::diag;
use unlucky_presenter::dto::AppCommand;
use crate::pages::appearance::Change;
@@ -54,7 +55,7 @@ impl App {
} else {
line.push_str(" layered=skipped outcome=no-window");
}
eprintln!("{line}");
diag!("{line}");
}
/// 设置页改了一项外观。
@@ -123,8 +124,8 @@ impl App {
self.appearance_prefs = prefs;
match self.bridge.path() {
Some(path) => eprintln!("[settings] 外观已写回 {}", path.display()),
None => eprintln!("[settings] 外观未落盘（数据根解析不出来，内存态运行）"),
Some(path) => diag!("[settings] 外观已写回 {}", path.display()),
None => diag!("[settings] 外观未落盘（数据根解析不出来，内存态运行）"),
}
}
}
crates/app-iced/src/app/boot.rs
+11 -10
View File
@@ -12,6 +12,7 @@
//! 为什么重开必须是**换进程**：Windows 实测本进程里再 `run()` 一次直接 panic
//! （`iced_winit-0.14.1/src/lib.rs:81` → `Create event loop: RecreationAttempt`）。
use crate::app::diag::diag;
use std::time::{Duration, Instant};
use iced::Task;
@@ -51,10 +52,10 @@ pub(crate) fn run(options: Options) -> iced::Result {
let font_started = Instant::now();
let resolved = fonts::resolve();
let font_ms = font_started.elapsed();
eprintln!("[font] 求值耗时 {:.0} ms", font_ms.as_secs_f64() * 1000.0);
eprintln!("{}", resolved.describe());
diag!("[font] 求值耗时 {:.0} ms", font_ms.as_secs_f64() * 1000.0);
diag!("{}", resolved.describe());
if resolved.has_synthetic() {
eprintln!(
diag!(
"[font] 警告：有字重落在「合成加粗」档（观感降级），D28 后半（CDN 字体/按档换字族）要处理"
);
}
@@ -64,7 +65,7 @@ pub(crate) fn run(options: Options) -> iced::Result {
// 截图模式：`--screenshot-theme` > `--theme` > **Light**（唯一取值口 `Options::capture_flavor`）。
// **不再有**「等系统主题到达」的闸门——CI 的 xvfb 没有主题会话，等它就是挂死（见 cli 文档）。
if options.screenshot.is_some() && options.shot_flavor().is_none() {
eprintln!("[shot] 未指定主题，按 Light 出图（D30 可复现；CI 冒烟依赖这条默认值）");
diag!("[shot] 未指定主题，按 Light 出图（D30 可复现；CI 冒烟依赖这条默认值）");
}
let flavor = options.capture_flavor().unwrap_or(SchemeFlavor::Light);
diagnostics::report_theme(&options, flavor);
@@ -86,14 +87,14 @@ pub(crate) fn run(options: Options) -> iced::Result {
}
Some(OnFailure::Refuse) => {
// 取证启动：**拒绝降级出图**（换了后端出的图会让报告撒谎）。
eprintln!(
diag!(
"[gpu] 拒绝降级出图：本次是取证启动（--screenshot {}），换后端出的图会撒谎。",
options
.screenshot
.as_ref()
.map_or_else(String::new, |path| path.display().to_string())
);
eprintln!(
diag!(
"[gpu] 想用 CPU 出图请显式加 --renderer=cpu / --software-renderer（CI 就是这么跑的）。"
);
Err(iced::Error::GraphicsCreationFailed(error))
@@ -192,13 +193,13 @@ fn boot_probe(options: &Options) -> Boot {
if let Some(kind) = renderer::forced_fallback() {
let decision = renderer::fallback_round(kind);
std::env::set_var("ICED_BACKEND", kind.env_value());
eprintln!(
diag!(
"[probe] 本次是降级重开（{}={}）：跳过探测 -> ICED_BACKEND={}",
renderer::FALLBACK_ENV,
kind.env_value(),
kind.env_value()
);
eprintln!("[probe] {}", decision.describe());
diag!("[probe] {}", decision.describe());
// 验收要 `[env]` 里的真实适配器：这一轮**也枚举一次，并如实计时**（没计时就 `None`
// ⇒ 日志写 `probe=skipped`，不写 0ms）。
let (probe, probe_ms) = if acceptance::enabled() {
@@ -232,11 +233,11 @@ fn boot_probe(options: &Options) -> Boot {
if cfg!(feature = "gpu") {
match probe_ms {
Some(elapsed) => eprintln!(
Some(elapsed) => diag!(
"[probe] 探测耗时 {:.0} ms（wgpu 实例 + 全后端适配器枚举）",
elapsed.as_secs_f64() * 1000.0
),
None => eprintln!(
None => diag!(
"[probe] 探测耗时 跳过（--renderer={} 与硬件无关，未枚举）",
options.backend.name()
),
crates/app-iced/src/app/boot/diagnostics.rs
+5
View File
@@ -35,6 +35,11 @@ pub(super) fn window_settings(size: (f32, f32)) -> window::Settings {
size: iced::Size::new(size.0, size.1),
min_size: Some(MIN_SIZE),
// 自绘三键（M93）：窗口**不许**带系统装饰，否则 macOS 上会出现原生标题栏 + 自绘三键两套。
//
// M182：这一行**同时**是「macOS 四角是直角」的原因——winit 见到 `decorations: false`
// 会给出 `NSWindowStyleMask::Borderless`（没有 `Titled`），而窗口服务器只给 titled 窗
// 做圆角裁剪。链条与「要不要迁移原生标题栏」的口径写在 `platform::macos` 的模块文档里，
// 改动这一行之前先读那一页（迁移必须连同撤掉自绘三键一起做，否则两套控件打架）。
decorations: false,
resizable: true,
// M93 / D36：整窗 α 需要 `WS_EX_LAYERED`，但这里给不了——`window::Settings` 没有扩展样式
crates/app-iced/src/app/boot/fallback.rs
+4 -3
View File
@@ -9,6 +9,7 @@
//! （`iced_winit-0.14.1/src/lib.rs:81` → `Create event loop: RecreationAttempt`），winit 一个进程
//! 只能建一次事件循环。
use crate::app::diag::diag;
use crate::renderer::Decision;
use crate::renderer::{self, acceptance, Kind};
@@ -58,10 +59,10 @@ pub(super) fn fallback_env(fallback: Kind) -> [(&'static str, &'static str); 2]
/// [`renderer::FALLBACK_ENV`] 必须跳过探测，否则无限递归重开（闸门在 `boot_probe` 入口）。
pub(super) fn respawn(failed: Kind, fallback: Kind, error: &str) -> ! {
let exe = std::env::current_exe().unwrap_or_else(|err| {
eprintln!("[gpu] 降级重开失败：拿不到自身路径（{err}）");
diag!("[gpu] 降级重开失败：拿不到自身路径（{err}）");
std::process::exit(exit_code(None));
});
eprintln!(
diag!(
"[gpu] 降级 → {}（{} 已失败，原因见上两行；换一个进程重开：winit 不允许同进程建两次事件循环）。\
下一次的日志从 `[probe] 本次是降级重开` 开始。",
fallback.name(),
@@ -78,7 +79,7 @@ pub(super) fn respawn(failed: Kind, fallback: Kind, error: &str) -> ! {
let code = match status {
Ok(status) => exit_code(status.code()),
Err(err) => {
eprintln!("[gpu] 降级重开失败：{err}");
diag!("[gpu] 降级重开失败：{err}");
exit_code(None)
}
};
crates/app-iced/src/app/diag.rs
+169
View File
@@ -0,0 +1,169 @@
//! 启动期诊断行的**双写**：stderr + `<.ULL>/logs/launcher.log`（M188）。
//!
//! ## 为什么要有这一层
//!
//! 双击启动的 GUI 进程**没有 stderr 去向**（Windows 上根本没有控制台）。此前 `[font]` /
//! `[probe]` / `[theme]` / `[appearance]` / `[gpu]` 这些诊断只走 `eprintln!`，于是「启动器视角
//! 到底发生了什么」在事故之后一个字都不剩——用户投诉的「只有一个安装日志」有一半是它。
//!
//! 现在这些行同时进 `launch::launcher_log`：
//!
//! ```text
//! diag!("[font] 求值耗时 {:.0} ms", ms) → stderr: [font] 求值耗时 12 ms
//! → launcher.log: 2026-… [font] 求值耗时 12 ms
//! ```
//!
//! scope 就是行首那个 `[tag]`，所以日志行与老用法**长得一样**，`grep '\[gpu\]'` 仍然好使。
//!
//! ## 哪些行进日志、哪些只进 stderr
//!
//! 判据（M188 复审后收紧成这一句）：**逐帧度量不接；显式取证开关与一次性事故行可接。**
//!
//! | 进日志 | 只进 stderr |
//! |---|---|
//! | 启动编排（探测结论 / 字体重建 / 主题来源 / 后端最终值 / 降级重开） | **验收与出图矩阵的逐帧度量**：`[window]` / `[perf]` / `[caps]` / `[theme] source=`（`renderer::acceptance/**`，一次启动上百行） |
//! | **一次性事故行**：`[gpu] <backend> 初始化失败（具名）` / `[gpu] 失败详情（具名）`（`renderer::report_failure`）、`[gpu] iced_wgpu: …Selected: AdapterInfo…`（`log_bridge`）、`[probe] request=… -> ICED_BACKEND=…`（`probe::apply_with_preflight`）、`[gpu-preflight]`（`ULL_PREFLIGHT=1`） | 组件几何探针的断言输出（`components/**` 的 `[feedback-probe]` / gallery 页面里的 `[gallery]`） |
//! | 用户动作的结果（打开目录、写设置失败、更新忽略/应用、语言没落盘） | 每条日志行的正文里再套一层括号（不是标签，见 [`split_scope`]） |
//! | 显式开关下的一次性行：`[tick]`（`ULL_TICK_TRACE=1`，≈1 行/秒 ≈ 4.8 小时才滚一次）、`[shot]` 的通道提示 | — |
//!
//! 为什么逐帧行不许接：`launcher.log` 有 1 MiB 上限（滚成 `launcher.1.log`，只留一份），
//! 逐帧写会在几分钟内把「事故现场」冲掉。反过来，`report_failure` 那两行**就是**事故本体——
//! 双击启动没有 stderr，把它们留在 stderr 等于在最该有日志的路径上什么都没有（M188 复审 P2-1）。
/// 行首没有 `[tag]` 时的默认 scope。
pub const APP_SCOPE: &str = "app";
/// 记一行诊断：stderr 照旧，另外进启动器日志（best-effort，写不进去也不影响启动）。
pub(crate) fn emit(line: &str) {
eprintln!("{line}");
let (scope, message) = split_scope(line);
unlucky_core::launch::launcher_log::record(scope, message);
}
/// `[font] 求值耗时 12 ms` → (`font`, `求值耗时 12 ms`)。
///
/// scope 只认「短、无空白、非空」的方括号前缀：`[a b]` 这种是正文而不是标签，别把整行拆坏。
pub(crate) fn split_scope(line: &str) -> (&str, &str) {
let Some(rest) = line.strip_prefix('[') else {
return (APP_SCOPE, line);
};
let Some((scope, tail)) = rest.split_once(']') else {
return (APP_SCOPE, line);
};
if scope.is_empty() || scope.len() > 24 || scope.contains(char::is_whitespace) {
return (APP_SCOPE, line);
}
(scope, tail.trim_start())
}
/// 双写一行诊断（`diag!("[scope] 正文")`，参数同 `eprintln!`）。
macro_rules! diag {
($($arg:tt)*) => {{
crate::app::diag::emit(&format!($($arg)*));
}};
}
pub(crate) use diag;
/// 串行化「会改 `launcher_log` 全局目录」的用例。
///
/// `core::launch::launcher_log` 是**进程级单例**（目录 + 缓冲），而 app-iced 的测试二进制里
/// 有两条用例会 `set_dir` 到自己的临时目录（本文件的滚动闸、`app/dialog/tests.rs` 的启动事实闸）。
/// 它们必须串行，否则互相把对方的落点改走——那是两条闸互相打架，不是产品问题。
#[cfg(test)]
pub(crate) static LOG_STATE_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
#[cfg(test)]
mod tests {
use super::split_scope;
#[test]
fn the_leading_bracket_becomes_the_scope() {
assert_eq!(
split_scope("[font] 求值耗时 12 ms"),
("font", "求值耗时 12 ms")
);
assert_eq!(split_scope("[gpu]"), ("gpu", ""));
// 正文里的方括号不是标签
assert_eq!(
split_scope("[page] 占位动作 [x] pressed"),
("page", "占位动作 [x] pressed")
);
}
#[test]
fn lines_without_a_tag_fall_back_to_the_default_scope() {
assert_eq!(split_scope("没有标签的一行"), ("app", "没有标签的一行"));
assert_eq!(
split_scope("[a b] 空白不是标签"),
("app", "[a b] 空白不是标签")
);
}
/// 守门②：**启动器日志的滚动真的会发生**，写超上限之后文件仍然有界。
///
/// ## 为什么要「重试」
///
/// `launcher_log` 是**进程级单例**（目录 + 缓冲），而同进程里还有一条用例
/// （`app/dialog/tests.rs` 的 `boot_facts_are_recorded_into_the_launcher_log`）会
/// `set_dir` 到它自己的临时目录。两边撞上时我这几行的落点就换了人，所以每一轮都要
/// **从头跑一遍**（登记 → 造超限 → 追加 → 看有没有滚），并且用「我这份超限文件有没有被
/// rename」判断这一轮是不是真的跑在我目录上。重试不是放宽断言：每轮该发生的都得真发生。
///
/// 变异证明：删掉 `core::launch::launcher_log::append` 里那段「超限就 rename 成 launcher.1.log」，
/// 每一轮都不会出现 `launcher.1.log`，本条在重试用尽后红。
#[test]
fn the_launcher_log_rolls_over_and_stays_bounded() {
use unlucky_core::launch::launcher_log;
let _guard = super::LOG_STATE_LOCK
.lock()
.unwrap_or_else(|error| error.into_inner());
let dir = std::env::temp_dir().join(format!("ull-launcher-log-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).expect("建夹具目录");
let path = dir.join(launcher_log::FILE_NAME);
let rolled = dir.join("launcher.1.log");
let oversize = usize::try_from(launcher_log::MAX_BYTES).expect("上限能塞进 usize") + 16;
for _ in 0..50 {
let _ = std::fs::remove_file(&path);
let _ = std::fs::remove_file(&rolled);
launcher_log::set_dir(&dir);
if launcher_log::path() != Some(path.clone()) {
continue; // 这一轮被别人的 set_dir 抢先了
}
launcher_log::record("boot", "第一行");
std::fs::write(&path, vec![b'x'; oversize]).expect("造一份超限日志");
if launcher_log::path() != Some(path.clone()) {
continue;
}
launcher_log::record("boot", "滚过之后这一行必须在新文件里");
if launcher_log::path() != Some(path.clone()) {
continue; // 追加落到了别人的目录，这一轮不算
}
// 到这儿为止，追加**确实**落在本目录：超限就必须滚。
assert!(rolled.is_file(), "超限之后旧档必须滚成 launcher.1.log");
let size = std::fs::metadata(&path).expect("新文件").len();
assert!(
size < launcher_log::MAX_BYTES,
"滚完之后新文件必须远小于上限：{size}"
);
let text = std::fs::read_to_string(&path).expect("读新文件");
assert!(text.contains("滚过之后这一行"), "{text}");
// 只留一份历史：再滚一次仍然是 `launcher.1.log`，不会长出 launcher.2.log。
std::fs::write(&path, vec![b'y'; oversize]).expect("再造一份超限日志");
launcher_log::record("boot", "第二次滚动");
assert!(rolled.is_file());
assert!(!dir.join("launcher.2.log").exists(), "历史只留一份");
assert!(std::fs::metadata(&path).expect("新文件").len() < launcher_log::MAX_BYTES);
std::fs::remove_dir_all(&dir).ok();
return;
}
panic!("50 轮都撞上别的用例在改全局日志目录，这一条没能真正跑起来");
}
}
crates/app-iced/src/app/dialog.rs
+390
View File
@@ -0,0 +1,390 @@
//! 模态对话框（M187 接通 `DialogQueue`）+ 启动失败卡片。
//!
//! ## 为什么先补这一层
//!
//! 接线审计（M177）的结论很硬：`DialogQueue` / `DialogRequest` 在 app-iced 里**零引用**，
//! 所有弹窗都画不出来。于是「像 PCL2 / HMCL 那样，启动失败时弹一个带崩溃说明的框」这件事
//! 在此之前根本无处落脚。本模块是最小可用的一层：
//!
//! ```text
//! presenter AppState::dialogs（唯一队列）
//! │ current()
//! ▼
//! dialog::current(lang, request, card) ← 纯视图模型（测试打这里）
//! │
//! ▼
//! dialog::view::layer(ui, base, modal) ← 模态遮罩 + 卡片 + 主/次按钮
//! ```
//!
//! 交互：主按钮 / 次按钮 / 点遮罩 / `Esc` 都关当前条（`DialogQueue::close_current`）。
//!
//! ## 崩溃卡片额外带什么
//!
//! `DialogRequest`（presenter 的 DTO）只有标题/正文/按钮，而这次用户要的是**证据**：
//! 退出码、一句人话原因、**文件路径**、可展开的崩溃说明、以及三个按钮（导出 / 打开文件夹 /
//! 复制路径）。这些东西不进 `DialogRequest`——它是 presenter 的公共 DTO，塞进 UI 专用字段
//! 会把「谁拥有证据」搅浑。做法是：队列管**弹窗**，[`CrashCard`] 管**这次失败的事实**，
//! 两者按 `DialogId` 绑定，见 [`App::open_failure_dialog`]。
//!
//! 事实来源是 `unlucky_core::launch::crash_report`（启动线程收尾时登记的现场）。这里只读它，
//! 不重算：**界面不读盘、不猜原因**。
use unlucky_core::launch::crash_report::{CrashReport, Evidence};
use unlucky_i18n::catalog::{Catalog, Key};
use unlucky_i18n::Lang;
use unlucky_presenter::dialogs::{DialogId, DialogKind, DialogSource};
use crate::app::state::App;
pub(super) mod export;
#[cfg(test)]
mod tests;
pub(super) mod view;
/// 崩溃卡片：一次失败的**事实**（不含任何结论）。
#[derive(Debug, Clone)]
pub struct CrashCard {
/// 现场。
pub report: CrashReport,
/// 「详细崩溃说明」是否展开。
pub expanded: bool,
/// 与哪一条队列请求绑定（关掉它时把卡片一起清掉）。
pub dialog: DialogId,
/// 上一次动作的结论（导出到哪 / 打不开文件夹的原因）。
///
/// 为什么写在卡片里而不是只推 Toast：app-iced 的 Toast 通道**至今没有任何渲染点**
/// （`state.toasts` 只被推入与过期，`view` 里一次都没读）。导出这种「必须看见落到哪」的
/// 结果不能挂在一条不显示的通道上。
pub outcome: Option<String>,
}
/// 弹窗消息。
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Message {
/// 主按钮。
Primary,
/// 次按钮。
Secondary,
/// 点遮罩 / Esc。
Dismiss,
/// 展开 / 收起详细说明。
Toggle,
/// 打开日志文件夹。
OpenFolder,
/// 复制全部路径。
CopyPaths,
/// 复制第 `index` 条路径（`Modal::paths` 的下标）。
CopyPath(usize),
}
/// 视图模型：**测试与渲染共用**的一份「这一屏该出现什么」。
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(super) struct Modal {
/// 标题。
pub title: String,
/// 正文（每行一段；都是运行时拼出来的 owned 字符串）。
pub body: Vec<String>,
/// 主按钮文字。
pub primary: String,
/// 次按钮文字（`None` = 不画）。
pub secondary: Option<String>,
/// 是否有次按钮（`Progress` 没有）。
pub blocking_progress: bool,
/// 崩溃卡片（普通弹窗为 `None`）。
pub card: Option<CardView>,
/// 动作结论（导出路径 / 失败原因）；`None` = 还没有动作。
pub notice: Option<String>,
}
/// 崩溃卡片的展示内容。
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(super) struct CardView {
/// 展开 / 收起按钮的文字。
pub toggle: String,
/// 当前的展开态。
pub expanded: bool,
/// （标签, 路径）列表——**逐条可点**（点了复制该条）。
pub paths: Vec<(String, String)>,
/// 详细说明的小标题（`None` = 没有可展开的内容）。
pub detail_title: Option<String>,
/// 详细说明的正文行。
pub detail_lines: Vec<String>,
/// 三个按钮的文字。
pub actions: [String; 3],
}
impl Modal {
/// 正文全文（测试与「复制摘要」共用；换行拼起来）。
#[must_use]
#[cfg(test)]
pub fn body_text(&self) -> String {
self.body.join("\n")
}
}
/// 从队列当前条与卡片造视图模型（**纯函数**：不读盘、不看 App）。
#[must_use]
pub(super) fn current(
lang: Lang,
request: &DialogRequestView<'_>,
card: Option<&CrashCard>,
) -> Modal {
let catalog = Catalog::of(lang);
let mut modal = Modal {
title: request.title.to_string(),
body: vec![request.body.to_string()],
primary: request.primary.to_string(),
secondary: request.secondary.map(str::to_string),
blocking_progress: request.blocking_progress,
card: None,
notice: None,
};
if let Some(card) = card {
let detail = detail_of(&catalog, card);
modal.body = failure_body(&catalog, &card.report);
modal.primary = catalog.text(Key::CrashDialogExport).to_string();
modal.secondary = Some(catalog.text(Key::CrashDialogClose).to_string());
modal.card = Some(CardView {
toggle: catalog
.text(if card.expanded {
Key::CrashDialogHideDetail
} else {
Key::CrashDialogShowDetail
})
.to_string(),
expanded: card.expanded,
paths: path_rows(&catalog, &card.report),
detail_title: detail.0,
detail_lines: detail.1,
actions: [
catalog.text(Key::CrashDialogExport).to_string(),
catalog.text(Key::CrashDialogOpenFolder).to_string(),
catalog.text(Key::CrashDialogCopyPaths).to_string(),
],
});
modal.notice = card.outcome.clone();
}
modal
}
/// 队列当前条的最小视图（避免把 `DialogRequest` 的细节漏进页面层）。
pub(super) struct DialogRequestView<'a> {
/// 标题。
pub title: &'a str,
/// 正文。
pub body: &'a str,
/// 主按钮。
pub primary: &'a str,
/// 次按钮。
pub secondary: Option<&'a str>,
/// 进度框不可点主按钮。
pub blocking_progress: bool,
}
impl<'a> DialogRequestView<'a> {
/// 从 presenter 的请求取视图。
pub(super) fn of(request: &'a unlucky_presenter::dialogs::DialogRequest) -> Self {
Self {
title: &request.title,
body: &request.body,
primary: request.kind.primary_label(),
secondary: request.kind.secondary_label(),
blocking_progress: request.kind.is_blocking_progress(),
}
}
}
/// 失败正文：退出码 + **一句人话原因** + 证据形态。
///
/// 三件事都必须有——用户投诉的原话是「找半天没找到崩溃日志」，所以第三句不是锦上添花：
/// 它要么指向游戏写的那份，要么明确说「这次没有，下面是捕获到的输出」。
fn failure_body(catalog: &Catalog, report: &CrashReport) -> Vec<String> {
let mut body = Vec::new();
if let Some(code) = report.exit_code {
body.push(catalog.render(Key::CrashDialogExitCode, &[("code", &code.to_string())]));
}
if let Some(stage) = &report.stage {
let label = stage_label(catalog, stage);
body.push(catalog.render(Key::CrashDialogStageReason, &[("stage", label)]));
} else if report.exit_code == Some(0) {
body.push(catalog.text(Key::CrashDialogSilentFailure).to_string());
} else {
body.push(catalog.text(Key::CrashDialogStartedThenDied).to_string());
}
body.push(
match report.evidence() {
Evidence::GameCrashReport => catalog.text(Key::CrashDialogCrashReportFound),
Evidence::CapturedOutput => catalog.text(Key::CrashDialogNoGameLog),
Evidence::Nothing => catalog.text(Key::CrashDialogNoLogAtAll),
}
.to_string(),
);
body
}
/// 装配阶段 slug → 文案（**不**复用 core 的中文诊断串）。
fn stage_label(catalog: &Catalog, slug: &str) -> &'static str {
let key = match slug {
"version_manifest" => Key::LaunchStageVersionManifest,
"inheritance" => Key::LaunchStageInheritance,
"instance_config" => Key::LaunchStageInstanceConfig,
"isolation" => Key::LaunchStageIsolation,
"identity" => Key::LaunchStageIdentity,
_ => Key::LaunchStageSpawn,
};
catalog.text(key)
}
/// 路径行（**启动器日志目录 + 该实例 latest.log + crash-reports 目录 + 会话 JSONL**）。
fn path_rows(catalog: &Catalog, report: &CrashReport) -> Vec<(String, String)> {
let mut rows = Vec::new();
if let Some(log) = &report.session_log {
rows.push((
catalog.text(Key::CrashDialogSessionLog).to_string(),
log.display().to_string(),
));
}
if let Some(dir) = &report.launcher_logs {
rows.push((
catalog.text(Key::CrashDialogLauncherLogs).to_string(),
dir.display().to_string(),
));
}
if let Some(path) = report.latest_log_path() {
rows.push((
catalog.text(Key::CrashDialogGameLog).to_string(),
path.display().to_string(),
));
}
if let Some(dir) = report.crash_reports_dir() {
rows.push((
catalog.text(Key::CrashDialogCrashReports).to_string(),
dir.display().to_string(),
));
}
rows
}
/// 详细说明：有崩溃报告贴 Description/栈片段，否则贴启动器捕获的尾巴。
fn detail_of(catalog: &Catalog, card: &CrashCard) -> (Option<String>, Vec<String>) {
let report = &card.report;
if let Some(artifact) = report
.artifacts
.iter()
.find(|artifact| artifact.source == "crash_report")
{
let mut lines = Vec::new();
if let Some(excerpt) = &artifact.excerpt {
lines.extend(excerpt.lines().map(str::to_string));
} else {
lines.push(artifact.path.display().to_string());
}
let title = format!(
"{} {}",
catalog.text(Key::LogsDiagnosisTitle),
artifact.path.display()
);
return (Some(title), lines);
}
if report.stderr_tail.is_empty() {
return (None, Vec::new());
}
let title = catalog.render(
Key::CrashDialogCapturedTail,
&[("count", &report.stderr_tail.len().to_string())],
);
(Some(title), report.stderr_tail.clone())
}
// --------------------------------------------------------------- 与 App 的接线
impl App {
/// 队列当前条 → 视图模型（`view()` 与测试共用同一个入口）。
pub(super) fn dialog_modal(&self) -> Option<Modal> {
let request = self.state.dialogs.current()?;
let view = DialogRequestView::of(request);
let card = self
.dialog_card
.as_ref()
.filter(|card| card.dialog == request.id);
Some(current(self.lang(), &view, card))
}
/// 收到一次启动收尾：失败就弹框（成功不打扰）。
///
/// 只在**真的失败**时弹：`LogOutcome::Ok` 且没有阶段失败 ⇒ 什么都不做，与既有 Toast 口径一致。
pub(super) fn open_failure_dialog(
&mut self,
finished: &unlucky_presenter::dto::LaunchFinished,
) {
let failed = finished.outcome != unlucky_presenter::dto::LogOutcome::Ok
|| finished.failure.is_some();
if !failed {
return;
}
let Some(report) = unlucky_core::launch::crash_report::failing_launch() else {
return;
};
if !finished.session.is_empty() && report.session != finished.session {
// 登记的是另一场（并发启动）：不拿它去解释这一场。
return;
}
let catalog = self.lang().catalog();
let crashed = report.started();
let title = catalog.text(if crashed {
Key::CrashDialogTitleCrashed
} else {
Key::CrashDialogTitleFailed
});
let summary = self.dialog_summary(&report);
let at = self.lang();
let id = self.state.dialogs.push(
DialogSource::UserAction,
title,
summary,
DialogKind::Confirm {
primary: Catalog::of(at).text(Key::CrashDialogExport).to_string(),
secondary: Catalog::of(at).text(Key::CrashDialogClose).to_string(),
},
);
self.dialog_card = Some(CrashCard {
report,
// 默认展开：正文已经说「下面是捕获的最后若干行」，收着就成了空口承诺。
expanded: true,
dialog: id,
outcome: None,
});
self.view_dirty = true;
}
/// 队列标题下的那一行摘要（弹窗正文由 [`current`] 按卡片重算，这里给它一份独立可读的短句）。
fn dialog_summary(&self, report: &CrashReport) -> String {
let catalog = self.lang().catalog();
match report.exit_code {
Some(code) => catalog.render(Key::CrashDialogExitCode, &[("code", &code.to_string())]),
None => catalog.text(Key::CrashDialogTitleFailed).to_string(),
}
}
/// 关掉当前弹窗（主/次按钮、遮罩、`Esc` 共用）。
pub(super) fn close_dialog(&mut self) {
let closed = self.state.dialogs.current().map(|request| request.id);
self.state.dialogs.close_current();
if self
.dialog_card
.as_ref()
.is_some_and(|card| closed == Some(card.dialog))
{
self.dialog_card = None;
}
self.view_dirty = true;
}
/// 展开 / 收起详细说明。
pub(super) fn toggle_dialog_detail(&mut self) {
if let Some(card) = &mut self.dialog_card {
card.expanded = !card.expanded;
self.view_dirty = true;
}
}
}
crates/app-iced/src/app/dialog/export.rs
+205
View File
@@ -0,0 +1,205 @@
//! 失败卡片的三个动作：导出诊断包 / 打开文件夹 / 复制路径。
//!
//! 与 [`super`] 分开是因为职责不同：那边管**弹窗与事实**，这边管**把事实带出界面**。
//! 打包本体在 `unlucky_core::launch::crash_bundle`（脱敏、上限、清单都在那一处），
//! 本文件只负责「放哪、叫什么名字、怎么打开」。
use std::path::PathBuf;
use unlucky_core::launch::crash_bundle::{self, BundleEntry, BundleSpec};
use unlucky_core::launch::crash_report::CrashReport;
use unlucky_i18n::catalog::{Catalog, Key};
use unlucky_i18n::Lang;
/// 一次导出的结论（**成功也带事实**：路径、字节数、有没有文件被截断）。
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Exported {
/// 给用户看的那一句（已本地化）。
pub text: String,
/// 是否成功。
pub ok: bool,
/// 有几个文件被截断（`>0` 时界面要明说「证据是残的」）。
pub truncated: usize,
}
/// 导出诊断包：打到「启动器日志目录 / exports / 一场一个文件名」。
///
/// 返回的那句话说清**落到哪、多少字节**（用户要的第一件事就是「文件在哪」）；
/// 有文件被截断时再补一句——别让用户以为包里的证据是完整的。
pub(crate) fn export(report: &CrashReport, lang: Lang) -> Exported {
let catalog = Catalog::of(lang);
let Some(logs) = &report.launcher_logs else {
return Exported {
text: catalog.render(
Key::CrashDialogExportFailed,
&[("error", "no launcher log dir")],
),
ok: false,
truncated: 0,
};
};
let stamp =
unlucky_core::launch::time::format_rfc3339_millis(unlucky_core::launch::time::now())
.replace([':', '.', 'T'], "-")
.trim_end_matches('Z')
.to_string();
let name = if report.session.is_empty() {
&report.instance
} else {
&report.session
};
let target = crash_bundle::default_target_dir(logs).join(format!("crash-{name}-{stamp}.zip"));
match crash_bundle::write_bundle(&spec_of(report), &target) {
Ok(bundle) => {
let mut text = catalog.render(
Key::CrashDialogExportDone,
&[
("bytes", &bundle.bytes.to_string()),
("path", &bundle.path.display().to_string()),
],
);
if bundle.truncated > 0 {
text.push('\n');
text.push_str(&catalog.render(
Key::CrashDialogExportTruncated,
&[("count", &bundle.truncated.to_string())],
));
}
Exported {
text,
ok: true,
truncated: bundle.truncated,
}
}
Err(error) => Exported {
text: catalog.render(Key::CrashDialogExportFailed, &[("error", &error)]),
ok: false,
truncated: 0,
},
}
}
/// 现场 → 诊断包清单（**进包的东西必须与弹窗上列出的路径一致**）。
fn spec_of(report: &CrashReport) -> BundleSpec {
let mut entries: Vec<BundleEntry> = Vec::new();
let push = |entries: &mut Vec<BundleEntry>, group: &'static str, path: &std::path::Path| {
if path.exists() {
entries.push(BundleEntry::new(group, path));
}
};
if let Some(logs) = &report.launcher_logs {
push(&mut entries, "launcher", &logs.join("launcher.log"));
push(&mut entries, "launcher", &logs.join("launcher.1.log"));
push(&mut entries, "launcher", &logs.join("install.log"));
}
if let Some(session) = &report.session_log {
// 源文件名就是会话 id：钉成 `session.jsonl`，包内名与清单名同时不再泄漏 id，
// 也不会出现「清单写 <redacted:token> 而包里是原始 id」（r1 复审 P2-2）。
if session.exists() {
entries.push(BundleEntry::named("session", session, "session.jsonl"));
}
}
for artifact in &report.artifacts {
// `latest.log` 在下面单独收一次（它同时是扫描结果与固定项，重复收会变成两份）。
if artifact.source != "latest_log" {
push(&mut entries, "game", &artifact.path);
}
}
if let Some(latest) = report.latest_log_path() {
push(&mut entries, "game", &latest);
}
if let Some(json) = &report.version_json {
push(&mut entries, "instance", json);
}
let mut secrets = vec![report.session.clone()];
secrets.retain(|secret| !secret.is_empty());
BundleSpec {
instance: report.name.clone(),
version: report.version.clone(),
session: report.session.clone(),
exit_code: report.exit_code,
exit_type: report.exit_type.clone(),
uptime_ms: report.uptime_ms,
command: report.command.clone(),
java: report.java.clone(),
system: report.system.clone(),
notes: report.note_lines(),
missing: report.missing_lines(),
entries,
secrets,
home: std::env::var("USERPROFILE")
.or_else(|_| std::env::var("HOME"))
.ok()
.map(PathBuf::from),
}
}
/// 打开「日志文件夹」：有现场就开实例运行目录，否则开启动器日志目录。
///
/// 平台差异只在这里一处（`explorer` / `open` / `xdg-open`），不往业务代码里散写 `cfg`。
pub(crate) fn open_folder(report: &CrashReport, lang: Lang) -> String {
let catalog = Catalog::of(lang);
let target = report
.run_dir
.clone()
.filter(|dir| dir.is_dir())
.or_else(|| report.launcher_logs.clone().filter(|dir| dir.is_dir()));
let Some(dir) = target else {
return catalog.render(
Key::CrashDialogOpenFailed,
&[("error", "no folder on disk")],
);
};
match open_dir(&dir) {
Ok(()) => String::new(),
Err(error) => catalog.render(Key::CrashDialogOpenFailed, &[("error", &error)]),
}
}
/// 打开一个目录（M188：设置页/日志页的「打开日志文件夹」也走这里，**不再另写一套 `cfg`**）。
///
/// 失败文本带完整路径：调用方把它显示/记日志出来，用户至少能照着路径去找。
pub(crate) fn open_dir(dir: &std::path::Path) -> Result<(), String> {
if !dir.is_dir() {
return Err(format!("{}（目录不存在）", dir.display()));
}
spawn_opener(dir).map_err(|error| format!("{}（打开失败：{error}）", dir.display()))
}
#[cfg(target_os = "windows")]
fn spawn_opener(dir: &std::path::Path) -> Result<(), String> {
// `explorer` 不用 shell：路径里的空格与 `&` 不会被当成命令分隔符。
std::process::Command::new("explorer")
.arg(dir)
.spawn()
.map(|_| ())
.map_err(|error| error.to_string())
}
#[cfg(target_os = "macos")]
fn spawn_opener(dir: &std::path::Path) -> Result<(), String> {
std::process::Command::new("open")
.arg(dir)
.spawn()
.map(|_| ())
.map_err(|error| error.to_string())
}
#[cfg(not(any(target_os = "windows", target_os = "macos")))]
fn spawn_opener(dir: &std::path::Path) -> Result<(), String> {
std::process::Command::new("xdg-open")
.arg(dir)
.spawn()
.map(|_| ())
.map_err(|error| error.to_string())
}
/// 「复制路径」的一段文本（每条一行，标签 + 路径）。
pub(crate) fn paths_text(report: &CrashReport) -> String {
report
.path_lines()
.into_iter()
.map(|(label, path)| format!("{label}: {}", path.display()))
.collect::<Vec<_>>()
.join("\n")
}
crates/app-iced/src/app/dialog/tests.rs
+344
View File
@@ -0,0 +1,344 @@
//! 弹窗的三条守卫：**队列真的被消费**、**运行时中文真的进了正文**、**两种失败说两句话**。
//!
//! ## 这些用例抓得住什么 / 抓不住什么（说在明处）
//!
//! | 用例 | 抓得住 | 抓不住 |
//! |---|---|---|
//! | [`queue_drives_the_modal_through_refresh_view`] | 队列里有请求 ⇒ `refresh_view` 之后 `view()` 拿到的模型里就有它（把消费点删掉即红） | 像素：`view()` 是否真的把控件塞进 iced 树（由 `DevDocs/artifacts/m187/` 的截图守） |
//! | [`runtime_chinese_reaches_the_body`] | 运行时拼出来的中文（`render` / `format!` 的 owned 串）确实在正文里 | 字形是否栅格化出来（同上，wgpu / tiny-skia 并排图） |
//! | [`two_failure_shapes_say_two_different_things`] | 没有 crash-report 时**不会**说成「有崩溃报告」，而且必须贴出捕获行 | 那句话读起来顺不顺（review） |
//!
//! 「owned 文字在 wgpu 下丢字」这条 M190 的怀疑在本 branch 上**没有复现**（A/B 图见
//! `DevDocs/artifacts/m187/ab-wgpu.png` 与 `ab-tinyskia.png`）：同一串中文走 `text_role` 与
//! `text_role_owned` 在两种后端下逐字相同。所以这里不编一条「为了变绿而改渲染路径」的断言。
use std::path::PathBuf;
use unlucky_core::launch::crash_report::{self, ArtifactFact, CrashReport};
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use unlucky_presenter::dialogs::{DialogKind, DialogQueue, DialogSource};
use unlucky_presenter::dto::{LaunchFinished, LogOutcome};
use super::{current, path_rows, CrashCard, DialogRequestView};
use crate::app::state::App;
use crate::cli::Options;
use crate::theme::Families;
const FAMILIES: Families = Families {
text: "Segoe UI",
display: "Segoe UI",
mono: "Consolas",
};
fn headless() -> App {
use unlucky_presenter::mock::MockBackend;
use unlucky_presenter::settings_bridge::SettingsBridge;
App::with_presenter(
Options::default(),
FAMILIES,
unlucky_design::color::SchemeFlavor::Light,
Box::new(MockBackend::new()),
SettingsBridge::memory_only(),
)
}
fn report(with_crash_report: bool, tail: Vec<String>) -> CrashReport {
let run_dir = PathBuf::from("/instances/survival");
let artifacts = if with_crash_report {
vec![ArtifactFact {
source: "crash_report".to_string(),
path: run_dir.join("crash-reports/crash-2026-11-08.txt"),
excerpt: Some("Description: Initializing game".to_string()),
}]
} else {
Vec::new()
};
CrashReport {
instance: "survival".to_string(),
name: "生存".to_string(),
version: "1.20.4-fabric".to_string(),
session: "9f2c".to_string(),
session_log: Some(PathBuf::from("/sessions/game/9f2c.jsonl")),
version_json: Some(PathBuf::from("/game/versions/1.20.4/1.20.4.json")),
launcher_logs: Some(PathBuf::from("/logs")),
run_dir: Some(run_dir),
artifacts,
exit_code: Some(1),
exit_type: "application_error".to_string(),
uptime_ms: 1_000,
command: "javaw -Xmx4096m".to_string(),
java: "javaw.exe (21)".to_string(),
system: "os=windows".to_string(),
stage: None,
stage_detail: None,
stderr_tail: tail,
}
}
/// 守卫①：队列消费。请求进队列 ⇒ `refresh_view` 之后模型里有它；空队列 ⇒ 没有。
///
/// **变异证明**：把 `refresh_view` 末尾那行 `self.dialog_model = self.dialog_modal();` 删掉，
/// 本用例第二段立刻红（`dialog_model` 恒 `None`）。
#[test]
fn queue_drives_the_modal_through_refresh_view() {
let mut app = headless();
app.refresh_view();
assert!(
app.dialog_model.is_none(),
"空队列不该画任何弹窗（现状：队列零引用，弹窗从不渲染）"
);
let title = app.lang().catalog().text(Key::CrashDialogTitleFailed);
app.state.dialogs.push(
DialogSource::UserAction,
title,
"正文一行",
DialogKind::Confirm {
primary: "主要".to_string(),
secondary: "次要".to_string(),
},
);
app.view_dirty = true;
app.refresh_view();
let modal = app.dialog_model.as_ref().expect("队列里有请求就必须有模型");
assert_eq!(modal.title, title);
assert_eq!(modal.primary, "主要");
assert_eq!(modal.secondary.as_deref(), Some("次要"));
}
/// 守卫②：**运行时拼出来的中文**必须真的进正文（owned 串走 `Catalog::render` / `format!`）。
///
/// **变异证明**：把 `failure_body` 里的 `catalog.render(Key::CrashDialogExitCode, …)` 换成固定
/// 英文，本用例第一处断言立刻红。
#[test]
fn runtime_chinese_reaches_the_body() {
let lang = Lang::ZhCn;
let card = CrashCard {
report: report(false, vec!["java.lang.RuntimeException: boom".to_string()]),
expanded: true,
dialog: 1,
outcome: None,
};
let mut queue = DialogQueue::new();
queue.push(
DialogSource::UserAction,
"游戏崩溃",
"",
DialogKind::Confirm {
primary: String::new(),
secondary: String::new(),
},
);
let request = queue.current().expect("当前条");
let view = DialogRequestView::of(request);
let modal = current(lang, &view, Some(&card));
let body = modal.body_text();
// 退出码那句是 `render`（带参数）拼出来的：必须带中文与数字。
assert!(body.contains("退出码 1"), "{body}");
assert!(body.contains("游戏进程起来了"), "{body}");
// 没有 crash-report 时必须说「没生成」+「下面是捕获的行」。
assert!(body.contains("没有生成崩溃报告"), "{body}");
assert!(body.contains("捕获"), "{body}");
// 英文界面里同样的三句不许出现中文（反向守卫：i18n 不是只往一个方向写）。
let en = current(Lang::En, &view, Some(&card));
assert!(!en.body_text().contains('崩'), "{}", en.body_text());
}
/// 守卫③：两种失败**说两句不同的话**，而且都可以导出（事实齐全）。
#[test]
fn two_failure_shapes_say_two_different_things() {
let lang = Lang::ZhCn;
let with = report(true, vec!["stack line".to_string()]);
let without = report(false, vec!["Error: could not find java.dll".to_string()]);
assert_ne!(with.evidence(), without.evidence());
let with_card = CrashCard {
report: with.clone(),
expanded: true,
dialog: 1,
outcome: None,
};
let without_card = CrashCard {
report: without.clone(),
expanded: true,
dialog: 1,
outcome: None,
};
let mut queue = DialogQueue::new();
queue.push(
DialogSource::UserAction,
"t",
"",
DialogKind::Error {
primary: "p".to_string(),
hint: None,
},
);
let request = queue.current().unwrap();
let view = DialogRequestView::of(request);
let crash = current(lang, &view, Some(&with_card));
let no_log = current(lang, &view, Some(&without_card));
assert_ne!(crash.body_text(), no_log.body_text());
assert!(crash.body_text().contains("写出了崩溃报告"));
assert!(!no_log.body_text().contains("写出了崩溃报告"));
// 没有 crash-report 的那一态仍然有可展开的细节（贴的是捕获行）与四条路径。
assert!(no_log.card.as_ref().expect("卡片").detail_title.is_some());
assert_eq!(path_rows(&lang.catalog(), &without).len(), 4);
assert!(path_rows(&lang.catalog(), &without)
.iter()
.any(|(_, path)| path.ends_with("latest.log")));
}
/// 弹窗开/关与卡片的绑定：关掉之后两样都要空（否则下一次失败会读到上一次的现场）。
#[test]
fn closing_the_dialog_clears_the_card() {
let mut app = headless();
crash_report::publish(report(false, vec!["line".to_string()]));
let finished = LaunchFinished {
id: "survival".to_string(),
session: "9f2c".to_string(),
outcome: LogOutcome::Crashed,
exit_code: Some(1),
uptime_ms: 1_000,
failure: None,
};
app.open_failure_dialog(&finished);
assert!(app.state.dialogs.current().is_some(), "失败必须弹框");
assert!(app.dialog_card.is_some());
app.close_dialog();
assert!(app.state.dialogs.current().is_none());
assert!(app.dialog_card.is_none());
}
/// 成功收尾不打扰用户。
#[test]
fn a_successful_launch_does_not_pop_anything() {
let mut app = headless();
crash_report::publish(report(false, Vec::new()));
let finished = LaunchFinished {
id: "survival".to_string(),
session: "9f2c".to_string(),
outcome: LogOutcome::Ok,
exit_code: Some(0),
uptime_ms: 90_000,
failure: None,
};
app.open_failure_dialog(&finished);
assert!(app.state.dialogs.current().is_none());
}
/// P2-1：**卡片那一层只能是卡片大**。
///
/// 抓得住什么：r1 复审实测的那个 bug —— `mouse_area(整窗居中容器)` 的命中区是整窗，
/// 卡片外任何一次点击都先被它捕获，遮罩永远收不到（「点遮罩关闭」形同虚设）。
/// `Widget::size_hint()` 不需要渲染器就能问，所以这条能在单测里跑：卡片层若声明
/// `Fill`/`Fill`，就等于「命中区 = 整窗」。
///
/// **抓不住什么**：端到端指针派发（本仓没有事件 harness，`Element` 的 `layout`/`update`
/// 需要真渲染器）。所以这条守的是**结构属性**，不是「点一下真的关了」。
#[test]
fn the_card_layer_is_card_sized_so_the_backdrop_can_be_clicked() {
use iced::Length;
let mut app = headless();
app.state.dialogs.push(
DialogSource::UserAction,
"t",
"b",
DialogKind::Confirm {
primary: "p".to_string(),
secondary: "s".to_string(),
},
);
let modal = {
let request = app.state.dialogs.current().expect("当前条");
let view = DialogRequestView::of(request);
super::current(app.lang(), &view, None)
};
let plane = super::view::card_plane(app.ui(), &modal);
let hint = iced::advanced::Widget::size_hint(plane.as_widget());
// 任一维是 `Fill` 就意味着「跟随父级 = 整窗」（外层是 Fill 的居中容器），
// 命中区于是变成整窗 —— 那正是 r1 抓到的原实现。
assert_ne!(
hint.width,
Length::Fill,
"卡片层宽度不能 Fill（会撑成整窗）"
);
assert_ne!(
hint.height,
Length::Fill,
"卡片层高度不能 Fill（会撑成整窗）"
);
}
/// P1-1：遮罩必须是**不透明预合成**，而且两档都**压暗**（深色档尤其）。
///
/// 抓得住 r1 实测的那个 p1：`Role::OnSurface @ 32%` 在深色档是「近白 @32%」⇒ 遮罩把整窗
/// 提亮（实测 (9,21,28) → (129,138,145)）。这里用亮度直接判方向：遮罩必须比画布暗。
///
/// 抓不住：具体色值对不对（那是令牌层的事）。
#[test]
fn the_backdrop_is_an_opaque_precomposite_and_darkens_both_flavors() {
use unlucky_design::color::{Role, SchemeFlavor};
use unlucky_design::elevation::MaterialLayer;
use unlucky_design::typography::Platform;
let luma = |color: iced::Color| 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
for flavor in [SchemeFlavor::Light, SchemeFlavor::Dark] {
let ui = crate::theme::Ui::with_platform(flavor, Platform::Windows, FAMILIES);
// 断言**视图真正用的那一份**（不是组件层的默认值）：改回「OnSurface @32%」这里就红。
let backdrop = super::view::backdrop_color(&ui);
assert_eq!(
backdrop.a, 1.0,
"{flavor:?}：遮罩必须是不透明预合成（D27：CPU 档零半透明）"
);
let canvas = crate::theme::to_iced(
unlucky_design::color::Scheme::baseline(flavor)
.get(MaterialLayer::Canvas.surface_role()),
);
assert!(
luma(backdrop) < luma(canvas),
"{flavor:?}：遮罩必须比画布暗（当前 lane {:.3} vs 画布 {:.3}）—— 用 Role::OnSurface 当遮罩会在深色档把整窗提亮",
luma(backdrop),
luma(canvas)
);
assert_eq!(Role::Surface, MaterialLayer::Canvas.surface_role());
}
}
/// P2-4：启动那一拍的**事实**确实进了启动器日志（登记目录后一次刷出）。
///
/// 抓得住：记录函数被拆掉/改空（缓冲里就什么都没有）。
/// 抓不住：`on_boot` 有没有调它 —— 那靠这条用例旁边的调用点与 `host/launch.rs` 的 `set_dir`，
/// 真机第一次崩溃才是最终验收闸门（复审与我的一致口径）。
#[test]
fn boot_facts_are_recorded_into_the_launcher_log() {
// 与 `app/diag.rs` 的滚动闸串行：两条用例都动同一个进程级单例目录。
let _guard = crate::app::diag::LOG_STATE_LOCK
.lock()
.unwrap_or_else(|error| error.into_inner());
let dir = std::env::temp_dir().join(format!("ull-m187-bootlog-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).expect("建目录");
unlucky_core::launch::launcher_log::set_dir(&dir);
let app = headless();
crate::app::update::boot_env::record_boot_log(&app);
let path = dir.join(unlucky_core::launch::launcher_log::FILE_NAME);
let text = std::fs::read_to_string(&path).expect("launcher.log");
assert!(text.contains("[boot] app boot"), "{text}");
assert!(text.contains("theme="), "{text}");
assert!(text.contains("window="), "{text}");
}
#[path = "tests/export.rs"]
mod export;
crates/app-iced/src/app/dialog/tests/export.rs
+85
View File
@@ -0,0 +1,85 @@
//! 导出的用例：真的落盘、真的报字节数、真的在有截断时说一句。
//!
//! 从 `tests.rs` 拆出（那个文件贴着 400 行硬线）。共用父模块的 `report()` 夹具。
use unlucky_i18n::Lang;
use super::report;
use crate::app::dialog::export;
/// 导出：真的落盘、真的报出路径与字节数（**没有 crash-report 也要能导出**）。
#[test]
fn export_writes_a_bundle_even_without_a_crash_report() {
let root = std::env::temp_dir().join(format!("ull-m187-export-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("logs")).expect("建目录");
std::fs::write(root.join("logs").join("launcher.log"), "[launch] boom\n").expect("写日志");
let mut spec_report = report(false, vec!["Error: boom".to_string()]);
spec_report.launcher_logs = Some(root.join("logs"));
spec_report.session_log = None;
spec_report.run_dir = None;
spec_report.version_json = None;
let done = export::export(&spec_report, Lang::ZhCn);
let text = done.text.clone();
assert!(done.ok, "{text}");
assert_eq!(done.truncated, 0);
assert!(text.contains("已导出"), "{text}");
assert!(text.contains("字节"), "{text}");
let exports = root.join("logs").join("exports");
let files: Vec<_> = std::fs::read_dir(&exports)
.expect("导出目录")
.filter_map(Result::ok)
.collect();
assert_eq!(files.len(), 1, "一次导出只该落一个包");
let size = files[0].metadata().expect("元数据").len();
assert!(size > 0, "包不该是空文件");
assert!(
text.contains(&size.to_string()),
"报出来的字节数要与磁盘一致：{text} / {size}"
);
}
/// P3-4：`truncated > 0` 时**界面上那一句**真的出现（r2 复审登记的那条没有用例）。
///
/// 抓得住：把 `Exported.text` 里「有文件被截断」那句删掉/短路（变异证明见报告）。
/// 抓不住：那句话排版好不好看（视觉）。
#[test]
fn a_truncated_export_says_so_in_the_notice() {
use unlucky_core::launch::crash_bundle::MAX_ENTRY_BYTES;
let root = std::env::temp_dir().join(format!("ull-m187-trunc-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("logs")).expect("建目录");
std::fs::create_dir_all(root.join("game").join("logs")).expect("建目录");
std::fs::write(root.join("logs").join("launcher.log"), "boot\n").expect("写日志");
// 略超上限的 latest.log：必须用**真实日志行**填充 —— 同一字符的 4 MiB 会被
// 「长不透明串」脱敏规则整段替换成占位符，长度就不超限了（那测的是脱敏不是截断）。
let line = "2026-11-08T15:30:12.441Z [Render thread/INFO]: loading chunk\n";
let mut big = String::new();
while big.len() < usize::try_from(MAX_ENTRY_BYTES).expect("常数") + 256 {
big.push_str(line);
}
std::fs::write(root.join("game").join("logs").join("latest.log"), &big).expect("写大日志");
let mut report = report(false, Vec::new());
report.launcher_logs = Some(root.join("logs"));
report.run_dir = Some(root.join("game"));
report.session_log = None;
report.version_json = None;
let done = export::export(&report, Lang::ZhCn);
assert!(done.ok, "{}", done.text);
assert_eq!(
done.truncated, 1,
"这份 latest.log 必须真的被截断（>4 MiB）"
);
assert!(
done.text.contains("已截断"),
"界面上没有说「有文件被截断」：{}",
done.text
);
}
crates/app-iced/src/app/dialog/view.rs
+299
View File
@@ -0,0 +1,299 @@
//! 模态层的控件树：**遮罩 + 卡片 + 主/次按钮**，正文与路径全部来自 [`super::Modal`]。
//!
//! ## 命中语义（为什么点遮罩能关、点卡片不关）
//!
//! `iced::widget::Stack` 的 `update` 从上往下（后画的先收）派发，遇到 `shell.is_event_captured()`
//! 立刻停。所以三层的顺序是：
//!
//! ```text
//! stack![ 页面树, 遮罩（mouse_area→Dismiss，整窗）, 居中容器（透明）→ opaque(卡片) ]
//! ```
//!
//! 卡片那层用 `opaque` 把卡片内的左键按下**吃掉**（[`super::Message`] 不需要再有一条专用
//! 消息），于是点卡片里的空白不会冒到遮罩去关框；卡片里的按钮自己会先捕获。
//! **`opaque` 只包卡片**是这条语义成立的前提：包住整窗居中容器的话，命中区就变成整窗，
//! 遮罩永远收不到按下（r1 复审 P2-1 抓到的原实现）。
use iced::widget::text::LineHeight;
use iced::widget::{button, column, container, mouse_area, row, scrollable, text, Space};
use iced::{Alignment, Background, Border, Color, Element, Font, Length, Pixels, Shadow};
use unlucky_design::color::Role;
use unlucky_design::component_map::Component;
use unlucky_design::elevation::MaterialLayer;
use unlucky_design::spacing::Space as Sp;
use unlucky_design::typography::TypeRole;
use crate::app::components::buttons;
use crate::app::components::feedback::dialog::scrim;
use crate::app::components::feedback::panel::DialogGeometry;
use crate::pages::frame;
use crate::theme::Ui;
use super::super::message::Message;
use super::{Message as DialogMessage, Modal};
/// 卡片内**滚动区**高度（详情 + 路径在这里滚；页脚按钮永远在卡片里）。
const SCROLL_HEIGHT: f32 = 300.0;
/// 有导出结论时滚动区让出的高度（那一段会多占两行，不让就只能压扁页脚按钮）。
const SCROLL_HEIGHT_WITH_NOTICE: f32 = 210.0;
/// 卡片最大高（兜底：不许把边框撑出屏幕）。
const CARD_HEIGHT: f32 = 660.0;
/// 把模态层叠在 `base` 上（没有弹窗时由调用方原样返回 `base`，这里是纯叠加）。
///
/// ## 三层的命中语义（r1 复审 P2-1 的修法）
///
/// ```text
/// stack![ 页面树, 遮罩(mouse_area→Dismiss, 整窗), 居中容器(透明) → opaque(卡片) ]
/// ```
///
/// 关键在于**卡片那层只有卡片那么大**：`opaque(卡片)` 的命中区就是卡片本身，点卡片里
/// 只会被它吃掉（`shell.capture_event`），点卡片外则**继续往下走**到遮罩 → `Dismiss`。
/// 反例（r1 抓到的原实现）：`mouse_area(整窗居中容器).on_press(Swallow)` —— 整窗都在它
/// 的 bounds 里，任何一次卡片外点击都先被它捕获，遮罩永远收不到，于是「点遮罩关闭」
/// 只存在于注释里。
pub(crate) fn layer<'a>(
ui: &'a Ui,
base: Element<'a, Message>,
modal: &'a Modal,
) -> Element<'a, Message> {
let backdrop = mouse_area(
container(Space::new())
.width(Length::Fill)
.height(Length::Fill)
.style(move |_theme| container::Style {
background: Some(Background::Color(backdrop_color(ui))),
..container::Style::default()
}),
)
.on_press(Message::Dialog(DialogMessage::Dismiss));
// 透明的一层只负责居中；会吃点击的 `opaque` 只包卡片。
let centered = container(card_plane(ui, modal))
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Center)
.align_y(Alignment::Center)
.padding(ui.space(Sp::X6));
iced::widget::stack![base, backdrop, centered].into()
}
/// 遮罩色：**组件层那一份不透明预合成**（黑 @0.32 叠在画布上）。
///
/// 为什么不自己拿 `Role::OnSurface` 加 α：它在深色档是 **tone 90（近白）**，32% 铺上去会把
/// 整窗**提亮**（r1 复审实测 (9,21,28) → (129,138,145)）；而且 α 混色在 wgpu/tiny-skia 两档
/// 合成口径不同（linear vs sRGB），D27 要求 CPU 档零半透明。组件层 [`scrim`] 两件事都解决了。
///
/// 单独成函数是为了让 [`super::tests`] 断言**视图真正用的那一份**（P1 的守卫）。
pub(super) fn backdrop_color(ui: &Ui) -> Color {
scrim(ui)
}
/// 卡片层：`opaque` 让「卡片内的点击」被吃掉，不再冒到遮罩（点遮罩才关）。
///
/// 可见性放宽到 `pub(super)` 只为让 [`super::tests`] 能断言它的 `size_hint`（P2-1 的守卫）。
pub(super) fn card_plane<'a>(ui: &'a Ui, modal: &'a Modal) -> Element<'a, Message> {
iced::widget::opaque(card(ui, modal))
}
/// 卡片本体（**尺寸 = 内容**，不声明 `Fill` —— 见 [`layer`] 的命中语义）。
fn card<'a>(ui: &'a Ui, modal: &'a Modal) -> Element<'a, Message> {
// 几何全部走组件层（r1 复审 P1 的纪律项：别绕过现成的 Dialog 档）。
let geometry = DialogGeometry::of(ui);
let shape = Component::Dialog.spec().shape;
// 头（标题 + 三句正文）与脚（按钮）**固定**，中间那段滚——按钮滚出屏幕等于功能不存在
// （视觉复审在日志页踩过同一坑：诊断卡把摘要页脚顶出去了）。
let mut header = column![].spacing(ui.space(Sp::X2)).width(Length::Fill);
header = header.push(role(
ui,
TypeRole::HeadlineSmall,
true,
modal.title.as_str(),
));
for line in &modal.body {
header = header.push(wrapped(ui, line.as_str(), ui.color(Role::OnSurface)));
}
let mut middle = column![].spacing(ui.space(Sp::X2)).width(Length::Fill);
if let Some(card) = &modal.card {
// **详细说明在前、路径在后**：用户先要知道「发生了什么」，再要「文件在哪」。
if card.expanded {
if let Some(title) = &card.detail_title {
middle = middle.push(role(ui, TypeRole::LabelMedium, false, title.as_str()));
}
for line in &card.detail_lines {
middle = middle.push(mono(ui, line.clone()));
}
middle = middle.push(frame::divider(ui).map(Message::Page));
}
for (index, (label, path)) in card.paths.iter().enumerate() {
middle = middle.push(
button(
column![
role(ui, TypeRole::LabelMedium, false, label.as_str()),
mono(ui, path.clone()),
]
.spacing(0.0)
.width(Length::Fill),
)
.width(Length::Fill)
.padding(0)
.style(|_theme, _status| button::Style {
background: None,
text_color: Color::TRANSPARENT,
border: Border::default(),
shadow: Shadow::default(),
snap: true,
})
.on_press(Message::Dialog(DialogMessage::CopyPath(index))),
);
}
}
let mut footer = column![].spacing(ui.space(Sp::X1)).width(Length::Fill);
if let Some(notice) = &modal.notice {
footer = footer.push(wrapped(ui, notice.as_str(), ui.color(Role::Primary)));
}
footer = footer.push(actions(ui, modal));
// 中间那段给**定高**预算：`Shrink` 会让滚动区按内容高排版，把页脚顶到卡片外面
// （实测第一版就是这样：导出/关闭两个按钮整排不可见）。
let body = if modal.card.is_some() {
column![
header,
scrollable(middle).height(Length::Fixed(if modal.notice.is_some() {
SCROLL_HEIGHT_WITH_NOTICE
} else {
SCROLL_HEIGHT
})),
frame::divider(ui).map(Message::Page),
footer,
]
} else {
column![header, frame::divider(ui).map(Message::Page), footer,]
}
.spacing(ui.space(Sp::X3))
.width(Length::Fill);
// 宽度取官方**上限** 560（`DialogGeometry::max_width`）而不是本项目默认 480：
// 崩溃卡片多两行路径 + 三枚辅助按钮，480 会把主按钮压成竖排（实测过）。
// 边界：组件层日后若改宽度，这里不会跟（已记 P3 台账）。
container(body)
.width(Length::Fixed(geometry.max_width))
.max_height(CARD_HEIGHT)
.padding(geometry.padding)
.style(move |_theme| container::Style {
background: Some(Background::Color(ui.layer(MaterialLayer::Overlay))),
border: ui.outlined(shape),
..container::Style::default()
})
.into()
}
/// 底部按钮区：**两行**——辅助操作（开文件夹 / 复制路径 / 展开）在上，主次按钮在下靠右。
///
/// 为什么分两行：五个按钮塞一行在 560 的卡宽里会把主按钮压成竖排（实测第一版就是这样，
/// 「导出诊断包」被挤成两行单字）。
fn actions<'a>(ui: &'a Ui, modal: &'a Modal) -> Element<'a, Message> {
let mut column_actions = column![].spacing(ui.space(Sp::X2)).width(Length::Fill);
if let Some(card) = &modal.card {
column_actions = column_actions.push(
row![
buttons::outlined(
ui,
buttons::Button::new(
card.actions[1].as_str(),
Message::Dialog(DialogMessage::OpenFolder),
),
),
buttons::outlined(
ui,
buttons::Button::new(
card.actions[2].as_str(),
Message::Dialog(DialogMessage::CopyPaths),
),
),
buttons::text(
ui,
buttons::Button::new(
card.toggle.as_str(),
Message::Dialog(DialogMessage::Toggle),
),
),
]
.spacing(ui.space(Sp::X2))
.align_y(Alignment::Center),
);
}
let mut line = row![Space::new().width(Length::Fill)].spacing(ui.space(Sp::X2));
if let Some(secondary) = &modal.secondary {
line = line.push(buttons::text(
ui,
buttons::Button::new(
secondary.as_str(),
Message::Dialog(DialogMessage::Secondary),
),
));
}
if !modal.blocking_progress {
line = line.push(buttons::filled(
ui,
buttons::Button::new(
modal.primary.as_str(),
Message::Dialog(DialogMessage::Primary),
),
));
}
column_actions.push(line.align_y(Alignment::Center)).into()
}
/// 令牌排版档的文字（`pages::frame` 的那一套，映射成本层的消息类型）。
fn role<'a>(
ui: &'a Ui,
role: TypeRole,
emphasized: bool,
content: &'a str,
) -> Element<'a, Message> {
frame::text_role(
ui,
role,
emphasized,
content,
ui.color(Role::OnSurfaceVariant),
)
.map(Message::Page)
}
/// 等宽文字（路径 / 堆栈 / 捕获输出——这些必须能一眼看出字符边界）。
fn mono<'a>(ui: &'a Ui, content: String) -> Element<'a, Message> {
let style = ui.style(TypeRole::BodySmall);
text(content)
.size(style.size_px)
.line_height(LineHeight::Absolute(Pixels(style.line_height_px)))
.font(Font {
family: iced::font::Family::Name(ui.families().mono),
..Font::DEFAULT
})
.color(ui.color(Role::OnSurface))
.width(Length::Fill)
.wrapping(iced::widget::text::Wrapping::WordOrGlyph)
.into()
}
/// 正文一段：令牌排版档 + 按词折行（长路径只按词折会把卡片顶破）。
fn wrapped<'a>(ui: &'a Ui, content: &'a str, color: Color) -> Element<'a, Message> {
let style = ui.style(TypeRole::BodyMedium);
text(content)
.size(style.size_px)
.line_height(LineHeight::Absolute(Pixels(style.line_height_px)))
.font(ui.font_of(style))
.color(color)
.width(Length::Fill)
.wrapping(iced::widget::text::Wrapping::WordOrGlyph)
.into()
}
crates/app-iced/src/app/logs_folder.rs
+121
View File
@@ -0,0 +1,121 @@
//! 「日志文件夹」在 app 侧的唯一解析口（M188）：路径从哪来、点了按钮之后开哪个目录。
//!
//! ## 为什么不在页面里现拼路径
//!
//! 日志根 = `<启动器数据目录>/logs`，而「启动器数据目录」是三模式解析（便携 / 标准 / 自定义）
//! 的结果。那条解析链只有一份实现（`core::platform::data_dir` + `presenter::settings_bridge`），
//! 页面若自己拼 `exe_dir/.ULL/logs`，标准模式与自定义模式的用户就会看到一个**不存在的目录**。
//!
//! 本模块只做两件事：
//!
//! 1. 从设置桥给定的 `config/launcher.json` 反推 `<home>`，再用 `LauncherLayout::logs()` 取分区
//! （分区名只从 core 的 `layout` 来，不手拼字符串）；
//! 2. 打开前先确认目录真的在（不在就建），失败时给出的文本**带完整路径**——用户至少能照着去翻。
//!
//! ## 谁来登记
//!
//! `App::new` 拿到设置桥之后调 [`register`]：那是本进程唯一知道「实际生效的数据根」的地方
//! （`--data-dir` 也在这里生效）。没登记时（`pages_demo` 出图通道、单测）退回
//! `platform::data::layout()`——同一份解析链的缓存版本。
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use unlucky_core::platform::layout::LauncherLayout;
use unlucky_presenter::settings_bridge::SettingsBridge;
static LOGS_DIR: OnceLock<Option<PathBuf>> = OnceLock::new();
/// `<home>/config/launcher.json` → `<home>/logs`（**只有**这一条形状，别处不许手拼）。
pub(crate) fn logs_dir_of(config: &Path) -> Option<PathBuf> {
let home = config.parent()?.parent()?;
Some(LauncherLayout::new(home).logs())
}
/// 登记本进程的日志目录（`App::new` 在第一帧之前调一次；重复调用以**第一次**为准）。
pub(crate) fn register(bridge: &SettingsBridge) {
let _ = LOGS_DIR.set(bridge.path().and_then(logs_dir_of));
}
/// 本进程的日志目录。
///
/// - 已登记且解析出来 ⇒ 那条；
/// - 已登记但解析不出来（内存态桥）⇒ `None`：页面照实说「数据根没解析出来」，不猜一个目录；
/// - 还没登记（`pages_demo` / 单测）⇒ 退回 `platform::data::layout()`。
pub(crate) fn logs_dir() -> Option<PathBuf> {
match LOGS_DIR.get() {
Some(known) => known.clone(),
None => crate::platform::data::layout().map(|layout| layout.logs()),
}
}
/// 确保日志目录存在（不在就建），返回给用户看的路径。
///
/// 失败文本里**带完整路径**：界面把这段话原样显示出来，用户能复制去自己找。
pub(crate) fn prepare(dir: &Path) -> Result<PathBuf, String> {
std::fs::create_dir_all(dir)
.map_err(|error| format!("{}（这个目录建不出来：{error}）", dir.display()))?;
if !dir.is_dir() {
return Err(format!("{}（这个路径不是一个目录）", dir.display()));
}
Ok(dir.to_path_buf())
}
/// 打开日志文件夹：解析 → 确保存在 → 交给平台打开器。
///
/// # Errors
///
/// 返回的文本永远带路径（`...logs` 那一串），可以直接贴给用户/贴进 issue。
pub(crate) fn open() -> Result<PathBuf, String> {
let dir = logs_dir().ok_or_else(|| {
"日志目录：数据根没解析出来（启动器拿不到自己所在的目录；用 --data-dir 指定一个）"
.to_string()
})?;
let dir = prepare(&dir)?;
crate::app::dialog::export::open_dir(&dir)?;
Ok(dir)
}
#[cfg(test)]
mod tests {
use super::*;
/// 落点形状：`<home>/config/launcher.json` → `<home>/logs`。
///
/// 变异证明：把 `logs_dir_of` 里的 `LauncherLayout::logs` 换成 `cache`，这条立刻红。
#[test]
fn the_log_folder_is_the_logs_partition_next_to_config() {
let config = PathBuf::from("/tmp/ull-home/.ULL/config/launcher.json");
assert_eq!(
logs_dir_of(&config),
Some(PathBuf::from("/tmp/ull-home/.ULL/logs"))
);
// 少了 config 那一层就没有 `<home>` 可言：宁可不猜。
assert_eq!(logs_dir_of(Path::new("launcher.json")), None);
}
/// **目录真的存在**（守门③）：`prepare` 在不在时把它建出来，并且返回同一个路径。
///
/// 变异证明：删掉 `create_dir_all` 那一行，`is_dir` 立刻为假。
#[test]
fn prepare_creates_the_folder_and_reports_the_same_path() {
let root = std::env::temp_dir().join(format!("ull-logs-folder-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
let dir = root.join(".ULL/logs");
assert!(!dir.is_dir(), "夹具目录不该已经存在");
let prepared = prepare(&dir).expect("应当建得出来");
assert_eq!(prepared, dir);
assert!(dir.is_dir(), "打开之前必须真的存在");
std::fs::remove_dir_all(&root).ok();
}
/// 失败文本带路径（「不许只在成功时可用」）。
#[test]
fn a_failure_names_the_path_it_could_not_use() {
let file = std::env::temp_dir().join(format!("ull-logs-notadir-{}", std::process::id()));
std::fs::write(&file, b"x").expect("写夹具");
let error = prepare(&file).expect_err("一个文件不是目录");
assert!(error.contains(&file.display().to_string()), "{error}");
std::fs::remove_file(&file).ok();
}
}
crates/app-iced/src/app/message.rs
+2
View File
@@ -67,6 +67,8 @@ pub enum Message {
Captured(window::Screenshot),
/// gallery（组件库 harness）里的演示交互。
Demo(components::gallery::DemoMessage),
/// 模态对话框（M187）：主/次按钮、遮罩、展开、导出、打开文件夹、复制路径。
Dialog(super::dialog::Message),
}
/// 外壳导航项 → 路由（导航项只在一级页之间有对应；AI 项对应 [`Route::Agent`]）。
crates/app-iced/src/app/mod.rs
+3
View File
@@ -30,6 +30,9 @@
mod appearance;
mod backend;
mod boot;
pub(crate) mod diag;
mod dialog;
pub(crate) mod logs_folder;
mod message;
mod state;
mod subscription;
crates/app-iced/src/app/state.rs
+13
View File
@@ -56,6 +56,9 @@ pub(super) const TICK: std::time::Duration = std::time::Duration::from_millis(TI
/// 实现用的是 `Task::perform(async { sleep(1s) })` 的自续链：[`App::heartbeat`]。它每秒只唤醒
/// 一次、只触发**一帧**重绘，而 `frames()` 是每秒几百帧。为什么不用 `iced::time::every`：
/// 它挂在 tokio/smol 后端下，本 crate 的执行器是 thread-pool（Cargo.toml 不在 scope）。
///
/// **M192 的第三条时钟不在这里**：动效（`components::motion`）也只在「有轨道」时借用帧订阅，
/// 最后一个轨道到期就清空 ⇒ 下一拍 [`App::needs_frames`] 自动退回这条 1 Hz 心跳。
pub(super) const IDLE_TICK: std::time::Duration = std::time::Duration::from_secs(1);
/// 派发指令后保持帧订阅的观察窗（见 [`App::watch_until`]）。
@@ -193,6 +196,16 @@ pub struct App {
/// `pages::Model`，用户正在输入的内容存不到视图模型里。重播种点在
/// [`App::refresh_view`]（`LaunchForm::sync`，换实例必重播种、同实例的脏草稿不覆盖）。
pub(super) launch_form: pages::LaunchForm,
/// 启动失败弹窗的**事实**（M187）：与 `state.dialogs` 里的当前条按 id 绑定。
///
/// 为什么事实不塞进 `DialogRequest`：那是 presenter 的公共 DTO，弹窗与「这次失败的现场」
/// 是两件事——队列管弹窗的排队与按钮，卡片管证据（路径 / 崩溃摘要 / 捕获输出）。
pub(super) dialog_card: Option<super::dialog::CrashCard>,
/// 弹窗的**视图模型**（在 [`App::refresh_view`] 里重建；`view()` 只借它）。
///
/// 为什么不像页面那样现算：`Element` 借字符串，现算的模型是局部变量，`view()` 一返回就
/// 悬空（编译期就过不去）。与 `view` / `account` 两张缓存同一条理由、同一个门控。
pub(super) dialog_model: Option<super::dialog::Modal>,
/// 皮肤/头像解码缓存（M114：同一张皮肤只解一次）。
pub(super) avatars: pages::account::avatar::Cache,
/// 上一次**真下发过**的圆角判定指纹（M116 r1 复审 P2-4：判定没变就不重下、不重记日志）。
crates/app-iced/src/app/state/boot_probe.rs
+2 -1
View File
@@ -4,6 +4,7 @@
//! 「进程启动那一刻记了什么」，与 `App` 的状态机无关；`state.rs` 只留 `pub(super) use` 再导出，
//! 于是 `app/boot.rs`（`use super::state::STARTED`）与 `app/view.rs`（`log_first_frame`）的既有路径一字未变。
use crate::app::diag::diag;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::OnceLock;
use std::time::Instant;
@@ -32,7 +33,7 @@ pub(crate) fn log_first_frame() {
return;
}
if let Some(started) = STARTED.get() {
eprintln!(
diag!(
"[boot] first frame in {:.0} ms（run() 开始 → 首次 view，含后端探测与字体扫描）",
started.elapsed().as_secs_f64() * 1000.0
);
crates/app-iced/src/app/state/construct.rs
+7
View File
@@ -41,6 +41,9 @@ impl App {
Some(root) => SettingsBridge::with_path(config_path(root)),
None => SettingsBridge::open(),
};
// M188：日志目录也在这一拍登记——它是从**同一份**设置桥反推的（`--data-dir` 同样生效），
// 所以设置页显示的路径与 `launcher.log` 的真实落点不会各说各话。
crate::app::logs_folder::register(&bridge);
Self::with_presenter(options, families, flavor, backend, bridge)
}
@@ -135,6 +138,8 @@ impl App {
launch_form: pages::LaunchForm::default(),
install_cancelled_seen: 0,
launch_ends_seen: 0,
dialog_card: None,
dialog_model: None,
content: pages::content::PageState::default(),
account_form: pages::account::Form::new(),
account: pages::account::Page::build(
@@ -151,6 +156,8 @@ impl App {
app.rebuild_ui();
// M174：助手配置的首屏值（真值来自 `config/launcher.json`；截图通道走 `ULL_AI_STATE`）。
app.hydrate_ai_settings();
// M175：Java 分组的首屏值 + **首屏自动扫一次盘**（截图通道走 `ULL_JAVA_STATE`）。
app.hydrate_java_settings();
// 两行日志：①档位 + 探测结论 + 生效语言 ②中文策略（D28 缺字体不许静默）。
// 下一个人据此分得清「探测错了」还是「探测对了但没用上」。
app.lang.log();
crates/app-iced/src/app/state/refresh.rs
+6
View File
@@ -51,6 +51,9 @@ impl App {
ToastKind::Error
};
self.state.toasts.push(kind, text);
// M187：失败要**弹窗**（Toast 会自己消失，崩溃现场不能只靠它）。
let ended = finished.clone();
self.open_failure_dialog(&ended);
}
}
@@ -78,6 +81,9 @@ impl App {
// 账户页（M114）：与 `view` 同一次门控重建（实现见 `view/account_page.rs`，
// 皮肤解码走缓存，所以重复重建不重解图）。
self.rebuild_account_page(width);
// M187：弹窗的视图模型也在这一处重建——`view()` 只借 `&self`，放不进局部变量
// （Element 借字符串，局部一死树就悬空）。全仓「快照 → 视图模型」只在这里发生。
self.dialog_model = self.dialog_modal();
self.view_dirty = false;
self.refreshes += 1;
}
crates/app-iced/src/app/state/theme.rs
+3 -2
View File
@@ -5,6 +5,7 @@
//!
//! 截图通道的判据 [`App::has_screenshot`] 也放在这儿：上面三条里两条都要「截图不读用户配置」。
use crate::app::diag::diag;
use unlucky_design::color::SchemeFlavor;
use unlucky_presenter::prefs::ThemeMode;
@@ -30,7 +31,7 @@ impl App {
self.appearance.set_flavor(flavor);
let previous = self.ui.name();
self.rebuild_ui();
eprintln!(
diag!(
"[theme] {} -> {} (Theme::name 变化触发缓存重算)",
previous,
self.ui.name()
@@ -48,7 +49,7 @@ impl App {
let panel_alpha = self.appearance.effective_panel_alpha();
self.ui = match self.appearance.derived_scheme() {
Some(scheme) => {
eprintln!(
diag!(
"[appearance] palette={} → Ui::from_scheme（取色方案接管 49 个角色）",
self.appearance.palette_level()
);
crates/app-iced/src/app/subscription.rs
+256
View File
@@ -11,10 +11,14 @@
//! | 条件 | 为什么需要 33 ms 节拍 |
//! |---|---|
//! | 截图通道 | 第 3 帧要落盘 |
//! | **有动画在跑**（M192） | 动效时间轴要逐帧采样（帧泵自己按 16 ms 结算，见 `components::motion`） |
//! | 有 `Busy` / `Running` 实例 | 启动进度、日志尾随都靠 `backend.tick` 推进 |
//! | 有未过期的 toast | toast 按毫秒倒计时 |
//! | 刚派发过指令（3 s 观察窗） | 真 host 的异步事件要靠节拍抽出来 |
//!
//! 上面五条**共享同一个布尔**：订阅表里 `window::frames()` 只出现一处（写在同一个 `if` 里），
//! 所以「动画」与「观察窗 / Busy」同时成立时也只有一条订阅——不双订阅靠的是结构，不是判重。
//!
//! 空闲态**一条帧消息都不来** ⇒ 窗口不重绘、`refresh_view` 不跑（配合 `view_dirty`）。
//!
//! ## 空闲态的时钟从哪来（M90 r3 / P2-2）
@@ -43,6 +47,7 @@ use std::time::Instant;
use iced::{window, Subscription};
use super::components::motion;
use super::message::Message;
use super::state::App;
@@ -85,10 +90,261 @@ impl App {
/// 现在要不要**时钟**（见模块文档的表）。
pub(super) fn needs_frames(&self) -> bool {
self.has_screenshot()
// M192：只有动画在跑时才多这一条（帧泵清空轨道后立刻为假 ⇒ 退回 1 Hz 心跳）。
|| motion::needs_frames()
|| !self.state.toasts.is_empty()
|| !self.state.running().is_empty()
// M175：Java 扫描进行中（进度 3/7 要动起来，否则用户只看到「正在扫描」卡着）。
|| self.settings.java.scanning.is_some()
|| self
.watch_until
.is_some_and(|deadline| Instant::now() < deadline)
}
}
#[cfg(test)]
mod tests {
//! 帧订阅的**有界**守卫（M192）：动画期间订阅、结束即退订、关掉动效一帧都不订阅。
//!
//! ## 这一组按**运行时顺序**写（M192 r1 复审 P1-1 的教训）
//!
//! 第一版这里是「先 `motion::enter(...)` 再问 `needs_frames()`」——而 iced 的真实顺序是
//! 「`update()`（订阅表在这里求值）→ `view()`」，于是这条守卫全绿、生产路径上却根本播不出来。
//! 现在全部改走**真消息**：`app.update(Message::Page(Navigate(..)))` 之后再问订阅表，
//! 而且断言 `watch_until` 仍是 `None`（排除「观察窗顺手开了帧」这条假绿）。
//!
//! 时间轴用 `motion::advance_by` 摆（不等真实时钟），每个用例在自己的线程上跑，互不干扰。
use super::*;
use crate::app::components::motion::{Slot, FRAME_MS};
use crate::cli::Options;
use crate::pages;
use crate::theme::Families;
use unlucky_design::color::SchemeFlavor;
use unlucky_design::motion::MotionScale;
use unlucky_presenter::mock::MockBackend;
use unlucky_presenter::router::Route;
use unlucky_presenter::settings_bridge::SettingsBridge;
const FAMILIES: Families = Families {
text: "Segoe UI",
display: "Segoe UI",
mono: "Consolas",
};
/// 不碰磁盘、后端是 mock 的 App（与 `app/tests.rs` 的 `headless` 同构）。
fn headless() -> App {
App::with_presenter(
Options::default(),
FAMILIES,
SchemeFlavor::Light,
Box::new(MockBackend::new()),
SettingsBridge::memory_only(),
)
}
/// 走到「真·空闲」：没有观察窗、没有忙碌实例、没有动画（首屏那一条 Boot 已跑完）。
///
/// `Boot` 自己就会起跑一次首屏动效（`on_boot` → `sync_motion`），所以必须先把它推完，
/// 否则后面的 `assert!(!needs_frames())` 测的是「动画还在跑」而不是「空闲」。
fn idle_app() -> App {
motion::reset();
motion::configure(MotionScale::STANDARD, None);
let mut app = headless();
// 有窗口才谈得上动效（`sync_motion` 在没有窗口时直接返回，见它的文档）
app.window = Some(iced::window::Id::unique());
let _ = app.update(Message::Boot);
app.watch_until = None;
run_until_idle();
assert!(!motion::needs_frames(), "前提：首屏动效已经跑完");
app
}
/// 把时间轴推到全部轨道结束（每步 16 ms，上限 20 s）。
fn run_until_idle() {
for _ in 0..1250 {
if !motion::needs_frames() {
return;
}
motion::advance_by(FRAME_MS);
}
}
/// **按运行时顺序**：空闲态一条消息进来（换页）⇒ **同一拍**订阅表就要有帧；跑完立刻退订。
///
/// 变异证明：把起跑搬回 `view`（删掉 `App::update` 里的 `sync_motion`）⇒ 第一步的
/// `assert!(app.needs_frames())` 红；把 `Pump::advance` 的「到期即删除」删掉 ⇒ 最后一步红。
#[test]
fn a_state_change_opens_the_frame_subscription_in_the_same_tick() {
let mut app = idle_app();
assert!(!app.needs_frames(), "前提：空闲交互态本来就不订阅帧");
// 用户点了一次导航轨：**一条**消息，之后不再补任何消息
let _ = app.update(Message::Page(pages::Message::Navigate(Route::Download)));
assert!(
app.watch_until.is_none(),
"换页不该打开观察窗（这里要证明帧是**动效**要来的，不是派发顺手开的）"
);
assert!(motion::needs_frames(), "换页必须在同一拍起跑");
assert!(
app.needs_frames(),
"同一拍的订阅表必须能看见轨道（iced 先算订阅表、后建视图 —— 复审 P1-1）"
);
run_until_idle();
assert!(!motion::needs_frames(), "动画跑完帧泵必须清空");
assert!(
!app.needs_frames(),
"动画结束后必须退回 1 Hz 心跳（占着帧订阅 = 空闲烧帧）"
);
motion::reset();
}
/// 列表 ↔ 详情同样走「一条消息 ⇒ 当拍有帧」，且 `Detail` 槽真的是那条。
#[test]
fn opening_a_detail_also_opens_the_frames_in_the_same_tick() {
let mut app = idle_app();
// 出厂快照会自动选中第一条 ⇒ 先回列表，让「点进详情」真的是一次详情变化
let _ = app.update(Message::Page(pages::Message::Navigate(Route::Instances)));
run_until_idle();
assert!(!app.needs_frames());
let _ = app.update(Message::Page(pages::Message::Navigate(Route::Detail(
"survival".to_string(),
))));
assert!(app.needs_frames(), "点进详情必须当拍订阅帧");
run_until_idle();
assert!(!app.needs_frames());
motion::reset();
}
/// 账户页 / AI 独立页**不归 pages 画**：切过去不起跑（否则白跑 300 ms 帧）；切回来照旧跑。
#[test]
fn pages_that_render_elsewhere_do_not_start_a_track() {
let mut app = idle_app();
let _ = app.update(Message::Page(pages::Message::Navigate(Route::Accounts)));
assert!(
!motion::needs_frames(),
"账户页没有 pages 树可动，不许白开帧"
);
let _ = app.update(Message::Page(pages::Message::Navigate(Route::Instances)));
assert!(motion::needs_frames(), "从账户页回到某一屏仍然是换页，要跑");
run_until_idle();
motion::reset();
}
/// **没有窗口就不起跑**：`window::frames()` 在没窗口时一条消息都不会有，起跑只是白占一档；
/// 首屏那一条也因此要等窗口到了才算「第一眼」。
#[test]
fn without_a_window_nothing_animates() {
motion::reset();
motion::configure(MotionScale::STANDARD, None);
let mut app = headless();
assert!(app.window.is_none(), "前提：还没拿到窗口句柄");
let _ = app.update(Message::Boot);
app.watch_until = None;
assert!(!motion::needs_frames(), "没有窗口 ⇒ 不许起跑");
// 窗口来了：首屏入场这时才开始（不是被启动期那棵空树吃掉）
let _ = app.update(Message::WindowReady(Some(iced::window::Id::unique())));
assert!(app.needs_frames(), "窗口到了之后「首屏」才起跑");
run_until_idle();
motion::reset();
}
/// **`MotionScale::NONE` 真的零订阅**：不是「跑一遍 0 时长动画」。
///
/// 变异证明：把 `Pump::play` 的 `is_off()` 分支删掉 ⇒ 帧采样次数非 0，本用例红。
#[test]
fn no_scale_requests_no_frames_at_all() {
motion::reset();
let mut app = headless();
app.window = Some(iced::window::Id::unique());
let _ = app.update(Message::Boot);
app.watch_until = None;
motion::configure(MotionScale::NONE, None);
// 三种状态变化：换页 / 换详情 / 再换回来
let _ = app.update(Message::Page(pages::Message::Navigate(Route::Download)));
assert!(!app.needs_frames(), "关掉动效后换页一帧都不该订阅");
let _ = app.update(Message::Page(pages::Message::Navigate(Route::Detail(
"survival".to_string(),
))));
assert!(!app.needs_frames());
run_until_idle();
assert!(!motion::needs_frames());
assert_eq!(motion::samples(), 0, "NONE 档的帧采样次数必须是 0");
motion::reset();
}
/// 帧订阅在**产品接线**里只出现一处：五条理由共享同一个布尔，所以不会出现「动画与 Busy 各订一条」。
///
/// 口径是**全仓 `src/**`**（复审 r1 备注：只扫 `subscription.rs` 抓不到别人另开订阅），只看
/// 代码行（注释/文档里提到这个符号不算）。唯一允许的第二个文件是 `pages/harness.rs`——
/// 那是 `pages_demo` 这条**独立 example** 自己的 iced app（不接 `App`、不进产品路径）。
#[test]
fn there_is_exactly_one_frame_subscription() {
let src = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
let mut files = Vec::new();
collect_rust_files(&src, &mut files);
assert!(
files.len() >= 40,
"只扫到 {} 个文件：扫描逻辑坏了",
files.len()
);
let mut hits = Vec::new();
for path in files {
let text = std::fs::read_to_string(&path).expect("读源文件");
let product = text.split("#[cfg(test)]").next().unwrap_or(&text);
let code = product
.lines()
.filter(|line| !line.trim_start().starts_with("//"))
.collect::<Vec<_>>()
.join(
"
",
);
let count = code.matches("window::frames()").count();
if count > 0 {
let name = path
.strip_prefix(&src)
.unwrap_or(&path)
.to_string_lossy()
.replace(std::path::MAIN_SEPARATOR, "/");
hits.push((name, count));
}
}
hits.sort();
let expected = [
("app/subscription.rs".to_string(), 1_usize),
("pages/harness.rs".to_string(), 1_usize),
];
assert_eq!(
hits, expected,
"`window::frames()` 只许出现在 `app/subscription.rs`（产品接线）\
与 `pages/harness.rs`（独立 example 的自有 app），且各一处"
);
}
/// 递归收集 `dir/**/*.rs`。
fn collect_rust_files(dir: &std::path::Path, out: &mut Vec<std::path::PathBuf>) {
for entry in std::fs::read_dir(dir).expect("读目录") {
let path = entry.expect("目录项").path();
if path.is_dir() {
collect_rust_files(&path, out);
} else if path.extension().is_some_and(|ext| ext == "rs") {
out.push(path);
}
}
}
/// 槽枚举的可见性检查：`Slot` 只经帧泵导出（页面拿不到「给我 250ms」这种口子）。
#[test]
fn slots_are_the_three_documented_ones() {
assert_eq!(Slot::ALL.len(), 3);
assert_eq!(Slot::ALL.map(Slot::name), ["boot", "screen", "detail"]);
}
}
crates/app-iced/src/app/update.rs
+99 -12
View File
@@ -20,11 +20,15 @@
//!
//! | 场景 | 时钟 | 周期 | 谁触发 |
//! |---|---|---|---|
//! | 截图 / 有 Busy-Running 实例 / 有 toast / 派发后 3 s 观察窗 | `window::frames()` + 闸门 | 33 ms | [`App::needs_frames`] |
//! | 截图 / **有动画在跑（M192）** / 有 Busy-Running 实例 / 有 toast / 派发后 3 s 观察窗 | `window::frames()` + 闸门 | 33 ms | [`App::needs_frames`] |
//! | 其余（空闲） | `Heartbeat` 自续链 | 1 s | [`App::heartbeat`] |
//!
//! 两条时钟不会同时干活：心跳在 `needs_frames()` 为真时**只续排、不推进**，忙碌结束自动接回。
//! 动效那条**不新开循环**：它只是给同一个布尔加一个分支（有轨道才为真），轨道到期当场清空，
//! 下一拍就退回心跳（见 `components::motion`）。
use crate::app::components::motion;
use crate::app::diag::diag;
use std::time::Instant;
use iced::{window, Task};
@@ -44,19 +48,44 @@ use super::CAPTURE_AT_FRAME;
mod account;
mod agent;
mod appearance;
mod boot_env;
pub(super) mod boot_env;
mod clock;
mod content;
mod content_pack;
mod dialog;
mod dialog_fixture;
mod download;
mod instances;
mod motion_sync;
mod page_messages;
mod settings;
mod update_action;
/// 这一条键盘事件是不是 `Esc` 按下。
fn is_escape(event: &iced::keyboard::Event) -> bool {
matches!(
event,
iced::keyboard::Event::KeyPressed {
key: iced::keyboard::Key::Named(iced::keyboard::key::Named::Escape),
..
}
)
}
impl App {
/// 一条消息进来，改状态并返回后续任务。
///
/// **分两段**：先派发（[`App::route_message`]），再同步一次动效的内容标识。第二段必须在
/// `update` 里而不是 `view` 里：iced 求值订阅表**早于**建视图（`app/update/motion.rs` 的模块
/// 文档有源码行号），在 `view` 里起跑的轨道当拍订阅不上，动画会退化成「一帧偏移 + 闪跳」。
pub(super) fn update(&mut self, message: Message) -> Task<Message> {
let task = self.route_message(message);
self.sync_motion();
task
}
/// 把一条消息派发到它的落点（`update` 的正文；拆出来只为让 [`App::sync_motion`] 收尾）。
fn route_message(&mut self, message: Message) -> Task<Message> {
match message {
Message::Boot => self.on_boot(),
Message::WindowReady(id) => {
@@ -75,7 +104,7 @@ impl App {
match hwnd {
Some(_) => self.apply_window_alpha("boot"),
None => {
eprintln!("[appearance] hwnd=none（拿不到窗口句柄：整窗 α 无法下发）");
diag!("[appearance] hwnd=none（拿不到窗口句柄：整窗 α 无法下发）");
self.log_appearance("boot", None);
}
}
@@ -89,7 +118,7 @@ impl App {
iced::theme::Mode::Dark => SchemeFlavor::Dark,
iced::theme::Mode::None | iced::theme::Mode::Light => SchemeFlavor::Light,
};
eprintln!("[theme] 系统主题 = {mode:?}");
diag!("[theme] 系统主题 = {mode:?}");
// 优先级：`--theme` > 配置文件里的 `appearance.theme_mode` > 系统。
// 早先这里无条件盖掉，于是「配置文件写 dark、系统是浅色」会出现
// `light -> dark -> light` 的一次抖动，配置永远不生效（M90 r3 顺手修）。
@@ -119,7 +148,16 @@ impl App {
Task::none()
}
Message::Page(message) => self.on_page(message),
Message::Agent(message) => self.on_agent(message),
Message::Dialog(message) => dialog::on_dialog(self, message),
Message::Agent(message) => {
// `Esc` 先给弹窗：有弹窗时它属于「关掉这一层」，不属于 AI 栏的收起。
if let crate::shell::agent::Message::Key(event) = &message {
if is_escape(event) && dialog::escape(self) {
return Task::none();
}
}
self.on_agent(message)
}
// 外壳导航轨（`src/shell/nav.rs`）发来的点选：翻成同一次路由跳转
Message::Select(nav) => {
self.state.navigate(route_of(nav));
@@ -147,7 +185,7 @@ impl App {
Message::Captured(screenshot) => self.on_captured(&screenshot),
Message::Demo(message) => {
// gallery 只是 harness：按下只打日志，不接业务（组件库要能脱离业务验收）
eprintln!("[gallery] {} pressed", message.id());
diag!("[gallery] {} pressed", message.id());
Task::none()
}
}
@@ -160,12 +198,16 @@ impl App {
fn on_boot(&mut self) -> Task<Message> {
let mut tasks = vec![window::latest().map(Message::WindowReady)];
// M192：给动效帧泵定档（截图档关、CPU 档半速、GPU 档正常；`ULL_MOTION*` 可覆盖）。
// 必须在第一次 `view()` 之前：页面主体的入场由 `pages::render` 采样，配置晚了首屏就没有动效。
self.configure_motion();
// M117：启动日志一行 —— `[auth] msa client_id=configured|missing source=env|build|none`。
// 判据（配没配 + 从哪来）在 `core::auth::microsoft::client_id_status()`，零网络；
// 本 crate 不直接依赖 core，所以经 `unlucky_cli`（已是本 crate 的依赖）出面，
// 免得 UI 侧把判据重算一遍、两份口径漂。日后看日志能一眼分辨
// 「没配置」与「配了但登录失败」。
eprintln!("{}", unlucky_cli::commands::msa_client_id_log_line());
diag!("{}", unlucky_cli::commands::msa_client_id_log_line());
// 主题优先级：显式 `--theme` / `--screenshot-theme` > 设置文件 > 系统。
// 截图通道**不读设置文件**（D30 可复现：同一份代码在两台机器上要出同一张图）。
@@ -176,6 +218,8 @@ impl App {
self.appearance.apply_env();
self.rebuild_ui();
self.log_appearance("boot", None);
// M187（r1 复审 P2-4）：启动这一拍的事实进启动器日志的缓冲（第一次启动时落盘）。
boot_env::record_boot_log(self);
// 交互模式且没显式指定主题 → 探系统；截图模式永不等（见 cli 模块文档）
if self.options.wants_system_theme() {
@@ -194,7 +238,7 @@ impl App {
// 取证开关 `ULL_START_ROUTE`：截图/冒烟直接落到某一页（`cli.rs` 不在本 mission 的 scope，
// 而「外观」分组只在设置页上，出矩阵必须能直达）。未知值忽略。
if let Some(route) = boot_env::env_start_route() {
eprintln!("[boot] ULL_START_ROUTE → {route:?}");
diag!("[boot] ULL_START_ROUTE → {route:?}");
self.state.navigate(route);
// 直达某一页时不要再被「自动选中第一条实例」拉回详情页。
self.auto_selected = true;
@@ -202,6 +246,10 @@ impl App {
self.ensure_content_loaded();
}
account::force_account_state(self);
// M187：启动失败弹窗的取证夹具（`ULL_DIALOG_FIXTURE`），必须在 `refresh_view` 之前。
if let Some(mode) = dialog_fixture::apply(self) {
diag!("[boot] ULL_DIALOG_FIXTURE → {mode}");
}
self.auto_select();
self.view_dirty = true;
@@ -213,27 +261,66 @@ impl App {
Task::batch(tasks)
}
/// M192：给帧泵定档（策略全在 [`boot_env::motion_scale`]，这里只搬输入）。
fn configure_motion(&mut self) {
let pin = boot_env::env_motion_pin();
let gpu = matches!(
super::backend::effective_kind(),
Some(crate::renderer::Kind::Wgpu)
);
let scale = boot_env::motion_scale(self.options.screenshot.is_some(), gpu, pin.is_some());
motion::configure(scale, pin);
// 打**帧泵实际拿到的**档位（不是刚算出的那个）：配置没生效时这一行会露馅。
diag!(
"[motion] scale={:.2} pin={:?} gpu={} screenshot={}",
motion::scale().factor(),
pin,
gpu,
self.options.screenshot.is_some()
);
}
/// 空闲心跳：只有「不需要帧节拍」时才推进一拍，然后**无条件续排**下一拍。
///
/// 为什么无条件续排：忙碌结束（游戏退出、toast 过期、观察窗关闭）之后没有别的东西会叫醒
/// app，心跳链必须一直在，才能把低频时钟接回去。忙碌期间它只是每秒醒一次、什么都不做。
fn on_heartbeat(&mut self) -> Task<Message> {
// 动效时间轴也吃这一拍：窗口被遮挡 / 最小化 / 合成器不送绘制时，帧一个都不来，而
// 「有轨道」又让下面的 1 Hz 推进整段停摆——那会让 `needs_frames()` 永远为真。心跳把
// 轨道按单次上限（[`components::motion::pump::MAX_STEP_MS`]）推几步收尾，最坏的「没有帧」
// 情况下 5 拍内自然退订；有帧时它只多推 64 ms/秒，看不出来。
motion::advance();
if !self.needs_frames() {
let now = Instant::now();
let elapsed = now.saturating_duration_since(self.last_tick).max(IDLE_TICK);
self.last_tick = now;
self.advance(elapsed);
}
// M192 真机取证（`ULL_MOTION_FIXTURE_AT`）：到点就**真的**导航一次。放在 advance 之后 ⇒
// 这一拍是货真价实的空闲态；跳转后由 `update` 收尾的 `sync_motion` 起跑（与点击同一条路）。
self.motion_fixture_after_idle();
heartbeat()
}
/// 一帧画完：①够 33 ms 就推进一拍 presenter ②截图模式在第 [`CAPTURE_AT_FRAME`] 帧出图。
/// 一帧画完：①动效时间轴推进 ②够 33 ms 就推进一拍 presenter ③截图模式在第
/// [`CAPTURE_AT_FRAME`] 帧出图。
///
/// 时间闸门按**真实流逝时间**判（不是数帧）：掉帧不会把游戏启动进度拖慢，
/// 也不会在慢机器上把 1.5 s 的下载阶段拉成 4 s。
fn on_frame(&mut self) -> Task<Message> {
self.frames += 1;
// M192：动效时间轴。**每帧都调**，帧率上限在帧泵内部（16 ms 一次结算），所以忙碌态的
// 近千 fps 不会变成近千次重排；动画结束后帧泵自动清空，下一拍订阅表就不再有 `frames()`。
motion::advance();
// 出图取证（`ULL_MOTION_FIXTURE`）：前两帧各做一次**真的**状态变化。
// 没有这步，截图通道每一帧画的都是同一屏，页面切换 / 列表↔详情的入场就没有可拍的相位。
// `ULL_MOTION_FIXTURE_AT`（真机空闲取证）在的时候**不跑**这一支：两条取证路互斥，
// 否则第 1 帧就把页面换成目标页，等 `_AT` 的心跳再跳同一个目标 = 标识没变 = 没有动效。
if self.frames <= 2 && boot_env::env_motion_fixture_at().is_none() {
self.motion_fixture();
}
let now = Instant::now();
let elapsed = now.saturating_duration_since(self.last_tick);
if elapsed >= TICK {
@@ -259,9 +346,9 @@ impl App {
};
match crate::shot::save(screenshot, &path) {
Ok(summary) => {
eprintln!("{}", summary.describe());
diag!("{}", summary.describe());
// M97：打**实际**后端名（`wgpu`/`tiny-skia`），不是请求值——`renderer=auto` 曾经出现在每张验收图的日志里。
eprintln!(
diag!(
"[shot] screen={} theme={} renderer={} route={:?}",
self.options.screen.name(),
crate::shot::flavor_slug(&self.ui),
@@ -269,7 +356,7 @@ impl App {
self.state.route()
);
}
Err(error) => eprintln!("[shot] 失败：{error}"),
Err(error) => diag!("[shot] 失败：{error}"),
}
iced::exit()
crates/app-iced/src/app/update/account.rs
+25 -2
View File
@@ -95,7 +95,7 @@ impl App {
self.dispatch(AppCommand::AddAuthlibAccount(request));
}
}
Panel::Microsoft => return self.on_account(Account::StartBrowser),
Panel::Microsoft => return self.on_account(Account::StartDevice),
Panel::None => {}
},
Account::StartDevice => self.dispatch(AppCommand::StartDeviceLogin),
@@ -136,7 +136,8 @@ impl App {
match account.kind {
AccountKind::Microsoft => {
self.account_form.panel = Panel::Microsoft;
self.dispatch(AppCommand::StartBrowserLogin);
// M178：重登也走设备码（不依赖任何应用注册项）。想试浏览器再点面板里的次按钮。
self.dispatch(AppCommand::StartDeviceLogin);
}
AccountKind::Authlib => {
self.account_form.open(Track::Authlib);
@@ -173,6 +174,23 @@ pub(super) fn force_account_state(app: &mut App) {
app.state.device_login_started =
Some(std::time::Instant::now() - std::time::Duration::from_secs(3_600));
}
// M178：浏览器登录没走成、已回退设备码的那一态（设备码 + 一句「为什么 + 怎么修」）。
//
// 为什么在 app 层造：真走到这一步要一次真网络请求（预检），截图通道要的是**确定性**。
// 这里只替换登录视图本身——面板的渲染路径与真 host 完全同一条
// （`apply_device_login` → `pages::account::panels::device_panel` → `login::panel`）。
"msa-fallback" => {
app.account_form.panel = crate::pages::account::Panel::Microsoft;
app.state.apply_device_login(
unlucky_presenter::dto::DeviceLoginView::waiting(
"ABCD-EFGH",
"https://www.microsoft.com/link",
900,
"",
)
.with_browser_note(unlucky_presenter::dto::BrowserLoginNote::RedirectNotRegistered),
);
}
// 第三方站**失败**态：面板打开 + mock 那边给出的 `AuthlibLoginChanged(Failed)`
"authlib-failed" => {
app.account_form.panel = crate::pages::account::Panel::Authlib;
@@ -198,6 +216,11 @@ pub(super) fn force_account_state(app: &mut App) {
"closed" => {
let _ = app.on_account(crate::pages::account::Message::Close);
}
// M178：登录入口面板（两个按钮 + 一行「没有浏览器时用这个」）。复审 r1 P2-5 的文案改动
// 要有图可看：`device_login` 是 Idle ⇒ 面板落在空闲态（主按钮=设备码，次按钮=浏览器）。
"msa-entry" => {
app.account_form.panel = crate::pages::account::Panel::Microsoft;
}
// 有账号时「Add an account」展开态（P2-4 的收敛后形态）
"add" => {
app.account_form.section_open = true;
crates/app-iced/src/app/update/account/tests.rs
+2 -2
View File
@@ -125,10 +125,10 @@ fn the_device_code_flow_is_started_visible_and_cancellable() {
let _ = app.on_account(Account::StartDevice);
match &app.account.device {
DevicePanel::Code {
code, remaining, ..
code, countdown, ..
} => {
assert_eq!(code, "ABCD-EFGH", "用户码要上屏");
assert!(remaining.is_some_and(|left| left > 0), "倒计时在跑");
assert!(!countdown.is_empty(), "倒计时在跑（文案由模型拼好）");
}
other => panic!("进行中状态必须可见，实际 {other:?}"),
}
crates/app-iced/src/app/update/agent.rs
+6 -5
View File
@@ -29,6 +29,7 @@
//! 一次状态，流式标记与未读会打架。所以 [`App::drain_agent`] 抽出来之后立刻
//! `on_agent(agent::Message::Events(..))` —— 同一条 `Message::Agent(..)` 通道。
use crate::app::diag::diag;
use iced::keyboard::{key, Key};
use iced::Task;
@@ -141,10 +142,10 @@ impl App {
self.drain_agent();
}
SubmitOutcome::Failed(failure) => {
eprintln!("[agent] 提交失败（{}）", failure.code());
diag!("[agent] 提交失败（{}）", failure.code());
}
SubmitOutcome::Rejected => {
eprintln!("[agent] presenter 拒收：空文本 / 上一轮未完 / 待确认 三闸该先挡住");
diag!("[agent] presenter 拒收：空文本 / 上一轮未完 / 待确认 三闸该先挡住");
}
}
}
@@ -204,7 +205,7 @@ impl App {
let on_confirm = matches!(self.agent.focus, Focus::ConfirmAllow | Focus::ConfirmDeny);
if pending && !on_confirm {
self.agent.focus = Focus::ConfirmAllow;
eprintln!("[agent] 写操作待确认 → 焦点落到 Allow（Tab 点亮焦点环后 Enter/Space 裁决）");
diag!("[agent] 写操作待确认 → 焦点落到 Allow（Tab 点亮焦点环后 Enter/Space 裁决）");
} else if !pending && on_confirm {
self.agent.focus = Focus::Composer;
self.agent.keyboard_mode = false;
@@ -279,7 +280,7 @@ impl App {
}
if self.agent.rail == RailState::Detached && self.state.route() != &Route::Agent {
eprintln!("[agent] rail=detached → Route::Agent");
diag!("[agent] rail=detached → Route::Agent");
self.state.navigate(Route::Agent);
// 直达独立页时不要再被「自动选中第一条实例」拉回详情页。
self.auto_selected = true;
@@ -371,7 +372,7 @@ impl App {
let _ = self.on_agent(message);
} else {
// 「不得静默无反应」：焦点在输入框上按 Enter 由输入框自己处理，这里只留一行日志。
eprintln!(
diag!(
"[agent] Enter on focus={} handled by the composer",
self.agent.focus.name()
);
crates/app-iced/src/app/update/appearance.rs
+2 -1
View File
@@ -28,6 +28,7 @@
//! `radius=system` 是刻意的：系统不暴露 DWM 的圆角半径，我们也不自己定一个数字
//! （M116 取消了 8/12/16 固定档）。
use crate::app::diag::diag;
use crate::platform;
use crate::platform::win32::corner::{self, CornerApplied};
use crate::platform::win32::transparency::{apply_corner, style_summary, CornerOutcome};
@@ -73,7 +74,7 @@ impl App {
"frame=? layered=?".to_owned(),
),
};
eprintln!(
diag!(
"{}",
corner::format_line(context, &plan, policy, &outcome, &style, suppressed_by)
);
crates/app-iced/src/app/update/boot_env.rs
+149 -2
View File
@@ -1,8 +1,11 @@
//! 启动期的取证环境变量解析（`ULL_START_ROUTE`）。
//! 启动期的取证环境变量解析（`ULL_START_ROUTE` / 动效三个开关）。
//!
//! 从 `app/update.rs` 原样搬出（那个文件在 M105/M106/M109/M113 之后贴着 400 行硬线）：
//! **纯函数、无状态**，只是取值表长到了七条。
//! **纯函数、无状态**，只是取值表长到了十条。M192 在这里加的是动效那一组
//! （[`motion_scale`] / [`env_motion_pin`] / [`env_motion_fixture`]）：档位策略只有这一处，
//! 帧泵自己不读环境变量。
use unlucky_design::motion::MotionScale;
use unlucky_presenter::router::Route;
/// 取证开关 `ULL_START_ROUTE` 的取值解析（`settings` / `instances` / `download` / `content` / `logs`）。
@@ -24,3 +27,147 @@ pub(super) fn env_start_route() -> Option<Route> {
_ => None,
}
}
/// 动效档位与相位钉住（M192）：帧泵**只在产品的 `on_boot` 里定档**。
///
/// ## 为什么档位在这里算
///
/// 三个输入只有启动这一拍齐全：①是不是截图通道（`--screenshot`）②实际渲染后端
/// （`backend::effective_kind()`，不是 `--renderer` 的请求值）③`ULL_MOTION` 的强制值。
/// 帧泵自己（`components::motion`）不读环境变量，它只接受一个 [`MotionScale`]——这样动效策略
/// 只有一处，测试也不必摆环境变量。
///
/// | 条件 | 档位 | 为什么 |
/// |---|---|---|
/// | `ULL_MOTION=off` | `NONE` | 一键关（排障 / 想量基线时用） |
/// | 截图通道，且没给 `ULL_MOTION_AT` | `NONE` | D30：出图不许有动画（否则第 3 帧抓到中间态，图就不可复现） |
/// | CPU 渲染（`tiny-skia`） | `HALF` | 时长减半 = 帧数减半。位移是**布局量**，CPU 档最贵的就是逐帧重排 |
/// | 其余（`wgpu`） | `STANDARD` | —— |
/// | `ULL_MOTION=half` / `full` | 强制 | 覆盖上表（出图矩阵要在 GPU 上量同一段动效） |
///
/// 「减少动效」的用户开关**还不存在**（`core/src/setting` 里没有 animation key，见报告 follow-up），
/// 所以本函数只认上面这些来源。
pub(super) fn motion_scale(screenshot: bool, gpu: bool, pinned: bool) -> MotionScale {
match std::env::var("ULL_MOTION").ok().as_deref().map(str::trim) {
Some("off") | Some("none") => return MotionScale::NONE,
Some("half") => return MotionScale::HALF,
Some("full") => return MotionScale::STANDARD,
_ => {}
}
if pinned {
// 取证相位优先于「截图必须静」，否则多帧序列图一张都出不来。
return MotionScale::STANDARD;
}
if screenshot {
return MotionScale::NONE;
}
if gpu {
MotionScale::STANDARD
} else {
MotionScale::HALF
}
}
/// `ULL_MOTION_AT=<ms>`：把动画时钟钉在某一毫秒（多帧序列图取证）。
///
/// 语义与 `ULL_APPEARANCE_*` / `ULL_DIALOG_FIXTURE` 一致：只影响这一次进程。没有它，第 3 帧落在
/// 动画的哪个相位取决于这台机器的渲染速度 —— 那样「0% / 50% / 100% 三张图」是抓阄抓出来的。
pub(super) fn env_motion_pin() -> Option<f64> {
std::env::var("ULL_MOTION_AT")
.ok()?
.trim()
.parse::<f64>()
.ok()
.filter(|ms| ms.is_finite() && *ms >= 0.0)
}
/// `ULL_MOTION_FIXTURE`：第 1 帧之后**真的**做一次状态变化（多帧序列图靠它）。
///
/// 为什么要制造变化：页面主体的入场只在「内容标识变了」时起跑（`motion::observe`），而截图通道
/// 从第一帧起画的就是同一页——不制造一次真实的路由变化，就没有可拍的动效。
#[derive(Debug, Clone)]
pub(super) enum MotionFixture {
/// 跳到一个一级页（走「换页」那一档）。
Route(Route),
/// 「列表 → 详情」：先回列表（第 1 帧），再点进第一条实例（第 2 帧）。
Detail,
}
/// `ULL_MOTION_FIXTURE=<instances|download|logs|settings|content|detail>`。
pub(super) fn env_motion_fixture() -> Option<MotionFixture> {
Some(match std::env::var("ULL_MOTION_FIXTURE").ok()?.trim() {
"instances" => MotionFixture::Route(Route::Instances),
"download" => MotionFixture::Route(Route::Download),
"logs" => MotionFixture::Route(Route::Logs),
"settings" => MotionFixture::Route(Route::Settings),
"content" => MotionFixture::Route(Route::Content),
"detail" => MotionFixture::Detail,
_ => return None,
})
}
/// `ULL_MOTION_FIXTURE_AT=<秒>`：启动后第 N 次心跳（≈第 N 秒）**真的**导航一次。
///
/// ## 为什么需要它（真机空闲取证）
///
/// 复审 r1 要求「空闲 ≥10 s 后点一次导航轨，看 `[tick] motion=` 涨多少」。本机工作区所在会话
/// 没有前台窗口（`GetForegroundWindow()==0`），合成鼠标事件（`mouse_event` 与
/// `PostMessage(WM_LBUTTONDOWN)` 都试过）递不进 iced 的输入层，所以这里换一条**同构**的路：
/// 由 1 Hz 心跳（空闲态本来就有的消息）在第 N 秒做一次真实的路由跳转。
///
/// 两条路在 `update` 之后**完全同一段代码**：消息 → `sync_motion`（起跑）→ `subscription()`
/// （同一拍看见轨道）→ `frames()`。差别只在「消息是谁产生的」，而这正是 P1 要验的那一段。
pub(super) fn env_motion_fixture_at() -> Option<u32> {
std::env::var("ULL_MOTION_FIXTURE_AT")
.ok()?
.trim()
.parse::<u32>()
.ok()
.filter(|beats| *beats > 0)
}
/// 把启动那一拍的**事实**写进启动器自己的日志（M187 / r1 复审 P2-4）。
///
/// ## 为什么这一拍只能「先记、后落」
///
/// `.ULL/logs` 的落点由 `platform::data_dir` 的三模式决定（要读配置、follow `redirect.json`），
/// 那件事只有 presenter 的 `HostEnv` 做过。app 层拿不到它，于是这里只 `record`
/// （core 侧缓冲，最多 200 行）；presenter **构造 `HostEnv` 的那一刻**就调
/// `launcher_log::set_dir`（M188 补上的那一半），缓冲一次刷进 `<.ULL>/logs/launcher.log`。
///
/// 效果正是用户投诉要的那份东西：他「双击 → 启动 → 崩 → 找日志」时，`launcher.log` 里从
/// **启动这一拍**（主题 / 语言 / 路由 / 窗口 / 后端）一直写到退出，而不是只有 launch 那一段。
///
/// M188 之后边界也变了：`boot.rs` / `boot/fallback.rs` / `state/*` 那些 `eprintln!` 改走
/// [`crate::app::diag::emit`]（stderr + 文件双写），同样靠这条缓冲接住——所以「一局都没开就崩」
/// 的进程也会留下 `launcher.log`。
pub(crate) fn record_boot_log(app: &super::super::state::App) {
use unlucky_core::launch::launcher_log;
launcher_log::record("boot", "app boot");
launcher_log::record(
"boot",
&format!(
"theme={} lang={:?} route={:?} window={:.0}x{:.0} screenshot={} instances={}",
app.ui().name(),
app.lang(),
app.state.route(),
app.width,
app.height,
app.has_screenshot(),
app.state.instances.len(),
),
);
launcher_log::record("boot", &unlucky_cli::commands::msa_client_id_log_line());
// 后端这一拍也要在日志里：`[probe]` / `[backend]` 那几行由 `renderer::acceptance` 打到
// stderr（那个模块不在 M188 的 scope），事故之后翻日志的人至少要看得出「这次用的是哪个后端」。
launcher_log::record(
"boot",
&format!(
"backend request={} effective={} renderer_fallback={}",
app.options.backend.name(),
super::super::backend::effective_backend(app.options.backend).name(),
std::env::var(crate::renderer::FALLBACK_ENV).unwrap_or_else(|_| "-".to_string()),
),
);
}
crates/app-iced/src/app/update/clock.rs
+13 -4
View File
@@ -17,6 +17,7 @@
//! [`App::pump`] 里多了一行 [`App::drain_agent`]：AI 助手的事件队列和 core 的事件队列同拍抽干，
//! 于是「右栗的未读/流式状态」和页面快照共享同一个刷新节奏（不会一个 30 Hz、一个 1 Hz）。
use crate::app::diag::diag;
use std::time::{Duration, Instant};
use unlucky_presenter::dto::AppCommand;
@@ -49,6 +50,9 @@ impl App {
self.font_seen = font_status;
self.view_dirty = true;
}
// Java 扫描（M175）：同一条「后台线程 + 快照」路数。进度（3/7）与结论都在里面，
// 扫描期间按帧跑（见 `subscription::needs_frames`），扫完回到 1 Hz。
self.hydrate_java_scan();
// `ticks` 的单位是**33 ms 的一拍**，不是「advance 被调了几次」：空闲心跳一次跨 1 s，
// 要记 30 拍，这样 `theme::config_poll_due`（30 拍 ≈ 1 秒）在两种时钟下语义一致。
let ticks = elapsed.as_millis().div_euclid(u128::from(TICK_MS));
@@ -71,12 +75,14 @@ impl App {
let reloaded =
!self.has_screenshot() && poll_due && self.bridge.reload_if_changed().is_some();
if reloaded {
eprintln!("[settings] 配置文件变了，重读主题 + 外观");
diag!("[settings] 配置文件变了，重读主题 + 外观");
self.apply_config_theme();
// M93：外观也热切（面板 α / 背景图 / 配色来源 / 整窗 α 都在里面）。
self.reload_appearance();
// M174：助手那四项也一样（`ull config set ai.* …` 改完 1 秒内可见；脏草稿不覆盖）。
self.hydrate_ai_settings();
// M175：Java 三键同理（外部改了内存 / JVM 参数 / 默认 JDK，设置页 1 秒内跟上）。
self.hydrate_java_settings();
}
if self.view_dirty {
@@ -87,8 +93,8 @@ impl App {
// 忙碌态由帧节拍跨桶（≈1 行/秒），空闲态由心跳一次 +30 跨桶（**也是 1 行/秒**）——
// 两种时钟都用同一把尺子，所以 trace 的密度本身就是「时钟在跑」的证据。
if bucket_after != bucket_before && std::env::var_os("ULL_TICK_TRACE").is_some() {
eprintln!(
"[tick] n={} frames={} refreshes={} clock={}",
diag!(
"[tick] n={} frames={} refreshes={} clock={} motion={}",
self.ticks,
self.frames,
self.refreshes,
@@ -96,7 +102,10 @@ impl App {
"frames"
} else {
"idle-1hz"
}
},
// M192：动效时间轴已结算的帧数（每秒一行 ⇒ 这一列的增长速度就是动画的实际帧率，
// 也是「动画期间重绘成本」的记账口径，见报告）
crate::app::components::motion::samples()
);
}
}
crates/app-iced/src/app/update/content.rs
+14 -2
View File
@@ -16,6 +16,7 @@
//! `AppState::content.query` 是「当前结果对应哪份条件」的唯一真相：结果回来时
//! `apply_content` 用它判「迟到的事件要不要丢」。页面自己存一份就会有两份真相。
use crate::app::diag::diag;
use unlucky_presenter::dto::{
AppCommand, ContentDetailRequest, ContentInstallRequest, ContentQuery, ContentSource,
ExportRequestView,
@@ -103,6 +104,15 @@ impl App {
self.dispatch(AppCommand::InstallContent(Box::new(request)));
}
}
// M191：「只重试上次失败的那几项」。请求构造在 `pages/content/model.rs`
// （`retry_install_request`：载荷带 `retry: true`），这里只做转发。
pages::content::Message::RetryFailed => {
let catalog = unlucky_i18n::Lang::En.catalog();
let model = Content::from_snapshot(&self.state, &self.content, catalog);
if let Some(request) = model.retry_install_request() {
self.dispatch(AppCommand::InstallContent(Box::new(request)));
}
}
// M113: import/export —— 导入/导出区（细节在 `on_pack`）
pages::content::Message::Pack(message) => self.on_pack(message),
}
@@ -199,10 +209,10 @@ impl App {
if !model.can_install() {
// 有原因就打印出来（取证用）；没有选中项时什么都不做
for reason in model.blocker_reasons(catalog) {
eprintln!("[content] 装入被挡下：{reason}");
diag!("[content] 装入被挡下：{reason}");
}
if model.blockers.contains(&Blocker::NeedsPipeline) {
eprintln!("[content] 整合包装入未实现（M111）");
diag!("[content] 整合包装入未实现（M111）");
}
return None;
}
@@ -221,6 +231,8 @@ impl App {
instance: target.id.clone(),
game_version: target.mc_version.clone(),
loader: target.loader,
// 普通装入：从根项目解起（「只重试这些」是另一条消息，`retry: true`）
retry: false,
})
}
}
crates/app-iced/src/app/update/dialog.rs
+104
View File
@@ -0,0 +1,104 @@
//! 弹窗消息的落点：关闭 / 展开 / 导出 / 打开文件夹 / 复制路径。
//!
//! 只有两类副作用：**剪贴板**（返回 `Task`，必须交回 runtime）与**弹 Toast**（就地推）。
//! 导出与打开文件夹是同步的本地动作（写一个 zip / 拉起一个 `explorer`），耗时都在毫秒级，
//! 不为它们单开线程——真要慢（网络盘）也是用户能感知的一次点击。
use iced::Task;
use unlucky_presenter::toast::ToastKind;
use crate::app::dialog::{export, Message as DialogMessage};
use crate::app::state::App;
pub(super) fn on_dialog(app: &mut App, message: DialogMessage) -> Task<crate::app::Message> {
match message {
DialogMessage::Primary => {
// 崩溃卡片的主按钮是「导出诊断包」；普通确认框的主按钮就是「关掉」。
let Some(card) = app.dialog_card.clone() else {
app.close_dialog();
return Task::none();
};
let done = export::export(&card.report, app.lang());
// 结论**画在卡片里**：导出这种「必须看见落到哪」的结果不能只靠 Toast
// （app-iced 的 Toast 至今没有渲染点）。成败按 `write_bundle` 的真实结果判，
// 不看「launcher_logs 有没有值」——那只是入参齐全度（r1 复审 P3-2）。
app.state.toasts.push(
if done.ok {
ToastKind::Success
} else {
ToastKind::Error
},
done.text.clone(),
);
if let Some(state) = &mut app.dialog_card {
state.outcome = Some(done.text);
}
app.view_dirty = true;
app.refresh_view();
Task::none()
}
DialogMessage::Secondary | DialogMessage::Dismiss => {
app.close_dialog();
// 立即重画：空闲态只有 1 Hz 心跳，只置 `view_dirty` 会让弹窗再留最多 1 秒
// （r1 复审 P3-1）。
app.refresh_view();
Task::none()
}
DialogMessage::Toggle => {
app.toggle_dialog_detail();
Task::none()
}
DialogMessage::OpenFolder => {
let Some(card) = app.dialog_card.clone() else {
return Task::none();
};
let problem = export::open_folder(&card.report, app.lang());
if !problem.is_empty() {
if let Some(state) = &mut app.dialog_card {
state.outcome = Some(problem.clone());
}
app.state.toasts.push(ToastKind::Error, problem);
app.view_dirty = true;
app.refresh_view();
}
Task::none()
}
DialogMessage::CopyPaths => {
let Some(card) = app.dialog_card.clone() else {
return Task::none();
};
app.state.toasts.push(
ToastKind::Info,
app.lang()
.catalog()
.text(unlucky_i18n::catalog::Key::CrashDialogCopied),
);
iced::clipboard::write(export::paths_text(&card.report))
}
DialogMessage::CopyPath(index) => {
let Some(card) = app.dialog_card.clone() else {
return Task::none();
};
let Some((_, path)) = card.report.path_lines().into_iter().nth(index) else {
return Task::none();
};
app.state.toasts.push(
ToastKind::Info,
app.lang()
.catalog()
.text(unlucky_i18n::catalog::Key::CrashDialogCopied),
);
iced::clipboard::write(path.display().to_string())
}
}
}
/// `Esc` 关弹窗（有弹窗时**先吃这一条**，不让它落到 AI 栏的 Esc 收起上）。
pub(super) fn escape(app: &mut App) -> bool {
if app.state.dialogs.current().is_none() {
return false;
}
app.close_dialog();
app.refresh_view();
true
}
crates/app-iced/src/app/update/dialog_fixture.rs
+152
View File
@@ -0,0 +1,152 @@
//! 启动失败弹窗的**取证夹具**（`ULL_DIALOG_FIXTURE`，只在 `--screenshot` 下生效）。
//!
//! ## 为什么要有它
//!
//! 弹窗要出两张图（「有 crash-report」/「只有捕获输出」），而真机上要复现一次崩溃得先让一个
//! 真实的 MC 进程死掉——截图通道要的是**确定性**。做法与 `ULL_ACCOUNT_STATE` 同一档：
//! 在临时目录里造一份**真的文件树**（launcher.log / 会话 JSONL / crash-reports / latest.log），
//! 于是弹窗上的路径是真路径、点「导出诊断包」真的会打出一个装得下这些文件的 zip。
//!
//! 取值：
//!
//! | 值 | 现场 |
//! |---|---|
//! | `crash-report` | 游戏写了 `crash-reports/crash-*.txt`（证据一） |
//! | `no-logs` | 没有 crash-report、没有 latest.log，只有会话 JSONL 里的 stderr（证据二） |
//! | `export` | 同 `no-logs`，并在出图前**真的跑一次导出**（第三张图：路径 + 字节数） |
//!
//! 夹具只影响这一次进程；产品路径（`host/launch.rs` 收尾 → `crash_report::publish` →
//! `refresh_view` → 弹窗）与它完全同一条，这里只是**代填事实**。
use std::path::{Path, PathBuf};
use unlucky_core::launch::crash_report::{self, ArtifactFact, CrashReport};
use unlucky_core::launch::crash_scan::{self, CrashSource};
use unlucky_presenter::dto::{LaunchFinished, LogOutcome};
use crate::app::state::App;
/// 现场根（`%TEMP%/ull-m187-fixture-<pid>`）。
fn root() -> PathBuf {
std::env::temp_dir().join(format!("ull-m187-fixture-{}", std::process::id()))
}
fn write(path: &Path, text: &str) {
if let Some(parent) = path.parent() {
let _ = std::fs::create_dir_all(parent);
}
let _ = std::fs::write(path, text);
}
/// 出图用的夹具（`None` = 没有开关，什么都不做）。
pub(super) fn apply(app: &mut App) -> Option<String> {
let mode = std::env::var("ULL_DIALOG_FIXTURE").ok()?;
let mode = mode.trim().to_lowercase();
if !app.has_screenshot() {
return None;
}
let root = root();
let _ = std::fs::remove_dir_all(&root);
let logs = root.join("logs");
write(
&logs.join("launcher.log"),
"2026-11-08T15:30:11.002Z [boot] renderer=wgpu\n\
2026-11-08T15:30:12.441Z [launch] instance=survival spawn game_dir=… java=javaw (21)\n\
2026-11-08T15:30:19.870Z [launch] instance=survival session=9f2c exit=1\n",
);
write(&logs.join("install.log"), "installed 1.20.4-fabric\n");
let session = "9f2c4a1e-77bd-4f27-9d21-5b0a1f2c3d4e";
let session_log = root
.join("sessions")
.join("game")
.join(format!("{session}.jsonl"));
write(
&session_log,
"{\"kind\":\"stdout\",\"payload\":{\"line\":\"[main/INFO]: Loading Minecraft 1.20.4\"}}\n\
{\"kind\":\"stderr\",\"payload\":{\"line\":\"java.lang.RuntimeException: mixin injection failed\"}}\n\
{\"kind\":\"stderr\",\"payload\":{\"line\":\"Caused by: java.lang.NoClassDefFoundError: org/lwjgl/glfw/GLFW\"}}\n\
{\"kind\":\"exit\",\"payload\":{\"code\":1}}\n",
);
let tail: Vec<String> = vec![
"[main/INFO]: Loading Minecraft 1.20.4".to_string(),
"java.lang.RuntimeException: mixin injection failed".to_string(),
"Caused by: java.lang.NoClassDefFoundError: org/lwjgl/glfw/GLFW".to_string(),
];
let run_dir = root.join("instances").join("survival");
let latest = run_dir.join("logs").join("latest.log");
let version_json = root
.join("game")
.join("versions")
.join("1.20.4-fabric")
.join("1.20.4-fabric.json");
write(&version_json, "{\"id\":\"1.20.4-fabric\"}\n");
let mut artifacts: Vec<ArtifactFact> = Vec::new();
if mode != "no-logs" {
write(
&run_dir
.join("crash-reports")
.join("crash-2026-11-08_15.30.19-client.txt"),
"---- Minecraft Crash Report ----\n\
Time: 2026-11-08 15:30:19\n\
Description: Initializing game\n\n\
java.lang.RuntimeException: mixin injection failed\n\
\tat net.fabricmc.loader.impl.launch.knot.Knot.init(Knot.java:142)\n\
\tat net.minecraft.client.main.Main.main(Main.java:51)\n",
);
write(&latest, "[15:30:12] [main/INFO]: Loading Minecraft 1.20.4\n[15:30:19] [Render thread/ERROR]: GLFW init failed\n");
let since = std::time::SystemTime::now() - std::time::Duration::from_secs(120);
artifacts = crash_scan::scan(&run_dir, since, 8)
.into_iter()
.map(|artifact| ArtifactFact {
source: artifact.source.as_str().to_string(),
path: artifact.path,
excerpt: artifact.excerpt,
})
.collect();
}
let report = CrashReport {
instance: "survival".to_string(),
name: "生存服的 1.20.4".to_string(),
version: "1.20.4-fabric".to_string(),
session: session.to_string(),
session_log: Some(session_log),
version_json: Some(version_json),
launcher_logs: Some(logs),
run_dir: Some(run_dir),
artifacts,
exit_code: Some(1),
exit_type: "application_error".to_string(),
uptime_ms: 7_400,
command: "javaw -Xmx4096m -Djava.library.path=<home>… ".to_string(),
java: "C:/Program Files/Java/jdk-21/bin/javaw.exe (major 21)".to_string(),
system: "os=windows version=10.0.26100 arch=x86_64".to_string(),
stage: None,
stage_detail: None,
stderr_tail: tail,
};
crash_report::publish(report);
let finished = LaunchFinished {
id: "survival".to_string(),
session: session.to_string(),
outcome: LogOutcome::Crashed,
exit_code: Some(1),
uptime_ms: 7_400,
failure: None,
};
app.open_failure_dialog(&finished);
if mode == "export" {
// 走**真的**那一条：与用户点「导出诊断包」同一个处理函数。
let _ = super::dialog::on_dialog(app, crate::app::dialog::Message::Primary);
}
Some(mode)
}
/// 夹具里崩溃报告的来源名（与 `CrashSource::CrashReport` 同源，测试用）。
#[allow(dead_code)]
pub(super) fn crash_report_source() -> &'static str {
CrashSource::CrashReport.as_str()
}
crates/app-iced/src/app/update/motion_sync.rs
+166
View File
@@ -0,0 +1,166 @@
//! 动效的**起跑点**（M192 r1 复审 P1-1 修的正是这里）。
//!
//! ## 为什么这条不能在 `view` 里
//!
//! iced 0.14 的处理顺序是：
//!
//! ```text
//! 消息 ──► update() ← program.subscription() 在这里求值（iced_winit src/lib.rs:1338）
//! ──► build_user_interfaces() ← 这时才调 program.view（src/lib.rs:1233）
//! ```
//!
//! 也就是说**订阅表的求值早于视图**。第一版把「内容标识变了 → 起跑」写在 `pages::render`
//! （= `view`）里，于是同一拍订阅表看不见轨道，`frames()` 要等下一条消息（最快鼠标抬起、
//! 最慢 1 Hz 心跳）才打开；那一帧的 dt 又是整段空闲时长 ⇒ 轨道被当成「早已到期」清掉，
//! 用户看到的是一次 12/8px 的偏移闪跳，比硬切更难看。截图通道因为 `has_screenshot()` 恒真，
//! **结构上**不可能暴露这条。
//!
//! 所以起跑搬到这里：`App::update` 处理完每一条消息后调 [`App::sync_motion`]，
//! 于是「轨道存在」对**同一拍**的 `subscription()` 可见，帧订阅当拍打开。
//!
//! ## 标识从哪来
//!
//! 从**路由**取（`AppState::route()` 是唯一真源），不从视图模型取：账户页 / AI 独立页不走
//! `pages::render`，用路由才能表达「这一屏不归 pages 画」（`None`）——它们之间的切换不起跑，
//! 而「从它们回到某一屏」照旧跑换页那一档（复审 r1 结论 4 的硬切顺手收口）。
use unlucky_presenter::router::Route;
use crate::app::components::motion;
use crate::pages;
use super::boot_env::MotionFixture;
use super::*;
impl App {
/// 每条消息处理完之后同步一次内容标识（**必须在 `update` 里**，理由见模块文档）。
pub(in crate::app) fn sync_motion(&mut self) {
// **还没有窗口就什么都不做**（也不记标识）：动效是画出来的东西，没有窗口时
// `window::frames()` 一条消息也不会有，起跑只会白占一档。更要紧的是「首屏入场」的语义——
// 等窗口到了再算「第一眼看到的内容」，否则首屏那一下会被启动期的空树吃掉。
// 截图通道例外：它的窗口句柄也是异步到的，而序列图必须从第 1 帧就按钉住的相位画。
if self.window.is_none() && !self.has_screenshot() {
return;
}
let route = self.state.route();
let screen = screen_key(route);
let detail = match route {
Route::Detail(id) => Some(id.as_str()),
_ => None,
};
motion::observe(screen, detail);
}
/// 出图取证：让这一次进程真的发生一次「换页」或「列表 → 详情」（见 [`super::boot_env::MotionFixture`]）。
pub(in crate::app) fn motion_fixture(&mut self) {
let Some(fixture) = super::boot_env::env_motion_fixture() else {
return;
};
let route = match (fixture, self.frames) {
// 列表 → 详情：第 1 帧先回列表（详情收起来），第 2 帧再点进第一条实例。
(MotionFixture::Detail, 1) => Route::Instances,
(MotionFixture::Detail, 2) => {
let Some(first) = self
.state
.tiles()
.first()
.map(|cell| cell.instance.id.clone())
else {
return;
};
Route::Detail(first)
}
(MotionFixture::Route(route), 1) => route,
_ => return,
};
diag!("[motion] ULL_MOTION_FIXTURE → {route:?}");
self.state.navigate(route);
self.view_dirty = true;
self.refresh_view();
}
/// 真机空闲取证：`ULL_MOTION_FIXTURE_AT=<秒>` 到点就**真的**导航一次（`on_heartbeat` 调）。
///
/// 为什么不用点击：[`super::boot_env::env_motion_fixture_at`] 的文档写了原因——本机会话没有
/// 前台窗口，合成鼠标事件递不进 iced 的输入层。心跳这条路与点击在 `update` 之后是同一段代码。
/// 返回 `true` = 这一拍真的跳了页。
pub(in crate::app) fn motion_fixture_after_idle(&mut self) -> bool {
use std::sync::atomic::{AtomicU32, Ordering};
/// 已经过去的心跳数（进程内一次；只有取证开关打开时才会用到）。
static FIXTURE_BEATS: AtomicU32 = AtomicU32::new(0);
let Some(target) = boot_env::env_motion_fixture_at() else {
return false;
};
let beat = FIXTURE_BEATS.fetch_add(1, Ordering::Relaxed) + 1;
if beat != target {
return false;
}
let route = match boot_env::env_motion_fixture() {
Some(MotionFixture::Route(route)) => route,
Some(MotionFixture::Detail) => {
let Some(id) = self
.state
.tiles()
.first()
.map(|cell| cell.instance.id.clone())
else {
return false;
};
Route::Detail(id)
}
None => Route::Download,
};
diag!("[motion] ULL_MOTION_FIXTURE_AT 到点（第 {beat} 次心跳）→ {route:?}");
self.state.navigate(route);
self.view_dirty = true;
self.refresh_view();
true
}
}
/// 路由 → 屏的稳定键（`pages::Screen::ALL` 的下标 + 1；`None` = 不归 pages 画）。
///
/// 与 `pages::Screen::of` 同一判据（`Screen::Instances` ↔ `Route::Instances | Route::Detail(_)`），
/// 只是把「有没有这一屏」也表达出来——`pages::Screen::of` 给的是 `Option<Screen>`，这里
/// 再折成 `Option<u64>` 给帧泵用。
fn screen_key(route: &Route) -> Option<u64> {
let screen = pages::Screen::of(route)?;
pages::Screen::ALL
.iter()
.position(|candidate| *candidate == screen)
.map(|index| index as u64 + 1)
}
#[cfg(test)]
mod tests {
use super::*;
/// 路由 → 屏键：五个一级页各自唯一，`Detail` 归「实例」，账户/AI 不归 pages。
#[test]
fn only_the_five_screens_get_a_key() {
let keys: Vec<Option<u64>> = [
Route::Instances,
Route::Download,
Route::Content,
Route::Settings,
Route::Logs,
Route::Detail("survival".to_string()),
Route::Accounts,
Route::Agent,
]
.iter()
.map(screen_key)
.collect();
assert_eq!(&keys[..5], &[Some(1), Some(2), Some(3), Some(4), Some(5)]);
assert_eq!(
keys[5],
Some(1),
"详情页归「实例」那一屏（与 Screen::of 同源）"
);
assert_eq!(keys[6], None, "账户页不归 pages 画");
assert_eq!(keys[7], None, "AI 独立页不归 pages 画");
}
}
crates/app-iced/src/app/update/page_messages.rs
+17 -4
View File
@@ -21,6 +21,7 @@
use unlucky_i18n::{Lang, LangChoice};
use crate::app::diag::diag;
use crate::pages;
use crate::ui::lang::LangState;
@@ -94,9 +95,23 @@ impl App {
pages::Message::Instances(message) => return self.on_instance_message(message),
// M114：账户页（三轨登录 / 列表动作 / 表单输入）
pages::Message::Account(message) => return self.on_account(message),
// M188：日志页与设置页的「打开日志文件夹」——同一个落点，路径从设置桥反推
// （三模式都对），失败文本带完整路径，并**送进剪贴板**（打不开时用户至少能粘出去）。
pages::Message::Action(pages::Action::OpenLogs) => {
return match crate::app::logs_folder::open() {
Ok(dir) => {
diag!("[logs] 已打开日志文件夹 {}", dir.display());
Task::none()
}
Err(error) => {
diag!("[logs] 打开日志文件夹失败：{error}");
iced::clipboard::write(error)
}
};
}
// 还没接后端的占位动作：只打日志（哪几个、为什么，见 pages 模块文档的偏离登记）
pages::Message::Action(action) => {
eprintln!("[page] 占位动作 {action:?} pressed（没有对应 AppCommand）");
diag!("[page] 占位动作 {action:?} pressed（没有对应 AppCommand）");
}
}
@@ -127,9 +142,7 @@ impl App {
self.lang = LangState::of(choice);
self.lang.log();
if !self.bridge.persist_ui_language(choice.setting_value()) {
eprintln!(
"[i18n] 语言偏好没落盘（配置只读或数据根解析不出来）：本次生效，重启会回到旧值"
);
diag!("[i18n] 语言偏好没落盘（配置只读或数据根解析不出来）：本次生效，重启会回到旧值");
}
self.lang.log_cjk();
self.view_dirty = true;
crates/app-iced/src/app/update/settings/java.rs
+273 -14
View File
@@ -1,18 +1,30 @@
//! Java 分组消息的落点（M101 `SETTINGSMSG`）：**只归 java 线**。
//! Java 分组消息的落点（M175）：扫描 / 手动路径 / 默认 JDK / 内存 / JVM 参数。
//!
//! 消息口在 `pages/settings/java.rs`（`pages::settings::java::Message`）。加一支消息 = 改那两个
//! 文件，`pages/mod.rs` / `page_messages.rs` / `app/update/settings.rs` 都不用动。
//! 消息口在 `pages/settings/java.rs`（`pages::settings::java::Message`）；状态与读写落在
//! `pages/settings/java/{state,store}.rs`。本文件只有四件事：
//!
//! 消息进来的通道有两条，都不经过共享文件：
//! 1. **页面点击**：`pages::Message::Settings(GroupMessage::Java(..))` → `on_page` → `on_settings`；
//! 2. **异步结果**：本文件自己构造 `Message::Page(pages::Message::Settings(GroupMessage::Java(..)))`
//! （`app::Message::Page` 是既有通道，不用加新变体）。
//! | 消息 | 做什么 |
//! |---|---|
//! | `Scan` / `CancelScan` | 起一次后台真扫盘 / 置取消位（进度由心跳灌回状态） |
//! | `AddDraft` / `Add` | 只改草稿 / 严格校验（真跑 `java -version`）+ 写手动名单 |
//! | `SelectRuntime` | 写 `java.selected_path`（**立刻落盘**，与「设为默认」的语义一致） |
//! | `EditMemory` / `EditJvm` / `Save` | 改草稿 / 校验后写 `java.default_memory_mb` + `java.extra_args` |
//!
//! 穷尽性：这里对 `java::Message` 做**穷尽**匹配（没有 `_ =>`、没有 `other =>`）。加了变体不接线
//! 立刻 E0004；写成兜底会把编译错误降级成「点了没反应」，`app/update/settings/tests.rs` 的
//! `the_group_dispatch_has_no_catch_all_arm` 会红。
//! ## 为什么「设为默认」不攒到「保存」里
//!
//! 它与内存 / JVM 参数是两件事：前者是**选择**（点哪个用哪个，与方案里其它单选控件一致），
//! 后者是**编辑**（有草稿、有脏标记、有保存）。把选择也攒进保存队列，用户点完「设为默认」看到
//! 界面还标着旧的默认值，只会以为没生效。
//!
//! ## 版本门槛（「为什么选它」那句话的数据）
//!
//! `requirement_for(mc_version)` 是 core 的纯函数（静态表，读不到版本 JSON 时也成立）。
//! 页面自己不看盘：本文件在每次 hydrate 时算好 [`Context`] 塞进状态，渲染器只负责画。
use super::super::*;
use crate::app::diag::diag;
use crate::pages::settings::java::{Context, Layer, Notice, Requirement};
impl App {
/// Java 分组的一条消息。
@@ -20,14 +32,261 @@ impl App {
&mut self,
message: pages::settings::java::Message,
) -> Task<Message> {
use pages::settings::java::Message;
match message {
// M101 r2 的**活的端到端证据**：只有测试构造这一支（java 线接第一个真控件时换成真变体）。
// 它真的改一个 app 状态，所以「消息从外壳走到 handler」这件事有运行时证据，不只是编译期。
#[cfg(test)]
pages::settings::java::Message::Ping => {
Message::Scan => return self.start_java_scan(),
Message::CancelScan => {
self.settings.java.scan.cancel();
self.hydrate_java_scan();
}
Message::AddDraft(value) => {
self.settings.java.add_draft = value;
self.settings.java.notice = None;
self.view_dirty = true;
}
Message::Add => self.add_java_manual(),
Message::SelectRuntime(binary) => self.select_java_default(&binary),
Message::EditMemory(value) => {
self.settings.java.memory = value;
self.touch_java();
}
Message::EditJvm(value) => {
self.settings.java.jvm = value;
self.touch_java();
}
Message::Save => self.save_java_settings(),
}
Task::none()
}
/// 记一次「草稿变了」：清掉旧回执（它已经在说另一份配置了），并让视图重建。
fn touch_java(&mut self) {
self.settings.java.dirty = true;
self.settings.java.notice = None;
self.view_dirty = true;
}
/// 从真值（`config/launcher.json` + 手动名单 + 扫描快照）灌一次状态。
///
/// 什么时候调：① 构造之后（首屏就显示已存的值）；② 配置文件被外部改过（`update/clock.rs`
/// 的 mtime 轮询）。**脏草稿不覆盖**（`State::hydrate` 自己判）。
///
/// 首次调用会**自动发起一次扫描**（用户实测的头一条抱怨就是「设置页内并没有自动检测本机已
/// 安装过的 Java 路径」）：已经扫完 / 正在扫 / 截图通道都不重扫，所以它只发生一次。
///
/// 截图通道的两档：`ULL_JAVA_STATE=<empty|two|editing>` 用种子（D30 可复现）；
/// `ULL_JAVA_STATE=live` 走**真路径**（读本机配置 + 真扫盘），用来人工看一眼「别的机器上到底
/// 扫到了什么」——它不是出图档，所以扫描判据按产品路径算。
pub(in crate::app) fn hydrate_java_settings(&mut self) {
let seeded = self.options.screenshot.is_some();
let mut live = false;
if seeded {
let raw = std::env::var("ULL_JAVA_STATE").unwrap_or_else(|_| "two".to_string());
if raw.trim() == "live" {
live = true;
} else {
if let Some(state) = pages::settings::java::State::screenshot_seed(&raw) {
self.settings.java = state;
}
return;
}
}
let Some(config) = pages::settings::java::store::config_of(&self.bridge) else {
self.settings.java = pages::settings::java::State::default();
return;
};
let snapshot = pages::settings::java::store::load(&config);
self.settings.java.manual = pages::settings::java::store::load_manual(&config);
let changed = self.settings.java.hydrate(snapshot);
let scan_changed = self.hydrate_java_scan();
self.settings.java.context = self.java_context();
if changed || scan_changed {
self.view_dirty = true;
}
// 自动扫一次（首屏就该有真数据）。`cfg!(test)` 只关掉**这条生产入口的自动发起**
// （单测不该真去查注册表 / 跑 PATH 上的 java）；判据与发起本身由
// [`App::auto_scan_java_if_due`] 承载，测试直接调它。
if !cfg!(test) {
self.auto_scan_java_if_due(seeded && !live);
}
}
/// 该自动扫就发起一次（判据在 [`pages::settings::java::store::auto_scan_due`]）。
///
/// 单独抽出来是为了可测：`hydrate_java_settings` 的自动发起被 `cfg!(test)` 关掉了，
/// 而「取消过就不再自动扫」这条语义必须有一条能红的用例（r2 复审 P2-2）。
pub(in crate::app) fn auto_scan_java_if_due(&mut self, screenshot: bool) -> bool {
let report = self.settings.java.scan.report();
if pages::settings::java::store::auto_scan_due(&report, screenshot) {
let _ = self.start_java_scan();
return true;
}
false
}
/// 把后台扫描的快照灌进状态。返回是否变了。
pub(in crate::app) fn hydrate_java_scan(&mut self) -> bool {
let report = self.settings.java.scan.report();
let changed = self.settings.java.apply_scan(&report);
if changed {
self.view_dirty = true;
}
changed
}
/// 起一次扫描（真扫盘：托管根 + `JAVA_HOME`/`PATH`/标准安装位置 + 手动名单）。
fn start_java_scan(&mut self) -> Task<Message> {
let Some(config) = pages::settings::java::store::config_of(&self.bridge) else {
self.settings.java.notice = Some(Notice::NoStorage);
self.view_dirty = true;
return Task::none();
};
let manual = pages::settings::java::store::load_manual(&config)
.into_iter()
.map(std::path::PathBuf::from)
.collect::<Vec<_>>();
let roots = pages::settings::java::store::managed_roots(&config);
self.settings.java.notice = None;
if self.settings.java.scan.start(roots, manual, true) {
self.hydrate_java_scan();
}
self.view_dirty = true;
Task::none()
}
/// 手动加一条 JDK 路径：严格校验 → 进名单 → 立刻出现在列表里。
fn add_java_manual(&mut self) {
let Some(config) = pages::settings::java::store::config_of(&self.bridge) else {
self.settings.java.notice = Some(Notice::NoStorage);
self.view_dirty = true;
return;
};
let draft = self.settings.java.add_draft.clone();
match pages::settings::java::store::add_manual(&config, &draft) {
Ok((binary, row)) => {
self.settings.java.manual = pages::settings::java::store::load_manual(&config);
if !self
.settings
.java
.runtimes
.iter()
.any(|known| pages::settings::java::same_path(&known.binary, &binary))
{
self.settings.java.runtimes.push(row);
self.settings
.java
.runtimes
.sort_by_key(|runtime| runtime.major);
}
self.settings.java.add_draft = String::new();
// 手动加的这条已经是「盘上真扫到的一行」，所以顺便把「还没扫描过」这一档收掉：
// 否则列表里明明有一行，状态行却写着「还没扫描过」。
self.settings.java.scanned = true;
self.settings.java.notice = Some(Notice::Added(binary));
}
Err(refusal) => self.settings.java.notice = Some(Notice::Refused(refusal)),
}
self.view_dirty = true;
}
/// 把某个运行时设为默认（写 `java.selected_path`，写完读回）。
fn select_java_default(&mut self, binary: &str) {
let Some(config) = pages::settings::java::store::config_of(&self.bridge) else {
self.settings.java.notice = Some(Notice::NoStorage);
self.view_dirty = true;
return;
};
match pages::settings::java::store::set_selected(&config, binary) {
Ok(snapshot) => {
// **不许清脏**（r1 复审 P2-1）：这一次只写了 `java.selected_path`，内存与 JVM
// 参数的草稿一个字节都没落盘。`hydrate` 在 `dirty` 时本来就保留草稿、只刷新
// `selected` / `saved_*`，所以这里唯一正确的做法是什么都不动。
self.settings.java.hydrate(snapshot);
self.settings.java.context = self.java_context();
self.settings.java.notice = Some(Notice::DefaultSet(binary.to_string()));
}
Err(error) => self.settings.java.notice = Some(write_notice(error)),
}
self.view_dirty = true;
}
/// 保存内存 + JVM 参数：本地校验 → 落盘 → 用**落盘后读回来的真值**刷新。
fn save_java_settings(&mut self) {
let state = &self.settings.java;
if let Err(refusal) = state.validate() {
self.settings.java.notice = Some(Notice::Refused(refusal));
self.view_dirty = true;
return;
}
let Some(config) = pages::settings::java::store::config_of(&self.bridge) else {
self.settings.java.notice = Some(Notice::NoStorage);
self.view_dirty = true;
return;
};
match pages::settings::java::store::save(&config, &self.settings.java) {
Ok(snapshot) => {
// 先清脏再 hydrate：我们刚写进去的就是这一份，不存在「冲掉用户输入」。
self.settings.java.dirty = false;
self.settings.java.hydrate(snapshot);
self.settings.java.context = self.java_context();
self.settings.java.notice = Some(Notice::Saved);
}
Err(error) => self.settings.java.notice = Some(write_notice(error)),
}
self.view_dirty = true;
}
/// 当前实例的上下文（版本门槛 + 生效内存来自哪一层）。
///
/// 「当前实例」= 路由栈顶是详情页时那个实例，否则列表第一行。没有实例 ⇒ 空上下文
/// （页面就不画门槛那一行，也不假装有要求）。
fn java_context(&self) -> Context {
let tiles = self.state.tiles();
let routed = match self.state.route() {
unlucky_presenter::router::Route::Detail(id) => {
tiles.iter().find(|cell| &cell.instance.id == id)
}
_ => None,
};
let Some(cell) = routed.or_else(|| tiles.first()) else {
return Context::default();
};
let instance = cell.instance;
let requirement = unlucky_core::game::java::requirement_for(&instance.mc_version);
Context {
required: Some(Requirement {
instance: instance.name.clone(),
version: instance.mc_version.clone(),
minimum: requirement.minimum,
maximum: requirement.maximum,
}),
layer: Some(match instance.launch.memory_mb {
Some(mb) => Layer::Instance {
instance: instance.name.clone(),
mb,
},
None => Layer::Global,
}),
effective_memory_mb: Some(instance.launch.memory_effective_mb),
}
}
}
/// 写盘失败 → 回执：三档都走 i18n key。
///
/// `WriteError::Schema` 里装的是 `core::setting::StoreError` 的 `Display`（**中文**），
/// 直出会把 `Not saved: IO 失败 @ …` 塞进英文界面（r2 复审 P3-3）——所以只进 stderr 日志，
/// 界面上给一句页面自己的「写不进去」。
fn write_notice(error: pages::settings::java::store::WriteError) -> Notice {
use pages::settings::java::store::WriteError;
match error {
WriteError::Refused(refusal) => Notice::Refused(refusal),
WriteError::Unwritable(reason) => Notice::Unwritable(reason),
WriteError::Schema(detail) => {
diag!("[java] 设置写盘失败：{detail}");
Notice::WriteFailed
}
}
}
crates/app-iced/src/app/update/settings/tests.rs
+10 -2
View File
@@ -256,8 +256,12 @@ fn a_group_message_reaches_its_handler_through_the_funnel() {
let mut app = headless();
app.view_dirty = false;
// M175：`Ping` 随演示行一起删了，改用一个**真变体**（改内存草稿）——它同样只经这条漏斗
// 改 `App` 状态，所以证据强度不变，还顺带证明这条臂真的接到了 handler 上。
let _ = app.update(Message::Page(pages::Message::Settings(
pages::settings::GroupMessage::Java(pages::settings::java::Message::Ping),
pages::settings::GroupMessage::Java(pages::settings::java::Message::EditMemory(
"4096".to_string(),
)),
)));
assert!(
@@ -269,7 +273,7 @@ fn a_group_message_reaches_its_handler_through_the_funnel() {
// --------------------------------------------------------------- M174：助手配置的活路径
/// 一个指向临时目录的设置桥（真文件，不是内存态）。
fn bridged_app(label: &str) -> (App, std::path::PathBuf) {
pub(super) fn bridged_app(label: &str) -> (App, std::path::PathBuf) {
let dir = std::env::temp_dir().join(format!(
"ull-ai-app-{label}-{}-{}",
std::process::id(),
@@ -386,3 +390,7 @@ fn testing_without_configuration_does_nothing() {
);
std::fs::remove_dir_all(path.parent().unwrap().parent().unwrap()).ok();
}
/// M175 r1 复审的用例（拆出来守 400 行硬线；`gate::every_source_file_stays_under_the_line_limit` 会红）。
#[path = "tests/java.rs"]
mod java;
crates/app-iced/src/app/update/settings/tests/java.rs
+163
View File
@@ -0,0 +1,163 @@
//! M175 的 App 层用例：**「设为默认」不许吃掉未保存的内存 / JVM 草稿**（r1 复审 P2-1）。
//!
//! 为什么单独一个文件：`tests.rs` 加上它之后 446 行，越过 400 行硬线
//! （`app/components/gate.rs` 的 `every_source_file_stays_under_the_line_limit` 会判红）。
use super::bridged_app;
use crate::app::Message;
use crate::pages;
// --------------------------------------------------------------- M175 r1 P2-1：设为默认不许吃草稿
/// 一条 Java 分组消息 → 页面消息。
fn java(message: pages::settings::java::Message) -> Message {
Message::Page(pages::Message::Settings(
pages::settings::GroupMessage::Java(message),
))
}
/// 改内存 / JVM 草稿（还没保存）之后去点「设为默认」，**草稿必须还在**，而且仍算未保存。
///
/// 复审 r1 P2-1 的现场：旧代码在 `select_java_default` 里先 `dirty = false` 再 `hydrate`，
/// 于是只写了 `java.selected_path` 的一次操作把用户没保存的内存 / JVM 参数一起冲掉，
/// 一个字节都没落盘、也没有任何提示。
///
/// 变异证明：把 `dirty = false` 那一行加回 `select_java_default` ⇒ 这条红（内存回到 2048、
/// JVM 回到空、`dirty` 变假）。
#[test]
fn setting_the_default_jdk_keeps_unsaved_memory_and_jvm_drafts() {
let (mut app, path) = bridged_app("java-select");
let _ = app.update(java(pages::settings::java::Message::EditMemory(
"6144".to_string(),
)));
let _ = app.update(java(pages::settings::java::Message::EditJvm(
"-XX:+UseG1GC".to_string(),
)));
assert!(app.settings.java.dirty, "改过草稿就该是脏的");
assert_eq!(app.settings.java.saved_memory, 2048, "落盘真值还没变");
let _ = app.update(java(pages::settings::java::Message::SelectRuntime(
"C:/jdk-21/bin/java.exe".to_string(),
)));
assert_eq!(
app.settings.java.selected, "C:/jdk-21/bin/java.exe",
"设为默认必须真的写进去"
);
assert_eq!(
app.settings.java.memory, "6144",
"内存草稿被「设为默认」清掉了（P2-1 的数据丢失）"
);
assert_eq!(
app.settings.java.jvm, "-XX:+UseG1GC",
"JVM 草稿被「设为默认」清掉了（P2-1 的数据丢失）"
);
assert!(
app.settings.java.dirty,
"内存 / JVM 参数还没保存，不许标成已保存"
);
assert_eq!(app.settings.java.saved_memory, 2048, "落盘真值仍然没变");
std::fs::remove_dir_all(path.parent().unwrap().parent().unwrap()).ok();
}
// --------------------------------------------------------------- r2 P2-2：取消之后不许自己重新起来
static HOLD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(true);
/// 一个会一直卡住的扫描作业（直到被取消）。
fn held_job(
_candidates: &[unlucky_core::game::java::staged::Candidate],
cancelled: &dyn Fn() -> bool,
_progress: &mut dyn FnMut(usize, usize),
) -> Vec<pages::settings::java::RuntimeRow> {
while !HOLD.load(std::sync::atomic::Ordering::SeqCst) && !cancelled() {
std::thread::sleep(std::time::Duration::from_millis(10));
}
Vec::new()
}
/// 取消过一次之后，**配置文件再变（心跳重读）也不会把扫描自己拉起来**，状态行仍是「已取消」。
///
/// 现场（r2 复审 P2-2）：被取消的扫描 `running=false` / `cancelled=true` / `finished` 仍是
/// `false`，而 `auto_scan_due` 不看 `cancelled` ⇒ `clock.rs` 的 `reload_if_changed` 每变一次
/// `launcher.json`（存内存、改主题、改语言都算）就重新起一个扫描线程，用户的取消被无声撤销。
///
/// 变异证明：把 `auto_scan_due` 里的 `!report.cancelled` 去掉 ⇒ 这里 `auto_scan_java_if_due`
/// 会真的起第二个线程，`scanning` 变 `Some`、状态行不再是「已取消」⇒ 本条红。
#[test]
fn a_cancelled_scan_is_not_started_again_by_a_config_reload() {
use std::sync::atomic::Ordering;
use std::time::{Duration, Instant};
HOLD.store(false, Ordering::SeqCst);
let (mut app, path) = bridged_app("java-cancel");
// 真起一次扫描（注入卡住的作业），再取消，等线程退出：report 变成
// cancelled=true / finished=false —— 正是复审指认的那个形状。
let slot = app.settings.java.scan.clone();
assert!(slot.start_with(Vec::new(), Vec::new(), false, held_job));
slot.cancel();
let deadline = Instant::now() + Duration::from_secs(5);
while slot.report().running && Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(10));
}
assert!(!slot.report().running, "取消之后线程必须退出");
assert!(slot.report().cancelled);
assert!(!slot.report().finished);
// 心跳那条路：把状态灌一次（`hydrate_java_scan`），再走「该自动扫就扫」的判据。
app.hydrate_java_scan();
assert!(app.settings.java.cancelled, "状态行要留着「已取消」");
assert!(app.settings.java.scanning.is_none());
let started = app.auto_scan_java_if_due(false);
assert!(
!started,
"取消过的扫描不许被自动重新拉起（P2-2：用户取消被无声撤销）"
);
assert!(
!slot.report().running,
"不许起第二个扫描线程：{:?}",
slot.report()
);
app.hydrate_java_scan();
assert!(
app.settings.java.scanning.is_none(),
"状态行不许回到「正在扫描」"
);
assert!(
app.settings.java.cancelled,
"取消标记要保持到下一次手动扫描为止"
);
HOLD.store(true, Ordering::SeqCst);
std::fs::remove_dir_all(path.parent().unwrap().parent().unwrap()).ok();
}
// --------------------------------------------------------------- r2 P3-3：core 的中文串不许直出
/// 写盘被 schema 拒时，界面拿到的是**页面自己的 key**，而不是 `StoreError` 的中文 `Display`。
///
/// 现场（r2 复审 P3-3）：`WriteError::Schema(format!("{error}"))` 里 `core::setting::StoreError`
/// 的 `Display` 是中文（`IO 失败 @ …` / `文件只读，拒绝保存: …`），原样渲染就是
/// `Not saved: IO 失败 @ …`。
///
/// 变异证明：`write_notice` 里把 `Schema(detail)` 映射成 `Notice::Unwritable(NotDirty)` ⇒ 本条红。
#[test]
fn a_schema_rejection_surfaces_as_a_page_key_not_the_core_sentence() {
let (mut app, path) = bridged_app("java-schema");
// `java.extra_args` 的 schema 是 `Text{max_len: 1024}`：本地校验（内存/引号）不管长度，
// 所以这一条会走到 `store.set` 的 schema 拒绝那一档。
let too_long = "-D".to_string() + &"x".repeat(2000);
let _ = app.update(java(pages::settings::java::Message::EditJvm(too_long)));
let _ = app.update(java(pages::settings::java::Message::Save));
assert_eq!(
app.settings.java.notice,
Some(pages::settings::java::Notice::WriteFailed),
"schema 拒绝要走页面的「写不进去」key，不能把 core 的中文句子原样上屏"
);
std::fs::remove_dir_all(path.parent().unwrap().parent().unwrap()).ok();
}
crates/app-iced/src/app/update/update_action.rs
+6 -5
View File
@@ -8,6 +8,7 @@
//! 3. 「立即重启」是本文件唯一碰进程的地方：先按同样的命令行拉起新进程，再退出自己——
//! 正因为替换已经完成（新 exe 就在原路径上），拉起来的就是新版本。
use crate::app::diag::diag;
use iced::Task;
use unlucky_presenter::dto::AppCommand;
@@ -54,7 +55,7 @@ impl App {
/// 忙碌时把这条动作丢掉（不派发、不乐观改状态），并在日志里留一行取证。
fn refuse_busy(&self, what: &str) -> Task<Message> {
eprintln!("[update] 已有一条检查/下载在跑，忽略重复的「{what}」");
diag!("[update] 已有一条检查/下载在跑，忽略重复的「{what}」");
Task::none()
}
@@ -64,26 +65,26 @@ impl App {
/// 文件、并把取证进程拖成死循环。
fn restart_now(&mut self) -> Task<Message> {
if self.options.screenshot.is_some() {
eprintln!("[update] 截图通道不重启（忽略「立即重启」）");
diag!("[update] 截图通道不重启（忽略「立即重启」）");
return Task::none();
}
match std::env::current_exe() {
Ok(exe) => {
let args: Vec<std::ffi::OsString> = std::env::args_os().skip(1).collect();
match std::process::Command::new(&exe).args(&args).spawn() {
Ok(child) => eprintln!(
Ok(child) => diag!(
"[update] 已拉起新进程 pid={}：{}",
child.id(),
exe.display()
),
Err(error) => {
eprintln!("[update] 拉起新进程失败：{error}（请手动重启启动器）");
diag!("[update] 拉起新进程失败：{error}（请手动重启启动器）");
return Task::none();
}
}
}
Err(error) => {
eprintln!("[update] 取 current_exe 失败：{error}");
diag!("[update] 取 current_exe 失败：{error}");
return Task::none();
}
}
crates/app-iced/src/app/view.rs
+7 -1
View File
@@ -75,7 +75,8 @@ impl App {
};
let account = self.rail_account();
match pages::Screen::of(self.state.route()) {
// M187：页面树先立起来，再叠模态层（弹窗画在整窗之上，含标题栏区域）。
let tree: Element<'_, Message> = match pages::Screen::of(self.state.route()) {
Some(_) => shell::view_with_account(
&self.ui,
shell::NavRail {
@@ -124,6 +125,11 @@ impl App {
self.options.force_state,
self.lang(),
),
};
// 队列里有一条就叠一层模态（没有则原样返回）。模型由 `refresh_view` 维护。
match self.dialog_model.as_ref() {
Some(modal) => super::dialog::view::layer(&self.ui, tree, modal),
None => tree,
}
}
}
crates/app-iced/src/components/mod.rs
+3
View File
@@ -11,6 +11,7 @@
//! buttons/ ← COMPBASE（12b §1 按钮家族 + §2 IconButton）
//! divider.rs ← COMPBASE（15 §22）
//! scroll.rs ← M173：竖直滚动区的滚动条槽（轨道不压内容）
//! motion/ ← M192：动效帧泵（时间轴，不是控件家族；页面经 `pages::render` 用它）
//! selection/ ← 本文件只放桩；后续 mission 在自己的目录里填（§18/§19/§10/§13）
//! inputs/ ← 同上（§9/§20/§11/§8）
//! feedback/ ← 同上（§12/§14/§7/§15）
@@ -52,6 +53,8 @@ pub mod gallery;
pub mod inputs;
pub mod interaction;
pub mod layout;
/// M192：动效帧泵（时间轴，不是控件家族）。页面只经 `pages::render` 用它，见模块文档。
pub mod motion;
pub mod navigation;
pub mod scroll;
pub mod selection;
crates/app-iced/src/components/motion/mod.rs
+182
View File
@@ -0,0 +1,182 @@
//! **动效帧泵**（M192）：design 的 motion 令牌 → iced 的**有界**帧订阅。
//!
//! ## 这个模块解决什么
//!
//! `crates/design/src/motion/` 里令牌一直齐着（16 档时长 / 可采样缓动 / 二维弹簧表 /
//! `MotionScale::NONE` 降级），但适配层从没消费过 ⇒ 所有状态变化都是硬切。本模块是那条缺失的
//! 中间层：**谁能动**（[`Slot`]）、**动多久**（[`spec`] 的令牌表）、**什么时候该订阅帧**
//! （[`needs_frames`]）。
//!
//! ## 有界泵的契约（四条，都有守卫）
//!
//! | 契约 | 为什么 | 守在哪 |
//! |---|---|---|
//! | 只在**有轨道**时订阅帧 | `window::frames()` 一订阅就自持重绘循环（实测几百帧/秒） | `pump::tests::a_finished_animation_stops_asking_for_frames` |
//! | 轨道到期**当场删除**，不靠「下次状态变化」 | 删晚了就是空闲烧帧 | 同上（把 `advance` 的清理删掉就红） |
//! | **时间轴推进**不密于 [`FRAME_MS`]（16 ms ≈ 62.5/s），且单次最多吃 [`pump::MAX_STEP_MS`] | 帧到得再快也只该改这么多次布局；空闲醒来时 stale 的帧基准不许把动画一帧杀完 | `pump::tests::frames_are_capped_at_sixty_per_second`、`pump::tests::a_stale_baseline_cannot_kill_the_track_in_one_sample` |
//! | 起跑**必须发生在 `update` 侧**（[`observe`]），`view` 侧只采样（[`sample`]） | iced 先算订阅表（`update()` 内部）后建视图 ⇒ 在 `view` 里插轨道当拍订阅不上，动画会退化成「一帧偏移 + 闪跳」 | `app::subscription::tests::a_state_change_opens_the_frame_subscription_in_the_same_tick` |
//!
//! ⚠️ **16 ms 只卡「采样与布局推进」，不卡整窗重绘。** 整窗重绘**跟随渲染器**：
//! 软件渲染实测 ≈**970 帧/秒**（一次 300 ms 的换页 ≈ **290 次整窗重绘** ≈ **0.30 核·秒**），
//! GPU 档被 AutoVsync 限到 40~60 帧/秒。重绘次数是「订阅开着多久」的函数，与闸门无关。
//!
//! 接法是**加进**既有那条链，不是另起一条：`App::needs_frames()` 多一个「有轨道」的分支，
//! 订阅表仍然是**一处** `if`（`app/subscription.rs`），所以与 `watch_until` / Busy 续订/ 心跳
//! 天然不会双订阅——它们共享同一个布尔。
//!
//! ## `MotionScale::NONE` 是**真归零**
//!
//! 关掉动效 ≠ 跑一遍 0 时长动画：`Pump::play` 在 `is_off()` 时**不插入轨道**，`progress` 于是
//! 直接返回 `1.0`（到位），`needs_frames()` 恒为假 ⇒ **一帧都不订阅**。守卫见
//! `pump::tests::none_scale_never_starts_a_track`。
//!
//! ## 为什么是 thread-local 而不是 `App` 的字段
//!
//! 它是**时间轴**（`(槽 → 进度)` 一张表 + 一个时钟），不是应用状态：没有任何业务语义，也不需要
//! 跨进程持久。iced 在事件循环线程上串行调 `update` / `view`（这与 `App::update(&mut self)` 能存在
//! 是同一条纪律），所以一个线程局部就够，且**测试天然隔离**（`cargo test` 每个用例一个线程，
//! 不会出现「另一条线的动画把 `needs_frames()` 顶成真」的假红）。
//!
//! 仓内已有同样的先例（`pages/appearance/probe.rs`、`core/src/addon/pack/format/probe.rs` 都用了
//! `#[allow(clippy::missing_const_for_thread_local)]`），所以这不是给本 crate 开的新口子。
//!
//! ## 谁在什么时候调
//!
//! | 时机 | 调用 | 在哪 |
//! |---|---|---|
//! | 每条消息处理完（**订阅表求值之前**） | [`observe`]：内容标识变了就起跑 | `App::sync_motion`（`app/update/motion.rs`） |
//! | 每帧画视图 | [`sample`]：只读当前位移 | `pages::render` |
//! | 每帧 | [`advance`]：推进时间轴 | `App::on_frame` |
//!
//! 页面**拿不到**时长/缓动/弹簧参数——那是 [`spec`] 的事。
//!
//! 位移走 `container` 的 `padding`：动画期间内容比容器少几像素高，末帧归零后与静息**逐像素相同**。
//! 不做逐像素 α（D27：CPU 档零运行时半透明）也不做模糊（同上），所以两个渲染后端出图一致。
mod pump;
// 本 mission 里这五个只被测试与文档引用（产品路径只经 `observe`/`sample`/`shifted`，拿不到时长/缓动），
// 所以显式 `allow` 一下——与 `interaction::Tracker` 那条同一条理由：它们是对外口径的一部分
// （`spec` 是唯一一张规格表），不该因为「暂时没人调」就被删掉。
#[allow(unused_imports)]
pub use pump::{offset, spec, Slot, Spec, FRAME_MS};
use std::cell::{Cell, RefCell};
use std::time::Instant;
use iced::widget::container;
use iced::{Element, Length, Padding};
use unlucky_design::motion::MotionScale;
// clippy 1.99 的 `missing_const_for_thread_local` 对**已经是** `const { … }` 的初始化也报
// （换过三种写法都照报，属于误报；复审 r1 已复核并确认，仓内 `pages/appearance/probe.rs` 等
// 两处已有同样的 `allow`）。初始化确实已是常量，所以按项显式放过（上在宏外面不算，lint 是对
// 展开后的 item 报的）。
thread_local! {
/// 进程内唯一时间轴（见模块文档「为什么是 thread-local」）。
#[allow(clippy::missing_const_for_thread_local)]
static PUMP: RefCell<pump::Pump> = const { RefCell::new(pump::Pump::new()) };
/// 上次收到帧的时刻（`advance` 用它把「帧到达」换算成流逝毫秒）。
#[allow(clippy::missing_const_for_thread_local)]
static LAST_FRAME: Cell<Option<Instant>> = const { Cell::new(None) };
}
/// 定档：`on_boot` 调一次（截图档给 `NONE`，CPU 档给 `HALF`，见 `app/update/boot_env.rs`）。
pub fn configure(scale: MotionScale, pin: Option<f64>) {
PUMP.with(|pump| pump.borrow_mut().configure(scale, pin));
}
/// 当前档位。
pub fn scale() -> MotionScale {
PUMP.with(|pump| pump.borrow().scale())
}
/// 已推进的帧数。
pub fn samples() -> u64 {
PUMP.with(|pump| pump.borrow().samples())
}
/// 现在有没有动画在跑（`App::needs_frames` 的一个分支）。
pub fn needs_frames() -> bool {
PUMP.with(|pump| pump.borrow().is_animating())
}
/// 页主体的内容**标识**：**每条消息处理完**调一次（`App::sync_motion`），标识变了就此起跑。
///
/// `screen` 是 `pages::Screen` 的稳定键（`None` = 这一屏不归 pages 画：账户页 / AI 独立页），
/// `detail` 是详情页的实例 id。
///
/// ## 为什么必须在 update 侧（M192 r1 复审 P1-1）
///
/// iced 0.14 的顺序是「消息 → `update()`（订阅表在**这里**求值）→ `build_user_interfaces`
/// （这时才调 `view`）」（iced_winit-0.14.1 `src/lib.rs:1222-1240`）。轨道若在 `view` 里插，
/// 同一拍的订阅表看不见它 ⇒ `frames()` 要等下一条消息（最快鼠标 / 最慢 1 Hz 心跳）才打开，
/// 而那一帧的 dt 是整段空闲时长 ⇒ 动画一帧走完，用户只看到一次偏移闪跳。
///
/// 起跑时**顺带把帧基准重置到「现在」**：空闲期没有帧，`LAST_FRAME` 是几分钟前的值，
/// 不重置的话第一帧仍会按整段空闲时长结算（第二道兜底是 [`pump::MAX_STEP_MS`]）。
pub fn observe(screen: Option<u64>, detail: Option<&str>) {
let started = PUMP.with(|pump| pump.borrow_mut().observe(screen, detail));
if started {
LAST_FRAME.with(|last| last.set(Some(Instant::now())));
}
}
/// 当前入场位移（**只采样、无副作用**）：`pages::render` 每帧调一次。
pub fn sample() -> (f32, f32) {
PUMP.with(|pump| pump.borrow().offsets())
}
/// 推进时间轴（`App::on_frame` 每帧调一次）。
pub fn advance() {
let now = Instant::now();
let elapsed_ms = LAST_FRAME.with(|last| {
let previous = last.replace(Some(now));
previous.map_or(0.0, |previous| {
now.saturating_duration_since(previous).as_secs_f64() * 1000.0
})
});
PUMP.with(|pump| {
pump.borrow_mut().advance(elapsed_ms);
});
}
/// 把入场位移套到树上。
///
/// **总是**套这一层（位移为 `(0,0)` 时只是 `padding = 0`）：它是树的**根**，而 iced 的
/// `Tree::diff` 按 widget tag 判等——根 tag 一换就重建整棵子树。若只在动画期间才套，
/// 动画起止两侧会各重建一次，页面内的滚动位置 / 焦点会被重置（复审 r1 提示的风险）。
/// 常驻一层的代价是布局上多一个 `Fill` 容器（零内距时逐像素相同，出图基线已复验）。
pub fn shifted<'a, M: 'a>(
element: impl Into<Element<'a, M>>,
(dx, dy): (f32, f32),
) -> Element<'a, M> {
container(element.into())
.width(Length::Fill)
.height(Length::Fill)
.padding(Padding {
top: dy,
right: 0.0,
bottom: 0.0,
left: dx,
})
.into()
}
#[cfg(test)]
pub fn reset() {
PUMP.with(|pump| *pump.borrow_mut() = pump::Pump::new());
LAST_FRAME.with(|last| last.set(None));
}
/// 测试专用：按给定毫秒推进（`advance` 读真实时钟，单元测试不能等它）。
#[cfg(test)]
pub fn advance_by(ms: f64) {
PUMP.with(|pump| {
pump.borrow_mut().advance(ms);
});
}
#[cfg(test)]
mod tests;
crates/app-iced/src/components/motion/pump.rs
+348
View File
@@ -0,0 +1,348 @@
//! 帧泵的**纯逻辑**：槽 / 规格表 / 时间轴 / 进度采样。
//!
//! 这一层不认识 iced、不认识线程、不读环境变量——那些都在 [`super`]。分开的理由很实际：
//! 「帧间隔上限」「结束后必须清空」这两条守卫是**算术性质**，用本地 `Pump` 直接摆时间轴就能判死，
//! 不必起窗口、不必等真实时间（那两条最容易写成「看起来在跑」的假绿）。
//!
//! ## 三个概念
//!
//! | 名字 | 是什么 | 谁定 |
//! |---|---|---|
//! | [`Slot`] | 一个**同屏互斥**的动画位（首屏 / 换页 / 列表↔详情） | 本文件 |
//! | [`Spec`] | 该位的时长档 + 缓动档，**只能**是 design 令牌 | [`spec`]（全项目唯一一张表） |
//! | [`Pump`] | 一条时间轴 + 每槽最多一条轨道 | 本文件 |
//!
//! ## 为什么规格表在代码里而不是页面里
//!
//! D31：弹簧/时长令牌是**表**，页面只许按表取、不许自调参数。所以页面拿不到「给我 250ms」这种
//! 口子——它只能说「我要换页了」（[`Pump::enter`]），用哪一档由 [`spec`] 决定。改观感只改这张表。
use std::collections::BTreeMap;
use unlucky_design::motion::{DurationToken, Easing, MotionScale};
use unlucky_design::spacing::Space;
/// 逐帧**推进时间轴**的最短间隔（16 ms ≈ 60 次/秒）。
///
/// ⚠️ **这只卡「采样与布局推进」，不卡整窗重绘。** 两个频率必须分开看：
///
/// | 什么 | 频率 | 由谁决定 |
/// |---|---|---|
/// | 时间轴推进 / 位移采样（本常量） | ≤62.5 次/秒 | 这里 |
/// | **整窗重绘** | **跟随渲染器**：软件渲染实测 ≈**970 帧/秒**（一次 300 ms 的换页 ≈**290 次整窗重绘** ≈ **0.30 核·秒**）；GPU 档被 AutoVsync 限到 40~60 | `window::frames()` 一订阅，iced_winit 每条消息后都 `request_redraw()`（iced_winit-0.14.1 `src/lib.rs:1222-1240`） |
///
/// 所以「动画期间最多 60fps」只对**采样**成立；重绘次数是订阅时长的函数，与 16 ms 无关。
/// 为什么仍然要 16 ms：每帧重绘已经是既成事实（忙碌态本来就这样），16 ms 卡的是**布局重排**
/// 与 `pages::render` 的重建成本；两者的量级差一个数量级以上（见报告的性能记账）。
pub const FRAME_MS: f64 = 16.0;
/// 单次推进的**最大步进**（4 帧 = 64 ms）。
///
/// 为什么需要它：`advance` 的 dt 来自「上一帧到现在」，而空闲期根本没有帧——醒来的第一帧如果
/// 按真实流逝（秒~分钟级）结算，`duration` 当场就被跨过 ⇒ 到期轨道被立刻删除 ⇒ 动画一帧走完
/// （M192 r1 复审 P1-1 就是这么暴露的）。起点由 `motion::observe` 重置，这里再兜一道：
/// **任何一次采样最多只吃掉 4 帧的时长**，掉帧/被挂起时宁可把动画放慢，也不许把它一次性抹掉。
pub const MAX_STEP_MS: f64 = FRAME_MS * 4.0;
/// 一个动效槽。
///
/// 槽是**同屏互斥**的：三个槽都是「页主体入场」的不同触发点，同时跑会让位移叠加
/// （首屏 16 + 换页 12 = 28px）。所以 [`Pump::play`] 起跑新槽时丢掉旧的——语义上也对：
/// 新的一次内容变化取代上一次。
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Slot {
/// 首屏进入：进程内只在第一帧跑一次。
Boot,
/// 换页：路由换了（导航轨点选、返回、启动直达）。
Screen,
/// 列表 ↔ 详情：同一页里的子视图切换（实例页点一行）。
Detail,
}
impl Slot {
/// 全部槽（遍历顺序稳定，写日志/断言用）。
pub const ALL: [Slot; 3] = [Slot::Boot, Slot::Screen, Slot::Detail];
/// 稳定名字（日志与测试失败信息用；只有测试在调，故按 `cfg(test)` 编译）。
#[cfg(test)]
pub const fn name(self) -> &'static str {
match self {
Slot::Boot => "boot",
Slot::Screen => "screen",
Slot::Detail => "detail",
}
}
}
/// 一条轨道的规格：**时长档 × 缓动档**，两个都是 design 令牌。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Spec {
/// 时长档（毫秒值经 [`MotionScale`] 缩放后生效）。
pub duration: DurationToken,
/// 缓动曲线。
pub easing: Easing,
}
/// 槽 → 规格（**唯一**一张表）。
///
/// 三档时长取自令牌注释里对应场景的那一档（`Medium2` = 导航/tab 切换、`Medium3` = 卡片展开/
/// 列表重排、`Medium4` = 面板开合），曲线**统一用 `Standard`**：
///
/// - 整块页面的位移不是「元素从屏外飞入」，而是「屏内这块内容换了」——M3 把 `Standard` 定义为
/// 「起止都在屏内的元素」，`*Decelerate` 是给「已经在高速运动、要迅速落定」的共享元素用的；
/// - 本地实测（`dev` 机器，见报告）：`EmphasizedDecelerate` 把 **75% 的位移压在 51 ms 内**走完
/// （300 ms 档），12px 的整页平移会看起来像「跳一格」；`Standard` 同样时长下是 105 ms，落点更稳。
pub const fn spec(slot: Slot) -> Spec {
match slot {
Slot::Boot => Spec {
duration: DurationToken::Medium4,
easing: Easing::Standard,
},
Slot::Screen => Spec {
duration: DurationToken::Medium2,
easing: Easing::Standard,
},
Slot::Detail => Spec {
duration: DurationToken::Medium3,
easing: Easing::Standard,
},
}
}
/// 槽 → 入场位移（像素；正值 = 从右下方向归位，末态恒为 `(0, 0)`）。
///
/// 幅度取**间距令牌**（4px 栅格）而不是新造一组数字：位移是布局量，和间距用同一把尺子，
/// 将来改栅格不会出现「间距 12、位移 14」这种两套刻度。
pub fn offset(slot: Slot) -> (f32, f32) {
match slot {
Slot::Boot => (0.0, Space::X4.dp()),
Slot::Screen => (0.0, Space::X3.dp()),
Slot::Detail => (Space::X2.dp(), 0.0),
}
}
/// 一条正在跑的轨道。
#[derive(Debug, Clone, Copy)]
struct Track {
/// 起跑时刻（动画时间轴的坐标，毫秒）。
start_ms: f64,
spec: Spec,
}
/// 帧泵：一条时间轴 + 每槽一条轨道。
///
/// **默认是关的**（`MotionScale::NONE`）：产品启动时由 `App::on_boot` 按档位打开，而
/// `pages_demo` 这类截图 harness 从不打开——D30 的「同一份代码出同一张图」因此不受动效影响。
#[derive(Debug)]
pub struct Pump {
scale: MotionScale,
/// `Some(ms)` = 钉住相位（多帧序列图取证；见 `ULL_MOTION_AT`）。
pin: Option<f64>,
now_ms: f64,
pending_ms: f64,
tracks: BTreeMap<Slot, Track>,
screen: Option<u64>,
detail: Option<String>,
painted: bool,
samples: u64,
}
impl Pump {
/// 出厂态：关着、没跑过、没有轨道。
pub const fn new() -> Self {
Self {
scale: MotionScale::NONE,
pin: None,
now_ms: 0.0,
pending_ms: 0.0,
tracks: BTreeMap::new(),
screen: None,
detail: None,
painted: false,
samples: 0,
}
}
/// 定档（启动一拍调一次）。
///
/// 顺带**重置内容标识**：iced 会在处理 `Boot` 之前先问一次 `view()`（实测：那一帧早于
/// `on_boot` 的日志），于是「第一帧」发生在档位还没定下来的时候。不重置的话首屏入场就被那次
/// 预渲染吃掉了（`painted = true`），之后标识再没变过 ⇒ Boot 槽永远不跑。
pub fn configure(&mut self, scale: MotionScale, pin: Option<f64>) {
self.scale = scale;
self.pin = pin;
self.painted = false;
self.screen = None;
self.detail = None;
self.pending_ms = 0.0;
if scale.is_off() {
// 关掉动效 = 直接落终态：把在跑的轨道清掉，而不是让它跑一遍 0 时长。
self.tracks.clear();
}
}
/// 当前档位。
pub fn scale(&self) -> MotionScale {
self.scale
}
/// 已推进的帧数（守卫与 `ULL_TICK_TRACE` 用）。
pub fn samples(&self) -> u64 {
self.samples
}
/// 时间轴（毫秒）。
#[cfg(test)]
pub fn now_ms(&self) -> f64 {
self.now_ms
}
/// 现在有没有动画在跑（= 要不要订阅帧）。
pub fn is_animating(&self) -> bool {
!self.tracks.is_empty()
}
/// 起跑一个槽（关着动效时什么都不做——**不是**跑一遍 0 时长动画）。返回 `true` = 真的起跑了。
///
/// 三个槽**互斥**：它们都是「页主体入场」的不同触发点，同时跑会让位移叠加（首屏 + 换页 =
/// 28px）。所以起跑新槽就丢掉旧的——语义上也对：新的一次内容变化取代上一次。
pub fn play(&mut self, slot: Slot) -> bool {
self.tracks.clear();
if self.scale.is_off() {
return false;
}
// 钉住相位时轨道的起点固定在 0：进度于是恒等于「钉住的毫秒 / 时长」，
// 与「谁在第几帧起跑」无关——这正是多帧序列图要的可复现性。
let start_ms = if self.pin.is_some() { 0.0 } else { self.now_ms };
self.tracks.insert(
slot,
Track {
start_ms,
spec: spec(slot),
},
);
true
}
/// 采样：`0.0` = 刚起跑，`1.0` = 到位（**没有轨道就是到位**）。
pub fn progress(&self, slot: Slot) -> f32 {
let Some(track) = self.tracks.get(&slot) else {
return 1.0;
};
let duration = f64::from(self.scale.ms(track.spec.duration));
if duration <= 0.0 {
return 1.0;
}
let elapsed = self.elapsed_ms() - track.start_ms;
let t = (elapsed / duration).clamp(0.0, 1.0) as f32;
track.spec.easing.sample(t)
}
/// 当前动画时刻（钉住相位时恒为钉住值）。
fn elapsed_ms(&self) -> f64 {
self.pin.unwrap_or(self.now_ms)
}
/// 页主体的内容**标识**变了就起跑对应槽；**必须在 update 侧调**（见 `App::sync_motion`）。
///
/// ## 为什么不能放在 `view` 里（M192 r1 复审 P1-1，这是本轮最重要的一行注释）
///
/// iced 0.14 的顺序是「消息 → `update()`（**`program.subscription()` 在这里求值**）→
/// `build_user_interfaces`（这时才调 `view`）」（iced_winit-0.14.1 `src/lib.rs:1222-1240`，
/// 订阅表在 `update()` 内部的 `lib.rs:1338` 求值）。所以在 `view` 里插轨道，同一拍的订阅表
/// **看不见**它，`frames()` 要等下一条消息（最快鼠标、最慢 1 Hz 心跳）才打开——那一段里
/// 页面已经带着位移画过一帧，然后就没了：用户看到的是一次偏移闪跳。
///
/// 三条判据（顺序即优先级）：
/// 1. 第一次看到**归 pages 画的屏** → [`Slot::Boot`]；
/// 2. 屏变了 → [`Slot::Screen`]；
/// 3. 屏没变但详情变了 → [`Slot::Detail`]。
///
/// `screen == None`（账户页 / AI 独立页：它们不走 `pages::render`）**只记标识、不起跑**——
/// 否则会白跑 300 ms 的帧却没人采样它；而「从这些页回到某一屏」因为标识从 `None` 变回
/// `Some`，仍然会跑换页那一档。
///
/// 返回 `true` = 真的起跑了新轨道（调用方要重置帧基准，见 [`MAX_STEP_MS`]）。
pub fn observe(&mut self, screen: Option<u64>, detail: Option<&str>) -> bool {
let mut started = false;
if !self.painted {
self.painted = true;
if screen.is_some() {
started = self.play(Slot::Boot);
}
} else if self.screen != screen {
if screen.is_some() {
started = self.play(Slot::Screen);
}
} else if self.detail.as_deref() != detail && screen.is_some() {
started = self.play(Slot::Detail);
}
self.screen = screen;
if self.detail.as_deref() != detail {
self.detail = detail.map(str::to_owned);
}
started
}
/// 页主体的入场位移（**只采样，无副作用**）：`pages::render` 每帧调一次。
///
/// 三个槽的剩余量求和后**取整**：整像素位移不会让文字在动画期间发虚；末帧全部 `1.0`
/// ⇒ 恒为 `(0, 0)` ⇒ 与静息的布局逐像素相同。
pub fn offsets(&self) -> (f32, f32) {
let mut dx = 0.0_f32;
let mut dy = 0.0_f32;
for slot in Slot::ALL {
let remaining = 1.0 - self.progress(slot);
let (ox, oy) = offset(slot);
dx += ox * remaining;
dy += oy * remaining;
}
(dx.round(), dy.round())
}
/// 推进时间轴。返回 `true` = 这一帧真的推进了（进度变了 ⇒ 要重画）。
///
/// 四步：①不满 [`FRAME_MS`] 就不动（采样上限）②**单次最多吃 [`MAX_STEP_MS`]**（掉帧 /
/// 被挂起 / 空闲醒来的第一帧都不许一次性跨过时长）③到期的轨道**当场删除**（这是「空闲不烧帧」
/// 的唯一出口：删掉最后一个轨道之后 [`is_animating`](Self::is_animating) 立刻为假，下一拍订阅表
/// 里就不再有 `window::frames()`）④钉住相位时时间轴不前进（取证专用）。
pub fn advance(&mut self, dt_ms: f64) -> bool {
if self.tracks.is_empty() {
self.pending_ms = 0.0;
return false;
}
if dt_ms.is_finite() && dt_ms > 0.0 {
// ②：上限不是「省事」，是正确性——stale 的帧基准（空闲整段）会把轨道一帧杀完。
self.pending_ms += dt_ms.min(MAX_STEP_MS);
}
if self.pending_ms < FRAME_MS {
return false;
}
let step = std::mem::take(&mut self.pending_ms);
if self.pin.is_none() {
self.now_ms += step;
}
self.samples += 1;
let now = self.elapsed_ms();
let finished: Vec<Slot> = self
.tracks
.iter()
.filter(|(_, track)| {
let duration = f64::from(self.scale.ms(track.spec.duration));
duration <= 0.0 || now - track.start_ms >= duration
})
.map(|(slot, _)| *slot)
.collect();
for slot in finished {
self.tracks.remove(&slot);
}
true
}
}
impl Default for Pump {
fn default() -> Self {
Self::new()
}
}
crates/app-iced/src/components/motion/tests.rs
+345
View File
@@ -0,0 +1,345 @@
//! 帧泵的守卫（M192）。全部用**本地** `Pump` 摆时间轴：不起窗口、不等真实时间，所以不会假绿。
//!
//! 接线级的守卫（真消息 / 真订阅表）在 `app/subscription.rs` 的 `mod tests`：这一组只管算术。
use super::pump::{offset, spec, Pump, Slot, FRAME_MS, MAX_STEP_MS};
use super::*;
/// 标准档、没有钉相位的泵（出厂态是 `NONE`，见 [`Pump::new`]）。
fn standard() -> Pump {
let mut pump = Pump::new();
pump.configure(MotionScale::STANDARD, None);
pump
}
/// 按「每帧 16 ms」推进到全部轨道结束（上限 20 s，防死循环）。
fn settle(pump: &mut Pump) -> u64 {
let mut frames = 0;
for _ in 0..1250 {
if !pump.is_animating() {
break;
}
if pump.advance(FRAME_MS) {
frames += 1;
}
}
frames
}
// ------------------------------------------------------------------ 令牌表
/// 规格**全部**来自 design 的令牌表，且落在 M3 的常规区间（改表会让这条红）。
#[test]
fn every_slot_spec_is_a_registered_token_pair() {
for slot in Slot::ALL {
let spec = spec(slot);
let ms = spec.duration.ms();
assert!(
(250..=500).contains(&ms),
"{}: 时长 {}ms 不在换页类动效的合理区间（克制优先）",
slot.name(),
ms
);
// 缓动必须是真的曲线（端点 = 0/1）
assert!(spec.easing.sample(0.0).abs() < 1.0e-6);
assert!((spec.easing.sample(1.0) - 1.0).abs() < 1.0e-6);
// 位移必须来自间距栅格（4 的倍数），且不为零
let (dx, dy) = offset(slot);
assert!(
dx > 0.0 || dy > 0.0,
"{}: 位移为 0 就没有入场感",
slot.name()
);
assert_eq!(dx % 4.0, 0.0);
assert_eq!(dy % 4.0, 0.0);
assert!(dx.max(dy) <= 24.0, "{}: 位移过大（克制优先）", slot.name());
}
// 表本身钉住：谁改了这三档，报告与出图都要跟着改
assert_eq!(spec(Slot::Screen).duration.ms(), 300);
assert_eq!(spec(Slot::Detail).duration.ms(), 350);
assert_eq!(spec(Slot::Boot).duration.ms(), 400);
}
// ------------------------------------------------------------------ 有界泵
/// **空闲不烧帧**：动画跑完 ⇒ `is_animating()` 立刻为假，且不再推进。
///
/// 抓得住：把 `advance` 里的「到期即删除」删掉（轨道永远留着 ⇒ 帧订阅永不退订），或把
/// `is_animating` 改成恒真。两条都让本用例红。
#[test]
fn a_finished_animation_stops_asking_for_frames() {
let mut pump = standard();
assert!(pump.play(Slot::Screen), "起跑必须成功");
assert!(pump.is_animating(), "起跑后必须有轨道（订阅帧的唯一理由）");
settle(&mut pump);
assert!(
!pump.is_animating(),
"动画结束必须**当场**退订（占着轨道 = 空闲烧帧）"
);
assert_eq!(pump.progress(Slot::Screen), 1.0, "结束即到位");
assert_eq!(pump.offsets(), (0.0, 0.0), "结束即归位");
// 再推进也不该有任何采样（订阅表里已经没有帧了）
let before = pump.samples();
for _ in 0..60 {
assert!(!pump.advance(FRAME_MS), "没有轨道时推进必须返回 false");
}
assert_eq!(pump.samples(), before, "空闲态一次采样都不该发生");
}
/// **采样频率上限**：帧到得再快，时间轴也只按 16 ms 结算（≈62.5 次/秒）。
///
/// 注意这条**不管整窗重绘**：重绘跟随渲染器（见 [`FRAME_MS`] 文档）。
/// 抓得住：把 `pending_ms` 那道闸门删掉（每来一帧就推进 ⇒ 软件渲染下几百次/秒的重排）。
#[test]
fn frames_are_capped_at_sixty_per_second() {
let mut pump = standard();
pump.play(Slot::Screen);
// 200 帧、每帧 1 ms（模拟 1000 fps 的渲染器）
let mut advanced = 0;
for _ in 0..200 {
if pump.advance(1.0) {
advanced += 1;
}
}
assert!(
advanced <= 13,
"200 ms 内最多 13 次推进（200/16），实测 {advanced} 次"
);
assert!(
advanced >= 11,
"也别少得离谱（掉帧会看起来卡），实测 {advanced}"
);
assert_eq!(pump.samples(), advanced);
// 时间轴按真实时间走，不受「帧被合并」影响
assert!(
(pump.now_ms() - 192.0).abs() <= 16.0,
"时间轴应约 192 ms（12 × 16），实测 {}",
pump.now_ms()
);
}
/// **stale 帧基准不许把轨道一帧杀完**（M192 r1 复审 P1-1 的算术面）。
///
/// 运行时真出现过：空闲几分钟后第一条消息起跑轨道，第一帧的 dt 是整段空闲时长 ⇒ 立即到期 ⇒
/// 动画一帧走完，用户只看到一次偏移闪跳。两道兜底：起跑时重置帧基准（`motion::observe`）与
/// 单次最大步进 [`MAX_STEP_MS`]；这条守的是第二道。
#[test]
fn a_stale_baseline_cannot_kill_the_track_in_one_sample() {
let mut pump = standard();
pump.play(Slot::Screen);
// 60 秒的「空闲间隔」当 dt
assert!(pump.advance(60_000.0));
assert!(
pump.is_animating(),
"一次超长 dt 不许把轨道当场删掉（那就等于没有动画）"
);
assert!(
pump.now_ms() <= MAX_STEP_MS + 1.0e-6,
"单次推进最多 {:?} ms，实测 {}",
MAX_STEP_MS,
pump.now_ms()
);
assert!(
pump.progress(Slot::Screen) < 1.0,
"进度不许一步到位（那就是闪跳）"
);
// 正常帧间隔照样把动画跑完（没被抖动卡死）
settle(&mut pump);
assert!(!pump.is_animating());
}
/// 采样必须单调、且末尾回到 1.0（回弹类曲线不在本批，见 [`spec`] 的表）。
#[test]
fn progress_is_monotone_and_lands_on_one() {
let mut pump = standard();
pump.play(Slot::Detail);
let mut previous = 0.0;
for _ in 0..40 {
let value = pump.progress(Slot::Detail);
assert!(value >= previous, "进度倒退了：{previous} → {value}");
previous = value;
if !pump.advance(FRAME_MS) {
break;
}
}
assert_eq!(previous, 1.0, "末帧必须到位");
}
// ------------------------------------------------------------------ NONE 降级
/// **`MotionScale::NONE` 是真归零**：不起轨道、不采样、位移恒为 0。
///
/// 抓得住：把 `play` 里的 `is_off()` 分支删掉（变成「跑一遍 0 时长动画」）——那样这个用例里
/// `is_animating()` 会短暂为真、`samples` 会增长，帧订阅次数就不是 0 了。
#[test]
fn none_scale_never_starts_a_track() {
let mut pump = Pump::new(); // 出厂即 NONE
assert!(pump.scale().is_off());
// 首屏 + 换页 + 换详情：三次状态变化都不许留下轨道
assert!(!pump.observe(Some(1), None), "关掉动效时不许起跑");
assert_eq!(pump.offsets(), (0.0, 0.0), "关掉动效必须直接落终态");
assert!(!pump.is_animating());
assert!(!pump.observe(Some(2), None));
assert_eq!(pump.offsets(), (0.0, 0.0));
assert!(!pump.observe(Some(2), Some("instance-7")));
assert_eq!(pump.offsets(), (0.0, 0.0));
assert!(!pump.is_animating());
for _ in 0..120 {
assert!(!pump.advance(FRAME_MS), "关掉动效后没有任何可推进的");
}
assert_eq!(pump.samples(), 0, "NONE 档的帧订阅次数必须是 0");
}
/// 运行期把关掉动效（`configure(NONE)`）也要立刻落终态，而不是把在跑的动画「缩到 0 时长」。
#[test]
fn switching_to_none_mid_flight_settles_immediately() {
let mut pump = standard();
pump.play(Slot::Screen);
pump.advance(FRAME_MS);
assert!(pump.is_animating());
pump.configure(MotionScale::NONE, None);
assert!(!pump.is_animating(), "关掉动效必须当场清空轨道");
assert_eq!(pump.progress(Slot::Screen), 1.0);
assert_eq!(pump.offsets(), (0.0, 0.0));
}
/// 半速档（CPU 渲染兜底）真的把时长减半：同样的时间轴推进，轨道更早结束。
#[test]
fn half_scale_finishes_in_half_the_frames() {
let mut full = standard();
full.play(Slot::Screen);
let full_frames = settle(&mut full);
let mut half = Pump::new();
half.configure(MotionScale::HALF, None);
half.play(Slot::Screen);
let half_frames = settle(&mut half);
assert!(half_frames > 0 && full_frames > 0);
assert!(
half_frames * 2 <= full_frames + 2,
"半速档应约用一半帧数：full={full_frames} half={half_frames}"
);
}
// ------------------------------------------------------------------ 触发判据
/// 三个槽的触发优先级：首屏 Boot → 换屏 Screen → 同屏换详情 Detail。
#[test]
fn identity_changes_pick_the_right_slot() {
let mut pump = standard();
// 首帧：Boot（位移是纵向 16）
assert!(pump.observe(Some(1), None), "首帧要跑 Boot 槽");
let (dx, dy) = pump.offsets();
assert_eq!(dx, 0.0);
assert_eq!(dy, offset(Slot::Boot).1, "首屏应有一个向下的入场位移");
assert_eq!(
pump.progress(Slot::Screen),
1.0,
"首帧不该顺带起跑 Screen 槽"
);
settle(&mut pump);
assert!(!pump.observe(Some(1), None), "标识没变 ⇒ 不起跑");
assert_eq!(pump.offsets(), (0.0, 0.0));
// 换屏：Screen（纵向）
assert!(pump.observe(Some(2), None));
let (dx, dy) = pump.offsets();
assert_eq!(dx, 0.0);
assert_eq!(dy, offset(Slot::Screen).1);
assert!(pump.progress(Slot::Screen) < 1.0, "换屏要跑 Screen 槽");
settle(&mut pump);
// 同屏换详情：Detail（横向）
assert!(pump.observe(Some(2), Some("instance-7")));
let (dx, dy) = pump.offsets();
assert_eq!(dx, offset(Slot::Detail).0, "列表↔详情是横向入场");
assert_eq!(dy, 0.0);
assert!(pump.progress(Slot::Detail) < 1.0);
settle(&mut pump);
assert!(!pump.observe(Some(2), Some("instance-7")));
assert_eq!(pump.offsets(), (0.0, 0.0));
}
/// 不归 pages 画的屏（账户页 / AI 独立页，`screen == None`）**不起跑**；回到某一屏照样跑。
#[test]
fn screens_rendered_elsewhere_never_start_a_track() {
let mut pump = standard();
assert!(pump.observe(Some(1), None), "首屏开机跑 Boot");
settle(&mut pump);
assert!(!pump.observe(None, None), "没有 pages 树可动 ⇒ 不许白开帧");
assert!(!pump.is_animating());
assert_eq!(pump.offsets(), (0.0, 0.0));
assert!(
pump.observe(Some(1), None),
"从账户页回到某一屏仍然是换页，要跑"
);
assert_eq!(pump.offsets().1, offset(Slot::Screen).1);
}
/// 换页会**取代**首屏那一档：位移不叠加（12px，不是 16+12）。
#[test]
fn a_new_transition_supersedes_the_previous_one() {
let mut pump = standard();
assert_eq!(
pump.offsets().1,
0.0,
"还没 observe 时没有位移（采样是纯函数）"
);
pump.observe(Some(1), None);
assert_eq!(pump.offsets().1, offset(Slot::Boot).1);
// 首屏还没跑完就换页：位移必须是 Screen 那一档，而不是两档相加
pump.observe(Some(2), None);
assert_eq!(
pump.offsets().1,
offset(Slot::Screen).1,
"新的一次内容变化应取代上一次（叠加会让位移变成两档之和）"
);
}
/// 同一屏同一详情重复绘制**永远不会**重新起跑（否则每帧都在重启动画 = 永远停不下来）。
#[test]
fn repeated_paints_never_restart_the_animation() {
let mut pump = standard();
pump.observe(Some(3), Some("instance-9"));
let frames = settle(&mut pump);
assert!(frames > 0);
for _ in 0..30 {
assert!(!pump.observe(Some(3), Some("instance-9")));
assert_eq!(pump.offsets(), (0.0, 0.0));
}
assert!(!pump.is_animating(), "重复绘制不该起新轨道");
}
// ------------------------------------------------------------------ 取证相位
/// `ULL_MOTION_AT` 的钉住相位：时间轴不前进，进度恒定（多帧序列图靠它可复现）。
#[test]
fn pinned_phase_freezes_the_clock() {
let mut pump = Pump::new();
pump.configure(MotionScale::STANDARD, Some(150.0));
pump.play(Slot::Screen); // 300 ms 档 ⇒ 钉在 150 = 一半
for _ in 0..10 {
pump.advance(FRAME_MS);
}
let progress = pump.progress(Slot::Screen);
assert!(
(progress - spec(Slot::Screen).easing.sample(0.5)).abs() < 1.0e-6,
"钉在 150/300 的进度应等于缓动曲线的中点，实测 {progress}"
);
assert!(pump.is_animating(), "钉住的相位不会自然结束（取证专用）");
}
crates/app-iced/src/components/selection/chip.rs
+16
View File
@@ -56,6 +56,22 @@ impl<'a, M> Chip<'a, M> {
Self::new(label, ChipVariant::Input, false, on_press)
}
/// **纯展示**的 filter chip（选中态、无消息 ⇒ 永远不可交互）。
///
/// 与 `filter(label, true, msg).disabled()` 等价，但**不要求调用方编一条永远收不到的消息**：
/// 本轮 Java 页那颗「默认」标记就是这么用的（`Message::Noop` 已删，别再拿一条真消息当占位）。
pub fn badge(label: &'a str) -> Self {
Self {
label,
variant: ChipVariant::Filter,
selected: true,
leading: None,
trailing: None,
on_press: None,
state: None,
}
}
/// 转成禁用：**只清消息**，图标 / 选中态 / 状态层全部保留（复审 P2-1）。
///
/// 官方禁用态是「容器/描边 12%、文字与**图标** 38%」——只降**不删**。早先的
crates/app-iced/src/pages/account.rs
+3
View File
@@ -38,6 +38,9 @@ pub mod widgets;
#[cfg(test)]
mod tests;
#[cfg(test)]
#[path = "account/tests_msa.rs"]
mod tests_msa;
#[cfg(test)]
#[path = "account/tests_text.rs"]
mod tests_text;
crates/app-iced/src/pages/account/login.rs
+88 -55
View File
@@ -2,9 +2,15 @@
//!
//! ## 为什么不是「一个转圈」
//!
//! 设备码流的等待期可以长到 15 分钟。只画转圈的话，用户既不知道要做什么、也不知道还剩多久，
//! 更不知道已经过期了——M114 把这三件事都做成可见状态：用户码（可复制）、链接（可复制/打开）、
//! 倒计时（`{secs}s left`）与过期后的「已过期，重试」。授权码流同理，另外必须能**取消**。
//! 设备码的等待期可以长到 15 分钟。只画转圈的话，用户既不知道要做什么、也不知道还剩多久，
//! 更不知道已经过期了——M114 把这三件事都做成可见状态：用户码、链接、倒计时与「已过期，重试」。
//!
//! ## 文案一律**借用模型里的串**（M178）
//!
//! 倒计时/回退说明这类运行时格式化出来的句子由 [`super::panels`] 在模型层拼好（带 i18n），
//! 视图只拿 `&'a str` 画。为什么不在这里 `format!` 后交给 `frame::text_role_owned`：
//! 那条 owned 路径上的**中文画不出来**（实测：同一位置 ASCII 能画、`剩 15:00` 一片空白），
//! 而借用路径正常。模型持有字符串、视图借用，两个问题一起消掉。
use iced::widget::{column, row};
use iced::{Alignment, Element};
@@ -13,7 +19,7 @@ use unlucky_design::color::Role;
use unlucky_design::spacing::Space;
use unlucky_design::typography::TypeRole;
use unlucky_i18n::{Catalog, Key};
use unlucky_presenter::dto::LoginFailure;
use unlucky_presenter::dto::{BrowserLoginNote, LoginFailure};
use crate::app::components::buttons::{self, Button};
use crate::pages::frame;
@@ -36,34 +42,40 @@ pub fn panel<'a>(
DevicePanel::Code {
code,
link,
remaining,
countdown,
expired,
} => device_code(ui, code, link, *remaining, *expired, catalog),
note,
} => device_code(ui, code, link, countdown, *expired, *note, catalog),
DevicePanel::Browser {
link,
remaining,
countdown,
expired,
} => browser(ui, link, *remaining, *expired, catalog),
DevicePanel::Failed { failure } => failed(ui, *failure, catalog),
} => browser(ui, link, countdown, *expired, catalog),
DevicePanel::Failed { failure, note } => failed(ui, *failure, *note, catalog),
DevicePanel::Succeeded { name } => succeeded(ui, name, catalog),
}
}
/// 空闲：给出两条流的入口（GUI 默认授权码流，设备码是备选）。
/// 空闲：两条流的入口。**主按钮是设备码**（M178）：它不依赖应用注册里的任何一项，是官方
/// 产物上唯一开箱可用的路；浏览器流是右手的次要按钮（要注册 `http://localhost/auth`，
/// 没登记时在预检处直接回退设备码）。
///
/// 文案（复审 r1 P2-5）：主按钮写「使用 Microsoft 账户登录」而不是「改用设备码」；
/// 「没有浏览器时用这个」放在按钮下面一行说明里。
fn idle<'a>(ui: &'a Ui, catalog: Catalog) -> Element<'a, PageMessage> {
let body = column![row![
buttons::filled(
ui,
Button::new(
catalog.text(Key::AccountDeviceBrowser),
Account::StartBrowser.into_page(),
catalog.text(Key::AccountDeviceSignIn),
Account::StartDevice.into_page(),
)
),
buttons::outlined(
ui,
Button::new(
catalog.text(Key::AccountDeviceUseCode),
Account::StartDevice.into_page(),
catalog.text(Key::AccountDeviceBrowser),
Account::StartBrowser.into_page(),
)
),
buttons::text(
@@ -76,7 +88,14 @@ fn idle<'a>(ui: &'a Ui, catalog: Catalog) -> Element<'a, PageMessage> {
]
.spacing(ui.space(Space::X2))
.align_y(Alignment::Center),]
.spacing(ui.space(Space::X3));
.spacing(ui.space(Space::X3))
.push(frame::text_role(
ui,
TypeRole::BodySmall,
false,
catalog.text(Key::AccountDeviceFallbackHint),
ui.color(Role::OnSurfaceVariant),
));
frame::card(ui, body)
}
@@ -105,13 +124,14 @@ fn requesting<'a>(ui: &'a Ui, catalog: Catalog) -> Element<'a, PageMessage> {
frame::card(ui, body)
}
/// 设备码等待态：**码 + 链接 + 倒计时**。
/// 设备码等待态：码 + 链接 + 倒计时（`note` = 回退说明）。
fn device_code<'a>(
ui: &'a Ui,
code: &'a str,
link: &'a str,
remaining: Option<u64>,
countdown: &'a str,
expired: bool,
note: Option<BrowserLoginNote>,
catalog: Catalog,
) -> Element<'a, PageMessage> {
let mut actions = row![
@@ -150,9 +170,7 @@ fn device_code<'a>(
),
));
let countdown = countdown_line(ui, remaining, expired, catalog);
let body = column![
let mut body = column![
frame::text_role(
ui,
TypeRole::LabelMedium,
@@ -174,7 +192,7 @@ fn device_code<'a>(
link,
ui.color(Role::OnSurfaceVariant),
),
countdown,
countdown_line(ui, countdown, expired),
frame::text_role(
ui,
TypeRole::BodySmall,
@@ -182,17 +200,21 @@ fn device_code<'a>(
catalog.text(Key::AccountDeviceHint),
ui.color(Role::OnSurfaceVariant),
),
actions,
]
.spacing(ui.space(Space::X3));
frame::card(ui, body)
// 回退说明放在**动作行之前**：它解释的是「这个面板为什么是设备码」，
// 用户读完再决定复制码/取消（放在按钮下面会像脚注，读不到）。
if let Some(text) = note_text(ui, note, catalog) {
body = body.push(text);
}
frame::card(ui, body.push(actions))
}
/// 授权码等待态：浏览器已拉起，链接可复制；过期可重试。
fn browser<'a>(
ui: &'a Ui,
link: &'a str,
remaining: Option<u64>,
countdown: &'a str,
expired: bool,
catalog: Catalog,
) -> Element<'a, PageMessage> {
@@ -237,37 +259,19 @@ fn browser<'a>(
link,
ui.color(Role::OnSurfaceVariant),
),
countdown_line(ui, remaining, expired, catalog),
countdown_line(ui, countdown, expired),
actions,
]
.spacing(ui.space(Space::X3));
frame::card(ui, body)
}
/// 倒计时 / 过期提示（**这一行是「不得只转圈」的落点**）。
fn countdown_line<'a>(
ui: &'a Ui,
remaining: Option<u64>,
expired: bool,
catalog: Catalog,
) -> Element<'a, PageMessage> {
/// 倒计时 / 过期提示（**这一行是「不得只转圈」的落点**；文案由模型拼好，这里只定颜色与强调）。
fn countdown_line<'a>(ui: &'a Ui, text: &'a str, expired: bool) -> Element<'a, PageMessage> {
if expired {
return frame::text_role(
ui,
TypeRole::LabelMedium,
true,
catalog.text(Key::AccountDeviceExpired),
ui.color(Role::Error),
);
return frame::text_role(ui, TypeRole::LabelMedium, true, text, ui.color(Role::Error));
}
let text = remaining.map_or_else(String::new, |secs| {
// mm:ss（`15:00 left`）而不是 `900s left`：人读的是分秒，而且不随语言换格式
// （数字与冒号在两种语言里同形，只有 `left`/`剩` 走 catalog）。
let clock = format!("{:02}:{:02}", secs / 60, secs % 60);
catalog.render(Key::AccountDeviceCountdown, &[("time", &clock)])
});
// 运行时格式化的串走 `text_role_owned`（`text_role` 只借 `&'a str`）
frame::text_role_owned(
frame::text_role(
ui,
TypeRole::LabelMedium,
false,
@@ -276,16 +280,45 @@ fn countdown_line<'a>(
)
}
/// 回退说明的**唯一文案出口**（视图与页面级断言共用：断言取样走这里，才是「视图会画的那句」）。
pub(super) fn browser_note_text(note: BrowserLoginNote, catalog: Catalog) -> &'static str {
catalog.text(super::model::note_key(note))
}
/// 回退说明那一行（`None` = 没有这回事）。
fn note_text<'a>(
ui: &'a Ui,
note: Option<BrowserLoginNote>,
catalog: Catalog,
) -> Option<Element<'a, PageMessage>> {
let note = note?;
// 用正文色而不是 `Error`：这不是失败态（设备码接着跑），画成红色会让人以为登录已经挂了。
Some(frame::text_role(
ui,
TypeRole::BodySmall,
false,
browser_note_text(note, catalog),
ui.color(Role::OnSurfaceVariant),
))
}
/// 失败态：**M3 内联 alert**（左侧 `ErrorContainer` 图标块 + 标题/正文/Code + 重试/关闭）。
///
/// 三点修订叠在这里：
/// - **语言泄漏（r1 p1）**：只画原因码对应的 i18n + 一行 `Code: …`，后端中文原文不上屏；
/// - **不许通栏实心红（tower r2）**：面板底走 `SurfaceContainerHigh` + 描边，
/// `ErrorContainer`/`OnErrorContainer` 只作左侧图标块的强调（角色不变，面积收小）；
/// - **可操作的失败要有可读说明（M132）**：缺 client id 换专属标题 + 「要设哪个环境变量」的
/// 正文，且**不给「重试」**——进程内的环境变量改不了，重试必然还是同一个错。
fn failed<'a>(ui: &'a Ui, failure: LoginFailure, catalog: Catalog) -> Element<'a, PageMessage> {
let body = catalog.text(failure_body_key(failure)).to_string();
/// - 语言泄漏（r1 p1）：只画原因码对应的 i18n + 一行 `Code: …`，后端中文原文不上屏；
/// - 不许通栏实心红（tower r2）：面板底 `SurfaceContainerHigh` + 描边，`ErrorContainer` 只做图标块强调；
/// - 可操作的失败要有可读说明（M132）：缺 client id 换专属标题 + 「要设哪个环境变量」，且不给「重试」；
/// - M178：`note`（浏览器登录没走成）另起一行画在正文下面，两者都能看见。
fn failed<'a>(
ui: &'a Ui,
failure: LoginFailure,
note: Option<BrowserLoginNote>,
catalog: Catalog,
) -> Element<'a, PageMessage> {
let mut body = catalog.text(failure_body_key(failure)).to_string();
if let Some(note) = note {
body.push_str("\n\n");
body.push_str(browser_note_text(note, catalog));
}
let code = catalog.render(Key::AccountFailureCode, &[("code", failure.code())]);
let mut actions: Vec<Element<'a, PageMessage>> = Vec::new();
if !matches!(failure, LoginFailure::MsaNotConfigured) {
crates/app-iced/src/pages/account/model.rs
+17 -2
View File
@@ -7,7 +7,9 @@
use iced::widget::image;
use unlucky_i18n::{Key, Lang};
use unlucky_presenter::dto::{AccountKind, AccountNotice, AccountNoticeCode, AccountView};
use unlucky_presenter::dto::{
AccountKind, AccountNotice, AccountNoticeCode, AccountView, BrowserLoginNote,
};
use unlucky_presenter::state::AppState;
use super::avatar::{Avatar, Cache};
@@ -164,6 +166,18 @@ impl Form {
}
}
/// 回退说明码 → i18n key（**唯一的「码→文案」映射点**；原文永远不上屏）。
///
/// 与 [`Track::title_key`] 同一种写法：页面只认 key，后端只给码，两边独立演进。
#[must_use]
pub const fn note_key(note: BrowserLoginNote) -> Key {
match note {
BrowserLoginNote::RedirectNotRegistered => Key::AccountBrowserFallbackNotRegistered,
BrowserLoginNote::PreflightUnavailable => Key::AccountBrowserFallbackUnverified,
BrowserLoginNote::AttemptFailed => Key::AccountBrowserFallbackFailed,
}
}
/// 列表行 / 当前账户卡片用的数据。
#[derive(Debug, Clone, PartialEq)]
pub struct Row {
@@ -253,7 +267,8 @@ impl Page {
.map(|account| row_of(account, avatars, lang))
.collect();
let active = rows.iter().position(|row| row.active);
let device = device_panel(&state.device_login, state.device_code_remaining());
let remaining = state.device_code_remaining();
let device = device_panel(&state.device_login, remaining, lang.catalog());
// 登录在进行（或刚失败/刚成功）时，面板**必须**是微软那条轨：否则用户点了登录、
// 后台已经在等设备码，页面上却只剩三张入口卡——那正是「只转圈」的另一种坏法。
let panel = if matches!(device, DevicePanel::Hidden) {
crates/app-iced/src/pages/account/panels.rs
+40 -9
View File
@@ -10,7 +10,10 @@
//! 现在直接把字段删掉：视图**没有材料可画**，想画原文是编译错误——比任何测试都硬。
//! 原文仍在 presenter 的 `DeviceLoginView/AuthlibLoginView::message` 里（只进 `eprintln!`）。
use unlucky_presenter::dto::{AuthlibLoginView, DeviceLoginPhase, DeviceLoginView, LoginFailure};
use unlucky_i18n::{Catalog, Key};
use unlucky_presenter::dto::{
AuthlibLoginView, BrowserLoginNote, DeviceLoginPhase, DeviceLoginView, LoginFailure,
};
/// 微软登录面板要画什么（每态都不同，**不允许只有一个转圈**）。
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -25,17 +28,23 @@ pub enum DevicePanel {
code: String,
/// 验证链接
link: String,
/// 剩余秒数
remaining: Option<u64>,
/// 是否已过期
/// 倒计时那行**已经渲染好的文案**（`15:00 left` / `剩 15:00`；过期时是「已过期」）
///
/// 为什么文案在模型层拼（M178）：`frame::text_role_owned` 那条 owned 文字路径
/// **画不出中文**（ASCII 正常），倒计时在中文界面会整行消失。模型持有字符串、
/// 视图用 `&'a str` 借用，两边都不依赖那条路径。
countdown: String,
/// 是否已过期（决定颜色与「重试」按钮）
expired: bool,
/// 浏览器登录没走成、已回退到设备码的说明（M178；`None` = 没这回事）
note: Option<BrowserLoginNote>,
},
/// 授权码流：等浏览器回调
Browser {
/// 授权链接（可复制）
link: String,
/// 剩余秒数
remaining: Option<u64>,
/// 倒计时那行已渲染好的文案（同上）
countdown: String,
/// 是否已过期
expired: bool,
},
@@ -43,6 +52,8 @@ pub enum DevicePanel {
Failed {
/// 原因码（页面据此选 i18n）
failure: LoginFailure,
/// 回退说明（浏览器登录没走成之后设备码也失败了；M178）
note: Option<BrowserLoginNote>,
},
/// 成功
Succeeded {
@@ -76,8 +87,13 @@ pub enum AuthlibPanel {
}
/// 微软登录状态 → 面板态（倒计时与「已过期」都在这里定性，UI 只画）。
pub(super) fn device_panel(view: &DeviceLoginView, remaining: Option<u64>) -> DevicePanel {
pub(super) fn device_panel(
view: &DeviceLoginView,
remaining: Option<u64>,
catalog: Catalog,
) -> DevicePanel {
let expired = remaining == Some(0);
let countdown = countdown_text(remaining, expired, catalog);
match view.phase {
DeviceLoginPhase::Idle => DevicePanel::Hidden,
DeviceLoginPhase::Requesting => DevicePanel::Requesting,
@@ -85,20 +101,22 @@ pub(super) fn device_panel(view: &DeviceLoginView, remaining: Option<u64>) -> De
if view.user_code.trim().is_empty() {
DevicePanel::Browser {
link: view.verification_uri.clone(),
remaining,
countdown,
expired,
}
} else {
DevicePanel::Code {
code: view.user_code.clone(),
link: view.qr_link.clone(),
remaining,
countdown,
expired,
note: view.browser_note,
}
}
}
DeviceLoginPhase::Failed => DevicePanel::Failed {
failure: view.failure.unwrap_or(LoginFailure::Other),
note: view.browser_note,
},
DeviceLoginPhase::Succeeded => DevicePanel::Succeeded {
name: view.account_name.clone(),
@@ -106,6 +124,19 @@ pub(super) fn device_panel(view: &DeviceLoginView, remaining: Option<u64>) -> De
}
}
/// 倒计时那一行的文案（`mm:ss` + i18n；过期/不知道有效期的两种情况都在这里收口）。
///
/// `mm:ss` 而不是 `900s`：人读的是分秒；数字与冒号在两种语言里同形，只有 `left`/`剩` 走 catalog。
fn countdown_text(remaining: Option<u64>, expired: bool, catalog: Catalog) -> String {
if expired {
return catalog.text(Key::AccountDeviceExpired).to_string();
}
remaining.map_or_else(String::new, |secs| {
let clock = format!("{:02}:{:02}", secs / 60, secs % 60);
catalog.render(Key::AccountDeviceCountdown, &[("time", &clock)])
})
}
/// 第三方轨状态 → 面板态（顺带取出「校验通过的服务器名」）。
pub(super) fn authlib_panel(view: &AuthlibLoginView) -> (AuthlibPanel, String) {
match view.phase {
crates/app-iced/src/pages/account/tests.rs
+8 -5
View File
@@ -33,7 +33,7 @@ fn account(name: &str, kind: AccountKind, active: bool) -> AccountView {
}
}
fn build(state: &AppState, form: &Form) -> Page {
pub(super) fn build(state: &AppState, form: &Form) -> Page {
// 断言口径是英文界面（app 钉死 `Lang::En`）：英文目录下「视图里有中文」=「后端原文上屏了」。
// 宽度取验收窗口 1180（r2 起 `Page` 记中栏可用宽）。
Page::build(state, form, &mut Cache::default(), Lang::En, 1180.0)
@@ -212,12 +212,15 @@ fn the_device_code_panel_shows_a_countdown_and_expires() {
match &page.device {
DevicePanel::Code {
code,
remaining,
countdown,
expired,
..
} => {
assert_eq!(code, "ABCD-EFGH");
assert_eq!(*remaining, Some(900));
assert!(
countdown.contains("15:00"),
"倒计时要画成 mm:ss：{countdown}"
);
assert!(!expired);
}
other => panic!("等待态应该是设备码面板，实际 {other:?}"),
@@ -232,10 +235,10 @@ fn the_device_code_panel_shows_a_countdown_and_expires() {
let page = build(&state, &Form::new());
match &page.device {
DevicePanel::Code {
remaining, expired, ..
countdown, expired, ..
} => {
assert_eq!(*remaining, Some(0));
assert!(*expired, "过期必须被标出来（面板要画「已过期，重试」）");
assert!(!countdown.is_empty(), "过期也要有一句人话，不是空行");
}
other => panic!("过期态仍是设备码面板，实际 {other:?}"),
}
crates/app-iced/src/pages/account/tests_msa.rs
+126
View File
@@ -0,0 +1,126 @@
//! M178 的登录回退判据（从 `tests.rs` 拆出来守 400 行硬线）。
//!
//! 这两条钉的是**页面这一半**：浏览器登录没走成、已回退设备码时，用户看到的是
//! i18n 那句「为什么 + 怎么修」，而不是 AAD 的原始报文。core 那一半（真的回退、不白开监听口）
//! 在 `crates/core/tests/auth/microsoft_msalogin.rs`。
use unlucky_i18n::Lang;
use unlucky_presenter::dto::{
AppEvent, BrowserLoginNote, CoreEvent, DeviceLoginView, LoginFailure,
};
use unlucky_presenter::state::AppState;
use super::avatar::Cache;
use super::login::browser_note_text;
use super::model::{DevicePanel, Form, Page};
use super::tests::build;
use super::tests_text::{has_cjk, on_screen};
/// 中文界面的同一页（`build` 钉死英文，这里要中文那一套）。
fn build_zh(state: &AppState, form: &Form) -> Page {
Page::build(state, form, &mut Cache::default(), Lang::ZhCn, 1180.0)
}
/// **M178 守卫（页面这一半）**：浏览器登录没走成、已回退设备码时，页面上要有一句**可读的**
/// 中文/英文说明（含「怎么修」），且**不是** AAD 的原始报文。
///
/// 抓得住：`browser_note` 在 `device_panel` 里被丢掉（面板就只剩用户码，用户不知道为什么
/// 变成了设备码）、或有人把 presenter 的原始诊断串（`invalid_request ...`）画上屏。
/// 抓不住：这句提示在 1180 宽下会不会换行难看（那靠出图给 tower 看）。
#[test]
fn a_browser_fallback_shows_a_readable_note_not_the_raw_aad_error() {
let mut state = AppState::new();
state.apply(AppEvent::Core(CoreEvent::DeviceLoginChanged(
DeviceLoginView {
message: "invalid_request: The provided value for the input parameter 'redirect_uri' \
is not valid. The expected value is a URI which matches a redirect URI registered for this client \
application."
.to_string(),
..DeviceLoginView::waiting("ABCD-EFGH", "https://www.microsoft.com/link", 900, "")
}
.with_browser_note(BrowserLoginNote::RedirectNotRegistered),
)));
let page = build(&state, &Form::new());
// 1. 面板态带着说明码（不是只剩一个用户码）
match &page.device {
DevicePanel::Code { note, code, .. } => {
assert_eq!(*note, Some(BrowserLoginNote::RedirectNotRegistered));
assert_eq!(code, "ABCD-EFGH");
}
other => panic!("回退后仍是设备码面板，实际 {other:?}"),
}
// 2. 英文界面上画出来的那一段：是 i18n 文案、含可照抄的修法，且没有 AAD 原始报文/中文
let text = on_screen(&page);
assert!(!has_cjk(&text), "英文界面不许出现中文：{text}");
assert!(
text.contains("http://localhost/auth"),
"提示里要给出可照抄的重定向 URI：{text}"
);
assert!(
text.to_lowercase().contains("redirect uri"),
"提示里要点名「重定向 URI」这一项：{text}"
);
assert!(
!text.contains("invalid_request"),
"原始报文不许上屏：{text}"
);
assert!(!text.contains("AADSTS"), "原始报文不许上屏：{text}");
assert!(!text.contains("is not valid"), "原始报文不许上屏：{text}");
// 3. 中文界面同样走一遍（复审 r1 P2-4）：文案来自**视图自己的出口**
// `login::browser_note_text`，中文要有、可照抄的修法要有、AAD 原始码不许有。
let zh = build_zh(&state, &Form::new());
let zh_text = on_screen(&zh);
assert!(has_cjk(&zh_text), "中文界面要真有中文：{zh_text}");
let note_text = browser_note_text(
BrowserLoginNote::RedirectNotRegistered,
Lang::ZhCn.catalog(),
);
assert!(
note_text.contains("http://localhost/auth"),
"中文文案也要给出可照抄的重定向 URI：{note_text}"
);
assert!(note_text.contains("重定向 URI"), "{note_text}");
assert!(note_text.contains("设备码"), "{note_text}");
for forbidden in ["invalid_request", "AADSTS", "is not valid", "{"] {
assert!(
!zh_text.contains(forbidden),
"中文界面混进了原始报文：{zh_text}"
);
assert!(
!note_text.contains(forbidden),
"词条混进了原始报文：{note_text}"
);
}
// 视图那一行的来源就是这一条文案：取样函数与视图共用同一个出口（不是测试另写映射）。
assert_eq!(
browser_note_text(BrowserLoginNote::PreflightUnavailable, Lang::En.catalog()),
"Could not confirm that browser sign-in is usable, so it switched to a device code."
);
}
/// 回退之后设备码又失败：失败面板上**两者都要在**（失败原因 + 为什么没走浏览器）。
#[test]
fn a_failed_device_login_keeps_the_fallback_note() {
let mut state = AppState::new();
state.apply(AppEvent::Core(CoreEvent::DeviceLoginChanged(
DeviceLoginView::failed_as(
LoginFailure::Unreachable,
"连不上 login.microsoftonline.com",
)
.with_browser_note(BrowserLoginNote::PreflightUnavailable),
)));
let page = build(&state, &Form::new());
match &page.device {
DevicePanel::Failed { failure, note } => {
assert_eq!(*failure, LoginFailure::Unreachable);
assert_eq!(*note, Some(BrowserLoginNote::PreflightUnavailable));
}
other => panic!("应是失败面板，实际 {other:?}"),
}
let text = on_screen(&page);
assert!(!has_cjk(&text), "{text}");
assert!(text.contains("unreachable"), "失败码要画出来：{text}");
}
crates/app-iced/src/pages/account/tests_text.rs
+20 -10
View File
@@ -16,7 +16,7 @@
use unlucky_i18n::{Key, Lang};
use unlucky_presenter::dto::AccountNoticeCode;
use super::login::{failure_body_key, failure_title_key};
use super::login::{browser_note_text, failure_body_key, failure_title_key};
use super::model::{AuthlibPanel, DevicePanel, Hint, Page};
/// 页面**会画什么**：模型里的数据 + 视图层对码的 i18n 查表结果。
@@ -60,23 +60,33 @@ pub(super) fn on_screen(page: &Page) -> String {
DevicePanel::Code {
code,
link,
remaining,
expired,
countdown,
note,
..
} => {
out.push_str(code);
out.push_str(link);
if *expired {
out.push_str(catalog.text(Key::AccountDeviceExpired));
} else if let Some(secs) = remaining {
let clock = format!("{:02}:{:02}", secs / 60, secs % 60);
out.push_str(&catalog.render(Key::AccountDeviceCountdown, &[("time", &clock)]));
// 倒计时文案由模型拼好（M178：owned 文字路径画不出中文）。
out.push_str(countdown);
// M178：回退说明走**视图自己的**文案出口（`login::browser_note_text`），
// 不是测试另写一份映射——否则视图哪天不画这一行，取样仍会绿。
if let Some(note) = note {
out.push_str(browser_note_text(*note, catalog));
}
}
DevicePanel::Browser { link, .. } => out.push_str(link),
DevicePanel::Failed { failure } => {
DevicePanel::Browser {
link, countdown, ..
} => {
out.push_str(link);
out.push_str(countdown);
}
DevicePanel::Failed { failure, note } => {
out.push_str(catalog.text(failure_title_key(*failure)));
out.push_str(catalog.text(failure_body_key(*failure)));
out.push_str(&catalog.render(Key::AccountFailureCode, &[("code", failure.code())]));
if let Some(note) = note {
out.push_str(browser_note_text(*note, catalog));
}
}
DevicePanel::Succeeded { name } => {
out.push_str(&catalog.render(Key::AccountLoginSucceeded, &[("name", name)]));
crates/app-iced/src/pages/appearance/background.rs
+78 -13
View File
@@ -26,6 +26,8 @@
//! 为什么向底色退而不是「叠黑」：浅色主题下叠黑会把亮图压成暗块，深色正文反而更读不清
//! （偏离登记在 [`super`] 的偏离表 #7）。
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use unlucky_presenter::prefs::BgFill;
/// 暗化上限（core 的 `BG_DIM_MAX` = 0.95，经 `unlucky_presenter::prefs` 重导出；这里只给 f32 形态）。
@@ -63,7 +65,7 @@ pub const TILE_SCALE_STEP: f32 = 1.15;
/// 会退化成「留缝」，正是 r1 的 P2-1。真实图片不会走到这个上限。
pub const MAX_TILE_SCALE: f32 = 1024.0;
/// 解码失败的原因（人话在 [`LoadError::describe`]）。
/// 解码失败的原因（人话在 [`LoadError::note`]）。
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum LoadError {
/// 读文件失败：不存在 / 没权限 / 被占用。
@@ -79,17 +81,76 @@ pub enum LoadError {
},
}
impl LoadError {
/// 可读诊断（设置页提示行与日志共用同一句）。
/// 一条**可翻译**诊断：`key` + 已经格式化好的参数（模板里只有 `{name}`，见 [`Key`]）。
///
/// 为什么不是 `String`：文案表在金表里（M180 `I18NAPPEAR`），本模块只给「哪条 key + 哪些值」。
/// 数字在这一层就格式化好（`{:.2}` / `{:?}` 这些格式说明词表不支持）。
///
/// 为什么 `types` 是 `String` 而不是 `&'static str`：`Io(reason)` / `Undecodable(reason)` 的原因来自
/// 磁盘与解码库（运行时字符串），只能持有。
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Note {
key: Key,
args: Vec<(&'static str, String)>,
}
impl Note {
/// 组装一条（参数名必须与译文里的 `{name}` 逐字相同）。
fn new(key: Key, args: Vec<(&'static str, String)>) -> Self {
Self { key, args }
}
/// 这条诊断是哪条文案。
#[must_use]
pub fn describe(&self) -> String {
pub fn key(&self) -> Key {
self.key
}
/// 参数（名 → 已成形的值）。
#[must_use]
pub fn args(&self) -> Vec<(&str, &str)> {
self.args
.iter()
.map(|(name, value)| (*name, value.as_str()))
.collect()
}
/// 按语言取整句（`{name}` 全替换；缺参时占位符原样留着，见 [`unlucky_i18n::catalog::Catalog::render`]）。
#[must_use]
pub fn render(&self, lang: Lang) -> String {
lang.catalog().render(self.key, &self.args())
}
/// 英文基线里有没有这个子串。
///
/// 给**跨 mission 的既有断言**用（`app/tests/appearance.rs` 查「诊断里有没有说出原因」），
/// 那条断言不在本 mission 的 scope 里、不能改成按 key 断言。UI 一律走 [`Self::render`]。
#[must_use]
pub fn contains(&self, needle: &str) -> bool {
self.render(Lang::En).contains(needle)
}
}
impl LoadError {
/// 可翻译诊断（设置页提示行与日志共用同一条 key）。
#[must_use]
pub fn note(&self) -> Note {
match self {
Self::Io(reason) => format!("Background image could not be read: {reason}"),
Self::Undecodable(reason) => format!(
"Background image could not be decoded ({reason}; this build decodes PNG, JPEG and BMP)"
Self::Io(reason) => Note::new(
Key::SettingsAppearanceBgReadFailed,
vec![("reason", reason.clone())],
),
Self::TooLarge { width, height } => format!(
"Background image is too large to decode: {width}×{height} (limit {MAX_SOURCE_EDGE} px per edge)"
Self::Undecodable(reason) => Note::new(
Key::SettingsAppearanceBgDecodeFailed,
vec![("reason", reason.clone())],
),
Self::TooLarge { width, height } => Note::new(
Key::SettingsAppearanceBgTooLarge,
vec![
("width", width.to_string()),
("height", height.to_string()),
("limit", MAX_SOURCE_EDGE.to_string()),
],
),
}
}
@@ -193,7 +254,7 @@ fn header_size(bytes: &[u8]) -> Result<(u32, u32), LoadError> {
/// 判据只看图片本身（短边 < [`SMALL_TILE_EDGE`]）——视口尺寸在渲染层才知道，而这里要的是
/// 「这张图小到要放大」这个与视口无关的事实。`scale` 条数上限由 [`tiles`] 保证覆盖 ≥ 视口。
#[must_use]
pub fn small_tile_note(image: &Image, fill: BgFill) -> Option<String> {
pub fn small_tile_note(image: &Image, fill: BgFill) -> Option<Note> {
if !matches!(fill, BgFill::Tile) {
return None;
}
@@ -201,9 +262,13 @@ pub fn small_tile_note(image: &Image, fill: BgFill) -> Option<String> {
if width.min(height) >= SMALL_TILE_EDGE {
return None;
}
Some(format!(
"Small image ({}×{}): tiles are scaled up so the window stays covered (max {MAX_TILES} tiles, no gaps).",
image.source.0, image.source.1
Some(Note::new(
Key::SettingsAppearanceBgSmallTile,
vec![
("width", image.source.0.to_string()),
("height", image.source.1.to_string()),
("max", MAX_TILES.to_string()),
],
))
}
crates/app-iced/src/pages/appearance/background/tests.rs
+44 -9
View File
@@ -4,6 +4,8 @@
use super::{dim_alpha, load, small_tile_note, tiles, LoadError, BG_DIM_MAX, MAX_TILES};
use std::path::{Path, PathBuf};
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use unlucky_presenter::prefs::BgFill;
fn temp_file(label: &str, name: &str) -> PathBuf {
@@ -66,19 +68,28 @@ fn a_real_jpeg_decodes_too() {
#[test]
fn a_missing_or_broken_file_reports_a_readable_reason() {
// 抓得住：①路径不存在 → Io；②文件存在但不是图片 → Undecodable；③空路径 → Io。
// 都必须是 Err（不许静默回默认色），且 describe() 是人话。
// 都必须是 Err（不许静默回默认色），且 note() 给出**哪条 key + 哪些参数**（句子在词表里）。
// 抓不住：webp/tiff 这类没开编码器的格式具体报什么字符串（只钉分类，不钉解码库原文）。
let missing = temp_file("missing", "bg.png");
let error = load(missing.to_str().unwrap()).expect_err("不存在的路径必须报错");
assert!(matches!(error, LoadError::Io(_)), "实际 {error:?}");
assert!(error
.describe()
.starts_with("Background image could not be read"));
let note = error.note();
assert_eq!(note.key(), Key::SettingsAppearanceBgReadFailed);
assert!(
note.contains("could not be read"),
"英文基线要说出「读不出来」：{}",
note.render(Lang::En)
);
let broken = temp_file("broken", "bg.png");
std::fs::write(&broken, b"this is not an image").expect("写坏文件");
let error = load(broken.to_str().unwrap()).expect_err("非图片必须报错");
assert!(matches!(error, LoadError::Undecodable(_)), "实际 {error:?}");
assert_eq!(
error.note().key(),
Key::SettingsAppearanceBgDecodeFailed,
"解不开与读不出来必须是两条 key（措辞与修法都不同）"
);
cleanup(&broken);
let empty = load(" ").expect_err("空路径必须报错");
@@ -168,10 +179,21 @@ fn an_over_sized_image_reports_too_large_instead_of_trying_to_decode() {
),
"实际 {error:?}"
);
let note = error.note();
assert_eq!(note.key(), Key::SettingsAppearanceBgTooLarge);
assert!(
error.describe().contains("too large"),
"提示要人话：{}",
error.describe()
note.contains("too large"),
"英文基线要说出「太大」：{}",
note.render(Lang::En)
);
let args = note.args();
assert!(
args.contains(&("width", "9000")) && args.contains(&("height", "4")),
"宽高要作为参数传进去（不是写进译文）：{args:?}"
);
assert!(
args.contains(&("limit", "8192")),
"上限走占位符而不是写进译文：{args:?}"
);
// 上限不许再放宽（r1 的 16384 等于允许 1 GB 的中间缓冲）：常量级约束放在测试里钉。
const _: () = assert!(super::MAX_SOURCE_EDGE <= 8_192);
@@ -187,8 +209,21 @@ fn an_over_sized_image_reports_too_large_instead_of_trying_to_decode() {
fn small_images_get_a_tile_diagnostic_instead_of_silently_degrading() {
let small = super::Image::from_rgba((32, 32), 4, 4, vec![0; 64]);
let note = small_tile_note(&small, BgFill::Tile).expect("小图 tile 必须有提示");
assert!(note.contains("32×32"), "{note}");
assert!(note.contains("scaled up"), "{note}");
assert_eq!(note.key(), Key::SettingsAppearanceBgSmallTile);
let args = note.args();
assert!(
args.contains(&("width", "32")) && args.contains(&("height", "32")),
"尺寸作为参数：{args:?}"
);
assert!(
args.contains(&("max", "64")),
"块数上限走占位符（`MAX_TILES` 改了不该动译文）：{args:?}"
);
assert!(
note.render(Lang::En).contains("scaled up"),
"英文基线要说出「会被放大」：{}",
note.render(Lang::En)
);
// 非 tile 档不提示（cover/contain 会等比铺满，不存在「小图被放大铺」这件事）。
assert!(small_tile_note(&small, BgFill::Cover).is_none());
crates/app-iced/src/pages/appearance/mod.rs
+6 -55
View File
@@ -20,7 +20,7 @@
//! | [`background`] | 背景图解码（png/jpeg/bmp）、平铺网格、暗化系数、可读诊断 | 读盘一次（`load`） |
//! | `palette` | D38 三级优先序的调用侧 + 提示文案 | 无（像素由 `background` 给） |
//! | `state` | 运行期状态：把上面三件的输入输出连起来 | 只在 `refresh_background` |
//! | `section` | 设置页「外观」分组（真控件） | 无 |
//! | `section/` | 设置页「外观」分组（真控件）：壳 + 五段控件，M179 从单文件拆开 | 无 |
//! | `picture` | 背景层 Element：真图直出（Cover/Contain/Tile）+ 暗化叠层 | 无 |
//!
//! ## 偏离登记（D30 要求逐条写清）
@@ -65,10 +65,14 @@ pub mod background;
mod palette;
mod picture;
#[cfg(test)]
pub(crate) mod probe;
mod section;
mod state;
#[cfg(test)]
mod tests;
/// 状态提示的 **tonal notice**（`section.rs` 的 400 行硬顶把它放在模块根）。
/// 状态提示的 **tonal notice**（行数硬顶把 `section/` 撑开之后它仍放在模块根）。
///
/// `SurfaceContainerHighest` 底 + `ShapeScale::Small` 圆角 + 两侧 `X2` 内边距，文字 `OnSurfaceVariant`。
/// 用它而不是「换色的正文」：容器才是 M3 表达「当前状态」的形态，也和说明段在**形态**上分开
@@ -164,56 +168,3 @@ impl Change {
})
}
}
#[cfg(test)]
mod tests {
use super::{Change, APPEARANCE_GROUP};
use unlucky_presenter::prefs::{keys, BgFill, PaletteSource};
/// 抓得住：每条改动都点名到自己那个 schema 键（写错键 = 静默写到别的配置项上）。
/// 抓不住：这些键是否真的在 core 的 schema 白名单里（那由 presenter/core 的测试守）。
#[test]
fn every_change_names_its_own_schema_key() {
assert_eq!(APPEARANCE_GROUP, 1, "左列第 1 项是 Appearance");
let cases = [
(Change::WindowOpacity(0.8), keys::WINDOW_OPACITY),
(Change::PanelAlpha(0.6), keys::PANEL_ALPHA),
(Change::BgEnabled(true), keys::BG_IMAGE_ENABLED),
(Change::BgImage("D:/x.png".to_owned()), keys::BG_IMAGE),
(Change::BgFill(BgFill::Tile), keys::BG_FILL),
(Change::BgDim(0.5), keys::BG_DIM),
(
Change::PaletteSource(PaletteSource::Wallpaper),
keys::PALETTE_SOURCE,
),
(
Change::Corner(unlucky_presenter::prefs::WindowCorner::Square),
keys::WINDOW_CORNER,
),
];
for (change, key) in cases {
assert_eq!(change.key(), Some(key), "{change:?}");
assert!(change.value().is_some());
}
assert_eq!(Change::SelectGroup(2).key(), None, "切分组不落盘");
assert_eq!(Change::SelectGroup(2).value(), None);
}
/// 抓得住：落盘字符串必须是 schema 认识的词表（枚举档写错就整条配置读回默认值）。
/// 抓不住：数值是否在范围内（钳位在 core 侧，越界写入会被 schema 拒绝）。
#[test]
fn persisted_values_use_the_schema_vocabulary() {
assert_eq!(
Change::BgFill(BgFill::Contain).value().as_deref(),
Some("contain")
);
assert_eq!(
Change::PaletteSource(PaletteSource::BackgroundImage)
.value()
.as_deref(),
Some("background-image")
);
assert_eq!(Change::BgEnabled(false).value().as_deref(), Some("false"));
assert_eq!(Change::WindowOpacity(0.8).value().as_deref(), Some("0.8"));
}
}
crates/app-iced/src/pages/appearance/palette.rs
+83 -32
View File
@@ -9,7 +9,8 @@
//!
//! 1. 把「没设」与「设了但坏了」**分开传**（[`Source::Absent`] vs [`Source::Undecodable`]）——
//! 混成一个 `None` 会让设置页说错话（「没设背景图」 vs 「你那张图读不出来」）；
//! 2. 把 `Provenance::hint_key()` 翻成一句可读提示（键 → 文案是 UI 层的活，i18n 之后再统一）。
//! 2. 把 `Provenance::hint_key()` 翻成一条词表 key（M180：句子在 `catalog/settings/appearance.rs`，
//! 这里只给 key——中文界面下这句提示也是中文）。
//!
//! ## 为什么不在这里做对比度
//!
@@ -19,6 +20,7 @@
use unlucky_design::color::{Scheme, SchemeFlavor};
use unlucky_design::palette::{resolve_source, ImageInput, Level, Provenance};
use unlucky_i18n::catalog::Key;
use unlucky_presenter::prefs::PaletteSource;
use super::background::Image;
@@ -62,9 +64,9 @@ impl Resolved {
self.provenance.level
}
/// 可读提示（`None` = 一级成功、没什么可解释的）。
/// 提示 key（`None` = 一级成功、没什么可解释的）。
#[must_use]
pub fn note(&self) -> Option<&'static str> {
pub fn note(&self) -> Option<Key> {
note(&self.provenance)
}
}
@@ -97,47 +99,55 @@ pub fn resolve(
Resolved { scheme, provenance }
}
/// `Provenance::hint_key()` → 一句可读提示（英文基线；i18n mission 之后走词表）。
/// `Provenance::hint_key()` → 一条词表 key（M180：句子在 `catalog/settings/appearance.rs`）。
///
/// 键的完整表在 `unlucky_design::palette::resolve::Provenance::hint_key` 的文档里；
/// 这里只翻「本 mission 真会产生的那几个」，未识别键返回 `None` 而不是编一句话。
#[must_use]
pub fn note(provenance: &Provenance) -> Option<&'static str> {
pub fn note(provenance: &Provenance) -> Option<Key> {
Some(match provenance.hint_key()? {
"palette.hint.background.undecodable" => {
"Background image could not be read; colours fall back."
}
"palette.hint.background.too-small" => {
"Background image is too small to sample; colours fall back."
}
"palette.hint.background.bad-dimensions" => {
"Background image data looks inconsistent; colours fall back."
}
"palette.hint.background.undecodable" => Key::SettingsAppearancePaletteBgUndecodable,
"palette.hint.background.too-small" => Key::SettingsAppearancePaletteBgTooSmall,
"palette.hint.background.bad-dimensions" => Key::SettingsAppearancePaletteBgBadDimensions,
"palette.hint.background.no-opaque-pixels" => {
"Background image is almost fully transparent; colours fall back."
Key::SettingsAppearancePaletteBgNoOpaquePixels
}
"palette.hint.background.low-chroma" => {
"Background image is too monochrome to tint from; colours fall back."
"palette.hint.background.low-chroma" => Key::SettingsAppearancePaletteBgLowChroma,
"palette.hint.background.contrast" => Key::SettingsAppearancePaletteBgContrast,
"palette.hint.wallpaper.undecodable" => Key::SettingsAppearancePaletteWallpaperUndecodable,
"palette.hint.wallpaper.low-chroma" => Key::SettingsAppearancePaletteWallpaperLowChroma,
"palette.hint.wallpaper.too-small" => Key::SettingsAppearancePaletteWallpaperTooSmall,
"palette.hint.wallpaper.bad-dimensions" => {
Key::SettingsAppearancePaletteWallpaperBadDimensions
}
"palette.hint.background.contrast" => {
"Background image colours would be unreadable; colours fall back."
}
"palette.hint.wallpaper.undecodable" => "Desktop wallpaper could not be read.",
"palette.hint.wallpaper.low-chroma" => "Desktop wallpaper is too monochrome to tint from.",
"palette.hint.wallpaper.too-small" => "Desktop wallpaper is too small to sample.",
"palette.hint.wallpaper.bad-dimensions" => "Desktop wallpaper data looks inconsistent.",
"palette.hint.wallpaper.no-opaque-pixels" => {
"Desktop wallpaper is almost fully transparent."
Key::SettingsAppearancePaletteWallpaperNoOpaquePixels
}
"palette.hint.wallpaper.contrast" => {
"Desktop wallpaper colours would be unreadable; colours fall back."
}
"palette.hint.preset.contrast" => "The built-in card needed a small contrast correction.",
"palette.hint.adjusted" => "A few colours were nudged for readability.",
"palette.hint.wallpaper.contrast" => Key::SettingsAppearancePaletteWallpaperContrast,
"palette.hint.preset.contrast" => Key::SettingsAppearancePalettePresetContrast,
"palette.hint.adjusted" => Key::SettingsAppearancePaletteAdjusted,
_ => return None,
})
}
/// 生效层级**码值** → 已有的那三条档位 key（M180 复审 P2-2：中文界面里不许留机器码）。
///
/// 码值的全部来源只有两处，取值集合相同：`Level::code()`（`background-image` / `wallpaper` /
/// `preset`）与 `PaletteSource::as_str()`（同三个词）。所以三条 key 就够，**不新增平行词表**——
/// 卡片底部「配色来源」用它们表示**用户选的**档，这一行用它们表示**回落之后真正生效**的档。
///
/// 未识别的码值落到 `background-image` 那条（宁可显示一个偏保守的档名，也不许把机器码漏进
/// 中文界面——这条兜底本身由 `tests` 里的 `every_level_code_maps_to_its_own_sentence` 钉住）。
/// `state.rs` 已贴 400 行线，所以这个映射住在本文件。
#[must_use]
pub fn level_key(code: &str) -> Key {
match code {
"preset" => Key::SettingsAppearancePalettePreset,
"wallpaper" => Key::SettingsAppearancePaletteWallpaper,
_ => Key::SettingsAppearancePaletteBackground,
}
}
#[cfg(test)]
mod tests {
use super::{note, resolve, Source};
@@ -145,6 +155,7 @@ mod tests {
use unlucky_design::color::SchemeFlavor;
use unlucky_design::palette::wcag::check;
use unlucky_design::palette::{Level, Outcome, Skip};
use unlucky_i18n::catalog::Key;
use unlucky_presenter::prefs::PaletteSource;
/// 高彩度的图（纯红）：取色一定成功。
@@ -193,7 +204,7 @@ mod tests {
assert!(resolved.provenance.did_fall_back());
assert_eq!(
resolved.note(),
Some("Background image could not be read; colours fall back.")
Some(Key::SettingsAppearancePaletteBgUndecodable)
);
assert!(check(&resolved.scheme).is_clean());
}
@@ -215,7 +226,11 @@ mod tests {
}
other => panic!("灰图必须被判不合格，实际 {other:?}"),
}
assert!(resolved.note().unwrap().contains("monochrome"));
assert_eq!(
resolved.note(),
Some(Key::SettingsAppearancePaletteBgLowChroma),
"灰图的回落原因要指名「彩度不足」"
);
}
#[test]
@@ -276,4 +291,40 @@ mod tests {
None
);
}
/// **M180 复审 P2-2 的守门**：生效层级的**每一个码值**都必须映射到它自己那条中文句子。
///
/// 抓得住：① 三个码值被映射到同一条 key（界面上分不出到底生效的是哪一级）；
/// ② 某条映射被删掉 / 写错（`preset` 落到 background 那条 ⇒ 中文界面说「取自背景图」）；
/// ③ 有人再加一级却忘了扩映射。
/// 抓不住：译文本身的措辞（那是 `catalog/settings/appearance.rs` 的译文守卫的事）。
///
/// 变异证明：把 `"preset"` 那行删掉（落进兜底）⇒ 本条红，且 `assert_ne!` 直接点名码值。
///
/// 为什么这条必须有：`the_appearance_card_speaks_chinese` 断的是**整句**非 ASCII，
/// 而「配色：preset」里有汉字 ⇒ 整句非 ASCII ⇒ 那个守卫放过它。这个口子只能在这里堵。
#[test]
fn every_level_code_maps_to_its_own_sentence() {
use super::level_key;
let codes = ["background-image", "wallpaper", "preset"];
let keys: Vec<Key> = codes.iter().copied().map(level_key).collect();
assert_eq!(
keys,
vec![
Key::SettingsAppearancePaletteBackground,
Key::SettingsAppearancePaletteWallpaper,
Key::SettingsAppearancePalettePreset,
],
"码值与档位 key 必须一一对应"
);
// 三条中文句子互不相同（否则「映射对了」但界面上仍分不出层级）。
let zh = unlucky_i18n::Lang::ZhCn.catalog();
let mut texts: Vec<&str> = keys.iter().map(|key| zh.text(*key)).collect();
let total = texts.len();
texts.sort_unstable();
texts.dedup();
assert_eq!(texts.len(), total, "三条档位译文有重复：{texts:?}");
}
}
crates/app-iced/src/pages/appearance/probe.rs
+68
View File
@@ -0,0 +1,68 @@
//! **测试专用**：记录「画一帧时从词表取出的每一条译文」。
//!
//! ## 为什么需要这一层
//!
//! 判据是「中文界面下外观分组渲染出来的字里必须含汉字」，但 iced 0.14 **没有**可以遍历控件树的
//! 公开接口：
//!
//! - `Element::as_widget()` 拿到的是 `&dyn Widget`，而 `Widget::children()` 返回的是**状态** `Tree`
//! （不是子控件），没有 `as_any` 之类的向下转型口；
//! - 想走 `Widget::operate` 得自己造 `Tree` + 跑布局 + 传 `Renderer`，而单测里**没有渲染器**
//! （`pages/download/tests/options_screen.rs` 记的正是这条边界）。
//!
//! 所以取证点退到「字进树之前」那一层：`section::t` / `section::tr` 是本分组**唯一**两个取词口，
//! 它们把每条译文顺手记一份（M180 起分成两份：`t()` 的 `&'static str` 与 `tr()` 替换完占位符的
//! 整句），测试再断言这批字里有没有汉字。这不是「看源码字符串」那种假守卫——它要求真的把
//! [`crate::pages::appearance::section`] 跑一遍（并且走 `settings::view` 的语言分发），只是不画像素。
//!
//! ## 为什么是 thread-local
//!
//! `cargo test` 默认多线程跑，每个测试一个线程；thread-local 让并发测试的取证互不串台，
//! 也不需要加锁或串行化。
//!
//! 整个模块只在 `#[cfg(test)]` 下编译，产品路径零代价。
use std::cell::RefCell;
use unlucky_i18n::catalog::Key;
// 自上次 `take` 以来记录下的 `(key, 译文)`，顺序 = 取词顺序（`t()` 取的 `&'static str`）。
thread_local! {
// clippy 1.99.1（= 本仓 CI 的 stable）对这条 lint **误报**：初始化器已经写成 `const { … }`
// 它还是报「can be made const」。最小复现（clippy-driver 原地可验，无本仓任何符号）：
// `thread_local!{ static X: RefCell<Vec<u32>> = const { RefCell::new(Vec::new()) }; }`
// —— 同一个文件加不加 `const` 报同一句。等 clippy 修掉这条误报即可删掉本行 allow。
#[allow(clippy::missing_const_for_thread_local)]
static TEXTS: RefCell<Vec<(Key, &'static str)>> = const { RefCell::new(Vec::new()) };
}
// 自上次 `take_rendered` 以来记录下的 `(key, 整句)`：`tr()` 那条带占位符的路径（M180 加）。
//
// 为什么单独一份而不是把上面那份改成 `String`：M179 的守卫
// （`pages/settings/tests/appearance_section.rs::the_appearance_group_speaks_chinese_when_the_interface_does`）
// 断言的是 `&'static str`，那个文件不在 M180 的 scope 里、不能跟着改签名。两份记录各自的
// `take*` 也各自清空，互不干扰。
thread_local! {
#[allow(clippy::missing_const_for_thread_local)]
static RENDERED: RefCell<Vec<(Key, String)>> = const { RefCell::new(Vec::new()) };
}
/// 记一条（由 [`super::section::t`] 调用；不对外）。
pub(crate) fn record(key: Key, text: &'static str) {
TEXTS.with(|texts| texts.borrow_mut().push((key, text)));
}
/// 记一条**替换完占位符**的整句（由 [`super::section::tr`] 调用；不对外）。
pub(crate) fn record_rendered(key: Key, text: String) {
RENDERED.with(|texts| texts.borrow_mut().push((key, text)));
}
/// 取走并清空本线程记录下的取词（测试用）。
pub(crate) fn take() -> Vec<(Key, &'static str)> {
TEXTS.with(|texts| std::mem::take(&mut *texts.borrow_mut()))
}
/// 取走并清空本线程记录下的整句（测试用）。
pub(crate) fn take_rendered() -> Vec<(Key, String)> {
RENDERED.with(|texts| std::mem::take(&mut *texts.borrow_mut()))
}
crates/app-iced/src/pages/appearance/section.rs
-395
View File
@@ -1,395 +0,0 @@
//! 设置页「外观」分组（**真控件**）+ 背景层 Element + 面板层配色。
//!
//! ## 控件与键的对应
//!
//! | 控件 | 键 | 改动消息 |
//! |---|---|---|
//! | 整窗透明度滑块（下限 0.08） | `appearance.window_opacity` | [`Change::WindowOpacity`] |
//! | 窗口圆角（跟随系统 / 直角，M116） | `appearance.window_corner` | [`Change::Corner`] |
//! | 面板透明度滑块（下限 0.4，CPU 档禁用） | `appearance.panel_alpha` | [`Change::PanelAlpha`] |
//! | 背景图开关 | `appearance.bg_image_enabled` | [`Change::BgEnabled`] |
//! | 背景图路径（文本框） | `appearance.bg_image` | [`Change::BgImage`] |
//! | 填充（封面 / 拉伸 / 平铺） | `appearance.bg_fill` | [`Change::BgFill`] |
//! | 暗化强度（0~0.95） | `appearance.bg_dim` | [`Change::BgDim`] |
//! | 配色来源（三档） | `appearance.palette_source` | [`Change::PaletteSource`] |
//!
//! 文案一律英文基线（i18n 是别的 mission；本文件不拼中文、不 import 尚不存在的 crate）。
//!
//! ## 为什么「值」与「生效值」分开显示
//!
//! CPU 档下面板 α 被强制 1.0（D36），而用户请求值可能是 0.5。滑块位置按**生效值**画、旁边写
//! 「requested 0.50 → forced 1.00」，这样「为什么拖了没反应」在界面上就有答案，而不是只躺在日志里。
use iced::widget::{button, column, container, row, space};
use iced::{
Alignment, Background, Border, Color, Element, Length, Padding, Shadow, Theme as IcedTheme,
};
use unlucky_design::color::Role;
use unlucky_design::component_map::Component;
use unlucky_design::elevation::MaterialLayer;
use unlucky_design::shape::ShapeScale;
use unlucky_design::spacing::Space;
use unlucky_design::typography::TypeRole;
use unlucky_i18n::catalog::Key;
use unlucky_presenter::prefs::{BgFill, PaletteSource, WindowCorner};
use crate::app::components::inputs::{slider, text_field, Field, Slider};
use crate::pages::{frame, Message};
use crate::theme::Ui;
use super::alpha::{
panel_alpha_from_fraction, panel_fraction, window_alpha_from_fraction, window_fraction,
WINDOW_ALPHA_FLOOR,
};
use super::background::{self, BG_DIM_MAX};
use super::state::State;
use super::Change;
/// 「外观」分组整块（一张卡）。
pub fn section<'a>(ui: &'a Ui, state: &'a State) -> Element<'a, Message> {
let mut rows = column![].spacing(ui.space(Space::X1)).width(Length::Fill);
// ① 整窗透明度
let window_percent = format!("{:.0}%", state.window_opacity * 100.0);
rows = rows.push(slider_row(
ui,
"Window transparency",
window_percent,
format!(
"Applies to the whole window. Floor {:.2}; 1.00 = fully opaque.",
WINDOW_ALPHA_FLOOR
),
state.window_opacity < 1.0,
slider(
Slider::new(ui, window_fraction(state.window_opacity)).on_change(|fraction| {
Message::Appearance(Change::WindowOpacity(window_alpha_from_fraction(fraction)))
}),
),
));
// ② 窗口圆角（M116）：只有两档 + 一句按平台说明；不做 8/12/16 档（系统不暴露半径）。
let corner = state.window_corner();
rows = rows.push(choice_row(
ui,
t(Key::SettingsAppearanceCorner),
vec![
choice(
ui,
t(Key::SettingsAppearanceCornerSystem),
corner == WindowCorner::System,
Change::Corner(WindowCorner::System),
),
choice(
ui,
t(Key::SettingsAppearanceCornerSquare),
corner == WindowCorner::Square,
Change::Corner(WindowCorner::Square),
),
],
));
// **tonal notice**（r5 视觉终稿）：M3 里表达「当前状态」的惯用形态是**容器**，不是改字色。
// 只在「跟随系统 + α<1」出现；与下面的说明段之间再留 `Space::X1`（列间距 X1 + 这里 X1 = X2）。
if corner == WindowCorner::System && state.window_opacity < 1.0 {
rows = rows.push(super::notice(ui, t(Key::SettingsAppearanceCornerSuspended)));
let gap: Element<'a, Message> = space::vertical().height(ui.space(Space::X1)).into();
rows = rows.push(gap);
}
let tone = ui.color(Role::OnSurfaceVariant);
rows = rows.push(note_line(ui, t(Key::SettingsAppearanceCornerHint), tone));
// ③ 面板透明度（CPU 档强制 1.0）
let forced = state.panel_is_forced();
let panel_percent = if forced {
format!("100% (forced from {:.2})", state.panel_alpha)
} else {
format!("{:.0}%", state.effective_panel_alpha() * 100.0)
};
let panel_hint = if forced {
"Software renderer: panels stay fully opaque (window transparency still works)."
} else {
"Only the panel/card layer. Floor 0.40; independent of window transparency."
};
let panel_control = if forced {
slider(Slider::new(ui, panel_fraction(1.0)))
} else {
slider(
Slider::new(ui, panel_fraction(state.panel_alpha)).on_change(|fraction| {
Message::Appearance(Change::PanelAlpha(panel_alpha_from_fraction(fraction)))
}),
)
};
rows = rows.push(slider_row(
ui,
"Panel transparency",
panel_percent,
panel_hint.to_owned(),
!forced,
panel_control,
));
// ④ 背景图开关
rows = rows.push(choice_row(
ui,
"Background image",
vec![
choice(ui, "Off", !state.bg_enabled, Change::BgEnabled(false)),
choice(ui, "On", state.bg_enabled, Change::BgEnabled(true)),
],
));
// ⑤ 路径（文本框：受控，输入即生效）
let path_field: Element<'a, Message> = text_field(
ui,
Field::new(&state.bg_path)
.label("Image path")
.placeholder("D:/Pictures/background.png"),
|value| Message::Appearance(Change::BgImage(value)),
);
rows = rows.push(
column![label(ui, "Image path"), path_field]
.spacing(ui.space(Space::X1))
.width(Length::Fill),
);
// ⑥ 诊断（读盘失败 / CPU 降级 / 配色回落）——**不许静默**，且必须在**首屏可见处**
// （复审 r1 P2-3：文案落在折叠线以下等于没提示）。位置就在背景图那两行的紧下方。
for note in state.diagnostics() {
rows = rows.push(note_line(ui, note, ui.color(Role::Error)));
}
if let Some(note) = state.backend_note() {
rows = rows.push(note_line(ui, note, ui.color(Role::OnSurfaceVariant)));
}
if let Some(note) = state
.image()
.and_then(|image| background::small_tile_note(image, state.bg_fill))
{
rows = rows.push(note_line(ui, &note, ui.color(Role::OnSurfaceVariant)));
}
if let Some(note) = state.palette_note() {
rows = rows.push(note_line(ui, note, ui.color(Role::OnSurfaceVariant)));
}
let resolved = format!("Colours: {}", state.palette_level());
rows = rows.push(note_line(ui, &resolved, ui.color(Role::OnSurfaceVariant)));
// ⑦ 填充
rows = rows.push(choice_row(
ui,
"Fill",
vec![
choice(
ui,
"Cover",
state.bg_fill == BgFill::Cover,
Change::BgFill(BgFill::Cover),
),
choice(
ui,
"Contain",
state.bg_fill == BgFill::Contain,
Change::BgFill(BgFill::Contain),
),
choice(
ui,
"Tile",
state.bg_fill == BgFill::Tile,
Change::BgFill(BgFill::Tile),
),
],
));
// ⑧ 暗化
rows = rows.push(slider_row(
ui,
"Dim",
format!("{:.0}%", state.bg_dim * 100.0),
format!(
"Blends the image toward the panel colour so text stays readable. Max {BG_DIM_MAX:.2}."
),
state.bg_dim > 0.0,
slider(
Slider::new(ui, state.bg_dim / BG_DIM_MAX)
.on_change(|fraction| Message::Appearance(Change::BgDim(fraction * BG_DIM_MAX))),
),
));
// ⑨ 配色来源
rows = rows.push(choice_row(
ui,
"Colour source",
vec![
choice(
ui,
"Background",
state.palette_source == PaletteSource::BackgroundImage,
Change::PaletteSource(PaletteSource::BackgroundImage),
),
choice(
ui,
"Wallpaper",
state.palette_source == PaletteSource::Wallpaper,
Change::PaletteSource(PaletteSource::Wallpaper),
),
choice(
ui,
"Preset",
state.palette_source == PaletteSource::Preset,
Change::PaletteSource(PaletteSource::Preset),
),
],
));
card(ui, rows)
}
/// 外观卡片：底色走 `ui.layer`（面板 α 的唯一来源），与其它页的卡片同源。
fn card<'a>(ui: &'a Ui, content: impl Into<Element<'a, Message>>) -> Element<'a, Message> {
let spec = Component::OutlinedCard.spec();
let background = ui.layer(MaterialLayer::Card);
container(content)
.width(Length::Fill)
.padding(ui.metrics().card_padding)
.style(move |_theme| container::Style {
background: Some(Background::Color(background)),
border: ui.outlined(spec.shape),
..container::Style::default()
})
.into()
}
// --------------------------------------------------------------- 行与控件
fn label<'a>(ui: &'a Ui, content: &'a str) -> Element<'a, Message> {
frame::text_role(
ui,
TypeRole::BodyMedium,
false,
content,
ui.color(Role::OnSurface),
)
}
/// 设置页文案的 i18n 取词口（M116 起新条目一律走词表，不再写字面量）。
///
/// 为什么是 [`Lang::En`]：本文件的既有文案是英文基线（i18n 接线是另一条 mission，
/// 见本文件头部「文案一律英文基线」）。走词表的意义是**新增条目已经有中英两套**，
/// 接线时只换这一行，不用回来重写控件。
fn t(key: Key) -> &'static str {
unlucky_i18n::Lang::En.catalog().text(key)
}
fn note_line<'a>(ui: &'a Ui, content: &str, color: Color) -> Element<'a, Message> {
// 诊断文案是**运行时拼出来的**（路径、错误原因），只能走 owned 版本。
frame::text_role_owned(ui, TypeRole::BodySmall, false, content.to_owned(), color)
}
/// 一行「标签 + 值 + 滑块 + 说明」。
fn slider_row<'a>(
ui: &'a Ui,
title: &'a str,
value: String,
hint: String,
enabled: bool,
control: Element<'a, Message>,
) -> Element<'a, Message> {
let value_color = if enabled {
ui.color(Role::OnSurface)
} else {
ui.color(Role::OnSurfaceVariant)
};
let head = row![
container(label(ui, title))
.width(Length::Fill)
.align_y(Alignment::Center),
frame::text_role_owned(ui, TypeRole::LabelLarge, true, value, value_color),
]
.width(Length::Fill)
.align_y(Alignment::Center);
column![
head,
control,
frame::text_role_owned(
ui,
TypeRole::BodySmall,
false,
hint,
ui.color(Role::OnSurfaceVariant),
),
]
.spacing(ui.space(Space::X1))
.width(Length::Fill)
.padding(Padding::from([ui.space(Space::X2), 0.0]))
.into()
}
/// 一行「标签 + 一排互斥按钮」。
fn choice_row<'a>(
ui: &'a Ui,
title: &'a str,
choices: Vec<Element<'a, Message>>,
) -> Element<'a, Message> {
row![
container(label(ui, title))
.width(Length::Fill)
.align_y(Alignment::Center),
row(choices)
.spacing(ui.space(Space::X1))
.align_y(Alignment::Center),
]
.width(Length::Fill)
.align_y(Alignment::Center)
.padding(Padding::from([ui.space(Space::X2), 0.0]))
.into()
}
/// 一个互斥按钮（选中态用 `SecondaryContainer`，未选中用透明 + `OnSurfaceVariant`）。
fn choice<'a>(ui: &'a Ui, text: &'a str, selected: bool, change: Change) -> Element<'a, Message> {
let height = ui.metrics().control_height;
let content_color = if selected {
ui.color(Role::OnSecondaryContainer)
} else {
ui.color(Role::OnSurfaceVariant)
};
button(
container(frame::text_role(
ui,
TypeRole::LabelLarge,
selected,
text,
content_color,
))
.align_y(Alignment::Center),
)
.height(height)
.padding(Padding::from([0.0, ui.space(Space::X3)]))
.style(move |_theme: &IcedTheme, status| {
let background = if selected {
Some(Background::Color(ui.color(Role::SecondaryContainer)))
} else if matches!(status, button::Status::Hovered | button::Status::Pressed) {
Some(Background::Color(ui.state_over(
unlucky_design::color::StateLayer::Hover,
Role::OnSurface,
Role::Surface,
)))
} else {
None
};
button::Style {
background,
text_color: content_color,
border: Border {
radius: ui.radius(ShapeScale::Full, height),
..Border::default()
},
shadow: Shadow::default(),
snap: true,
}
})
.on_press(Message::Appearance(change))
.into()
}
crates/app-iced/src/pages/appearance/section/bg_image.rs
+144
View File
@@ -0,0 +1,144 @@
//! 外观分组第 ④ ⑤ ⑥ ⑦ ⑧ 段：**背景图**——开关、路径、诊断、填充档、暗化强度。
//!
//! 这五段挤在一起是因为它们读同一份 `bg_*` 状态，而且**诊断必须紧贴控件**（复审 r1 P2-3：
//! 读盘失败 / CPU 降级 / 配色回落这些提示落在折叠线以下等于没提示）。
use iced::widget::column;
use iced::{Element, Length};
use unlucky_design::color::Role;
use unlucky_design::spacing::Space;
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use unlucky_presenter::prefs::BgFill;
use crate::app::components::inputs::{slider, text_field, Field, Slider};
use crate::pages::Message;
use crate::theme::Ui;
use super::super::background::{self, BG_DIM_MAX};
use super::super::palette;
use super::super::state::State;
use super::super::Change;
use super::{choice, choice_row, fixed2, label, note_line, slider_row, t, tr, tr_note};
/// 把 ④ 开关、⑤ 路径、⑥ 诊断、⑦ 填充、⑧ 暗化按视觉顺序推进 `rows`。
pub(super) fn push<'a>(
ui: &'a Ui,
state: &'a State,
lang: Lang,
rows: &mut Vec<Element<'a, Message>>,
) {
// ④ 背景图开关
rows.push(choice_row(
ui,
t(Key::SettingsAppearanceBackgroundImage, lang),
vec![
choice(
ui,
t(Key::SettingsAppearanceOff, lang),
!state.bg_enabled,
Change::BgEnabled(false),
),
choice(
ui,
t(Key::SettingsAppearanceOn, lang),
state.bg_enabled,
Change::BgEnabled(true),
),
],
));
// ⑤ 路径（文本框：受控，输入即生效）
let path_field: Element<'a, Message> = text_field(
ui,
Field::new(&state.bg_path)
.label(t(Key::SettingsAppearanceImagePath, lang))
.placeholder("D:/Pictures/background.png"),
|value| Message::Appearance(Change::BgImage(value)),
);
rows.push(
column![
label(ui, t(Key::SettingsAppearanceImagePath, lang)),
path_field
]
.spacing(ui.space(Space::X1))
.width(Length::Fill)
.into(),
);
// ⑥ 诊断（读盘失败 / 配色回落）——**不许静默**，且必须在**首屏可见处**
// （复审 r1 P2-3：文案落在折叠线以下等于没提示）。位置就在背景图那两行的紧下方。
//
// CPU 档的「面板/玻璃被强制」那句**不在这里**：它是张卡级状态，挂在被禁用的面板滑块旁边
// （`panel.rs` 的 `PanelOpacityForcedHint`），一屏只出现一次（M180 复审 P2-1）。
for note in state.diagnostics() {
let text = tr_note(lang, note);
rows.push(note_line(ui, &text, ui.color(Role::Error)));
}
if let Some(note) = state
.image()
.and_then(|image| background::small_tile_note(image, state.bg_fill))
{
let text = tr_note(lang, &note);
rows.push(note_line(ui, &text, ui.color(Role::OnSurfaceVariant)));
}
if let Some(key) = state.palette_note() {
rows.push(note_line(
ui,
t(key, lang),
ui.color(Role::OnSurfaceVariant),
));
}
// 生效的配色层级：显示的是**回落之后真正生效**的那一级（与底部「配色来源」里用户选的那一档
// 不一定相同）。码值 → 已有的三条档位 key（不新增平行词表），所以中文界面也读得懂。
let level = tr(
lang,
Key::SettingsAppearancePaletteLevel,
&[("level", t(palette::level_key(state.palette_level()), lang))],
);
rows.push(note_line(ui, &level, ui.color(Role::OnSurfaceVariant)));
// ⑦ 填充
rows.push(choice_row(
ui,
t(Key::SettingsAppearanceBgFill, lang),
vec![
choice(
ui,
t(Key::SettingsAppearanceBgFillCover, lang),
state.bg_fill == BgFill::Cover,
Change::BgFill(BgFill::Cover),
),
choice(
ui,
t(Key::SettingsAppearanceBgFillContain, lang),
state.bg_fill == BgFill::Contain,
Change::BgFill(BgFill::Contain),
),
choice(
ui,
t(Key::SettingsAppearanceBgFillTile, lang),
state.bg_fill == BgFill::Tile,
Change::BgFill(BgFill::Tile),
),
],
));
// ⑧ 暗化
rows.push(slider_row(
ui,
t(Key::SettingsAppearanceBgDim, lang),
format!("{:.0}%", state.bg_dim * 100.0),
tr(
lang,
Key::SettingsAppearanceBgDimHint,
&[("max", &fixed2(BG_DIM_MAX))],
),
state.bg_dim > 0.0,
slider(
Slider::new(ui, state.bg_dim / BG_DIM_MAX)
.on_change(|fraction| Message::Appearance(Change::BgDim(fraction * BG_DIM_MAX))),
),
));
}
crates/app-iced/src/pages/appearance/section/colour_source.rs
+47
View File
@@ -0,0 +1,47 @@
//! 外观分组第 ⑨ 段：**配色来源**（背景图 / 壁纸 / 色卡三档；它选的正是 D38 三级优先序的起点）。
use iced::Element;
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use unlucky_presenter::prefs::PaletteSource;
use crate::pages::Message;
use crate::theme::Ui;
use super::super::state::State;
use super::super::Change;
use super::{choice, choice_row, t};
/// 把 ⑨ 配色来源推进行 `rows`。
pub(super) fn push<'a>(
ui: &'a Ui,
state: &'a State,
lang: Lang,
rows: &mut Vec<Element<'a, Message>>,
) {
// ⑨ 配色来源
rows.push(choice_row(
ui,
t(Key::SettingsAppearancePaletteSource, lang),
vec![
choice(
ui,
t(Key::SettingsAppearancePaletteBackground, lang),
state.palette_source == PaletteSource::BackgroundImage,
Change::PaletteSource(PaletteSource::BackgroundImage),
),
choice(
ui,
t(Key::SettingsAppearancePaletteWallpaper, lang),
state.palette_source == PaletteSource::Wallpaper,
Change::PaletteSource(PaletteSource::Wallpaper),
),
choice(
ui,
t(Key::SettingsAppearancePalettePreset, lang),
state.palette_source == PaletteSource::Preset,
Change::PaletteSource(PaletteSource::Preset),
),
],
));
}
crates/app-iced/src/pages/appearance/section/mod.rs
+286
View File
@@ -0,0 +1,286 @@
//! 设置页「外观」分组（**真控件**）+ 背景层 Element + 面板层配色。
//!
//! ## 控件与键的对应
//!
//! | 控件 | 键 | 改动消息 |
//! |---|---|---|
//! | 整窗透明度滑块（下限 0.08） | `appearance.window_opacity` | [`Change::WindowOpacity`] |
//! | 窗口圆角（跟随系统 / 直角，M116） | `appearance.window_corner` | [`Change::Corner`] |
//! | 面板透明度滑块（下限 0.4，CPU 档禁用） | `appearance.panel_alpha` | [`Change::PanelAlpha`] |
//! | 背景图开关 | `appearance.bg_image_enabled` | [`Change::BgEnabled`] |
//! | 背景图路径（文本框） | `appearance.bg_image` | [`Change::BgImage`] |
//! | 填充（铺满 / 完整显示 / 平铺） | `appearance.bg_fill` | [`Change::BgFill`] |
//! | 暗化强度（0~0.95） | `appearance.bg_dim` | [`Change::BgDim`] |
//! | 配色来源（三档） | `appearance.palette_source` | [`Change::PaletteSource`] |
//!
//! ## 文件分工（M179 `I18NSEAM`：纯搬移 + 语言接线）
//!
//! 本模块原来是一个 395 行的 `section.rs`，而全仓行数守卫是 400（`components/gate.rs`），
//! 剩 5 行——加不了任何东西。M179 按「一段控件一个文件」切开了它：
//!
//! | 文件 | 是什么 |
//! |---|---|
//! | 本文件（`section/mod.rs`） | **壳**：[`section`] 按顺序拼各段 + [`card`] 卡片 + 行控件（[`label`] / [`slider_row`] / [`choice_row`] / [`choice`] / [`note_line`]）+ 两个取词口 [`t`] / [`tr`] |
//! | [`window`] | ① 整窗透明度 + ② 窗口圆角（含「因整窗 α 不生效」的 notice 与说明段） |
//! | [`panel`] | ③ 面板透明度（CPU 档强制 1.0，值 / 生效值分开显示） |
//! | [`bg_image`] | ④ 背景图开关 + ⑤ 路径 + ⑥ 诊断 + ⑦ 填充 + ⑧ 暗化 |
//! | [`colour_source`] | ⑨ 配色来源（三档） |
//!
//! 拆分口径：**纯搬移**——每段的语句逐字搬过去，只有下面这几处机械改写（M179 报告里用「去空白/
//! 去尾逗号 diff」逐段证明：改完之后与原文件逐字相同，断言一条没动）：
//!
//! 1. `rows = rows.push(…)` → `rows.push(…)`（壳现在传 `&mut Vec<Element>`）；
//! 2. `t(Key::X)` → `t(Key::X, lang)`（本 mission 的语言接线）；
//! 3. `super::notice(…)` → `super::super::notice(…)`（多了一层模块）；
//! 4. 唯一一处非 `Element` 实参：`rows.push(column![…])` → 末尾加 `.into()`（`Vec::push` 不做 `Into`）；
//! 5. rustfmt 因为多出来的 `, lang` 把两处调用换成了多行。
//!
//! ## 语言（M179 接过管子，M180 补齐文案）
//!
//! [`t`] / [`tr`] 是**唯一**两个取词口（一个拿 `&'static str`、一个拿带占位符的 owned 句子），
//! `lang` 从 `settings::view` 的 `Language.effective` → `Group.body` → [`section`] 一路递进来。
//! M179 只把管子接通（当时本组 27 条文案里真正本地化的只有圆角那 5 条）；M180 `I18NAPPEAR` 把
//! 剩下 22 条字面量与 `state.rs` / `background.rs` / `palette.rs` 的运行时诊断全部搬进
//! `catalog/settings/appearance.rs`，于是中文界面上这一页的**卡片文案**没有一句是英文。
//!
//! 两处例外（M180 复审 L-1 记下的口径）：① 写进 `{reason}` 的**原因串**里，来自本仓库自写的
//! 两条（`"no path configured"`、`"unknown image format …"`）与 OS / 解码库给出的文本仍是英文——
//! 它们是不可翻译的第三方或诊断原文；② `Windows 11` / `macOS` / `Linux` / `PNG` / `JPEG` / `BMP`
//! 这些专名。除此之外这一页不出现英文。
//!
//! ## 为什么「值」与「生效值」分开显示
//!
//! CPU 档下面板 α 被强制 1.0（D36），而用户请求值可能是 0.5。滑块位置按**生效值**画、旁边写
//! 「requested 0.50 → forced 1.00」，这样「为什么拖了没反应」在界面上就有答案，而不是只躺在日志里。
use iced::widget::{button, column, container, row};
use iced::{
Alignment, Background, Border, Color, Element, Length, Padding, Shadow, Theme as IcedTheme,
};
use unlucky_design::color::Role;
use unlucky_design::component_map::Component;
use unlucky_design::elevation::MaterialLayer;
use unlucky_design::shape::ShapeScale;
use unlucky_design::spacing::Space;
use unlucky_design::typography::TypeRole;
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use crate::pages::{frame, Message};
use crate::theme::Ui;
use super::state::State;
use super::Change;
mod bg_image;
mod colour_source;
mod panel;
mod window;
/// 「外观」分组整块（一张卡）。
///
/// `lang` 是**这一次生效的语言**：`settings::view` 的 `Language.effective`（M179）。壳把各段按
/// **视觉顺序**拼起来；每一段的语句逐字来自拆分前的 `section()`。
pub fn section<'a>(ui: &'a Ui, state: &'a State, lang: Lang) -> Element<'a, Message> {
let mut rows: Vec<Element<'a, Message>> = Vec::new();
window::push(ui, state, lang, &mut rows);
panel::push(ui, state, lang, &mut rows);
bg_image::push(ui, state, lang, &mut rows);
colour_source::push(ui, state, lang, &mut rows);
card(
ui,
column(rows)
.spacing(ui.space(Space::X1))
.width(Length::Fill),
)
}
/// 外观卡片：底色走 `ui.layer`（面板 α 的唯一来源），与其它页的卡片同源。
fn card<'a>(ui: &'a Ui, content: impl Into<Element<'a, Message>>) -> Element<'a, Message> {
let spec = Component::OutlinedCard.spec();
let background = ui.layer(MaterialLayer::Card);
container(content)
.width(Length::Fill)
.padding(ui.metrics().card_padding)
.style(move |_theme| container::Style {
background: Some(Background::Color(background)),
border: ui.outlined(spec.shape),
..container::Style::default()
})
.into()
}
// --------------------------------------------------------------- 行与控件
//
// 五个行控件由各段共用，所以留在壳里（`pub(super)` = 只给 `section/` 下的兄弟模块用）。
pub(super) fn label<'a>(ui: &'a Ui, content: &'a str) -> Element<'a, Message> {
frame::text_role(
ui,
TypeRole::BodyMedium,
false,
content,
ui.color(Role::OnSurface),
)
}
/// 设置页文案的 i18n 取词口（M116 起新条目一律走词表，不再写字面量）。
///
/// `lang` 是**这一次生效的语言**，由 [`section`] 一路递下来（M179 `I18NSEAM` 之前这里按英文目录
/// 取词，于是中文界面上本分组的 27 条文案里真正本地化 0 条）。现在这个函数是全模块
/// **唯一**的取词点：谁硬编码英文，就不会经过这里——M180 `I18NAPPEAR` 已把这一页剩余的 22 处
/// 字面量与全部运行时诊断搬进词表，见 `catalog/settings/appearance.rs` 的模块文档。
pub(super) fn t(key: Key, lang: Lang) -> &'static str {
let text = lang.catalog().text(key);
// 测试专用：把「这一帧真的取了哪条译文」记一份（iced 0.14 的 `Element` 没有可遍历控件树的
// 公开接口，所以「渲染出来的字是不是中文」只能在取词口取证，见 `appearance::probe`）。
#[cfg(test)]
super::probe::record(key, text);
text
}
/// 带占位符的句子（`{name}` 替换后的 owned 版本）。
///
/// 为什么不直接 `lang.catalog().render(...)`：这条路径也要进 [`t`] 那份取证记录
/// （`probe::record_rendered`），否则「中文界面下这一页每一句都不是纯 ASCII」的守卫会漏掉所有
/// 带数字的说明句。数值参数由调用方先格式化好（词表只认 `{name}`，不认 `{:.2}`）。
pub(super) fn tr(lang: Lang, key: Key, args: &[(&str, &str)]) -> String {
let text = lang.catalog().render(key, args);
#[cfg(test)]
super::probe::record_rendered(key, text.clone());
text
}
/// 两位小数（`{:.2}` 这种格式说明由 Rust 侧做，词表里只留 `{name}`）。
pub(super) fn fixed2(value: f32) -> String {
format!("{value:.2}")
}
/// 一条 [`Note`]（key + 已格式化的参数）按语言取整句；与 [`tr`] 共用取证口。
pub(super) fn tr_note(lang: Lang, note: &super::background::Note) -> String {
tr(lang, note.key(), &note.args())
}
pub(super) fn note_line<'a>(ui: &'a Ui, content: &str, color: Color) -> Element<'a, Message> {
// 诊断文案是**运行时拼出来的**（路径、错误原因），只能走 owned 版本。
frame::text_role_owned(ui, TypeRole::BodySmall, false, content.to_owned(), color)
}
/// 一行「标签 + 值 + 滑块 + 说明」。
pub(super) fn slider_row<'a>(
ui: &'a Ui,
title: &'a str,
value: String,
hint: String,
enabled: bool,
control: Element<'a, Message>,
) -> Element<'a, Message> {
let value_color = if enabled {
ui.color(Role::OnSurface)
} else {
ui.color(Role::OnSurfaceVariant)
};
let head = row![
container(label(ui, title))
.width(Length::Fill)
.align_y(Alignment::Center),
frame::text_role_owned(ui, TypeRole::LabelLarge, true, value, value_color),
]
.width(Length::Fill)
.align_y(Alignment::Center);
column![
head,
control,
frame::text_role_owned(
ui,
TypeRole::BodySmall,
false,
hint,
ui.color(Role::OnSurfaceVariant),
),
]
.spacing(ui.space(Space::X1))
.width(Length::Fill)
.padding(Padding::from([ui.space(Space::X2), 0.0]))
.into()
}
/// 一行「标签 + 一排互斥按钮」。
pub(super) fn choice_row<'a>(
ui: &'a Ui,
title: &'a str,
choices: Vec<Element<'a, Message>>,
) -> Element<'a, Message> {
row![
container(label(ui, title))
.width(Length::Fill)
.align_y(Alignment::Center),
row(choices)
.spacing(ui.space(Space::X1))
.align_y(Alignment::Center),
]
.width(Length::Fill)
.align_y(Alignment::Center)
.padding(Padding::from([ui.space(Space::X2), 0.0]))
.into()
}
/// 一个互斥按钮（选中态用 `SecondaryContainer`，未选中用透明 + `OnSurfaceVariant`）。
pub(super) fn choice<'a>(
ui: &'a Ui,
text: &'a str,
selected: bool,
change: Change,
) -> Element<'a, Message> {
let height = ui.metrics().control_height;
let content_color = if selected {
ui.color(Role::OnSecondaryContainer)
} else {
ui.color(Role::OnSurfaceVariant)
};
button(
container(frame::text_role(
ui,
TypeRole::LabelLarge,
selected,
text,
content_color,
))
.align_y(Alignment::Center),
)
.height(height)
.padding(Padding::from([0.0, ui.space(Space::X3)]))
.style(move |_theme: &IcedTheme, status| {
let background = if selected {
Some(Background::Color(ui.color(Role::SecondaryContainer)))
} else if matches!(status, button::Status::Hovered | button::Status::Pressed) {
Some(Background::Color(ui.state_over(
unlucky_design::color::StateLayer::Hover,
Role::OnSurface,
Role::Surface,
)))
} else {
None
};
button::Style {
background,
text_color: content_color,
border: Border {
radius: ui.radius(ShapeScale::Full, height),
..Border::default()
},
shadow: Shadow::default(),
snap: true,
}
})
.on_press(Message::Appearance(change))
.into()
}
crates/app-iced/src/pages/appearance/section/panel.rs
+62
View File
@@ -0,0 +1,62 @@
//! 外观分组第 ③ 段：**面板透明度**滑块（下限 0.4；CPU 档强制 1.0 并禁用滑块）。
use iced::Element;
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use crate::app::components::inputs::{slider, Slider};
use crate::pages::Message;
use crate::theme::Ui;
use super::super::alpha::{panel_alpha_from_fraction, panel_fraction, PANEL_ALPHA_FLOOR};
use super::super::state::State;
use super::super::Change;
use super::{fixed2, slider_row, t, tr};
/// 把 ③ 面板透明度推进 `rows`。
pub(super) fn push<'a>(
ui: &'a Ui,
state: &'a State,
lang: Lang,
rows: &mut Vec<Element<'a, Message>>,
) {
// ③ 面板透明度（CPU 档强制 1.0）
let forced = state.panel_is_forced();
let panel_percent = if forced {
// 数值占位：`{requested}` 是请求值（词表不认 `{:.2}`，所以在这里先格式化成两位小数）。
tr(
lang,
Key::SettingsAppearancePanelOpacityForcedValue,
&[("requested", &fixed2(state.panel_alpha))],
)
} else {
format!("{:.0}%", state.effective_panel_alpha() * 100.0)
};
let panel_hint = if forced {
t(Key::SettingsAppearancePanelOpacityForcedHint, lang).to_owned()
} else {
tr(
lang,
Key::SettingsAppearancePanelOpacityHint,
&[("floor", &fixed2(PANEL_ALPHA_FLOOR))],
)
};
let panel_control = if forced {
slider(Slider::new(ui, panel_fraction(1.0)))
} else {
slider(
Slider::new(ui, panel_fraction(state.panel_alpha)).on_change(|fraction| {
Message::Appearance(Change::PanelAlpha(panel_alpha_from_fraction(fraction)))
}),
)
};
rows.push(slider_row(
ui,
t(Key::SettingsAppearancePanelOpacity, lang),
panel_percent,
panel_hint,
!forced,
panel_control,
));
}
crates/app-iced/src/pages/appearance/section/window.rs
+87
View File
@@ -0,0 +1,87 @@
//! 外观分组第 ① ② 段：**整窗**两件——整窗透明度滑块、窗口圆角（含 notice 与说明段）。
//!
//! 这两段是唯一**一个控件牵动另一个控件**的地方：圆角「跟随系统」时把整窗透明度调低会让圆角失效
//! （`DwmExtendFrameIntoClientArea` 的世界里没有半透明边框），所以只有这一对放在同一个文件里——
//! notice 的判据（`corner == System && window_opacity < 1.0`）跨这两段。
use iced::widget::space;
use iced::Element;
use unlucky_design::color::Role;
use unlucky_design::spacing::Space;
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use unlucky_presenter::prefs::WindowCorner;
use crate::app::components::inputs::{slider, Slider};
use crate::pages::Message;
use crate::theme::Ui;
use super::super::alpha::{window_alpha_from_fraction, window_fraction, WINDOW_ALPHA_FLOOR};
use super::super::state::State;
use super::super::Change;
use super::{choice, choice_row, fixed2, note_line, slider_row, t, tr};
/// 把 ① 整窗透明度与 ② 窗口圆角按视觉顺序推进 `rows`。
pub(super) fn push<'a>(
ui: &'a Ui,
state: &'a State,
lang: Lang,
rows: &mut Vec<Element<'a, Message>>,
) {
// ① 整窗透明度
let window_percent = format!("{:.0}%", state.window_opacity * 100.0);
rows.push(slider_row(
ui,
t(Key::SettingsAppearanceWindowOpacity, lang),
window_percent,
tr(
lang,
Key::SettingsAppearanceWindowOpacityHint,
&[("floor", &fixed2(WINDOW_ALPHA_FLOOR))],
),
state.window_opacity < 1.0,
slider(
Slider::new(ui, window_fraction(state.window_opacity)).on_change(|fraction| {
Message::Appearance(Change::WindowOpacity(window_alpha_from_fraction(fraction)))
}),
),
));
// ② 窗口圆角（M116）：只有两档 + 一句按平台说明；不做 8/12/16 档（系统不暴露半径）。
let corner = state.window_corner();
rows.push(choice_row(
ui,
t(Key::SettingsAppearanceCorner, lang),
vec![
choice(
ui,
t(Key::SettingsAppearanceCornerSystem, lang),
corner == WindowCorner::System,
Change::Corner(WindowCorner::System),
),
choice(
ui,
t(Key::SettingsAppearanceCornerSquare, lang),
corner == WindowCorner::Square,
Change::Corner(WindowCorner::Square),
),
],
));
// **tonal notice**（r5 视觉终稿）：M3 里表达「当前状态」的惯用形态是**容器**，不是改字色。
// 只在「跟随系统 + α<1」出现；与下面的说明段之间再留 `Space::X1`（列间距 X1 + 这里 X1 = X2）。
if corner == WindowCorner::System && state.window_opacity < 1.0 {
rows.push(super::super::notice(
ui,
t(Key::SettingsAppearanceCornerSuspended, lang),
));
let gap: Element<'a, Message> = space::vertical().height(ui.space(Space::X1)).into();
rows.push(gap);
}
let tone = ui.color(Role::OnSurfaceVariant);
rows.push(note_line(
ui,
t(Key::SettingsAppearanceCornerHint, lang),
tone,
));
}
crates/app-iced/src/pages/appearance/state.rs
+9 -17
View File
@@ -17,6 +17,7 @@
//! 变成一条**可读诊断**而不是一个 `unwrap`。
use unlucky_design::color::{Scheme, SchemeFlavor};
use unlucky_i18n::catalog::Key;
use unlucky_presenter::prefs::{
AppearanceBase, AppearancePrefs, BgFill, PaletteSource, WindowCorner,
};
@@ -24,7 +25,7 @@ use unlucky_presenter::prefs::{
use crate::Backend;
use super::alpha::{self, effective_glass, effective_panel_alpha, panel_is_forced_opaque};
use super::background::{self, Image};
use super::background::{self, Image, Note};
use super::palette::{self, Resolved, Source};
/// 取证开关的环境变量名（截图矩阵与真机日志用；生产默认全部不设）。
@@ -67,8 +68,8 @@ pub struct State {
pub selected_group: usize,
/// 已解码的背景图（`None` = 没设 / 读失败）。
image: Option<Image>,
/// 读盘/解码失败的**可读诊断**（按发生顺序追加）。
diagnostics: Vec<String>,
/// 读盘/解码失败的**可读诊断**（按发生顺序追加；`Note` = key + 参数，句子在词表里）。
diagnostics: Vec<Note>,
/// 上一次的配色解析结果。
resolved: Option<Resolved>,
/// 当前深浅（配色解析的输入）。
@@ -196,24 +197,15 @@ impl State {
Some(&resolved.scheme)
}
/// 读盘/解码失败的诊断（设置页逐条显示）。
/// 读盘/解码失败的诊断（设置页逐条显示；一条 = 一条 key + 它的参数）。
#[must_use]
pub fn diagnostics(&self) -> &[String] {
pub fn diagnostics(&self) -> &[Note] {
&self.diagnostics
}
/// CPU 档降级的说明（`None` = 没有降级）。
/// 配色来源的提示 key（`None` = 一级成功）。
#[must_use]
pub fn backend_note(&self) -> Option<&'static str> {
self.panel_is_forced().then_some(
"Software renderer: panel transparency and glass stay fully opaque (window \
transparency still works).",
)
}
/// 配色来源的提示（`None` = 一级成功）。
#[must_use]
pub fn palette_note(&self) -> Option<&'static str> {
pub fn palette_note(&self) -> Option<Key> {
self.resolved.as_ref()?.note()
}
@@ -362,7 +354,7 @@ impl State {
}
match background::load(trimmed) {
Ok(image) => self.image = Some(image),
Err(error) => self.diagnostics.push(error.describe()),
Err(error) => self.diagnostics.push(error.note()),
}
}
crates/app-iced/src/pages/appearance/tests.rs
+263
View File
@@ -0,0 +1,263 @@
//! `pages::appearance` 的单测：`Change` 的落盘映射（M93）+ **中文界面文案的取证守卫**（M180）。
//!
//! 为什么是独立文件：`mod.rs` 已经 220 行上下，而 M180 要在模块里加三条取证用例。搬移口径与
//! `background/tests.rs` 一致——既有两条用例**一字未动**，只是从 `mod.rs` 的行内 `mod tests` 挪到这里。
//!
//! ## M180 的两条取证守卫，它们「抓得住什么」
//!
//! iced 0.14 没有可遍历控件树的公开接口（见 [`super::probe`] 的模块文档），所以取证点只能是
//! 取词口 `section::t` / `section::tr`。于是这一对守卫分工如下：
//!
//! | 守卫 | 抓得住 | 抓不住 |
//! |---|---|---|
//! | [`the_appearance_card_speaks_chinese`] | 中文界面下取到的每一条文案都是纯 ASCII（= 有人把某条 key 的英文写回中文表 / 中文表里放英文原句） | 硬编码字面量（它压根不过取词口） |
//! | [`every_appearance_card_key_is_drawn`] | 某一处控件被改回**写死英文**：那条 key 不再被取，集合里就少一个元素 | 新加一条字面量（新 key 还没有，集合不看它） |
//!
//! 两条合起来才等于「中文界面下外观卡片里不再出现英文字面量」——单看任一条都有一个真会发生的
//! 漏网口，所以这里刻意写两条。
use super::{Change, APPEARANCE_GROUP};
use unlucky_i18n::catalog::Key;
use unlucky_i18n::Lang;
use unlucky_presenter::prefs::{keys, BgFill, PaletteSource};
/// 抓得住：每条改动都点名到自己那个 schema 键（写错键 = 静默写到别的配置项上）。
/// 抓不住：这些键是否真的在 core 的 schema 白名单里（那由 presenter/core 的测试守）。
#[test]
fn every_change_names_its_own_schema_key() {
assert_eq!(APPEARANCE_GROUP, 1, "左列第 1 项是 Appearance");
let cases = [
(Change::WindowOpacity(0.8), keys::WINDOW_OPACITY),
(Change::PanelAlpha(0.6), keys::PANEL_ALPHA),
(Change::BgEnabled(true), keys::BG_IMAGE_ENABLED),
(Change::BgImage("D:/x.png".to_owned()), keys::BG_IMAGE),
(Change::BgFill(BgFill::Tile), keys::BG_FILL),
(Change::BgDim(0.5), keys::BG_DIM),
(
Change::PaletteSource(PaletteSource::Wallpaper),
keys::PALETTE_SOURCE,
),
(
Change::Corner(unlucky_presenter::prefs::WindowCorner::Square),
keys::WINDOW_CORNER,
),
];
for (change, key) in cases {
assert_eq!(change.key(), Some(key), "{change:?}");
assert!(change.value().is_some());
}
assert_eq!(Change::SelectGroup(2).key(), None, "切分组不落盘");
assert_eq!(Change::SelectGroup(2).value(), None);
}
/// 抓得住：落盘字符串必须是 schema 认识的词表（枚举档写错就整条配置读回默认值）。
/// 抓不住：数值是否在范围内（钳位在 core 侧，越界写入会被 schema 拒绝）。
#[test]
fn persisted_values_use_the_schema_vocabulary() {
assert_eq!(
Change::BgFill(BgFill::Contain).value().as_deref(),
Some("contain")
);
assert_eq!(
Change::PaletteSource(PaletteSource::BackgroundImage)
.value()
.as_deref(),
Some("background-image")
);
assert_eq!(Change::BgEnabled(false).value().as_deref(), Some("false"));
assert_eq!(Change::WindowOpacity(0.8).value().as_deref(), Some("0.8"));
}
// --------------------------------------------------------------- 文案（M180 I18NAPPEAR）
/// 画一帧外观卡片，取走这一帧从词表取到的**全部**字：`(key, 文案)`。
///
/// 三档状态各画一帧：
/// - [`Case::Factory`]：auto 档、没设背景图——覆盖常驻的标签 / 选项 / 说明；
/// - [`Case::Cpu`]：CPU 档——覆盖「强制 100%」那一行与软件渲染说明（这两条只在降级态出现）；
/// - [`Case::Dim`]：整窗 α 调低——覆盖「圆角暂时不生效」那条 notice。
///
/// 两条取词路径都要收：`t()` 的 `&'static str` 与 `tr()` 替换完占位符的整句（后者不进前者的记录）。
fn appearance_texts(lang: Lang, case: Case) -> Vec<(Key, String)> {
use unlucky_design::color::SchemeFlavor;
use unlucky_presenter::prefs::{AppearanceBase, AppearancePrefs};
use super::probe;
use crate::cli::Backend;
use crate::theme::{Families, Ui};
const FAMILIES: Families = Families {
text: "Segoe UI",
display: "Segoe UI",
mono: "Consolas",
};
let (backend, alpha) = match case {
Case::Factory => (Backend::Auto, 1.0),
Case::Cpu => (Backend::Cpu, 1.0),
Case::Dim => (Backend::Gpu, 0.5),
};
let mut state = super::State::new(
&AppearancePrefs::factory(),
&AppearanceBase::factory(),
backend,
SchemeFlavor::Light,
);
if alpha < 1.0 {
state.apply(Change::WindowOpacity(alpha));
}
let ui = Ui::new(SchemeFlavor::Light, FAMILIES);
// 前面几条用例可能留了记录：本线程的取证每次都从清空开始。
probe::take();
probe::take_rendered();
let _tree = super::section(&ui, &state, lang);
let mut texts: Vec<(Key, String)> = probe::take()
.into_iter()
.map(|(key, text)| (key, text.to_owned()))
.collect();
texts.extend(probe::take_rendered());
// 复审 L-2：`{name}` 换完还留着花括号 ⇒ 某处参数名与模板不一致（`("floor", …)` 写成
// `("flor", …)` 时句子会原样显示「下限 {floor}」，而「整句非 ASCII」的守卫看不出来）。
// 三档状态合起来覆盖本页全部 `tr()` 调用，所以这条断言是全覆盖的。
for (key, text) in &texts {
assert!(
!text.contains('{'),
"{case:?}：{} 渲染后还留着占位符「{text}」——`tr()` 的参数名与模板对不上",
key.name()
);
}
texts
}
/// 画哪一档状态。
#[derive(Debug, Clone, Copy)]
enum Case {
/// 工厂态（GPU / auto）。
Factory,
/// CPU 降级态（面板 α 与玻璃被强制）。
Cpu,
/// 整窗 α 调低（圆角暂时不生效）。
Dim,
}
/// 这一页**常驻**的 key（三档状态合起来必须一个不缺地取到）。
///
/// 为什么是手写清单而不是「`Key::ALL` 里所有 `SettingsAppearance*`」：诊断一族（读盘失败 / 配色回落 /
/// 小图平铺）取决于运行时状态，单测里要让它们出现得造磁盘上的坏图；那些由
/// `background/tests.rs` 与 `palette.rs` 的单测按 key 逐条钉（见各自的用例注释）。
const CARD_KEYS: &[Key] = &[
Key::SettingsAppearanceCorner,
Key::SettingsAppearanceCornerSystem,
Key::SettingsAppearanceCornerSquare,
Key::SettingsAppearanceCornerHint,
Key::SettingsAppearanceCornerSuspended,
Key::SettingsAppearanceWindowOpacity,
Key::SettingsAppearanceWindowOpacityHint,
Key::SettingsAppearancePanelOpacity,
Key::SettingsAppearancePanelOpacityHint,
Key::SettingsAppearancePanelOpacityForcedValue,
Key::SettingsAppearancePanelOpacityForcedHint,
Key::SettingsAppearanceBackgroundImage,
Key::SettingsAppearanceOff,
Key::SettingsAppearanceOn,
Key::SettingsAppearanceImagePath,
Key::SettingsAppearancePaletteLevel,
Key::SettingsAppearanceBgFill,
Key::SettingsAppearanceBgFillCover,
Key::SettingsAppearanceBgFillContain,
Key::SettingsAppearanceBgFillTile,
Key::SettingsAppearanceBgDim,
Key::SettingsAppearanceBgDimHint,
Key::SettingsAppearancePaletteSource,
Key::SettingsAppearancePaletteBackground,
Key::SettingsAppearancePaletteWallpaper,
Key::SettingsAppearancePalettePreset,
];
/// **M180 守门 ①**：中文界面下，外观卡片里取到的每一条文案都不是纯 ASCII。
///
/// 抓得住：某条 key 的中文译文被换成英文原句（中文表里出现纯 ASCII 的一句）；中文译文写成
/// `PNG` / `Preset` 这种专名；`tr()` 那条路径把数字拼进英文模板（比如 `Colours: preset`）。
/// 抓不住：硬编码字面量——它不过取词口，由 [`every_appearance_card_key_is_drawn`] 与
/// `catalog/settings/appearance.rs` 的译文守卫合力守。
///
/// 变异证明：把 `SettingsAppearanceOff` 的中文改成 `"Off"` ⇒ 本条立刻红。
#[test]
fn the_appearance_card_speaks_chinese() {
// 白名单：技术专名允许是纯 ASCII（现在一条都没有——`%` / 数字不在文案里，它们是参数）。
const ASCII_OK: &[&str] = &[];
for case in [Case::Factory, Case::Cpu, Case::Dim] {
let pairs = appearance_texts(Lang::ZhCn, case);
assert!(
pairs.len() >= 20,
"{case:?}：取词口只记到 {} 条文案，渲染路径没走到底（语言管子断了？）",
pairs.len()
);
for (key, text) in &pairs {
if ASCII_OK.contains(&text.as_str()) {
continue;
}
assert!(
!text.is_ascii(),
"{case:?}：中文界面下外观卡片里出现了纯 ASCII 的文案「{text}」（{}）\
——写死英文，或中文表里放了英文原句",
key.name()
);
}
}
}
/// **M180 守门 ②（漏项）**：这一页每一处控件都必须从词表取词。
///
/// 抓得住：把某处 `t(Key::X, lang)` / `tr(lang, Key::X, …)` 改回写死的英文字面量——那条 key 不再
/// 出现在取词记录里，集合比较当场红（这正是 M172 口径「22 处硬编码」的复发形态）。
/// 抓不住：新加一条写死英文（它没有 key，也就没有「少了哪条」）。
///
/// 变异证明：把 `bg_image.rs` 里 `t(Key::SettingsAppearanceOff, lang)` 换回 `"Off"` ⇒ 本条红。
#[test]
fn every_appearance_card_key_is_drawn() {
let mut seen: Vec<Key> = Vec::new();
for case in [Case::Factory, Case::Cpu, Case::Dim] {
seen.extend(
appearance_texts(Lang::ZhCn, case)
.into_iter()
.map(|(key, _)| key),
);
}
let missing: Vec<&str> = CARD_KEYS
.iter()
.filter(|key| !seen.contains(key))
.map(|key| key.name())
.collect();
assert!(
missing.is_empty(),
"这些 key 一帧都没取到（控件被改回写死英文，或整段没画）：{missing:?}"
);
}
/// 英文界面下不许出现汉字（否则「含汉字」可能来自写死的中文，而不是词表）。
#[test]
fn the_appearance_card_keeps_its_english_baseline() {
for case in [Case::Factory, Case::Cpu, Case::Dim] {
let texts = appearance_texts(Lang::En, case);
let with_han: Vec<&(Key, String)> = texts
.iter()
.filter(|(_, text)| text.chars().any(is_han))
.collect();
assert!(
with_han.is_empty(),
"{case:?}：英文界面下外观卡片出现了汉字：{with_han:?}"
);
}
}
/// 有没有汉字（与 `pages/settings/tests/appearance_section.rs` 的 `is_han` 同一段码位）。
fn is_han(ch: char) -> bool {
('\u{4e00}'..='\u{9fff}').contains(&ch)
}
crates/app-iced/src/pages/content.rs
+14 -1
View File
@@ -47,6 +47,16 @@
//! | 3 | 整合包的「装入」是禁用态 | core 没有远程整合包的安装管线 | 导入管线落地后接同一入口 |
//! | 5 | CurseForge 的「装入」同样是禁用态（`Blocker::SourceNotWired`） | 检索通了，**文件端点**还没接（CF 的文件列表要带 key） | 接上 CF 文件端点后删掉这条原因 |
//! | 4 | 安装进度只有阶段级（无字节条） | presenter 依赖表里没有 tokio/futures，拿不到 `ProgressEmitter` 的接收端 | presenter 补依赖后换成字节级 |
//!
//! ## 安装失败之后：两档分组 + 「只重试这些」（M191）
//!
//! 装入失败且**有可重试项**时，页底那块失败面板换成 [`parts::retry_panel`]：按
//! `InstallFailureKind` 分两段（不兼容 / 取不到，各有自己的词表文案），并给一个「只重试这 N 个」
//! 的实心按钮。按钮发 [`Message::RetryFailed`]，app 层翻成 `AppCommand::InstallContent{retry: true}`，
//! host 拿上一轮的计划调 `DependencyPlan::retry_request()` ⇒ **只请求失败的那几个项目**。
//!
//! 判据只有一条且在模型里（`RetryPanel::of`）：`stage == Failed && !retry.is_empty()`。
//! 全成功、没有失败项、还在跑，三种情况都得到 `None`——**不渲染**，不是画一个灰按钮。
mod demo;
mod layout;
@@ -61,7 +71,10 @@ mod view;
mod tests;
pub use message::Message;
pub use model::{loader_name, Blocker, Content, ContentQueryView, Hit, PageState, Status, Target};
pub use model::{
loader_name, Blocker, Content, ContentQueryView, Hit, PageState, RetryGroup, RetryPanel,
Status, Target,
};
// M113: import/export
pub use packui::{request_export, Pack, PackMessage, PackPageState};
crates/app-iced/src/pages/content/demo.rs
+80 -2
View File
@@ -11,7 +11,7 @@
//! | 变量 | 取值 | 作用 |
//! |---|---|---|
//! | `ULL_CONTENT_KIND` | `modpack` / `mod` / `resourcepack` / `shader` | 选内容类型（默认 `mod`） |
//! | `ULL_CONTENT_STATE` | `ok` / `empty` / `incompatible` / `install` / `cf` / `offline` | 选状态（默认 `ok`；`offline` = M162 的未联网态） |
//! | `ULL_CONTENT_STATE` | `ok` / `empty` / `incompatible` / `install` / `cf` / `offline` / `retryfail` / `retryok` | 选状态（默认 `ok`；`offline` = M162 的未联网态；`retryfail` = M191 的「有失败项」，`retryok` = M191 的「全部成功」） |
//!
//! 只影响本来就用演示数据的 harness 路径；产品二进制里 `demo()` 根本不会被调用。
@@ -19,10 +19,52 @@ use unlucky_i18n::{Catalog, Key, Lang};
use unlucky_presenter::dto::{ContentHit, ContentKind, ContentSort, ContentSource, LoaderKind};
use super::model::{
blockers_of, Content, ContentQueryView, Hit, HitFacts, Status, Target, VersionRow,
blockers_of, Content, ContentQueryView, Hit, HitFacts, RetryPanel, Status, Target, VersionRow,
};
use crate::pages::download::Download;
/// M191「有失败项」那一屏：两档各几个项目，面板按档分组。
///
/// **走真判据**（[`RetryPanel::of`]），不手搓面板字段：出图与产品路径读同一个函数，
/// 判据一改这条演示就跟着变（否则演示图能一直画着一个已经不存在的面板）。
fn retry_failure(instance: &str, catalog: Catalog) -> Option<RetryPanel> {
use unlucky_presenter::dto::{
InstallFailureKind, InstallFailureView, InstallProgressView, InstallStage,
};
let mut progress = InstallProgressView {
version: "Sodium".to_string(),
instance: instance.to_string(),
loader: "Fabric".to_string(),
stage: InstallStage::Failed,
files_done: 1,
files_total: 4,
..InstallProgressView::new()
};
// 三种可显示性各一条，与 host 侧 `plan::label_of` 的三种情况同形：
// 根项目 = 请求里的标题、下载失败 = 文件名、不兼容档 = 失败路径上现取的项目名。
progress.retry = vec![
InstallFailureView::new(
"AANobbMI",
"Sodium",
InstallFailureKind::Unreachable,
"下载 sodium-fabric-0.6.0.jar 失败（online_not_connected）：连不上 cdn.modrinth.com",
),
InstallFailureView::new(
"P7dR8mSH",
"Entity Culling",
InstallFailureKind::Incompatible,
"没有匹配所选游戏版本/加载器（1.20.1 / fabric）的版本",
),
InstallFailureView::new(
"1eAoo2KR",
"fabric-api-0.92.2+1.20.1.jar",
InstallFailureKind::Unreachable,
"下载 fabric-api-0.92.2+1.20.1.jar 失败（online_not_connected）：连不上 cdn.modrinth.com",
),
];
RetryPanel::of(&progress, catalog)
}
/// 一个固定的演示环境：两个实例（一个 Fabric / 一个 Forge）。
fn targets() -> Vec<Target> {
vec![
@@ -254,6 +296,12 @@ pub(super) fn demo(fallback_kind: ContentKind, lang: Lang) -> Content {
} else {
None
},
// M191：`retryfail` 画「有失败项」，`retryok` 画「全部成功」——后者走同一条判据，
// 得到 `None`（连按钮都不渲染）。
retry: match state.as_str() {
"retryfail" => retry_failure("survival", catalog),
_ => None,
},
versions: vec!["1.20.1".to_string(), "1.21.1".to_string()],
available_versions: demo_versions,
versions_note: None,
@@ -265,3 +313,33 @@ pub(super) fn demo(fallback_kind: ContentKind, lang: Lang) -> Content {
pack,
}
}
#[cfg(test)]
mod tests {
use super::*;
/// 「有失败项」那一屏的两档走**真判据**（`RetryPanel::of`），不是手搓的面板字段。
#[test]
fn the_failure_screen_shows_both_tiers() {
let panel = retry_failure("survival", Lang::En.catalog()).expect("演示必须有面板");
assert_eq!(panel.total, 3);
assert!(panel.has_both_tiers(), "{:?}", panel.groups);
assert_eq!(
panel.items_of(unlucky_presenter::dto::InstallFailureKind::Unreachable),
Some(
[
// 根项目：名字来自请求标题
"Sodium (AANobbMI)".to_string(),
// 下载失败：名字来自文件名
"fabric-api-0.92.2+1.20.1.jar (1eAoo2KR)".to_string(),
]
.as_slice()
)
);
// 不兼容档：失败路径上现取的项目名（不是 id）
assert_eq!(
panel.items_of(unlucky_presenter::dto::InstallFailureKind::Incompatible),
Some(["Entity Culling (P7dR8mSH)".to_string()].as_slice())
);
}
}
crates/app-iced/src/pages/content/message.rs
+5
View File
@@ -37,6 +37,11 @@ pub enum Message {
Retry,
/// 装进目标实例
Install,
/// **只重试上次失败的那几项**（M191；不是「整单重装」）
///
/// app 层的落点：`AppCommand::InstallContent` 带 `retry: true`——host 拿上一轮的依赖计划
/// 调 `DependencyPlan::retry_request()`，只重解失败项。
RetryFailed,
/// 导入/导出区（M113：整合包导入与导出；一切细节在 `packui::Message`）
Pack(super::packui::PackMessage),
}
crates/app-iced/src/pages/content/model.rs
+12
View File
@@ -32,10 +32,12 @@ use unlucky_i18n::{Catalog, Key};
use crate::pages::download::Download;
mod items;
mod retry;
pub(crate) use items::HitFacts;
pub(crate) use items::{capitalize, thousands};
pub use items::{loader_name, Blocker, Hit, PageState, Status, Target, VersionRow};
pub use retry::{RetryGroup, RetryPanel};
/// 内容库页要画的东西。
#[derive(Debug, Clone, PartialEq)]
@@ -69,6 +71,11 @@ pub struct Content {
/// 存整个 `Download` 而不是只存一帧视图：面板的入参就是 `&Download`，而 iced 的控件树
/// 借用它 ⇒ 被借的东西必须活得比这一帧长（局部临时值不行）。
pub panel: Option<Download>,
/// 「只重试这些」面板（M191）：`None` = 不渲染（全成功 / 没有失败项 / 还在跑）。
///
/// 与 `panel` 互斥地画：失败且有可重试项时，这块**顶替**下载页那块通用失败面板，
/// 一屏只有一个失败块（两个会说同一件事，还各自给一个「关闭」）。
pub retry: Option<RetryPanel>,
/// 游戏版本筛选的候选（来自实例；去重、保持实例顺序）
pub versions: Vec<String>,
/// 关键词草稿
@@ -187,6 +194,11 @@ impl Content {
target_label,
blockers,
panel: content_install(state, catalog),
// M191：失败且有可重试项时这块才存在（全成功 ⇒ `None` ⇒ 视图里连按钮都没有）
retry: state
.install
.as_ref()
.and_then(|progress| RetryPanel::of(progress, catalog)),
versions,
draft: page.draft.clone(),
pack,
crates/app-iced/src/pages/content/model/retry.rs
+153
View File
@@ -0,0 +1,153 @@
//! 「只重试这些」面板的视图模型（M191）。
//!
//! ## 它画的是什么
//!
//! 安装失败之后，界面要说清「哪几项没装上、分别是哪种没装上」：
//!
//! ```text
//! 安装未完成 —— 3 项没装上
//! 不兼容所选版本/加载器
//! P7dR8mSH ← 拿不到名字时只画 id（合理兜底）
//! 取不到（网络 / 项目不存在）
//! Sodium (AANobbMI) ← 根项目：名字来自请求标题
//! fabric-api-0.92.2.jar (1eAoo2KR) ← 下载失败：名字来自文件名
//! [只重试这 3 个] [关闭]
//! ```
//!
//! 每行是 `InstallFailureView::line()` 的结果（名字优先、id 次要）。名字是**语言中立**的站点
//! 标题或文件名，不是 core 的中文散文——那条线（i18n R2）踩了就回不去。
//!
//! ## 三条判据（都落在 [`RetryPanel::of`]，纯函数，用例直接钉）
//!
//! 1. **全成功不渲染**：`retry` 名单空 ⇒ `None` ⇒ 视图里连按钮都不存在（不是置灰）；
//! 2. **两档不混**：分组按 [`InstallFailureKind`] 分开，两档各有自己的标题 key；
//! 3. **只列名单里的**：条目原样来自 DTO（`presenter` 从 `DependencyPlan::retry_request()`
//! 的同一份失败名单产出），页面不自己挑、也不补「顺便重装根」。
//!
//! ## 为什么这里不拼文案
//!
//! 分组标题是 [`Key`]（i18n），条目是项目键（站点数据，不是文案）。拼一句带量的中文句子
//! 会把语序写死——英文与中文的量词位置不同（`Retry just these 3` / `只重试这 3 个`）。
use unlucky_i18n::{Catalog, Key};
use unlucky_presenter::dto::{
ContentInstallRequest, ContentSource, InstallFailureKind, InstallFailureView,
InstallProgressView, InstallStage, LoaderKind,
};
/// 面板上的一个档位分组。
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RetryGroup {
/// 哪一档（顺序固定，见 [`InstallFailureKind::ALL`]）
pub kind: InstallFailureKind,
/// 这一档的标题 key（不硬编码中文）
pub title: Key,
/// 这一档要画的每一行（`名字 (id)`；拿不到名字时就只有 id，顺序 = 计划里的顺序）
pub items: Vec<String>,
}
/// 「只重试这些」面板（`None` = 不渲染：没有失败项、或已经全成功）。
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RetryPanel {
/// 失败的那次装入的目标实例（重试只对这个实例生效）
pub instance: String,
/// 标题（已按词表渲染：带条数）
pub title: String,
/// 主按钮文字（已按词表渲染：`只重试这 N 个`）
///
/// 存在这里而不是画的时候现拼：`Button::new` 要的是 `&'a str`，而词表渲染出来的是
/// `String`——存进模型（与 `Hit` / `VersionRow.line` 同一手法）就不必为了一个标签
/// 去改组件库的入参类型。
pub action: String,
/// 按档分组（空组不出现）
pub groups: Vec<RetryGroup>,
/// 失败项总数（标题与按钮都用这个数）
pub total: usize,
}
impl RetryPanel {
/// 进度快照 → 面板（**唯一**判据；`None` = 视图里不该出现这块）。
///
/// 只认 `Failed` 这一态：`Done` 没有可重试的东西，`Cancelled` 是用户自己停的
/// （那条路上根本没有失败名单），`Planning`/`Downloading` 还在跑。
#[must_use]
pub fn of(progress: &InstallProgressView, catalog: Catalog) -> Option<Self> {
if progress.stage != InstallStage::Failed || !progress.has_retry() {
return None;
}
let total = progress.retry.len();
let count = total.to_string();
let groups = InstallFailureKind::ALL
.into_iter()
.map(|kind| RetryGroup {
kind,
title: title_of(kind),
items: progress
.retry_of(kind)
.map(InstallFailureView::line)
.collect(),
})
.filter(|group| !group.items.is_empty())
.collect();
Some(Self {
instance: progress.instance.clone(),
title: catalog.render(Key::ContentInstallFailedTitle, &[("count", count.as_str())]),
action: catalog.render(Key::ContentInstallRetryOnly, &[("count", count.as_str())]),
groups,
total,
})
}
/// 两档都在吗（「分组」这件事本身的判据：都出现时界面上是两段，不是一段）。
#[must_use]
pub fn has_both_tiers(&self) -> bool {
self.groups.len() == 2
}
/// 某一档的条目（用例断言用）。
#[must_use]
pub fn items_of(&self, kind: InstallFailureKind) -> Option<&[String]> {
self.groups
.iter()
.find(|group| group.kind == kind)
.map(|group| group.items.as_slice())
}
}
/// 档位 → 标题 key（**穷尽 match**：合并两档会少一条文案，用例会红）。
#[must_use]
pub const fn title_of(kind: InstallFailureKind) -> Key {
match kind {
InstallFailureKind::Incompatible => Key::ContentInstallRetryIncompatible,
InstallFailureKind::Unreachable => Key::ContentInstallRetryUnreachable,
}
}
impl super::Content {
/// 「只重试这些」那一次请求（M191；`None` = 没有可重试的面板 ⇒ 这个动作不存在）。
///
/// 载荷里 `retry: true` 是**唯一**的语义开关：host 收到它就不解根项目，而是拿上一轮的计划
/// 调 `DependencyPlan::retry_request()`（只请求失败的那几个项目）。其余字段照旧填，
/// 是因为 `ContentInstallRequest` 的判据仍要能读（`project` / `title` 也用于日志）；
/// 这些字段在重试路径上**不被 host 读取**——过滤条件与落盘目录都来自那份计划。
///
/// 实例取**失败那次的**实例，不是页面上此刻选中的那个：用户可能已经换了目标实例。
pub fn retry_install_request(&self) -> Option<ContentInstallRequest> {
let retry = self.retry.as_ref()?;
let hit = self.selected_hit();
let target = self
.targets
.iter()
.find(|target| target.id == retry.instance);
Some(ContentInstallRequest {
project: hit.map(|hit| hit.id.clone()).unwrap_or_default(),
title: hit.map(|hit| hit.title.clone()).unwrap_or_default(),
kind: self.kind,
source: hit.map_or(ContentSource::Modrinth, |hit| hit.source),
instance: retry.instance.clone(),
game_version: target.map_or_else(String::new, |target| target.mc_version.clone()),
loader: target.map_or(LoaderKind::Vanilla, |target| target.loader),
retry: true,
})
}
}
crates/app-iced/src/pages/content/model/tests.rs
+7
View File
@@ -355,3 +355,10 @@ fn loader_names_are_ascii_so_the_english_baseline_stays_english() {
"不能画「原版」"
);
}
// M191：安装失败的两档分组与「只重试这些」（按主题分卷，父文件已贴 400 行硬线）
//
// `#[path]` 显式给出：本文件自己是 `#[path = "model/tests.rs"]` 挂上去的，子模块默认按
// 「父模块所在目录」找，会指到 `model/retry.rs`（视图模型本体）而不是这里的 `tests/retry.rs`。
#[path = "tests/retry.rs"]
mod retry;
crates/app-iced/src/pages/content/model/tests/retry.rs
+158
View File
@@ -0,0 +1,158 @@
//! M191：安装失败的两档分组 + 「只重试这些」（`super` 按主题分卷，父文件已贴 400 行硬线）。
//!
//! 三条变异守门：两档不许合并 / 全成功不许渲染 / 重试只针对失败那次的实例。
use super::super::{Content, PageState, RetryPanel};
use super::{hit, results, state_with};
use unlucky_i18n::{Key, Lang};
use unlucky_presenter::dto::{
InstallFailureKind, InstallFailureView, InstallProgressView, InstallStage,
};
/// 一份「两档都有」的失败进度快照。
fn failed_progress() -> unlucky_presenter::dto::InstallProgressView {
let mut progress = InstallProgressView {
version: "Sodium".to_string(),
instance: "survival".to_string(),
stage: InstallStage::Failed,
files_done: 1,
files_total: 4,
..InstallProgressView::new()
};
// 三种可显示性各一条（与 `plan::label_of` 的三种情况同形）：
// 根项目用请求里的标题、下载失败用文件名、拿不到名的只画 id。
progress.retry = vec![
InstallFailureView::new(
"AANobbMI",
"Sodium",
InstallFailureKind::Unreachable,
"连不上 CDN",
),
InstallFailureView::new(
"P7dR8mSH",
"Entity Culling",
InstallFailureKind::Incompatible,
"没有匹配的版本",
),
InstallFailureView::new("1eAoo2KR", "", InstallFailureKind::Unreachable, "HTTP 404"),
];
progress
}
/// 两档**分组**画，各有自己的标题；条目按档分开，不混成一段。
///
/// 变异守门②：把两档合并（`kind_of` 都映成 `Unreachable`，或 `title_of` 都返回同一个 key）
/// ⇒ `groups.len()` 变 1 / 两个 title 相同 ⇒ 这条红。
#[test]
fn the_two_tiers_are_two_groups_with_two_labels() {
let panel = RetryPanel::of(&failed_progress(), Lang::En.catalog()).expect("有失败项就有面板");
assert_eq!(panel.total, 3);
assert!(panel.has_both_tiers(), "{:?}", panel.groups);
// **P2-1 的守门**：有名字的画「名字 (id)」，没有名字的才只画 id
assert_eq!(
panel.items_of(InstallFailureKind::Incompatible),
Some(["Entity Culling (P7dR8mSH)".to_string()].as_slice())
);
assert_eq!(
panel.items_of(InstallFailureKind::Unreachable),
Some(["Sodium (AANobbMI)".to_string(), "1eAoo2KR".to_string()].as_slice())
);
// 变异守门：把标签置空 ⇒ 这一行退回裸 id，上面两条立刻红
assert!(
panel
.items_of(InstallFailureKind::Unreachable)
.is_some_and(|items| items[0].starts_with("Sodium")),
"根项目必须显示请求里的标题，不是 id"
);
let titles: Vec<Key> = panel.groups.iter().map(|group| group.title).collect();
assert_ne!(titles[0], titles[1], "两档的标题 key 不许是同一个");
// 文案来自词表（不是硬编码中文）：英文目录下这两句必须不同且不含中文
let incompatible = Lang::En.catalog().text(titles[0]);
let unreachable = Lang::En.catalog().text(titles[1]);
assert_ne!(incompatible, unreachable);
assert!(incompatible.is_ascii(), "{incompatible}");
assert!(unreachable.is_ascii(), "{unreachable}");
// 按钮文字带条数，也来自词表
assert!(panel.action.contains('3'), "{}", panel.action);
assert!(panel.action.is_ascii(), "{}", panel.action);
}
/// 只有一档失败时只画一段（空组不出现——空的「取不到」标题会让用户以为那里也坏了）。
#[test]
fn an_empty_tier_does_not_get_a_group() {
let mut progress = InstallProgressView {
stage: InstallStage::Failed,
..InstallProgressView::new()
};
progress.retry = vec![InstallFailureView::new(
"P7dR8mSH",
"Entity Culling",
InstallFailureKind::Incompatible,
"没有匹配的版本",
)];
let panel = RetryPanel::of(&progress, Lang::En.catalog()).expect("有失败项就有面板");
assert!(!panel.has_both_tiers());
assert!(panel.items_of(InstallFailureKind::Unreachable).is_none());
}
/// **全成功时不渲染**：`Done` 且没有失败项 ⇒ 面板不存在（不是置灰，是连构造都没有）。
///
/// 变异守门③：把 `RetryPanel::of` 的判据去掉（恒返回 `Some`）⇒ 这条红。
#[test]
fn a_fully_successful_install_has_no_retry_surface_at_all() {
let done = InstallProgressView {
version: "Sodium".to_string(),
instance: "survival".to_string(),
stage: InstallStage::Done,
files_done: 4,
files_total: 4,
..InstallProgressView::new()
};
assert!(RetryPanel::of(&done, Lang::En.catalog()).is_none());
// 页面上也一样：状态是 Done ⇒ 页底那块既没有重试面板，也没有失败面板
let mut state = state_with(Some(results(vec![hit(&["1.20.1"], &["fabric"])], 0)), false);
state.install = Some(done);
let model = Content::from_snapshot(&state, &PageState::default(), Lang::En.catalog());
assert!(model.retry.is_none(), "全成功还在页面上画重试面板");
assert!(model.panel.is_none());
assert!(model.retry_install_request().is_none());
// 判据是**两半**：`Failed` **且** 名单非空。第一半单独钉住——就算快照里残留了名单
// （不该发生，host 成功时会清），`Done` 也不画（r1 复审指出：只去掉这一半曾全绿）。
let mut stale = InstallProgressView {
stage: InstallStage::Done,
..InstallProgressView::new()
};
stale.retry = failed_progress().retry;
assert!(
RetryPanel::of(&stale, Lang::En.catalog()).is_none(),
"Done 态不许画重试面板（判据是「失败且有名单」，不是「有名单」）"
);
// 第二半：失败但没有名单（例如整合包那条本地失败）同样不画：没有可重试的东西
let mut failed = InstallProgressView {
stage: InstallStage::Failed,
..InstallProgressView::new()
};
failed.retry.clear();
assert!(RetryPanel::of(&failed, Lang::En.catalog()).is_none());
}
/// 「只重试这些」发出去的是**失败那次的实例** + `retry: true`（不是页面此刻选中的实例，
/// 也不是一次新的根项目安装）。
#[test]
fn the_retry_action_targets_the_failed_attempt() {
let mut state = state_with(Some(results(vec![hit(&["1.20.1"], &["fabric"])], 0)), false);
// 名单要有，否则这块入口根本不存在
state.install = Some(failed_progress());
let model = Content::from_snapshot(&state, &PageState::default(), Lang::En.catalog());
assert!(model.retry.is_some());
let request = model.retry_install_request().expect("有面板就该有请求");
assert!(
request.retry,
"重试必须是 retry: true（否则 host 会从根解起）"
);
assert_eq!(request.instance, "survival");
}
crates/app-iced/src/pages/content/packui/demo.rs
+5 -3
View File
@@ -19,9 +19,10 @@ use std::path::PathBuf;
use unlucky_i18n::Lang;
use unlucky_presenter::dto::{
ConflictChoiceView, ConflictFileView, ConflictReasonView, ExportClassView, ExportFileView,
ExportPreviewView, ExportReasonView, ExportState, FileActionView, ImportErrorView,
ImportFailureStageView, ImportProgressView, ImportReportView, ImportStageView, ImportState,
ImportStatusView, InstanceId, LoaderKind, MissingFileView, MissingReasonView, PackFormatView,
ExportPreviewView, ExportReasonView, ExportState, FileActionView, ImportCancelView,
ImportErrorView, ImportFailureStageView, ImportProgressView, ImportReportView, ImportStageView,
ImportState, ImportStatusView, InstanceId, LoaderKind, MissingFileView, MissingReasonView,
PackFormatView,
};
use crate::pages::content::Target;
@@ -212,6 +213,7 @@ fn report(status: ImportStatusView, conflicts: bool) -> ImportReportView {
bytes_written: 3_400_000,
rolled_back: true,
failure_stage: None,
cancel: ImportCancelView::NotRequested,
};
if conflicts {
report.conflicts = vec![
crates/app-iced/src/pages/content/packui/model.rs
+2 -2
View File
@@ -196,8 +196,8 @@ pub struct Pack {
pub running: Option<Running>,
/// 探测失败诊断
pub probe: Option<Probe>,
/// 用户取消过这次导入：面板收回但**后台还在跑**（core 没有取消令牌），
/// 所以要把这句话留在界面上，别让用户以为「没建成」（复审 r1 P1-2）。
/// 用户点过取消、**结果还没回来**（面板已收回）。它只作占位：真实结局在
/// `report.cancel` 里（已回滚 / 回滚没做完 / 取消太晚），所以文案不许在这里替结局下结论。
pub cancelled: bool,
/// 取消提示的正文
pub cancelled_note: &'static str,
crates/app-iced/src/pages/content/packui/model/progress.rs
+2
View File
@@ -100,6 +100,8 @@ pub fn panel_progress(progress: &ImportProgressView) -> InstallProgressView {
eta_secs: 0,
// 整合包导入的失败不产生内容库分类（它有自己的报告视图）。
failure_kind: None,
// 导入没有「只重试这些」这条路径（重试整个导入由导入区自己管）。
retry: Vec::new(),
message: progress.current.clone().unwrap_or_default(),
}
}
crates/app-iced/src/pages/content/packui/model/report.rs
+22 -1
View File
@@ -14,7 +14,7 @@
use unlucky_i18n::{Catalog, Key};
use unlucky_presenter::dto::{
ConflictChoiceView, ConflictFileView, ConflictReasonView, ImportErrorView,
ConflictChoiceView, ConflictFileView, ConflictReasonView, ImportCancelView, ImportErrorView,
ImportFailureStageView, ImportReportView, ImportStatusView, MissingFileView, MissingReasonView,
};
@@ -124,6 +124,11 @@ pub struct Report {
pub can_overwrite: bool,
/// 「两者都留改名」为何不支持（有冲突时如实写）
pub overwrite_note: Option<String>,
/// 这次运行与取消的关系（M195 r3：标题与图标按它分档，不许一句打天下）
pub cancel: ImportCancelView,
/// 取消的**补充说明**：只有「取消太晚」有——那种情况标题照常是"已导入/部分成功"，
/// 必须另起一句说清"你的取消没赶上，实例会保留、同名文件可能已被覆盖"。
pub cancel_note: Option<String>,
}
impl Report {
@@ -202,6 +207,16 @@ pub(super) fn report_of(
&& page.instance.is_some(),
overwrite_note: (!report.conflicts.is_empty())
.then(|| catalog.text(Key::PackOverwriteNote).to_owned()),
cancel: report.cancel,
// 「取消太晚」那句只说给**真的跑完**的导入（复审 r3 P2-1）：推导那边已经保证
// `Failed` 不会落到 `TooLate`，这里再看一眼状态是双保险——万一推导回归，也不会让
// 红卡（"零残留"）与"已经跑完、文件可能被覆盖"同时出现在一屏上。
cancel_note: (report.cancel == ImportCancelView::TooLate
&& matches!(
report.status,
ImportStatusView::Success | ImportStatusView::Partial
))
.then(|| catalog.text(Key::PackCancelTooLate).to_owned()),
}
}
@@ -215,6 +230,12 @@ fn status_title(report: &ImportReportView, catalog: Catalog) -> &'static str {
match report.status {
ImportStatusView::Success => catalog.text(Key::PackStatusSuccess),
ImportStatusView::Partial => catalog.text(Key::PackStatusPartial),
// 三档取消各有各的话：已回滚（什么都没留下）/ 回滚没做完（要对一眼目录）/
// 取消太晚（标题是真实状态，另有一句 cancel_note 说明"没赶上"）。
ImportStatusView::Cancelled => match report.cancel {
ImportCancelView::RollbackIncomplete => catalog.text(Key::PackCancelIncomplete),
_ => catalog.text(Key::PackStatusCancelled),
},
ImportStatusView::Failed => match report.failure_stage {
Some(ImportFailureStageView::NotStarted) => {
catalog.text(Key::PackStatusFailedNotStarted)
crates/app-iced/src/pages/content/packui/model/tests.rs
+7 -20
View File
@@ -3,6 +3,7 @@
//! 这里**不测画法**（画法靠出图），测的是「决策」：哪些数字进了哪一行、哪些字段被截短、
//! 哪一态该出现哪一块。所有断言都能在没有图形环境的情况下跑。
mod cancel;
mod pick;
mod stage;
@@ -11,8 +12,9 @@ use std::path::PathBuf;
use unlucky_i18n::Lang;
use unlucky_presenter::dto::{
ConflictChoiceView, ConflictFileView, ConflictReasonView, ExportClassView, ExportFileView,
ExportPreviewView, ImportErrorView, ImportProgressView, ImportReportView, ImportStageView,
ImportStatusView, InstallStage, MissingFileView, MissingReasonView, PackFormatView,
ExportPreviewView, ImportCancelView, ImportErrorView, ImportProgressView, ImportReportView,
ImportStageView, ImportStatusView, InstallStage, MissingFileView, MissingReasonView,
PackFormatView,
};
use super::progress::{panel_progress, panel_stage, stage_line};
@@ -228,6 +230,7 @@ fn report_keeps_tolerable_and_fatal_apart() {
bytes_written: 0,
rolled_back: true,
failure_stage: None,
cancel: ImportCancelView::NotRequested,
};
let block = report_of(&report, &PackPageState::default(), catalog());
assert!(block.fatal.is_some(), "致命块必须单独存在");
@@ -265,6 +268,7 @@ fn conflicts_default_to_keeping_the_user_copy() {
bytes_written: 0,
rolled_back: true,
failure_stage: None,
cancel: ImportCancelView::NotRequested,
};
// 「以包为准」只在导入到**已有实例**时给（复审 r1 P2-2），所以这里选一个实例
let page = PackPageState {
@@ -363,6 +367,7 @@ fn overwrite_is_offered_only_when_importing_into_an_existing_instance() {
bytes_written: 0,
rolled_back: true,
failure_stage: None,
cancel: ImportCancelView::NotRequested,
};
let new_instance = PackPageState::default();
@@ -380,21 +385,3 @@ fn overwrite_is_offered_only_when_importing_into_an_existing_instance() {
"导入到已有实例时才给翻档动作"
);
}
#[test]
fn cancelled_state_is_visible_and_says_the_import_keeps_running() {
// 复审 r1 P1-2：面板收回之后，界面上必须留一句「后台还在跑」
let import = unlucky_presenter::dto::ImportState {
cancelled: true,
..unlucky_presenter::dto::ImportState::default()
};
let export = unlucky_presenter::dto::ExportState::default();
let model = Pack::of(&import, &export, &PackPageState::default(), &[], catalog());
assert!(model.cancelled);
assert!(
model.cancelled_note.to_lowercase().contains("background"),
"取消提示必须说清后台还在跑：{}",
model.cancelled_note
);
assert!(!model.is_idle(), "取消态不能被当成「什么都没有」");
}
crates/app-iced/src/pages/content/packui/model/tests/cancel.rs
+140
View File
@@ -0,0 +1,140 @@
//! 取消的**三档真实结局**在界面上的分支（M195 r3）。
//!
//! 口径：一句「已停手并回滚」打天下是假话——取消可能停在提交前（已回滚）、可能停在回滚没收尾
//! （目标目录可能变了）、也可能**太晚**（管线已经跑完，实例保留、同名文件可能已被覆盖）。
//! 这一族用例钉的就是"三档各说各的话"，以及"占位文案不再替结局下结论"。
use std::path::PathBuf;
use unlucky_i18n::{Catalog, Key, Lang};
use unlucky_presenter::dto::{
ImportCancelView, ImportReportView, ImportStatusView, PackFormatView,
};
use super::super::report::report_of;
use super::super::PackPageState;
fn catalog() -> Catalog {
Lang::En.catalog()
}
fn report(
status: ImportStatusView,
cancel: ImportCancelView,
rolled_back: bool,
) -> ImportReportView {
ImportReportView {
status,
format: Some(PackFormatView::Multimc),
pack_name: Some("Better MC".to_string()),
pack_version: None,
game_version: Some("1.20.1".to_string()),
loader: None,
version_id: Some("1.20.1".to_string()),
target: PathBuf::from("C:/tmp/instance"),
files: Vec::new(),
conflicts: Vec::new(),
missing: Vec::new(),
rejected: Vec::new(),
warnings: Vec::new(),
error: None,
registered: None,
bytes_written: 0,
rolled_back,
failure_stage: None,
cancel,
}
}
#[test]
fn a_rolled_back_cancel_says_it_is_cancelled_not_partially_installed() {
// 取消停在提交前：已回滚 ⇒ 标题是「已取消 —— 已回滚」，**不是**「部分成功」（那等于说装了一半），
// 也不能出现「取消太晚」那句补充说明。
let view = report(
ImportStatusView::Cancelled,
ImportCancelView::RolledBack,
true,
);
let block = report_of(&view, &PackPageState::default(), catalog());
assert_eq!(block.title, catalog().text(Key::PackStatusCancelled));
assert_ne!(
block.title,
catalog().text(Key::PackStatusPartial),
"已回滚的取消不许显示成「部分成功」"
);
assert!(!block.installed(), "取消不是「装上了」");
assert!(block.cancel_note.is_none(), "已回滚不需要「太晚」那句");
}
#[test]
fn an_incomplete_cancel_rollback_says_the_directory_may_differ() {
let view = report(
ImportStatusView::Cancelled,
ImportCancelView::RollbackIncomplete,
false,
);
let block = report_of(&view, &PackPageState::default(), catalog());
assert_eq!(block.title, catalog().text(Key::PackCancelIncomplete));
assert_ne!(
block.title,
catalog().text(Key::PackStatusCancelled),
"回滚没做完 ≠ 已回滚（这两句话不能混）"
);
}
#[test]
fn a_too_late_cancel_says_the_import_already_finished() {
// 取消来得太晚：状态是真实的 `Success`，另加一句「实例会保留、同名文件可能已被覆盖」。
let view = report(ImportStatusView::Success, ImportCancelView::TooLate, false);
let block = report_of(&view, &PackPageState::default(), catalog());
assert_eq!(block.title, catalog().text(Key::PackStatusSuccess));
assert_eq!(block.status, ImportStatusView::Success);
assert_ne!(
block.status,
ImportStatusView::Cancelled,
"太晚 ≠ 已回滚（状态是真的 Success/Partial）"
);
assert_eq!(
block.cancel_note,
Some(catalog().text(Key::PackCancelTooLate).to_owned()),
"必须另外说清「取消没赶上」"
);
}
/// 三档的标题**互不相同**（把任意两档并成一句，这里就红）。
#[test]
fn the_three_cancel_outcomes_have_three_different_titles() {
let titles = [
report_of(
&report(
ImportStatusView::Cancelled,
ImportCancelView::RolledBack,
true,
),
&PackPageState::default(),
catalog(),
)
.title,
report_of(
&report(
ImportStatusView::Cancelled,
ImportCancelView::RollbackIncomplete,
false,
),
&PackPageState::default(),
catalog(),
)
.title,
report_of(
&report(ImportStatusView::Success, ImportCancelView::TooLate, false),
&PackPageState::default(),
catalog(),
)
.title,
];
let unique: std::collections::BTreeSet<&String> = titles.iter().collect();
assert_eq!(unique.len(), 3, "三档必须各说各的话：{titles:?}");
}
crates/app-iced/src/pages/content/packui/model/tests/stage.rs
+2 -1
View File
@@ -3,7 +3,7 @@
//! 从 `tests.rs` 拆出（那边贴着 400 行硬线）：本文件只守「预检没过（一个字节都没写）」与
//! 「已回滚」的措辞/图标分野。夹具在父模块（`use super::*`）。
use unlucky_presenter::dto::ImportFailureStageView;
use unlucky_presenter::dto::{ImportCancelView, ImportFailureStageView};
use super::*;
@@ -39,6 +39,7 @@ fn the_two_failure_stages_never_share_one_sentence() {
bytes_written: 0,
rolled_back: true,
failure_stage: stage,
cancel: ImportCancelView::NotRequested,
}
}
crates/app-iced/src/pages/content/packui/view.rs
+2 -1
View File
@@ -98,7 +98,8 @@ pub(crate) fn section<'a>(
} else if let Some(report) = &model.report {
block = block.push(report_block(ui, catalog, report));
} else if model.cancelled {
// 取消过、还没有新结果：把「后台还在跑」这句话留在屏上（复审 r1 P1-2）
// 取消过、**结果还没回来**：先留一句"正在停手"的占位（真实结局随后的报告给出，
// 已回滚 / 回滚没做完 / 取消太晚三档见 `model::report`）
block = block.push(
column![
frame::text_role(
crates/app-iced/src/pages/content/packui/view/report.rs
+28 -6
View File
@@ -57,6 +57,14 @@ pub(super) fn report_block<'a>(
report.written_line.as_str(),
ui.color(Role::OnSurfaceVariant),
),
// 「取消太晚」的那句补充说明（标题仍是真实的 `已导入 / 部分成功`）。
frame::text_role(
ui,
TypeRole::BodySmall,
false,
report.cancel_note.as_deref().unwrap_or(""),
ui.color(Role::Tertiary),
),
]
.spacing(ui.space(Space::X1))
.width(Length::Fill);
@@ -292,17 +300,31 @@ pub(super) fn conflict_row<'a>(
}
pub(super) fn status_icon(report: &Report) -> IconKind {
use unlucky_presenter::dto::{ImportCancelView, ImportStatusView};
match report.status {
unlucky_presenter::dto::ImportStatusView::Success => IconKind::Check,
unlucky_presenter::dto::ImportStatusView::Partial => IconKind::Warn,
unlucky_presenter::dto::ImportStatusView::Failed => IconKind::Error,
ImportStatusView::Success => IconKind::Check,
ImportStatusView::Partial => IconKind::Warn,
ImportStatusView::Failed => IconKind::Error,
// 取消**不是错误**（M195）：停手用「关闭（叉）」这个描边字形（页面骨架只允许描边，
// 令牌层的 Play/Stop/More 是填充字形，见 `tests/no_hardcoded_tokens.rs` 的守门），
// 回滚没做完才升级成 Warn，都不上红。
ImportStatusView::Cancelled => match report.cancel {
ImportCancelView::RollbackIncomplete => IconKind::Warn,
_ => IconKind::Close,
},
}
}
pub(super) fn status_role(report: &Report) -> Role {
use unlucky_presenter::dto::{ImportCancelView, ImportStatusView};
match report.status {
unlucky_presenter::dto::ImportStatusView::Success => Role::Primary,
unlucky_presenter::dto::ImportStatusView::Partial => Role::Tertiary,
unlucky_presenter::dto::ImportStatusView::Failed => Role::Error,
ImportStatusView::Success => Role::Primary,
ImportStatusView::Partial => Role::Tertiary,
ImportStatusView::Failed => Role::Error,
// 取消一档也不做成 `Role::Error`：用户自己点的，不该看起来像装坏了。
ImportStatusView::Cancelled => match report.cancel {
ImportCancelView::RollbackIncomplete => Role::Tertiary,
_ => Role::OnSurfaceVariant,
},
}
}
crates/app-iced/src/pages/content/parts.rs
+2
View File
@@ -30,9 +30,11 @@ use super::model::{Content, Hit};
mod detail;
mod filters;
mod retry;
pub(crate) use detail::detail;
pub(crate) use filters::{filters, labelled};
pub(crate) use retry::maybe as retry_panel;
use super::Message as ContentMessage;
use crate::pages::frame;
crates/app-iced/src/pages/content/parts/retry.rs
+140
View File
@@ -0,0 +1,140 @@
//! 安装失败后的「只重试这些」面板（M191）。
//!
//! ## 为什么这块画在内容库，而不是复用下载页那块失败面板
//!
//! 下载页的失败面板讲的是「停在哪一步 + 打开日志」，而这里要讲的是**哪几项没装上、属于哪种
//! 没装上、以及能不能只重试它们**。两件事混在一个块里会得到「失败 + 一堆条目 + 两个关闭」。
//! 所以：有可重试名单时（[`RetryPanel::of`] 给了 `Some`）这块**顶替**通用失败面板，
//! 一屏只有一个失败块。
//!
//! ## 三个控件行为
//!
//! | 控件 | 消息 | 落点 |
//! |---|---|---|
//! | 只重试这 N 个 | [`ContentMessage::RetryFailed`] | `AppCommand::InstallContent{retry: true}`（host 只重解失败项） |
//! | 关闭 | [`PageMessage::CancelInstall`] | 清 install 快照（对没在跑的安装是安全 no-op，与下载页同一个出口） |
//!
//! 两个按钮都**按不动就不画**：没有名单时整块不存在（不是画一个灰按钮）。
use iced::widget::{column, container, row};
use iced::{Alignment, Background, Border, Element, Length};
use unlucky_design::color::Role;
use unlucky_design::icons::IconKind;
use unlucky_design::shape::ShapeScale;
use unlucky_design::spacing::Space;
use unlucky_design::typography::TypeRole;
use unlucky_i18n::{Catalog, Key};
use crate::app::components::buttons::{self, Button};
use crate::theme::Ui;
use super::super::model::{Content, RetryPanel};
use super::intent;
use crate::pages::content::Message as ContentMessage;
use crate::pages::frame;
use crate::pages::Message as PageMessage;
/// 整块面板（`model.retry` 为 `None` 时调用方不该调它——判据在模型里，不在这里）。
pub(crate) fn retry_panel<'a>(
ui: &'a Ui,
catalog: Catalog,
panel: &'a RetryPanel,
) -> Element<'a, PageMessage> {
let head = row![
frame::glyph(IconKind::Error, ui.color(Role::Error), frame::ICON_PX),
frame::text_role(
ui,
TypeRole::TitleSmall,
true,
panel.title.as_str(),
ui.color(Role::Error),
),
]
.spacing(ui.space(Space::X2))
.align_y(Alignment::Center);
let mut body = column![head]
.spacing(ui.space(Space::X2))
.width(Length::Fill);
// 两档分成两段：**各自的标题 + 各自的条目**（合并成一段就说不出「换版本还是检查网络」）。
// 条目之间用 ASCII 逗号：项目键是站点数据，句读不是文案，不该在这里挑中文的「、」。
for group in &panel.groups {
let items = group.items.join(", ");
body = body.push(
column![
frame::text_role(
ui,
TypeRole::LabelMedium,
true,
catalog.text(group.title),
ui.color(Role::OnErrorContainer),
),
frame::text_role_owned(
ui,
TypeRole::BodySmall,
false,
items,
ui.color(Role::OnErrorContainer),
),
]
.spacing(ui.space(Space::X1)),
);
}
body = body.push(frame::text_role(
ui,
TypeRole::BodySmall,
false,
catalog.text(Key::ContentInstallRetryHint),
ui.color(Role::OnErrorContainer),
));
let actions = row![
// 主按钮：只重试这些（这个块存在的**唯一**理由）
buttons::filled(
ui,
Button::new(panel.action.as_str(), intent(ContentMessage::RetryFailed))
.leading(IconKind::Refresh),
),
buttons::text(
ui,
// 复用下载页那条现有的「关闭」：同一句话不另立一条要同步的 key（r1 复审 N2）
Button::new(
catalog.text(Key::DownloadDismiss),
PageMessage::CancelInstall
),
),
]
.spacing(ui.space(Space::X2))
.align_y(Alignment::Center);
body = body.push(actions);
container(body)
.width(Length::Fill)
.padding(ui.space(Space::X4))
.style(move |_theme| container::Style {
background: Some(Background::Color(ui.color(Role::ErrorContainer))),
border: Border {
radius: ui.radius_dp(ShapeScale::Large),
..Border::default()
},
..container::Style::default()
})
.into()
}
/// 整页底部那块（判据在 [`Content::retry`]；`None` ⇒ 一帧都不画）。
pub(crate) fn maybe<'a>(
ui: &'a Ui,
catalog: Catalog,
model: &'a Content,
) -> Option<Element<'a, PageMessage>> {
model
.retry
.as_ref()
.map(|panel| retry_panel(ui, catalog, panel))
}
crates/app-iced/src/pages/content/tests.rs
+13
View File
@@ -85,3 +85,16 @@ fn the_demo_selection_is_always_one_of_the_hits() {
);
}
}
/// M191：「全部成功」那一屏（默认态）**没有**重试面板——出图与判据同源，不是手搓的。
#[test]
fn the_default_demo_screen_has_no_retry_surface() {
for kind in ContentKind::ALL {
let model = demo(kind, Lang::En);
assert!(
model.retry.is_none(),
"{} 默认态不该有重试面板",
kind.slug()
);
}
}
crates/app-iced/src/pages/content/view.rs
+6 -1
View File
@@ -98,7 +98,12 @@ fn body<'a>(
.spacing(ui.space(Space::X3))
.width(Length::Fill)
.height(Length::Fill);
if let Some(panel) = &model.panel {
// M191：有可重试的失败项时，这块**顶替**下载页那块通用失败面板（一屏只有一个失败块）；
// 没有名单时它连构造都不存在（`None`），不是画一个灰按钮。
let retry = parts::retry_panel(ui, catalog, model);
if let Some(panel) = retry {
stack = stack.push(divider::full(ui)).push(panel);
} else if let Some(panel) = &model.panel {
// **同一块安装面板**（下载页那个函数）：内容库不另画一套进度/失败/取消。
stack = stack
.push(divider::full(ui))
crates/app-iced/src/pages/download/demo.rs
+2
View File
@@ -297,6 +297,8 @@ fn install(stage: InstallStage, ratio: f32, catalog: Catalog) -> InstallView {
message: String::new(),
// 演示里这次失败不是内容库那条路来的，不给分类（面板照旧画「失败 + 文案」）。
failure_kind: None,
// 同理：没有失败名单 ⇒ 内容库那块「只重试这些」不出现（下载页也不画它）。
retry: Vec::new(),
},
catalog,
)
crates/app-iced/src/pages/mod.rs
+9 -3
View File
@@ -143,6 +143,7 @@ use iced::{Element, Length};
use unlucky_design::elevation::MaterialLayer;
use unlucky_design::spacing::Space;
use crate::app::components::motion;
use crate::theme::Ui;
use frame::filled;
@@ -243,14 +244,19 @@ fn render<'a>(
// M159：自更新提示条挂在**每一页**的页头之上（有新版 / 正在下载 / 已就位时才出现）。
// 为什么在这里而不是外壳里：外壳（`shell`）只认窗口装饰与导航，页面层才能按快照决定画什么；
// 而「每一页都要能看见」这条要求又决定了它不能只挂在实例页上。
match update::banner(ui, &model.update, model.lang.catalog()) {
let tree: Element<'a, Message> = match update::banner(ui, &model.update, model.lang.catalog()) {
Some(banner) => column![banner, page]
.spacing(ui.space(Space::X3))
.width(Length::Fill)
.height(Length::Fill)
.into(),
None => page,
}
};
// M192：主体入场（首屏 / 换页 / 列表↔详情）。**这里只采样**——「标识变了就起跑」在 update 侧
// （`App::sync_motion`）：iced 先算订阅表后建视图，在 view 里插轨道当拍订阅不上（复审 P1-1）。
// 静息时位移恒为 `(0, 0)`，`shifted` 常驻的那一层零内距，与没有动效时逐像素相同。
motion::shifted(tree, motion::sample())
}
/// 整窗（**harness 专用**）：标题栏留白带 + 导航轨 + 当前路由的页面。
@@ -268,7 +274,7 @@ pub fn app<'a>(
/// 同 [`app`]，但可以带上**外观运行期状态**。
///
/// `Some(state)` ⇒ 设置页「外观」分组画**真控件**（`pages/appearance/section.rs`）；
/// `Some(state)` ⇒ 设置页「外观」分组画**真控件**（`pages/appearance/section/`）；
/// `None` ⇒ 画演示行，与 [`app`] 逐像素等价。harness 的 `--appearance=real` 走的就是这一支：
/// M100 之前 harness 恒传 `None`，于是 D30 要的「带真实外观控件」那一屏**根本不存在**——
/// 报告上写着「设置页已接真控件」，图里却只有演示行（U1 的形状）。
crates/app-iced/src/pages/settings/ai_about.rs
+5 -4
View File
@@ -5,15 +5,16 @@
//! | 这里 | 内容 |
//! |---|---|
//! | [`GROUP`] | 左列名 / 图标 / 演示行（产品路径走 [`super::ai::view::body`]） |
//! | [`AI_GROUP`] | 本组在 `GROUPS` 里的下标（与 General / Update 同一条**按下标分发**：本组要 i18n 文案与 `Lang` 形参，`Group.body` 的签名里没有它） |
//! | [`AI_GROUP`] | 本组在 `GROUPS` 里的下标（与 General / Update 同一条**按下标分发**：本组尚未迁到 `Group.body` 槽位，见下节） |
//! | [`Message`] | 本线的消息口（落点 `app/update/settings/ai_about.rs`） |
//! | [`State`] | 转发 `ai::State`（`Groups.ai_about` 的载荷类型不变，`settings/state.rs` 一行不用改） |
//!
//! ## 为什么 `body` 是 `None` 而不是 `Some(..)`
//!
//! `Group.body` 的签名是 `fn(&Ui, States) -> Option<Element>`：拿不到 `Lang`，也就画不出中英两套
//! 文案（本组的硬要求是「不得硬编码中文」）。M106 的语言行与 M159 的更新组是同一个理由走了
//! 按下标分发；本组沿用同一条路，代价是 `settings/mod.rs` 里多一行 `else if`。
//! `Group.body` 的槽位（M179 起）拿的是 [`States`](super::States) 与**生效语言** `Lang`——本组要的
//! 两件它其实都装得下。本组仍走按下标分发，是因为**还没迁过去**：槽位要求返回 `Option<Element>`，
//! 而 `ai::view::body` 返回 `Element`，把本组（以及 Java 组）统一迁到槽位上是一次独立重构。
//! M106 的语言行与 M159 的更新组当初也是同一个理由走上这条路，代价是 `settings/mod.rs` 多一行 `else if`。
//!
//! ## 密钥纪律
//!
crates/app-iced/src/pages/settings/appearance.rs
+11 -4
View File
@@ -5,20 +5,25 @@
//! 「Appearance」这个名字**；分组在左列的下标仍由 `crate::pages::appearance::APPEARANCE_GROUP`
//! 声明，`settings/tests/mod.rs` 拿它和本文件比对（顺序被调换会红）。
//!
//! **这一组归 language+appearance 线**：真控件的实现全在 `pages/appearance/section.rs`（本文件只负责
//! **这一组归 language+appearance 线**：真控件的实现全在 `pages/appearance/section/`（本文件只负责
//! 把它挂进注册表），所以改控件时不用碰设置页目录。
//!
//! M101 r2：本组的渲染器签名改成收 [`States`]（组状态 + 外观状态），于是「这一组要读哪些状态」
//! 由本文件决定——`settings/mod.rs` 不再认识 `appearance::State`。
//!
//! M179 `I18NSEAM`：签名再加一个 `lang`（`Group.body` 的槽位本身就带语言，见 `settings/mod.rs` 的
//! `Body` 类型别名），于是这一组的中文界面文案真的走词表——此前它只能写死 `Lang::En`，
//! 因为渲染器拿不到「这一次生效的语言」。
use iced::Element;
use unlucky_design::icons::IconKind;
use unlucky_i18n::Lang;
use crate::theme::Ui;
use super::{Group, Message, States};
/// Appearance 分组。`body` 指着 [`body`]（它再转给 `pages/appearance/section.rs` 的真控件）；
/// Appearance 分组。`body` 指着 [`body`]（它再转给 `pages/appearance/section/` 的真控件）；
/// 没有外观运行期状态时（harness / `pages_demo`）返回 `None`，由 `form` 退回下面的演示行。
pub(super) const GROUP: Group = Group {
name: "Appearance",
@@ -33,8 +38,10 @@ pub(super) const GROUP: Group = Group {
};
/// 本组的真控件渲染器：有外观状态就画真控件（M93），没有（harness）返回 `None`。
fn body<'a>(ui: &'a Ui, states: States<'a>) -> Option<Element<'a, Message>> {
///
/// `lang` 一路递给 `pages::appearance::section`——它是这一组唯一知道「界面现在是什么语言」的东西。
fn body<'a>(ui: &'a Ui, states: States<'a>, lang: Lang) -> Option<Element<'a, Message>> {
states
.appearance
.map(|state| crate::pages::appearance::section(ui, state))
.map(|state| crate::pages::appearance::section(ui, state, lang))
}
crates/app-iced/src/pages/settings/download.rs
+23 -4
View File
@@ -1,9 +1,25 @@
//! 设置页「Downloads」分组：首选源 / 并发数 / 校验（演示行）。
//! 设置页「Downloads」分组：并发 / 单源尝试次数 / GitHub 加速前缀（M193）。
//!
//! **这一组归 download 线**：接真控件时在本文件把 `body` 换成 `Some(download::body)`（渲染器也写在本文件），
//! `settings/mod.rs` 的注册表不用动。
//!
//! 注意与下载页（`pages/download*`）的区别：那是「装哪个版本」，这里是「怎么下」的默认值。
//!
//! ## 为什么这三行是「说语义」而不是「说当前值」（M193）
//!
//! 原来这三行是**写死的演示值**（`("Concurrency", "8 threads")` / `("Preferred source",
//! "Automatic (region)")` / `("Verify checksums", "On")`）。用户实测把它们当成真值投诉过
//! （「它默认显示 8，可我改成 2 也没变」）——因为 iced 侧**根本没有设置数据通路**：
//! `pages::Model` 没有设置快照、`grep -rn "SettingsChanged" crates/app-iced/src` 零命中、
//! [`State`] 是个空 struct 且无人填。而这三行里「8 threads」当时还是**假的**：引擎真值曾是 64
//! （schema 说 8），「Verify checksums」更是没有任何校验开关（校验恒开）。
//!
//! 所以这一轮把假值换成**不会撒谎的语义行**：区间、默认值、「留空 / off / 前缀」三态各是什么。
//! 真值（用户在 `launcher.json` 里填的那个数）不在这里显示——**宁可不说，也不说假的**。
//! 真正的可改控件要等一条 presenter 快照 → app → `Groups.download` 的数据通路，另立 mission。
//!
//! **生效保证**：这三条设置真的会被引擎读走（`core::download::shared::set_tuning`，宿主侧
//! 翻译在 `presenter::host::settings`），所以「行里的语义」与「引擎行为」是同一份契约。
use unlucky_design::icons::IconKind;
@@ -14,9 +30,11 @@ pub(super) const GROUP: Group = Group {
name: "Downloads",
icon: IconKind::Download,
rows: &[
("Preferred source", "Automatic (region)"),
("Concurrency", "8 threads"),
("Verify checksums", "On"),
("并发数", "出厂 8 · 可调 1~64"),
("单源尝试次数", "出厂 3 · 含首次 · 0/1 = 只试一次"),
("GitHub 加速前缀", "留空 = 跟随内置默认"),
("关掉它", "填 off = 关闭"),
("换掉它", "填 URL 前缀 = 覆盖"),
],
body: None,
};
@@ -24,6 +42,7 @@ pub(super) const GROUP: Group = Group {
/// Downloads 分组的运行期状态（M101 r2：**只归 download 线**）。
///
/// 加字段只改本文件：`Groups` 只认 `Groups.download` 这一个字段。
/// 现在仍然是空的——真值的数据通路还没接（见文件头「为什么这三行是说语义」）。
#[derive(Debug, Default)]
pub struct State {}
crates/app-iced/src/pages/settings/frame.rs
+136 -24
View File
@@ -1,4 +1,4 @@
//! 设置页骨架：页头、左列分组导航、表单列的滚动区、演示卡片、空态位。
//! 设置页骨架：页头、左列分组导航、表单列的滚动区、演示卡片。
//!
//! ## 为什么这里还再导出一批 `pages::frame` 的名字
//!
@@ -8,8 +8,8 @@
//! 这不是新 API，只是一条转发（新增控件仍归 [`crate::pages::frame`]）。
pub(super) use super::super::frame::{
card, divider, empty_state, glyph_box, left_aligned, page, panes, scroll_style, single_column,
text_action, text_role, Header, ICON_PX, SCROLLBAR_MARGIN, SCROLLBAR_WIDTH,
card, divider, glyph_box, left_aligned, page, panes, scroll_style, single_column, text_action,
text_role, Header, ICON_PX, SCROLLBAR_MARGIN, SCROLLBAR_WIDTH,
};
use iced::widget::{column, container, mouse_area, row};
@@ -18,7 +18,6 @@ use iced::{Alignment, Background, Border, Element, Length, Padding, Theme};
use unlucky_design::color::Role;
use unlucky_design::component_map::Component;
use unlucky_design::elevation::MaterialLayer;
use unlucky_design::icons::IconKind;
use unlucky_design::shape::ShapeScale;
use unlucky_design::spacing::Space;
use unlucky_design::typography::TypeRole;
@@ -30,9 +29,6 @@ use crate::theme::Ui;
use super::Group;
/// 空态位高度：给图标块 96 + 标题 + 副文案 + 按钮留够空间（`[估]`，按 12b §15 的元素最小高度累加）。
const EMPTY_SLOT_HEIGHT: f32 = 320.0;
/// 页头：标题 + 副标题 + 两个占位动作。
///
/// M106：三条文案走 catalog（`lang` 由 `settings::view` 传下来）。页标题复用 `NavSettings`——
@@ -218,21 +214,137 @@ fn setting_row<'a>(ui: &'a Ui, label: &'a str, value: &'a str) -> Element<'a, Me
.into()
}
/// 空态位：没有逐实例覆盖时的样子（12b §15 的口径）。
pub(super) fn overrides_empty<'a>(ui: &'a Ui, lang: Lang) -> Element<'a, Message> {
let catalog = lang.catalog();
container(empty_state(
ui,
IconKind::Instances,
catalog.text(Key::SettingsOverridesEmptyTitle),
catalog.text(Key::SettingsOverridesEmptyBody),
vec![text_action(
ui,
catalog.text(Key::SettingsOverridesAdd),
Action::AddOverride,
)],
))
.width(Length::Fill)
.height(Length::Fixed(EMPTY_SLOT_HEIGHT))
.into()
// --------------------------------------------------------------- M196 守门
/// M196：设置页正文**不许**在最后一组之后挂一张空态卡。
///
/// ## 守的是哪一件事
///
/// 用户 2026-11-08 在 M174 的助手页与 M175 的 Java 页都看到同一张不属于本页的空态卡（四格图标 +
/// 「没有逐实例覆盖」+ 说明被窗口下沿截断），两张图 1180×1100、卡片位置完全一致。根因是
/// `settings/mod.rs` 的 `form()` 在分组循环之后**无条件**叠了一件固定 320dp 高的空态位
/// （M84 骨架期的占位，M99 纯搬移时原样留下）——于是任何一组下面都长出同一张卡。
///
/// ## 两条判据怎么合起来咬死它
///
/// 正文由两半拼成：`mod.rs` 的 [`section_columns`](super::section_columns) **生产**「每组一件」的列，
/// `form` 只把它们堆起来再滚出去。于是：
///
/// - [`the_form_stops_at_its_last_group`] 守**收尾**：`form()` 里 `stack = stack.push(` 恰好一处、
/// 且以 `frame::scroll(ui, stack)` 收尾 —— 尾部多一件、或整段换成别的拼装（push 数变 0）都红；
/// - [`the_form_holds_exactly_one_column_per_group`] 守**生产**：真调 `section_columns` 数它交出的
/// 列数（窄窗 == `GROUPS.len()`，单选各组 == 1）—— 多塞一件就红，**不管那件叫什么名字**。
///
/// 两半合起来 = 「正文恰好这些列，没有尾巴」。
///
/// ## 为什么住在 `frame.rs` 而不是 `pages/settings/tests/`
///
/// `tests/` 归四条 section 线所有（各改各的），而这里守的是**本文件与 `mod.rs` 之间的分工**：
/// 壳层不提供空态位、分发点不在尾部多堆一件。判据要是哪天挪进 `tests/`，也请原样保留这两条。
///
/// ## 抓得住 / 抓不住（据实写）
///
/// 抓得住（三种变异都实测过）：①按原样把卡加回循环之后（`stack = stack.push(...)`）⇒ 收尾那条红；
/// ②改成「塞进列清单」（`section_columns` 里多 push 一件）⇒ 列数那条红，换任何名字都躲不掉；
/// ③把拼装整段重写成别的形状（不再用上面那个惯用法）⇒ 收尾那条数的 1 变成 0，同样红。
/// 抓不住：**某一组自己的列里**换内容（比如某个分组真的需要自己的空态）。那不是本缺陷——本页允许
/// 组内有空态，前提是它长在该组的列里、用本页语义的文案。`DevDocs/artifacts/m196/` 那组图是**当时**
/// 的证据，不是将来的防线（静态图只能证明「现在没有」）。
#[cfg(test)]
mod no_stray_empty_state {
use unlucky_design::color::SchemeFlavor;
use unlucky_design::typography::Platform;
use crate::pages::update::Update;
use crate::theme::{Families, Ui};
use super::super::{demo_groups, section_columns, Language, States, GROUPS};
/// 设置页的分发点（本文件是它的被调用方）。
const FORM: &str = include_str!("mod.rs");
const FAMILIES: Families = Families {
text: "Segoe UI",
display: "Segoe UI",
mono: "Consolas",
};
/// `form()` 的函数体：从它的签名取到下一个函数（`section_columns`）的签名之前。
///
/// 只取 `form` 自己：`section_columns` 里面有 `columns.push(`，那是另一条判据管的事。
fn form_body() -> &'static str {
let start = FORM
.find("fn form<'a>(")
.expect("settings/mod.rs 里找不到 form()：分发点被改名了，本守门要跟着改");
let rest = &FORM[start..];
let end = rest
.find("\nfn section_columns")
.expect("settings/mod.rs 里找不到 section_columns()：列生产被改名了，本守门要跟着改");
&rest[..end]
}
fn ui() -> Ui {
Ui::with_platform(SchemeFlavor::Light, Platform::Windows, FAMILIES)
}
/// 演示 / harness 路径那份只读状态（与 `pages::page` 同源，不伪造第二份）。
fn states() -> States<'static> {
States {
appearance: None,
groups: demo_groups(),
}
}
/// 判据 ①（**收尾**）：循环之后没有任何额外的 `push`，且函数以滚出去收尾。
///
/// 循环体里只有一件（一组一列），所以「`stack = stack.push(` 恰好一次」等于「尾部空着」；
/// 拼装被整段重写成别的形状时计数变 0，同样红。
#[test]
fn the_form_stops_at_its_last_group() {
let body = form_body();
let pushes = body.matches("stack = stack.push(").count();
assert_eq!(
pushes, 1,
"`form()` 里出现了 {pushes} 处 `stack = stack.push(`：分组循环里只该有一处。\
尾部又被叠了一件东西的话，设置页每一组下面都会多出同一件（M196 那张\
「没有逐实例覆盖」的卡就是这么来的）"
);
assert!(
body.contains(" frame::scroll(ui, stack)\n}"),
"`form()` 必须以 `frame::scroll(ui, stack)` 收尾（后面紧跟函数右花括号）：\
正文到最后一组就结束，别再往后叠东西"
);
}
/// 判据 ②（**生产**）：真跑 `section_columns`，量它到底交出几列。
///
/// 这是行为断言：调的是产品路径上那个真函数，**不认任何名字**。谁往正文里多塞一件（M196 那张
/// 「没有逐实例覆盖」的卡当初就是这么塞的），列数就不等于组数。
///
/// 为什么不走 `tests/scroll_fit.rs` 那条「`()` 渲染器真跑布局」的路：`form` / `section_columns`
/// 交出的是**产品渲染器**的 `Element`，要按那条路量子节点数，得把 `general` / `update` / `ai`
/// 三条线的 `body` 一并泛型化（它们不在本 mission 的 scope 内）。量列数拿到的是同一个不变量，
/// 且不需要泛型。
#[test]
fn the_form_holds_exactly_one_column_per_group() {
let ui = ui();
let update = Update::default();
let narrow = section_columns(&ui, None, states(), Language::default(), &update);
assert_eq!(
narrow.len(),
GROUPS.len(),
"窄窗（按组堆叠）的正文应当是「每组一件」：多出来的那一件就是 M196 那张卡的位置"
);
for index in 0..GROUPS.len() {
let single = section_columns(&ui, Some(index), states(), Language::default(), &update);
assert_eq!(
single.len(),
1,
"supporting-pane 只该画被选中的那一组（下标 {index}），实际拿到 {} 列",
single.len()
);
}
}
}
crates/app-iced/src/pages/settings/general.rs
+11 -5
View File
@@ -4,10 +4,11 @@
//!
//! ## 这一组为什么特殊
//!
//! 它**不走** `Group::body`：那个渲染器的签名是 `fn(&Ui, States) -> Option<Element>`，`States` 只有
//! `appearance` + `groups` 两格，装不下「当前语言档位 + 生效语言」。语言行要的两件在
//! `pages::Language` 里，由 `pages::settings::view` 的 `language` 形参一路递进来、`form` 按下标
//! 转交 [`body`]；所以 `GROUP.body` 仍是 `None`，`tests/mod.rs` 那条「只有外观组带真控件」照样成立。
//! 它**不走** `Group::body`：那个渲染器拿的是 [`States`](super::States) 与**生效语言** `Lang`
//! （M179 起；此前连 `Lang` 都没有），而语言行要的是「当前语言**档位** `LangChoice` + 生效语言」
//! 这一对——档位不在 `States` 里。所以它由 `pages::settings::view` 的 `language` 形参一路递进来、
//! `form` 按下标转交 [`body`]；`GROUP.body` 仍是 `None`，`tests/mod.rs` 那条「只有外观组带真控件」
//! 照样成立。
//!
//! ## 语言切换**没有**走 M101 的 `GroupMessage` 投递口（偏离，已登记）
//!
@@ -77,6 +78,11 @@ pub(super) fn body<'a>(ui: &'a Ui, language: Language) -> Element<'a, Message> {
stacked = stacked.push(divider(ui));
stacked = stacked.push(font_row(ui, language));
// M188：日志文件夹（路径 + 打开 + 复制路径）。放在「主题/启动页」之前——用户投诉
// 「找不到崩溃日志」要的答案，不该埋在只读行后面。
stacked = stacked.push(divider(ui));
stacked = stacked.push(super::logs_row::folder_row(ui, &catalog));
// 主题 / 启动页 / 关闭按钮：还没有后端，只读；文案已经进 catalog。
for (label, value) in [
(Key::SettingsTheme, Key::SettingsThemeFollowSystem),
@@ -284,7 +290,7 @@ fn setting_row<'a>(ui: &'a Ui, label: &'a str, value: &'a str) -> Element<'a, Me
/// 一个互斥按钮（选中态 `SecondaryContainer`，未选中透明 + `OnSurfaceVariant`）。
///
/// 与 `pages/appearance/section.rs` 的 `choice` 同款，但文案来自 catalog（那份是英文基线）。
/// 与 `pages/appearance/section/mod.rs` 的 `choice` 同款，但文案来自 catalog（那份是英文基线）。
fn chip<'a>(ui: &'a Ui, text: &'a str, selected: bool, choice: LangChoice) -> Element<'a, Message> {
let height = ui.metrics().control_height;
let content_color = if selected {
crates/app-iced/src/pages/settings/java.rs
+67 -27
View File
@@ -1,44 +1,84 @@
//! 设置页「Java」分组：运行时 / 默认内存 / JVM 参数（演示行）。
//! 设置页「Java」分组（M175）：运行时列表 / 默认 JDK / 内存 / JVM 参数。
//!
//! **这一组归 java 线**：接真控件时在本文件把 `body` 换成 `Some(java::body)`（渲染器也写在本文件），
//! 再把 `rows` 换成真数据源给的文本；`settings/mod.rs` 的注册表不用动。
//! 本文件只剩三样东西，正文 / 状态 / 读写都在 `pages/settings/java/` 里：
//!
//! 图标说明（视觉复审 P2-3）：令牌里 `Play` 是填充字形，和同屏其它描边图标语汇打架；
//! Java 分组讲的是运行时安装位置，用目录图标语义也对得上。
//! | 这里 | 内容 |
//! |---|---|
//! | [`GROUP`] | 左列名 / 图标（正文走 [`view::body`]，`body` 槽位保持 `None`） |
//! | [`JAVA_GROUP`] | 本组在 `GROUPS` 里的下标（与 General / Update / Assistant 同一条**按下标分发**：本组要 `Lang`，`Group.body` 的签名里没有它） |
//! | [`Message`] | 本线的消息口（落点 `app/update/settings/java.rs`） |
//!
//! ## M101 的演示行去哪了
//!
//! M101 留的 `rows: &[("Runtime","Temurin 21.0.4"), …]` 与绊线测试
//! `the_java_group_is_still_demo_rows`（断言 `body.is_none()`）在 M175 一起删掉了：
//! 那三个值是**写死的演示字符串**，用户实测把它们当成了真检测结果
//! （「它默认显示 Temurin 21.0.4 我甚至不能确定它是否是一个硬编码的值」）。
//! 现在的真值来自三段真读盘：`core::game::java::staged`（扫描）、`core::game::java::manual`
//! （手动路径严格探测）、`config/launcher.json`（`java.*` 三键）。
//!
//! `rows` 仍留成空切片：它是 `Group` 的字段（另外五组在用），而本组的 `body` 分发永远命中
//! [`view::body`]，空切片不会被画出来——宁可空着，也不留一句会撒谎的演示值。
mod fields;
mod row;
mod seed;
mod state;
pub(crate) mod store;
pub(super) mod view;
#[cfg(test)]
mod tests;
pub use state::{same_path, Context, Layer, Notice, Requirement, State};
/// 测试里的注入作业要写 `Vec<RuntimeRow>`（App 层在生产路径上只用 `State`，不需要这个名字）。
#[cfg(test)]
pub use row::RuntimeRow;
use unlucky_design::icons::IconKind;
use super::Group;
/// 本组在 [`super::GROUPS`] 里的下标（`GROUPS` 的顺序是 general / appearance / **java** / …）。
///
/// 写死 2 与 `groups[2]` 同一个来源：`tests/mod.rs` 的「左列顺序」把这张表钉住了。
pub(crate) const JAVA_GROUP: usize = 2;
/// Java 分组。
pub(super) const GROUP: Group = Group {
name: "Java",
icon: IconKind::Folder,
rows: &[
("Runtime", "Temurin 21.0.4"),
("Default memory", "4 GiB"),
("JVM arguments", "Automatic"),
],
// 空：产品路径与窄窗「按组堆叠」都走 `view::body`（见文件头「M101 的演示行去哪了」）。
rows: &[],
body: None,
};
/// Java 分组的运行期状态（M101 r2：**只归 java 线**）。
///
/// 加字段只改本文件：`Groups` 只认 `Groups.java`（一个字段），不认这个类型里的任何字段，
/// 所以 `settings/mod.rs` / `app/state.rs` / `app/view.rs` 都不用动。
#[derive(Debug, Default)]
pub struct State {}
/// Java 分组的消息（M101：**只归 java 线**，加变体只改本文件）。
///
/// 落点是 `app/update/settings/java.rs`；`pages/mod.rs` 与 `page_messages.rs` 都不用动（它们只认
/// [`GroupMessage`](super::GroupMessage)）。
/// 本线的消息（**只归本线**）：加变体只改本文件 + `app/update/settings/java.rs`。
#[derive(Debug, Clone)]
pub enum Message {
/// **只有测试构造它**：M101 r2 留的「活的端到端证据」——外壳消息 →
/// `on_page` → `on_settings` → `on_settings_java` 这条路在运行时真的跑通，不是只靠编译期穷尽。
/// java 线接第一个真控件时把这一支换成真变体：`tests/java_section.rs` 的
/// `the_java_group_is_still_demo_rows` 就是那条会提醒你的绊线（它断言 `body.is_none()`）。
#[cfg(test)]
Ping,
/// 手动触发一次自动扫描（真扫盘，后台线程；进度与结果由心跳灌回来）
Scan,
/// 取消正在跑的扫描
CancelScan,
/// 手动路径输入框
AddDraft(String),
/// 提交手动添加（严格校验：真跑 `java -version`）
Add,
/// 把某个运行时设为默认（写 `java.selected_path`）
SelectRuntime(String),
/// 默认内存草稿（MB 文本）
EditMemory(String),
/// JVM 额外参数草稿
EditJvm(String),
/// 保存内存 + JVM 参数（校验 + 落盘 + 回读）
Save,
}
impl Message {
/// 一条本组消息 → 设置页的投递口（`pages::settings::GroupMessage::Java`）。
#[must_use]
pub fn into_group(self) -> super::GroupMessage {
super::GroupMessage::Java(self)
}
}
crates/app-iced/src/pages/settings/java/fields.rs
+246
View File
@@ -0,0 +1,246 @@
//! 「Java」分组的**编辑区**（M175）：手动路径 / 默认内存 / JVM 参数 / 保存与回执。
//!
//! 从 `view.rs` 拆出来的（那个文件加了守卫之后贴到 438 行，越过 400 行硬线）：这里全是
//! 「用户能改的东西」，`view.rs` 只剩「扫到了什么」与版面。两半共用 `view::msg` 这一个消息口，
//! 所以「一条控件对应哪条消息」不会各写一遍。
use iced::widget::{column, container, row};
use iced::{Alignment, Element, Length};
use unlucky_design::color::Role;
use unlucky_design::spacing::Space;
use unlucky_design::typography::TypeRole;
use unlucky_i18n::{Catalog, Key};
use crate::app::components::buttons::{self, Button};
use crate::app::components::inputs::{text_field, Field, FieldVariant};
use crate::pages::frame::text_role_owned;
use crate::pages::Message;
use crate::theme::Ui;
use super::state::{Layer, Notice, Refusal, State, MAX_MEMORY_MB, MIN_MEMORY_MB};
use super::view::msg;
use super::Message as JavaMessage;
/// 手动添加一行：输入框 + 「添加」按钮 + 原因。
pub(super) fn add_row<'a>(ui: &'a Ui, catalog: Catalog, state: &'a State) -> Element<'a, Message> {
let field = Field::new(&state.add_draft)
.variant(FieldVariant::Outlined)
.label(catalog.text(Key::SettingsJavaAdd))
.placeholder(catalog.text(Key::SettingsJavaAddPlaceholder))
.supporting(catalog.text(Key::SettingsJavaAddHint));
let add = if state.add_draft.trim().is_empty() || !state.storage {
buttons::outlined(
ui,
Button::disabled(catalog.text(Key::SettingsJavaAddAction)),
)
} else {
buttons::outlined(
ui,
Button::new(
catalog.text(Key::SettingsJavaAddAction),
msg(JavaMessage::Add),
),
)
};
row![
container(text_field(ui, field, |value| msg(JavaMessage::AddDraft(
value
))))
.width(Length::Fill),
add,
]
.spacing(ui.space(Space::X2))
.width(Length::Fill)
.align_y(Alignment::Center)
.into()
}
/// 默认内存：数字框 + 范围 + 「生效值来自哪一层」。
pub(super) fn memory_field<'a>(
ui: &'a Ui,
catalog: Catalog,
state: &'a State,
) -> Element<'a, Message> {
let range = catalog.render(
Key::SettingsJavaMemoryHint,
&[
("min", MIN_MEMORY_MB.to_string().as_str()),
("max", MAX_MEMORY_MB.to_string().as_str()),
],
);
let field = Field::new(&state.memory)
.variant(FieldVariant::Outlined)
.label(catalog.text(Key::SettingsJavaMemory));
// 校验不过就把输入框本身标红（不只是下面那行字）：用户一眼看到「是这个框有问题」。
let field = match state.validate() {
Err(Refusal::MemoryEmpty | Refusal::MemoryNotNumber | Refusal::MemoryRange) => {
field.error()
}
_ => field,
};
let effective = match state.layer() {
Layer::Global => catalog.render(
Key::SettingsJavaLayerGlobal,
&[("mb", state.saved_memory.to_string().as_str())],
),
Layer::Instance { instance, mb } => catalog.render(
Key::SettingsJavaLayerInstance,
&[
("mb", mb.to_string().as_str()),
("instance", instance.as_str()),
],
),
};
column![
text_field(ui, field, |value| msg(JavaMessage::EditMemory(value))),
text_role_owned(
ui,
TypeRole::BodySmall,
false,
effective,
ui.color(Role::OnSurfaceVariant),
),
text_role_owned(
ui,
TypeRole::BodySmall,
false,
range,
ui.color(Role::OnSurfaceVariant),
),
]
.spacing(ui.space(Space::X1))
.width(Length::Fill)
.into()
}
/// JVM 额外参数：文本框 + 「会拼到每次启动」的说明。
pub(super) fn jvm_field<'a>(
ui: &'a Ui,
catalog: Catalog,
state: &'a State,
) -> Element<'a, Message> {
let field = Field::new(&state.jvm)
.variant(FieldVariant::Outlined)
.label(catalog.text(Key::SettingsJavaJvm))
.placeholder(catalog.text(Key::SettingsJavaJvmPlaceholder))
.supporting(catalog.text(Key::SettingsJavaJvmHint));
let field = if matches!(state.validate(), Err(Refusal::JvmQuotes)) {
field.error()
} else {
field
};
// 已保存值：空的时候说「还没有保存任何额外参数」，而不是让「已保存的值：」后面空着。
let saved = if state.saved_jvm.trim().is_empty() {
catalog.text(Key::SettingsJavaJvmSavedNone).to_string()
} else {
catalog.render(
Key::SettingsJavaJvmSaved,
&[("value", state.saved_jvm.as_str())],
)
};
column![
text_field(ui, field, |value| msg(JavaMessage::EditJvm(value))),
text_role_owned(
ui,
TypeRole::BodySmall,
false,
saved,
ui.color(Role::OnSurfaceVariant),
),
]
.spacing(ui.space(Space::X1))
.width(Length::Fill)
.into()
}
pub(super) fn actions_row<'a>(
ui: &'a Ui,
catalog: Catalog,
state: &'a State,
) -> Element<'a, Message> {
let label = catalog.text(Key::SettingsJavaSave);
if state.can_save() {
buttons::filled(ui, Button::new(label, msg(JavaMessage::Save)))
} else {
buttons::filled(ui, Button::disabled(label))
}
}
/// 按钮为什么灰着 / 下一步做什么——**永远说清**。
pub(super) fn hint_line<'a>(
ui: &'a Ui,
catalog: Catalog,
state: &'a State,
) -> Element<'a, Message> {
let (text, error) = if !state.storage {
(catalog.text(Key::SettingsJavaNoStorage).to_string(), true)
} else if state.dirty {
(catalog.text(Key::SettingsJavaUnsaved).to_string(), false)
} else {
(String::new(), false)
};
text_role_owned(
ui,
TypeRole::BodySmall,
false,
text,
ui.color(if error {
Role::Error
} else {
Role::OnSurfaceVariant
}),
)
}
pub(super) fn notice_line<'a>(
ui: &'a Ui,
catalog: Catalog,
notice: &Notice,
) -> Element<'a, Message> {
let (text, error) = match notice {
Notice::Saved => (catalog.text(Key::SettingsJavaSaved).to_string(), false),
Notice::Refused(reason) => (
catalog.render(
Key::SettingsJavaRefused,
&[("reason", catalog.text(refusal_key(*reason)))],
),
true,
),
Notice::Unwritable(reason) => (
catalog.render(
Key::SettingsJavaRefused,
&[("reason", catalog.text(reason.label()))],
),
true,
),
Notice::WriteFailed => (
catalog.render(
Key::SettingsJavaRefused,
&[("reason", catalog.text(Key::SettingsJavaReasonWriteFailed))],
),
true,
),
Notice::NoStorage => (catalog.text(Key::SettingsJavaNoStorage).to_string(), true),
Notice::DefaultSet(path) => (
catalog.render(Key::SettingsJavaDefaultSet, &[("path", path.as_str())]),
false,
),
Notice::Added(path) => (
catalog.render(Key::SettingsJavaAdded, &[("path", path.as_str())]),
false,
),
};
text_role_owned(
ui,
TypeRole::BodySmall,
false,
text,
ui.color(if error { Role::Error } else { Role::OnSurface }),
)
}
/// 拒绝原因 → 文案 key（`Refusal::label` 已是这张表，这里只是给 `match` 一个名字）。
pub(super) fn refusal_key(refusal: Refusal) -> Key {
refusal.label()
}
Loaded 100 of 290 files, more files were not shown because too many files have changed in this diff. Show more