Skip to content

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.rs
index 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(&params) {
- 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(&params) {
+ 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", &current), rule, "the inherited rule");
+ assert_eq!(shown_rule(&d, "", "ruleAbove", &current)["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 {