细节调整及优化(26.8.3)

This commit is contained in:
zhongluofeng committed 2026-08-21 17:25:47 +08:00
1 parent 0a19b4b38a
commit 4dd60f42a1
72 files changed
+4779 -1395

No files matched your search

+531 -5
View File
@@ -10,12 +10,27 @@
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);
@@ -24,6 +39,50 @@ static POPUP_PENDING_SHOW: AtomicBool = AtomicBool::new(false);
/// 避免窗口重建后仍停留在屏幕外 (-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,避免首次创建的时序问题。
@@ -54,13 +113,41 @@ fn create_popup_window(app: &AppHandle) {
}
};
// 监听窗口失焦:自动隐藏
// 监听窗口失焦:自动隐藏(同时隐藏预览窗)
let app_handle = app.clone();
let win_handle = win.clone();
win.on_window_event(move |event| {
if let tauri::WindowEvent::Focused(false) = event {
let _ = win_handle.hide();
let _ = app_handle.emit(crate::constants::events::CLIPBOARD_POPUP_HIDE, ());
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);
}
_ => {}
}
});
@@ -112,6 +199,7 @@ pub fn show_popup(app: &AppHandle) {
y: y as i32,
}));
let _ = win.show();
mark_shown();
let _ = win.set_focus();
// 通知前端刷新数据
let _ = app.emit(crate::constants::events::CLIPBOARD_POPUP_SHOW, ());
@@ -143,17 +231,27 @@ pub fn show_window(app: &AppHandle) {
}));
}
let _ = win.show();
mark_shown();
let _ = win.set_focus();
// 通知前端刷新数据
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 粘贴到之前聚焦的窗口。
@@ -207,6 +305,434 @@ 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 || {
let start = Instant::now();
let mut outside = 0u32;
let mut was_down = false;
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;
}
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};