DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Merge #837: Preferences: Story Editor size stays finite and in range
aiongge94e04fb6ed0
diff --cc crates/ui-egui/src/dialogs.rsindex 234b630c8,e9776928e..0b33cfcc9--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@@ -4280,2690 -3323,638 +4283,2706 @@@ fn bullets_and_numbering(lang: &str, ui});}-/// 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));- }+/// Paragraph Borders and Shading, Span Columns, and Bullets and Numbering for the selected+/// paragraphs: the Paragraph Style Options sections over the paragraphs' attributes (`current`);+/// OK applies the edits (`p.<key>`) as local formatting.+fn paragraph_local(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let Some(doc) = app.session.active().map(|s| s.doc.clone()) else { return };+ let pv = d.fields.get("current").cloned().unwrap_or_default();+ let lang = app.ui.language.clone();+ ui.set_min_width(480.0);+ match d.s("section").as_str() {+ "span" => span_columns(&lang, ui, d, &pv, &doc),+ "bullets" => {+ let (char_styles, families, fonts, scope) = ListUi::new_parts(app);+ let (family, style) = (d.s("family"), d.s("style"));+ let lu = ListUi { char_styles: &char_styles, families: &families, fonts: &fonts, scope, family: &family, style: &style };+ bullets_and_numbering(&lang, ui, d, &pv, &doc, &lu);}- });- 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"), ("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();+ section => {+ let border = section != "shading";+ ui.horizontal(|ui| {+ for (tab, label) in [("border", "Border"), ("shading", "Shading")] {+ if ui.selectable_label(section == tab, crate::rtl::widget(ui, crate::i18n::tr(&lang, label))).clicked() {+ d.fields.insert("section".into(), json!(tab));+ }+ }+ });+ ui.separator();+ border_shading(&lang, ui, d, &pv, &doc, border);+ }+ }+}++fn section_list(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, cjk: bool, sections: &[(&str, &str)]) {+ let sections = style_cjk::sections(cjk, d.id == "paragraphStyleOptions", sections);+ ui.vertical(|ui| {+ ui.set_width(170.0);+ // The dialog has a fixed height; a long list scrolls.+ egui::ScrollArea::vertical().id_salt("style_sections").auto_shrink([false, true]).show(ui, |ui| {+ for (id, label) in §ions {+ if ui.selectable_label(d.s("section") == *id, crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() {+ d.fields.insert("section".into(), json!(id));+ }+ }});+ });+}++/// "Paragraph Style n" / "Character Style n": the first name no style has.+fn next_style_name(styles: &designcraft_doc::Styles, para: bool) -> String {+ let (base, count) = if para { ("Paragraph Style", styles.paragraph.len()) } else { ("Character Style", styles.character.len()) };+ let taken = |n: &str| if para { styles.para(n).is_some() } else { styles.char_style(n).is_some() };+ // Among count + 1 numbers at least one is free.+ (1..=count + 1).map(|i| format!("{base} {i}")).find(|n| !taken(n)).unwrap_or_else(|| format!("{base} {}", count + 1))+}++/// Paragraph or Character Style Options for an existing style (a double-click on it in the styles+/// panel, or Edit in its menu). [None] and [No Paragraph Style] have no options.+pub fn open_style_options(app: &mut DesignApp, para: bool, name: &str) {+ if name == if para { designcraft_doc::NO_PARA_STYLE } else { designcraft_doc::NO_CHAR_STYLE } {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,+ let id = if para { "paragraphStyleOptions" } else { "characterStyleOptions" };+ app.ui.dialog = Some(Dialog::new(id, json!({"name": name})));+}++/// New Paragraph Style… / New Character Style…: the style options for a style made on OK, named+/// with the next free "Paragraph Style n" / "Character Style n".+pub fn open_new_style(app: &mut DesignApp, para: bool) {+ let Some(st) = app.session.active() else { return };+ let name = next_style_name(&st.doc.styles, para);+ let id = if para { "paragraphStyleOptions" } else { "characterStyleOptions" };+ app.ui.dialog = Some(Dialog::new(id, json!({"new": true, "rename": name})));+}++/// Character Style Options: General, then the character sections it shares with Paragraph Style+/// Options. A character style sets only some attributes: the fields show those it and its Based+/// On set and leave the rest blank. Edits are `c.<attr>` fields (`null` = no longer set), applied+/// on OK; `new` makes the style instead of editing `name`.+fn character_style_options(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let name = d.s("name");+ let new = d.b("new");+ let Some(doc) = app.session.active().map(|st| st.doc.clone()) else { return };+ let styles = &doc.styles;+ let style = match styles.char_style(&name) {+ _ if new => designcraft_doc::CharacterStyle { name: String::new(), based_on: None, chars: Default::default(), shortcut: String::new() },+ Some(s) if name != designcraft_doc::NO_CHAR_STYLE => s.clone(),+ _ => {+ crate::rtl::label(ui, format!("No style named {name}"));+ return;+ }+ };+ if !d.fields.contains_key("rename") {+ d.fields.insert("rename".into(), json!(if new { next_style_name(styles, false) } else { name.clone() }));+ }+ let based = d+ .fields+ .get("basedOn")+ .and_then(Value::as_str)+ .map(str::to_string)+ .or(style.based_on.clone())+ .unwrap_or_else(|| designcraft_doc::NO_CHAR_STYLE.into());+ // The fields show the style's own attributes over those its Based On gives it.+ let mut shown = styles.char_style_attrs(&based);+ shown.merge(&style.chars);+ let base = serde_json::to_value(&shown).unwrap_or_default();+ let cf = CharFields { base: &base, sparse: true };+ let lang = app.ui.language.clone();+ ui.set_min_width(560.0);+ ui.horizontal_top(|ui| {+ // A fixed height: the separator would otherwise stretch the dialog to the window.+ ui.set_min_height(380.0);+ ui.set_max_height(380.0);+ section_list(+ &lang,+ ui,d,- "style",+ crate::cjk_features(app),&[- ("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", "*, †, ‡, §..."),+ ("general", "General"),+ ("chars", "Basic Character Formats"),+ ("advanced", "Advanced Character Formats"),+ ("color", "Character Color"),+ ("openType", "OpenType Features"),+ ("underline", "Underline Options"),+ ("strikethrough", "Strikethrough Options"),],);+ ui.separator();+ ui.vertical(|ui| match d.s("section").as_str() {+ "chars" => basic_character_formats(app, ui, d, &cf),+ "advanced" => advanced_character_formats(&lang, ui, d, &cf),+ "color" => character_color(&lang, ui, d, &cf, &doc),+ "openType" => open_type_features(&lang, ui, d, &cf),+ "underline" => line_options(&lang, ui, d, &cf, &doc, "underline"),+ "strikethrough" => line_options(&lang, ui, d, &cf, &doc, "strikethrough"),+ s if style_cjk::is_section(s) => style_cjk::section_ui(app, ui, d, s, &cf, None, &doc),+ _ => {+ egui::Grid::new("csg").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&lang, "Style Name:"));+ text_field(ui, d, "rename", 220.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&lang, "Based On:"));+ egui::ComboBox::from_id_salt("csbased")+ .selected_text(crate::rtl::widget(ui, crate::i18n::style_name(&lang, &based)))+ .width(220.0)+ .show_ui(ui, |ui| {+ // Not itself, nor a style based on it.+ for s in styles.character.iter().filter(|s| new || !styles.char_based_on_cycles(&name, &s.name)) {+ if ui.selectable_label(s.name == based, crate::rtl::widget(ui, crate::i18n::style_name(&lang, &s.name))).clicked() {+ d.fields.insert("basedOn".into(), json!(s.name));+ }+ }+ });+ ui.end_row();+ });+ let status = d.s("status");+ if !status.is_empty() {+ crate::rtl::label(ui, egui::RichText::new(status).color(crate::theme::Tokens::get(ui.ctx()).text_strong));+ }+ ui.add_space(8.0);+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&lang, "Style Settings:")).font(semibold(12.0)));+ // What OK would leave the style setting, after its Based On.+ let mut own = serde_json::to_value(&style.chars).unwrap_or_default();+ if let Some(o) = own.as_object_mut() {+ for (k, v) in d.fields.iter().filter_map(|(k, v)| Some((k.strip_prefix("c.")?, v))) {+ if v.is_null() {+ o.remove(k);+ } else {+ o.insert(k.to_string(), v.clone());+ }+ }+ }+ let mut parts = vec![crate::i18n::style_name(&lang, &based).to_string()];+ parts.extend(own.as_object().into_iter().flatten().map(|(k, v)| format!("{}: {}", setting_label(&lang, k), setting_text(v))));+ ui.add(egui::Label::new(egui::RichText::new(parts.join(" + ")).color(crate::theme::Tokens::get(ui.ctx()).text_dim)).wrap());+ }+ });+ });+}++/// An attribute's name as Style Settings shows it: the field's label where the name reads poorly.+fn setting_label(lang: &str, key: &str) -> String {+ match key {+ "hScale" => crate::i18n::tr(lang, "Horizontal Scale:").trim_end_matches([':', ':']).to_string(),+ "vScale" => crate::i18n::tr(lang, "Vertical Scale:").trim_end_matches([':', ':']).to_string(),+ "capitalization" => crate::i18n::tr(lang, "Case:").trim_end_matches([':', ':']).to_string(),+ "otfFeatures" => crate::i18n::tr(lang, "OpenType Features").to_string(),+ _ => crate::i18n::tr(lang, &humanize(key)).to_string(),+ }+}++/// An attribute value as Style Settings shows it.+fn setting_text(v: &Value) -> String {+ match v {+ Value::String(s) => s.clone(),+ Value::Number(n) => n.as_f64().map_or_else(|| n.to_string(), |x| format!("{}", (x * 1000.0).round() / 1000.0)),+ Value::Bool(b) => if *b { "on" } else { "off" }.into(),+ Value::Array(a) => a.iter().map(setting_text).collect::<Vec<_>>().join(", "),+ Value::Object(o) => o.get("value").or_else(|| o.get("kind")).map(setting_text).unwrap_or_default(),+ Value::Null => String::new(),+ }+}++/// Where the character sections of the style options dialogs get the values they show: `base`+/// holds them by attribute name (resolved values for a paragraph style; for a character style the+/// attributes it sets, the others absent). `sparse` (a character style) lets a field be blank:+/// emptying it, or picking the blank entry, unsets the attribute.+struct CharFields<'a> {+ base: &'a Value,+ sparse: bool,+}++impl CharFields<'_> {+ /// The value shown for attribute `key`: the dialog's edit, else the base value.+ fn get(&self, d: &Dialog, key: &str) -> Value {+ d.fields.get(&format!("c.{key}")).cloned().unwrap_or_else(|| self.base.get(key).cloned().unwrap_or(Value::Null))+ }+ fn set(&self, d: &mut Dialog, key: &str, v: Value) {+ d.fields.insert(format!("c.{key}"), v);+ }+}++/// A number attribute shown multiplied by `scale` (100 for a fraction shown as a percentage).+fn char_number(ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields, key: &str, suffix: &str, scale: f64, range: (f64, f64)) {+ let v = cf.get(d, key).as_f64().map(|x| x * scale);+ let field = crate::widgets::NumField::number(key, v, suffix, 2).width(80.0).range(range.0, range.1);+ let edit = if cf.sparse { field.show_or_clear(ui) } else { field.show(ui).map(Some) };+ if let Some(n) = edit {+ cf.set(d, key, n.map_or(Value::Null, |n| json!(n / scale)));+ }+}++/// An attribute chosen from `opts` (value, label); a character style also has a blank entry.+fn char_choice(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields, key: &str, opts: &[(Value, &str)]) {+ let cur = cf.get(d, key);+ let shown = opts.iter().find(|o| o.0 == cur).map_or("", |o| crate::i18n::tr(lang, o.1));+ egui::ComboBox::from_id_salt(("cs", key)).selected_text(crate::rtl::widget(ui, shown)).width(200.0).show_ui(ui, |ui| {+ if cf.sparse && ui.selectable_label(cur.is_null(), " ").clicked() {+ cf.set(d, key, Value::Null);+ }+ for (v, label) in opts {+ if ui.selectable_label(*v == cur, crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() {+ cf.set(d, key, v.clone());+ }+ }+ });+}++/// An on/off attribute; for a character style a third, mixed state leaves it unset (clicks go+/// unset → on → off → unset).+fn char_check(ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields, key: &str, label: &str) {+ let cur = cf.get(d, key);+ let mut on = cur.as_bool().unwrap_or(false);+ let unset = cf.sparse && cur.is_null();+ if ui.add(egui::Checkbox::new(&mut on, crate::rtl::widget(ui, label)).indeterminate(unset)).clicked() {+ let next = match cur.as_bool() {+ _ if !cf.sparse => json!(on),+ None => json!(true),+ Some(true) => json!(false),+ Some(false) => Value::Null,+ };+ cf.set(d, key, next);+ }+}++/// A swatch attribute from a menu; `text_color` names the "" entry (the text's own colour).+fn char_swatch(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields, doc: &designcraft_doc::Document, key: &str, text_color: Option<&str>) {+ let mut opts: Vec<(Value, &str)> = text_color.map(|l| (json!(""), l)).into_iter().collect();+ opts.extend(doc.swatches.iter().map(|w| (json!(w.name), w.name.as_str())));+ char_choice(lang, ui, d, cf, key, &opts);+}++/// Basic Character Formats: font, size, leading, kerning, tracking, case, position and the+/// underline, strikethrough, ligatures and no-break switches.+fn basic_character_formats(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields) {+ let lang = app.ui.language.clone();+ let lang = lang.as_str();+ let fonts = crate::panels::fonts(app);+ let menu = crate::panels::font_menu(app);+ egui::Grid::new("psc").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(lang, "Font Family:"));+ let fam = cf.get(d, "fontFamily").as_str().unwrap_or("").to_string();+ let shown = if fam.is_empty() { "—".to_string() } else { crate::panels::font_label(app, &menu, &fam) };+ egui::ComboBox::from_id_salt("psfam")+ .selected_text(shown)+ .width(200.0)+ .height(440.0)+ .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)+ .show_ui(ui, |ui| {+ if cf.sparse && ui.selectable_label(fam.is_empty(), " ").clicked() {+ cf.set(d, "fontFamily", Value::Null);+ }+ if let Some(f) = crate::panels::font_menu_body(app, ui, &menu, &fam, 200.0) {+ cf.set(d, "fontFamily", json!(f.family));+ if let Some(style) = f.style {+ cf.set(d, "fontStyle", json!(style));+ }+ }+ });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,+ crate::rtl::label(ui, crate::i18n::tr(lang, "Font Style:"));+ let sty = cf.get(d, "fontStyle").as_str().unwrap_or("").to_string();+ if cf.sparse && fam.is_empty() {+ // No family to list styles of: type the style ("Italic" in whatever font the text has).+ let mut s = sty.clone();+ if ui.add(egui::TextEdit::singleline(&mut s).desired_width(200.0)).changed() {+ cf.set(d, "fontStyle", if s.trim().is_empty() { Value::Null } else { json!(s) });+ }+ } else {+ egui::ComboBox::from_id_salt("pssty").selected_text(&sty).width(200.0).show_ui(ui, |ui| {+ if cf.sparse && ui.selectable_label(sty.is_empty(), " ").clicked() {+ cf.set(d, "fontStyle", Value::Null);+ }+ for s in fonts.styles(&fam) {+ if ui.selectable_label(s == sty, &s).clicked() {+ cf.set(d, "fontStyle", json!(s));+ }+ }+ });+ }+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Size:"));+ char_number(ui, d, cf, "size", " pt", 1.0, (0.1, 1296.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Leading:"));+ let lv = match cf.get(d, "leading") {+ v if v["kind"] == "points" => v["value"].as_f64(),+ _ => None,+ };+ let field = crate::widgets::NumField::number("pslead", lv, " pt", 2).width(80.0).range(0.0, 5000.0);+ let edit = if cf.sparse { field.show_or_clear(ui) } else { field.show(ui).map(Some) };+ if let Some(n) = edit {+ cf.set(d, "leading", n.map_or(Value::Null, |n| json!({"kind": "points", "value": n})));+ }+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Kerning:"));+ char_choice(+ lang,+ ui,+ d,+ cf,+ "kerning",+ &[(json!({"kind": "metrics"}), "Metrics"), (json!({"kind": "optical"}), "Optical"), (json!({"kind": "none"}), "0")],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Tracking:"));+ char_number(ui, d, cf, "tracking", "", 1.0, (-1000.0, 10000.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Case:"));+ char_choice(+ lang,+ ui,+ d,+ cf,+ "capitalization",+ &[+ (json!("normal"), "Normal"),+ (json!("allCaps"), "All Caps"),+ (json!("smallCaps"), "Small Caps"),+ (json!("openTypeAllSmallCaps"), "OpenType All Small Caps"),+ ],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Position:"));+ char_choice(+ lang,+ ui,+ d,+ cf,+ "position",+ &[+ (json!("normal"), "Normal"),+ (json!("superscript"), "Superscript"),+ (json!("subscript"), "Subscript"),+ (json!("otSuperscript"), "OpenType Superscript"),+ (json!("otSubscript"), "OpenType Subscript"),+ (json!("otNumerator"), "OpenType Numerator"),+ (json!("otDenominator"), "OpenType Denominator"),+ ],+ );+ ui.end_row();+ });+ ui.add_space(4.0);+ egui::Grid::new("pscb").num_columns(2).spacing([16.0, 4.0]).show(ui, |ui| {+ char_check(ui, d, cf, "underline", crate::i18n::tr(lang, "Underline"));+ char_check(ui, d, cf, "ligatures", crate::i18n::tr(lang, "Ligatures"));+ ui.end_row();+ char_check(ui, d, cf, "strikethrough", crate::i18n::tr(lang, "Strikethrough"));+ char_check(ui, d, cf, "noBreak", crate::i18n::tr(lang, "No Break"));+ ui.end_row();+ });+}++/// Advanced Character Formats: scaling, baseline shift, skew and language.+fn advanced_character_formats(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields) {+ egui::Grid::new("csa").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(lang, "Horizontal Scale:"));+ char_number(ui, d, cf, "hScale", "%", 100.0, (1.0, 1000.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Vertical Scale:"));+ char_number(ui, d, cf, "vScale", "%", 100.0, (1.0, 1000.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Baseline Shift:"));+ char_number(ui, d, cf, "baselineShift", " pt", 1.0, (-5000.0, 5000.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Skew:"));+ char_number(ui, d, cf, "skew", "°", 1.0, (-85.0, 85.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Language:"));+ let opts: Vec<(Value, &str)> = crate::panels::properties::LANGUAGES.iter().map(|l| (json!(l), *l)).collect();+ char_choice(lang, ui, d, cf, "language", &opts);+ ui.end_row();+ });+}++/// Character Color: the fill or stroke swatch, its tint and the stroke weight.+fn character_color(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields, doc: &designcraft_doc::Document) {+ let stroke = d.s("colorTarget") == "stroke";+ ui.horizontal(|ui| {+ for (target, label) in [("fill", "Fill"), ("stroke", "Stroke")] {+ if ui.selectable_label((target == "stroke") == stroke, crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() {+ d.fields.insert("colorTarget".into(), json!(target));+ }+ }+ });+ let key = if stroke { "stroke" } else { "fill" };+ let cur = cf.get(d, key).as_str().unwrap_or("").to_string();+ egui::ScrollArea::vertical().id_salt(("cscolor", key)).max_height(220.0).show(ui, |ui| {+ for sw in &doc.swatches {+ let (c, g) = crate::widgets::swatch_colors(doc, &sw.name, 1.0);+ ui.horizontal(|ui| {+ let (r, _) = ui.allocate_exact_size(egui::vec2(14.0, 14.0), egui::Sense::hover());+ crate::widgets::paint_chip(ui.painter(), r, c, g);+ if ui.selectable_label(sw.name == cur, &sw.name).clicked() {+ // A character style's chosen swatch, clicked again, is no longer set.+ cf.set(d, key, if cf.sparse && sw.name == cur { Value::Null } else { json!(sw.name) });+ }+ });+ }+ });+ egui::Grid::new("cscg").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(lang, "Tint:"));+ char_number(ui, d, cf, if stroke { "strokeTint" } else { "fillTint" }, "%", 100.0, (0.0, 100.0));+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(lang, "Weight:"));+ char_number(ui, d, cf, "strokeWeight", " pt", 1.0, (0.0, 800.0));+ ui.end_row();+ ui.label("");+ char_check(ui, d, cf, "strokeBehindFill", crate::i18n::tr(lang, "Stroke Behind Fill"));+ ui.end_row();+ });+}++/// OpenType Features: the feature switches, figure style and stylistic sets (one `otfFeatures`+/// list: changing any feature sets the whole list).+fn open_type_features(lang: &str, ui: &mut egui::Ui, d: &mut Dialog, cf: &CharFields) {+ use designcraft_doc::otf;+ let mut list: Vec<String> =+ cf.get(d, "otfFeatures").as_array().map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_string)).collect()).unwrap_or_default();+ let mut changed = false;+ egui::Grid::new("csot").num_columns(2).spacing([16.0, 4.0]).show(ui, |ui| {+ for (i, (tag, label, _)) in otf::TOGGLES.iter().enumerate() {+ let mut on = otf::is_on(&list, tag);+ if ui.checkbox(&mut on, crate::rtl::widget(ui, crate::i18n::tr(lang, label))).changed() {+ otf::set(&mut list, tag, on);+ changed = true;+ }+ if i % 2 == 1 {+ ui.end_row();+ }+ }+ });+ ui.add_space(6.0);+ ui.horizontal(|ui| {+ crate::rtl::label(ui, crate::i18n::tr(lang, "Figure Style:"));+ let fig = otf::figures(&list);+ let shown = otf::FIGURES.iter().find(|f| f.0 == fig).map_or("", |f| f.1);+ egui::ComboBox::from_id_salt("csfig").selected_text(crate::rtl::widget(ui, crate::i18n::tr(lang, shown))).width(180.0).show_ui(ui, |ui| {+ for (id, label, ..) in otf::FIGURES {+ if ui.selectable_label(fig == *id, crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() && otf::set_figures(&mut list, id)+ {+ changed = true;+ }+ }+ });+ });+ ui.add_space(4.0);+ crate::rtl::label(ui, crate::i18n::tr(lang, "Stylistic Sets"));+ let mask = otf::stylistic_sets(&list);+ egui::Grid::new("csss").num_columns(10).spacing([2.0, 2.0]).show(ui, |ui| {+ for n in 1..=20u32 {+ let bit = 1u32 << (n - 1);+ if ui.add_sized([28.0, 20.0], egui::Button::selectable(mask & bit != 0, format!("{n}"))).clicked() {+ otf::set_stylistic_sets(&mut list, mask ^ bit);+ changed = true;+ }+ if n % 10 == 0 {+ ui.end_row();+ }+ }+ });+ if changed {+ cf.set(d, "otfFeatures", json!(list));+ }+}++/// 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();+ });+}++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));+ }+ }+ });+}++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}%"));+ }+ 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";+const TOC: &str = "cmd:toc.generate";++/// One included style of the Table of Contents dialog, as `toc.generate` takes it, with the+/// separator in the dialog's notation (`^t` a tab).+#[derive(Clone, Debug, Default, Deserialize, Serialize)]+#[serde(rename_all = "camelCase", default)]+struct TocRow {+ style: String,+ level: u8,+ entry_style: String,+ page_number: String,+ separator: String,+}++fn toc_separator_shown(s: &str) -> String {+ s.replace('\t', "^t").replace('\u{2003}', "^m").replace('\u{2002}', "^>")+}++fn toc_separator_typed(s: &str) -> String {+ s.replace("^t", "\t").replace("^m", "\u{2003}").replace("^>", "\u{2002}")+}++fn toc_rows(d: &Dialog) -> Vec<TocRow> {+ d.fields.get("included").cloned().and_then(|v| serde_json::from_value(v).ok()).unwrap_or_default()+}++/// Layout › Table of Contents…: prefilled from the document's table of contents when it has one.+pub fn open_toc(app: &mut DesignApp) {+ let Some(st) = app.session.active() else { return };+ let d = &st.doc;+ let styles: Vec<&str> = d.styles.paragraph.iter().map(|p| p.name.as_str()).filter(|n| *n != designcraft_doc::NO_PARA_STYLE).collect();+ let toc = d.toc.as_ref().filter(|t| d.story(t.story).is_some());+ let rows: Vec<TocRow> = toc+ .map(|t| {+ t.entries+ .iter()+ .map(|e| TocRow {+ style: e.style.clone(),+ level: e.level,+ entry_style: e.entry_style.clone().unwrap_or_default(),+ page_number: match (t.page_numbers, e.page_number) {+ (false, _) | (_, designcraft_doc::TocPageNumber::None) => "none",+ (_, designcraft_doc::TocPageNumber::Before) => "before",+ _ => "after",+ }+ .into(),+ separator: toc_separator_shown(e.separator.as_deref().unwrap_or("\t")),+ })+ .collect()+ })+ .unwrap_or_default();+ let fields = json!({+ "title": toc.map_or("Contents", |t| t.title.as_str()),+ "titleStyle": toc.and_then(|t| t.title_style.clone()).unwrap_or_default(),+ "included": rows,+ "selected": 0,+ "styles": styles,+ "hasToc": toc.is_some(),+ "replace": toc.is_some(),+ });+ app.ui.dialog = Some(Dialog::new(TOC, fields));+}++/// The dialog's fields as `toc.generate` params. A new frame goes on the page in view.+fn toc_params(app: &DesignApp, d: &Dialog) -> Value {+ let entries: Vec<Value> = toc_rows(d)+ .iter()+ .map(|r| {+ let mut e = json!({"style": r.style, "level": r.level, "separator": toc_separator_typed(&r.separator)});+ if !r.entry_style.is_empty() {+ e["entryStyle"] = json!(r.entry_style);+ }+ if !r.page_number.is_empty() {+ e["pageNumber"] = json!(r.page_number);+ }+ e+ })+ .collect();+ let mut p = json!({"title": d.s("title"), "entries": entries, "replace": d.b("replace")});+ let title_style = d.s("titleStyle");+ if !title_style.is_empty() {+ p["titleStyle"] = json!(title_style);+ }+ if let Some(page) = crate::canvas::current_page(app) {+ p["page"] = json!(page + 1);+ }+ p+}++/// A paragraph style menu whose first choice, stored as "", is the generated style `auto`.+fn toc_style_combo(ui: &mut egui::Ui, salt: &str, styles: &[String], auto: &str, cur: &mut String) -> bool {+ let shown = if cur.is_empty() { auto.to_string() } else { cur.clone() };+ let mut changed = false;+ egui::ComboBox::from_id_salt(("toc_style", salt)).selected_text(shown).width(200.0).show_ui(ui, |ui| {+ if ui.selectable_label(cur.is_empty(), auto).clicked() {+ cur.clear();+ changed = true;+ }+ for n in styles.iter().filter(|n| *n != auto) {+ if ui.selectable_label(cur == n, n.as_str()).clicked() {+ *cur = n.clone();+ changed = true;+ }+ }+ });+ changed+}++/// Layout › Table of Contents: the title and its style, the paragraph styles to include (Add /+/// Remove between the two lists) and, for the selected one, its entry style, page number+/// position, separator and level.+fn toc_dialog(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let lang = app.ui.language.clone();+ let tr = |s: &str| crate::i18n::tr(&lang, s).to_string();+ let styles: Vec<String> = d.fields.get("styles").cloned().and_then(|v| serde_json::from_value(v).ok()).unwrap_or_default();+ let mut rows = toc_rows(d);+ let mut sel = d.n("selected").map_or(0, |n| n.max(0.0) as usize);+ let mut other = d.s("other");+ let mut title_style = d.s("titleStyle");+ egui::Grid::new("toc_title").num_columns(4).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, tr("Title:"));+ text_field(ui, d, "title", 200.0);+ crate::rtl::label(ui, tr("Style:"));+ toc_style_combo(ui, "title", &styles, "TOC Title", &mut title_style);+ ui.end_row();+ });+ ui.add_space(8.0);+ crate::rtl::label(ui, egui::RichText::new(tr("Styles in Table of Contents")).font(semibold(12.0)));+ let others: Vec<&String> = styles.iter().filter(|n| !rows.iter().any(|r| &r.style == *n)).collect();+ ui.horizontal_top(|ui| {+ ui.vertical(|ui| {+ crate::rtl::label(ui, tr("Include Paragraph Styles:"));+ egui::Frame::group(ui.style()).show(ui, |ui| {+ ui.set_width(200.0);+ egui::ScrollArea::vertical().id_salt("toc_included").max_height(150.0).min_scrolled_height(150.0).show(ui, |ui| {+ for (i, r) in rows.iter().enumerate() {+ let indent = " ".repeat(usize::from(r.level.saturating_sub(1)));+ if ui.selectable_label(i == sel, format!("{indent}{}", r.style)).clicked() {+ sel = i;+ }+ }+ });+ });+ });+ ui.vertical(|ui| {+ ui.add_space(40.0);+ if ui.button(tr("« Add")).clicked() && others.iter().any(|n| **n == other) {+ let level = u8::try_from(rows.len() + 1).unwrap_or(9).min(9);+ rows.push(TocRow { style: other.clone(), level, page_number: "after".into(), separator: "^t".into(), ..Default::default() });+ sel = rows.len() - 1;+ other.clear();+ }+ if ui.button(tr("Remove »")).clicked() && sel < rows.len() {+ other = rows.remove(sel).style;+ sel = sel.min(rows.len().saturating_sub(1));+ }+ });+ ui.vertical(|ui| {+ crate::rtl::label(ui, tr("Other Styles:"));+ egui::Frame::group(ui.style()).show(ui, |ui| {+ ui.set_width(200.0);+ egui::ScrollArea::vertical().id_salt("toc_other").max_height(150.0).min_scrolled_height(150.0).show(ui, |ui| {+ for n in styles.iter().filter(|n| !rows.iter().any(|r| &r.style == *n)) {+ if ui.selectable_label(*n == other, n.as_str()).clicked() {+ other = n.clone();+ }+ }+ });+ });+ });+ });+ if let Some(r) = rows.get_mut(sel) {+ ui.add_space(8.0);+ crate::rtl::label(ui, egui::RichText::new(format!("{} {}", tr("Style:"), r.style)).font(semibold(12.0)));+ egui::Grid::new("toc_entry").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, tr("Entry Style:"));+ let auto = format!("TOC Level {}", r.level.clamp(1, 9));+ toc_style_combo(ui, "entry", &styles, &auto, &mut r.entry_style);+ ui.end_row();+ crate::rtl::label(ui, tr("Page Number:"));+ let choices = [("after", "After Entry"), ("before", "Before Entry"), ("none", "No Page Number")];+ let cur = choices.iter().find(|(v, _)| *v == r.page_number).map_or("After Entry", |(_, l)| l);+ egui::ComboBox::from_id_salt("toc_page_number").selected_text(tr(cur)).width(200.0).show_ui(ui, |ui| {+ for (v, l) in choices {+ if ui.selectable_label(r.page_number == v, tr(l)).clicked() {+ r.page_number = v.into();+ }+ }+ });+ ui.end_row();+ crate::rtl::label(ui, tr("Between Entry and Number:"));+ ui.add(egui::TextEdit::singleline(&mut r.separator).desired_width(80.0).horizontal_align(egui::Align::Min));+ ui.end_row();+ crate::rtl::label(ui, tr("Level:"));+ egui::ComboBox::from_id_salt("toc_level").selected_text(r.level.to_string()).width(60.0).show_ui(ui, |ui| {+ for l in 1..=9u8 {+ if ui.selectable_label(r.level == l, l.to_string()).clicked() {+ r.level = l;+ }+ }+ });+ ui.end_row();+ });+ }+ ui.add_space(8.0);+ crate::rtl::label(ui, egui::RichText::new(tr("Options")).font(semibold(12.0)));+ let has_toc = d.b("hasToc");+ ui.add_enabled_ui(has_toc, |ui| check(ui, d, "replace", &tr("Replace Existing Table of Contents")));+ 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));+ }+ d.fields.insert("included".into(), json!(rows));+ d.fields.insert("selected".into(), json!(sel));+ d.fields.insert("other".into(), json!(other));+ d.fields.insert("titleStyle".into(), json!(title_style));+}+/// 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));+ }+}++/// `N` numbers from a dialog field holding a JSON array.+fn nums<const N: usize>(d: &Dialog, k: &str) -> Option<[f64; N]> {+ let a = d.fields.get(k)?.as_array()?;+ if a.len() != N {+ return None;+ }+ let mut out = [0.0; N];+ for (o, v) in out.iter_mut().zip(a) {+ *o = v.as_f64().filter(|x| x.is_finite())?;+ }+ Some(out)+}++/// What changed the Color Picker's colour this frame.+#[derive(Clone, Copy, PartialEq)]+enum ColorEdit {+ None,+ /// The saturation/brightness field, the hue slider or the hex field: keeps the colour's model.+ Picked,+ /// Typed R/G/B values: the colour becomes RGB.+ Rgb,+ /// Typed C/M/Y/K values: the colour becomes CMYK.+ Cmyk,+}++/// Color Picker: saturation/brightness field and hue slider, with R/G/B, C/M/Y/K and hex fields.+///+/// `rgb` (0-255) and `cmyk` (percent) hold the values as typed, so a field being edited is never+/// rebuilt from the colour; the hex field keeps its text in `hexEdit` while it has focus and shows+/// the colour again when focus leaves. `model` is what OK applies: picking keeps a CMYK colour CMYK+/// (converted through the CMYK working space); typing R/G/B or C/M/Y/K values chooses that model.+fn color_picker(ui: &mut egui::Ui, d: &mut Dialog) {+ use designcraft_color::Color;+ let to8 = |v: f64| v.clamp(0.0, 255.0).round() as u8;+ let display_rgb = |c: Color| c.to_rgb().map(|v| (f64::from(v) * 255.0).clamp(0.0, 255.0).round());+ let cmyk_of = |rgb: [f64; 3]| {+ let c = Color::rgb((rgb[0] / 255.0) as f32, (rgb[1] / 255.0) as f32, (rgb[2] / 255.0) as f32);+ c.to_cmyk_managed(designcraft_color::cms::active_settings().intent).map(|v| f64::from(v) * 100.0)+ };+ let hex_rgb = |s: &str| match Color::from_hex(s) {+ Some(Color::Rgb { r, g, b }) => Some([r, g, b].map(|v| (f64::from(v) * 255.0).round())),+ _ => None,+ };+ let mut rgb = nums::<3>(d, "rgb").unwrap_or_else(|| hex_rgb(&d.s("hex")).unwrap_or([0.0; 3]));+ let mut cmyk = nums::<4>(d, "cmyk").unwrap_or_else(|| cmyk_of(rgb));+ let mut model = if d.s("model") == "cmyk" || (!d.fields.contains_key("model") && d.fields.contains_key("cmyk")) { "cmyk" } else { "rgb" };+ let mut edit = ColorEdit::None;+ let hex_id = egui::Id::new("color_picker_hex");+ ui.horizontal_top(|ui| {+ let mut c = egui::Color32::from_rgb(to8(rgb[0]), to8(rgb[1]), to8(rgb[2]));+ let shown = c;+ if egui::color_picker::color_picker_color32(ui, &mut c, egui::color_picker::Alpha::Opaque) && c != shown {+ rgb = [c.r(), c.g(), c.b()].map(f64::from);+ edit = ColorEdit::Picked;+ }+ ui.vertical(|ui| {+ egui::Grid::new("cp_values").num_columns(4).spacing([6.0, 4.0]).show(ui, |ui| {+ let mut rgb_rows = rgb.iter_mut().zip(["R", "G", "B"]);+ for (v, l) in cmyk.iter_mut().zip(["C", "M", "Y", "K"]) {+ if let Some((rv, rl)) = rgb_rows.next() {+ ui.label(rl);+ if ui.add(egui::DragValue::new(rv).range(0.0..=255.0).max_decimals(1)).changed() {+ edit = ColorEdit::Rgb;+ }+ } else {+ ui.label("");+ ui.label("");+ }+ ui.label(l);+ if ui.add(egui::DragValue::new(v).range(0.0..=100.0).max_decimals(1).suffix("%")).changed() {+ edit = ColorEdit::Cmyk;+ }+ ui.end_row();+ }+ });+ ui.add_space(6.0);+ ui.horizontal(|ui| {+ ui.label("#");+ let editing = ui.memory(|m| m.has_focus(hex_id));+ let mut h = if editing { d.s("hexEdit") } else { format!("{:02x}{:02x}{:02x}", to8(rgb[0]), to8(rgb[1]), to8(rgb[2])) };+ if ui.add(egui::TextEdit::singleline(&mut h).id(hex_id).desired_width(70.0)).changed()+ && let Some(v) = hex_rgb(&h)+ {+ rgb = v;+ edit = ColorEdit::Picked;+ }+ d.fields.insert("hexEdit".into(), json!(h));+ });+ });+ });+ match edit {+ ColorEdit::None => {}+ ColorEdit::Picked => cmyk = cmyk_of(rgb),+ ColorEdit::Rgb => {+ model = "rgb";+ cmyk = cmyk_of(rgb);+ }+ ColorEdit::Cmyk => {+ model = "cmyk";+ let [c, m, y, k] = cmyk.map(|v| (v / 100.0) as f32);+ rgb = display_rgb(Color::cmyk(c, m, y, k));+ }+ }+ if edit != ColorEdit::None {+ d.fields.insert("edited".into(), json!(true));+ }+ d.fields.insert("rgb".into(), json!(rgb));+ d.fields.insert("cmyk".into(), json!(cmyk));+ d.fields.insert("model".into(), json!(model));+ d.fields.insert("hex".into(), json!(format!("#{:02x}{:02x}{:02x}", to8(rgb[0]), to8(rgb[1]), to8(rgb[2]))));+}++/// 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,- d,- "affixIn",- &[("none", "None"), ("reference", "Footnote Reference"), ("text", "Footnote Text"), ("both", "Both")],+ crate::i18n::tr(+ &app.ui.language,+ "This document uses unavailable fonts. Choose replacements, or select Done to continue with fallback fonts.",+ ),);- 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();+ }+ 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));+ }+ }});- 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,+ 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,- d,- "refPosition",- &[- ("superscript", "Apply Superscript"),- ("subscript", "Apply Subscript"),- ("normal", "Apply Normal"),- ("otSuperscript", "OpenType Superscript"),- ],+ 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();- 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);+ 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),+ ));}-/// 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,-}+#[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 preferences_ok_saves_a_story_editor_size_that_loads_back() {++ // `ui.dialog.set` takes any value; a size that isn't finite is saved as `null`.++ let sizes = [(json!("nan"), 20.0), (json!("inf"), 20.0), (json!(null), 20.0), (json!(1e39), 36.0), (json!(3), 8.0), (json!(11), 11.0)];++ for (size, want) in sizes {++ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());++ app.run("file.new", json!({})).unwrap();++ app.ui.story_editor_size = 20.0;++ app.run("app.preferences", json!({})).unwrap();++ app.ui.dialog.as_mut().unwrap().fields.insert("storyEditorSize".into(), size);++ confirm(&mut app).unwrap();++ let saved = serde_json::to_vec(&app.ui).unwrap();++ assert_eq!(crate::UiState::from_preferences_json(&saved).unwrap().story_editor_size, want);++ }++ }+++ #[test]+ fn preferences_ok_sets_only_the_ruler_units_it_is_given() {+ // `ui.dialog.open` takes any fields, so the vertical units can be missing.+ for (vertical, want) in [(None, "inches"), (Some("points"), "points")] {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("document.preferences", json!({"verticalUnits": "inches"})).unwrap();+ let mut fields = json!({"horizontalUnits": "millimeters", "bg.relativeTo": "topOfPage"});+ if let Some(vertical) = vertical {+ fields["verticalUnits"] = json!(vertical);+ }+ app.ui.dialog = Some(Dialog::new("preferences", fields));+ confirm(&mut app).unwrap();+ let units = app.run("document.preferences", json!({})).unwrap();+ assert_eq!((units["horizontalUnits"].as_str(), units["verticalUnits"].as_str()), (Some("millimeters"), Some(want)));+ }+ }-/// 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;- }+ #[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());}- 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;++ #[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");+ }}- _ => {}}}- 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;++ fn select_all_key() -> egui::Event {+ egui::Event::Key {+ key: egui::Key::A,+ physical_key: None,+ pressed: true,+ repeat: false,+ modifiers: egui::Modifiers { ctrl: true, command: true, ..Default::default() },}- 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);+ /// The Color Picker over a new document's selected frame, a few frames in.+ fn picker(fields: Value) -> (DesignApp, egui::Context, egui::Rect, u64) {+ 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": [36, 36, 200, 200]})).unwrap()["id"].as_u64().unwrap();+ app.run("selection.set", json!({"ids": [id]})).unwrap();+ app.ui.dialog = Some(Dialog::new("colorPicker", fields));+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(700.0, 500.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);}+ (app, ctx, screen, id)}- 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));- }+ /// The rightmost painted `text`: the picker's own field, right of egui's colour editor (which+ /// has R/G/B fields of its own).+ fn rightmost(labels: &[(String, egui::Rect, egui::Rect)], text: &str) -> egui::Pos2 {+ labels+ .iter()+ .filter(|(t, _, _)| t.trim() == text)+ .map(|(_, r, _)| r.center())+ .max_by(|a, b| a.x.total_cmp(&b.x))+ .unwrap_or_else(|| panic!("{text} is painted"))+ }++ /// Types `text` one character per frame, with an idle frame after each.+ fn type_slowly(app: &mut DesignApp, ctx: &egui::Context, screen: egui::Rect, text: &str) {+ for ch in text.chars() {+ dialog_frame(app, ctx, screen, vec![egui::Event::Text(ch.into())]);+ dialog_frame(app, ctx, screen, vec![]);+ }+ }++ fn fill(app: &DesignApp, id: u64) -> designcraft_color::Color {+ let d = &app.session.active().unwrap().doc;+ d.resolve_color(&d.item(designcraft_doc::ItemId(id)).unwrap().fill.swatch, 1.0).unwrap()+ }++ #[test]+ fn the_hex_field_keeps_typed_text_and_commits_a_valid_code() {+ let (mut app, ctx, screen, _) = picker(json!({"target": "fill", "hex": "#ffffff"}));+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "ffffff").center());+ dialog_frame(&mut app, &ctx, screen, vec![select_all_key()]);+ type_slowly(&mut app, &ctx, screen, "#f5");+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!((d.s("hexEdit").as_str(), d.s("hex").as_str()), ("#f5", "#ffffff"), "half-typed text stays; the colour waits");+ type_slowly(&mut app, &ctx, screen, "9019");+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!((d.s("hexEdit").as_str(), d.s("hex").as_str()), ("#f59019", "#f59019"), "a 7-character #rrggbb commits");+ // Invalid text is replaced by the colour when focus leaves.+ dialog_frame(&mut app, &ctx, screen, vec![select_all_key()]);+ type_slowly(&mut app, &ctx, screen, "zz");+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "#").center());+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&labels, screen, "f59019");+ assert_eq!(app.ui.dialog.as_ref().unwrap().s("hex"), "#f59019");+ }++ #[test]+ fn typed_channel_values_are_kept_while_typing() {+ let (mut app, ctx, screen, id) = picker(json!({"target": "fill", "hex": "#010203", "model": "rgb", "rgb": [1, 2, 3]}));+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, rightmost(&labels, "1"));+ dialog_frame(&mut app, &ctx, screen, vec![select_all_key()]);+ type_slowly(&mut app, &ctx, screen, "12.5");+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ assert!(rightmost(&labels, "12.5").x > rightmost(&labels, "2").x - 1.0, "the typed text stays in the R field");+ assert_eq!(app.ui.dialog.as_ref().unwrap().s("hex"), "#0d0203");+ confirm(&mut app).unwrap();+ let designcraft_color::Color::Rgb { r, .. } = fill(&app, id) else { panic!("not RGB") };+ assert!((r - 12.5 / 255.0).abs() < 1e-6, "{r}");+ }++ #[test]+ fn a_cmyk_colour_stays_cmyk_unless_rgb_values_are_typed() {+ let cmyk = json!({"target": "fill", "hex": "#ff8000", "model": "cmyk", "cmyk": [0, 50, 100, 0]});+ // Picked by hex: converted to CMYK.+ let (mut app, ctx, screen, id) = picker(cmyk.clone());+ let hex = app.ui.dialog.as_ref().unwrap().s("hex");+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, hex.trim_start_matches('#')).center());+ dialog_frame(&mut app, &ctx, screen, vec![select_all_key()]);+ type_slowly(&mut app, &ctx, screen, "3366cc");+ confirm(&mut app).unwrap();+ assert!(matches!(fill(&app, id), designcraft_color::Color::Cmyk { .. }), "{:?}", fill(&app, id));+ // A typed C/M/Y/K percent is a percent: M 1 is 1 %.+ let (mut app, ctx, screen, id) = picker(cmyk.clone());+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, rightmost(&labels, "50"));+ dialog_frame(&mut app, &ctx, screen, vec![select_all_key()]);+ type_slowly(&mut app, &ctx, screen, "1");+ confirm(&mut app).unwrap();+ let designcraft_color::Color::Cmyk { c, m, y, k } = fill(&app, id) else { panic!("not CMYK") };+ assert!(c == 0.0 && (m - 0.01).abs() < 1e-6 && (y - 1.0).abs() < 1e-6 && k == 0.0, "{c} {m} {y} {k}");+ // Typed R/G/B values: RGB.+ let (mut app, ctx, screen, id) = picker(cmyk);+ let r = app.ui.dialog.as_ref().unwrap().fields["rgb"][0].as_f64().unwrap();+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, rightmost(&labels, &r.to_string()));+ dialog_frame(&mut app, &ctx, screen, vec![select_all_key()]);+ type_slowly(&mut app, &ctx, screen, "10");+ confirm(&mut app).unwrap();+ assert!(matches!(fill(&app, id), designcraft_color::Color::Rgb { .. }), "{:?}", fill(&app, id));+ }++ #[test]+ fn ok_without_edits_leaves_the_fill_alone() {+ let (mut app, _, _, id) = picker(json!({"target": "fill", "hex": "#ff8000", "model": "cmyk", "cmyk": [0, 50, 100, 0]}));+ let before = app.session.active().unwrap().doc.item(designcraft_doc::ItemId(id)).unwrap().fill.clone();+ confirm(&mut app).unwrap();+ assert_eq!(app.session.active().unwrap().doc.item(designcraft_doc::ItemId(id)).unwrap().fill, before);+ }++ #[test]+ fn dialogs_do_not_dim_the_page() {+ let (mut app, ctx, screen, _) = picker(json!({"target": "fill", "hex": "#ff8000"}));+ let time = ctx.input(|i| i.time) + 1.0 / 60.0;+ let output = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), time: Some(time), ..Default::default() }, |ui| show(&mut app, ui.ctx()));+ fn covers(shape: &egui::Shape, screen: egui::Rect) -> bool {+ match shape {+ egui::Shape::Rect(r) => r.rect.contains_rect(screen) && r.fill.a() > 0,+ egui::Shape::Vec(v) => v.iter().any(|s| covers(s, screen)),+ _ => false,}- 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));+ assert!(app.ui.dialog.is_some());+ assert!(!output.shapes.iter().any(|s| covers(&s.shape, screen)), "nothing paints over the whole window");+ }++ 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);}-}-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";+ /// 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())+ }-/// 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);+ /// 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()}- 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 {- crate::rtl::label(ui, tr(l));- 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);- }- });++ #[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);});- 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));+ 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());}-}-/// `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})- })-}+ #[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);-/// 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");+ // 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");}- return;- }- let params = match step_and_repeat_params(app, d) {- Ok(p) => p,- Err(e) => {- d.fields.insert("status".into(), json!(e));- return;+ 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");}- };- 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;++ 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}- 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:"));- combo(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),- ));+ #[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);}- });- } 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));- }- }- }- })- });- });+ // `primaryTextFrame` is documented since #776, so the dialog passes it on (`status` isn't).+ assert!(doc.spreads.iter().any(|s| !s.items.is_empty()), "documented fields reach the command");+ 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));+ }++ #[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);+ }}-}-/// 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_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"));}-}-/// 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 text_frame_options_set_columns_baseline_and_wrap_as_indesign_does() {+ let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ // A 300 pt frame, 2 columns, 12 pt gutter (picas in the dialog).+ 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, "gutter": 12})).unwrap();+ let opts = |app: &DesignApp| app.session.doc().unwrap().doc.item(id).unwrap().text_frame().unwrap().options.clone();+ let mut d = Dialog::new("textFrameOptions", json!({}));+ seed_text_frame_options(&app, &mut d);+ // Fixed Number shows each column's width: (300 - 12) / 2 = 144 pt.+ assert_eq!((d.s("columnsKind"), d.s("columnWidth"), d.s("firstBaseline")), ("fixedNumber".into(), "12p0".into(), "ascent".into()));+ for (k, v) in [+ ("columnsKind", json!("fixedWidth")),+ ("columnWidth", json!("10p0")),+ ("firstBaseline", json!("capHeight")),+ ("firstBaselineMin", json!("0p6")),+ ("balanceColumns", json!(true)),+ ("ignoreWrap", json!(true)),+ ] {+ d.fields.insert(k.into(), v);+ }+ app.ui.dialog = Some(d);+ confirm(&mut app).unwrap();+ let o = opts(&app);+ assert_eq!(o.columns_kind, designcraft_doc::ColumnsKind::FixedWidth);+ assert_eq!((o.column_width, o.first_baseline_min, o.columns), (120.0, 6.0, 2));+ assert_eq!(o.first_baseline, designcraft_doc::FirstBaseline::CapHeight);+ assert!(o.balance_columns && o.ignore_wrap);+ // Fixed Number again: the width isn't sent.+ let mut d = Dialog::new("textFrameOptions", json!({}));+ seed_text_frame_options(&app, &mut d);+ assert_eq!(d.s("columnWidth"), "10p0", "Fixed Width shows its own width");+ d.fields.insert("columnsKind".into(), json!("fixedNumber"));+ app.ui.dialog = Some(d);+ confirm(&mut app).unwrap();+ assert_eq!((opts(&app).columns_kind, opts(&app).column_width), (designcraft_doc::ColumnsKind::FixedNumber, 120.0));}- 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]);+ open(&mut app, &[("balanceColumns", json!(true))]).unwrap();+ let o = opts(&app);+ assert!(o.balance_columns && o.column_rule && o.columns == 2, "{o:?}");+ // 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..4 {+ 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);+ }#[test]- fn step_and_repeat_dialog_previews_and_makes_the_copies_as_one_undo_step() {+ fn toc_dialog_adds_a_style_and_ok_makes_the_table_of_contents() {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));+ app.run("file.newSample", json!({})).unwrap();+ crate::menus::activate(&mut app, "toc.generate", &Value::Null);+ assert_eq!(app.ui.dialog.as_ref().map(|d| d.id.as_str()), Some(TOC));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"] {+ for expected in+ ["Table of Contents", "Title:", "Include Paragraph Styles:", "Other Styles:", "« Add", "Remove »", "Replace Existing Table of Contents"]+ {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"));+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "Headline").center());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());+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "« Add").center());+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ for expected in ["Entry Style:", "TOC Level 1", "After Entry", "Between Entry and Number:", "Level:"] {+ visible_label(&labels, screen, expected);+ }+ let undo = app.session.doc().unwrap().history.undo.len();+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "OK").center());+ assert!(app.ui.dialog.is_none());+ let d = &app.session.doc().unwrap().doc;+ let toc = d.toc.clone().unwrap();+ assert_eq!(toc.entries, vec![designcraft_doc::TocEntry::new("Headline", 1)]);+ let text = &d.story(toc.story).unwrap().text;+ assert!(text.starts_with("Contents\n") && text.contains("\nNotes on the Grid\t"), "{text}");+ assert_eq!(app.session.doc().unwrap().history.undo.len(), undo + 1);+ // Reopened, the dialog shows the table of contents and replaces it.+ crate::menus::activate(&mut app, "toc.generate", &Value::Null);let d = app.ui.dialog.as_ref().unwrap();- assert_eq!(d.s("status"), "Invalid value: up");+ assert!(d.b("replace"));+ assert_eq!(toc_rows(d).iter().map(|r| r.style.as_str()).collect::<Vec<_>>(), ["Headline"]);}fn dialog_context(language: &str) -> egui::Context {