GitCorner

Code

ossartcraftwordcraft🌐
6ef13b2cc8a6
//! The main window's size, position and maximized state, saved with the UI preferences so the
//! next launch opens the window where the user left it (#23).
//!
//! Sizes and positions are in egui points: what [`egui::ViewportInfo`] reports and what
//! [`egui::ViewportBuilder`] takes.

use serde::{Deserialize, Serialize};

/// The host's window state for one raw frame.
///
/// [`egui::InputState::viewport`] still describes the last painted frame on a hidden logic tick,
/// and its `viewport_rect()` is that frame's content size. The host's [`egui::RawInput`] is the
/// fresh answer for this frame, so the app copies the fields it needs here in `raw_input_hook`.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct RawWindowState {
    /// The content rectangle, when the platform reports it (not Wayland).
    pub inner_rect: Option<egui::Rect>,
    /// The window rectangle including decorations, when the platform reports it.
    pub outer_rect: Option<egui::Rect>,
    /// This frame's `RawInput::screen_rect`: the content size even where `inner_rect` is unknown.
    pub screen_rect: Option<egui::Rect>,
    pub monitor_size: Option<egui::Vec2>,
    pub maximized: Option<bool>,
    pub minimized: Option<bool>,
    pub fullscreen: Option<bool>,
    /// The host's [`reachable`] answer: `None` where it can't list the monitors (Wayland).
    pub on_a_monitor: Option<bool>,
    /// The primary monitor's bounds in egui points, when the host can identify it.
    pub primary_monitor_rect: Option<egui::Rect>,
}

impl RawWindowState {
    /// Copy the window state out of this frame's raw input.
    pub fn from_raw(raw: &egui::RawInput) -> Self {
        Self::from_viewport(raw.viewports.get(&raw.viewport_id), raw.screen_rect)
    }

    /// The state of one viewport, from what egui knows about it and its content rectangle.
    pub fn from_viewport(viewport: Option<&egui::ViewportInfo>, screen_rect: Option<egui::Rect>) -> Self {
        Self {
            inner_rect: viewport.and_then(|v| v.inner_rect).filter(|r| r.is_finite()),
            outer_rect: viewport.and_then(|v| v.outer_rect).filter(|r| r.is_finite()),
            screen_rect: screen_rect.filter(|r| r.is_finite()),
            monitor_size: viewport.and_then(|v| v.monitor_size),
            maximized: viewport.and_then(|v| v.maximized),
            minimized: viewport.and_then(|v| v.minimized),
            fullscreen: viewport.and_then(|v| v.fullscreen),
            on_a_monitor: None,
            primary_monitor_rect: None,
        }
    }

    /// The content size reported by this frame, if any. Never the last painted size: a hidden
    /// Wayland tick with neither an `inner_rect` nor a screen rect has no usable geometry.
    pub fn content_size(self) -> Option<egui::Vec2> {
        [self.inner_rect, self.screen_rect]
            .into_iter()
            .flatten()
            .filter(|r| r.is_finite())
            .map(|r| r.size())
            .find(|s| s.is_finite() && s.x > 0.0 && s.y > 0.0)
    }
}

/// The desktop app's minimum inner size, and the smallest window restored. 600 pt wide (#5886):
/// allows half-screen split window tiling on standard displays (e.g. 1280 pt or 1366 pt, such as
/// under GNOME Wayland), and the widest dialogs that fitted 760 pt (Organizer, Define New
/// Multilevel List) still fit.
pub const MIN_SIZE: egui::Vec2 = egui::vec2(600.0, 480.0);
/// Larger saved sizes are corrupt. eframe also shrinks the start size to the largest monitor.
const MAX_SIZE: egui::Vec2 = egui::vec2(16384.0, 16384.0);
/// Saved positions farther from the origin than this are corrupt.
const MAX_COORD: f32 = 32768.0;
/// Room a window leaves on each side of its monitor for the taskbar, the Dock or a desktop panel,
/// which the monitor size (all egui reports) includes.
pub const SYSTEM_BAR: egui::Vec2 = egui::vec2(48.0, 48.0);
/// How much of a window's top edge must be on one monitor for the pointer to drag it back.
const GRIP: egui::Vec2 = egui::vec2(96.0, 16.0);

/// Whether a [`GRIP`] of `window`'s top edge lies on one of `monitors`, in one shared unit.
/// Monitor sizes alone can't tell: a monitor that went away can leave one of the same size.
pub fn reachable(window: egui::Rect, monitors: &[egui::Rect]) -> bool {
    let top = egui::Rect::from_min_size(window.min, egui::vec2(window.width(), window.height().min(GRIP.y)));
    let need = GRIP.min(top.size());
    monitors.iter().any(|m| {
        let on = top.intersect(*m);
        on.is_positive() && on.width() >= need.x && on.height() >= need.y
    })
}

