Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Merge #573: Step and Repeat: InDesign's dialog with Create as a grid and Preview

aiongg19bf6dd86865
diff --cc ROADMAP.md
index 8c21af731,a89a290ca..175a78328
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@@ -128,54 -129,12 +128,55 @@@ list) · [roadmap.md](docs/roadmap.md)
Newest first.
+ - **2026-10-12** · Edit › Step and Repeat has its InDesign dialog: Repeat (Count, or Rows and Columns with Create as a grid), Offset (Vertical, Horizontal, in ruler units) and Preview, which shows the copies while the dialog is open; Cancel takes them away and OK makes them as one undo step. No readiness percentage change.
+- **2026-10-12** · Load Styles: the Paragraph Styles and Character Styles panels load styles from another DesignCraft document or an IDML file, with the styles, swatches and lists they name; a dialog picks the styles and what happens to one the document defines differently (`style.load`). No readiness percentage change.
+- **2026-10-12** · On screen, blend modes blend with the objects below and not with the paper, as in InDesign and in PDF export: a Color Dodge or Screen object over blank paper shows as it is. No readiness percentage change.
+- **2026-10-12** · Text threads by hand: click a selected text frame's in or out port to load
+ the text cursor, then click a frame to thread it, click empty space for a column-wide frame or
+ drag one (it snaps like frame drawing); Shift-click autoflows, Alt-click stays loaded on the
+ frame just added; click the linked frame or double-click a port to break the thread.
+ `text.thread`, `text.unthread`, `text.removeFromThread` with undo; locked frames and layers
+ refuse threads. The alpha gate now waits only on the Primary Text Frame page fixes (#165). No
+ readiness percentage change.
+- **2026-10-12** · Properties › Transform shows rotation, shear and X/Y scale, and Rotate 90° and Flip Horizontal/Vertical buttons, as InDesign's does. No readiness percentage change.
+- **2026-10-12** · Underlines and strikethroughs are drawn as one bar per stretch of text on screen, as in PDF export: a bar per letter left faint seams between the letters. No readiness percentage change.
+- **2026-10-12** · The section marker character shows its section's marker text on document pages (nothing when the section has none) instead of the word "Section", which stays on parent pages; editing the marker recomposes (#556). No readiness percentage change.
+- **2026-10-12** · IDML import keeps a font family name exactly as written, trailing spaces included, and font lookup falls back to the name without surrounding spaces; `FontStyle="Nothing"` leaves the style to the paragraph (#558). No readiness percentage change.
+- **2026-10-12** · Clipping paths saved with images in IDML (Detect Edges, Alpha Channel, Photoshop Path, User-Modified Path, inverted or not) clip the image on screen and in PDF and survive IDML export; `object.clippingPathOptions` reports, inverts or removes one (#450). No readiness percentage change.
+- **2026-10-12** · Anchored objects with text wrap push text aside: other stories' text under them and the lines of their own story after the anchor's line (#557). No readiness percentage change.
- **2026-10-12** · Words in capitals hyphenate like capitalized words (FERRUM COM-MODI), as in InDesign; Hyphenate Capitalized Words off keeps them whole. No readiness percentage change.
+- **2026-10-12** · Load Swatches refuses an `.ase` file with more than 100,000 colors, and `swatch.load` merges a file of 100,000 colors in under 0.1 s (it took 9.6 s of CPU in a test build). No readiness percentage change.
+- **2026-10-11 (printing):** `file.printers` and `file.print` use craft-libs/craft-print for CUPS and Windows. DesignCraft retains PDF export, page selection, spreads, marks and bleed; dry runs create no temporary PDF or print job. Windows selects matching or default driver paper and shrinks oversized sheets without enlarging smaller ones; queue duplex defaults are preserved. Headless tests exercise exported bytes, job settings, dry runs and refusals; shared native Windows CI passes, including paused-queue submission and cleanup. PostScript, production print controls and physical output validation remain open. No readiness percentage change.
+- **2026-10-11** · The View menu follows InDesign's: proofing first, then zoom, Rotate Spread, Screen Mode, Display Performance, rulers, Extras, Grids & Guides and Structure; the view items that sat at the end of the Type menu moved there. No readiness percentage change.
+- **2026-10-11** · Properties › Appearance's Fill and Stroke menus gain InDesign's Tint field and, for a text frame, Apply To: Frame / Text. No readiness percentage change.
+- **2026-10-11** · `story.replaceRange`, `story.setText`, notes, footnotes, endnotes, type on a path and table cells read `\r` and `\r\n` as paragraph returns, as `frame.create` and `text.insert` already did. No readiness percentage change.
+- **2026-10-11** · Corner Options keep curved sides curved and round every corner point, including where an arc meets a line (a Pathfinder quarter circle with rounded corners stayed a triangle). No readiness percentage change.
+- **2026-10-11:** Type › Justification… (Cmd+Alt+Shift+J, also in the Paragraph panel menu) sets word and letter spacing, glyph scaling and the composer on the selected paragraphs, sharing the Paragraph Style Options section (#531). No readiness percentage change.
+- **2026-10-11** · Properties gains InDesign's Pathfinder section (Add, Subtract, Intersect, Exclude Overlap, Minus Back) with several objects selected; section titles and icon buttons have accessible names. No readiness percentage change.
- **2026-10-11** · `transform.move {copy}`, Edit › Duplicate and Step and Repeat return the copies' ids, so a script can go on with them. No readiness percentage change.
- **2026-10-11** · `object.fill` and `object.stroke` refuse a swatch name the document doesn't have (it painted nothing) and suggest the name meant (`Paper` → `[Paper]`). No readiness percentage change.
-- **2026-10-11 (printing):** `file.printers` and `file.print` use craft-libs/craft-print for CUPS and Windows. DesignCraft retains PDF export, page selection, spreads, marks and bleed; dry runs create no temporary PDF or print job. Windows selects matching or default driver paper and shrinks oversized sheets without enlarging smaller ones; queue duplex defaults are preserved. Headless tests exercise exported bytes, job settings, dry runs and refusals; shared native Windows CI passes, including paused-queue submission and cleanup. PostScript, production print controls and physical output validation remain open. No readiness percentage change.
-
+- **2026-10-11** · Japanese captions now cover print ranges, imported style handling and table
+ row/column movement, including row-height distribution. Existing translation and RTL helpers
+ handle the display; command IDs, stored option values and user-defined style names are unchanged.
+- **2026-10-11** · Moving a sheared and rotated text frame no longer leaves trails of text behind: canvas repaints cover the frame's whole text box, not just its outline. No readiness percentage change.
+- **2026-10-11** · Live corners: the yellow widget on a selected rectangle frame shows corner
+ diamonds; dragging one rounds the corners, Alt-click steps the corner shape (#186).
+- **2026-10-11** · Optical kerning (#181): pairs are spaced from their outlines (ink gap per band,
+ pulled towards the font's stem gap, bounded) instead of silently using the font's kern pairs.
+- **2026-10-11** · New Document laid out like InDesign's (#325): Recent, Saved, Print, Web and
+ Mobile preset tabs beside the preset's details; saved document presets live in the engine
+ (`file.savePreset`, `file.deletePreset`, `file.new {preset}`); `file.new` takes intent, units,
+ start page and per-edge bleed and slug.
+- **2026-10-11** · macOS: fonts that font services and managers activate (Adobe Fonts,
+ RightFont) are listed, read from the files CoreText has available (#261, #327).
+- **2026-10-11:** Document pages take their parent page's margins and columns (left or right parent page by side) and follow its changes unless they have their own; parent ruler guides draw and snap on the pages based on it. IDML import marks a page margin preference that differs from its parent as the page's own. No readiness percentage change.
+- **2026-10-11** · Document Setup laid out like InDesign's: Page Size, Margins (new: every
+ page's, `layout.documentSetup {margins}`), Bleed and Slug with links, Adjust Layout.
+- **2026-10-11** · IDML reads and writes a spread's view rotation (Rotate Spread) as the
+ rotation part of the spread transform (#484).
+- **2026-10-11** · The document grid is drawn (View ▸ Grids & Guides ▸ Show/Hide Document Grid,
+ ⌘'), on the lines Snap to Document Grid uses, behind or in front of page items (#530).
+- **2026-10-12** · Double-clicking the Fill or Stroke box in the Tools panel opens the Color Picker with the selection's colour, as in InDesign (it opened the Swatches panel). No readiness percentage change.
- **2026-10-10 (UI.4–UI.5):** Panel tabs can move into other groups, split the dock, float, resize and return to their saved locations through shared docking transactions. Layouts persist in custom workspaces; UI and control commands share the same validated action path. Shared pane geometry and widget-state theme application retain all five palettes and local fonts. Split panes send keyboard input only to the focused canvas and scope contextual toolbar IDs per pane. No readiness percentage change.
- **2026-10-10** · Version 0.6.0; releases add a Linux riscv64 tar.gz (cross-compiled, CLI
smoke-tested under QEMU).
diff --cc crates/ui-egui/src/dialogs.rs
index 6b5370713,639ad0897..b483a7d75
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@@ -2024,122 -1739,13 +2025,126 @@@ pub fn show(app: &mut DesignApp, ctx: &
}
}
+/// Cell Options keys (`table.getCellStroke` names) and whether each belongs to the stroke.
+const CELL_OPTION_KEYS: [(&str, bool); 8] =
+ [("weight", true), ("type", true), ("color", true), ("tint", true), ("gapColor", true), ("gapTint", true), ("fill", false), ("fillTint", false)];
+
+/// Table › Cell Options › Strokes and Fills… for the target cells. The fields start from the
+/// cells' values (`seed`); OK applies the fields that differ from it.
+pub fn open_cell_options(app: &mut DesignApp) -> Result<Value, String> {
+ let edges = crate::panels::cell_stroke::edges_param(&[true; 6]);
+ let cur = app.session.execute("table.getCellStroke", &json!({"edges": edges})).map_err(|e| e.to_string())?;
+ let mut fields = Map::new();
+ for (k, _) in CELL_OPTION_KEYS {
+ fields.insert(k.into(), cur[k].clone());
+ }
+ fields.insert("seed".into(), Value::Object(fields.clone()));
+ fields.insert("edges".into(), edges);
+ app.ui.dialog = Some(Dialog::new("cellOptions", Value::Object(fields)));
+ Ok(Value::Null)
+}
+
+/// Cell Options › Strokes and Fills: the edge proxy and stroke fields, then the cell fill.
+fn cell_options(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {
+ use crate::panels::cell_stroke;
+ let lang = app.ui.language.clone();
+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&lang, "Cell Stroke")).font(semibold(12.0)));
+ let mut edges = cell_stroke::edges_from(d.fields.get("edges").unwrap_or(&Value::Null));
+ if cell_stroke::edge_proxy(ui, "cell_options", &mut edges, &lang) {
+ cell_options_edges_changed(app, d, &edges);
+ }
+ ui.add_space(6.0);
+ let values = Value::Object(d.fields.clone());
+ let any = edges.iter().any(|on| *on);
+ if let Some((k, v)) = ui.add_enabled_ui(any, |ui| cell_stroke::stroke_fields(app, ui, "cell_options", &values)).inner {
+ d.fields.insert(k.into(), v);
+ }
+ ui.add_space(10.0);
+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&lang, "Cell Fill")).font(semibold(12.0)));
+ egui::Grid::new("cell_fill").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {
+ crate::rtl::label(ui, crate::i18n::tr(&lang, "Color:"));
+ let mut picked = None;
+ crate::panels::swatch_picker(app, ui, "cell_fill_color", values["fill"].as_str().map(str::to_string), |_, n| picked = Some(n));
+ if let Some(n) = picked {
+ d.fields.insert("fill".into(), json!(n));
+ }
+ ui.end_row();
+ crate::rtl::label(ui, crate::i18n::tr(&lang, "Tint:"));
+ let tint = values["fillTint"].as_f64().map(|t| (t * 100.0).round());
+ if let Some(t) = crate::widgets::NumField::number("cell_fill_tint", tint, "%", 0).width(60.0).range(0.0, 100.0).show(ui) {
+ d.fields.insert("fillTint".into(), json!(t / 100.0));
+ }
+ ui.end_row();
+ });
+}
+
+/// Cell Options with a new edge choice: the stroke fields the user hasn't changed show the
+/// chosen edges' values, and every stroke field's seed becomes those values, so OK applies
+/// exactly the fields that differ from what the chosen edges show.
+fn cell_options_edges_changed(app: &mut DesignApp, d: &mut Dialog, edges: &crate::panels::cell_stroke::Edges) {
+ d.fields.insert("edges".into(), crate::panels::cell_stroke::edges_param(edges));
+ let cur = crate::panels::cell_stroke::current(app, edges);
+ let mut seed = d.fields.get("seed").and_then(Value::as_object).cloned().unwrap_or_default();
+ for (k, stroke) in CELL_OPTION_KEYS {
+ if !stroke {
+ continue;
+ }
+ let v = cur.get(k).cloned().unwrap_or(Value::Null);
+ // Null shows mixed values; the user can't type it.
+ let field = d.fields.get(k).filter(|f| !f.is_null());
+ if field.is_none() || field == seed.get(k) {
+ d.fields.insert(k.into(), v.clone());
+ }
+ seed.insert(k.into(), v);
+ }
+ d.fields.insert("seed".into(), Value::Object(seed));
+}
+
+/// Apply the Cell Options fields that differ from the cells' values, as one `table.setCell`.
+fn confirm_cell_options(app: &mut DesignApp, d: &Dialog) -> Result<Value, String> {
+ let seed = d.fields.get("seed").cloned().unwrap_or(Value::Null);
+ let mut stroke = Map::new();
+ let mut params = Map::new();
+ for (k, is_stroke) in CELL_OPTION_KEYS {
+ let Some(v) = d.fields.get(k).filter(|v| !v.is_null() && seed.get(k) != Some(*v)) else { continue };
+ match (is_stroke, k) {
+ (true, _) => {
+ stroke.insert(k.into(), v.clone());
+ }
+ (false, "fillTint") => {
+ params.insert("tint".into(), v.clone());
+ }
+ _ => {
+ params.insert(k.into(), v.clone());
+ }
+ }
+ }
+ if !stroke.is_empty() {
+ stroke.insert("edges".into(), d.fields.get("edges").cloned().unwrap_or(json!("all")));
+ params.insert("stroke".into(), Value::Object(stroke));
+ }
+ if params.is_empty() {
+ return Ok(Value::Null);
+ }
+ app.run("table.setCell", Value::Object(params))
+}
+
- /// Close the open dialog without applying it. Preferences also puts back the interface language
- /// it opened with, since choosing one previews it at once.
+ /// Close the open dialog without applying it (Cancel, Esc, the control channel): a previewing
-/// dialog puts the document back as it was.
++/// dialog puts the document back as it was, and Preferences puts back the interface language it
++/// opened with, since choosing one previews it at once.
pub fn cancel(app: &mut DesignApp) {
- if app.ui.dialog.take().is_some_and(|d| d.fields.contains_key(PREVIEWED)) {
+ let d = app.ui.dialog.take();
++ if d.as_ref().is_some_and(|d| d.fields.contains_key(PREVIEWED)) {
+ app.session.cancel_interaction();
+ }
app.cancel_pdf_import();
+ if let Some(d) = d
+ && d.id == "preferences"
+ && let Some(lang) = d.fields.get("openedLanguage").and_then(Value::as_str)
+ && lang != app.ui.language
+ {
+ let _ = app.run("app.language", json!({"lang": lang}));
+ }
}
/// Apply the open dialog.
@@@ -4494,1431 -3576,379 +4513,1620 @@@ 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";
+/// 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();
+ });
+}
-/// 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 {
- 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);
+fn delete_character_style(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {
+ let name = d.s("name");
+ ui.set_min_width(380.0);
+ crate::rtl::label(
+ ui,
+ egui::RichText::new(
+ crate::i18n::tr(&app.ui.language, "Delete the character style \"{name}\"?")
+ .replace("{name}", crate::i18n::style_name(&app.ui.language, &name)),
+ )
+ .size(12.5),
+ );
+ ui.add_space(8.0);
+ let Some(st) = app.session.active() else { return };
+ let in_use = st.doc.stories.values().any(|s| s.chars.iter().any(|r| r.format.style == name));
+ let names: Vec<String> = st.doc.styles.character.iter().map(|c| c.name.clone()).filter(|n| *n != name).collect();
+ if in_use {
+ crate::rtl::label(
+ ui,
+ egui::RichText::new(crate::i18n::tr(&app.ui.language, "This style is in use. Text using it will be reassigned to:"))
+ .size(11.0)
+ .color(crate::theme::Tokens::get(ui.ctx()).text_dim),
+ );
+ } else {
+ crate::rtl::label(
+ ui,
+ egui::RichText::new(crate::i18n::tr(&app.ui.language, "Replace with:")).size(11.0).color(crate::theme::Tokens::get(ui.ctx()).text_dim),
+ );
+ }
+ ui.add_space(4.0);
+ if !d.fields.contains_key("replaceWith") {
+ d.fields.insert("replaceWith".into(), json!(designcraft_doc::NO_CHAR_STYLE));
+ }
+ let replace = d.s("replaceWith");
+ egui::ComboBox::from_id_salt("del_char_replace")
+ .selected_text(crate::rtl::widget(ui, crate::i18n::style_name(&app.ui.language, &replace)))
+ .width(260.0)
+ .show_ui(ui, |ui| {
+ for n in [designcraft_doc::NO_CHAR_STYLE].into_iter().chain(names.iter().map(String::as_str)) {
+ if ui.selectable_label(n == replace, crate::rtl::widget(ui, crate::i18n::style_name(&app.ui.language, n))).clicked() {
+ d.fields.insert("replaceWith".into(), json!(n));
}
- });
+ }
});
- 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")]);
+ let shown = RULES.iter().find(|r| r.0 == which).map_or(which, |r| r.1);
+ egui::ComboBox::from_id_salt("rule_which").selected_text(crate::rtl::widget(ui, crate::i18n::tr(lang, shown))).width(130.0).show_ui(
+ ui,
+ |ui| {
+ for (v, label) in RULES {
+ if ui.selectable_label(v == which, crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() {
+ d.fields.insert("rule".into(), json!(v));
+ }
+ }
+ },
+ );
+ ui.add_space(12.0);
+ let mut on = rule["on"].as_bool().unwrap_or(false);
+ if ui.checkbox(&mut on, crate::rtl::widget(ui, crate::i18n::tr(lang, "Rule On"))).changed() {
+ d.fields.insert(key("on"), json!(on));
+ }
});
ui.add_space(6.0);
- let 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 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));
}
}
- 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),
- ));
+ ui.end_row();
+ });
+ });
+}
+
+/// Document Footnote Options: Numbering and Formatting / Layout tabs.
+fn footnote_options(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {
+ ui.horizontal(|ui| {
+ for (tab, label) in [("numbering", "Numbering and Formatting"), ("layout", "Layout")] {
+ if ui.selectable_label(d.s("tab") == tab, crate::rtl::widget(ui, crate::i18n::tr(&app.ui.language, label))).clicked() {
+ d.fields.insert("tab".into(), json!(tab));
}
+ }
+ });
+ ui.separator();
+ let head = |ui: &mut egui::Ui, t: &str| {
+ ui.add_space(4.0);
+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, t)).font(semibold(12.0)));
+ };
+ if d.s("tab") == "layout" {
+ head(ui, "Spacing Options");
+ egui::Grid::new("fn_sp").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {
+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Minimum Space Before First Footnote:"));
+ text_field(ui, d, "spaceBefore", 70.0);
+ ui.end_row();
+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Space Between Footnotes:"));
+ text_field(ui, d, "spaceBetween", 70.0);
+ ui.end_row();
});
- } 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));
- }
- }
- }
- })
- });
+ 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;
}
- 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);
+ 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();
});
- if let Some(m) = d.fields.get("status").and_then(Value::as_str) {
- ui.label(egui::RichText::new(m).color(dim));
- }
}
-/// Color Picker: saturation/brightness field and hue slider, with RGB, CMYK and hex fields.
-fn color_picker(ui: &mut egui::Ui, d: &mut Dialog) {
- let hex = d.s("hex");
- let mut c = designcraft_color::Color::from_hex(&hex).map(|c| c.to_rgb()).map_or(egui::Color32::BLACK, |[r, g, b]| {
- egui::Color32::from_rgb((r * 255.0).round() as u8, (g * 255.0).round() as u8, (b * 255.0).round() as u8)
- });
- let before = c;
- ui.horizontal_top(|ui| {
- egui::color_picker::color_picker_color32(ui, &mut c, egui::color_picker::Alpha::Opaque);
- ui.vertical(|ui| {
- let mut rgb = [c.r() as f32, c.g() as f32, c.b() as f32];
- egui::Grid::new("cp_rgb").num_columns(2).spacing([6.0, 4.0]).show(ui, |ui| {
- for (k, l) in ["R", "G", "B"].iter().enumerate() {
- ui.label(*l);
- ui.add(egui::DragValue::new(&mut rgb[k]).range(0.0..=255.0));
- ui.end_row();
- }
- });
- c = egui::Color32::from_rgb(rgb[0] as u8, rgb[1] as u8, rgb[2] as u8);
- let col = designcraft_color::Color::rgb8(c.r(), c.g(), c.b());
- let [cc, m, y, k] = col.to_cmyk();
- ui.add_space(6.0);
- ui.label(format!("C {:.0}% M {:.0}% Y {:.0}% K {:.0}%", cc * 100.0, m * 100.0, y * 100.0, k * 100.0));
- ui.add_space(6.0);
- ui.horizontal(|ui| {
- ui.label("#");
- let mut h = format!("{:02x}{:02x}{:02x}", c.r(), c.g(), c.b());
- if ui.add(egui::TextEdit::singleline(&mut h).desired_width(70.0)).changed()
- && let Some(n) = designcraft_color::Color::from_hex(&h)
- {
- let [r, g, b] = n.to_rgb();
- c = egui::Color32::from_rgb((r * 255.0).round() as u8, (g * 255.0).round() as u8, (b * 255.0).round() as u8);
+/// 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 {
++ 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(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));
+ }
+}
+
+/// Color Picker: saturation/brightness field and hue slider, with RGB, CMYK and hex fields.
+fn color_picker(ui: &mut egui::Ui, d: &mut Dialog) {
+ let hex = d.s("hex");
+ let mut c = designcraft_color::Color::from_hex(&hex).map(|c| c.to_rgb()).map_or(egui::Color32::BLACK, |[r, g, b]| {
+ egui::Color32::from_rgb((r * 255.0).round() as u8, (g * 255.0).round() as u8, (b * 255.0).round() as u8)
+ });
+ let before = c;
+ ui.horizontal_top(|ui| {
+ egui::color_picker::color_picker_color32(ui, &mut c, egui::color_picker::Alpha::Opaque);
+ ui.vertical(|ui| {
+ let mut rgb = [c.r() as f32, c.g() as f32, c.b() as f32];
+ egui::Grid::new("cp_rgb").num_columns(2).spacing([6.0, 4.0]).show(ui, |ui| {
+ for (k, l) in ["R", "G", "B"].iter().enumerate() {
+ ui.label(*l);
+ ui.add(egui::DragValue::new(&mut rgb[k]).range(0.0..=255.0));
+ ui.end_row();
+ }
+ });
+ c = egui::Color32::from_rgb(rgb[0] as u8, rgb[1] as u8, rgb[2] as u8);
+ let col = designcraft_color::Color::rgb8(c.r(), c.g(), c.b());
+ let [cc, m, y, k] = col.to_cmyk();
+ ui.add_space(6.0);
+ ui.label(format!("C {:.0}% M {:.0}% Y {:.0}% K {:.0}%", cc * 100.0, m * 100.0, y * 100.0, k * 100.0));
+ ui.add_space(6.0);
+ ui.horizontal(|ui| {
+ ui.label("#");
+ let mut h = format!("{:02x}{:02x}{:02x}", c.r(), c.g(), c.b());
+ if ui.add(egui::TextEdit::singleline(&mut h).desired_width(70.0)).changed()
+ && let Some(n) = designcraft_color::Color::from_hex(&h)
+ {
+ let [r, g, b] = n.to_rgb();
+ c = egui::Color32::from_rgb((r * 255.0).round() as u8, (g * 255.0).round() as u8, (b * 255.0).round() as u8);
+ }
+ });
+ });
+ });
+ if c != before {
+ d.fields.insert("hex".into(), json!(format!("#{:02x}{:02x}{:02x}", c.r(), c.g(), c.b())));
+ }
+}
+
+/// Find/Replace Font: the document's fonts (missing ones first, flagged) and a replacement.
+/// Load Styles: a checkbox for each style of the picked file, and what happens to a style this
+/// document defines differently under the same name.
+fn load_styles(app: &DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {
+ let lang = app.ui.language.as_str();
+ let dim = crate::theme::Tokens::get(ui.ctx()).text_dim;
+ ui.label(egui::RichText::new(d.s("path")).size(10.5));
+ ui.horizontal(|ui| {
+ for (label, on) in [("Select All", true), ("Deselect All", false)] {
+ if ui.button(crate::rtl::widget(ui, crate::i18n::tr(lang, label))).clicked() {
+ for key in ["paragraph", "character"] {
+ for row in d.fields.get_mut(key).and_then(Value::as_array_mut).into_iter().flatten().filter_map(Value::as_object_mut) {
+ row.insert("on".into(), json!(on));
+ }
+ }
+ }
+ }
+ });
+ let mut conflicts = 0;
+ egui::ScrollArea::vertical().id_salt("load_styles").max_height(240.0).show(ui, |ui| {
+ for (key, title) in [("paragraph", "Paragraph Styles"), ("character", "Character Styles")] {
+ let Some(rows) = d.fields.get_mut(key).and_then(Value::as_array_mut).filter(|rows| !rows.is_empty()) else { continue };
+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(lang, title)).font(semibold(12.0)));
+ for row in rows.iter_mut().filter_map(Value::as_object_mut) {
+ let Some(name) = row.get("name").and_then(Value::as_str).map(str::to_string) else { continue };
+ let (mut on, conflict) = (row.get("on") != Some(&json!(false)), row.get("conflict") == Some(&json!(true)));
+ ui.horizontal(|ui| {
+ if ui.checkbox(&mut on, crate::rtl::widget(ui, crate::i18n::style_name(lang, &name))).changed() {
+ row.insert("on".into(), json!(on));
+ }
+ if conflict {
+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(lang, "Differs from this document")).size(10.5).color(dim));
+ }
+ });
+ conflicts += usize::from(on && conflict);
+ }
+ }
+ });
+ ui.add_space(4.0);
+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(lang, "Style Name Conflicts")).font(semibold(12.0)));
+ if conflicts == 0 {
+ crate::rtl::label(ui, crate::i18n::tr(lang, "No conflicts"));
+ return;
+ }
+ let cur = d.s("conflicts");
+ ui.horizontal(|ui| {
+ for (v, l) in [("redefine", "Redefine Document Style"), ("useExisting", "Use Document Style Definition"), ("autoRename", "Auto Rename")] {
+ if ui.radio(cur == v, crate::rtl::widget(ui, crate::i18n::tr(lang, l))).clicked() {
+ d.fields.insert("conflicts".into(), json!(v));
+ }
+ }
+ });
+}
+
+fn find_font(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {
+ // Listed once when the dialog opens (it scans every story).
+ if !d.fields.contains_key("_fonts") {
+ let list = app.session.execute("font.list", &json!({})).unwrap_or_default();
+ d.fields.insert("_fonts".into(), list);
+ }
+ let fonts = d.fields.get("_fonts").and_then(Value::as_array).cloned().unwrap_or_default();
+ if !fonts.iter().any(|font| font["family"] == d.s("family") && font["style"] == d.s("style"))
+ && let Some(font) = fonts.first()
+ {
+ d.fields.insert("family".into(), font["family"].clone());
+ d.fields.insert("style".into(), font["style"].clone());
+ }
+ if d.b("onOpen") && fonts.iter().any(|f| f["missing"] == true || f["styleMissing"] == true) {
+ crate::rtl::label(
+ ui,
+ crate::i18n::tr(
+ &app.ui.language,
+ "This document uses unavailable fonts. Choose replacements, or select Done to continue with fallback fonts.",
+ ),
+ );
+ }
+ if !d.s("error").is_empty() {
+ crate::rtl::label(ui, d.s("error"));
+ }
+ let missing = fonts.iter().filter(|f| f["missing"] == true || f["styleMissing"] == true).count();
+ crate::rtl::label(
+ ui,
+ crate::i18n::tr(&app.ui.language, "Fonts in Document: {count} Missing: {missing}")
+ .replace("{count}", &fonts.len().to_string())
+ .replace("{missing}", &missing.to_string()),
+ );
+ egui::ScrollArea::vertical().id_salt("ff_list").max_height(180.0).show(ui, |ui| {
+ for f in &fonts {
+ let (fam, st) = (f["family"].as_str().unwrap_or(""), f["style"].as_str().unwrap_or(""));
+ let warn = f["missing"] == true || f["styleMissing"] == true;
+ let label = format!("{}{fam} {st}", if warn { "\u{26A0} " } else { "" });
+ let on = d.s("family") == fam && d.s("style") == st;
+ let mut text = egui::RichText::new(label);
+ if warn && !on {
+ text = text.color(crate::theme::Tokens::get(ui.ctx()).text_strong);
+ }
+ if ui.selectable_label(on, text).clicked() {
+ d.fields.insert("family".into(), json!(fam));
+ d.fields.insert("style".into(), json!(st));
+ }
+ }
+ });
+ let key = format!("{}\n{}", d.s("family"), d.s("style"));
+ if let Some(font) = fonts.iter().find(|f| f["family"] == d.s("family") && f["style"] == d.s("style")) {
+ if d.s("_fontKey") != key {
+ d.fields.insert("_fontKey".into(), json!(key));
+ d.fields.insert("toFamily".into(), font["replacementFamily"].clone());
+ d.fields.insert("toStyle".into(), font["replacementStyle"].clone());
+ }
+ crate::rtl::label(
+ ui,
+ format!(
+ "{}: {} {}",
+ crate::i18n::tr(&app.ui.language, "Currently Rendered With"),
+ font["resolvedFamily"].as_str().unwrap_or(""),
+ font["resolvedStyle"].as_str().unwrap_or("")
+ ),
+ );
+ }
+ ui.add_space(8.0);
+ crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Replace With")).font(semibold(12.0)));
+ let db = crate::panels::fonts(app);
+ if d.s("toFamily").is_empty() {
+ d.fields.insert("toFamily".into(), json!(designcraft_fonts::FALLBACK_FAMILY));
+ }
+ egui::Grid::new("ff_to").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {
+ crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Family:"));
+ if let Some(f) = crate::panels::font_combo(app, ui, "toFamily", &d.s("toFamily"), 170.0) {
+ d.fields.insert("toFamily".into(), json!(f));
+ }
+ 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 numbering_and_section_options_keep_their_actions_in_view() {
+ for language in ["en", "ar"] {
+ for size in [egui::vec2(1178.0, 814.0), egui::vec2(392.0, 271.0)] {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.ui.language = language.into();
+ app.run("file.new", json!({"pages": 2})).unwrap();
+ crate::menus::activate(&mut app, "layout.section", &Value::Null);
+ let ctx = dialog_context(language);
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, size);
+ for _ in 0..3 {
+ dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ let tr = |s| crate::i18n::tr(language, s);
+ for expected in [tr("Numbering & Section Options…").trim_end_matches('…'), tr("OK"), tr("Cancel"), tr("Start Section")] {
+ visible_label(&labels, screen, expected);
+ }
+ if size.x > 1000.0 {
+ // Every option fits without scrolling, and choosing one then OK applies it.
+ visible_label(&labels, screen, &format!("{} {}", tr("Book Name:"), tr("N/A")));
+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, tr("Automatic Page Numbering")).center());
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, tr("OK")).center());
+ assert!(app.ui.dialog.is_none(), "{language}: OK closes the dialog");
+ let doc = &app.session.active().unwrap().doc;
+ assert!(doc.sections.iter().all(|s| s.start != 0 || s.start_number.is_none()), "{language}: page 1 numbers automatically");
+ }
+ }
+ }
+ }
+
+ fn draw(app: &mut DesignApp, ctx: &egui::Context) {
+ let input =
+ egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1400.0, 900.0))), ..Default::default() };
+ let mut out = ctx.run_ui(input, |ui| {
+ app.logic(&ui.ctx().clone());
+ app.ui(ui);
+ });
+ out.textures_delta.clear();
+ }
+
+ /// A paragraph styled "Ruled Child", whose Rule Below comes from its parent "Ruled".
+ fn ruled_paragraph() -> (DesignApp, Value) {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let rule = json!({"on": true, "weight": 3.0, "color": "[Black]", "tint": 0.5, "columnWidth": false, "offset": 4.0, "leftIndent": 6.0, "rightIndent": 2.0});
+ app.run("style.paragraph.create", json!({"name": "Ruled", "para": {"ruleBelow": rule}})).unwrap();
+ app.run("style.paragraph.create", json!({"name": "Ruled Child", "basedOn": "Ruled"})).unwrap();
+ let r = app.run("frame.create", json!({"rect": [72, 72, 300, 400], "content": "text", "text": "One"})).unwrap();
+ app.run("text.select", json!({"story": r["story"], "anchor": 0, "focus": 0})).unwrap();
+ app.run("style.paragraph.apply", json!({"name": "Ruled Child"})).unwrap();
+ (app, rule)
+ }
+
+ fn undo_steps(app: &DesignApp) -> usize {
+ app.session.doc().map_or(0, |st| st.history.undo.len())
+ }
+
+ #[test]
+ fn paragraph_rules_dialog_shows_the_rule_and_applies_one_field() {
+ let (mut app, rule) = ruled_paragraph();
+ let ctx = egui::Context::default();
+ app.run("app.paragraphRulesDialog", json!({"rule": "ruleBelow"})).unwrap();
+ draw(&mut app, &ctx);
+ let d = app.ui.dialog.clone().unwrap();
+ assert_eq!(d.id, "paragraphRules");
+ let current = d.fields["current"].clone();
+ assert_eq!(shown_rule(&d, "", "ruleBelow", &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);
});
- });
- if c != before {
- d.fields.insert("hex".into(), json!(format!("#{:02x}{:02x}{:02x}", c.r(), c.g(), c.b())));
+ 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());
}
-}
-/// 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 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");
+ }
}
- 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));
+
+ fn command_app(id: &str, fields: Value) -> DesignApp {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.ui.dialog = Some(Dialog::new(&format!("cmd:{id}"), fields));
+ app
+ }
+
+ #[test]
+ fn generic_new_document_preserves_typed_values_and_text_entry() {
+ for pages in [json!(2), json!(" 2 ")] {
+ let mut app = command_app(
+ "file.new",
+ json!({
+ "preset": "A4", "pages": pages, "facingPages": false, "gutter": 0,
+ "margins": {"top": 10, "bottom": 20, "inside": 30, "outside": 40},
+ "title": " ", "status": "internal", "primaryTextFrame": true
+ }),
+ );
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ assert_eq!(doc.page_count(), 2);
+ assert!(!doc.settings.facing_pages);
+ assert!(doc.title.starts_with("Untitled-"));
+ for page in doc.spreads.iter().flat_map(|s| &s.pages) {
+ assert!((page.width - 595.2755905511812).abs() < 0.01);
+ assert!((page.height - 841.8897637795277).abs() < 0.01);
+ assert_eq!(page.columns.gutter, 0.0);
+ assert_eq!(page.margins.top, 10.0);
+ assert_eq!(page.margins.outside, 40.0);
}
+ assert!(doc.spreads.iter().all(|s| s.items.is_empty()), "undocumented fields stay excluded");
+ assert!(app.ui.dialog.is_none());
}
- });
- ui.add_space(8.0);
- crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "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 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"]);
+ }
+
+ #[test]
+ fn generic_command_preserves_array_geometry() {
+ let mut app = command_app("file.new", json!({}));
+ confirm(&mut app).unwrap();
+ app.ui.dialog = Some(Dialog::new("cmd:frame.create", json!({"rect": [10, 20, 110, 220]})));
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ let item = doc.spreads.iter().flat_map(|s| &s.items).next().unwrap();
+ assert_eq!(item.bounds(), designcraft_geom::Rect::new(10.0, 20.0, 110.0, 220.0));
+ }
+
+ #[test]
+ fn generic_explicit_null_uses_the_commands_existing_semantics() {
+ // file.new accepts null width by using the selected preset's width.
+ for width in [Value::Null, json!("null")] {
+ let mut app = command_app("file.new", json!({"preset": "A4", "width": width, "title": " Sample layout "}));
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ assert_eq!(doc.title, "Sample layout");
+ assert!((doc.settings.page_width - 595.2755905511812).abs() < 0.01);
}
- 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]);
+ // An unknown swatch is an error and the dialog stays open.
+ let e = open(&mut app, &[("columnRuleColor", json!("Mauve"))]).unwrap_err();
+ assert!(e.contains("Mauve") && app.ui.dialog.is_some(), "{e}");
+ assert_eq!(opts(&app).column_rule_color, designcraft_color::swatch::BLACK);
+ // Each OK is one undo step.
+ for _ in 0..3 {
+ app.run("edit.undo", json!({})).unwrap();
}
- // 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 {