编辑调整、对比模块

This commit is contained in:
zhongluofeng committed 2026-10-16 13:18:32 +08:00
1 parent c9e61f38c5
commit 6cfa74c901
76 files changed
+9513 -625

No files matched your search

+2 -1
View File
@@ -386,6 +386,7 @@ LibreHardwareMonitor 访问 CPU MSR(温度/时钟)、存储 SMART、SMBus、
采用 **ShellExecuteW "runas"** 弹 UAC 提权启动 Kernel,架构上与普通模式分离:
- **启动**:[monitor_kernel.rs](file:///d:/Atie/Gitea/Thing/src-tauri/src/monitor_kernel.rs) `start_elevated` → 停止当前 Kernel → `ShellExecuteW "runas"` 启动管理员 Kernel(隐藏控制台窗口)→ 等待 ready → 重新订阅 SSE
- **提权偏好(持久化)**:提权成功后会写入 `{app_data_dir}/monitor/settings.json` 的 `elevateOnStart=true`。此后 `start_with_subscription` 检测到该偏好且 Thing 非管理员时,改走 `start_elevated`,因此**应用重启后的自动启动路径也会提权**(仍会弹一次 UAC 确认)。前端「监控设置」提供同名开关可随时关闭(关闭后内核启动回到普通权限)。
- **停止**:调用 Kernel 的 `POST /shutdown` 接口(普通权限无法 `TerminateProcess` 管理员进程)
- **状态查询**:通过 HTTP `/status` 判断运行状态(pid 不可用,返回 None)
@@ -397,7 +398,7 @@ LibreHardwareMonitor 访问 CPU MSR(温度/时钟)、存储 SMART、SMBus、
| 崩溃重启 | 3s 巡检 + 自动重启 | 不支持(需手动重新提权) |
| 停止方式 | `ProcessManager.stop`(kill) | `POST /shutdown`(优雅退出) |
| PID 查询 | 可用 | 不可用(返回 None) |
| UAC 弹窗 | 无 | 每次启动需确认 |
| UAC 弹窗 | 无 | 每次启动需确认(提权偏好开启时,应用重启后的自动启动同样弹一次) |
### 7.4 C# Kernel /shutdown 接口
+3
View File
@@ -27,6 +27,7 @@
"@codemirror/language": "^6.12.4",
"@codemirror/language-data": "^6.5.2",
"@codemirror/legacy-modes": "^6.5.4",
"@codemirror/merge": "^6.12.2",
"@codemirror/search": "^6.7.2",
"@codemirror/state": "^6.7.6",
"@codemirror/theme-one-dark": "^6.1.3",
@@ -149,6 +150,8 @@
"@codemirror/lint": ["@codemirror/lint@6.9.7", "https://registry.npmmirror.com/@codemirror/lint/-/lint-6.9.7.tgz", { "dependencies": { "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.42.0", "crelt": "^1.0.5" } }, "sha512-28/+iWLYxKxsvGYhSYL7zaCZqLz5+FFFDq9tVsvGv9kv8RY4fFAchJ5WX9M3YrrRlTIsECjsXPqeNgnSmNP2dg=="],
"@codemirror/merge": ["@codemirror/merge@6.12.2", "https://registry.npmmirror.com/@codemirror/merge/-/merge-6.12.2.tgz", { "dependencies": { "@codemirror/language": "^6.0.0", "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.17.0", "@lezer/highlight": "^1.0.0", "style-mod": "^4.1.0" } }, "sha512-V8JvyAPjHbPupqP7BeMcsdsYCbyPij74jxIbaIJDORI+VZzW44zFmon8bF+oxGWvOKhcRmkiUMXd8MxHr3YA2w=="],
"@codemirror/search": ["@codemirror/search@6.7.2", "https://registry.npmmirror.com/@codemirror/search/-/search-6.7.2.tgz", { "dependencies": { "@codemirror/state": "^6.0.0", "@codemirror/view": "^6.37.0", "crelt": "^1.0.5" } }, "sha512-gUYkYhT2+n/+VGZ+8EzE5WFkYZUZYm1VOKDudIsNqh42uRVQJ0a6Yss9sdKT3MeOYfuL1N6AZA57oza0Oyr0LA=="],
"@codemirror/state": ["@codemirror/state@6.7.6", "https://registry.npmmirror.com/@codemirror/state/-/state-6.7.6.tgz", { "dependencies": { "@marijn/find-cluster-break": "^1.0.0" } }, "sha512-kAz+AncRtKuIknedxT1bq4XwXv4UowhbkHU1myPrtVb/jZtImWuV5BXzv5vK6i3kYACsdiZiQKFQQ5Mq7elW8w=="],
+349
View File
@@ -0,0 +1,349 @@
# 对比工具模块规划(Diff Module Plan)
> 状态:**P4 已落地**(选项卡 / 左右双树 / 下钻 / 快捷键 / 中间列快速替换)
> 本轮决策(2026-10-13,用户已拍板):**移除 devtools 的文本对比工具**(并入本模块)· **目录对比暂不做写回**(只读浏览)· **需要拖入支持**
> P4 决策(用户提出,2026-10-13):**选项卡式会话**(标题 `左 ↔ 右`)· **目录对比改为左右两棵结构树**(两侧路径可自由输入 + 图标按钮)· **点树里的文件新开文件选项卡** · **全局快捷键 Alt+C** · **中间列差异 + 快速替换**(参考 Beyond Compare)
> 定位:Thing 工具集的第 14 个模块,`id = diff`,`category = 'tool'`
> 作者:砚 | 日期:2026-10-13
> 关联文档:`AI_DEV_GUIDE.md`(模块注册 / IPC / 独立窗口范式)、`UI_DESIGN_SYSTEM.md`(页面框架 / 组件规范)、`EDITOR_MODULE_PLAN.md`(CM6 装配 / 编码探测 / 独立窗口 / 任务栏身份范式)、`TERMINAL_MODULE_PLAN.md`(拖放补注入范式)
> 阅读顺序:§9 开工清单(执行入口)→ §0 结论 → §4 技术选型 → §6 文件清单 → §8 分期。
---
## 0. 结论先行
六个关键判断。
1. **可行,且仓库里已有大半基础设施。** 编辑器模块已经把「CM6 + 主题系统 + 多语言高亮」「带编码探测的文件读取」「递归遍历(`walkdir` 已在依赖树)」「独立窗口 + 任务栏身份 + 拖放补注入」四块能力做完了。本模块的主要工作是**组装**,而不是造轮子。
2. **做成独立模块 + 独立窗口,不塞进编辑器。** 编辑器模块的中心对象是「一篇文档的生命周期」(标签、自动保存、光标、会话恢复);对比工具是「两个只读视图 + 一棵目录树」,没有自动保存、没有文档标签。混进去会让本已很大的 `EditorWindow.vue`(1500 行)与 `editorStore.ts` 继续膨胀,也会让 `editor-window-*` 这个 capability 的语义变模糊。模块体系是现成的(`moduleConfig` + 一行注册 + 图标表 + 搜索索引 + 启用开关),独立成模块成本很低。
3. **渲染层用 `@codemirror/merge`(CM6 官方 MergeView),计算层留在 Rust。** MergeView 天然给出并排 / 统一视图、块级高亮、chunk 跳转、接受/拒绝,并且**直接吃项目现有的 CM6 主题**(编辑器那九套配色自动跟随,无需为对比工具再维护一套配色)。Rust 只负责目录级扫描与分类:`walkdir` 递归 + size/mtime 快速路径 + 按需内容比对。这样目录对比的每一项都能「点一下」下钻到 MergeView 的文件级对比 —— 正是 Beyond Compare 的交互主线。
4. **三层能力按「易 → 难」分期,P1 只做文本对比。** 文本对比(粘贴两段)→ 文件对比(两个路径,含编码探测)→ 文件夹对比(递归树 + 三态分类 + 下钻)。P1 的价值不只是功能,更是**验证 `@codemirror/merge` 与项目现有 CM6 版本的兼容性**(见 §10),风险最低、最快闭环。
5. **目录对比这一期只读,不做写回。** 「浏览差异」与「同步目录」是两个量级的工程:后者要处理冲突策略、部分失败回滚、覆盖确认、二进制文件、只读属性与长路径。这一期给出只读的三态树 + 下钻即可,写回(复制 / 镜像 / 双向同步)留待单独评估。
6. **拖入支持从 P2 起生效。** 文本对比没有文件路径,用不上拖放;P2 起需要把「拖文件进窗口」纳入。既有实现是编辑器专用的 `editor/drag_drop.rs`(不通用:它按 editor 窗口的 label 前缀做注入),因此本模块**另建一份同构实现**或把它**泛化成按 label 前缀参数化**(见 §7.1,倾向后者)。
---
## 1. 定位与边界
| 维度 | 说明 |
|---|---|
| 一句话 | 一个 Beyond Compare 式的对比工具:文本 / 文件 / 文件夹三层,左右双栏 |
| 中心对象 | **两个被比较的目标**(一段文本、一个文件、一棵目录树),而不是某篇文档 |
| 首要入口 | 模块页「新建对比」+ 独立窗口(可拖入文件/文件夹) |
| 与编辑器模块的关系 | 复用它的 CM6 装配、主题与语言包、Rust 文件读取;但**不共享窗口、不共享 store** |
| 明确不做 | 不做三路合并(3-way merge)· 不做 Git 集成 · 本期不做目录写回/同步 · 不做二进制语义对比(只报「二进制不同」) |
---
## 2. 需求解构
| 用户原话 | 解构为 | 落点 |
|---|---|---|
| 「能够进行文本,文件,文件夹对比」 | 三种对比目标,同一条渲染管线 | §3.1 / §3.2 / §3.3 |
| 「左右两个窗口对比,参考 beyond compare」 | 并排双栏 + 块级高亮 + 差异导航 + 三态目录树 | §3.1 / §3.3 |
| 「调整…对比工具…做到编辑器里面还是单独做模块」 | 架构决策 → 独立模块 | §5 |
| 「去除 devtools 里的 diff」 | 删除 `DiffTools.vue` 及其注册项,能力并入本模块 | §8 开工清单 |
| 「目录对比暂时不用写回」 | P3 只读三态树,不做复制/同步 | §3.3 / §9 |
| 「需要拖入支持」 | 拖文件/文件夹进窗口即作为某一侧目标 | §7.1 |
---
## 3. 能力规格
### 3.1 文本对比(P1)
- 左右两个**可编辑**的 CM6 视图,构成一个 MergeView;任一侧输入即重算差异。
- 差异呈现:行内块级高亮(左边「被删/被改」、右边「新增/被改」),行号槽标注变化。
- 差异导航:上一个 / 下一个差异(工具栏按钮;到两端即停,不做循环跳转)。
- 顶部工具栏:粘贴到某一侧(从剪贴板)、交换左右、差异导航、清空两侧。并排是**唯一**的视图形态(统一视图需要另一套渲染路径,留待后续评估)。
- 状态栏:`差异 N 处 · +A 行 · -R 行 · 左侧 X 行 / 右侧 Y 行`。
- 大文本保护:**不做「超过 N 行就不算」的硬阈值**,改用 MergeView 内置的 `diffConfig.scanLimit`(默认 500)—— 它在差异过大时放弃精确比对、退回快速(不精确)算法,从而避开二次方耗时,同时**仍然给出结果**(比「停算并提示」更可用)。已知代价:极端输入下差异块可能不够精确(`Chunk.precise` 为 false)。
### 3.2 文件对比(P2)
- 两个路径(任意磁盘文件,不限于笔记库),来源:文件对话框 / 拖入 / 命令行 / 编辑器「与…对比」。
- **编码感知**:复用 `editor::files::read_file`(BOM → 严格 UTF-8 → chardetng 探测 → GB18030 兜底),状态栏显示两侧各自探测到的编码,不一致时给出提示(「左边 GBK / 右边 UTF-8」这类差异往往就是用户要找的问题)。
- 二进制文件:不渲染 diff,只报「二进制文件,大小 X vs Y,内容不同/相同」。
- 只读打开 + 可切换为可编辑;保存回写**仅作用于被显式编辑的一侧**(这一条属于 P2,不等同于 P3 的目录同步)。
- 拖入:拖文件到左半区 = 设为左侧目标,右半区 = 右侧目标。
### 3.3 文件夹对比(P3,只读)
- 递归遍历两侧,按**相对路径**对齐(根目录不同名也要对齐)。
- 每个条目三态 + 细分:
| 状态 | 判据 |
|---|---|
| 仅左侧有 | 右侧无同相对路径 |
| 仅右侧有 | 左侧无同相对路径 |
| 两侧都有 · 相同 | size 相同 → mtime 相同 →(必要时)内容一致 |
| 两侧都有 · 不同 | size 不同,或 size 相同但内容不同 |
| 目标类型不同 | 一侧是文件、另一侧是同名目录 |
- 树形展开 + 过滤(只看有差异 / 只看某一侧有)+ 「展开到下一个差异」。
- 目录级汇总:`N 项不同 · M 项仅左 · K 项仅右`,可折叠跳过相同项。
- 点击「不同」的文件行 → 在**同一个窗口**下钻到 §3.2 的文件对比视图(带返回上一级)。
- 忽略规则(可选,P3 后期):`node_modules` / `.git` 等常见目录的默认忽略清单。
### 3.4 不做(本期明确划界)
- 目录写回 / 镜像 / 双向同步(用户已拍板暂不做)。
- 三路合并与冲突解决。
- 二进制内容级对比(只判「相同/不同」与大小)。
- 大文件(> 阈值)的完整 diff —— 降级为只报状态,不做行级对齐。
---
## 4. 技术选型
### 4.1 渲染层:`@codemirror/merge`(已安装 6.12.2)
| 方案 | 结论 | 理由 |
|---|---|---|
| **`@codemirror/merge`** | **采用** | CM6 官方 MergeView:并排/统一、块级高亮、chunk 导航、接受/拒绝、行号 gutter 全部现成;与已装的 `@codemirror/state 6.7.6` / `view 6.43.x` 同源;主题直接复用 `editor/editor/themes.ts` 的九套配色 |
| Rust `similar` crate | 暂不引入 | 计算快、可单测,但并排对齐 UI 要自己写;P1/P2 用不到,等 P3 目录级需要「批量算文件差异摘要」时再评估 |
| 手写 LCS(原 devtools 实现) | 弃用 | O(n·m) DP 会卡死 UI,且没有对齐/高亮,已随 `DiffTools.vue` 一并移除 |
### 4.2 计算层:Rust 只做目录级
- `walkdir` 已在依赖树([Cargo.toml](../src-tauri/Cargo.toml)),递归扫描零新增成本。
- 文件内容比对优先用 **size → mtime → 内容** 三级快速路径,避免几万文件目录下全量读盘。
- 需要内容级判定时可选 `similar` 或 SHA-256(`sha2` 已在依赖树)。
### 4.3 主题:复用编辑器配色,不新建一套
对比窗口必须与编辑器窗口「同深同浅、同配色」,否则用户从编辑器跳到对比会感到割裂。做法:直接调用 `resolveEditorTheme` / `editorTypography` / `editorBackground`,并沿用编辑器窗口那套「跟随主应用主题 / 配色方案」的深浅推导(`EditorWindow.windowIsDark` 的逻辑)。**不需要在本模块重复维护配色表。**
---
## 5. 模块化决策(编辑器内 vs 独立模块)
| 维度 | 放进编辑器 | **独立 `diff` 模块(采纳)** |
|---|---|---|
| 中心对象 | 一篇文档的生命周期 | 两个被比较的目标 |
| 窗口形态 | 编辑器标签栏 + 编辑区 | 双栏 + 目录树(布局不兼容) |
| 状态 | 自动保存 / 脏标记 / 会话恢复 / 光标 | 无自动保存;目标是只读或被显式编辑 |
| capability 语义 | 「编辑笔记」 | 「对比」(授权范围各自清晰) |
| 代码影响面 | 继续膨胀 `EditorWindow.vue` / `editorStore.ts` | 新增独立目录,互不干扰 |
| 复用方式 | —— | 复用 CM6 装配 / 主题 / 语言包 / Rust 文件读取,**不共享窗口与 store** |
补充两条:
- **不做成 devtools 里的小工具**:devtools 是「主窗口内的单页聚合」,双栏 + 目录树装不进那个壳,也没有空间与拖拽入口。
- **交叉入口(可选,P2 之后再评估)**:编辑器窗口加「与…对比」,把当前文档发给 diff 窗口。它只是锦上添花,不影响主体结构。
---
## 6. 架构与文件清单
```
主模块页(入口 / 进度) 独立窗口(双栏差异视图 / 目录三态树)
↓ Tauri IPC ↓
src-tauri/src/diff/ 命令层
↓
commands.rs 单文件读取 / 写回 / 路径类型探测 / 目录对比入口
scan.rs 目录对比:递归遍历 + 三态分类(三层判据,见 §7.3)
types.rs 回传前端的 DTO(与前端 types.ts 对齐)
↓
editor::files 文件读取与编码探测(**复用**,提升为 pub(crate))
src-tauri/src/drag_drop.rs 拖放补注入(**通用**,编辑器与对比窗口共用)
前端:
src/modules/diff/
index.ts moduleConfig(icon: 'diff',order 50)
DiffModule.vue 主模块页:入口 + 三层能力进度
DiffWindow.vue 独立窗口外壳:模式切换(文件 / 文本 ↔ 文件夹)+ 文件对比界面
openWindow.ts diff-window 创建入口(单例,隐藏创建 + 拖放补注入)
diffClient.ts 命令名唯一落点(照抄 editorClient.ts 范式)
types.ts 与 Rust DTO 对齐的类型(DiffStats / DiffFileDoc / DirDiffEntry / DirDiffReport / DiffSide)
components/
TextMergeView.vue MergeView 封装(P1;P2 增补 setTexts / getText / doc-changed)
DirDiffView.vue 目录对比视图(P3:工具行 / 根路径 / 过滤 / 三态树 / 汇总)
登记点:
src/modules/index.ts 注册 moduleConfig
src/modules/icons.ts 图标映射(diff → Diff)
src/main.ts 独立窗口路由表加一行 '#diff-window'(按前缀匹配,支持 ?path=)
src/lib/constants.ts WINDOWS.diffWindow
src-tauri/src/taskbar_identity.rs 新增 'diff' 窗口类型(AUMID + 组合图标)
src-tauri/capabilities/diff-window.json windows: ["diff-window"]
```
---
## 7. 关键实现细节
### 7.1 拖入支持(用户点名需要)
既有实现原先在 `src-tauri/src/editor/drag_drop.rs`,**已泛化**为 `src-tauri/src/drag_drop.rs` 的 `window_attach_drag_drop`(按传入 label 生效,日志标记为 `drag-drop`),编辑器窗口与对比窗口共用同一份实现 —— 泛化而非复制,避免第二份同构实现各自腐坏。
要点(两条实现路径的取舍已定:**泛化**):
| 事项 | 结论 |
|---|---|
| 命令 | `window_attach_drag_drop(label)`,模块位于 crate 根部(不再属于 editor) |
| 调用时机 | 窗口创建后**立即** fire-and-forget 调用(不能等 `tauri://created`:窗口创建过快时该事件可能早于监听注册而永远等不到)。Rust 侧自行重试等待子窗口就位 |
| 窗口配置 | `dragDropEnabled: true` |
| 落点分侧 | 前端按 drop 坐标分左右半边。坐标是**物理像素**,需除以 `devicePixelRatio` 再与 CSS 宽度比较 |
| 目录 | `diff_read_file` 会拒绝目录并提示「目录对比尚未开放」——不让用户拖了没反应 |
### 7.2 编码与二进制(P2)
- 读取复用 `editor::files::read_file(path, max_mb)`:BOM → 严格 UTF-8 → chardetng 探测 → GB18030 兜底,并把「读到的编码 + 换行」成对记下来供写回原样还原。为此把 `editor::files` 提升为 `pub(crate)`(跨模块复用,范式同 `terminal::local_fs`)。
- **二进制由对比模块自己判定**(`editor::files` 只负责解码,没有二进制概念):按**头部 8KB 含 NUL** 判定,与 `editor::grep` 的跳过判据完全一致 —— 否则会出现「搜索跳过了、对比工具却显示一堆乱码」这种自相矛盾的行为。判定为二进制后**不读内容**,只回元信息(避免把无意义字节解码成一大段乱码再走 IPC)。
- 两侧编码分别在各自头部以 chip 显示;**编码不一致要在状态栏显式提示**(这是真实场景里最常见的「看起来全是乱码差异」根因)。
- 尺寸两级:软阈值 5MB(置 `large`,供前端降级)、硬上限 16MB(直接拒绝)。硬上限比编辑器的每篇上限更严,因为对比窗口**同时**持有两侧内容。
- 大文件降级:`large` 已回传,前端目前只在 `TextMergeView` 里靠 MergeView 的 `scanLimit` 兜底(见 §7.4),更细的降级(关折叠 / 不做行级对齐)留待后续。
### 7.3 目录扫描性能与判据(P3)
三层判据(代价递增,能不打盘就不打盘):
1. **size 不同** → 直接判「不同」(大小都不同,内容不可能相同);
2. **size 相同且 mtime 相同** → 判「相同」;
3. **size 相同但 mtime 不同** → 才读内容逐字节比对。
第 3 步有预算:[`MAX_CONTENT_COMPARES`] = 2000 条、单文件 ≤ 4MB。超出后不再读盘,按
时间戳归入「不同」并把 `content_compared` 置 false —— 结论仍是「不同」,但界面会显式
标注「未比对内容」,不与已确认的差异用同一种语气呈现(不能把「按元数据的推测」包装成
「读过的结论」)。
其余边界:
- **条目上限** 8000(`truncated` 标记 + 界面提示):再大就让用户缩小范围,
而不是把几十 MB 的 JSON 塞过 IPC。
- **不跟随符号链接**(`walkdir` 默认):跟随会让「链接成的环」把遍历变成死循环。
- **跳过清单由前端给出**(目录名、大小写不敏感、命中即整棵子树不遍历),默认清单与
`editor` 模块的默认跳过清单一致,另有开关可关。后端只按清单执行 —— 同 `editor::grep`
把默认清单留在前端的取舍。
- 扫描是**同步命令 + 前端异步等待**(一次返回整棵树),不做进度事件:实测量级下
(几万条目)耗时在百毫秒到数秒,做进度事件的复杂度不值当。若将来真的出现分钟级扫描,
再改成分批回传。
- 返回**扁平列表**(不是树):递归类型在 specta 下会生成无穷展开的 TS 类型(同
`editor::types::LibraryEntry` 的坑);树的组装、剪枝、排序都在前端。
### 7.4 大文本保护(P1)
旧的 devtools 实现是 3000 行、LCS O(n·m)、超限直接停算。P1 **不设硬阈值**:MergeView 的 `diffConfig.scanLimit`(默认 500)会在差异过大时放弃精确比对、退回快速但不精确的算法,避开二次方耗时且仍然给出结果。真要做「超大文件不做行级对齐」的降级,留到 P2/P3 与文件读取的 `large` 标记一并处理 —— 那时才有「一个真实的大文件」这个输入,而不是用户粘贴的文本。
### 7.5 窗口与任务栏身份
沿用编辑器窗口的范式:**隐藏创建**(避免深色主题下闪白)→ 应用主题与窗口效果 → `window_set_taskbar_identity`(独立任务栏按钮 + 组合图标)→ `show()`。任务栏身份**必须在 show() 之前**设置。
---
## 8. 分期路线图
### P1 · 文本对比(**已落地**)
**目标**:双栏 MergeView 跑通,验证 `@codemirror/merge` 与项目 CM6 版本的兼容性。
已交付:
1. `src/modules/diff/`:`index.ts`(moduleConfig)+ `DiffModule.vue`(主模块页)+ `DiffWindow.vue`(独立窗口)+ `openWindow.ts` + `components/TextMergeView.vue` + `types.ts`。
2. `src/modules/icons.ts` 加 `diff` 图标映射;`src/modules/index.ts` 注册模块;`src/main.ts` 加 `#diff-window` 路由。
3. `src-tauri/capabilities/diff-window.json`(glob `diff-window-*` 同源权限集)。
4. `src-tauri/src/taskbar_identity.rs` 新增 `diff` 类型(独立 AUMID + 双栏图形组合图标)。
5. `src/lib/constants.ts` 加 `WINDOWS.diffWindow`。
6. 删除 devtools 的文本对比工具:`DiffTools.vue` 已删,`tools/index.ts` 去掉元数据 / 图标 / 组件映射,`devtools/index.ts` 计数 20 → 19。
7. 依赖:`@codemirror/merge ^6.12.2`(`@codemirror/state 6.7.6` 未变,`view 6.43.x` 补丁级同步)。
8. 校验:`vue-tsc --noEmit`、`eslint`、`vite build`、`cargo check` 全部通过。
**尚未验证**:窗口在真实 Tauri 运行时的观感(滚动联动、mica 底色下的对比度、任务栏图标)需要跑一次 `tauri dev` 目视确认。
### P2 · 文件对比(**已落地**)
已交付:
1. Rust `src-tauri/src/diff/`:`mod.rs` / `types.rs`(`DiffFileDoc`)/ `commands.rs`(`diff_read_file`、`diff_write_file`)。读取复用 `editor::files::read_file`(编码探测 / 换行归一 / 只读探测),读取即登记授权(于是「打开过就能保存」成立)。为此把 `editor::files` 提升为 `pub(crate)`。
2. 尺寸与二进制策略:软阈值 5MB(置 `large`)、硬上限 16MB(直接拒绝,对比窗口天生要同时持有两侧)、二进制按「头部 8KB 含 NUL」判定(与 `editor::grep` 同一判据),二进制**不读内容**只回元信息。
3. 拖放泛化:`editor/drag_drop.rs` → `src-tauri/src/drag_drop.rs`,命令改名 `window_attach_drag_drop`,编辑器与对比窗口共用;`diff/openWindow.ts` 创建后立即补注入。
4. `diffClient.ts`(命令名唯一落点)+ `types.ts` 扩展(`DiffFileDoc` / `DiffSide`)。
5. `TextMergeView` 增补 `setTexts` / `getText` 与 `doc-changed` 事件(程序化装载期间抑制,避免把装载记成用户编辑)。
6. `DiffWindow.vue`:两侧头部(打开文件 / 保存 / 编码 chip / 只读 chip / 脏标记)、拖入分侧高亮、编码不一致提示、二进制概览面板(只比大小,不断言「内容相同」)、`Ctrl+S` 单侧写回、关闭前三选一确认。
7. `DiffModule.vue` 主模块页把「文件对比」标为可用。
8. 校验:`cargo check`、`vue-tsc --noEmit`、`eslint`、`vite build` 全部通过。
**已知取舍**:
- `bindings.ts` 是 `run()` 里 `export_bindings()` 在 debug 构建时生成的,本次未跑 `tauri dev`,因此其中仍留着旧的 `editorAttachDragDrop` 声明(**无任何调用点**);下次 debug 运行会自动重建。
- 脏标记是布尔(改过即脏),「改了又撤销回原样」仍显示为脏 —— 方向安全(至多多一次关闭确认),换来的是每次按键不必把整篇文档 `toString()` 出来比对。
- 单侧写回**不检查另一侧是否也改了同一个文件**(两侧选中同一路径时后保存的覆盖先保存的)。仍是未解决的边界 —— P3 的目录模式是只读的,不会走到这条路径。
### P3 · 文件夹对比(**已落地**,只读)
已交付:
1. Rust `diff/scan.rs`:递归遍历(`walkdir`,不跟随符号链接)+ 三态分类 + 三层判据(见 §7.3)+ 跳过清单 + 条目上限。
2. `diff/commands.rs` 增补 `diff_compare_dirs` 与 `diff_path_kind`(后者用于「拖入 / `?path=` 传进来的路径是文件还是目录」)。
3. 前端 `diffClient.compareDirs` / `pathKind`,`types.ts` 增补 `DirDiffEntry` / `DirDiffReport` / `DirDiffStatus`。
4. `components/DirDiffView.vue`:选两侧文件夹、跳过构建目录 / 比对内容两个开关、过滤(仅差异 / 全部 / 仅左侧 / 仅右侧)、树(目录在前、同名排序、可折叠、展开/折叠全部)、按子树剪枝、汇总栏(不同 / 仅左 / 仅右 / 相同 / 类型不一致 / 跳过目录数 / 耗时 / 截断提示)。
5. `DiffWindow.vue` 增加模式切换(文件 / 文本 ↔ 文件夹,各自记住自己的目标)、拖入按模式分派(目录模式取该侧根;拖文件取父目录)、点差异行下钻到文件对比 + 「返回目录对比」。
6. 校验:`cargo check`、`vue-tsc --noEmit`、`eslint`、`vite build` 全部通过(并核对 `h-6.5` 这类分数间距类确实被 Tailwind v4 生成)。
**关键取舍(都在实现里写了理由)**:
- **切模式不能丢改动**:目录模式下 `TextMergeView` 被卸载,用户刚敲的内容只存在于 CM6 实例里。离开文件模式前先 `snapshotEdits()` 把脏侧的内容取进 `contentA/B`,切回来时再灌回去(`setTexts` 抑制 `doc-changed`,脏标记原样保留)。
- **保存必须先确保文件模式已挂载**:`saveSide` 在取不到内容时直接返回 false 而**不是**写空串;`Ctrl+S` / 「保存并关闭」走 `saveAllDirtyEnsuringFiles`,会先切回文件模式再保存 —— 否则目录模式下保存会把文件写空。
- **目录的「相同 / 不同」由子树决定**:Rust 一律给目录标 `identical`,前端按子树是否含差异决定目录行的颜色与是否显示。
- **只读**:本期不做任何写回 / 同步(用户已拍板)。
**尚未验证**:与 P1/P2 一样,真实 Tauri 运行时下的观感与拖放行为需要跑一次 `tauri dev` 目视确认。
### P4 · 交互层补全(**已落地**,参考 Beyond Compare)
用户提出的五项调整,逐项落地情况:
| # | 需求 | 实现 |
|---|---|---|
| 1 | 选项卡,标题 `xxx ↔ xxx` | `DiffWindow` 改为**会话(session)**架构:一个选项卡 = 一对目标。标题取两侧显示名(文件用文件名、目录用末段目录名)。窗口标题同步为 `对比 — 左 ↔ 右`,任务栏悬停可见 |
| 2 | 目录对比改左右两个界面,都用结构树;两侧可自由输入与选择,选择改图标按钮 | `DirDiffView` 重写为**左右两棵结构树**:同一份并集行渲染两遍(行数/顺序一致、共用折叠状态),每侧只显示该侧真实存在的文件(缺失侧显示「—」并压暗名字);每侧顶部是**可编辑路径输入框 + 文件夹图标按钮**;列头对齐 Beyond Compare 的「名称 / 大小 / 已修改」 |
| 3 | 点一侧文件 → 新开文件对比选项卡 | 行点击 → `open-file` → 新开文件选项卡(记录 `fromDirTabId`,工具栏出现「返回目录对比」)。**只在一侧存在的文件也能开**(另一侧留空,整篇为新增/删除) |
| 4 | 快捷键唤出对比窗口,默认 Alt+C,参考编辑器机制 | Rust 侧新增 `DiffSettings` + `DiffManager`(`{app_data_dir}/diff/settings.json`),`init_on_launch` 用 `shortcut.rs` 注册(原子注册 + 应用内冲突检测),触发只发 `diff-open-window` 事件;`App.vue` **应用级**监听后调 `openDiffWindow()`。模块页可改快捷键(保存后就地重注册) |
| 5 | 中间列显示差异、快速替换等 BC 细节 | 文件对比启用 MergeView 的 `revertControls`:**中间列**按差异块渲染 ⇜ / ⇝ 按钮,点一下即把该块替换到另一侧(替换后该侧变脏)。MergeView 一次只能渲染一个方向,因此工具栏给出「右 → 左 / 左 → 右」方向切换(`reconfigure` 热切换,不重建视图) |
**P4 关键取舍**:
- **切选项卡不能丢改动**:`TextMergeView` 只有一个实例,内容只在 CM6 里是最新的。切走前 `snapshotEdits()` 把脏侧内容取回会话,切回来再灌进去(`setTexts` 抑制 `doc-changed`,脏标记保留)。
- **关闭选项卡的判据是「脏」而不是「编辑器是否挂载」**:非激活选项卡的编辑内容已快照在会话里,静默丢弃同样是丢改动 —— 因此脏就弹确认,确认后先激活它再保存(激活那一刻才能拿到最新内容)。
- **会话状态里的大对象要 `markRaw`**:扫描报告可达数千条目,进响应式系统会逐条生成 Proxy。内容字符串是原始值,不进 Proxy,可以放心放会话里。
- **`v-model:session` 而不是普通 prop**:`DirDiffView` 要直接改会话字段(8 个字段几乎都双向改),而 `vue/no-mutating-props` 禁止改 prop;`defineModel` 是 Vue 为这种场景给的正解。
---
## 9. 已拍板决策表
| # | 问题 | 决策 | 影响 |
|---|---|---|---|
| 1 | devtools 里的文本对比工具 | **移除**,能力并入本模块 | 避免仓库里存在两套 diff 引擎;顺带解决它的 3000 行上限 |
| 2 | 目录对比是否写回 | **暂不做**(P3 只读) | P3 工程量显著下降;写回留待单独评估 |
| 3 | 是否需要拖入 | **需要** | 已落地:P2 起拖入文件按落点装入左 / 右半区 |
| 4 | 做进编辑器还是独立模块 | **独立模块 + 独立窗口** | 复用编辑器能力但不共享窗口/store |
| 5 | 渲染层选型 | **`@codemirror/merge`** | 已有 6.12.2 安装;主题复用编辑器配色 |
| 6 | 本期是否引入 Rust `similar` | **不引入**(P1/P2 不需要) | P3 目录级若需批量摘要再评估 |
| 7 | 拖放补注入的实现路径 | **泛化既有实现**(不复制第二份) | `drag_drop.rs` 移到 crate 根部、命令改名 `window_attach_drag_drop`;编辑器调用点随之一并更新 |
| 8 | 单文件读取的尺寸策略 | 软阈值 **5MB** / 硬上限 **16MB** | 硬上限比编辑器更严:对比窗口同时持有两侧内容 |
| 9 | 目录对比的判据 | size → mtime → 内容(三层) | 内容比对有预算(2000 条 / 4MB):超出按时间戳判定,并在界面标注「未比对内容」 |
| 10 | 目录树结构 | Rust 返回**扁平列表**,前端组装 | 避开 specta 递归类型的坑(同 `LibraryEntry`);剪枝 / 排序 / 过滤都在前端 |
| 11 | 本期是否做目录写回 | **不做**(只读) | 用户已拍板;冲突策略等留待单独评估 |
| 12 | 窗口内是否有选项卡 | **有**(P4):一选项卡 = 一对目标 | 状态按会话组织;目录下钻新开选项卡而不是替换 |
| 13 | 目录对比的界面形态 | **左右两棵结构树**(P4,原为一棵并集树) | 同一份并集行渲染两遍,共用折叠状态保证不错行 |
| 14 | 打开对比窗口的快捷键 | **Alt+C**(P4,可在模块页改) | 走 `shortcut.rs`;触发只发事件,窗口由前端创建 |
| 15 | 中间列快速替换 | **启用**(P4):⇜/⇝ 单方向 + 工具栏切换 | MergeView 一次只能一个方向;双方向要自绘中间列,暂不做 |
---
## 10. 风险与待验证
| 风险 / 未知 | 说明 | 应对 |
|---|---|---|
| `@codemirror/merge` 与项目版本兼容 | 已确认安装 `6.12.2`,`@codemirror/state 6.7.6` 未变,`view` 由 `6.43.13` 升到 `6.43.14`(补丁级) | 已通过安装验证;P1 构建与运行再复核一次 |
| MergeView 的块级高亮配色与自建主题的融合 | MergeView 提供的是结构类名/默认色,需按项目语义色覆盖(新增/删除/修改) | P1 里显式覆盖 `.cm-changedLine` 等规则,对齐 `--success-soft` / `--danger-soft` |
| 目录扫描在大目录上的耗时 | 几十万文件递归 + 内容比对可能秒级到十几秒 | §7.3 快速路径 + 忽略清单 +(必要时)进度事件分批 |
| 拖放注入射程 | 现实现是编辑器专用的,泛化会触及编辑器路径 | §7.1 二选一;若选泛化,回归编辑器窗口的拖入 |
| 二进制与超长行文本在 MergeView 下的表现 | 极长单行(如压缩后的 JSON)会让对齐与渲染变慢 | 阈值降级 + 明确提示,不做静默失败 |
+4 -4
View File
@@ -137,10 +137,10 @@ shadcn 既有(值调整) → --background / --foreground / --primary / --c
--divider: #26262B;
--input: #2E2E34;
--foreground: #F5F5F7;
--fg-secondary: #A8A8B0;
--muted-foreground: #7A7A82;
--fg-disabled: #55555C;
--foreground: #FFFFFF; /* 深色下主文字用纯白 */
--fg-secondary: #ECECF2;
--muted-foreground: #D2D2DA;
--fg-disabled: #9A9AA4;
--primary: #2997FF;
--primary-hover: #4AA8FF;
+14
View File
@@ -30,6 +30,7 @@
"@codemirror/language": "^6.12.4",
"@codemirror/language-data": "^6.5.2",
"@codemirror/legacy-modes": "^6.5.4",
"@codemirror/merge": "^6.12.2",
"@codemirror/search": "^6.7.2",
"@codemirror/state": "^6.7.6",
"@codemirror/theme-one-dark": "^6.1.3",
@@ -516,6 +517,19 @@
"crelt": "^1.0.5"
}
},
"node_modules/@codemirror/merge": {
"version": "6.12.2",
"resolved": "https://registry.npmmirror.com/@codemirror/merge/-/merge-6.12.2.tgz",
"integrity": "sha512-V8JvyAPjHbPupqP7BeMcsdsYCbyPij74jxIbaIJDORI+VZzW44zFmon8bF+oxGWvOKhcRmkiUMXd8MxHr3YA2w==",
"license": "MIT",
"dependencies": {
"@codemirror/language": "^6.0.0",
"@codemirror/state": "^6.0.0",
"@codemirror/view": "^6.17.0",
"@lezer/highlight": "^1.0.0",
"style-mod": "^4.1.0"
}
},
"node_modules/@codemirror/search": {
"version": "6.7.2",
"resolved": "https://registry.npmmirror.com/@codemirror/search/-/search-6.7.2.tgz",
+1
View File
@@ -36,6 +36,7 @@
"@codemirror/language": "^6.12.4",
"@codemirror/language-data": "^6.5.2",
"@codemirror/legacy-modes": "^6.5.4",
"@codemirror/merge": "^6.12.2",
"@codemirror/search": "^6.7.2",
"@codemirror/state": "^6.7.6",
"@codemirror/theme-one-dark": "^6.1.3",
+2
View File
@@ -7714,7 +7714,9 @@ dependencies = [
"url",
"walkdir",
"windows 0.52.0",
"windows 0.62.2",
"windows-capture",
"windows-core 0.62.2",
"windows-sys 0.52.0",
"winreg 0.52.0",
"zip",
+20
View File
@@ -221,6 +221,26 @@ windows = { version = "0.52", features = [
"Win32_Graphics_Dxgi_Common",
"Win32_Graphics_Gdi",
] }
# 与 tauri / wry 同版本的 windows crate(**重命名**以便与上面项目自用的 0.52 并存;
# 同名不同版本不能写在同一个表里)。仅用于 editor/drag_drop.rs 实现 IDropTarget:
# 需要与 `WebviewWindow::hwnd()` 返回的 HWND 是同一个类型,才能直接对接。
windows62 = { package = "windows", version = "0.62", features = [
"Win32_Foundation",
"Win32_Graphics_Gdi",
"Win32_System_Com",
# 窗口级 AppUserModelID:PROPVARIANT 在 Com\StructuredStorage 下
"Win32_System_Com_StructuredStorage",
"Win32_System_Ole",
"Win32_System_SystemServices",
"Win32_UI_Shell",
# 窗口级 AUMID:SHGetPropertyStoreForWindow / IPropertyStore(Shell\PropertiesSystem)
"Win32_UI_Shell_PropertiesSystem",
"Win32_UI_WindowsAndMessaging",
# PKEY_AppUserModel_ID 常量声明在 Storage\EnhancedStorage 下
"Win32_Storage_EnhancedStorage",
] }
# `#[implement]` 宏展开出的代码按裸名引用 `windows_core`,因此必须直接依赖同名 crate。
windows-core = "0.62"
[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
tauri-plugin-autostart = "2"
+28
View File
@@ -0,0 +1,28 @@
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "diff-window",
"description": "Capability for the compare window (singleton, label = diff-window). Dual-pane merge view + folder tree — needs the editor window's control set (self-drawn title bar, mica/acrylic effects) plus drag & drop for setting either side from Explorer.",
"windows": ["diff-window"],
"permissions": [
"core:default",
"core:window:allow-show",
"core:window:allow-hide",
"core:window:allow-close",
"core:window:allow-minimize",
"core:window:allow-maximize",
"core:window:allow-toggle-maximize",
"core:window:allow-set-focus",
"core:window:allow-set-title",
"core:window:allow-start-dragging",
"core:window:allow-set-theme",
"core:window:allow-set-effects",
"core:window:allow-set-background-color",
"core:event:allow-listen",
"core:event:allow-emit",
"dialog:default",
"opener:default",
"opener:allow-open-path",
"opener:allow-reveal-item-in-dir",
"snap-layout:default"
]
}
+26 -2
View File
@@ -163,6 +163,30 @@ pub fn ensure_popup_window(app: &AppHandle) {
create_popup_window(app);
}
/// 把已显示的弹窗强制置前。
///
/// 只调 `set_focus` 不够:它内部是 `SetForegroundWindow`,受 Windows **前台锁定**限制 ——
/// 从别的应用按 Alt+V(本进程不拥有前台)时会被静默忽略,弹窗「出来了但拿不到焦点」,
/// 键盘导航 / 搜索都用不了。这里改用原生强制置前(模拟 Alt 释放重置前台锁定 +
/// SetForegroundWindow + BringWindowToTop),与快速面板 / 托盘 / 下载窗口同一套做法。
///
/// 调用前窗口应已 `show()`。置前失败(拿不到 hwnd)时退回普通 `set_focus`。
fn focus_force(win: &tauri::WebviewWindow) {
#[cfg(windows)]
{
match win.hwnd() {
Ok(hwnd) => crate::win32_util::force_foreground(hwnd.0 as isize),
Err(_) => {
let _ = win.set_focus();
}
}
}
#[cfg(not(windows))]
{
let _ = win.set_focus();
}
}
/// 在鼠标当前位置显示弹窗。
/// 窗口不存在则创建(隐藏状态,等前端挂载后调用 show_window 显示)。
/// 窗口已存在则移动到鼠标位置并显示。
@@ -200,7 +224,7 @@ pub fn show_popup(app: &AppHandle) {
}));
let _ = win.show();
mark_shown();
let _ = win.set_focus();
focus_force(&win);
// 通知前端刷新数据
let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
return;
@@ -232,7 +256,7 @@ pub fn show_window(app: &AppHandle) {
}
let _ = win.show();
mark_shown();
let _ = win.set_focus();
focus_force(&win);
// 通知前端刷新数据
let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
}
+10
View File
@@ -33,6 +33,9 @@ pub mod windows {
/// 服务就绪后由前端打开真正的 [`DSH_WEB`] 窗口并关闭它。
#[allow(dead_code)]
pub const DSH_WINDOW: &str = "dsh-window";
/// 对比工具独立窗口(单例,由前端创建)。
#[allow(dead_code)]
pub const DIFF_WINDOW: &str = "diff-window";
}
/// Tauri 事件名(与前端 constants::EVENTS 对应)
@@ -168,4 +171,11 @@ pub mod events {
// 笔记模块:需要打开一个**文件夹**(负载 `{ path }`)。
// 来源:资源管理器右键「用 Thing 编辑器打开」(目录 / 目录背景)。
pub const EDITOR_OPEN_FOLDER: &str = "editor-open-folder";
// 对比模块:全局快捷键按下「打开对比窗口」(无负载)。
// 窗口 label 策略与判重都在前端(它持有窗口),Rust 侧只负责注册快捷键。
pub const DIFF_OPEN_WINDOW: &str = "diff-open-window";
// 对比模块:目录扫描进度(负载见 diff::types::DiffScanProgress)。
// 进度在**发送端**按时间节流(见 diff::commands::diff_compare_dirs):整棵树可能有
// 上万个条目、上千次读盘,逐条 emit 会把 IPC 打满;前端只负责显示。
pub const DIFF_SCAN_PROGRESS: &str = "diff-scan-progress";
}
+207
View File
@@ -0,0 +1,207 @@
//! 对比模块的命令层。
//!
//! 三件事:读取一侧的文件、把一侧的内容写回、对比两棵目录树。文本级差异计算全在前端
//! (`@codemirror/merge`);目录级扫描在 [`super::scan`]。
//!
//! # 尺寸上限为什么要有两个
//!
//! - [`DIFF_LARGE_MB`]:**软**阈值。超过就置 `large`,前端据此关掉未变化段折叠等
//! 高开销特性 —— 文件照样完整读出来,只是更省。
//! - [`DIFF_HARD_LIMIT`]:**硬**上限。超过直接拒绝。对比窗口天生同时持有两侧内容
//! (不像编辑器只有一篇),单侧 16MB 已经是「两份都塞进 WebView + CM6 状态」的
//! 上限量级;再大不是「慢」而是「卡死」,早拒绝比让用户等一分钟再失败好。
use std::path::Path;
use std::time::{Duration, Instant};
use tauri::{AppHandle, Emitter, State};
use crate::editor::files;
use super::scan;
use super::types::{DiffFileDoc, DiffScanProgress, DiffSettings, DirDiffReport};
use super::DiffManager;
/// 「大文件」软阈值(MB)。与编辑器设置的默认值一致。
const DIFF_LARGE_MB: u32 = 5;
/// 硬上限(字节):单侧超过则拒绝读取。
const DIFF_HARD_LIMIT: u64 = 16 * 1024 * 1024;
/// 二进制探测的头部字节数。**与 `editor::grep` 的判据一致**(头部含 NUL 即二进制),
/// 否则会出现「搜索跳过了但对比工具显示了乱码」这种自相矛盾的行为。
const BINARY_SNIFF_BYTES: usize = 8 * 1024;
/// 打开文件并读出头部,同时判断是否二进制(头部含 NUL 字节)。
///
/// 返回**同一个已打开的句柄**(读位置停在头部之后)与那段头部:文本文件随后要靠这个
/// 句柄继续整读(见 `files::read_file_after_head`)—— 于是文件只被打开一次,也不会
/// 出现「嗅探时与整读时文件已被换掉」的窗口。二进制则到此为止,绝不整读。
fn open_with_head(path: &Path) -> Result<(std::fs::File, Vec<u8>, bool), String> {
use std::io::Read;
let mut file = std::fs::File::open(path).map_err(|e| format!("读取文件失败: {e}"))?;
let mut head = vec![0u8; BINARY_SNIFF_BYTES];
let read = file
.read(&mut head)
.map_err(|e| format!("读取文件失败: {e}"))?;
head.truncate(read);
let binary = head.contains(&0u8);
Ok((file, head, binary))
}
/// 写权限探测:以写模式打开但**不写入**(失败 → 只读)。
///
/// `editor::files` 里同名的函数是私有的(只服务编辑器自己的打开流程),这里重写一遍
/// 三行而不是把它提升为 `pub(crate)`:那个是模块内部细节,把它开放出去会让「谁在读
/// 权限探测」变得不清晰。
fn is_writable(path: &Path) -> bool {
std::fs::OpenOptions::new().write(true).open(path).is_ok()
}
/// 读取对比窗口某一侧的文件。
///
/// 复用 `editor::files::read_file`(编码探测 / 换行归一 / 只读探测),并顺带登记
/// 授权 —— 于是该文件随后可以被 [`diff_write_file`] 写回。
#[tauri::command]
#[specta::specta]
pub fn diff_read_file(path: String) -> Result<DiffFileDoc, String> {
let trimmed = path.trim();
if trimmed.is_empty() {
return Err("路径为空".to_string());
}
let p = Path::new(trimmed);
let meta = std::fs::metadata(p).map_err(|e| format!("读取文件信息失败: {e}"))?;
if meta.is_dir() {
return Err("这是一个目录 —— 请切到「文件夹」模式并把它设为某一侧".to_string());
}
if !meta.is_file() {
return Err("目标不是普通文件".to_string());
}
if meta.len() > DIFF_HARD_LIMIT {
return Err(format!(
"文件过大({} MB),超出对比窗口的 {} MB 上限",
meta.len() / (1024 * 1024),
DIFF_HARD_LIMIT / (1024 * 1024)
));
}
// 先读头部判断二进制(二进制到此为止、不整读),并把这段头部与**同一个句柄**
// 交给文本读取路径复用 —— 同一个文件全程只打开一次
let (file, head, binary) = open_with_head(p)?;
if binary {
return Ok(DiffFileDoc::binary_of(p, &meta, is_writable(p)));
}
let doc = files::read_file_after_head(file, p, &meta, &head, DIFF_LARGE_MB)?;
// 「打开过就能保存」:读取即登记授权(写回仍会再校验一次授权与写权限)
files::authorize(Path::new(&doc.path));
Ok(DiffFileDoc::from_file_doc(doc))
}
/// 把某一侧的内容写回磁盘。
///
/// `encoding` / `eol` 由前端回传**读取时探测到的值**,写回时原样还原 —— 一次「随手
/// 保存」不该把 GBK 文件变成 UTF-8、把 CRLF 变成 LF(那会在整个 diff 里掀起风暴)。
#[tauri::command]
#[specta::specta]
pub fn diff_write_file(
path: String,
content: String,
encoding: String,
eol: String,
) -> Result<DiffFileDoc, String> {
let doc = files::write_file(&path, &content, &encoding, &eol, DIFF_LARGE_MB)?;
Ok(DiffFileDoc::from_file_doc(doc))
}
/// 探测一个路径是文件还是目录(`"dir"` / `"file"` / `"missing"`)。
///
/// 用途:拖入或 `?path=` 传进来的路径前端拿不到文件系统元信息,而对比窗口需要据此
/// 决定「进文件模式还是目录模式」。**刻意不新增 Rust 侧的状态**:只读一次 `metadata`,
/// 不写盘、不需授权。
#[tauri::command]
#[specta::specta]
pub fn diff_path_kind(path: String) -> Result<String, String> {
let trimmed = path.trim();
if trimmed.is_empty() {
return Err("路径为空".to_string());
}
match std::fs::metadata(trimmed) {
Ok(meta) if meta.is_dir() => Ok("dir".to_string()),
Ok(meta) if meta.is_file() => Ok("file".to_string()),
Ok(_) => Ok("missing".to_string()),
Err(_) => Ok("missing".to_string()),
}
}
/// 对比两棵目录树(只读)。
///
/// `skip_dirs` 是**目录名**清单(大小写不敏感):默认清单由前端给出(它是界面约定,
/// 用户能否修改是 UI 的事),后端只负责按它执行 —— 同 `editor::grep` 把默认跳过清单
/// 留在前端的取舍。
///
/// 走 `spawn_blocking`:两遍目录遍历 + 最多 2000 次读盘都是同步阻塞 IO,放在 Tauri
/// 命令线程上会占住它(范式同 `editor_search_in_path`)。
///
/// `scan_id` 由前端生成并随进度事件原样回传:进度事件是全局的,多选项卡并发扫描时
/// 前端据此只认自己那一轮(见 `constants::events::DIFF_SCAN_PROGRESS`)。
#[tauri::command]
#[specta::specta]
pub async fn diff_compare_dirs(
app: AppHandle,
scan_id: u64,
left: String,
right: String,
skip_dirs: Vec<String>,
compare_content: bool,
) -> Result<DirDiffReport, String> {
tauri::async_runtime::spawn_blocking(move || {
// 进度按**时间**节流(≥120ms 才发一条):整棵树可能有上万个条目、上千次读盘,
// 逐条 emit 会把 IPC 打满;而按条目数节流在「条目少但每个都很大」时又会太稀。
// 最后一条进度由前端在命令返回时清掉,不依赖这里补齐。
let mut last_emit = Instant::now();
let mut progress = |phase: scan::ScanPhase, done: u64, total: u64| {
if last_emit.elapsed() < Duration::from_millis(120) {
return;
}
last_emit = Instant::now();
let phase = match phase {
scan::ScanPhase::Walk => "scan",
scan::ScanPhase::Compare => "compare",
};
let payload = DiffScanProgress {
scan_id,
phase: phase.to_string(),
done,
total,
};
let _ = app.emit(crate::constants::events::DIFF_SCAN_PROGRESS, payload);
};
scan::compare_dirs(&left, &right, &skip_dirs, compare_content, &mut progress)
})
.await
.map_err(|e| format!("目录对比任务失败: {e}"))?
}
/// 读取对比模块设置。
#[tauri::command]
#[specta::specta]
pub fn diff_get_settings(state: State<'_, DiffManager>) -> DiffSettings {
state.load_settings()
}
/// 保存对比模块设置。
///
/// 保存后**就地重注册**全局快捷键(`register_shortcut` 会先注销本模块的旧键,因此
/// 「清空快捷键」也能通过传空串生效)—— 同 `editor_save_settings`。
#[tauri::command]
#[specta::specta]
pub fn diff_save_settings(
app: AppHandle,
state: State<'_, DiffManager>,
settings: DiffSettings,
) -> Result<DiffSettings, String> {
let mut next = settings;
next.heal();
state.save_settings(&next)?;
state.init_on_launch(&app);
Ok(next)
}
+149
View File
@@ -0,0 +1,149 @@
//! 对比模块(文本 / 文件 / 目录)。
//!
//! 架构位置:
//!
//! ```text
//! 主模块页(入口 / 进度) 独立窗口(双栏差异视图)
//! ↓ Tauri IPC ↓
//! commands.rs 命令层
//! ↓
//! types.rs(回传前端的 DTO,与前端 src/modules/diff/types.ts 对齐)
//! ↓
//! editor::files 文件读取与编码探测(**复用**,不重复实现)
//! ```
//!
//! # 为什么复用 `editor::files` 而不自己读文件
//!
//! 「读一个文本文件」在这里不是 `fs::read_to_string`:要探测 BOM / 严格 UTF-8 /
//! GB18030 / Shift_JIS,要让「读到的编码」与「写回的编码」成对(GBK 文件按 UTF-8
//! 存回去就是永久损坏),要统一换行风格并原样还原,还要探测只读。这些编辑器模块
//! 都已经做完并踩过坑(见 `editor/files.rs` 的模块注释),对比工具没有任何理由
//! 再实现一遍 —— 因此 `editor::files` 提升为 `pub(crate)`,本模块直接调用。
//!
//! # 授权模型沿用编辑器
//!
//! `editor::files` 的写操作要求路径在会话内被「用户显式选择过」(对话框 / 拖入 /
//! 命令行)。本模块在**读取时顺带登记授权**,于是「在对比窗口打开过就能保存」这条
//! 最符合直觉的规则自动成立,不需要前端再单独调用一次授权命令。
//!
//! # 当前进度
//!
//! P2 落地:单文件读取(`diff_read_file`)与写回(`diff_write_file`)。
//! P3 落地:目录对比(`diff_compare_dirs` / `diff_path_kind`,只读)。
//! 规划见 `doc/DIFF_MODULE_PLAN.md`。
mod commands;
mod scan;
mod types;
pub use commands::{
diff_compare_dirs, diff_get_settings, diff_path_kind, diff_read_file, diff_save_settings,
diff_write_file,
};
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use std::time::{Duration, Instant};
use types::DiffSettings;
/// 设置内存缓存有效期(与 ai / translate / terminal / editor 的 500ms 一致)。
const SETTINGS_CACHE_TTL: Duration = Duration::from_millis(500);
struct SettingsCache {
read_at: Instant,
settings: DiffSettings,
}
/// 对比模块管理器(Tauri State)。
///
/// 目前只承担一件事:设置的读写与全局快捷键注册。目标(左右文件 / 左右目录)**不在这里**
/// —— 它们是前端会话状态,Rust 侧不需要知道用户在比哪两个东西。
pub struct DiffManager {
/// 模块自身目录:`{app_data_dir}/diff`
module_dir: PathBuf,
cache: Mutex<Option<SettingsCache>>,
}
impl DiffManager {
pub fn new(app_data_dir: PathBuf) -> Self {
let module_dir = app_data_dir.join("diff");
let _ = std::fs::create_dir_all(&module_dir);
Self {
module_dir,
cache: Mutex::new(None),
}
}
fn settings_path(&self) -> PathBuf {
self.module_dir.join("settings.json")
}
/// 读取设置(带短时缓存;文件缺失回退默认值;自愈结果落盘)。
pub fn load_settings(&self) -> DiffSettings {
if let Ok(cache) = self.cache.lock() {
if let Some(entry) = cache.as_ref() {
if entry.read_at.elapsed() < SETTINGS_CACHE_TTL {
return entry.settings.clone();
}
}
}
let mut settings = std::fs::read_to_string(self.settings_path())
.ok()
.and_then(|s| serde_json::from_str::<DiffSettings>(&s).ok())
.unwrap_or_default();
let healed = settings.heal();
if let Ok(mut cache) = self.cache.lock() {
*cache = Some(SettingsCache {
read_at: Instant::now(),
settings: settings.clone(),
});
}
if healed {
if let Err(e) = self.save_settings(&settings) {
crate::logger::log_error("diff", &format!("设置自愈落盘失败: {e}"));
}
}
settings
}
/// 保存设置并刷新缓存。
pub fn save_settings(&self, settings: &DiffSettings) -> Result<(), String> {
let json = serde_json::to_string_pretty(settings)
.map_err(|e| format!("序列化对比设置失败: {e}"))?;
std::fs::write(self.settings_path(), json).map_err(|e| format!("写入对比设置失败: {e}"))?;
if let Ok(mut cache) = self.cache.lock() {
*cache = Some(SettingsCache {
read_at: Instant::now(),
settings: settings.clone(),
});
}
Ok(())
}
/// 启动时按设置注册「打开对比窗口」全局快捷键(默认 Alt+C)。
///
/// 失败只记日志:快捷键被别的应用占了不该阻断启动(同 editor / translate / terminal)。
/// 触发时**只发事件**:窗口 label 策略与判重都在前端(它持有窗口),Rust 侧不该操心。
pub fn init_on_launch(&self, app: &tauri::AppHandle) {
use tauri::Emitter;
let settings = self.load_settings();
let shortcut = settings.open_diff_shortcut.clone();
if let Err(e) =
crate::shortcut::register_shortcut(app, "diff-open-window", &shortcut, |app| {
if let Err(e) = app.emit(crate::constants::events::DIFF_OPEN_WINDOW, ()) {
crate::logger::log_warn("diff", &format!("发出打开对比窗口事件失败: {e}"));
}
})
{
crate::logger::log_warn("diff", &format!("注册「打开对比窗口」快捷键失败: {e}"));
}
}
/// 模块目录(保留给将来的诊断 / 导出用)。
#[allow(dead_code)]
pub fn module_dir(&self) -> &Path {
&self.module_dir
}
}
+313
View File
@@ -0,0 +1,313 @@
//! 目录对比:递归遍历两侧 + 三态分类(**只读**,本期不做写回)。
//!
//! # 为什么是三层判据,而不是逐字节比对
//!
//! 一个几万文件的目录树逐字节比对,等于把两边全读一遍 —— 慢且没必要。判据按代价递增:
//!
//! 1. **size 不同** → 直接判「不同」(两文件大小都不同,内容不可能相同,不必读盘);
//! 2. **两侧都是空文件** → 直接判「相同」(长度都是 0,内容必然相同;这一条必须显式判,
//! 否则「空文件 + 时间戳不同」会掉进下面「按时间戳判不同」的兜底,把两个空文件报成差异);
//! 3. **size 相同且 mtime 相同** → 判「相同」(各对比工具的通行快速路径);
//! 4. **size 相同但 mtime 不同** → 才读内容逐字节比对。
//!
//! 第 4 步有预算([`MAX_CONTENT_COMPARES`] 条数与 [`MAX_CONTENT_BYTES`] 单文件体积):
//! 超出后不再读盘,按时间戳归入「不同」并把 `content_compared` 置 false ——
//! 结论仍然是「不同」,但**明确标记它未经内容比对**,而不是给出一个看起来同样确定的答案。
//!
//! # 为什么返回扁平列表而不是树
//!
//! 递归类型在 specta 的 `Type` 派生下容易生成无穷展开的 TS 类型(`editor::types::LibraryEntry`
//! 的注释里踩过同一个坑)。这里同样返回扁平列表(`rel_path` 用 `/` 分隔),由前端组装成树。
//!
//! # 只读
//!
//! 本模块**不写任何文件**。目录写回(复制 / 镜像 / 双向同步)是另一个量级的工程
//! (冲突策略、部分失败回滚、覆盖确认),已与用户确认不在本期。
use std::cell::Cell;
use std::collections::{HashMap, HashSet};
use std::path::Path;
use std::time::{Instant, UNIX_EPOCH};
use walkdir::WalkDir;
use crate::editor::files::display_path;
use super::types::{DirDiffEntry, DirDiffReport, NodeInfo};
/// 单次对比最多回传的条目数(超出即截断并置 `truncated`)。
///
/// 取值权衡:条目是扁平 JSON,每条含两侧绝对路径,约 200 字节 —— 8000 条约 1.6MB 一次性
/// 走 IPC,是「还能接受」与「再大就该让用户缩小范围」的分界。
const MAX_ENTRIES: usize = 8000;
/// 最多读多少个文件的内容做逐字节比对(防止「上万文件大小相同、时间戳不同」时把盘读穿)。
const MAX_CONTENT_COMPARES: usize = 2000;
/// 单个文件超过这个体积就不读内容比对(按时间戳判定)。
const MAX_CONTENT_BYTES: u64 = 4 * 1024 * 1024;
/// 扫描阶段(进度事件用;事件名与负载见 [`super::types::DiffScanProgress`])。
#[derive(Clone, Copy, Debug)]
pub enum ScanPhase {
/// 遍历目录树(此时总数无从预知)
Walk,
/// 读内容逐字节核对(总数 = 预算上限)
Compare,
}
/// 一次遍历的产出。
struct Collected {
files: HashMap<String, NodeInfo>,
skipped_dirs: u32,
truncated: bool,
}
/// 把根路径解析成「存在的目录」的绝对路径。
fn resolve_root(raw: &str, label: &str) -> Result<std::path::PathBuf, String> {
let trimmed = raw.trim();
if trimmed.is_empty() {
return Err(format!("{label}目录为空"));
}
let path = Path::new(trimmed);
let meta = std::fs::metadata(path).map_err(|e| format!("读取{label}目录失败: {e}"))?;
if !meta.is_dir() {
return Err(format!("{label}不是目录(文件对比请用「文件 / 文本」模式)"));
}
// 规范化:统一成真实位置,避免两侧用不同写法指向同一目录(`C:\a\..\b` / 尾部斜杠)
std::fs::canonicalize(path).map_err(|e| format!("解析{label}目录失败: {e}"))
}
/// 递归收集一侧的全部条目。
///
/// **不跟随符号链接**(walkdir 默认):跟随会让「链接成的环」把遍历变成死循环。
///
/// 跳过清单用 `filter_entry` **真正剪枝**:walkdir 在返回一个目录条目的**同一次**
/// `next()` 里就已把该目录压进遍历栈(见 walkdir 的 `handle_entry`),因此仅对命中的
/// 目录条目 `continue` 并不会阻止继续下钻 —— 那会「跳过」得名不副实(构建目录的子项
/// 照样进结果),还把整棵构建目录白扫一遍。
fn collect(
root: &Path,
skip: &HashSet<String>,
progress: &mut dyn FnMut(ScanPhase, u64, u64),
) -> Collected {
let mut files: HashMap<String, NodeInfo> = HashMap::new();
let skipped = Cell::new(0u32);
let truncated = Cell::new(false);
let mut encountered: u64 = 0;
let walker = WalkDir::new(root)
.follow_links(false)
.into_iter()
.filter_entry(|entry| {
// 根自身永远放行:否则根的名字恰好命中清单时整棵树都没了
if entry.depth() == 0 {
return true;
}
if entry.file_type().is_dir() {
let name = entry.file_name().to_string_lossy().to_lowercase();
if skip.contains(&name) {
skipped.set(skipped.get() + 1);
return false; // 既不产出该目录,也不再下钻
}
}
true
});
for entry in walker {
if truncated.get() {
break;
}
let Ok(entry) = entry else { continue };
// 根自身不作为条目
if entry.depth() == 0 {
continue;
}
encountered += 1;
// 每 512 个条目报一次(真正的节流由命令层按时间做,见 `diff_compare_dirs`)
if encountered % 512 == 0 {
progress(ScanPhase::Walk, encountered, 0);
}
if files.len() >= MAX_ENTRIES {
truncated.set(true);
break;
}
let is_dir = entry.file_type().is_dir();
let name = entry.file_name().to_string_lossy().to_string();
let Ok(meta) = entry.metadata() else { continue };
let rel = entry
.path()
.strip_prefix(root)
.map(|p| p.to_string_lossy().replace('\\', "/"))
.unwrap_or_else(|_| name.clone());
files.insert(
rel,
NodeInfo {
is_dir,
size: if is_dir { 0 } else { meta.len() },
modified: meta
.modified()
.ok()
.and_then(|t| t.duration_since(UNIX_EPOCH).ok())
.map(|d| d.as_millis() as u64)
.unwrap_or(0),
path: display_path(entry.path()),
},
);
}
// 收尾再报一次:让「最后一截」不被 512 的步长吞掉
progress(ScanPhase::Walk, encountered, 0);
Collected {
files,
skipped_dirs: skipped.get(),
truncated: truncated.get(),
}
}
/// 两个文件的内容是否逐字节相同(只在「大小相同、时间戳不同」时才调用)。
///
/// 分块比较而不是把两个文件整体读进内存:单文件上限 [`MAX_CONTENT_BYTES`](4MB),
/// 整体读要一次性占两块 4MB;分块读的峰值只有缓冲区大小,遇到首个差异就能立刻返回。
fn same_content(left: &Path, right: &Path) -> Result<bool, std::io::Error> {
let mut a = std::io::BufReader::new(std::fs::File::open(left)?);
let mut b = std::io::BufReader::new(std::fs::File::open(right)?);
let mut buf_a = [0u8; 64 * 1024];
let mut buf_b = [0u8; 64 * 1024];
loop {
let n = read_full(&mut a, &mut buf_a)?;
let m = read_full(&mut b, &mut buf_b)?;
// 长度不同(含「一个先到 EOF」)即判不同
if n != m || buf_a[..n] != buf_b[..m] {
return Ok(false);
}
if n == 0 {
return Ok(true);
}
}
}
/// 把缓冲区读到满(除非到达 EOF)。
///
/// `Read::read` 允许短读,直接拿短读的字节数比较会误判「不同」,因此这里循环到读满。
fn read_full(reader: &mut impl std::io::Read, buf: &mut [u8]) -> Result<usize, std::io::Error> {
let mut filled = 0;
while filled < buf.len() {
let n = reader.read(&mut buf[filled..])?;
if n == 0 {
break;
}
filled += n;
}
Ok(filled)
}
/// 对比两棵目录树。
///
/// `skip_dirs` 由前端给出(大小写不敏感、按目录名匹配):默认清单是**界面约定**而不是
/// 后端常量 —— 用户能不能改这份清单是 UI 的事,后端只负责按它执行(同 `editor::grep`
/// 把默认清单留在前端的取舍)。
///
/// `progress` 是进度回调(阶段, 已完成, 总数):本函数只负责在关键节点调用它,
/// 事件名 / 节流 / 发给谁都在命令层决定(见 `super::commands`)。
pub fn compare_dirs(
left: &str,
right: &str,
skip_dirs: &[String],
compare_content: bool,
progress: &mut dyn FnMut(ScanPhase, u64, u64),
) -> Result<DirDiffReport, String> {
let started = Instant::now();
let left_root = resolve_root(left, "左侧")?;
let right_root = resolve_root(right, "右侧")?;
// 跳过清单归一成集合:命中的目录要在剪枝判定里按名做 O(1) 查表(清单有十几项、
// 目录数可达上万,逐个线性比对不值得)
let skip: HashSet<String> = skip_dirs
.iter()
.map(|s| s.trim().to_lowercase())
.filter(|s| !s.is_empty())
.collect();
let l = collect(&left_root, &skip, &mut *progress);
let r = collect(&right_root, &skip, &mut *progress);
// 两侧相对路径的并集,排序后输出(顺序稳定,前端组装树的观感才稳定)
let mut keys: Vec<&String> = l.files.keys().chain(r.files.keys()).collect();
keys.sort();
keys.dedup();
let mut entries: Vec<DirDiffEntry> = Vec::with_capacity(keys.len());
let mut content_budget = MAX_CONTENT_COMPARES;
let mut compared: u64 = 0;
for key in keys {
let left_node = l.files.get(key);
let right_node = r.files.get(key);
let is_dir = left_node.map(|n| n.is_dir).unwrap_or(false)
|| right_node.map(|n| n.is_dir).unwrap_or(false);
let mut content_compared = false;
let status: &str = match (left_node, right_node) {
(Some(_), None) => "left-only",
(None, Some(_)) => "right-only",
(Some(a), Some(b)) => {
if a.is_dir != b.is_dir {
// 同名但一侧是文件、另一侧是目录:无法比较内容,单独归类
"type-mismatch"
} else if a.is_dir {
// 目录本身没有内容,是否「相同」由它的子条目决定;前端按子树判断
"identical"
} else if a.size != b.size {
"different"
} else if a.size == 0 {
// 两侧都是空文件(上面的 size 不等已排除「单侧为空」):内容必然相同。
// 不单独判的话会掉进最后的兜底,按时间戳把两个空文件报成「不同」
"identical"
} else if a.modified == b.modified {
"identical"
} else if compare_content && content_budget > 0 && a.size <= MAX_CONTENT_BYTES {
content_budget -= 1;
content_compared = true;
compared += 1;
// 核对阶段是最慢的一段(每处都要读两个文件),进度最有价值
progress(ScanPhase::Compare, compared, MAX_CONTENT_COMPARES as u64);
match same_content(Path::new(&a.path), Path::new(&b.path)) {
Ok(true) => "identical",
Ok(false) => "different",
// 读失败(权限 / 竞态删除):按时间戳判定,不把错误伪装成结论
Err(_) => "different",
}
} else {
// 体积超限 / 预算用尽:按时间戳判定,标记未比对内容
"different"
}
}
(None, None) => unreachable!("key 来自两侧键的并集"),
};
entries.push(DirDiffEntry {
rel_path: key.clone(),
is_dir,
status: status.to_string(),
left_path: left_node.map(|n| n.path.clone()).unwrap_or_default(),
right_path: right_node.map(|n| n.path.clone()).unwrap_or_default(),
left_size: left_node.map(|n| n.size).unwrap_or(0),
right_size: right_node.map(|n| n.size).unwrap_or(0),
left_modified: left_node.map(|n| n.modified).unwrap_or(0),
right_modified: right_node.map(|n| n.modified).unwrap_or(0),
content_compared,
});
}
Ok(DirDiffReport {
left_root: display_path(&left_root),
right_root: display_path(&right_root),
entries,
truncated: l.truncated || r.truncated,
skipped_dirs: l.skipped_dirs + r.skipped_dirs,
elapsed_ms: started.elapsed().as_millis() as u64,
})
}
+206
View File
@@ -0,0 +1,206 @@
//! 对比模块的数据模型(回传前端的 DTO)。
//!
//! 与前端 `src/modules/diff/types.ts` 一一对应;新增字段两侧都要改。
use serde::{Deserialize, Serialize};
use specta::Type;
use std::fs::Metadata;
use std::path::Path;
use crate::editor::files::{display_path, FileDoc};
/// 设置结构版本号。字段增减时递增,由 [`DiffSettings::heal`] 推进。
pub const DIFF_SETTINGS_VERSION: u32 = 1;
/// 对比模块设置(持久化到 `{app_data_dir}/diff/settings.json`,范式同 editor / translate)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct DiffSettings {
pub version: u32,
/// 全局快捷键:打开 / 唤出对比窗口(空串 = 不注册)。
///
/// 走 `shortcut.rs` 的原子注册 + 冲突检测(与终端 / 翻译 / 编辑器同一套);触发时只发
/// `diff-open-window` 事件,窗口由前端创建 —— Rust 侧不持窗口 label 策略。
pub open_diff_shortcut: String,
/// 目录对比:默认是否比对内容(大小相同、时间戳不同时读文件逐字节比对)
pub compare_content: bool,
/// 目录对比:默认是否跳过常见构建目录
pub skip_build_dirs: bool,
}
impl Default for DiffSettings {
fn default() -> Self {
Self {
version: DIFF_SETTINGS_VERSION,
open_diff_shortcut: "Alt+C".to_string(),
compare_content: true,
skip_build_dirs: true,
}
}
}
impl DiffSettings {
/// 自愈:推进版本号(并在首次遇到旧配置时补上默认快捷键)。返回是否发生了变化。
///
/// 刻意**不**把空的 `open_diff_shortcut` 补回默认:空串是「用户主动清空快捷键」的
/// 合法表达,快捷键被静默改回来比不生效更让人困惑。只有版本号为 0(从未写过这份
/// 配置)时才补一次 Alt+C。
pub fn heal(&mut self) -> bool {
if self.version >= DIFF_SETTINGS_VERSION {
return false;
}
if self.version == 0 && self.open_diff_shortcut.is_empty() {
self.open_diff_shortcut = "Alt+C".to_string();
}
self.version = DIFF_SETTINGS_VERSION;
true
}
}
/// 对比窗口里**一侧**文件的状态。
///
/// 刻意不复用 `FileDoc`:对比窗口需要额外的 `binary` 标记(二进制文件不进入文本
/// diff,只报「不同」),而 `FileDoc` 是编辑器模块的对外契约,为对比工具加字段会
/// 把「谁需要什么」搅在一起。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DiffFileDoc {
/// 绝对路径(Windows 下已剥掉 `\\?\` 前缀)
pub path: String,
/// 显示名(文件名)
pub name: String,
/// 文本内容(换行已统一为 `\n`,写回时按 `eol` 还原)。二进制文件为空串
pub content: String,
/// 探测到的编码(`utf-8` / `utf-8-bom` / `gbk` / …)。二进制文件为空串
pub encoding: String,
/// 换行风格:"lf" | "crlf"。二进制文件为空串
pub eol: String,
/// 文件字节数
pub size: u64,
/// 最后修改时间(Unix 毫秒)
pub modified: u64,
/// 行数(二进制文件为 0)
pub lines: u64,
/// 是否超过「大文件」阈值(前端据此关掉折叠等高开销特性)
pub large: bool,
/// 是否只读(写权限探测失败)
pub readonly: bool,
/// 是否为二进制(头部含 NUL 字节):此类文件不渲染 diff
pub binary: bool,
}
impl DiffFileDoc {
/// 由编辑器的读取结果构造(文本文件路径)。
pub fn from_file_doc(doc: FileDoc) -> Self {
Self {
path: doc.path,
name: doc.name,
content: doc.content,
encoding: doc.encoding,
eol: doc.eol,
size: doc.size,
modified: doc.modified,
lines: doc.lines,
large: doc.large,
readonly: doc.readonly,
binary: false,
}
}
/// 二进制文件:**不读内容**(避免把无意义的字节解码成一大段乱码再走 IPC)。
pub fn binary_of(path: &Path, meta: &Metadata, readonly: bool) -> Self {
Self {
path: display_path(path),
name: path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default(),
content: String::new(),
encoding: String::new(),
eol: String::new(),
size: meta.len(),
modified: meta
.modified()
.ok()
.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
.map(|d| d.as_millis() as u64)
.unwrap_or(0),
lines: 0,
large: false,
readonly,
binary: true,
}
}
}
/// 遍历时一侧的一个条目(**内部结构**,不回传前端)。
pub struct NodeInfo {
pub is_dir: bool,
/// 目录为 0
pub size: u64,
/// 最后修改时间(Unix 毫秒)
pub modified: u64,
/// 绝对路径(回传前端用于「下钻到文件对比」)
pub path: String,
}
/// 目录对比中的一个条目(扁平列表,由前端组装成树)。
///
/// `status` 取值:`left-only` / `right-only` / `different` / `identical` / `type-mismatch`
/// (同名但一侧是文件、另一侧是目录)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DirDiffEntry {
/// 相对根的路径,`/` 分隔(前端据此组装树,显示名自己从最后一段取)
pub rel_path: String,
/// 是否目录(type-mismatch 时为 true)
pub is_dir: bool,
pub status: String,
/// 该侧的绝对路径;该侧不存在时为空串
pub left_path: String,
pub right_path: String,
/// 该侧字节数;不存在为 0
pub left_size: u64,
pub right_size: u64,
/// 该侧最后修改时间(Unix 毫秒);不存在为 0
pub left_modified: u64,
pub right_modified: u64,
/// 结论是否**由内容逐字节比对**得出。
///
/// false 表示「大小相同、时间戳不同」且未读内容(体积超限 / 预算用尽),
/// 此时 `different` 是**按时间戳**判定的 —— 界面要据此提示,不能与已确认的差异
/// 用同一种语气呈现。
pub content_compared: bool,
}
/// 目录对比的扫描进度(**事件负载**,不是命令返回值)。
///
/// 前端按 `scan_id` 过滤:进度事件是全局的(Rust 不区分选项卡),多选项卡并发扫描时
/// 只有属于本轮的那一份进度才该被采用。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DiffScanProgress {
/// 本轮扫描的标识(前端生成,随命令传入并原样回传)
pub scan_id: u64,
/// `scan` = 正在遍历目录;`compare` = 正在读内容逐字节核对
pub phase: String,
/// 已完成数(遍历 = 已过的条目数;核对 = 已比对的文件数)
pub done: u64,
/// 总数(遍历阶段无从预知,为 0;核对阶段为预算上限)
pub total: u64,
}
/// 一次目录对比的结果。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DirDiffReport {
pub left_root: String,
pub right_root: String,
pub entries: Vec<DirDiffEntry>,
/// 条目数达到上限、遍历被截断(界面提示用户缩小范围)
pub truncated: bool,
/// 按跳过清单略过的目录数
pub skipped_dirs: u32,
/// 扫描耗时(毫秒;状态栏显示)
pub elapsed_ms: u64,
}
+352
View File
@@ -0,0 +1,352 @@
//! 子窗口拖放「补注入」(仅 Windows 真正生效,其它平台是 no-op)。
//!
//! # 为什么需要这个模块
//!
//! wry 只在**创建 webview 的那一刻**枚举一次子窗口、给它们注入 OLE drop target
//! (见 wry `webview2/drag_drop.rs` 的 `DragDropController::new` 里那句
//! `EnumChildWindows`)。而 WebView2 的 `Chrome_WidgetWin_1` /
//! `Chrome_RenderWidgetHostHWND` 是**异步惰性创建**的:
//!
//! - 由 `tauri.conf.json` 在 setup 阶段创建的主窗口 —— 注入时这些子窗口已存在,正常;
//! - 运行时经 IPC 创建的窗口(编辑器 / 对比,`new WebviewWindow`)—— 注入时子窗口
//! 还没生出来,于是它们**永远没有 drop target**。表现就是:拖文件进去光标变成禁止
//! 符号,Tauri 原生拖放事件与 HTML5 `drop` 都不触发(实测两个窗口的 Win32 样式完全
//! 一致,差别只在 `OleDropTargetInterface` 落在哪些子窗口上)。
//!
//! # 做法
//!
//! 窗口创建后延迟重试,等 WebView2 子窗口出现,再照 wry 的同一手法
//! (`RevokeDragDrop` + `RegisterDragDrop`)给**顶层窗口及其全部后代**补注入自己的
//! `IDropTarget`;收到拖放后按 Tauri 原生拖放事件**同样的名字与载荷**发出
//! `tauri://drag-enter|over|drop|leave` —— 前端 `onDragDropEvent` 无需任何改动。
//!
//! **通用**:只对显式传入 label 的窗口生效,调用方传自己的窗口 label(目前是
//! 编辑器窗口与对比窗口),不碰主窗口。
use tauri::AppHandle;
/// 给指定窗口补注入拖放支持(Windows 专用;其它平台直接返回 `Ok`)。
#[tauri::command]
#[specta::specta]
pub fn window_attach_drag_drop(app: AppHandle, label: String) -> Result<(), String> {
#[cfg(windows)]
{
imp::spawn_attach(app, label);
Ok(())
}
#[cfg(not(windows))]
{
let _ = (app, label);
Ok(())
}
}
#[cfg(windows)]
mod imp {
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::ffi::OsString;
use std::os::windows::ffi::OsStringExt;
use std::sync::{mpsc, Mutex, OnceLock};
use std::time::Duration;
use tauri::{AppHandle, Emitter, EventTarget, Manager};
use windows62::core::{implement, Ref, BOOL};
use windows62::Win32::Foundation::{HWND, LPARAM, POINT, POINTL};
use windows62::Win32::Graphics::Gdi::ScreenToClient;
use windows62::Win32::System::Com::{IDataObject, DVASPECT_CONTENT, FORMATETC, TYMED_HGLOBAL};
use windows62::Win32::System::Ole::{
IDropTarget, IDropTarget_Impl, RegisterDragDrop, RevokeDragDrop, CF_HDROP, DROPEFFECT,
DROPEFFECT_COPY, DROPEFFECT_NONE,
};
use windows62::Win32::System::SystemServices::MODIFIERKEYS_FLAGS;
use windows62::Win32::UI::Shell::{DragFinish, DragQueryFileW, HDROP};
use windows62::Win32::UI::WindowsAndMessaging::{EnumChildWindows, GetClassNameW};
/// 重试节奏:WebView2 的渲染子窗口在窗口显示后才陆续出现,前几秒足以覆盖。
const RETRY_INTERVAL: Duration = Duration::from_millis(400);
/// 重试次数上限(400ms × 24 ≈ 10s,与前端窗口冷启动量级一致)。
const MAX_RETRY: u32 = 24;
/// 已注入的 drop target 集合。
///
/// `RegisterDragDrop` 只保存裸指针,**对象必须由我们保持存活**(同 wry 的
/// `DragDropController::drop_targets`)。接口对象是 STA 私有的、实际只在主线程
/// 访问,这里标 `Send`/`Sync` 仅为能放进全局表。
/// 字段本身从不读取:它的唯一作用是**持有引用**,让 `RegisterDragDrop`
/// 存下的裸指针在窗口存活期间始终有效。
struct TargetSet(#[allow(dead_code)] Vec<IDropTarget>);
unsafe impl Send for TargetSet {}
unsafe impl Sync for TargetSet {}
static INJECTED: OnceLock<Mutex<HashMap<String, TargetSet>>> = OnceLock::new();
fn injected() -> &'static Mutex<HashMap<String, TargetSet>> {
INJECTED.get_or_init(|| Mutex::new(HashMap::new()))
}
// EnumChildWindows 的回调只带 LPARAM,用线程局部变量收集最省事(回调同步执行)。
thread_local! {
static FOUND: RefCell<Vec<HWND>> = const { RefCell::new(Vec::new()) };
}
unsafe extern "system" fn collect_child(hwnd: HWND, _lparam: LPARAM) -> BOOL {
FOUND.with(|v| v.borrow_mut().push(hwnd));
BOOL(1)
}
/// 顶层窗口 + 全部后代(WebView2 的 `Chrome_*`、`WRY_WEBVIEW` 等都在其中)。
fn window_and_descendants(hwnd: HWND) -> Vec<HWND> {
FOUND.with(|v| v.borrow_mut().clear());
let _ = unsafe { EnumChildWindows(Some(hwnd), Some(collect_child), LPARAM(0)) };
let descendants: Vec<HWND> = FOUND.with(|v| v.borrow().clone());
let mut all = Vec::with_capacity(descendants.len() + 1);
all.push(hwnd);
all.extend(descendants);
all
}
fn class_name(hwnd: HWND) -> String {
let mut buf = [0u16; 128];
let len = unsafe { GetClassNameW(hwnd, &mut buf) }.max(0) as usize;
OsString::from_wide(&buf[..len.min(buf.len())])
.to_string_lossy()
.to_string()
}
/// 是否已经出现 WebView2 的**渲染**子窗口。
///
/// 判据用 `Chrome_RenderWidgetHostHWND`(Chromium 最后创建的那个),而不是
/// 「任意 `Chrome_*`」——`Chrome_WidgetWin_0` 出现得更早,用它当"就绪"会过早
/// 停止重试,导致真正的落点(RenderWidget)没有 drop target。
fn has_render_host(hwnds: &[HWND]) -> bool {
hwnds
.iter()
.any(|h| class_name(*h).contains("RenderWidgetHost"))
}
#[implement(IDropTarget)]
struct WindowDropTarget {
hwnd: HWND,
app: AppHandle,
label: String,
cursor_effect: Cell<DROPEFFECT>,
enter_valid: Cell<bool>,
}
impl WindowDropTarget {
fn emit(&self, event: &str, payload: serde_json::Value) {
if let Err(e) = self.app.emit_to(
EventTarget::AnyLabel {
label: self.label.clone(),
},
event,
payload,
) {
crate::logger::log_warn("drag-drop", &format!("发送拖放事件失败: {e}"));
}
}
/// 从 `IDataObject` 取 CF_HDROP 里的文件路径。
///
/// 同时把 `HDROP` 交回调用方:**只能在 `Drop` 里 `DragFinish`**,
/// `DragEnter`/`DragOver` 阶段释放会让后续拿不到数据。
unsafe fn collect_paths(data: Ref<'_, IDataObject>) -> Option<(HDROP, Vec<String>)> {
let format = FORMATETC {
cfFormat: CF_HDROP.0,
ptd: std::ptr::null_mut(),
dwAspect: DVASPECT_CONTENT.0,
lindex: -1,
tymed: TYMED_HGLOBAL.0 as u32,
};
let medium = data.as_ref()?.GetData(&format).ok()?;
let hdrop = HDROP(medium.u.hGlobal.0 as _);
let count = DragQueryFileW(hdrop, u32::MAX, None);
let mut paths = Vec::with_capacity(count as usize);
for index in 0..count {
let len = DragQueryFileW(hdrop, index, None) as usize;
let mut buf = vec![0u16; len + 1];
DragQueryFileW(hdrop, index, Some(&mut buf));
paths.push(OsString::from_wide(&buf[..len]).to_string_lossy().to_string());
}
Some((hdrop, paths))
}
/// 屏幕坐标 → 客户区坐标(与 wry 一致,前端拿到的是相对 webview 的位置)。
fn client_pos(&self, point: &POINTL) -> (i32, i32) {
let mut pt = POINT {
x: point.x,
y: point.y,
};
let _ = unsafe { ScreenToClient(self.hwnd, &mut pt) };
(pt.x, pt.y)
}
}
#[allow(non_snake_case)]
impl IDropTarget_Impl for WindowDropTarget_Impl {
fn DragEnter(
&self,
pDataObj: Ref<'_, IDataObject>,
_grfKeyState: MODIFIERKEYS_FLAGS,
pt: &POINTL,
pdwEffect: *mut DROPEFFECT,
) -> windows62::core::Result<()> {
let (x, y) = self.client_pos(pt);
let found = unsafe { WindowDropTarget::collect_paths(pDataObj) };
let valid = found.is_some();
self.enter_valid.set(valid);
if let Some((_hdrop, paths)) = found {
self.emit(
"tauri://drag-enter",
serde_json::json!({ "paths": paths, "position": { "x": x, "y": y } }),
);
}
let effect = if valid { DROPEFFECT_COPY } else { DROPEFFECT_NONE };
unsafe { *pdwEffect = effect };
self.cursor_effect.set(effect);
Ok(())
}
fn DragOver(
&self,
_grfKeyState: MODIFIERKEYS_FLAGS,
pt: &POINTL,
pdwEffect: *mut DROPEFFECT,
) -> windows62::core::Result<()> {
if self.enter_valid.get() {
let (x, y) = self.client_pos(pt);
self.emit(
"tauri://drag-over",
serde_json::json!({ "position": { "x": x, "y": y } }),
);
}
unsafe { *pdwEffect = self.cursor_effect.get() };
Ok(())
}
fn DragLeave(&self) -> windows62::core::Result<()> {
if self.enter_valid.get() {
self.emit("tauri://drag-leave", serde_json::json!(null));
}
Ok(())
}
fn Drop(
&self,
pDataObj: Ref<'_, IDataObject>,
_grfKeyState: MODIFIERKEYS_FLAGS,
pt: &POINTL,
pdwEffect: *mut DROPEFFECT,
) -> windows62::core::Result<()> {
if self.enter_valid.get() {
let (x, y) = self.client_pos(pt);
if let Some((hdrop, paths)) = unsafe { WindowDropTarget::collect_paths(pDataObj) } {
self.emit(
"tauri://drag-drop",
serde_json::json!({ "paths": paths, "position": { "x": x, "y": y } }),
);
unsafe { DragFinish(hdrop) };
}
}
unsafe { *pdwEffect = DROPEFFECT_COPY };
Ok(())
}
}
/// 在**主线程**给该窗口补注入(OLE/COM 必须在初始化过 OLE 的线程上操作)。
/// 返回 true 表示 WebView2 子窗口已就位,后续无需再扫。
fn inject_now(app: &AppHandle, label: &str) -> bool {
let Some(window) = app.get_webview_window(label) else {
crate::logger::log_warn("drag-drop", &format!("补注入:找不到窗口 {label}"));
return true;
};
let Ok(hwnd) = window.hwnd() else {
crate::logger::log_warn("drag-drop", &format!("补注入:取不到 hwnd({label})"));
return false;
};
let all = window_and_descendants(hwnd);
let ready = has_render_host(&all);
let mut targets = Vec::with_capacity(all.len());
let mut ok = 0usize;
let mut failed = 0usize;
for child in all {
let target: IDropTarget = WindowDropTarget {
hwnd: child,
app: app.clone(),
label: label.to_string(),
cursor_effect: Cell::new(DROPEFFECT_NONE),
enter_valid: Cell::new(false),
}
.into();
// 与 wry 同一手法:先撤销(把它早期注入的空壳换掉),再注册自己的
let _ = unsafe { RevokeDragDrop(child) };
match unsafe { RegisterDragDrop(child, &target) } {
Ok(()) => {
ok += 1;
targets.push(target);
}
Err(e) => {
failed += 1;
crate::logger::log_warn(
"editor",
&format!(
"补注入:RegisterDragDrop 失败 class={} err={e}",
class_name(child)
),
);
}
}
}
crate::logger::log_info(
"editor",
&format!("补注入:{label} 后代={} 成功={ok} 失败={failed} ready={ready}", targets.len() + failed),
);
if let Ok(mut map) = injected().lock() {
map.insert(label.to_string(), TargetSet(targets));
}
ready
}
/// 后台线程:等到窗口与子窗口都就位后注入;窗口提前关闭则放弃。
pub fn spawn_attach(app: AppHandle, label: String) {
crate::logger::log_info("drag-drop", &format!("补注入:收到请求 label={label}"));
std::thread::spawn(move || {
for _ in 0..MAX_RETRY {
std::thread::sleep(RETRY_INTERVAL);
if app.get_webview_window(&label).is_none() {
crate::logger::log_info("drag-drop", &format!("补注入:窗口已关闭,放弃 {label}"));
if let Ok(mut map) = injected().lock() {
map.remove(&label);
}
return;
}
let (tx, rx) = mpsc::channel::<bool>();
let app_main = app.clone();
let label_main = label.clone();
if let Err(e) = app.run_on_main_thread(move || {
let _ = tx.send(inject_now(&app_main, &label_main));
}) {
crate::logger::log_warn("drag-drop", &format!("补注入:run_on_main_thread 失败 {e}"));
return;
}
// 主线程执行完再决定是否继续(超时按"未就绪"处理)
if matches!(rx.recv_timeout(Duration::from_secs(2)), Ok(true)) {
crate::logger::log_info("drag-drop", &format!("拖放补注入完成:{label}"));
return;
}
}
crate::logger::log_warn("drag-drop", &format!("拖放补注入未完成(子窗口未就位):{label}"));
});
}
}
+39 -1
View File
@@ -26,6 +26,7 @@
//! 还是 CRLF,否则一次「随手保存」就会在整个 diff 里掀起风暴。
use std::collections::HashSet;
use std::fs::Metadata;
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use std::time::UNIX_EPOCH;
@@ -293,8 +294,45 @@ fn read_file_inner(
if !meta.is_file() {
return Err("目标不是普通文件".to_string());
}
let bytes = std::fs::read(p).map_err(|e| format!("读取文件失败: {e}"))?;
build_doc(p, &meta, bytes, max_mb, forced_encoding)
}
/// 读取文件,复用调用方**已经读过**的头部(不重开文件、也不重读开头)。
///
/// 用途是对比模块:它必须「先读头部判断二进制、是文本才整读」(二进制要尽早放弃,
/// 不能整读),若先自己嗅探再调 `read_file`,同一个文件会被打开两次、开头读两遍。
/// 这里让调用方把**同一个句柄**(读位置已停在 `head` 之后)连同那段头部一起递进来,
/// 于是全程只打开一次;也顺带消掉「嗅探时与整读时文件已被换掉」的那个窗口。
///
/// `meta` 同样由调用方传入(它刚读过一次 `metadata`,两边都省一次 stat)。
pub(crate) fn read_file_after_head(
mut reader: impl std::io::Read,
path: &Path,
meta: &Metadata,
head: &[u8],
max_mb: u32,
) -> Result<FileDoc, String> {
let mut bytes = Vec::with_capacity(head.len());
bytes.extend_from_slice(head);
reader
.read_to_end(&mut bytes)
.map_err(|e| format!("读取文件失败: {e}"))?;
build_doc(path, meta, bytes, max_mb, None)
}
/// 读取链路的公共尾部:由「磁盘字节 + 元信息」组装 [`FileDoc`]。
///
/// 两个调用方共用 —— [`read_file_inner`](自己整读)与 [`read_file_after_head`]
/// (头部由调用方提供)。把这段独立出来是为了让「字节从哪来」与「字节怎么解释」解耦,
/// 而不是让解码 / 换行 / 元信息这段逻辑出现两份。
fn build_doc(
p: &Path,
meta: &Metadata,
bytes: Vec<u8>,
max_mb: u32,
forced_encoding: Option<&str>,
) -> Result<FileDoc, String> {
let encoding = match forced_encoding {
Some(enc) if !enc.trim().is_empty() => {
let requested = enc.trim();
+1 -1
View File
@@ -33,7 +33,7 @@ mod backup;
mod commands;
mod dirs;
mod export;
mod files;
pub(crate) mod files;
mod grep;
mod import;
mod index;
+12 -3
View File
@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
use specta::Type;
/// 结构版本号。字段增减时递增,由 [`EditorSettings::heal`] 推进。
pub const EDITOR_SETTINGS_VERSION: u32 = 4;
pub const EDITOR_SETTINGS_VERSION: u32 = 5;
/// 最近文件 / 文件夹各自的保留上限(超出淘汰最旧)。
pub const RECENT_LIMIT: usize = 20;
@@ -188,7 +188,8 @@ pub struct EditorSettings {
pub library_root: Option<String>,
/// 编辑器配色方案 key(`"system"` / `"vscode-dark"` / `"vscode-light"` / …)
pub editor_theme: String,
/// 编辑器配色是否跟随应用深浅(`editor_theme` 仅作取色基准)
/// 编辑器**窗口**是否跟随主应用主题(开:整体跟随应用;关:由 `editor_theme` 决定,
/// 窗口外壳与编辑区保持同一深浅)
pub follow_app_theme: bool,
/// 编辑器字体族(空串 = 用内置等宽字体栈)
pub font_family: String,
@@ -244,7 +245,7 @@ impl Default for EditorSettings {
version: EDITOR_SETTINGS_VERSION,
library_root: None,
editor_theme: "system".to_string(),
follow_app_theme: true,
follow_app_theme: false,
font_family: String::new(),
font_size: 14,
line_height: 1.7,
@@ -328,6 +329,14 @@ impl EditorSettings {
changed = true;
}
// v5:`followAppTheme` 的语义从「配色方案取色基准」改为「编辑器窗口是否跟随主应用
// 主题」,默认亦由「跟随」改为「不跟随」。仍是 true 说明用户从未改过这个值(旧默认),
// 此时改为不跟随;用户显式关过(false)的保持 false,不做任何覆盖。
if self.version < 5 && self.follow_app_theme {
self.follow_app_theme = false;
changed = true;
}
if self.version < EDITOR_SETTINGS_VERSION {
self.version = EDITOR_SETTINGS_VERSION;
changed = true;
+42 -6
View File
@@ -3,7 +3,9 @@ use tauri::Manager;
mod ai;
mod clipboard;
mod constants;
mod diff;
mod download_engine;
mod drag_drop;
mod dsh;
mod logger;
mod mihomo_manager;
@@ -19,6 +21,7 @@ mod secrets;
mod setup;
mod shortcut;
mod snap_fix;
mod taskbar_identity;
mod terminal;
mod translate;
mod tray_menu;
@@ -53,6 +56,11 @@ use editor::{
editor_move_path, editor_search_in_path, editor_replace_in_path,
editor_context_menu_status, editor_register_context_menu, editor_unregister_context_menu,
};
use diff::{
diff_compare_dirs, diff_get_settings, diff_path_kind, diff_read_file, diff_save_settings,
diff_write_file,
};
use drag_drop::window_attach_drag_drop;
use mihomo_manager::{
proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_connections, proxy_get_proxies, proxy_get_settings, proxy_get_system_proxy,
@@ -61,9 +69,9 @@ use mihomo_manager::{
proxy_test_delay, proxy_update_profile, proxy_version, MihomoManager,
};
use monitor_kernel::{
monitor_elevate_self, monitor_get_auto_start, monitor_get_elevate_on_launch,
monitor_get_auto_start, monitor_get_elevate_on_start,
monitor_get_hardware_config, monitor_get_snapshot, monitor_get_status, monitor_kernel_info,
monitor_repair_pawnio, monitor_set_auto_start, monitor_set_elevate_on_launch,
monitor_repair_pawnio, monitor_set_auto_start, monitor_set_elevate_on_start,
monitor_set_hardware_config, monitor_start, monitor_start_elevated, monitor_status, monitor_stop,
MonitorKernel,
};
@@ -185,6 +193,8 @@ use terminal::commands::{
terminal_ai_engines, terminal_ai_suggest,
};
use terminal::TerminalManager;
use taskbar_identity::window_set_taskbar_identity;
use win32_util::window_focus_window;
use translate::{
translate_abort, translate_ai_engine_remove, translate_ai_params_save, translate_apply_shortcuts,
translate_copy_text, translate_engine_delete, translate_engine_models, translate_engine_save,
@@ -361,6 +371,20 @@ fn export_bindings() {
editor_search_in_path, editor_replace_in_path,
// 系统集成(P4-4)
editor_context_menu_status, editor_register_context_menu, editor_unregister_context_menu,
// 编辑器窗口拖放补注入(Windows;wry 只在创建时扫一次子窗口,运行期创建的
// 编辑器窗口需要事后补注入才有 drop target)
window_attach_drag_drop,
// 对比模块:单文件读取 / 写回(编码探测复用 editor::files)+ 目录对比(只读)
diff_read_file,
diff_write_file,
diff_path_kind,
diff_compare_dirs,
diff_get_settings,
diff_save_settings,
// 子窗口任务栏身份(独立 AUMID + 组合图标)
window_set_taskbar_identity,
// 通用「显示 + 取消最小化 + 强制置前」(绕过 Windows 前台锁定)
window_focus_window,
])
.export(Typescript::default(), "../src/lib/bindings.ts")
.expect("failed to export bindings");
@@ -474,15 +498,14 @@ pub fn run() {
monitor_status,
monitor_start,
monitor_start_elevated,
monitor_elevate_self,
monitor_stop,
monitor_get_status,
monitor_repair_pawnio,
monitor_get_snapshot,
monitor_get_elevate_on_launch,
monitor_set_elevate_on_launch,
monitor_get_auto_start,
monitor_set_auto_start,
monitor_get_elevate_on_start,
monitor_set_elevate_on_start,
monitor_get_hardware_config,
monitor_set_hardware_config,
music_env_status,
@@ -883,7 +906,20 @@ pub fn run() {
// 系统集成(P4-4)
editor_context_menu_status,
editor_register_context_menu,
editor_unregister_context_menu
editor_unregister_context_menu,
// 编辑器窗口拖放补注入
window_attach_drag_drop,
// 对比模块:单文件读取 / 写回 + 目录对比(只读)+ 设置
diff_read_file,
diff_write_file,
diff_path_kind,
diff_compare_dirs,
diff_get_settings,
diff_save_settings,
// 子窗口任务栏身份(独立 AUMID + 组合图标)
window_set_taskbar_identity,
// 通用「显示 + 取消最小化 + 强制置前」
window_focus_window
])
.setup(setup::init)
.on_window_event(|window, event| {
+49 -115
View File
@@ -142,6 +142,10 @@ pub struct MonitorSettings {
/// 应用启动时自动启动监控内核(默认 false)
#[serde(default)]
pub auto_start: bool,
/// 启动内核时使用提权模式(通过 UAC 以管理员权限启动,Thing 自身保持普通权限)。
/// 由"提权内核"操作写入,使提权状态在应用重启后(自动启动路径)得以保持。
#[serde(default)]
pub elevate_on_start: bool,
}
/// 监控设置文件路径: {app_data_dir}/monitor/settings.json
@@ -167,59 +171,6 @@ pub fn save_monitor_settings(app_data_dir: &std::path::Path, settings: &MonitorS
fs::write(path, content).map_err(|e| format!("写入设置失败: {}", e))
}
// ===================== 永久提权标志持久化 =====================
/// 永久提权标志文件路径: {app_data_dir}/monitor/elevate.json
/// 内容: { "enabled": true }
fn elevate_flag_path(app_data_dir: &std::path::Path) -> PathBuf {
app_data_dir.join("monitor").join("elevate.json")
}
/// 读取永久提权标志
fn read_elevate_flag(flag_path: &std::path::Path) -> bool {
match fs::read_to_string(flag_path) {
Ok(content) => serde_json::from_str::<serde_json::Value>(&content)
.ok()
.and_then(|v| v.get("enabled").and_then(|e| e.as_bool()))
.unwrap_or(false),
Err(_) => false,
}
}
/// 写入永久提权标志
fn write_elevate_flag(flag_path: &std::path::Path, enabled: bool) -> Result<(), String> {
if let Some(parent) = flag_path.parent() {
fs::create_dir_all(parent).map_err(|e| format!("创建目录失败: {}", e))?;
}
let content = serde_json::json!({ "enabled": enabled }).to_string();
fs::write(flag_path, content).map_err(|e| format!("写入提权标志失败: {}", e))
}
/// 启动时检查永久提权标志,如果已设置且当前非管理员,则 ShellExecute "runas" 重启自身。
/// 在 `setup` 早期调用(MonitorKernel 初始化之前)。
/// 返回 true 表示已触发提权重启,调用方应立即退出当前进程。
pub fn check_and_relaunch_if_needed(app_data_dir: &std::path::Path) -> bool {
let flag_path = elevate_flag_path(app_data_dir);
if !read_elevate_flag(&flag_path) {
return false;
}
if is_thing_elevated() {
return false; // 已是管理员,无需重启
}
let exe = match std::env::current_exe() {
Ok(e) => e,
Err(_) => return false,
};
crate::logger::log_info("monitor", "检测到永久提权标志,以管理员权限重启 Thing");
match shell_execute_elevated(&exe.to_string_lossy(), "", None) {
Ok(()) => true,
Err(e) => {
crate::logger::log_warn("monitor", &format!("永久提权重启失败(用户可能取消了 UAC): {}", e));
false
}
}
}
// ===================== 数据结构 =====================
/// Kernel /status 响应(与 ThingHK Contracts.cs KernelStatus 对应)
@@ -322,16 +273,6 @@ impl MonitorKernel {
self.elevated.load(Ordering::SeqCst)
}
/// 永久提权标志是否已启用(后续启动自动触发 UAC)
pub fn elevate_on_launch(&self) -> bool {
read_elevate_flag(&self.root.join("elevate.json"))
}
/// 设置/清除永久提权标志
pub fn set_elevate_on_launch(&self, enabled: bool) -> Result<(), String> {
write_elevate_flag(&self.root.join("elevate.json"), enabled)
}
/// 读取监控设置(auto_start 等)
pub fn load_settings(&self) -> MonitorSettings {
load_monitor_settings(&self.root.parent().unwrap_or(&self.root).to_path_buf())
@@ -685,6 +626,10 @@ impl MonitorKernel {
/// - 如果是提权 Kernel(isAdmin=true):直接接管,设置 elevated=true,跳过 ProcessManager 启动
/// - 如果是普通权限 Kernel:调用 /shutdown 停止后重新启动
///
/// 提权偏好模式(Thing 普通、ThingHK 提权,elevateOnStart=true):
/// - 端口无内核运行时,走 start_elevated(ShellExecuteW "runas" 弹 UAC),
/// 使提权状态在应用重启后的自动启动路径上得以保持
///
/// 永久提权模式(Thing 自身是管理员):
/// - ThingHK 通过 ProcessManager 启动,子进程继承管理员权限
/// - 设置 elevated=true 表示 ThingHK 在管理员权限下运行
@@ -734,6 +679,21 @@ impl MonitorKernel {
}
}
// 提权偏好:Thing 自身非管理员时,按偏好以管理员权限启动内核(弹 UAC)。
// 偏好由 monitor_start_elevated 写入,使提权状态在应用重启后(自动启动)仍能保持。
if !thing_elevated && self.load_settings().elevate_on_start {
crate::logger::log_info("monitor", "按提权偏好启动 ThingHK 内核");
self.start_elevated(app).await?;
// 提权模式下内核不归 ProcessManager 管理,pid 不可查询
return Ok(crate::process_manager::ProcessInfo {
id: PROCESS_ID.into(),
name: "ThingHK".into(),
status: crate::process_manager::ProcessStatus::Running,
pid: None,
restart_count: 0,
});
}
let pm = app.state::<ProcessManager>();
let params = self.prepare_for_start(app)?;
let info = pm.start(params)?;
@@ -824,6 +784,14 @@ impl MonitorKernel {
}
self.elevated.store(true, Ordering::SeqCst);
// 记住提权偏好:后续启动(含应用重启后的自动启动)沿用提权模式
let mut settings = self.load_settings();
if !settings.elevate_on_start {
settings.elevate_on_start = true;
if let Err(e) = self.save_settings(&settings) {
crate::logger::log_warn("monitor", &format!("保存提权偏好失败: {}", e));
}
}
crate::logger::log_info("monitor", "提权启动已发起,等待 Kernel ready");
// 5. 启动 SSE 订阅(提权模式不注册 register_auto_reconnect:
@@ -961,40 +929,6 @@ pub async fn monitor_start_elevated(
state.start_elevated(&app).await
}
/// 永久提权:以管理员权限重启 Thing 自身,并持久化标志使后续启动自动提权。
/// - 已是管理员:仅设置标志,不重启
/// - 非管理员:设置标志 + ShellExecute "runas" 重启 + 退出当前进程
#[tauri::command]
pub async fn monitor_elevate_self(
state: tauri::State<'_, MonitorKernel>,
app: AppHandle,
) -> Result<(), String> {
#[cfg(windows)]
{
// 持久化标志:后续启动时 setup 检测到此标志会自动 ShellExecute "runas"
state.set_elevate_on_launch(true)?;
if is_thing_elevated() {
// 已是管理员,只需设置标志,无需重启
crate::logger::log_info("monitor", "Thing 已是管理员,仅设置永久提权标志");
return Ok(());
}
let exe = std::env::current_exe().map_err(|e| format!("获取当前路径失败: {}", e))?;
let exe_str = exe.to_string_lossy().to_string();
crate::logger::log_info("monitor", "永久提权:以管理员权限重启 Thing");
shell_execute_elevated(&exe_str, "", None)?;
// 退出当前进程(非提权),新的提权进程会接管
app.exit(0);
Ok(())
}
#[cfg(not(windows))]
{
let _ = (state, app);
Err("永久提权仅支持 Windows".into())
}
}
#[tauri::command]
pub async fn monitor_stop(
state: tauri::State<'_, MonitorKernel>,
@@ -1069,24 +1003,6 @@ pub async fn monitor_get_snapshot(state: tauri::State<'_, MonitorKernel>) -> Res
state.get_snapshot().await
}
/// 查询永久提权标志是否已启用
#[tauri::command]
pub fn monitor_get_elevate_on_launch(
state: tauri::State<'_, MonitorKernel>,
) -> bool {
state.elevate_on_launch()
}
/// 设置/清除永久提权标志。
/// 清除后,下次启动不再触发 UAC(当前会话权限不变)。
#[tauri::command]
pub fn monitor_set_elevate_on_launch(
state: tauri::State<'_, MonitorKernel>,
enabled: bool,
) -> Result<(), String> {
state.set_elevate_on_launch(enabled)
}
/// 查询"应用启动时自动启动监控内核"是否已启用
#[tauri::command]
pub fn monitor_get_auto_start(
@@ -1106,6 +1022,24 @@ pub fn monitor_set_auto_start(
state.save_settings(&settings)
}
/// 查询"内核启动时以管理员权限运行"(提权偏好)是否已启用
#[tauri::command]
pub fn monitor_get_elevate_on_start(state: tauri::State<'_, MonitorKernel>) -> bool {
state.load_settings().elevate_on_start
}
/// 设置提权偏好:启用后内核启动(含应用重启后的自动启动)将以管理员权限运行(弹 UAC)。
/// 由"提权内核"操作自动开启;关闭后内核启动回到普通权限。
#[tauri::command]
pub fn monitor_set_elevate_on_start(
state: tauri::State<'_, MonitorKernel>,
enabled: bool,
) -> Result<(), String> {
let mut settings = state.load_settings();
settings.elevate_on_start = enabled;
state.save_settings(&settings)
}
/// 查询硬件监控配置(透传 Kernel GET /config/hardware)。
/// 返回当前配置 + 可用硬件/传感器类型清单,供前端 Dialog 渲染。
#[tauri::command]
+9
View File
@@ -224,6 +224,15 @@ impl AudioEngine {
}
}
/// 当前音量与静音位(0.0~1.0)。
/// 供托盘菜单读取显示;跨曲目沿用同一组值(切歌不重置)。
pub fn volume(&self) -> (f32, bool) {
(
f32::from_bits(self.volume.load(Ordering::Relaxed)),
self.muted.load(Ordering::Relaxed),
)
}
pub fn state(&self) -> AudioState {
let Some(s) = self.current() else {
return AudioState {
+9 -7
View File
@@ -18,13 +18,14 @@ use crate::ai::AiManager;
use crate::download_engine::{DownloadEngine, ExtensionServer};
use crate::logger::LogManager;
use crate::mihomo_manager::MihomoManager;
use crate::monitor_kernel::{MonitorKernel, check_and_relaunch_if_needed};
use crate::monitor_kernel::MonitorKernel;
use crate::music::MusicManager;
use crate::network_monitor::NetworkMonitor;
use crate::editor::EditorManager;
use crate::process_manager::{ProcessManager, start_monitoring_thread};
use crate::terminal::TerminalManager;
use crate::translate::TranslateManager;
use crate::diff::DiffManager;
/// 应用启动初始化入口(setup 闭包调用)。
/// 初始化顺序即依赖顺序:日志 → 数据目录 → 各管理器 → 托盘 → 进程监控 → 自动启动。
@@ -45,12 +46,6 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
.app_data_dir()
.unwrap_or_else(|_| std::path::PathBuf::from("."));
// 永久提权检查:如果标志已设置且当前非管理员,以管理员权限重启自身并退出
// 必须在所有模块初始化之前执行(此时无资源需要清理)
if check_and_relaunch_if_needed(&app_data_dir) {
std::process::exit(0);
}
// ===== 代理模块:MihomoManager =====
let mihomo = MihomoManager::new(app_data_dir.clone());
app.manage(mihomo);
@@ -99,6 +94,13 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
crate::editor::remember_pending_target(target);
}
// ===== 对比模块:DiffManager =====
// 只承担设置的读写与「打开对比窗口」全局快捷键(默认 Alt+C)的注册;
// 左右目标(比哪两个文件 / 目录)是前端会话状态,Rust 侧不需要知道。
let diff = DiffManager::new(app_data_dir.clone());
diff.init_on_launch(app.handle());
app.manage(diff);
// ===== 翻译模块:TranslateManager =====
// 仅注册状态:设置与密钥都在命令调用时按需读取,启动阶段不发任何网络请求
// (模型可用性校验因此改为懒校验:首次翻译失败时解释原因 + 设置页手动拉取模型列表)。
+281
View File
@@ -0,0 +1,281 @@
//! 子窗口的「任务栏身份」:窗口级 AppUserModelID + 自定义窗口图标。
//!
//! # 为什么需要它
//!
//! 应用启动时用 [`crate::win32_util::set_app_user_model_id`] 设置了**进程级** AUMID
//! (`thing.lfeng.me`,与安装包写进开始菜单快捷方式的标识一致),好处是系统托盘/媒体面板
//! 能认出本应用;代价是 Windows 任务栏按 AUMID 分组 —— 编辑器、终端等**子窗口全都和主窗口
//! 合并成一个按钮、共用主程序图标**,最小化后根本分不清谁是谁。
//!
//! 本模块给子窗口做两件事:
//!
//! 1. **窗口级 AUMID**(`PKEY_AppUserModel_ID`,见 `win32_util::set_window_app_user_model_id`):
//! 覆盖进程级值 → 该窗口独立成组 → 任务栏多出一个自己的按钮;
//! 2. **自定义窗口图标**:底图是该窗口类型的功能图形(现在是「文档」代表编辑器),右下角
//! 叠加**主程序图标**,一眼能看出「这是 Thing 的哪个子窗口」。
//!
//! # 时机
//!
//! 必须在窗口**首次 `show()` 之前**调用:任务栏按钮在窗口显示时创建并按 AUMID 分组。
//! 编辑器窗口正是「隐藏创建 → 前端应用完主题再 show」,中间这段窗口期刚好可以设置。
//! 前端调用点见 `EditorWindow.vue`。
use tauri::Manager;
use crate::logger;
/// 主程序 AUMID(与开始菜单快捷方式 / Tauri identifier 一致);子窗口在其后缀派生。
const APP_AUMID: &str = "thing.lfeng.me";
/// 主程序图标 PNG(随二进制打包,保证与安装包图标一致)
const APP_ICON_PNG: &[u8] = include_bytes!("../icons/128x128.png");
/// 输出图标边长(任务栏会自行缩放到 16/32/48…,用大图更清晰)
const ICON_SIZE: u32 = 256;
/// 右下角主程序图标的边长
const BADGE_SIZE: u32 = 100;
/// 支持的窗口类型(同时作为 AUMID 后缀与图形选择键)。
/// 新增一类子窗口时:在此登记 + 在 [`draw_glyph`] / [`glyph_accent`] 加一个分支。
const SUPPORTED_KINDS: &[&str] = &["editor", "terminal", "files", "download", "dsh", "diff"];
/// 设置某个窗口的任务栏身份(独立 AUMID + 组合图标)。
///
/// 由窗口自身在 `show()` 之前调用(`label` 传自己的窗口 label)。
#[tauri::command]
#[specta::specta]
pub fn window_set_taskbar_identity(
app: tauri::AppHandle,
label: String,
kind: String,
) -> Result<(), String> {
let Some(window) = app.get_webview_window(&label) else {
return Err(format!("窗口不存在: {label}"));
};
if !SUPPORTED_KINDS.contains(&kind.as_str()) {
return Err(format!("不支持的窗口类型: {kind}"));
}
#[cfg(windows)]
{
let hwnd = window.hwnd().map_err(|e| format!("取窗口句柄失败: {e}"))?;
let aumid = format!("{APP_AUMID}.{kind}");
crate::win32_util::set_window_app_user_model_id(hwnd.0 as isize, &aumid)?;
}
let icon = compose_icon(&kind)?;
window.set_icon(icon).map_err(|e| format!("设置窗口图标失败: {e}"))?;
logger::log_info("window", &format!("任务栏身份已设置: {label} kind={kind}"));
Ok(())
}
/// 组合图标:功能图形铺底(圆角色块),右下角叠加主程序图标。
fn compose_icon(kind: &str) -> Result<tauri::image::Image<'static>, String> {
use image::{Rgba, RgbaImage};
let accent = glyph_accent(kind);
let pad = 10;
let radius = 56;
// 底:圆角色块(透明度即「可见区域」,最后据此裁剪,避免角标溢出圆角)
let mut base = RgbaImage::from_pixel(ICON_SIZE, ICON_SIZE, Rgba([0, 0, 0, 0]));
fill_rounded_rect(&mut base, pad, pad, ICON_SIZE - pad, ICON_SIZE - pad, radius, accent);
// 上层:功能图形 + 角标(先画在独立图层,最后按底色裁剪合成)
let mut layer = RgbaImage::from_pixel(ICON_SIZE, ICON_SIZE, Rgba([0, 0, 0, 0]));
draw_glyph(&mut layer, kind, accent);
let badge_from = ICON_SIZE - BADGE_SIZE - 14;
fill_rounded_rect(
&mut layer,
badge_from.saturating_sub(6),
badge_from.saturating_sub(6),
badge_from + BADGE_SIZE + 6,
badge_from + BADGE_SIZE + 6,
24,
Rgba([255, 255, 255, 255]),
);
let app_icon = image::load_from_memory(APP_ICON_PNG)
.map_err(|e| format!("解码主程序图标失败: {e}"))?
.to_rgba8();
let badge = image::imageops::resize(
&app_icon,
BADGE_SIZE,
BADGE_SIZE,
image::imageops::FilterType::Lanczos3,
);
image::imageops::overlay(&mut layer, &badge, badge_from as i64, badge_from as i64);
// 合成:底色不透明处才写入图层内容
let mut out = base.clone();
for (x, y, px) in layer.enumerate_pixels() {
if px.0[3] > 0 && base.get_pixel(x, y).0[3] > 0 {
blend_pixel(&mut out, x, y, *px);
}
}
Ok(tauri::image::Image::new_owned(out.into_raw(), ICON_SIZE, ICON_SIZE))
}
/// 各窗口类型的主色(圆角色块底色)。
fn glyph_accent(kind: &str) -> image::Rgba<u8> {
match kind {
// 终端:深板岩
"terminal" => image::Rgba([15, 23, 42, 255]),
// 文件管理:琥珀
"files" => image::Rgba([245, 158, 11, 255]),
// 下载:天蓝
"download" => image::Rgba([14, 165, 233, 255]),
// dsh:紫罗兰
"dsh" => image::Rgba([124, 58, 237, 255]),
// 对比:青碧(与下载的「天蓝」在缩略尺寸下仍可区分)
"diff" => image::Rgba([13, 148, 136, 255]),
// 编辑器(默认):靛蓝
_ => image::Rgba([79, 70, 229, 255]),
}
}
/// 画各窗口类型的功能图形(画在透明图层上,颜色自定)。
fn draw_glyph(img: &mut image::RgbaImage, kind: &str, accent: image::Rgba<u8>) {
use image::Rgba;
let white = Rgba([255, 255, 255, 255]);
match kind {
"terminal" => {
// 窗口主体 + 绿色标题栏 + 两行绿色提示符
let green = Rgba([34, 197, 94, 255]);
fill_rounded_rect(img, 58, 58, 198, 198, 20, white);
fill_rounded_rect(img, 58, 58, 198, 96, 20, green);
fill_rounded_rect(img, 58, 84, 198, 96, 0, green);
fill_rounded_rect(img, 84, 122, 176, 136, 7, green);
fill_rounded_rect(img, 84, 152, 146, 166, 7, green);
}
"files" => {
// 文件夹:左上标签 + 主体
fill_rounded_rect(img, 66, 62, 132, 96, 12, white);
fill_rounded_rect(img, 58, 84, 198, 198, 20, white);
}
"download" => {
// 向下箭头 + 托盘
fill_rounded_rect(img, 114, 56, 142, 132, 14, white);
fill_triangle(img, (128.0, 178.0), (82.0, 124.0), (174.0, 124.0), white);
fill_rounded_rect(img, 64, 150, 84, 198, 10, white);
fill_rounded_rect(img, 172, 150, 192, 198, 10, white);
fill_rounded_rect(img, 64, 178, 192, 198, 10, white);
}
"dsh" => {
// 嵌套方框:外壳 / 内层 / 核心 —— 「harness」容器
fill_rounded_rect(img, 58, 58, 198, 198, 26, white);
fill_rounded_rect(img, 84, 84, 172, 172, 18, accent);
fill_rounded_rect(img, 106, 106, 150, 150, 10, white);
}
"diff" => {
// 双栏:左右两块面板,中间留出底色的缝隙 —— 一眼读出「两边对照」
fill_rounded_rect(img, 56, 62, 122, 194, 16, white);
fill_rounded_rect(img, 134, 62, 200, 194, 16, white);
}
_ => {
// 编辑器:白色纸张 + 主色文字行(最后一行短一点,更像正文)
fill_rounded_rect(img, 70, 44, 186, 214, 16, white);
let rows = [(92u32, 168u32), (120, 168), (148, 168), (176, 142)];
for (y, right) in rows {
fill_rounded_rect(img, 94, y, right, y + 12, 6, accent);
}
}
}
}
/// 填充三角形(下载箭头的箭头部分;边缘符号法判定内外)。
fn fill_triangle(
img: &mut image::RgbaImage,
a: (f32, f32),
b: (f32, f32),
c: (f32, f32),
color: image::Rgba<u8>,
) {
let min_x = a.0.min(b.0).min(c.0).floor().max(0.0) as u32;
let max_x = a.0.max(b.0).max(c.0).ceil().min(img.width() as f32) as u32;
let min_y = a.1.min(b.1).min(c.1).floor().max(0.0) as u32;
let max_y = a.1.max(b.1).max(c.1).ceil().min(img.height() as f32) as u32;
let edge = |p: (f32, f32), q: (f32, f32), r: (f32, f32)| {
(q.0 - p.0) * (r.1 - p.1) - (q.1 - p.1) * (r.0 - p.0)
};
for y in min_y..max_y {
for x in min_x..max_x {
let p = (x as f32 + 0.5, y as f32 + 0.5);
let (d1, d2, d3) = (edge(a, b, p), edge(b, c, p), edge(c, a, p));
let has_neg = d1 < 0.0 || d2 < 0.0 || d3 < 0.0;
let has_pos = d1 > 0.0 || d2 > 0.0 || d3 > 0.0;
if !(has_neg && has_pos) {
blend_pixel(img, x, y, color);
}
}
}
}
/// 填充圆角矩形(硬边;任务栏缩放到小尺寸后看不出锯齿)。
fn fill_rounded_rect(
img: &mut image::RgbaImage,
x0: u32,
y0: u32,
x1: u32,
y1: u32,
radius: u32,
color: image::Rgba<u8>,
) {
if color.0[3] == 0 || x1 <= x0 || y1 <= y0 {
return;
}
let (fx0, fy0, fx1, fy1) = (x0 as f32, y0 as f32, x1 as f32, y1 as f32);
let r = (radius as f32).min((fx1 - fx0) / 2.0).min((fy1 - fy0) / 2.0);
for y in y0..y1 {
let fy = y as f32 + 0.5;
for x in x0..x1 {
let fx = x as f32 + 0.5;
let dx = if fx < fx0 + r {
fx0 + r - fx
} else if fx > fx1 - r {
fx - (fx1 - r)
} else {
0.0
};
let dy = if fy < fy0 + r {
fy0 + r - fy
} else if fy > fy1 - r {
fy - (fy1 - r)
} else {
0.0
};
if dx * dx + dy * dy <= r * r {
blend_pixel(img, x, y, color);
}
}
}
}
/// 把 `src` 以 alpha 混合写到 `img` 的 (x, y)(不做边界外的处理)。
fn blend_pixel(img: &mut image::RgbaImage, x: u32, y: u32, src: image::Rgba<u8>) {
if x >= img.width() || y >= img.height() {
return;
}
let sa = src.0[3] as u32;
if sa == 0 {
return;
}
if sa == 255 {
img.put_pixel(x, y, src);
return;
}
let dst = img.get_pixel(x, y).0;
let inv = 255 - sa;
let mix = |s: u8, d: u8| ((s as u32 * sa + d as u32 * inv) / 255) as u8;
img.put_pixel(
x,
y,
image::Rgba([
mix(src.0[0], dst[0]),
mix(src.0[1], dst[1]),
mix(src.0[2], dst[2]),
(sa + dst[3] as u32 * inv / 255) as u8,
]),
);
}
+57 -6
View File
@@ -64,6 +64,21 @@ pub struct MusicState {
pub playing: bool,
pub title: String,
pub artist: String,
/// 当前音量(0.0~1.0)
pub volume: f32,
pub muted: bool,
}
/// 托盘调音量 / 静音后广播给主窗口前端的权威值(前端据此更新 ref 并落盘)。
///
/// 为什么不走 [`SMTC_BUTTON_EVENT`]:那条通道是「无负载字符串动作」,音量要带数值。
pub const TRAY_MUSIC_VOLUME_EVENT: &str = "tray-music-volume";
#[derive(Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct TrayVolumeState {
pub volume: f32,
pub muted: bool,
}
fn get_music_state(app: &AppHandle) -> MusicState {
@@ -71,6 +86,11 @@ fn get_music_state(app: &AppHandle) -> MusicState {
.try_state::<AudioEngine>()
.map(|e| e.state().playing)
.unwrap_or(false);
// 音量/静音取自引擎:托盘拖动滑块直接改的就是它,这里读到的是真实生效值
let (volume, muted) = app
.try_state::<AudioEngine>()
.map(|e| e.volume())
.unwrap_or((1.0, false));
let (title, artist) = app
.try_state::<SmtcMetaCache>()
.and_then(|c| c.0.lock().ok().map(|g| (g.title.clone(), g.artist.clone())))
@@ -79,6 +99,8 @@ fn get_music_state(app: &AppHandle) -> MusicState {
playing,
title,
artist,
volume,
muted,
}
}
@@ -504,11 +526,35 @@ pub fn tray_music_state(app: AppHandle) -> MusicState {
/// 托盘音乐控制条动作。
///
/// 动作统一经 [`SMTC_BUTTON_EVENT`] 转给主窗口前端(`feiniuStore`)执行——
/// 队列、洗牌、单曲循环等播放语义都在前端,托盘只负责转发,不重复实现。
/// `action`:`toggle` | `play` | `pause` | `next` | `prev`。
/// 播放语义(队列、洗牌、单曲循环等)都在前端,托盘只负责转发:
/// - 播放/暂停/上下首/切换播放顺序 → [`SMTC_BUTTON_EVENT`] 转给主窗口前端(`feiniuStore`)执行;
/// - 音量与静音**直接改 Rust 侧引擎**(拖动滑块要即时出声,不能等一轮事件往返),
/// 改完把权威值经 [`TRAY_MUSIC_VOLUME_EVENT`] 广播给前端,由它更新 ref 并落盘。
///
/// `action`:`toggle` | `play` | `pause` | `next` | `prev` | `toggle-mode` | `volume` | `toggle-mute`。
/// `level`:仅 `volume` 需要(0.0~1.0)。
#[tauri::command]
pub fn tray_music_control(app: AppHandle, action: String) -> Result<(), String> {
pub fn tray_music_control(
app: AppHandle,
action: String,
level: Option<f32>,
) -> Result<(), String> {
if action == "volume" || action == "toggle-mute" {
let engine = app.try_state::<AudioEngine>().ok_or("播放引擎未初始化")?;
let (cur, muted) = engine.volume();
if action == "volume" {
let v = level.ok_or("volume 动作缺少 level")?.clamp(0.0, 1.0);
// 调到非零即解除静音(与手机遥控的音量语义一致)
engine.set_volume(v, if v > 0.0 { false } else { muted });
} else {
engine.set_volume(cur, !muted);
}
let (volume, muted) = engine.volume();
return app
.emit(TRAY_MUSIC_VOLUME_EVENT, TrayVolumeState { volume, muted })
.map_err(|e| e.to_string());
}
let name = match action.as_str() {
"play" => "play",
"pause" => "pause",
@@ -522,6 +568,8 @@ pub fn tray_music_control(app: AppHandle, action: String) -> Result<(), String>
}
"next" => "next",
"prev" => "prev",
// 播放顺序(列表循环 / 单曲循环 / 随机)由前端维护,这里只转发
"toggle-mode" => "toggle-mode",
other => return Err(format!("未知的音乐控制动作: {other}")),
};
app.emit(SMTC_BUTTON_EVENT, name).map_err(|e| e.to_string())
@@ -539,8 +587,11 @@ pub async fn tray_menu_ready(content_height: f64, app: AppHandle) -> Result<(),
layout.unwrap_or((0.0, 1040.0, 0.0, 1080.0, 1.0))
};
// 将内容高度限制在合理范围内(前端上报为逻辑像素)
let h = content_height.max(100.0).min(520.0);
// 可用高度:光标所在位置到屏幕顶部的空间(菜单底部对齐光标向上展开)。
// 不再用固定上限,内容多时窗口按内容完整撑开;仅当内容超过可用空间时才收窄
// (此时前端 .tray-menu-scroll 退化为滚动)。
let avail_logical = (cursor_y - scr_top).max(0.0) / scale;
let h = content_height.max(100.0).min(avail_logical.max(100.0));
// 调整窗口尺寸(物理像素,与物理坐标定位保持一致,避免混合 DPI 换算偏移)
let win_w_px = MENU_W * scale;
+62
View File
@@ -21,6 +21,41 @@ pub fn set_app_user_model_id(app_id: &str) {
}
}
/// 给**单个窗口**设置 AppUserModelID(窗口级 AUMID),使其在任务栏**独立成组**。
///
/// 进程级 AUMID(见 [`set_app_user_model_id`])会让整个应用的所有窗口合并成一个任务栏
/// 按钮;子窗口想要自己的按钮与图标,就用窗口级 AUMID 覆盖它 —— 任务栏按窗口的
/// `PKEY_AppUserModel_ID` 决定分组,不同值即不同按钮。
///
/// **必须在窗口首次 `show()` 之前调用**:任务栏按钮在窗口显示时创建并按 AUMID 分组,
/// 显示之后再改往往要 hide/show 才重新生效。
///
/// 本函数由 Tauri 同步命令调用(跑在主线程,COM 已由 WebView2 初始化为 STA),
/// 因此不再自行 `CoInitializeEx`。
#[cfg(windows)]
pub fn set_window_app_user_model_id(hwnd: isize, app_id: &str) -> Result<(), String> {
use windows62::Win32::Foundation::HWND;
use windows62::Win32::Storage::EnhancedStorage::PKEY_AppUserModel_ID;
use windows62::Win32::System::Com::StructuredStorage::PROPVARIANT;
use windows62::Win32::UI::Shell::PropertiesSystem::{IPropertyStore, SHGetPropertyStoreForWindow};
// SAFETY: hwnd 来自当前进程的真实窗口,且在调用期间保持有效;PROPVARIANT 由 &str 构造。
unsafe {
let store: IPropertyStore = SHGetPropertyStoreForWindow(HWND(hwnd as *mut core::ffi::c_void))
.map_err(|e| format!("SHGetPropertyStoreForWindow 失败: {e}"))?;
let value: PROPVARIANT = app_id.into();
store
.SetValue(&PKEY_AppUserModel_ID, &value)
.map_err(|e| format!("写入 PKEY_AppUserModel_ID 失败: {e}"))?;
}
Ok(())
}
#[cfg(not(windows))]
pub fn set_window_app_user_model_id(_hwnd: isize, _app_id: &str) -> Result<(), String> {
Err("窗口级 AUMID 仅支持 Windows".into())
}
/// 获取鼠标位置(屏幕坐标,物理像素)
#[cfg(windows)]
pub fn get_cursor_pos() -> Option<(i32, i32)> {
@@ -141,6 +176,33 @@ pub fn force_foreground(hwnd: isize) {
}
}
/// 显示 + 取消最小化 + 强制置前(按窗口 label 定位)。
///
/// 前端 `setFocus()` 在 Windows 上同样受前台锁定限制(本进程不拥有前台时被忽略),
/// 表现就是「窗口明明开着却唤不到前面」。这里统一走原生
/// [`force_foreground`](SetForegroundWindow + BringWindowToTop),与下载窗口 /
/// 快速面板 / 托盘同一套做法。
///
/// 窗口不存在时**不报错**(已关闭 = 目标已达成),让调用方少写一层判空。
#[tauri::command]
#[specta::specta]
pub fn window_focus_window(app: tauri::AppHandle, label: String) -> Result<(), String> {
use tauri::Manager;
let Some(window) = app.get_webview_window(&label) else {
return Ok(());
};
window.show().map_err(|e| e.to_string())?;
window.unminimize().map_err(|e| e.to_string())?;
match window.hwnd() {
Ok(hwnd) => force_foreground(hwnd.0 as isize),
Err(_) => {
window.set_focus().ok();
}
}
Ok(())
}
/// 应用 WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW 扩展样式到指定窗口。
/// 用于预览窗等不抢焦点的悬浮窗:窗口可接收鼠标交互但不激活、不进 Alt-Tab。
#[cfg(windows)]
+30
View File
@@ -15,11 +15,13 @@ import { useQuickPanelStore } from '@/stores/quickpanelStore'
import { useMonitorStore } from '@/stores/monitorStore'
import { useProcessStore } from '@/stores/processStore'
import { useDshStore } from '@/stores/dshStore'
import { useEditorStore } from '@/stores/editorStore'
import { TooltipProvider } from '@/components/ui/tooltip'
import { moduleRegistry } from '@/modules/registry'
import type { ModuleMeta } from '@/types/module'
import { openTerminalPickerWindow } from '@/modules/terminal/openWindow'
import { openEditorWindow } from '@/modules/editor/openWindow'
import { openDiffWindow } from '@/modules/diff/openWindow'
import { EVENTS, STORAGE_KEYS, WINDOWS } from '@/lib/constants'
import { commands } from '@/lib/bindings'
@@ -30,6 +32,7 @@ const quickpanelStore = useQuickPanelStore()
const monitorStore = useMonitorStore()
const processStore = useProcessStore()
const dshStore = useDshStore()
const editorStore = useEditorStore()
/** 侧边栏 / 标题栏需要的模块信息(id + name + icon) */
interface NavModule {
@@ -261,6 +264,33 @@ onMounted(async () => {
void openEditorWindow().catch(e => console.error('[tray] 打开编辑器窗口失败:', e))
})
)
// 全局快捷键 Alt+E:打开 / 唤出编辑器窗口。
//
// **必须挂在应用级**(而非编辑器模块页里):快捷键要在任意模块下都能用 —— 挂在模块页
// 只有当编辑器页已挂载时才有效,于是「刚启动应用、还没进过编辑器页」时按 Alt+E 毫无反应
// (同 main.ts 里 dsh 快捷键的取舍:模块卸载不能把快捷键带走)。
trayUnlisteners.push(
await listen(EVENTS.editorOpenEditor, () => {
void openEditorWindow().catch(e => console.error('[shortcut] 打开编辑器窗口失败:', e))
})
)
// 全局快捷键 Alt+C:打开 / 唤出对比窗口(默认值,见 Rust `DiffSettings::default`)。
// 同样必须挂在应用级:快捷键要在任意模块下都能用,挂在对比模块页里会导致
// 「刚启动、还没进过对比页」时按了没反应(同上面 Alt+E 的取舍)。
trayUnlisteners.push(
await listen(EVENTS.diffOpenWindow, () => {
void openDiffWindow().catch(e => console.error('[shortcut] 打开对比窗口失败:', e))
})
)
// 全局快捷键 Ctrl+Shift+N:新建笔记。
// 对话框在编辑器模块页 → 先置挂起请求、再切到该页(模块挂载时消费,见 EditorModule);
// 同理不能放进模块页里监听,否则没进过编辑器页时按了没反应。
trayUnlisteners.push(
await listen(EVENTS.editorNewNote, () => {
editorStore.requestNewNote()
handleModuleChange('editor')
})
)
// 托盘「dsh」:就绪则直接开界面,否则先开启动进度窗口并同步拉起服务
trayUnlisteners.push(
await listen(EVENTS.trayOpenDsh, () => {
+160 -1
View File
@@ -1117,6 +1117,70 @@ export const commands = {
editorRegisterContextMenu: () => __TAURI_INVOKE<ContextMenuStatus>("editor_register_context_menu"),
/** 卸载右键菜单(删 HKCU 对应项)。 */
editorUnregisterContextMenu: () => __TAURI_INVOKE<ContextMenuStatus>("editor_unregister_context_menu"),
/** 给指定窗口补注入拖放支持(Windows 专用;其它平台直接返回 `Ok`)。 */
windowAttachDragDrop: (label: string) => __TAURI_INVOKE<null>("window_attach_drag_drop", { label }),
/**
* 读取对比窗口某一侧的文件。
*
* 复用 `editor::files::read_file`(编码探测 / 换行归一 / 只读探测),并顺带登记
* 授权 —— 于是该文件随后可以被 [`diff_write_file`] 写回。
*/
diffReadFile: (path: string) => __TAURI_INVOKE<DiffFileDoc>("diff_read_file", { path }),
/**
* 把某一侧的内容写回磁盘。
*
* `encoding` / `eol` 由前端回传**读取时探测到的值**,写回时原样还原 —— 一次「随手
* 保存」不该把 GBK 文件变成 UTF-8、把 CRLF 变成 LF(那会在整个 diff 里掀起风暴)。
*/
diffWriteFile: (path: string, content: string, encoding: string, eol: string) => __TAURI_INVOKE<DiffFileDoc>("diff_write_file", { path, content, encoding, eol }),
/**
* 探测一个路径是文件还是目录(`"dir"` / `"file"` / `"missing"`)。
*
* 用途:拖入或 `?path=` 传进来的路径前端拿不到文件系统元信息,而对比窗口需要据此
* 决定「进文件模式还是目录模式」。**刻意不新增 Rust 侧的状态**:只读一次 `metadata`,
* 不写盘、不需授权。
*/
diffPathKind: (path: string) => __TAURI_INVOKE<string>("diff_path_kind", { path }),
/**
* 对比两棵目录树(只读)。
*
* `skip_dirs` 是**目录名**清单(大小写不敏感):默认清单由前端给出(它是界面约定,
* 用户能否修改是 UI 的事),后端只负责按它执行 —— 同 `editor::grep` 把默认跳过清单
* 留在前端的取舍。
*
* 走 `spawn_blocking`:两遍目录遍历 + 最多 2000 次读盘都是同步阻塞 IO,放在 Tauri
* 命令线程上会占住它(范式同 `editor_search_in_path`)。
*
* `scan_id` 由前端生成并随进度事件原样回传:进度事件是全局的,多选项卡并发扫描时
* 前端据此只认自己那一轮(见 `constants::events::DIFF_SCAN_PROGRESS`)。
*/
diffCompareDirs: (scanId: number, left: string, right: string, skipDirs: string[], compareContent: boolean) => __TAURI_INVOKE<DirDiffReport>("diff_compare_dirs", { scanId, left, right, skipDirs, compareContent }),
/** 读取对比模块设置。 */
diffGetSettings: () => __TAURI_INVOKE<DiffSettings>("diff_get_settings"),
/**
* 保存对比模块设置。
*
* 保存后**就地重注册**全局快捷键(`register_shortcut` 会先注销本模块的旧键,因此
* 「清空快捷键」也能通过传空串生效)—— 同 `editor_save_settings`。
*/
diffSaveSettings: (settings: DiffSettings) => __TAURI_INVOKE<DiffSettings>("diff_save_settings", { settings }),
/**
* 设置某个窗口的任务栏身份(独立 AUMID + 组合图标)。
*
* 由窗口自身在 `show()` 之前调用(`label` 传自己的窗口 label)。
*/
windowSetTaskbarIdentity: (label: string, kind: string) => __TAURI_INVOKE<null>("window_set_taskbar_identity", { label, kind }),
/**
* 显示 + 取消最小化 + 强制置前(按窗口 label 定位)。
*
* 前端 `setFocus()` 在 Windows 上同样受前台锁定限制(本进程不拥有前台时被忽略),
* 表现就是「窗口明明开着却唤不到前面」。这里统一走原生
* [`force_foreground`](SetForegroundWindow + BringWindowToTop),与下载窗口 /
* 快速面板 / 托盘同一套做法。
*
* 窗口不存在时**不报错**(已关闭 = 目标已达成),让调用方少写一层判空。
*/
windowFocusWindow: (label: string) => __TAURI_INVOKE<null>("window_focus_window", { label }),
};
/* Types */
@@ -1608,6 +1672,98 @@ export type DeleteResult = {
error: string,
};
/**
* 对比窗口里**一侧**文件的状态。
*
* 刻意不复用 `FileDoc`:对比窗口需要额外的 `binary` 标记(二进制文件不进入文本
* diff,只报「不同」),而 `FileDoc` 是编辑器模块的对外契约,为对比工具加字段会
* 把「谁需要什么」搅在一起。
*/
export type DiffFileDoc = {
/** 绝对路径(Windows 下已剥掉 `\\?\` 前缀) */
path: string,
/** 显示名(文件名) */
name: string,
/** 文本内容(换行已统一为 `\n`,写回时按 `eol` 还原)。二进制文件为空串 */
content: string,
/** 探测到的编码(`utf-8` / `utf-8-bom` / `gbk` / …)。二进制文件为空串 */
encoding: string,
/** 换行风格:"lf" | "crlf"。二进制文件为空串 */
eol: string,
/** 文件字节数 */
size: number,
/** 最后修改时间(Unix 毫秒) */
modified: number,
/** 行数(二进制文件为 0) */
lines: number,
/** 是否超过「大文件」阈值(前端据此关掉折叠等高开销特性) */
large: boolean,
/** 是否只读(写权限探测失败) */
readonly: boolean,
/** 是否为二进制(头部含 NUL 字节):此类文件不渲染 diff */
binary: boolean,
};
/** 对比模块设置(持久化到 `{app_data_dir}/diff/settings.json`,范式同 editor / translate)。 */
export type DiffSettings = {
version?: number,
/**
* 全局快捷键:打开 / 唤出对比窗口(空串 = 不注册)。
*
* 走 `shortcut.rs` 的原子注册 + 冲突检测(与终端 / 翻译 / 编辑器同一套);触发时只发
* `diff-open-window` 事件,窗口由前端创建 —— Rust 侧不持窗口 label 策略。
*/
openDiffShortcut?: string,
/** 目录对比:默认是否比对内容(大小相同、时间戳不同时读文件逐字节比对) */
compareContent?: boolean,
/** 目录对比:默认是否跳过常见构建目录 */
skipBuildDirs?: boolean,
};
/**
* 目录对比中的一个条目(扁平列表,由前端组装成树)。
*
* `status` 取值:`left-only` / `right-only` / `different` / `identical` / `type-mismatch`
* (同名但一侧是文件、另一侧是目录)。
*/
export type DirDiffEntry = {
/** 相对根的路径,`/` 分隔(前端据此组装树,显示名自己从最后一段取) */
relPath: string,
/** 是否目录(type-mismatch 时为 true) */
isDir: boolean,
status: string,
/** 该侧的绝对路径;该侧不存在时为空串 */
leftPath: string,
rightPath: string,
/** 该侧字节数;不存在为 0 */
leftSize: number,
rightSize: number,
/** 该侧最后修改时间(Unix 毫秒);不存在为 0 */
leftModified: number,
rightModified: number,
/**
* 结论是否**由内容逐字节比对**得出。
*
* false 表示「大小相同、时间戳不同」且未读内容(体积超限 / 预算用尽),
* 此时 `different` 是**按时间戳**判定的 —— 界面要据此提示,不能与已确认的差异
* 用同一种语气呈现。
*/
contentCompared: boolean,
};
/** 一次目录对比的结果。 */
export type DirDiffReport = {
leftRoot: string,
rightRoot: string,
entries: DirDiffEntry[],
/** 条目数达到上限、遍历被截断(界面提示用户缩小范围) */
truncated: boolean,
/** 按跳过清单略过的目录数 */
skippedDirs: number,
/** 扫描耗时(毫秒;状态栏显示) */
elapsedMs: number,
};
/** 下载任务 */
export type DownloadTask = {
/** 任务 ID(自增 hex 字符串) */
@@ -1832,7 +1988,10 @@ export type EditorSettings = {
libraryRoot?: string | null,
/** 编辑器配色方案 key(`"system"` / `"vscode-dark"` / `"vscode-light"` / …) */
editorTheme?: string,
/** 编辑器配色是否跟随应用深浅(`editor_theme` 仅作取色基准) */
/**
* 编辑器**窗口**是否跟随主应用主题(开:整体跟随应用;关:由 `editor_theme` 决定,
* 窗口外壳与编辑区保持同一深浅)
*/
followAppTheme?: boolean,
/** 编辑器字体族(空串 = 用内置等宽字体栈) */
fontFamily?: string,
+18
View File
@@ -34,6 +34,11 @@ export const WINDOWS = {
* 服务就绪后由主窗口打开真正的 {@link dshWeb} 窗口并关闭它。
*/
dshWindow: 'dsh-window',
/**
* 对比工具独立窗口(单例)。双栏差异视图 + 目录三态树,
* 与编辑器窗口同一范式(隐藏创建 → 应用主题 → 设置任务栏身份 → show)。
*/
diffWindow: 'diff-window',
} as const
/** Tauri 事件名(前端 emit / listen 与 Rust constants::events 对应) */
@@ -174,6 +179,19 @@ export const EVENTS = {
editorOpenFile: 'editor-open-file',
/** 编辑器:需要打开一个文件夹(负载 `{ path }`;来自资源管理器右键) */
editorOpenFolder: 'editor-open-folder',
/**
* 编辑器:在**既有**编辑器窗口里加一个标签(负载见 `EditorOpenTabPayload`)。
* 纯前端事件(Rust 不参与):主窗口在发现有编辑器窗口时用 `emitTo` 定向发给它,
* 于是「系统右键 / 主界面打开历史文件」不会再多开一个窗口。
*/
editorOpenTab: 'editor-open-tab',
// 对比:全局快捷键按下「打开对比窗口」(无负载;窗口由前端创建,见 modules/diff/openWindow.ts)
diffOpenWindow: 'diff-open-window',
/**
* 对比:目录扫描进度(负载见 src/modules/diff/types.ts 的 DiffScanProgress)。
* 进度在 Rust 侧按时间节流发送;前端按 `scanId` 过滤(事件是全局的)。
*/
diffScanProgress: 'diff-scan-progress',
} as const
/** localStorage 存储键 */
+5 -2
View File
@@ -44,6 +44,7 @@ const standaloneWindowApps: Array<[hash: string, label: string, loader: () => Pr
['#new-terminal-window', '新建终端窗口', () => import('./modules/terminal/NewTerminalWindow.vue')],
['#file-window', '文件管理器窗口', () => import('./modules/terminal/FileWindow.vue')],
['#editor-window', '编辑器窗口', () => import('./modules/editor/EditorWindow.vue')],
['#diff-window', '对比窗口', () => import('./modules/diff/DiffWindow.vue')],
['#dsh-window', 'dsh 启动窗口', () => import('./modules/dsh/DshWindow.vue')],
]
@@ -51,14 +52,16 @@ const winHash = window.location.hash
// #screenshot-overlay 带窗口号参数(多屏)、#download-window 带 ?task= 参数,
// #terminal-window 带 /{session_id} 路径参数、#editor-window 带 ?file=(库内笔记)
// 或 ?path=(库外文件)参数,均按前缀匹配;其余精确匹配
// 或 ?path=(库外文件)参数、#diff-window 带 ?path=(P2 起的目标文件)参数,
// 均按前缀匹配;其余精确匹配
const matched = standaloneWindowApps.find(([hash]) => {
if (
hash === '#screenshot-overlay' ||
hash === '#screenshot-scroll' ||
hash === '#download-window' ||
hash === '#terminal-window' ||
hash === '#editor-window'
hash === '#editor-window' ||
hash === '#diff-window'
)
return winHash.startsWith(hash)
return winHash === hash
+1 -1
View File
@@ -89,7 +89,7 @@ watch(selectedId, () => {
p-5 属于**滚动内容**(模块根在主滚动区内部),因此卡片阴影四周都有余量,
不再需要任何负外边距补偿。
工具自身需要限高的地方(正则结果、diff 输出等)仍保留各自的 `max-h-*` 内滚动
工具自身需要限高的地方(正则结果等)仍保留各自的 `max-h-*` 内滚动
盒子 —— 那是「一块有边界的输出区」,与页面级滚动不是一回事。
-->
<div class="min-h-full p-5 flex flex-col">
+1 -1
View File
@@ -14,7 +14,7 @@ export const moduleConfig: ModuleConfig = {
id: 'devtools',
name: '开发者工具',
icon: 'devtools',
description: 'JSON / Base64 / 时间戳 / 正则 / 颜色 / Cron / 密码等 20 个常用开发工具',
description: 'JSON / Base64 / 时间戳 / 正则 / 颜色 / Cron / 密码等 19 个常用开发工具',
category: 'tool',
defaultEnabled: true,
loader: () => import('./DevToolsModule.vue'),
-146
View File
@@ -1,146 +0,0 @@
<script setup lang="ts">
import { computed, ref } from 'vue'
import { Textarea } from '@/components/ui/textarea'
import { Label } from '@/components/ui/label'
import ResultArea from '../components/ResultArea.vue'
const oldText = ref('')
const newText = ref('')
type Op = 'equal' | 'del' | 'add'
interface DiffLine {
op: Op
oldLine: string
line: string
newLine: string
}
// LCS DP 为 O(n·m),行数过大会卡死 UI;超过上限停止计算并提示
const MAX_LINES = 3000
// 先裁剪公共前缀/后缀,LCS 只算中间差异部分(典型场景提速明显)
function diffLines(a: string[], b: string[]): DiffLine[] {
const out: DiffLine[] = []
let start = 0
while (start < a.length && start < b.length && a[start] === b[start]) {
out.push({ op: 'equal', oldLine: a[start], line: a[start], newLine: b[start] })
start++
}
let endA = a.length, endB = b.length
while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
endA--
endB--
}
const mid = lcsDiff(a.slice(start, endA), b.slice(start, endB))
// 后缀公共部分:a[endA..] 与 b[endB..] 逐行配对
const suffix: DiffLine[] = []
for (let i = a.length - 1; i >= endA; i--) {
const j = endB + (i - endA)
suffix.unshift({ op: 'equal', oldLine: a[i], line: a[i], newLine: b[j] })
}
return [...out, ...mid, ...suffix]
}
function lcsDiff(a: string[], b: string[]): DiffLine[] {
const n = a.length
const m = b.length
if (n === 0) return b.map(line => ({ op: 'add' as const, oldLine: '', line, newLine: '' }))
if (m === 0) return a.map(line => ({ op: 'del' as const, oldLine: line, line, newLine: '' }))
// LCS DP
const dp: number[][] = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0))
for (let i = n - 1; i >= 0; i--) {
for (let j = m - 1; j >= 0; j--) {
dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1])
}
}
const out: DiffLine[] = []
let i = 0
let j = 0
while (i < n && j < m) {
if (a[i] === b[j]) {
out.push({ op: 'equal', oldLine: a[i], line: a[i], newLine: b[j] })
i++
j++
} else if (dp[i + 1][j] >= dp[i][j + 1]) {
out.push({ op: 'del', oldLine: a[i], line: a[i], newLine: '' })
i++
} else {
out.push({ op: 'add', oldLine: '', line: b[j], newLine: b[j] })
j++
}
}
while (i < n) {
out.push({ op: 'del', oldLine: a[i], line: a[i], newLine: '' })
i++
}
while (j < m) {
out.push({ op: 'add', oldLine: '', line: b[j], newLine: b[j] })
j++
}
return out
}
const tooLarge = computed(() =>
oldText.value.split('\n').length > MAX_LINES || newText.value.split('\n').length > MAX_LINES
)
const lines = computed(() => {
if (tooLarge.value) return []
return diffLines(oldText.value.split('\n'), newText.value.split('\n'))
})
const stats = computed(() => {
let adds = 0
let dels = 0
for (const l of lines.value) {
if (l.op === 'add') adds++
else if (l.op === 'del') dels++
}
return { adds, dels }
})
const unifiedText = computed(() => {
if (lines.value.length === 0) return ''
return lines.value
.map(l => (l.op === 'add' ? '+' : l.op === 'del' ? '-' : ' ') + l.line)
.join('\n')
})
</script>
<template>
<div class="flex flex-col gap-4">
<div class="grid grid-cols-2 gap-3">
<div class="flex flex-col gap-1.5">
<Label class="text-xs text-danger">旧文本(删除 {{ stats.dels }} 行)</Label>
<Textarea v-model="oldText" placeholder="旧文本..." class="min-h-[140px] font-mono text-xs resize-y" />
</div>
<div class="flex flex-col gap-1.5">
<Label class="text-xs text-success">新文本(新增 {{ stats.adds }} 行)</Label>
<Textarea v-model="newText" placeholder="新文本..." class="min-h-[140px] font-mono text-xs resize-y" />
</div>
</div>
<div class="flex flex-col gap-1.5">
<Label class="text-xs">差异预览</Label>
<div class="rounded-md border border-border max-h-64 overflow-auto font-mono text-xs leading-relaxed">
<div v-if="tooLarge" class="p-3 text-destructive">文本超过 {{ MAX_LINES }} 行,差异计算已停止(LCS 算法复杂度 O(n·m)),请缩减输入。</div>
<div v-else-if="lines.length === 0 || (oldText === '' && newText === '')" class="p-3 text-muted-foreground">输入两边文本查看差异。</div>
<div
v-for="(l, i) in lines"
:key="i"
class="flex whitespace-pre px-2 py-0.5"
:class="{
'bg-danger-soft text-danger-text': l.op === 'del',
'bg-success-soft text-success-text': l.op === 'add',
'text-muted-foreground': l.op === 'equal'
}"
>
<span class="w-5 shrink-0 select-none">{{ l.op === 'add' ? '+' : l.op === 'del' ? '-' : ' ' }}</span>
<span class="break-all">{{ l.line }}</span>
</div>
</div>
</div>
<ResultArea :text="unifiedText" label="统一格式(可复制)" placeholder="unified diff" />
</div>
</template>
+1 -8
View File
@@ -2,7 +2,7 @@ import type { Component } from 'vue'
import { defineAsyncComponent } from 'vue'
import {
FileJson, Binary, Link, Clock, MoveHorizontal, Fingerprint,
Wand2, KeyRound, CaseSensitive, Hash, Code, GitCompare, Shield,
Wand2, KeyRound, CaseSensitive, Hash, Code, Shield,
Palette, Lock, CalendarClock, Network, Sigma, Replace, Globe
} from '@lucide/vue'
import { registerTool, type DevTool } from '../registry'
@@ -69,11 +69,6 @@ export const TOOLS_META: Array<Omit<DevTool, 'component' | 'icon'>> = [
description: '在线测试正则表达式,实时匹配、分组查看与替换预览',
keywords: ['正则', 'regex', '匹配', 'test', 're', '替换']
},
{
id: 'diff', name: '文本对比', category: 'text',
description: '两段文本逐行差异对比',
keywords: ['对比', '差异', 'diff', '比较', 'compare']
},
{
id: 'eol', name: '行尾符转换', category: 'text',
description: 'CRLF / LF / CR 行尾符统一',
@@ -125,7 +120,6 @@ const TOOL_ICONS: Record<string, Component> = {
escape: Code,
case: CaseSensitive,
regex: Wand2,
diff: GitCompare,
eol: MoveHorizontal,
replace: Replace,
charcount: Sigma,
@@ -149,7 +143,6 @@ const TOOL_COMPONENTS: Record<string, () => Promise<{ default: Component }>> = {
escape: () => import('./EscapeTools.vue'),
case: () => import('./CaseTools.vue'),
regex: () => import('./RegexTools.vue'),
diff: () => import('./DiffTools.vue'),
eol: () => import('./EolTools.vue'),
replace: () => import('./ReplaceTools.vue'),
charcount: () => import('./CharCountTools.vue'),
+172
View File
@@ -0,0 +1,172 @@
<script setup lang="ts">
/**
* 对比工具主模块页(主窗口内)。
*
* 真正的对比发生在独立窗口(`openWindow.ts`),本页只负责入口、进度说明与设置 ——
* 与编辑器模块「主模块页做设置与入口、编辑发生在独立窗口」同一分工。
*
* 设置项少(只有一个快捷键 + 两个目录对比默认值),因此直接从 Rust 读写,不再单独建
* store:`diff_get_settings` / `diff_save_settings` 一次往返就够,且保存后后端会就地
* 重注册快捷键,「改完立刻生效」不需要前端额外做什么。
*/
import { onMounted, ref } from 'vue'
import { Diff, FileText, FolderTree, Rows2 } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Button } from '@/components/ui/button'
import { Card, CardContent } from '@/components/ui/card'
import { Input } from '@/components/ui/input'
import { Switch } from '@/components/ui/switch'
import { SettingGroup, SettingRow } from '@/components/common'
import { diffClient } from './diffClient'
import { openDiffWindow } from './openWindow'
import type { DiffSettings } from './types'
/** 三种对比能力。 */
const LEVELS = [
{
id: 'text',
name: '文本对比',
icon: Rows2,
description: '两段文本并排对照,块级高亮差异,可上下跳转',
available: true
},
{
id: 'file',
name: '文件对比',
icon: FileText,
description: '两个磁盘文件并排对照,自动探测编码(GBK / Shift_JIS / UTF-8…),支持拖入与单侧写回',
available: true
},
{
id: 'folder',
name: '文件夹对比',
icon: FolderTree,
description: '左右两棵结构树,递归比对:仅左侧有 / 仅右侧有 / 内容不同(只读,不做写回)',
available: true
}
]
const settings = ref<DiffSettings | null>(null)
async function openDiff(): Promise<void> {
try {
await openDiffWindow()
} catch (e) {
toast.error(`打开对比窗口失败:${String(e)}`)
}
}
/** 提交一处设置改动(后端保存后会就地重注册快捷键)。 */
async function commit(patch: Partial<DiffSettings>): Promise<void> {
const current = settings.value
if (!current) return
try {
settings.value = await diffClient.saveSettings({ ...current, ...patch })
} catch (e) {
toast.error(`保存失败:${String(e)}`)
}
}
onMounted(async () => {
try {
settings.value = await diffClient.getSettings()
} catch (e) {
toast.error(`读取设置失败:${String(e)}`)
}
})
</script>
<template>
<div class="min-h-full p-5">
<div class="flex flex-col gap-4">
<!-- 状态与入口 -->
<Card class="!py-0 !gap-0">
<CardContent class="flex flex-wrap items-center gap-x-6 gap-y-3 px-4 py-4">
<div class="flex items-center gap-2.5">
<span class="flex items-center gap-1.5 text-[13px] text-fg-secondary">
<span class="size-2 rounded-full bg-success" />三层均已可用
</span>
<span class="text-[13px] text-fg-secondary">文本 · 文件 · 文件夹对比</span>
</div>
<div class="flex min-w-0 flex-1 flex-col gap-0.5">
<span class="text-[11px] text-muted-foreground">当前范围</span>
<span class="truncate text-[13px] text-fg-secondary">
目录对比为只读(不做写回 / 同步)
</span>
</div>
<div class="ml-auto flex flex-wrap gap-2">
<Button size="sm" @click="openDiff">
<Diff class="size-3.5" />打开对比窗口
</Button>
</div>
</CardContent>
</Card>
<!-- 三种对比层级 -->
<Card class="!gap-2 !py-4">
<CardContent class="flex flex-col divide-y divide-divider !px-4">
<div
v-for="level in LEVELS"
:key="level.id"
class="flex items-center gap-4 py-3 first:pt-0 last:pb-0"
>
<div
class="flex size-8 shrink-0 items-center justify-center rounded-lg bg-primary-soft text-primary-soft-text"
>
<component :is="level.icon" class="size-4" />
</div>
<div class="flex min-w-0 flex-1 flex-col gap-0.5">
<span class="text-[13px] text-foreground">{{ level.name }}</span>
<span class="truncate text-xs text-muted-foreground">{{ level.description }}</span>
</div>
<span class="shrink-0 rounded-sm bg-success-soft px-1.5 py-0.5 text-[10px] text-success-text">
可用
</span>
</div>
</CardContent>
</Card>
<!-- 设置(改动即时生效,无保存按钮) -->
<SettingGroup
v-if="settings"
title="对比窗口"
description="快捷键与目录对比的默认行为;改动即时生效,无需保存"
>
<SettingRow
label="打开对比窗口"
description="全局快捷键,任意模块下都可用;留空则不注册"
control-width="wide"
>
<Input
:model-value="settings.openDiffShortcut"
placeholder="Alt+C"
spellcheck="false"
@change="(e: Event) => commit({ openDiffShortcut: (e.target as HTMLInputElement).value })"
/>
</SettingRow>
<SettingRow
label="目录对比默认比对内容"
description="大小相同但时间戳不同时,读文件内容逐字节比对(更准,也更慢)"
>
<Switch
:model-value="settings.compareContent"
@update:model-value="v => commit({ compareContent: v === true })"
/>
</SettingRow>
<SettingRow
label="目录对比默认跳过构建目录"
description="跳过 node_modules / .git / target 等目录,避免把无关目录也扫一遍"
>
<Switch
:model-value="settings.skipBuildDirs"
@update:model-value="v => commit({ skipBuildDirs: v === true })"
/>
</SettingRow>
</SettingGroup>
</div>
</div>
</template>
File diff suppressed because it is too large. Load diff
+981
View File
@@ -0,0 +1,981 @@
<script setup lang="ts">
/**
* 目录对比视图(**只读**):左右两棵结构树。
*
* # 为什么是两棵树,而不是一棵并集树
*
* 第一版是一棵「三态并集树」(每行用一种颜色标 仅左 / 仅右 / 不同)。但对比工具的心智
* 模型是「左边是一个目录、右边是另一个目录」—— 参考 Beyond Compare:两边各自一棵树、
* 各自一列大小与修改时间,人一眼就能看出「这个文件只在右边有」。因此这里**两个结构树
* 渲染同一份并集行**(行数、顺序完全一致,共用折叠状态),只是每一侧的单元格只显示该侧
* 真实存在的文件(另一侧缺失时显示为「—」并把名字压暗)。
*
* 共用一份行列表还有两个好处:左右永远不错行;将来做「滚动联动」时不需要额外对齐逻辑。
*
* # 会话状态是「共享可变模型」
*
* 状态由 `DiffWindow` 持有(一个选项卡一份),本组件直接读写传入的 `session` —— 理由见
* `types.ts` 的 `DirSessionState` 注释(8 个字段几乎都双向改,拆成 props/emits 会得到
* 十几个定义,而它们本来就是同一个东西)。
*
* # 点击任意一侧的文件 → 新开一个文件对比选项卡
*
* 这符合 Beyond Compare 的用法:在目录级先定位「哪个文件不一样」,再下钻到内容级。
* 只在一侧存在的文件也可以开(另一侧为空,整篇都是新增/删除)。
*/
import { computed, markRaw, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { open } from '@tauri-apps/plugin-dialog'
import { ChevronDown, ChevronRight, FolderOpen, Loader2, RefreshCw } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { ScrollArea } from '@/components/ui/scroll-area'
import { StateBlock } from '@/components/common'
import { EVENTS } from '@/lib/constants'
import { diffClient } from '../diffClient'
import type {
DiffScanProgress,
DiffSide,
DirDiffEntry,
DirFilterId,
DirSessionState
} from '../types'
/**
* 会话状态:用 `v-model:session` 而不是普通 prop。
*
* 本组件要**直接改**会话字段(根路径、过滤、折叠、扫描结果…),而 Vue 的
* `vue/no-mutating-props` 明确禁止改 prop。`defineModel` 拿到的是本地 model 引用
* (与父组件共享同一个响应式对象),改它的**字段**是合法且惯用的做法 —— 父组件那边
* 用 getter-only 的 computed 提供句柄即可(子组件从不整体替换会话,只改字段)。
*/
const session = defineModel<DirSessionState>('session', { required: true })
const emit = defineEmits<{
/** 点击某一侧的文件 → 由 DiffWindow 新开一个文件对比选项卡 */
'open-file': [payload: { side: DiffSide; entry: DirDiffEntry }]
}>()
const SIDES: readonly DiffSide[] = ['a', 'b']
/**
* 默认跳过的目录名(**唯一事实来源在这里**)。
*
* 与 `editor` 模块的默认跳过清单保持一致:同一台机器上「哪些目录不值得看」是同一个
* 判断,两个功能给出不同的默认值会让人困惑。后端只接收这份清单并按它执行。
*/
const DEFAULT_SKIP_DIRS =
'debug|.vs|.git|.svn|.hg|.idea|.vscode|node_modules|target|dist|build|out|.cache|__pycache__|.venv|venv|vendor|.next|coverage|.tmp-build'
.split('|')
const FILTERS: Array<{ id: DirFilterId; label: string }> = [
{ id: 'diff', label: '仅差异' },
{ id: 'all', label: '全部' },
{ id: 'left-only', label: '仅左侧' },
{ id: 'right-only', label: '仅右侧' }
]
const ready = computed(() => !!session.value.leftRoot && !!session.value.rightRoot)
function rootOf(side: DiffSide): string {
return side === 'a' ? session.value.leftRoot : session.value.rightRoot
}
/** 输入框回车 / 失焦即生效(失焦只有值变了才写,避免无意义的重扫)。 */
function onRootInput(side: DiffSide, event: Event): void {
const value = (event.target as HTMLInputElement).value
if (value === rootOf(side)) return
setRoot(side, value)
}
/**
* 输入框回车。
*
* 值有改动时**什么都不做**:回车随后会触发 `change`,由它提交并(两侧就绪时)扫描。
* 若这里也顺手扫一次,就会先用**旧**根路径白扫一遍(`keydown` 早于 `change`,此刻
* 会话里的根还是旧值),表现为「按回车闪一下旧结果再换成新的」。
* 值没改时回车 = 重新扫描(这是用户按回车的常见意图)。
*/
function onRootEnter(side: DiffSide, event: KeyboardEvent): void {
const value = (event.target as HTMLInputElement).value
if (value !== rootOf(side)) return
void compare()
}
/** 图标按钮:系统对话框选目录。 */
async function browse(side: DiffSide): Promise<void> {
try {
const selected = await open({ directory: true, multiple: false, title: '选择要对比的文件夹' })
if (typeof selected !== 'string') return
setRoot(side, selected)
} catch (e) {
toast.error(`选择文件夹失败:${String(e)}`)
}
}
/** 设定某一侧的根;两侧都就绪时自动开始扫描。 */
function setRoot(side: DiffSide, path: string): void {
if (side === 'a') session.value.leftRoot = path
else session.value.rightRoot = path
if (ready.value) void compare()
}
/**
* 拖入一个路径:目录直接作为该侧根;文件则取其**所在目录**
* (拖一个文件进来想比的是它所在的目录结构,而不是报错)。
*/
async function loadDropped(side: DiffSide, path: string): Promise<void> {
let target = path
try {
if ((await diffClient.pathKind(path)) === 'file') target = parentDir(path)
} catch {
/* 探测失败就按原路径试,让 compare 给出明确错误 */
}
setRoot(side, target)
}
/** 取父目录(同时兼容 `\` 与 `/`)。 */
function parentDir(path: string): string {
const trimmed = path.replace(/[\\/]+$/, '')
const index = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'))
return index > 0 ? trimmed.slice(0, index) : trimmed
}
/** 本轮扫描的序号(进度事件按它过滤,见 `compare`)。 */
let scanSeq = 0
/** 当前扫描的进度(`null` = 还没收到第一帧,界面显示「扫描中…」)。 */
const scanProgress = ref<DiffScanProgress | null>(null)
let unlistenProgress: UnlistenFn | null = null
/** 进度文案(`null` = 还没收到进度帧)。 */
const progressText = computed(() => {
const p = scanProgress.value
if (!p) return null
const label = p.phase === 'compare' ? '正在核对内容' : '已遍历'
return p.total ? `${label} ${p.done} / ${p.total}` : `${label} ${p.done} 项`
})
async function compare(): Promise<void> {
if (!ready.value) return
session.value.scanning = true
// 每轮扫描一个新的 id:进度事件是**全局**的(Rust 侧不区分选项卡),用一个自增 id
// 把别人的进度过滤掉 —— 否则切到另一个正在扫的目录选项卡时会看到对不上的计数。
const id = ++scanSeq
scanProgress.value = null
try {
const report = await diffClient.compareDirs(
id,
session.value.leftRoot,
session.value.rightRoot,
session.value.skipBuild ? DEFAULT_SKIP_DIRS : [],
session.value.compareContent
)
// markRaw:条目可达数千,让它进响应式系统会逐条生成 Proxy(纯开销)
session.value.report = markRaw(report)
session.value.collapsed = new Set()
} catch (e) {
session.value.report = null
toast.error(`目录对比失败:${String(e)}`)
} finally {
session.value.scanning = false
scanProgress.value = null
}
}
// ===== 树 =====
interface TreeNode {
relPath: string
name: string
depth: number
isDir: boolean
entry: DirDiffEntry | null
children: TreeNode[]
/** 自身或子树里是否有「值得显示」的条目 */
significant: boolean
}
function matches(entry: DirDiffEntry): boolean {
switch (session.value.filter) {
case 'all':
return true
case 'diff':
return entry.status === 'different' || entry.status === 'type-mismatch'
case 'left-only':
return entry.status === 'left-only'
case 'right-only':
return entry.status === 'right-only'
}
}
/** 由扁平条目组装成树(缺失的中间目录会被补齐,避免因截断 / 跳过而丢上下文)。 */
function buildTree(entries: DirDiffEntry[]): TreeNode {
const root: TreeNode = {
relPath: '',
name: '',
depth: 0,
isDir: true,
entry: null,
children: [],
significant: false
}
const map = new Map<string, TreeNode>([['', root]])
const ensure = (relPath: string): TreeNode => {
const existing = map.get(relPath)
if (existing) return existing
const cut = relPath.lastIndexOf('/')
const name = cut < 0 ? relPath : relPath.slice(cut + 1)
const parent = ensure(cut < 0 ? '' : relPath.slice(0, cut))
const node: TreeNode = {
relPath,
name,
depth: parent.depth + 1,
isDir: false,
entry: null,
children: [],
significant: false
}
parent.children.push(node)
map.set(relPath, node)
return node
}
for (const entry of entries) {
const node = ensure(entry.relPath)
node.entry = entry
node.isDir = entry.isDir
}
// 目录在前、同级按名字排序(与资源管理器的观感一致)
for (const node of map.values()) {
node.children.sort((a, b) => {
if (a.isDir !== b.isDir) return a.isDir ? -1 : 1
return a.name.localeCompare(b.name)
})
}
return root
}
/** 自底向上标注「这一支有没有值得显示的东西」。 */
function markSignificant(node: TreeNode): boolean {
let childSignificant = false
for (const child of node.children) {
// 注意顺序:先递归再取返回值,不能短路(短路会让后面的分支不被标注)
if (markSignificant(child)) childSignificant = true
}
node.significant = childSignificant || (node.entry ? matches(node.entry) : false)
return node.significant
}
/** 由扁平条目组装成的树(只随扫描结果变化;过滤条件不影响它的结构)。 */
const builtTree = computed<TreeNode>(() => {
const current = session.value.report
return buildTree(current ? current.entries : [])
})
/**
* 带「值得显示」标注的树。
*
* 与 `builtTree` 拆开,是为了**不让过滤条件的变化触发整棵树的重新组装**:`buildTree` 是
* O(条目数) 的分配 + 排序,而 `markSignificant` 只是在既有节点上重算一个布尔量。原来两步
* 挤在同一个 computed 里,点一下「仅差异 / 仅左侧」就要把全部节点重新建一遍。
*/
const tree = computed<TreeNode>(() => {
const root = builtTree.value
markSignificant(root)
return root
})
/** 展平成可渲染的行(跳过被剪掉的与折叠的)。左右两个结构树共用这份行。 */
const rows = computed<Array<{ node: TreeNode; depth: number }>>(() => {
const out: Array<{ node: TreeNode; depth: number }> = []
const collapsed = session.value.collapsed
const walk = (node: TreeNode): void => {
for (const child of node.children) {
if (!child.significant) continue
out.push({ node: child, depth: child.depth })
if (child.isDir && !collapsed.has(child.relPath)) walk(child)
}
}
walk(tree.value)
return out
})
function toggleDir(relPath: string): void {
const next = new Set(session.value.collapsed)
if (next.has(relPath)) next.delete(relPath)
else next.add(relPath)
session.value.collapsed = next
}
/** 展开 / 折叠全部目录。 */
function setAllCollapsed(value: boolean): void {
if (!value) {
session.value.collapsed = new Set()
return
}
const keys = new Set<string>()
const walk = (node: TreeNode): void => {
for (const child of node.children) {
if (child.isDir && child.children.length) keys.add(child.relPath)
walk(child)
}
}
walk(tree.value)
session.value.collapsed = keys
}
// ===== 汇总 =====
const summary = computed(() => {
const counts = { different: 0, leftOnly: 0, rightOnly: 0, identical: 0, mismatch: 0 }
for (const entry of session.value.report?.entries ?? []) {
if (entry.isDir) {
if (entry.status === 'type-mismatch') counts.mismatch++
continue
}
if (entry.status === 'different') counts.different++
else if (entry.status === 'left-only') counts.leftOnly++
else if (entry.status === 'right-only') counts.rightOnly++
else if (entry.status === 'identical') counts.identical++
}
return counts
})
function formatSize(bytes: number): string {
if (bytes < 1024) return `${bytes} B`
if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
}
function formatTime(ms: number): string {
if (!ms) return ''
const d = new Date(ms)
const pad = (n: number) => String(n).padStart(2, '0')
return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`
}
/** 该侧是否存在于这个条目(不存在的一侧显示为「—」并把名字压暗)。 */
function existsOn(entry: DirDiffEntry, side: DiffSide): boolean {
return side === 'a' ? !!entry.leftPath : !!entry.rightPath
}
function sizeOn(entry: DirDiffEntry, side: DiffSide): number {
return side === 'a' ? entry.leftSize : entry.rightSize
}
function timeOn(entry: DirDiffEntry, side: DiffSide): number {
return side === 'a' ? entry.leftModified : entry.rightModified
}
/** 状态点颜色(两侧都用同一套语义,便于一眼对上)。 */
function dotClass(status: DirDiffEntry['status']): string {
switch (status) {
case 'different':
return 'bg-danger'
case 'left-only':
return 'bg-warning'
case 'right-only':
return 'bg-info'
case 'type-mismatch':
return 'bg-danger'
default:
return 'bg-fg-disabled'
}
}
/** 行点击:目录折叠,文件开新选项卡(任一侧都可点)。 */
function onRowClick(node: TreeNode): void {
if (node.isDir) {
toggleDir(node.relPath)
return
}
const entry = node.entry
if (!entry) return
emit('open-file', { side: existsOn(entry, 'a') ? 'a' : 'b', entry })
}
/**
* 文件名颜色:**有差异**的文件用红、一致的文件用前景色(浅色主题下即黑色);
* 该侧不存在时一律压暗(那是「—」占位,不该与真实名字同色调)。
*
* 目录保持前景色:目录的差异由前面的状态点与另一侧的「—」表达,把整棵树的目录都染红
* 反而让真正要看的那几个文件淹没在噪声里。
*/
function nameClass(node: TreeNode, side: DiffSide): string {
if (!node.entry || !existsOn(node.entry, side)) return 'text-fg-disabled'
if (node.isDir) return 'text-foreground'
return node.entry.status === 'identical' ? 'text-foreground' : 'text-danger-text'
}
/**
* 该条目的「不同」是**按时间戳**判定的,而非内容逐字节比对。
*
* 后端只在「大小相同、时间戳不同」时才读内容核对,且有预算(单文件体积 / 条数上限);
* 预算用尽或文件过大时结论仍记为 `different`,但 `contentCompared` 为 false —— 界面上
* 必须与「已确认不同」区分,否则等于把猜测当结论。
*
* 判据要连 `leftSize === rightSize` 一起看:**大小不同**时后端也把 `contentCompared`
* 记为 false(它根本不需要读内容 —— 大小都不同,内容不可能相同),那是确定结论,
* 拿 `!contentCompared` 单独当判据会给几乎每个差异文件都挂上「未核实」。
*/
function unverified(entry: DirDiffEntry | null): boolean {
return (
!!entry &&
entry.status === 'different' &&
!entry.contentCompared &&
entry.leftSize === entry.rightSize
)
}
/**
* 目录行是否隐藏「大小 / 已修改」两列(合并成一个占位)。
*
* 目录的这两个属性不是可用于对比的信号:大小(`meta.len()` 在 Windows 上取决于文件系统,
* 后端已统一置 0)没有意义;mtime 只是「有子项被增删改」的副产物,几乎每次都和另一侧不同,
* 拿它当差异线索会误导。因此目录行把这两列并成一格。
*
* 例外是 `type-mismatch`(同名但一侧是文件):那是有意义的差异,按原来的两列渲染。
*/
function quietMeta(node: TreeNode): boolean {
return node.isDir && node.entry?.status !== 'type-mismatch'
}
// ===== 左右两棵树滚动联动 =====
//
// 两侧渲染的是**同一份行**(行数、顺序完全一致,只有单元格内容不同),因此行高一致、
// 内容高度一致 —— 一个像素级的镜像就够了。
//
// 不用「布尔锁 + 延迟释放」那种写法:scroll 事件是异步派发的,锁的释放时机很难对齐,
// 漏放会让联动卡死、错放会让两侧互相推着抖动。这里改成**比较目标位置**:谁在滚动就把
// 另一侧对齐到同一位置;后者随后触发的 scroll 事件会发现「对方已经和我一样」,自然不再
// 回推 —— 无需在两次事件之间维护任何时序状态。
const treeRootRef = ref<HTMLElement | null>(null)
let viewports: [HTMLElement, HTMLElement] | null = null
/** 把 `to` 对齐到 `from`;差值 ≤1px 视为已对齐(避免像素取整引起的抖动)。 */
function mirrorScroll(from: HTMLElement, to: HTMLElement): void {
if (Math.abs(to.scrollTop - from.scrollTop) <= 1) return
to.scrollTop = from.scrollTop
}
// ===== 行虚拟化 =====
//
// 上限 8000 条 × 两侧 = 最多约 6 万个 DOM 节点,一次性铺出来会让首次渲染与滚动都卡。
// 这里只渲染视口内的行(上下各留 OVERSCAN 行),用上下两个撑高的空 div 占住剩余空间,
// 于是滚动条长度与滚动位置与「全部渲染」完全一致(两者之和恒等于 行数 × 行高)。
//
// 两侧**共用同一份窗口**:滚动已被联动对齐、行数又完全一致,因此一个 scrollTop 对
// 两边都成立 —— 不需要按侧各算一份(那还会引入两侧窗口错位的一类新 bug)。
/**
* 行高(px)。
*
* 必须与模板里行的高度严格相等(那里同一个 `:style` 里就写了 `height`)。用像素而不是
* `h-6.5` 这类 rem 类:虚拟化的偏移量必须精确等于真实行高,绑在显式常量上比「依赖根字号
* 恰好 16px(6.5 × 0.25rem = 26px)」可靠。
*/
const ROW_HEIGHT = 26
/** 视口上下各多渲染的行数(滚动时不至于露白)。 */
const OVERSCAN = 8
/** 两侧共用的滚动位置(联动使两侧恒等,虚拟化只需一份)。 */
const scrollTop = ref(0)
/** 视口高度(两侧等宽等高,取其中一个即可)。 */
const viewportHeight = ref(0)
let viewportObserver: ResizeObserver | null = null
/** 当前要渲染的行区间 `[first, last)`。 */
const rowRange = computed(() => {
const total = rows.value.length
const first = Math.max(0, Math.floor(scrollTop.value / ROW_HEIGHT) - OVERSCAN)
const last = Math.max(
first,
Math.min(total, Math.ceil((scrollTop.value + viewportHeight.value) / ROW_HEIGHT) + OVERSCAN)
)
return { first, last }
})
/** 视口内(含上下缓冲)的行,并带上它在**全量 rows** 里的下标(键盘导航与 ARIA 要用真下标)。 */
const visibleRows = computed(() =>
rows.value
.slice(rowRange.value.first, rowRange.value.last)
.map((row, i) => ({ row, index: rowRange.value.first + i }))
)
/** 可见行上方的占位高度。 */
const padTop = computed(() => rowRange.value.first * ROW_HEIGHT)
/** 可见行下方的占位高度。 */
const padBottom = computed(() =>
Math.max(0, (rows.value.length - rowRange.value.last) * ROW_HEIGHT)
)
// ===== 整行 hover =====
//
// 两侧渲染的是同一份行,却是**两个独立的滚动容器** —— 只在鼠标所在的那一侧加 CSS `hover:`
// 会让高亮只覆盖半行。这里改记一个**行下标**,两侧按同一个下标上色,看起来就是一整行。
//
// 用「指针位置 → 下标」而不是逐行 mouseenter:行是虚拟化的,滚动时同一个 DOM 节点会被
// 复用成别的行,靠 enter/leave 记下的「上一行」会失效(高亮停在错误的行上)。这里在滚动
// 时也用最后记录的指针 Y 重算一次,于是滚轮滚动时高亮依然跟得上。
/** 鼠标所在行的下标(-1 = 不在任何行上)。 */
const hoverIndex = ref(-1)
/** 最后一次指针的 clientY(NaN = 指针不在树上)。 */
let pointerClientY = Number.NaN
function updateHover(): void {
const viewport = viewports?.[0]
if (!viewport || Number.isNaN(pointerClientY)) {
hoverIndex.value = -1
return
}
// 两侧视口处于同一水平线、行高也一致,所以一个下标对两边都成立
const y = pointerClientY - viewport.getBoundingClientRect().top
if (y < 0 || y >= viewport.clientHeight) {
hoverIndex.value = -1
return
}
const index = Math.floor((y + scrollTop.value) / ROW_HEIGHT)
hoverIndex.value = index >= 0 && index < rows.value.length ? index : -1
}
function onTreeMouseMove(event: MouseEvent): void {
pointerClientY = event.clientY
updateHover()
}
function onTreeMouseLeave(): void {
pointerClientY = Number.NaN
hoverIndex.value = -1
}
const onLeftScroll = (): void => {
if (!viewports) return
scrollTop.value = viewports[0].scrollTop
mirrorScroll(viewports[0], viewports[1])
updateHover()
}
const onRightScroll = (): void => {
if (!viewports) return
scrollTop.value = viewports[1].scrollTop
mirrorScroll(viewports[1], viewports[0])
updateHover()
}
// 滚动的真实容器是 reka-ui 的 viewport(`.cm-*` 那套同理,原生滚动被它接管)。
// 两侧的 ScrollArea 始终渲染(空态 / 扫描中也一样),因此挂载后即可取到,无需等数据。
onMounted(async () => {
// 扫描进度是**全局**事件(Rust 不区分选项卡):按 scanSeq 过滤,只认本轮扫描的进度。
// 注册失败不该影响其余初始化(虚拟化与滚动联动才是主体)—— 进度只是锦上添花。
try {
unlistenProgress = await listen<DiffScanProgress>(EVENTS.diffScanProgress, event => {
if (event.payload.scanId !== scanSeq) return
scanProgress.value = event.payload
})
} catch {
/* 注册失败就静默降级为「扫描中…」,不影响扫描本身 */
}
const found = treeRootRef.value?.querySelectorAll<HTMLElement>('[data-reka-scroll-area-viewport]')
if (!found || found.length < 2) return
const left = found[0]
const right = found[1]
if (!left || !right) return
viewports = [left, right]
left.addEventListener('scroll', onLeftScroll, { passive: true })
right.addEventListener('scroll', onRightScroll, { passive: true })
// 视口高度是虚拟化的另一个输入:它随窗口尺寸 / 分栏变化,用 ResizeObserver 跟住
viewportHeight.value = left.clientHeight
viewportObserver = new ResizeObserver(() => {
viewportHeight.value = viewports?.[0]?.clientHeight ?? 0
})
viewportObserver.observe(left)
})
onBeforeUnmount(() => {
viewports?.[0].removeEventListener('scroll', onLeftScroll)
viewports?.[1].removeEventListener('scroll', onRightScroll)
viewports = null
viewportObserver?.disconnect()
viewportObserver = null
unlistenProgress?.()
unlistenProgress = null
})
/**
* 换过滤条件 / 重新扫描后两侧回到顶部。
*
* 不复位的话,原来滚到很靠下时新内容可能停在中间甚至底部,用户会以为「结果没变」。
* 两侧一起设 0(而不是走镜像):此处语义就是「从头看」,显式置顶比镜像更直白。
*/
watch([() => session.value.filter, () => session.value.report], () => {
scrollTop.value = 0
if (!viewports) return
viewports[0].scrollTop = 0
viewports[1].scrollTop = 0
})
// ===== 键盘可达性 =====
//
// 行是 div,本身不可聚焦 —— 键盘用户完全用不了。这里按 ARIA tree 的常规做法补上:
// 行 `role="treeitem"`(带 aria-level / aria-expanded / aria-selected),并用
// **roving tabindex**(同一时刻只有一个行可 Tab 到)避免 Tab 要穿过上千行;方向键在
// `rows` 上移动,Enter / 空格与鼠标点击同义。
//
// 与虚拟化的配合:目标行在窗口外时先把它滚进视口、等这一帧渲染完再 `focus` ——
// 否则要聚焦的元素在虚拟化下根本不在 DOM 里。
/** 当前键盘活动行。存 **relPath** 而不是下标:过滤 / 折叠 / 重新扫描都会让下标失效。 */
const activeRelPath = ref('')
/** 活动行在 `rows` 里的下标;存的路径已不在当前行集里时回落到第一行。 */
const activeRowIndex = computed(() => {
const index = rows.value.findIndex(row => row.node.relPath === activeRelPath.value)
return index >= 0 ? index : 0
})
function isActive(index: number): boolean {
return index === activeRowIndex.value
}
/** 直接设置两侧的滚动位置(键盘导航用;两侧联动会随之对齐)。 */
function scrollBoth(top: number): void {
scrollTop.value = top
if (!viewports) return
viewports[0].scrollTop = top
viewports[1].scrollTop = top
}
/** 让第 index 行进入视口(必要时滚动)。 */
function revealIndex(index: number): void {
const top = index * ROW_HEIGHT
const bottom = top + ROW_HEIGHT
if (top < scrollTop.value) scrollBoth(top)
else if (bottom > scrollTop.value + viewportHeight.value) {
scrollBoth(bottom - viewportHeight.value)
}
}
/** 移动活动行,并按需滚动 + 聚焦。 */
function moveActive(index: number): void {
const total = rows.value.length
if (!total) return
const clamped = Math.max(0, Math.min(index, total - 1))
const row = rows.value[clamped]
if (!row) return
activeRelPath.value = row.node.relPath
revealIndex(clamped)
void nextTick(() => {
treeRootRef.value?.querySelector<HTMLElement>('[data-active-row]')?.focus()
})
}
/** 第 index 行的最近祖先(`rows` 是深度优先展平,往前找第一个深度更小的行)。 */
function parentIndexOf(index: number): number {
const depth = rows.value[index]?.depth ?? 0
for (let i = index - 1; i >= 0; i--) {
if ((rows.value[i]?.depth ?? 0) < depth) return i
}
return -1
}
/** 点击 / Tab 到某一行时把它记为活动行(roving tabindex 的锚点)。 */
function onRowFocus(node: TreeNode): void {
activeRelPath.value = node.relPath
}
function onTreeKeydown(event: KeyboardEvent): void {
const total = rows.value.length
if (!total) return
const index = activeRowIndex.value
const row = rows.value[index]
if (!row) return
switch (event.key) {
case 'ArrowDown':
event.preventDefault()
moveActive(index + 1)
break
case 'ArrowUp':
event.preventDefault()
moveActive(index - 1)
break
case 'ArrowRight':
event.preventDefault()
// 折叠的目录先展开;否则移动到下一行(若下一行是子项,那正是「第一个子项」)
if (row.node.isDir && session.value.collapsed.has(row.node.relPath)) {
toggleDir(row.node.relPath)
} else {
moveActive(index + 1)
}
break
case 'ArrowLeft':
event.preventDefault()
// 展开的目录先折叠;否则回到父目录
if (row.node.isDir && !session.value.collapsed.has(row.node.relPath)) {
toggleDir(row.node.relPath)
} else {
const parent = parentIndexOf(index)
if (parent >= 0) moveActive(parent)
}
break
case 'Home':
event.preventDefault()
moveActive(0)
break
case 'End':
event.preventDefault()
moveActive(total - 1)
break
case 'Enter':
case ' ':
event.preventDefault()
onRowClick(row.node)
break
default:
break
}
}
defineExpose({ compare, setRoot, loadDropped })
</script>
<template>
<!-- 整块铺不透明底色:窗根是透明窗(mica/acrylic),不给底色的话「路径输入行 + 文件树」
会透出窗口背景,与旁边面板的观感割裂 -->
<div class="flex min-h-0 flex-1 flex-col bg-background">
<!-- 控制行:扫描 + 过滤 + 两个开关 -->
<div class="flex h-8 shrink-0 items-center gap-1 border-b border-border px-2">
<Button size="sm" class="h-6" :disabled="!ready || session.scanning" @click="compare">
<Loader2 v-if="session.scanning" class="size-3.5 animate-spin" />
<RefreshCw v-else class="size-3.5" />
扫描
</Button>
<div class="mx-1 h-4 w-px shrink-0 bg-border" />
<Button
v-for="item in FILTERS"
:key="item.id"
variant="ghost"
size="sm"
class="h-6 px-2 text-[11px]"
:class="
session.filter === item.id
? 'bg-primary-soft font-medium text-primary-soft-text'
: 'text-fg-secondary hover:text-foreground'
"
@click="session.filter = item.id"
>
{{ item.label }}
</Button>
<div class="ml-auto flex shrink-0 items-center gap-1">
<Button variant="ghost" size="sm" class="h-6 px-2 text-[11px]" @click="setAllCollapsed(false)">
展开全部
</Button>
<Button variant="ghost" size="sm" class="h-6 px-2 text-[11px]" @click="setAllCollapsed(true)">
折叠全部
</Button>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[11px] transition-colors"
:class="
session.skipBuild
? 'bg-primary-soft font-medium text-primary-soft-text'
: 'text-fg-secondary hover:bg-hover'
"
title="跳过 node_modules / .git / target 等常见构建目录"
@click="session.skipBuild = !session.skipBuild"
>
跳过构建目录
</button>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[11px] transition-colors"
:class="
session.compareContent
? 'bg-primary-soft font-medium text-primary-soft-text'
: 'text-fg-secondary hover:bg-hover'
"
title="大小相同、时间戳不同时读内容逐字节比对(更准,也更慢)"
@click="session.compareContent = !session.compareContent"
>
比对内容
</button>
</div>
</div>
<!-- 左右两棵结构树(滚动联动,见脚本里的滚动镜像;方向键导航的 keydown 挂在这层容器上,
事件从聚焦的行冒泡上来 —— 两侧共用一套导航) -->
<div
ref="treeRootRef"
class="flex min-h-0 flex-1"
@keydown="onTreeKeydown"
@mousemove="onTreeMouseMove"
@mouseleave="onTreeMouseLeave"
>
<div
v-for="side in SIDES"
:key="side"
class="flex min-w-0 flex-1 flex-col"
:class="side === 'b' ? 'border-l border-border' : ''"
>
<!-- 该侧的根路径:可自由输入,也可用图标按钮选 -->
<div class="flex h-8 shrink-0 items-center gap-1 border-b border-border px-1.5">
<Input
:model-value="rootOf(side)"
class="h-6 flex-1 font-mono text-[11px]"
:placeholder="side === 'a' ? '左侧文件夹…' : '右侧文件夹…'"
spellcheck="false"
@change="(e: Event) => onRootInput(side, e)"
@keydown.enter="onRootEnter(side, $event)"
/>
<Button variant="ghost" size="icon-sm" title="选择文件夹" @click="browse(side)">
<FolderOpen class="size-3.5" />
</Button>
</div>
<!-- 列头(名称 / 大小 / 已修改,与 Beyond Compare 的口径一致) -->
<div
class="flex h-6 shrink-0 items-center gap-2 border-b border-divider px-2 text-[10px] text-muted-foreground"
>
<span class="min-w-0 flex-1">名称</span>
<span class="w-16 shrink-0 text-right">大小</span>
<span class="w-24 shrink-0 text-right">已修改</span>
</div>
<ScrollArea class="min-h-0 flex-1">
<div v-if="!session.report && !session.scanning" class="p-3">
<StateBlock
variant="empty"
title="选择左右两个文件夹开始对比"
description="两侧都可以直接输入路径或点文件夹图标选择;也可以把文件夹拖到这一侧"
:min-height="160"
/>
</div>
<div
v-else-if="session.scanning"
class="flex items-center gap-2 p-3 text-xs text-muted-foreground"
>
<Loader2 class="size-3.5 animate-spin" />{{ progressText ?? '正在扫描…' }}
</div>
<div v-else-if="!rows.length" class="p-3">
<StateBlock
variant="empty"
:title="session.filter === 'diff' ? '两棵目录树没有差异' : '当前过滤条件下没有条目'"
description="换一个过滤条件,或点「全部」查看两侧所有的文件"
:min-height="140"
/>
</div>
<!-- 行虚拟化:上下两个占位 div 撑住未渲染的部分(见脚本里的「行虚拟化」)。
这层也是该侧的 ARIA tree —— 左右各一棵(两侧展示的是同一批行的不同侧信息) -->
<div v-else role="tree" :aria-label="side === 'a' ? '左侧目录' : '右侧目录'">
<div :style="{ height: `${padTop}px` }" aria-hidden="true" />
<div
v-for="item in visibleRows"
:key="item.row.node.relPath"
role="treeitem"
:aria-level="item.row.depth + 1"
:aria-expanded="
item.row.node.isDir ? !session.collapsed.has(item.row.node.relPath) : undefined
"
:aria-selected="isActive(item.index)"
:tabindex="isActive(item.index) ? 0 : -1"
:data-active-row="isActive(item.index) ? '' : undefined"
class="flex cursor-pointer items-center gap-2 pr-2 text-xs focus:outline-none"
:class="
item.index === hoverIndex ? 'bg-hover' : isActive(item.index) && 'bg-row-selected'
"
:style="{ height: `${ROW_HEIGHT}px`, paddingLeft: `${4 + item.row.depth * 14}px` }"
@click="onRowClick(item.row.node)"
@focus="onRowFocus(item.row.node)"
>
<!-- 展开箭头(两侧共用折叠状态,点哪边都一样;键盘用 → / ← 展开折叠) -->
<button
v-if="item.row.node.isDir"
type="button"
tabindex="-1"
class="flex size-4 shrink-0 items-center justify-center text-muted-foreground"
@click.stop="toggleDir(item.row.node.relPath)"
>
<ChevronDown
v-if="!session.collapsed.has(item.row.node.relPath) && item.row.node.children.length"
class="size-3.5"
/>
<ChevronRight v-else-if="item.row.node.children.length" class="size-3.5" />
</button>
<span
v-else
class="ml-0.5 size-1.5 shrink-0 rounded-full"
:class="dotClass(item.row.node.entry?.status ?? 'identical')"
/>
<span
class="min-w-0 flex-1 truncate"
:class="[item.row.node.isDir ? 'font-medium' : '', nameClass(item.row.node, side)]"
>
{{ item.row.node.name }}
</span>
<!-- 「不同」是按时间戳判定的(大小相同、时间戳不同,但没读内容核对) —— 不能
与已确认的差异用同一种语气,故单独标出 -->
<span
v-if="unverified(item.row.node.entry)"
class="shrink-0 rounded-sm bg-warning-soft px-1 text-[9px] text-warning-text"
title="两侧大小相同但时间戳不同,且未读内容逐字节比对(文件过大或比对预算用尽)——这是按时间戳判定的差异,未必真的不同"
>
未核实
</span>
<!-- 目录行:大小 / 已修改不是对比信号,合并成一格(见脚本里的 quietMeta)。
宽度 = 4rem + gap(0.5rem) + 6rem,与下面两格的合计严格一致,名字列才不会错位 -->
<span
v-if="quietMeta(item.row.node)"
class="w-[10.5rem] shrink-0 text-right font-mono text-[10px] text-fg-disabled"
title="目录的大小与已修改时间不参与对比(大小在 Windows 上无意义,mtime 只是子项变动的副产物)"
>
—
</span>
<template v-else>
<span class="w-16 shrink-0 text-right font-mono text-[10px] text-muted-foreground">
{{ item.row.node.entry && existsOn(item.row.node.entry, side) && !item.row.node.isDir ? formatSize(sizeOn(item.row.node.entry, side)) : '—' }}
</span>
<span class="w-24 shrink-0 truncate text-right font-mono text-[10px] text-muted-foreground">
{{ item.row.node.entry && existsOn(item.row.node.entry, side) ? formatTime(timeOn(item.row.node.entry, side)) : '—' }}
</span>
</template>
</div>
<div :style="{ height: `${padBottom}px` }" aria-hidden="true" />
</div>
</ScrollArea>
</div>
</div>
<!-- 汇总 -->
<footer
class="flex h-7 shrink-0 items-center gap-3 border-t border-border px-3 text-[11px] text-muted-foreground"
>
<span v-if="session.report" class="tabular-nums text-danger-text">不同 {{ summary.different }}</span>
<span v-if="session.report" class="tabular-nums text-warning-text">仅左 {{ summary.leftOnly }}</span>
<span v-if="session.report" class="tabular-nums text-info-text">仅右 {{ summary.rightOnly }}</span>
<span v-if="session.report" class="tabular-nums">相同 {{ summary.identical }}</span>
<span v-if="summary.mismatch" class="tabular-nums text-danger-text">
类型不一致 {{ summary.mismatch }}
</span>
<span v-if="session.report?.skippedDirs" class="tabular-nums">
已跳过 {{ session.report.skippedDirs }} 个目录
</span>
<span class="truncate text-muted-foreground">点任意一侧的文件即可新开一个文件对比选项卡</span>
<span class="ml-auto shrink-0 tabular-nums">
<template v-if="session.scanning">{{ progressText ?? '扫描中…' }}</template>
<template v-else-if="session.report">
{{ session.report.entries.length }} 项 · {{ session.report.elapsedMs }} ms
</template>
</span>
<span v-if="session.report?.truncated" class="shrink-0 text-warning-text">
条目已达上限,结果被截断
</span>
</footer>
</div>
</template>
File diff suppressed because it is too large. Load diff
+64
View File
@@ -0,0 +1,64 @@
/**
* 对比模块的 IPC 客户端:命令名的**唯一落点**。
*
* 与 `editor/editorClient.ts` 同一理由:命令名与返回类型只在本文件出现一次,
* 避免散落在组件里各自手写(后端改字段时前端还会编译通过)。
*
* 参数名用 snake_case 形态的 camelCase(与 tauri-specta 的调用约定一致)。
*/
import { invoke } from '@tauri-apps/api/core'
import type { DiffFileDoc, DiffSettings, DirDiffReport } from './types'
export const diffClient = {
/**
* 读取一侧的文件(文本自动探测编码;二进制只回元信息)。
*
* 该命令同时登记「已授权可写」,因此随后可以直接 `writeFile` 保存。
*/
readFile: (path: string) => invoke<DiffFileDoc>('diff_read_file', { path }),
/**
* 把一侧的内容写回磁盘。
*
* `encoding` / `eol` 必须回传**读取时探测到的值**:否则一次保存就会把 GBK 文件
* 变成 UTF-8、CRLF 变成 LF,整个 diff 会因此掀翻。
*/
writeFile: (path: string, content: string, encoding: string, eol: string) =>
invoke<DiffFileDoc>('diff_write_file', { path, content, encoding, eol }),
/**
* 探测路径是文件还是目录(拖入与 `?path=` 时前端拿不到文件系统元信息)。
*
* 只读一次 `metadata`,不写盘、不需授权。
*/
pathKind: (path: string) => invoke<'dir' | 'file' | 'missing'>('diff_path_kind', { path }),
/**
* 对比两棵目录树(只读)。
*
* `skipDirs` 是**目录名**清单(大小写不敏感):默认清单由前端给出(它是界面约定,
* 用户能不能改是 UI 的事),后端只负责按它执行。
*
* `scanId` 由前端生成:后端把它原样放进进度事件(`diff-scan-progress`),前端据此
* 只认自己那一轮的进度 —— 事件是全局的,多个选项卡可能同时在扫。
*/
compareDirs: (
scanId: number,
left: string,
right: string,
skipDirs: string[],
compareContent: boolean
) =>
invoke<DirDiffReport>('diff_compare_dirs', { scanId, left, right, skipDirs, compareContent }),
// ===== 设置 =====
getSettings: () => invoke<DiffSettings>('diff_get_settings'),
/**
* 保存设置。
*
* Rust 侧保存后会**就地重注册**全局快捷键,因此「改了快捷键立刻生效」,
* 不需要前端再调一次注册命令。
*/
saveSettings: (settings: DiffSettings) =>
invoke<DiffSettings>('diff_save_settings', { settings })
}
+39
View File
@@ -0,0 +1,39 @@
import type { ModuleConfig } from '@/types/module'
import type { SearchIndexItem } from '@/stores/searchIndex'
/**
* 对比工具模块:文本 / 文件 / 文件夹三层对比。
*
* 规划见 `doc/DIFF_MODULE_PLAN.md`。当前进度 = **P1(文本对比)**:
* 双栏 MergeView 已可用;文件对比(P2)与文件夹对比(P3)待做。
*
* 为什么独立成模块而不是塞进编辑器:编辑器模块的中心对象是「一篇文档的生命周期」
* (标签 / 自动保存 / 光标 / 会话恢复),而对比工具是「两个只读视图 + 一棵目录树」,
* 没有自动保存、没有文档标签。混进去会让编辑器的窗口与 store 继续膨胀,也会让
* `editor-window-*` 这个 capability 的语义变模糊(详见规划 §5)。
*/
const searchItems: SearchIndexItem[] = [
{
title: '对比工具',
description: '文本 / 文件 / 文件夹对比:双栏差异视图,类 Beyond Compare',
keywords: ['对比', '比较', '差异', 'diff', 'compare', '文本对比', '文件对比', '文件夹对比', 'merge']
},
{
title: '打开对比窗口',
description: '打开对比工具窗口,粘贴两段文本或(P2 起)拖入文件开始比较',
keywords: ['打开', '对比', '窗口', '独立窗口', 'diff', 'compare']
}
]
export const moduleConfig: ModuleConfig = {
id: 'diff',
name: '对比工具',
icon: 'diff',
description: '文本 / 文件 / 文件夹对比(双栏差异视图;目录对比只读,不做写回)',
category: 'tool',
defaultEnabled: true,
loader: () => import('./DiffModule.vue'),
searchItems,
// 紧挨编辑器(45):两者同属「处理文本 / 文件」一族
order: 50
}
+84
View File
@@ -0,0 +1,84 @@
/**
* 对比窗口的创建入口(由前端创建,范式同 `editor/openWindow.ts`)。
*
* # 为什么是单例
*
* 与编辑器窗口(可多开、按目标判重)不同,对比工具的语义是「比较这一对目标」,
* 窗口里本来就同时容纳左右两侧 —— 多开只会让用户分不清哪一对是哪一对。
* 因此 label 固定为 `diff-window`,已存在就强制置前。
*
* # 隐藏创建 + 先应用主题
*
* 窗口初始底色是白的,而深色主题要等前端读 localStorage 后才应用 —— 直接显示会先
* 闪一下纯白。因此 `visible: false` 创建,由 `DiffWindow.vue` 应用完主题(含窗口效果)
* 与任务栏身份之后再自己 `show()`(同编辑器 / 终端窗口)。
*
* # 置前走原生命令
*
* `SetForegroundWindow` 不受 Windows 前台锁定限制;前端 `setFocus()` 在「本进程不拥有
* 前台」时会被系统直接忽略(表现为窗口明明开着却唤不到前面)。同下载窗口 / 快速面板。
*/
import { WebviewWindow } from '@tauri-apps/api/webviewWindow'
import { invoke } from '@tauri-apps/api/core'
import { createLogger } from '@/lib/logger'
import { WINDOWS } from '@/lib/constants'
const logger = createLogger('diff')
const LABEL = WINDOWS.diffWindow
/**
* 打开(或唤出)对比窗口。
*
* @param target 可选:P2 起用于把某个文件 / 文件夹作为初始目标(写入 URL 查询串)
*/
export async function openDiffWindow(target?: { path?: string }): Promise<void> {
const existing = await WebviewWindow.getByLabel(LABEL)
if (existing) {
try {
await invoke('window_focus_window', { label: LABEL })
return
} catch (e) {
logger.warn(`唤出既有对比窗口失败:${String(e)}`)
}
}
const query = target?.path ? `?path=${encodeURIComponent(target.path)}` : ''
const win = new WebviewWindow(LABEL, {
url: `index.html#${LABEL}${query}`,
title: '对比',
width: 1180,
height: 780,
minWidth: 720,
minHeight: 460,
resizable: true,
// 自绘标题栏(与编辑器 / 终端 / 文件窗口一致)
decorations: false,
// 透明通道用于承载 mica / acrylic
transparent: true,
shadow: true,
center: true,
visible: false,
focus: false,
// 拖入任意文件 / 文件夹作为某一侧目标(P2 起真正使用)
dragDropEnabled: true
})
// 不要等到 `tauri://created` 之后才挂错误监听:窗口创建过快时事件可能早于监听注册
win.once('tauri://error', e => logger.error(`打开对比窗口失败:${String(e)}`))
// 补注入拖放支持:wry 只在创建 webview 那一刻扫一次子窗口,运行期新建的窗口拿不到
// OLE drop target(拖文件进去是禁止光标)。详见 src-tauri/src/drag_drop.rs
//
// 注意**不要**放到下面那个 `await` 之后:`tauri://created` 在窗口创建过快时可能早于
// 监听注册而永远等不到。Rust 侧会自行重试等待窗口与 WebView2 子窗口就位,因此这里
// fire-and-forget 即可。
void invoke('window_attach_drag_drop', { label: LABEL }).catch(e => {
logger.warn(`拖放补注入失败:${String(e)}`)
})
await new Promise<void>((resolve, reject) => {
win.once('tauri://created', () => resolve())
win.once('tauri://error', e => reject(new Error(String(e))))
})
}
+157
View File
@@ -0,0 +1,157 @@
/**
* 对比模块的前端类型。
*
* [`DiffStats`] 由 `MergeView` 的 chunk 列表算出(纯前端);[`DiffFileDoc`] 与 Rust 侧
* `diff::types::DiffFileDoc` 一一对应(新增字段两侧都要改)。
*/
/** 两侧文本的差异统计(状态栏展示用)。 */
export interface DiffStats {
/** 变化块数量(MergeView 的 chunk 个数) */
chunks: number
/** 右侧相对左侧新增的行数 */
addedLines: number
/** 左侧相对右侧被删除的行数 */
removedLines: number
/** 左侧行数(空文档为 0,而不是 CM6 报的 1) */
linesA: number
/** 右侧行数(同左) */
linesB: number
}
/** 某一侧的文件状态(来自 `diff_read_file` / `diff_write_file`)。 */
export interface DiffFileDoc {
/** 绝对路径 */
path: string
/** 显示名(文件名) */
name: string
/** 文本内容(换行已统一为 `\n`)。二进制文件为空串 */
content: string
/** 探测到的编码(`utf-8` / `gbk` / …)。二进制文件为空串 */
encoding: string
/** 换行风格:"lf" | "crlf"。二进制文件为空串 */
eol: string
/** 文件字节数 */
size: number
/** 最后修改时间(Unix 毫秒) */
modified: number
/** 行数(二进制文件为 0) */
lines: number
/** 是否超过「大文件」阈值 */
large: boolean
/** 是否只读(写权限探测失败) */
readonly: boolean
/** 是否为二进制文件(不渲染 diff,只报「不同」) */
binary: boolean
}
/** 一侧的标识(左 = 原始,右 = 对比)。 */
export type DiffSide = 'a' | 'b'
/** 目录对比中一个条目的状态。 */
export type DirDiffStatus =
/** 仅左侧有 */
| 'left-only'
/** 仅右侧有 */
| 'right-only'
/** 两侧都有且内容不同 */
| 'different'
/** 两侧都有且相同 */
| 'identical'
/** 同名但一侧是文件、另一侧是目录 */
| 'type-mismatch'
/**
* 目录对比中的一个条目(扁平列表,由前端组装成树)。
*
* 与 Rust 侧 `diff::types::DirDiffEntry` 一一对应。
*/
export interface DirDiffEntry {
/** 相对根的路径,/ 分隔(显示名从前端最后一段取) */
relPath: string
/** 是否目录(`type-mismatch` 时视为目录) */
isDir: boolean
status: DirDiffStatus
/** 该侧绝对路径;该侧不存在时为空串 */
leftPath: string
rightPath: string
leftSize: number
rightSize: number
leftModified: number
rightModified: number
/**
* 结论是否由**内容逐字节比对**得出。
*
* `false` 表示「大小相同、时间戳不同」且未读内容(体积超限 / 预算用尽),
* 此时 `different` 是按时间戳判定的 —— 界面上要区别于已确认的差异。
*/
contentCompared: boolean
}
/** 目录对比的扫描进度(事件负载,与 Rust 侧 `diff::types::DiffScanProgress` 一一对应)。 */
export interface DiffScanProgress {
/** 本轮扫描的标识(前端生成、随命令传入,据此过滤掉其它选项卡的进度) */
scanId: number
/** `scan` = 正在遍历目录;`compare` = 正在读内容逐字节核对 */
phase: 'scan' | 'compare'
/** 已完成数(遍历 = 已过的条目数;核对 = 已比对的文件数) */
done: number
/** 总数(遍历阶段未知为 0;核对阶段为预算上限) */
total: number
}
/** 一次目录对比的结果。 */
export interface DirDiffReport {
leftRoot: string
rightRoot: string
entries: DirDiffEntry[]
/** 条目数达到上限、遍历被截断 */
truncated: boolean
/** 按跳过清单略过的目录数 */
skippedDirs: number
/** 扫描耗时(毫秒) */
elapsedMs: number
}
/** 目录对比的过滤条件。 */
export type DirFilterId = 'diff' | 'all' | 'left-only' | 'right-only'
/**
* 目录对比选项卡的状态。
*
* 由 `DiffWindow` 持有(它是选项卡会话的宿主),`DirDiffView` 读写它。
*
* # 为什么把可变会话对象当 prop 传,而不是逐项 props/emits
*
* 这里的状态有 8 个字段、且几乎每个都会双向改(输入根路径、切过滤、折叠、扫描结果…)。
* 逐项拆成 `v-model` + emitters 会得到十几个 props 与 emits,而它们**本来就是同一个
* 东西**(一个选项卡的会话状态)。因此按「共享可变模型」传:`DirDiffView` 直接改字段、
* 只把无法自己完成的动作(触发扫描)emit 出去。
*/
export interface DirSessionState {
leftRoot: string
rightRoot: string
report: DirDiffReport | null
scanning: boolean
filter: DirFilterId
/**
* 已折叠的目录相对路径。
*
* **两侧共用一份**:两个结构树渲染的是同一个并集树(行数与顺序完全一致,只有单元格
* 内容不同),共用折叠状态才不会让左右两边错行。
*/
collapsed: Set<string>
skipBuild: boolean
compareContent: boolean
}
/** 对比模块设置(与 Rust 侧 `diff::types::DiffSettings` 一一对应)。 */
export interface DiffSettings {
version: number
/** 全局快捷键:打开 / 唤出对比窗口(空串 = 不注册) */
openDiffShortcut: string
/** 目录对比:默认是否比对内容 */
compareContent: boolean
/** 目录对比:默认是否跳过常见构建目录 */
skipBuildDirs: boolean
}
@@ -1,6 +1,7 @@
<script setup lang="ts">
import { ref, computed, onMounted, onUnmounted } from 'vue'
import { getCurrentWindow, Effect, EffectState } from '@tauri-apps/api/window'
import { invoke } from '@tauri-apps/api/core'
import { LogicalSize } from '@tauri-apps/api/dpi'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { Pause, Play, X, Minus, FolderOpen, AlertCircle, Loader2, XCircle } from '@lucide/vue'
@@ -280,6 +281,12 @@ onMounted(async () => {
window.setTimeout(async () => {
// 隐藏态下多贴合一次,确保尺寸已对内容就位
await applyAutoHeight()
// 任务栏身份:窗口级 AUMID(独立任务栏按钮)+ 组合图标;必须在 show() 之前设置
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'download' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try { await win.show() } catch { /* 忽略 */ }
try { await win.unminimize() } catch { /* 忽略 */ }
void commands.downloaderFocusWindow(win.label).catch(() => {})
+6
View File
@@ -130,6 +130,12 @@ function closeWindow() {
onMounted(async () => {
await applyTheme()
// 任务栏身份:窗口级 AUMID(独立任务栏按钮)+ 组合图标;必须在 show() 之前设置
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'dsh' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try {
await win.show()
await win.setFocus()
+110 -12
View File
@@ -13,6 +13,8 @@
* - 空态一律 `StateBlock`,不手写占位文案
*/
import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { getCurrentWebview } from '@tauri-apps/api/webview'
import type { UnlistenFn } from '@tauri-apps/api/event'
import { open } from '@tauri-apps/plugin-dialog'
import { openPath } from '@tauri-apps/plugin-opener'
import {
@@ -48,6 +50,7 @@ import {
import { ConfirmDialog, SettingRow, StateBlock } from '@/components/common'
import { useModuleTabs } from '@/lib/use-module-tabs'
import { WINDOWS } from '@/lib/constants'
import { createLogger } from '@/lib/logger'
import { useEditorStore } from '@/stores/editorStore'
import { openEditorWindow } from './openWindow'
import { editorClient } from './editorClient'
@@ -58,6 +61,11 @@ import NewNoteDialog from './components/NewNoteDialog.vue'
import type { ContextMenuStatus, EditorSettings } from '@/types/editor'
const store = useEditorStore()
const logger = createLogger('editor')
/** 是否正有文件被拖到模块页上方(显示拖入提示遮罩) */
const dragOver = ref(false)
let unlistenDragDrop: UnlistenFn | null = null
const activeTab = ref('overview')
// Tab 结构(规划 §6.1):概览 / 库 / 编辑器 / 集成。
@@ -74,29 +82,98 @@ useModuleTabs(
{ alwaysVisible: true }
)
/**
* 模块页拖入文件:为每个路径开一个编辑器窗口(本页只做管理,编辑在独立窗口)。
*
* 用 Tauri 原生拖放事件(`onDragDropEvent`)而非 HTML5 `drop`:`dragDropEnabled`
* 默认开启时 Tauri 会接管 WebView2 的拖放,HTML5 在 Windows 上拿不到外部文件路径。
* 注意 Windows UIPI 会拦截拖入以管理员运行的窗口 —— 仅在非提权时可用。
*/
async function onDroppedPaths(paths: string[]): Promise<void> {
for (const path of paths) {
try {
const options = (await editorClient.pathKind(path)) === 'folder' ? { folder: path } : { path }
await openEditorWindow(options)
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
}
/** HTML5 dragover:亮遮罩(只有在 Tauri 原生拖放未接管时才会触发,见 onDomDrop)。 */
function onDomDragOver(): void {
dragOver.value = true
}
/**
* HTML5 `drop` 兜底:拦住浏览器默认行为(否则会把文件内容插进页面/编辑器),
* 能拿到绝对路径时照样打开。正常情况下拖放由 Tauri 原生处理器接管,这里不会被触发。
*/
function onDomDrop(event: DragEvent): void {
event.preventDefault()
dragOver.value = false
const files = Array.from(event.dataTransfer?.files ?? [])
const paths = files
.map(f => (f as File & { path?: string }).path)
.filter((p): p is string => !!p)
if (paths.length) {
void onDroppedPaths(paths)
} else if (files.length) {
logger.warn(`拖放未走原生通道(files=${files.length},取不到绝对路径)`)
toast.error('未取到拖入文件的绝对路径(拖放被浏览器接管),请改用「打开文件」')
}
}
onMounted(() => {
// 快捷键在别的模块按下时 App.vue 已把请求挂起并切到本页:挂载即消费
if (store.consumeNewNote()) openNewNote()
void store.init()
void loadContextMenu()
const selfWebview = getCurrentWebview()
void selfWebview
.onDragDropEvent(event => {
const payload = event.payload
if (payload.type === 'enter' || payload.type === 'over') {
dragOver.value = true
} else if (payload.type === 'drop') {
dragOver.value = false
logger.info(`原生拖放 drop:${payload.paths.length} 项`)
void onDroppedPaths(payload.paths)
} else {
dragOver.value = false
}
})
.then(unlisten => {
unlistenDragDrop = unlisten
})
logger.info(`拖放监听已注册:webview=${selfWebview.label}`)
})
onBeforeUnmount(() => {
unlistenDragDrop?.()
unlistenDragDrop = null
store.disposeListeners()
})
// ===== 全局快捷键请求(Rust 只发事件,这里负责开对话框 / 开窗口)=====
// ===== 全局快捷键请求(Rust 只发事件,App.vue 在应用级转发 / 开窗)=====
//
// 「新建笔记」:App.vue 收到快捷键后置挂起标记并切到本页,本页**挂载时消费**(快捷键在
// 其它模块按下时本页还没挂载,页内 watch 会漏掉),已挂载时则由下面的 watch 消费。
const newNoteOpen = ref(false)
function openNewNote(): void {
activeTab.value = 'overview'
newNoteOpen.value = true
}
watch(
() => store.newNoteRequest,
() => {
activeTab.value = 'overview'
newNoteOpen.value = true
() => store.newNotePending,
pending => {
if (pending && store.consumeNewNote()) openNewNote()
}
)
watch(
() => store.openEditorRequest,
() => void openEditor()
)
// 全局快捷键(`Alt+E` 打开编辑器窗口)由 App.vue 在应用级处理(快捷键在任意模块下
// 都要可用,不能依赖本页已挂载 —— 见 App.vue 的说明);这里只保留模块内的入口按钮。
/**
* 冷启动的「用 Thing 打开」:命令行留下的文件路径取到后,直接开一个笔记窗口。
@@ -304,7 +381,12 @@ const indexSummary = computed(() => {
</script>
<template>
<div class="min-h-full p-5">
<div
class="relative min-h-full p-5"
@dragenter.prevent="onDomDragOver"
@dragover.prevent="onDomDragOver"
@drop.prevent="onDomDrop"
>
<Tabs v-model="activeTab" class="flex min-h-full w-full flex-col">
<!-- ===== 概览 ===== -->
<TabsContent value="overview" class="tab-animate">
@@ -564,7 +646,7 @@ const indexSummary = computed(() => {
</CardHeader>
<CardContent class="!px-4">
<div class="flex flex-col divide-y divide-divider">
<SettingRow label="配色方案" description="跟随应用时按应用深浅自动选深/浅变体" control-width="wide">
<SettingRow label="配色方案" description="「跟随主应用主题」关闭时,窗口按本方案取色与深浅" control-width="wide">
<Select
:model-value="String(store.settings.editorTheme)"
@update:model-value="v => commit({ editorTheme: String(v) })"
@@ -578,7 +660,7 @@ const indexSummary = computed(() => {
</Select>
</SettingRow>
<SettingRow label="跟随应用深浅" description="开关打开时,配色方案仅作为取色基准">
<SettingRow label="跟随主应用主题" description="打开时编辑器窗口整体跟随主应用主题;关闭时由上方「配色方案」决定,窗口内外深浅一致">
<Switch
:model-value="store.settings.followAppTheme"
@update:model-value="v => commit({ followAppTheme: v === true })"
@@ -888,5 +970,21 @@ const indexSummary = computed(() => {
<!-- 全局快捷键(Ctrl+Shift+N)触发的新建对话框:落在库根 -->
<NewNoteDialog v-model:open="newNoteOpen" dir-rel="" />
<!-- 拖入提示遮罩(Tauri 原生拖放事件驱动) -->
<div
v-if="dragOver"
class="pointer-events-none absolute inset-0 z-50 flex items-center justify-center bg-background/70 backdrop-blur-sm"
>
<div
class="flex flex-col items-center gap-1.5 rounded-lg border-2 border-dashed border-primary px-8 py-6 text-center"
>
<NotebookPen class="size-6 text-primary" />
<span class="text-sm font-medium">松开以打开</span>
<span class="text-xs text-muted-foreground">
文件 / 文件夹会在新的编辑器窗口打开
</span>
</div>
</div>
</div>
</template>
+709 -40
View File
@@ -25,11 +25,27 @@
*/
import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { Effect, EffectState, getCurrentWindow } from '@tauri-apps/api/window'
import { invoke } from '@tauri-apps/api/core'
import { getCurrentWebview } from '@tauri-apps/api/webview'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { open, save } from '@tauri-apps/plugin-dialog'
import { AlertTriangle, History, Minus, NotebookPen, PanelLeft, Square, X } from '@lucide/vue'
import {
AlertTriangle,
FileCode2,
FileText,
History,
Loader2,
Minus,
NotebookPen,
PanelLeft,
Settings,
Square,
X
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Toaster } from '@/components/ui/sonner'
import { Button } from '@/components/ui/button'
import { ScrollArea } from '@/components/ui/scroll-area'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import {
Dialog,
@@ -47,11 +63,13 @@ import {
DropdownMenuTrigger
} from '@/components/ui/dropdown-menu'
import { ConfirmDialog, StateBlock } from '@/components/common'
import { STORAGE_KEYS } from '@/lib/constants'
import { EVENTS, STORAGE_KEYS } from '@/lib/constants'
import { applyStoredAccent } from '@/lib/theme'
import { createLogger } from '@/lib/logger'
import { useEditorStore } from '@/stores/editorStore'
import type { PathReplaceResult } from '@/types/editor'
import { editorClient } from './editorClient'
import { EDITOR_THEMES } from './editor/themes'
import type { EditorOpenTabPayload, PathReplaceResult } from '@/types/editor'
import LibrarySidebar from './components/LibrarySidebar.vue'
import EditorHost from './components/EditorHost.vue'
import EditorToolbar from './components/EditorToolbar.vue'
@@ -60,6 +78,7 @@ import DrawerPanel from './components/DrawerPanel.vue'
import EditorTabs from './components/EditorTabs.vue'
import EditorSearch, { type SearchScope } from './components/EditorSearch.vue'
import SearchResultsPanel from './components/SearchResultsPanel.vue'
import EditorSettingsDialog from './components/EditorSettingsDialog.vue'
import { useEditorSearchStore } from '@/stores/editorSearchStore'
import type { Command, EditorView } from '@codemirror/view'
@@ -70,10 +89,18 @@ const searchStore = useEditorSearchStore()
const isDark = ref(false)
const sidebarVisible = ref(true)
/** 是否正有文件被拖到窗口上方(显示拖入提示遮罩) */
const dragOver = ref(false)
let unlistenDragDrop: UnlistenFn | null = null
/** 主窗口发来的「在既有窗口加标签」监听(见 openWindow.ts) */
let unlistenOpenTab: UnlistenFn | null = null
const hostRef = ref<InstanceType<typeof EditorHost> | null>(null)
const sidebarRef = ref<InstanceType<typeof LibrarySidebar> | null>(null)
const quickOpen = ref(false)
/** 设置对话框(库设置 / 编辑器设置,见 EditorSettingsDialog) */
const settingsOpen = ref(false)
const cursorColumn = ref(1)
const searchRef = ref<InstanceType<typeof EditorSearch> | null>(null)
// ===== 统一搜索器(P4-6):一个输入区覆盖「当前文件 / 当前目录 / 笔记库」 =====
const searchOpen = ref(false)
const searchScope = ref<SearchScope>('file')
@@ -81,6 +108,8 @@ const searchScope = ref<SearchScope>('file')
const drawerMode = ref<'outline' | 'links' | 'graph' | null>(null)
// ===== 主题与窗口效果(与主应用同步) =====
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
function readMainTheme(): { theme: string; effect: string } {
try {
const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
@@ -100,17 +129,44 @@ function resolveIsDark(theme: string): boolean {
return window.matchMedia('(prefers-color-scheme: dark)').matches
}
/**
* 编辑器窗口当前应当采用的深浅(着色由它统一推导:外壳、mica 底色、编辑区)。
*
* - **跟随主应用主题**(设置开关打开):整体跟随应用 —— 读主应用写在同一份
* `localStorage` 里的主题;
* - **不跟随**(默认):由**配色方案**决定 —— 具体主题看它自身的亮暗归属,
* 配色方案为「跟随系统」时按应用解析出的系统深浅(应用本身为「跟随系统」即操作系统)。
*
* 这样窗口外壳(标题栏 / 侧栏 / 状态栏)与编辑区始终同深同浅,「内外统一」。
*/
function windowIsDark(): boolean {
// 应用的深浅(应用为「跟随系统」时按系统偏好解析)
const appDark = resolveIsDark(readMainTheme().theme)
if (store.settings.followAppTheme) return appDark
const theme = String(store.settings.editorTheme)
if (theme === 'system') return appDark
// 具体主题取自身的亮暗归属;未知取值回落到 vscode-dark(与 effectiveThemeName 一致,
// 避免外壳与编辑区深浅对不上)
return EDITOR_THEMES[theme]?.dark ?? EDITOR_THEMES['vscode-dark']?.dark ?? true
}
async function applyTheme(): Promise<void> {
const root = document.documentElement
const { theme, effect } = readMainTheme()
const { theme: appTheme, effect } = readMainTheme()
const dark = windowIsDark()
try {
await win.setTheme(theme === 'system' ? null : (theme as 'dark' | 'light'))
// 原生窗口主题**只跟应用主题走**,与其它独立窗口(终端 / 托盘 / 快速面板…)一致。
//
// ⚠️ 绝不能按编辑器自己的配色方案传 'dark'/'light':`setTheme` 会改写**整个应用**的
// `prefers-color-scheme`(同 appStore 的注释),于是托盘菜单、快速面板等靠
// `matchMedia` 取深浅的窗口会被编辑器一起带偏(表现为它们的文字与底色反了)。
// 编辑器自身的深浅由下面的 CSS class 决定,不依赖这里的原生主题。
await win.setTheme(appTheme === 'system' ? null : (appTheme as 'dark' | 'light'))
} catch {
/* 平台不支持时忽略 */
}
const dark = resolveIsDark(theme)
isDark.value = dark
root.classList.remove('dark', 'effect-mica', 'effect-acrylic', 'effect-normal')
root.classList.add(`effect-${effect}`)
@@ -120,8 +176,12 @@ async function applyTheme(): Promise<void> {
try {
// setEffects 会直接覆盖当前效果,无需 clearEffects(那个命令未在 capability 中授权)
if (effect === 'mica') {
// 用 micaDark / micaLight 明确指定着色:编辑器窗口的深浅可以与应用 / 系统不同
// (不跟随时由配色方案决定),沿用 `Effect.Mica` 会跟随系统深浅,深色编辑器配
// 浅色糊化层会「内深外浅」。同 appStore 的做法。
const micaEffect = (dark ? 'micaDark' : 'micaLight') as unknown as Effect
await win.setEffects({
effects: [Effect.Mica],
effects: [micaEffect],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
@@ -145,12 +205,17 @@ async function applyTheme(): Promise<void> {
}
}
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
const onThemeChange = () => void applyTheme()
const onStorageChange = (e: StorageEvent) => {
if (e.key === STORAGE_KEYS.appSettings) void applyTheme()
}
// 设置里改了「跟随主应用主题」或「配色方案」:窗口整体重新着色(外壳 + 编辑区)。
// 用逐项 watch 而不是 `() => [a, b]`:后者每次都会生成新数组,设置一刷新就误触发。
watch([() => store.settings.followAppTheme, () => String(store.settings.editorTheme)], () =>
void applyTheme()
)
// ===== 窗口控制 =====
const doMinimize = () => win.minimize().catch(() => undefined)
const doToggleMaximize = () => win.toggleMaximize().catch(() => undefined)
@@ -182,6 +247,60 @@ function requestCloseTab(id: string): void {
store.closeTab(id)
}
// ===== 标签栏右键菜单:批量关闭 =====
//
// 单标签关闭有「保存 / 放弃」三选一(见 requestCloseTab);批量关多个时逐个三选一
// 会把用户淹没,因此退化为**一次确认**:有脏数据 / 临时草稿就提示「会丢失改动」,
// 确认后统一放弃关闭。
/** 除指定标签外的全部 id。 */
function tabIdsExcept(id: string): string[] {
return store.tabs.filter(t => t.id !== id).map(t => t.id)
}
/** 指定标签左侧的全部 id。 */
function tabIdsLeftOf(id: string): string[] {
const index = store.tabs.findIndex(t => t.id === id)
return index < 0 ? [] : store.tabs.slice(0, index).map(t => t.id)
}
/** 指定标签右侧的全部 id。 */
function tabIdsRightOf(id: string): string[] {
const index = store.tabs.findIndex(t => t.id === id)
return index < 0 ? [] : store.tabs.slice(index + 1).map(t => t.id)
}
const batchCloseOpen = ref(false)
const batchCloseIds = ref<string[]>([])
/** 关闭多个标签;被固定的标签跳过,其余有未保存改动或临时草稿时先弹确认。 */
function requestCloseTabs(ids: string[]): void {
const valid = ids.filter(id => {
const tab = store.tabs.find(t => t.id === id)
return !!tab && !tab.pinned
})
if (!valid.length) return
const risky = valid.some(id => {
const tab = store.tabs.find(t => t.id === id)
if (!tab) return false
const dirty = id === store.activeTabId ? store.dirty : tab.dirty
return dirty || store.isScratchTab(id)
})
if (risky) {
batchCloseIds.value = valid
batchCloseOpen.value = true
return
}
store.closeTabsByIds(valid)
}
function confirmBatchClose(): void {
batchCloseOpen.value = false
const ids = batchCloseIds.value
batchCloseIds.value = []
store.closeTabsByIds(ids)
}
/**
* 草稿关闭三选一:保存到别处 / 删除 / 取消。
*
@@ -243,37 +362,66 @@ async function confirmCloseTab(): Promise<void> {
store.closeTab(id)
}
/**
* 放弃改动直接关闭标签(不保存)。
*
* 直接 `closeTab` 即可 —— 未保存的内容只在 store 的标签项 / 扁平 state 里,标签一移除
* 就随之丢弃。切走会触发 `docRevision` 变化,EditorHost 会顺手清掉挂起的自动保存定时器,
* 所以不会出现「关掉之后又被自动保存写回磁盘」。
*/
function discardAndCloseTab(): void {
const id = pendingCloseTabId.value
tabCloseConfirmOpen.value = false
if (!id) return
store.closeTab(id)
}
async function doClose(): Promise<void> {
if (store.anyDirty) {
closeConfirmOpen.value = true
return
}
await forceClose()
await closeWindow(true)
}
async function forceClose(): Promise<void> {
/**
* 关闭窗口。
*
* `saveFirst` 为真时逐个标签切换并保存(保存只作用于活动文档);为假则**不写盘**直接关
* —— 用户在确认框里选了「放弃修改并关闭」。
*
* 两条路都要落一次会话:会话记的是「开过哪些标签、光标在哪」,不是内容本身;放弃内容
* 不等于要丢掉下次恢复的入口。
*/
async function closeWindow(saveFirst: boolean): Promise<void> {
const original = store.activeTabId
// 逐个标签切换并保存(保存只作用于活动文档)
for (const tab of [...store.tabs]) {
store.activateTab(tab.id)
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
if (saveFirst) {
for (const tab of [...store.tabs]) {
store.activateTab(tab.id)
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
}
}
// 上面的循环把活动标签挪到了最后一个 —— 复原成用户关闭时正在看的那一篇,
// 会话里的「活动项」才与用户所见一致(不保存时活动标签没被动过,无需复原)
if (original) store.activateTab(original)
}
// 上面的循环把活动标签挪到了最后一个 —— 复原成用户关闭时正在看的那一篇,
// 会话里的「活动项」才与用户所见一致
if (original) store.activateTab(original)
// 关窗前记录会话(下次无目标打开时恢复)
store.saveSession()
win.close().catch(() => undefined)
}
/** 确认框里的「保存并关闭」。 */
const forceClose = () => closeWindow(true)
/** 确认框里的「放弃修改并关闭」:不写盘,直接关窗。 */
const discardAndCloseWindow = () => closeWindow(false)
/**
* 标签集合一变就落一次会话(防抖 300ms)。
*
* 只在关窗时写是不够的:标题栏的关闭按钮走 `forceClose` 会写,但 Alt+F4 / 任务栏
* 只在关窗时写是不够的:标题栏的关闭按钮走 `closeWindow` 会写,但 Alt+F4 / 任务栏
* 关闭不走前端流程,`onBeforeUnmount` 在 WebView 被销毁时也不保证执行 —— 会话就是这么
* 丢的。持续写把这个缺口堵上。
*
@@ -292,6 +440,117 @@ watch(sessionShape, () => {
}, 300)
})
// ===== Markdown 预览(标签栏的「眼睛」按钮) =====
/**
* 处于预览状态的标签 id。
*
* **按标签独立**而非窗口一个开关:预览是「看这一篇的渲染结果」,切到下一篇应当还是
* 编辑器本体。放在组件本地而不是 store,是因为它是纯视图状态(不需要跨窗口同步、
* 也不必进会话),关掉重开标签后重新点一下本来也是合理预期。
*/
const previewIds = ref<string[]>([])
// ===== 并排分屏 =====
/**
* 副面板展示的标签 id(空串 = 不分屏)。
*
* 副面板绑定的是**非活动标签**:主面板始终对应活动文档,副面板再开一个独立缓冲,
* 于是两个文档可同时编辑。若副面板对应标签被切到前台(成为活动标签)或已被关闭,
* 分屏自动收起 —— 否则同一标签会被两个面板同时持有,改动互相打架。
*/
const splitTabId = ref('')
const splitTab = computed(() => store.tabs.find(t => t.id === splitTabId.value) ?? null)
function openSplit(id: string): void {
if (id !== store.activeTabId) splitTabId.value = id
}
watch(
() => [splitTabId.value, store.activeTabId, store.tabs.length] as const,
() => {
if (splitTabId.value && (!splitTab.value || splitTabId.value === store.activeTabId)) {
splitTabId.value = ''
}
}
)
/**
* 预览用的 HTML 片段(`renderMarkdownFragment` 的产物,已过 DOMPurify)。
*
* 它只作为**渲染产物**存在,是否允许显示由 [`previewReady`] 决定 —— 绝不把「上一份
* 内容」当占位显示(先出现旧内容再被替换,观感很差)。
*/
const previewHtml = ref('')
/** 当前活动标签是否正处于预览 */
const previewActive = computed(
() => !!store.activeTabId && previewIds.value.includes(store.activeTabId)
)
/**
* 现有 `previewHtml` 是「为哪个标签、哪一版内容」渲染的(`null` = 还没渲染出来)。
*
* 用「标签 + 内容」双判据而不是一个 `loading` 布尔:切标签、切预览、内容被外部改动
* 这几种情况都会让已有产物失效,判据写在数据里就不用在每个入口手动置位。
*/
const previewRenderedFor = ref<{ id: string; content: string } | null>(null)
/** 当前是否可以直接显示 `previewHtml`(对得上活动标签与当前内容) */
const previewReady = computed(() => {
const rendered = previewRenderedFor.value
return (
rendered !== null && rendered.id === store.activeTabId && rendered.content === store.content
)
})
/** 渲染令牌:丢弃过期的异步渲染结果(快速切换标签 / 连续修改内容时) */
let previewToken = 0
/**
* 渲染模块缓存。
*
* 渲染链路(markdown-it + DOMPurify + highlight.js,约 1MB)与导出一样**按需 import**:
* 只有用户真的点开预览才付这份体积。缓存下来还能让后续渲染**同步完成** —— 否则每次
* 都要先过一个微任务,面板会闪一下「正在渲染」。
*/
let renderModule: typeof import('./editor/markdownExport') | null = null
/**
* 重新渲染预览(拿到的是**已消毒的 HTML 片段**,直接 `v-html`,不走 iframe)。
*
* `id` / `content` 在 await 之前取值:等待期间用户可能切了标签或改了内容,那样这次
* 结果就作废(令牌不一致),不能把旧文档的渲染挂到新文档上。
*/
async function refreshPreview(): Promise<void> {
const token = ++previewToken
if (!previewActive.value) return
const id = store.activeTabId
const content = store.content
// 先标失效:宁可短暂显示「正在渲染」,也不显示上一份内容
previewRenderedFor.value = null
try {
const mod = renderModule ?? (renderModule = await import('./editor/markdownExport'))
if (token !== previewToken || !previewActive.value) return
previewHtml.value = mod.renderMarkdownFragment(content)
previewRenderedFor.value = { id, content }
} catch (e) {
logger.error(`Markdown 预览渲染失败:${String(e)}`)
}
}
/** 切换某个标签的预览状态;开启时把它切到前台(否则点了看不到任何变化)。 */
function togglePreview(id: string): void {
const index = previewIds.value.indexOf(id)
if (index >= 0) {
previewIds.value.splice(index, 1)
return
}
previewIds.value.push(id)
// 切到前台;渲染由下面的 watch 触发(切标签与「开预览」都走同一条路径)
store.activateTab(id)
}
// 预览开关 / 内容变化要重渲染(深浅主题不需要:配色走 CSS 变量,自动跟随)。
// 非预览状态下的内容变化直接跳过 —— 否则每敲一个字都要重新渲染整篇。
watch([previewActive, () => store.content], () => {
if (!previewActive.value) return
void refreshPreview()
})
// ===== 编辑器命令转发 =====
function applyCommand(command: Command): void {
const view = hostRef.value?.getView() as EditorView | null | undefined
@@ -349,8 +608,12 @@ const searchDir = computed(() => {
const libraryPath = computed(() => store.info?.root ?? '')
function openSearch(scope: SearchScope = 'file'): void {
const wasOpen = searchOpen.value
searchScope.value = scope
searchOpen.value = true
// 已经打开时再次 Ctrl+F:把新选中的文本换进输入框(与输入栏内容不同才替换)。
// 关闭状态下由 EditorSearch 的 open 监听统一预填,这里不重复触发。
if (wasOpen) searchRef.value?.refillFromSelection()
}
/** 结果点击:打开文件并跳到那一行(检索期间文件可能已被改动,由 jumpToLine 夹取)。 */
@@ -451,6 +714,95 @@ async function doOpenFile(): Promise<void> {
}
}
// ===== 拖入文件打开 =====
/**
* 把拖入的路径逐个打开:文件夹进「目录」面板,文件按「库内笔记 / 库外文件」分流
* (分流规则在 `store.openDoc`)。
*
* # 为什么用 Tauri 原生拖放事件
*
* `dragDropEnabled` 默认开启时 Tauri 会替换 WebView2 的拖放处理器,HTML5 的
* `drop` 事件在 Windows 上拿不到外部文件路径;原生 `onDragDropEvent` 才能拿到
* `paths`。
*
* # 已知限制(非代码问题)
*
* Windows UIPI 会拦截从资源管理器(中完整性)拖入以**管理员**运行的窗口
* (高完整性),因此仅当 Thing 以普通权限运行时拖入才可用。
*/
async function onDroppedPaths(paths: string[]): Promise<void> {
for (const path of paths) {
try {
if ((await editorClient.pathKind(path)) === 'folder') {
await store.openFolder(path)
sidebarVisible.value = true
sidebarRef.value?.showDirectory()
} else {
await store.openDoc(path)
}
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
}
/**
* HTML5 `drop` 兜底。
*
* 正常情况下拖放由 Tauri 原生处理器接管,页面根本收不到 `drop`;但在 Windows 上
* 一旦原生处理器没接管(例如透明/分层窗口),浏览器就会把文件当「可放置内容」交给
* 页面 —— CodeMirror 的 contenteditable 会把**文件内容插进当前文档**,这就是
* 「拖入后内容被写进正在编辑的文件」的原因。这里 `preventDefault` 拦住这个默认
* 行为(同时消除拖动过程中的卡顿),并在能拿到绝对路径时照样打开。
*/
/** HTML5 dragover:亮遮罩(只有在 Tauri 原生拖放未接管时才会触发,见 onDomDrop)。 */
function onDomDragOver(): void {
dragOver.value = true
}
function onDomDrop(event: DragEvent): void {
// 拦 `drop` 默认行为:Chromium 对 contenteditable 的默认处理会把文件内容插进文档
event.preventDefault()
dragOver.value = false
const files = Array.from(event.dataTransfer?.files ?? [])
const paths = files
.map(f => (f as File & { path?: string }).path)
.filter((p): p is string => !!p)
if (paths.length) {
void onDroppedPaths(paths)
} else if (files.length) {
logger.warn(`拖放未走原生通道(files=${files.length},取不到绝对路径)`)
toast.error('未取到拖入文件的绝对路径(拖放被浏览器接管),请改用「打开文件」')
}
}
// ===== 主窗口发来的「在既有窗口加标签」 =====
/**
* 在**本窗口**打开一个目标(加标签 / 切到已开的标签)。
*
* 主窗口在发现有编辑器窗口时不再开新窗口,而是 `emitTo` 这个事件(见
* `openWindow.ts`)。监听放在组件而不是 store:store 的监听每个窗口都注册,
* 放进去会让主窗口自己把目标也「打开」一遍(主窗口没有编辑器界面,纯属副作用)。
*
* 三种目标与 `openEditorWindow` 的入参一一对应:`relPath`(库内笔记,笔记语义)、
* `path` + `folder`(目录面板)、`path`(库外文件)。
*/
async function onOpenTabRequest(payload: EditorOpenTabPayload): Promise<void> {
try {
if (payload.relPath) {
await store.openNote(payload.relPath)
} else if (payload.path && payload.folder) {
sidebarVisible.value = true
sidebarRef.value?.showDirectory()
await store.openFolder(payload.path)
} else if (payload.path) {
await store.openFile(payload.path)
}
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
// ===== 外部改动 =====
const externalConfirmOpen = ref(false)
@@ -540,11 +892,44 @@ onMounted(async () => {
window.addEventListener('storage', onStorageChange)
window.addEventListener('keydown', onKeydown, true)
// 拖入文件打开:走 Tauri 原生拖放事件(`enter/over` 亮遮罩,`drop` 取 paths)。
// 用 webview 而非 window 注册:拖放事件在 Rust 侧是发给 webview 的。
const selfWebview = getCurrentWebview()
unlistenDragDrop = await selfWebview.onDragDropEvent(event => {
const payload = event.payload
if (payload.type === 'enter' || payload.type === 'over') {
dragOver.value = true
} else if (payload.type === 'drop') {
dragOver.value = false
logger.info(`原生拖放 drop:${payload.paths.length} 项`)
void onDroppedPaths(payload.paths)
} else {
dragOver.value = false
}
})
logger.info(`拖放监听已注册:webview=${selfWebview.label}`)
// 主窗口要求「在既有窗口里加标签」:定向事件(`emitTo`),只有本窗口会收到
unlistenOpenTab = await listen<EditorOpenTabPayload>(EVENTS.editorOpenTab, event => {
void onOpenTabRequest(event.payload ?? {})
})
// 检索历史与面板高度来自 localStorage:尽早读取,状态栏按钮与结果面板都要用
searchStore.init()
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)。
// 窗口深浅要按设置里的「跟随主应用主题 / 配色方案」推导,因此先取一次设置;
// `store.init()` 后面还会再读一次(无害,且那次要顺带做库扫描等初始化)。
await store.loadSettings()
await applyTheme()
// 任务栏身份:窗口级 AUMID(拆成独立任务栏按钮,不与主窗口合并)+ 组合图标
// (编辑器图形 + 右下角主程序图标)。**必须在 show() 之前**——任务栏按钮在窗口显示时
// 按 AUMID 决定分组,显示后再改往往要 hide/show 才生效。
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'editor' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try {
await win.show()
await win.setFocus()
@@ -580,6 +965,10 @@ onBeforeUnmount(() => {
darkMedia.removeEventListener('change', onThemeChange)
window.removeEventListener('storage', onStorageChange)
window.removeEventListener('keydown', onKeydown, true)
unlistenDragDrop?.()
unlistenDragDrop = null
unlistenOpenTab?.()
unlistenOpenTab = null
if (sessionTimer) {
clearTimeout(sessionTimer)
sessionTimer = null
@@ -660,7 +1049,12 @@ async function saveThenRedecode(): Promise<void> {
</script>
<template>
<div class="editor-window relative flex h-screen flex-col overflow-hidden text-foreground">
<div
class="editor-window relative flex h-screen flex-col overflow-hidden text-foreground"
@dragenter.prevent="onDomDragOver"
@dragover.prevent="onDomDragOver"
@drop.prevent="onDomDrop"
>
<!-- 自绘标题栏:仅标题区是拖动区,右侧按钮区不是(否则鼠标事件被拖动拦截) -->
<header class="flex h-9 shrink-0 items-center gap-1 border-b border-border px-2">
<!--
@@ -678,6 +1072,18 @@ async function saveThenRedecode(): Promise<void> {
<span v-if="store.dirty" class="size-1.5 shrink-0 rounded-full bg-primary" />
</div>
<!-- 设置:库设置 / 编辑器设置的快捷入口(在主界面对应「库」「编辑器」两页) -->
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="settingsOpen = true">
<Settings class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">设置</TooltipContent>
</Tooltip>
</TooltipProvider>
<div class="w-px h-4 bg-border shrink-0" />
<TooltipProvider :delay-duration="400">
@@ -736,7 +1142,17 @@ async function saveThenRedecode(): Promise<void> {
/>
<!-- 文档标签栏(多文档) -->
<EditorTabs v-if="store.tabs.length" @close="requestCloseTab" />
<EditorTabs
v-if="store.tabs.length"
:preview-ids="previewIds"
@close="requestCloseTab"
@toggle-preview="togglePreview"
@close-others="requestCloseTabs(tabIdsExcept($event))"
@close-left="requestCloseTabs(tabIdsLeftOf($event))"
@close-right="requestCloseTabs(tabIdsRightOf($event))"
@close-all="requestCloseTabs(store.tabs.map(t => t.id))"
@split="openSplit"
/>
<!-- 外部改动提示(有未保存改动时才会出现) -->
<div
@@ -764,16 +1180,19 @@ async function saveThenRedecode(): Promise<void> {
<!-- 统一搜索栏:横跨编辑列宽度,压在内容上方(IDEA 的 Find 栏位置) -->
<EditorSearch
ref="searchRef"
v-model:open="searchOpen"
v-model:scope="searchScope"
:dir-path="searchDir"
:library-path="libraryPath"
:get-view="getEditorView"
:doc-revision="store.docRevision"
@open-file="onSearchOpenFile"
@replaced="onPathReplaced"
/>
<main class="relative flex min-h-0 min-w-0 flex-1 flex-col">
<main class="flex min-h-0 min-w-0 flex-1">
<div class="relative flex min-h-0 min-w-0 flex-1 flex-col">
<div v-if="!store.hasDocument" class="flex min-h-0 flex-1 items-center justify-center">
<StateBlock
variant="empty"
@@ -800,6 +1219,73 @@ async function saveThenRedecode(): Promise<void> {
@wikilink="onWikilink"
/>
<!--
Markdown 预览:盖在编辑器**之上**而不是替换它 —— EditorHost 保持挂载,
来回切换不会丢撤销历史、光标与滚动位置。滚动交给项目的 ScrollArea(原生滚动条
在深色主题下与整体观感割裂),内容直接用 `v-html`(已消毒片段)。
# 为什么不是 iframe `srcdoc`(原先的做法)
Tauri 的插件(这里的 snap-layout)会向**每个 document** 注入初始化脚本,iframe
里的 `about:srcdoc` 也在其中:注入脚本在无 `__TAURI_INTERNALS__` 的帧里抛错,
而且帧被销毁重建后 `srcdoc` 的二次导航在 WebView2 上不可靠 —— 表现就是「退出
预览后再点预览,一片空白」。改用应用内渲染后这两个问题都不存在,样式改由
下面 `.md-preview` 的 scoped 规则隔离(安全边界仍是 DOMPurify,与导出同一套)。
已知限制:正文里**相对路径的本地图片**在预览中不会加载 —— 面板没有「库根 /
当前笔记目录」这个上下文(Live Preview 是靠 `editor_read_asset` 把图片取成
data URL 才显示的)。
-->
<!--
⚠️ 定位必须落在**外层这层 div**上,不能直接给 `ScrollArea` 加 `absolute`:
reka-ui 的 ScrollAreaRoot 自带内联 `position: relative`,内联样式压过 class,
于是 `absolute` 失效 —— 根节点退化成内容高度,viewport 没有可滚动空间
(症状就是「预览显示出来了,但滚不动」)。
-->
<div v-if="previewActive" class="absolute inset-0 bg-background">
<ScrollArea v-if="previewReady" class="h-full w-full">
<!-- eslint-disable-next-line vue/no-v-html -- 内容来自 renderMarkdownFragment(已过 DOMPurify) -->
<div class="md-preview" v-html="previewHtml" />
</ScrollArea>
<!-- 渲染未就绪:显示占位而**不是**上一份内容(旧内容先出现再被替换的观感很差) -->
<div v-else class="flex h-full items-center justify-center gap-2 text-xs text-muted-foreground">
<Loader2 class="size-3.5 animate-spin" />
正在渲染预览…
</div>
</div>
</div>
<!--
并排副面板:与主编辑列等宽,绑定**另一个标签**自己的缓冲(见 EditorHost 的 tabId)。
`:key` 保证换目标时整块重建(编辑器实例不可跨文档复用)。
-->
<div
v-if="splitTab"
class="relative flex min-h-0 w-1/2 min-w-0 flex-col border-l border-border"
>
<div class="flex h-8 shrink-0 items-center gap-1.5 border-b border-border px-2 text-xs">
<FileText v-if="splitTab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate font-medium text-foreground">{{ splitTab.name }}</span>
<Button
variant="ghost"
size="icon-sm"
class="ml-auto"
title="关闭分屏"
@click="splitTabId = ''"
>
<X class="size-3.5" />
</Button>
</div>
<EditorHost
:key="splitTab.id"
:tab-id="splitTab.id"
:is-dark="isDark"
:live-preview="store.viewMode === 'wysiwyg'"
class="min-h-0 flex-1"
/>
</div>
</main>
<!-- 目录 / 库检索结果面板:编辑列底部(IDE 的「Find in Path」工具窗位置) -->
@@ -914,14 +1400,31 @@ async function saveThenRedecode(): Promise<void> {
<!-- 快速打开(Ctrl+P) -->
<QuickOpen v-model:open="quickOpen" @select="store.openNote($event)" />
<!-- 关闭确认 -->
<ConfirmDialog
v-model:open="closeConfirmOpen"
title="有未保存的改动"
description="关闭窗口会丢失这些改动(自动保存会对未保存内容做最后一次尝试)。"
confirm-text="保存并关闭"
@confirm="forceClose"
/>
<!-- 设置对话框:库设置 / 编辑器设置(即时生效,无需保存按钮) -->
<EditorSettingsDialog v-model:open="settingsOpen" />
<!--
关闭窗口:三选一(保存并关闭 / 放弃修改并关闭 / 取消)。
与下面「关闭脏标签」同一套取舍 —— ConfirmDialog 只有两键,而「放弃修改」是用户
在这里最常需要的那条出路,不能藏在「取消」里。
-->
<Dialog :open="closeConfirmOpen" @update:open="closeConfirmOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>有未保存的改动</DialogTitle>
<DialogDescription>
「保存并关闭」会先把每个标签写入磁盘再退出;「放弃修改并关闭」直接丢弃这些改动。
</DialogDescription>
</DialogHeader>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="forceClose">保存并关闭</Button>
<Button variant="destructive" class="w-full" @click="discardAndCloseWindow">
放弃修改并关闭
</Button>
<Button variant="ghost" class="w-full" @click="closeConfirmOpen = false">取消</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 重载确认 -->
<ConfirmDialog
@@ -933,13 +1436,37 @@ async function saveThenRedecode(): Promise<void> {
@confirm="reloadFromExternal"
/>
<!-- 关闭标签确认 -->
<!--
关闭脏标签:三选一(保存并关闭 / 放弃修改并关闭 / 取消)。
不用 ConfirmDialog —— 它只有「确认 / 取消」两键,而「放弃修改」是用户在这里最常
需要的那条出路,不能藏在「取消」里(同下面草稿关闭对话框的取舍)。
-->
<Dialog :open="tabCloseConfirmOpen" @update:open="tabCloseConfirmOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>该标签有未保存的改动</DialogTitle>
<DialogDescription>
关闭标签会丢失这些改动。「保存并关闭」会先写入磁盘,再关闭标签。
</DialogDescription>
</DialogHeader>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="confirmCloseTab">保存并关闭</Button>
<Button variant="destructive" class="w-full" @click="discardAndCloseTab">
放弃修改并关闭
</Button>
<Button variant="ghost" class="w-full" @click="tabCloseConfirmOpen = false">取消</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 批量关闭确认:一次关多个标签,不做逐标签「保存 / 放弃」三选一 -->
<ConfirmDialog
v-model:open="tabCloseConfirmOpen"
title="该标签有未保存的改动"
description="关闭标签会丢失这些改动(选择「保存并关闭」会先保存再关闭)。"
confirm-text="保存并关闭"
@confirm="confirmCloseTab"
v-model:open="batchCloseOpen"
title="关闭多个标签"
variant="danger"
confirm-text="放弃修改并关闭"
:description="`选中的 ${batchCloseIds.length} 个标签中有未保存的改动或临时草稿,关闭会丢失这些改动。`"
@confirm="confirmBatchClose"
/>
<!--
@@ -988,6 +1515,22 @@ async function saveThenRedecode(): Promise<void> {
</DialogContent>
</Dialog>
<!-- 拖入提示遮罩(Tauri 原生拖放事件驱动;HTML5 拖放被 Tauri 接管,不可用) -->
<div
v-if="dragOver"
class="pointer-events-none absolute inset-0 z-50 flex items-center justify-center bg-background/70 backdrop-blur-sm"
>
<div
class="flex flex-col items-center gap-1.5 rounded-lg border-2 border-dashed border-primary px-8 py-6 text-center"
>
<NotebookPen class="size-6 text-primary" />
<span class="text-sm font-medium">松开以打开</span>
<span class="text-xs text-muted-foreground">
文件在本窗口打开,文件夹载入「目录」面板
</span>
</div>
</div>
<Toaster />
</div>
</template>
@@ -997,4 +1540,130 @@ async function saveThenRedecode(): Promise<void> {
.editor-window {
background: var(--popup-bg, var(--background));
}
/* ===== Markdown 预览 =====
与导出(`markdownExport` 的 EXPORT_STYLE)是同一套排版语言,但配色**全部换成应用语义
变量**:导出物要离线自洽,必须写死颜色;预览在应用内,深浅主题应当自动跟随。
预览**不套卡片外壳**:没有 max-width、没有阴影、没有灰底,正文直接铺满整个编辑区,
滚动交给外层的 ScrollArea(原生滚动条与本项目观感不一致,见 EditorHost 的同款处理)。 */
.md-preview {
padding: 16px 30px 72px;
color: var(--foreground);
font-size: 14.5px;
line-height: 1.75;
overflow-wrap: break-word;
}
.md-preview :deep(h1),
.md-preview :deep(h2),
.md-preview :deep(h3),
.md-preview :deep(h4),
.md-preview :deep(h5),
.md-preview :deep(h6) {
margin: 1.6em 0 0.6em;
font-weight: 600;
line-height: 1.35;
}
.md-preview :deep(h1) {
font-size: 1.7em;
padding-bottom: 0.3em;
border-bottom: 1px solid var(--border);
}
.md-preview :deep(h2) {
font-size: 1.4em;
padding-bottom: 0.3em;
border-bottom: 1px solid var(--border);
}
.md-preview :deep(h3) { font-size: 1.2em; }
.md-preview :deep(h4) { font-size: 1.05em; }
.md-preview :deep(p) { margin: 0 0 1em; }
.md-preview :deep(a) {
color: var(--primary);
text-decoration: none;
border-bottom: 1px solid color-mix(in srgb, var(--primary) 35%, transparent);
}
.md-preview :deep(a:hover) { border-bottom-color: currentColor; }
.md-preview :deep(strong) { font-weight: 600; }
.md-preview :deep(mark) {
padding: 0 0.15em;
background: var(--warning-soft);
color: inherit;
border-radius: 2px;
}
.md-preview :deep(img) { max-width: 100%; height: auto; border-radius: 6px; }
.md-preview :deep(blockquote) {
margin: 0 0 1em;
padding: 0.2em 0 0.2em 1em;
border-left: 4px solid var(--border);
color: var(--fg-secondary);
}
.md-preview :deep(blockquote > :last-child) { margin-bottom: 0; }
.md-preview :deep(ul),
.md-preview :deep(ol) { margin: 0 0 1em; padding-left: 1.6em; }
.md-preview :deep(li) { margin: 0.25em 0; }
.md-preview :deep(li.task-list-item) { margin-left: -1.35em; list-style: none; }
.md-preview :deep(input[type='checkbox']) { margin-right: 0.45em; vertical-align: middle; }
.md-preview :deep(code) {
padding: 0.15em 0.35em;
font-family: var(--font-mono);
font-size: 0.9em;
background: var(--subtle);
border-radius: 4px;
}
.md-preview :deep(pre) {
margin: 0 0 1em;
padding: 12px 14px;
overflow-x: auto;
background: var(--subtle);
border: 1px solid var(--border);
border-radius: 6px;
line-height: 1.55;
}
.md-preview :deep(pre code) {
padding: 0;
font-size: 0.875em;
background: transparent;
white-space: pre;
}
.md-preview :deep(table) {
display: block;
max-width: 100%;
margin: 0 0 1em;
overflow-x: auto;
border-collapse: collapse;
}
.md-preview :deep(th),
.md-preview :deep(td) { padding: 6px 12px; border: 1px solid var(--border); }
.md-preview :deep(th) { font-weight: 600; background: var(--subtle); }
.md-preview :deep(hr) { height: 1px; margin: 1.8em 0; border: 0; background: var(--border); }
/* 高亮 token:只做「语义色 → 主题变量」的映射,深浅各自可读(对应导出的固定配色表) */
.md-preview :deep(.hljs-comment),
.md-preview :deep(.hljs-quote) { color: var(--muted-foreground); font-style: italic; }
.md-preview :deep(.hljs-keyword),
.md-preview :deep(.hljs-selector-tag),
.md-preview :deep(.hljs-literal),
.md-preview :deep(.hljs-section) { color: var(--danger); }
.md-preview :deep(.hljs-string),
.md-preview :deep(.hljs-regexp),
.md-preview :deep(.hljs-addition) { color: var(--success); }
.md-preview :deep(.hljs-number),
.md-preview :deep(.hljs-symbol),
.md-preview :deep(.hljs-bullet) { color: var(--info); }
.md-preview :deep(.hljs-title),
.md-preview :deep(.hljs-name),
.md-preview :deep(.hljs-selector-id),
.md-preview :deep(.hljs-selector-class) { color: var(--info); }
.md-preview :deep(.hljs-attr),
.md-preview :deep(.hljs-attribute),
.md-preview :deep(.hljs-variable),
.md-preview :deep(.hljs-template-variable) { color: var(--warning); }
.md-preview :deep(.hljs-built_in),
.md-preview :deep(.hljs-type) { color: var(--info); }
.md-preview :deep(.hljs-meta),
.md-preview :deep(.hljs-doctag),
.md-preview :deep(.hljs-deletion) { color: var(--danger); }
.md-preview :deep(.hljs-tag) { color: var(--success); }
.md-preview :deep(.hljs-emphasis) { font-style: italic; }
.md-preview :deep(.hljs-strong) { font-weight: 600; }
</style>
@@ -22,7 +22,7 @@
* 清空子层缓存 → 重读根 → 并行重读所有已展开目录。展开的目录通常只有几个,代价可忽略;
* 换来的是「缓存里的路径永远有效」这条不变量(拖放目标、选中集都按路径工作)。
*/
import { computed, ref, watch } from 'vue'
import { computed, nextTick, ref, watch } from 'vue'
import {
AppWindow,
ArrowUp,
@@ -36,6 +36,7 @@ import {
FolderOpen,
FolderPlus,
Loader2,
LocateFixed,
Pencil,
RotateCw,
SquarePen,
@@ -256,6 +257,90 @@ async function refresh(): Promise<void> {
}
}
// ===== 定位当前文件 =====
//
// 树是懒加载的,「定位」必须顺着路径逐级展开并**按需拉取**中间层,否则目标行根本
// 不在 `rows` 里。虚线是:只对当前打开的库外文件(`fileDoc.path`)且确实位于本目录根
// 之下时才提供入口 —— 否则点了也没有意义。
/** 树内容容器(滚动目标用) */
const treeRef = ref<HTMLElement | null>(null)
/** 需要短暂高亮的路径(定位反馈) */
const locateTarget = ref('')
function normalizePath(p: string): string {
return p.replace(/\//g, '\\').replace(/\\+$/, '')
}
const currentFilePath = computed(() => {
if (store.kind === 'file') return store.fileDoc?.path ?? ''
// 库内笔记也可定位:只要它所在的库目录被当作本地目录打开过,就能在这棵树里找到
if (store.kind === 'note' && store.currentRelPath) return store.noteAbsPath(store.currentRelPath)
return ''
})
/** 当前文件是否在本目录根之下(决定定位按钮是否出现)。 */
const canLocateCurrent = computed(() => {
const file = currentFilePath.value
const root = rootCwd.value
if (!file || !root) return false
const fn = normalizePath(file).toLowerCase()
const rn = normalizePath(root).toLowerCase()
return fn.startsWith(`${rn}\\`)
})
/** 某个目录当前可见的子项(根走 `dirListing`,其余走子层缓存)。 */
function entriesOf(dir: string): DirEntry[] {
if (normalizePath(dir).toLowerCase() === normalizePath(rootCwd.value).toLowerCase()) {
return rootEntries.value
}
return childrenMap.value.get(dir) ?? []
}
/** 确保某目录的子层已缓存(根无需加载)。 */
async function ensureChildren(dir: string): Promise<void> {
if (normalizePath(dir).toLowerCase() === normalizePath(rootCwd.value).toLowerCase()) return
if (!childrenMap.value.has(dir)) await loadChildren(dir)
}
/** 展开到当前文件的父目录,滚动到该行并短暂高亮。 */
async function locateCurrent(): Promise<void> {
const file = currentFilePath.value
const root = rootCwd.value
if (!file || !root || !canLocateCurrent.value) return
// 过滤会隐藏目标行,先清掉
filter.value = ''
const rootNorm = normalizePath(root)
const relative = normalizePath(file).slice(rootNorm.length).replace(/^\\+/, '')
const segments = relative.split('\\').filter(Boolean)
segments.pop() // 去掉文件名,只展开到父目录
const next = new Set(expanded.value)
let current = rootNorm
for (const segment of segments) {
await ensureChildren(current)
const found = entriesOf(current).find(e => e.kind === 'dir' && e.name === segment)
if (!found) {
current = ''
break
}
next.add(found.path)
current = found.path
}
expanded.value = next
if (!current) return
await ensureChildren(current) // 让目标文件行出现在列表里
locateTarget.value = file
await nextTick()
const rows = treeRef.value?.querySelectorAll<HTMLElement>('[data-path]')
const target = rows ? Array.from(rows).find(el => el.dataset.path === file) : undefined
target?.scrollIntoView({ block: 'center' })
window.setTimeout(() => {
if (locateTarget.value === file) locateTarget.value = ''
}, 1400)
}
function openEntry(entry: DirEntry): void {
if (entry.kind === 'dir') {
toggleDir(entry)
@@ -589,6 +674,16 @@ function menuDelete(): void {
>
<RotateCw class="size-3.5" :class="store.dirLoading && 'animate-spin'" />
</Button>
<!-- 定位当前文件:仅当前打开的文件位于本目录之下时出现(否则无意义) -->
<Button
v-if="canLocateCurrent"
variant="ghost"
size="icon-sm"
title="定位当前文件(展开目录树并高亮)"
@click="locateCurrent"
>
<LocateFixed class="size-3.5" />
</Button>
<span class="ml-1 truncate text-[11px] font-medium text-fg-secondary" :title="store.dirListing?.cwd">
{{ cwdName }}
</span>
@@ -631,7 +726,7 @@ function menuDelete(): void {
<!-- 树 -->
<ScrollArea v-if="store.dirListing" class="min-h-0 flex-1">
<div class="px-1.5 pb-2">
<div ref="treeRef" class="px-1.5 pb-2">
<div v-if="store.dirLoading && !rootEntries.length" class="flex items-center justify-center gap-2 p-4">
<Loader2 class="size-3.5 animate-spin text-muted-foreground" />
<span class="text-[11px] text-muted-foreground">正在读取目录…</span>
@@ -649,14 +744,16 @@ function menuDelete(): void {
<div
v-for="row in rows"
:key="row.entry.path"
:data-path="row.entry.path"
class="group flex h-7 cursor-pointer items-center gap-1 rounded-sm pr-1.5 transition-colors duration-150"
:class="[
selected.has(row.entry.path)
? 'bg-primary-soft text-primary-soft-text'
: store.fileDoc?.path === row.entry.path
: currentFilePath === row.entry.path
? 'bg-row-selected text-primary-soft-text'
: 'text-fg-secondary hover:bg-row-hover hover:text-foreground',
dropTarget === row.entry.path && 'ring-1 ring-primary ring-inset'
dropTarget === row.entry.path && 'ring-1 ring-primary ring-inset',
locateTarget === row.entry.path && 'ring-2 ring-primary ring-inset'
]"
:style="{ paddingLeft: `${row.depth * 12 + 4}px` }"
:title="row.entry.path"
+74 -35
View File
@@ -36,15 +36,27 @@ import {
} from '../editor/core'
import { editorBackground } from '../editor/themes'
import { createLogger } from '@/lib/logger'
import type { LanguageLoader } from '../editor/languages'
import type { Extension } from '@codemirror/state'
const logger = createLogger('editor')
const props = defineProps<{
/** 应用当前是否深色(跟随应用主题时用于取深/浅变体) */
/**
* 编辑器**窗口**当前是否深色(由 EditorWindow 按「跟随主应用主题 / 配色方案」推导)。
* 用于:跟随应用时按它取深浅变体,配色方案为「跟随系统」时按它取 VS Code 深/浅。
*/
isDark: boolean
/** 是否启用 Live Preview */
livePreview: boolean
/**
* 绑定的标签 id(并排副面板用)。
*
* 缺省(主面板)= 绑定 store 的**扁平活动文档**;给出 id 时 = 绑定该标签**自己的缓冲**
* (读 `tab.content`、写 `tab.content` 并置脏、保存走 `saveTab`)。副面板永远绑定非活动
* 标签,因此不会与主面板争抢扁平 state。
*/
tabId?: string
}>()
const emit = defineEmits<{
@@ -57,6 +69,29 @@ const emit = defineEmits<{
const store = useEditorStore()
const hostRef = ref<HTMLDivElement | null>(null)
/** 是否为「绑定某个标签」的副面板(否则为主面板,读扁平 state)。 */
const isPane = computed(() => !!props.tabId)
/** 副面板绑定的标签(主面板为 null)。 */
const boundTab = computed(() =>
props.tabId ? store.tabs.find(t => t.id === props.tabId) ?? null : null
)
/** 需要读取的文档属性:主面板取扁平 state,副面板取标签缓冲。 */
const paneContent = computed(() => (isPane.value ? boundTab.value?.content ?? '' : store.content))
const paneLarge = computed(() =>
isPane.value ? boundTab.value?.fileDoc?.large ?? false : store.fileDoc?.large ?? false
)
const paneKind = computed(() => (isPane.value ? boundTab.value?.kind ?? 'none' : store.kind))
const paneRelPath = computed(() =>
isPane.value ? boundTab.value?.relPath ?? '' : store.currentRelPath
)
const paneRevision = computed(() =>
isPane.value ? boundTab.value?.docRevision ?? 0 : store.docRevision
)
const paneLanguage = computed<LanguageLoader>(() =>
isPane.value ? boundTab.value?.language ?? (() => Promise.resolve(null)) : store.language
)
/**
* 编辑器外壳底色:跟随当前**实际生效**的主题。
*
@@ -78,7 +113,8 @@ let languageSeq = 0
function currentConfig(): EditorConfig {
const s = store.settings
const large = store.fileDoc?.large ?? false
const large = paneLarge.value
const note = paneKind.value === 'note'
return {
livePreview: props.livePreview,
showLineNumbers: s.showLineNumbers,
@@ -95,11 +131,11 @@ function currentConfig(): EditorConfig {
language: () => null,
largeFile: large,
autocomplete: s.autocomplete,
wikilink: s.wikilink && store.kind === 'note',
wikilink: s.wikilink && note,
onWikilink: target => emit('wikilink', target),
// 图片预览只在库内笔记里有意义(库外文件没有库根上下文)
currentRelPath: store.kind === 'note' ? store.currentRelPath : '',
images: store.kind === 'note'
currentRelPath: note ? paneRelPath.value : '',
images: note
}
}
@@ -109,16 +145,21 @@ function scheduleAutosave(): void {
if (autosaveTimer) clearTimeout(autosaveTimer)
autosaveTimer = setTimeout(() => {
autosaveTimer = null
void store.saveCurrent().catch(() => undefined)
void persist().catch(() => undefined)
}, ms)
}
/** 落盘:主面板存活动文档,副面板存它绑定的标签。 */
function persist(): Promise<void> {
return isPane.value && props.tabId ? store.saveTab(props.tabId) : store.saveCurrent()
}
function flushAutosave(): void {
if (autosaveTimer) {
clearTimeout(autosaveTimer)
autosaveTimer = null
}
void store.saveCurrent().catch(() => undefined)
void persist().catch(() => undefined)
}
/** 加载并应用当前文档的语言扩展。 */
@@ -126,7 +167,7 @@ async function applyLanguage(seq: number): Promise<void> {
if (!view) return
let extension: Extension | null = null
try {
extension = await store.language()
extension = await paneLanguage.value()
} catch (e) {
logger.warn(`语言扩展加载失败:${String(e)}`)
}
@@ -140,17 +181,21 @@ onMounted(() => {
view = new EditorView({
parent: hostRef.value,
state: createEditorState({
doc: store.content,
doc: paneContent.value,
config: currentConfig(),
onDocChanged: doc => {
if (applyingDoc) return
store.setContent(doc)
if (isPane.value && props.tabId) store.setTabContent(props.tabId, doc)
else store.setContent(doc)
scheduleAutosave()
},
onSelectionChanged: (line, column) => emit('cursor-moved', line, column)
// 副面板的光标不该覆盖状态栏(状态栏跟随活动文档)
onSelectionChanged: (line, column) => {
if (!isPane.value) emit('cursor-moved', line, column)
}
})
})
appliedRevision = store.docRevision
appliedRevision = paneRevision.value
void applyLanguage(++languageSeq)
})
@@ -160,20 +205,20 @@ onMounted(() => {
* 用 `docRevision` 而不是路径:重载同一篇时路径没变,但内容必须被换掉。
*/
watch(
() => store.docRevision,
() => {
paneRevision,
revision => {
if (!view) return
if (autosaveTimer) {
clearTimeout(autosaveTimer)
autosaveTimer = null
}
if (appliedRevision === store.docRevision) return
appliedRevision = store.docRevision
if (appliedRevision === revision) return
appliedRevision = revision
// 目标光标行要在 replaceDoc **之前**取:替换会派发 selection 变化,
// updateListener 随即把 store.cursorLine 覆盖成 1,之后再读就只剩第 1 行了。
const restoreLine = store.cursorLine
const restoreLine = isPane.value ? 1 : store.cursorLine
applyingDoc = true
replaceDoc(view, store.content)
replaceDoc(view, paneContent.value)
// 标签切换 / 会话恢复:按 store.cursorLine 复位光标(默认第 1 行不动)
if (restoreLine > 1) {
const line = Math.min(restoreLine, view.state.doc.lines)
@@ -186,12 +231,9 @@ watch(
)
/** 语言变化(异步加载完成 / 切换到另一种语言)。 */
watch(
() => store.language,
() => {
void applyLanguage(++languageSeq)
}
)
watch(paneLanguage, () => {
void applyLanguage(++languageSeq)
})
/**
* 切换笔记:Live Preview 的图片预览按「相对当前笔记所在目录」解析目标,
@@ -200,21 +242,18 @@ watch(
* 只动 mode 与 wikilink 两个 compartment:语言由 `applyLanguage` 单独负责,
* 在这里一并 reconfigure 会把刚异步加载好的语言重置掉。
*/
watch(
() => store.currentRelPath,
() => {
if (!view) return
try {
reconfigureEditor(view, currentConfig())
} catch (e) {
logger.error(`切换笔记后重配置失败:${String(e)}`)
}
watch(paneRelPath, () => {
if (!view) return
try {
reconfigureEditor(view, currentConfig())
} catch (e) {
logger.error(`切换笔记后重配置失败:${String(e)}`)
}
)
})
/** 设置 / 深浅 / 视图模式 / 文档类型变化:热重配置,不重建编辑器。 */
watch(
() => [store.settings, props.isDark, props.livePreview, store.fileDoc?.large],
() => [store.settings, props.isDark, props.livePreview, paneLarge.value],
() => {
if (!view) return
try {
+75 -12
View File
@@ -89,7 +89,7 @@ import {
} from '@lucide/vue'
// 别名:`open` 与本组件的 `open` prop 同名,会和模板里的绑定撞名
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import type { EditorView } from '@codemirror/view'
import { EditorView } from '@codemirror/view'
import {
SearchQuery,
replaceAll as cmReplaceAll,
@@ -116,6 +116,13 @@ const props = defineProps<{
libraryPath: string
/** 取当前 CM6 视图(未打开文档时为 null) */
getView: () => EditorView | null
/**
* 当前活动文档的装载版本(`editorStore.docRevision`)。
*
* 切换标签 / 重载文档时它会自增,用来把「当前文件」范围的搜索**换成新标签**做:
* 命中下标是旧文档的字符偏移,不重算就会算错计数、甚至在更短的新文档里越界。
*/
docRevision: number
}>()
const emit = defineEmits<{
@@ -278,22 +285,53 @@ const scopeHint = computed(() => {
})
/**
* Ctrl+F 打开时用**当前选中的文本**填关键词(IDEA / VS Code 的行为)。
* 当前选区里可作关键词的文本(空串 = 没有可用的单行选中)。
*
* 只取「非空且不跨行」的选区:跨行片段当关键词没有意义 —— 当前文件里换行只是字面量,
* 磁盘 grep 又是逐行匹配的,拿一整段代码当搜索词只会得到 0 命中。此时沿用上一次的
* 关键词,由调用方在输入框里全选,方便直接覆盖输入。
* 磁盘 grep 又是逐行匹配的,拿一整段代码当搜索词只会得到 0 命中。
*/
function selectionKeyword(): string {
const view = props.getView()
if (!view) return ''
const range = view.state.selection.main
if (range.empty) return ''
const text = view.state.sliceDoc(range.from, range.to)
if (!text || text.includes('\n') || text.includes('\r')) return ''
return text
}
/**
* Ctrl+F 打开时用**当前选中的文本**填关键词(IDEA / VS Code 的行为)。
*
* 没有可用的选中时沿用上一次的关键词,由调用方在输入框里全选,方便直接覆盖输入。
*/
function prefillFromSelection(): void {
const view = props.getView()
if (!view) return
const range = view.state.selection.main
if (range.empty) return
const text = view.state.sliceDoc(range.from, range.to)
if (!text || text.includes('\n') || text.includes('\r')) return
const text = selectionKeyword()
if (!text) return
pattern.value = text
}
/**
* 搜索栏**已经打开**时再次 Ctrl+F。
*
* - 有新选中文本、且与输入框内容不同 → 换进输入框并全选(便于直接覆盖输入);
* - 没有可填充的新文本(未选中,或选中与当前关键词相同)→ 仅把焦点放回输入框。
*
* 两种情况下**都要聚焦**:Ctrl+F 的语义是「回到查找框」,不该因为选区恰好与关键词
* 相同就毫无反应。
*/
function refillFromSelection(): void {
const text = selectionKeyword()
if (text && text !== pattern.value) {
pattern.value = text
void nextTick(() => patternRef.value?.focusAndSelect())
return
}
void nextTick(() => patternRef.value?.focus())
}
defineExpose({ refillFromSelection })
// ===== 当前文件:CM6 search API =====
function buildQuery(): SearchQuery {
@@ -316,14 +354,19 @@ function clearFileHighlights(): void {
fileMatches = []
}
/** 选中第 index 处命中(0 起)并滚动到可见。 */
/**
* 选中第 index 处命中(0 起)并把该行**滚动到页面垂直居中**。
*
* 不用 `scrollIntoView: true`(CM6 默认的最小滚动):命中在视口下方时它只会把命中行
* 顶到**最后一行**,上下没有余量,看不出前后文。显式 `y: 'center'` 让命中居中。
*/
function selectMatch(index: number): void {
const view = props.getView()
const range = fileMatches[index]
if (!view || !range) return
view.dispatch({
selection: { anchor: range.from, head: range.to },
scrollIntoView: true
effects: EditorView.scrollIntoView(range.from, { y: 'center' })
})
}
@@ -590,6 +633,26 @@ watch(
if (isFile.value) runFileSearch()
}
)
/**
* 切换标签 / 重载文档:当前文件范围的搜索跟着换到新文档重算一次。
*
* `fileMatches` / `matchCount` 是**旧文档的字符偏移**,不重算的话计数会停留在上一篇的
* 数字,「上一个 / 下一个」还会拿旧偏移去 dispatch 选区 —— 新文档更短时越界报错,
* 表现就是「切到新标签后搜索失灵」。
*
* 用 `flush: 'post'`:编辑器里文档的整篇替换由 `EditorHost` 的 pre watcher 完成,
* post 回调保证跑在它**之后**,否则会拿还没换过的旧文档去搜。目录 / 笔记库范围不重算
* —— 那是磁盘扫描,一律由回车 / 点搜索按钮发起。
*/
watch(
() => props.docRevision,
() => {
if (!props.open || !isFile.value) return
runFileSearch()
},
{ flush: 'post' }
)
</script>
<template>
@@ -0,0 +1,420 @@
<script setup lang="ts">
/**
* 编辑器窗口内的设置对话框。
*
* # 为什么把主界面的设置搬到这里
*
* 「库」与「编辑器」两页的设置本来只在主模块页可达 —— 用户把编辑器窗口拖到副屏、
* 或在专注写作时,改个字号 / 换库都得先切回主界面。这里把这些**高频设置**就地暴露
* 出来(导入导出 / WebDAV 这类重面板不搬)。
*
* # 改完即全局生效
*
* 读写都走当前窗口的 `editorStore`:`patchSettings` 落盘后 Rust 广播 `editor-settings`
* 事件,主窗口与其它编辑器窗口据此重新读取设置;库根同理(`editor-library-changed`)。
* 因此这里没有「保存」按钮,也不需要与主窗口做额外同步。
*/
import { ref } from 'vue'
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import { openPath } from '@tauri-apps/plugin-opener'
import {
Copy,
FolderOpen,
Library,
NotebookPen,
Palette,
RefreshCw,
Settings,
Tags
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import {
Dialog,
DialogContent,
DialogHeader,
DialogTitle
} from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Switch } from '@/components/ui/switch'
import { ScrollArea } from '@/components/ui/scroll-area'
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue
} from '@/components/ui/select'
import { ConfirmDialog, SegmentedNav, SettingGroup, SettingRow } from '@/components/common'
import { useEditorStore } from '@/stores/editorStore'
import { EDITOR_THEME_OPTIONS } from '../editor/themes'
import type { EditorSettings } from '@/types/editor'
defineProps<{ open: boolean }>()
const emit = defineEmits<{ 'update:open': [value: boolean] }>()
const store = useEditorStore()
/** 当前分区(默认「编辑器设置」—— 在编辑器窗口里调整外观 / 行为是最常见的诉求) */
const section = ref<'library' | 'editor'>('editor')
const sections = [
{ value: 'library', label: '库设置', icon: Library },
{ value: 'editor', label: '编辑器设置', icon: Palette }
]
// ===== 设置写入(即时生效) =====
function commit(patch: Partial<EditorSettings>): void {
void store.patchSettings(patch)
}
function onNumber(
patchKey: 'fontSize' | 'lineHeight' | 'tabSize' | 'autosaveMs' | 'maxFileSizeMb',
event: Event
): void {
const value = Number((event.target as HTMLInputElement).value)
if (!Number.isFinite(value)) return
commit({ [patchKey]: value } as Partial<EditorSettings>)
}
// ===== 库根 =====
const resetRootOpen = ref(false)
async function pickLibraryRoot(): Promise<void> {
try {
const selected = await openDialog({ directory: true, multiple: false, title: '选择笔记库目录' })
if (typeof selected !== 'string') return
await store.setLibraryRoot(selected)
toast.success('已切换笔记库')
} catch (e) {
toast.error(`切换失败:${String(e)}`)
}
}
async function resetLibraryRoot(): Promise<void> {
try {
await store.setLibraryRoot(null)
toast.success('已恢复默认库目录')
} catch (e) {
toast.error(`恢复失败:${String(e)}`)
} finally {
resetRootOpen.value = false
}
}
async function revealRoot(): Promise<void> {
if (!store.libraryRoot) return
try {
await openPath(store.libraryRoot)
} catch (e) {
toast.error(`打开目录失败:${String(e)}`)
}
}
async function copyRoot(): Promise<void> {
if (!store.libraryRoot) return
try {
await navigator.clipboard.writeText(store.libraryRoot)
toast.success('库路径已复制')
} catch {
toast.error('复制失败')
}
}
// ===== 索引 =====
const rebuilding = ref(false)
async function rebuildIndex(): Promise<void> {
rebuilding.value = true
try {
await store.rebuildIndex()
await store.refreshLibrary()
toast.success('索引已重建')
} catch (e) {
toast.error(`重建索引失败:${String(e)}`)
} finally {
rebuilding.value = false
}
}
</script>
<template>
<Dialog :open="open" @update:open="emit('update:open', $event)">
<DialogContent class="max-h-[85vh] sm:max-w-2xl">
<DialogHeader class="shrink-0">
<DialogTitle class="flex items-center gap-2 text-base">
<Settings class="size-4 text-primary" />
设置
</DialogTitle>
</DialogHeader>
<SegmentedNav v-model="section" :items="sections" block class="shrink-0" />
<ScrollArea class="max-h-[60vh] pr-3">
<!-- ===== 库设置 ===== -->
<div v-if="section === 'library'" class="flex flex-col gap-4 pb-1">
<SettingGroup
title="笔记库"
description="笔记以 Markdown 文件形式保存在该目录;切换库只改变指向,原目录内容不会被移动"
>
<SettingRow label="库目录" :description="store.libraryRoot || '—'">
<div class="flex flex-wrap items-center gap-2">
<Button variant="outline" size="sm" :disabled="!store.libraryRoot" @click="copyRoot">
<Copy class="size-3.5" />复制
</Button>
<Button variant="outline" size="sm" :disabled="!store.libraryRoot" @click="revealRoot">
<FolderOpen class="size-3.5" />浏览
</Button>
<Button variant="outline" size="sm" @click="pickLibraryRoot">
<NotebookPen class="size-3.5" />切换…
</Button>
<Button
v-if="store.info?.isCustom"
variant="ghost"
size="sm"
class="text-muted-foreground"
@click="resetRootOpen = true"
>
恢复默认
</Button>
</div>
</SettingRow>
<SettingRow label="重新扫描" description="在应用外新增或修改文件后,手动刷新库内容">
<Button variant="outline" size="sm" @click="store.refreshLibrary()">
<RefreshCw class="size-3.5" />刷新
</Button>
</SettingRow>
</SettingGroup>
<SettingGroup
title="索引与检索"
description="全文检索与标签依赖库内的 SQLite 索引;删掉也能从 Markdown 文件完整重建"
>
<SettingRow label="索引状态" :description="store.indexStats?.dbPath || '尚未建立索引'">
<div class="flex items-center gap-3 text-[13px] text-fg-secondary">
<span class="tabular-nums">笔记 {{ store.indexStats?.noteCount ?? 0 }}</span>
<span class="tabular-nums">文件 {{ store.indexStats?.fileCount ?? 0 }}</span>
<span class="flex items-center gap-1 tabular-nums">
<Tags class="size-3.5" />{{ store.indexStats?.tagCount ?? 0 }}
</span>
</div>
</SettingRow>
<SettingRow
label="重建索引"
description="按文件重新解析标题、标签与双链(库很大时需要一点时间)"
>
<Button
variant="outline"
size="sm"
:disabled="rebuilding || store.indexing"
@click="rebuildIndex"
>
<RefreshCw class="size-3.5" :class="rebuilding && 'animate-spin'" />重建
</Button>
</SettingRow>
<SettingRow
label="单文件大小上限"
description="超过该大小的文件会关闭所见即所得 / 折叠 / 补全,单位 MB"
control-width="wide"
>
<Input
type="number"
min="1"
max="100"
:model-value="store.settings.maxFileSizeMb"
@change="onNumber('maxFileSizeMb', $event)"
/>
</SettingRow>
</SettingGroup>
</div>
<!-- ===== 编辑器设置 ===== -->
<div v-else class="flex flex-col gap-4 pb-1">
<SettingGroup title="编辑器外观">
<SettingRow
label="配色方案"
description="「跟随主应用主题」关闭时,窗口按本方案取色与深浅"
control-width="wide"
>
<Select
:model-value="String(store.settings.editorTheme)"
@update:model-value="v => commit({ editorTheme: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem v-for="opt in EDITOR_THEME_OPTIONS" :key="opt.value" :value="opt.value">
{{ opt.label }}
</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow label="跟随主应用主题" description="打开时编辑器窗口整体跟随主应用主题;关闭时由上方「配色方案」决定,窗口内外深浅一致">
<Switch
:model-value="store.settings.followAppTheme"
@update:model-value="v => commit({ followAppTheme: v === true })"
/>
</SettingRow>
<SettingRow label="字体族" description="留空使用内置等宽字体栈" control-width="wide">
<Input
:model-value="store.settings.fontFamily"
placeholder="Cascadia Code, Consolas, …"
@change="(e: Event) => commit({ fontFamily: (e.target as HTMLInputElement).value })"
/>
</SettingRow>
<SettingRow label="字号" description="单位 px" control-width="wide">
<Input
type="number"
min="10"
max="32"
:model-value="store.settings.fontSize"
@change="onNumber('fontSize', $event)"
/>
</SettingRow>
<SettingRow label="行高" description="倍数,建议 1.5 ~ 2.0" control-width="wide">
<Input
type="number"
step="0.1"
min="1"
max="3"
:model-value="store.settings.lineHeight"
@change="onNumber('lineHeight', $event)"
/>
</SettingRow>
<SettingRow label="字体连字" description="启用 ligatures(如 => 显示为箭头)">
<Switch
:model-value="store.settings.ligatures"
@update:model-value="v => commit({ ligatures: v === true })"
/>
</SettingRow>
<SettingRow label="显示行号">
<Switch
:model-value="store.settings.showLineNumbers"
@update:model-value="v => commit({ showLineNumbers: v === true })"
/>
</SettingRow>
<SettingRow
label="显示大纲"
description="在编辑区右侧抽屉显示标题树(Ctrl+Shift+O 可临时切换)"
>
<Switch
:model-value="store.settings.showOutline"
@update:model-value="v => commit({ showOutline: v === true })"
/>
</SettingRow>
</SettingGroup>
<SettingGroup title="编辑器行为">
<SettingRow
label="所见即所得"
description="Live Preview:语法符号在非光标行隐藏、光标行显形;关闭后为纯源码 + 高亮"
>
<Switch
:model-value="store.settings.livePreview"
@update:model-value="v => commit({ livePreview: v === true })"
/>
</SettingRow>
<SettingRow label="默认视图" description="新开编辑器窗口时的初始视图" control-width="wide">
<Select
:model-value="String(store.settings.defaultView)"
@update:model-value="v => commit({ defaultView: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="wysiwyg">所见即所得</SelectItem>
<SelectItem value="source">源码</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow
label="自动保存"
description="停止输入后延迟保存,单位毫秒;0 = 关闭(仅 Ctrl+S)"
control-width="wide"
>
<Input
type="number"
min="0"
max="10000"
step="100"
:model-value="store.settings.autosaveMs"
@change="onNumber('autosaveMs', $event)"
/>
</SettingRow>
<SettingRow label="Tab 宽度" description="按空格数计" control-width="wide">
<Input
type="number"
min="1"
max="8"
:model-value="store.settings.tabSize"
@change="onNumber('tabSize', $event)"
/>
</SettingRow>
<SettingRow label="自动补全" description="括号自动闭合与代码补全(大文件会临时关闭)">
<Switch
:model-value="store.settings.autocomplete"
@update:model-value="v => commit({ autocomplete: v === true })"
/>
</SettingRow>
<SettingRow
label="识别 [[双链]]"
description="按 Obsidian 语义解析双链并写入索引(反链面板留待后续)"
>
<Switch
:model-value="store.settings.wikilink"
@update:model-value="v => commit({ wikilink: v === true })"
/>
</SettingRow>
<SettingRow
label="复用文档窗口"
description="同一篇笔记重复打开时聚焦已有窗口,而不是开出第二个"
>
<Switch
:model-value="store.settings.reuseWindow"
@update:model-value="v => commit({ reuseWindow: v === true })"
/>
</SettingRow>
<SettingRow
label="导出时高亮代码"
description="关闭后导出的 HTML 里代码块是纯黑白,适合黑白打印机"
>
<Switch
:model-value="store.settings.exportHighlight"
@update:model-value="v => commit({ exportHighlight: v === true })"
/>
</SettingRow>
<SettingRow label="新建时选模板" description="关闭后用上次选中的模板直接新建">
<Switch
:model-value="store.settings.showTemplatePicker"
@update:model-value="v => commit({ showTemplatePicker: v === true })"
/>
</SettingRow>
</SettingGroup>
</div>
</ScrollArea>
<ConfirmDialog
v-model:open="resetRootOpen"
title="恢复默认库目录"
description="笔记不会丢失:仅把库根指回应用数据目录下的默认位置,原目录内容保持不动。"
confirm-text="恢复默认"
@confirm="resetLibraryRoot"
/>
</DialogContent>
</Dialog>
</template>
+585 -23
View File
@@ -5,41 +5,603 @@
* 一个编辑器窗口内可同时打开多篇文档,每个标签**独立**保存内容、编码 / 换行、
* 视图模式与未保存状态。标签的「脏」指示点用 store 的 `tabViews`:活动标签取
* 实时值(正在敲字),后台标签取切换时收回的快照。
*
* # Markdown 标签多一个「预览」按钮
*
* 预览状态同样**按标签独立**(`previewIds` 由父组件 `EditorWindow` 持有并渲染面板):
* 一个标签在预览渲染结果时,切到别的标签仍是正常的编辑器 —— 这与「视图模式按标签存」
* 的模型一致(见 `DocumentTab.viewMode`)。按钮只对 `tab.markdown` 出现:非 Markdown
* 文档(代码 / 配置 / 纯文本)没有可渲染的语义。
*
* # 右键菜单
*
* - **关闭类**(当前 / 其他 / 左 / 右 / 全部)涉及脏数据确认,统一 `emit` 给
* `EditorWindow` 走既有确认流程;「关闭未修改」无脏数据风险,就地调用 store。
* - **位置 / 窗口类**(所在文件夹 / 资源管理器 / 新窗口 / 移动新窗口)只读 store 与系统;
* 其中「移动到新窗口」先落盘再开新窗口、最后关掉本标签。
* - **视图类**(并排分屏 / 固定)分别 `emit('split')` 与写 store。
* - **文件类**(重命名 / 复制名字 / 路径 / 相对路径)。
*
* # 拖拽重排与溢出下拉
*
* 标签支持 HTML5 拖拽重排(`store.moveTab`)。标签溢出横向滚动时,右侧出现下拉按钮,
* 汇总列出所有标签以便快速跳转 —— 否则藏在滚动区外的标签很难被发现。
*/
import { FileCode2, FileText, X } from '@lucide/vue'
import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import {
AppWindow,
ChevronDown,
ClipboardCopy,
Columns2,
Copy,
ExternalLink,
Eye,
FileCode2,
FileText,
FileX,
FolderOpen,
Pencil,
Pin,
PinOff,
X
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog'
import { useEditorStore } from '@/stores/editorStore'
import { openEditorWindow } from '../openWindow'
const emit = defineEmits<{ close: [id: string] }>()
const props = defineProps<{
/** 正处于预览状态的标签 id(每个标签独立) */
previewIds: string[]
}>()
const emit = defineEmits<{
close: [id: string]
/** 切换某个标签的预览状态 */
'toggle-preview': [id: string]
'close-others': [id: string]
'close-left': [id: string]
'close-right': [id: string]
'close-all': []
/** 把某个标签放到副面板与当前文档并排 */
split: [id: string]
}>()
const store = useEditorStore()
const isPreviewing = (id: string) => props.previewIds.includes(id)
// ===== 标签的目标解析 =====
type Tab = (typeof store.tabs)[number]
function tabOf(id: string): Tab | undefined {
return store.tabs.find(t => t.id === id)
}
/** 标签对应文件的**真实文件名**(含扩展名;重命名对话框的初值)。 */
function tabFileName(id: string): string {
const tab = tabOf(id)
if (!tab) return ''
const source = tab.kind === 'note' ? tab.relPath : tab.path
return source.split(/[\\/]/).filter(Boolean).pop() ?? tab.name
}
/** 标签对应文件的**绝对路径**(复制 / 定位 / 打开所在文件夹用)。 */
function tabAbsPath(id: string): string {
const tab = tabOf(id)
if (!tab) return ''
if (tab.kind === 'note') return store.noteAbsPath(tab.relPath)
// 活动文件的真值在扁平 state 上,后台标签取收回的快照
return id === store.activeTabId ? (store.fileDoc?.path ?? tab.path) : tab.path
}
/** 标签对应文件的**相对路径**(仅库内笔记有意义)。 */
function tabRelPath(id: string): string {
const tab = tabOf(id)
return tab && tab.kind === 'note' ? tab.relPath : ''
}
// ===== 拖拽重排(Pointer Events)=====
//
// **为什么不用 HTML5 拖放**:编辑器窗口为了接收 OS 文件拖入而设了 `dragDropEnabled: true`
// (见 openWindow.ts),WebView2 的原生 OLE drop target 会拦截窗口内所有 HTML5 DnD ——
// `dragover` 的 `preventDefault()` 不生效,拖动时显示「禁止」光标。Pointer Events 不走
// 那条管线,与 Tauri 原生拖放零冲突(同侧栏宽度拖拽、结果面板高度拖拽的范式)。
const dragId = ref('')
const dragOverId = ref('')
/** 指针采集元素(releasePointerCapture 用) */
let dragEl: HTMLElement | null = null
/** 本次拖拽是否真的发生了重排:抑制紧随其后的 click,避免误激活 */
let reordered = false
function onTabPointerDown(id: string, event: PointerEvent): void {
if (event.button !== 0) return
// 点在预览 / 关闭按钮上时不启动拖拽(否则会与按钮的 click 抢指针)
if ((event.target as HTMLElement).closest('button')) return
dragEl = event.currentTarget as HTMLElement
dragId.value = id
dragOverId.value = ''
reordered = false
dragEl.setPointerCapture(event.pointerId)
window.addEventListener('pointermove', onTabPointerMove)
window.addEventListener('pointerup', onTabPointerUp)
window.addEventListener('pointercancel', onTabPointerUp)
}
function onTabPointerMove(event: PointerEvent): void {
if (!dragId.value) return
const over = (document.elementFromPoint(event.clientX, event.clientY) as HTMLElement | null)
?.closest<HTMLElement>('[data-tab-id]')
const overId = over?.dataset.tabId ?? ''
dragOverId.value = overId && overId !== dragId.value ? overId : ''
}
function onTabPointerUp(event: PointerEvent): void {
window.removeEventListener('pointermove', onTabPointerMove)
window.removeEventListener('pointerup', onTabPointerUp)
window.removeEventListener('pointercancel', onTabPointerUp)
try {
dragEl?.releasePointerCapture(event.pointerId)
} catch {
/* 指针已释放,忽略 */
}
dragEl = null
const from = dragId.value
const over = dragOverId.value
dragId.value = ''
dragOverId.value = ''
if (!from || !over || from === over) return
const to = store.tabs.findIndex(t => t.id === over)
if (to < 0) return
store.moveTab(from, to)
reordered = true
// click 在 pointerup 之后同批次派发;等它走完再复位
window.setTimeout(() => {
reordered = false
}, 0)
}
/** 标签点击:拖拽刚结束的那一下不再激活(否则拖完会顺带跳一下)。 */
function onTabClick(id: string): void {
if (reordered) return
store.activateTab(id)
}
// ===== 溢出下拉 =====
const stripRef = ref<HTMLElement | null>(null)
const overflowing = ref(false)
const overflowOpen = ref(false)
let resizeObserver: ResizeObserver | null = null
function updateOverflow(): void {
const el = stripRef.value
overflowing.value = !!el && el.scrollWidth > el.clientWidth + 1
if (!overflowing.value) overflowOpen.value = false
}
onMounted(() => {
if (stripRef.value) {
resizeObserver = new ResizeObserver(updateOverflow)
resizeObserver.observe(stripRef.value)
}
window.addEventListener('resize', updateOverflow)
void nextTick(updateOverflow)
})
onBeforeUnmount(() => {
resizeObserver?.disconnect()
resizeObserver = null
window.removeEventListener('resize', updateOverflow)
window.removeEventListener('pointermove', onTabPointerMove)
window.removeEventListener('pointerup', onTabPointerUp)
window.removeEventListener('pointercancel', onTabPointerUp)
})
// 标签数量 / 名称变化都可能改变宽度
watch(
() => store.tabViews.map(t => `${t.id}:${t.name}:${t.dirty}:${t.pinned}`).join('|'),
() => void nextTick(updateOverflow)
)
/** 从下拉列表切换标签:激活并把该标签滚进可视区。 */
function pickTab(id: string): void {
overflowOpen.value = false
store.activateTab(id)
void nextTick(() => {
stripRef.value?.querySelector(`[data-tab-id="${id}"]`)?.scrollIntoView({ inline: 'nearest', block: 'nearest' })
})
}
// ===== 右键菜单 =====
const menuOpen = ref(false)
const menuX = ref(0)
const menuY = ref(0)
/** 右键作用的标签 id(关闭菜单后仍保留,供重命名对话框使用) */
const menuTabId = ref('')
const MENU_WIDTH = 216
/** 菜单项行数(用于贴边翻转时预估高度:16 项 + 3 条分隔线) */
const MENU_HEIGHT = 16 * 28 + 3 * 9 + 16
const menuIndex = computed(() => store.tabs.findIndex(t => t.id === menuTabId.value))
const menuTab = computed(() => tabOf(menuTabId.value))
const hasLeft = computed(() => menuIndex.value > 0)
const hasRight = computed(() => menuIndex.value >= 0 && menuIndex.value < store.tabs.length - 1)
const hasOthers = computed(() => store.tabs.length > 1)
const hasUnmodified = computed(() =>
store.tabs.some(t => !t.pinned && !(t.id === store.activeTabId ? store.dirty : t.dirty))
)
function openMenu(event: MouseEvent, id: string): void {
menuTabId.value = id
menuX.value = Math.max(8, Math.min(event.clientX, window.innerWidth - MENU_WIDTH - 8))
menuY.value = Math.max(8, Math.min(event.clientY, window.innerHeight - MENU_HEIGHT - 8))
menuOpen.value = true
}
function closeMenu(): void {
menuOpen.value = false
}
/** 关闭菜单后执行(菜单是纯操作入口,不保留焦点)。 */
function run(action: () => void): void {
closeMenu()
action()
}
function openContainingFolder(): void {
const path = tabAbsPath(menuTabId.value)
const dir = path.slice(0, Math.max(path.lastIndexOf('\\'), path.lastIndexOf('/')))
if (!dir) {
toast.error('无法确定所在文件夹')
return
}
void store
.openFolder(dir)
.then(() => store.setSideView('directory'))
.catch(e => toast.error(`打开文件夹失败:${String(e)}`))
}
function revealInExplorer(): void {
const path = tabAbsPath(menuTabId.value)
if (path) store.revealPath(path)
}
async function openInNewWindow(): Promise<void> {
const tab = tabOf(menuTabId.value)
if (!tab) return
try {
if (tab.kind === 'note') await openEditorWindow({ relPath: tab.relPath, dedupe: false })
else await openEditorWindow({ path: tabAbsPath(tab.id), dedupe: false })
} catch (e) {
toast.error(`在新窗口打开失败:${String(e)}`)
}
}
/** 移动到新窗口:先落盘(保住未保存改动),再开新窗口,最后关掉本标签。 */
async function moveToNewWindow(): Promise<void> {
const id = menuTabId.value
const tab = tabOf(id)
if (!tab) return
try {
await store.saveTab(id)
} catch (e) {
toast.error(`保存失败,未移动:${String(e)}`)
return
}
try {
if (tab.kind === 'note') await openEditorWindow({ relPath: tab.relPath, dedupe: false })
else await openEditorWindow({ path: tabAbsPath(id), dedupe: false })
} catch (e) {
toast.error(`打开新窗口失败:${String(e)}`)
return
}
emit('close', id)
}
function togglePin(): void {
const tab = tabOf(menuTabId.value)
if (tab) store.setTabPinned(tab.id, !tab.pinned)
}
async function copyName(): Promise<void> {
const name = tabFileName(menuTabId.value)
if (!name) return
try {
await navigator.clipboard.writeText(name)
toast.success('已复制文件名')
} catch {
toast.error('复制失败')
}
}
async function copyPath(): Promise<void> {
const path = tabAbsPath(menuTabId.value)
if (!path) return
try {
await navigator.clipboard.writeText(path)
toast.success('已复制文件路径')
} catch {
toast.error('复制失败')
}
}
async function copyRelPath(): Promise<void> {
const rel = tabRelPath(menuTabId.value)
if (!rel) return
try {
await navigator.clipboard.writeText(rel)
toast.success('已复制相对路径')
} catch {
toast.error('复制失败')
}
}
// ===== 重命名 =====
const renameOpen = ref(false)
const renameValue = ref('')
const renameBusy = ref(false)
function startRename(): void {
renameValue.value = tabFileName(menuTabId.value)
renameOpen.value = true
}
async function confirmRename(): Promise<void> {
const name = renameValue.value.trim()
if (!name) {
toast.error('名称不能为空')
return
}
renameBusy.value = true
try {
await store.renameTab(menuTabId.value, name)
renameOpen.value = false
} catch (e) {
toast.error(String(e))
} finally {
renameBusy.value = false
}
}
</script>
<template>
<div class="flex h-8 shrink-0 items-stretch gap-0.5 overflow-x-auto border-b border-border px-1">
<div
v-for="tab in store.tabViews"
:key="tab.id"
class="group flex max-w-52 min-w-0 cursor-pointer items-center gap-1.5 rounded-t-sm border-b-2 px-2 text-xs transition-colors duration-150"
:class="
tab.id === store.activeTabId
? 'border-primary bg-row-selected text-foreground'
: 'border-transparent text-fg-secondary hover:bg-row-hover hover:text-foreground'
"
:title="tab.name"
@click="store.activateTab(tab.id)"
<div class="relative flex h-8 shrink-0 items-stretch border-b border-border">
<div ref="stripRef" class="flex min-w-0 flex-1 items-stretch gap-0.5 overflow-x-auto px-1">
<div
v-for="tab in store.tabViews"
:key="tab.id"
:data-tab-id="tab.id"
class="group flex max-w-52 min-w-0 cursor-pointer items-center gap-1.5 rounded-t-sm border-b-2 px-2 text-xs transition-colors duration-150"
:class="[
tab.id === store.activeTabId
? 'border-primary bg-row-selected text-foreground'
: 'border-transparent text-fg-secondary hover:bg-row-hover hover:text-foreground',
dragId === tab.id && 'opacity-40',
dragOverId === tab.id && 'ring-1 ring-primary ring-inset'
]"
:title="tab.name"
@pointerdown="onTabPointerDown(tab.id, $event)"
@click="onTabClick(tab.id)"
@contextmenu.prevent="openMenu($event, tab.id)"
>
<Pin v-if="tab.pinned" class="size-3 shrink-0 text-primary" title="已固定" />
<FileText v-if="tab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ tab.name }}</span>
<span v-if="tab.dirty" class="shrink-0 font-medium text-primary" title="有未保存的改动">*</span>
<!-- 预览:仅 Markdown 标签出现;**常驻可见**(不做 hover 才显形,否则用户不知道有这个能力) -->
<button
v-if="tab.markdown"
type="button"
class="shrink-0 rounded-sm p-0.5 transition-colors hover:bg-active"
:class="isPreviewing(tab.id) ? 'bg-active text-primary' : 'text-muted-foreground hover:text-foreground'"
:title="isPreviewing(tab.id) ? '退出预览,回到编辑器' : '预览渲染后的 Markdown'"
@click.stop="emit('toggle-preview', tab.id)"
>
<Eye class="size-3" />
</button>
<button
type="button"
class="shrink-0 rounded-sm p-0.5 opacity-0 transition-opacity hover:bg-active group-hover:opacity-100"
title="关闭标签(Ctrl+W)"
@click.stop="emit('close', tab.id)"
>
<X class="size-3" />
</button>
</div>
</div>
<!-- 溢出下拉:标签太多时汇总列出,避免藏在滚动区外 -->
<button
v-if="overflowing"
type="button"
class="flex shrink-0 items-center px-1 text-muted-foreground transition-colors hover:bg-row-hover hover:text-foreground"
title="全部标签"
@click="overflowOpen = !overflowOpen"
>
<ChevronDown class="size-3.5" />
</button>
<template v-if="overflowOpen">
<div class="fixed inset-0 z-40" @click="overflowOpen = false" />
<div
class="absolute top-full right-0 z-50 max-h-72 w-64 overflow-y-auto rounded-md border border-border bg-card py-1 text-xs shadow-md"
>
<button
v-for="tab in store.tabViews"
:key="tab.id"
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
:class="tab.id === store.activeTabId ? 'text-foreground' : 'text-fg-secondary'"
@click="pickTab(tab.id)"
>
<Pin v-if="tab.pinned" class="size-3 shrink-0 text-primary" />
<FileText v-if="tab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ tab.name }}</span>
<span v-if="tab.dirty" class="shrink-0 font-medium text-primary">*</span>
</button>
</div>
</template>
</div>
<!-- 右键菜单 -->
<template v-if="menuOpen">
<div class="fixed inset-0 z-40" @click="closeMenu" @contextmenu.prevent="closeMenu" />
<div
class="fixed z-50 min-w-[216px] overflow-hidden rounded-md border border-border bg-card py-1 text-xs text-foreground shadow-md"
:style="{ left: `${menuX}px`, top: `${menuY}px` }"
>
<FileText v-if="tab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ tab.name }}</span>
<span v-if="tab.dirty" class="shrink-0 font-medium text-primary" title="有未保存的改动">*</span>
<button
type="button"
class="shrink-0 rounded-sm p-0.5 opacity-0 transition-opacity hover:bg-active group-hover:opacity-100"
title="关闭标签(Ctrl+W)"
@click.stop="emit('close', tab.id)"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(() => emit('close', menuTabId))"
>
<X class="size-3" />
<X class="size-3.5 opacity-70" />关闭当前文件
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="!hasOthers"
@click="run(() => emit('close-others', menuTabId))"
>
<X class="size-3.5 opacity-70" />关闭其他文件
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="!hasLeft"
@click="run(() => emit('close-left', menuTabId))"
>
<X class="size-3.5 opacity-70" />关闭左边所有
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="!hasRight"
@click="run(() => emit('close-right', menuTabId))"
>
<X class="size-3.5 opacity-70" />关闭右边所有
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(() => emit('close-all'))"
>
<X class="size-3.5 opacity-70" />关闭所有文件
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="!hasUnmodified"
@click="run(() => store.closeUnmodifiedTabs())"
>
<FileX class="size-3.5 opacity-70" />关闭未修改标签
</button>
<div class="my-1 h-px bg-divider" />
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(openContainingFolder)"
>
<FolderOpen class="size-3.5 opacity-70" />打开所在文件夹
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(revealInExplorer)"
>
<ExternalLink class="size-3.5 opacity-70" />在资源管理器打开
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(openInNewWindow)"
>
<AppWindow class="size-3.5 opacity-70" />在新窗口打开
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(moveToNewWindow)"
>
<AppWindow class="size-3.5 opacity-70" />移动到新窗口
</button>
<div class="my-1 h-px bg-divider" />
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="menuTabId === store.activeTabId"
@click="run(() => emit('split', menuTabId))"
>
<Columns2 class="size-3.5 opacity-70" />并排分屏
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(togglePin)"
>
<PinOff v-if="menuTab?.pinned" class="size-3.5 opacity-70" />
<Pin v-else class="size-3.5 opacity-70" />
{{ menuTab?.pinned ? '取消固定' : '固定标签' }}
</button>
<div class="my-1 h-px bg-divider" />
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(startRename)"
>
<Pencil class="size-3.5 opacity-70" />重命名文件
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(copyName)"
>
<Copy class="size-3.5 opacity-70" />复制文件名
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(copyPath)"
>
<ClipboardCopy class="size-3.5 opacity-70" />复制文件路径
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="menuTab?.kind !== 'note'"
@click="run(copyRelPath)"
>
<Copy class="size-3.5 opacity-70" />复制相对路径
</button>
</div>
</div>
</template>
<!-- 重命名文件 -->
<Dialog :open="renameOpen" @update:open="renameOpen = $event">
<DialogContent class="sm:max-w-sm">
<DialogHeader>
<DialogTitle>重命名文件</DialogTitle>
</DialogHeader>
<Input v-model="renameValue" placeholder="文件名(含扩展名)" @keydown.enter="confirmRename" />
<DialogFooter>
<Button variant="outline" :disabled="renameBusy" @click="renameOpen = false">取消</Button>
<Button :disabled="renameBusy" @click="confirmRename">确定</Button>
</DialogFooter>
</DialogContent>
</Dialog>
</template>
+30 -10
View File
@@ -88,31 +88,44 @@ function isActive(view: SideView): boolean {
}
/**
* 导出当前笔记为 HTML。
* 导出当前 Markdown 文档为 HTML(笔记与库外 `.md` 文件都支持)。
*
* 两条落盘路径,因为两者的「真相位置」不同:
* - **笔记**:走库语义 `exportNote`(库内相对路径,磁盘上的那一份为准);
* - **库外文件**:目标路径来自系统对话框,先 `authorizeFile` 再 `writeFile`
* (文件的写入是严格的:没登记过的路径一律拒绝)。
*
* 渲染链路(markdown-it + DOMPurify + highlight.js)**按需 import**:
* 它约 1MB,而导出是低频动作 —— 静态引入会让「打开编辑器窗口」这个最常见的动作
* 也背上这份体积。
*/
async function exportHtml(): Promise<void> {
if (!store.currentRelPath) return
if (!store.hasDocument) return
const isNote = store.kind === 'note'
const relPath = store.currentRelPath
if (isNote && !relPath) return
exporting.value = true
try {
const doc = await editorClient.readNote(store.currentRelPath)
const doc = isNote
? await editorClient.readNote(relPath)
: { name: store.fileDoc?.name ?? 'document.md', content: store.content }
const base = doc.name.replace(/\.(md|markdown|mdx)$/i, '')
const { renderNoteHtml } = await import('../editor/markdownExport')
const html = renderNoteHtml({
title: store.currentName || doc.name.replace(/\.md$/i, ''),
title: (isNote && store.currentName) || base,
fileName: doc.name,
markdown: doc.content,
highlight: store.settings.exportHighlight
})
const dest = await open({
title: '导出为 HTML',
defaultPath: `${doc.name.replace(/\.md$/i, '')}.html`,
defaultPath: `${base}.html`,
filters: [{ name: 'HTML 文件', extensions: ['html'] }]
})
if (typeof dest !== 'string') return
const saved = await editorClient.exportNote(store.currentRelPath, html, dest)
const saved = isNote
? await editorClient.exportNote(relPath, html, dest)
: await writeExternalHtml(dest, html)
toast.success(`已导出:${saved}`)
} catch (e) {
toast.error(`导出失败:${String(e)}`)
@@ -120,6 +133,13 @@ async function exportHtml(): Promise<void> {
exporting.value = false
}
}
/** 库外文件的导出落盘:先登记授权(路径来自系统对话框),再按 UTF-8 写入。 */
async function writeExternalHtml(dest: string, html: string): Promise<string> {
await editorClient.authorizeFile(dest)
await editorClient.writeFile(dest, html, 'utf-8', 'lf')
return dest
}
</script>
<template>
@@ -202,8 +222,9 @@ async function exportHtml(): Promise<void> {
<Loader2 v-if="saving" class="size-3.5 animate-spin" />
<Save v-else class="size-3.5" />
</Button>
<!-- 视图切换 / 导出 / 格式化:只对 Markdown 有意义(笔记与库外 .md 文件同样开放) -->
<Button
v-if="store.kind === 'note'"
v-if="store.isMarkdown"
variant="ghost"
size="icon-sm"
:title="viewMode === 'wysiwyg' ? '切到源码视图 (Ctrl+Shift+M)' : '切到所见即所得 (Ctrl+Shift+M)'"
@@ -212,7 +233,7 @@ async function exportHtml(): Promise<void> {
<Eye class="size-3.5" />
</Button>
<Button
v-if="store.kind === 'note' && store.currentRelPath"
v-if="store.isMarkdown"
variant="ghost"
size="icon-sm"
:disabled="exporting"
@@ -223,8 +244,7 @@ async function exportHtml(): Promise<void> {
<FileDown v-else class="size-3.5" />
</Button>
<!-- Markdown 格式化(仅笔记) -->
<template v-if="store.kind === 'note'">
<template v-if="store.isMarkdown">
<div class="mx-1 h-4 w-px shrink-0 bg-divider" />
<Button variant="ghost" size="icon-sm" title="加粗 (Ctrl+B)" @click="run(editorCommands.bold)">
<Bold class="size-3.5" />
+1 -1
View File
@@ -132,7 +132,7 @@ watch(keyword, () => {
>
<div
ref="panelRef"
class="flex max-h-[60vh] w-[min(560px,92vw)] flex-col overflow-hidden rounded-lg border border-border bg-popup shadow-lg"
class="flex max-h-[60vh] w-[min(560px,92vw)] flex-col overflow-hidden rounded-lg border border-border bg-popover text-popover-foreground shadow-lg"
@keydown="onKeydown"
>
<div class="relative shrink-0 border-b border-border p-2">
+25 -2
View File
@@ -22,6 +22,25 @@ const store = useEditorStore()
const files = computed(() => store.recentFiles)
const folders = computed(() => store.recentFolders)
/** 取所在目录(同时兼容 `\` 与 `/`)。 */
function parentDir(fullPath: string): string {
const index = Math.max(fullPath.lastIndexOf('\\'), fullPath.lastIndexOf('/'))
return index > 0 ? fullPath.slice(0, index) : ''
}
/**
* 路径尾部摘要:只保留末尾若干字符并前置省略号(例:`...ways\Downloads`)。
*
* 做「一眼看出在哪儿」的提示,完整路径仍由行的 `title` 提供。短路径整段显示,
* 长路径保留末尾 14 个字符 —— 前面的盘符与中间层级对辨认位置帮助不大,省略它们
* 反而让列表更整齐。目录项与文件项都取**所在目录**,名字里已经有的末级不再重复。
*/
function pathTail(fullPath: string): string {
const dir = parentDir(fullPath).replace(/\//g, '\\')
if (!dir) return ''
return dir.length <= 18 ? dir : `...${dir.slice(-14)}`
}
async function openFile(entry: RecentEntry): Promise<void> {
try {
await store.openDoc(entry.path)
@@ -83,7 +102,9 @@ async function openFolder(entry: RecentEntry): Promise<void> {
@click="openFile(entry)"
>
<FileText class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ entry.name }}</span>
<span class="truncate">
{{ entry.name }}<span v-if="pathTail(entry.path)" class="text-muted-foreground">({{ pathTail(entry.path) }})</span>
</span>
<span v-if="!entry.exists" class="shrink-0 text-[10px]">(已失效)</span>
<button
type="button"
@@ -118,7 +139,9 @@ async function openFolder(entry: RecentEntry): Promise<void> {
@click="openFolder(entry)"
>
<History class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ entry.name }}</span>
<span class="truncate">
{{ entry.name }}<span v-if="pathTail(entry.path)" class="text-muted-foreground">({{ pathTail(entry.path) }})</span>
</span>
<span v-if="!entry.exists" class="shrink-0 text-[10px]">(已失效)</span>
<button
type="button"
@@ -52,18 +52,16 @@ const inputRef = ref<InstanceType<typeof Input> | null>(null)
const manualOpen = ref(false)
/**
* 只在「输入框有内容」时按包含关系过滤,空框则列全部。
* 历史条目(新的在前)。
*
* 当前值本身要从列表里排除(否则刚提交过的词会自己冒出来挡着)。
* **不按当前输入过滤**:早先按包含关系筛过一遍 —— 一旦输入框里的词不是任何历史项的子串
* (例如刚敲进去一个没搜过的词),下拉会被判定为空,点历史图标就毫无反应;而「翻出之前
* 搜过什么」恰恰是那一刻的需求。故始终列出**完整历史**,点一下就能看到全部用过的值。
*/
const items = computed(() => {
const query = props.modelValue.trim().toLowerCase()
const list = props.history.filter(h => h !== props.modelValue)
if (!query) return list
return list.filter(h => h.toLowerCase().includes(query))
})
const items = computed(() => props.history)
const open = computed(() => manualOpen.value && !props.disabled && items.value.length > 0)
/** 历史图标点击即可展开 —— 与输入框当前内容无关,随时可唤出。 */
const open = computed(() => manualOpen.value && !props.disabled)
function toggleHistory(): void {
manualOpen.value = !open.value
@@ -73,13 +71,18 @@ function closeHistory(): void {
manualOpen.value = false
}
/** 聚焦输入框(不动内容与选区;用于「把焦点放回查找框」)。 */
function focus(): void {
inputRef.value?.focus()
}
/** 聚焦并全选已有内容(打开卡片时用:直接输入即可覆盖)。 */
function focusAndSelect(): void {
inputRef.value?.focus()
inputRef.value?.element()?.select()
}
defineExpose({ focusAndSelect })
defineExpose({ focus, focusAndSelect })
</script>
<template>
@@ -120,6 +123,7 @@ defineExpose({ focusAndSelect })
<div class="flex items-center gap-1 px-1.5 py-1 text-[10px] text-fg-disabled">
<History class="size-3" />历史
<button
v-if="items.length"
type="button"
class="ml-auto rounded-sm px-1 transition-colors duration-150 hover:bg-hover hover:text-foreground"
title="清空这组历史"
@@ -129,7 +133,10 @@ defineExpose({ focusAndSelect })
</button>
</div>
<ScrollArea class="max-h-56">
<!-- 无历史时也要给一句说明:图标随时可点开,空下拉不能是一片空白 -->
<p v-if="!items.length" class="px-1.5 py-1 text-[11px] text-fg-disabled">暂无历史</p>
<ScrollArea v-else class="max-h-56">
<div class="pb-0.5">
<div
v-for="item in items"
+164
View File
@@ -0,0 +1,164 @@
/**
* Windows 批处理(`.bat` / `.cmd`)的流式语法。
*
* # 为什么要自建
*
* CM6 没有 batch 语言包(不存在 `@codemirror/lang-batch`),`@codemirror/legacy-modes`
* 也没有对应的流式模式 —— 官方 `@codemirror/language-data` 同样给不出 `.bat` 的高亮。
* 因此这里补一个**最简可用**的词法器,走与其它语言相同的 `StreamLanguage` 通道
* (同 `aspMode.ts` 的定位)。
*
* # 为什么是词法而不是语法树
*
* 批处理本来就不是「先解析再高亮」的语言:命令、参数、重定向都是**行**层面的约定,
* 没有可供 lezer 依靠的语句结构。逐行词法已经能覆盖绝大多数观感需求 —— 注释、标签、
* 变量、字符串、命令、重定向与分隔符。代价是没有语义标签,也不提供补全。
*
* # 已知取舍(诚实记录,未做未提)
*
* - 命令只在**语句起始处**着色(行首 / `(` / `)` / `&` / `&&` / `|` / `||` / `do` /
* `else` 之后)。若全文档按词着色,路径与变量值里的同名单词(`C:\Git\cmd`、
* `set x=echo`)会被误判成命令,那属于「高亮错乱」,比不上色更糟;
* - 由此带来的缺口:`if … goto …` 里 `if` 之后的命令不在语句起始处,不会着色;
* - `REM` 只认**语句起始处**的写法(`& rem x` 这种行内注释不额外处理);
* - 字符串不处理 `^` 转义(`"a^"b"` 这种极端写法会提前收尾)。
*/
import { StreamLanguage, type StreamParser, type StringStream } from '@codemirror/language'
import type { Extension } from '@codemirror/state'
/** 词法状态:下一个词是否处在语句起始处(决定要不要按「命令」着色)。 */
interface BatchState {
stmtStart: boolean
}
/**
* 命令 / 关键字的词法白名单(小写)。
*
* 做成集合而不是正则:命令是确定的一小组词,命中即命令,未命中按普通词处理。
* `rem` 不列在这里 —— 它在语句起始处由上面的注释分支先行拦下。
*/
const COMMANDS = new Set<string>([
'assoc', 'attrib', 'break', 'call', 'cd', 'chdir', 'chkdsk', 'choice', 'cls', 'cmd',
'color', 'comp', 'copy', 'date', 'defined', 'del', 'dir', 'do', 'echo', 'else',
'endlocal', 'erase', 'errorlevel', 'exist', 'exit', 'fc', 'find', 'findstr', 'for',
'format', 'ftype', 'goto', 'help', 'if', 'in', 'ipconfig', 'label', 'md', 'mkdir',
'mode', 'more', 'move', 'net', 'netstat', 'not', 'path', 'pause', 'ping', 'popd',
'print', 'prompt', 'pushd', 'rd', 'recover', 'reg', 'ren', 'rename', 'replace',
'rmdir', 'robocopy', 'route', 'sc', 'schtasks', 'set', 'setlocal', 'shift', 'sort',
'start', 'subst', 'systeminfo', 'taskkill', 'tasklist', 'time', 'timeout', 'title',
'tracert', 'tree', 'type', 'ver', 'verify', 'vol', 'where', 'wmic', 'xcopy',
// setlocal 的子命令
'enableextensions', 'enabledelayedexpansion', 'disabledelayedexpansion'
])
/** 需要在命令之后把「语句起始处」重新打开的写法(`for … do echo …` / `) else (`)。 */
const COMMAND_OPENERS = new Set(['do', 'else'])
function createBatch(): StreamParser<BatchState> {
return {
name: 'batch',
startState: () => ({ stmtStart: true }),
copyState: state => ({ stmtStart: state.stmtStart }),
blankLine: state => {
state.stmtStart = true
},
token(stream: StringStream, state: BatchState) {
// 每个新行都从「语句起始处」开始(sol 只在本行第一次调用时为真)
if (stream.sol()) state.stmtStart = true
if (stream.eatSpace()) return null
// ===== 语句起始处:注释 / 标签 / 命令 =====
if (state.stmtStart) {
// `::` 注释(批处理里 `::` 常被当作注释写法)
if (stream.match('::')) {
stream.skipToEnd()
return 'comment'
}
// `REM` / `@REM` 行注释(词边界,避免把 `remark` 当成注释)
if (stream.match(/^@?rem\b/i)) {
stream.skipToEnd()
return 'comment'
}
// `:label`
if (stream.match(/^:[A-Za-z_][\w.-]*/)) {
state.stmtStart = false
return 'labelName'
}
// `@`(关闭回显,如 `@echo off`)—— 后面的词仍算语句起始处,故不重置 stmtStart
if (stream.eat('@')) return 'meta'
// 命令词:命中白名单才着色,未命中按普通词处理
const word = stream.match(/^[A-Za-z]+/) as RegExpMatchArray | null
if (word) {
const lower = word[0].toLowerCase()
if (COMMANDS.has(lower)) {
state.stmtStart = COMMAND_OPENERS.has(lower)
return 'keyword'
}
state.stmtStart = false
return null
}
}
// 走到这里说明本词不是「语句起始处的命令形态」(变量 / 字符串 / 运算符 / 数字…)
state.stmtStart = false
// ===== 字符串(未闭合则吃到行尾) =====
if (stream.eat('"')) {
stream.eatWhile(ch => ch !== '"')
stream.eat('"')
return 'string'
}
// ===== 变量 =====
// `%%i`(for 的循环变量)/ `%%~ni`
if (stream.match(/^%%~?[A-Za-z]+/)) return 'variable-2'
// `!VAR!`(延迟展开)
if (stream.match(/^![A-Za-z0-9_]+!/)) return 'variable-2'
// `%VAR%`(环境变量,如 `%ERRORLEVEL%`、`%PATH%`)
if (stream.match(/^%[A-Za-z_][A-Za-z0-9_]*%/)) return 'variable'
// `%1` / `%~1` / `%*` / `%~dp0`(位置参数与修饰)
if (stream.match(/^%~?[A-Za-z0-9*]+/)) return 'variable'
// ===== 重定向:`>` / `>>` / `2>` / `<` =====
if (stream.match(/^\d*>>?|^\d*</)) return 'operator'
// ===== 语句分隔 / 管道(其后的词回到语句起始处) =====
if (stream.match('&&') || stream.match('||')) {
state.stmtStart = true
return 'operator'
}
if (stream.eat('&') || stream.eat('|')) {
state.stmtStart = true
return 'operator'
}
// ===== 比较(`if "%a%"=="%b%"`) =====
if (stream.match('==')) return 'operator'
// ===== 分组括号(块内的词仍是语句起始处) =====
if (stream.eat('(') || stream.eat(')')) {
state.stmtStart = true
return 'punctuation'
}
// ===== 数字 =====
if (stream.match(/^\d+/)) return 'number'
// ===== 普通词 / 路径:整段吞掉,不上色 =====
// 逐字符着色会让长路径产生海量 token(`readToken` 每次只走一个 token),
// 这里把连续的非结构字符一次性吃掉,兼顾性能与「不误判」。
if (stream.match(/^[^\s&|<>()"'%!^@=]+/)) return null
// 兜底:保证流一定前进(防止 `readToken` 因零位移报错)
stream.next()
return null
}
}
}
/** Windows 批处理(`.bat` / `.cmd`)的流式语言扩展。 */
export function batch(): Extension {
return StreamLanguage.define(createBatch())
}
+1 -1
View File
@@ -59,7 +59,7 @@ export interface EditorConfig {
ligatures: boolean
theme: string
followAppTheme: boolean
/** 应用当前是否为深色(跟随应用时用于取深/浅变体) */
/** 编辑器**窗口**当前的深浅(由 EditorWindow 按「跟随主应用主题 / 配色方案」推导) */
isDark: boolean
/** 语言扩展加载器 */
language: LanguageLoader
+66
View File
@@ -4,6 +4,7 @@
* 命令都通过 `state.changeByRange` 表达,保证多光标下每个选区都被正确处理。
*/
import { EditorSelection, type EditorState } from '@codemirror/state'
import { ensureSyntaxTree, syntaxTree } from '@codemirror/language'
import { type Command, type KeyBinding } from '@codemirror/view'
/** 用标记包裹选区;若选区两侧已是该标记,则取消包裹(可反复切换)。 */
@@ -105,8 +106,73 @@ const insertCodeBlock: Command = view => {
return true
}
/**
* 光标处是否是一个**未闭合**的围栏开头。
*
* 用语法树而不是纯文本判断,是为了区分三种长得很像的情况:
*
* - 真的刚起了个头(``` 或 ```ts 独占一行,节点止于本行)→ 是;
* - 已经写完了(节点一直延伸到后面的闭合围栏)→ 否,否则会把整块内容挤到尾巴后面;
* - 光标停在**闭合**围栏上(节点起点在更早的行)→ 否。
*
* 顺带一提:非 Markdown 文档(`.ts` 里的模板字符串等)本来就没有 `FencedCode` 节点,
* 因此这个判断天然把补全限定在了 Markdown 里,不需要额外的文件类型分支。
*
* `ensureSyntaxTree` 会强制同步解析到这里 —— 用户敲完 ``` 立刻按回车时,增量解析可能
* 还没追上最后一次输入,直接读 `syntaxTree` 会拿到还没有这个围栏的旧树。
*/
function isUnclosedFenceAt(state: EditorState, lineFrom: number, lineTo: number): boolean {
const tree = ensureSyntaxTree(state, lineTo, 100) ?? syntaxTree(state)
let unclosed = false
tree.iterate({
from: lineFrom,
to: lineTo,
enter: node => {
if (node.name !== 'FencedCode') return
// 起点在本行 = 这是开头围栏;终点不越过本行 = 还没闭合
if (node.from >= lineFrom && node.to <= lineTo) unclosed = true
return false
}
})
return unclosed
}
/**
* 围栏代码块「自动补尾巴」:光标停在 ``` / ```ts 这类未闭合的开头上按回车,补出闭合
* 围栏,并把光标留在中间那行(空行):
*
* ```ts
* <光标>
* ```
*
* 只在**光标位于行尾**时触发:光标在行中按回车应当是「拆行」这个默认行为,硬插尾巴只会
* 把后半截挤到围栏之外。
*/
const insertFenceTail: Command = view => {
const { state } = view
const range = state.selection.main
if (!range.empty) return false
const line = state.doc.lineAt(range.head)
if (range.head !== line.to) return false
const match = /^(\s*)(`{3,}|~{3,})\s*([^\s`~]*)\s*$/.exec(line.text)
if (!match) return false
if (!isUnclosedFenceAt(state, line.from, line.to)) return false
const [, indent, fence] = match
view.dispatch({
changes: { from: range.head, insert: `\n\n${indent}${fence}` },
// 落在中间的空行上,用户直接开写正文
selection: EditorSelection.cursor(range.head + 1),
userEvent: 'input'
})
return true
}
/** 编辑器快捷键(优先级高于全局快捷键)。 */
export const editorKeymap: KeyBinding[] = [
// 回车补围栏尾巴:必须排在 `defaultKeymap` 的 Enter 之前才轮得到(见 core.ts 的装配顺序)
{ key: 'Enter', run: insertFenceTail, preventDefault: true },
{ key: 'Mod-b', run: wrapSelection('**'), preventDefault: true },
{ key: 'Mod-i', run: wrapSelection('*'), preventDefault: true },
{ key: 'Mod-Shift-x', run: wrapSelection('~~'), preventDefault: true },
+20
View File
@@ -117,6 +117,18 @@ const MAKEFILE: LanguageEntry = {
load: () => import('codemirror-lang-makefile').then(m => m.makefile())
}
/**
* Markdown(`.md` / `.markdown` / `.mdx`)。
*
* 笔记(`kind: 'note'`)走 `markdownLoader()` 的专用通道,但**库外文件**(「打开文件」
* 或拖入的外部 `.md`)走的是下面的 `LOADERS` 表 —— 此前漏登记,于是这类 `.md` 被当作
* 「纯文本」,既无 markdown 高亮、状态栏也显示纯文本。
*/
const MARKDOWN: LanguageEntry = {
label: 'Markdown',
load: () => markdownLoader()()
}
/**
* 扩展名(小写,不含点)→ 语言。
*
@@ -124,6 +136,10 @@ const MAKEFILE: LanguageEntry = {
* 表本身的构建不产生任何网络/打包开销。
*/
const LOADERS: Record<string, LanguageEntry> = {
// ===== 标记 / 文档 =====
md: MARKDOWN,
markdown: MARKDOWN,
mdx: MARKDOWN,
// ===== 前端 =====
js: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
mjs: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
@@ -232,6 +248,10 @@ const LOADERS: Record<string, LanguageEntry> = {
label: 'PowerShell',
load: () => stream(() => import('@codemirror/legacy-modes/mode/powershell'), m => m.powerShell)
},
// Windows 批处理(`.bat` / `.cmd`):CM6 与 legacy-modes 都没有对应模式,
// 自建一个流式词法器,见 `batchMode.ts`
bat: { label: 'Batch', load: () => import('./batchMode').then(m => m.batch()) },
cmd: { label: 'Batch', load: () => import('./batchMode').then(m => m.batch()) },
// VBScript / VB.NET(与 ASP 同族,但独立文件按纯脚本高亮,不套 HTML 多路复用)。
// VBScript 用裹了一层词法修正的 vbScript(原版把语句分隔符 `:` 当 error 涂红)——
// 见 `vbsStream()` 注释;ASP 的多路复用内部复用了同一个修正版
@@ -271,7 +271,7 @@ function createBuilder(options: LivePreviewOptions) {
if (!active) hide(node.from, node.to, true)
break
case 'CodeMark':
// 仅行内代码的反引号隐藏;围栏代码块的 ``` 保留(保留语言标注)
// 行内代码的反引号;围栏代码块的 ``` 连同语言标注在 FencedCode 分支里整行处理
if (!active && n.parent?.name === 'InlineCode') hide(node.from, node.to)
break
@@ -294,12 +294,37 @@ function createBuilder(options: LivePreviewOptions) {
break
}
// ===== 围栏代码块:整块底色 =====
// ===== 围栏代码块:整块底色 + 围栏行隐藏 =====
case 'FencedCode': {
// 开头的 ``` 永远是第一个子节点;结尾的 ``` 只有在**闭合**时才存在
// (未闭合时最后一个子节点是代码正文),据此拿到两条围栏各自所在的行
const openMark = n.firstChild?.name === 'CodeMark' ? n.firstChild : null
const closeMark =
n.lastChild?.name === 'CodeMark' && n.lastChild !== openMark ? n.lastChild : null
const openLine = openMark ? doc.lineAt(openMark.from).number : -1
const closeLine = closeMark ? doc.lineAt(closeMark.from).number : -1
const firstLine = doc.lineAt(node.from).number
const lastLine = doc.lineAt(node.to).number
let pos = node.from
while (pos <= node.to) {
const l = doc.lineAt(pos)
line(l.from, 'cm-md-codeblock')
const classes = ['cm-md-codeblock']
if (l.number === firstLine) classes.push('cm-md-codeblock-first')
if (l.number === lastLine) classes.push('cm-md-codeblock-last')
decos.push({
from: l.from,
to: l.from,
value: Decoration.line({ class: classes.join(' ') })
})
// 围栏行(开头的 ``` / ```lang 与结尾的 ```)整行隐藏 —— Obsidian 的做法:
// 只有光标落到那一行,语法符号才显形。隐藏后该行留空,正好当作代码区的留白
// (光标在块内任意正文行时,上下围栏都不会跳出来打断阅读)。
if ((l.number === openLine || l.number === closeLine) && !isActive(l.from)) {
hide(l.from, l.to)
}
if (l.to >= node.to) break
pos = l.to + 1
}
@@ -385,8 +410,21 @@ const livePreviewTheme = EditorView.baseTheme({
opacity: '0.9',
paddingLeft: '12px'
},
// 围栏代码块:一块**独立的输入区**(底色 + 圆角 + 代码字体 + 左右留白),
// 围栏符号本身由上层装饰在非光标行隐藏,于是看到的只有代码本身
'.cm-md-codeblock': {
backgroundColor: 'rgba(127, 127, 127, 0.12)'
backgroundColor: 'rgba(127, 127, 127, 0.12)',
paddingLeft: '12px',
paddingRight: '12px',
fontFamily: "'Cascadia Code', 'JetBrains Mono', Consolas, monospace"
},
'.cm-md-codeblock-first': {
borderTopLeftRadius: '8px',
borderTopRightRadius: '8px'
},
'.cm-md-codeblock-last': {
borderBottomLeftRadius: '8px',
borderBottomRightRadius: '8px'
},
'.cm-md-inlinecode': {
backgroundColor: 'rgba(127, 127, 127, 0.16)',
+62 -29
View File
@@ -23,7 +23,7 @@ import { oneDark } from '@codemirror/theme-one-dark'
import { createTheme } from '@uiw/codemirror-themes'
import { tags as t } from '@lezer/highlight'
/** 主题的亮暗归属(供「跟随应用」取对应侧) */
/** 主题的亮暗归属(「跟随主应用主题」关闭时,窗口外壳与编辑区都按它取深浅) */
interface ThemeDefinition {
dark: boolean
extension: Extension
@@ -197,7 +197,31 @@ const MONOKAI_PRO: TagStyle[] = [
{ tag: t.quote, color: '#727072' }
]
/** 主题注册表(key 与 Rust 侧取值一致) */
/**
* `one-dark` 的高亮覆盖层。
*
* 其它主题都走 `createTheme`,选中 / 活动行由各自的 `settings` 直接给色;而 `one-dark`
* 用的是现成扩展 `oneDark`,这几处配色是它内置的、改不到。这里追加一层覆盖主题把它们
* 提到与其它主题一致的对比度(活动行 `<lineHighlight>`、选中 `<selection>`、同词匹配
* `<selectionMatch>`)。选择器与 oneDark 内置的一致并加 `!important`,确保覆盖生效。
*/
const ONE_DARK_HIGHLIGHT: Extension = EditorView.theme(
{
'&.cm-focused .cm-selectionBackground, & .cm-selectionLayer .cm-selectionBackground, .cm-content ::selection':
{ background: '#4a5670 !important' },
'.cm-selectionMatch': { backgroundColor: '#4a5670b3 !important' },
'.cm-activeLine': { backgroundColor: '#ffffff1a !important' }
},
{ dark: true }
)
/**
* 主题注册表(key 与 Rust 侧取值一致)。
*
* 每套主题的 `selection` / `selectionMatch` / `lineHighlight` 都**刻意调高对比度**:
* 活动行、选中文字、同词匹配若照搬上游的浅色值(例如 VS Code 的 `#264f78`、
* `#ffffff0a`),在编辑器里几乎看不出选中范围。宁可略重也不要看不清。
*/
export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
'vscode-dark': {
dark: true,
@@ -207,9 +231,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#1e1e1e',
foreground: '#d4d4d4',
caret: '#aeafad',
selection: '#264f78',
selectionMatch: '#264f7866',
lineHighlight: '#ffffff0a',
selection: '#3b6ea5',
selectionMatch: '#3b6ea5b3',
lineHighlight: '#ffffff1a',
gutterBackground: '#1e1e1e',
gutterForeground: '#858585',
gutterActiveForeground: '#cccccc',
@@ -226,9 +250,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#ffffff',
foreground: '#333333',
caret: '#000000',
selection: '#add6ff',
selectionMatch: '#add6ff80',
lineHighlight: '#00000008',
selection: '#9ec8f5',
selectionMatch: '#9ec8f5b3',
lineHighlight: '#00000014',
gutterBackground: '#ffffff',
gutterForeground: '#237893',
gutterActiveForeground: '#0b216f',
@@ -239,7 +263,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
},
'one-dark': {
dark: true,
extension: oneDark
// `oneDark` 是现成扩展(不走 createTheme),选中 / 活动行配色是它内置的,
// 因此追加一层覆盖主题把这几处提亮(见 ONE_DARK_HIGHLIGHT)
extension: [oneDark, ONE_DARK_HIGHLIGHT]
},
dracula: {
dark: true,
@@ -249,9 +275,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#282a36',
foreground: '#f8f8f2',
caret: '#f8f8f2',
selection: '#44475a',
selectionMatch: '#44475a80',
lineHighlight: '#ffffff08',
selection: '#5b6079',
selectionMatch: '#5b6079b3',
lineHighlight: '#ffffff1a',
gutterBackground: '#282a36',
gutterForeground: '#6272a4',
gutterActiveForeground: '#f8f8f2',
@@ -268,9 +294,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#002b36',
foreground: '#839496',
caret: '#93a1a1',
selection: '#073642',
selectionMatch: '#07364280',
lineHighlight: '#ffffff08',
selection: '#11505f',
selectionMatch: '#11505fb3',
lineHighlight: '#ffffff1a',
gutterBackground: '#002b36',
gutterForeground: '#586e75',
gutterActiveForeground: '#93a1a1',
@@ -287,9 +313,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#fdf6e3',
foreground: '#657b83',
caret: '#586e75',
selection: '#eee8d5',
selectionMatch: '#eee8d580',
lineHighlight: '#00000008',
selection: '#d9cfae',
selectionMatch: '#d9cfaeb3',
lineHighlight: '#00000014',
gutterBackground: '#fdf6e3',
gutterForeground: '#93a1a1',
gutterActiveForeground: '#586e75',
@@ -306,9 +332,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#2b2b2b',
foreground: '#a9b7c6',
caret: '#bbbbbb',
selection: '#214283',
selectionMatch: '#21428380',
lineHighlight: '#ffffff08',
selection: '#2f5aa8',
selectionMatch: '#2f5aa8b3',
lineHighlight: '#ffffff1a',
gutterBackground: '#313335',
gutterForeground: '#606366',
gutterActiveForeground: '#a1a3a5',
@@ -325,9 +351,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#ffffff',
foreground: '#000000',
caret: '#000000',
selection: '#a6d2ff',
selectionMatch: '#a6d2ff80',
lineHighlight: '#00000008',
selection: '#8dbfef',
selectionMatch: '#8dbfefb3',
lineHighlight: '#00000014',
gutterBackground: '#ffffff',
gutterForeground: '#999999',
gutterActiveForeground: '#666666',
@@ -344,9 +370,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#2d2a2e',
foreground: '#fcfcfa',
caret: '#ffd866',
selection: '#5b595c',
selectionMatch: '#5b595c80',
lineHighlight: '#ffffff08',
selection: '#6f6c74',
selectionMatch: '#6f6c74b3',
lineHighlight: '#ffffff1a',
gutterBackground: '#2d2a2e',
gutterForeground: '#727072',
gutterActiveForeground: '#fcfcfa',
@@ -387,7 +413,7 @@ export function editorBackground(
/** 设置页下拉选项(`system` 置于首位) */
export const EDITOR_THEME_OPTIONS: Array<{ value: string; label: string }> = [
{ value: 'system', label: '跟随应用' },
{ value: 'system', label: '跟随系统' },
{ value: 'vscode-dark', label: 'VS Code 深色' },
{ value: 'vscode-light', label: 'VS Code 浅色' },
{ value: 'one-dark', label: 'One Dark' },
@@ -415,7 +441,14 @@ const THEME_PAIRS: Record<string, { light: string; dark: string }> = {
system: { light: 'vscode-light', dark: 'vscode-dark' }
}
/** 求实际生效的主题名。 */
/**
* 求实际生效的主题名。
*
* 参数 `isDark` 是**编辑器窗口当前的深浅**(见 `EditorWindow.windowIsDark`):
* - `followAppTheme` 开:窗口跟随主应用,`isDark` 即应用的深浅,按配对取对应侧;
* - `followAppTheme` 关:窗口由配色方案决定 —— 具体主题直接用自身,`system`
* (「跟随系统」)则按传给它的深浅取 VS Code 深/浅(此时是应用解析出的系统深浅)。
*/
export function effectiveThemeName(
theme: string,
followAppTheme: boolean,
+26 -1
View File
@@ -155,6 +155,20 @@ export const editorClient = {
// ===== 本地目录(P3-5,操作用户真实文件系统) =====
readDir: (path: string) => invoke<DirListing>('editor_read_dir', { path }),
/**
* 判定一个路径是文件还是文件夹(只探测,不打开)。
*
* 拖放事件只给绝对路径,前端拿不到文件系统元信息,因此复用 `editor_read_dir`
* 探测:能列出即目录(该命令对文件会报错)。探测是只读的,不写盘、不需授权。
*/
pathKind: async (path: string): Promise<'file' | 'folder'> => {
try {
await invoke<DirListing>('editor_read_dir', { path })
return 'folder'
} catch {
return 'file'
}
},
createFile: (dir: string, name: string) => invoke<string>('editor_create_file', { dir, name }),
createDir: (dir: string, name: string) => invoke<string>('editor_create_dir', { dir, name }),
renamePath: (path: string, newName: string) =>
@@ -167,5 +181,16 @@ export const editorClient = {
// ===== 系统集成(P4-4,HKCU 右键菜单) =====
contextMenuStatus: () => invoke<ContextMenuStatus>('editor_context_menu_status'),
registerContextMenu: () => invoke<ContextMenuStatus>('editor_register_context_menu'),
unregisterContextMenu: () => invoke<ContextMenuStatus>('editor_unregister_context_menu')
unregisterContextMenu: () => invoke<ContextMenuStatus>('editor_unregister_context_menu'),
/**
* 给新建的编辑器窗口补注入拖放支持(Windows)。
*
* wry 只在创建 webview 的那一刻扫一次子窗口注入 OLE drop target,而 WebView2 的
* 渲染子窗口是异步创建的 —— 运行期新建的窗口因此拿不到 drop target(拖文件进去
* 是禁止光标)。这里让 Rust 侧在子窗口出现后补注入。非 Windows 是空操作。
*
* 命令是**通用**的(`window_attach_drag_drop`,按传入的 label 生效):对比窗口也用它。
*/
attachDragDrop: (label: string) => invoke<void>('window_attach_drag_drop', { label })
}
+83 -4
View File
@@ -6,6 +6,8 @@
* 直接显示会先闪一下纯白。由 EditorWindow.vue 应用完主题(含窗口效果)再自己 show;
* - **同目标判重聚焦**(规划 §8-Q1 选 (a)):窗口默认多开,但「同一个文件开两个窗口」
* 几乎总是误操作 —— 两个窗口各自自动保存,后写的会覆盖先写的。
* - **已有编辑器窗口时加标签**(复用设置打开时):打开另一个文件 / 目录不再多开窗口,
* 而是 `emitTo` 一个 `editor-open-tab` 给既有窗口,由它加一个标签(见下)。
*
* # label 里为什么是哈希而不是明文路径
*
@@ -16,9 +18,13 @@
* 可以忽略,而代价(不判重)远小于把路径写进 label。
*/
import { WebviewWindow } from '@tauri-apps/api/webviewWindow'
import { emitTo } from '@tauri-apps/api/event'
import { invoke } from '@tauri-apps/api/core'
import { createLogger } from '@/lib/logger'
import { WINDOWS } from '@/lib/constants'
import { EVENTS, WINDOWS } from '@/lib/constants'
import { useEditorStore } from '@/stores/editorStore'
import { editorClient } from './editorClient'
import type { EditorOpenTabPayload } from '@/types/editor'
const logger = createLogger('editor')
@@ -40,19 +46,48 @@ export function labelForTarget(target: string): string {
return `${LABEL_PREFIX}t${hashTarget(target)}`
}
/**
* 显示 + 取消最小化 + 强制置前(按窗口 label)。
*
* 走 Rust 原生 `SetForegroundWindow`(见 `win32_util::force_foreground`)而不是前端
* `show() / unminimize() / setFocus()`:后者受 Windows **前台锁定**限制 —— 快捷键从
* 别的应用触发时「本进程不拥有前台」,`setFocus` 会被系统直接忽略,表现就是
* **窗口明明开着却唤不到前面**(下载窗口 / 快速面板 / 托盘同一处理)。
*/
async function focusWindow(label: string): Promise<void> {
await invoke('window_focus_window', { label })
}
/** 聚焦已经打开该目标的窗口(找到返回 true)。 */
async function focusTarget(target: string): Promise<boolean> {
const existing = await WebviewWindow.getByLabel(labelForTarget(target))
if (!existing) return false
try {
await existing.show()
await existing.setFocus()
await focusWindow(existing.label)
return true
} catch {
return false
}
}
/**
* 找一个**已存在**的编辑器窗口(任意一个),没有则 null。
*
* 与 [`focusTarget`] 的区别:那个要的是「这个目标自己的窗口」,这个要的是「有没有
* 任何一个编辑器窗口可以接收新标签」。两者的判据不同,因此不合并成一个函数。
*/
async function findOpenEditorWindow(): Promise<WebviewWindow | null> {
const windows = await WebviewWindow.getAll()
return windows.find(w => w.label.startsWith(LABEL_PREFIX)) ?? null
}
/** 把打开请求转换成「加标签」负载(三种目标与 `openEditorWindow` 的入参一一对应)。 */
function toTabPayload(options: { relPath?: string; path?: string; folder?: string }): EditorOpenTabPayload {
if (options.relPath) return { relPath: options.relPath }
if (options.folder) return { path: options.folder, folder: true }
return { path: options.path }
}
/**
* 打开一个编辑器窗口。
*
@@ -60,6 +95,9 @@ async function focusTarget(target: string): Promise<boolean> {
* @param options.path 可选:打开时直达的**库外文件**(绝对路径)
* @param options.folder 可选:打开时直达的**本地目录**(绝对路径,目录面板)
* @param options.dedupe 同一目标已开窗口时聚焦它(默认 true)
*
* **无目标**(`Alt+E` / 托盘「打开编辑器」)时:已有编辑器窗口就**唤出它**而不是新开一个
* —— 快捷键的语义是「去编辑」,反复按不该堆出一串空窗口。
*/
export async function openEditorWindow(options?: {
relPath?: string
@@ -76,13 +114,41 @@ export async function openEditorWindow(options?: {
? `?folder=${encodeURIComponent(options.folder)}`
: ''
// 无目标:任何编辑器窗口存在就直接唤出(显示 + 取消最小化 + 强制置前)
if (!target && options?.dedupe !== false) {
const existing = await findOpenEditorWindow()
if (existing) {
try {
await focusWindow(existing.label)
return
} catch (e) {
logger.warn(`唤出既有编辑器窗口失败,改为新建:${String(e)}`)
}
}
}
if (target && options?.dedupe !== false) {
// 「复用文档窗口」是可关闭的设置(默认开)。关掉时每次新建窗口 ——
// 有些用户确实想并排对照同一篇的不同位置。
const reuse = useEditorStore().settings.reuseWindow
if (reuse) {
// ① 这个目标自己已经有窗口:聚焦它(原行为)
const focused = await focusTarget(target)
if (focused) return
// ② 任何编辑器窗口存在:把目标交给它**加标签**,而不是再开一个窗口。
// 「再点一次同一个文件」由 ① 拦住,这里处理的是「打开另一个文件 / 目录」——
// 过去每次都会多出一个窗口,而用户真正想要的是标签栏多一项。
// (编辑器窗口尚未加载完时事件可能落空,属于极窄的竞态:窗口已存在即已在监听。)
const host = await findOpenEditorWindow()
if (host) {
try {
await emitTo(host.label, EVENTS.editorOpenTab, toTabPayload(options ?? {}))
await focusWindow(host.label)
return
} catch (e) {
logger.warn(`向既有编辑器窗口加标签失败,改为新建窗口:${String(e)}`)
}
}
}
}
@@ -106,13 +172,26 @@ export async function openEditorWindow(options?: {
shadow: true,
center: true,
visible: false,
focus: false
focus: false,
// 显式开启 Tauri 原生拖放(拖文件进窗口打开):默认值虽为开,但显式声明可避免
// 依赖「动态创建窗口的默认值」这一隐含前提,且与 capabilities 的意图一致。
dragDropEnabled: true
})
win.once('tauri://error', e => {
logger.error(`打开编辑器窗口失败:${String(e)}`)
})
// 补注入拖放支持:wry 只在创建 webview 那一刻扫一次子窗口,运行期新建的窗口拿不到
// OLE drop target(拖文件进去是禁止光标)。详见 src-tauri/src/editor/drag_drop.rs
//
// 注意**不要**放到下面那个 `await` 之后:`tauri://created` 在窗口创建过快时可能早于
// 监听注册而永远等不到,那个 promise 会一直挂着。Rust 侧会自行重试等待窗口与
// WebView2 子窗口就位,所以这里 fire-and-forget 即可。
void editorClient.attachDragDrop(finalLabel).catch(e => {
logger.warn(`拖放补注入失败:${String(e)}`)
})
await new Promise<void>((resolve, reject) => {
win.once('tauri://created', () => resolve())
win.once('tauri://error', e => reject(new Error(String(e))))
+4 -2
View File
@@ -12,7 +12,8 @@ import {
Languages,
SquareTerminal,
Bot,
FileCode2
FileCode2,
Diff
} from '@lucide/vue'
/**
@@ -35,7 +36,8 @@ export const moduleIconMap: Record<string, Component> = {
translate: Languages,
terminal: SquareTerminal,
dsh: Bot,
editor: FileCode2
editor: FileCode2,
diff: Diff
}
/** 获取模块图标组件,未找到时回退到 Settings 图标 */
+3 -1
View File
@@ -15,6 +15,7 @@ import { moduleConfig as translate } from './translate'
import { moduleConfig as terminal } from './terminal'
import { moduleConfig as dsh } from './dsh'
import { moduleConfig as editor } from './editor'
import { moduleConfig as diff } from './diff'
const allModules: ModuleConfig[] = [
proxy,
@@ -29,7 +30,8 @@ const allModules: ModuleConfig[] = [
translate,
terminal,
dsh,
editor
editor,
diff
]
// 启动时注册所有模块
+27 -45
View File
@@ -2,7 +2,7 @@
import {
Activity, Play, Square, RefreshCw, Loader2, Cpu, MemoryStick,
Gauge, HardDrive, Settings as SettingsIcon, AlertTriangle,
ShieldCheck, ShieldOff, Zap, Thermometer, Clock, ChevronDown,
ShieldCheck, Zap, Thermometer, Clock, ChevronDown,
ArrowDown, ArrowUp, Wifi, FolderOpen, Copy, ListChecks,
Monitor as MonitorIcon, GripVertical, SlidersHorizontal,
Eye, EyeOff, MousePointerClick, Check, PencilLine,
@@ -469,26 +469,15 @@ async function handleRepairPawnio() {
}
}
/** 提权:以管理员权限重启 Thing 自身,并持久化标志使后续启动自动提权。
* Thing 以管理员权限运行时,ThingHK 子进程继承权限,ProcessManager 可直接管控,
* ThingHK 崩溃会自动重启,避免数据停止后 Thing 不感知。
* 非管理员时进程退出;已是管理员时仅设置标志并返回。
*/
async function handleElevateSelf() {
await store.elevateSelf()
// 非管理员时进程已退出,不会走到这里
/** 提权:仅以管理员权限重启 ThingHK 内核(弹 UAC),Thing 自身保持普通权限。
* 提权后可读取完整的 CPU 温度/时钟、存储 SMART、主板/电压等传感器;
* 代价是内核不归 ProcessManager 管(停止走 /shutdown,崩溃不自动重启)。 */
async function handleElevateKernel() {
await store.elevateKernel()
if (store.errorMsg) {
toast.error('提权失败', { description: store.errorMsg })
} else if (store.elevateOnLaunch) {
toast.success('已启用提权', { description: '后续启动将自动以管理员权限运行' })
}
}
/** 取消提权:清除标志,下次启动不再触发 UAC(当前会话权限不变) */
async function handleCancelElevation() {
await store.cancelElevation()
if (!store.errorMsg) {
toast.success('已取消提权', { description: '下次启动将以普通权限运行' })
toast.error('内核提权失败', { description: store.errorMsg })
} else if (store.status?.elevated) {
toast.success('ThingHK 已以管理员权限运行', { description: 'Thing 自身仍为普通权限' })
}
}
@@ -1376,9 +1365,6 @@ watch(() => store.status?.ready, (ready, prev) => {
<Badge :variant="store.snapshot?.isAdmin ? 'default' : 'outline'" :class="store.snapshot?.isAdmin ? 'bg-success hover:bg-success' : ''">
{{ store.snapshot?.isAdmin ? '管理员' : '普通' }}
</Badge>
<Badge v-if="store.status?.thingElevated" variant="outline" class="border-success/50 text-success-text">
<ShieldCheck class="size-2.5 mr-0.5" />提权
</Badge>
</div>
<!-- 指标区:核心属性同样占一个指标位(label 11px 灰 + 数值 18px/600 tabular-nums) -->
<div class="flex flex-wrap items-center gap-6">
@@ -1408,24 +1394,16 @@ watch(() => store.status?.ready, (ready, prev) => {
<Button v-if="store.connState === 'idle' && !store.starting" size="sm" :disabled="store.starting" @click="handleStart">
<Play class="size-3.5" />启动
</Button>
<!-- 提权按钮(标志未启用时显示:设置标志 + 以管理员权限重启 Thing) -->
<Tooltip v-if="!store.elevateOnLaunch">
<!-- 提权按钮:仅以管理员权限重启 ThingHK 内核(Thing 自身保持普通权限)。
提权成功后会记住提权偏好,应用重启后自动以提权方式启动(可在监控设置中关闭)。 -->
<Tooltip v-if="!store.status?.elevated">
<TooltipTrigger as-child>
<Button size="sm" variant="outline" class="gap-1 text-success-text border-success/40 hover:bg-success/10" :disabled="store.starting" @click="handleElevateSelf">
<Button size="sm" variant="outline" class="gap-1 text-success-text border-success/40 hover:bg-success/10" :disabled="store.starting" @click="handleElevateKernel">
<Loader2 v-if="store.starting" class="size-3.5 animate-spin" />
<ShieldCheck v-else class="size-3.5" />提权
<ShieldCheck v-else class="size-3.5" />提权内核
</Button>
</TooltipTrigger>
<TooltipContent class="max-w-[480px] break-words">以管理员权限重启 Thing(弹 UAC,ThingHK 子进程继承权限,后续启动自动提权,崩溃自动重启)</TooltipContent>
</Tooltip>
<!-- 取消提权按钮(标志已启用时显示:清除标志,下次启动不触发 UAC) -->
<Tooltip v-else>
<TooltipTrigger as-child>
<Button size="sm" variant="outline" class="gap-1 text-muted-foreground hover:text-foreground" @click="handleCancelElevation">
<ShieldOff class="size-3.5" />取消提权
</Button>
</TooltipTrigger>
<TooltipContent class="max-w-[480px] break-words">取消提权,下次启动将以普通权限运行(不影响当前会话)</TooltipContent>
<TooltipContent class="max-w-[480px] break-words">仅以管理员权限重启 ThingHK 内核(弹 UAC),Thing 自身保持普通权限。提权后可读取 CPU 温度/时钟、存储 SMART、主板/电压;停止走内核 /shutdown,崩溃不自动重启。成功后记住提权偏好,应用重启后自动沿用(可在监控设置中关闭)</TooltipContent>
</Tooltip>
<!--
刷新:图标按钮(原来是与启动/停止同级的文字按钮,把操作区撑宽
@@ -2330,6 +2308,17 @@ watch(() => store.status?.ready, (ready, prev) => {
@update:model-value="(v: boolean) => store.setAutoStart(v)"
/>
</div>
<!-- 内核启动时提权 toggle:提权偏好持久化,重启应用后自动沿用(弹 UAC) -->
<div class="flex items-center justify-between rounded-md border p-3">
<div>
<p class="text-sm">内核启动时以管理员权限运行</p>
<p class="text-xs text-muted-foreground">启动内核时弹 UAC 提权,Thing 自身保持普通权限;开启后应用重启仍保持提权</p>
</div>
<Switch
:model-value="store.elevateOnStart"
@update:model-value="(v: boolean) => store.setElevateOnStart(v)"
/>
</div>
</CardContent>
</Card>
@@ -2401,9 +2390,6 @@ watch(() => store.status?.ready, (ready, prev) => {
<Badge :variant="store.snapshot?.isAdmin ? 'default' : 'outline'" :class="store.snapshot?.isAdmin ? 'bg-success hover:bg-success' : ''">
{{ store.snapshot?.isAdmin ? '管理员' : '普通' }}
</Badge>
<Badge v-if="store.status?.thingElevated" variant="outline" class="border-success/50 text-success-text">
<ShieldCheck class="size-2.5 mr-0.5" />提权
</Badge>
</div>
</div>
<Separator />
@@ -2416,14 +2402,10 @@ watch(() => store.status?.ready, (ready, prev) => {
<div class="flex items-start gap-2">
<ShieldCheck class="size-3.5 mt-0.5 shrink-0 text-success" />
<div class="text-xs">
<span class="font-medium text-foreground">提权</span>:以管理员权限重启 Thing 自身,ThingHK 子进程继承权限。标志持久化,后续每次启动自动触发 UAC;可在概览页点击"取消提权"关闭。ThingHK 崩溃由 ProcessManager 自动重启,避免数据停止后 Thing 不感知。
<span class="font-medium text-foreground">提权内核</span>:仅以管理员权限重启 ThingHK 内核(弹 UAC),Thing 自身始终以普通权限运行。该状态不持久化,重启内核即回到普通权限。提权内核不归 ProcessManager 管:停止走内核 /shutdown 接口,崩溃不自动重启,需手动重新提权。
</div>
</div>
</div>
<p v-if="store.status?.thingElevated" class="text-xs leading-relaxed text-success-text flex items-start gap-1.5">
<ShieldCheck class="size-3.5 mt-0.5 shrink-0" />
<span>提权模式:Thing 与 ThingHK 均以管理员权限运行,ProcessManager 可直接 kill,崩溃自动重启可用。</span>
</p>
</CardContent>
</Card>
+6
View File
@@ -51,6 +51,12 @@ const searchItems: SearchIndexItem[] = [
keywords: ['自动启动', '开机', '内核', 'autoStart'],
tab: 'settings'
},
{
title: '内核启动时提权',
description: '内核以管理员权限运行,应用重启后保持提权',
keywords: ['提权', '管理员', 'uac', 'elevate', 'admin', '内核'],
tab: 'settings'
},
{
title: '监控项配置',
description: '选择要监控的传感器分组与项目',
+7
View File
@@ -26,6 +26,7 @@
* 因此这里除了切 class 还要设**窗口底色**,否则显示瞬间是白底。
*/
import { onBeforeUnmount, onMounted, ref } from 'vue'
import { invoke } from '@tauri-apps/api/core'
import { getCurrentWindow } from '@tauri-apps/api/window'
import { FolderTree, Loader2, Minus, Square, X } from '@lucide/vue'
import { toast } from 'vue-sonner'
@@ -100,6 +101,12 @@ onMounted(async () => {
// 主题 → 显示:窗口是隐藏创建的,这一步之后用户才第一次看到它
await applyTheme()
// 任务栏身份:窗口级 AUMID(独立任务栏按钮)+ 组合图标;必须在 show() 之前设置
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'files' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try {
await win.show()
await win.setFocus()
+7
View File
@@ -47,6 +47,7 @@
* 语义:主窗口那侧的「已在独立窗口中打开」提示条、标签上的「独立」徽标都以此为准。
*/
import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
import { invoke } from '@tauri-apps/api/core'
import { getCurrentWindow } from '@tauri-apps/api/window'
import {
AlertTriangle,
@@ -192,6 +193,12 @@ async function applyTheme() {
* 放在 `applyTheme` 之后,用户看到的第一帧就是正确配色。
*/
async function revealWindow() {
// 任务栏身份:窗口级 AUMID(独立任务栏按钮)+ 组合图标;必须在 show() 之前设置
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'terminal' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try {
await win.show()
await win.setFocus()
+156 -17
View File
@@ -9,6 +9,7 @@ import { Effect, EffectState } from '@tauri-apps/api/window'
import {
Globe, Power, PowerOff, RefreshCw, Check, Monitor, LogOut,
Play, Pause, SkipBack, SkipForward, Music, SquareTerminal, Bot, FileCode2,
Repeat, Repeat1, Shuffle, Volume1, Volume2, VolumeX,
} from '@lucide/vue'
import {
Select, SelectContent, SelectItem, SelectTrigger, SelectValue,
@@ -33,8 +34,15 @@ interface MusicState {
playing: boolean
title: string
artist: string
/** 当前音量(0.0~1.0),来自 Rust 播放引擎 */
volume: number
muted: boolean
}
/** 播放顺序(与 `feiniuStore` 的 `thing.music.playmode` 同一份 localStorage) */
type PlayMode = 'loopAll' | 'loopOne' | 'shuffle'
const PLAY_MODE_KEY = 'thing.music.playmode'
const state = reactive<TrayMenuState>({
proxyRunning: false,
systemProxy: false,
@@ -43,7 +51,11 @@ const state = reactive<TrayMenuState>({
proxyNodes: [],
proxyCurrent: null,
})
const music = reactive<MusicState>({ playing: false, title: '', artist: '' })
const music = reactive<MusicState>({ playing: false, title: '', artist: '', volume: 1, muted: false })
/** 播放顺序:真相在主窗口前端的 feiniuStore(localStorage 同步),托盘只读来显示图标 */
const playMode = ref<PlayMode>('loopAll')
/** 音量面板是否展开(展开时窗口需要长高,见 toggleVolumePanel) */
const volumeOpen = ref(false)
const loadingAction = ref<string | null>(null)
const refreshing = ref(false)
const osdVisible = ref(false)
@@ -53,6 +65,8 @@ const unlistenFns: UnlistenFn[] = []
/** 菜单关闭/失焦前重置状态:关闭节点下拉框并取消所有焦点,避免下次打开时残留 */
function resetMenuState() {
nodeSelectOpen.value = false
// 音量面板随菜单收起一并复位:下次弹出应回到简洁的两行
volumeOpen.value = false
if (document.activeElement instanceof HTMLElement) {
document.activeElement.blur()
}
@@ -314,22 +328,71 @@ function handleSelectNode(name: unknown) {
// 与普通菜单项不同:点音乐按钮**不关闭菜单**(用户常要连点下一首),
// 因此不走 handleAction(它会 hide 菜单 + 取消焦点),而是单独一条路径。
/** 从 localStorage 读播放顺序(主窗口 feiniuStore 写的是同一个键) */
function readPlayMode() {
try {
const v = localStorage.getItem(PLAY_MODE_KEY)
if (v === 'loopAll' || v === 'loopOne' || v === 'shuffle') playMode.value = v
} catch { /* localStorage 不可用时保持默认 */ }
}
/** 拉取一次音乐状态(本地查询,开销极小) */
async function refreshMusic() {
try {
Object.assign(music, await invoke<MusicState>('tray_music_state'))
const s = await invoke<MusicState>('tray_music_state')
// 音量面板展开 / 拖动期间不覆盖本地值:1s 轮询会把用户正在拖的滑块拽回去
if (!volumeOpen.value) Object.assign(music, s)
else music.playing = s.playing
} catch { /* 忽略 */ }
readPlayMode()
}
async function handleMusicControl(action: 'toggle' | 'next' | 'prev') {
type MusicAction = 'toggle' | 'next' | 'prev' | 'toggle-mode' | 'toggle-mute'
async function handleMusicControl(action: MusicAction) {
// 乐观翻转播放态:动作要经主窗口前端执行(异步),先改本地避免按钮有明显延迟;
// 真实值由 1s 轮询纠正
if (action === 'toggle') music.playing = !music.playing
try {
await invoke('tray_music_control', { action })
} catch { /* 忽略 */ }
// 播放顺序 / 静音是本地读的,改完立刻重读一次(不必等下一轮轮询)
if (action === 'toggle-mode' || action === 'toggle-mute') readPlayMode()
}
/** 音量变化(拖动 / 点击轨道):直接改 Rust 引擎,即时出声 */
let volumeSentAt = 0
async function handleVolumeInput(value: number): Promise<void> {
music.volume = value
// 节流:range 的 input 事件很密,50ms 一次足够跟手,避免刷爆 IPC
const now = Date.now()
if (now - volumeSentAt < 50) return
volumeSentAt = now
try {
await invoke('tray_music_control', { action: 'volume', level: value })
} catch { /* 忽略 */ }
}
/** 音量面板开合:面板在正常流里长高/收起,需重新测高让窗口跟着变,否则滑块会被裁掉 */
async function toggleVolumePanel() {
volumeOpen.value = !volumeOpen.value
await nextTick()
await measureAndShow()
}
/** 音量图标:静音 / 低音量 / 正常 */
const volumeIcon = computed(() =>
music.muted || music.volume <= 0 ? VolumeX : music.volume < 0.5 ? Volume1 : Volume2
)
/** 播放顺序图标与说明 */
const modeIcon = computed(() =>
playMode.value === 'loopOne' ? Repeat1 : playMode.value === 'shuffle' ? Shuffle : Repeat
)
const modeTitle = computed(() =>
playMode.value === 'loopAll' ? '列表循环' : playMode.value === 'loopOne' ? '单曲循环' : '随机播放'
)
/** 音乐状态轮询定时器(仅菜单可见时运行) */
let musicTimer: number | null = null
@@ -370,9 +433,10 @@ function onKeydown(e: KeyboardEvent) {
}
const MENU_MIN_HEIGHT = 200
const MENU_MAX_HEIGHT = 520
/** 测量内容高度(逻辑像素) */
/** 测量内容高度(逻辑像素)。
* 不做上限截断:窗口按内容完整撑开,菜单不出现滚动条;
* 仅当内容超出光标上方的屏幕可用空间时,才由 Rust 侧 tray_menu_ready 收窄并退化为滚动。 */
function measureContentHeight(): number {
const root = document.querySelector('.tray-menu-root') as HTMLElement | null
if (!root) return MENU_MIN_HEIGHT
@@ -382,7 +446,7 @@ function measureContentHeight(): number {
if (scroll) scroll.style.maxHeight = 'none'
const height = root.scrollHeight
if (scroll) scroll.style.maxHeight = prevMax
return Math.min(Math.max(height, MENU_MIN_HEIGHT), MENU_MAX_HEIGHT)
return Math.max(height, MENU_MIN_HEIGHT)
}
/** 测量内容高度并通知 Rust 调整窗口大小、定位、显示 */
@@ -539,14 +603,23 @@ onUnmounted(() => {
<template>
<div class="tray-menu-root flex flex-col" @keydown="onKeydown" tabindex="0">
<div class="tray-menu-scroll flex-1 min-h-0 overflow-y-auto">
<!-- 音乐控制条(代理之上):当前曲目 + 上一首/播放暂停/下一首 -->
<!-- 音乐控制条(代理之上):第一行曲目信息,第二行播放控制(一行太挤) -->
<div class="tray-music">
<Music class="size-4 shrink-0 tray-music-icon" />
<div class="tray-music-text">
<span class="tray-music-title">{{ music.title || '未在播放' }}</span>
<span class="tray-music-artist">{{ music.artist || (music.title ? '未知歌手' : '') }}</span>
<div class="tray-music-info">
<Music class="size-4 shrink-0 tray-music-icon" />
<div class="tray-music-text">
<span class="tray-music-title">{{ music.title || '未在播放' }}</span>
<span class="tray-music-artist">{{ music.artist || (music.title ? '未知歌手' : '') }}</span>
</div>
</div>
<div class="tray-music-actions">
<button
class="tray-music-btn"
:title="modeTitle"
@click="handleMusicControl('toggle-mode')"
>
<component :is="modeIcon" class="size-4" />
</button>
<button
class="tray-music-btn"
:disabled="!music.title"
@@ -567,6 +640,37 @@ onUnmounted(() => {
>
<SkipForward class="size-4" />
</button>
<button
class="tray-music-btn"
:class="volumeOpen && 'bg-active'"
:title="music.muted ? '已静音(点击调节音量)' : `音量 ${Math.round(music.volume * 100)}%`"
@click="toggleVolumePanel"
>
<component :is="volumeIcon" class="size-4" />
</button>
</div>
<!-- 音量面板:点音量按钮后展开(窗口是内容自适应高度,浮层会被裁切,故用内联展开) -->
<div v-if="volumeOpen" class="tray-music-volume">
<button
class="tray-music-btn"
:title="music.muted ? '取消静音' : '静音'"
@click="handleMusicControl('toggle-mute')"
>
<VolumeX v-if="music.muted" class="size-4" />
<Volume2 v-else class="size-4" />
</button>
<input
class="tray-volume-slider"
type="range"
min="0"
max="1"
step="0.01"
:value="music.muted ? 0 : music.volume"
title="音量"
@input="handleVolumeInput(Number(($event.target as HTMLInputElement).value))"
/>
<span class="tray-volume-value">{{ Math.round((music.muted ? 0 : music.volume) * 100) }}</span>
</div>
</div>
@@ -699,7 +803,9 @@ onUnmounted(() => {
.tray-menu-scroll {
padding: 6px;
overflow-y: auto;
max-height: 520px;
/* 仅作为兜底:正常情况下窗口高度 = 内容高度(不滚动);
内容超出窗口(屏幕空间不足被 Rust 收窄)时才出现滚动条 */
max-height: 100vh;
}
.tray-menu-scroll::-webkit-scrollbar {
@@ -757,14 +863,23 @@ onUnmounted(() => {
opacity: 0.5;
}
/* ===== 音乐控制条(代理之上) ===== */
/* ===== 音乐控制条(代理之上) =====
两行:上行曲目信息,下行播放控制 —— 一行放「图标 + 曲名 + 歌手 + 三个按钮」太挤,
长曲名只能截到几个字。 */
.tray-music {
display: flex;
flex-direction: column;
gap: 6px;
padding: 8px 10px;
border-radius: 6px;
}
.tray-music-info {
display: flex;
align-items: center;
gap: 8px;
padding: 7px 10px;
border-radius: 6px;
min-width: 0;
}
.tray-music-icon {
@@ -800,8 +915,8 @@ onUnmounted(() => {
.tray-music-actions {
display: flex;
align-items: center;
gap: 2px;
flex-shrink: 0;
justify-content: center;
gap: 8px;
}
.tray-music-btn {
@@ -839,6 +954,30 @@ onUnmounted(() => {
background: color-mix(in oklch, var(--primary) 22%, transparent);
}
/* 音量面板(点音量按钮后展开的第三行) */
.tray-music-volume {
display: flex;
align-items: center;
gap: 6px;
}
.tray-volume-slider {
flex: 1;
min-width: 0;
height: 18px;
cursor: pointer;
/* 用原生 range + accent-color:与主题同色,且天然支持键盘 / 无障碍 */
accent-color: var(--primary);
}
.tray-volume-value {
min-width: 26px;
text-align: right;
font-size: 10.5px;
color: var(--muted-foreground);
font-variant-numeric: tabular-nums;
}
.tray-item {
display: flex;
align-items: center;
+6 -3
View File
@@ -364,7 +364,10 @@ export const useDshStore = defineStore('dsh', () => {
try {
const existing = await WebviewWindow.getByLabel(label)
if (existing) {
await existing.setFocus()
// 强制置前走原生 SetForegroundWindow(`window_focus_window`):前端 setFocus 受
// Windows 前台锁定限制 —— 从托盘 / 全局快捷键触发时本进程可能不拥有前台,
// setFocus 会被静默忽略,表现为「窗口开着却唤不到前面」
await invoke('window_focus_window', { label })
return
}
// 远端页面拿不到 Tauri IPC(未登记 capability),因此保留系统装饰以便拖动与关闭
@@ -408,8 +411,8 @@ export const useDshStore = defineStore('dsh', () => {
const label = WINDOWS.dshWindow
const existing = await WebviewWindow.getByLabel(label)
if (existing) {
await existing.show().catch(() => {})
await existing.setFocus().catch(() => {})
// 同上:走原生强制置前,避免托盘 / 快捷键唤不出启动进度窗口
await invoke('window_focus_window', { label }).catch(() => {})
return
}
const win = new WebviewWindow(label, {
+170 -21
View File
@@ -87,6 +87,11 @@ export interface DocumentTab {
/** 光标所在行(1 起;用于会话恢复与大纲高亮) */
cursorLine: number
docRevision: number
/**
* 固定标签:批量关闭(其他 / 左 / 右 / 全部)与「关闭未修改」都会跳过它。
* 单个关闭(点 × 或「关闭当前文件」)仍然有效 —— 固定是防误关,不是不可关。
*/
pinned?: boolean
}
let tabSeq = 0
@@ -240,6 +245,17 @@ function buildTree(entries: LibraryEntry[]): LibraryTreeNode[] {
return roots
}
/**
* 一个文档是不是 Markdown(决定「编辑按钮 / 预览」这类依赖语法的能力是否开放)。
*
* 笔记天然是 Markdown;库外文件则看语言标签 —— 库内 `.md` 走笔记语义,
* 而「打开文件」或拖入的 `.md` 是 `kind: 'file'` + `languageLabel: 'Markdown'`
* (映射见 `editor/languages.ts` 的 `LOADERS`)。两者都应当有完整的 Markdown 能力。
*/
function isMarkdownDoc(kind: EditorKind, languageLabel: string): boolean {
return kind === 'note' || languageLabel === 'Markdown'
}
/** 当前是否运行在编辑器独立窗口里(hash 形如 `#editor-window?...`)。 */
function isEditorWindowContext(): boolean {
return window.location.hash.startsWith(`#${WINDOWS.editorWindow}`)
@@ -346,10 +362,16 @@ export const useEditorStore = defineStore('editor', {
*/
externalChange: null as NoteFileEvent | null,
/** 新建笔记的请求标记(全局快捷键触发时自增,主模块页据此打开对话框)。 */
newNoteRequest: 0,
/** 「打开编辑器」的请求标记(全局快捷键触发时自增)。 */
openEditorRequest: 0,
/**
* 全局快捷键「新建笔记」的**挂起请求**。
*
* App.vue(应用级)收到 `editor-new-note` 时置位并切到编辑器模块页,模块页挂载时
* 或已挂载时消费它打开新建对话框 —— 快捷键在任意模块下都要可用,不能只靠页内
* watch(未挂载时事件会丢)。
*
* 注:「打开编辑器窗口」(Alt+E)不用本 store 中转,由 App.vue 直接开窗。
*/
newNotePending: false,
/**
* 启动时命令行 / 资源管理器右键指定的待打开目标(冷启动)。
*
@@ -391,6 +413,10 @@ export const useEditorStore = defineStore('editor', {
hasDocument(state): boolean {
return state.kind === 'note' ? !!state.currentRelPath : state.kind === 'file'
},
/** 当前文档是不是 Markdown(笔记,或扩展名映射到 Markdown 的库外文件) */
isMarkdown(state): boolean {
return isMarkdownDoc(state.kind, state.languageLabel)
},
/**
* 当前文档字数(按非空白字符计)。
*
@@ -419,14 +445,36 @@ export const useEditorStore = defineStore('editor', {
recentFolders(state) {
return state.settings.recentFolders
},
/** 标签栏视图(活动标签的 dirty 用扁平值,保证指示点实时) */
tabViews(state): Array<{ id: string; name: string; kind: 'note' | 'file'; dirty: boolean }> {
return state.tabs.map(t => ({
id: t.id,
name: t.name,
kind: t.kind,
dirty: t.id === state.activeTabId ? state.dirty : t.dirty
}))
/**
* 标签栏视图(活动标签取扁平值,保证指示点与 md 标记实时)。
*
* `markdown` 决定标签上是否出现「预览」按钮:后台标签用切换时收回的
* `languageLabel`,活动标签用当前值(刚打开的 `.md` 语言是异步装配的,
* 只有活动标签的扁平 state 能反映最新结果)。
*/
tabViews(
state
): Array<{
id: string
name: string
kind: 'note' | 'file'
dirty: boolean
markdown: boolean
pinned: boolean
}> {
return state.tabs.map(t => {
const active = t.id === state.activeTabId
return {
id: t.id,
name: t.name,
kind: t.kind,
dirty: active ? state.dirty : t.dirty,
markdown: active
? isMarkdownDoc(state.kind, state.languageLabel)
: isMarkdownDoc(t.kind, t.languageLabel),
pinned: !!t.pinned
}
})
},
/** 是否有任何标签存在未保存改动(关闭窗口确认用) */
anyDirty(state): boolean {
@@ -457,6 +505,18 @@ export const useEditorStore = defineStore('editor', {
}
},
/** 全局快捷键「新建笔记」:置挂起请求(由 App.vue 在应用级调用)。 */
requestNewNote(): void {
this.newNotePending = true
},
/** 取走挂起的新建请求(有则清空并返回 true)。 */
consumeNewNote(): boolean {
if (!this.newNotePending) return false
this.newNotePending = false
return true
},
// ===== 库 =====
async refreshLibrary(): Promise<void> {
@@ -656,6 +716,102 @@ export const useEditorStore = defineStore('editor', {
this.resetDocument()
},
/**
* 批量关闭标签(按 id)。
*
* 脏数据确认由 UI 负责(与 `closeTab` 同一约定);这里逐个调用 `closeTab`,
* 活动标签被关掉时会自动落到相邻标签,全部关完则回到空态。
*/
closeTabsByIds(ids: string[]): void {
for (const id of ids) this.closeTab(id)
},
/** 关闭所有**未修改且未固定**的标签(脏数据确认无关:它们本来就没有改动)。 */
closeUnmodifiedTabs(): void {
const ids = this.tabs
.filter(t => !t.pinned && !(t.id === this.activeTabId ? this.dirty : t.dirty))
.map(t => t.id)
if (ids.length) this.closeTabsByIds(ids)
},
/** 固定 / 取消固定标签(批量关闭时跳过被固定的标签)。 */
setTabPinned(id: string, pinned: boolean): void {
const tab = this.tabs.find(t => t.id === id)
if (tab) tab.pinned = pinned
},
/** 把标签拖到目标下标(拖拽重排)。 */
moveTab(id: string, toIndex: number): void {
const from = this.tabs.findIndex(t => t.id === id)
if (from < 0) return
const to = Math.max(0, Math.min(toIndex, this.tabs.length - 1))
if (from === to) return
const [tab] = this.tabs.splice(from, 1)
this.tabs.splice(to, 0, tab)
},
/**
* 更新某个**非活动**标签的缓冲内容并置脏(并排副面板编辑用)。
*
* 活动标签的真值在扁平 state 上,不经过这里 —— 副面板永远绑定非活动标签。
*/
setTabContent(id: string, content: string): void {
const tab = this.tabs.find(t => t.id === id)
if (!tab) return
tab.content = content
tab.dirty = true
},
/**
* 保存指定标签自己的缓冲(并排副面板 / 「移动到新窗口」前落盘用)。
*
* 与 `saveCurrent` 的区别:后者保存的是扁平 state 上的活动文档;这里按标签自己的
* `relPath` / `fileDoc` 写盘,不影响活动文档。未修改时直接返回。
*/
async saveTab(id: string): Promise<void> {
const tab = this.tabs.find(t => t.id === id)
if (!tab || !tab.dirty) return
if (tab.kind === 'file') {
const doc = tab.fileDoc
if (!doc) return
if (doc.readonly) throw new Error('文件为只读,无法保存')
tab.fileDoc = await editorClient.writeFile(doc.path, tab.content, doc.encoding, doc.eol)
} else {
await editorClient.saveNote(tab.relPath, tab.content)
}
tab.dirty = false
},
/**
* 重命名某个已打开标签对应的磁盘文件,并同步标签 / 活动文档 / 最近记录。
*
* 笔记走**库内相对路径**重命名(顺带刷新库树,标签的 relPath 随之更新);
* 库外文件走**绝对路径**重命名。`newName` 含扩展名。
*/
async renameTab(id: string, newName: string): Promise<void> {
const name = newName.trim()
if (!name) return
const tab = this.tabs.find(t => t.id === id)
if (!tab) return
const active = id === this.activeTabId
if (tab.kind === 'note') {
const nextRel = await editorClient.renameEntry(tab.relPath, name)
const fileName = nextRel.split('/').pop() ?? name
tab.relPath = nextRel
tab.name = fileName.replace(/\.md$/i, '')
if (active) this.currentRelPath = nextRel
await this.refreshLibrary()
void this.recordRecentFile(this.noteAbsPath(nextRel), fileName)
} else {
const nextPath = await editorClient.renamePath(tab.path, name)
tab.path = nextPath
tab.name = name
if (tab.fileDoc) tab.fileDoc = { ...tab.fileDoc, path: nextPath, name }
if (active) this.fileDoc = tab.fileDoc
void this.recordRecentFile(nextPath, name)
}
},
// ===== 笔记文档 =====
async openNote(relPath: string, options?: { keepDirty?: boolean }): Promise<void> {
@@ -1398,13 +1554,8 @@ export const useEditorStore = defineStore('editor', {
const unSync = await listen<SyncProgress>(EVENTS.editorSyncProgress, event => {
this.syncProgress = event.payload
})
// 全局快捷键:Rust 只发事件,窗口与对话框都由前端决定
const unNewNote = await listen(EVENTS.editorNewNote, () => {
this.newNoteRequest += 1
})
const unOpenEditor = await listen(EVENTS.editorOpenEditor, () => {
this.openEditorRequest += 1
})
// 注:两个编辑器全局快捷键(Alt+E 打开编辑器 / Ctrl+Shift+N 新建笔记)都不在这里
// 监听 —— 由 App.vue 在应用级处理(快捷键要在任意模块下都能用,见那里的说明)。
// 「用 Thing 打开」(文件关联 / 命令行 / 资源管理器右键):
// 在编辑器窗口里就地打开;在主窗口里置 pending 交给模块页开一个新窗口
const routeOpen = (kind: 'file' | 'folder', path: string) => {
@@ -1427,8 +1578,6 @@ export const useEditorStore = defineStore('editor', {
unLibrary,
unFile,
unSync,
unNewNote,
unOpenEditor,
unOpenFile,
unOpenFolder
]
+22
View File
@@ -514,6 +514,8 @@ export const useFeiniuStore = defineStore('feiniu', () => {
void ensureCacheStatus()
// 系统媒体控件的按钮 → 播放器动作(原生 SMTC 事件,整个应用生命周期只订阅一次)
setupSmtcButtons()
// 托盘菜单调音量 / 静音 → 同步前端状态并落盘(同上只订阅一次)
setupTrayVolumeSync()
// 手机遥控选歌事件(同样只订阅一次)
setupRemoteJump()
// 引擎事件(播完 / 失败),同样只订阅一次
@@ -1761,10 +1763,30 @@ export const useFeiniuStore = defineStore('feiniu', () => {
// 系统面板的「停止」= 结束会话但保留队列(与停止按钮语义一致)
stopEngine()
break
// 托盘菜单的「播放顺序」按钮:三种模式循环(语义与标题栏按钮一致)
case 'toggle-mode':
togglePlayMode()
break
}
}).catch((e) => logger.error(`订阅系统媒体按钮事件失败: ${e}`))
}
/**
* 托盘菜单调音量 / 静音后回同步到前端。
*
* 托盘直接改的是 Rust 引擎(即时出声),这里只负责**更新反应式状态并落盘**,
* 不再回推引擎(避免把刚设好的值再发一次)。
*/
function setupTrayVolumeSync() {
void listen<{ volume: number; muted: boolean }>('tray-music-volume', (e) => {
const v = Number(e.payload?.volume)
if (!isFinite(v)) return
volume.value = Math.min(1, Math.max(0, v))
muted.value = !!e.payload?.muted
persistVolumeSoon()
}).catch((e) => logger.error(`订阅托盘音量事件失败: ${e}`))
}
// ===== 手机遥控:队列下发 + 选歌(Thing 专属) =====
/** 下发给手机的队列片段上限(完整队列可到 4000 条,手机端只展示当前附近一段) */
+50 -37
View File
@@ -327,12 +327,13 @@ export const useMonitorStore = defineStore('monitor', () => {
/** 是否已完成首次加载(避免初始 null/false 导致 UI 闪烁误导状态) */
const initialized = ref(false)
/** 提权标志是否已启用(后续启动自动触发 UAC) */
const elevateOnLaunch = ref(false)
/** "应用启动时自动启动监控内核"开关(持久化于后端 settings.json) */
const autoStart = ref(false)
/** "内核启动时以管理员权限运行(提权)"偏好(持久化于后端 settings.json)。
* 由"提权内核"操作自动开启,使提权状态在应用重启后的自动启动路径上保持。 */
const elevateOnStart = ref(false)
/** 硬件监控配置(可用硬件 + 传感器类型清单 + 当前启用状态) */
const hardwareConfig = ref<HardwareConfigResponse | null>(null)
@@ -544,46 +545,36 @@ export const useMonitorStore = defineStore('monitor', () => {
}
}
/** 提权:以管理员权限重启 Thing 自身,ThingHK 子进程会继承管理员权限。
* Thing 以管理员权限运行时,ProcessManager 可直接管控 ThingHK,崩溃自动重启。
* 非管理员时进程退出;已是管理员时仅设置标志并返回。 */
async function elevateSelf() {
/** 提权:仅以管理员权限重启 ThingHK 内核(弹 UAC),Thing 自身保持普通权限。
* 提权后的内核不归 ProcessManager 管(停止走内核 /shutdown 接口,崩溃不自动重启),
* 但可获得完整的 CPU 温度/时钟、存储 SMART、主板/电压等传感器。
* 提权成功后会记住提权偏好,应用重启后自动沿用(可在监控设置中关闭)。 */
async function elevateKernel() {
if (starting.value) return
starting.value = true
errorMsg.value = null
try {
await invoke('monitor_elevate_self')
// 命令返回说明已是管理员(非管理员时进程已 exit,不会走到这里)
await refreshElevateOnLaunch()
await invoke('monitor_start_elevated')
// 提权内核冷启动约 5s,轮询等待就绪后拉一次快照;
// 后端成功提权后会写入提权偏好,这里同步刷新开关状态(应用重启后沿用)
await refreshElevateOnStart()
await refreshStatus()
for (let i = 0; i < 20; i++) {
await new Promise(r => setTimeout(r, 500))
await refreshStatus()
if (status.value?.ready) {
await fetchSnapshot()
break
}
}
} catch (e) {
errorMsg.value = String(e)
logger.error('提权失败: ' + e)
logger.error('内核提权失败: ' + e)
} finally {
starting.value = false
}
}
/** 刷新提权标志状态 */
async function refreshElevateOnLaunch() {
try {
elevateOnLaunch.value = await invoke<boolean>('monitor_get_elevate_on_launch')
} catch (e) {
logger.error('获取提权标志失败: ' + e)
}
return elevateOnLaunch.value
}
/** 取消提权:清除标志,下次启动不再触发 UAC(当前会话权限不变) */
async function cancelElevation() {
try {
await invoke('monitor_set_elevate_on_launch', { enabled: false })
await refreshElevateOnLaunch()
} catch (e) {
errorMsg.value = String(e)
logger.error('取消提权失败: ' + e)
}
}
/** 刷新"自动启动监控内核"开关状态 */
async function refreshAutoStart() {
try {
@@ -635,6 +626,28 @@ export const useMonitorStore = defineStore('monitor', () => {
}
}
/** 刷新"内核启动时提权"偏好状态 */
async function refreshElevateOnStart() {
try {
elevateOnStart.value = await invoke<boolean>('monitor_get_elevate_on_start')
} catch (e) {
logger.error('获取提权偏好失败: ' + e)
}
return elevateOnStart.value
}
/** 设置"内核启动时提权"偏好(持久化):启用后内核启动以管理员权限运行(弹 UAC),
* Thing 自身保持普通权限;关闭后内核启动回到普通权限。 */
async function setElevateOnStart(enabled: boolean) {
try {
await invoke('monitor_set_elevate_on_start', { enabled })
elevateOnStart.value = enabled
} catch (e) {
errorMsg.value = String(e)
logger.error('设置提权偏好失败: ' + e)
}
}
/** 拉取硬件监控配置(可用硬件 + 传感器类型清单 + 当前启用状态) */
async function fetchHardwareConfig() {
try {
@@ -738,7 +751,7 @@ export const useMonitorStore = defineStore('monitor', () => {
try {
// 启动心跳,驱动 connState 的断线判定(SSE 断开后依赖不再变化,须有心跳触发重算)
startHeartbeat()
await Promise.all([refreshStatus(), refreshKernelInfo(), refreshElevateOnLaunch(), refreshAutoStart()])
await Promise.all([refreshStatus(), refreshKernelInfo(), refreshAutoStart(), refreshElevateOnStart()])
await subscribe()
// 若 Kernel 已就绪,立即拉一次快照避免 UI 空白
if (status.value?.ready) {
@@ -1304,8 +1317,8 @@ export const useMonitorStore = defineStore('monitor', () => {
stopping,
initialized,
networkSpeed,
elevateOnLaunch,
autoStart,
elevateOnStart,
hardwareConfig,
// getters
connState,
@@ -1315,12 +1328,12 @@ export const useMonitorStore = defineStore('monitor', () => {
findSensorValue,
refreshStatus,
refreshKernelInfo,
refreshElevateOnLaunch,
refreshAutoStart,
setAutoStart,
refreshElevateOnStart,
setElevateOnStart,
start,
elevateSelf,
cancelElevation,
elevateKernel,
fetchHardwareConfig,
saveHardwareConfig,
stop,
+6 -4
View File
@@ -268,10 +268,12 @@
--divider: #26262b;
--input: #2e2e34;
--foreground: #f5f5f7;
--fg-secondary: #a8a8b0;
--muted-foreground: #7a7a82;
--fg-disabled: #55555c;
/* 文字整体提亮:旧值(次 #A8A8B0 / 辅助 #7A7A82)偏灰,深底上图标与说明不够醒目。
主文字给纯白,次级 / 辅助仍留一点层次但都明显高于旧值。 */
--foreground: #ffffff;
--fg-secondary: #ececf2;
--muted-foreground: #d2d2da;
--fg-disabled: #9a9aa4;
--primary: #2997ff;
--primary-hover: #4aa8ff;
+17 -1
View File
@@ -128,6 +128,21 @@ export interface OpenTargetPayload {
kind: 'file' | 'folder'
}
/**
* 「在既有编辑器窗口里加一个标签」的请求负载(纯前端事件,主窗口 → 编辑器窗口)。
*
* 与 [`OpenTargetPayload`] 的差别是多了 `relPath`:库内笔记必须按**笔记语义**打开
* (相对路径 + front-matter + 双链等),而 `path` 是绝对路径,只能走库外文件语义。
*/
export interface EditorOpenTabPayload {
/** 库内笔记的相对库根路径(与 `path` 二选一) */
relPath?: string
/** 文件或目录的绝对路径 */
path?: string
/** `true` = 把 `path` 当目录打开(目录面板),否则当文件 */
folder?: boolean
}
/** 右键菜单注册状态(对应 Rust `ContextMenuStatus`) */
export interface ContextMenuStatus {
registered: boolean
@@ -326,6 +341,7 @@ export interface EditorSettings {
/** 自定义库根;`null` = 默认 `{appData}/editor/library` */
libraryRoot: string | null
editorTheme: EditorThemeId | string
/** 编辑器**窗口**是否跟随主应用主题(关:由 `editorTheme` 决定,窗口内外同一深浅) */
followAppTheme: boolean
fontFamily: string
fontSize: number
@@ -497,7 +513,7 @@ export function defaultEditorSettings(): EditorSettings {
version: 2,
libraryRoot: null,
editorTheme: 'system',
followAppTheme: true,
followAppTheme: false,
fontFamily: '',
fontSize: 14,
lineHeight: 1.7,