/// The window as it was when the app last closed.
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct WindowGeometry {
    /// Top-left corner: of the frame, or of the content on macOS (where winit places a new
    /// window by it). `None` where the platform doesn't report it (Wayland).
    pub position: Option<[f32; 2]>,
    /// Content size of the un-maximized window.
    pub width: f32,
    pub height: f32,
    pub maximized: bool,
    /// Size of the monitor the window was on, to notice when that monitor is gone.
    pub monitor: Option<[f32; 2]>,
}

impl WindowGeometry {
    /// The geometry to save, given the last saved one and the window as it is now. While the
    /// window is minimized, full screen or maximized, the last un-maximized size and position are
    /// kept, so un-maximizing after the next launch returns to them.
    pub fn track(prev: Option<Self>, window: &RawWindowState) -> Option<Self> {
        if window.minimized == Some(true) || window.fullscreen == Some(true) {
            return prev;
        }
        // egui reads the maximized state on macOS only when the window opens (egui#3494), so a
        // window that opened zoomed would stay "maximized" for good. There the zoomed frame is
        // saved like any other size instead.
        let maximized = window.maximized == Some(true) && !cfg!(target_os = "macos");
        if maximized && let Some(prev) = prev {
            return Some(Self { maximized, ..prev });
        }
        let rect = if cfg!(target_os = "macos") { window.inner_rect } else { window.outer_rect };
        // No rect on this raw frame: keep the last saved geometry. Falling back to
        // `InputState::viewport_rect()` here would save the previous painted size, which is the
        // stale value a hidden Wayland tick must not write.
        let Some(size) = window.content_size() else {
            return prev;
        };
        let position = rect.map(|r| [r.min.x, r.min.y]);
        let monitor = window.monitor_size.map(|s| [s.x, s.y]);
        Self { position, width: size.x, height: size.y, maximized, monitor }.sanitized().or(prev)
    }

    /// `None` for a size that isn't positive and finite. Otherwise the size is clamped to
    /// [`MIN_SIZE`]..=16384, and a position or monitor size that can't be real is dropped.
    pub fn sanitized(self) -> Option<Self> {
        let size = egui::vec2(self.width, self.height);
        if !size.is_finite() || size.x <= 0.0 || size.y <= 0.0 {
            return None;
        }
        let size = size.clamp(MIN_SIZE, MAX_SIZE);
        let position = self.position.filter(|p| p.iter().all(|c| c.is_finite() && c.abs() <= MAX_COORD));
        let monitor = self.monitor.filter(|m| m.iter().all(|c| c.is_finite() && *c > 0.0 && *c <= MAX_SIZE.x));
        Some(Self { position, width: size.x, height: size.y, maximized: self.maximized, monitor })
    }

    /// Whether the window is maximized after it has opened rather than as it opens. On Windows,
    /// winit shows a window the moment it creates it maximized, even one that is meant to stay
    /// hidden until the first frame (eframe's white-flash guard), so a maximized window flashed
    /// on and off about four times at start-up. There it opens at its normal size, hidden, and the
    /// first frame maximizes it ([`Self::maximize_after_open`]).
    pub fn maximizes_after_open(self) -> bool {
        self.maximized && cfg!(windows)
    }

    /// The command that maximizes the window after it opened, if [`Self::maximizes_after_open`].
    pub fn maximize_after_open(self) -> Option<egui::ViewportCommand> {
        self.maximizes_after_open().then_some(egui::ViewportCommand::Maximized(true))
    }

    /// Open the window at this size, position and maximized state.
    pub fn apply(self, builder: egui::ViewportBuilder) -> egui::ViewportBuilder {
        let builder = builder.with_inner_size([self.width, self.height]).with_maximized(self.maximized && !self.maximizes_after_open());
        match self.position {
            Some(p) => builder.with_position(p),
            None => builder,
        }
    }

    /// After a restore: where to move the window when it opened on no monitor, or when the monitor
    /// it now reports differs from the one it was saved on (an external monitor was unplugged,
    /// say). Centred on the primary monitor, whose top-left corner is the origin. A maximized
    /// window fills whichever monitor the system picks, so it stays put.
    pub fn rescue_position(&self, window: &RawWindowState) -> Option<egui::Pos2> {
        if self.maximized || self.position.is_none() {
            return None;
        }
        let now = window.monitor_size.filter(|s| s.is_finite() && s.x > 0.0 && s.y > 0.0)?;
        let other_monitor = self.monitor.is_some_and(|saved| (now - egui::Vec2::from(saved)).length() > 1.0);
        if !other_monitor && window.on_a_monitor != Some(false) {
            return None;
        }
        let monitor = window.primary_monitor_rect.unwrap_or_else(|| egui::Rect::from_min_size(egui::Pos2::ZERO, now));
        let free = monitor.size() - egui::vec2(self.width, self.height);
        Some(monitor.min + (free / 2.0).max(egui::Vec2::ZERO))
    }

