DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Merge #807: Preferences: OK without vertical units keeps them
aiongg693ca187138c
diff --cc crates/ui-egui/src/dialogs.rsindex dbdc7edc6,bf4bd3d87..e148089fb--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@@ -2586,13 -2034,12 +2586,15 @@@ pub fn confirm(app: &mut DesignApp) ->}app.run("view.snapPreferences", snap)?;}- if !d.fields.contains_key("horizontalUnits") {- return Ok(Value::Null);+ let Some(horizontal) = d.fields.get("horizontalUnits") else { return Ok(Value::Null) };+ let mut doc = json!({"horizontalUnits": horizontal});+ // Fields can come from `ui.dialog.open`; rulers it doesn't name keep their units.+ if let Some(vertical) = d.fields.get("verticalUnits") {+ doc["verticalUnits"] = vertical.clone();}- let mut doc = json!({"horizontalUnits": d.fields["horizontalUnits"], "verticalUnits": d.fields["verticalUnits"]});+ if let Some(o) = d.fields.get("rulerOrigin").filter(|o| o.is_string()) {+ doc["rulerOrigin"] = o.clone();+ }let mut bg = json!({"relativeTo": d.s("bg.relativeTo"), "color": d.fields.get("bg.color").cloned().unwrap_or(json!([140, 205, 230]))});if let Some(v) = d.m("bg.start") {bg["start"] = json!(v.max(0.0));@@@ -4643,1871 -3581,379 +4645,1889 @@@ fn open_type_features(lang: &str, ui: &}}-const STEP_AND_REPEAT: &str = "cmd:edit.stepAndRepeat";-/// The params a previewing dialog shows on the page (its interaction is open while it is set).-const PREVIEWED: &str = "_previewed";--/// Edit › Step and Repeat, as in InDesign: Repeat (Count, or Rows and Columns with Create as a-/// grid), Offset (Vertical, Horizontal, in the document's ruler units) and Preview, which shows-/// the copies on the page while the dialog is open.-fn step_and_repeat_dialog(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {- let (hu, vu) = app.session.active().map_or((Unit::Picas, Unit::Picas), |s| (s.doc.settings.horizontal_units, s.doc.settings.vertical_units));- for (k, v) in [- ("count", json!("1")),- ("rows", json!("1")),- ("columns", json!("1")),- ("vertical", json!(format_measure(12.0, vu))),- ("horizontal", json!(format_measure(12.0, hu))),- ] {- d.fields.entry(k).or_insert(v);+/// 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),+ );}- 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);+ 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));}- });+ }});- ui.add_space(32.0);- check(ui, d, "preview", &tr("Preview"));+}++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));+ }+ }});- 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));+}++/// 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);}-/// `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)) }+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 measure = |k: &str, u: Unit| {- let s = d.s(k);- if s.trim().is_empty() {- return Ok(12.0);+ 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());}- 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})- })+ }+ Value::Object(r)}-/// 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");+/// 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"));}- return;}- let params = match step_and_repeat_params(app, d) {- Ok(p) => p,- Err(e) => {- d.fields.insert("status".into(), json!(e));- return;+ 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();}- };- if shown.as_ref() == Some(¶ms) {- return;+ 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));}- if shown.is_none()- && let Err(e) = app.session.begin_interaction("Step and Repeat")- {- d.fields.insert("status".into(), json!(e.to_string()));- return;+}++/// 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));+ }}- 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);+ out}-/// 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]";+/// 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| {- 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));+ 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));}}- }- 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(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();});- }- 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();+ });+}++/// Document Footnote Options: Numbering and Formatting / Layout tabs.+fn footnote_options(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {ui.horizontal(|ui| {- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Format:"));- combo(ui, d, "format", &opts);+ 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));+ }+ }});- if let Some(m) = d.fields.get("status").and_then(Value::as_str) {- ui.label(egui::RichText::new(m).color(dim));+ ui.separator();+ let head = |ui: &mut egui::Ui, t: &str| {+ ui.add_space(4.0);+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, t)).font(semibold(12.0)));+ };+ if d.s("tab") == "layout" {+ head(ui, "Spacing Options");+ egui::Grid::new("fn_sp").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Minimum Space Before First Footnote:"));+ text_field(ui, d, "spaceBefore", 70.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Space Between Footnotes:"));+ text_field(ui, d, "spaceBetween", 70.0);+ ui.end_row();+ });+ head(ui, "First Baseline");+ egui::Grid::new("fn_fb").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Offset:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "firstBaseline",+ &[+ ("ascent", "Ascent"),+ ("capHeight", "Cap Height"),+ ("leading", "Leading"),+ ("xHeight", "x Height"),+ ("emboxHeight", "Em Box Height"),+ ("fixed", "Fixed"),+ ],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Min:"));+ text_field(ui, d, "firstBaselineMin", 70.0);+ ui.end_row();+ });+ check(ui, d, "spanColumns", crate::i18n::tr(&app.ui.language, "Span Footnotes Across Columns"));+ head(ui, "Rule Above");+ check(ui, d, "rule.on", crate::i18n::tr(&app.ui.language, "Rule On"));+ egui::Grid::new("fn_rule").num_columns(4).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Weight:"));+ text_field(ui, d, "rule.weight", 60.0);+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Color:"));+ let swatches: Vec<String> = app.session.active().map(|st| st.doc.swatches.iter().map(|s| s.name.clone()).collect()).unwrap_or_default();+ let opts: Vec<(&str, &str)> = swatches.iter().map(|n| (n.as_str(), n.as_str())).collect();+ combo(ui, d, "rule.color", &opts);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Width:"));+ text_field(ui, d, "rule.width", 60.0);+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Offset:"));+ text_field(ui, d, "rule.offset", 60.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Left Indent:"));+ text_field(ui, d, "rule.leftIndent", 60.0);+ ui.end_row();+ });+ return;+ }+ head(ui, "Numbering");+ egui::Grid::new("fn_num").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Style:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "style",+ &[+ ("arabic", "1, 2, 3, 4..."),+ ("upperRoman", "I, II, III, IV..."),+ ("lowerRoman", "i, ii, iii, iv..."),+ ("upperLetters", "A, B, C, D..."),+ ("lowerLetters", "a, b, c, d..."),+ ("arabicLeadingZero", "01, 02, 03..."),+ ("symbols", "*, †, ‡, §..."),+ ("kanji", "一, 二, 三, 四..."),+ ],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Start at:"));+ text_field(ui, d, "startAt", 60.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Restart Numbering Every:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "restart",+ &[("never", "Never (continuous)"), ("page", "Page"), ("spread", "Spread"), ("section", "Section")],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Show Prefix/Suffix in:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "affixIn",+ &[("none", "None"), ("reference", "Footnote Reference"), ("text", "Footnote Text"), ("both", "Both")],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Prefix:"));+ text_field(ui, d, "prefix", 60.0);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Suffix:"));+ text_field(ui, d, "suffix", 60.0);+ ui.end_row();+ });+ head(ui, "Footnote Reference Number in Text");+ egui::Grid::new("fn_ref").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Position:"));+ translated_combo(+ &app.ui.language,+ ui,+ d,+ "refPosition",+ &[+ ("superscript", "Apply Superscript"),+ ("subscript", "Apply Subscript"),+ ("normal", "Apply Normal"),+ ("otSuperscript", "OpenType Superscript"),+ ],+ );+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Character Style:"));+ style_combo(app, ui, d, "refCharStyle", true);+ ui.end_row();+ });+ head(ui, "Footnote Formatting");+ egui::Grid::new("fn_fmt").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Paragraph Style:"));+ style_combo(app, ui, d, "paraStyle", false);+ ui.end_row();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Separator:"));+ text_field(ui, d, "separator", 60.0);+ ui.end_row();+ });+}++/// One parameter of a command, parsed from its params documentation+/// (`{name, type?: a|b|c, count?, flag?: bool, …}`).+#[derive(Clone, Debug, PartialEq)]+pub struct CommandField {+ pub key: String,+ pub optional: bool,+ /// Enumerated values (`a|b|c`).+ pub choices: Vec<String>,+ pub boolean: bool,+ /// The documented value spec (shown as a hint).+ pub hint: String,+}++/// Parameters of a command from its documentation string: the top-level keys of the first `{…}`.+pub fn command_fields(doc: &str) -> Vec<CommandField> {+ let Some(start) = doc.find('{') else { return vec![] };+ let mut depth = 0i32;+ let mut end = doc.len();+ for (i, c) in doc[start..].char_indices() {+ match c {+ '{' | '[' | '(' => depth += 1,+ '}' | ']' | ')' => {+ depth -= 1;+ if depth == 0 {+ end = start + i;+ break;+ }+ }+ _ => {}+ }+ }+ let body = &doc[start + 1..end];+ let mut parts = Vec::new();+ let (mut depth, mut from) = (0i32, 0usize);+ for (i, c) in body.char_indices() {+ match c {+ '{' | '[' | '(' => depth += 1,+ '}' | ']' | ')' => depth -= 1,+ ',' if depth == 0 => {+ parts.push(&body[from..i]);+ from = i + 1;+ }+ _ => {}+ }+ }+ parts.push(&body[from..]);+ let ident = |s: &str| !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') && !s.starts_with(|c: char| c.is_ascii_digit());+ let mut out = Vec::new();+ for part in parts {+ // `key`, `key?`, `key: spec` or `key (spec)`: the key is the leading word.+ let part = part.trim();+ let k_end = part.find(|c: char| c.is_whitespace() || c == ':' || c == '(').unwrap_or(part.len());+ let (k, rest) = part.split_at(k_end);+ let rest = rest.trim_start();+ let spec = match rest.strip_prefix(':') {+ Some(v) => v.trim(),+ None => rest.strip_prefix('(').and_then(|r| r.strip_suffix(')')).unwrap_or(rest).trim(),+ };+ let optional = k.ends_with('?');+ let key = k.trim_end_matches('?');+ if !ident(key) || out.iter().any(|f: &CommandField| f.key == key) {+ continue;+ }+ let word = spec.split_whitespace().next().unwrap_or("");+ let choices: Vec<String> =+ if word.contains('|') && word.split('|').all(ident) { word.split('|').map(str::to_string).collect() } else { vec![] };+ let boolean = spec.starts_with("bool") || spec.starts_with("true|false") || spec.starts_with("true") && spec.len() <= 5;+ out.push(CommandField { key: key.into(), optional, choices: if boolean { vec![] } else { choices }, boolean, hint: spec.into() });+ }+ out+}++fn humanize(key: &str) -> String {+ let mut s = String::new();+ for (i, c) in key.chars().enumerate() {+ if i == 0 {+ s.extend(c.to_uppercase());+ } else if c.is_uppercase() {+ s.push(' ');+ s.extend(c.to_lowercase());+ } else {+ s.push(c);+ }+ }+ s+}++/// A form for any command, from its parameter documentation.+fn command_form(app: &crate::DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let doc = designcraft_engine::find_command(&d.id[4..]).map_or("", |c| c.params);+ let fields = command_fields(doc);+ let dim = crate::theme::Tokens::get(ui.ctx()).text_dim;+ egui::Grid::new("cmdform").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ for f in &fields {+ ui.label(crate::rtl::widget(+ ui,+ format!("{}{}", crate::i18n::tr(&app.ui.language, &humanize(&f.key)), if f.optional { "" } else { " *" }),+ ));+ if f.boolean {+ check(ui, d, &f.key, "");+ } else if !f.choices.is_empty() {+ let mut opts: Vec<(&str, &str)> = vec![("", "—")];+ let labels: Vec<_> = f.choices.iter().map(|c| humanize(c)).collect();+ opts.extend(f.choices.iter().zip(&labels).map(|(value, label)| (value.as_str(), crate::i18n::tr(&app.ui.language, label))));+ combo(ui, d, &f.key, &opts);+ } else {+ let mut s = d.s(&f.key);+ let hint = if f.hint.is_empty() { String::new() } else { f.hint.clone() };+ if ui.add(egui::TextEdit::singleline(&mut s).hint_text(egui::RichText::new(hint).color(dim)).desired_width(240.0)).changed() {+ d.fields.insert(f.key.clone(), Value::String(s));+ }+ }+ ui.end_row();+ }+ });+ if let Some(st) = d.fields.get("status").and_then(Value::as_str) {+ ui.label(egui::RichText::new(st).color(crate::theme::Tokens::get(ui.ctx()).text_dim));+ }+}++const STEP_AND_REPEAT: &str = "cmd:edit.stepAndRepeat";+/// The params a previewing dialog shows on the page (its interaction is open while it is set).+const PREVIEWED: &str = "_previewed";++/// Edit › Step and Repeat, as in InDesign: Repeat (Count, or Rows and Columns with Create as a+/// grid), Offset (Vertical, Horizontal, in the document's ruler units) and Preview, which shows+/// the copies on the page while the dialog is open.+fn step_and_repeat_dialog(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let (hu, vu) = app.session.active().map_or((Unit::Picas, Unit::Picas), |s| (s.doc.settings.horizontal_units, s.doc.settings.vertical_units));+ for (k, v) in [+ ("count", json!("1")),+ ("rows", json!("1")),+ ("columns", json!("1")),+ ("vertical", json!(format_measure(12.0, vu))),+ ("horizontal", json!(format_measure(12.0, hu))),+ ] {+ d.fields.entry(k).or_insert(v);+ }+ let lang = app.ui.language.clone();+ let tr = |s: &str| crate::i18n::tr(&lang, s).to_string();+ ui.horizontal_top(|ui| {+ ui.vertical(|ui| {+ crate::rtl::label(ui, egui::RichText::new(tr("Repeat")).font(semibold(12.0)));+ egui::Grid::new("sr_repeat").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ let grid = d.b("grid");+ let fields: &[(&str, &str)] = if grid { &[("rows", "Rows:"), ("columns", "Columns:")] } else { &[("count", "Count:")] };+ for (k, l) in fields {+ // A grid's columns, not a text frame's.+ crate::rtl::label(ui, crate::i18n::tr_context(&lang, l, "grid"));+ text_field(ui, d, k, 70.0);+ ui.end_row();+ }+ crate::rtl::label(ui, "");+ check(ui, d, "grid", &tr("Create as a grid"));+ ui.end_row();+ });+ ui.add_space(10.0);+ crate::rtl::label(ui, egui::RichText::new(tr("Offset")).font(semibold(12.0)));+ ui.horizontal(|ui| {+ for (k, l) in [("vertical", "Vertical:"), ("horizontal", "Horizontal:")] {+ crate::rtl::label(ui, tr(l));+ text_field(ui, d, k, 80.0);+ ui.add_space(12.0);+ }+ });+ });+ ui.add_space(32.0);+ check(ui, d, "preview", &tr("Preview"));+ });+ step_and_repeat_preview(app, d);+ if let Some(st) = d.fields.get("status").and_then(Value::as_str) {+ ui.add_space(6.0);+ crate::rtl::label(ui, egui::RichText::new(st).color(crate::theme::Tokens::get(ui.ctx()).text_dim));+ }+}++/// `edit.stepAndRepeat`'s params from the dialog: whole counts, offsets in the ruler units+/// (or any unit typed: "-0.75 in", "3p"). Empty fields are 1 copy and 1p0.+fn step_and_repeat_params(app: &DesignApp, d: &Dialog) -> Result<Value, String> {+ let (hu, vu) = app.session.active().map_or((Unit::Picas, Unit::Picas), |s| (s.doc.settings.horizontal_units, s.doc.settings.vertical_units));+ let invalid = |s: &str| format!("{}: {}", crate::i18n::tr(&app.ui.language, "Invalid value"), s.trim());+ // Fields not shown yet (a dialog confirmed over the control channel) take the defaults.+ let whole = |k: &str| {+ let s = d.s(k);+ if s.trim().is_empty() { Ok(1) } else { s.trim().parse::<u64>().map_err(|_| invalid(&s)) }+ };+ let measure = |k: &str, u: Unit| {+ let s = d.s(k);+ if s.trim().is_empty() {+ return Ok(12.0);+ }+ parse_measure(&s, u).ok().filter(|v| v.is_finite()).ok_or_else(|| invalid(&s))+ };+ let (dx, dy) = (measure("horizontal", hu)?, measure("vertical", vu)?);+ Ok(if d.b("grid") {+ json!({"rows": whole("rows")?, "columns": whole("columns")?, "dx": dx, "dy": dy})+ } else {+ json!({"count": whole("count")?, "dx": dx, "dy": dy})+ })+}++/// Preview on: the copies show on the page (redone when a field changes); off: they go.+fn step_and_repeat_preview(app: &mut DesignApp, d: &mut Dialog) {+ let shown = d.fields.get(PREVIEWED).cloned();+ if !d.b("preview") {+ if shown.is_some() {+ app.session.cancel_interaction();+ d.fields.remove(PREVIEWED);+ d.fields.remove("status");+ }+ return;+ }+ let params = match step_and_repeat_params(app, d) {+ Ok(p) => p,+ Err(e) => {+ d.fields.insert("status".into(), json!(e));+ return;+ }+ };+ if shown.as_ref() == Some(¶ms) {+ return;+ }+ if shown.is_none()+ && let Err(e) = app.session.begin_interaction("Step and Repeat")+ {+ d.fields.insert("status".into(), json!(e.to_string()));+ return;+ }+ match app.session.preview("edit.stepAndRepeat", params.clone()) {+ Ok(()) => d.fields.remove("status"),+ Err(e) => d.fields.insert("status".into(), json!(e.to_string())),+ };+ d.fields.insert(PREVIEWED.into(), params);+}++/// New Cross-Reference: link to a paragraph (paragraph styles on the left, their paragraphs on+/// the right) or a text anchor, with a cross-reference format.+fn insert_xref(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {+ let Some(st) = app.session.active() else { return };+ let doc = &st.doc;+ let all = "[All Paragraphs]";+ ui.horizontal(|ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Link To:"));+ translated_combo(&app.ui.language, ui, d, "linkTo", &[("paragraph", "Paragraph"), ("anchor", "Text Anchor")]);+ });+ ui.add_space(6.0);+ let dim = crate::theme::Tokens::get(ui.ctx()).text_dim;+ if d.s("linkTo") == "anchor" {+ egui::ScrollArea::vertical().id_salt("xr_anchors").max_height(220.0).max_width(460.0).show(ui, |ui| {+ let mut any = false;+ for st in doc.stories.values() {+ for a in &st.anchors {+ any = true;+ let key = format!("a:{}", a.id);+ if ui.selectable_label(d.s("target") == key, &a.name).clicked() {+ d.fields.insert("target".into(), json!(key));+ }+ }+ }+ if !any {+ ui.label(crate::rtl::widget(+ ui,+ egui::RichText::new(crate::i18n::tr(&app.ui.language, "No text anchors in this document.")).color(dim),+ ));+ }+ });+ } else {+ let mut styles: Vec<String> = vec![all.to_string()];+ styles.extend(doc.styles.paragraph.iter().map(|s| s.name.clone()));+ let cur_style = if d.s("style").is_empty() { all.to_string() } else { d.s("style") };+ ui.horizontal_top(|ui| {+ let col = |w: f32| (egui::vec2(w, 240.0), egui::Layout::top_down(egui::Align::Min));+ let (sz, lay) = col(180.0);+ ui.allocate_ui_with_layout(sz, lay, |ui| {+ egui::ScrollArea::vertical().id_salt("xr_styles").auto_shrink([false, false]).show(ui, |ui| {+ for name in &styles {+ if ui.selectable_label(*name == cur_style, name).clicked() {+ d.fields.insert("style".into(), json!(name));+ }+ }+ })+ });+ ui.add_space(8.0);+ let (sz, lay) = col(330.0);+ ui.allocate_ui_with_layout(sz, lay, |ui| {+ egui::ScrollArea::vertical().id_salt("xr_paras").auto_shrink([false, false]).show(ui, |ui| {+ for st in doc.stories.values().filter(|s| !s.frames.is_empty()) {+ for (pi, r) in st.para_ranges().into_iter().enumerate() {+ if cur_style != all && st.paras[pi].style != cur_style {+ continue;+ }+ let text = designcraft_doc::xref::clean(&st.text[r]);+ if text.is_empty() {+ continue;+ }+ let short: String = text.chars().take(52).collect();+ let key = format!("{}:{pi}", st.id.0);+ if ui.selectable_label(d.s("target") == key, short).clicked() {+ d.fields.insert("target".into(), json!(key));+ }+ }+ }+ })+ });+ });+ }+ ui.add_space(8.0);+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Cross-Reference Format")).font(semibold(12.0)));+ let names: Vec<String> = doc.xref_formats.iter().map(|f| f.name.clone()).collect();+ if d.s("format").is_empty() {+ d.fields.insert("format".into(), json!(names.first().cloned().unwrap_or_default()));+ }+ let opts: Vec<(&str, &str)> = names.iter().map(|n| (n.as_str(), n.as_str())).collect();+ ui.horizontal(|ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Format:"));+ combo(ui, d, "format", &opts);+ });+ if let Some(m) = d.fields.get("status").and_then(Value::as_str) {+ ui.label(egui::RichText::new(m).color(dim));+ }+}++/// `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,+ crate::i18n::tr(+ &app.ui.language,+ "This document uses unavailable fonts. Choose replacements, or select Done to continue with fallback fonts.",+ ),+ );+ }+ if !d.s("error").is_empty() {+ crate::rtl::label(ui, d.s("error"));+ }+ let missing = fonts.iter().filter(|f| f["missing"] == true || f["styleMissing"] == true).count();+ crate::rtl::label(+ ui,+ crate::i18n::tr(&app.ui.language, "Fonts in Document: {count} Missing: {missing}")+ .replace("{count}", &fonts.len().to_string())+ .replace("{missing}", &missing.to_string()),+ );+ egui::ScrollArea::vertical().id_salt("ff_list").max_height(180.0).show(ui, |ui| {+ for f in &fonts {+ let (fam, st) = (f["family"].as_str().unwrap_or(""), f["style"].as_str().unwrap_or(""));+ let warn = f["missing"] == true || f["styleMissing"] == true;+ let label = format!("{}{fam} {st}", if warn { "\u{26A0} " } else { "" });+ let on = d.s("family") == fam && d.s("style") == st;+ let mut text = egui::RichText::new(label);+ if warn && !on {+ text = text.color(crate::theme::Tokens::get(ui.ctx()).text_strong);+ }+ if ui.selectable_label(on, text).clicked() {+ d.fields.insert("family".into(), json!(fam));+ d.fields.insert("style".into(), json!(st));+ }+ }+ });+ let key = format!("{}\n{}", d.s("family"), d.s("style"));+ if let Some(font) = fonts.iter().find(|f| f["family"] == d.s("family") && f["style"] == d.s("style")) {+ if d.s("_fontKey") != key {+ d.fields.insert("_fontKey".into(), json!(key));+ d.fields.insert("toFamily".into(), font["replacementFamily"].clone());+ d.fields.insert("toStyle".into(), font["replacementStyle"].clone());+ }+ crate::rtl::label(+ ui,+ format!(+ "{}: {} {}",+ crate::i18n::tr(&app.ui.language, "Currently Rendered With"),+ font["resolvedFamily"].as_str().unwrap_or(""),+ font["resolvedStyle"].as_str().unwrap_or("")+ ),+ );+ }+ ui.add_space(8.0);+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Replace With")).font(semibold(12.0)));+ let db = crate::panels::fonts(app);+ if d.s("toFamily").is_empty() {+ d.fields.insert("toFamily".into(), json!(designcraft_fonts::FALLBACK_FAMILY));+ }+ egui::Grid::new("ff_to").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Family:"));+ if let Some(f) = crate::panels::font_combo(app, ui, "toFamily", &d.s("toFamily"), 170.0) {+ let style = crate::panels::pick_style(app, &f);+ d.fields.insert("toFamily".into(), json!(f.family));+ d.fields.insert("toStyle".into(), json!(style));+ }+ ui.end_row();+ let styles = db.styles(&d.s("toFamily"));+ if !styles.iter().any(|style| style == &d.s("toStyle")) {+ let preferred = d.s("style");+ let style = styles+ .iter()+ .find(|s| s.eq_ignore_ascii_case(&preferred))+ .or_else(|| styles.iter().find(|s| s.eq_ignore_ascii_case("Regular")))+ .or_else(|| styles.first());+ if let Some(style) = style {+ d.fields.insert("toStyle".into(), json!(style));+ }+ }+ let st_opts: Vec<(&str, &str)> = styles.iter().map(|s| (s.as_str(), s.as_str())).collect();+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Style:"));+ combo(ui, d, "toStyle", &st_opts);+ ui.end_row();+ });+ ui.label(crate::rtl::widget(+ ui,+ egui::RichText::new(crate::i18n::tr(+ &app.ui.language,+ "Replace All updates this font throughout text and styles. Done keeps remaining fallback fonts.",+ ))+ .color(crate::theme::Tokens::get(ui.ctx()).text_dim)+ .size(11.0),+ ));+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn step_and_repeat_dialog_previews_and_makes_the_copies_as_one_undo_step() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ let id = app.run("frame.create", json!({"rect": [72, 600, 540, 640]})).unwrap()["id"].as_u64().unwrap();+ app.run("selection.set", json!({"ids": [id]})).unwrap();+ let open = |app: &mut DesignApp| {+ crate::menus::activate(app, "edit.stepAndRepeat", &Value::Null);+ assert_eq!(app.ui.dialog.as_ref().map(|d| d.id.as_str()), Some(STEP_AND_REPEAT));+ };+ let set = |app: &mut DesignApp, k: &str, v: Value| {+ app.ui.dialog.as_mut().unwrap().fields.insert(k.into(), v);+ };+ let items = |app: &DesignApp| app.session.doc().unwrap().doc.spreads[0].items.len();+ let undo = |app: &DesignApp| app.session.doc().unwrap().history.undo.len();+ let (n0, u0) = (items(&app), undo(&app));+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0));+ open(&mut app);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ for expected in ["Step and Repeat", "Repeat", "Count:", "Create as a grid", "Offset", "Vertical:", "Horizontal:", "Preview", "OK", "Cancel"] {+ visible_label(&labels, screen, expected);+ }+ // Preview: the copies show, and change with the fields, without an undo step.+ set(&mut app, "count", json!("5"));+ set(&mut app, "vertical", json!("-0.75 in"));+ set(&mut app, "horizontal", json!("0"));+ set(&mut app, "preview", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!((items(&app), undo(&app)), (n0 + 5, u0));+ set(&mut app, "count", json!("3"));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(items(&app), n0 + 3);+ set(&mut app, "preview", json!(false));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(items(&app), n0, "Preview off takes them away");+ set(&mut app, "preview", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert_eq!(items(&app), n0 + 3);+ // Cancel puts the document back.+ cancel(&mut app);+ assert!(app.ui.dialog.is_none());+ assert_eq!((items(&app), undo(&app)), (n0, u0));+ // OK after a preview makes the copies once, as one undo step, 0.75 in apart.+ app.run("selection.set", json!({"ids": [id]})).unwrap();+ open(&mut app);+ set(&mut app, "count", json!("2"));+ set(&mut app, "vertical", json!("-0.75 in"));+ set(&mut app, "horizontal", json!("0"));+ set(&mut app, "preview", json!(true));+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let r = confirm(&mut app).unwrap();+ assert_eq!((items(&app), undo(&app)), (n0 + 2, u0 + 1));+ let last = r["ids"][1].as_u64().unwrap();+ let top = app.session.doc().unwrap().doc.item(designcraft_doc::ItemId(last)).unwrap().bounds().min_y();+ assert!((top - (600.0 - 108.0)).abs() < 1e-6, "{top}");+ // Create as a grid: Rows × Columns cells, the original being one.+ app.run("selection.set", json!({"ids": [id]})).unwrap();+ open(&mut app);+ set(&mut app, "grid", json!(true));+ set(&mut app, "rows", json!("2"));+ set(&mut app, "columns", json!("3"));+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ visible_label(&labels, screen, "Rows:");+ visible_label(&labels, screen, "Columns:");+ assert_eq!(confirm(&mut app).unwrap()["created"], 5);+ // A value that isn't a measure keeps the dialog open and says so.+ open(&mut app);+ set(&mut app, "vertical", json!("up"));+ assert!(confirm(&mut app).is_err());+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!(d.s("status"), "Invalid value: up");+ }++ /// A three-page document in `units` with Document Setup open.+ fn document_setup_app(units: &str) -> DesignApp {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({"pages": 3})).unwrap();+ app.run("document.preferences", json!({"horizontalUnits": units, "verticalUnits": units})).unwrap();+ crate::menus::activate(&mut app, "layout.documentSetup", &Value::Null);+ app+ }++ fn setup_fields(app: &mut DesignApp, fields: Value) {+ let d = app.ui.dialog.as_mut().unwrap();+ for (k, v) in fields.as_object().unwrap() {+ d.fields.insert(k.clone(), v.clone());+ }+ }++ #[test]+ fn document_setup_ok_applies_margins_bleed_and_size_in_one_step() {+ let mut app = document_setup_app("millimeters");+ let d = app.ui.dialog.as_ref().unwrap();+ assert_eq!(d.id, "documentSetup");+ assert_eq!((d.s("marginTop"), d.b("marginLinked")), ("12.7 mm".to_string(), true), "the document's margins, in its units");+ setup_fields(+ &mut app,+ json!({"marginTop": "20 mm", "marginBottom": "20 mm", "marginInside": "20 mm", "marginOutside": "20 mm", "bleedTop": "3 mm",+ "bleedBottom": "3 mm", "bleedInside": "3 mm", "bleedOutside": "3 mm", "width": "210 mm", "height": "297 mm"}),+ );+ confirm(&mut app).unwrap();+ assert!(app.ui.dialog.is_none());+ let mm = designcraft_geom::units::PT_PER_MM;+ let doc = &app.session.active().unwrap().doc;+ assert!((doc.settings.page_width - 210.0 * mm).abs() < 1e-6 && (doc.settings.bleed[2] - 3.0 * mm).abs() < 1e-6);+ assert!(doc.spreads.iter().flat_map(|s| &s.pages).all(|p| (p.margins.top - 20.0 * mm).abs() < 1e-6), "every page");+ app.run("edit.undo", json!({})).unwrap();+ let doc = &app.session.active().unwrap().doc;+ assert!((doc.settings.page_width - 612.0).abs() < 1e-6 && doc.settings.bleed[0] == 0.0, "one undo step");+ }++ #[test]+ fn document_setup_keeps_each_pages_margins_unless_they_are_edited() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({"pages": 3, "margins": 36})).unwrap();+ app.run("layout.marginsAndColumns", json!({"pages": [1], "margins": 90})).unwrap();+ let margins =+ |app: &DesignApp| app.session.active().unwrap().doc.spreads.iter().flat_map(|s| &s.pages).map(|p| p.margins.top).collect::<Vec<_>>();+ // Only the page count changes: every page keeps its own margins.+ crate::menus::activate(&mut app, "layout.documentSetup", &Value::Null);+ setup_fields(&mut app, json!({"pages": "4"}));+ confirm(&mut app).unwrap();+ assert_eq!(margins(&app), [36.0, 90.0, 36.0, 36.0]);+ // Edited margins go to every page.+ crate::menus::activate(&mut app, "layout.documentSetup", &Value::Null);+ setup_fields(&mut app, json!({"marginTop": "1p0"}));+ confirm(&mut app).unwrap();+ assert_eq!(margins(&app), [12.0; 4]);+ }++ #[test]+ fn document_setup_keeps_a_value_it_cannot_read_and_changes_nothing() {+ for (key, value) in [("width", "wide"), ("marginTop", "-"), ("pages", "0"), ("bleedTop", "x")] {+ let mut app = document_setup_app("points");+ setup_fields(&mut app, json!({key: value, "bleedInside": "9"}));+ assert!(confirm(&mut app).is_err(), "{key}");+ assert!(app.ui.dialog.is_some(), "{key}: the dialog stays open");+ assert_eq!(app.session.active().unwrap().doc.settings.bleed, [0.0; 4], "{key}: nothing changed");+ }+ }++ #[test]+ fn document_setup_links_edges_and_adjust_layout_applies() {+ let mut app = document_setup_app("points");+ let f = app.run("frame.create", json!({"rect": [36, 36, 576, 756], "content": "text"})).unwrap();+ crate::menus::activate(&mut app, "layout.documentSetup", &Value::Null);+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1178.0, 900.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ // Typing in a linked margin sets all four.+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ let top = labels.iter().filter(|(t, _, _)| t == "36 pt").map(|(_, r, _)| *r).next().expect("the top margin");+ click_dialog(&mut app, &ctx, screen, top.center());+ let select_all =+ egui::Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::COMMAND };+ dialog_frame(&mut app, &ctx, screen, vec![select_all, egui::Event::Text("72 pt".into())]);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ let d = app.ui.dialog.as_ref().unwrap();+ assert!(["Top", "Bottom", "Inside", "Outside"].iter().all(|e| d.s(&format!("margin{e}")) == "72 pt"), "linked: {:?}", d.fields);+ // Adjust Layout applies at once, and the frame follows the margins.+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "Adjust Layout").center());+ assert!(app.ui.dialog.is_none(), "applied");+ let doc = &app.session.active().unwrap().doc;+ let b = doc.item(designcraft_doc::ItemId(f["id"].as_u64().unwrap())).unwrap().bounds();+ assert!((b.y0 - 72.0).abs() < 1e-6 && doc.page(0).unwrap().margins.outside == 72.0, "{b:?}");+ }++ #[test]+ fn cell_options_dialog_draws_and_applies_only_changed_values_to_the_chosen_edges() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("frame.create", json!({"rect": [72, 72, 400, 400], "content": "text", "caret": true})).unwrap();+ let tid = app.run("table.insert", json!({"rows": 2, "cols": 2})).unwrap()["table"].as_u64().unwrap();+ app.run("table.select", json!({"what": "table"})).unwrap();+ app.run("app.cellOptionsDialog", json!({})).unwrap();+ let ctx = dialog_context("");+ dialog_frame(&mut app, &ctx, egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(900.0, 700.0)), vec![]);+ let d = app.ui.dialog.as_mut().unwrap();+ assert_eq!(d.id, "cellOptions");+ assert_eq!(d.fields["weight"], json!(1.0));+ d.fields.insert("edges".into(), json!(["top", "bottom", "left", "right"]));+ d.fields.insert("gapColor".into(), json!("[Paper]"));+ d.fields.insert("fill".into(), json!("[Black]"));+ d.fields.insert("fillTint".into(), json!(0.2));+ confirm(&mut app).unwrap();+ let st = app.session.active().unwrap();+ let t = st.doc.stories.values().find_map(|s| s.tables.get(&tid)).unwrap();+ let gap = |r: usize, c: usize, side: usize| t.cell(r, c).unwrap().strokes[side].gap_color.clone();+ assert_eq!([gap(0, 0, 0), gap(0, 0, 1), gap(1, 1, 2), gap(1, 1, 3)], ["[Paper]"; 4].map(String::from), "outer edges");+ assert_eq!([gap(0, 0, 2), gap(0, 0, 3)], ["[None]"; 2].map(String::from), "inner edges keep theirs");+ assert!(t.cells.iter().all(|c| c.fill == "[Black]" && (c.fill_tint - 0.2).abs() < 1e-6));+ assert!(t.cells.iter().all(|c| c.strokes.iter().all(|e| e.weight == 1.0)), "unchanged values are not applied");+ }++ #[test]+ fn cell_options_edge_changes_reseed_every_stroke_field_and_survive_a_bad_seed() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ app.run("frame.create", json!({"rect": [72, 72, 400, 400], "content": "text", "caret": true})).unwrap();+ let tid = app.run("table.insert", json!({"rows": 2, "cols": 2})).unwrap()["table"].as_u64().unwrap();+ app.run("table.select", json!({"what": "table"})).unwrap();+ app.run("table.setCell", json!({"stroke": {"weight": 3, "edges": "innerHorizontal"}})).unwrap();+ app.run("app.cellOptionsDialog", json!({})).unwrap();+ let mut d = app.ui.dialog.take().unwrap();+ d.fields.insert("seed".into(), json!(5));+ let outer = [true, true, true, true, false, false];+ cell_options_edges_changed(&mut app, &mut d, &outer);+ assert_eq!((&d.fields["weight"], &d.fields["seed"]["weight"]), (&json!(1.0), &json!(1.0)));+ // A weight typed for the outer edges, then the inner horizontal edges (3 pt) chosen+ // and 1 pt typed: 1 pt differs from what those edges show, so OK applies it.+ d.fields.insert("weight".into(), json!(5.0));+ cell_options_edges_changed(&mut app, &mut d, &[false, false, false, false, true, false]);+ assert_eq!((&d.fields["weight"], &d.fields["seed"]["weight"]), (&json!(5.0), &json!(3.0)));+ d.fields.insert("weight".into(), json!(1.0));+ app.ui.dialog = Some(d);+ confirm(&mut app).unwrap();+ let st = app.session.active().unwrap();+ let t = st.doc.stories.values().find_map(|s| s.tables.get(&tid)).unwrap();+ assert_eq!([t.cell(0, 0).unwrap().strokes[2].weight, t.cell(1, 1).unwrap().strokes[0].weight], [1.0; 2]);+ }+++ #[test]++ fn 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)));++ }++ }+++ #[test]+ fn enter_and_escape_close_the_style_menu_not_numbering_and_section_options() {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({"pages": 2})).unwrap();+ crate::menus::activate(&mut app, "layout.section", &Value::Null);+ let ctx = dialog_context("en");+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1178.0, 814.0));+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let key = |key| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE };+ for pressed in [egui::Key::Enter, egui::Key::Escape] {+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ // The section's Style menu (the first of the two).+ let style = labels.iter().filter(|(t, r, c)| t.trim() == "1, 2, 3, 4…" && c.contains_rect(*r)).map(|(_, r, _)| *r).next().unwrap();+ click_dialog(&mut app, &ctx, screen, style.center());+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert!(egui::Popup::is_any_open(&ctx), "the Style menu opened");+ dialog_frame(&mut app, &ctx, screen, vec![key(pressed)]);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ assert!(app.ui.dialog.is_some(), "{pressed:?} with the menu open leaves the dialog open");+ assert!(app.session.active().unwrap().doc.sections.iter().all(|s| s.start_number != Some(0)));+ if egui::Popup::is_any_open(&ctx) {+ egui::Popup::close_all(&ctx);+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ }+ // With no menu open, Escape closes the dialog.+ dialog_frame(&mut app, &ctx, screen, vec![key(egui::Key::Escape)]);+ assert!(app.ui.dialog.is_none());+ }++ #[test]+ fn numbering_and_section_options_keep_their_actions_in_view() {+ for language in ["en", "ar"] {+ for size in [egui::vec2(1178.0, 814.0), egui::vec2(392.0, 271.0)] {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.ui.language = language.into();+ app.run("file.new", json!({"pages": 2})).unwrap();+ crate::menus::activate(&mut app, "layout.section", &Value::Null);+ let ctx = dialog_context(language);+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, size);+ for _ in 0..3 {+ dialog_frame(&mut app, &ctx, screen, vec![]);+ }+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ let tr = |s| crate::i18n::tr(language, s);+ for expected in [tr("Numbering & Section Options…").trim_end_matches('…'), tr("OK"), tr("Cancel"), tr("Start Section")] {+ visible_label(&labels, screen, expected);+ }+ if size.x > 1000.0 {+ // Every option fits without scrolling, and choosing one then OK applies it.+ visible_label(&labels, screen, &format!("{} {}", tr("Book Name:"), tr("N/A")));+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, tr("Automatic Page Numbering")).center());+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, tr("OK")).center());+ assert!(app.ui.dialog.is_none(), "{language}: OK closes the dialog");+ let doc = &app.session.active().unwrap().doc;+ assert!(doc.sections.iter().all(|s| s.start != 0 || s.start_number.is_none()), "{language}: page 1 numbers automatically");+ }+ }+ }+ }++ fn 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() },+ }+ }++ /// 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)+ }++ /// 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,+ }+ }+ 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);+ }++ /// A frame with two paragraphs of [Basic Paragraph]; the first has a local Word Spacing minimum.+ fn two_paragraphs() -> (DesignApp, Value) {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.run("file.new", json!({})).unwrap();+ let r = app.run("frame.create", json!({"rect": [72, 72, 300, 400], "content": "text", "text": "One\nTwo"})).unwrap();+ app.run("text.select", json!({"story": r["story"], "anchor": 0, "focus": 0})).unwrap();+ app.run("type.para", json!({"attrs": {"wordSpaceMin": 0.7}})).unwrap();+ (app, r["story"].clone())+ }++ /// The resolved paragraph attribute `key` of the paragraph at byte `at`.+ fn para_attr(app: &mut DesignApp, story: &Value, at: usize, key: &str) -> Value {+ app.run("text.select", json!({"story": story, "anchor": at, "focus": at})).unwrap();+ app.run("type.selectionAttrs", json!({})).unwrap()["para"][key].clone()+ }++ #[test]+ fn justification_dialog_applies_to_a_local_paragraph_and_cancel_changes_nothing() {+ let (mut app, story) = two_paragraphs();+ let ctx = egui::Context::default();+ assert!(crate::menus::menu_enabled(&app, "app.justificationDialog"));+ app.run("app.justificationDialog", json!({})).unwrap();+ draw(&mut app, &ctx);+ let d = app.ui.dialog.clone().unwrap();+ assert_eq!(d.id, "justification");+ assert_eq!(d.fields["current"]["wordSpaceMin"], 0.7);+ assert_eq!(d.fields["current"]["wordSpaceDesired"], 1.0);+ app.ui.dialog.as_mut().unwrap().fields.insert("wordSpaceDesired".into(), json!(1.1));+ draw(&mut app, &ctx);+ let before = undo_steps(&app);+ confirm(&mut app).unwrap();+ assert_eq!(undo_steps(&app), before + 1, "one undo step");+ assert_eq!(para_attr(&mut app, &story, 0, "wordSpaceDesired"), 1.1);+ assert_eq!(para_attr(&mut app, &story, 0, "wordSpaceMin"), 0.7, "unedited fields stay");+ assert_eq!(para_attr(&mut app, &story, 4, "wordSpaceDesired"), 1.0, "only the selected paragraph");+ let style = app.session.doc().unwrap().doc.styles.resolve_para_style(designcraft_doc::story::BASIC_PARAGRAPH).0.word_space_desired;+ assert_eq!(style, 1.0, "the paragraph style keeps its value");++ // Cancel (Escape) leaves the paragraph alone.+ app.run("text.select", json!({"story": story, "anchor": 0, "focus": 0})).unwrap();+ app.run("app.justificationDialog", json!({})).unwrap();+ app.ui.dialog.as_mut().unwrap().fields.insert("wordSpaceDesired".into(), json!(1.2));+ let before = undo_steps(&app);+ let escape = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };+ let input = egui::RawInput {+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1400.0, 900.0))),+ events: vec![escape],+ ..Default::default()+ };+ let mut out = ctx.run_ui(input, |ui| {+ app.logic(&ui.ctx().clone());+ app.ui(ui);+ });+ out.textures_delta.clear();+ assert!(app.ui.dialog.is_none(), "cancelled");+ assert_eq!(undo_steps(&app), before);+ assert_eq!(para_attr(&mut app, &story, 0, "wordSpaceDesired"), 1.1);++ app.run("edit.deselectAll", json!({})).unwrap();+ assert!(!crate::menus::menu_enabled(&app, "app.justificationDialog"), "nothing to justify");+ assert!(app.run("app.justificationDialog", json!({})).is_err());+ }++ #[test]+ fn justification_dialog_leaves_mixed_fields_alone_and_refuses_bad_values() {+ let (mut app, story) = two_paragraphs();+ let ctx = egui::Context::default();+ app.run("text.select", json!({"story": story, "anchor": 0, "focus": 7})).unwrap();+ app.run("app.justificationDialog", json!({})).unwrap();+ draw(&mut app, &ctx);+ let d = app.ui.dialog.clone().unwrap();+ assert_eq!(d.fields["current"]["wordSpaceMin"], Value::Null, "mixed shows empty");+ assert_eq!(d.fields["current"]["wordSpaceMax"], 1.33);++ // Out of range, and minimum above desired: an error, the dialog stays open, nothing changes.+ let before = undo_steps(&app);+ for (key, v) in [("wordSpaceMax", 20.0), ("glyphScaleMin", 0.2), ("letterSpaceDesired", f64::NAN)] {+ app.ui.dialog = Some(d.clone());+ app.ui.dialog.as_mut().unwrap().fields.insert(key.into(), json!(v));+ assert!(confirm(&mut app).is_err(), "{key} = {v}");+ assert!(app.ui.dialog.as_ref().is_some_and(|d| d.fields.contains_key("justifyError")), "{key}: the dialog shows why");+ }+ app.ui.dialog = Some(d.clone());+ app.ui.dialog.as_mut().unwrap().fields.insert("letterSpaceMin".into(), json!(0.1));+ assert!(confirm(&mut app).is_err(), "letter spacing minimum above desired");+ draw(&mut app, &ctx);+ assert_eq!(undo_steps(&app), before);++ app.ui.dialog = Some(d);+ app.ui.dialog.as_mut().unwrap().fields.insert("wordSpaceMax".into(), json!(1.5));+ confirm(&mut app).unwrap();+ assert_eq!(undo_steps(&app), before + 1);+ for (at, min) in [(0, 0.7), (4, 0.8)] {+ assert_eq!(para_attr(&mut app, &story, at, "wordSpaceMax"), 1.5);+ assert_eq!(para_attr(&mut app, &story, at, "wordSpaceMin"), min, "each paragraph keeps its own minimum");+ }+ }++ fn command_app(id: &str, fields: Value) -> DesignApp {+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ app.ui.dialog = Some(Dialog::new(&format!("cmd:{id}"), fields));+ app+ }++ #[test]+ fn generic_new_document_preserves_typed_values_and_text_entry() {+ for pages in [json!(2), json!(" 2 ")] {+ let mut app = command_app(+ "file.new",+ json!({+ "preset": "A4", "pages": pages, "facingPages": false, "gutter": 0,+ "margins": {"top": 10, "bottom": 20, "inside": 30, "outside": 40},+ "title": " ", "status": "internal", "primaryTextFrame": true+ }),+ );+ confirm(&mut app).unwrap();+ let doc = &app.session.active().unwrap().doc;+ assert_eq!(doc.page_count(), 2);+ assert!(!doc.settings.facing_pages);+ assert!(doc.title.starts_with("Untitled-"));+ for page in doc.spreads.iter().flat_map(|s| &s.pages) {+ assert!((page.width - 595.2755905511812).abs() < 0.01);+ assert!((page.height - 841.8897637795277).abs() < 0.01);+ assert_eq!(page.columns.gutter, 0.0);+ assert_eq!(page.margins.top, 10.0);+ assert_eq!(page.margins.outside, 40.0);+ }+ assert!(doc.spreads.iter().all(|s| s.items.is_empty()), "undocumented fields stay excluded");+ assert!(app.ui.dialog.is_none());+ }}-}-/// 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 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"]);}-}-/// Find/Replace Font: the document's fonts (missing ones first, flagged) and a replacement.-fn find_font(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {- // Listed once when the dialog opens (it scans every story).- if !d.fields.contains_key("_fonts") {- let list = app.session.execute("font.list", &json!({})).unwrap_or_default();- d.fields.insert("_fonts".into(), list);+ #[test]+ fn generic_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));}- 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));- }- }- });- 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));++ #[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);}- 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::*;+ #[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"));+ }#[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());+ 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 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 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)};- 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);+ // 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();}- // 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");+ assert_eq!(opts(&app), before);}fn dialog_context(language: &str) -> egui::Context {