DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Merge PR #1513: Preferences › File Handling: Number of Recent Items shows 20, not 20.0
aiongged53f8a7446c
diff --cc ROADMAP.mdindex 988155794,6700c0df8..de3bb0fb3--- a/ROADMAP.md+++ b/ROADMAP.md@@@ -457,12 -443,7 +457,13 @@@ Newest first- **2026-10-16** · Lock Guides and Lock Column Guides are commands in View ▸ Grids & Guides (`view.lockGuides`, ⌥⌘;, and `view.lockColumnGuides`), so the control channel and MCP reach them. Lock Column Guides is an undo step, is saved with the document, on in new ones, and read from and written to IDML's `ColumnGuideLocked`, which export always wrote as locked (#1096). No readiness percentage change.- **2026-10-16** · IDML: a page keeps column guides that were dragged off centre (InDesign's Custom columns). They were divided evenly on import, so the gutter sprang back to the middle; the imported positions now place the columns, with the canvas guides, snapping and text placement following them, and they are written back on export. Layout › Margins and Columns re-divides them evenly when the count or gutter changes, as InDesign's does. No readiness percentage change.- **2026-10-16** · IDML: custom column positions are checked before they are used (#1096). A set must give two edges per column, ascending from the left margin to the right one; any other (a wrong count, unsorted or non-numeric values, a list longer than 216 columns allow, or positions left behind by a margin or page-size change) is the even split, in the canvas, on import and on export, instead of columns drawn outside the margins. No readiness percentage change.+- **2026-10-21** · Paragraph Border and Paragraph Shading link their four sides as InDesign's: the stroke weights, offsets and corners have the "Make all settings the same" link, on when the four are the same, so a side typed in sets all four; with the link off a side is set alone (a border with only a thick left side). Found in the Learn Skills Daily course, chapter 40. No readiness percentage change.+- **2026-10-21** · Paragraph rules have InDesign's Type (solid, thick/thin stripes, dashed, dotted, straight hash, wavy, or a stroke style of the document), Gap Color and Gap Tint, and Keep In Frame (rule above); the Paragraph Rules page is laid out as InDesign's (Weight and Type, Color and Tint, Gap Color and Gap Tint, Width and Offset, Left and Right Indent). IDML reads and writes them (`RuleAboveType`, `RuleBelowGapColor`, `KeepRuleAboveInFrame`…). Found in the Learn Skills Daily course, chapter 20. No readiness percentage change.+- **2026-10-21** · New Character Style with text selected starts from what the text has of its own over its paragraph style, as InDesign's ("[None] + Bold + color"), and Apply Style to Selection gives the text the new style, with no override left. A new style's dialog is titled New Paragraph Style / New Character Style. `type.selectionAttrs` reports the text's own character attributes (`ownChars`). Found in the Learn Skills Daily course, chapter 22. No readiness percentage change.+- **2026-10-21** · New Paragraph Style with text selected starts from it, as InDesign's (Based On [No Paragraph Style], every setting of the text that differs) and Apply Style to Selection gives the paragraph the new style; General has Next Style and Reset To Base; Basic Character Formats is in two columns (Size | Leading, Kerning | Tracking, Case | Position). `style.paragraph.edit` honours `nextStyle` (it was ignored) and takes `resetToBase`. Found in the Learn Skills Daily course, chapter 20. No readiness percentage change.+- **2026-10-21** · Find/Change has InDesign's Change Format. Specify Attributes opens Change Format Settings: Style Options (the character and paragraph style to apply, [Any Style] for none), then Basic and Advanced Character Formats, Character Color, OpenType Features, Underline and Strikethrough Options. The box shows the format ("Character Style: eggs"), and Change All gives it to the changed text. With a Change Format and nothing in Change to, the found text stays and is only formatted, as InDesign's (an ⓘ beside Change to says so). `find.change` takes `charStyle` and `paraStyle`. Found in the Learn Skills Daily course, chapter 22. No readiness percentage change.+- **2026-10-21** · Preferences › Interface follows InDesign's: Appearance has a Color Theme swatch per interface theme (a click shows it at once, Cancel goes back) and Panels sets the Tools panel to a single or double column; UI Size moves to a UI Scaling section of its own. Interface held only UI Size, and the theme could be changed only from the Window menu. Found in the Learn Skills Daily course, chapter 26. No readiness percentage change.+ - **2026-10-21** · Preferences › File Handling shows Number of Recent Items to Display as a whole number ("20"; it read "20.0"). Found in the Learn Skills Daily course, chapter 26. No readiness percentage change.- **2026-10-21** · Properties › Character and Paragraph: ••• (More Options) expands the section in place, as InDesign's: Character adds vertical and horizontal scale, baseline shift, skew, language and OpenType, and All Caps, Small Caps, Superscript, Subscript, Underline and Strikethrough; Paragraph adds the left, right, first line and last line indents, space before and after, the drop cap's lines and characters, Align to Baseline Grid and Hyphenate. It used to open the Character or Paragraph panel; the language field moved under ••• as in InDesign. Found in the Learn Skills Daily course, chapter 16. No readiness percentage change.- **2026-10-21** · The text Control panel has InDesign's two modes: A (Character Formatting Controls: font and style, size and leading, All Caps/Superscript/Underline and Small Caps/Subscript/Strikethrough, kerning and tracking, vertical and horizontal scale, baseline shift and skew, character style and language) and ¶ (Paragraph Formatting Controls: the nine alignments, left/first line and right/last line indents, space before and after, the drop cap's lines and characters, paragraph style, Hyphenate and Align to Baseline Grid). It used to show a fixed mix of both. Found in the Learn Skills Daily course, chapter 16. No readiness percentage change.- **2026-10-20** · With the Type tool, the Control panel's font size, leading and tracking fields have a spinner and a list of common values, as in InDesign (auto leading in parentheses). No readiness percentage change.diff --cc crates/ui-egui/src/dialogs/tests.rsindex 7d1ceaa7f,167158d84..c75950b9a--- a/crates/ui-egui/src/dialogs/tests.rs+++ b/crates/ui-egui/src/dialogs/tests.rs@@@ -3525,498 -3522,21 +3525,517 @@@ fn character_style_options_set_the_digiassert_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"));+}+++ /// Preferences › File Handling shows the number of recent items as a whole number, as+ /// InDesign's does ("20"; it read "20.0").+ #[test]+ fn file_handling_shows_the_recent_items_count_as_a_whole_number() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("app.preferences", json!({})).unwrap();+ app.ui.dialog.as_mut().unwrap().fields.insert("section".into(), json!("files"));+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1000.0, 700.0));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&labels, screen, "Number of Recent Items to Display:");+ let count = app.ui.dialog.as_ref().unwrap().n("recentFilesMax").unwrap();+ assert_eq!(count, 20.0, "InDesign's default");+ visible_label(&labels, screen, &format!("{count}"));+ assert!(!labels.iter().any(|(t, _, _)| t.trim() == format!("{count:.1}")), "no decimal shown");+ }