Skip to content

armgit / Wake

Public Imported from GitHub
0

All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.

Rust
12.8 KB
Raw Blame
//! 主窗口:句柄登记,以及几何的记忆与恢复(哪块屏、屏内位置、全屏/最大化)。
//!
//! 坐标约定(2026-09-02 双屏反馈定稿):macOS 上 gpui 的 `window.bounds()` 与开窗
//! 的 `window_bounds` 都是**所在屏幕内的相对坐标**,屏幕由 `WindowOptions.display_id`
//! 选定、留空落主屏;`PlatformDisplay::bounds()`/`visible_bounds()` 同样以屏幕
//! 自身为原点。Windows/X11 上这几个 API 给的则是虚拟桌面的**全局坐标**,显示器
//! 原点非零。所以落盘的是(屏幕 uuid,减去该屏原点后的相对 bounds):macOS 上
//! 减零等于无操作,Windows 上显示器换了主屏或挪了位置时 uuid 仍命中、相对位置
//! 照样恢复(Codex review)。开任何窗都要把目标屏的 display_id 一起传——只算
//! 坐标不传屏幕,就是"设置窗跑到主屏"那个 bug。
//!
//! 两个平台差异(2026-09-02 Codex review):①落盘取 `inner_window_bounds()` 而非
//! `window_bounds()`——Wayland/X11 客户端装饰下后者含 gpui-component 加的 20px 阴影
//! inset,原样开窗会被 `set_client_inset` 再加一层,每次重启长 40px(Zed #22301 同病);
//! macOS/Windows 两者相同。②macOS 后端从不报 `WindowBounds::Maximized`,Zoom 后仍是
//! `Windowed` + 铺满可见区的 frame,要用 `is_maximized()` 补判,并且最大化/全屏时
//! 保住上一次 windowed 的 bounds 落盘,恢复时先按它开窗再放大/全屏(gpui 开窗后自动
//! 调 zoom/toggle_fullscreen),退出时才回得到原尺寸。
use crate::prefs;
use gpui::*;
use gpui_component::Root;
use serde::{Deserialize, Serialize};
use std::time::Duration;

/// 首次启动的主窗尺寸
const MAIN_SIZE: Size<Pixels> = size(px(1180.), px(760.));
/// 两扇窗的最小尺寸。gpui 只在开窗那一刻设它(macOS `setContentMinSize_`),运行时改不了,
/// 所以界面放大后定宽栏要给其余部分让位(`ui::rails_factor`),让位的量从这里推出
pub const MAIN_MIN_SIZE: Size<Pixels> = size(px(940.), px(620.));
pub const SETTINGS_MIN_SIZE: Size<Pixels> = size(px(720.), px(520.));

/// 主窗句柄。无窗时的菜单兜底与 Window → Main Window 据此找主窗,从属窗口
/// 据此取主窗几何
pub struct MainWindow(pub WindowHandle<Root>);
impl Global for MainWindow {}

#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
enum Mode {
    #[default]
    Windowed,
    Maximized,
    Fullscreen,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
struct SavedWindow {
    /// 屏内相对坐标;最大化/全屏时存的是进入前的 windowed bounds,恢复时先按它
    /// 开窗再放大/切全屏,退出也回到原位
    bounds: Bounds<Pixels>,
    #[serde(default)]
    mode: Mode,
    /// `PlatformDisplay::uuid()`,跨重启稳定;None = 拿不到,恢复时落主屏
    #[serde(default)]
    display: Option<String>,
}

/// 进程内快照与落盘状态。关窗后 Dock/菜单重开、退出时落盘都读快照,不依赖
/// 节流写盘是否已经落地
#[derive(Default)]
struct MainGeometry {
    /// 已提交的快照;`bounds` 是 windowed 尺寸,最大化/全屏期间保持不变
    saved: SavedWindow,
    /// windowed 模式下最近一次事件的 frame,等节流任务到期、模式仍是 windowed 才提交成
    /// `saved.bounds`。Zoom/全屏的入场动画每帧都按 windowed 报上来(尺寸还没铺满,
    /// `is_maximized()` 尚为假),直接提交会把"差一点铺满"的中间帧当成恢复尺寸;
    /// 延迟到到期时它已被最终的 Maximized/Fullscreen 盖掉(Codex review)
    live: Option<Bounds<Pixels>>,
    /// 节流落盘任务:在队 ⇔ 快照有未落盘的变化;在队就不再起新的,触发时读最新快照
    save_task: Option<Task<()>>,
}
impl Global for MainGeometry {}

impl MainGeometry {
    /// 待提交的 windowed frame 并进快照后的样子
    fn snapshot(&self) -> SavedWindow {
        let mut saved = self.saved.clone();
        if saved.mode == Mode::Windowed {
            if let Some(live) = self.live {
                saved.bounds = live;
            }
        }
        saved
    }

