794 lines
35 KiB
Rust
794 lines
35 KiB
Rust
//! 剪贴板快捷弹窗:在鼠标位置显示历史记录弹窗。
|
||
//!
|
||
//! 流程:
|
||
//! 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<Option<(f64, f64)>> = 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<Option<Instant>> = 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::<INPUT>() 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<Option<PreviewSide>> = Mutex::new(None);
|
||
|
||
/// 最近一次显示预览时的鼠标 Y 锚点(物理像素)。预览窗垂直中线对齐该位置
|
||
/// (贴近鼠标所悬停的条目),resize(切换条目/放大还原)时沿用,保持中线稳定不跳变。
|
||
static PREVIEW_ANCHOR_Y: Mutex<Option<i32>> = 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<i32>,
|
||
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};
|