b45255bb6fe2
ui_scale_tests.rs
//! The interface size, driven through egui headless on screens of different system scales: 100 %
//! leaves the system's scale alone, another size is relative to it on every screen, and the
//! Preferences drop-down tells a screen reader its name and value.
//!
//! The test window's size is fixed in points, so it grows with the zoom here; the limit for a small
//! window is tested on its own in `ui_scale::tests`, and the sizes below stay inside it.
use egui::accesskit::Role;
use egui::{RawInput, ViewportId, ViewportInfo};
use figcraft_engine::Session;
use serde_json::json;
use crate::layers_drag_tests::Ui;
/// One frame on a screen whose system scale is `native` (a real window reports it every frame).
fn frame_at(u: &mut Ui, native: f32) -> egui::FullOutput {
let mut raw = RawInput::default();
raw.viewports.insert(ViewportId::ROOT, ViewportInfo { native_pixels_per_point: Some(native), ..Default::default() });
u.frame_raw(raw)
}
/// Frames on that screen, enough for a new zoom to take effect.
fn settle(u: &mut Ui, native: f32) {
for _ in 0..4 {
frame_at(u, native);
}
}
const SCREENS: [f32; 5] = [1.0, 1.25, 1.5, 2.0, 3.0];
#[test]
fn by_default_the_interface_is_the_systems_own_size() {
for native in SCREENS {
let mut u = Ui::new(Session::new());
settle(&mut u, native);
assert_eq!(u.ctx.zoom_factor(), 1.0, "{native}");
assert_eq!(u.ctx.pixels_per_point(), native, "{native}");
}
}
#[test]
fn a_size_is_relative_to_the_systems_scale_on_every_screen_and_auto_is_100() {
for native in SCREENS {
let mut u = Ui::new(Session::new());
for size in [0.75_f64, 0.9, 1.25, 1.5] {
assert!(u.app.run("pref.uiScale", json!({"scale": size})).is_some());
settle(&mut u, native);
let drawn = u.ctx.pixels_per_point();
assert!((drawn - size as f32 * native).abs() < 1e-4, "{size} on a {native}× screen drew at {drawn}");
assert!((u.ctx.zoom_factor() - size as f32).abs() < 1e-5, "{size} on {native}");
assert!(!u.app.ui.ui_scale.limited, "{size} on {native}");
}
assert!(u.app.run("pref.uiScale", json!({"scale": "auto"})).is_some());
settle(&mut u, native);
assert_eq!((u.ctx.zoom_factor(), u.ctx.pixels_per_point()), (1.0, native), "{native}");
}
}
#[test]
fn the_interface_size_menu_has_a_name_a_value_and_a_state_for_a_screen_reader() {
let mut u = Ui::new(Session::new());
u.app.ui.preferences = true;
u.ctx.enable_accesskit();
let combo = |u: &mut Ui| {
settle(u, 2.0);
let out = frame_at(u, 2.0);
let nodes: Vec<_> = out.platform_output.accesskit_update.expect("an AccessKit update").nodes.into_iter().map(|(_, n)| n).collect();
let n = nodes.iter().find(|n| n.role() == Role::ComboBox && n.label() == Some("Interface size")).expect("an Interface size menu");
(n.value().map(str::to_owned), n.is_expanded())
};
// 100 % is the system's own size, whatever it is (2× here).
assert_eq!(combo(&mut u), (Some("100%".to_owned()), Some(false)));
u.app.run("pref.uiScale", json!({"scale": 1.25}));
assert_eq!(combo(&mut u), (Some("125%".to_owned()), Some(false)));
}
/// Every window size, system scale and interface size, drawn the way a real window is: the window is
/// a fixed number of physical pixels, and its size in points is that divided by the scale drawn now
/// (egui-winit does the same each frame), so a bigger size shrinks the window in points.
///
/// What a fixed size promises: whatever it draws at above 100 %, the window still holds the smallest
/// layout the interface is made for (`ui_scale::FIT_POINTS`), and the panels leave room for a canvas.
#[test]
fn every_window_size_system_scale_and_interface_size_lays_out_inside_the_window() {
use crate::ui_scale::{FIT_POINTS, SIZES};
use crate::{FigApp, NoServices};
use egui::{Pos2, Rect, vec2};
// Window sizes in points: the main window's minimum, common laptop and desktop screens up to 5K,
// and a short wide strip.
let windows: [(f32, f32); 10] = [
(800.0, 500.0),
(1024.0, 640.0),
(1280.0, 720.0),
(1366.0, 768.0),
(1440.0, 900.0),
(1920.0, 1080.0),
(2560.0, 1440.0),
(3840.0, 2160.0),
(5120.0, 2880.0),
(2560.0, 520.0),
];
for native in [1.0_f32, 1.25, 1.5, 1.75, 2.0, 3.0] {
for (w, h) in windows {
let px = vec2(w * native, h * native);
for want in SIZES {
let case = format!("{w}x{h} pt at {native}x, {want}");
let mut app = FigApp::new(Session::new(), Box::new(NoServices));
assert!(app.run("pref.uiScale", json!({"scale": want})).is_some(), "{case}");
let ctx = egui::Context::default();
let mut time = 0.0;
let mut seen = Vec::new();
for _ in 0..8 {
time += 1.0 / 60.0;
let ppp = ctx.pixels_per_point();
let mut raw = RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, px / ppp)), time: Some(time), ..Default::default() };
raw.viewports.insert(ViewportId::ROOT, ViewportInfo { native_pixels_per_point: Some(native), ..Default::default() });
let mut out = ctx.run_ui(raw, |ui| app.ui(ui));
out.textures_delta.clear();
seen.push((ctx.pixels_per_point(), ctx.content_rect().size()));
}
// It settles within a few frames and then stays put: no flicker between two sizes.
let (ppp, content) = seen[seen.len() - 1];
assert_eq!(seen[seen.len() - 2].0, ppp, "{case}: still changing");
assert!(ppp.is_finite() && ppp > 0.0 && content.x.is_finite() && content.y.is_finite(), "{case}: {ppp} {content:?}");
let plan = app.ui.ui_scale;
assert!((ppp - plan.drawn).abs() < 1e-3, "{case}: egui draws at {ppp}, the plan said {}", plan.drawn);
// The size drawn, relative to the system's scale.
let zoom = ppp / native;
let want = want as f32;
assert_eq!(plan.limited, zoom < want - 0.005, "{case}: limited flag");
// Above 100 % the window holds the smallest layout; at or below it there is nothing more to give up.
if zoom > 1.001 {
assert!(content.x >= FIT_POINTS.0 - 0.5 && content.y >= FIT_POINTS.1 - 0.5, "{case}: window is {content:?} points at {ppp}");
}
// It never draws bigger than asked, and only a window too small for it draws smaller.
assert!(zoom <= want + 1e-3, "{case}");
if !plan.limited {
assert!((zoom - want).abs() < 1e-3, "{case}");
}
let panels = &app.inspect()["panels"];
let side = panels["left"].as_f64().unwrap_or(0.0) + panels["right"].as_f64().unwrap_or(0.0);
assert!(side < f64::from(content.x) - 100.0, "{case}: the panels ({side} pt) leave no canvas in {content:?}");
}
}
}
}
/// The interface size is reachable and changeable without a pointer: Tab reaches the menu, Enter
/// opens it, the arrows and Tab move through its entries, Enter picks one and closes the menu, and
/// Escape closes it alone, without changing anything and without closing Preferences (a second
/// Escape does).
#[test]
fn the_interface_size_menu_works_from_the_keyboard() {
use crate::a11y::focused_name;
use egui::{Event, Key, Modifiers, Popup};
// A key press, then two quiet frames for the focus (and the name a screen reader reads) to settle.
let press_mod = |u: &mut Ui, key: Key, modifiers: Modifiers| {
u.frame_with(
vec![
Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers },
Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers },
],
modifiers,
);
u.frame(vec![]);
u.frame(vec![]);
};
let press = |u: &mut Ui, key: Key| press_mod(u, key, Modifiers::NONE);
let open = |u: &mut Ui| {
// The Preferences dialog is not modal for the keyboard: Tab crosses the main window first.
let mut tabs = 0;
while focused_name(&u.ctx) != "Interface size" {
assert!(tabs < 140, "Tab never reaches the Interface size menu (focus: {:?})", focused_name(&u.ctx));
press(u, Key::Tab);
tabs += 1;
}
press(u, Key::Enter);
assert!(Popup::is_any_open(&u.ctx), "Enter opens the menu");
};
let chosen = |u: &Ui| u.app.inspect()["uiScale"]["choice"].clone();
let mut u = Ui::new(Session::new());
u.app.ui.preferences = true;
u.ctx.enable_accesskit();
settle(&mut u, 1.0);
assert_eq!(chosen(&u), json!(1.0));
// Escape closes the menu and nothing else: the size is unchanged and Preferences stays open.
open(&mut u);
press(&mut u, Key::Escape);
u.frame(vec![]);
assert!(!Popup::is_any_open(&u.ctx));
assert!(u.app.ui.preferences, "the first Escape closes the menu only");
assert_eq!(chosen(&u), json!(1.0));
// The arrows enter the menu on its first size and go down through the sizes (75, 90, 100, 110,
// 125); Enter picks the one that has the keyboard and closes the menu.
open(&mut u);
press(&mut u, Key::ArrowDown);
assert_eq!(focused_name(&u.ctx), "75%");
for _ in 0..4 {
press(&mut u, Key::ArrowDown);
}
assert_eq!(focused_name(&u.ctx), "125%");
for expected in ["150%", "175%", "200%", "200%"] {
press(&mut u, Key::Tab);
assert_eq!(focused_name(&u.ctx), expected, "Tab stays in the size menu");
}
for expected in ["175%", "150%", "125%"] {
press_mod(&mut u, Key::Tab, Modifiers::SHIFT);
assert_eq!(focused_name(&u.ctx), expected, "Shift+Tab stays in the size menu");
}
press(&mut u, Key::Enter);
assert_eq!(chosen(&u), json!(1.25));
assert!(!Popup::is_any_open(&u.ctx), "picking a size closes the menu");
assert!(u.app.ui.preferences, "picking a size leaves Preferences open");
// With no menu open, Escape closes Preferences as before.
press(&mut u, Key::Escape);
assert!(!u.app.ui.preferences);
}
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.