编辑调整、对比模块

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

No files matched your search

+2
View File
@@ -7714,7 +7714,9 @@ dependencies = [
"url",
"walkdir",
"windows 0.52.0",
"windows 0.62.2",
"windows-capture",
"windows-core 0.62.2",
"windows-sys 0.52.0",
"winreg 0.52.0",
"zip",
+20
View File
@@ -221,6 +221,26 @@ windows = { version = "0.52", features = [
"Win32_Graphics_Dxgi_Common",
"Win32_Graphics_Gdi",
] }
# 与 tauri / wry 同版本的 windows crate(**重命名**以便与上面项目自用的 0.52 并存;
# 同名不同版本不能写在同一个表里)。仅用于 editor/drag_drop.rs 实现 IDropTarget:
# 需要与 `WebviewWindow::hwnd()` 返回的 HWND 是同一个类型,才能直接对接。
windows62 = { package = "windows", version = "0.62", features = [
"Win32_Foundation",
"Win32_Graphics_Gdi",
"Win32_System_Com",
# 窗口级 AppUserModelID:PROPVARIANT 在 Com\StructuredStorage 下
"Win32_System_Com_StructuredStorage",
"Win32_System_Ole",
"Win32_System_SystemServices",
"Win32_UI_Shell",
# 窗口级 AUMID:SHGetPropertyStoreForWindow / IPropertyStore(Shell\PropertiesSystem)
"Win32_UI_Shell_PropertiesSystem",
"Win32_UI_WindowsAndMessaging",
# PKEY_AppUserModel_ID 常量声明在 Storage\EnhancedStorage 下
"Win32_Storage_EnhancedStorage",
] }
# `#[implement]` 宏展开出的代码按裸名引用 `windows_core`,因此必须直接依赖同名 crate。
windows-core = "0.62"
[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
tauri-plugin-autostart = "2"
+28
View File
@@ -0,0 +1,28 @@
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "diff-window",
"description": "Capability for the compare window (singleton, label = diff-window). Dual-pane merge view + folder tree — needs the editor window's control set (self-drawn title bar, mica/acrylic effects) plus drag & drop for setting either side from Explorer.",
"windows": ["diff-window"],
"permissions": [
"core:default",
"core:window:allow-show",
"core:window:allow-hide",
"core:window:allow-close",
"core:window:allow-minimize",
"core:window:allow-maximize",
"core:window:allow-toggle-maximize",
"core:window:allow-set-focus",
"core:window:allow-set-title",
"core:window:allow-start-dragging",
"core:window:allow-set-theme",
"core:window:allow-set-effects",
"core:window:allow-set-background-color",
"core:event:allow-listen",
"core:event:allow-emit",
"dialog:default",
"opener:default",
"opener:allow-open-path",
"opener:allow-reveal-item-in-dir",
"snap-layout:default"
]
}
+26 -2
View File
@@ -163,6 +163,30 @@ pub fn ensure_popup_window(app: &AppHandle) {
create_popup_window(app);
}
/// 把已显示的弹窗强制置前。
///
/// 只调 `set_focus` 不够:它内部是 `SetForegroundWindow`,受 Windows **前台锁定**限制 ——
/// 从别的应用按 Alt+V(本进程不拥有前台)时会被静默忽略,弹窗「出来了但拿不到焦点」,
/// 键盘导航 / 搜索都用不了。这里改用原生强制置前(模拟 Alt 释放重置前台锁定 +
/// SetForegroundWindow + BringWindowToTop),与快速面板 / 托盘 / 下载窗口同一套做法。
///
/// 调用前窗口应已 `show()`。置前失败(拿不到 hwnd)时退回普通 `set_focus`。
fn focus_force(win: &tauri::WebviewWindow) {
#[cfg(windows)]
{
match win.hwnd() {
Ok(hwnd) => crate::win32_util::force_foreground(hwnd.0 as isize),
Err(_) => {
let _ = win.set_focus();
}
}
}
#[cfg(not(windows))]
{
let _ = win.set_focus();
}
}
/// 在鼠标当前位置显示弹窗。
/// 窗口不存在则创建(隐藏状态,等前端挂载后调用 show_window 显示)。
/// 窗口已存在则移动到鼠标位置并显示。
@@ -200,7 +224,7 @@ pub fn show_popup(app: &AppHandle) {
}));
let _ = win.show();
mark_shown();
let _ = win.set_focus();
focus_force(&win);
// 通知前端刷新数据
let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
return;
@@ -232,7 +256,7 @@ pub fn show_window(app: &AppHandle) {
}
let _ = win.show();
mark_shown();
let _ = win.set_focus();
focus_force(&win);
// 通知前端刷新数据
let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
}
+10
View File
@@ -33,6 +33,9 @@ pub mod windows {
/// 服务就绪后由前端打开真正的 [`DSH_WEB`] 窗口并关闭它。
#[allow(dead_code)]
pub const DSH_WINDOW: &str = "dsh-window";
/// 对比工具独立窗口(单例,由前端创建)。
#[allow(dead_code)]
pub const DIFF_WINDOW: &str = "diff-window";
}
/// Tauri 事件名(与前端 constants::EVENTS 对应)
@@ -168,4 +171,11 @@ pub mod events {
// 笔记模块:需要打开一个**文件夹**(负载 `{ path }`)。
// 来源:资源管理器右键「用 Thing 编辑器打开」(目录 / 目录背景)。
pub const EDITOR_OPEN_FOLDER: &str = "editor-open-folder";
// 对比模块:全局快捷键按下「打开对比窗口」(无负载)。
// 窗口 label 策略与判重都在前端(它持有窗口),Rust 侧只负责注册快捷键。
pub const DIFF_OPEN_WINDOW: &str = "diff-open-window";
// 对比模块:目录扫描进度(负载见 diff::types::DiffScanProgress)。
// 进度在**发送端**按时间节流(见 diff::commands::diff_compare_dirs):整棵树可能有
// 上万个条目、上千次读盘,逐条 emit 会把 IPC 打满;前端只负责显示。
pub const DIFF_SCAN_PROGRESS: &str = "diff-scan-progress";
}
+207
View File
@@ -0,0 +1,207 @@
//! 对比模块的命令层。
//!
//! 三件事:读取一侧的文件、把一侧的内容写回、对比两棵目录树。文本级差异计算全在前端
//! (`@codemirror/merge`);目录级扫描在 [`super::scan`]。
//!
//! # 尺寸上限为什么要有两个
//!
//! - [`DIFF_LARGE_MB`]:**软**阈值。超过就置 `large`,前端据此关掉未变化段折叠等
//! 高开销特性 —— 文件照样完整读出来,只是更省。
//! - [`DIFF_HARD_LIMIT`]:**硬**上限。超过直接拒绝。对比窗口天生同时持有两侧内容
//! (不像编辑器只有一篇),单侧 16MB 已经是「两份都塞进 WebView + CM6 状态」的
//! 上限量级;再大不是「慢」而是「卡死」,早拒绝比让用户等一分钟再失败好。
use std::path::Path;
use std::time::{Duration, Instant};
use tauri::{AppHandle, Emitter, State};
use crate::editor::files;
use super::scan;
use super::types::{DiffFileDoc, DiffScanProgress, DiffSettings, DirDiffReport};
use super::DiffManager;
/// 「大文件」软阈值(MB)。与编辑器设置的默认值一致。
const DIFF_LARGE_MB: u32 = 5;
/// 硬上限(字节):单侧超过则拒绝读取。
const DIFF_HARD_LIMIT: u64 = 16 * 1024 * 1024;
/// 二进制探测的头部字节数。**与 `editor::grep` 的判据一致**(头部含 NUL 即二进制),
/// 否则会出现「搜索跳过了但对比工具显示了乱码」这种自相矛盾的行为。
const BINARY_SNIFF_BYTES: usize = 8 * 1024;
/// 打开文件并读出头部,同时判断是否二进制(头部含 NUL 字节)。
///
/// 返回**同一个已打开的句柄**(读位置停在头部之后)与那段头部:文本文件随后要靠这个
/// 句柄继续整读(见 `files::read_file_after_head`)—— 于是文件只被打开一次,也不会
/// 出现「嗅探时与整读时文件已被换掉」的窗口。二进制则到此为止,绝不整读。
fn open_with_head(path: &Path) -> Result<(std::fs::File, Vec<u8>, bool), String> {
use std::io::Read;
let mut file = std::fs::File::open(path).map_err(|e| format!("读取文件失败: {e}"))?;
let mut head = vec![0u8; BINARY_SNIFF_BYTES];
let read = file
.read(&mut head)
.map_err(|e| format!("读取文件失败: {e}"))?;
head.truncate(read);
let binary = head.contains(&0u8);
Ok((file, head, binary))
}
/// 写权限探测:以写模式打开但**不写入**(失败 → 只读)。
///
/// `editor::files` 里同名的函数是私有的(只服务编辑器自己的打开流程),这里重写一遍
/// 三行而不是把它提升为 `pub(crate)`:那个是模块内部细节,把它开放出去会让「谁在读
/// 权限探测」变得不清晰。
fn is_writable(path: &Path) -> bool {
std::fs::OpenOptions::new().write(true).open(path).is_ok()
}
/// 读取对比窗口某一侧的文件。
///
/// 复用 `editor::files::read_file`(编码探测 / 换行归一 / 只读探测),并顺带登记
/// 授权 —— 于是该文件随后可以被 [`diff_write_file`] 写回。
#[tauri::command]
#[specta::specta]
pub fn diff_read_file(path: String) -> Result<DiffFileDoc, String> {
let trimmed = path.trim();
if trimmed.is_empty() {
return Err("路径为空".to_string());
}
let p = Path::new(trimmed);
let meta = std::fs::metadata(p).map_err(|e| format!("读取文件信息失败: {e}"))?;
if meta.is_dir() {
return Err("这是一个目录 —— 请切到「文件夹」模式并把它设为某一侧".to_string());
}
if !meta.is_file() {
return Err("目标不是普通文件".to_string());
}
if meta.len() > DIFF_HARD_LIMIT {
return Err(format!(
"文件过大({} MB),超出对比窗口的 {} MB 上限",
meta.len() / (1024 * 1024),
DIFF_HARD_LIMIT / (1024 * 1024)
));
}
// 先读头部判断二进制(二进制到此为止、不整读),并把这段头部与**同一个句柄**
// 交给文本读取路径复用 —— 同一个文件全程只打开一次
let (file, head, binary) = open_with_head(p)?;
if binary {
return Ok(DiffFileDoc::binary_of(p, &meta, is_writable(p)));
}
let doc = files::read_file_after_head(file, p, &meta, &head, DIFF_LARGE_MB)?;
// 「打开过就能保存」:读取即登记授权(写回仍会再校验一次授权与写权限)
files::authorize(Path::new(&doc.path));
Ok(DiffFileDoc::from_file_doc(doc))
}
/// 把某一侧的内容写回磁盘。
///
/// `encoding` / `eol` 由前端回传**读取时探测到的值**,写回时原样还原 —— 一次「随手
/// 保存」不该把 GBK 文件变成 UTF-8、把 CRLF 变成 LF(那会在整个 diff 里掀起风暴)。
#[tauri::command]
#[specta::specta]
pub fn diff_write_file(
path: String,
content: String,
encoding: String,
eol: String,
) -> Result<DiffFileDoc, String> {
let doc = files::write_file(&path, &content, &encoding, &eol, DIFF_LARGE_MB)?;
Ok(DiffFileDoc::from_file_doc(doc))
}
/// 探测一个路径是文件还是目录(`"dir"` / `"file"` / `"missing"`)。
///
/// 用途:拖入或 `?path=` 传进来的路径前端拿不到文件系统元信息,而对比窗口需要据此
/// 决定「进文件模式还是目录模式」。**刻意不新增 Rust 侧的状态**:只读一次 `metadata`,
/// 不写盘、不需授权。
#[tauri::command]
#[specta::specta]
pub fn diff_path_kind(path: String) -> Result<String, String> {
let trimmed = path.trim();
if trimmed.is_empty() {
return Err("路径为空".to_string());
}
match std::fs::metadata(trimmed) {
Ok(meta) if meta.is_dir() => Ok("dir".to_string()),
Ok(meta) if meta.is_file() => Ok("file".to_string()),
Ok(_) => Ok("missing".to_string()),
Err(_) => Ok("missing".to_string()),
}
}
/// 对比两棵目录树(只读)。
///
/// `skip_dirs` 是**目录名**清单(大小写不敏感):默认清单由前端给出(它是界面约定,
/// 用户能否修改是 UI 的事),后端只负责按它执行 —— 同 `editor::grep` 把默认跳过清单
/// 留在前端的取舍。
///
/// 走 `spawn_blocking`:两遍目录遍历 + 最多 2000 次读盘都是同步阻塞 IO,放在 Tauri
/// 命令线程上会占住它(范式同 `editor_search_in_path`)。
///
/// `scan_id` 由前端生成并随进度事件原样回传:进度事件是全局的,多选项卡并发扫描时
/// 前端据此只认自己那一轮(见 `constants::events::DIFF_SCAN_PROGRESS`)。
#[tauri::command]
#[specta::specta]
pub async fn diff_compare_dirs(
app: AppHandle,
scan_id: u64,
left: String,
right: String,
skip_dirs: Vec<String>,
compare_content: bool,
) -> Result<DirDiffReport, String> {
tauri::async_runtime::spawn_blocking(move || {
// 进度按**时间**节流(≥120ms 才发一条):整棵树可能有上万个条目、上千次读盘,
// 逐条 emit 会把 IPC 打满;而按条目数节流在「条目少但每个都很大」时又会太稀。
// 最后一条进度由前端在命令返回时清掉,不依赖这里补齐。
let mut last_emit = Instant::now();
let mut progress = |phase: scan::ScanPhase, done: u64, total: u64| {
if last_emit.elapsed() < Duration::from_millis(120) {
return;
}
last_emit = Instant::now();
let phase = match phase {
scan::ScanPhase::Walk => "scan",
scan::ScanPhase::Compare => "compare",
};
let payload = DiffScanProgress {
scan_id,
phase: phase.to_string(),
done,
total,
};
let _ = app.emit(crate::constants::events::DIFF_SCAN_PROGRESS, payload);
};
scan::compare_dirs(&left, &right, &skip_dirs, compare_content, &mut progress)
})
.await
.map_err(|e| format!("目录对比任务失败: {e}"))?
}
/// 读取对比模块设置。
#[tauri::command]
#[specta::specta]
pub fn diff_get_settings(state: State<'_, DiffManager>) -> DiffSettings {
state.load_settings()
}
/// 保存对比模块设置。
///
/// 保存后**就地重注册**全局快捷键(`register_shortcut` 会先注销本模块的旧键,因此
/// 「清空快捷键」也能通过传空串生效)—— 同 `editor_save_settings`。
#[tauri::command]
#[specta::specta]
pub fn diff_save_settings(
app: AppHandle,
state: State<'_, DiffManager>,
settings: DiffSettings,
) -> Result<DiffSettings, String> {
let mut next = settings;
next.heal();
state.save_settings(&next)?;
state.init_on_launch(&app);
Ok(next)
}
+149
View File
@@ -0,0 +1,149 @@
//! 对比模块(文本 / 文件 / 目录)。
//!
//! 架构位置:
//!
//! ```text
//! 主模块页(入口 / 进度) 独立窗口(双栏差异视图)
//! ↓ Tauri IPC ↓
//! commands.rs 命令层
//! ↓
//! types.rs(回传前端的 DTO,与前端 src/modules/diff/types.ts 对齐)
//! ↓
//! editor::files 文件读取与编码探测(**复用**,不重复实现)
//! ```
//!
//! # 为什么复用 `editor::files` 而不自己读文件
//!
//! 「读一个文本文件」在这里不是 `fs::read_to_string`:要探测 BOM / 严格 UTF-8 /
//! GB18030 / Shift_JIS,要让「读到的编码」与「写回的编码」成对(GBK 文件按 UTF-8
//! 存回去就是永久损坏),要统一换行风格并原样还原,还要探测只读。这些编辑器模块
//! 都已经做完并踩过坑(见 `editor/files.rs` 的模块注释),对比工具没有任何理由
//! 再实现一遍 —— 因此 `editor::files` 提升为 `pub(crate)`,本模块直接调用。
//!
//! # 授权模型沿用编辑器
//!
//! `editor::files` 的写操作要求路径在会话内被「用户显式选择过」(对话框 / 拖入 /
//! 命令行)。本模块在**读取时顺带登记授权**,于是「在对比窗口打开过就能保存」这条
//! 最符合直觉的规则自动成立,不需要前端再单独调用一次授权命令。
//!
//! # 当前进度
//!
//! P2 落地:单文件读取(`diff_read_file`)与写回(`diff_write_file`)。
//! P3 落地:目录对比(`diff_compare_dirs` / `diff_path_kind`,只读)。
//! 规划见 `doc/DIFF_MODULE_PLAN.md`。
mod commands;
mod scan;
mod types;
pub use commands::{
diff_compare_dirs, diff_get_settings, diff_path_kind, diff_read_file, diff_save_settings,
diff_write_file,
};
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use std::time::{Duration, Instant};
use types::DiffSettings;
/// 设置内存缓存有效期(与 ai / translate / terminal / editor 的 500ms 一致)。
const SETTINGS_CACHE_TTL: Duration = Duration::from_millis(500);
struct SettingsCache {
read_at: Instant,
settings: DiffSettings,
}
/// 对比模块管理器(Tauri State)。
///
/// 目前只承担一件事:设置的读写与全局快捷键注册。目标(左右文件 / 左右目录)**不在这里**
/// —— 它们是前端会话状态,Rust 侧不需要知道用户在比哪两个东西。
pub struct DiffManager {
/// 模块自身目录:`{app_data_dir}/diff`
module_dir: PathBuf,
cache: Mutex<Option<SettingsCache>>,
}
impl DiffManager {
pub fn new(app_data_dir: PathBuf) -> Self {
let module_dir = app_data_dir.join("diff");
let _ = std::fs::create_dir_all(&module_dir);
Self {
module_dir,
cache: Mutex::new(None),
}
}
fn settings_path(&self) -> PathBuf {
self.module_dir.join("settings.json")
}
/// 读取设置(带短时缓存;文件缺失回退默认值;自愈结果落盘)。
pub fn load_settings(&self) -> DiffSettings {
if let Ok(cache) = self.cache.lock() {
if let Some(entry) = cache.as_ref() {
if entry.read_at.elapsed() < SETTINGS_CACHE_TTL {
return entry.settings.clone();
}
}
}
let mut settings = std::fs::read_to_string(self.settings_path())
.ok()
.and_then(|s| serde_json::from_str::<DiffSettings>(&s).ok())
.unwrap_or_default();
let healed = settings.heal();
if let Ok(mut cache) = self.cache.lock() {
*cache = Some(SettingsCache {
read_at: Instant::now(),
settings: settings.clone(),
});
}
if healed {
if let Err(e) = self.save_settings(&settings) {
crate::logger::log_error("diff", &format!("设置自愈落盘失败: {e}"));
}
}
settings
}
/// 保存设置并刷新缓存。
pub fn save_settings(&self, settings: &DiffSettings) -> Result<(), String> {
let json = serde_json::to_string_pretty(settings)
.map_err(|e| format!("序列化对比设置失败: {e}"))?;
std::fs::write(self.settings_path(), json).map_err(|e| format!("写入对比设置失败: {e}"))?;
if let Ok(mut cache) = self.cache.lock() {
*cache = Some(SettingsCache {
read_at: Instant::now(),
settings: settings.clone(),
});
}
Ok(())
}
/// 启动时按设置注册「打开对比窗口」全局快捷键(默认 Alt+C)。
///
/// 失败只记日志:快捷键被别的应用占了不该阻断启动(同 editor / translate / terminal)。
/// 触发时**只发事件**:窗口 label 策略与判重都在前端(它持有窗口),Rust 侧不该操心。
pub fn init_on_launch(&self, app: &tauri::AppHandle) {
use tauri::Emitter;
let settings = self.load_settings();
let shortcut = settings.open_diff_shortcut.clone();
if let Err(e) =
crate::shortcut::register_shortcut(app, "diff-open-window", &shortcut, |app| {
if let Err(e) = app.emit(crate::constants::events::DIFF_OPEN_WINDOW, ()) {
crate::logger::log_warn("diff", &format!("发出打开对比窗口事件失败: {e}"));
}
})
{
crate::logger::log_warn("diff", &format!("注册「打开对比窗口」快捷键失败: {e}"));
}
}
/// 模块目录(保留给将来的诊断 / 导出用)。
#[allow(dead_code)]
pub fn module_dir(&self) -> &Path {
&self.module_dir
}
}
+313
View File
@@ -0,0 +1,313 @@
//! 目录对比:递归遍历两侧 + 三态分类(**只读**,本期不做写回)。
//!
//! # 为什么是三层判据,而不是逐字节比对
//!
//! 一个几万文件的目录树逐字节比对,等于把两边全读一遍 —— 慢且没必要。判据按代价递增:
//!
//! 1. **size 不同** → 直接判「不同」(两文件大小都不同,内容不可能相同,不必读盘);
//! 2. **两侧都是空文件** → 直接判「相同」(长度都是 0,内容必然相同;这一条必须显式判,
//! 否则「空文件 + 时间戳不同」会掉进下面「按时间戳判不同」的兜底,把两个空文件报成差异);
//! 3. **size 相同且 mtime 相同** → 判「相同」(各对比工具的通行快速路径);
//! 4. **size 相同但 mtime 不同** → 才读内容逐字节比对。
//!
//! 第 4 步有预算([`MAX_CONTENT_COMPARES`] 条数与 [`MAX_CONTENT_BYTES`] 单文件体积):
//! 超出后不再读盘,按时间戳归入「不同」并把 `content_compared` 置 false ——
//! 结论仍然是「不同」,但**明确标记它未经内容比对**,而不是给出一个看起来同样确定的答案。
//!
//! # 为什么返回扁平列表而不是树
//!
//! 递归类型在 specta 的 `Type` 派生下容易生成无穷展开的 TS 类型(`editor::types::LibraryEntry`
//! 的注释里踩过同一个坑)。这里同样返回扁平列表(`rel_path` 用 `/` 分隔),由前端组装成树。
//!
//! # 只读
//!
//! 本模块**不写任何文件**。目录写回(复制 / 镜像 / 双向同步)是另一个量级的工程
//! (冲突策略、部分失败回滚、覆盖确认),已与用户确认不在本期。
use std::cell::Cell;
use std::collections::{HashMap, HashSet};
use std::path::Path;
use std::time::{Instant, UNIX_EPOCH};
use walkdir::WalkDir;
use crate::editor::files::display_path;
use super::types::{DirDiffEntry, DirDiffReport, NodeInfo};
/// 单次对比最多回传的条目数(超出即截断并置 `truncated`)。
///
/// 取值权衡:条目是扁平 JSON,每条含两侧绝对路径,约 200 字节 —— 8000 条约 1.6MB 一次性
/// 走 IPC,是「还能接受」与「再大就该让用户缩小范围」的分界。
const MAX_ENTRIES: usize = 8000;
/// 最多读多少个文件的内容做逐字节比对(防止「上万文件大小相同、时间戳不同」时把盘读穿)。
const MAX_CONTENT_COMPARES: usize = 2000;
/// 单个文件超过这个体积就不读内容比对(按时间戳判定)。
const MAX_CONTENT_BYTES: u64 = 4 * 1024 * 1024;
/// 扫描阶段(进度事件用;事件名与负载见 [`super::types::DiffScanProgress`])。
#[derive(Clone, Copy, Debug)]
pub enum ScanPhase {
/// 遍历目录树(此时总数无从预知)
Walk,
/// 读内容逐字节核对(总数 = 预算上限)
Compare,
}
/// 一次遍历的产出。
struct Collected {
files: HashMap<String, NodeInfo>,
skipped_dirs: u32,
truncated: bool,
}
/// 把根路径解析成「存在的目录」的绝对路径。
fn resolve_root(raw: &str, label: &str) -> Result<std::path::PathBuf, String> {
let trimmed = raw.trim();
if trimmed.is_empty() {
return Err(format!("{label}目录为空"));
}
let path = Path::new(trimmed);
let meta = std::fs::metadata(path).map_err(|e| format!("读取{label}目录失败: {e}"))?;
if !meta.is_dir() {
return Err(format!("{label}不是目录(文件对比请用「文件 / 文本」模式)"));
}
// 规范化:统一成真实位置,避免两侧用不同写法指向同一目录(`C:\a\..\b` / 尾部斜杠)
std::fs::canonicalize(path).map_err(|e| format!("解析{label}目录失败: {e}"))
}
/// 递归收集一侧的全部条目。
///
/// **不跟随符号链接**(walkdir 默认):跟随会让「链接成的环」把遍历变成死循环。
///
/// 跳过清单用 `filter_entry` **真正剪枝**:walkdir 在返回一个目录条目的**同一次**
/// `next()` 里就已把该目录压进遍历栈(见 walkdir 的 `handle_entry`),因此仅对命中的
/// 目录条目 `continue` 并不会阻止继续下钻 —— 那会「跳过」得名不副实(构建目录的子项
/// 照样进结果),还把整棵构建目录白扫一遍。
fn collect(
root: &Path,
skip: &HashSet<String>,
progress: &mut dyn FnMut(ScanPhase, u64, u64),
) -> Collected {
let mut files: HashMap<String, NodeInfo> = HashMap::new();
let skipped = Cell::new(0u32);
let truncated = Cell::new(false);
let mut encountered: u64 = 0;
let walker = WalkDir::new(root)
.follow_links(false)
.into_iter()
.filter_entry(|entry| {
// 根自身永远放行:否则根的名字恰好命中清单时整棵树都没了
if entry.depth() == 0 {
return true;
}
if entry.file_type().is_dir() {
let name = entry.file_name().to_string_lossy().to_lowercase();
if skip.contains(&name) {
skipped.set(skipped.get() + 1);
return false; // 既不产出该目录,也不再下钻
}
}
true
});
for entry in walker {
if truncated.get() {
break;
}
let Ok(entry) = entry else { continue };
// 根自身不作为条目
if entry.depth() == 0 {
continue;
}
encountered += 1;
// 每 512 个条目报一次(真正的节流由命令层按时间做,见 `diff_compare_dirs`)
if encountered % 512 == 0 {
progress(ScanPhase::Walk, encountered, 0);
}
if files.len() >= MAX_ENTRIES {
truncated.set(true);
break;
}
let is_dir = entry.file_type().is_dir();
let name = entry.file_name().to_string_lossy().to_string();
let Ok(meta) = entry.metadata() else { continue };
let rel = entry
.path()
.strip_prefix(root)
.map(|p| p.to_string_lossy().replace('\\', "/"))
.unwrap_or_else(|_| name.clone());
files.insert(
rel,
NodeInfo {
is_dir,
size: if is_dir { 0 } else { meta.len() },
modified: meta
.modified()
.ok()
.and_then(|t| t.duration_since(UNIX_EPOCH).ok())
.map(|d| d.as_millis() as u64)
.unwrap_or(0),
path: display_path(entry.path()),
},
);
}
// 收尾再报一次:让「最后一截」不被 512 的步长吞掉
progress(ScanPhase::Walk, encountered, 0);
Collected {
files,
skipped_dirs: skipped.get(),
truncated: truncated.get(),
}
}
/// 两个文件的内容是否逐字节相同(只在「大小相同、时间戳不同」时才调用)。
///
/// 分块比较而不是把两个文件整体读进内存:单文件上限 [`MAX_CONTENT_BYTES`](4MB),
/// 整体读要一次性占两块 4MB;分块读的峰值只有缓冲区大小,遇到首个差异就能立刻返回。
fn same_content(left: &Path, right: &Path) -> Result<bool, std::io::Error> {
let mut a = std::io::BufReader::new(std::fs::File::open(left)?);
let mut b = std::io::BufReader::new(std::fs::File::open(right)?);
let mut buf_a = [0u8; 64 * 1024];
let mut buf_b = [0u8; 64 * 1024];
loop {
let n = read_full(&mut a, &mut buf_a)?;
let m = read_full(&mut b, &mut buf_b)?;
// 长度不同(含「一个先到 EOF」)即判不同
if n != m || buf_a[..n] != buf_b[..m] {
return Ok(false);
}
if n == 0 {
return Ok(true);
}
}
}
/// 把缓冲区读到满(除非到达 EOF)。
///
/// `Read::read` 允许短读,直接拿短读的字节数比较会误判「不同」,因此这里循环到读满。
fn read_full(reader: &mut impl std::io::Read, buf: &mut [u8]) -> Result<usize, std::io::Error> {
let mut filled = 0;
while filled < buf.len() {
let n = reader.read(&mut buf[filled..])?;
if n == 0 {
break;
}
filled += n;
}
Ok(filled)
}
/// 对比两棵目录树。
///
/// `skip_dirs` 由前端给出(大小写不敏感、按目录名匹配):默认清单是**界面约定**而不是
/// 后端常量 —— 用户能不能改这份清单是 UI 的事,后端只负责按它执行(同 `editor::grep`
/// 把默认清单留在前端的取舍)。
///
/// `progress` 是进度回调(阶段, 已完成, 总数):本函数只负责在关键节点调用它,
/// 事件名 / 节流 / 发给谁都在命令层决定(见 `super::commands`)。
pub fn compare_dirs(
left: &str,
right: &str,
skip_dirs: &[String],
compare_content: bool,
progress: &mut dyn FnMut(ScanPhase, u64, u64),
) -> Result<DirDiffReport, String> {
let started = Instant::now();
let left_root = resolve_root(left, "左侧")?;
let right_root = resolve_root(right, "右侧")?;
// 跳过清单归一成集合:命中的目录要在剪枝判定里按名做 O(1) 查表(清单有十几项、
// 目录数可达上万,逐个线性比对不值得)
let skip: HashSet<String> = skip_dirs
.iter()
.map(|s| s.trim().to_lowercase())
.filter(|s| !s.is_empty())
.collect();
let l = collect(&left_root, &skip, &mut *progress);
let r = collect(&right_root, &skip, &mut *progress);
// 两侧相对路径的并集,排序后输出(顺序稳定,前端组装树的观感才稳定)
let mut keys: Vec<&String> = l.files.keys().chain(r.files.keys()).collect();
keys.sort();
keys.dedup();
let mut entries: Vec<DirDiffEntry> = Vec::with_capacity(keys.len());
let mut content_budget = MAX_CONTENT_COMPARES;
let mut compared: u64 = 0;
for key in keys {
let left_node = l.files.get(key);
let right_node = r.files.get(key);
let is_dir = left_node.map(|n| n.is_dir).unwrap_or(false)
|| right_node.map(|n| n.is_dir).unwrap_or(false);
let mut content_compared = false;
let status: &str = match (left_node, right_node) {
(Some(_), None) => "left-only",
(None, Some(_)) => "right-only",
(Some(a), Some(b)) => {
if a.is_dir != b.is_dir {
// 同名但一侧是文件、另一侧是目录:无法比较内容,单独归类
"type-mismatch"
} else if a.is_dir {
// 目录本身没有内容,是否「相同」由它的子条目决定;前端按子树判断
"identical"
} else if a.size != b.size {
"different"
} else if a.size == 0 {
// 两侧都是空文件(上面的 size 不等已排除「单侧为空」):内容必然相同。
// 不单独判的话会掉进最后的兜底,按时间戳把两个空文件报成「不同」
"identical"
} else if a.modified == b.modified {
"identical"
} else if compare_content && content_budget > 0 && a.size <= MAX_CONTENT_BYTES {
content_budget -= 1;
content_compared = true;
compared += 1;
// 核对阶段是最慢的一段(每处都要读两个文件),进度最有价值
progress(ScanPhase::Compare, compared, MAX_CONTENT_COMPARES as u64);
match same_content(Path::new(&a.path), Path::new(&b.path)) {
Ok(true) => "identical",
Ok(false) => "different",
// 读失败(权限 / 竞态删除):按时间戳判定,不把错误伪装成结论
Err(_) => "different",
}
} else {
// 体积超限 / 预算用尽:按时间戳判定,标记未比对内容
"different"
}
}
(None, None) => unreachable!("key 来自两侧键的并集"),
};
entries.push(DirDiffEntry {
rel_path: key.clone(),
is_dir,
status: status.to_string(),
left_path: left_node.map(|n| n.path.clone()).unwrap_or_default(),
right_path: right_node.map(|n| n.path.clone()).unwrap_or_default(),
left_size: left_node.map(|n| n.size).unwrap_or(0),
right_size: right_node.map(|n| n.size).unwrap_or(0),
left_modified: left_node.map(|n| n.modified).unwrap_or(0),
right_modified: right_node.map(|n| n.modified).unwrap_or(0),
content_compared,
});
}
Ok(DirDiffReport {
left_root: display_path(&left_root),
right_root: display_path(&right_root),
entries,
truncated: l.truncated || r.truncated,
skipped_dirs: l.skipped_dirs + r.skipped_dirs,
elapsed_ms: started.elapsed().as_millis() as u64,
})
}
+206
View File
@@ -0,0 +1,206 @@
//! 对比模块的数据模型(回传前端的 DTO)。
//!
//! 与前端 `src/modules/diff/types.ts` 一一对应;新增字段两侧都要改。
use serde::{Deserialize, Serialize};
use specta::Type;
use std::fs::Metadata;
use std::path::Path;
use crate::editor::files::{display_path, FileDoc};
/// 设置结构版本号。字段增减时递增,由 [`DiffSettings::heal`] 推进。
pub const DIFF_SETTINGS_VERSION: u32 = 1;
/// 对比模块设置(持久化到 `{app_data_dir}/diff/settings.json`,范式同 editor / translate)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct DiffSettings {
pub version: u32,
/// 全局快捷键:打开 / 唤出对比窗口(空串 = 不注册)。
///
/// 走 `shortcut.rs` 的原子注册 + 冲突检测(与终端 / 翻译 / 编辑器同一套);触发时只发
/// `diff-open-window` 事件,窗口由前端创建 —— Rust 侧不持窗口 label 策略。
pub open_diff_shortcut: String,
/// 目录对比:默认是否比对内容(大小相同、时间戳不同时读文件逐字节比对)
pub compare_content: bool,
/// 目录对比:默认是否跳过常见构建目录
pub skip_build_dirs: bool,
}
impl Default for DiffSettings {
fn default() -> Self {
Self {
version: DIFF_SETTINGS_VERSION,
open_diff_shortcut: "Alt+C".to_string(),
compare_content: true,
skip_build_dirs: true,
}
}
}
impl DiffSettings {
/// 自愈:推进版本号(并在首次遇到旧配置时补上默认快捷键)。返回是否发生了变化。
///
/// 刻意**不**把空的 `open_diff_shortcut` 补回默认:空串是「用户主动清空快捷键」的
/// 合法表达,快捷键被静默改回来比不生效更让人困惑。只有版本号为 0(从未写过这份
/// 配置)时才补一次 Alt+C。
pub fn heal(&mut self) -> bool {
if self.version >= DIFF_SETTINGS_VERSION {
return false;
}
if self.version == 0 && self.open_diff_shortcut.is_empty() {
self.open_diff_shortcut = "Alt+C".to_string();
}
self.version = DIFF_SETTINGS_VERSION;
true
}
}
/// 对比窗口里**一侧**文件的状态。
///
/// 刻意不复用 `FileDoc`:对比窗口需要额外的 `binary` 标记(二进制文件不进入文本
/// diff,只报「不同」),而 `FileDoc` 是编辑器模块的对外契约,为对比工具加字段会
/// 把「谁需要什么」搅在一起。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DiffFileDoc {
/// 绝对路径(Windows 下已剥掉 `\\?\` 前缀)
pub path: String,
/// 显示名(文件名)
pub name: String,
/// 文本内容(换行已统一为 `\n`,写回时按 `eol` 还原)。二进制文件为空串
pub content: String,
/// 探测到的编码(`utf-8` / `utf-8-bom` / `gbk` / …)。二进制文件为空串
pub encoding: String,
/// 换行风格:"lf" | "crlf"。二进制文件为空串
pub eol: String,
/// 文件字节数
pub size: u64,
/// 最后修改时间(Unix 毫秒)
pub modified: u64,
/// 行数(二进制文件为 0)
pub lines: u64,
/// 是否超过「大文件」阈值(前端据此关掉折叠等高开销特性)
pub large: bool,
/// 是否只读(写权限探测失败)
pub readonly: bool,
/// 是否为二进制(头部含 NUL 字节):此类文件不渲染 diff
pub binary: bool,
}
impl DiffFileDoc {
/// 由编辑器的读取结果构造(文本文件路径)。
pub fn from_file_doc(doc: FileDoc) -> Self {
Self {
path: doc.path,
name: doc.name,
content: doc.content,
encoding: doc.encoding,
eol: doc.eol,
size: doc.size,
modified: doc.modified,
lines: doc.lines,
large: doc.large,
readonly: doc.readonly,
binary: false,
}
}
/// 二进制文件:**不读内容**(避免把无意义的字节解码成一大段乱码再走 IPC)。
pub fn binary_of(path: &Path, meta: &Metadata, readonly: bool) -> Self {
Self {
path: display_path(path),
name: path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default(),
content: String::new(),
encoding: String::new(),
eol: String::new(),
size: meta.len(),
modified: meta
.modified()
.ok()
.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
.map(|d| d.as_millis() as u64)
.unwrap_or(0),
lines: 0,
large: false,
readonly,
binary: true,
}
}
}
/// 遍历时一侧的一个条目(**内部结构**,不回传前端)。
pub struct NodeInfo {
pub is_dir: bool,
/// 目录为 0
pub size: u64,
/// 最后修改时间(Unix 毫秒)
pub modified: u64,
/// 绝对路径(回传前端用于「下钻到文件对比」)
pub path: String,
}
/// 目录对比中的一个条目(扁平列表,由前端组装成树)。
///
/// `status` 取值:`left-only` / `right-only` / `different` / `identical` / `type-mismatch`
/// (同名但一侧是文件、另一侧是目录)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DirDiffEntry {
/// 相对根的路径,`/` 分隔(前端据此组装树,显示名自己从最后一段取)
pub rel_path: String,
/// 是否目录(type-mismatch 时为 true)
pub is_dir: bool,
pub status: String,
/// 该侧的绝对路径;该侧不存在时为空串
pub left_path: String,
pub right_path: String,
/// 该侧字节数;不存在为 0
pub left_size: u64,
pub right_size: u64,
/// 该侧最后修改时间(Unix 毫秒);不存在为 0
pub left_modified: u64,
pub right_modified: u64,
/// 结论是否**由内容逐字节比对**得出。
///
/// false 表示「大小相同、时间戳不同」且未读内容(体积超限 / 预算用尽),
/// 此时 `different` 是**按时间戳**判定的 —— 界面要据此提示,不能与已确认的差异
/// 用同一种语气呈现。
pub content_compared: bool,
}
/// 目录对比的扫描进度(**事件负载**,不是命令返回值)。
///
/// 前端按 `scan_id` 过滤:进度事件是全局的(Rust 不区分选项卡),多选项卡并发扫描时
/// 只有属于本轮的那一份进度才该被采用。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DiffScanProgress {
/// 本轮扫描的标识(前端生成,随命令传入并原样回传)
pub scan_id: u64,
/// `scan` = 正在遍历目录;`compare` = 正在读内容逐字节核对
pub phase: String,
/// 已完成数(遍历 = 已过的条目数;核对 = 已比对的文件数)
pub done: u64,
/// 总数(遍历阶段无从预知,为 0;核对阶段为预算上限)
pub total: u64,
}
/// 一次目录对比的结果。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DirDiffReport {
pub left_root: String,
pub right_root: String,
pub entries: Vec<DirDiffEntry>,
/// 条目数达到上限、遍历被截断(界面提示用户缩小范围)
pub truncated: bool,
/// 按跳过清单略过的目录数
pub skipped_dirs: u32,
/// 扫描耗时(毫秒;状态栏显示)
pub elapsed_ms: u64,
}
+352
View File
@@ -0,0 +1,352 @@
//! 子窗口拖放「补注入」(仅 Windows 真正生效,其它平台是 no-op)。
//!
//! # 为什么需要这个模块
//!
//! wry 只在**创建 webview 的那一刻**枚举一次子窗口、给它们注入 OLE drop target
//! (见 wry `webview2/drag_drop.rs` 的 `DragDropController::new` 里那句
//! `EnumChildWindows`)。而 WebView2 的 `Chrome_WidgetWin_1` /
//! `Chrome_RenderWidgetHostHWND` 是**异步惰性创建**的:
//!
//! - 由 `tauri.conf.json` 在 setup 阶段创建的主窗口 —— 注入时这些子窗口已存在,正常;
//! - 运行时经 IPC 创建的窗口(编辑器 / 对比,`new WebviewWindow`)—— 注入时子窗口
//! 还没生出来,于是它们**永远没有 drop target**。表现就是:拖文件进去光标变成禁止
//! 符号,Tauri 原生拖放事件与 HTML5 `drop` 都不触发(实测两个窗口的 Win32 样式完全
//! 一致,差别只在 `OleDropTargetInterface` 落在哪些子窗口上)。
//!
//! # 做法
//!
//! 窗口创建后延迟重试,等 WebView2 子窗口出现,再照 wry 的同一手法
//! (`RevokeDragDrop` + `RegisterDragDrop`)给**顶层窗口及其全部后代**补注入自己的
//! `IDropTarget`;收到拖放后按 Tauri 原生拖放事件**同样的名字与载荷**发出
//! `tauri://drag-enter|over|drop|leave` —— 前端 `onDragDropEvent` 无需任何改动。
//!
//! **通用**:只对显式传入 label 的窗口生效,调用方传自己的窗口 label(目前是
//! 编辑器窗口与对比窗口),不碰主窗口。
use tauri::AppHandle;
/// 给指定窗口补注入拖放支持(Windows 专用;其它平台直接返回 `Ok`)。
#[tauri::command]
#[specta::specta]
pub fn window_attach_drag_drop(app: AppHandle, label: String) -> Result<(), String> {
#[cfg(windows)]
{
imp::spawn_attach(app, label);
Ok(())
}
#[cfg(not(windows))]
{
let _ = (app, label);
Ok(())
}
}
#[cfg(windows)]
mod imp {
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::ffi::OsString;
use std::os::windows::ffi::OsStringExt;
use std::sync::{mpsc, Mutex, OnceLock};
use std::time::Duration;
use tauri::{AppHandle, Emitter, EventTarget, Manager};
use windows62::core::{implement, Ref, BOOL};
use windows62::Win32::Foundation::{HWND, LPARAM, POINT, POINTL};
use windows62::Win32::Graphics::Gdi::ScreenToClient;
use windows62::Win32::System::Com::{IDataObject, DVASPECT_CONTENT, FORMATETC, TYMED_HGLOBAL};
use windows62::Win32::System::Ole::{
IDropTarget, IDropTarget_Impl, RegisterDragDrop, RevokeDragDrop, CF_HDROP, DROPEFFECT,
DROPEFFECT_COPY, DROPEFFECT_NONE,
};
use windows62::Win32::System::SystemServices::MODIFIERKEYS_FLAGS;
use windows62::Win32::UI::Shell::{DragFinish, DragQueryFileW, HDROP};
use windows62::Win32::UI::WindowsAndMessaging::{EnumChildWindows, GetClassNameW};
/// 重试节奏:WebView2 的渲染子窗口在窗口显示后才陆续出现,前几秒足以覆盖。
const RETRY_INTERVAL: Duration = Duration::from_millis(400);
/// 重试次数上限(400ms × 24 ≈ 10s,与前端窗口冷启动量级一致)。
const MAX_RETRY: u32 = 24;
/// 已注入的 drop target 集合。
///
/// `RegisterDragDrop` 只保存裸指针,**对象必须由我们保持存活**(同 wry 的
/// `DragDropController::drop_targets`)。接口对象是 STA 私有的、实际只在主线程
/// 访问,这里标 `Send`/`Sync` 仅为能放进全局表。
/// 字段本身从不读取:它的唯一作用是**持有引用**,让 `RegisterDragDrop`
/// 存下的裸指针在窗口存活期间始终有效。
struct TargetSet(#[allow(dead_code)] Vec<IDropTarget>);
unsafe impl Send for TargetSet {}
unsafe impl Sync for TargetSet {}
static INJECTED: OnceLock<Mutex<HashMap<String, TargetSet>>> = OnceLock::new();
fn injected() -> &'static Mutex<HashMap<String, TargetSet>> {
INJECTED.get_or_init(|| Mutex::new(HashMap::new()))
}
// EnumChildWindows 的回调只带 LPARAM,用线程局部变量收集最省事(回调同步执行)。
thread_local! {
static FOUND: RefCell<Vec<HWND>> = const { RefCell::new(Vec::new()) };
}
unsafe extern "system" fn collect_child(hwnd: HWND, _lparam: LPARAM) -> BOOL {
FOUND.with(|v| v.borrow_mut().push(hwnd));
BOOL(1)
}
/// 顶层窗口 + 全部后代(WebView2 的 `Chrome_*`、`WRY_WEBVIEW` 等都在其中)。
fn window_and_descendants(hwnd: HWND) -> Vec<HWND> {
FOUND.with(|v| v.borrow_mut().clear());
let _ = unsafe { EnumChildWindows(Some(hwnd), Some(collect_child), LPARAM(0)) };
let descendants: Vec<HWND> = FOUND.with(|v| v.borrow().clone());
let mut all = Vec::with_capacity(descendants.len() + 1);
all.push(hwnd);
all.extend(descendants);
all
}
fn class_name(hwnd: HWND) -> String {
let mut buf = [0u16; 128];
let len = unsafe { GetClassNameW(hwnd, &mut buf) }.max(0) as usize;
OsString::from_wide(&buf[..len.min(buf.len())])
.to_string_lossy()
.to_string()
}
/// 是否已经出现 WebView2 的**渲染**子窗口。
///
/// 判据用 `Chrome_RenderWidgetHostHWND`(Chromium 最后创建的那个),而不是
/// 「任意 `Chrome_*`」——`Chrome_WidgetWin_0` 出现得更早,用它当"就绪"会过早
/// 停止重试,导致真正的落点(RenderWidget)没有 drop target。
fn has_render_host(hwnds: &[HWND]) -> bool {
hwnds
.iter()
.any(|h| class_name(*h).contains("RenderWidgetHost"))
}
#[implement(IDropTarget)]
struct WindowDropTarget {
hwnd: HWND,
app: AppHandle,
label: String,
cursor_effect: Cell<DROPEFFECT>,
enter_valid: Cell<bool>,
}
impl WindowDropTarget {
fn emit(&self, event: &str, payload: serde_json::Value) {
if let Err(e) = self.app.emit_to(
EventTarget::AnyLabel {
label: self.label.clone(),
},
event,
payload,
) {
crate::logger::log_warn("drag-drop", &format!("发送拖放事件失败: {e}"));
}
}
/// 从 `IDataObject` 取 CF_HDROP 里的文件路径。
///
/// 同时把 `HDROP` 交回调用方:**只能在 `Drop` 里 `DragFinish`**,
/// `DragEnter`/`DragOver` 阶段释放会让后续拿不到数据。
unsafe fn collect_paths(data: Ref<'_, IDataObject>) -> Option<(HDROP, Vec<String>)> {
let format = FORMATETC {
cfFormat: CF_HDROP.0,
ptd: std::ptr::null_mut(),
dwAspect: DVASPECT_CONTENT.0,
lindex: -1,
tymed: TYMED_HGLOBAL.0 as u32,
};
let medium = data.as_ref()?.GetData(&format).ok()?;
let hdrop = HDROP(medium.u.hGlobal.0 as _);
let count = DragQueryFileW(hdrop, u32::MAX, None);
let mut paths = Vec::with_capacity(count as usize);
for index in 0..count {
let len = DragQueryFileW(hdrop, index, None) as usize;
let mut buf = vec![0u16; len + 1];
DragQueryFileW(hdrop, index, Some(&mut buf));
paths.push(OsString::from_wide(&buf[..len]).to_string_lossy().to_string());
}
Some((hdrop, paths))
}
/// 屏幕坐标 → 客户区坐标(与 wry 一致,前端拿到的是相对 webview 的位置)。
fn client_pos(&self, point: &POINTL) -> (i32, i32) {
let mut pt = POINT {
x: point.x,
y: point.y,
};
let _ = unsafe { ScreenToClient(self.hwnd, &mut pt) };
(pt.x, pt.y)
}
}
#[allow(non_snake_case)]
impl IDropTarget_Impl for WindowDropTarget_Impl {
fn DragEnter(
&self,
pDataObj: Ref<'_, IDataObject>,
_grfKeyState: MODIFIERKEYS_FLAGS,
pt: &POINTL,
pdwEffect: *mut DROPEFFECT,
) -> windows62::core::Result<()> {
let (x, y) = self.client_pos(pt);
let found = unsafe { WindowDropTarget::collect_paths(pDataObj) };
let valid = found.is_some();
self.enter_valid.set(valid);
if let Some((_hdrop, paths)) = found {
self.emit(
"tauri://drag-enter",
serde_json::json!({ "paths": paths, "position": { "x": x, "y": y } }),
);
}
let effect = if valid { DROPEFFECT_COPY } else { DROPEFFECT_NONE };
unsafe { *pdwEffect = effect };
self.cursor_effect.set(effect);
Ok(())
}
fn DragOver(
&self,
_grfKeyState: MODIFIERKEYS_FLAGS,
pt: &POINTL,
pdwEffect: *mut DROPEFFECT,
) -> windows62::core::Result<()> {
if self.enter_valid.get() {
let (x, y) = self.client_pos(pt);
self.emit(
"tauri://drag-over",
serde_json::json!({ "position": { "x": x, "y": y } }),
);
}
unsafe { *pdwEffect = self.cursor_effect.get() };
Ok(())
}
fn DragLeave(&self) -> windows62::core::Result<()> {
if self.enter_valid.get() {
self.emit("tauri://drag-leave", serde_json::json!(null));
}
Ok(())
}
fn Drop(
&self,
pDataObj: Ref<'_, IDataObject>,
_grfKeyState: MODIFIERKEYS_FLAGS,
pt: &POINTL,
pdwEffect: *mut DROPEFFECT,
) -> windows62::core::Result<()> {
if self.enter_valid.get() {
let (x, y) = self.client_pos(pt);
if let Some((hdrop, paths)) = unsafe { WindowDropTarget::collect_paths(pDataObj) } {
self.emit(
"tauri://drag-drop",
serde_json::json!({ "paths": paths, "position": { "x": x, "y": y } }),
);
unsafe { DragFinish(hdrop) };
}
}
unsafe { *pdwEffect = DROPEFFECT_COPY };
Ok(())
}
}
/// 在**主线程**给该窗口补注入(OLE/COM 必须在初始化过 OLE 的线程上操作)。
/// 返回 true 表示 WebView2 子窗口已就位,后续无需再扫。
fn inject_now(app: &AppHandle, label: &str) -> bool {
let Some(window) = app.get_webview_window(label) else {
crate::logger::log_warn("drag-drop", &format!("补注入:找不到窗口 {label}"));
return true;
};
let Ok(hwnd) = window.hwnd() else {
crate::logger::log_warn("drag-drop", &format!("补注入:取不到 hwnd({label})"));
return false;
};
let all = window_and_descendants(hwnd);
let ready = has_render_host(&all);
let mut targets = Vec::with_capacity(all.len());
let mut ok = 0usize;
let mut failed = 0usize;
for child in all {
let target: IDropTarget = WindowDropTarget {
hwnd: child,
app: app.clone(),
label: label.to_string(),
cursor_effect: Cell::new(DROPEFFECT_NONE),
enter_valid: Cell::new(false),
}
.into();
// 与 wry 同一手法:先撤销(把它早期注入的空壳换掉),再注册自己的
let _ = unsafe { RevokeDragDrop(child) };
match unsafe { RegisterDragDrop(child, &target) } {
Ok(()) => {
ok += 1;
targets.push(target);
}
Err(e) => {
failed += 1;
crate::logger::log_warn(
"editor",
&format!(
"补注入:RegisterDragDrop 失败 class={} err={e}",
class_name(child)
),
);
}
}
}
crate::logger::log_info(
"editor",
&format!("补注入:{label} 后代={} 成功={ok} 失败={failed} ready={ready}", targets.len() + failed),
);
if let Ok(mut map) = injected().lock() {
map.insert(label.to_string(), TargetSet(targets));
}
ready
}
/// 后台线程:等到窗口与子窗口都就位后注入;窗口提前关闭则放弃。
pub fn spawn_attach(app: AppHandle, label: String) {
crate::logger::log_info("drag-drop", &format!("补注入:收到请求 label={label}"));
std::thread::spawn(move || {
for _ in 0..MAX_RETRY {
std::thread::sleep(RETRY_INTERVAL);
if app.get_webview_window(&label).is_none() {
crate::logger::log_info("drag-drop", &format!("补注入:窗口已关闭,放弃 {label}"));
if let Ok(mut map) = injected().lock() {
map.remove(&label);
}
return;
}
let (tx, rx) = mpsc::channel::<bool>();
let app_main = app.clone();
let label_main = label.clone();
if let Err(e) = app.run_on_main_thread(move || {
let _ = tx.send(inject_now(&app_main, &label_main));
}) {
crate::logger::log_warn("drag-drop", &format!("补注入:run_on_main_thread 失败 {e}"));
return;
}
// 主线程执行完再决定是否继续(超时按"未就绪"处理)
if matches!(rx.recv_timeout(Duration::from_secs(2)), Ok(true)) {
crate::logger::log_info("drag-drop", &format!("拖放补注入完成:{label}"));
return;
}
}
crate::logger::log_warn("drag-drop", &format!("拖放补注入未完成(子窗口未就位):{label}"));
});
}
}
+39 -1
View File
@@ -26,6 +26,7 @@
//! 还是 CRLF,否则一次「随手保存」就会在整个 diff 里掀起风暴。
use std::collections::HashSet;
use std::fs::Metadata;
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use std::time::UNIX_EPOCH;
@@ -293,8 +294,45 @@ fn read_file_inner(
if !meta.is_file() {
return Err("目标不是普通文件".to_string());
}
let bytes = std::fs::read(p).map_err(|e| format!("读取文件失败: {e}"))?;
build_doc(p, &meta, bytes, max_mb, forced_encoding)
}
/// 读取文件,复用调用方**已经读过**的头部(不重开文件、也不重读开头)。
///
/// 用途是对比模块:它必须「先读头部判断二进制、是文本才整读」(二进制要尽早放弃,
/// 不能整读),若先自己嗅探再调 `read_file`,同一个文件会被打开两次、开头读两遍。
/// 这里让调用方把**同一个句柄**(读位置已停在 `head` 之后)连同那段头部一起递进来,
/// 于是全程只打开一次;也顺带消掉「嗅探时与整读时文件已被换掉」的那个窗口。
///
/// `meta` 同样由调用方传入(它刚读过一次 `metadata`,两边都省一次 stat)。
pub(crate) fn read_file_after_head(
mut reader: impl std::io::Read,
path: &Path,
meta: &Metadata,
head: &[u8],
max_mb: u32,
) -> Result<FileDoc, String> {
let mut bytes = Vec::with_capacity(head.len());
bytes.extend_from_slice(head);
reader
.read_to_end(&mut bytes)
.map_err(|e| format!("读取文件失败: {e}"))?;
build_doc(path, meta, bytes, max_mb, None)
}
/// 读取链路的公共尾部:由「磁盘字节 + 元信息」组装 [`FileDoc`]。
///
/// 两个调用方共用 —— [`read_file_inner`](自己整读)与 [`read_file_after_head`]
/// (头部由调用方提供)。把这段独立出来是为了让「字节从哪来」与「字节怎么解释」解耦,
/// 而不是让解码 / 换行 / 元信息这段逻辑出现两份。
fn build_doc(
p: &Path,
meta: &Metadata,
bytes: Vec<u8>,
max_mb: u32,
forced_encoding: Option<&str>,
) -> Result<FileDoc, String> {
let encoding = match forced_encoding {
Some(enc) if !enc.trim().is_empty() => {
let requested = enc.trim();
+1 -1
View File
@@ -33,7 +33,7 @@ mod backup;
mod commands;
mod dirs;
mod export;
mod files;
pub(crate) mod files;
mod grep;
mod import;
mod index;
+12 -3
View File
@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
use specta::Type;
/// 结构版本号。字段增减时递增,由 [`EditorSettings::heal`] 推进。
pub const EDITOR_SETTINGS_VERSION: u32 = 4;
pub const EDITOR_SETTINGS_VERSION: u32 = 5;
/// 最近文件 / 文件夹各自的保留上限(超出淘汰最旧)。
pub const RECENT_LIMIT: usize = 20;
@@ -188,7 +188,8 @@ pub struct EditorSettings {
pub library_root: Option<String>,
/// 编辑器配色方案 key(`"system"` / `"vscode-dark"` / `"vscode-light"` / …)
pub editor_theme: String,
/// 编辑器配色是否跟随应用深浅(`editor_theme` 仅作取色基准)
/// 编辑器**窗口**是否跟随主应用主题(开:整体跟随应用;关:由 `editor_theme` 决定,
/// 窗口外壳与编辑区保持同一深浅)
pub follow_app_theme: bool,
/// 编辑器字体族(空串 = 用内置等宽字体栈)
pub font_family: String,
@@ -244,7 +245,7 @@ impl Default for EditorSettings {
version: EDITOR_SETTINGS_VERSION,
library_root: None,
editor_theme: "system".to_string(),
follow_app_theme: true,
follow_app_theme: false,
font_family: String::new(),
font_size: 14,
line_height: 1.7,
@@ -328,6 +329,14 @@ impl EditorSettings {
changed = true;
}
// v5:`followAppTheme` 的语义从「配色方案取色基准」改为「编辑器窗口是否跟随主应用
// 主题」,默认亦由「跟随」改为「不跟随」。仍是 true 说明用户从未改过这个值(旧默认),
// 此时改为不跟随;用户显式关过(false)的保持 false,不做任何覆盖。
if self.version < 5 && self.follow_app_theme {
self.follow_app_theme = false;
changed = true;
}
if self.version < EDITOR_SETTINGS_VERSION {
self.version = EDITOR_SETTINGS_VERSION;
changed = true;
+42 -6
View File
@@ -3,7 +3,9 @@ use tauri::Manager;
mod ai;
mod clipboard;
mod constants;
mod diff;
mod download_engine;
mod drag_drop;
mod dsh;
mod logger;
mod mihomo_manager;
@@ -19,6 +21,7 @@ mod secrets;
mod setup;
mod shortcut;
mod snap_fix;
mod taskbar_identity;
mod terminal;
mod translate;
mod tray_menu;
@@ -53,6 +56,11 @@ use editor::{
editor_move_path, editor_search_in_path, editor_replace_in_path,
editor_context_menu_status, editor_register_context_menu, editor_unregister_context_menu,
};
use diff::{
diff_compare_dirs, diff_get_settings, diff_path_kind, diff_read_file, diff_save_settings,
diff_write_file,
};
use drag_drop::window_attach_drag_drop;
use mihomo_manager::{
proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_connections, proxy_get_proxies, proxy_get_settings, proxy_get_system_proxy,
@@ -61,9 +69,9 @@ use mihomo_manager::{
proxy_test_delay, proxy_update_profile, proxy_version, MihomoManager,
};
use monitor_kernel::{
monitor_elevate_self, monitor_get_auto_start, monitor_get_elevate_on_launch,
monitor_get_auto_start, monitor_get_elevate_on_start,
monitor_get_hardware_config, monitor_get_snapshot, monitor_get_status, monitor_kernel_info,
monitor_repair_pawnio, monitor_set_auto_start, monitor_set_elevate_on_launch,
monitor_repair_pawnio, monitor_set_auto_start, monitor_set_elevate_on_start,
monitor_set_hardware_config, monitor_start, monitor_start_elevated, monitor_status, monitor_stop,
MonitorKernel,
};
@@ -185,6 +193,8 @@ use terminal::commands::{
terminal_ai_engines, terminal_ai_suggest,
};
use terminal::TerminalManager;
use taskbar_identity::window_set_taskbar_identity;
use win32_util::window_focus_window;
use translate::{
translate_abort, translate_ai_engine_remove, translate_ai_params_save, translate_apply_shortcuts,
translate_copy_text, translate_engine_delete, translate_engine_models, translate_engine_save,
@@ -361,6 +371,20 @@ fn export_bindings() {
editor_search_in_path, editor_replace_in_path,
// 系统集成(P4-4)
editor_context_menu_status, editor_register_context_menu, editor_unregister_context_menu,
// 编辑器窗口拖放补注入(Windows;wry 只在创建时扫一次子窗口,运行期创建的
// 编辑器窗口需要事后补注入才有 drop target)
window_attach_drag_drop,
// 对比模块:单文件读取 / 写回(编码探测复用 editor::files)+ 目录对比(只读)
diff_read_file,
diff_write_file,
diff_path_kind,
diff_compare_dirs,
diff_get_settings,
diff_save_settings,
// 子窗口任务栏身份(独立 AUMID + 组合图标)
window_set_taskbar_identity,
// 通用「显示 + 取消最小化 + 强制置前」(绕过 Windows 前台锁定)
window_focus_window,
])
.export(Typescript::default(), "../src/lib/bindings.ts")
.expect("failed to export bindings");
@@ -474,15 +498,14 @@ pub fn run() {
monitor_status,
monitor_start,
monitor_start_elevated,
monitor_elevate_self,
monitor_stop,
monitor_get_status,
monitor_repair_pawnio,
monitor_get_snapshot,
monitor_get_elevate_on_launch,
monitor_set_elevate_on_launch,
monitor_get_auto_start,
monitor_set_auto_start,
monitor_get_elevate_on_start,
monitor_set_elevate_on_start,
monitor_get_hardware_config,
monitor_set_hardware_config,
music_env_status,
@@ -883,7 +906,20 @@ pub fn run() {
// 系统集成(P4-4)
editor_context_menu_status,
editor_register_context_menu,
editor_unregister_context_menu
editor_unregister_context_menu,
// 编辑器窗口拖放补注入
window_attach_drag_drop,
// 对比模块:单文件读取 / 写回 + 目录对比(只读)+ 设置
diff_read_file,
diff_write_file,
diff_path_kind,
diff_compare_dirs,
diff_get_settings,
diff_save_settings,
// 子窗口任务栏身份(独立 AUMID + 组合图标)
window_set_taskbar_identity,
// 通用「显示 + 取消最小化 + 强制置前」
window_focus_window
])
.setup(setup::init)
.on_window_event(|window, event| {
+49 -115
View File
@@ -142,6 +142,10 @@ pub struct MonitorSettings {
/// 应用启动时自动启动监控内核(默认 false)
#[serde(default)]
pub auto_start: bool,
/// 启动内核时使用提权模式(通过 UAC 以管理员权限启动,Thing 自身保持普通权限)。
/// 由"提权内核"操作写入,使提权状态在应用重启后(自动启动路径)得以保持。
#[serde(default)]
pub elevate_on_start: bool,
}
/// 监控设置文件路径: {app_data_dir}/monitor/settings.json
@@ -167,59 +171,6 @@ pub fn save_monitor_settings(app_data_dir: &std::path::Path, settings: &MonitorS
fs::write(path, content).map_err(|e| format!("写入设置失败: {}", e))
}
// ===================== 永久提权标志持久化 =====================
/// 永久提权标志文件路径: {app_data_dir}/monitor/elevate.json
/// 内容: { "enabled": true }
fn elevate_flag_path(app_data_dir: &std::path::Path) -> PathBuf {
app_data_dir.join("monitor").join("elevate.json")
}
/// 读取永久提权标志
fn read_elevate_flag(flag_path: &std::path::Path) -> bool {
match fs::read_to_string(flag_path) {
Ok(content) => serde_json::from_str::<serde_json::Value>(&content)
.ok()
.and_then(|v| v.get("enabled").and_then(|e| e.as_bool()))
.unwrap_or(false),
Err(_) => false,
}
}
/// 写入永久提权标志
fn write_elevate_flag(flag_path: &std::path::Path, enabled: bool) -> Result<(), String> {
if let Some(parent) = flag_path.parent() {
fs::create_dir_all(parent).map_err(|e| format!("创建目录失败: {}", e))?;
}
let content = serde_json::json!({ "enabled": enabled }).to_string();
fs::write(flag_path, content).map_err(|e| format!("写入提权标志失败: {}", e))
}
/// 启动时检查永久提权标志,如果已设置且当前非管理员,则 ShellExecute "runas" 重启自身。
/// 在 `setup` 早期调用(MonitorKernel 初始化之前)。
/// 返回 true 表示已触发提权重启,调用方应立即退出当前进程。
pub fn check_and_relaunch_if_needed(app_data_dir: &std::path::Path) -> bool {
let flag_path = elevate_flag_path(app_data_dir);
if !read_elevate_flag(&flag_path) {
return false;
}
if is_thing_elevated() {
return false; // 已是管理员,无需重启
}
let exe = match std::env::current_exe() {
Ok(e) => e,
Err(_) => return false,
};
crate::logger::log_info("monitor", "检测到永久提权标志,以管理员权限重启 Thing");
match shell_execute_elevated(&exe.to_string_lossy(), "", None) {
Ok(()) => true,
Err(e) => {
crate::logger::log_warn("monitor", &format!("永久提权重启失败(用户可能取消了 UAC): {}", e));
false
}
}
}
// ===================== 数据结构 =====================
/// Kernel /status 响应(与 ThingHK Contracts.cs KernelStatus 对应)
@@ -322,16 +273,6 @@ impl MonitorKernel {
self.elevated.load(Ordering::SeqCst)
}
/// 永久提权标志是否已启用(后续启动自动触发 UAC)
pub fn elevate_on_launch(&self) -> bool {
read_elevate_flag(&self.root.join("elevate.json"))
}
/// 设置/清除永久提权标志
pub fn set_elevate_on_launch(&self, enabled: bool) -> Result<(), String> {
write_elevate_flag(&self.root.join("elevate.json"), enabled)
}
/// 读取监控设置(auto_start 等)
pub fn load_settings(&self) -> MonitorSettings {
load_monitor_settings(&self.root.parent().unwrap_or(&self.root).to_path_buf())
@@ -685,6 +626,10 @@ impl MonitorKernel {
/// - 如果是提权 Kernel(isAdmin=true):直接接管,设置 elevated=true,跳过 ProcessManager 启动
/// - 如果是普通权限 Kernel:调用 /shutdown 停止后重新启动
///
/// 提权偏好模式(Thing 普通、ThingHK 提权,elevateOnStart=true):
/// - 端口无内核运行时,走 start_elevated(ShellExecuteW "runas" 弹 UAC),
/// 使提权状态在应用重启后的自动启动路径上得以保持
///
/// 永久提权模式(Thing 自身是管理员):
/// - ThingHK 通过 ProcessManager 启动,子进程继承管理员权限
/// - 设置 elevated=true 表示 ThingHK 在管理员权限下运行
@@ -734,6 +679,21 @@ impl MonitorKernel {
}
}
// 提权偏好:Thing 自身非管理员时,按偏好以管理员权限启动内核(弹 UAC)。
// 偏好由 monitor_start_elevated 写入,使提权状态在应用重启后(自动启动)仍能保持。
if !thing_elevated && self.load_settings().elevate_on_start {
crate::logger::log_info("monitor", "按提权偏好启动 ThingHK 内核");
self.start_elevated(app).await?;
// 提权模式下内核不归 ProcessManager 管理,pid 不可查询
return Ok(crate::process_manager::ProcessInfo {
id: PROCESS_ID.into(),
name: "ThingHK".into(),
status: crate::process_manager::ProcessStatus::Running,
pid: None,
restart_count: 0,
});
}
let pm = app.state::<ProcessManager>();
let params = self.prepare_for_start(app)?;
let info = pm.start(params)?;
@@ -824,6 +784,14 @@ impl MonitorKernel {
}
self.elevated.store(true, Ordering::SeqCst);
// 记住提权偏好:后续启动(含应用重启后的自动启动)沿用提权模式
let mut settings = self.load_settings();
if !settings.elevate_on_start {
settings.elevate_on_start = true;
if let Err(e) = self.save_settings(&settings) {
crate::logger::log_warn("monitor", &format!("保存提权偏好失败: {}", e));
}
}
crate::logger::log_info("monitor", "提权启动已发起,等待 Kernel ready");
// 5. 启动 SSE 订阅(提权模式不注册 register_auto_reconnect:
@@ -961,40 +929,6 @@ pub async fn monitor_start_elevated(
state.start_elevated(&app).await
}
/// 永久提权:以管理员权限重启 Thing 自身,并持久化标志使后续启动自动提权。
/// - 已是管理员:仅设置标志,不重启
/// - 非管理员:设置标志 + ShellExecute "runas" 重启 + 退出当前进程
#[tauri::command]
pub async fn monitor_elevate_self(
state: tauri::State<'_, MonitorKernel>,
app: AppHandle,
) -> Result<(), String> {
#[cfg(windows)]
{
// 持久化标志:后续启动时 setup 检测到此标志会自动 ShellExecute "runas"
state.set_elevate_on_launch(true)?;
if is_thing_elevated() {
// 已是管理员,只需设置标志,无需重启
crate::logger::log_info("monitor", "Thing 已是管理员,仅设置永久提权标志");
return Ok(());
}
let exe = std::env::current_exe().map_err(|e| format!("获取当前路径失败: {}", e))?;
let exe_str = exe.to_string_lossy().to_string();
crate::logger::log_info("monitor", "永久提权:以管理员权限重启 Thing");
shell_execute_elevated(&exe_str, "", None)?;
// 退出当前进程(非提权),新的提权进程会接管
app.exit(0);
Ok(())
}
#[cfg(not(windows))]
{
let _ = (state, app);
Err("永久提权仅支持 Windows".into())
}
}
#[tauri::command]
pub async fn monitor_stop(
state: tauri::State<'_, MonitorKernel>,
@@ -1069,24 +1003,6 @@ pub async fn monitor_get_snapshot(state: tauri::State<'_, MonitorKernel>) -> Res
state.get_snapshot().await
}
/// 查询永久提权标志是否已启用
#[tauri::command]
pub fn monitor_get_elevate_on_launch(
state: tauri::State<'_, MonitorKernel>,
) -> bool {
state.elevate_on_launch()
}
/// 设置/清除永久提权标志。
/// 清除后,下次启动不再触发 UAC(当前会话权限不变)。
#[tauri::command]
pub fn monitor_set_elevate_on_launch(
state: tauri::State<'_, MonitorKernel>,
enabled: bool,
) -> Result<(), String> {
state.set_elevate_on_launch(enabled)
}
/// 查询"应用启动时自动启动监控内核"是否已启用
#[tauri::command]
pub fn monitor_get_auto_start(
@@ -1106,6 +1022,24 @@ pub fn monitor_set_auto_start(
state.save_settings(&settings)
}
/// 查询"内核启动时以管理员权限运行"(提权偏好)是否已启用
#[tauri::command]
pub fn monitor_get_elevate_on_start(state: tauri::State<'_, MonitorKernel>) -> bool {
state.load_settings().elevate_on_start
}
/// 设置提权偏好:启用后内核启动(含应用重启后的自动启动)将以管理员权限运行(弹 UAC)。
/// 由"提权内核"操作自动开启;关闭后内核启动回到普通权限。
#[tauri::command]
pub fn monitor_set_elevate_on_start(
state: tauri::State<'_, MonitorKernel>,
enabled: bool,
) -> Result<(), String> {
let mut settings = state.load_settings();
settings.elevate_on_start = enabled;
state.save_settings(&settings)
}
/// 查询硬件监控配置(透传 Kernel GET /config/hardware)。
/// 返回当前配置 + 可用硬件/传感器类型清单,供前端 Dialog 渲染。
#[tauri::command]
+9
View File
@@ -224,6 +224,15 @@ impl AudioEngine {
}
}
/// 当前音量与静音位(0.0~1.0)。
/// 供托盘菜单读取显示;跨曲目沿用同一组值(切歌不重置)。
pub fn volume(&self) -> (f32, bool) {
(
f32::from_bits(self.volume.load(Ordering::Relaxed)),
self.muted.load(Ordering::Relaxed),
)
}
pub fn state(&self) -> AudioState {
let Some(s) = self.current() else {
return AudioState {
+9 -7
View File
@@ -18,13 +18,14 @@ use crate::ai::AiManager;
use crate::download_engine::{DownloadEngine, ExtensionServer};
use crate::logger::LogManager;
use crate::mihomo_manager::MihomoManager;
use crate::monitor_kernel::{MonitorKernel, check_and_relaunch_if_needed};
use crate::monitor_kernel::MonitorKernel;
use crate::music::MusicManager;
use crate::network_monitor::NetworkMonitor;
use crate::editor::EditorManager;
use crate::process_manager::{ProcessManager, start_monitoring_thread};
use crate::terminal::TerminalManager;
use crate::translate::TranslateManager;
use crate::diff::DiffManager;
/// 应用启动初始化入口(setup 闭包调用)。
/// 初始化顺序即依赖顺序:日志 → 数据目录 → 各管理器 → 托盘 → 进程监控 → 自动启动。
@@ -45,12 +46,6 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
.app_data_dir()
.unwrap_or_else(|_| std::path::PathBuf::from("."));
// 永久提权检查:如果标志已设置且当前非管理员,以管理员权限重启自身并退出
// 必须在所有模块初始化之前执行(此时无资源需要清理)
if check_and_relaunch_if_needed(&app_data_dir) {
std::process::exit(0);
}
// ===== 代理模块:MihomoManager =====
let mihomo = MihomoManager::new(app_data_dir.clone());
app.manage(mihomo);
@@ -99,6 +94,13 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
crate::editor::remember_pending_target(target);
}
// ===== 对比模块:DiffManager =====
// 只承担设置的读写与「打开对比窗口」全局快捷键(默认 Alt+C)的注册;
// 左右目标(比哪两个文件 / 目录)是前端会话状态,Rust 侧不需要知道。
let diff = DiffManager::new(app_data_dir.clone());
diff.init_on_launch(app.handle());
app.manage(diff);
// ===== 翻译模块:TranslateManager =====
// 仅注册状态:设置与密钥都在命令调用时按需读取,启动阶段不发任何网络请求
// (模型可用性校验因此改为懒校验:首次翻译失败时解释原因 + 设置页手动拉取模型列表)。
+281
View File
@@ -0,0 +1,281 @@
//! 子窗口的「任务栏身份」:窗口级 AppUserModelID + 自定义窗口图标。
//!
//! # 为什么需要它
//!
//! 应用启动时用 [`crate::win32_util::set_app_user_model_id`] 设置了**进程级** AUMID
//! (`thing.lfeng.me`,与安装包写进开始菜单快捷方式的标识一致),好处是系统托盘/媒体面板
//! 能认出本应用;代价是 Windows 任务栏按 AUMID 分组 —— 编辑器、终端等**子窗口全都和主窗口
//! 合并成一个按钮、共用主程序图标**,最小化后根本分不清谁是谁。
//!
//! 本模块给子窗口做两件事:
//!
//! 1. **窗口级 AUMID**(`PKEY_AppUserModel_ID`,见 `win32_util::set_window_app_user_model_id`):
//! 覆盖进程级值 → 该窗口独立成组 → 任务栏多出一个自己的按钮;
//! 2. **自定义窗口图标**:底图是该窗口类型的功能图形(现在是「文档」代表编辑器),右下角
//! 叠加**主程序图标**,一眼能看出「这是 Thing 的哪个子窗口」。
//!
//! # 时机
//!
//! 必须在窗口**首次 `show()` 之前**调用:任务栏按钮在窗口显示时创建并按 AUMID 分组。
//! 编辑器窗口正是「隐藏创建 → 前端应用完主题再 show」,中间这段窗口期刚好可以设置。
//! 前端调用点见 `EditorWindow.vue`。
use tauri::Manager;
use crate::logger;
/// 主程序 AUMID(与开始菜单快捷方式 / Tauri identifier 一致);子窗口在其后缀派生。
const APP_AUMID: &str = "thing.lfeng.me";
/// 主程序图标 PNG(随二进制打包,保证与安装包图标一致)
const APP_ICON_PNG: &[u8] = include_bytes!("../icons/128x128.png");
/// 输出图标边长(任务栏会自行缩放到 16/32/48…,用大图更清晰)
const ICON_SIZE: u32 = 256;
/// 右下角主程序图标的边长
const BADGE_SIZE: u32 = 100;
/// 支持的窗口类型(同时作为 AUMID 后缀与图形选择键)。
/// 新增一类子窗口时:在此登记 + 在 [`draw_glyph`] / [`glyph_accent`] 加一个分支。
const SUPPORTED_KINDS: &[&str] = &["editor", "terminal", "files", "download", "dsh", "diff"];
/// 设置某个窗口的任务栏身份(独立 AUMID + 组合图标)。
///
/// 由窗口自身在 `show()` 之前调用(`label` 传自己的窗口 label)。
#[tauri::command]
#[specta::specta]
pub fn window_set_taskbar_identity(
app: tauri::AppHandle,
label: String,
kind: String,
) -> Result<(), String> {
let Some(window) = app.get_webview_window(&label) else {
return Err(format!("窗口不存在: {label}"));
};
if !SUPPORTED_KINDS.contains(&kind.as_str()) {
return Err(format!("不支持的窗口类型: {kind}"));
}
#[cfg(windows)]
{
let hwnd = window.hwnd().map_err(|e| format!("取窗口句柄失败: {e}"))?;
let aumid = format!("{APP_AUMID}.{kind}");
crate::win32_util::set_window_app_user_model_id(hwnd.0 as isize, &aumid)?;
}
let icon = compose_icon(&kind)?;
window.set_icon(icon).map_err(|e| format!("设置窗口图标失败: {e}"))?;
logger::log_info("window", &format!("任务栏身份已设置: {label} kind={kind}"));
Ok(())
}
/// 组合图标:功能图形铺底(圆角色块),右下角叠加主程序图标。
fn compose_icon(kind: &str) -> Result<tauri::image::Image<'static>, String> {
use image::{Rgba, RgbaImage};
let accent = glyph_accent(kind);
let pad = 10;
let radius = 56;
// 底:圆角色块(透明度即「可见区域」,最后据此裁剪,避免角标溢出圆角)
let mut base = RgbaImage::from_pixel(ICON_SIZE, ICON_SIZE, Rgba([0, 0, 0, 0]));
fill_rounded_rect(&mut base, pad, pad, ICON_SIZE - pad, ICON_SIZE - pad, radius, accent);
// 上层:功能图形 + 角标(先画在独立图层,最后按底色裁剪合成)
let mut layer = RgbaImage::from_pixel(ICON_SIZE, ICON_SIZE, Rgba([0, 0, 0, 0]));
draw_glyph(&mut layer, kind, accent);
let badge_from = ICON_SIZE - BADGE_SIZE - 14;
fill_rounded_rect(
&mut layer,
badge_from.saturating_sub(6),
badge_from.saturating_sub(6),
badge_from + BADGE_SIZE + 6,
badge_from + BADGE_SIZE + 6,
24,
Rgba([255, 255, 255, 255]),
);
let app_icon = image::load_from_memory(APP_ICON_PNG)
.map_err(|e| format!("解码主程序图标失败: {e}"))?
.to_rgba8();
let badge = image::imageops::resize(
&app_icon,
BADGE_SIZE,
BADGE_SIZE,
image::imageops::FilterType::Lanczos3,
);
image::imageops::overlay(&mut layer, &badge, badge_from as i64, badge_from as i64);
// 合成:底色不透明处才写入图层内容
let mut out = base.clone();
for (x, y, px) in layer.enumerate_pixels() {
if px.0[3] > 0 && base.get_pixel(x, y).0[3] > 0 {
blend_pixel(&mut out, x, y, *px);
}
}
Ok(tauri::image::Image::new_owned(out.into_raw(), ICON_SIZE, ICON_SIZE))
}
/// 各窗口类型的主色(圆角色块底色)。
fn glyph_accent(kind: &str) -> image::Rgba<u8> {
match kind {
// 终端:深板岩
"terminal" => image::Rgba([15, 23, 42, 255]),
// 文件管理:琥珀
"files" => image::Rgba([245, 158, 11, 255]),
// 下载:天蓝
"download" => image::Rgba([14, 165, 233, 255]),
// dsh:紫罗兰
"dsh" => image::Rgba([124, 58, 237, 255]),
// 对比:青碧(与下载的「天蓝」在缩略尺寸下仍可区分)
"diff" => image::Rgba([13, 148, 136, 255]),
// 编辑器(默认):靛蓝
_ => image::Rgba([79, 70, 229, 255]),
}
}
/// 画各窗口类型的功能图形(画在透明图层上,颜色自定)。
fn draw_glyph(img: &mut image::RgbaImage, kind: &str, accent: image::Rgba<u8>) {
use image::Rgba;
let white = Rgba([255, 255, 255, 255]);
match kind {
"terminal" => {
// 窗口主体 + 绿色标题栏 + 两行绿色提示符
let green = Rgba([34, 197, 94, 255]);
fill_rounded_rect(img, 58, 58, 198, 198, 20, white);
fill_rounded_rect(img, 58, 58, 198, 96, 20, green);
fill_rounded_rect(img, 58, 84, 198, 96, 0, green);
fill_rounded_rect(img, 84, 122, 176, 136, 7, green);
fill_rounded_rect(img, 84, 152, 146, 166, 7, green);
}
"files" => {
// 文件夹:左上标签 + 主体
fill_rounded_rect(img, 66, 62, 132, 96, 12, white);
fill_rounded_rect(img, 58, 84, 198, 198, 20, white);
}
"download" => {
// 向下箭头 + 托盘
fill_rounded_rect(img, 114, 56, 142, 132, 14, white);
fill_triangle(img, (128.0, 178.0), (82.0, 124.0), (174.0, 124.0), white);
fill_rounded_rect(img, 64, 150, 84, 198, 10, white);
fill_rounded_rect(img, 172, 150, 192, 198, 10, white);
fill_rounded_rect(img, 64, 178, 192, 198, 10, white);
}
"dsh" => {
// 嵌套方框:外壳 / 内层 / 核心 —— 「harness」容器
fill_rounded_rect(img, 58, 58, 198, 198, 26, white);
fill_rounded_rect(img, 84, 84, 172, 172, 18, accent);
fill_rounded_rect(img, 106, 106, 150, 150, 10, white);
}
"diff" => {
// 双栏:左右两块面板,中间留出底色的缝隙 —— 一眼读出「两边对照」
fill_rounded_rect(img, 56, 62, 122, 194, 16, white);
fill_rounded_rect(img, 134, 62, 200, 194, 16, white);
}
_ => {
// 编辑器:白色纸张 + 主色文字行(最后一行短一点,更像正文)
fill_rounded_rect(img, 70, 44, 186, 214, 16, white);
let rows = [(92u32, 168u32), (120, 168), (148, 168), (176, 142)];
for (y, right) in rows {
fill_rounded_rect(img, 94, y, right, y + 12, 6, accent);
}
}
}
}
/// 填充三角形(下载箭头的箭头部分;边缘符号法判定内外)。
fn fill_triangle(
img: &mut image::RgbaImage,
a: (f32, f32),
b: (f32, f32),
c: (f32, f32),
color: image::Rgba<u8>,
) {
let min_x = a.0.min(b.0).min(c.0).floor().max(0.0) as u32;
let max_x = a.0.max(b.0).max(c.0).ceil().min(img.width() as f32) as u32;
let min_y = a.1.min(b.1).min(c.1).floor().max(0.0) as u32;
let max_y = a.1.max(b.1).max(c.1).ceil().min(img.height() as f32) as u32;
let edge = |p: (f32, f32), q: (f32, f32), r: (f32, f32)| {
(q.0 - p.0) * (r.1 - p.1) - (q.1 - p.1) * (r.0 - p.0)
};
for y in min_y..max_y {
for x in min_x..max_x {
let p = (x as f32 + 0.5, y as f32 + 0.5);
let (d1, d2, d3) = (edge(a, b, p), edge(b, c, p), edge(c, a, p));
let has_neg = d1 < 0.0 || d2 < 0.0 || d3 < 0.0;
let has_pos = d1 > 0.0 || d2 > 0.0 || d3 > 0.0;
if !(has_neg && has_pos) {
blend_pixel(img, x, y, color);
}
}
}
}
/// 填充圆角矩形(硬边;任务栏缩放到小尺寸后看不出锯齿)。
fn fill_rounded_rect(
img: &mut image::RgbaImage,
x0: u32,
y0: u32,
x1: u32,
y1: u32,
radius: u32,
color: image::Rgba<u8>,
) {
if color.0[3] == 0 || x1 <= x0 || y1 <= y0 {
return;
}
let (fx0, fy0, fx1, fy1) = (x0 as f32, y0 as f32, x1 as f32, y1 as f32);
let r = (radius as f32).min((fx1 - fx0) / 2.0).min((fy1 - fy0) / 2.0);
for y in y0..y1 {
let fy = y as f32 + 0.5;
for x in x0..x1 {
let fx = x as f32 + 0.5;
let dx = if fx < fx0 + r {
fx0 + r - fx
} else if fx > fx1 - r {
fx - (fx1 - r)
} else {
0.0
};
let dy = if fy < fy0 + r {
fy0 + r - fy
} else if fy > fy1 - r {
fy - (fy1 - r)
} else {
0.0
};
if dx * dx + dy * dy <= r * r {
blend_pixel(img, x, y, color);
}
}
}
}
/// 把 `src` 以 alpha 混合写到 `img` 的 (x, y)(不做边界外的处理)。
fn blend_pixel(img: &mut image::RgbaImage, x: u32, y: u32, src: image::Rgba<u8>) {
if x >= img.width() || y >= img.height() {
return;
}
let sa = src.0[3] as u32;
if sa == 0 {
return;
}
if sa == 255 {
img.put_pixel(x, y, src);
return;
}
let dst = img.get_pixel(x, y).0;
let inv = 255 - sa;
let mix = |s: u8, d: u8| ((s as u32 * sa + d as u32 * inv) / 255) as u8;
img.put_pixel(
x,
y,
image::Rgba([
mix(src.0[0], dst[0]),
mix(src.0[1], dst[1]),
mix(src.0[2], dst[2]),
(sa + dst[3] as u32 * inv / 255) as u8,
]),
);
}
+57 -6
View File
@@ -64,6 +64,21 @@ pub struct MusicState {
pub playing: bool,
pub title: String,
pub artist: String,
/// 当前音量(0.0~1.0)
pub volume: f32,
pub muted: bool,
}
/// 托盘调音量 / 静音后广播给主窗口前端的权威值(前端据此更新 ref 并落盘)。
///
/// 为什么不走 [`SMTC_BUTTON_EVENT`]:那条通道是「无负载字符串动作」,音量要带数值。
pub const TRAY_MUSIC_VOLUME_EVENT: &str = "tray-music-volume";
#[derive(Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct TrayVolumeState {
pub volume: f32,
pub muted: bool,
}
fn get_music_state(app: &AppHandle) -> MusicState {
@@ -71,6 +86,11 @@ fn get_music_state(app: &AppHandle) -> MusicState {
.try_state::<AudioEngine>()
.map(|e| e.state().playing)
.unwrap_or(false);
// 音量/静音取自引擎:托盘拖动滑块直接改的就是它,这里读到的是真实生效值
let (volume, muted) = app
.try_state::<AudioEngine>()
.map(|e| e.volume())
.unwrap_or((1.0, false));
let (title, artist) = app
.try_state::<SmtcMetaCache>()
.and_then(|c| c.0.lock().ok().map(|g| (g.title.clone(), g.artist.clone())))
@@ -79,6 +99,8 @@ fn get_music_state(app: &AppHandle) -> MusicState {
playing,
title,
artist,
volume,
muted,
}
}
@@ -504,11 +526,35 @@ pub fn tray_music_state(app: AppHandle) -> MusicState {
/// 托盘音乐控制条动作。
///
/// 动作统一经 [`SMTC_BUTTON_EVENT`] 转给主窗口前端(`feiniuStore`)执行——
/// 队列、洗牌、单曲循环等播放语义都在前端,托盘只负责转发,不重复实现。
/// `action`:`toggle` | `play` | `pause` | `next` | `prev`。
/// 播放语义(队列、洗牌、单曲循环等)都在前端,托盘只负责转发:
/// - 播放/暂停/上下首/切换播放顺序 → [`SMTC_BUTTON_EVENT`] 转给主窗口前端(`feiniuStore`)执行;
/// - 音量与静音**直接改 Rust 侧引擎**(拖动滑块要即时出声,不能等一轮事件往返),
/// 改完把权威值经 [`TRAY_MUSIC_VOLUME_EVENT`] 广播给前端,由它更新 ref 并落盘。
///
/// `action`:`toggle` | `play` | `pause` | `next` | `prev` | `toggle-mode` | `volume` | `toggle-mute`。
/// `level`:仅 `volume` 需要(0.0~1.0)。
#[tauri::command]
pub fn tray_music_control(app: AppHandle, action: String) -> Result<(), String> {
pub fn tray_music_control(
app: AppHandle,
action: String,
level: Option<f32>,
) -> Result<(), String> {
if action == "volume" || action == "toggle-mute" {
let engine = app.try_state::<AudioEngine>().ok_or("播放引擎未初始化")?;
let (cur, muted) = engine.volume();
if action == "volume" {
let v = level.ok_or("volume 动作缺少 level")?.clamp(0.0, 1.0);
// 调到非零即解除静音(与手机遥控的音量语义一致)
engine.set_volume(v, if v > 0.0 { false } else { muted });
} else {
engine.set_volume(cur, !muted);
}
let (volume, muted) = engine.volume();
return app
.emit(TRAY_MUSIC_VOLUME_EVENT, TrayVolumeState { volume, muted })
.map_err(|e| e.to_string());
}
let name = match action.as_str() {
"play" => "play",
"pause" => "pause",
@@ -522,6 +568,8 @@ pub fn tray_music_control(app: AppHandle, action: String) -> Result<(), String>
}
"next" => "next",
"prev" => "prev",
// 播放顺序(列表循环 / 单曲循环 / 随机)由前端维护,这里只转发
"toggle-mode" => "toggle-mode",
other => return Err(format!("未知的音乐控制动作: {other}")),
};
app.emit(SMTC_BUTTON_EVENT, name).map_err(|e| e.to_string())
@@ -539,8 +587,11 @@ pub async fn tray_menu_ready(content_height: f64, app: AppHandle) -> Result<(),
layout.unwrap_or((0.0, 1040.0, 0.0, 1080.0, 1.0))
};
// 将内容高度限制在合理范围内(前端上报为逻辑像素)
let h = content_height.max(100.0).min(520.0);
// 可用高度:光标所在位置到屏幕顶部的空间(菜单底部对齐光标向上展开)。
// 不再用固定上限,内容多时窗口按内容完整撑开;仅当内容超过可用空间时才收窄
// (此时前端 .tray-menu-scroll 退化为滚动)。
let avail_logical = (cursor_y - scr_top).max(0.0) / scale;
let h = content_height.max(100.0).min(avail_logical.max(100.0));
// 调整窗口尺寸(物理像素,与物理坐标定位保持一致,避免混合 DPI 换算偏移)
let win_w_px = MENU_W * scale;
+62
View File
@@ -21,6 +21,41 @@ pub fn set_app_user_model_id(app_id: &str) {
}
}
/// 给**单个窗口**设置 AppUserModelID(窗口级 AUMID),使其在任务栏**独立成组**。
///
/// 进程级 AUMID(见 [`set_app_user_model_id`])会让整个应用的所有窗口合并成一个任务栏
/// 按钮;子窗口想要自己的按钮与图标,就用窗口级 AUMID 覆盖它 —— 任务栏按窗口的
/// `PKEY_AppUserModel_ID` 决定分组,不同值即不同按钮。
///
/// **必须在窗口首次 `show()` 之前调用**:任务栏按钮在窗口显示时创建并按 AUMID 分组,
/// 显示之后再改往往要 hide/show 才重新生效。
///
/// 本函数由 Tauri 同步命令调用(跑在主线程,COM 已由 WebView2 初始化为 STA),
/// 因此不再自行 `CoInitializeEx`。
#[cfg(windows)]
pub fn set_window_app_user_model_id(hwnd: isize, app_id: &str) -> Result<(), String> {
use windows62::Win32::Foundation::HWND;
use windows62::Win32::Storage::EnhancedStorage::PKEY_AppUserModel_ID;
use windows62::Win32::System::Com::StructuredStorage::PROPVARIANT;
use windows62::Win32::UI::Shell::PropertiesSystem::{IPropertyStore, SHGetPropertyStoreForWindow};
// SAFETY: hwnd 来自当前进程的真实窗口,且在调用期间保持有效;PROPVARIANT 由 &str 构造。
unsafe {
let store: IPropertyStore = SHGetPropertyStoreForWindow(HWND(hwnd as *mut core::ffi::c_void))
.map_err(|e| format!("SHGetPropertyStoreForWindow 失败: {e}"))?;
let value: PROPVARIANT = app_id.into();
store
.SetValue(&PKEY_AppUserModel_ID, &value)
.map_err(|e| format!("写入 PKEY_AppUserModel_ID 失败: {e}"))?;
}
Ok(())
}
#[cfg(not(windows))]
pub fn set_window_app_user_model_id(_hwnd: isize, _app_id: &str) -> Result<(), String> {
Err("窗口级 AUMID 仅支持 Windows".into())
}
/// 获取鼠标位置(屏幕坐标,物理像素)
#[cfg(windows)]
pub fn get_cursor_pos() -> Option<(i32, i32)> {
@@ -141,6 +176,33 @@ pub fn force_foreground(hwnd: isize) {
}
}
/// 显示 + 取消最小化 + 强制置前(按窗口 label 定位)。
///
/// 前端 `setFocus()` 在 Windows 上同样受前台锁定限制(本进程不拥有前台时被忽略),
/// 表现就是「窗口明明开着却唤不到前面」。这里统一走原生
/// [`force_foreground`](SetForegroundWindow + BringWindowToTop),与下载窗口 /
/// 快速面板 / 托盘同一套做法。
///
/// 窗口不存在时**不报错**(已关闭 = 目标已达成),让调用方少写一层判空。
#[tauri::command]
#[specta::specta]
pub fn window_focus_window(app: tauri::AppHandle, label: String) -> Result<(), String> {
use tauri::Manager;
let Some(window) = app.get_webview_window(&label) else {
return Ok(());
};
window.show().map_err(|e| e.to_string())?;
window.unminimize().map_err(|e| e.to_string())?;
match window.hwnd() {
Ok(hwnd) => force_foreground(hwnd.0 as isize),
Err(_) => {
window.set_focus().ok();
}
}
Ok(())
}
/// 应用 WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW 扩展样式到指定窗口。
/// 用于预览窗等不抢焦点的悬浮窗:窗口可接收鼠标交互但不激活、不进 Alt-Tab。
#[cfg(windows)]