    /// Once the monitor size is known: a smaller size and a centred position for a window that
    /// doesn't fit on its monitor, frame included (#1215). eframe shrinks the start size to the
    /// monitor's, but not by the frame, the title bar or the taskbar, so on a laptop screen the
    /// default window reached past the screen's edge, and the end of the scroll bar with it: a
    /// drag of the scroll bar stopped where the pointer met the edge. A window the system placed
    /// (no position here) is on the primary monitor, whose top-left corner is the origin, so its
    /// position counts too; a restored one may be on another monitor, so only its size does. A
    /// maximized window fills its monitor already.
    pub fn fit_on_monitor(&self, window: &RawWindowState) -> Option<(egui::Pos2, egui::Vec2)> {
        if self.maximized || window.maximized == Some(true) || window.fullscreen == Some(true) || window.minimized == Some(true) {
            return None;
        }
        let monitor = window.monitor_size.filter(|s| s.is_finite() && s.x > 0.0 && s.y > 0.0)?;
        let inner = window.inner_rect.filter(|r| r.is_finite())?;
        let outer = window.outer_rect.filter(|r| r.is_finite()).unwrap_or(inner);
        let frame = (outer.size() - inner.size()).max(egui::Vec2::ZERO);
        let room = monitor - 2.0 * SYSTEM_BAR;
        let too_big = outer.width() > room.x || outer.height() > room.y;
        let edge = monitor - SYSTEM_BAR;
        let past_edge = self.position.is_none() && (outer.max.x > edge.x || outer.max.y > edge.y);
        if !too_big && !past_edge {
            return None;
        }
        let size = (room - frame).min(inner.size()).max(MIN_SIZE);
        let free = monitor - (size + frame);
        Some((egui::pos2((free.x / 2.0).max(0.0), (free.y / 2.0).max(0.0)), size))
    }
}

/// Checks the restored geometry in `pending` once, and only once the monitor size is known: while
/// `window` doesn't report a usable one, `pending` is left in place for a later frame. Then it is taken
/// and [`WindowGeometry::rescue_position`] decides where to move the window, if anywhere.
pub fn take_rescue(pending: &mut Option<WindowGeometry>, window: &RawWindowState) -> Option<egui::Pos2> {
    window.monitor_size.filter(|s| s.is_finite() && s.x > 0.0 && s.y > 0.0)?;
    pending.take()?.rescue_position(window)
}

/// The window size to ask for when a caller (the control channel's `ui.resize`) wants `size`:
/// `None` unless both sides are positive and finite. Otherwise at least [`MIN_SIZE`], the desktop
/// app's minimum, and at most `max_side` points (the largest texture the GPU draws, which the
/// window's surface must fit in) or 16384, whichever is smaller; the GPU's limit wins over the
/// minimum (#3734).
pub fn requested_size(size: egui::Vec2, max_side: f32) -> Option<egui::Vec2> {
    if !size.is_finite() || size.x <= 0.0 || size.y <= 0.0 {
        return None;
    }
    let max = MAX_SIZE.min(egui::Vec2::splat(max_side));
    if !(max.x > 0.0 && max.y > 0.0) {
        return None;
    }
    Some(size.max(MIN_SIZE).min(max))
}

/// Clamps an inner window size so that the window (including decoration `frame`) fits on `monitor_size`
/// leaving room on each side for system bars ([`SYSTEM_BAR`]), bounded below by [`MIN_SIZE`] (#5871).
pub fn fit_inner_size(inner: egui::Vec2, monitor_size: egui::Vec2, frame: egui::Vec2) -> egui::Vec2 {
    if !inner.is_finite() || inner.x <= 0.0 || inner.y <= 0.0 {
        return MIN_SIZE;
    }
    if !monitor_size.is_finite() || monitor_size.x <= 0.0 || monitor_size.y <= 0.0 {
        return inner.max(MIN_SIZE);
    }
    let frame = if frame.is_finite() { frame.max(egui::Vec2::ZERO) } else { egui::Vec2::ZERO };
    let room = (monitor_size - 2.0 * SYSTEM_BAR).max(MIN_SIZE);
    let max = (room - frame).max(MIN_SIZE);
    inner.min(max).max(MIN_SIZE)
}

