const DEFAULT_W: u32 = 1280;
const DEFAULT_H: u32 = 720;
const MIN_W: u32 = 200;
const MIN_H: u32 = 150;
const FALLBACK_MAX_DIM: u32 = 8192;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SavedBounds {
pub width: u32,
pub height: u32,
pub maximized: bool,
}
pub trait WindowBoundsStore {
fn load(&self) -> Option<SavedBounds>;
fn save(&self, bounds: SavedBounds);
}
pub fn sanitize_restored_window_size(
saved: Option<(u32, u32)>,
monitor: Option<(u32, u32)>,
) -> (u32, u32) {
let (w, h) = match saved {
Some(s) => s,
None => return (DEFAULT_W, DEFAULT_H),
};
let (max_w, max_h) = match monitor {
Some((mw, mh)) => (mw.max(MIN_W), mh.max(MIN_H)),
None => (FALLBACK_MAX_DIM, FALLBACK_MAX_DIM),
};
(w.clamp(MIN_W, max_w), h.clamp(MIN_H, max_h))
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct WindowedSizeTracker {
size: (u32, u32),
}
impl WindowedSizeTracker {
pub(crate) fn new(restored: Option<(u32, u32)>, configured: (u32, u32)) -> Self {
Self {
size: restored.unwrap_or(configured),
}
}
pub(crate) fn note_resize(&mut self, size: (u32, u32), maximized: bool, fullscreen: bool) {
if !maximized && !fullscreen {
self.size = size;
}
}
pub(crate) fn size(&self) -> (u32, u32) {
self.size
}
}
#[derive(Default)]
pub(crate) struct BoundsAutoSave {
last_saved: Option<SavedBounds>,
}
impl BoundsAutoSave {
pub(crate) fn seed(&mut self, bounds: Option<SavedBounds>) {
self.last_saved = bounds;
}
pub(crate) fn should_save(&mut self, idle: bool, current: SavedBounds) -> bool {
if !idle || self.last_saved == Some(current) {
return false;
}
self.last_saved = Some(current);
true
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn corrupted_saved_size_clamps_to_monitor() {
let out = sanitize_restored_window_size(Some((10224, 5925)), Some((3408, 1975)));
assert_eq!(out, (3408, 1975));
}
#[test]
fn no_saved_size_uses_default() {
assert_eq!(
sanitize_restored_window_size(None, Some((3408, 1975))),
(1280, 720)
);
assert_eq!(sanitize_restored_window_size(None, None), (1280, 720));
}
#[test]
fn in_bounds_size_is_unchanged() {
assert_eq!(
sanitize_restored_window_size(Some((1600, 900)), Some((3408, 1975))),
(1600, 900)
);
}
#[test]
fn no_monitor_clamps_to_fallback_max() {
assert_eq!(
sanitize_restored_window_size(Some((10224, 5925)), None),
(8192, 5925)
);
assert_eq!(
sanitize_restored_window_size(Some((1280, 720)), None),
(1280, 720)
);
}
#[test]
fn zero_or_tiny_size_is_floored() {
assert_eq!(
sanitize_restored_window_size(Some((0, 0)), Some((3408, 1975))),
(200, 150)
);
assert_eq!(
sanitize_restored_window_size(Some((10, 5)), None),
(200, 150)
);
}
#[test]
fn monitor_smaller_than_floor_keeps_range_valid() {
assert_eq!(
sanitize_restored_window_size(Some((100, 100)), Some((50, 40))),
(200, 150)
);
}
#[test]
fn bounds_are_saved_once_per_change_and_never_mid_drag() {
let b = |w, h| SavedBounds {
width: w,
height: h,
maximized: false,
};
let mut auto = BoundsAutoSave::default();
auto.seed(Some(b(1280, 720)));
assert!(!auto.should_save(true, b(1280, 720)));
assert!(!auto.should_save(false, b(1000, 700)));
assert!(auto.should_save(true, b(1000, 700)));
assert!(!auto.should_save(true, b(1000, 700)));
assert!(auto.should_save(
true,
SavedBounds {
width: 1000,
height: 700,
maximized: true
}
));
}
#[test]
fn restoring_maximized_keeps_the_saved_windowed_size() {
let mut tracker = WindowedSizeTracker::new(Some((1280, 720)), (3408, 1895));
assert_eq!(tracker.size(), (1280, 720));
tracker.note_resize((3408, 1895), true, false);
assert_eq!(tracker.size(), (1280, 720));
}
#[test]
fn without_saved_bounds_the_tracker_starts_at_the_surface_size() {
let tracker = WindowedSizeTracker::new(None, (1600, 900));
assert_eq!(tracker.size(), (1600, 900));
}
#[test]
fn windowed_resizes_are_tracked() {
let mut tracker = WindowedSizeTracker::new(Some((1280, 720)), (1280, 720));
tracker.note_resize((1000, 800), false, false);
assert_eq!(tracker.size(), (1000, 800));
}
#[test]
fn fullscreen_resizes_do_not_clobber_the_windowed_size() {
let mut tracker = WindowedSizeTracker::new(Some((1280, 720)), (1280, 720));
tracker.note_resize((3840, 2160), false, true);
assert_eq!(tracker.size(), (1280, 720));
tracker.note_resize((1280, 720), false, false);
assert_eq!(tracker.size(), (1280, 720));
}
#[test]
fn first_save_happens_when_nothing_was_loaded() {
let mut auto = BoundsAutoSave::default();
auto.seed(None);
assert!(auto.should_save(
true,
SavedBounds {
width: 800,
height: 600,
maximized: false
}
));
}
}