//! 剪贴板快捷弹窗:在鼠标位置显示历史记录弹窗。 //! //! 流程: //! 1. 全局快捷键触发 → `show_popup` 在鼠标位置创建(隐藏)或显示窗口 //! 2. 前端 Vue 挂载完成、主题应用后调用 `clipboard_show_window` 显示窗口 //! 3. 前端监听 `clipboard-popup-show` 事件刷新数据 //! 4. 用户选择 → 前端调用 `clipboard_copy_back` 写回剪贴板 //! 5. 前端调用 `clipboard_paste_to_target` → 隐藏窗口 → 延迟模拟 Ctrl+V 粘贴 //! 6. 窗口失焦自动隐藏 use std::sync::Mutex; use std::sync::atomic::{AtomicBool, Ordering}; use std::time::{Duration, Instant}; use tauri::{AppHandle, Manager, WebviewUrl, WebviewWindowBuilder, Emitter}; use tauri::window::{Effect, EffectsBuilder}; /// 弹窗窗口标签 pub const POPUP_LABEL: &str = "clipboard-popup"; /// 预览窗口标签(悬停/键盘选中条目时在弹窗旁显示内容) pub const PREVIEW_LABEL: &str = "clipboard-preview"; /// 预览窗口初始逻辑尺寸(后续由前端按内容自适应调整,见 resize_preview) const PREVIEW_W: f64 = 340.0; const PREVIEW_H: f64 = 300.0; /// 预览窗口最小逻辑尺寸(防止内容过小时窗口退化) const PREVIEW_MIN_W: f64 = 240.0; const PREVIEW_MIN_H: f64 = 160.0; /// 弹窗与预览窗之间的可视间距(逻辑像素,左右对称) const PREVIEW_GAP: f64 = 12.0; /// 标志:show_popup 兜底创建路径设为 true,前端 onMounted 回调 show_window 时据此判断是否显示。 /// 预创建路径不设置,避免应用启动时弹窗自动弹出。 static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false); /// 兜底创建路径下 show_popup 计算出的待显示位置(物理坐标),供 show_window 应用, /// 避免窗口重建后仍停留在屏幕外 (-10000, -10000)。 static PENDING_POS: Mutex> = Mutex::new(None); /// 弹窗当前是否可见(同步单一事实来源)。 /// show_preview 用它代替 popup.is_visible():后者在 hide 异步在途时可能返回过期 true, /// 导致"弹窗已隐藏但残留的悬停/键盘请求重新弹出孤立预览窗"。该标志在隐藏路径 /// 同步置 false,任何在途请求都会直接拒绝。 static POPUP_VISIBLE: AtomicBool = AtomicBool::new(false); /// 预览窗当前是否可见(同步标志,与 POPUP_VISIBLE 同理:预览窗以原生 /// SW_SHOWNOACTIVATE 显示,Tauri 的 is_visible() 可能与其真实状态不同步, /// 故用该标志代替 is_visible 判断预览交互状态)。 static PREVIEW_VISIBLE: AtomicBool = AtomicBool::new(false); /// 弹窗因预览交互(光标位于预览窗内)而推迟隐藏的标记: /// 点击预览窗(选择/复制文本、放大图片)时,弹窗会收到 Focused(false),但用户正在 /// 预览窗内交互,此时不应隐藏弹窗。置该标记后保持弹窗显示,待用户离开预览窗 /// (hide_preview)时再连同弹窗一起隐藏,避免"点击预览即关闭弹窗"导致无法交互。 static POPUP_DEFER_HIDE: AtomicBool = AtomicBool::new(false); /// 失焦隐藏的宽限期:WebView2 透明窗口在 show 后激活期间焦点可能短暂弹跳 /// (与快速面板同因),导致 Focused(false) 紧跟在 show 之后触发并立即隐藏刚显示的弹窗。 const SHOW_GRACE: Duration = Duration::from_millis(500); /// 最近一次 show 的时间,用于失焦宽限期判断。 static LAST_SHOWN: Mutex> = Mutex::new(None); /// 标记"已发起显示",并记录时间供失焦宽限期使用。 fn mark_shown() { if let Ok(mut t) = LAST_SHOWN.lock() { *t = Some(Instant::now()); } POPUP_VISIBLE.store(true, Ordering::SeqCst); // 重新显示弹窗时复位推迟隐藏标记(上一轮预览交互的遗留状态不应影响本轮) POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); } /// 判断距上次 show 是否仍在宽限期内(是则忽略失焦自动隐藏)。 fn within_show_grace() -> bool { LAST_SHOWN .lock() .ok() .and_then(|t| *t) .map(|t| t.elapsed() < SHOW_GRACE) .unwrap_or(false) } /// 创建弹窗窗口(隐藏状态)并注册失焦监听。 /// 位置默认在屏幕外,show_popup 时会重新定位。 /// 预创建后首次按快捷键走"窗口已存在"分支直接 show,避免首次创建的时序问题。 fn create_popup_window(app: &AppHandle) { let win = match WebviewWindowBuilder::new( app, POPUP_LABEL, WebviewUrl::App("index.html#clipboard-popup".into()), ) .title("剪贴板") .inner_size(380.0, 460.0) .position(-10000.0, -10000.0) // 屏幕外,避免隐藏时一闪 .decorations(false) .transparent(true) .shadow(true) .always_on_top(true) .skip_taskbar(true) .resizable(false) .visible(false) .focused(false) // 不抢占焦点,避免创建即触发 Focused(false) .effects(EffectsBuilder::new().effects(vec![Effect::Mica]).build()) .build() { Ok(w) => w, Err(e) => { crate::logger::log_error("clipboard", &format!("创建弹窗失败: {}", e)); return; } }; // 监听窗口失焦:自动隐藏(同时隐藏预览窗) let app_handle = app.clone(); let win_handle = win.clone(); win.on_window_event(move |event| { match event { tauri::WindowEvent::Focused(false) => { // 失焦宽限期:show 后激活期间的焦点弹跳不隐藏弹窗,避免弹窗刚显示就被隐藏 if within_show_grace() { return; } // 交互锁定模式(点击过预览窗):弹窗与预览保持显示,仅由看护线程在 // "点击外部"时关闭;此处的失焦是点击预览窗(NoActivate)所致,不隐藏。 if POPUP_INTERACTED.load(Ordering::SeqCst) { return; } // 鼠标当前位于预览窗或弹窗内(用户正在交互:选择/复制文本、放大图片、或 // 已移回弹窗准备继续浏览):弹窗失焦是点击预览窗或焦点反弹所致,不应隐藏弹窗。 // 置推迟标记保持弹窗显示,待用户离开整个区域(hide_preview / 再次失焦)再隐藏。 if is_cursor_in_preview(&app_handle) || is_cursor_in_popup(&app_handle) { POPUP_DEFER_HIDE.store(true, Ordering::SeqCst); return; } // 先同步标记弹窗不可见,再隐藏窗口/预览:异步 hide 在途时,残留的 // show_preview 请求会因该标志为 false 而拒绝,预览窗不会孤立残留。 POPUP_VISIBLE.store(false, Ordering::SeqCst); POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); let _ = win_handle.hide(); hide_preview(&app_handle); let _ = app_handle.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ()); } tauri::WindowEvent::Focused(true) => { // 弹窗重新获得焦点(用户点击/移回弹窗):取消推迟隐藏状态 POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); } _ => {} } }); crate::logger::log_info("clipboard", "弹窗窗口已预创建(隐藏状态)"); } /// 应用启动时预创建弹窗窗口(隐藏)。 /// 这样首次按快捷键时窗口已存在,直接 show + 定位,避免首次创建时序问题。 pub fn ensure_popup_window(app: &AppHandle) { if app.get_webview_window(POPUP_LABEL).is_some() { return; } 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 显示)。 /// 窗口已存在则移动到鼠标位置并显示。 pub fn show_popup(app: &AppHandle) { // 获取鼠标位置(物理像素,Per-Monitor DPI V2) let (mx, my) = match get_cursor_pos() { Some(p) => p, None => return, }; // 窗口尺寸(物理像素,由光标所在屏 DPI 换算) let w = 380.0_f64; let h = 460.0_f64; // 获取光标所在显示器的工作区(物理像素,与 get_cursor_pos 同一坐标系) let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(mx, my) .unwrap_or((0, 0, 1920, 1040)); // 光标所在显示器的 DPI:窗口尺寸需按物理像素放大 let dpi = get_dpi_for_point(mx, my).unwrap_or(96); let scale = dpi as f64 / 96.0; let w_px = w * scale; let h_px = h * scale; // 直接以物理坐标 clamping(光标位置 + 工作区均为物理像素,避免混合 DPI 下 // 手动"物理→逻辑"换算后 Tauri 再按窗口所在屏解释导致的定位偏移) let x = (mx as f64).max(wa_left as f64).min(wa_right as f64 - w_px); let y = (my as f64).max(wa_top as f64).min(wa_bottom as f64 - h_px); // 窗口已存在:移动 + 显示 + 请求焦点 if let Some(win) = app.get_webview_window(POPUP_LABEL) { let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition { x: x as i32, y: y as i32, })); let _ = win.show(); mark_shown(); focus_force(&win); // 通知前端刷新数据 let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ()); return; } // 兜底:窗口被销毁时重新创建(隐藏),等前端 onMounted 回调 show_window POPUP_PENDING_SHOW.store(true, Ordering::SeqCst); if let Ok(mut pos) = PENDING_POS.lock() { *pos = Some((x, y)); } create_popup_window(app); } /// 显示已创建的弹窗窗口(由前端 onMounted 后调用)。 /// 预创建路径下前端 onMounted 也会调用此函数,但 POPUP_PENDING_SHOW 为 false 时直接跳过, /// 避免应用启动时弹窗自动弹出。仅 show_popup 兜底创建路径才真正显示。 pub fn show_window(app: &AppHandle) { if !POPUP_PENDING_SHOW.swap(false, Ordering::SeqCst) { return; } if let Some(win) = app.get_webview_window(POPUP_LABEL) { // 应用 show_popup 计算的兜底位置(物理坐标),避免停留在屏幕外 let pos = PENDING_POS.lock().ok().and_then(|p| *p); if let Some((x, y)) = pos { let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition { x: x as i32, y: y as i32, })); } let _ = win.show(); mark_shown(); focus_force(&win); // 通知前端刷新数据 let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ()); } } /// 隐藏弹窗(不销毁,保留复用),并通知前端清理悬停定时器/预览。 pub fn hide_popup(app: &AppHandle) { // 复位推迟隐藏标记(先于 hide_preview,避免 hide_preview 重入 hide_popup 形成递归) POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); // 复位交互锁定:弹窗关闭后下次呼出恢复"失焦即隐藏"的常规模式 POPUP_INTERACTED.store(false, Ordering::SeqCst); // 同步标记弹窗不可见,拒绝此后在途的 show_preview 请求 POPUP_VISIBLE.store(false, Ordering::SeqCst); hide_preview(app); if let Some(win) = app.get_webview_window(POPUP_LABEL) { let _ = win.hide(); } // 通知前端:取消悬停定时器并隐藏预览,避免弹窗隐藏后残留定时器重新弹出预览窗 let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ()); } /// 隐藏弹窗后延迟模拟 Ctrl+V 粘贴到之前聚焦的窗口。 /// 延迟 150ms 确保焦点切换回原窗口后再发送按键。 pub fn paste_to_target(app: &AppHandle) { // 先隐藏弹窗,让焦点回到原窗口 hide_popup(app); // 在独立线程中延迟模拟 Ctrl+V std::thread::spawn(move || { std::thread::sleep(std::time::Duration::from_millis(150)); simulate_paste(); }); } /// 使用 Win32 SendInput 模拟 Ctrl+V 按键 #[cfg(windows)] fn simulate_paste() { use windows_sys::Win32::UI::Input::KeyboardAndMouse::{ SendInput, INPUT, INPUT_KEYBOARD, KEYBDINPUT, KEYEVENTF_KEYUP, VK_CONTROL, }; const VK_V: u16 = 0x56; // 安全初始化为零值,避免未定义字段 let mut inputs: [INPUT; 4] = unsafe { std::mem::zeroed() }; // Ctrl down inputs[0].r#type = INPUT_KEYBOARD; inputs[0].Anonymous.ki = KEYBDINPUT { wVk: VK_CONTROL, wScan: 0, dwFlags: 0, time: 0, dwExtraInfo: 0 }; // V down inputs[1].r#type = INPUT_KEYBOARD; inputs[1].Anonymous.ki = KEYBDINPUT { wVk: VK_V, wScan: 0, dwFlags: 0, time: 0, dwExtraInfo: 0 }; // V up inputs[2].r#type = INPUT_KEYBOARD; inputs[2].Anonymous.ki = KEYBDINPUT { wVk: VK_V, wScan: 0, dwFlags: KEYEVENTF_KEYUP, time: 0, dwExtraInfo: 0 }; // Ctrl up inputs[3].r#type = INPUT_KEYBOARD; inputs[3].Anonymous.ki = KEYBDINPUT { wVk: VK_CONTROL, wScan: 0, dwFlags: KEYEVENTF_KEYUP, time: 0, dwExtraInfo: 0 }; unsafe { SendInput(4, inputs.as_ptr(), std::mem::size_of::() as i32); } } #[cfg(not(windows))] fn simulate_paste() { // 非 Windows 平台暂不支持自动粘贴 } // ===== 独立预览窗口 ===== /// 创建预览窗口(隐藏状态),应用 NoActivate 样式避免抢焦点。 fn create_preview_window(app: &AppHandle) { let win = match WebviewWindowBuilder::new( app, PREVIEW_LABEL, WebviewUrl::App("index.html#clipboard-preview".into()), ) .title("预览") .inner_size(PREVIEW_W, PREVIEW_H) .position(-10000.0, -10000.0) // 屏幕外,避免隐藏时一闪 .decorations(false) .transparent(true) .shadow(true) .always_on_top(true) .skip_taskbar(true) .resizable(false) .visible(false) .focused(false) // 不抢占焦点 .effects(EffectsBuilder::new().effects(vec![Effect::Mica]).build()) .build() { Ok(w) => w, Err(e) => { crate::logger::log_error("clipboard", &format!("创建预览窗失败: {}", e)); return; } }; // NoActivate:预览窗可交互但不激活,弹窗保持前台(键盘导航/粘贴不受影响) // 圆角:NoActivate 悬浮窗系统不自动圆角,显式指定 DWMWCP_ROUND 与弹窗外观统一 #[cfg(windows)] if let Ok(hwnd) = win.hwnd() { crate::win32_util::apply_no_activate(hwnd.0 as isize); crate::win32_util::apply_rounded_corners(hwnd.0 as isize); } crate::logger::log_info("clipboard", "预览窗口已预创建(隐藏状态)"); } /// 应用启动时预创建预览窗口(隐藏),随弹窗一起就绪。 pub fn ensure_preview_window(app: &AppHandle) { if app.get_webview_window(PREVIEW_LABEL).is_some() { return; } create_preview_window(app); } /// 预览当前所在侧(default=右,left=左),供放大/还原重定位沿用同侧。 #[derive(Clone, Copy, PartialEq)] enum PreviewSide { Right, Left, } static PREVIEW_SIDE: Mutex> = Mutex::new(None); /// 最近一次显示预览时的鼠标 Y 锚点(物理像素)。预览窗垂直中线对齐该位置 /// (贴近鼠标所悬停的条目),resize(切换条目/放大还原)时沿用,保持中线稳定不跳变。 static PREVIEW_ANCHOR_Y: Mutex> = Mutex::new(None); /// 弹窗离开看护线程是否已在运行(防重入,见 spawn_popup_leave_watch)。 static POPUP_LEAVE_WATCH: AtomicBool = AtomicBool::new(false); /// 交互锁定模式:用户点击过预览窗(放大/缩小、复制文本等)后置位。 /// 该模式下弹窗与预览不因失焦/鼠标离开而关闭,仅当点击弹窗+预览之外的 /// 区域(看护线程检测鼠标按下沿)或弹窗重新聚焦(恢复正常模式)时才复位。 static POPUP_INTERACTED: AtomicBool = AtomicBool::new(false); /// 重新定位预览窗口(物理像素)。preferred 指定优先放置侧,返回实际落位侧。 /// anchor_y 为鼠标 Y 锚点:预览窗垂直中线对齐该位置(贴近悬停条目), /// 上下 clamp 到工作区;None 时退回弹窗顶部对齐。 /// /// 无边框+阴影窗口(tao 实现)的外框矩形在客户区四周各留一条不可见边框 /// (SM_CXSIZEFRAME+SM_CXPADDEDBORDER,典型 8px):outer_position/outer_size 均含该边框, /// 而可视内容仅占客户区。若直接用外框尺寸计算右侧落位,右侧可视间距会比左侧多出 /// 两侧边框之和(约 16px)。这里以"可视边缘"对齐:frame = (外框宽 - 客户区宽) / 2, /// 左右两侧使用同一 GAP,保证两侧可视间距一致。 fn reposition_preview( popup: &tauri::WebviewWindow, win: &tauri::WebviewWindow, vw: i32, vh: i32, preferred: PreviewSide, anchor_y: Option, allow_flip: bool, ) -> PreviewSide { // 弹窗当前物理位置与尺寸(外框,含不可见边框) let Ok(pos) = popup.outer_position() else { return preferred }; let Ok(osz) = popup.outer_size() else { return preferred }; let Ok(isz) = popup.inner_size() else { return preferred }; let (px, py) = (pos.x, pos.y); let pw = osz.width as i32; // 不可见边框宽度(外框与客户区之差的一半;无阴影窗口为 0) let frame = ((osz.width.saturating_sub(isz.width)) / 2) as i32; // 弹窗所在显示器工作区 let (wa_left, wa_top, wa_right, wa_bottom) = get_work_area_at_point(px, py) .unwrap_or((0, 0, 1920, 1040)); let gap = (PREVIEW_GAP * popup.scale_factor().unwrap_or(1.0)).round() as i32; // 可视边缘对齐: // 右侧落位 = 弹窗可视右缘(px+pw-frame) + GAP - 预览窗自身左边框(frame) // 左侧落位 = 弹窗可视左缘(px+frame) - GAP - 预览可视宽(vw) - 预览窗左边框(frame) // (frame 两两抵消,与旧公式一致) let right_x = px + pw - 2 * frame + gap; let left_x = px - gap - vw; // 可视区域(含预览窗自身边框偏移)不越工作区 let fits_right = right_x + frame + vw <= wa_right; let fits_left = left_x + frame >= wa_left; let mut x = match preferred { PreviewSide::Right => right_x, PreviewSide::Left => left_x, }; // 仅初始落位(allow_flip=true)允许换侧:优先侧放不下时切到另一侧。 // 内容尺寸变化(放大/还原,allow_flip=false)不允许换侧:窗口跳到另一侧会使 // 鼠标瞬间落在窗外,误触发 mouseleave 而关闭预览/弹窗;此时保持原侧并靠 // 工作区 clamp(大图可能覆盖弹窗边缘,属合理取舍,鼠标仍在预览窗内可交互)。 if allow_flip { match preferred { PreviewSide::Right => { if !fits_right { x = left_x; } } PreviewSide::Left => { if !fits_left { x = right_x; } } } } x = (x + frame).max(wa_left).min(wa_right - vw) - frame; // 仅初始落位(allow_flip)按最终位置更新所在侧(换侧时位置在弹窗另一侧,判定正确); // 放大/还原(不允许换侧)时即使被工作区 clamp 覆盖到弹窗上方,语义上仍属原侧, // 必须沿用 preferred——否则 clamp 后按位置误判为另一侧并存档,缩小后会跳侧。 let side = if allow_flip { if x + vw <= px { PreviewSide::Left } else { PreviewSide::Right } } else { preferred }; // 垂直定位:预览窗中线对齐鼠标 Y 锚点(贴近悬停条目),上下 clamp 到工作区; // 无锚点时退回弹窗顶部对齐 let y = match anchor_y { Some(ay) => (ay - vh / 2).max(wa_top).min(wa_bottom - vh), None => py.max(wa_top).min(wa_bottom - vh), }; let _ = win.set_position(tauri::Position::Physical(tauri::PhysicalPosition { x, y })); if let Ok(mut s) = PREVIEW_SIDE.lock() { *s = Some(side); } side } /// 通知预览前端加载指定条目。窗口此时保持隐藏:前端测得内容尺寸后先调用 /// resize_preview(隐藏状态下完成尺寸/位置调整)再 reveal_preview 显示, /// 避免"先以上次尺寸(可能是放大态大窗)显示再缩回"的闪烁。 pub fn show_preview(app: &AppHandle, id: i64) { // 弹窗已隐藏(或隐藏中)时拒绝显示预览:同步标志消除 is_visible() 的异步时序竞态, // 保证"弹窗失焦消失后预览窗不会孤立残留"。 if !POPUP_VISIBLE.load(Ordering::SeqCst) { return; } if app.get_webview_window(PREVIEW_LABEL).is_none() { return; } let Some(popup) = app.get_webview_window(POPUP_LABEL) else { return; }; // 弹窗不可见时不显示预览:避免弹窗隐藏后仍在途的悬停请求重新弹出孤立的预览窗 if !popup.is_visible().unwrap_or(false) { return; } // 记录鼠标 Y 锚点:预览窗中线对齐鼠标所悬停的条目位置;resize 时沿用 if let Some((_, y)) = get_cursor_pos() { if let Ok(mut a) = PREVIEW_ANCHOR_Y.lock() { *a = Some(y); } } // 通知前端加载条目内容(前端完成后自行 resize + reveal) let _ = app.emit(crate::constants::events::CLIPBOARD_PREVIEW_SHOW, id); } /// 显示已就绪的预览窗口(前端完成内容加载与 resize 后调用)。 /// 显示前重查弹窗可见性,消除内容加载期间弹窗已隐藏的竞态。 pub fn reveal_preview(app: &AppHandle) { // 弹窗已隐藏:在途请求作废 if !POPUP_VISIBLE.load(Ordering::SeqCst) { return; } // 已可见则跳过(放大/还原触发的重复 reveal) if PREVIEW_VISIBLE.load(Ordering::SeqCst) { return; } let Some(win) = app.get_webview_window(PREVIEW_LABEL) else { return; }; // 同步标记预览窗可见(以原生方式显示,Tauri 的 is_visible 可能不同步) PREVIEW_VISIBLE.store(true, Ordering::SeqCst); // 不激活显示(SW_SHOWNOACTIVATE),弹窗保持前台 #[cfg(windows)] if let Ok(hwnd) = win.hwnd() { crate::win32_util::show_no_activate(hwnd.0 as isize); } #[cfg(not(windows))] let _ = win.show(); // 显示期间弹窗可能已被隐藏(失焦/关闭):立即收回预览。 // 关闭初次检查与真正 show 之间的竞态——失焦处理器先置 POPUP_VISIBLE=false // 再隐藏,这里 show 之后重查一次,若已被隐藏则收回预览,避免孤立残留。 if !POPUP_VISIBLE.load(Ordering::SeqCst) { PREVIEW_VISIBLE.store(false, Ordering::SeqCst); let _ = win.hide(); } } /// 按内容自适应调整预览窗大小(逻辑像素),位置沿用当前所在侧并重新对齐弹窗。 /// 前端加载/切换内容(文本测高、图片按宽高比)后调用,窗口贴合内容消除留白。 /// allow_flip:初始落位为 true(优先侧放不下可换侧);放大/还原为 false /// (保持原侧靠工作区 clamp,避免窗口跳侧使鼠标落在窗外误触发隐藏)。 pub fn resize_preview(app: &AppHandle, width: f64, height: f64, allow_flip: bool) { // 弹窗不可见时忽略(无对齐基准) if !POPUP_VISIBLE.load(Ordering::SeqCst) { return; } let Some(win) = app.get_webview_window(PREVIEW_LABEL) else { return; }; let Some(popup) = app.get_webview_window(POPUP_LABEL) else { return; }; let scale = popup.scale_factor().unwrap_or(1.0); // 以弹窗所在屏工作区为上限钳制(逻辑像素),并保证不小于最小可视尺寸 let (wa_left, wa_top, wa_right, wa_bottom) = popup .outer_position() .ok() .and_then(|p| get_work_area_at_point(p.x, p.y)) .unwrap_or((0, 0, 1920, 1040)); let max_w = ((wa_right - wa_left).max(0) as f64 / scale).floor().max(PREVIEW_MIN_W); let max_h = ((wa_bottom - wa_top).max(0) as f64 / scale).floor().max(PREVIEW_MIN_H); let w = width.clamp(PREVIEW_MIN_W, max_w); let h = height.clamp(PREVIEW_MIN_H, max_h); let vw = (w * scale).round() as i32; let vh = (h * scale).round() as i32; let side = PREVIEW_SIDE.lock().ok().and_then(|s| *s).unwrap_or(PreviewSide::Right); // 沿用最近一次的鼠标 Y 锚点:高度变化时中线保持对齐悬停条目,不产生跳变 let anchor_y = PREVIEW_ANCHOR_Y.lock().ok().and_then(|a| *a); reposition_preview(&popup, &win, vw, vh, side, anchor_y, allow_flip); let _ = win.set_size(tauri::Size::Physical(tauri::PhysicalSize { width: vw as u32, height: vh as u32 })); } /// 交互锁定模式入口:前端预览窗收到 mousedown(放大/缩小、复制、选择文本)时调用。 /// 置位锁定标志并启动看护线程:此后弹窗+预览不因失焦/鼠标离开而关闭, /// 仅当点击弹窗+预览之外的区域或弹窗重新聚焦时退出锁定。 pub fn preview_interacted(app: &AppHandle) { POPUP_INTERACTED.store(true, Ordering::SeqCst); // 交互锁定取代推迟隐藏模式:清除可能残留的 DEFER 标记, // 避免后续取消钉住时 hide_preview 走 DEFER 分支误关弹窗 POPUP_DEFER_HIDE.store(false, Ordering::SeqCst); spawn_popup_leave_watch(app.clone()); } /// 隐藏预览窗口(保留复用),并通知前端清空内容。 pub fn hide_preview(app: &AppHandle) { // 交互锁定模式:弹窗仍显示时预览保持(生命周期由看护线程管理,点击外部才 // 随弹窗一起关闭),忽略常规隐藏请求(条目离开、键盘切换等)。 if POPUP_INTERACTED.load(Ordering::SeqCst) && POPUP_VISIBLE.load(Ordering::SeqCst) { return; } POPUP_INTERACTED.store(false, Ordering::SeqCst); // 若此前因预览交互推迟了弹窗隐藏(弹窗已失焦但保持显示),现在用户离开预览窗, // 需判断去向:光标已回到弹窗内(继续浏览弹窗)→ 仅隐藏预览、保持弹窗显示; // 光标在弹窗之外(离开整个区域)→ 连同弹窗一起隐藏。 // (hide_popup 会先复位该标记,故此处 swap(false) 后调用不会递归重入) if POPUP_DEFER_HIDE.swap(false, Ordering::SeqCst) { if !is_cursor_in_popup(app) { hide_popup(app); return; } // 光标已回到弹窗内。若弹窗仍持有焦点(曾点击弹窗重新激活),仅隐藏预览即可, // 后续失焦仍走 Focused(false) 正常关闭;若弹窗已失焦(点击预览窗所致), // 它不会再收到 Focused(false) 事件——光标一旦离开弹窗区域,弹窗将永远 // 无法关闭(无焦点残留窗口)。启动看护线程兜底关闭。 let focused = app .get_webview_window(POPUP_LABEL) .map(|w| w.is_focused().unwrap_or(false)) .unwrap_or(false); if !focused { spawn_popup_leave_watch(app.clone()); } } PREVIEW_VISIBLE.store(false, Ordering::SeqCst); if let Some(win) = app.get_webview_window(PREVIEW_LABEL) { let _ = win.hide(); // 预览窗以原生 SW_SHOWNOACTIVATE 方式显示,Tauri 内部可见性状态可能与其 // 不同步;补一次原生 SW_HIDE,确保任何路径下都被可靠隐藏。 #[cfg(windows)] if let Ok(hwnd) = win.hwnd() { crate::win32_util::hide_window(hwnd.0 as isize); } } let _ = app.emit(crate::constants::events::CLIPBOARD_PREVIEW_HIDE, ()); } /// 弹窗失焦但保持显示时的看护线程(防重入单例)。 /// /// 两种工作模式(每轮动态读取 POPUP_INTERACTED,可中途切换): /// - 常规模式(未点击过预览窗):光标连续 ~300ms 既不在弹窗也不在预览窗内 /// (连续计数防"穿越弹窗-预览间隙"时的瞬时离开误判)→ 关闭弹窗; /// - 交互锁定模式(点击过预览窗的放大/缩小/复制等):弹窗已失焦不会再收到 /// Focused(false),检测"鼠标按下沿且按下位置在弹窗+预览之外"→ 点击外部,关闭弹窗。 /// /// 退出条件:弹窗已隐藏/销毁(其他路径关闭);弹窗重新获得焦点(用户点击 /// 弹窗,恢复正常失焦关闭路径,并复位交互锁定);**光标回到弹窗内并停留片刻 /// (交互锁定解除,但看护继续以常规模式运行)**;超时兜底防线程泄漏 /// (常规 30s;交互锁定为事件驱动,放宽至 10min)。 fn spawn_popup_leave_watch(app: AppHandle) { // 防重入:已有看护在运行则跳过 if POPUP_LEAVE_WATCH.swap(true, Ordering::SeqCst) { return; } std::thread::spawn(move || { // 超时兜底的起点:交互锁定解除时重置(那之后按常规模式的 30s 计) let mut start = Instant::now(); let mut outside = 0u32; let mut was_down = false; // 交互锁定期间光标停在弹窗内的连续轮数(30ms/轮) let mut back_in_popup = 0u32; loop { std::thread::sleep(Duration::from_millis(30)); // 弹窗已隐藏或被销毁:看护结束 if !POPUP_VISIBLE.load(Ordering::SeqCst) || app.get_webview_window(POPUP_LABEL).is_none() { break; } // 弹窗重新获得焦点(用户点击弹窗):恢复正常失焦关闭路径,复位交互锁定 if app .get_webview_window(POPUP_LABEL) .map(|w| w.is_focused().unwrap_or(false)) .unwrap_or(false) { POPUP_INTERACTED.store(false, Ordering::SeqCst); break; } // 交互锁定期间光标已回到弹窗内:用户离开预览窗、回到列表继续浏览 —— // 解除锁定,让前端的悬停逻辑重新生效(否则 hide_preview 在锁定期间一律 // 被忽略,表现为「鼠标回到弹窗、悬停在不需要预览的条目上,预览窗不关」)。 // // 这里**只解除锁定、不 break**:弹窗此刻没有焦点,不会再收到 Focused(false), // 若连看护也退出,它就成了无人负责关闭的残留窗口。继续跑常规模式, // 光标离开弹窗+预览区域约 300ms 后照常关闭。 // 连续计数(~210ms)用来排除「弹窗-预览之间的间隙」造成的瞬时误判。 if POPUP_INTERACTED.load(Ordering::SeqCst) { if is_cursor_in_popup(&app) { back_in_popup += 1; if back_in_popup >= 7 { POPUP_INTERACTED.store(false, Ordering::SeqCst); back_in_popup = 0; // 兜底超时从「解除锁定」这一刻重新计时 start = Instant::now(); // 顺势收起预览:用户回到弹窗意味着意图已从「看预览」变回 // 「浏览列表」。前端在悬停时发出的那次 hide_preview 落在锁定 // 期间、已被忽略,这里补上(否则预览会一直挂到下次悬停)。 hide_preview(&app); } } else { back_in_popup = 0; } } else { back_in_popup = 0; } let interacted = POPUP_INTERACTED.load(Ordering::SeqCst); // 超长兜底:避免异常路径下看护线程无限轮询 let timeout = if interacted { Duration::from_secs(600) } else { Duration::from_secs(30) }; if start.elapsed() > timeout { hide_popup(&app); break; } let cursor_in = is_cursor_in_popup(&app) || is_cursor_in_preview(&app); if interacted { // 交互锁定:左键按下沿发生在弹窗+预览之外 → 点击外部,关闭弹窗+预览。 // 按下沿判定(上一轮未按下、本轮按下)配合 30ms 轮询,可捕获常规点击; // 在弹窗/预览内按下后拖出再松开不算外部点击(以按下位置为准)。 let down = crate::win32_util::is_left_button_down(); if down && !was_down && !cursor_in { hide_popup(&app); break; } was_down = down; } else if cursor_in { outside = 0; } else { outside += 1; // 连续 ~300ms 不在弹窗/预览区域(排除穿越间隙的瞬时状态)才关闭 if outside >= 10 { hide_popup(&app); break; } } } POPUP_LEAVE_WATCH.store(false, Ordering::SeqCst); }); } /// 鼠标当前是否位于弹窗矩形内(弹窗可见且光标在其窗口范围内)。 /// 用于 hide_preview 判断"用户是回到弹窗继续浏览,还是离开整个区域"。 fn is_cursor_in_popup(app: &AppHandle) -> bool { if !POPUP_VISIBLE.load(Ordering::SeqCst) { return false; } let Some(win) = app.get_webview_window(POPUP_LABEL) else { return false; }; let Ok(pos) = win.outer_position() else { return false }; let Ok(size) = win.outer_size() else { return false }; let Some((cx, cy)) = crate::win32_util::get_cursor_pos() else { return false; }; let x = pos.x; let y = pos.y; let w = size.width as i32; let h = size.height as i32; cx >= x && cx <= x + w && cy >= y && cy <= y + h } /// 鼠标当前是否位于预览窗矩形内(预览窗可见且光标在其窗口范围内)。 /// 用于弹窗失焦时判断是否因预览交互所致,决定是否推迟隐藏弹窗。 fn is_cursor_in_preview(app: &AppHandle) -> bool { if !PREVIEW_VISIBLE.load(Ordering::SeqCst) { return false; } let Some(win) = app.get_webview_window(PREVIEW_LABEL) else { return false; }; let Ok(pos) = win.outer_position() else { return false }; let Ok(size) = win.outer_size() else { return false }; let Some((cx, cy)) = crate::win32_util::get_cursor_pos() else { return false; }; let x = pos.x; let y = pos.y; let w = size.width as i32; let h = size.height as i32; cx >= x && cx <= x + w && cy >= y && cy <= y + h } // ===== 屏幕/光标/DPI 工具已迁移至 crate::win32_util(跨模块共享) ===== use crate::win32_util::{get_cursor_pos, get_work_area_at_point, get_dpi_for_point};