Merge pull request #818 from leandrodslv/feat/ui-size

feat(ui): add the interface size preference (#540)

crates/engine/src/a11y_keys_tests.rs

@@ -55,3 +55,51 @@ fn reduce_motion_is_a_preference_that_persists() {
     let old: crate::Prefs = serde_json::from_value(json!({"theme": "dark"})).unwrap();
     assert!(!old.reduce_motion);
 }
+
+#[test]
+fn interface_size_is_relative_to_the_system_and_persists() {
+    let mut s = Session::new();
+    assert_eq!(s.prefs.ui_scale, 1.0, "the system's own size by default");
+    assert_eq!(s.execute("pref.uiScale", &json!({})).unwrap()["scale"], 1.0);
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": 1.25})).unwrap()["scale"], 1.25);
+    assert_eq!(s.prefs.ui_scale, 1.25);
+    // Reading changes nothing; "auto" (older scripts) is the system's own size.
+    assert_eq!(s.execute("pref.uiScale", &json!({})).unwrap()["scale"], 1.25);
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": "Auto"})).unwrap()["scale"], 1.0);
+    // Nothing to undo: the document didn't change.
+    assert!(!s.ds().map(|d| d.is_dirty()).unwrap_or(false));
+    // Saved with the other preferences and read back.
+    s.prefs.ui_scale = 0.9;
+    let v = serde_json::to_value(&s.prefs).unwrap();
+    assert_eq!(v["ui_scale"], 0.9);
+    let back: crate::Prefs = serde_json::from_value(v).unwrap();
+    assert_eq!(back.ui_scale, 0.9);
+}
+
+#[test]
+fn interface_size_stops_at_the_ends_and_junk_never_changes_it() {
+    let mut s = Session::new();
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": 0.01})).unwrap()["scale"], crate::UI_SCALE_MIN);
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": -4})).unwrap()["scale"], crate::UI_SCALE_MIN);
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": 1e308})).unwrap()["scale"], crate::UI_SCALE_MAX);
+    // The size is a factor (1.25), not a percentage: 125 is far past the end and stops there.
+    assert_eq!(s.execute("pref.uiScale", &json!({"scale": 125})).unwrap()["scale"], crate::UI_SCALE_MAX);
+    s.prefs.ui_scale = 1.5;
+    for junk in [json!({"scale": "NaN"}), json!({"scale": "big"}), json!({"scale": [1]}), json!({"scale": {"x": 1}})] {
+        assert!(s.execute("pref.uiScale", &junk).is_err(), "{junk}");
+        assert_eq!(s.prefs.ui_scale, 1.5, "{junk}");
+    }
+}
+
+#[test]
+fn a_settings_file_without_or_with_a_wrong_interface_size_reads_as_the_systems_size_and_keeps_the_rest() {
+    let old: crate::Prefs = serde_json::from_value(json!({"theme": "dark"})).unwrap();
+    assert_eq!(old.ui_scale, 1.0);
+    for bad in [json!("big"), json!(null), json!([2]), json!(true)] {
+        let p: crate::Prefs = serde_json::from_value(json!({"theme": "dark", "ui_scale": bad})).unwrap();
+        assert_eq!((p.ui_scale, p.theme.as_str()), (1.0, "dark"), "{bad}");
+    }
+    // A number out of range is clamped rather than refused.
+    let p: crate::Prefs = serde_json::from_value(json!({"ui_scale": 99, "theme": "dark"})).unwrap();
+    assert_eq!((p.ui_scale, p.theme.as_str()), (crate::UI_SCALE_MAX, "dark"));
+}

crates/engine/src/cmd/view.rs

@@ -370,6 +370,23 @@ pub fn specs() -> Vec<CommandSpec> {
         spec!("pref.showDimensions", "Show dimensions on objects", "{on?}", false, |s, p| pref(s, p, |x| &mut x.show_dimensions)),
         spec!("pref.numberKeysOpacity", "Use number keys for opacity", "{on?}", false, |s, p| pref(s, p, |x| &mut x.number_keys_opacity)),
         spec!("pref.reduceMotion", "Reduce motion", "{on?}", false, |s, p| pref(s, p, |x| &mut x.reduce_motion)),
+        spec!(
+            "pref.uiScale",
+            "Interface size",
+            "{scale?: a size from 0.75 to 3 relative to the system's display scale, 1 being the system's own size, so 1.25 is 125 %, not 125 (outside the range it stops at the nearest end; \"auto\" is 1; omit: just read it)} → {scale}: how large the whole interface is drawn; the canvas zoom is separate",
+            false,
+            |s, p| {
+                match get(p, "scale") {
+                    None => {}
+                    Some(Value::String(v)) if v.trim().eq_ignore_ascii_case("auto") => s.prefs.ui_scale = 1.0,
+                    Some(_) => {
+                        let scale = req_num("pref.uiScale", p, "scale")?;
+                        s.prefs.ui_scale = crate::clamp_ui_scale(scale).ok_or_else(|| bad("pref.uiScale", "`scale` must be a finite number"))?;
+                    }
+                }
+                Ok(json!({"scale": s.prefs.ui_scale}))
+            }
+        ),
         spec!("pref.autoSave", "Save files automatically", "{on?}", false, |s, p| pref(s, p, |x| &mut x.auto_save)),
         spec!("pref.startOnHome", "Start on the Home screen", "{on?}", false, |s, p| pref(s, p, |x| &mut x.start_on_home)),
         spec!("pref.nudge", "Nudge amount", "{small?, big?}", false, |s, p| {

crates/engine/src/lib.rs

@@ -604,6 +604,23 @@ impl DocState {
     }
 }
 
+/// The smallest and largest interface size, relative to the system's display scale (1.0 is the
+/// system's own size).
+pub const UI_SCALE_MIN: f64 = 0.75;
+pub const UI_SCALE_MAX: f64 = 3.0;
+
+/// `scale` kept between [`UI_SCALE_MIN`] and [`UI_SCALE_MAX`]; not a finite number: `None`.
+pub fn clamp_ui_scale(scale: f64) -> Option<f64> {
+    scale.is_finite().then(|| scale.clamp(UI_SCALE_MIN, UI_SCALE_MAX))
+}
+
+/// Reads the saved interface size. Anything but a number reads as 1 (the system's size) and a
+/// number out of range is clamped, so a settings file edited by hand never costs the other
+/// preferences.
+fn read_ui_scale<'de, D: serde::Deserializer<'de>>(d: D) -> std::result::Result<f64, D::Error> {
+    Ok(Value::deserialize(d)?.as_f64().and_then(clamp_ui_scale).unwrap_or(1.0))
+}
+
 /// App-wide preferences that commands read (nudge amounts, behaviours).
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
@@ -631,6 +648,11 @@ pub struct Prefs {
     /// Reduce motion: the interface's own animations are off (the system's setting turns them off
     /// too). Prototype transitions still play.
     pub reduce_motion: bool,
+    /// How large the whole interface is drawn, relative to the system's display scale: 1.0 is the
+    /// system's own size, 1.25 a quarter larger (kept between [`UI_SCALE_MIN`] and
+    /// [`UI_SCALE_MAX`]). The canvas zoom is separate.
+    #[serde(deserialize_with = "read_ui_scale")]
+    pub ui_scale: f64,
     /// Files that have a path are saved by themselves a few seconds after they change (the app's
     /// timer; off: only File ▸ Save writes them).
     pub auto_save: bool,
@@ -701,6 +723,7 @@ impl Default for Prefs {
             language: "system".into(),
             user_name: cmd::comment::DEFAULT_AUTHOR.into(),
             reduce_motion: false,
+            ui_scale: 1.0,
             auto_save: false,
             start_on_home: false,
             invite_links: None,