From 6cfa74c901e186388b49835854316f501fbc92ad Mon Sep 17 00:00:00 2001 From: zhongluofeng Date: Fri, 16 Oct 2026 13:18:32 +0800 Subject: [PATCH] =?UTF-8?q?=E7=BC=96=E8=BE=91=E8=B0=83=E6=95=B4=E3=80=81?= =?UTF-8?q?=E5=AF=B9=E6=AF=94=E6=A8=A1=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ThingHK/ThingHK_GUIDE.md | 3 +- bun.lock | 3 + doc/DIFF_MODULE_PLAN.md | 349 +++++ doc/UI_DESIGN_SYSTEM.md | 8 +- package-lock.json | 14 + package.json | 1 + src-tauri/Cargo.lock | 2 + src-tauri/Cargo.toml | 20 + src-tauri/capabilities/diff-window.json | 28 + src-tauri/src/clipboard/popup.rs | 28 +- src-tauri/src/constants.rs | 10 + src-tauri/src/diff/commands.rs | 207 +++ src-tauri/src/diff/mod.rs | 149 ++ src-tauri/src/diff/scan.rs | 313 ++++ src-tauri/src/diff/types.rs | 206 +++ src-tauri/src/drag_drop.rs | 352 +++++ src-tauri/src/editor/files.rs | 40 +- src-tauri/src/editor/mod.rs | 2 +- src-tauri/src/editor/types.rs | 15 +- src-tauri/src/lib.rs | 48 +- src-tauri/src/monitor_kernel.rs | 164 +- src-tauri/src/music/audio/engine.rs | 9 + src-tauri/src/setup.rs | 16 +- src-tauri/src/taskbar_identity.rs | 281 ++++ src-tauri/src/tray_menu.rs | 63 +- src-tauri/src/win32_util.rs | 62 + src/App.vue | 30 + src/lib/bindings.ts | 161 +- src/lib/constants.ts | 18 + src/main.ts | 7 +- src/modules/devtools/DevToolsModule.vue | 2 +- src/modules/devtools/index.ts | 2 +- src/modules/devtools/tools/DiffTools.vue | 146 -- src/modules/devtools/tools/index.ts | 9 +- src/modules/diff/DiffModule.vue | 172 +++ src/modules/diff/DiffWindow.vue | 1319 +++++++++++++++++ src/modules/diff/components/DirDiffView.vue | 981 ++++++++++++ src/modules/diff/components/TextMergeView.vue | 1128 ++++++++++++++ src/modules/diff/diffClient.ts | 64 + src/modules/diff/index.ts | 39 + src/modules/diff/openWindow.ts | 84 ++ src/modules/diff/types.ts | 157 ++ src/modules/downloader/DownloadWindow.vue | 7 + src/modules/dsh/DshWindow.vue | 6 + src/modules/editor/EditorModule.vue | 122 +- src/modules/editor/EditorWindow.vue | 749 +++++++++- .../editor/components/DirectoryPanel.vue | 105 +- src/modules/editor/components/EditorHost.vue | 109 +- .../editor/components/EditorSearch.vue | 87 +- .../components/EditorSettingsDialog.vue | 420 ++++++ src/modules/editor/components/EditorTabs.vue | 610 +++++++- .../editor/components/EditorToolbar.vue | 40 +- src/modules/editor/components/QuickOpen.vue | 2 +- src/modules/editor/components/RecentPanel.vue | 27 +- .../editor/components/SearchHistoryInput.vue | 29 +- src/modules/editor/editor/batchMode.ts | 164 ++ src/modules/editor/editor/core.ts | 2 +- src/modules/editor/editor/keymap.ts | 66 + src/modules/editor/editor/languages.ts | 20 + .../editor/editor/markdownLivePreview.ts | 46 +- src/modules/editor/editor/themes.ts | 91 +- src/modules/editor/editorClient.ts | 27 +- src/modules/editor/openWindow.ts | 87 +- src/modules/icons.ts | 6 +- src/modules/index.ts | 4 +- src/modules/monitor/MonitorModule.vue | 72 +- src/modules/monitor/index.ts | 6 + src/modules/terminal/FileWindow.vue | 7 + src/modules/terminal/TerminalWindow.vue | 7 + src/modules/tray/TrayMenu.vue | 173 ++- src/stores/dshStore.ts | 9 +- src/stores/editorStore.ts | 191 ++- src/stores/feiniuStore.ts | 22 + src/stores/monitorStore.ts | 87 +- src/style.css | 10 +- src/types/editor.ts | 18 +- 76 files changed, 9514 insertions(+), 626 deletions(-) create mode 100644 doc/DIFF_MODULE_PLAN.md create mode 100644 src-tauri/capabilities/diff-window.json create mode 100644 src-tauri/src/diff/commands.rs create mode 100644 src-tauri/src/diff/mod.rs create mode 100644 src-tauri/src/diff/scan.rs create mode 100644 src-tauri/src/diff/types.rs create mode 100644 src-tauri/src/drag_drop.rs create mode 100644 src-tauri/src/taskbar_identity.rs delete mode 100644 src/modules/devtools/tools/DiffTools.vue create mode 100644 src/modules/diff/DiffModule.vue create mode 100644 src/modules/diff/DiffWindow.vue create mode 100644 src/modules/diff/components/DirDiffView.vue create mode 100644 src/modules/diff/components/TextMergeView.vue create mode 100644 src/modules/diff/diffClient.ts create mode 100644 src/modules/diff/index.ts create mode 100644 src/modules/diff/openWindow.ts create mode 100644 src/modules/diff/types.ts create mode 100644 src/modules/editor/components/EditorSettingsDialog.vue create mode 100644 src/modules/editor/editor/batchMode.ts diff --git a/ThingHK/ThingHK_GUIDE.md b/ThingHK/ThingHK_GUIDE.md index 1809a08..52f18f6 100644 --- a/ThingHK/ThingHK_GUIDE.md +++ b/ThingHK/ThingHK_GUIDE.md @@ -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 接口 diff --git a/bun.lock b/bun.lock index d12d128..dd099f7 100644 --- a/bun.lock +++ b/bun.lock @@ -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=="], diff --git a/doc/DIFF_MODULE_PLAN.md b/doc/DIFF_MODULE_PLAN.md new file mode 100644 index 0000000..852de90 --- /dev/null +++ b/doc/DIFF_MODULE_PLAN.md @@ -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)会让对齐与渲染变慢 | 阈值降级 + 明确提示,不做静默失败 | diff --git a/doc/UI_DESIGN_SYSTEM.md b/doc/UI_DESIGN_SYSTEM.md index ec7c770..72346d6 100644 --- a/doc/UI_DESIGN_SYSTEM.md +++ b/doc/UI_DESIGN_SYSTEM.md @@ -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; diff --git a/package-lock.json b/package-lock.json index 218c879..c0e4d06 100644 --- a/package-lock.json +++ b/package-lock.json @@ -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", diff --git a/package.json b/package.json index c44b07b..c23623c 100644 --- a/package.json +++ b/package.json @@ -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", diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock index bf8a8d2..887d9de 100644 --- a/src-tauri/Cargo.lock +++ b/src-tauri/Cargo.lock @@ -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", diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml index 5c7ef11..82a6bb3 100644 --- a/src-tauri/Cargo.toml +++ b/src-tauri/Cargo.toml @@ -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" diff --git a/src-tauri/capabilities/diff-window.json b/src-tauri/capabilities/diff-window.json new file mode 100644 index 0000000..26d8ad7 --- /dev/null +++ b/src-tauri/capabilities/diff-window.json @@ -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" + ] +} diff --git a/src-tauri/src/clipboard/popup.rs b/src-tauri/src/clipboard/popup.rs index 9f40625..090f888 100644 --- a/src-tauri/src/clipboard/popup.rs +++ b/src-tauri/src/clipboard/popup.rs @@ -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, ()); } diff --git a/src-tauri/src/constants.rs b/src-tauri/src/constants.rs index a4eb3dd..0ae55e8 100644 --- a/src-tauri/src/constants.rs +++ b/src-tauri/src/constants.rs @@ -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"; } diff --git a/src-tauri/src/diff/commands.rs b/src-tauri/src/diff/commands.rs new file mode 100644 index 0000000..ae85574 --- /dev/null +++ b/src-tauri/src/diff/commands.rs @@ -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, 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 { + 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 { + 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 { + 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, + compare_content: bool, +) -> Result { + 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 { + let mut next = settings; + next.heal(); + state.save_settings(&next)?; + state.init_on_launch(&app); + Ok(next) +} diff --git a/src-tauri/src/diff/mod.rs b/src-tauri/src/diff/mod.rs new file mode 100644 index 0000000..06dcb5a --- /dev/null +++ b/src-tauri/src/diff/mod.rs @@ -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>, +} + +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::(&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 + } +} diff --git a/src-tauri/src/diff/scan.rs b/src-tauri/src/diff/scan.rs new file mode 100644 index 0000000..38595b0 --- /dev/null +++ b/src-tauri/src/diff/scan.rs @@ -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, + skipped_dirs: u32, + truncated: bool, +} + +/// 把根路径解析成「存在的目录」的绝对路径。 +fn resolve_root(raw: &str, label: &str) -> Result { + 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, + progress: &mut dyn FnMut(ScanPhase, u64, u64), +) -> Collected { + let mut files: HashMap = 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 { + 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 { + 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 { + let started = Instant::now(); + let left_root = resolve_root(left, "左侧")?; + let right_root = resolve_root(right, "右侧")?; + + // 跳过清单归一成集合:命中的目录要在剪枝判定里按名做 O(1) 查表(清单有十几项、 + // 目录数可达上万,逐个线性比对不值得) + let skip: HashSet = 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 = 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, + }) +} diff --git a/src-tauri/src/diff/types.rs b/src-tauri/src/diff/types.rs new file mode 100644 index 0000000..1b556e7 --- /dev/null +++ b/src-tauri/src/diff/types.rs @@ -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, + /// 条目数达到上限、遍历被截断(界面提示用户缩小范围) + pub truncated: bool, + /// 按跳过清单略过的目录数 + pub skipped_dirs: u32, + /// 扫描耗时(毫秒;状态栏显示) + pub elapsed_ms: u64, +} diff --git a/src-tauri/src/drag_drop.rs b/src-tauri/src/drag_drop.rs new file mode 100644 index 0000000..d64bdde --- /dev/null +++ b/src-tauri/src/drag_drop.rs @@ -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); + unsafe impl Send for TargetSet {} + unsafe impl Sync for TargetSet {} + + static INJECTED: OnceLock>> = OnceLock::new(); + + fn injected() -> &'static Mutex> { + INJECTED.get_or_init(|| Mutex::new(HashMap::new())) + } + + // EnumChildWindows 的回调只带 LPARAM,用线程局部变量收集最省事(回调同步执行)。 + thread_local! { + static FOUND: RefCell> = 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 { + FOUND.with(|v| v.borrow_mut().clear()); + let _ = unsafe { EnumChildWindows(Some(hwnd), Some(collect_child), LPARAM(0)) }; + let descendants: Vec = 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, + enter_valid: Cell, + } + + 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)> { + 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::(); + 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}")); + }); + } +} \ No newline at end of file diff --git a/src-tauri/src/editor/files.rs b/src-tauri/src/editor/files.rs index ae48c91..7689492 100644 --- a/src-tauri/src/editor/files.rs +++ b/src-tauri/src/editor/files.rs @@ -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 { + 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, + max_mb: u32, + forced_encoding: Option<&str>, +) -> Result { let encoding = match forced_encoding { Some(enc) if !enc.trim().is_empty() => { let requested = enc.trim(); diff --git a/src-tauri/src/editor/mod.rs b/src-tauri/src/editor/mod.rs index b70f036..7400a79 100644 --- a/src-tauri/src/editor/mod.rs +++ b/src-tauri/src/editor/mod.rs @@ -33,7 +33,7 @@ mod backup; mod commands; mod dirs; mod export; -mod files; +pub(crate) mod files; mod grep; mod import; mod index; diff --git a/src-tauri/src/editor/types.rs b/src-tauri/src/editor/types.rs index fc423b3..edd5e05 100644 --- a/src-tauri/src/editor/types.rs +++ b/src-tauri/src/editor/types.rs @@ -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, /// 编辑器配色方案 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; diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index b1a0969..7b9f50d 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -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| { diff --git a/src-tauri/src/monitor_kernel.rs b/src-tauri/src/monitor_kernel.rs index 947c1fa..2196021 100644 --- a/src-tauri/src/monitor_kernel.rs +++ b/src-tauri/src/monitor_kernel.rs @@ -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::(&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::(); 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] diff --git a/src-tauri/src/music/audio/engine.rs b/src-tauri/src/music/audio/engine.rs index 271b882..dd3daa6 100644 --- a/src-tauri/src/music/audio/engine.rs +++ b/src-tauri/src/music/audio/engine.rs @@ -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 { diff --git a/src-tauri/src/setup.rs b/src-tauri/src/setup.rs index 46ad737..63c9a67 100644 --- a/src-tauri/src/setup.rs +++ b/src-tauri/src/setup.rs @@ -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) -> Result<(), Box> { .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) -> Result<(), Box> { 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 ===== // 仅注册状态:设置与密钥都在命令调用时按需读取,启动阶段不发任何网络请求 // (模型可用性校验因此改为懒校验:首次翻译失败时解释原因 + 设置页手动拉取模型列表)。 diff --git a/src-tauri/src/taskbar_identity.rs b/src-tauri/src/taskbar_identity.rs new file mode 100644 index 0000000..9bf03e8 --- /dev/null +++ b/src-tauri/src/taskbar_identity.rs @@ -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, 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 { + 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) { + 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, +) { + 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, +) { + 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) { + 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, + ]), + ); +} diff --git a/src-tauri/src/tray_menu.rs b/src-tauri/src/tray_menu.rs index eeeb74c..57d5d1f 100644 --- a/src-tauri/src/tray_menu.rs +++ b/src-tauri/src/tray_menu.rs @@ -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::() .map(|e| e.state().playing) .unwrap_or(false); + // 音量/静音取自引擎:托盘拖动滑块直接改的就是它,这里读到的是真实生效值 + let (volume, muted) = app + .try_state::() + .map(|e| e.volume()) + .unwrap_or((1.0, false)); let (title, artist) = app .try_state::() .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, +) -> Result<(), String> { + if action == "volume" || action == "toggle-mute" { + let engine = app.try_state::().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; diff --git a/src-tauri/src/win32_util.rs b/src-tauri/src/win32_util.rs index 8c0485f..b784cd3 100644 --- a/src-tauri/src/win32_util.rs +++ b/src-tauri/src/win32_util.rs @@ -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)] diff --git a/src/App.vue b/src/App.vue index 5da7ae8..2924fed 100644 --- a/src/App.vue +++ b/src/App.vue @@ -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, () => { diff --git a/src/lib/bindings.ts b/src/lib/bindings.ts index b8f0398..1eee23c 100644 --- a/src/lib/bindings.ts +++ b/src/lib/bindings.ts @@ -1117,6 +1117,70 @@ export const commands = { editorRegisterContextMenu: () => __TAURI_INVOKE("editor_register_context_menu"), /** 卸载右键菜单(删 HKCU 对应项)。 */ editorUnregisterContextMenu: () => __TAURI_INVOKE("editor_unregister_context_menu"), + /** 给指定窗口补注入拖放支持(Windows 专用;其它平台直接返回 `Ok`)。 */ + windowAttachDragDrop: (label: string) => __TAURI_INVOKE("window_attach_drag_drop", { label }), + /** + * 读取对比窗口某一侧的文件。 + * + * 复用 `editor::files::read_file`(编码探测 / 换行归一 / 只读探测),并顺带登记 + * 授权 —— 于是该文件随后可以被 [`diff_write_file`] 写回。 + */ + diffReadFile: (path: string) => __TAURI_INVOKE("diff_read_file", { path }), + /** + * 把某一侧的内容写回磁盘。 + * + * `encoding` / `eol` 由前端回传**读取时探测到的值**,写回时原样还原 —— 一次「随手 + * 保存」不该把 GBK 文件变成 UTF-8、把 CRLF 变成 LF(那会在整个 diff 里掀起风暴)。 + */ + diffWriteFile: (path: string, content: string, encoding: string, eol: string) => __TAURI_INVOKE("diff_write_file", { path, content, encoding, eol }), + /** + * 探测一个路径是文件还是目录(`"dir"` / `"file"` / `"missing"`)。 + * + * 用途:拖入或 `?path=` 传进来的路径前端拿不到文件系统元信息,而对比窗口需要据此 + * 决定「进文件模式还是目录模式」。**刻意不新增 Rust 侧的状态**:只读一次 `metadata`, + * 不写盘、不需授权。 + */ + diffPathKind: (path: string) => __TAURI_INVOKE("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("diff_compare_dirs", { scanId, left, right, skipDirs, compareContent }), + /** 读取对比模块设置。 */ + diffGetSettings: () => __TAURI_INVOKE("diff_get_settings"), + /** + * 保存对比模块设置。 + * + * 保存后**就地重注册**全局快捷键(`register_shortcut` 会先注销本模块的旧键,因此 + * 「清空快捷键」也能通过传空串生效)—— 同 `editor_save_settings`。 + */ + diffSaveSettings: (settings: DiffSettings) => __TAURI_INVOKE("diff_save_settings", { settings }), + /** + * 设置某个窗口的任务栏身份(独立 AUMID + 组合图标)。 + * + * 由窗口自身在 `show()` 之前调用(`label` 传自己的窗口 label)。 + */ + windowSetTaskbarIdentity: (label: string, kind: string) => __TAURI_INVOKE("window_set_taskbar_identity", { label, kind }), + /** + * 显示 + 取消最小化 + 强制置前(按窗口 label 定位)。 + * + * 前端 `setFocus()` 在 Windows 上同样受前台锁定限制(本进程不拥有前台时被忽略), + * 表现就是「窗口明明开着却唤不到前面」。这里统一走原生 + * [`force_foreground`](SetForegroundWindow + BringWindowToTop),与下载窗口 / + * 快速面板 / 托盘同一套做法。 + * + * 窗口不存在时**不报错**(已关闭 = 目标已达成),让调用方少写一层判空。 + */ + windowFocusWindow: (label: string) => __TAURI_INVOKE("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, diff --git a/src/lib/constants.ts b/src/lib/constants.ts index 271da31..9153dcd 100644 --- a/src/lib/constants.ts +++ b/src/lib/constants.ts @@ -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 存储键 */ diff --git a/src/main.ts b/src/main.ts index b81f870..69de90e 100644 --- a/src/main.ts +++ b/src/main.ts @@ -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 diff --git a/src/modules/devtools/DevToolsModule.vue b/src/modules/devtools/DevToolsModule.vue index bf10998..0121d82 100644 --- a/src/modules/devtools/DevToolsModule.vue +++ b/src/modules/devtools/DevToolsModule.vue @@ -89,7 +89,7 @@ watch(selectedId, () => { p-5 属于**滚动内容**(模块根在主滚动区内部),因此卡片阴影四周都有余量, 不再需要任何负外边距补偿。 - 工具自身需要限高的地方(正则结果、diff 输出等)仍保留各自的 `max-h-*` 内滚动 + 工具自身需要限高的地方(正则结果等)仍保留各自的 `max-h-*` 内滚动 盒子 —— 那是「一块有边界的输出区」,与页面级滚动不是一回事。 -->
diff --git a/src/modules/devtools/index.ts b/src/modules/devtools/index.ts index 51bba9c..c793ffb 100644 --- a/src/modules/devtools/index.ts +++ b/src/modules/devtools/index.ts @@ -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'), diff --git a/src/modules/devtools/tools/DiffTools.vue b/src/modules/devtools/tools/DiffTools.vue deleted file mode 100644 index 74e6465..0000000 --- a/src/modules/devtools/tools/DiffTools.vue +++ /dev/null @@ -1,146 +0,0 @@ - - -