DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Merge #342 (update): feat(ui): Lay out Numbering & Section Options like InDesign's
aionggc490660cedfb
diff --cc crates/engine/src/cmd/layout.rsindex 2af1babc7,abd45dfde..10933b024--- a/crates/engine/src/cmd/layout.rs+++ b/crates/engine/src/cmd/layout.rs@@@ -436,58 -385,12 +436,12 @@@ pub fn specs() -> Vec<CommandSpec>"Numbering & Section Options…",["Layout"],None,- "{page (1-based; starts a section there), startNumber?: n|null (continue), style?: arabic|upperRoman|lowerRoman|upperLetters|lowerLetters|arabicLeadingZero|arabicThreeDigits|arabicFourDigits|kanji, prefix? (up to 8 characters; no + or comma), includePrefix?, marker?, remove?: bool}",- "{page (1-based; starts a section there), startNumber?: n (1–99999)|null (continue), style?: arabic|upperRoman|lowerRoman|upperLetters|lowerLetters|arabicLeadingZero|arabicThreeDigits|arabicFourDigits, prefix? (up to 8 characters; no + or comma), includePrefix?, marker?, remove?: bool}",++ "{page (1-based; starts a section there), startNumber?: n (1–99999)|null (continue), style?: arabic|upperRoman|lowerRoman|upperLetters|lowerLetters|arabicLeadingZero|arabicThreeDigits|arabicFourDigits|kanji, prefix? (up to 8 characters; no + or comma), includePrefix?, marker?, remove?: bool}",has_doc,|s, p| {- let page = p.get("page").and_then(Value::as_u64).ok_or_else(|| bad("layout.section", "missing page"))? as usize;- let n = s.doc()?.doc.page_count();- if page == 0 || page > n {- return Err(bad("layout.section", format!("no page {page}")));- }- let start = page - 1;- if let Some(prefix) = p.get("prefix").and_then(Value::as_str)- && (prefix.chars().count() > 8 || prefix.contains(['+', ',']))- {- return Err(bad("layout.section", "section prefix: up to 8 characters, without + or ,"));- }- let p = p.clone();+ let edit = SectionEdit::parse("layout.section", s, p)?;s.edit(|d, _| {- d.sections.retain(|x| x.start != start || start == 0);- if p.get("remove").and_then(Value::as_bool).unwrap_or(false) && start != 0 {- return ok();- }- let mut sec = d.sections.iter().find(|x| x.start == start).cloned().unwrap_or(designcraft_doc::Section {- start,- start_number: None,- style: Default::default(),- prefix: String::new(),- marker: String::new(),- include_prefix: false,- });- match p.get("startNumber") {- Some(Value::Null) => sec.start_number = None,- Some(v) => sec.start_number = Some(start_number("layout.section", "startNumber", v)?),- None => {}- }- if let Some(v) = p.get("style") {- sec.style = match serde_json::from_value(v.clone()) {- Ok(designcraft_doc::NumberStyle::Symbols) => return Err(bad("layout.section", "symbols don't number pages")),- Ok(style) => style,- Err(e) => return Err(bad("layout.section", e.to_string())),- };- }- if let Some(v) = p.get("prefix").and_then(Value::as_str) {- sec.prefix = v.into();- }- if let Some(v) = p.get("includePrefix").and_then(Value::as_bool) {- sec.include_prefix = v;- }- if let Some(v) = p.get("marker").and_then(Value::as_str) {- sec.marker = v.into();- }- d.sections.retain(|x| x.start != start);- d.sections.push(sec);- d.sections.sort_by_key(|x| x.start);+ edit.apply(d);Ok(json!({"names": (0..d.page_count()).map(|i| d.page_name(i)).collect::<Vec<_>>()}))})}@@@ -546,13 -414,35 +465,35 @@@chapter_numbering(s)}),+ cmd!(+ "layout.numberingOptions",+ "Apply Numbering & Section Options",+ [],+ None,+ "{page, …layout.section's settings, chapter?: {…layout.chapterNumbering's settings}} — the section and the document's chapter numbering in one undo step; if either is refused nothing changes",+ has_doc,+ |s, p| {+ let section = SectionEdit::parse("layout.numberingOptions", s, p)?;+ let chapter = match p.get("chapter") {+ Some(c) => Some(ChapterEdit::parse("layout.numberingOptions", c)?),+ None => None,+ };+ s.edit(|d, _| {+ section.apply(d);+ if let Some(chapter) = &chapter {+ chapter.apply(d);+ }+ Ok(json!({"names": (0..d.page_count()).map(|i| d.page_name(i)).collect::<Vec<_>>(), "chapter": d.chapter_label()}))+ })+ }+ ),cmd!("layer.move", "Move Layer", [], None, "{id, to: index (0 = top/frontmost)}", has_doc, |s, p| {- let id = LayerId(p.get("id").and_then(Value::as_u64).unwrap_or(0));- let to = p.get("to").and_then(Value::as_u64).unwrap_or(0) as usize;+ let id = LayerId(p.get("id").and_then(Value::as_u64).ok_or_else(|| bad("layer.move", "missing id"))?);+ let to = p.get("to").and_then(Value::as_u64).ok_or_else(|| bad("layer.move", "missing to"))?;s.edit(|d, _| {let i = d.layers.iter().position(|l| l.id == id).ok_or_else(|| bad("layer.move", "no such layer"))?;+ let to = usize::try_from(to).ok().filter(|t| *t < d.layers.len()).ok_or_else(|| bad("layer.move", "to out of range"))?;let l = d.layers.remove(i);- let to = to.min(d.layers.len());d.layers.insert(to, l);ok()})@@@ -838,7 -713,144 +779,141 @@@ fn document_setup(d: &designcraft_doc::}/// The largest chapter number (as for page numbers).- const MAX_CHAPTER: u64 = 99_999;+ const MAX_CHAPTER: u64 = designcraft_doc::MAX_PAGE_NUMBER as u64;++ /// A `layout.section` edit, checked before the document changes.+ struct SectionEdit {+ /// Absolute index of the section's first page.+ start: usize,+ remove: bool,+ /// Some(None): continue from the previous section.+ start_number: Option<Option<u32>>,+ style: Option<designcraft_doc::NumberStyle>,+ prefix: Option<String>,+ include_prefix: Option<bool>,+ marker: Option<String>,+ }++ impl SectionEdit {+ fn parse(cmd: &str, s: &Session, p: &Value) -> Result<Self> {+ let page = p.get("page").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "missing page"))?;+ let n = s.doc()?.doc.page_count() as u64;+ if page == 0 || page > n {+ return Err(bad(cmd, format!("no page {page}")));+ }+ let prefix = p.get("prefix").and_then(Value::as_str).map(str::to_string);+ if prefix.as_ref().is_some_and(|x| x.chars().count() > 8 || x.contains(['+', ','])) {+ return Err(bad(cmd, "section prefix: up to 8 characters, without + or ,"));+ }- let max = designcraft_doc::MAX_PAGE_NUMBER;+ let start_number = match p.get("startNumber") {+ None => None,+ Some(Value::Null) => Some(None),- Some(v) => Some(Some(- v.as_u64().filter(|n| (1..=u64::from(max)).contains(n)).ok_or_else(|| bad(cmd, format!("startNumber: 1 to {max}")))? as u32,- )),++ Some(v) => Some(Some(start_number(cmd, "startNumber", v)?)),+ };+ let style = match p.get("style") {+ None => None,+ Some(v) => match serde_json::from_value(v.clone()) {+ Ok(designcraft_doc::NumberStyle::Symbols) => return Err(bad(cmd, "symbols don't number pages")),+ Ok(style) => Some(style),+ Err(e) => return Err(bad(cmd, e.to_string())),+ },+ };+ Ok(SectionEdit {+ start: (page - 1) as usize,+ remove: p.get("remove").and_then(Value::as_bool).unwrap_or(false),+ start_number,+ style,+ prefix,+ include_prefix: p.get("includePrefix").and_then(Value::as_bool),+ marker: p.get("marker").and_then(Value::as_str).map(str::to_string),+ })+ }++ fn apply(&self, d: &mut designcraft_doc::Document) {+ let start = self.start;+ // Page 1 always starts a section.+ if self.remove && start != 0 {+ d.sections.retain(|x| x.start != start);+ return;+ }+ let mut sec = d.sections.iter().find(|x| x.start == start).cloned().unwrap_or(designcraft_doc::Section {+ start,+ start_number: None,+ style: Default::default(),+ prefix: String::new(),+ marker: String::new(),+ include_prefix: false,+ });+ if let Some(n) = self.start_number {+ sec.start_number = n;+ }+ if let Some(style) = self.style {+ sec.style = style;+ }+ if let Some(prefix) = &self.prefix {+ sec.prefix = prefix.clone();+ }+ if let Some(on) = self.include_prefix {+ sec.include_prefix = on;+ }+ if let Some(marker) = &self.marker {+ sec.marker = marker.clone();+ }+ d.sections.retain(|x| x.start != start);+ d.sections.push(sec);+ d.sections.sort_by_key(|x| x.start);+ }+ }++ /// A `layout.chapterNumbering` edit, checked before the document changes.+ struct ChapterEdit {+ style: Option<designcraft_doc::NumberStyle>,+ source: Option<designcraft_doc::ChapterSource>,+ start: Option<u32>,+ }++ impl ChapterEdit {+ fn parse(cmd: &str, p: &Value) -> Result<Self> {+ let style = match p.get("style") {+ Some(v) => match serde_json::from_value::<designcraft_doc::NumberStyle>(v.clone()) {+ Ok(designcraft_doc::NumberStyle::Symbols) | Err(_) => return Err(bad(cmd, format!("unknown chapter style {v}"))),+ Ok(style) => Some(style),+ },+ None => None,+ };+ let mut source = match p.get("source") {+ Some(v) => Some(+ serde_json::from_value::<designcraft_doc::ChapterSource>(v.clone())+ .map_err(|_| bad(cmd, format!("unknown chapter number source {v}")))?,+ ),+ None => None,+ };+ let start = match p.get("start") {+ Some(v) => {+ Some(v.as_u64().filter(|n| (1..=MAX_CHAPTER).contains(n)).ok_or_else(|| bad(cmd, format!("chapter start: 1 to {MAX_CHAPTER}")))?+ as u32)+ }+ None => None,+ };+ // A start number alone means Start Chapter Numbering at.+ if start.is_some() && source.is_none() {+ source = Some(designcraft_doc::ChapterSource::UserDefined);+ }+ Ok(ChapterEdit { style, source, start })+ }++ fn apply(&self, d: &mut designcraft_doc::Document) {+ if let Some(style) = self.style {+ d.settings.chapter_style = style;+ }+ if let Some(source) = self.source {+ d.settings.chapter_source = source;+ }+ if let Some(n) = self.start {+ d.settings.chapter_number = n;+ }+ }+ }/// The active document's chapter numbering, and the open book that holds it (what/// `layout.chapterNumbering {}` reports, read without running a command).@@@ -1198,20 -1075,53 +1273,53 @@@ mod page_numbering_view_testsassert_eq!(s.resolve_page("9"), None);}+ #[test]+ fn section_start_numbers_are_bounded() {+ let mut s = Session::new();+ s.execute("file.new", &json!({"pages": 2})).unwrap();+ for n in [json!(0), json!(100_000), json!(u32::MAX), json!(u64::from(u32::MAX) + 2), json!(-1), json!(2.5), json!("7")] {+ let e = s.execute("layout.section", &json!({"page": 1, "startNumber": n})).unwrap_err().to_string();+ assert!(e.contains("startNumber"), "{n}: {e}");+ assert!(s.execute("layout.documentSetup", &json!({"startPage": n})).is_err(), "{n}");+ }+ assert_eq!((0..2).map(|i| s.page_label(i)).collect::<Vec<_>>(), ["1", "2"]);+ let r = s.execute("layout.section", &json!({"page": 1, "startNumber": 99_999})).unwrap();+ assert_eq!(r["names"], json!(["99999", "100000"]));+ }++ #[test]+ fn numbering_options_apply_in_one_undo_step_or_not_at_all() {+ let mut s = crate::Session::new();+ s.execute("file.new", &json!({"pages": 4})).unwrap();+ let names = |s: &crate::Session| (0..4).map(|i| s.doc().unwrap().doc.page_name(i)).collect::<Vec<_>>();+ let r = s+ .execute(+ "layout.numberingOptions",+ &json!({"page": 3, "startNumber": 5, "style": "lowerRoman", "prefix": "A-", "includePrefix": true, "chapter": {"start": 4, "style": "upperRoman"}}),+ )+ .unwrap();+ assert_eq!((r["names"].clone(), r["chapter"].clone()), (json!(["1", "2", "A-v", "A-vi"]), json!("IV")));+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(names(&s), ["1", "2", "3", "4"], "one undo reverts the section…");+ assert_eq!(s.doc().unwrap().doc.chapter_label(), "1", "…and the chapter numbering");+ // A refused part leaves the other undone too.+ for bad in [+ json!({"page": 3, "startNumber": 5, "chapter": {"start": 100_000}}),+ json!({"page": 3, "startNumber": 4_294_967_295u64, "chapter": {"start": 2}}),+ json!({"page": 3, "prefix": "A+B", "chapter": {"start": 2}}),+ json!({"page": 9, "chapter": {"start": 2}}),+ ] {+ assert!(s.execute("layout.numberingOptions", &bad).is_err(), "{bad}");+ assert_eq!(names(&s), ["1", "2", "3", "4"], "{bad}");+ assert_eq!(s.doc().unwrap().doc.settings.chapter_source, designcraft_doc::ChapterSource::Automatic, "{bad}");+ }+ // Removing a section keeps the chapter part.+ s.execute("layout.section", &json!({"page": 3, "startNumber": 1})).unwrap();+ s.execute("layout.numberingOptions", &json!({"page": 3, "remove": true, "chapter": {"source": "userDefined", "start": 2}})).unwrap();+ assert_eq!(names(&s), ["1", "2", "3", "4"]);+ assert_eq!(s.doc().unwrap().doc.chapter_label(), "2");+ }+- #[test]- fn start_numbers_are_bounded() {- let mut s = crate::Session::new();- s.execute("file.new", &json!({"pages": 2})).unwrap();- for n in [0u64, 100_000, 4_294_967_295] {- assert!(s.execute("layout.section", &json!({"page": 1, "startNumber": n})).is_err(), "{n}");- }- s.execute("layout.section", &json!({"page": 1, "startNumber": 99_999})).unwrap();- assert_eq!(s.doc().unwrap().doc.page_name(1), "100000");- // Document Setup clamps instead of wrapping into a 32-bit number.- s.execute("layout.documentSetup", &json!({"startPage": 4_294_967_295u64})).unwrap();- assert_eq!(s.execute("layout.documentSetup", &json!({})).unwrap()["startPage"], 99_999);- }-#[test]fn section_prefixes_are_short_and_avoid_plus_and_comma() {let mut s = crate::Session::new();diff --cc crates/ui-egui/src/dialogs.rsindex 469cf9d50,c0deeb564..1a121803b--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@@ -4519,1624 -3605,191 +4519,1656 @@@ fn open_type_features(lang: &str, ui: &}}-/// New Cross-Reference: link to a paragraph (paragraph styles on the left, their paragraphs on-/// the right) or a text anchor, with a cross-reference format.-fn insert_xref(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {- let Some(st) = app.session.active() else { return };- let doc = &st.doc;- let all = "[All Paragraphs]";- ui.horizontal(|ui| {- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Link To:"));- combo(ui, d, "linkTo", &[("paragraph", "Paragraph"), ("anchor", "Text Anchor")]);+/// Underline Options / Strikethrough Options (`key` is `underline` or `strikethrough`).+fn line_options(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields, doc: &designcraft_doc::Document, key: &str) {+ char_check(ui, d, cf, key, crate::i18n::tr(lang, if key == "underline" { "Underline On" } else { "Strikethrough On" }));+ ui.add_space(4.0);+ egui::Grid::new(("csline", key)).num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(lang, "Weight:"));+ char_number(ui, d, cf, &format!("{key}Weight"), " pt", 1.0, (0.0, 800.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Offset:"));+ char_number(ui, d, cf, &format!("{key}Offset"), " pt", 1.0, (-800.0, 800.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Color:"));+ char_swatch(lang, ui, d, cf, doc, &format!("{key}Color"), Some("(Text Color)"));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Tint:"));+ char_number(ui, d, cf, &format!("{key}Tint"), "%", 100.0, (0.0, 100.0));+ ui.end_row();});- ui.add_space(6.0);- let dim = crate::theme::Tokens::get(ui.ctx()).text_dim;- if d.s("linkTo") == "anchor" {- egui::ScrollArea::vertical().id_salt("xr_anchors").max_height(220.0).max_width(460.0).show(ui, |ui| {- let mut any = false;- for st in doc.stories.values() {- for a in &st.anchors {- any = true;- let key = format!("a:{}", a.id);- if ui.selectable_label(d.s("target") == key, &a.name).clicked() {- d.fields.insert("target".into(), json!(key));- }- }- }- if !any {- ui.label(crate::rtl::widget(- ui,- egui::RichText::new(crate::i18n::tr(&app.ui.language, "No text anchors in this document.")).color(dim),- ));+}++fn delete_character_style(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let name = d.s("name");+ ui.set_min_width(380.0);+ crate::rtl::label(+ ui,+ egui::RichText::new(+ crate::i18n::tr(&app.ui.language, "Delete the character style \"{name}\"?")+ .replace("{name}", crate::i18n::style_name(&app.ui.language, &name)),+ )+ .size(12.5),+ );+ ui.add_space(8.0);+ let Some(st) = app.session.active() else { return };+ let in_use = st.doc.stories.values().any(|s| s.chars.iter().any(|r| r.format.style == name));+ let names: Vec<String> = st.doc.styles.character.iter().map(|c| c.name.clone()).filter(|n| *n != name).collect();+ if in_use {+ crate::rtl::label(+ ui,+ egui::RichText::new(crate::i18n::tr(&app.ui.language, "This style is in use. Text using it will be reassigned to:"))+ .size(11.0)+ .color(crate::theme::Tokens::get(ui.ctx()).text_dim),+ );+ } else {+ crate::rtl::label(+ ui,+ egui::RichText::new(crate::i18n::tr(&app.ui.language, "Replace with:")).size(11.0).color(crate::theme::Tokens::get(ui.ctx()).text_dim),+ );+ }+ ui.add_space(4.0);+ if !d.fields.contains_key("replaceWith") {+ d.fields.insert("replaceWith".into(), json!(designcraft_doc::NO_CHAR_STYLE));+ }+ let replace = d.s("replaceWith");+ egui::ComboBox::from_id_salt("del_char_replace")+ .selected_text(crate::rtl::widget(ui, crate::i18n::style_name(&app.ui.language, &replace)))+ .width(260.0)+ .show_ui(ui, |ui| {+ for n in [designcraft_doc::NO_CHAR_STYLE].into_iter().chain(names.iter().map(String::as_str)) {+ if ui.selectable_label(n == replace, crate::rtl::widget(ui, crate::i18n::style_name(&app.ui.language, n))).clicked() {+ d.fields.insert("replaceWith".into(), json!(n));+ }}});- } else {- let mut styles: Vec<String> = vec![all.to_string()];- styles.extend(doc.styles.paragraph.iter().map(|s| s.name.clone()));- let cur_style = if d.s("style").is_empty() { all.to_string() } else { d.s("style") };- ui.horizontal_top(|ui| {- let col = |w: f32| (egui::vec2(w, 240.0), egui::Layout::top_down(egui::Align::Min));- let (sz, lay) = col(180.0);- ui.allocate_ui_with_layout(sz, lay, |ui| {- egui::ScrollArea::vertical().id_salt("xr_styles").auto_shrink([false, false]).show(ui, |ui| {- for name in &styles {- if ui.selectable_label(*name == cur_style, name).clicked() {- d.fields.insert("style".into(), json!(name));- }+}++fn combo(ui: &mut egui::Ui, d: &mut Dialog, key: &str, opts: &[(&str, &str)]) {+ let cur = d.s(key);+ let shown = opts.iter().find(|o| o.0 == cur).map_or(cur.as_str(), |o| o.1).to_string();+ egui::ComboBox::from_id_salt(key).selected_text(crate::rtl::widget(ui, &shown)).width(170.0).show_ui(ui, |ui| {+ for (v, label) in opts {+ if ui.selectable_label(cur == *v, crate::rtl::widget(ui, *label)).clicked() {+ d.fields.insert(key.into(), json!(v));+ }+ }+ });+}++/// Translate enum captions without changing serialized values or user-defined names.+fn translated_combo(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, key: &str, opts: &[(&str, &str)]) {+ let opts: Vec<_> = opts.iter().map(|(value, label)| (*value, crate::i18n::tr(lang, label))).collect();+ combo(ui, d, key, &opts);+}++/// Style name picker (paragraph or character styles of the active document).+fn style_combo(app: &DesignApp, ui: &mut egui::Ui, d: &mut Dialog, key: &str, character: bool) {+ let names: Vec<String> = app+ .session+ .active()+ .map(|st| {+ if character {+ st.doc.styles.character.iter().map(|s| s.name.clone()).collect()+ } else {+ st.doc.styles.paragraph.iter().map(|s| s.name.clone()).collect()+ }+ })+ .unwrap_or_default();+ let mut opts: Vec<(&str, &str)> = names.iter().map(|n| (n.as_str(), crate::i18n::style_name(&app.ui.language, n))).collect();+ if character && !names.iter().any(|n| n == designcraft_doc::NO_CHAR_STYLE) {+ opts.insert(0, (designcraft_doc::NO_CHAR_STYLE, crate::i18n::style_name(&app.ui.language, designcraft_doc::NO_CHAR_STYLE)));+ }+ combo(ui, d, key, &opts);+}++const RULES: [(&str, &str); 2] = [("ruleAbove", "Rule Above"), ("ruleBelow", "Rule Below")];++/// A rule as the dialog shows it: `current[which]` (the resolved rule, inherited values included)+/// with the fields edited in the dialog (`{prefix}{which}.{field}`) on top.+fn shown_rule(d: &Dialog, prefix: &str, which: &str, current: &Value) -> Value {+ let mut r = match current.get(which) {+ Some(Value::Object(m)) => m.clone(),+ _ => Map::new(),+ };+ let edited = format!("{prefix}{which}.");+ for (k, v) in &d.fields {+ if let Some(field) = k.strip_prefix(&edited) {+ r.insert(field.into(), v.clone());+ }+ }+ Value::Object(r)+}++/// The paragraph attributes of the Justification controls.+pub const JUSTIFY_ATTRS: [&str; 12] = [+ "wordSpaceMin",+ "wordSpaceDesired",+ "wordSpaceMax",+ "letterSpaceMin",+ "letterSpaceDesired",+ "letterSpaceMax",+ "glyphScaleMin",+ "glyphScaleDesired",+ "glyphScaleMax",+ "composer",+ "kashidas",+ "koreanCharBreaks",+];++/// The spacing rows of the Justification controls: (label, attribute stem, allowed percent range).+const JUSTIFY_ROWS: [(&str, &str, (f64, f64)); 3] = [+ ("Word Spacing", "wordSpace", (0.0, 1000.0)),+ ("Letter Spacing", "letterSpace", (-100.0, 500.0)),+ ("Glyph Scaling", "glyphScale", (50.0, 200.0)),+];++/// Checks the edited spacing values: each within its range, and minimum ≤ desired ≤ maximum+/// (values left mixed are not compared).+fn check_justification(d: &Dialog, prefix: &str, current: &Value) -> Result<(), String> {+ for (label, stem, (lo, hi)) in JUSTIFY_ROWS {+ let mut edited = false;+ let mut known = Vec::new();+ for suffix in ["Min", "Desired", "Max"] {+ let key = format!("{stem}{suffix}");+ let v = match d.fields.get(&format!("{prefix}{key}")) {+ Some(v) => {+ edited = true;+ let pct =+ v.as_f64().map(|x| x * 100.0).filter(|x| x.is_finite()).ok_or_else(|| format!("Justification: {label} is not a number"))?;+ // The fields show whole percents; compare what was shown.+ if pct.round() < lo || pct.round() > hi {+ return Err(format!("Justification: {label} must be between {lo}% and {hi}%"));}- })- });- ui.add_space(8.0);- let (sz, lay) = col(330.0);- ui.allocate_ui_with_layout(sz, lay, |ui| {- egui::ScrollArea::vertical().id_salt("xr_paras").auto_shrink([false, false]).show(ui, |ui| {- for st in doc.stories.values().filter(|s| !s.frames.is_empty()) {- for (pi, r) in st.para_ranges().into_iter().enumerate() {- if cur_style != all && st.paras[pi].style != cur_style {- continue;- }- let text = designcraft_doc::xref::clean(&st.text[r]);- if text.is_empty() {- continue;- }- let short: String = text.chars().take(52).collect();- let key = format!("{}:{pi}", st.id.0);- if ui.selectable_label(d.s("target") == key, short).clicked() {- d.fields.insert("target".into(), json!(key));- }+ Some(pct)+ }+ None => current[key.as_str()].as_f64().map(|x| x * 100.0),+ };+ known.extend(v);+ }+ if edited && known.windows(2).any(|w| w[0] > w[1] + 1e-9) {+ return Err(format!("Justification: {label} needs Minimum ≤ Desired ≤ Maximum"));+ }+ }+ Ok(())+}++/// The Justification controls (the Justification dialog, and the Paragraph Style Options section).+/// `current` holds the resolved paragraph attributes, `null` where the selected paragraphs differ+/// (the field shows empty); each edit is stored as `{prefix}{attr}`, so OK changes only the fields+/// edited.+fn justification(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, prefix: &str, current: &Value) {+ let cur = |d: &Dialog, k: &str| d.fields.get(&format!("{prefix}{k}")).cloned().unwrap_or_else(|| current[k].clone());+ egui::Grid::new("psj").num_columns(4).spacing([8.0, 6.0]).show(ui, |ui| {+ ui.label("");+ crate::rtl::label(ui, crate::i18n::tr(lang, "Minimum"));+ crate::rtl::label(ui, crate::i18n::tr(lang, "Desired"));+ crate::rtl::label(ui, crate::i18n::tr(lang, "Maximum"));+ ui.end_row();+ for (label, base, _) in JUSTIFY_ROWS {+ crate::rtl::label(ui, crate::i18n::tr(lang, &format!("{label}:")));+ for suffix in ["Min", "Desired", "Max"] {+ let key = format!("{base}{suffix}");+ let v = cur(d, &key).as_f64().map(|x| x * 100.0);+ if let Some(n) = ui.scope(|ui| crate::widgets::number(ui, &format!("ps{key}"), v, "%", 60.0, 0)).inner {+ d.fields.insert(format!("{prefix}{key}"), json!(n / 100.0));+ }+ }+ ui.end_row();+ }+ crate::rtl::label(ui, crate::i18n::tr(lang, "Composer:"));+ let composer = cur(d, "composer");+ // Mixed (null) selects neither; a Japanese composer keeps its kind.+ let (single, [paragraph, single_line]) = crate::panels::properties::composer_choice(composer.as_str());+ let known = !composer.is_null();+ if ui.selectable_label(known && !single, crate::rtl::widget(ui, crate::i18n::tr(lang, "Paragraph Composer"))).clicked() {+ d.fields.insert(format!("{prefix}composer"), json!(paragraph));+ }+ if ui.selectable_label(known && single, crate::rtl::widget(ui, crate::i18n::tr(lang, "Single-line Composer"))).clicked() {+ d.fields.insert(format!("{prefix}composer"), json!(single_line));+ }+ ui.end_row();+ for (label, key, text, default) in [+ ("Insert Kashidas:", "kashidas", "In justified Arabic text", true),+ ("Korean Line Breaks:", "koreanCharBreaks", "Between syllables (not only at spaces)", false),+ ] {+ crate::rtl::label(ui, crate::i18n::tr(lang, label));+ let v = cur(d, key);+ let mut on = v.as_bool().unwrap_or(default);+ if ui.add(egui::Checkbox::new(&mut on, crate::rtl::widget(ui, crate::i18n::tr(lang, text))).indeterminate(v.is_null())).changed() {+ d.fields.insert(format!("{prefix}{key}"), json!(on));+ }+ ui.end_row();+ }+ });+ if let Some(e) = d.fields.get("justifyError").and_then(Value::as_str) {+ ui.add_space(6.0);+ crate::rtl::label(ui, egui::RichText::new(e).color(ui.visuals().error_fg_color));+ }+}++/// The rule fields edited in the dialog, as `type.para` attrs: `{ruleAbove?: {…}, ruleBelow?: {…}}`.+fn rule_edits(d: &Dialog, prefix: &str) -> Map<String, Value> {+ let mut out = Map::new();+ for (which, _) in RULES {+ let edited = format!("{prefix}{which}.");+ let fields: Map<String, Value> = d.fields.iter().filter_map(|(k, v)| k.strip_prefix(&edited).map(|f| (f.to_string(), v.clone()))).collect();+ if !fields.is_empty() {+ out.insert(which.into(), Value::Object(fields));+ }+ }+ out+}++/// Paragraph Rules (the dialog, and the Paragraph Style Options section): Rule Above or Rule Below,+/// chosen at the top. `current` holds the resolved `ruleAbove` / `ruleBelow`; each edit is stored as+/// `{prefix}{rule}.{field}`, so OK changes only the fields edited.+fn paragraph_rules(app: &DesignApp, ui: &mut egui::Ui, d: &mut Dialog, prefix: &str, current: &Value) {+ let lang = app.ui.language.as_str();+ let (h_units, v_units) =+ app.session.active().map(|st| (st.doc.settings.horizontal_units, st.doc.settings.vertical_units)).unwrap_or((Unit::Points, Unit::Points));+ let which = if d.s("rule") == "ruleBelow" { "ruleBelow" } else { "ruleAbove" };+ let rule = shown_rule(d, prefix, which, current);+ let key = |field: &str| format!("{prefix}{which}.{field}");+ // A number field takes the rest of the row; keep its grid column to the field's width.+ let sized = |ui: &mut egui::Ui, add: &mut dyn FnMut(&mut egui::Ui) -> Option<f64>| {+ ui.allocate_ui_with_layout(egui::vec2(80.0, 22.0), egui::Layout::left_to_right(egui::Align::Center), |ui| add(ui)).inner+ };+ ui.horizontal(|ui| {+ let shown = RULES.iter().find(|r| r.0 == which).map_or(which, |r| r.1);+ egui::ComboBox::from_id_salt("rule_which").selected_text(crate::rtl::widget(ui, crate::i18n::tr(lang, shown))).width(130.0).show_ui(+ ui,+ |ui| {+ for (v, label) in RULES {+ if ui.selectable_label(v == which, crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() {+ d.fields.insert("rule".into(), json!(v));+ }+ }+ },+ );+ ui.add_space(12.0);+ let mut on = rule["on"].as_bool().unwrap_or(false);+ if ui.checkbox(&mut on, crate::rtl::widget(ui, crate::i18n::tr(lang, "Rule On"))).changed() {+ d.fields.insert(key("on"), json!(on));+ }+ });+ ui.add_space(6.0);+ let on = rule["on"].as_bool().unwrap_or(false);+ ui.add_enabled_ui(on, |ui| {+ egui::Grid::new(("rules", which)).num_columns(4).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(lang, "Weight:"));+ if let Some(v) = sized(ui, &mut |ui| crate::widgets::number(ui, &key("weight"), rule["weight"].as_f64(), " pt", 80.0, 2)) {+ d.fields.insert(key("weight"), json!(v.clamp(0.0, 1000.0)));+ }+ crate::rtl::label(ui, crate::i18n::tr(lang, "Color:"));+ let color = rule["color"].as_str().unwrap_or("").to_string();+ if let Some(w) = app.session.active().and_then(|st| swatch_menu(ui, &st.doc, ("rule_color", which), &color, 130.0)) {+ d.fields.insert(key("color"), json!(w));+ }+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Tint:"));+ if let Some(v) = sized(ui, &mut |ui| crate::widgets::number(ui, &key("tint"), rule["tint"].as_f64().map(|t| t * 100.0), "%", 80.0, 0)) {+ d.fields.insert(key("tint"), json!((v / 100.0).clamp(0.0, 1.0)));+ }+ crate::rtl::label(ui, crate::i18n::tr(lang, "Width:"));+ let column = rule["columnWidth"].as_bool().unwrap_or(true);+ egui::ComboBox::from_id_salt(("rule_width", which))+ .selected_text(crate::rtl::widget(ui, crate::i18n::tr(lang, if column { "Column" } else { "Text" })))+ .width(130.0)+ .show_ui(ui, |ui| {+ for (v, label) in [(true, "Column"), (false, "Text")] {+ if ui.selectable_label(v == column, crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() {+ d.fields.insert(key("columnWidth"), json!(v));}}- })- });+ });+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Offset:"));+ if let Some(v) = sized(ui, &mut |ui| crate::widgets::measure(ui, &key("offset"), rule["offset"].as_f64(), v_units, 80.0)) {+ d.fields.insert(key("offset"), json!(v));+ }+ ui.end_row();+ for (label, field) in [("Left Indent:", "leftIndent"), ("Right Indent:", "rightIndent")] {+ crate::rtl::label(ui, crate::i18n::tr(lang, label));+ if let Some(v) = sized(ui, &mut |ui| crate::widgets::measure(ui, &key(field), rule[field].as_f64(), h_units, 80.0)) {+ d.fields.insert(key(field), json!(v));+ }+ }+ ui.end_row();+ });+ });+}++/// Document Footnote Options: Numbering and Formatting / Layout tabs.+fn footnote_options(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ ui.horizontal(|ui| {+ for (tab, label) in [("numbering", "Numbering and Formatting"), ("layout", "Layout")] {+ if ui.selectable_label(d.s("tab") == tab, crate::rtl::widget(ui, crate::i18n::tr(&app.ui.language, label))).clicked() {+ d.fields.insert("tab".into(), json!(tab));+ }+ }+ });+ ui.separator();+ let head = |ui: &mut egui::Ui, t: &str| {+ ui.add_space(4.0);+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, t)).font(semibold(12.0)));+ };+ if d.s("tab") == "layout" {+ head(ui, "Spacing Options");+ egui::Grid::new("fn_sp").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Minimum Space Before First Footnote:"));+ text_field(ui, d, "spaceBefore", 70.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Space Between Footnotes:"));+ text_field(ui, d, "spaceBetween", 70.0);+ ui.end_row();});+ head(ui, "First Baseline");+ egui::Grid::new("fn_fb").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Offset:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "firstBaseline",+ &[+ ("ascent", "Ascent"),+ ("capHeight", "Cap Height"),+ ("leading", "Leading"),+ ("xHeight", "x Height"),+ ("emboxHeight", "Em Box Height"),+ ("fixed", "Fixed"),+ ],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Min:"));+ text_field(ui, d, "firstBaselineMin", 70.0);+ ui.end_row();+ });+ check(ui, d, "spanColumns", crate::i18n::tr(&app.ui.language, "Span Footnotes Across Columns"));+ head(ui, "Rule Above");+ check(ui, d, "rule.on", crate::i18n::tr(&app.ui.language, "Rule On"));+ egui::Grid::new("fn_rule").num_columns(4).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Weight:"));+ text_field(ui, d, "rule.weight", 60.0);+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Color:"));+ let swatches: Vec<String> = app.session.active().map(|st| st.doc.swatches.iter().map(|s| s.name.clone()).collect()).unwrap_or_default();+ let opts: Vec<(&str, &str)> = swatches.iter().map(|n| (n.as_str(), n.as_str())).collect();+ combo(ui, d, "rule.color", &opts);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Width:"));+ text_field(ui, d, "rule.width", 60.0);+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Offset:"));+ text_field(ui, d, "rule.offset", 60.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Left Indent:"));+ text_field(ui, d, "rule.leftIndent", 60.0);+ ui.end_row();+ });+ return;+ }+ head(ui, "Numbering");+ egui::Grid::new("fn_num").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Style:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "style",+ &[+ ("arabic", "1, 2, 3, 4..."),+ ("upperRoman", "I, II, III, IV..."),+ ("lowerRoman", "i, ii, iii, iv..."),+ ("upperLetters", "A, B, C, D..."),+ ("lowerLetters", "a, b, c, d..."),+ ("arabicLeadingZero", "01, 02, 03..."),+ ("symbols", "*, †, ‡, §..."),+ ("kanji", "一, 二, 三, 四..."),+ ],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Start at:"));+ text_field(ui, d, "startAt", 60.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Restart Numbering Every:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "restart",+ &[("never", "Never (continuous)"), ("page", "Page"), ("spread", "Spread"), ("section", "Section")],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Show Prefix/Suffix in:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "affixIn",+ &[("none", "None"), ("reference", "Footnote Reference"), ("text", "Footnote Text"), ("both", "Both")],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Prefix:"));+ text_field(ui, d, "prefix", 60.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Suffix:"));+ text_field(ui, d, "suffix", 60.0);+ ui.end_row();+ });+ head(ui, "Footnote Reference Number in Text");+ egui::Grid::new("fn_ref").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Position:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "refPosition",+ &[+ ("superscript", "Apply Superscript"),+ ("subscript", "Apply Subscript"),+ ("normal", "Apply Normal"),+ ("otSuperscript", "OpenType Superscript"),+ ],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Character Style:"));+ style_combo(app, ui, d, "refCharStyle", true);+ ui.end_row();+ });+ head(ui, "Footnote Formatting");+ egui::Grid::new("fn_fmt").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Paragraph Style:"));+ style_combo(app, ui, d, "paraStyle", false);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Separator:"));+ text_field(ui, d, "separator", 60.0);+ ui.end_row();+ });+}++/// One parameter of a command, parsed from its params documentation+/// (`{name, type?: a|b|c, count?, flag?: bool, …}`).+#[derive(Clone, Debug, PartialEq)]+pub struct CommandField {+ pub key: String,+ pub optional: bool,+ /// Enumerated values (`a|b|c`).+ pub choices: Vec<String>,+ pub boolean: bool,+ /// The documented value spec (shown as a hint).+ pub hint: String,+}++/// Parameters of a command from its documentation string: the top-level keys of the first `{…}`.+pub fn command_fields(doc: &str) -> Vec<CommandField> {+ let Some(start) = doc.find('{') else { return vec![] };+ let mut depth = 0i32;+ let mut end = doc.len();+ for (i, c) in doc[start..].char_indices() {+ match c {+ '{' | '[' | '(' => depth += 1,+ '}' | ']' | ')' => {+ depth -= 1;+ if depth == 0 {+ end = start + i;+ break;+ }+ }+ _ => {}+ }+ }+ let body = &doc[start + 1..end];+ let mut parts = Vec::new();+ let (mut depth, mut from) = (0i32, 0usize);+ for (i, c) in body.char_indices() {+ match c {+ '{' | '[' | '(' => depth += 1,+ '}' | ']' | ')' => depth -= 1,+ ',' if depth == 0 => {+ parts.push(&body[from..i]);+ from = i + 1;+ }+ _ => {}+ }+ }+ parts.push(&body[from..]);+ let ident = |s: &str| !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') && !s.starts_with(|c: char| c.is_ascii_digit());+ let mut out = Vec::new();+ for part in parts {+ // `key`, `key?`, `key: spec` or `key (spec)`: the key is the leading word.+ let part = part.trim();+ let k_end = part.find(|c: char| c.is_whitespace() || c == ':' || c == '(').unwrap_or(part.len());+ let (k, rest) = part.split_at(k_end);+ let rest = rest.trim_start();+ let spec = match rest.strip_prefix(':') {+ Some(v) => v.trim(),+ None => rest.strip_prefix('(').and_then(|r| r.strip_suffix(')')).unwrap_or(rest).trim(),+ };+ let optional = k.ends_with('?');+ let key = k.trim_end_matches('?');+ if !ident(key) || out.iter().any(|f: &CommandField| f.key == key) {+ continue;+ }+ let word = spec.split_whitespace().next().unwrap_or("");+ let choices: Vec<String> =+ if word.contains('|') && word.split('|').all(ident) { word.split('|').map(str::to_string).collect() } else { vec![] };+ let boolean = spec.starts_with("bool") || spec.starts_with("true|false") || spec.starts_with("true") && spec.len() <= 5;+ out.push(CommandField { key: key.into(), optional, choices: if boolean { vec![] } else { choices }, boolean, hint: spec.into() });+ }+ out+}++fn humanize(key: &str) -> String {+ let mut s = String::new();+ for (i, c) in key.chars().enumerate() {+ if i == 0 {+ s.extend(c.to_uppercase());+ } else if c.is_uppercase() {+ s.push(' ');+ s.extend(c.to_lowercase());+ } else {+ s.push(c);+ }+ }+ s+}++/// A form for any command, from its parameter documentation.+fn command_form(app: &crate::DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let doc = designcraft_engine::find_command(&d.id[4..]).map_or("", |c| c.params);+ let fields = command_fields(doc);+ let dim = crate::theme::Tokens::get(ui.ctx()).text_dim;+ egui::Grid::new("cmdform").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ for f in &fields {+ ui.label(crate::rtl::widget(+ ui,+ format!("{}{}", crate::i18n::tr(&app.ui.language, &humanize(&f.key)), if f.optional { "" } else { " *" }),+ ));+ if f.boolean {+ check(ui, d, &f.key, "");+ } else if !f.choices.is_empty() {+ let mut opts: Vec<(&str, &str)> = vec![("", "—")];+ let labels: Vec<_> = f.choices.iter().map(|c| humanize(c)).collect();+ opts.extend(f.choices.iter().zip(&labels).map(|(value, label)| (value.as_str(), crate::i18n::tr(&app.ui.language, label))));+ combo(ui, d, &f.key, &opts);+ } else {+ let mut s = d.s(&f.key);+ let hint = if f.hint.is_empty() { String::new() } else { f.hint.clone() };+ if ui.add(egui::TextEdit::singleline(&mut s).hint_text(egui::RichText::new(hint).color(dim)).desired_width(240.0)).changed() {+ d.fields.insert(f.key.clone(), Value::String(s));+ }+ }+ ui.end_row();+ }+ });+ if let Some(st) = d.fields.get("status").and_then(Value::as_str) {+ ui.label(egui::RichText::new(st).color(crate::theme::Tokens::get(ui.ctx()).text_dim));+ }+}++const STEP_AND_REPEAT: &str = "cmd:edit.stepAndRepeat";+/// The params a previewing dialog shows on the page (its interaction is open while it is set).+const PREVIEWED: &str = "_previewed";++/// Edit › Step and Repeat, as in InDesign: Repeat (Count, or Rows and Columns with Create as a+/// grid), Offset (Vertical, Horizontal, in the document's ruler units) and Preview, which shows+/// the copies on the page while the dialog is open.+fn step_and_repeat_dialog(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let (hu, vu) = app.session.active().map_or((Unit::Picas, Unit::Picas), |s| (s.doc.settings.horizontal_units, s.doc.settings.vertical_units));+ for (k, v) in [+ ("count", json!("1")),+ ("rows", json!("1")),+ ("columns", json!("1")),+ ("vertical", json!(format_measure(12.0, vu))),+ ("horizontal", json!(format_measure(12.0, hu))),+ ] {+ d.fields.entry(k).or_insert(v);+ }+ let lang = app.ui.language.clone();+ let tr = |s: &str| crate::i18n::tr(&lang, s).to_string();+ ui.horizontal_top(|ui| {+ ui.vertical(|ui| {+ crate::rtl::label(ui, egui::RichText::new(tr("Repeat")).font(semibold(12.0)));+ egui::Grid::new("sr_repeat").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ let grid = d.b("grid");+ let fields: &[(&str, &str)] = if grid { &[("rows", "Rows:"), ("columns", "Columns:")] } else { &[("count", "Count:")] };+ for (k, l) in fields {+ // A grid's columns, not a text frame's.+ crate::rtl::label(ui, crate::i18n::tr_context(&lang, l, "grid"));+ text_field(ui, d, k, 70.0);+ ui.end_row();+ }+ crate::rtl::label(ui, "");+ check(ui, d, "grid", &tr("Create as a grid"));+ ui.end_row();+ });+ ui.add_space(10.0);+ crate::rtl::label(ui, egui::RichText::new(tr("Offset")).font(semibold(12.0)));+ ui.horizontal(|ui| {+ for (k, l) in [("vertical", "Vertical:"), ("horizontal", "Horizontal:")] {+ crate::rtl::label(ui, tr(l));+ text_field(ui, d, k, 80.0);+ ui.add_space(12.0);+ }+ });+ });+ ui.add_space(32.0);+ check(ui, d, "preview", &tr("Preview"));+ });+ step_and_repeat_preview(app, d);+ if let Some(st) = d.fields.get("status").and_then(Value::as_str) {+ ui.add_space(6.0);+ crate::rtl::label(ui, egui::RichText::new(st).color(crate::theme::Tokens::get(ui.ctx()).text_dim));+ }+}++/// `edit.stepAndRepeat`'s params from the dialog: whole counts, offsets in the ruler units+/// (or any unit typed: "-0.75 in", "3p"). Empty fields are 1 copy and 1p0.+fn step_and_repeat_params(app: &DesignApp, d: &Dialog) -> Result<Value, String> {+ let (hu, vu) = app.session.active().map_or((Unit::Picas, Unit::Picas), |s| (s.doc.settings.horizontal_units, s.doc.settings.vertical_units));+ let invalid = |s: &str| format!("{}: {}", crate::i18n::tr(&app.ui.language, "Invalid value"), s.trim());+ // Fields not shown yet (a dialog confirmed over the control channel) take the defaults.+ let whole = |k: &str| {+ let s = d.s(k);+ if s.trim().is_empty() { Ok(1) } else { s.trim().parse::<u64>().map_err(|_| invalid(&s)) }+ };+ let measure = |k: &str, u: Unit| {+ let s = d.s(k);+ if s.trim().is_empty() {+ return Ok(12.0);+ }+ parse_measure(&s, u).ok().filter(|v| v.is_finite()).ok_or_else(|| invalid(&s))+ };+ let (dx, dy) = (measure("horizontal", hu)?, measure("vertical", vu)?);+ Ok(if d.b("grid") {+ json!({"rows": whole("rows")?, "columns": whole("columns")?, "dx": dx, "dy": dy})+ } else {+ json!({"count": whole("count")?, "dx": dx, "dy": dy})+ })+}++/// Preview on: the copies show on the page (redone when a field changes); off: they go.+fn step_and_repeat_preview(app: &mut DesignApp, d: &mut Dialog) {+ let shown = d.fields.get(PREVIEWED).cloned();+ if !d.b("preview") {+ if shown.is_some() {+ app.session.cancel_interaction();+ d.fields.remove(PREVIEWED);+ d.fields.remove("status");+ }+ return;+ }+ let params = match step_and_repeat_params(app, d) {+ Ok(p) => p,+ Err(e) => {+ d.fields.insert("status".into(), json!(e));+ return;+ }+ };+ if shown.as_ref() == Some(¶ms) {+ return;+ }+ if shown.is_none()+ && let Err(e) = app.session.begin_interaction("Step and Repeat")+ {+ d.fields.insert("status".into(), json!(e.to_string()));+ return;+ }+ match app.session.preview("edit.stepAndRepeat", params.clone()) {+ Ok(()) => d.fields.remove("status"),+ Err(e) => d.fields.insert("status".into(), json!(e.to_string())),+ };+ d.fields.insert(PREVIEWED.into(), params);+}++/// New Cross-Reference: link to a paragraph (paragraph styles on the left, their paragraphs on+/// the right) or a text anchor, with a cross-reference format.+fn insert_xref(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let Some(st) = app.session.active() else { return };+ let doc = &st.doc;+ let all = "[All Paragraphs]";+ ui.horizontal(|ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Link To:"));+ translated_combo(&app.ui.language, ui, d, "linkTo", &[("paragraph", "Paragraph"), ("anchor", "Text Anchor")]);+ });+ ui.add_space(6.0);+ let dim = crate::theme::Tokens::get(ui.ctx()).text_dim;+ if d.s("linkTo") == "anchor" {+ egui::ScrollArea::vertical().id_salt("xr_anchors").max_height(220.0).max_width(460.0).show(ui, |ui| {+ let mut any = false;+ for st in doc.stories.values() {+ for a in &st.anchors {+ any = true;+ let key = format!("a:{}", a.id);+ if ui.selectable_label(d.s("target") == key, &a.name).clicked() {+ d.fields.insert("target".into(), json!(key));+ }+ }+ }+ if !any {+ ui.label(crate::rtl::widget(+ ui,+ egui::RichText::new(crate::i18n::tr(&app.ui.language, "No text anchors in this document.")).color(dim),+ ));+ }+ });+ } else {+ let mut styles: Vec<String> = vec![all.to_string()];+ styles.extend(doc.styles.paragraph.iter().map(|s| s.name.clone()));+ let cur_style = if d.s("style").is_empty() { all.to_string() } else { d.s("style") };+ ui.horizontal_top(|ui| {+ let col = |w: f32| (egui::vec2(w, 240.0), egui::Layout::top_down(egui::Align::Min));+ let (sz, lay) = col(180.0);+ ui.allocate_ui_with_layout(sz, lay, |ui| {+ egui::ScrollArea::vertical().id_salt("xr_styles").auto_shrink([false, false]).show(ui, |ui| {+ for name in &styles {+ if ui.selectable_label(*name == cur_style, name).clicked() {+ d.fields.insert("style".into(), json!(name));+ }+ }+ })+ });+ ui.add_space(8.0);+ let (sz, lay) = col(330.0);+ ui.allocate_ui_with_layout(sz, lay, |ui| {+ egui::ScrollArea::vertical().id_salt("xr_paras").auto_shrink([false, false]).show(ui, |ui| {+ for st in doc.stories.values().filter(|s| !s.frames.is_empty()) {+ for (pi, r) in st.para_ranges().into_iter().enumerate() {+ if cur_style != all && st.paras[pi].style != cur_style {+ continue;+ }+ let text = designcraft_doc::xref::clean(&st.text[r]);+ if text.is_empty() {+ continue;+ }+ let short: String = text.chars().take(52).collect();+ let key = format!("{}:{pi}", st.id.0);+ if ui.selectable_label(d.s("target") == key, short).clicked() {+ d.fields.insert("target".into(), json!(key));+ }+ }+ }+ })+ });+ });+ }+ ui.add_space(8.0);+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Cross-Reference Format")).font(semibold(12.0)));+ let names: Vec<String> = doc.xref_formats.iter().map(|f| f.name.clone()).collect();+ if d.s("format").is_empty() {+ d.fields.insert("format".into(), json!(names.first().cloned().unwrap_or_default()));+ }+ let opts: Vec<(&str, &str)> = names.iter().map(|n| (n.as_str(), n.as_str())).collect();+ ui.horizontal(|ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Format:"));+ combo(ui, d, "format", &opts);+ });+ if let Some(m) = d.fields.get("status").and_then(Value::as_str) {+ ui.label(egui::RichText::new(m).color(dim));+ }+}++/// Color Picker: saturation/brightness field and hue slider, with RGB, CMYK and hex fields.+fn color_picker(ui: &mut egui::Ui, d: &mut Dialog) {+ let hex = d.s("hex");+ let mut c = designcraft_color::Color::from_hex(&hex).map(|c| c.to_rgb()).map_or(egui::Color32::BLACK, |[r, g, b]| {+ egui::Color32::from_rgb((r * 255.0).round() as u8, (g * 255.0).round() as u8, (b * 255.0).round() as u8)+ });+ let before = c;+ ui.horizontal_top(|ui| {+ egui::color_picker::color_picker_color32(ui, &mut c, egui::color_picker::Alpha::Opaque);+ ui.vertical(|ui| {+ let mut rgb = [c.r() as f32, c.g() as f32, c.b() as f32];+ egui::Grid::new("cp_rgb").num_columns(2).spacing([6.0, 4.0]).show(ui, |ui| {+ for (k, l) in ["R", "G", "B"].iter().enumerate() {+ ui.label(*l);+ ui.add(egui::DragValue::new(&mut rgb[k]).range(0.0..=255.0));+ ui.end_row();+ }+ });+ c = egui::Color32::from_rgb(rgb[0] as u8, rgb[1] as u8, rgb[2] as u8);+ let col = designcraft_color::Color::rgb8(c.r(), c.g(), c.b());+ let [cc, m, y, k] = col.to_cmyk();+ ui.add_space(6.0);+ ui.label(format!("C {:.0}% M {:.0}% Y {:.0}% K {:.0}%", cc * 100.0, m * 100.0, y * 100.0, k * 100.0));+ ui.add_space(6.0);+ ui.horizontal(|ui| {+ ui.label("#");+ let mut h = format!("{:02x}{:02x}{:02x}", c.r(), c.g(), c.b());+ if ui.add(egui::TextEdit::singleline(&mut h).desired_width(70.0)).changed()+ && let Some(n) = designcraft_color::Color::from_hex(&h)+ {+ let [r, g, b] = n.to_rgb();+ c = egui::Color32::from_rgb((r * 255.0).round() as u8, (g * 255.0).round() as u8, (b * 255.0).round() as u8);+ }+ });+ });+ });+ if c != before {+ d.fields.insert("hex".into(), json!(format!("#{:02x}{:02x}{:02x}", c.r(), c.g(), c.b())));+ }+}++/// Find/Replace Font: the document's fonts (missing ones first, flagged) and a replacement.+/// Load Styles: a checkbox for each style of the picked file, and what happens to a style this+/// document defines differently under the same name.+fn load_styles(app: &DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let lang = app.ui.language.as_str();+ let dim = crate::theme::Tokens::get(ui.ctx()).text_dim;+ ui.label(egui::RichText::new(d.s("path")).size(10.5));+ ui.horizontal(|ui| {+ for (label, on) in [("Select All", true), ("Deselect All", false)] {+ if ui.button(crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() {+ for key in ["paragraph", "character"] {+ for row in d.fields.get_mut(key).and_then(Value::as_array_mut).into_iter().flatten().filter_map(Value::as_object_mut) {+ row.insert("on".into(), json!(on));+ }+ }+ }+ }+ });+ let mut conflicts = 0;+ egui::ScrollArea::vertical().id_salt("load_styles").max_height(240.0).show(ui, |ui| {+ for (key, title) in [("paragraph", "Paragraph Styles"), ("character", "Character Styles")] {+ let Some(rows) = d.fields.get_mut(key).and_then(Value::as_array_mut).filter(|rows| !rows.is_empty()) else { continue };+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(lang, title)).font(semibold(12.0)));+ for row in rows.iter_mut().filter_map(Value::as_object_mut) {+ let Some(name) = row.get("name").and_then(Value::as_str).map(str::to_string) else { continue };+ let (mut on, conflict) = (row.get("on") != Some(&json!(false)), row.get("conflict") == Some(&json!(true)));+ ui.horizontal(|ui| {+ if ui.checkbox(&mut on, crate::rtl::widget(ui, crate::i18n::style_name(lang, &name))).changed() {+ row.insert("on".into(), json!(on));+ }+ if conflict {+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(lang, "Differs from this document")).size(10.5).color(dim));+ }+ });+ conflicts += usize::from(on && conflict);+ }+ }+ });+ ui.add_space(4.0);+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(lang, "Style Name Conflicts")).font(semibold(12.0)));+ if conflicts == 0 {+ crate::rtl::label(ui, crate::i18n::tr(lang, "No conflicts"));+ return;+ }+ let cur = d.s("conflicts");+ ui.horizontal(|ui| {+ for (v, l) in [("redefine", "Redefine Document Style"), ("useExisting", "Use Document Style Definition"), ("autoRename", "Auto Rename")] {+ if ui.radio(cur == v, crate::rtl::widget(ui, crate::i18n::tr(lang, l))).clicked() {+ d.fields.insert("conflicts".into(), json!(v));+ }+ }+ });+}++fn find_font(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ // Listed once when the dialog opens (it scans every story).+ if !d.fields.contains_key("_fonts") {+ let list = app.session.execute("font.list", &json!({})).unwrap_or_default();+ d.fields.insert("_fonts".into(), list);+ }+ let fonts = d.fields.get("_fonts").and_then(Value::as_array).cloned().unwrap_or_default();+ if !fonts.iter().any(|font| font["family"] == d.s("family") && font["style"] == d.s("style"))+ && let Some(font) = fonts.first()+ {+ d.fields.insert("family".into(), font["family"].clone());+ d.fields.insert("style".into(), font["style"].clone());+ }+ if d.b("onOpen") && fonts.iter().any(|f| f["missing"] == true || f["styleMissing"] == true) {+ crate::rtl::label(+ ui,+ crate::i18n::tr(+ &app.ui.language,+ "This document uses unavailable fonts. Choose replacements, or select Done to continue with fallback fonts.",+ ),+ );+ }+ if !d.s("error").is_empty() {+ crate::rtl::label(ui, d.s("error"));+ }+ let missing = fonts.iter().filter(|f| f["missing"] == true || f["styleMissing"] == true).count();+ crate::rtl::label(+ ui,+ crate::i18n::tr(&app.ui.language, "Fonts in Document: {count} Missing: {missing}")+ .replace("{count}", &fonts.len().to_string())+ .replace("{missing}", &missing.to_string()),+ );+ egui::ScrollArea::vertical().id_salt("ff_list").max_height(180.0).show(ui, |ui| {+ for f in &fonts {+ let (fam, st) = (f["family"].as_str().unwrap_or(""), f["style"].as_str().unwrap_or(""));+ let warn = f["missing"] == true || f["styleMissing"] == true;+ let label = format!("{}{fam} {st}", if warn { "\u{26A0} " } else { "" });+ let on = d.s("family") == fam && d.s("style") == st;+ let mut text = egui::RichText::new(label);+ if warn && !on {+ text = text.color(crate::theme::Tokens::get(ui.ctx()).text_strong);+ }+ if ui.selectable_label(on, text).clicked() {+ d.fields.insert("family".into(), json!(fam));+ d.fields.insert("style".into(), json!(st));+ }+ }+ });+ let key = format!("{}\n{}", d.s("family"), d.s("style"));+ if let Some(font) = fonts.iter().find(|f| f["family"] == d.s("family") && f["style"] == d.s("style")) {+ if d.s("_fontKey") != key {+ d.fields.insert("_fontKey".into(), json!(key));+ d.fields.insert("toFamily".into(), font["replacementFamily"].clone());+ d.fields.insert("toStyle".into(), font["replacementStyle"].clone());+ }+ crate::rtl::label(+ ui,+ format!(+ "{}: {} {}",+ crate::i18n::tr(&app.ui.language, "Currently Rendered With"),+ font["resolvedFamily"].as_str().unwrap_or(""),+ font["resolvedStyle"].as_str().unwrap_or("")+ ),+ );+ }+ ui.add_space(8.0);+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Replace With")).font(semibold(12.0)));+ let db = crate::panels::fonts(app);+ if d.s("toFamily").is_empty() {+ d.fields.insert("toFamily".into(), json!(designcraft_fonts::FALLBACK_FAMILY));+ }+ egui::Grid::new("ff_to").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Family:"));+ if let Some(f) = crate::panels::font_combo(app, ui, "toFamily", &d.s("toFamily"), 170.0) {+ let style = crate::panels::pick_style(app, &f);+ d.fields.insert("toFamily".into(), json!(f.family));+ d.fields.insert("toStyle".into(), json!(style));+ }+ ui.end_row();+ let styles = db.styles(&d.s("toFamily"));+ if !styles.iter().any(|style| style == &d.s("toStyle")) {+ let preferred = d.s("style");+ let style = styles+ .iter()+ .find(|s| s.eq_ignore_ascii_case(&preferred))+ .or_else(|| styles.iter().find(|s| s.eq_ignore_ascii_case("Regular")))+ .or_else(|| styles.first());+ if let Some(style) = style {+ d.fields.insert("toStyle".into(), json!(style));+ }+ }+ let st_opts: Vec<(&str, &str)> = styles.iter().map(|s| (s.as_str(), s.as_str())).collect();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Style:"));+ combo(ui, d, "toStyle", &st_opts);+ ui.end_row();+ });+ ui.label(crate::rtl::widget(+ ui,+ egui::RichText::new(crate::i18n::tr(+ &app.ui.language,+ "Replace All updates this font throughout text and styles. Done keeps remaining fallback fonts.",+ ))+ .color(crate::theme::Tokens::get(ui.ctx()).text_dim)+ .size(11.0),+ ));+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn step_and_repeat_dialog_previews_and_makes_the_copies_as_one_undo_step() {+ 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, 600, 540, 640]})).unwrap()["id"].as_u64().unwrap();+ app.run("selection.set", json!({"ids": [id]})).unwrap();+ let open = |app: &mut DesignApp| {+ crate::menus::activate(app, "edit.stepAndRepeat", &Value::Null);+ assert_eq!(app.ui.dialog.as_ref().map(|d| d.id.as_str()), Some(STEP_AND_REPEAT));+ };+ let set = |app: &mut DesignApp, k: &str, v: Value| {+ app.ui.dialog.as_mut().unwrap().fields.insert(k.into(), v);+ };+ let items = |app: &DesignApp| app.session.doc().unwrap().doc.spreads[0].items.len();+ let undo = |app: &DesignApp| app.session.doc().unwrap().history.undo.len();+ let (n0, u0) = (items(&app), undo(&app));+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0));+ open(&mut app);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ for expected in ["Step and Repeat", "Repeat", "Count:", "Create as a grid", "Offset", "Vertical:", "Horizontal:", "Preview", "OK", "Cancel"] {+ visible_label(&labels, screen, expected);+ }+ // Preview: the copies show, and change with the fields, without an undo step.+ set(&mut app, "count", json!("5"));+ set(&mut app, "vertical", json!("-0.75 in"));+ set(&mut app, "horizontal", json!("0"));+ set(&mut app, "preview", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!((items(&app), undo(&app)), (n0 + 5, u0));+ set(&mut app, "count", json!("3"));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(items(&app), n0 + 3);+ set(&mut app, "preview", json!(false));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(items(&app), n0, "Preview off takes them away");+ set(&mut app, "preview", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(items(&app), n0 + 3);+ // Cancel puts the document back.+ cancel(&mut app);+ assert!(app.ui.dialog.is_none());+ assert_eq!((items(&app), undo(&app)), (n0, u0));+ // OK after a preview makes the copies once, as one undo step, 0.75 in apart.+ app.run("selection.set", json!({"ids": [id]})).unwrap();+ open(&mut app);+ set(&mut app, "count", json!("2"));+ set(&mut app, "vertical", json!("-0.75 in"));+ set(&mut app, "horizontal", json!("0"));+ set(&mut app, "preview", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let r = confirm(&mut app).unwrap();+ assert_eq!((items(&app), undo(&app)), (n0 + 2, u0 + 1));+ let last = r["ids"][1].as_u64().unwrap();+ let top = app.session.doc().unwrap().doc.item(designcraft_doc::ItemId(last)).unwrap().bounds().min_y();+ assert!((top - (600.0 - 108.0)).abs() < 1e-6, "{top}");+ // Create as a grid: Rows × Columns cells, the original being one.+ app.run("selection.set", json!({"ids": [id]})).unwrap();+ open(&mut app);+ set(&mut app, "grid", json!(true));+ set(&mut app, "rows", json!("2"));+ set(&mut app, "columns", json!("3"));+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&labels, screen, "Rows:");+ visible_label(&labels, screen, "Columns:");+ assert_eq!(confirm(&mut app).unwrap()["created"], 5);+ // A value that isn't a measure keeps the dialog open and says so.+ open(&mut app);+ set(&mut app, "vertical", json!("up"));+ assert!(confirm(&mut app).is_err());+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!(d.s("status"), "Invalid value: up");+ }++ /// A three-page document in `units` with Document Setup open.+ fn document_setup_app(units: &str) -> DesignApp {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({"pages": 3})).unwrap();+ app.run("document.preferences", json!({"horizontalUnits": units, "verticalUnits": units})).unwrap();+ crate::menus::activate(&mut app, "layout.documentSetup", &Value::Null);+ app+ }++ fn setup_fields(app: &mut DesignApp, fields: Value) {+ let d = app.ui.dialog.as_mut().unwrap();+ for (k, v) in fields.as_object().unwrap() {+ d.fields.insert(k.clone(), v.clone());+ }+ }++ #[test]+ fn document_setup_ok_applies_margins_bleed_and_size_in_one_step() {+ let mut app = document_setup_app("millimeters");+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!(d.id, "documentSetup");+ assert_eq!((d.s("marginTop"), d.b("marginLinked")), ("12.7 mm".to_string(), true), "the document's margins, in its units");+ setup_fields(+ &mut app,+ json!({"marginTop": "20 mm", "marginBottom": "20 mm", "marginInside": "20 mm", "marginOutside": "20 mm", "bleedTop": "3 mm",+ "bleedBottom": "3 mm", "bleedInside": "3 mm", "bleedOutside": "3 mm", "width": "210 mm", "height": "297 mm"}),+ );+ confirm(&mut app).unwrap();+ assert!(app.ui.dialog.is_none());+ let mm = designcraft_geom::units::PT_PER_MM;+ let doc = &app.session.active().unwrap().doc;+ assert!((doc.settings.page_width - 210.0 * mm).abs() < 1e-6 && (doc.settings.bleed[2] - 3.0 * mm).abs() < 1e-6);+ assert!(doc.spreads.iter().flat_map(|s| &s.pages).all(|p| (p.margins.top - 20.0 * mm).abs() < 1e-6), "every page");+ app.run("edit.undo", json!({})).unwrap();+ let doc = &app.session.active().unwrap().doc;+ assert!((doc.settings.page_width - 612.0).abs() < 1e-6 && doc.settings.bleed[0] == 0.0, "one undo step");+ }++ #[test]+ fn document_setup_keeps_each_pages_margins_unless_they_are_edited() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({"pages": 3, "margins": 36})).unwrap();+ app.run("layout.marginsAndColumns", json!({"pages": [1], "margins": 90})).unwrap();+ let margins =+ |app: &DesignApp| app.session.active().unwrap().doc.spreads.iter().flat_map(|s| &s.pages).map(|p| p.margins.top).collect::<Vec<_>>();+ // Only the page count changes: every page keeps its own margins.+ crate::menus::activate(&mut app, "layout.documentSetup", &Value::Null);+ setup_fields(&mut app, json!({"pages": "4"}));+ confirm(&mut app).unwrap();+ assert_eq!(margins(&app), [36.0, 90.0, 36.0, 36.0]);+ // Edited margins go to every page.+ crate::menus::activate(&mut app, "layout.documentSetup", &Value::Null);+ setup_fields(&mut app, json!({"marginTop": "1p0"}));+ confirm(&mut app).unwrap();+ assert_eq!(margins(&app), [12.0; 4]);+ }++ #[test]+ fn document_setup_keeps_a_value_it_cannot_read_and_changes_nothing() {+ for (key, value) in [("width", "wide"), ("marginTop", "-"), ("pages", "0"), ("bleedTop", "x")] {+ let mut app = document_setup_app("points");+ setup_fields(&mut app, json!({key: value, "bleedInside": "9"}));+ assert!(confirm(&mut app).is_err(), "{key}");+ assert!(app.ui.dialog.is_some(), "{key}: the dialog stays open");+ assert_eq!(app.session.active().unwrap().doc.settings.bleed, [0.0; 4], "{key}: nothing changed");+ }+ }++ #[test]+ fn document_setup_links_edges_and_adjust_layout_applies() {+ let mut app = document_setup_app("points");+ let f = app.run("frame.create", json!({"rect": [36, 36, 576, 756], "content": "text"})).unwrap();+ crate::menus::activate(&mut app, "layout.documentSetup", &Value::Null);+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1178.0, 900.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ // Typing in a linked margin sets all four.+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ let top = labels.iter().filter(|(t, _, _)| t == "36 pt").map(|(_, r, _)| *r).next().expect("the top margin");+ click_dialog(&mut app, &ctx, screen, top.center());+ let select_all =+ egui::Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::COMMAND };+ dialog_frame(&mut app, &ctx, screen, vec![select_all, egui::Event::Text("72 pt".into())]);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let d = app.ui.dialog.as_ref().unwrap();+ assert!(["Top", "Bottom", "Inside", "Outside"].iter().all(|e| d.s(&format!("margin{e}")) == "72 pt"), "linked: {:?}", d.fields);+ // Adjust Layout applies at once, and the frame follows the margins.+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "Adjust Layout").center());+ assert!(app.ui.dialog.is_none(), "applied");+ let doc = &app.session.active().unwrap().doc;+ let b = doc.item(designcraft_doc::ItemId(f["id"].as_u64().unwrap())).unwrap().bounds();+ assert!((b.y0 - 72.0).abs() < 1e-6 && doc.page(0).unwrap().margins.outside == 72.0, "{b:?}");+ }++ #[test]+ fn cell_options_dialog_draws_and_applies_only_changed_values_to_the_chosen_edges() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("frame.create", json!({"rect": [72, 72, 400, 400], "content": "text", "caret": true})).unwrap();+ let tid = app.run("table.insert", json!({"rows": 2, "cols": 2})).unwrap()["table"].as_u64().unwrap();+ app.run("table.select", json!({"what": "table"})).unwrap();+ app.run("app.cellOptionsDialog", json!({})).unwrap();+ let ctx = dialog_context("");+ dialog_frame(&mut app, &ctx, egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(900.0, 700.0)), vec![]);+ let d = app.ui.dialog.as_mut().unwrap();+ assert_eq!(d.id, "cellOptions");+ assert_eq!(d.fields["weight"], json!(1.0));+ d.fields.insert("edges".into(), json!(["top", "bottom", "left", "right"]));+ d.fields.insert("gapColor".into(), json!("[Paper]"));+ d.fields.insert("fill".into(), json!("[Black]"));+ d.fields.insert("fillTint".into(), json!(0.2));+ confirm(&mut app).unwrap();+ let st = app.session.active().unwrap();+ let t = st.doc.stories.values().find_map(|s| s.tables.get(&tid)).unwrap();+ let gap = |r: usize, c: usize, side: usize| t.cell(r, c).unwrap().strokes[side].gap_color.clone();+ assert_eq!([gap(0, 0, 0), gap(0, 0, 1), gap(1, 1, 2), gap(1, 1, 3)], ["[Paper]"; 4].map(String::from), "outer edges");+ assert_eq!([gap(0, 0, 2), gap(0, 0, 3)], ["[None]"; 2].map(String::from), "inner edges keep theirs");+ assert!(t.cells.iter().all(|c| c.fill == "[Black]" && (c.fill_tint - 0.2).abs() < 1e-6));+ assert!(t.cells.iter().all(|c| c.strokes.iter().all(|e| e.weight == 1.0)), "unchanged values are not applied");+ }++ #[test]+ fn cell_options_edge_changes_reseed_every_stroke_field_and_survive_a_bad_seed() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("frame.create", json!({"rect": [72, 72, 400, 400], "content": "text", "caret": true})).unwrap();+ let tid = app.run("table.insert", json!({"rows": 2, "cols": 2})).unwrap()["table"].as_u64().unwrap();+ app.run("table.select", json!({"what": "table"})).unwrap();+ app.run("table.setCell", json!({"stroke": {"weight": 3, "edges": "innerHorizontal"}})).unwrap();+ app.run("app.cellOptionsDialog", json!({})).unwrap();+ let mut d = app.ui.dialog.take().unwrap();+ d.fields.insert("seed".into(), json!(5));+ let outer = [true, true, true, true, false, false];+ cell_options_edges_changed(&mut app, &mut d, &outer);+ assert_eq!((&d.fields["weight"], &d.fields["seed"]["weight"]), (&json!(1.0), &json!(1.0)));+ // A weight typed for the outer edges, then the inner horizontal edges (3 pt) chosen+ // and 1 pt typed: 1 pt differs from what those edges show, so OK applies it.+ d.fields.insert("weight".into(), json!(5.0));+ cell_options_edges_changed(&mut app, &mut d, &[false, false, false, false, true, false]);+ assert_eq!((&d.fields["weight"], &d.fields["seed"]["weight"]), (&json!(5.0), &json!(3.0)));+ d.fields.insert("weight".into(), json!(1.0));+ app.ui.dialog = Some(d);+ confirm(&mut app).unwrap();+ let st = app.session.active().unwrap();+ let t = st.doc.stories.values().find_map(|s| s.tables.get(&tid)).unwrap();+ assert_eq!([t.cell(0, 0).unwrap().strokes[2].weight, t.cell(1, 1).unwrap().strokes[0].weight], [1.0; 2]);+ }+++ #[test]++ fn enter_and_escape_close_the_style_menu_not_numbering_and_section_options() {++ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());++ app.run("file.new", json!({"pages": 2})).unwrap();++ crate::menus::activate(&mut app, "layout.section", &Value::Null);++ 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 key = |key| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE };++ for pressed in [egui::Key::Enter, egui::Key::Escape] {++ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);++ // The section's Style menu (the first of the two).++ let style = labels.iter().filter(|(t, r, c)| t.trim() == "1, 2, 3, 4…" && c.contains_rect(*r)).map(|(_, r, _)| *r).next().unwrap();++ click_dialog(&mut app, &ctx, screen, style.center());++ dialog_frame(&mut app, &ctx, screen, vec![]);++ assert!(egui::Popup::is_any_open(&ctx), "the Style menu opened");++ dialog_frame(&mut app, &ctx, screen, vec![key(pressed)]);++ dialog_frame(&mut app, &ctx, screen, vec![]);++ assert!(app.ui.dialog.is_some(), "{pressed:?} with the menu open leaves the dialog open");++ assert!(app.session.active().unwrap().doc.sections.iter().all(|s| s.start_number != Some(0)));++ if egui::Popup::is_any_open(&ctx) {++ egui::Popup::close_all(&ctx);++ dialog_frame(&mut app, &ctx, screen, vec![]);++ }++ }++ // With no menu open, Escape closes the dialog.++ dialog_frame(&mut app, &ctx, screen, vec![key(egui::Key::Escape)]);++ assert!(app.ui.dialog.is_none());++ }+++ #[test]+ fn numbering_and_section_options_keep_their_actions_in_view() {+ for language in ["en", "ar"] {+ for size in [egui::vec2(1178.0, 814.0), egui::vec2(392.0, 271.0)] {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.ui.language = language.into();+ app.run("file.new", json!({"pages": 2})).unwrap();+ crate::menus::activate(&mut app, "layout.section", &Value::Null);+ let ctx = dialog_context(language);+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, size);+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ let tr = |s| crate::i18n::tr(language, s);+ for expected in [tr("Numbering & Section Options…").trim_end_matches('…'), tr("OK"), tr("Cancel"), tr("Start Section")] {+ visible_label(&labels, screen, expected);+ }+ if size.x > 1000.0 {+ // Every option fits without scrolling, and choosing one then OK applies it.+ visible_label(&labels, screen, &format!("{} {}", tr("Book Name:"), tr("N/A")));+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, tr("Automatic Page Numbering")).center());+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, tr("OK")).center());+ assert!(app.ui.dialog.is_none(), "{language}: OK closes the dialog");+ let doc = &app.session.active().unwrap().doc;+ assert!(doc.sections.iter().all(|s| s.start != 0 || s.start_number.is_none()), "{language}: page 1 numbers automatically");+ }+ }+ }+ }++ fn draw(app: &mut DesignApp, ctx: &egui::Context) {+ let input =+ egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1400.0, 900.0))), ..Default::default() };+ let mut out = ctx.run_ui(input, |ui| {+ app.logic(&ui.ctx().clone());+ app.ui(ui);+ });+ out.textures_delta.clear();+ }++ /// A paragraph styled "Ruled Child", whose Rule Below comes from its parent "Ruled".+ fn ruled_paragraph() -> (DesignApp, Value) {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ let rule = json!({"on": true, "weight": 3.0, "color": "[Black]", "tint": 0.5, "columnWidth": false, "offset": 4.0, "leftIndent": 6.0, "rightIndent": 2.0});+ app.run("style.paragraph.create", json!({"name": "Ruled", "para": {"ruleBelow": rule}})).unwrap();+ app.run("style.paragraph.create", json!({"name": "Ruled Child", "basedOn": "Ruled"})).unwrap();+ let r = app.run("frame.create", json!({"rect": [72, 72, 300, 400], "content": "text", "text": "One"})).unwrap();+ app.run("text.select", json!({"story": r["story"], "anchor": 0, "focus": 0})).unwrap();+ app.run("style.paragraph.apply", json!({"name": "Ruled Child"})).unwrap();+ (app, rule)+ }++ fn undo_steps(app: &DesignApp) -> usize {+ app.session.doc().map_or(0, |st| st.history.undo.len())+ }++ #[test]+ fn paragraph_rules_dialog_shows_the_rule_and_applies_one_field() {+ let (mut app, rule) = ruled_paragraph();+ let ctx = egui::Context::default();+ app.run("app.paragraphRulesDialog", json!({"rule": "ruleBelow"})).unwrap();+ draw(&mut app, &ctx);+ let d = app.ui.dialog.clone().unwrap();+ assert_eq!(d.id, "paragraphRules");+ let current = d.fields["current"].clone();+ assert_eq!(shown_rule(&d, "", "ruleBelow", ¤t), rule, "the inherited rule");+ assert_eq!(shown_rule(&d, "", "ruleAbove", ¤t)["on"], false);+ // Pick a colour, as the Color menu does.+ app.ui.dialog.as_mut().unwrap().fields.insert("ruleBelow.color".into(), json!("[Registration]"));+ draw(&mut app, &ctx);+ let before = undo_steps(&app);+ confirm(&mut app).unwrap();+ assert_eq!(undo_steps(&app), before + 1, "one undo step");+ let mut want = rule.clone();+ want["color"] = json!("[Registration]");+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], want);+ app.run("edit.undo", json!({})).unwrap();+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], rule);+ }++ #[test]+ fn paragraph_style_options_edit_one_rule_field() {+ let (mut app, rule) = 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);+ let resolved = |app: &DesignApp| serde_json::to_value(app.session.doc().unwrap().doc.styles.resolve_para_style("Ruled Child").0).unwrap();+ let d = app.ui.dialog.clone().unwrap();+ assert_eq!(shown_rule(&d, "p.", "ruleBelow", &resolved(&app)), rule, "inherited from the parent style");+ app.ui.dialog.as_mut().unwrap().fields.insert("p.ruleBelow.weight".into(), json!(1.5));+ draw(&mut app, &ctx);+ let before = undo_steps(&app);+ confirm(&mut app).unwrap();+ assert_eq!(undo_steps(&app), before + 1, "one undo step");+ let mut want = rule.clone();+ want["weight"] = json!(1.5);+ assert_eq!(resolved(&app)["ruleBelow"], want);+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], want, "the paragraph follows its style");+ app.run("edit.undo", json!({})).unwrap();+ assert_eq!(resolved(&app)["ruleBelow"], rule);+ }++ /// Opens Paragraph Style Options on "Ruled Child" at each of `sections`, sets `fields` and+ /// clicks OK; returns the resolved attributes of the paragraph styled with it.+ fn style_section_edit(sections: &[&str], fields: Value) -> Value {+ let (mut app, _) = ruled_paragraph();+ let ctx = egui::Context::default();+ app.ui.dialog = Some(Dialog::new("paragraphStyleOptions", json!({"name": "Ruled Child"})));+ for section in sections {+ app.ui.dialog.as_mut().unwrap().fields.insert("section".into(), json!(section));+ draw(&mut app, &ctx);+ }+ for (k, v) in fields.as_object().unwrap() {+ app.ui.dialog.as_mut().unwrap().fields.insert(k.clone(), v.clone());+ }+ draw(&mut app, &ctx);+ let before = undo_steps(&app);+ confirm(&mut app).unwrap();+ assert_eq!(undo_steps(&app), before + 1, "one undo step");+ let style = app.session.doc().unwrap().doc.styles.para("Ruled Child").cloned().unwrap();+ let own = serde_json::to_value(&style.para).unwrap();+ for (k, v) in fields.as_object().unwrap() {+ assert_eq!(own[k.trim_start_matches("p.")], *v, "the style sets {k}");+ }+ app.run("type.selectionAttrs", json!({})).unwrap()["para"].clone()+ }++ #[test]+ fn paragraph_style_options_keep_and_border_sections_reach_the_styled_paragraph() {+ let para = style_section_edit(+ &["keep", "border"],+ json!({"p.keepWithNext": 2, "p.keepLinesTogether": true, "p.keepAllLines": false, "p.keepFirst": 3,+ "p.startParagraph": "nextPage", "p.borderOn": true, "p.borderWeights": [2.0, 0.0, 2.0, 0.0]}),+ );+ assert_eq!(para["keepWithNext"], 2);+ assert_eq!(para["keepLinesTogether"], true);+ assert_eq!(para["keepAllLines"], false);+ assert_eq!(para["keepFirst"], 3);+ assert_eq!(para["startParagraph"], "nextPage");+ assert_eq!(para["borderOn"], true);+ assert_eq!(para["borderWeights"], json!([2.0, 0.0, 2.0, 0.0]));+ // Fields not edited keep the resolved value.+ assert_eq!(para["keepLast"], 2);+ assert_eq!(para["ruleBelow"]["weight"], 3.0);+ }++ #[test]+ fn paragraph_style_options_bullets_and_span_sections_reach_the_styled_paragraph() {+ let para = style_section_edit(+ &["bullets", "span"],+ json!({"p.listType": "numbers", "p.numberStyle": "upperRoman", "p.numberExpression": "^#)^t", "p.startAt": 3,+ "p.spanColumns": {"kind": "split", "columns": 3}}),+ );+ assert_eq!(para["listType"], "numbers");+ assert_eq!(para["numberStyle"], "upperRoman");+ assert_eq!(para["numberExpression"], "^#)^t");+ assert_eq!(para["startAt"], 3);+ assert_eq!(para["spanColumns"], json!({"kind": "split", "columns": 3}));+ let props: designcraft_doc::ParaProps = serde_json::from_value(para).unwrap();+ assert_eq!(props.number_label(3), "III)\t");+ }++ #[test]+ fn paragraph_style_options_keep_a_bad_grep_pattern_open_with_the_error() {+ let (mut app, _) = ruled_paragraph();+ let ctx = egui::Context::default();+ app.ui.dialog = Some(Dialog::new("paragraphStyleOptions", json!({"name": "Ruled", "section": "general"})));+ draw(&mut app, &ctx);+ app.ui.dialog.as_mut().unwrap().fields.insert("p.grepStyles".into(), json!([{"style": "[None]", "pattern": "(?<=x"}]));+ let e = confirm(&mut app).unwrap_err();+ assert!(e.contains("bad GREP"), "{e}");+ let d = app.ui.dialog.clone().expect("the dialog stays open");+ assert_eq!((d.s("section").as_str(), d.s("status").contains("bad GREP")), ("grep", true));+ assert!(app.session.doc().unwrap().doc.styles.para("Ruled").unwrap().para.grep_styles.is_none(), "nothing saved");+ draw(&mut app, &ctx);+ }++ /// A frame with two paragraphs of [Basic Paragraph]; the first has a local Word Spacing minimum.+ fn two_paragraphs() -> (DesignApp, Value) {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ let r = app.run("frame.create", json!({"rect": [72, 72, 300, 400], "content": "text", "text": "One\nTwo"})).unwrap();+ app.run("text.select", json!({"story": r["story"], "anchor": 0, "focus": 0})).unwrap();+ app.run("type.para", json!({"attrs": {"wordSpaceMin": 0.7}})).unwrap();+ (app, r["story"].clone())+ }++ /// The resolved paragraph attribute `key` of the paragraph at byte `at`.+ fn para_attr(app: &mut DesignApp, story: &Value, at: usize, key: &str) -> Value {+ app.run("text.select", json!({"story": story, "anchor": at, "focus": at})).unwrap();+ app.run("type.selectionAttrs", json!({})).unwrap()["para"][key].clone()+ }++ #[test]+ fn justification_dialog_applies_to_a_local_paragraph_and_cancel_changes_nothing() {+ let (mut app, story) = two_paragraphs();+ let ctx = egui::Context::default();+ assert!(crate::menus::menu_enabled(&app, "app.justificationDialog"));+ app.run("app.justificationDialog", json!({})).unwrap();+ draw(&mut app, &ctx);+ let d = app.ui.dialog.clone().unwrap();+ assert_eq!(d.id, "justification");+ assert_eq!(d.fields["current"]["wordSpaceMin"], 0.7);+ assert_eq!(d.fields["current"]["wordSpaceDesired"], 1.0);+ app.ui.dialog.as_mut().unwrap().fields.insert("wordSpaceDesired".into(), json!(1.1));+ draw(&mut app, &ctx);+ let before = undo_steps(&app);+ confirm(&mut app).unwrap();+ assert_eq!(undo_steps(&app), before + 1, "one undo step");+ assert_eq!(para_attr(&mut app, &story, 0, "wordSpaceDesired"), 1.1);+ assert_eq!(para_attr(&mut app, &story, 0, "wordSpaceMin"), 0.7, "unedited fields stay");+ assert_eq!(para_attr(&mut app, &story, 4, "wordSpaceDesired"), 1.0, "only the selected paragraph");+ let style = app.session.doc().unwrap().doc.styles.resolve_para_style(designcraft_doc::story::BASIC_PARAGRAPH).0.word_space_desired;+ assert_eq!(style, 1.0, "the paragraph style keeps its value");++ // Cancel (Escape) leaves the paragraph alone.+ app.run("text.select", json!({"story": story, "anchor": 0, "focus": 0})).unwrap();+ app.run("app.justificationDialog", json!({})).unwrap();+ app.ui.dialog.as_mut().unwrap().fields.insert("wordSpaceDesired".into(), json!(1.2));+ let before = undo_steps(&app);+ let escape = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };+ let input = egui::RawInput {+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1400.0, 900.0))),+ events: vec![escape],+ ..Default::default()+ };+ let mut out = ctx.run_ui(input, |ui| {+ app.logic(&ui.ctx().clone());+ app.ui(ui);+ });+ out.textures_delta.clear();+ assert!(app.ui.dialog.is_none(), "cancelled");+ assert_eq!(undo_steps(&app), before);+ assert_eq!(para_attr(&mut app, &story, 0, "wordSpaceDesired"), 1.1);++ app.run("edit.deselectAll", json!({})).unwrap();+ assert!(!crate::menus::menu_enabled(&app, "app.justificationDialog"), "nothing to justify");+ assert!(app.run("app.justificationDialog", json!({})).is_err());+ }++ #[test]+ fn justification_dialog_leaves_mixed_fields_alone_and_refuses_bad_values() {+ let (mut app, story) = two_paragraphs();+ let ctx = egui::Context::default();+ app.run("text.select", json!({"story": story, "anchor": 0, "focus": 7})).unwrap();+ app.run("app.justificationDialog", json!({})).unwrap();+ draw(&mut app, &ctx);+ let d = app.ui.dialog.clone().unwrap();+ assert_eq!(d.fields["current"]["wordSpaceMin"], Value::Null, "mixed shows empty");+ assert_eq!(d.fields["current"]["wordSpaceMax"], 1.33);++ // Out of range, and minimum above desired: an error, the dialog stays open, nothing changes.+ let before = undo_steps(&app);+ for (key, v) in [("wordSpaceMax", 20.0), ("glyphScaleMin", 0.2), ("letterSpaceDesired", f64::NAN)] {+ app.ui.dialog = Some(d.clone());+ app.ui.dialog.as_mut().unwrap().fields.insert(key.into(), json!(v));+ assert!(confirm(&mut app).is_err(), "{key} = {v}");+ assert!(app.ui.dialog.as_ref().is_some_and(|d| d.fields.contains_key("justifyError")), "{key}: the dialog shows why");+ }+ app.ui.dialog = Some(d.clone());+ app.ui.dialog.as_mut().unwrap().fields.insert("letterSpaceMin".into(), json!(0.1));+ assert!(confirm(&mut app).is_err(), "letter spacing minimum above desired");+ draw(&mut app, &ctx);+ assert_eq!(undo_steps(&app), before);++ app.ui.dialog = Some(d);+ app.ui.dialog.as_mut().unwrap().fields.insert("wordSpaceMax".into(), json!(1.5));+ confirm(&mut app).unwrap();+ assert_eq!(undo_steps(&app), before + 1);+ for (at, min) in [(0, 0.7), (4, 0.8)] {+ assert_eq!(para_attr(&mut app, &story, at, "wordSpaceMax"), 1.5);+ assert_eq!(para_attr(&mut app, &story, at, "wordSpaceMin"), min, "each paragraph keeps its own minimum");+ }+ }++ fn command_app(id: &str, fields: Value) -> DesignApp {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.ui.dialog = Some(Dialog::new(&format!("cmd:{id}"), fields));+ app+ }++ #[test]+ fn generic_new_document_preserves_typed_values_and_text_entry() {+ for pages in [json!(2), json!(" 2 ")] {+ let mut app = command_app(+ "file.new",+ json!({+ "preset": "A4", "pages": pages, "facingPages": false, "gutter": 0,+ "margins": {"top": 10, "bottom": 20, "inside": 30, "outside": 40},+ "title": " ", "status": "internal", "primaryTextFrame": true+ }),+ );+ confirm(&mut app).unwrap();+ let doc = &app.session.active().unwrap().doc;+ assert_eq!(doc.page_count(), 2);+ assert!(!doc.settings.facing_pages);+ assert!(doc.title.starts_with("Untitled-"));+ for page in doc.spreads.iter().flat_map(|s| &s.pages) {+ assert!((page.width - 595.2755905511812).abs() < 0.01);+ assert!((page.height - 841.8897637795277).abs() < 0.01);+ assert_eq!(page.columns.gutter, 0.0);+ assert_eq!(page.margins.top, 10.0);+ assert_eq!(page.margins.outside, 40.0);+ }+ assert!(doc.spreads.iter().all(|s| s.items.is_empty()), "undocumented fields stay excluded");+ assert!(app.ui.dialog.is_none());+ }}- ui.add_space(8.0);- crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Cross-Reference Format")).font(semibold(12.0)));- let names: Vec<String> = doc.xref_formats.iter().map(|f| f.name.clone()).collect();- if d.s("format").is_empty() {- d.fields.insert("format".into(), json!(names.first().cloned().unwrap_or_default()));++ #[test]+ fn numbering_commands_document_their_fields() {+ let names = |id: &str| command_fields(designcraft_engine::find_command(id).unwrap().params).into_iter().map(|f| f.key).collect::<Vec<_>>();+ assert_eq!(names("layout.section"), ["page", "startNumber", "style", "prefix", "includePrefix", "marker", "remove"]);+ assert_eq!(names("layout.chapterNumbering"), ["style", "start", "source"]);}- let opts: Vec<(&str, &str)> = names.iter().map(|n| (n.as_str(), n.as_str())).collect();- ui.horizontal(|ui| {- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Format:"));- combo(ui, d, "format", &opts);- });- if let Some(m) = d.fields.get("status").and_then(Value::as_str) {- ui.label(egui::RichText::new(m).color(dim));++ #[test]+ fn generic_command_preserves_array_geometry() {+ let mut app = command_app("file.new", json!({}));+ confirm(&mut app).unwrap();+ app.ui.dialog = Some(Dialog::new("cmd:frame.create", json!({"rect": [10, 20, 110, 220]})));+ confirm(&mut app).unwrap();+ let doc = &app.session.active().unwrap().doc;+ let item = doc.spreads.iter().flat_map(|s| &s.items).next().unwrap();+ assert_eq!(item.bounds(), designcraft_geom::Rect::new(10.0, 20.0, 110.0, 220.0));}-}-/// Color Picker: saturation/brightness field and hue slider, with RGB, CMYK and hex fields.-fn color_picker(ui: &mut egui::Ui, d: &mut Dialog) {- let hex = d.s("hex");- let mut c = designcraft_color::Color::from_hex(&hex).map(|c| c.to_rgb()).map_or(egui::Color32::BLACK, |[r, g, b]| {- egui::Color32::from_rgb((r * 255.0).round() as u8, (g * 255.0).round() as u8, (b * 255.0).round() as u8)- });- let before = c;- ui.horizontal_top(|ui| {- egui::color_picker::color_picker_color32(ui, &mut c, egui::color_picker::Alpha::Opaque);- ui.vertical(|ui| {- let mut rgb = [c.r() as f32, c.g() as f32, c.b() as f32];- egui::Grid::new("cp_rgb").num_columns(2).spacing([6.0, 4.0]).show(ui, |ui| {- for (k, l) in ["R", "G", "B"].iter().enumerate() {- ui.label(*l);- ui.add(egui::DragValue::new(&mut rgb[k]).range(0.0..=255.0));- ui.end_row();- }- });- c = egui::Color32::from_rgb(rgb[0] as u8, rgb[1] as u8, rgb[2] as u8);- let col = designcraft_color::Color::rgb8(c.r(), c.g(), c.b());- let [cc, m, y, k] = col.to_cmyk();- ui.add_space(6.0);- ui.label(format!("C {:.0}% M {:.0}% Y {:.0}% K {:.0}%", cc * 100.0, m * 100.0, y * 100.0, k * 100.0));- ui.add_space(6.0);- ui.horizontal(|ui| {- ui.label("#");- let mut h = format!("{:02x}{:02x}{:02x}", c.r(), c.g(), c.b());- if ui.add(egui::TextEdit::singleline(&mut h).desired_width(70.0)).changed()- && let Some(n) = designcraft_color::Color::from_hex(&h)- {- let [r, g, b] = n.to_rgb();- c = egui::Color32::from_rgb((r * 255.0).round() as u8, (g * 255.0).round() as u8, (b * 255.0).round() as u8);- }- });- });- });- if c != before {- d.fields.insert("hex".into(), json!(format!("#{:02x}{:02x}{:02x}", c.r(), c.g(), c.b())));+ #[test]+ fn generic_explicit_null_uses_the_commands_existing_semantics() {+ // file.new accepts null width by using the selected preset's width.+ for width in [Value::Null, json!("null")] {+ let mut app = command_app("file.new", json!({"preset": "A4", "width": width, "title": " Sample layout "}));+ confirm(&mut app).unwrap();+ let doc = &app.session.active().unwrap().doc;+ assert_eq!(doc.title, "Sample layout");+ assert!((doc.settings.page_width - 595.2755905511812).abs() < 0.01);+ }}-}-/// Find/Replace Font: the document's fonts (missing ones first, flagged) and a replacement.-fn find_font(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {- // Listed once when the dialog opens (it scans every story).- if !d.fields.contains_key("_fonts") {- let list = app.session.execute("font.list", &json!({})).unwrap_or_default();- d.fields.insert("_fonts".into(), list);+ #[test]+ fn generic_invalid_number_retains_dialog_without_creating_document() {+ let mut app = command_app("file.new", json!({"width": 0}));+ assert!(confirm(&mut app).is_err());+ assert!(app.session.active().is_none());+ let dialog = app.ui.dialog.as_ref().unwrap();+ assert_eq!(dialog.fields["width"], 0);+ assert!(dialog.fields["status"].as_str().unwrap().contains("page size out of range"));}- let fonts = d.fields.get("_fonts").and_then(Value::as_array).cloned().unwrap_or_default();- let missing = fonts.iter().filter(|f| f["missing"] == true || f["styleMissing"] == true).count();- crate::rtl::label(- ui,- crate::i18n::tr(&app.ui.language, "Fonts in Document: {count} Missing: {missing}")- .replace("{count}", &fonts.len().to_string())- .replace("{missing}", &missing.to_string()),- );- egui::ScrollArea::vertical().id_salt("ff_list").max_height(180.0).show(ui, |ui| {- for f in &fonts {- let (fam, st) = (f["family"].as_str().unwrap_or(""), f["style"].as_str().unwrap_or(""));- let warn = f["missing"] == true || f["styleMissing"] == true;- let label = format!("{}{fam} {st}", if warn { "\u{26A0} " } else { "" });- let on = d.s("family") == fam && d.s("style") == st;- let mut text = egui::RichText::new(label);- if warn {- text = text.color(egui::Color32::from_rgb(0xe5, 0x4b, 0x4b));- }- if ui.selectable_label(on, text).clicked() {- d.fields.insert("family".into(), json!(fam));- d.fields.insert("style".into(), json!(st));++ #[test]+ fn text_frame_options_change_only_what_was_edited() {+ let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ let r = app.run("frame.create", json!({"rect": [36, 36, 336, 236], "content": "text", "text": "Hello"})).unwrap();+ let id = designcraft_doc::ItemId(r["id"].as_u64().unwrap());+ app.run("object.textFrameOptions", json!({"ids": [id.0], "columns": 2, "inset": [1, 2, 3, 4]})).unwrap();+ let opts = |app: &DesignApp| app.session.doc().unwrap().doc.item(id).unwrap().text_frame().unwrap().options.clone();+ let before = opts(&app);+ let open = |app: &mut DesignApp, fields: &[(&str, Value)]| {+ app.ui.dialog = Some(Dialog::new("textFrameOptions", json!({})));+ let mut d = app.ui.dialog.take().unwrap();+ seed_text_frame_options(app, &mut d);+ for (k, v) in fields {+ d.fields.insert((*k).into(), v.clone());}+ app.ui.dialog = Some(d);+ confirm(app)+ };+ // OK without edits changes nothing (no undo step either).+ assert_eq!(open(&mut app, &[]).unwrap(), Value::Null);+ assert_eq!(opts(&app), before);+ // The rule's weight is in points; unequal insets the user didn't touch stay.+ open(&mut app, &[("columnRule", json!(true)), ("columnRuleWeight", json!("6"))]).unwrap();+ let o = opts(&app);+ assert!(o.column_rule && o.column_rule_weight == 6.0, "{o:?}");+ assert_eq!((o.inset, o.columns, o.gutter), (before.inset, before.columns, before.gutter));+ // One of the rule's insets edited: the other rule settings stay.+ open(&mut app, &[("columnRuleBottomInset", json!("0p9")), ("columnRuleTint", json!("40"))]).unwrap();+ let o = opts(&app);+ assert_eq!((o.column_rule_bottom_inset, o.column_rule_top_inset, o.column_rule_offset, o.column_rule_weight), (9.0, 0.0, 0.0, 6.0));+ assert!((o.column_rule_tint - 0.4).abs() < 1e-6 && o.column_rule);+ // One inset side edited: the others keep their values.+ open(&mut app, &[("insetLeft", json!("1p0"))]).unwrap();+ assert_eq!(opts(&app).inset, [1.0, 12.0, 3.0, 4.0]);+ // An unknown swatch is an error and the dialog stays open.+ let e = open(&mut app, &[("columnRuleColor", json!("Mauve"))]).unwrap_err();+ assert!(e.contains("Mauve") && app.ui.dialog.is_some(), "{e}");+ assert_eq!(opts(&app).column_rule_color, designcraft_color::swatch::BLACK);+ // Each OK is one undo step.+ for _ in 0..3 {+ app.run("edit.undo", json!({})).unwrap();}- });- ui.add_space(8.0);- crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Replace With")).font(semibold(12.0)));- let db = crate::panels::fonts(app);- egui::Grid::new("ff_to").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Family:"));- if let Some(f) = crate::panels::font_combo(app, ui, "toFamily", &d.s("toFamily"), 170.0) {- d.fields.insert("toFamily".into(), json!(f));- }- ui.end_row();- let styles = db.styles(&d.s("toFamily"));- let st_opts: Vec<(&str, &str)> = styles.iter().map(|s| (s.as_str(), s.as_str())).collect();- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Style:"));- combo(ui, d, "toStyle", &st_opts);- ui.end_row();- });- ui.label(crate::rtl::widget(- ui,- egui::RichText::new(crate::i18n::tr(&app.ui.language, "OK changes all: text and paragraph/character styles."))- .color(crate::theme::Tokens::get(ui.ctx()).text_dim)- .size(11.0),- ));-}--#[cfg(test)]-mod tests {- use super::*;+ assert_eq!(opts(&app), before);+ }fn dialog_context(language: &str) -> egui::Context {let ctx = egui::Context::default();diff --cc docs/target-app-parity.mdindex 5edde1c9f,3a7e65ace..f98ccfb76--- a/docs/target-app-parity.md+++ b/docs/target-app-parity.md@@@ -352,8 -348,9 +352,9 @@@ It is evidence of breadth: each item ex- Edit ▸ Menus (`window.hideMenuItem`): hide menu items; menus with hidden items end in Show All Menu Items.- View ▸ Separations Preview (`view.separations`): one process plate as ink density, or areas over an ink limit in red (a GCR preview of the rendered view; spot plates and the flattener preview aren't there).- Separations Preview plates now come from each object's own colour (CMYK as authored; RGB and images through the colour settings, images via a cached 17³ table), so pure black shows only on the black plate.-- Language (Character panel ▸ Language, Properties ▸ Character, `type.char {language}`): text in other languages isn't hyphenated or spell-checked with the English dictionaries, typographer's quotes follow the language (German „…“, French and Russian «…», Swiss, Spanish, Dutch, Nordic, Japanese and Traditional Chinese 「…」, Simplified Chinese “…”), the font's localized forms (OpenType `locl`: Turkish i, Bulgarian Cyrillic, Japanese / Chinese / Korean glyph variants) follow it too, and so does the fallback for CJK characters the font lacks (with Draw Missing Glyphs from Fallback Fonts on): Japanese, Simplified Chinese, Traditional Chinese and Korean each try their own installed system fonts (Japanese starts with the craft-fonts Japanese faces, Mincho first, when built with them; Hangul, kana and Bopomofo pick their language's fonts whatever the language). Language names from IDML keep their spelling; locale codes as InDesign writes them for some languages (`de_DE_2006`, `nl_NL_2005`; any `ll`, `ll_CC`, `ll-CC`) are their language and region for all of the above, and Chinese is also recognised in its common spellings ("Simplified Chinese", "Chinese (Traditional)", `zh_CN`, `zh-Hant`). Spanish is hyphenated with Javier Bezos's Liang patterns (`hyph-es.tex` 5.0, MIT) and Portuguese with hyph-utf8's `hyph-pt.tex` 1.4 (BSD-3-Clause), both through the `hypher` crate; hyphenation for other languages isn't bundled yet.+- Language (Character panel ▸ Language, Properties ▸ Character, `type.char {language}`): text in other languages isn't hyphenated or spell-checked with the English dictionaries, typographer's quotes follow the language (German „…“, French and Russian «…», Swiss, Spanish, Dutch, Nordic, Japanese and Traditional Chinese 「…」, Simplified Chinese “…”), the font's localized forms (OpenType `locl`: Turkish i, Bulgarian Cyrillic, Japanese / Chinese / Korean glyph variants) follow it too, and so does the fallback for CJK characters the font lacks (with Draw Missing Glyphs from Fallback Fonts on): Japanese, Simplified Chinese, Traditional Chinese and Korean each try their own installed system fonts (Japanese starts with the craft-fonts Japanese faces, Mincho first, when built with them; Hangul, kana and Bopomofo pick their language's fonts whatever the language). Language names from IDML keep their spelling; locale codes as InDesign writes them for some languages (`de_DE_2006`, `nl_NL_2005`; any `ll`, `ll_CC`, `ll-CC`) are their language and region for all of the above, and Chinese is also recognised in its common spellings ("Simplified Chinese", "Chinese (Traditional)", `zh_CN`, `zh-Hant`). Spanish is hyphenated with Javier Bezos's Liang patterns (`hyph-es.tex` 5.0, MIT), Portuguese with hyph-utf8's `hyph-pt.tex` 1.4 (BSD-3-Clause) and Norwegian with hyph-utf8's `hyph-no.tex` (permissive), all through the `hypher` crate; hyphenation for other languages isn't bundled yet.- Books (`book.new/open/add/remove/list/styleSource/paginate/syncStyles/exportPdf`, Book panel): `.dcbook` files, continuous page numbering, chapter numbers resolved in book order (Automatic, Start Chapter Numbering at, Same as Previous Document; `layout.chapterNumbering`, with a style for Chapter Number variables and cross-references), style sync from a style source, one merged PDF. Section prefixes follow InDesign's rule (up to 8 characters, no + or comma).+ - Numbering & Section Options window as in InDesign (Start Section, automatic or explicit page numbering up to 99999, prefix, style, marker, Include Prefix; the document's chapter numbering and its book); OK applies both in one undo step (`layout.numberingOptions`).- Track Changes (`changes.track/list/acceptAll/rejectAll`, Type ▸ Track Changes): typing is marked added (highlighted on screen), deletions are kept but hidden from layout and exports until accepted or rejected. Per-change accept/reject and authors aren't there yet.- Track Changes: per-change Accept / Reject (`changes.accept`, `changes.reject`) and a Track Changes panel listing every change.- Move table rows and columns (`table.moveRow`, `table.moveColumn`, Table panel buttons; with whole rows or columns selected, drag them with the Type tool — `table.dropCells`).