    fn commit(&mut self) {
        self.saved = self.snapshot();
        self.live = None;
    }
}

fn split(window_bounds: WindowBounds) -> (Bounds<Pixels>, Mode) {
    match window_bounds {
        WindowBounds::Windowed(b) => (b, Mode::Windowed),
        WindowBounds::Maximized(b) => (b, Mode::Maximized),
        WindowBounds::Fullscreen(b) => (b, Mode::Fullscreen),
    }
}

/// 挂到主窗上:移动/缩放/全屏都更新快照并节流落盘。观察器按窗口登记,只挂主窗
pub fn track(window: &mut Window, cx: &mut Context<Root>) {
    // 开窗即记一次:启动后不挪窗直接 Zoom、或以 Maximized 启动由 gpui 自动 zoom 时,
    // 最终那次回调才有"进 Zoom 前的尺寸"可保
    observe(window, cx);
    cx.observe_window_bounds(window, |_, window, cx| observe(window, cx))
        .detach();
}

fn observe(window: &Window, cx: &mut App) {
    // inner_window_bounds / is_maximized 的取舍见模块头
    let (platform_bounds, platform_mode) = split(window.inner_window_bounds());
    let mode = match platform_mode {
        Mode::Windowed if window.is_maximized() => Mode::Maximized,
        mode => mode,
    };
    let display = window.display(cx);
    let uuid = display
        .as_ref()
        .and_then(|d| d.uuid().ok())
        .map(|u| u.to_string());
    // 落盘的是相对所在屏幕原点的坐标(见模块头)
    let origin = display.map(|d| d.bounds().origin).unwrap_or_default();
    let platform_bounds = platform_bounds - origin;
    if !cx.has_global::<MainGeometry>() {
        // 首次(开窗时 track 主动调的那次):直接成为快照,不排落盘——磁盘上就是刚恢复
        // 出来的那份
        cx.set_global(MainGeometry {
            saved: SavedWindow {
                bounds: platform_bounds,
                mode,
                display: uuid,
            },
            ..Default::default()
        });
        return;
    }
    let geometry = cx.global_mut::<MainGeometry>();
    // 激活、换屏通知也会触发观察器,拖动时更是每帧一次:几何没变就什么都不做。
    // 最大化/全屏时各平台给的 bounds 不一(macOS Zoom 给的是铺满后的 frame,X11 给的
    // 是当前 bounds),一律不看,只认模式与屏幕
    let unchanged = mode == geometry.saved.mode
        && uuid == geometry.saved.display
        && match mode {
            Mode::Windowed => geometry
                .live
                .map_or(geometry.saved.bounds == platform_bounds, |live| {
                    live == platform_bounds
                }),
            _ => true,
        };
    if unchanged {
        return;
    }
    geometry.saved.mode = mode;
    geometry.saved.display = uuid;
    if mode == Mode::Windowed {
        geometry.live = Some(platform_bounds);
    }
    schedule_save(cx);
}

/// 一次移动只排一个任务:500ms 后写当时最新的快照,期间的事件只改快照
fn schedule_save(cx: &mut App) {
    if cx.global::<MainGeometry>().save_task.is_some() {
        return;
    }
    let task = cx.spawn(async move |cx| {
        cx.background_executor()
            .timer(Duration::from_millis(500))
            .await;
        cx.update(flush);
    });
    cx.global_mut::<MainGeometry>().save_task = Some(task);
}

/// 有排队中的落盘任务才写(排队 ⇔ 快照有未落盘的变化):先提交待定的 windowed frame,
/// 写完即出队。节流任务与退出前(on_app_quit)都走这里
pub fn flush(cx: &mut App) {
    if !cx.has_global::<MainGeometry>() {
        return;
    }
    let geometry = cx.global_mut::<MainGeometry>();
    if geometry.save_task.take().is_none() {
        return;
    }
    geometry.commit();
    if let Err(e) = save(&geometry.saved) {
        eprintln!("failed to save window geometry: {e}");
    }
}

/// Linux 的主窗关闭即退出;从属窗口以及其他平台仍走普通关窗。
/// 返回 false 保留主窗,交给事件循环退出后的 GPUI shutdown 统一释放,
/// 不在正在派发关闭事件的窗口回调里销毁它。
pub fn should_close(window: &mut Window, cx: &mut App) -> bool {
    let is_main = cx
        .try_global::<MainWindow>()
        .is_some_and(|main| AnyWindowHandle::from(main.0) == window.window_handle());
    if cfg!(target_os = "linux") && is_main {
        quit(cx);
        false
    } else {
        true
    }
}

/// 客户端标题栏和 CloseWindow 快捷键共用,与原生关闭请求采用相同策略。
pub fn close(window: &mut Window, cx: &mut App) {
    if should_close(window, cx) {
        window.remove_window();
    }
}

/// 先请求正常退出,让 on_app_quit、窗口释放和 watcher 的 join 有机会完成。
/// Linux 有关窗后一直挂起的反馈,独立线程只在退出超过期限时兜底,不把
/// 尚未定位的 Wayland/驱动/清理阻塞当作每次都要跳过析构的理由。
pub fn quit(cx: &mut App) {
    if cfg!(target_os = "linux") {
        flush(cx);
        arm_exit_timeout();
    }
    cx.quit();
}

const EXIT_TIMEOUT: Duration = Duration::from_secs(3);

fn arm_exit_timeout() {
    static ARMED: std::sync::Once = std::sync::Once::new();
    ARMED.call_once(|| {
        // 正常退出时 main 返回会结束整个进程,无需等待这个兜底线程。
        // 不能用 GPUI task:若主线程卡在析构或事件循环里,它也无法被调度。
        if let Err(error) = std::thread::Builder::new()
            .name("wake-exit-timeout".into())
            .spawn(|| {
                std::thread::sleep(EXIT_TIMEOUT);
                eprintln!("wake: shutdown exceeded {EXIT_TIMEOUT:?}; forcing exit");
                std::process::exit(0);
            })
        {
            eprintln!("wake: could not start exit timeout: {error}");
        }
    });
}

fn load() -> Option<SavedWindow> {
    serde_json::from_str(&prefs::read("window.json")?).ok()
}

fn save(saved: &SavedWindow) -> std::io::Result<()> {
    let bytes = serde_json::to_vec_pretty(saved).map_err(std::io::Error::other)?;
    prefs::write("window.json", &bytes)
}

/// 把窗口夹进屏幕范围:尺寸先按屏幕封顶,再把原点限制在屏内
fn fit_in(mut bounds: Bounds<Pixels>, screen: Bounds<Pixels>) -> Bounds<Pixels> {
    bounds.size = bounds.size.min(&screen.size);
    let max_origin = point(
        screen.origin.x + screen.size.width - bounds.size.width,
        screen.origin.y + screen.size.height - bounds.size.height,
    );
    bounds.origin = bounds.origin.clamp(&screen.origin, &max_origin);
    bounds
}

/// 开主窗的参数:进程内快照(本次会话刚关掉的位置)> 上次落盘 > 主屏居中。
/// 返回的 bounds 是所选屏幕内的相对坐标,必须与 display_id 一起交给 open_window。
/// 按 uuid 找不回屏幕(显示器拔了)退回主屏;一律夹进可见区,换过分辨率也不会
/// 开到屏外或压住 Dock
pub fn restore(cx: &App) -> (WindowBounds, Option<DisplayId>) {
    let fallback = || (WindowBounds::centered(MAIN_SIZE, cx), None);
    let saved = cx.try_global::<MainGeometry>().map(MainGeometry::snapshot);
    let Some(saved) = saved.or_else(load) else {
        return fallback();
    };
    let display = saved
        .display
        .as_deref()
        .and_then(|uuid| {
            cx.displays()
                .into_iter()
                .find(|d| d.uuid().is_ok_and(|u| u.to_string() == uuid))
        })
        .or_else(|| cx.primary_display());
    let Some(display) = display else {
        return fallback();
    };
    // 相对坐标加回当前这块屏的原点,再夹进它的可见区
    let bounds = fit_in(
        saved.bounds + display.bounds().origin,
        display.visible_bounds(),
    );
    let window_bounds = match saved.mode {
        Mode::Windowed => WindowBounds::Windowed(bounds),
        Mode::Maximized => WindowBounds::Maximized(bounds),
        Mode::Fullscreen => WindowBounds::Fullscreen(bounds),
    };
    (window_bounds, Some(display.id()))
}

/// 从属窗口(Settings)的开窗参数:开在主窗所在屏幕、居中压在主窗上、夹进
/// 可见区。主窗不在(理论上只有开窗失败)退回主屏居中。要在没有窗口被借出时
/// 调用(defer 里)
pub fn centered_over_main(size: Size<Pixels>, cx: &mut App) -> (Bounds<Pixels>, Option<DisplayId>) {
    let anchor = cx
        .try_global::<MainWindow>()
        .map(|main| main.0)
        .and_then(|handle| {
            handle
                .update(cx, |_, window, cx| (window.bounds(), window.display(cx)))
                .ok()
        });
    match anchor {
        Some((main, display)) => {
            let mut bounds = Bounds::centered_at(main.center(), size);
            if let Some(display) = &display {
                bounds = fit_in(bounds, display.visible_bounds());
            }
            (bounds, display.map(|d| d.id()))
        }
        None => (Bounds::centered(None, size, cx), None),
    }
}

#[cfg(test)]
#[path = "main_window_tests.rs"]
mod tests;