/// Returns a copy of `builder` whose requested inner size is clamped to fit within `monitor_size`
/// (including decoration `frame`) with room for system bars ([`SYSTEM_BAR`]) (#5871).
pub fn fit_builder_to_monitor(builder: egui::ViewportBuilder, monitor_size: egui::Vec2, frame: egui::Vec2) -> egui::ViewportBuilder {
    match builder.inner_size {
        Some(inner) => builder.with_inner_size(fit_inner_size(inner, monitor_size, frame)),
        None => builder,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Builds a raw window-state fixture whose inner, outer and screen rectangles match and whose
    /// monitor is `monitor`.
    fn raw(rect: egui::Rect, monitor: egui::Vec2) -> RawWindowState {
        RawWindowState { inner_rect: Some(rect), outer_rect: Some(rect), screen_rect: Some(rect), monitor_size: Some(monitor), ..Default::default() }
    }

    fn saved() -> WindowGeometry {
        WindowGeometry { position: Some([100.0, 50.0]), width: 1200.0, height: 800.0, maximized: false, monitor: Some([1920.0, 1080.0]) }
    }

    /// Tracking a normal rectangle saves its position, size and monitor, and applies them to a
    /// viewport builder.
    #[test]
    fn records_the_window_and_restores_it() {
        let rect = egui::Rect::from_min_size(egui::pos2(100.0, 50.0), egui::vec2(1200.0, 800.0));
        let g = WindowGeometry::track(None, &raw(rect, egui::vec2(1920.0, 1080.0)));
        assert_eq!(g, Some(saved()));
        let b = saved().apply(egui::ViewportBuilder::default());
        assert_eq!(b.inner_size, Some(egui::vec2(1200.0, 800.0)));
        assert_eq!(b.position, Some(egui::pos2(100.0, 50.0)));
        assert_eq!(b.maximized, Some(false));
    }

    #[test]
    fn a_maximized_window_opens_normal_on_windows_and_is_maximized_by_the_first_frame() {
        let g = WindowGeometry { maximized: true, ..saved() };
        let b = g.apply(egui::ViewportBuilder::default());
        // Normal size and position either way, so un-maximizing returns to them.
        assert_eq!(b.inner_size, Some(egui::vec2(1200.0, 800.0)));
        assert_eq!(b.position, Some(egui::pos2(100.0, 50.0)));
        if cfg!(windows) {
            assert_eq!(b.maximized, Some(false), "winit would show the hidden window while creating it maximized");
            assert_eq!(g.maximize_after_open(), Some(egui::ViewportCommand::Maximized(true)));
        } else {
            assert_eq!(b.maximized, Some(true));
            assert_eq!(g.maximize_after_open(), None);
        }
        assert_eq!(saved().maximize_after_open(), None, "a normal window needs no command");
    }

    /// On macOS a zoomed frame is saved as its zoomed frame rectangle without the maximized flag;
    /// elsewhere the previous geometry is kept with the maximized state. Minimized and full-screen
    /// frames change nothing.
    #[test]
    fn maximized_keeps_the_normal_size_and_position() {
        let full = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1920.0, 1040.0));
        let mut i = raw(full, egui::vec2(1920.0, 1080.0));
        i.maximized = Some(true);
        let g = WindowGeometry::track(Some(saved()), &i);
        if cfg!(target_os = "macos") {
            // The zoomed frame is saved as the size; the window never reopens "maximized".
            assert_eq!(g.map(|g| (g.position, g.width, g.height, g.maximized)), Some((Some([0.0, 0.0]), 1920.0, 1040.0, false)));
        } else {
            assert_eq!(g, Some(WindowGeometry { maximized: true, ..saved() }));
        }
        // Minimized or full screen: nothing changes.
        i.maximized = Some(false);
        i.minimized = Some(true);
        assert_eq!(WindowGeometry::track(Some(saved()), &i), Some(saved()));
        i.minimized = None;
        i.fullscreen = Some(true);
        assert_eq!(WindowGeometry::track(Some(saved()), &i), Some(saved()));
    }

    /// With no position reported, the raw screen rectangle still supplies the size, and the restored
    /// builder has no position.
    #[test]
    fn without_a_position_the_raw_screen_size_is_kept() {
        // Wayland reports no inner/outer rect, but RawInput still carries the content screen rect.
        let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1000.0, 700.0));
        let i = RawWindowState { screen_rect: Some(rect), ..Default::default() };
        let g = WindowGeometry::track(None, &i);
        assert_eq!(g, Some(WindowGeometry { position: None, width: 1000.0, height: 700.0, maximized: false, monitor: None }));
        assert_eq!(g.map(|g| g.apply(egui::ViewportBuilder::default()).position), Some(None));
    }

    /// A hidden Wayland logic tick has no fresh rect. It must keep the saved geometry rather than
    /// write the previous painted `InputState` size, and a fresh `screen_rect` on the same raw
    /// frame is used when the host reports one.
    #[test]
    fn a_hidden_raw_tick_never_reuses_the_last_painted_size() {
        assert_eq!(WindowGeometry::track(Some(saved()), &RawWindowState::default()), Some(saved()));

        let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1000.0, 700.0));
        let fresh = RawWindowState {
            inner_rect: None,
            outer_rect: None,
            screen_rect: Some(rect),
            monitor_size: Some(egui::vec2(1920.0, 1080.0)),
            ..Default::default()
        };
        let g = WindowGeometry::track(Some(saved()), &fresh).expect("the fresh raw size");
        assert_eq!((g.position, g.width, g.height, g.monitor), (None, 1000.0, 700.0, Some([1920.0, 1080.0])));
    }

    /// Invalid inner dimensions use fresh screen geometry; valid inner dimensions take precedence.
    #[test]
    fn invalid_inner_size_falls_back_to_fresh_screen_geometry() {
        let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1000.0, 700.0));
        for size in [egui::vec2(0.0, 0.0), egui::vec2(-1.0, 10.0), egui::vec2(f32::NAN, 10.0)] {
            let raw = RawWindowState {
                inner_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)),
                screen_rect: Some(screen),
                ..Default::default()
            };
            assert_eq!(raw.content_size(), Some(screen.size()));
        }
        let inner = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));
        assert_eq!(RawWindowState { inner_rect: Some(inner), screen_rect: Some(screen), ..Default::default() }.content_size(), Some(inner.size()));
        assert_eq!(
            RawWindowState { inner_rect: Some(egui::Rect::ZERO), screen_rect: Some(egui::Rect::ZERO), ..Default::default() }.content_size(),
            None
        );
    }

    /// Only the current frame's root viewport contributes inner, outer, content and monitor sizes; a
    /// missing viewport or non-finite data leaves defaults.
    #[test]
    fn raw_window_state_reads_only_this_frames_viewport() {
        let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(640.0, 480.0));
        let mut input = egui::RawInput { screen_rect: Some(rect), ..Default::default() };
        input.viewports.insert(
            egui::ViewportId::ROOT,
            egui::ViewportInfo {
                inner_rect: Some(rect),
                outer_rect: Some(rect.expand(10.0)),
                monitor_size: Some(egui::vec2(1920.0, 1080.0)),
                maximized: Some(false),
                minimized: Some(false),
                fullscreen: Some(false),
                ..Default::default()
            },
        );
        let state = RawWindowState::from_raw(&input);
        assert_eq!(state.inner_rect, Some(rect));
        assert_eq!(state.outer_rect, Some(rect.expand(10.0)));
        assert_eq!(state.content_size(), Some(egui::vec2(640.0, 480.0)));
        assert_eq!(state.monitor_size, Some(egui::vec2(1920.0, 1080.0)));

        // A frame without its viewport entry (or with non-finite rects) contributes nothing.
        let empty = RawWindowState::from_raw(&egui::RawInput::default());
        assert_eq!(empty, RawWindowState::default());
        assert_eq!(empty.content_size(), None);
    }

    #[test]
    fn insane_values_are_clamped_or_dropped() {
        let zero = WindowGeometry { width: 0.0, height: 800.0, ..saved() };
        assert_eq!(zero.sanitized(), None);
        assert_eq!(WindowGeometry::default().sanitized(), None);
        let nan = WindowGeometry { width: f32::NAN, ..saved() };
        assert_eq!(nan.sanitized(), None);
        let tiny = WindowGeometry { width: 10.0, height: 1.0e9, ..saved() }.sanitized();
        assert_eq!(tiny.map(|g| (g.width, g.height)), Some((MIN_SIZE.x, 16384.0)));
        let far = WindowGeometry { position: Some([1.0e7, 0.0]), monitor: Some([f32::INFINITY, 1080.0]), ..saved() }.sanitized();
        assert_eq!(far.map(|g| (g.position, g.monitor)), Some((None, None)));
        assert_eq!(saved().sanitized(), Some(saved()));
    }

    /// A saved window on a different monitor is centred on it, or clamped to its origin when too
    /// large; the same monitor, missing data, no saved position or a maximized window does nothing.
    #[test]
    fn a_window_whose_monitor_is_gone_is_moved_on_screen() {
        let on = egui::Rect::from_min_size(egui::pos2(2000.0, 50.0), egui::vec2(1200.0, 800.0));
        // Same monitor: stays where it was.
        assert_eq!(saved().rescue_position(&raw(on, egui::vec2(1920.0, 1080.0))), None);
        // A different (smaller) monitor now: centred on it.
        assert_eq!(saved().rescue_position(&raw(on, egui::vec2(1600.0, 900.0))), Some(egui::pos2(200.0, 50.0)));
        // Larger than that monitor: its top-left corner.
        assert_eq!(saved().rescue_position(&raw(on, egui::vec2(1024.0, 768.0))), Some(egui::Pos2::ZERO));
        // Nothing to compare, or no saved position: no move.
        assert_eq!(WindowGeometry { monitor: None, ..saved() }.rescue_position(&raw(on, egui::vec2(1600.0, 900.0))), None);
        assert_eq!(WindowGeometry { position: None, ..saved() }.rescue_position(&raw(on, egui::vec2(1600.0, 900.0))), None);
        assert_eq!(WindowGeometry { maximized: true, ..saved() }.rescue_position(&raw(on, egui::vec2(1600.0, 900.0))), None);
        assert_eq!(saved().rescue_position(&RawWindowState::default()), None);
    }

    #[test]
    fn a_window_on_no_monitor_is_moved_on_screen_when_a_same_size_monitor_replaced_its_own() {
        let off = egui::Rect::from_min_size(egui::pos2(-1920.0, -1080.0), egui::vec2(1200.0, 800.0));
        let lost = RawWindowState { on_a_monitor: Some(false), ..raw(off, egui::vec2(1920.0, 1080.0)) };
        assert_eq!(saved().rescue_position(&lost), Some(egui::pos2(360.0, 140.0)));
        assert_eq!(WindowGeometry { monitor: None, ..saved() }.rescue_position(&lost), Some(egui::pos2(360.0, 140.0)));
        assert_eq!(WindowGeometry { maximized: true, ..saved() }.rescue_position(&lost), None);
        let found = RawWindowState { on_a_monitor: Some(true), ..lost };
        assert_eq!(saved().rescue_position(&found), None);
    }

    #[test]
    fn only_a_grippable_top_edge_on_a_monitor_is_reachable() {
        let left = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1920.0, 1080.0));
        let right = egui::Rect::from_min_size(egui::pos2(1920.0, 0.0), egui::vec2(1920.0, 1080.0));
        let monitors = [left, right];
        let at = |x: f32, y: f32| egui::Rect::from_min_size(egui::pos2(x, y), egui::vec2(1440.0, 920.0));
        assert!(reachable(at(100.0, 50.0), &monitors));
        assert!(reachable(at(1000.0, 50.0), &monitors), "across both monitors");
        assert!(reachable(at(3840.0 - 96.0, 50.0), &monitors), "just enough of the right edge");
        assert!(!reachable(at(3840.0 - 95.0, 50.0), &monitors));
        assert!(!reachable(at(-1920.0, -1080.0), &monitors), "the gone monitor above-left");
        assert!(!reachable(at(100.0, -900.0), &monitors), "the top edge above every monitor");
        assert!(!reachable(at(100.0, 50.0), &[]));
        assert!(
            reachable(egui::Rect::from_min_size(egui::pos2(10.0, 1072.0), egui::vec2(40.0, 8.0)), &monitors),
            "smaller than the grip at the monitor edge"
        );
    }

    #[test]
    fn an_unreachable_window_is_centered_on_the_primary_monitor_when_monitor_sizes_differ() {
        let primary = egui::Rect::from_min_size(egui::pos2(0.0, 0.0), egui::vec2(1280.0, 1080.0));
        let off = egui::Rect::from_min_size(egui::pos2(-3840.0, 0.0), egui::vec2(1200.0, 800.0));
        let window = RawWindowState { on_a_monitor: Some(false), primary_monitor_rect: Some(primary), ..raw(off, egui::vec2(3840.0, 2160.0)) };
        assert_eq!(saved().rescue_position(&window), Some(egui::pos2(40.0, 140.0)));

        let primary_left = egui::Rect::from_min_size(egui::pos2(-1280.0, 120.0), egui::vec2(1280.0, 1024.0));
        let window = RawWindowState { primary_monitor_rect: Some(primary_left), ..window };
        assert_eq!(saved().rescue_position(&window), Some(egui::pos2(-1240.0, 232.0)));
    }

    /// The rescue waits for a known monitor size, then runs once (moving when needed) and clears the
    /// pending geometry.
    #[test]
    fn the_rescue_waits_for_the_monitor_size() {
        let on = egui::Rect::from_min_size(egui::pos2(2000.0, 50.0), egui::vec2(1200.0, 800.0));
        // The first frame doesn't know the monitor yet: nothing happens and the geometry is kept.
        let mut pending = Some(saved());
        assert_eq!(take_rescue(&mut pending, &RawWindowState::default()), None);
        assert_eq!(pending, Some(saved()));
        // A later frame reports a different monitor: centred on it, and the check is done.
        assert_eq!(take_rescue(&mut pending, &raw(on, egui::vec2(1600.0, 900.0))), Some(egui::pos2(200.0, 50.0)));
        assert_eq!(pending, None);
        assert_eq!(take_rescue(&mut pending, &raw(on, egui::vec2(1024.0, 768.0))), None);
        // The same monitor: no move, and the check is done as well.
        let mut pending = Some(saved());
        assert_eq!(take_rescue(&mut pending, &raw(on, egui::vec2(1920.0, 1080.0))), None);
        assert_eq!(pending, None);
    }

    #[test]
    fn survives_the_prefs_round_trip() {
        let ui = crate::UiState { window: Some(saved()), ..Default::default() };
        let json = serde_json::to_string(&ui).unwrap();
        let back: crate::UiState = serde_json::from_str(&json).unwrap();
        assert_eq!(back.window, Some(saved()));
        // Prefs written before #23 have no window.
        let old: crate::UiState = serde_json::from_str(r#"{"tab":"Insert"}"#).unwrap();
        assert_eq!(old.window, None);
        assert_eq!(old.tab, "Insert");
    }

    /// A window opened with its frame's top-left corner at `at`: 8 pt borders, a 31 pt title bar.
    fn opened(at: egui::Pos2, content: egui::Vec2, monitor: egui::Vec2) -> RawWindowState {
        RawWindowState {
            inner_rect: Some(egui::Rect::from_min_size(at + egui::vec2(8.0, 31.0), content)),
            outer_rect: Some(egui::Rect::from_min_size(at, content + egui::vec2(16.0, 39.0))),
            monitor_size: Some(monitor),
            ..Default::default()
        }
    }

    #[test]
    fn requested_sizes_are_positive_and_fit_the_gpu() {
        let bad = [
            egui::vec2(-5.0, 600.0),
            egui::vec2(0.0, 0.0),
            egui::vec2(1200.0, f32::NAN),
            egui::vec2(f32::NEG_INFINITY, 600.0),
            egui::vec2(f32::INFINITY, 600.0),
        ];
        for bad in bad {
            assert_eq!(requested_size(bad, 8192.0), None, "{bad:?}");
        }
        assert_eq!(requested_size(egui::vec2(1200.0, 800.0), 8192.0), Some(egui::vec2(1200.0, 800.0)));
        assert_eq!(requested_size(egui::vec2(1e9, 1.0), 8192.0), Some(egui::vec2(8192.0, MIN_SIZE.y)));
        assert_eq!(requested_size(egui::vec2(1e9, 1e9), f32::INFINITY), Some(MAX_SIZE));
        assert_eq!(requested_size(egui::vec2(1e9, 1e9), f32::NAN), Some(MAX_SIZE));
        // A GPU that can't hold the minimum: its limit wins, and no limit at all refuses.
        assert_eq!(requested_size(egui::vec2(1200.0, 300.0), 600.0), Some(egui::vec2(600.0, 480.0)));
        assert_eq!(requested_size(egui::vec2(1200.0, 300.0), 100.0), Some(egui::vec2(100.0, 100.0)));
        assert_eq!(requested_size(egui::vec2(1200.0, 800.0), 0.0), None);
    }

    /// #5886: window can be resized to half-screen split widths on standard screens (1280 pt, 1366 pt, etc.)
    /// down to the exact 600 pt minimum, including 1080p displays with 125% and 150% scaling.
    /// Clamping at 760 prevented Wayland and GNOME window managers from tiling the window side-by-side.
    #[test]
    fn requested_size_allows_split_window_narrow_widths() {
        // Exact 600 pt minimum width.
        assert_eq!(requested_size(MIN_SIZE, 8192.0), Some(MIN_SIZE));
        assert_eq!(requested_size(egui::vec2(600.0, 480.0), 8192.0), Some(egui::vec2(600.0, 480.0)));

        // 1080p display at 150% scaling (1920 / 1.5 = 1280 pt total width -> 640 pt half-screen split).
        // Also 1280x720 / 1280x800 at 100% scaling (1280 / 2 = 640 pt).
        assert_eq!(requested_size(egui::vec2(640.0, 480.0), 8192.0), Some(egui::vec2(640.0, 480.0)));
        assert_eq!(requested_size(egui::vec2(640.0, 540.0), 8192.0), Some(egui::vec2(640.0, 540.0)));

        // 1366x768 display at 100% scaling (1366 / 2 = 683 pt half-screen split).
        assert_eq!(requested_size(egui::vec2(683.0, 480.0), 8192.0), Some(egui::vec2(683.0, 480.0)));

        // 1080p display at 125% scaling (1920 / 1.25 = 1536 pt total width -> 768 pt half-screen split).
        assert_eq!(requested_size(egui::vec2(768.0, 480.0), 8192.0), Some(egui::vec2(768.0, 480.0)));

        // Scales above 150% (e.g. 175% where half width is ~548.5 pt) clamp up to the 600 pt minimum width.
        assert_eq!(requested_size(egui::vec2(548.0, 480.0), 8192.0), Some(egui::vec2(600.0, 480.0)));

        // Sanitized geometry preserves these split-window sizes.
        let geom = WindowGeometry { position: Some([0.0, 0.0]), width: 640.0, height: 480.0, maximized: false, monitor: None };
        assert_eq!(geom.sanitized().map(|g| (g.width, g.height)), Some((640.0, 480.0)));
    }

    /// An oversized default window shrinks and is centred to fit, while a restored window keeps its
    /// place; maximized, full-screen, minimized and unknown-monitor frames, and frames without
    /// rectangles, are left alone.
    #[test]
    fn a_window_too_big_for_its_screen_shrinks_to_fit() {
        let system = WindowGeometry::default();
        let at = egui::pos2(78.0, 78.0);
        // A 1920 × 1080 laptop screen at 125 %: eframe gave the default window the screen's height,
        // so the frame and the title bar push its bottom, and the scroll bar's end, off screen.
        let laptop = egui::vec2(1536.0, 864.0);
        let fitted = Some((egui::pos2(48.0, 48.0), egui::vec2(1424.0, 729.0)));
        assert_eq!(system.fit_on_monitor(&opened(at, egui::vec2(1440.0, 864.0), laptop)), fitted);
        // The same size restored from an earlier launch shrinks too.
        assert_eq!(saved().fit_on_monitor(&opened(at, egui::vec2(1440.0, 864.0), laptop)), fitted);
        // Full HD: the default size fits, but where the system put it the bottom reaches into the
        // taskbar, so it is only centred.
        let full_hd = egui::vec2(1920.0, 1080.0);
        let start = egui::vec2(1440.0, 920.0);
        assert_eq!(system.fit_on_monitor(&opened(at, start, full_hd)), Some((egui::pos2(232.0, 60.5), start)));
        // A restored window keeps its place: it may be on another monitor (its origin isn't known).
        assert_eq!(saved().fit_on_monitor(&opened(at, start, full_hd)), None);
        assert_eq!(saved().fit_on_monitor(&opened(egui::pos2(2000.0, 78.0), start, full_hd)), None);
        // Room to spare: nothing moves.
        assert_eq!(system.fit_on_monitor(&opened(at, start, egui::vec2(2560.0, 1440.0))), None);
        // Once fitted, the window saved and restored on the next launch stays as it is.
        let again = WindowGeometry { position: Some([48.0, 48.0]), width: 1424.0, height: 729.0, ..saved() };
        assert_eq!(again.fit_on_monitor(&opened(egui::pos2(48.0, 48.0), egui::vec2(1424.0, 729.0), laptop)), None);
        // Never smaller than the minimum size, and never off the top-left corner.
        let tiny = egui::vec2(MIN_SIZE.x + 40.0, 600.0);
        assert_eq!(system.fit_on_monitor(&opened(at, start, tiny)), Some((egui::pos2(12.0, 40.5), MIN_SIZE)));
        // Maximized, full screen or minimized, or the monitor not known yet: nothing to do.
        let mut i = opened(at, egui::vec2(1440.0, 864.0), laptop);
        assert_eq!(WindowGeometry { maximized: true, ..saved() }.fit_on_monitor(&i), None);
        i.maximized = Some(true);
        assert_eq!(system.fit_on_monitor(&i), None);
        i.maximized = None;
        i.fullscreen = Some(true);
        assert_eq!(system.fit_on_monitor(&i), None);
        i.fullscreen = None;
        i.minimized = Some(true);
        assert_eq!(system.fit_on_monitor(&i), None);
        i.minimized = None;
        i.monitor_size = None;
        assert_eq!(system.fit_on_monitor(&i), None);
        // Wayland reports no rects.
        assert_eq!(system.fit_on_monitor(&RawWindowState { monitor_size: Some(laptop), ..Default::default() }), None);
    }

    /// On displays with smaller dimensions or high DPI scaling (e.g. 2560x1440 at 200% scale,
    /// yielding a 1280x720 pt screen), the requested inner size shrinks to fit the screen
    /// rather than extending past the boundaries (#5871).
    #[test]
    fn fit_inner_size_constrains_window_to_available_screen_dimensions() {
        let default_inner = egui::vec2(1440.0, 920.0);
        let frame = egui::vec2(16.0, 39.0);

        // 2560x1440 display with 200% scaling: 1280x720 pt.
        let scaled_1440p = egui::vec2(1280.0, 720.0);
        let fitted = fit_inner_size(default_inner, scaled_1440p, frame);
        assert_eq!(fitted, egui::vec2(1168.0, 585.0));
        assert!(fitted.x + frame.x <= scaled_1440p.x);
        assert!(fitted.y + frame.y <= scaled_1440p.y);

        // Standard 2560x1440 at 100% scaling: ample room, size remains untouched.
        let large_monitor = egui::vec2(2560.0, 1440.0);
        assert_eq!(fit_inner_size(default_inner, large_monitor, frame), default_inner);

        // Tiny display: clamps to minimum inner size.
        let tiny = egui::vec2(600.0, 400.0);
        assert_eq!(fit_inner_size(default_inner, tiny, frame), MIN_SIZE);

        // Hostile / non-finite inputs never panic and fall back safely.
        assert_eq!(fit_inner_size(egui::vec2(f32::NAN, 100.0), scaled_1440p, frame), MIN_SIZE);
        assert_eq!(fit_inner_size(default_inner, egui::vec2(f32::INFINITY, f32::NAN), frame), default_inner.max(MIN_SIZE));

        // Viewport builder adaptation preserves other builder properties while clamping inner size.
        let builder = egui::ViewportBuilder::default().with_inner_size([1440.0, 920.0]).with_title("Test");
        let adapted = fit_builder_to_monitor(builder, scaled_1440p, frame);
        assert_eq!(adapted.inner_size, Some(egui::vec2(1168.0, 585.0)));
        assert_eq!(adapted.title, Some("Test".into()));
    }
}