648 lines
24 KiB
Rust
648 lines
24 KiB
Rust
//! 滚动截图会话（仅 Windows）：后台线程捕捉拼接 + 独立滚轮线程平滑滚动。
|
||
//!
|
||
//! 与 [super::scroll_capture::scroll_capture]（同步一次调用）不同，本模块把捕获循环
|
||
//! 放进后台线程，通过事件把**实时进度**推给前端。
|
||
//!
|
||
//! ## 自动模式架构
|
||
//! - **run_loop（会话线程）**：按节奏捕获客户区帧，与上一帧做带内偏移匹配，拼接新行；
|
||
//! - **ticker（滚轮线程）**：以 ~16ms 间隔发送小步长 `WM_MOUSEWHEEL`，由目标程序自身的
|
||
//! 平滑滚动动画呈现连续滚动（替代旧版"每 70ms 一整格"的跳变式滚动）；
|
||
//! - **目标策略升级**：带中心最深子窗口（小步长 Send）→ 子窗口整格 → 顶层整格 Send →
|
||
//! 顶层整格 Post。解决"一开始就不滚动"（顶层不转发滚轮 / 程序忽略非整格消息）；
|
||
//! - **自适应速度**：按每周期实测位移调滚轮步长 / 捕获周期，逼近"带高 1/4"的理想重叠；
|
||
//! - **停止补帧（settle）**：用户停止后等目标窗口滚动动画静止再补拼最后一帧，
|
||
//! 保证最终图片结尾 = 用户停止时窗口实际停留的位置；
|
||
//! - **精准回滚**：先按累计像素粗估上滚，再用帧匹配对初始帧校准回到起始位置。
|
||
//!
|
||
//! 事件（广播到所有窗口）：
|
||
//! - `SCROLL_PROGRESS`：`{ width, height, auto }` 当前已拼接高度
|
||
//! - `SCROLL_COMPLETE`：`{ width, height }` 完成导出（PNG 原始字节已存入编辑器图片槽，
|
||
//! 由前端常驻编辑器窗口通过 raw IPC 取出，事件本身不携带图片数据）
|
||
//! - `SCROLL_CANCELLED`：`{}` 取消（丢弃画布）
|
||
|
||
use std::sync::atomic::{AtomicBool, AtomicI32, AtomicIsize, Ordering};
|
||
use std::sync::Mutex;
|
||
use std::thread::sleep;
|
||
use std::time::{Duration, Instant};
|
||
|
||
use tauri::{AppHandle, Emitter};
|
||
use windows_sys::Win32::UI::WindowsAndMessaging::WHEEL_DELTA;
|
||
|
||
use crate::constants::events as evts;
|
||
use crate::logger::{log_error, log_info};
|
||
use super::capture::{bgra_to_png, crop_bgra};
|
||
use super::scroll_capture::{
|
||
capture_client_bgra, client_pt_to_screen, deep_child_at_point, detect_vscroll_offset,
|
||
post_wheel, resolve_band, send_wheel,
|
||
};
|
||
use super::ScrollRegion;
|
||
|
||
// ===== 可调参数 =====
|
||
|
||
/// 滚轮线程发送间隔（毫秒）。小步长 + 高频 → 目标程序的平滑滚动动画连贯不断帧。
|
||
const TICK_MS: u64 = 16;
|
||
/// 捕获周期基准（毫秒）。与滚轮解耦：滚动不因捕获/匹配而停顿。
|
||
const CYCLE_MS: u64 = 130;
|
||
/// 捕获周期上限（整格模式下按实测位移自适应放大）。
|
||
const CYCLE_MS_MAX: u64 = 360;
|
||
/// 每周期理想位移 = clamp(band_h / 4, TARGET_D_MIN, TARGET_D_MAX)。
|
||
/// 太小 → 慢；太大 → 带内重叠不足、匹配易失败。
|
||
const TARGET_D_MIN: usize = 32;
|
||
const TARGET_D_MAX: usize = 180;
|
||
/// 小步长模式：起始 / 上下限步长（WHEEL_DELTA=120 为一整格）。
|
||
const DELTA_START: i32 = 20;
|
||
const DELTA_MIN: i32 = 4;
|
||
const DELTA_MAX: i32 = 72;
|
||
/// 整格模式步长（部分程序忽略非整格滚轮消息，累不进小步长）。
|
||
const DELTA_NOTCH: i32 = 120;
|
||
/// 策略未锁定时：连续多少周期无位移 → 升级投递策略。
|
||
const ESCALATE_CYCLES: u32 = 3;
|
||
/// 策略已锁定时：连续多少周期无位移 → 判定到底。
|
||
const NO_CHANGE_STOP: u32 = 3;
|
||
/// 上限：拼接后总高（像素），超出即自动结束。
|
||
const MAX_TOTAL_H: u32 = 30000;
|
||
/// 进度事件节流。
|
||
const PROGRESS_THROTTLE_MS: u64 = 120;
|
||
/// 停止后等待滚动动画静止的超时（毫秒）。
|
||
const SETTLE_TIMEOUT_MS: u64 = 900;
|
||
/// 回滚粗估：每整格对应的滚动像素。
|
||
const ROLLBACK_PX_PER_NOTCH: f64 = 55.0;
|
||
|
||
// ===== 会话状态 =====
|
||
|
||
/// 活动会话（会话线程独占读写；命令只改 STOP/CANCEL 原子标志）
|
||
struct Session {
|
||
hwnd: isize,
|
||
/// 客户区尺寸与客户区在窗口位图内偏移
|
||
cw: i32,
|
||
ch: i32,
|
||
ox: i32,
|
||
oy: i32,
|
||
band_x: i32,
|
||
band_y: i32,
|
||
band_w: i32,
|
||
band_h: i32,
|
||
/// 已拼接像素（带宽 × total_h）
|
||
canvas: Vec<u8>,
|
||
total_h: u32,
|
||
/// 累计检测到的滚动像素
|
||
ttl_px: u32,
|
||
/// 上一帧（全客户区，匹配基准）
|
||
prev: Vec<u8>,
|
||
/// 初始帧（回滚校准用）
|
||
first: Vec<u8>,
|
||
auto_scroll: bool,
|
||
active: bool,
|
||
}
|
||
|
||
static SESSION: Mutex<Option<Session>> = Mutex::new(None);
|
||
/// 请求线程结束（完成/取消共用）
|
||
static STOP: AtomicBool = AtomicBool::new(false);
|
||
/// 结束方式：true = 取消（不导出），false = 完成（导出）
|
||
static CANCEL: AtomicBool = AtomicBool::new(false);
|
||
|
||
// ===== 滚轮线程共享控制 =====
|
||
|
||
static TICKER_STOP: AtomicBool = AtomicBool::new(false);
|
||
static WHEEL_TARGET: AtomicIsize = AtomicIsize::new(0);
|
||
/// 滚轮步长（有符号 delta，正值；发送时取负 = 向下滚）
|
||
static WHEEL_STEP: AtomicI32 = AtomicI32::new(0);
|
||
static WHEEL_POST: AtomicBool = AtomicBool::new(false);
|
||
static WHEEL_SX: AtomicI32 = AtomicI32::new(0);
|
||
static WHEEL_SY: AtomicI32 = AtomicI32::new(0);
|
||
|
||
/// 会话线程每轮用的只读参数（启动时一次性读出）。
|
||
struct Params {
|
||
hwnd: isize,
|
||
cw: i32,
|
||
ch: i32,
|
||
ox: i32,
|
||
oy: i32,
|
||
band_x: i32,
|
||
band_y: i32,
|
||
band_w: i32,
|
||
band_h: i32,
|
||
auto_scroll: bool,
|
||
}
|
||
|
||
fn read_params() -> Option<Params> {
|
||
let g = SESSION.lock().ok()?;
|
||
let s = g.as_ref().filter(|s| s.active)?;
|
||
Some(Params {
|
||
hwnd: s.hwnd,
|
||
cw: s.cw,
|
||
ch: s.ch,
|
||
ox: s.ox,
|
||
oy: s.oy,
|
||
band_x: s.band_x,
|
||
band_y: s.band_y,
|
||
band_w: s.band_w,
|
||
band_h: s.band_h,
|
||
auto_scroll: s.auto_scroll,
|
||
})
|
||
}
|
||
|
||
/// 会话是否仍活动（run_loop 每周期自检，异常路径提前退出）
|
||
fn is_active() -> bool {
|
||
SESSION
|
||
.lock()
|
||
.map(|g| g.as_ref().map(|s| s.active).unwrap_or(false))
|
||
.unwrap_or(false)
|
||
}
|
||
|
||
/// 启动滚动截图会话。`auto = true` 时线程自动下滚拼到底部；否则等用户手动滚动。
|
||
pub fn start(app: AppHandle, hwnd: isize, region: Option<ScrollRegion>, auto: bool) -> Result<(), String> {
|
||
{
|
||
let g = SESSION.lock().map_err(|e| e.to_string())?;
|
||
if g.as_ref().map(|s| s.active).unwrap_or(false) {
|
||
return Err("已有滚动截图进行中".into());
|
||
}
|
||
}
|
||
let (ctx, bx, by, bw, bh) = resolve_band(hwnd, region)?;
|
||
let first = capture_client_bgra(hwnd, ctx.ox, ctx.oy, ctx.cw, ctx.ch)?;
|
||
let canvas = crop_bgra(&first, ctx.cw as usize, bx, by, bw, bh)?;
|
||
|
||
{
|
||
let mut g = SESSION.lock().map_err(|e| e.to_string())?;
|
||
*g = Some(Session {
|
||
hwnd,
|
||
cw: ctx.cw,
|
||
ch: ctx.ch,
|
||
ox: ctx.ox,
|
||
oy: ctx.oy,
|
||
band_x: bx,
|
||
band_y: by,
|
||
band_w: bw,
|
||
band_h: bh,
|
||
canvas,
|
||
total_h: bh as u32,
|
||
ttl_px: 0,
|
||
first: first.clone(),
|
||
prev: first,
|
||
auto_scroll: auto,
|
||
active: true,
|
||
});
|
||
}
|
||
STOP.store(false, Ordering::Release);
|
||
CANCEL.store(false, Ordering::Release);
|
||
|
||
log_info("scroll-session", &format!(
|
||
"启动滚动截图 hwnd={} band={}x{} auto={}",
|
||
hwnd, bw, bh, auto
|
||
));
|
||
std::thread::spawn(move || run_loop(app));
|
||
Ok(())
|
||
}
|
||
|
||
/// 请求结束会话并导出（完成）。立即返回，线程在下一轮感知并完成。
|
||
pub fn finish() -> Result<(), String> {
|
||
if !running() {
|
||
return Err("没有进行中的滚动截图".into());
|
||
}
|
||
STOP.store(true, Ordering::Release);
|
||
CANCEL.store(false, Ordering::Release);
|
||
Ok(())
|
||
}
|
||
|
||
/// 请求取消会话（不导出）。立即返回，线程在下一轮感知并回滚终止。
|
||
pub fn cancel_now() -> Result<(), String> {
|
||
if !running() {
|
||
return Err("没有进行中的滚动截图".into());
|
||
}
|
||
STOP.store(true, Ordering::Release);
|
||
CANCEL.store(true, Ordering::Release);
|
||
Ok(())
|
||
}
|
||
|
||
fn running() -> bool {
|
||
SESSION.lock().map(|g| g.as_ref().map(|s| s.active).unwrap_or(false)).unwrap_or(false)
|
||
}
|
||
|
||
/// 滚轮线程：高频小步长发送，滚动手感交给目标程序的平滑滚动动画。
|
||
fn ticker_loop() {
|
||
loop {
|
||
if TICKER_STOP.load(Ordering::Acquire) {
|
||
break;
|
||
}
|
||
let target = WHEEL_TARGET.load(Ordering::Acquire);
|
||
let delta = WHEEL_STEP.load(Ordering::Acquire);
|
||
let sx = WHEEL_SX.load(Ordering::Acquire);
|
||
let sy = WHEEL_SY.load(Ordering::Acquire);
|
||
if target != 0 && delta != 0 {
|
||
if WHEEL_POST.load(Ordering::Acquire) {
|
||
post_wheel(target, sx, sy, -delta);
|
||
} else {
|
||
send_wheel(target, sx, sy, -delta);
|
||
}
|
||
}
|
||
sleep(Duration::from_millis(TICK_MS));
|
||
}
|
||
}
|
||
|
||
/// 应用滚轮投递策略（未检测到位移时逐级升级，直到找到能滚动的通道）。
|
||
fn apply_strategy(strategy: u8, p: &Params, bcx: i32, bcy: i32) {
|
||
match strategy {
|
||
0 => {
|
||
// 子窗口 + 小步长（Chromium/WinUI 等会累加小步长并平滑滚动）
|
||
WHEEL_TARGET.store(deep_child_at_point(p.hwnd, bcx, bcy), Ordering::Release);
|
||
WHEEL_STEP.store(DELTA_START, Ordering::Release);
|
||
WHEEL_POST.store(false, Ordering::Release);
|
||
}
|
||
1 => {
|
||
// 子窗口 + 整格（经典 Win32 控件只认整格消息）
|
||
WHEEL_TARGET.store(deep_child_at_point(p.hwnd, bcx, bcy), Ordering::Release);
|
||
WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
|
||
WHEEL_POST.store(false, Ordering::Release);
|
||
}
|
||
2 => {
|
||
// 顶层 + 整格 Send（部分程序由顶层统一处理滚轮）
|
||
WHEEL_TARGET.store(p.hwnd, Ordering::Release);
|
||
WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
|
||
WHEEL_POST.store(false, Ordering::Release);
|
||
}
|
||
_ => {
|
||
// 顶层 + 整格 Post（只处理消息泵排队事件的程序）
|
||
WHEEL_TARGET.store(p.hwnd, Ordering::Release);
|
||
WHEEL_STEP.store(DELTA_NOTCH, Ordering::Release);
|
||
WHEEL_POST.store(true, Ordering::Release);
|
||
}
|
||
}
|
||
log_info("scroll-session", &format!("滚轮策略升级为 {}", strategy));
|
||
}
|
||
|
||
/// 单周期匹配结果
|
||
enum CycleResult {
|
||
/// 两帧一致（未滚动）
|
||
NoChange,
|
||
/// 向下滚了 d 像素（已拼接）
|
||
Moved(usize),
|
||
/// 匹配失败（动画 / 位移超上限）
|
||
MatchFail,
|
||
}
|
||
|
||
/// 一轮捕获-匹配-拼接。返回 (band_w, total_h, CycleResult)。
|
||
fn stitch_cycle(p: &Params, cur: &[u8]) -> (i32, u32, CycleResult) {
|
||
let mut g = match SESSION.lock() {
|
||
Ok(g) => g,
|
||
Err(e) => {
|
||
log_error("scroll-session", &format!("会话锁异常: {}", e));
|
||
return (p.band_w, 0, CycleResult::MatchFail);
|
||
}
|
||
};
|
||
let s = match g.as_mut() {
|
||
Some(s) => s,
|
||
None => return (p.band_w, 0, CycleResult::MatchFail),
|
||
};
|
||
let prev = std::mem::take(&mut s.prev);
|
||
let (bx, by, bw, bh) = (s.band_x, s.band_y, s.band_w, s.band_h);
|
||
let off = detect_vscroll_offset(
|
||
&prev,
|
||
cur,
|
||
p.cw as usize,
|
||
p.ch as usize,
|
||
bx as usize,
|
||
by as usize,
|
||
bw as usize,
|
||
bh as usize,
|
||
);
|
||
match off {
|
||
Some(0) => {
|
||
s.prev = cur.to_vec();
|
||
(bw, s.total_h, CycleResult::NoChange)
|
||
}
|
||
Some(d) => {
|
||
// 一次最多拼接带的整高：单步滚动量超过带高时无法恢复中间内容，
|
||
// 以整带兜底（自适应速度会把位移压回安全区间）
|
||
let new_rows = (d as i32).min(bh) as usize;
|
||
let new_y = bh - new_rows as i32; // 带在客户区内的底对齐
|
||
match crop_bgra(cur, p.cw as usize, bx, s.band_y + new_y, bw, new_rows as i32) {
|
||
Ok(rows) => {
|
||
s.canvas.extend_from_slice(&rows);
|
||
s.total_h += new_rows as u32;
|
||
s.ttl_px += d as u32;
|
||
s.prev = cur.to_vec();
|
||
(bw, s.total_h, CycleResult::Moved(d))
|
||
}
|
||
Err(_) => {
|
||
s.prev = cur.to_vec();
|
||
(bw, s.total_h, CycleResult::MatchFail)
|
||
}
|
||
}
|
||
}
|
||
None => {
|
||
// 匹配失败：保留旧基准帧（下一帧与更早的稳定帧比对，累积位移仍能对上）
|
||
s.prev = prev;
|
||
(bw, s.total_h, CycleResult::MatchFail)
|
||
}
|
||
}
|
||
}
|
||
|
||
fn run_loop(app: AppHandle) {
|
||
let p = match read_params() {
|
||
Some(p) => p,
|
||
None => return,
|
||
};
|
||
|
||
// 滚轮目标初始参数：带中心（客户区坐标）→ 屏幕坐标
|
||
let bcx = p.band_x + p.band_w / 2;
|
||
let bcy = p.band_y + p.band_h / 2;
|
||
let (bsx, bsy) = client_pt_to_screen(p.hwnd, bcx, bcy).unwrap_or((0, 0));
|
||
WHEEL_SX.store(bsx, Ordering::Release);
|
||
WHEEL_SY.store(bsy, Ordering::Release);
|
||
|
||
// 自动模式：启动滚轮线程（策略 0 起步）
|
||
let mut strategy: u8 = 0;
|
||
let mut ticker = None;
|
||
if p.auto_scroll {
|
||
apply_strategy(0, &p, bcx, bcy);
|
||
TICKER_STOP.store(false, Ordering::Release);
|
||
ticker = Some(std::thread::spawn(ticker_loop));
|
||
}
|
||
|
||
let mut no_change: u32 = 0; // 锁定后：连续无位移（到底判定）
|
||
let mut no_move: u32 = 0; // 未锁定：连续无位移（策略升级判定）
|
||
let mut locked = false; // 是否已确认当前策略能滚动
|
||
let mut gave_up = false; // 所有策略都滚不动
|
||
let mut cycle_ms = CYCLE_MS;
|
||
let mut capture_errors: u32 = 0;
|
||
let mut last_emit = Instant::now();
|
||
|
||
loop {
|
||
if STOP.load(Ordering::Acquire) || !is_active() {
|
||
break;
|
||
}
|
||
// 周期节拍：捕获+匹配耗时计入周期
|
||
let t0 = Instant::now();
|
||
|
||
let cur = match capture_client_bgra(p.hwnd, p.ox, p.oy, p.cw, p.ch) {
|
||
Ok(f) => {
|
||
capture_errors = 0;
|
||
f
|
||
}
|
||
Err(e) => {
|
||
// 瞬时失败先重试，连续多次失败才视为窗口关闭/失去客户区
|
||
capture_errors += 1;
|
||
log_error("scroll-session", &format!("捕获失败({}/3): {}", capture_errors, e));
|
||
if capture_errors >= 3 {
|
||
break;
|
||
}
|
||
sleep(Duration::from_millis(100));
|
||
continue;
|
||
}
|
||
};
|
||
|
||
let (band_w, total_h, result) = stitch_cycle(&p, &cur);
|
||
|
||
// 目标位移：带高 1/4，夹在安全区间
|
||
let target_d = (p.band_h as usize / 4).clamp(TARGET_D_MIN, TARGET_D_MAX);
|
||
|
||
match result {
|
||
CycleResult::Moved(d) => {
|
||
if !locked {
|
||
locked = true;
|
||
log_info("scroll-session", &format!("策略 {} 生效，锁定", strategy));
|
||
}
|
||
no_change = 0;
|
||
no_move = 0;
|
||
if p.auto_scroll {
|
||
if strategy == 0 {
|
||
// 小步长模式：按实测位移调步长（sqrt 阻尼防过冲）
|
||
let delta = WHEEL_STEP.load(Ordering::Acquire) as f64;
|
||
let factor = target_d as f64 / d.max(6) as f64;
|
||
let nd = (delta * factor.sqrt()).clamp(DELTA_MIN as f64, DELTA_MAX as f64);
|
||
WHEEL_STEP.store(nd as i32, Ordering::Release);
|
||
} else {
|
||
// 整格模式：步长固定，按实测位移调捕获周期
|
||
if d as f64 > p.band_h as f64 * 0.55 {
|
||
cycle_ms = ((cycle_ms as f64) * 1.25).min(CYCLE_MS_MAX as f64) as u64;
|
||
} else if d < target_d / 2 && cycle_ms > CYCLE_MS {
|
||
cycle_ms = ((cycle_ms as f64) * 0.8).max(CYCLE_MS as f64) as u64;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
CycleResult::NoChange => {
|
||
if locked {
|
||
no_change += 1;
|
||
if no_change >= NO_CHANGE_STOP && p.auto_scroll {
|
||
break; // 已到底部
|
||
}
|
||
// 手动模式由用户控制，不自动结束
|
||
} else if p.auto_scroll {
|
||
no_move += 1;
|
||
if no_move >= ESCALATE_CYCLES {
|
||
no_move = 0;
|
||
strategy += 1;
|
||
if strategy > 3 {
|
||
gave_up = true; // 所有通道都滚不动 → 结束（前端提示）
|
||
break;
|
||
}
|
||
apply_strategy(strategy, &p, bcx, bcy);
|
||
}
|
||
}
|
||
}
|
||
CycleResult::MatchFail => {
|
||
// 内容大幅变化/动画/位移超上限：若持续失败则降速，
|
||
// 避免越滚越快导致匹配一直失败（表现即"滚动中断"）
|
||
if p.auto_scroll {
|
||
if locked && strategy == 0 {
|
||
let delta = WHEEL_STEP.load(Ordering::Acquire) as f64;
|
||
let nd = (delta * 0.75).max(DELTA_MIN as f64);
|
||
WHEEL_STEP.store(nd as i32, Ordering::Release);
|
||
} else if !locked {
|
||
// 未锁定：匹配失败也算"无位移"参与策略升级，
|
||
// 防止动画页面导致升级判定永不触发
|
||
no_move += 1;
|
||
if no_move >= ESCALATE_CYCLES {
|
||
no_move = 0;
|
||
strategy += 1;
|
||
if strategy > 3 {
|
||
gave_up = true;
|
||
break;
|
||
}
|
||
apply_strategy(strategy, &p, bcx, bcy);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 进度事件（节流）
|
||
if matches!(result, CycleResult::Moved(_))
|
||
&& last_emit.elapsed().as_millis() as u64 >= PROGRESS_THROTTLE_MS
|
||
{
|
||
last_emit = Instant::now();
|
||
emit_progress(&app, band_w, total_h, p.auto_scroll);
|
||
}
|
||
if total_h >= MAX_TOTAL_H {
|
||
break;
|
||
}
|
||
|
||
// 补足周期剩余时间
|
||
let el = t0.elapsed().as_millis() as u64;
|
||
if el < cycle_ms {
|
||
sleep(Duration::from_millis(cycle_ms - el));
|
||
}
|
||
}
|
||
|
||
// 停滚轮线程（join 等它退出，最多再发一拍）
|
||
if let Some(t) = ticker.take() {
|
||
TICKER_STOP.store(true, Ordering::Release);
|
||
let _ = t.join();
|
||
}
|
||
|
||
let cancel = CANCEL.load(Ordering::Acquire);
|
||
// 完成（非取消、非放弃）时：等滚动动画静止后补拼最后一帧，
|
||
// 保证图片结尾 = 用户停止时窗口实际停留的位置
|
||
if !cancel && !gave_up {
|
||
settle_and_stitch(&p);
|
||
}
|
||
|
||
// 取出会话数据
|
||
let mut s = match SESSION.lock().ok().and_then(|mut g| g.take()) {
|
||
Some(s) => s,
|
||
None => {
|
||
log_info("scroll-session", "会话已不存在（未导出）");
|
||
let _ = app.emit(evts::SCROLL_CANCELLED, serde_json::json!({}));
|
||
return;
|
||
}
|
||
};
|
||
|
||
// 编码与回滚并行：PNG 编码只依赖画布（已定格），回滚不依赖画布，
|
||
// 两者无数据依赖，并行可显著缩短「停止 → 打开编辑器」的等待
|
||
let (band_w, total_h) = (s.band_w, s.total_h);
|
||
let encode = if cancel {
|
||
None
|
||
} else {
|
||
let canvas = std::mem::take(&mut s.canvas);
|
||
Some(std::thread::spawn(move || {
|
||
bgra_to_png(&canvas, band_w, total_h as i32)
|
||
}))
|
||
};
|
||
|
||
// 回滚到起始位置（与编码并行）：先按累计像素粗估上滚，再帧匹配校准
|
||
if s.ttl_px > 0 {
|
||
rollback(&s);
|
||
}
|
||
|
||
STOP.store(false, Ordering::Release);
|
||
CANCEL.store(false, Ordering::Release);
|
||
|
||
// 等编码完成：PNG 原始字节直接存入编辑器图片槽（不经 base64 / JSON 事件传输）
|
||
let png = encode.and_then(|h| h.join().ok()).and_then(|r| r.ok());
|
||
match png {
|
||
Some(png) => {
|
||
log_info("scroll-session", &format!(
|
||
"完成导出 width={} height={}",
|
||
band_w, total_h
|
||
));
|
||
super::set_editor_image_raw(png);
|
||
let _ = app.emit(
|
||
evts::SCROLL_COMPLETE,
|
||
serde_json::json!({ "width": band_w, "height": total_h }),
|
||
);
|
||
}
|
||
None => {
|
||
log_info("scroll-session", "会话已取消（未导出）");
|
||
let _ = app.emit(evts::SCROLL_CANCELLED, serde_json::json!({}));
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 停止后等待目标窗口滚动动画静止，并把静止帧补拼进画布（结尾对齐停止位置）。
|
||
fn settle_and_stitch(p: &Params) {
|
||
let deadline = Instant::now() + Duration::from_millis(SETTLE_TIMEOUT_MS);
|
||
loop {
|
||
sleep(Duration::from_millis(70));
|
||
if Instant::now() >= deadline || !is_active() {
|
||
return;
|
||
}
|
||
let cur = match capture_client_bgra(p.hwnd, p.ox, p.oy, p.cw, p.ch) {
|
||
Ok(f) => f,
|
||
Err(_) => return,
|
||
};
|
||
match stitch_cycle(p, &cur).2 {
|
||
CycleResult::NoChange => return, // 已静止且无新内容
|
||
CycleResult::Moved(_) | CycleResult::MatchFail => {
|
||
// 动画仍在进行（Moved 已拼接；MatchFail 继续等）
|
||
if Instant::now() >= deadline {
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 回滚：粗估整格数上滚 → 与初始帧逐次比对校准，直到回到起始位置。
|
||
/// 帧匹配校准消除"每格滚动像素因程序而异"带来的累计误差。
|
||
fn rollback(s: &Session) {
|
||
let target = {
|
||
let t = WHEEL_TARGET.load(Ordering::Acquire);
|
||
if t != 0 { t } else { s.hwnd }
|
||
};
|
||
let mut sx = WHEEL_SX.load(Ordering::Acquire);
|
||
let mut sy = WHEEL_SY.load(Ordering::Acquire);
|
||
if sx == 0 && sy == 0 {
|
||
if let Some((x, y)) = client_pt_to_screen(
|
||
s.hwnd,
|
||
s.band_x + s.band_w / 2,
|
||
s.band_y + s.band_h / 2,
|
||
) {
|
||
sx = x;
|
||
sy = y;
|
||
}
|
||
}
|
||
|
||
// 粗估上滚（宁可略少，剩余交给校准补齐）。
|
||
// 上限按累计像素推算：长图捕获（累计数万 px）也要能回滚到位，
|
||
// 固定小上限会导致超长捕获结束后窗口停在半途。
|
||
let notches = (((s.ttl_px as f64) / ROLLBACK_PX_PER_NOTCH).floor() as i32).clamp(1, 800);
|
||
for _ in 0..notches {
|
||
send_wheel(target, sx, sy, WHEEL_DELTA as i32);
|
||
sleep(Duration::from_millis(3));
|
||
}
|
||
sleep(Duration::from_millis(80));
|
||
|
||
// 帧匹配校准：d = 当前仍相对起始位置向下滚动的像素
|
||
let mut last_d = usize::MAX;
|
||
for _ in 0..12 {
|
||
let cur = match capture_client_bgra(s.hwnd, s.ox, s.oy, s.cw, s.ch) {
|
||
Ok(f) => f,
|
||
Err(_) => return,
|
||
};
|
||
let d = detect_vscroll_offset(
|
||
&s.first,
|
||
&cur,
|
||
s.cw as usize,
|
||
s.ch as usize,
|
||
s.band_x as usize,
|
||
s.band_y as usize,
|
||
s.band_w as usize,
|
||
s.band_h as usize,
|
||
);
|
||
match d {
|
||
Some(0) | None => return, // 已回到起始位置 / 无法匹配（视为完成）
|
||
Some(d) if d < 10 => return, // 误差 10px 内视为到位
|
||
Some(d) => {
|
||
if d >= last_d {
|
||
return; // 不再下降：窗口可能不支持向上滚（虚拟化列表），放弃
|
||
}
|
||
last_d = d;
|
||
let more = (((d as f64) / ROLLBACK_PX_PER_NOTCH).ceil() as i32).clamp(1, 60);
|
||
for _ in 0..more {
|
||
send_wheel(target, sx, sy, WHEEL_DELTA as i32);
|
||
sleep(Duration::from_millis(3));
|
||
}
|
||
sleep(Duration::from_millis(60));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn emit_progress(app: &AppHandle, width: i32, height: u32, auto: bool) {
|
||
let _ = app.emit(
|
||
evts::SCROLL_PROGRESS,
|
||
serde_json::json!({ "width": width, "height": height, "auto": auto }),
|
||
);
|
||
}
|