DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Merge main into fix/1964-frame-size-units
Zinadin Zidan1afbc95900db
diff --cc crates/ui-egui/src/dialogs.rsindex b976887cd,253deebd3..a3448e23a--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@@ -935,28 -1070,9 +1071,29 @@@ fn doc_unit(app: &DesignApp) -> Unitapp.session.active().map(|s| s.doc.settings.horizontal_units).unwrap_or(Unit::Picas)}+/// The document's vertical ruler unit: what a bare number means in a height field.+fn doc_vertical_unit(app: &DesignApp) -> Unit {+ app.session.active().map(|s| s.doc.settings.vertical_units).unwrap_or(Unit::Picas)+}++/// The Rectangle dialog a click with a frame tool opens: the width (points in `params`) shown in+/// the horizontal ruler unit, the height in the vertical one, as Preferences › Units &+/// Increments and the rulers' menus set them (#1964).+pub fn frame_size_dialog(app: &DesignApp, params: Value) -> Dialog {+ let mut d = Dialog::new("frameSize", params);+ for (k, unit) in [("width", doc_unit(app)), ("height", doc_vertical_unit(app))] {+ if let Some(v) = d.fields.get(k).and_then(Value::as_f64) {+ d.fields.insert(k.into(), json!(format_measure(v, unit)));+ }+ }+ d.unit = doc_unit(app);+ d.vertical_unit = Some(doc_vertical_unit(app));+ d+}+- /// Layout › Create Guides…: guides go on the page in view (or the parent page being edited), not- /// on the first page, and the gutters are typed in the document's ruler unit.+ /// Layout › Create Guides…: guides go on every page of the spread in view (or of the parent+ /// spread being edited), as InDesign's do; "This page" narrows them to+ /// the page in view. The gutters are typed in the document's ruler unit.pub fn open_create_guides(app: &mut DesignApp) {let unit = doc_unit(app);let Some((spread, page)) = crate::canvas::current_spread_page(app) else { return };@@@ -3249,6 -3460,203 +3481,207 @@@ fn find_change_params(d: &Dialog) -> Vap}+ /// Find/Change's Change Format ({charStyle?, paraStyle?, chars?}), as Change Format Settings set+ /// it; absent when there is none.+ const CHANGE_FORMAT: &str = "changeFormat";+ /// The fields of Change Format Settings while it is open (its section, `charStyle`, `paraStyle`+ /// and `c.<attr>`), until OK makes them the Change Format.+ const FORMAT_EDIT: &str = "formatEdit";++ /// The sections of Change Format Settings: Style Options, then those of Character Style Options.+ const FORMAT_SECTIONS: &[(&str, &str)] = &[+ ("style", "Style Options"),+ ("chars", "Basic Character Formats"),+ ("advanced", "Advanced Character Formats"),+ ("color", "Character Color"),+ ("openType", "OpenType Features"),+ ("underline", "Underline Options"),+ ("strikethrough", "Strikethrough Options"),+ ];++ /// A small ⓘ whose tooltip is `tip`.+ fn info_icon(ui: &mut egui::Ui, tip: &str) {+ let (r, resp) = ui.allocate_exact_size(egui::vec2(16.0, 16.0), egui::Sense::hover());+ crate::icons::paint(ui.painter(), r, "info", crate::theme::Tokens::get(ui.ctx()).icon);+ resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Label, true, tip));+ resp.on_hover_text(tip);+ }++ /// What the Change Format box shows: "Character Style: eggs + …".+ fn change_format_summary(lang: &str, format: Option<&Value>) -> String {+ let Some(f) = format else { return String::new() };+ let mut parts = Vec::new();+ for (key, label) in [("charStyle", "Character Style:"), ("paraStyle", "Paragraph Style:")] {+ if let Some(name) = f.get(key).and_then(Value::as_str) {+ parts.push(format!("{} {}", crate::i18n::tr(lang, label), crate::i18n::style_name(lang, name)));+ }+ }+ parts.extend(+ f.get("chars").and_then(Value::as_object).into_iter().flatten().map(|(k, v)| format!("{}: {}", setting_label(lang, k), setting_text(v))),+ );+ parts.join(" + ")+ }++ /// Find/Change's Change Format, as InDesign's: a box with what Change All also gives the changed+ /// text, a button that opens Change Format Settings and one that clears it.+ fn change_format_box(lang: &str, ui: &mut egui::Ui, d: &mut Dialog) {+ ui.add_space(6.0);+ crate::rtl::label(ui, crate::i18n::tr(lang, "Change Format:"));+ ui.horizontal_top(|ui| {+ let t = crate::theme::Tokens::get(ui.ctx());+ egui::Frame::new().fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(6.0).show(ui, |ui| {+ ui.set_width(340.0);+ ui.set_min_height(40.0);+ let summary = change_format_summary(lang, d.fields.get(CHANGE_FORMAT));+ ui.add(egui::Label::new(egui::RichText::new(summary).color(t.text)).wrap());+ });+ ui.vertical(|ui| {+ if crate::icons::button(ui, "find-format", 22.0, false, crate::i18n::tr(lang, "Specify attributes to change")).clicked() {+ let f = d.fields.get(CHANGE_FORMAT).cloned().unwrap_or_default();+ let mut edit = Map::new();+ edit.insert("section".into(), json!("style"));+ for key in ["charStyle", "paraStyle"] {+ if let Some(v) = f.get(key) {+ edit.insert(key.into(), v.clone());+ }+ }+ for (k, v) in f.get("chars").and_then(Value::as_object).into_iter().flatten() {+ edit.insert(format!("c.{k}"), v.clone());+ }+ d.fields.insert(FORMAT_EDIT.into(), Value::Object(edit));+ }+ if crate::icons::button(ui, "trash", 22.0, false, crate::i18n::tr(lang, "Clear specified attributes")).clicked() {+ d.fields.remove(CHANGE_FORMAT);+ }+ });+ });+ }++ /// Find/Change › Change Format Settings, over Find/Change as InDesign's: Style Options (the+ /// character and paragraph style to apply, [Any Style] for none), then the character sections of+ /// Character Style Options with every field blank (left as it is). OK makes it the Change Format.+ fn change_format_settings(app: &mut DesignApp, ctx: &egui::Context, d: &mut Dialog) {+ let lang = app.ui.language.clone();+ let Some(doc) = app.session.active().map(|st| st.doc.clone()) else {+ d.fields.remove(FORMAT_EDIT);+ return;+ };- let mut fd =- Dialog { id: "changeFormat".into(), fields: d.fields.get(FORMAT_EDIT).and_then(Value::as_object).cloned().unwrap_or_default(), unit: d.unit };++ let mut fd = Dialog {++ id: "changeFormat".into(),++ fields: d.fields.get(FORMAT_EDIT).and_then(Value::as_object).cloned().unwrap_or_default(),++ unit: d.unit,++ vertical_unit: None,++ };+ let base = json!({});+ let cf = CharFields { base: &base, sparse: true };+ let popup_open = egui::Popup::is_any_open(ctx);+ let mut result = None;+ let host = egui::Id::unique("change_format_settings");+ crate::modal_drag::modal(ctx, host, host).backdrop_color(egui::Color32::TRANSPARENT).show(ctx, |ui| {+ let title_top = ui.cursor().top();+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&lang, "Change Format Settings")).font(semibold(16.0)));+ let margin = egui::Frame::popup(ui.style()).inner_margin;+ let title_row = egui::Rect::from_min_max(+ egui::pos2(ui.max_rect().left() - margin.leftf(), title_top - margin.topf()),+ egui::pos2(ui.max_rect().right() + margin.rightf(), ui.min_rect().bottom()),+ );+ crate::modal_drag::title_drag(ui, host, title_row);+ ui.add_space(10.0);+ ui.horizontal_top(|ui| {+ // A fixed height: the separator would otherwise stretch the dialog to the window.+ ui.set_min_height(380.0);+ ui.set_max_height(380.0);+ section_list(&lang, ui, &mut fd, false, FORMAT_SECTIONS);+ ui.separator();+ ui.vertical(|ui| {+ ui.set_min_width(440.0);+ match fd.s("section").as_str() {+ "chars" => basic_character_formats(app, ui, &mut fd, &cf),+ "advanced" => advanced_character_formats(&lang, ui, &mut fd, &cf),+ "color" => character_color(&lang, ui, &mut fd, &cf, &doc),+ "openType" => open_type_features(&lang, ui, &mut fd, &cf),+ "underline" => line_options(&lang, ui, &mut fd, &cf, &doc, "underline"),+ "strikethrough" => line_options(&lang, ui, &mut fd, &cf, &doc, "strikethrough"),+ _ => format_style_options(&lang, ui, &mut fd, &doc.styles),+ }+ });+ });+ ui.add_space(12.0);+ ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {+ if ui+ .add(+ egui::Button::new(crate::rtl::widget(ui, egui::RichText::new(crate::i18n::tr(&lang, " OK ")).color(egui::Color32::WHITE)))+ .fill(crate::theme::Tokens::get(ui.ctx()).accent_strong),+ )+ .clicked()+ || (!popup_open && ui.input(|i| i.key_pressed(egui::Key::Enter)))+ {+ result = Some(true);+ }+ if ui.button(crate::rtl::widget(ui, crate::i18n::tr(&lang, "Cancel"))).clicked()+ || (!popup_open && ui.input(|i| i.key_pressed(egui::Key::Escape)))+ {+ result = Some(false);+ }+ });+ });+ match result {+ Some(true) => {+ d.fields.remove(FORMAT_EDIT);+ let mut f = Map::new();+ for key in ["charStyle", "paraStyle"] {+ if let Some(v) = fd.fields.get(key).filter(|v| v.is_string()) {+ f.insert(key.into(), v.clone());+ }+ }+ let chars: Map<String, Value> =+ fd.fields.iter().filter(|(_, v)| !v.is_null()).filter_map(|(k, v)| Some((k.strip_prefix("c.")?.to_string(), v.clone()))).collect();+ if !chars.is_empty() {+ f.insert("chars".into(), Value::Object(chars));+ }+ if f.is_empty() {+ d.fields.remove(CHANGE_FORMAT);+ } else {+ d.fields.insert(CHANGE_FORMAT.into(), Value::Object(f));+ }+ }+ Some(false) => {+ d.fields.remove(FORMAT_EDIT);+ }+ None => {+ d.fields.insert(FORMAT_EDIT.into(), Value::Object(fd.fields));+ }+ }+ }++ /// Change Format Settings › Style Options: the character and paragraph style the changed text+ /// gets ([Any Style]: as it is).+ fn format_style_options(lang: &str, ui: &mut egui::Ui, fd: &mut Dialog, styles: &designcraft_doc::Styles) {+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(lang, "Style Options")).font(semibold(13.0)));+ ui.add_space(6.0);+ let any = crate::i18n::tr(lang, "[Any Style]");+ let chars: Vec<&str> = styles.character.iter().map(|s| s.name.as_str()).collect();+ let paras: Vec<&str> = styles.paragraph.iter().map(|s| s.name.as_str()).collect();+ egui::Grid::new("format_style_options").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ for (key, label, names) in [("charStyle", "Character Style:", &chars), ("paraStyle", "Paragraph Style:", ¶s)] {+ crate::rtl::label(ui, crate::i18n::tr(lang, label));+ let cur = fd.fields.get(key).and_then(Value::as_str).map(str::to_string);+ let shown = cur.as_deref().map_or_else(|| any.to_string(), |n| crate::i18n::style_name(lang, n).to_string());+ craft_ui::ComboBox::from_id_salt(("format_style", key)).selected_text(crate::rtl::widget(ui, shown)).width(240.0).show_ui(ui, |ui| {+ if ui.selectable_label(cur.is_none(), crate::rtl::widget(ui, any)).clicked() {+ fd.fields.remove(key);+ }+ for n in names.iter() {+ if ui.selectable_label(cur.as_deref() == Some(*n), crate::rtl::widget(ui, crate::i18n::style_name(lang, n))).clicked() {+ fd.fields.insert(key.into(), json!(n));+ }+ }+ });+ ui.end_row();+ }+ });+ }+/// Apply the open dialog.pub fn confirm(app: &mut DesignApp) -> Result<Value, String> {let Some(d) = app.ui.dialog.take() else { return Err("no dialog open".into()) };diff --cc crates/ui-egui/src/dialogs/tests.rsindex e195a8c23,8a80198ea..98b0f7044--- a/crates/ui-egui/src/dialogs/tests.rs+++ b/crates/ui-egui/src/dialogs/tests.rs@@@ -3522,85 -3527,812 +3527,895 @@@ 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");+ }++ /// Collapsing advanced TOC controls changes visibility without discarding their values.+ #[test]+ fn toc_more_options_preserves_hidden_settings() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.newSample", json!({})).unwrap();+ open_toc(&mut app);+ app.ui.dialog.as_mut().unwrap().fields.insert(+ "included".into(),+ json!([{+ "style": "Headline", "level": 3, "separator": " ^t", "pageNumber": "before",+ "pageNumberStyle": "Accent", "separatorStyle": "Emphasis", "sort": true+ }]),+ );+ let before = toc_params(&app, app.ui.dialog.as_ref().unwrap());+ let revision = app.session.doc().unwrap().revision;+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&labels, screen, "Between Entry and Number:");+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "Fewer Options").center());+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ assert!(!labels.iter().any(|(text, _, _)| text == "Between Entry and Number:"));+ visible_label(&labels, screen, "Entry Style:");+ assert_eq!(toc_params(&app, app.ui.dialog.as_ref().unwrap()), before);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "More Options").center());+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&labels, screen, "Between Entry and Number:");+ assert_eq!(toc_params(&app, app.ui.dialog.as_ref().unwrap()), before);+ assert_eq!(app.session.doc().unwrap().revision, revision);+ }++ /// Enter on the focused Fewer Options / More Options button toggles the options; it doesn't+ /// also make the table of contents.+ #[test]+ fn enter_on_the_toc_options_toggle_only_toggles() {+ use egui_kittest::{Harness, kittest::Queryable};+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.newSample", json!({})).unwrap();+ open_toc(&mut app);+ let revision = app.session.doc().unwrap().revision;+ let mut h = Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(+ |ui, app: &mut DesignApp| {+ let key = egui::Id::unique("toc_toggle_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);+ h.get_by_label("Fewer Options").focus();+ h.run_steps(2);+ h.key_press(egui::Key::Enter);+ h.run_steps(3);+ let d = h.state().ui.dialog.as_ref().expect("the dialog stays open");+ assert_eq!((d.id.as_str(), d.b("moreOptions")), (TOC, false), "the options are fewer");+ assert_eq!(h.state().session.doc().unwrap().revision, revision, "no table of contents made");+ assert!(h.query_by_label("More Options").is_some());+ }++ /// The title stays readable beside the style selector after the grid settles.+ #[test]+ fn toc_title_field_shows_the_whole_default_title() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.newSample", json!({})).unwrap();+ open_toc(&mut app);+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ let title_row = |labels: &[(String, egui::Rect, egui::Rect)]| {+ let y = visible_label(labels, screen, "Title:").center().y;+ labels.iter().filter(|(_, rect, _)| (rect.center().y - y).abs() < 2.0).cloned().collect::<Vec<_>>()+ };+ visible_label(&title_row(&labels), screen, "Contents");+ app.ui.dialog.as_mut().unwrap().fields.insert("title".into(), json!("Table of Contents"));+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&title_row(&labels), screen, "Table of Contents");+ // A small window: the title narrows and the style selector beside it stays in view.+ let small = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(450.0, 280.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, small, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, small, vec![]);+ let y = visible_label(&labels, small, "Title:").center().y;+ let row: Vec<_> = labels.iter().filter(|(_, rect, _)| (rect.center().y - y).abs() < 2.0).cloned().collect();+ let style = visible_label(&row, small, "TOC Title");+ // The selector is 200 pt wide from just before its text: all of it is in the dialog body.+ let (_, _, body) = row.iter().find(|(text, _, _)| text == "Style:").unwrap();+ assert!(style.min.x - 4.0 + 200.0 <= body.max.x, "the style selector fits the dialog: {style:?} in {body:?}");+ }++ /// The bookmarks checkbox persists through generation and reopening the dialog.+ #[test]+ fn toc_bookmarks_checkbox_sets_and_reopens_the_persisted_option() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.newSample", json!({})).unwrap();+ open_toc(&mut app);+ assert!(app.ui.dialog.as_ref().unwrap().b("createBookmarks"));+ app.ui.dialog.as_mut().unwrap().fields.insert("included".into(), json!([{"style": "Headline", "level": 1}]));+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&labels, screen, "Create PDF Bookmarks");+ confirm(&mut app).unwrap();+ assert!(app.session.doc().unwrap().doc.toc.as_ref().unwrap().create_bookmarks);+ assert!(!app.session.doc().unwrap().doc.bookmarks.is_empty());+ open_toc(&mut app);+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "Create PDF Bookmarks").center());+ confirm(&mut app).unwrap();+ assert!(app.session.doc().unwrap().doc.bookmarks.is_empty());+ open_toc(&mut app);+ assert!(!app.ui.dialog.as_ref().unwrap().b("createBookmarks"));+ }++ #[test]+ fn corner_options_dialog_sets_each_corner_with_preview_and_one_undo_step() {+ use designcraft_geom::corners::CornerShape;+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ let id = app.run("frame.create", json!({"rect": [72, 72, 360, 360]})).unwrap()["id"].as_u64().unwrap();+ app.run("selection.set", json!({"ids": [id]})).unwrap();+ let corners = |app: &DesignApp| app.session.doc().unwrap().doc.item(designcraft_doc::ItemId(id)).unwrap().corners.corners;+ let undo = |app: &DesignApp| app.session.doc().unwrap().history.undo.len();+ let set = |app: &mut DesignApp, k: &str, v: Value| {+ app.ui.dialog.as_mut().unwrap().fields.insert(k.into(), v);+ };+ let u0 = undo(&app);+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0));+ // Object › Corner Options… opens InDesign's dialog, not a form of the command's params.+ crate::menus::activate(&mut app, "object.cornerOptions", &Value::Null);+ assert_eq!(app.ui.dialog.as_ref().map(|d| d.id.as_str()), Some(CORNER_OPTIONS));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ for expected in ["Corner Options", "Corner Size and Shape:", "Preview", "OK", "Cancel"] {+ visible_label(&labels, screen, expected);+ }+ assert!(!labels.iter().any(|(t, _, _)| t.trim() == "Ids"), "no raw command fields");+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!((d.s("size1"), d.s("shape1"), d.b("link")), ("0p0".into(), "none".into(), true), "seeded from the frame, linked");+ // Linked: a corner changed is all four.+ set(&mut app, "size0", json!("1p0"));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(app.ui.dialog.as_ref().unwrap().s("size2"), "1p0");+ // Unlinked, only the top-right corner rounds, as in the tutorial.+ set(&mut app, "link", json!(false));+ for k in 0..4 {+ set(&mut app, &format!("size{k}"), json!("0"));+ }+ set(&mut app, "size1", json!("3 cm"));+ set(&mut app, "shape1", json!("rounded"));+ set(&mut app, "preview", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(corners(&app)[1].shape, CornerShape::Rounded, "Preview shows it");+ assert_eq!(undo(&app), u0, "without an undo step");+ set(&mut app, "preview", json!(false));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(corners(&app)[1].shape, CornerShape::None, "Preview off puts it back");+ set(&mut app, "preview", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ confirm(&mut app).unwrap();+ let c = corners(&app);+ assert_eq!(c.map(|c| c.shape), [CornerShape::None, CornerShape::Rounded, CornerShape::None, CornerShape::None]);+ assert!((c[1].size - 3.0 / 2.54 * 72.0).abs() < 1e-6, "{}", c[1].size);+ assert_eq!(undo(&app), u0 + 1, "one undo step");+ // Reopened, it shows the frame's corners, no longer linked.+ crate::menus::activate(&mut app, "object.cornerOptions", &Value::Null);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!((d.s("shape1"), d.s("shape0"), d.b("link")), ("rounded".into(), "none".into(), false));+ // A size that does not parse keeps the dialog open with the error; so does a shape the+ // dialog doesn't offer (rather than another shape taking its place).+ set(&mut app, "size0", json!("abc"));+ assert!(confirm(&mut app).is_err());+ assert!(app.ui.dialog.is_some());+ set(&mut app, "size0", json!("0"));+ set(&mut app, "shape0", json!("spiky"));+ assert!(confirm(&mut app).is_err());+ assert!(app.ui.dialog.is_some());+ cancel(&mut app);+ assert_eq!(corners(&app), c);+ }++ /// Several objects: the dialog shows the first one's corners, and OK sets only the corners+ /// edited; the others keep each object's own. A linked edit sets all four.+ #[test]+ fn corner_options_keep_each_objects_untouched_corners() {+ use designcraft_geom::corners::CornerShape;+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ let a = app.run("frame.create", json!({"rect": [72, 72, 200, 200]})).unwrap()["id"].as_u64().unwrap();+ let b = app.run("frame.create", json!({"rect": [272, 72, 400, 200]})).unwrap()["id"].as_u64().unwrap();+ app.run("object.cornerOptions", json!({"ids": [b], "shape": "bevel", "size": 12})).unwrap();+ app.run("selection.set", json!({"ids": [a, b]})).unwrap();+ let corners = |app: &DesignApp, id: u64| app.session.doc().unwrap().doc.item(designcraft_doc::ItemId(id)).unwrap().corners.corners;+ let set = |app: &mut DesignApp, k: &str, v: Value| {+ app.ui.dialog.as_mut().unwrap().fields.insert(k.into(), v);+ };+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0));+ let b0 = corners(&app, b);+ // Unlinked: only the top-right corner rounds, on both.+ crate::menus::activate(&mut app, "object.cornerOptions", &Value::Null);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ set(&mut app, "link", json!(false));+ set(&mut app, "size1", json!("1p0"));+ set(&mut app, "shape1", json!("rounded"));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ confirm(&mut app).unwrap();+ let (ca, cb) = (corners(&app, a), corners(&app, b));+ assert_eq!(ca.map(|c| c.shape), [CornerShape::None, CornerShape::Rounded, CornerShape::None, CornerShape::None]);+ assert_eq!(cb.map(|c| c.shape), [CornerShape::Bevel, CornerShape::Rounded, CornerShape::Bevel, CornerShape::Bevel], "b keeps its others");+ assert_eq!((cb[0], cb[2], cb[3]), (b0[0], b0[2], b0[3]));+ assert_eq!(ca[1], cb[1]);+ // Linked: a corner set to the first object's own value still sets all four, on both.+ crate::menus::activate(&mut app, "object.cornerOptions", &Value::Null);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ set(&mut app, "link", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ set(&mut app, "size0", json!("0p6"));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ confirm(&mut app).unwrap();+ let (ca, cb) = (corners(&app, a), corners(&app, b));+ assert_eq!(ca, cb, "all four, on both");+ assert!(ca.iter().all(|c| c.shape == CornerShape::None && (c.size - 6.0).abs() < 1e-6), "{ca:?}");+ }++ #[test]+ fn on_a_page_without_a_section_the_window_is_new_section() {+ // Chris Nielsen's "Numbering Page Sections" (4:43): page 3 selected, the Pages panel menu's+ // Numbering & Section Options opens New Section with Start Section on and 1 offered.+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({"pages": 6, "facingPages": true})).unwrap();+ app.canvas_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1000.0, 800.0)));+ crate::canvas::go_to_page(&mut app, 2);+ crate::menus::activate(&mut app, "layout.section", &Value::Null);+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!(+ (d.n("page"), d.b("newSection"), d.b("startSection"), d.b("automatic"), d.s("startNumber")),+ (Some(3.0), true, true, true, "1".into())+ );+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1178.0, 814.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&labels, screen, "New Section");+ // Typing a number in the field chooses Start Page Numbering at; OK: page 3 is page 5 (odd,+ // so a facing page stays on the right).+ let field = visible_label(&labels, screen, "1");+ click_dialog(&mut app, &ctx, screen, field.center());+ dialog_frame(+ &mut app,+ &ctx,+ screen,+ vec![+ egui::Event::Key { key: egui::Key::End, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE },+ egui::Event::Key { key: egui::Key::Backspace, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE },+ egui::Event::Text("5".into()),+ ],+ );+ assert!(!app.ui.dialog.as_ref().unwrap().b("automatic"), "typing chose Start Page Numbering at");+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "OK").center());+ assert!(app.ui.dialog.is_none());+ assert_eq!(app.session.active().unwrap().doc.page_name(2), "5");+ // Opened again on that page, it is Numbering & Section Options, showing the section.+ crate::menus::activate(&mut app, "layout.section", &Value::Null);+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!((d.b("newSection"), d.b("startSection"), d.b("automatic"), d.s("startNumber")), (false, true, false, "5".into()));+ let labels = (0..4).map(|_| dialog_frame(&mut app, &ctx, screen, vec![])).last().unwrap();+ visible_label(&labels, screen, "Numbering & Section Options");+ assert!(!labels.iter().any(|(t, _, _)| t == "New Section"));+ }+++/// The Rectangle dialog a frame-tool click opens shows the width in the horizontal ruler unit and+/// the height in the vertical one, not always picas, and reads bare numbers the same way (#1964).+#[test]+fn frame_size_dialog_follows_the_ruler_units() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("document.preferences", json!({"horizontalUnits": "inches", "verticalUnits": "millimeters"})).unwrap();+ // As the frame tool asks: a click at (36, 36), 72 pt by 72 pt.+ app.session.ui_requests.push(designcraft_engine::UiRequest::Dialog {+ id: "frameSize".into(),+ params: json!({"spread": 0, "shape": "rectangle", "content": "graphic", "x": 36.0, "y": 36.0, "width": 72.0, "height": 72.0}),+ });+ app.after_engine();+ let d = app.ui.dialog.as_ref().expect("the Rectangle dialog");+ assert_eq!((d.id.as_str(), d.unit), ("frameSize", Unit::Inches));+ assert_eq!(d.s("width"), format_measure(72.0, Unit::Inches));+ assert_eq!(d.s("height"), format_measure(72.0, Unit::Millimeters));+ assert!(!d.s("width").contains('p') && !d.s("height").contains('p'), "no picas: {} x {}", d.s("width"), d.s("height"));+ // Bare numbers typed in each field are in that field's unit: 2 in by 50 mm.+ let d = app.ui.dialog.as_mut().unwrap();+ d.fields.insert("width".into(), json!("2"));+ d.fields.insert("height".into(), json!("50"));+ let before = app.session.doc().unwrap().doc.clone();+ confirm(&mut app).unwrap();+ let after = &app.session.doc().unwrap().doc;+ let added: Vec<_> = after.spreads[0].items.iter().filter(|i| !before.spreads[0].items.iter().any(|b| b.id == i.id)).collect();+ assert_eq!(added.len(), 1, "one frame");+ let b = added[0].bounds();+ assert!((b.width() - 144.0).abs() < 0.01 && (b.height() - 50.0 / 25.4 * 72.0).abs() < 0.01, "{b:?}");+ // The properties panel's link opens it in the same units.+ let d = frame_size_dialog(&app, json!({"width": 36.0, "height": 36.0}));+ assert_eq!((d.s("width"), d.s("height")), (format_measure(36.0, Unit::Inches), format_measure(36.0, Unit::Millimeters)));+ // Every ruler unit: the shown size reads back as the size, so OK leaves a 72 pt frame 72 pt.+ let units = serde_json::to_value(Unit::ALL).unwrap();+ for (unit, name) in Unit::ALL.iter().zip(units.as_array().unwrap()) {+ app.run("document.preferences", json!({"horizontalUnits": name, "verticalUnits": name})).unwrap();+ let d = frame_size_dialog(&app, json!({"width": 72.0, "height": 145.0}));+ assert_eq!(d.unit, *unit);+ for (k, pt) in [("width", 72.0), ("height", 145.0)] {+ let back = d.m_in(k, *unit).unwrap_or(f64::NAN);+ assert!((back - pt).abs() < 0.05, "{name}: {k} shows {:?}, reads back {back}", d.s(k));+ }+ }+}++/// #2055 review: the Rectangle dialog reads the height in the vertical unit it showed when it+/// opened. Rulers switched while it is open (the control channel) leave a typed 50 at 50 mm.+#[test]+fn frame_size_dialog_keeps_its_units_while_open() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("document.preferences", json!({"horizontalUnits": "millimeters", "verticalUnits": "millimeters"})).unwrap();+ app.session.ui_requests.push(designcraft_engine::UiRequest::Dialog {+ id: "frameSize".into(),+ params: json!({"spread": 0, "shape": "rectangle", "content": "graphic", "x": 36.0, "y": 36.0, "width": 72.0, "height": 72.0}),+ });+ app.after_engine();+ let d = app.ui.dialog.as_mut().expect("the Rectangle dialog");+ d.fields.insert("width".into(), json!("50"));+ d.fields.insert("height".into(), json!("50"));+ app.run("document.preferences", json!({"horizontalUnits": "inches", "verticalUnits": "inches"})).unwrap();+ let before = app.session.doc().unwrap().doc.clone();+ confirm(&mut app).unwrap();+ let after = &app.session.doc().unwrap().doc;+ let added: Vec<_> = after.spreads[0].items.iter().filter(|i| !before.spreads[0].items.iter().any(|b| b.id == i.id)).collect();+ assert_eq!(added.len(), 1, "one frame");+ let b = added[0].bounds();+ let mm50 = 50.0 / 25.4 * 72.0;+ assert!((b.width() - mm50).abs() < 0.01 && (b.height() - mm50).abs() < 0.01, "50 mm by 50 mm (about 141.73 pt): {b:?}");+ // A dialog made without the vertical unit (`Dialog::new`) reads the height in its own unit.+ let mut d = Dialog::new("frameSize", json!({"width": "2", "height": "3"}));+ d.unit = Unit::Inches;+ assert_eq!(d.vertical_unit, None);+ app.ui.dialog = Some(d);+ let before = app.session.doc().unwrap().doc.clone();+ confirm(&mut app).unwrap();+ let after = &app.session.doc().unwrap().doc;+ let added: Vec<_> = after.spreads[0].items.iter().filter(|i| !before.spreads[0].items.iter().any(|b| b.id == i.id)).collect();+ assert_eq!(added.len(), 1, "one frame");+ let b = added[0].bounds();+ assert!((b.width() - 144.0).abs() < 0.01 && (b.height() - 216.0).abs() < 0.01, "{b:?}");+}