b45255bb6fe2
ui_scale.rs
//! The interface size (Preferences ▸ Interface size, `pref.uiScale`): how the saved choice becomes
//! egui's zoom factor.
//!
//! egui draws at `pixels_per_point = zoom factor × the system's scale`. The size is relative to the
//! system's scale, so it is the zoom itself: 100 % is the system's own size on every screen (native
//! on a Retina Mac too), 125 % a quarter larger. A size above 100 % is held back while the window is
//! too small to lay the interface out at it; the saved choice never changes.
/// The smallest window, in points, the interface is laid out for: the main window's minimum size.
pub const FIT_POINTS: (f32, f32) = (800.0, 500.0);
/// The zoom factors egui's own settings window allows.
const ZOOM_RANGE: (f32, f32) = (0.1, 10.0);
/// What to give egui for a saved choice on this screen and window.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Plan {
/// For `Context::set_zoom_factor`: the size drawn, relative to the system's scale.
pub zoom: f32,
/// Physical pixels per point once drawn (the zoom times the system's scale).
pub drawn: f32,
/// The window is too small for the size chosen, so a smaller one is drawn.
pub limited: bool,
}
/// The plan for `choice` (relative to the system's scale), the system's scale `native` and the
/// window's size in physical pixels `window_px`. An unknown, zero or not finite value reads as no
/// information: a size of 1, a system scale of 1 and a window of any size.
pub fn plan(choice: f64, native: Option<f32>, window_px: Option<(f32, f32)>) -> Plan {
let native = native.filter(|n| n.is_finite() && *n > 0.0).unwrap_or(1.0);
let want = Some(choice as f32).filter(|c| c.is_finite() && *c > 0.0).unwrap_or(1.0);
// The largest zoom at which the window still holds the smallest layout.
let fit = window_px
.filter(|(w, h)| w.is_finite() && h.is_finite() && *w > 0.0 && *h > 0.0)
.map(|(w, h)| (w / FIT_POINTS.0).min(h / FIT_POINTS.1) / native);
// Never below 100 % (or the size asked, when that is smaller): a tiny window doesn't shrink the interface further.
let zoom = match fit {
Some(fit) if want > fit => fit.max(want.min(1.0)),
_ => want,
}
.clamp(ZOOM_RANGE.0, ZOOM_RANGE.1);
Plan { zoom, drawn: zoom * native, limited: zoom < want - 0.005 }
}
/// A size as the percentage Preferences shows (1.25 → 125).
pub fn percent(scale: f32) -> u32 {
(scale * 100.0).round().clamp(0.0, 100_000.0) as u32
}
/// The sizes Preferences offers, relative to the system's scale (`pref.uiScale` takes up to 3);
/// the interface size keys step through the same list.
pub const SIZES: [f64; 8] = figcraft_engine::UI_SCALE_SIZES;
#[cfg(test)]
mod tests {
use super::*;
const BIG: Option<(f32, f32)> = Some((20000.0, 12000.0));
#[test]
fn a_size_is_relative_to_the_systems_scale_on_every_screen() {
// Windows 100/125/150/175 %, Retina 2×, a bare X11 window manager's guessed 2×, a 3× screen.
for native in [1.0, 1.25, 1.5, 1.75, 2.0, 3.0] {
let p = plan(1.0, Some(native), BIG);
assert_eq!((p.zoom, p.drawn, p.limited), (1.0, native, false), "100 % is the system's own size on {native}");
for size in SIZES {
let p = plan(size, Some(native), BIG);
assert!((p.zoom - size as f32).abs() < 1e-5, "{size} on {native}: zoom {}", p.zoom);
assert!((p.drawn - size as f32 * native).abs() < 1e-4, "{size} on {native}: drawn {}", p.drawn);
assert!(!p.limited, "{size} on {native}");
}
}
}
#[test]
fn a_missing_or_unusable_scale_reads_as_1_and_never_gives_egui_a_bad_zoom() {
for native in [None, Some(0.0), Some(-2.0), Some(f32::NAN), Some(f32::INFINITY)] {
for choice in [1.0, 1.5, f64::NAN, f64::INFINITY, -1.0, 0.0, 1e300] {
let p = plan(choice, native, Some((f32::NAN, 0.0)));
assert!(p.zoom.is_finite() && (ZOOM_RANGE.0..=ZOOM_RANGE.1).contains(&p.zoom), "{choice:?} {native:?}: {p:?}");
assert!(p.drawn.is_finite() && p.drawn > 0.0, "{choice:?} {native:?}: {p:?}");
}
}
// A choice that isn't a usable number is the system's own size.
assert_eq!(plan(f64::NAN, Some(2.0), BIG), plan(1.0, Some(2.0), BIG));
}
#[test]
fn a_small_window_holds_a_big_size_back_without_going_below_100() {
// The minimum window on a Retina Mac: 800 × 500 points is 1600 × 1000 pixels, which holds 100 % only.
let min = Some((1600.0, 1000.0));
let p = plan(1.5, Some(2.0), min);
assert_eq!((p.zoom, p.drawn, p.limited), (1.0, 2.0, true));
assert!(!plan(1.0, Some(2.0), min).limited);
// A larger window on a 1× screen: 1200 × 750 pixels hold 150 %.
let p = plan(2.0, Some(1.0), Some((1200.0, 750.0)));
assert_eq!((p.zoom, p.limited), (1.5, true));
// A window smaller than the minimum (a tiling window manager): never below 100 %, and never
// below a smaller size the person chose.
assert_eq!(plan(2.0, Some(1.0), Some((400.0, 250.0))).zoom, 1.0);
let p = plan(0.75, Some(1.0), Some((400.0, 250.0)));
assert_eq!((p.zoom, p.limited), (0.75, false));
}
#[test]
fn the_limit_does_not_depend_on_the_zoom_so_it_cannot_flicker() {
// The window's size in pixels is the same whatever zoom is drawn now, so the plan for it is too.
let px = Some((1700.0, 1100.0));
assert_eq!(plan(2.5, Some(2.0), px), plan(2.5, Some(2.0), px));
}
#[test]
fn percentages_round_like_the_menu_shows_them() {
assert_eq!([percent(0.75), percent(0.9), percent(1.1), percent(1.25), percent(2.0), percent(1.7999)], [75, 90, 110, 125, 200, 180]);
assert_eq!([percent(f32::NAN), percent(-1.0)], [0, 0]);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.