Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Merge PR #1554: Preferences: Units & Increments with no document open set the units of new documents, as in InDesign

aiongg2f8c43a079de
diff --cc crates/ui-egui/src/dialogs.rs
index 42b11bf1d,858f08a22..7dbf6c26d
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@@ -1749,9 -1749,9 +1750,10 @@@ fn preferences(app: &crate::DesignApp,
&[
("general", "General"),
("interface", "Interface"),
+ ("uiScaling", "UI Scaling"),
("type", "Type"),
("composition", "Composition"),
+ ("units", "Units & Increments"),
("spelling", "Spelling"),
("autocorrect", "Autocorrect"),
("notes", "Notes"),
diff --cc crates/ui-egui/src/dialogs/tests.rs
index 6978890b5,7b0c8b5ba..7d1ceaa7f
--- a/crates/ui-egui/src/dialogs/tests.rs
+++ b/crates/ui-egui/src/dialogs/tests.rs
@@@ -3525,444 -3522,56 +3525,498 @@@ fn character_style_options_set_the_digi
assert_eq!(char_style(&app, "Emphasis").unwrap().chars.digits, Some(designcraft_doc::Digits::Farsi));
}
+/// Replace the text of the field beside the `nth` label `label` (on its row, to its right) with
+/// `new`, and leave the field.
+fn retype_beside(h: &mut egui_kittest::Harness<'static, crate::test_window::Window>, label: &str, nth: usize, new: &str) {
+ use egui_kittest::kittest::Queryable;
+ let l = h.get_all_by_label(label).nth(nth).unwrap_or_else(|| panic!("no label {label} #{nth}")).rect();
+ let field = h
+ .get_all_by(|n| n.role() == egui::accesskit::Role::TextInput)
+ .map(|n| n.rect())
+ .filter(|r| r.center().x > l.max.x && (r.center().y - l.center().y).abs() < l.height().max(8.0))
+ .min_by(|a, b| a.min.x.total_cmp(&b.min.x))
+ .unwrap_or_else(|| panic!("no field beside {label} #{nth}"))
+ .center();
+ crate::test_window::click_at(h, field);
+ h.key_press_modifiers(egui::Modifiers::COMMAND, egui::Key::A);
+ h.event(egui::Event::Text(new.into()));
+ h.run_steps(1);
+ // Tab leaves the field (Enter would be the dialog's OK).
+ h.key_press(egui::Key::Tab);
+ h.run_steps(3);
+}
+
+/// The course's chapter 40: Paragraph Border's four weights are linked as InDesign's, so a
+/// side typed in sets all four; with the link off ("Make all settings the same") a side is set
+/// alone, as the lesson gives the border only a thick left side. The corners link the same way.
+#[test]
+fn paragraph_border_sides_and_corners_link_as_indesigns() {
+ use egui_kittest::kittest::Queryable;
+ let (app, _) = ruled_paragraph();
+ let mut h = crate::test_window::open(app, egui::vec2(1400.0, 900.0));
+ h.state_mut().app.ui.dialog = Some(Dialog::new("paragraphStyleOptions", json!({"name": "Ruled Child", "section": "border", "p.borderOn": true})));
+ h.run_steps(4);
+ let field = |h: &egui_kittest::Harness<'static, crate::test_window::Window>, key: &str| {
+ h.state().app.ui.dialog.as_ref().and_then(|d| d.fields.get(&format!("p.{key}")).cloned()).unwrap_or_default()
+ };
+ // The four weights start the same, so linked: Top sets them all.
+ retype_beside(&mut h, "Top:", 0, "3");
+ assert_eq!(field(&h, "borderWeights"), json!([3.0, 3.0, 3.0, 3.0]));
+ // Unlinked, Left alone takes 10 pt.
+ // The link of the weights (0), corners (1) or offsets (2), where it is now: the dialog
+ // scrolls as fields take focus.
+ let link = |h: &egui_kittest::Harness<'static, crate::test_window::Window>, n: usize| {
+ let links: Vec<egui::Rect> = h.get_all_by_label("Make all settings the same").map(|n| n.rect()).collect();
+ assert_eq!(links.len(), 3, "weights, corners and offsets each have a link");
+ links[n].center()
+ };
+ let at = link(&h, 0);
+ crate::test_window::click_at(&mut h, at);
+ retype_beside(&mut h, "Left:", 0, "10");
+ assert_eq!(field(&h, "borderWeights"), json!([3.0, 10.0, 3.0, 3.0]));
+ // Linked again, the four take Top's weight; unlinked once more for the thick left side.
+ let at = link(&h, 0);
+ crate::test_window::click_at(&mut h, at);
+ assert_eq!(field(&h, "borderWeights"), json!([3.0, 3.0, 3.0, 3.0]));
+ let at = link(&h, 0);
+ crate::test_window::click_at(&mut h, at);
+ retype_beside(&mut h, "Left:", 0, "10");
+ assert_eq!(field(&h, "borderWeights"), json!([3.0, 10.0, 3.0, 3.0]));
+ // The corners start the same too: Top Left's size goes to all four.
+ retype_beside(&mut h, "Top Left:", 0, "0p4");
+ let corners = field(&h, "borderCorners");
+ assert!((0..4).all(|i| corners[i]["size"] == json!(4.0)), "{corners}");
+ // Unlinked, Top Right alone takes 0p8; linked again, all four take Top Left's 4 pt.
+ let at = link(&h, 1);
+ crate::test_window::click_at(&mut h, at);
+ retype_beside(&mut h, "Top Right:", 0, "0p8");
+ assert_eq!(field(&h, "borderCorners")[1]["size"], json!(8.0));
+ assert_eq!(field(&h, "borderCorners")[0]["size"], json!(4.0));
+ let at = link(&h, 1);
+ crate::test_window::click_at(&mut h, at);
+ let corners = field(&h, "borderCorners");
+ assert!((0..4).all(|i| corners[i] == corners[0] && corners[i]["size"] == json!(4.0)), "{corners}");
+ confirm(&mut h.state_mut().app).unwrap();
+ let style = h.state().app.session.doc().unwrap().doc.styles.para("Ruled Child").cloned().unwrap();
+ assert_eq!(style.para.border_weights, Some([3.0, 10.0, 3.0, 3.0]));
+}
+
+/// Paragraph Rules › Color offers Text Color above the swatches, so a rule set to a swatch can
+/// go back to it; Gap Color lists only swatches.
+#[test]
+fn the_rule_colour_menu_offers_text_color() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let doc = app.session.doc().unwrap().doc.clone();
+ let menu = |ctx: &egui::Context, text: Option<&str>, click: Option<egui::Pos2>| {
+ let mut picked = None;
+ let mut labels = Vec::new();
+ let mut events = Vec::new();
+ if let Some(pos) = click {
+ events.push(egui::Event::PointerMoved(pos));
+ events.push(egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
+ events.push(egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
+ }
+ let input =
+ egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(600.0, 600.0))), events, ..Default::default() };
+ let mut out = ctx.run_ui(input, |ui| {
+ picked = swatch_menu_with(ui, &doc, "m", "[Black]", 130.0, text);
+ });
+ out.textures_delta.clear();
+ for s in out.shapes {
+ if let egui::Shape::Text(t) = s.shape {
+ labels.push((t.galley.job.text.clone(), t.visual_bounding_rect().center()));
+ }
+ }
+ (picked, labels)
+ };
+ for text in [Some("Text Color"), None] {
+ let ctx = egui::Context::default();
+ let (_, labels) = menu(&ctx, text, None);
+ let combo = labels.iter().find(|(t, _)| t == "[Black]").unwrap().1;
+ menu(&ctx, text, Some(combo));
+ let (_, labels) = menu(&ctx, text, None);
+ let item = labels.iter().find(|(t, _)| t == "Text Color").map(|l| l.1);
+ assert_eq!(item.is_some(), text.is_some(), "{labels:?}");
+ if let Some(pos) = item {
+ let (picked, _) = menu(&ctx, text, Some(pos));
+ assert_eq!(picked.as_deref(), Some(designcraft_doc::TEXT_COLOR));
+ }
+ }
+}
+
+/// The course's chapter 20: a paragraph style's rule below becomes wavy, 3 pt, with a gap
+/// colour, from Paragraph Rules › Type and Gap Color.
+#[test]
+fn paragraph_style_rules_take_a_type_and_a_gap_colour() {
+ let (mut app, _) = ruled_paragraph();
+ let ctx = egui::Context::default();
+ app.ui.dialog = Some(Dialog::new("paragraphStyleOptions", json!({"name": "Ruled Child", "section": "rules", "rule": "ruleBelow"})));
+ draw(&mut app, &ctx);
+ if let Some(d) = app.ui.dialog.as_mut() {
+ d.fields.insert("p.ruleBelow.type".into(), json!({"kind": "wavy"}));
+ d.fields.insert("p.ruleBelow.weight".into(), json!(3.0));
+ d.fields.insert("p.ruleBelow.gapColor".into(), json!("[Paper]"));
+ }
+ draw(&mut app, &ctx);
+ confirm(&mut app).unwrap();
+ let r = app.session.doc().unwrap().doc.styles.resolve_para_style("Ruled Child").0.rule_below;
+ assert_eq!((r.kind, r.weight, r.gap_color.as_str()), (designcraft_doc::StrokeType::Wavy, 3.0, "[Paper]"));
+}
+
+/// A rule's Gap Tint shows 100% at its default (the rule's JSON leaves a full gap tint out).
+#[test]
+fn a_rules_default_gap_tint_shows_100() {
+ use egui_kittest::kittest::Queryable;
+ let (mut app, _) = ruled_paragraph();
+ app.run(
+ "style.paragraph.edit",
+ json!({"name": "Ruled Child", "para": {"ruleBelow": {"type": {"kind": "dashed", "pattern": [4.0, 2.0]}, "gapColor": "[Paper]"}}}),
+ )
+ .unwrap();
+ let mut h = crate::test_window::open(app, egui::vec2(1400.0, 900.0));
+ h.state_mut().app.ui.dialog = Some(Dialog::new("paragraphStyleOptions", json!({"name": "Ruled Child", "section": "rules", "rule": "ruleBelow"})));
+ h.run_steps(4);
+ let label = h.get_by_label("Gap Tint:").rect();
+ let field = h
+ .get_all_by(|n| n.role() == egui::accesskit::Role::TextInput)
+ .filter(|n| n.rect().center().x > label.max.x && (n.rect().center().y - label.center().y).abs() < 8.0)
+ .min_by(|a, b| a.rect().min.x.total_cmp(&b.rect().min.x))
+ .and_then(|n| n.value());
+ assert_eq!(field.as_deref(), Some("100%"));
+}
+
+/// The course's chapter 20: the "Recipe Categories" title formatted on the page (size, All
+/// Caps, tracking, space after), then New Paragraph Style from it: the dialog starts from the
+/// text, and with Apply Style to Selection the paragraph takes the new style. Next Style and
+/// Reset To Base are set from General.
+#[test]
+fn a_new_paragraph_style_starts_from_the_selected_text() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let f = app.run("frame.create", json!({"rect": [36, 36, 400, 300], "content": "text", "text": "Egg Recipes\rBoil them."})).unwrap();
+ app.run("text.select", json!({"story": f["story"], "anchor": 0, "focus": 11})).unwrap();
+ app.run("type.char", json!({"attrs": {"size": 20, "capitalization": "allCaps", "tracking": 50}})).unwrap();
+ app.run("type.para", json!({"attrs": {"spaceAfter": 6}})).unwrap();
+ open_new_style(&mut app, true);
+ let d = app.ui.dialog.clone().unwrap();
+ assert_eq!(
+ (d.fields["c.size"].clone(), d.fields["c.capitalization"].clone(), d.fields["p.spaceAfter"].clone()),
+ (json!(20.0), json!("allCaps"), json!(6.0))
+ );
+ assert!(d.b("apply") && !d.fields.contains_key("c.fontFamily"), "only what differs from [No Paragraph Style]");
+ if let Some(d) = app.ui.dialog.as_mut() {
+ d.fields.insert("rename".into(), json!("Recipe Categories"));
+ d.fields.insert("nextStyle".into(), json!(designcraft_doc::BASIC_PARAGRAPH));
+ }
+ confirm(&mut app).unwrap();
+ let a = app.run("type.selectionAttrs", json!({})).unwrap();
+ assert_eq!(a["paragraphStyle"], "Recipe Categories", "applied to the selection");
+ assert_eq!(a["paraOverrides"].as_u64().unwrap_or(0) + a["charOverrides"].as_u64().unwrap_or(0), 0);
+ let style = |app: &DesignApp| app.session.doc().unwrap().doc.styles.para("Recipe Categories").cloned().unwrap();
+ assert_eq!(style(&app).next_style.as_deref(), Some(designcraft_doc::BASIC_PARAGRAPH));
+ assert_eq!(style(&app).chars.size, Some(20.0));
+ // Reset To Base: the style keeps nothing of its own, apart from the edits made then.
+ app.ui.dialog = Some(Dialog::new("paragraphStyleOptions", json!({"name": "Recipe Categories", "basedOn": designcraft_doc::BASIC_PARAGRAPH})));
+ if let Some(d) = app.ui.dialog.as_mut() {
+ d.fields.insert("resetToBase".into(), json!(true));
+ d.fields.insert("c.tracking".into(), json!(10.0));
+ }
+ confirm(&mut app).unwrap();
+ let s = style(&app);
+ assert_eq!((s.chars.size, s.chars.tracking, s.para.space_after), (None, Some(10.0), None), "{s:?}");
+ assert_eq!(s.based_on.as_deref(), Some(designcraft_doc::BASIC_PARAGRAPH));
+}
+
+/// The course's chapter 22: "eggs" made bold and red on the page, then New Character Style
+/// from it. The dialog is titled as InDesign's, starts from what the text has of its own
+/// over its paragraph style ("[None] + Bold + color"), and Apply Style to Selection gives the
+/// text the style, with no override left.
+#[test]
+fn a_new_character_style_starts_from_the_selected_text() {
+ use egui_kittest::{Harness, kittest::Queryable};
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let f = app.run("frame.create", json!({"rect": [36, 36, 400, 300], "content": "text", "text": "Drop eggs into boiling water."})).unwrap();
+ app.run("text.select", json!({"story": f["story"], "anchor": 0, "focus": 29})).unwrap();
+ app.run("style.paragraph.create", json!({"name": "Recipe", "chars": {"size": 14}})).unwrap();
+ app.run("style.paragraph.apply", json!({"name": "Recipe"})).unwrap();
+ app.run("text.select", json!({"story": f["story"], "anchor": 5, "focus": 9})).unwrap();
+ app.run("type.char", json!({"attrs": {"fontStyle": "Bold", "fill": "C=15 M=100 Y=100 K=0"}})).unwrap();
+ open_new_style(&mut app, false);
+ let d = app.ui.dialog.clone().unwrap();
+ assert_eq!((d.fields["c.fontStyle"].clone(), d.fields["c.fill"].clone()), (json!("Bold"), json!("C=15 M=100 Y=100 K=0")));
+ assert!(d.b("apply"));
+ let mut h = Harness::builder().with_size(egui::vec2(1000.0, 700.0)).build_ui_state(
+ |ui, app: &mut DesignApp| {
+ let key = egui::Id::unique("new_character_style_test_fonts");
+ if ui.data(|d| d.get_temp::<bool>(key)).is_none() {
+ crate::theme::install_fonts(ui.ctx(), "");
+ ui.data_mut(|d| d.insert_temp(key, true));
+ return;
+ }
+ show(app, ui.ctx());
+ },
+ app,
+ );
+ h.run_steps(4);
+ for l in ["New Character Style", "Apply Style to Selection"] {
+ assert!(h.query_by_label(l).is_some(), "{l}");
+ }
+ let app = h.state_mut();
+ if let Some(d) = app.ui.dialog.as_mut() {
+ d.fields.insert("rename".into(), json!("eggs"));
+ }
+ confirm(app).unwrap();
+ let style = app.session.doc().unwrap().doc.styles.char_style("eggs").cloned().unwrap();
+ assert_eq!((style.chars.font_style.as_deref(), style.chars.fill.as_deref()), (Some("Bold"), Some("C=15 M=100 Y=100 K=0")));
+ assert_eq!(style.chars.size, None, "the size is the paragraph style's, not the text's own");
+ let a = app.run("type.selectionAttrs", json!({})).unwrap();
+ assert_eq!((a["characterStyle"].clone(), a["charOverrides"].clone()), (json!("eggs"), json!(0)), "applied to the selection");
+}
+
+/// A Based On changed in the dialog (without Reset To Base) is what the fields are checked
+/// against: the style's own settings over the new parent.
+#[test]
+fn a_changed_based_on_is_what_the_fields_are_checked_against() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ app.run("style.paragraph.create", json!({"name": "Loose", "para": {"wordSpaceMin": 1.2, "wordSpaceDesired": 1.3}})).unwrap();
+ app.run("style.paragraph.create", json!({"name": "Child", "basedOn": "Loose"})).unwrap();
+ let mut d = Dialog::new("paragraphStyleOptions", json!({"name": "Child"}));
+ d.fields.insert("p.wordSpaceDesired".into(), json!(1.0));
+ assert!(check_paragraph_style_justification(&app, &d).is_err(), "below Loose's minimum");
+ d.fields.insert("basedOn".into(), json!(designcraft_doc::BASIC_PARAGRAPH));
+ assert_eq!(check_paragraph_style_justification(&app, &d), Ok(()), "[Basic Paragraph]'s minimum is lower");
+}
+
+/// With Reset To Base, the justification fields are checked against the base style (the
+/// style's own minimum no longer applies), and Preview shows the reset on the page.
+#[test]
+fn reset_to_base_checks_and_previews_against_the_base() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let f = app.run("frame.create", json!({"rect": [36, 36, 400, 300], "content": "text", "text": "Loose words"})).unwrap();
+ app.run("text.select", json!({"story": f["story"], "anchor": 0, "focus": 5})).unwrap();
+ app.run("style.paragraph.create", json!({"name": "Loose", "basedOn": designcraft_doc::BASIC_PARAGRAPH, "para": {"wordSpaceMin": 1.2, "wordSpaceDesired": 1.3}, "chars": {"size": 30}}))
+ .unwrap();
+ app.run("style.paragraph.apply", json!({"name": "Loose"})).unwrap();
+ let mut d = Dialog::new("paragraphStyleOptions", json!({"name": "Loose"}));
+ d.fields.insert("p.wordSpaceDesired".into(), json!(1.1));
+ assert!(check_paragraph_style_justification(&app, &d).is_err(), "below the style's own minimum");
+ d.fields.insert("resetToBase".into(), json!(true));
+ assert_eq!(check_paragraph_style_justification(&app, &d), Ok(()), "the base's minimum is 100%");
+ d.fields.insert("preview".into(), json!(true));
+ style_options_preview(&mut app, &mut d);
+ assert_eq!(d.fields[PREVIEWED]["resetToBase"], true);
+ let size = app.run("type.selectionAttrs", json!({})).unwrap()["chars"]["size"].clone();
+ assert_eq!(size, json!(12.0), "the page shows the style reset to its base");
+ app.session.cancel_interaction();
+}
+
+/// The course's chapter 22: Find/Change › Change Format. "eggs", case sensitive, nothing in
+/// Change to; Change Format Settings › Style Options sets Character Style "eggs", and the box
+/// shows it (with Change to's ⓘ). Escape leaves the settings, not Find/Change. Change All
+/// gives every lowercase "eggs" the style and keeps the words; the trash clears the format.
+#[test]
+fn find_change_gives_the_found_text_a_change_format() {
+ use egui_kittest::{Harness, kittest::Queryable};
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let text = "Poached Eggs\nBreak eggs; cook until eggs are set.";
+ let f = app.run("frame.create", json!({"rect": [36, 36, 400, 300], "content": "text", "text": text})).unwrap();
+ let sid = designcraft_doc::StoryId(f["story"].as_u64().unwrap());
+ app.run("style.character.create", json!({"name": "eggs", "chars": {"fontStyle": "Bold"}})).unwrap();
+ app.run("app.findChange", json!({})).unwrap();
+ if let Some(d) = app.ui.dialog.as_mut() {
+ d.fields.insert("find".into(), json!("eggs"));
+ d.fields.insert("caseSensitive".into(), json!(true));
+ }
+ let mut h = Harness::builder().with_size(egui::vec2(1200.0, 900.0)).build_ui_state(
+ |ui, app: &mut DesignApp| {
+ let key = egui::Id::unique("change_format_test_fonts");
+ if ui.data(|d| d.get_temp::<bool>(key)).is_none() {
+ crate::theme::install_fonts(ui.ctx(), "");
+ ui.data_mut(|d| d.insert_temp(key, true));
+ return;
+ }
+ show(app, ui.ctx());
+ },
+ app,
+ );
+ h.run_steps(4);
+ const TIP: &str = "With a Change Format and nothing in Change to, the found text stays and is only formatted";
+ assert!(h.query_by_label("Change Format:").is_some());
+ assert!(h.query_by_label(TIP).is_none(), "no ⓘ without a Change Format");
+ h.get_by_label("Specify attributes to change").click();
+ h.run_steps(3);
+ // Style Options is the section's name in the list and its heading.
+ for l in ["Change Format Settings", "Style Options", "Basic Character Formats", "Character Color"] {
+ assert!(h.query_all_by_label(l).next().is_some(), "{l}");
+ }
+ // Style Options › Character Style: eggs.
+ h.get_all_by_value("[Any Style]").next().unwrap().click();
+ h.run_steps(3);
+ h.get_by_label("eggs").click();
+ h.run_steps(3);
+ h.get_all_by_label(" OK ").last().unwrap().click();
+ h.run_steps(3);
+ let field = |h: &Harness<'_, DesignApp>, k: &str| h.state().ui.dialog.as_ref().unwrap().fields.get(k).cloned();
+ assert_eq!((field(&h, CHANGE_FORMAT), field(&h, FORMAT_EDIT)), (Some(json!({"charStyle": "eggs"})), None));
+ assert!(h.query_by_label("Character Style: eggs").is_some(), "the box shows it");
+ assert!(h.query_by_label(TIP).is_some(), "Change to's ⓘ");
+ // Escape closes Change Format Settings only, and keeps the Change Format.
+ h.get_by_label("Specify attributes to change").click();
+ h.run_steps(3);
+ h.key_press(egui::Key::Escape);
+ h.run_steps(3);
+ assert_eq!(h.state().ui.dialog.as_ref().map(|d| d.id.as_str()), Some("findChange"));
+ assert_eq!((field(&h, CHANGE_FORMAT), field(&h, FORMAT_EDIT)), (Some(json!({"charStyle": "eggs"})), None));
+ // Change All: the words stay, every lowercase "eggs" has the style.
+ h.get_by_label("Change All").click();
+ h.run_steps(3);
+ assert_eq!(field(&h, "status"), Some(json!("2 replacement(s) made")));
+ let story = h.state().session.doc().unwrap().doc.story(sid).cloned().unwrap();
+ assert_eq!(story.text, text);
+ assert_eq!(
+ [8, 19, 36].map(|at| story.format_after(at).style.clone()),
+ [designcraft_doc::NO_CHAR_STYLE.to_string(), "eggs".into(), "eggs".into()]
+ );
+ // The trash clears it.
+ h.get_by_label("Clear specified attributes").click();
+ h.run_steps(3);
+ assert_eq!(field(&h, CHANGE_FORMAT), None);
+ assert!(h.query_by_label(TIP).is_none());
+}
+
+/// What Change Format Settings sets goes to find.change: a paragraph style and character
+/// attributes as well as a character style; the box sums them up.
+#[test]
+fn a_change_format_goes_with_change_all() {
+ let mut d = Dialog::new("findChange", json!({"find": "cook"}));
+ d.fields.insert(CHANGE_FORMAT.into(), json!({"charStyle": "eggs", "paraStyle": "Method", "chars": {"underline": true}}));
+ let p = find_change_params(&d);
+ assert_eq!((p["charStyle"].clone(), p["paraStyle"].clone(), p["attrs"].clone()), (json!("eggs"), json!("Method"), json!({"underline": true})));
+ assert_eq!(change_format_summary("en", d.fields.get(CHANGE_FORMAT)), "Character Style: eggs + Paragraph Style: Method + Underline: on");
+ assert!(find_change_params(&Dialog::new("findChange", json!({"find": "cook"}))).get("attrs").is_none());
+}
+
+/// The course's chapter 26: Preferences › Interface as InDesign's. A Color Theme swatch shows
+/// its theme at once and Cancel goes back; OK keeps the theme and the Tools panel's columns.
+/// UI Size is in a UI Scaling section of its own.
+#[test]
+fn preferences_interface_sets_the_color_theme_and_tools_panel() {
+ use crate::theme::Brightness;
+ use egui::accesskit::Role;
+ use egui_kittest::{Harness, kittest::Queryable};
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let opened = app.ui.brightness;
+ let open = |app: &mut DesignApp| {
+ app.run("app.preferences", json!({})).unwrap();
+ app.ui.dialog.as_mut().unwrap().fields.insert("section".into(), json!("interface"));
+ };
+ open(&mut app);
+ let mut h = Harness::builder().with_size(egui::vec2(1100.0, 760.0)).build_ui_state(
+ |ui, app: &mut DesignApp| {
+ let key = egui::Id::unique("prefs_interface_test_fonts");
+ if ui.data(|d| d.get_temp::<bool>(key)).is_none() {
+ crate::theme::install_fonts(ui.ctx(), "");
+ ui.data_mut(|d| d.insert_temp(key, true));
+ return;
+ }
+ show(app, ui.ctx());
+ },
+ app,
+ );
+ h.run_steps(3);
+ let swatch = |h: &Harness<'_, DesignApp>, name: &str| h.get_by(|n| n.role() == Role::RadioButton && n.label().as_deref() == Some(name)).click();
+ for l in ["Appearance", "Color Theme:", "Panels", "Tools Panel:"] {
+ assert!(h.query_by_label(l).is_some(), "{l}");
+ }
+ // A click shows the theme at once; Cancel goes back.
+ swatch(&h, "Light");
+ h.run_steps(3);
+ assert_eq!(h.state().ui.brightness, Brightness::Light);
+ h.get_by_label("Cancel").click();
+ h.run_steps(3);
+ assert!(h.state().ui.dialog.is_none());
+ assert_eq!(h.state().ui.brightness, opened, "Cancel goes back to the theme Preferences opened with");
+ // OK keeps the theme and the Tools panel's columns.
+ open(h.state_mut());
+ h.run_steps(3);
+ swatch(&h, "Dark");
+ h.run_steps(2);
+ h.get_by(|n| n.role() == Role::ComboBox && n.value().as_deref() == Some("Single Column")).click();
+ h.run_steps(2);
+ h.get_by_label("Double Column").click();
+ h.run_steps(2);
+ h.get_by_label(" OK ").click();
+ h.run_steps(3);
+ assert!(h.state().ui.dialog.is_none());
+ assert_eq!(h.state().ui.brightness, Brightness::Dark);
+ assert!(h.state().ui.tools_double_column);
+ // The same command the Window menu toggles, with an explicit state for Preferences.
+ assert_eq!(h.state_mut().run("window.toolsDoubleColumn", json!({"on": false})).unwrap(), json!(false));
+ assert_eq!(h.state_mut().run("window.toolsDoubleColumn", json!({"on": false})).unwrap(), json!(false), "set, not toggled");
+ assert_eq!(h.state_mut().run("window.toolsDoubleColumn", json!({})).unwrap(), json!(true), "toggled without `on`");
+ // UI Size has a section of its own.
+ open(h.state_mut());
+ h.state_mut().ui.dialog.as_mut().unwrap().fields.insert("section".into(), json!("uiScaling"));
+ h.run_steps(3);
+ assert!(h.query_by_label("UI Size:").is_some());
+}
++
+ /// With no document open, Preferences has Units & Increments, as InDesign's: OK keeps them
+ /// for new documents, and New Document opens in them (Lollo's inches, set once).
+ #[test]
+ fn preferences_with_no_document_set_the_units_of_new_documents() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ crate::menus::activate(&mut app, "app.preferences", &Value::Null);
+ let mut d = app.ui.dialog.take().expect("Preferences");
+ assert!(d.b("defaults"), "for new documents");
+ let ctx = dialog_context("en");
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1178.0, 814.0));
+ app.ui.dialog = Some(d.clone());
+ let mut labels = vec![];
+ for _ in 0..3 {
+ labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ assert!(labels.iter().any(|(t, _, _)| t == "Units & Increments"), "listed with no document: {labels:?}");
+ d.fields.insert("horizontalUnits".into(), json!("inches"));
+ d.fields.insert("verticalUnits".into(), json!("inches"));
+ d.fields.insert("keyboardIncrement".into(), json!("0.5 pt"));
+ app.ui.dialog = Some(d);
+ confirm(&mut app).unwrap();
+ let du = app.session.prefs.default_units;
+ assert_eq!((du.horizontal_units, du.vertical_units, du.keyboard_increment), (Unit::Inches, Unit::Inches, 0.5));
+ assert!(app.session.active().is_none(), "no document made");
+ // A Cursor Key of 0 or text that isn't a measure is refused, keeping the dialog open and
+ // the saved values, the other preferences' too; a Kerning/Tracking of 0.5 is kept as it is.
+ let scale = app.session.prefs.scale_strokes;
+ for bad in [json!({"keyboardIncrement": "0 pt"}), json!({"keyboardIncrement": "wide"}), json!({"kerningIncrement": "lots"})] {
+ let mut d = Dialog::new("preferences", json!({"defaults": true, "horizontalUnits": "inches", "scaleStrokes": !scale}));
+ for (k, v) in bad.as_object().unwrap() {
+ d.fields.insert(k.clone(), v.clone());
+ }
+ app.ui.dialog = Some(d);
+ assert!(confirm(&mut app).is_err(), "{bad}");
+ assert!(app.ui.dialog.as_ref().is_some_and(|d| d.id == "preferences"), "still open: {bad}");
+ assert_eq!(app.session.prefs.default_units.keyboard_increment, 0.5, "{bad}");
+ assert_eq!(app.session.prefs.scale_strokes, scale, "no other preference saved: {bad}");
+ }
+ app.ui.dialog = Some(Dialog::new("preferences", json!({"defaults": true, "horizontalUnits": "inches", "kerningIncrement": "0.5"})));
+ confirm(&mut app).unwrap();
+ assert_eq!(app.session.prefs.default_units.kerning_increment, 0.5, "not rounded up to 1");
+ // New Document opens in inches, and the document it makes has inch rulers.
+ crate::menus::activate(&mut app, "app.newDocumentDialog", &Value::Null);
+ let nd = app.ui.dialog.clone().expect("New Document");
+ assert_eq!(nd.fields["units"], json!("inches"));
+ assert_eq!(nd.s("width"), designcraft_geom::format_measure(612.0, Unit::Inches));
+ confirm(&mut app).unwrap();
+ let st = &app.session.doc().unwrap().doc.settings;
+ assert_eq!((st.horizontal_units, st.vertical_units, st.keyboard_increment), (Unit::Inches, Unit::Inches, 0.5));
+ // With the document open, Preferences edits that document's units, not the defaults.
+ crate::menus::activate(&mut app, "app.preferences", &Value::Null);
+ assert!(!app.ui.dialog.as_ref().unwrap().b("defaults"));
+ }