DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
M7: footnotes — Insert Footnote, Document Footnote Options, column-bottom layout, PDF/IDML; generic command dialogs
Brandon Thomas3ad71d5a764f
diff --git a/ROADMAP.md b/ROADMAP.mdindex 9efad47df..2fd501ff1 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -17,13 +17,14 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope- Hyperlinks (text or frames → URL / e-mail / page) and bookmarks, exported as PDF link annotations and outline.- EPUB 3 (reflowable) export: stories in reading order, CSS from paragraph/character styles, images, navigation (`file.exportEpub`, CLI `--export x.epub`).- Data Merge (CSV or JSON rows, `<<Field>>` placeholders), spell checking (public-domain Moby list + document dictionary, suggestions), Step and Repeat (count or grid), snippets, object styles, Numbering & Section Options.+- Footnotes: Type › Insert Footnote (caret moves into the note), Document Footnote Options (numbering style incl. symbols, start/restart per page/spread/section, prefix/suffix, reference position/character style, paragraph style, separator, spacing, first baseline, rule above); notes composed at the bottom of the referencing column with the body text making room; edited in place on the canvas; rendered, exported to PDF (real text) and IDML (InDesign's structure, verified opening in InDesign 2026) and imported from IDML; `footnote.*` commands.- Table of contents (generate/update, dot leaders) and text variables (running headers, last page number, chapter number, file name, dates, custom) resolved per page.- Soft effects: blurred drop shadow, inner shadow, outer glow, basic feather.- ~200 commands, all reachable through the JSON control channel; headless CLI rendering to PNG.- MCP server (`designcraft-cli mcp [--connect PORT]`, docs/mcp.md): headless engine or the running app; commands, batch, document/story inspection, page renders as images, window screenshots, pointer/keyboard/dialog input.- Web build (`apps/designcraft-web`, trunk): the same UI on WebGPU with a WebGL2 fallback; open/place via the browser file picker or drag-and-drop, save/export as downloads.-**Next (in order):** footnotes, cross-references, index · table/cell styles, text rotation in cells · PDF/X-4 output intent, tagged PDF · Links panel + relink · UI for Data Merge/spelling/hyperlinks.+**Next (in order):** cross-references, index, footnotes in EPUB / span columns / split footnotes · table/cell styles, text rotation in cells · PDF/X-4 output intent, tagged PDF · Links panel + relink · UI for Data Merge/spelling/hyperlinks.## Milestones@@ -36,7 +37,7 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope| M4 | Color & effects | started || M5 | Graphics & links | started || M6 | Files & export (native, IDML, PDF, PNG/JPEG) | in progress (IDML ✅, PDF export) |-| M7 | Long documents (sections, TOC, index, footnotes, books) | in progress (sections, TOC, text variables/running heads, hyperlinks, bookmarks) |+| M7 | Long documents (sections, TOC, index, footnotes, books) | in progress (sections, TOC, text variables/running heads, hyperlinks, bookmarks, footnotes) || M8 | Tables | ✅ core (table/cell styles, rotation, diagonal lines pending) || M9 | Performance (MT composition, tiles) | in progress (glyph path cache, culling, parallel compose 6.7× faster, perf harness) || M10 | Find/Change, spelling, Preflight | in progress (Find/Change ✅, spelling ✅, Preflight) |diff --git a/apps/designcraft/src/native_menu.rs b/apps/designcraft/src/native_menu.rsindex 625087e00..803ce4c45 100644--- a/apps/designcraft/src/native_menu.rs+++ b/apps/designcraft/src/native_menu.rs@@ -75,8 +75,7 @@ impl NativeMenu {pub fn poll(&mut self, app: &mut DesignApp) {while let Ok(ev) = MenuEvent::receiver().try_recv() {if let Some((cmd, params, _)) = self.items.get(ev.id.as_ref()) {- let p = if params.is_null() { serde_json::json!({}) } else { params.clone() };- let _ = app.run(cmd, p);+ designcraft_ui_egui::menus::activate(app, &cmd.clone(), ¶ms.clone());}}let now = designcraft_ui_egui::now_ms();diff --git a/crates/compose/src/cache.rs b/crates/compose/src/cache.rsindex e88d32b0c..4171d2aa2 100644--- a/crates/compose/src/cache.rs+++ b/crates/compose/src/cache.rs@@ -68,6 +68,13 @@ impl Cache {sig.push(doc_signature(doc) as usize);}}+ if !story.notes.is_empty() {+ // Footnote numbers continue from earlier stories; layout follows the options.+ use std::hash::{Hash, Hasher};+ let mut h = std::collections::hash_map::DefaultHasher::new();+ format!("{:?}", doc.footnote_options).hash(&mut h);+ sig.extend([doc.footnote_start(sid) as usize, h.finish() as usize]);+ }{let mut g = self.map.lock().unwrap_or_else(|e| e.into_inner());g.1 += 1;@@ -85,7 +92,7 @@ impl Cache {_ => None,};let running = running.then(|| self.running_index(doc));- let out = Arc::new(crate::compose_story(doc, sid, &ComposeOptions { page_name: page_name.map(str::to_string), page, running }));+ let out = Arc::new(crate::compose_story(doc, sid, &ComposeOptions { page_name: page_name.map(str::to_string), page, running, label: None }));let mut g = self.map.lock().unwrap_or_else(|e| e.into_inner());let stamp = g.1;if g.0.len() > 4096 {diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rsindex 819e55eb9..22f05c3e5 100644--- a/crates/compose/src/lib.rs+++ b/crates/compose/src/lib.rs@@ -12,13 +12,14 @@pub mod breaker;mod cache;pub mod hyphen;+mod notes;pub mod shape;pub mod table;pub mod vars;use std::collections::HashMap;use std::ops::Range;-use std::sync::Mutex;+use std::sync::{Arc, Mutex};use designcraft_doc::{Align, Composer, Document, FirstBaseline, GridAlign, ItemId, ParaProps, SpanColumns, StartParagraph, Story, StoryId, TabAlign, TextFrameOptions,@@ -29,6 +30,8 @@ use designcraft_geom::{Point, Rect};use crate::breaker::{Break, Spacing};pub use crate::cache::Cache;+use crate::notes::Notes;+pub use crate::notes::{find_note, hit_note, note_caret};use crate::shape::{Glyph, StyleTable, SubstCtx};pub use crate::table::{PlacedCell, StrokeSeg, TableFrag, cell_caret, find_cell, hit_cell};@@ -108,6 +111,26 @@ pub struct FrameText {pub content_height: f64,/// Table fragments placed in this frame (each also has a glyph-less line in `lines`).pub tables: Vec<TableFrag>,+ /// Footnotes placed at the bottom of this frame's columns.+ pub notes: Vec<PlacedNote>,+}++/// A footnote composed at the bottom of a column.+#[derive(Clone, Debug)]+pub struct PlacedNote {+ /// Footnote id (in the story's [`Story::notes`]) and its index there.+ pub id: u64,+ pub index: usize,+ pub column: u32,+ /// The number shown.+ pub label: String,+ /// Where the footnote's composed text (its frame 0) sits in the frame.+ pub origin: Point,+ /// Area of the footnote in frame inner space.+ pub rect: Rect,+ pub text: Arc<ComposedStory>,+ /// The footnote's story text (exporters map glyphs back to text).+ pub source: Arc<str>,}#[derive(Clone, Debug, Default)]@@ -183,6 +206,8 @@ pub struct ComposeOptions {pub page: Option<usize>,/// Running-header index (needed when the story contains running-header variables).pub running: Option<std::sync::Arc<vars::RunningIndex>>,+ /// Generated text before the first paragraph (a footnote's number and separator).+ pub label: Option<String>,}/// Build the frame specs of a story from the document (geometry, wrap, page names, grid).@@ -269,12 +294,16 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compolet mut restores = 0usize;let mut pi = 0;let var_story = vars::has_vars(story);+ let mut notes = Notes::new(doc, story);+ let mut note_snaps: Vec<(u32, Option<usize>, usize)> = Vec::with_capacity(np);let mut var_cache: std::collections::HashMap<Option<usize>, std::sync::Arc<Vec<String>>> = Default::default();'paras: while pi < np {let prange = para_ranges[pi].clone();let snap = Snapshot::take(&out, &cur, list_counter);snaps.truncate(pi);snaps.push(snap);+ note_snaps.truncate(pi);+ note_snaps.push((notes.num, notes.key, notes.placed.len()));info.truncate(pi);let pf = &story.paras[pi];let (pp, base_chars) = doc.styles.resolve_para(pf);@@ -320,11 +349,15 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compo} else {Default::default()};- let sub = SubstCtx {+ let mut sub = SubstCtx {page_name: opts.page_name.clone().or_else(|| cur_frame.and_then(|f| f.page_name.clone())),section_marker: None,vars: var_values,+ ..Default::default()};+ if notes.active() {+ notes.number_refs(doc, prange.clone(), cur_frame.and_then(|f| f.page), &mut sub);+ }let mut table = StyleTable { styles: &mut styles_tab };let mut sp = shape::shape_para(db, &doc.styles, story, pi, prange.clone(), &base_chars, pp.auto_leading, &sub, &mut table);match pp.list_type {@@ -339,6 +372,11 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compo}designcraft_doc::ListType::None => list_counter = 0,}+ if pi == 0+ && let Some(label) = &opts.label+ {+ prepend_label(db, &mut sp.glyphs, label, prange.start, &base_chars, &pp, &mut table);+ }let mut glyphs = sp.glyphs;apply_desired_spacing(&mut glyphs, &pp);let hyph_after = hyphenation_points(&story.text, &glyphs, &pp);@@ -438,7 +476,13 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compo}}let capped = line_cap[pi] == Some(line_no) && line_no > col_first_line;- let fits = baseline + desc <= col.y1 + 0.01 && !capped;+ // Footnotes referenced on this line need room at the bottom of the column too+ // (a line at the top of a column is set anyway).+ let line_notes = if notes.active() { notes.refs_in(line_glyphs) } else { Vec::new() };+ let col_w = cols[cur.fi][cur.col.min(cols[cur.fi].len() - 1)].width();+ let reserve = notes.reserve(doc, cur.fi, cur.col, &line_notes, col_w, f, opts);+ let reserve = if cur.last_baseline.is_none() { notes.reserve(doc, cur.fi, cur.col, &[], col_w, f, opts) } else { reserve };+ let fits = baseline + desc <= col.y1 - reserve + 0.01 && !capped;if !fits {if !capped {let ctx = KeepCtx {@@ -468,6 +512,8 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compoline_cap[k] = None;}snaps[j].restore(&mut out, &mut cur, &mut list_counter);+ (notes.num, notes.key) = (note_snaps[j].0, note_snaps[j].1);+ notes.placed.truncate(note_snaps[j].2);pi = j;continue 'paras;}@@ -509,6 +555,9 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compoend_x,spacing: ratio,});+ for k in line_notes {+ notes.place(doc, k, cur.fi, cur.col, col_w, f, opts);+ }cur.last_baseline = Some(baseline);cur.last_descent = desc;cur.pending = 0.0;@@ -593,6 +642,7 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compocur.pending += pp.space_after;pi += 1;}+ notes.finish(doc, story, frames, &cols, &mut out);// Ranges, content heights and vertical justification.for (fi, ft) in out.frames.iter_mut().enumerate() {let f = &frames[fi];diff --git a/crates/compose/src/notes.rs b/crates/compose/src/notes.rsnew file mode 100644index 000000000..d4ca625b6--- /dev/null+++ b/crates/compose/src/notes.rs@@ -0,0 +1,206 @@+//! Footnote layout: numbering, room at the bottom of columns, and placement.+//!+//! When a line holding footnote references is set, each referenced footnote is composed at the+//! column width and the column's text area shrinks by its height (plus the minimum space before+//! the first footnote and the space between footnotes). A line that would collide moves to the+//! next column with its footnotes. After the story is laid out the footnotes of each column are+//! stacked against the column bottom, with the separator rule above the first one.++use std::collections::HashMap;+use std::ops::Range;+use std::sync::Arc;++use designcraft_doc::notes::NoteRestart;+use designcraft_doc::{Document, FOOTNOTE_REF, ItemId, Story, TextFrameOptions};+use designcraft_geom::{Point, Rect};++use crate::shape::{Glyph, SubstCtx};+use crate::{ComposeOptions, ComposedStory, Deco, FrameSpec, PlacedNote};++/// A footnote assigned to a column.+pub(crate) struct Placed {+ k: usize,+ fi: usize,+ col: usize,+ h: f64,+ text: Arc<ComposedStory>,+}++pub(crate) struct Notes {+ /// Byte offsets of the reference characters (index = footnote index).+ refs: Vec<usize>,+ /// Number of each footnote (assigned when its paragraph is shaped).+ numbers: Vec<u32>,+ /// Next number and the restart unit (page / spread / section start) it counts in.+ pub num: u32,+ pub key: Option<usize>,+ pub placed: Vec<Placed>,+ /// Composed footnote text by (index, label, width).+ cache: HashMap<(usize, String, u64), (Arc<ComposedStory>, f64)>,+ notes: Vec<Arc<designcraft_doc::Footnote>>,+}++impl Notes {+ pub fn new(doc: &Document, story: &Story) -> Notes {+ let refs: Vec<usize> = if story.notes.is_empty() { Vec::new() } else { story.text.match_indices(FOOTNOTE_REF).map(|(i, _)| i).collect() };+ let start = if refs.is_empty() { 1 } else { doc.footnote_start(story.id) };+ Notes { numbers: vec![start; refs.len()], refs, num: start, key: None, placed: Vec::new(), cache: HashMap::new(), notes: story.notes.clone() }+ }++ pub fn active(&self) -> bool {+ !self.refs.is_empty() && self.refs.len() == self.notes.len()+ }++ /// Number the references in a paragraph (shaped on `page`) and hand their labels to the shaper.+ pub fn number_refs(&mut self, doc: &Document, prange: Range<usize>, page: Option<usize>, sub: &mut SubstCtx) {+ let o = &doc.footnote_options;+ let key = page.and_then(|p| match o.restart {+ NoteRestart::Never => None,+ NoteRestart::Page => Some(p),+ NoteRestart::Spread => doc.page_loc(p).map(|l| l.0),+ NoteRestart::Section => Some(doc.section_of(p).map_or(0, |s| s.start)),+ });+ let a = self.refs.partition_point(|&b| b < prange.start);+ let b = self.refs.partition_point(|&b| b < prange.end);+ for k in a..b {+ if o.restart != NoteRestart::Never && key != self.key {+ self.key = key;+ self.num = o.start_at;+ }+ self.numbers[k] = self.num;+ self.num += 1;+ sub.notes.insert(self.refs[k], o.label(self.numbers[k], false));+ }+ sub.note_position = o.ref_position;+ sub.note_style = (o.ref_char_style != designcraft_doc::NO_CHAR_STYLE).then(|| o.ref_char_style.clone());+ }++ /// Footnote indices referenced by a line's glyphs.+ pub fn refs_in(&self, glyphs: &[Glyph]) -> Vec<usize> {+ let mut v: Vec<usize> = Vec::new();+ for g in glyphs.iter().filter(|g| g.ch == FOOTNOTE_REF && g.len > 0) {+ if let Ok(k) = self.refs.binary_search(&g.byte)+ && !v.contains(&k)+ {+ v.push(k);+ }+ }+ v+ }++ fn compose(&mut self, doc: &Document, k: usize, w: f64, f: &FrameSpec, opts: &ComposeOptions) -> (Arc<ComposedStory>, f64) {+ let o = &doc.footnote_options;+ let label = format!("{}{}", o.label(self.numbers[k], true), o.separator);+ let key = (k, label.clone(), w.to_bits());+ if let Some(c) = self.cache.get(&key) {+ return c.clone();+ }+ let spec = FrameSpec {+ id: ItemId(0),+ area: Rect::new(0.0, 0.0, w.max(1.0), 1.0e6),+ opts: TextFrameOptions { first_baseline: o.first_baseline, first_baseline_min: o.first_baseline_min, ..Default::default() },+ exclusions: vec![],+ page_name: f.page_name.clone(),+ page: f.page,+ grid: None,+ left_page: f.left_page,+ };+ let nopts = ComposeOptions { page_name: opts.page_name.clone(), page: opts.page, running: opts.running.clone(), label: Some(label) };+ let cs = crate::compose(doc, &self.notes[k].text, std::slice::from_ref(&spec), &nopts);+ let h = cs.frames.first().and_then(|ft| ft.lines.last()).map_or(0.0, |l| l.baseline + l.descent);+ let v = (Arc::new(cs), h);+ self.cache.insert(key, v.clone());+ v+ }++ /// Height the footnotes of column (fi, col) take, with `extra` footnotes added.+ #[allow(clippy::too_many_arguments)]+ pub fn reserve(&mut self, doc: &Document, fi: usize, col: usize, extra: &[usize], w: f64, f: &FrameSpec, opts: &ComposeOptions) -> f64 {+ let o = &doc.footnote_options;+ let mut n = 0usize;+ let mut h = 0.0;+ for p in self.placed.iter().filter(|p| p.fi == fi && p.col == col) {+ n += 1;+ h += p.h;+ }+ for &k in extra {+ n += 1;+ h += self.compose(doc, k, w, f, opts).1;+ }+ if n == 0 { 0.0 } else { h + o.space_between * (n - 1) as f64 + o.space_before }+ }++ pub fn place(&mut self, doc: &Document, k: usize, fi: usize, col: usize, w: f64, f: &FrameSpec, opts: &ComposeOptions) {+ if self.placed.iter().any(|p| p.k == k) {+ return;+ }+ let (text, h) = self.compose(doc, k, w, f, opts);+ self.placed.push(Placed { k, fi, col, h, text });+ }++ /// Stack each column's footnotes against its bottom, rule above the first.+ pub fn finish(&mut self, doc: &Document, story: &Story, frames: &[FrameSpec], cols: &[Vec<Rect>], out: &mut ComposedStory) {+ if self.placed.is_empty() {+ return;+ }+ let o = &doc.footnote_options;+ let mut groups: Vec<(usize, usize)> = self.placed.iter().map(|p| (p.fi, p.col)).collect();+ groups.dedup();+ groups.sort_unstable();+ groups.dedup();+ for (fi, ci) in groups {+ let (Some(_), Some(col)) = (frames.get(fi), cols.get(fi).and_then(|c| c.get(ci))) else { continue };+ let here: Vec<&Placed> = self.placed.iter().filter(|p| p.fi == fi && p.col == ci).collect();+ let total: f64 = here.iter().map(|p| p.h).sum::<f64>() + o.space_between * (here.len() - 1) as f64;+ let top = col.y1 - total;+ let ft = &mut out.frames[fi];+ if o.rule.on && o.rule.weight > 0.0 {+ let x0 = col.x0 + o.rule.left_indent;+ let y = top + o.rule.offset - o.rule.weight;+ ft.decos.push(Deco {+ rect: Rect::new(x0, y, (x0 + o.rule.width).min(col.x1), y + o.rule.weight),+ color: o.rule.color.clone(),+ tint: o.rule.tint,+ });+ }+ let mut y = top;+ for p in here {+ let note = &story.notes[p.k];+ ft.notes.push(PlacedNote {+ id: note.id,+ index: p.k,+ column: ci as u32,+ label: o.label(self.numbers[p.k], true),+ origin: Point::new(col.x0, y),+ rect: Rect::new(col.x0, y, col.x1, y + p.h),+ text: p.text.clone(),+ source: Arc::from(note.text.text.as_str()),+ });+ y += p.h + o.space_between;+ }+ }+ }+}++/// The placed footnote with id `id`: (frame index, footnote).+pub fn find_note(cs: &ComposedStory, id: u64) -> Option<(usize, &PlacedNote)> {+ cs.frames.iter().enumerate().find_map(|(fi, ft)| ft.notes.iter().find(|n| n.id == id).map(|n| (fi, n)))+}++/// Footnote text hit at frame-inner point `p`: (footnote id, byte in the footnote's story).+pub fn hit_note(cs: &ComposedStory, fi: usize, p: Point) -> Option<(u64, usize)> {+ let ft = cs.frames.get(fi)?;+ let n = ft.notes.iter().find(|n| n.rect.contains(p))?;+ let local = Point::new(p.x - n.origin.x, p.y - n.origin.y);+ Some((n.id, crate::hit(&n.text, 0, local).unwrap_or(0)))+}++/// Caret geometry for byte `pos` of a footnote's story, in frame inner space:+/// (frame index, x, baseline, ascent, descent).+pub fn note_caret(cs: &ComposedStory, id: u64, pos: usize) -> Option<(usize, f64, f64, f64, f64)> {+ let (fi, n) = find_note(cs, id)?;+ match crate::caret(&n.text, pos) {+ Some((_, x, bl, a, d)) => Some((fi, x + n.origin.x, bl + n.origin.y, a, d)),+ None => Some((fi, n.origin.x, n.origin.y + 10.0, 9.0, 3.0)),+ }+}diff --git a/crates/compose/src/shape.rs b/crates/compose/src/shape.rsindex 58d9b9dc5..0e1b15b69 100644--- a/crates/compose/src/shape.rs+++ b/crates/compose/src/shape.rs@@ -68,6 +68,11 @@ pub struct SubstCtx {pub section_marker: Option<String>,/// Text variable values by index (on the page being composed).pub vars: Arc<Vec<String>>,+ /// Footnote reference labels by story byte of the reference character.+ pub notes: HashMap<usize, String>,+ /// Footnote reference formatting: position and character style (`None` = the text's).+ pub note_position: designcraft_doc::Position,+ pub note_style: Option<String>,}pub(crate) struct StyleTable<'a> {@@ -117,7 +122,31 @@ pub(crate) fn shape_para(}let props = styles.resolve_char(para_chars, fmt);let style = table.intern(&props);- shape_run(db, &story.text, a..b, &props, auto_leading, style, sub, &mut glyphs);+ if !story.text[a..b].contains(designcraft_doc::FOOTNOTE_REF) {+ shape_run(db, &story.text, a..b, &props, auto_leading, style, sub, &mut glyphs);+ continue;+ }+ // Footnote references take the reference position / character style.+ let mut rf = fmt.clone();+ if let Some(cs) = &sub.note_style {+ rf.style = cs.clone();+ }+ rf.over.position = Some(sub.note_position);+ let rprops = styles.resolve_char(para_chars, &rf);+ let rstyle = table.intern(&rprops);+ let mut k = a;+ for (i, _) in story.text[a..b].match_indices(designcraft_doc::FOOTNOTE_REF) {+ let i = a + i;+ if k < i {+ shape_run(db, &story.text, k..i, &props, auto_leading, style, sub, &mut glyphs);+ }+ let e = i + designcraft_doc::FOOTNOTE_REF.len_utf8();+ shape_run(db, &story.text, i..e, &rprops, auto_leading, rstyle, sub, &mut glyphs);+ k = e;+ }+ if k < b {+ shape_run(db, &story.text, k..b, &props, auto_leading, style, sub, &mut glyphs);+ }}ShapedPara { glyphs, range }}@@ -192,6 +221,7 @@ fn shape_run(| story::INDENT_HERE| story::RIGHT_INDENT_TAB| story::TABLE_ANCHOR+ | designcraft_doc::FOOTNOTE_REF) || designcraft_doc::vars::var_index(c).is_some();if special {flush(seg_start, i, &seg_face, out);@@ -216,6 +246,10 @@ fn shape_run(};shape_segment(db, text, i..i + c.len_utf8(), Some(&s), p, &primary, auto_leading, style, out);}+ designcraft_doc::FOOTNOTE_REF => {+ let s = sub.notes.get(&i).map_or("#", String::as_str);+ shape_segment(db, text, i..i + c.len_utf8(), Some(s), p, &primary, auto_leading, style, out);+ }_ => {// Zero-width control glyph carrying metrics (tabs get their width at line layout).let mut g = control_glyph(&primary, p, auto_leading, style, i, c);diff --git a/crates/compose/src/tests.rs b/crates/compose/src/tests.rsindex 73bd778a4..f8f8318bc 100644--- a/crates/compose/src/tests.rs+++ b/crates/compose/src/tests.rs@@ -733,3 +733,57 @@ fn tab_leaders_fill_the_gap() {let num_x = line.glyphs.iter().find(|g| g.byte == 6).unwrap().x;assert!(last_dot < num_x, "leaders stop before the page number");}++#[test]+fn footnotes_sit_at_the_column_bottom_and_push_text() {+ // A short frame: without footnotes the text fills it; with two footnotes the body text+ // makes room and the footnotes stack against the bottom with a rule above.+ let text = format!("{LOREM} {LOREM} {LOREM}");+ let (mut d, sid, fid) = doc_with(&text, Rect::new(36.0, 36.0, 300.0, 236.0), ParaAttrs::default());+ let plain = compose_story(&d, sid, &ComposeOptions::default());+ let plain_lines = plain.frames[0].lines.len();+ {+ let st = d.story_mut(sid).unwrap();+ st.insert_note(10, "First note, long enough to take two lines in this narrow frame for sure.", ParaFormat::default());+ st.insert_note(40, "Second note.", ParaFormat::default());+ st.check().unwrap();+ }+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let ft = cs.frame(fid).unwrap();+ assert_eq!(ft.notes.len(), 2);+ assert!(ft.lines.len() < plain_lines, "body text makes room: {} vs {plain_lines}", ft.lines.len());+ let (a, b) = (&ft.notes[0], &ft.notes[1]);+ assert_eq!(a.label, "1");+ assert_eq!(b.label, "2");+ assert!(a.rect.y1 <= b.rect.y0 + 1e-6, "stacked in order");+ let area = ft.columns[0];+ assert!((b.rect.y1 - area.y1).abs() < 1e-6, "last footnote ends at the column bottom");+ let last = ft.lines.last().unwrap();+ assert!(last.baseline + last.descent <= a.rect.y0 - d.footnote_options.space_before + 0.01, "text clears the footnotes");+ assert!(a.text.frames[0].lines.len() >= 2);+ // The rule sits above the first footnote.+ assert!(ft.decos.iter().any(|dc| (dc.rect.width() - 72.0).abs() < 1e-6 && dc.rect.y1 <= a.rect.y0 + 1e-6));+ // The reference shows its number as superscript glyphs in the text.+ let refs: Vec<&PlacedGlyph> = ft.lines.iter().flat_map(|l| l.glyphs.iter()).filter(|g| g.byte == 10 && g.len > 0).collect();+ assert_eq!(refs.len(), 1);+ // Numbering continues from options and restarts per page when asked.+ d.footnote_options.start_at = 5;+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ assert_eq!(cs.frames[0].notes[1].label, "6");+ // Hit testing and carets reach footnote text.+ let n = &cs.frames[0].notes[1];+ let (id, _) = hit_note(&cs, 0, Point::new(n.rect.x0 + 40.0, n.rect.y0 + 5.0)).unwrap();+ assert_eq!(id, n.id);+ assert!(note_caret(&cs, n.id, 0).is_some());+}++#[test]+fn footnote_line_at_column_top_still_sets() {+ // A note taller than the frame can't push its reference line forever.+ let (mut d, sid, _) = doc_with("Short text.", Rect::new(0.0, 0.0, 200.0, 40.0), ParaAttrs::default());+ let long = LOREM.repeat(3);+ d.story_mut(sid).unwrap().insert_note(5, &long, ParaFormat::default());+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ assert!(!cs.frames[0].lines.is_empty());+ assert_eq!(cs.frames[0].notes.len(), 1);+}diff --git a/crates/doc/src/attrs.rs b/crates/doc/src/attrs.rsindex 4dab9e458..7836658ce 100644--- a/crates/doc/src/attrs.rs+++ b/crates/doc/src/attrs.rs@@ -301,6 +301,8 @@ pub enum NumberStyle {LowerLetters,/// 01, 02, …ArabicLeadingZero,+ /// *, †, ‡, §, ¶, ‖, then doubled (**, ††, …): footnotes.+ Symbols,}impl NumberStyle {@@ -312,6 +314,11 @@ impl NumberStyle {NumberStyle::LowerRoman => roman(n).to_lowercase(),NumberStyle::UpperLetters => letters(n),NumberStyle::LowerLetters => letters(n).to_lowercase(),+ NumberStyle::Symbols => {+ const SYM: [char; 6] = ['*', '†', '‡', '§', '¶', '‖'];+ let n = n.max(1) as usize - 1;+ std::iter::repeat_n(SYM[n % SYM.len()], n / SYM.len() + 1).collect()+ }}}}diff --git a/crates/doc/src/build.rs b/crates/doc/src/build.rsindex 451628c55..d071b2171 100644--- a/crates/doc/src/build.rs+++ b/crates/doc/src/build.rs@@ -140,6 +140,7 @@ impl Document {user_words: vec![],toc: None,text_variables: crate::vars::defaults(),+ footnote_options: Default::default(),created: crate::vars::now(),modified: 0,next_id: 0,diff --git a/crates/doc/src/edit.rs b/crates/doc/src/edit.rsindex 06655f37a..d4ef98c1a 100644--- a/crates/doc/src/edit.rs+++ b/crates/doc/src/edit.rs@@ -227,6 +227,10 @@ impl Document {}st.chars.extend(other.chars.iter().filter(|r| r.len > 0).cloned());st.tables.extend(other.tables.iter().map(|(k, v)| (*k, v.clone())));+ for n in &other.notes {+ let id = st.next_note_id();+ st.notes.push(Arc::new(crate::Footnote { id, text: n.text.clone() }));+ }st.rev += 1;}let at = st.frames.iter().position(|f| *f == from).map_or(st.frames.len(), |p| p + 1);@@ -352,6 +356,8 @@ impl Document {st.paras = vec![para; n];st.chars = vec![CharRun { len: text.len(), format: fmt }];st.tables.clear();+ st.notes.clear();+ st.fix_notes();st.rev += 1;Ok(())}diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsindex bc8bd26cb..6b6e38d8b 100644--- a/crates/doc/src/lib.rs+++ b/crates/doc/src/lib.rs@@ -13,6 +13,7 @@ pub mod build;mod edit;pub mod ids;pub mod item;+pub mod notes;pub mod page;pub mod selection;pub mod story;@@ -29,6 +30,7 @@ pub use designcraft_geom as geom;pub use edit::{ItemLoc, ItemPath, SpreadRef, item_hit as edit_hit};pub use ids::*;pub use item::*;+pub use notes::{FOOTNOTE_REF, FOOTNOTE_TABLE, Footnote, FootnoteOptions};pub use page::*;pub use selection::*;pub use story::*;@@ -247,6 +249,9 @@ pub struct Document {/// Text variable definitions (instances in stories are `vars::var_char(index)`).#[serde(default = "vars::defaults")]pub text_variables: Vec<vars::TextVariable>,+ /// Type › Document Footnote Options.+ #[serde(default)]+ pub footnote_options: FootnoteOptions,/// Creation / last save time (Unix seconds, UTC).#[serde(default)]pub created: i64,diff --git a/crates/doc/src/notes.rs b/crates/doc/src/notes.rsnew file mode 100644index 000000000..a38020ca5--- /dev/null+++ b/crates/doc/src/notes.rs@@ -0,0 +1,301 @@+//! Footnotes.+//!+//! A footnote reference is a [`FOOTNOTE_REF`] character in a story; the story's+//! [`Story::notes`] holds one [`Footnote`] per reference, in text order (the k-th reference+//! character owns `notes[k]`). Deleting the reference deletes the footnote; inserting text that+//! contains reference characters inserts empty footnotes. Each footnote's text is a frameless+//! [`Story`] (like a table cell) composed at the bottom of the column its reference lands in.+//!+//! Numbering and layout come from the document-wide [`FootnoteOptions`]+//! (Type › Document Footnote Options).++use std::sync::Arc;++use serde::{Deserialize, Serialize};++use crate::attrs::{NumberStyle, Position};+use crate::ids::StoryId;+use crate::item::FirstBaseline;+use crate::story::{BASIC_PARAGRAPH, CharFormat, NO_CHAR_STYLE, ParaFormat, Story};++/// Footnote reference character (the number shown in the text).+pub const FOOTNOTE_REF: char = '\u{E00A}';++/// Footnote addresses reuse [`crate::CellAddr`] with this pseudo table id (the row is the+/// footnote id): text selections, typing and formatting reach footnote text like cell text.+pub const FOOTNOTE_TABLE: u64 = u64::MAX;++#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct Footnote {+ /// Stable within the story (selection addresses).+ pub id: u64,+ /// The footnote text (no frames).+ pub text: Story,+}++/// Restart Numbering Every.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub enum NoteRestart {+ /// Continuous through the document.+ #[default]+ Never,+ Page,+ Spread,+ Section,+}++/// Where the prefix/suffix appear.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub enum AffixIn {+ #[default]+ None,+ Reference,+ Text,+ Both,+}++#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase", default)]+pub struct NoteRule {+ pub on: bool,+ pub weight: f64,+ pub color: String,+ pub tint: f32,+ /// Rule length.+ pub width: f64,+ /// Baseline offset below the top of the footnote area.+ pub offset: f64,+ pub left_indent: f64,+}++impl Default for NoteRule {+ fn default() -> Self {+ NoteRule { on: true, weight: 1.0, color: designcraft_color::swatch::BLACK.into(), tint: 1.0, width: 72.0, offset: 0.0, left_indent: 0.0 }+ }+}++/// Type › Document Footnote Options (Numbering and Formatting, Layout).+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase", default)]+pub struct FootnoteOptions {+ pub style: NumberStyle,+ pub start_at: u32,+ pub restart: NoteRestart,+ pub prefix: String,+ pub suffix: String,+ pub affix_in: AffixIn,+ /// Footnote reference number in text.+ pub ref_position: Position,+ pub ref_char_style: String,+ /// Footnote text formatting.+ pub para_style: String,+ /// Between the number and the footnote text.+ pub separator: String,+ /// Minimum space between the text and the first footnote.+ pub space_before: f64,+ pub space_between: f64,+ pub first_baseline: FirstBaseline,+ pub first_baseline_min: f64,+ /// Footnotes span all columns of a multi-column frame (else each column gets its own).+ pub span_columns: bool,+ /// Rule above the first footnote in a column.+ pub rule: NoteRule,+}++impl Default for FootnoteOptions {+ fn default() -> Self {+ FootnoteOptions {+ style: NumberStyle::Arabic,+ start_at: 1,+ restart: NoteRestart::Never,+ prefix: String::new(),+ suffix: String::new(),+ affix_in: AffixIn::None,+ ref_position: Position::Superscript,+ ref_char_style: NO_CHAR_STYLE.into(),+ para_style: BASIC_PARAGRAPH.into(),+ separator: "\t".into(),+ space_before: 0.0,+ space_between: 0.0,+ first_baseline: FirstBaseline::Leading,+ first_baseline_min: 0.0,+ span_columns: false,+ rule: NoteRule::default(),+ }+ }+}++impl FootnoteOptions {+ /// The number as shown at the reference (`text == false`) or before the footnote text.+ pub fn label(&self, n: u32, text: bool) -> String {+ let num = self.style.format(n);+ let affix = match self.affix_in {+ AffixIn::None => false,+ AffixIn::Both => true,+ AffixIn::Reference => !text,+ AffixIn::Text => text,+ };+ if affix { format!("{}{num}{}", self.prefix, self.suffix) } else { num }+ }+}++impl Story {+ /// Index (in [`Story::notes`]) of the footnote whose reference is the k-th reference before `pos`.+ pub fn notes_before(&self, pos: usize) -> usize {+ let pos = crate::story::floor_char_boundary(&self.text, pos);+ self.text[..pos].matches(FOOTNOTE_REF).count()+ }++ pub fn note(&self, id: u64) -> Option<&Footnote> {+ self.notes.iter().find(|n| n.id == id).map(|n| &**n)+ }++ /// Mutable footnote (copy-on-write); bumps the story revision.+ pub fn note_mut(&mut self, id: u64) -> Option<&mut Footnote> {+ let n = self.notes.iter_mut().find(|n| n.id == id)?;+ self.rev += 1;+ Some(Arc::make_mut(n))+ }++ /// Byte offset of a footnote's reference character.+ pub fn note_anchor(&self, id: u64) -> Option<usize> {+ let k = self.notes.iter().position(|n| n.id == id)?;+ self.text.match_indices(FOOTNOTE_REF).nth(k).map(|(i, _)| i)+ }++ /// Insert a footnote reference at `pos` with the given footnote text. Returns the footnote id.+ pub fn insert_note(&mut self, pos: usize, text: &str, para: ParaFormat) -> u64 {+ let pos = crate::story::floor_char_boundary(&self.text, pos.min(self.len()));+ let fmt = self.char_format_at(pos).clone();+ self.insert_with(pos, &FOOTNOTE_REF.to_string(), fmt);+ let k = self.notes_before(pos);+ let note = Arc::make_mut(&mut self.notes[k]);+ note.text = Story::with_text(StoryId(0), text, para);+ note.id+ }++ pub(crate) fn next_note_id(&self) -> u64 {+ self.notes.iter().map(|n| n.id).max().unwrap_or(0) + 1+ }++ /// Insert empty footnotes for `n` new reference characters before which `k` references sit.+ pub(crate) fn notes_inserted(&mut self, k: usize, n: usize) {+ for i in 0..n {+ let id = self.next_note_id();+ let mut text = Story::new(StoryId(0));+ text.chars[0].format = CharFormat::default();+ self.notes.insert((k + i).min(self.notes.len()), Arc::new(Footnote { id, text }));+ }+ }++ /// Make the footnote list match the reference characters (after wholesale text changes).+ pub fn fix_notes(&mut self) {+ let n = self.text.matches(FOOTNOTE_REF).count();+ if n < self.notes.len() {+ self.notes.truncate(n);+ } else if n > self.notes.len() {+ let k = self.notes.len();+ self.notes_inserted(k, n - k);+ }+ }++ pub(crate) fn check_notes(&self) -> Result<(), String> {+ let n = self.text.matches(FOOTNOTE_REF).count();+ if n != self.notes.len() {+ return Err(format!("story {}: {n} footnote references, {} footnotes", self.id.0, self.notes.len()));+ }+ let mut ids = std::collections::HashSet::new();+ for note in &self.notes {+ if !ids.insert(note.id) {+ return Err(format!("story {}: footnote id {} used twice", self.id.0, note.id));+ }+ note.text.check()?;+ }+ Ok(())+ }+}++impl crate::Document {+ /// Number of the first footnote of story `sid` when numbering runs through the document:+ /// the start number plus the footnotes of stories that start on earlier pages.+ pub fn footnote_start(&self, sid: StoryId) -> u32 {+ let o = &self.footnote_options;+ if o.restart != NoteRestart::Never {+ return o.start_at;+ }+ let key = |st: &Story| -> (usize, u64) {+ let page = st.frames.first().and_then(|f| self.page_of_item(*f)).unwrap_or(usize::MAX);+ (page, st.id.0)+ };+ let Some(me) = self.story(sid) else { return o.start_at };+ let mine = key(me);+ let before: usize = self.stories.values().filter(|st| st.id != sid && !st.notes.is_empty() && key(st) < mine).map(|st| st.notes.len()).sum();+ o.start_at + before as u32+ }++ /// Absolute page an item sits on (its center), None on parent pages / pasteboard-only spreads.+ pub fn page_of_item(&self, id: crate::ItemId) -> Option<usize> {+ let loc = self.find(id)?;+ let crate::SpreadRef::Doc(si) = loc.spread else { return None };+ let sp = self.spread(loc.spread)?;+ let c = self.item(id)?.bounds().center();+ Some(self.first_page_of_spread(si) + sp.page_at_x(c.x).unwrap_or(0))+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn st(t: &str) -> Story {+ Story::with_text(StoryId(1), t, ParaFormat::default())+ }++ #[test]+ fn references_own_notes_in_order() {+ let mut s = st("alpha beta gamma");+ let b = s.insert_note(10, "second", ParaFormat::default());+ let a = s.insert_note(5, "first", ParaFormat::default());+ s.check().unwrap();+ assert_eq!(s.notes.len(), 2);+ assert_eq!(s.notes[0].id, a);+ assert_eq!(s.notes[0].text.text, "first");+ assert_eq!(s.notes[1].text.text, "second");+ assert_eq!(s.note_anchor(b), Some(10 + FOOTNOTE_REF.len_utf8()));+ // Deleting the first reference deletes its note only.+ s.delete(5..5 + FOOTNOTE_REF.len_utf8());+ s.check().unwrap();+ assert_eq!(s.notes.len(), 1);+ assert_eq!(s.notes[0].id, b);+ // Typing a reference character (paste) creates an empty note.+ s.insert(0, &FOOTNOTE_REF.to_string());+ s.check().unwrap();+ assert_eq!(s.notes.len(), 2);+ assert_eq!(s.notes[1].id, b);+ assert!(s.notes[0].text.text.is_empty());+ // Deleting a range spanning everything clears all notes.+ let n = s.len();+ s.delete(0..n);+ s.check().unwrap();+ assert!(s.notes.is_empty());+ }++ #[test]+ fn labels_and_symbols() {+ let mut o = FootnoteOptions::default();+ assert_eq!(o.label(3, false), "3");+ o.style = NumberStyle::Symbols;+ assert_eq!(o.label(1, false), "*");+ assert_eq!(o.label(2, false), "†");+ assert_eq!(o.label(7, false), "**");+ o.style = NumberStyle::Arabic;+ o.prefix = "[".into();+ o.suffix = "]".into();+ o.affix_in = AffixIn::Reference;+ assert_eq!(o.label(4, false), "[4]");+ assert_eq!(o.label(4, true), "4");+ }+}diff --git a/crates/doc/src/selection.rs b/crates/doc/src/selection.rsindex fbe4b9132..d9e9b7a3d 100644--- a/crates/doc/src/selection.rs+++ b/crates/doc/src/selection.rs@@ -14,6 +14,17 @@ pub struct CellAddr {pub col: usize,}+impl CellAddr {+ /// The text of footnote `id` (see [`crate::notes::FOOTNOTE_TABLE`]).+ pub fn footnote(id: u64) -> Self {+ CellAddr { table: crate::notes::FOOTNOTE_TABLE, row: id as usize, col: 0 }+ }+ /// The footnote id when this addresses footnote text.+ pub fn footnote_id(&self) -> Option<u64> {+ (self.table == crate::notes::FOOTNOTE_TABLE).then_some(self.row as u64)+ }+}+/// Selected table cells (Table > Select, dragging across cells).#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]diff --git a/crates/doc/src/story.rs b/crates/doc/src/story.rsindex 132315898..11de1d7fc 100644--- a/crates/doc/src/story.rs+++ b/crates/doc/src/story.rs@@ -10,7 +10,7 @@//! Special characters: `\t` tab, `\u{2028}` forced line break, [`PAGE_NUMBER`], [`SECTION_MARKER`],//! [`COLUMN_BREAK`], [`FRAME_BREAK`], [`PAGE_BREAK`], `\u{AD}` discretionary hyphen,//! `\u{2011}` non-breaking hyphen, `\u{A0}` non-breaking space, [`INDENT_HERE`], [`RIGHT_INDENT_TAB`],-//! [`TABLE_ANCHOR`] (a table, see [`crate::table`]).+//! [`TABLE_ANCHOR`] (a table, see [`crate::table`]), [`crate::notes::FOOTNOTE_REF`] (a footnote).use std::collections::BTreeMap;use std::sync::Arc;@@ -94,6 +94,9 @@ pub struct Story {/// Tables anchored in the story, by id (see [`crate::table`]).#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]pub tables: BTreeMap<u64, Arc<Table>>,+ /// Footnotes, one per [`crate::notes::FOOTNOTE_REF`] in text order (see [`crate::notes`]).+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub notes: Vec<Arc<crate::notes::Footnote>>,}impl Story {@@ -106,6 +109,7 @@ impl Story {frames: vec![],rev: 0,tables: BTreeMap::new(),+ notes: Vec::new(),}}@@ -189,6 +193,11 @@ impl Story {return;}let pos = floor_char_boundary(&self.text, pos);+ let refs = text.matches(crate::notes::FOOTNOTE_REF).count();+ if refs > 0 {+ let k = self.notes_before(pos);+ self.notes_inserted(k, refs);+ }// Paragraph formats: each new '\n' splits the current paragraph; the new paragraphs copy it.let pi = self.para_at(pos);let newlines = text.bytes().filter(|b| *b == b'\n').count();@@ -212,6 +221,11 @@ impl Story {if a == b {return;}+ let refs = self.text[a..b].matches(crate::notes::FOOTNOTE_REF).count();+ if refs > 0 {+ let k = self.notes_before(a);+ self.notes.drain(k..(k + refs).min(self.notes.len()));+ }let pi = self.para_at(a);let removed = self.text[a..b].bytes().filter(|c| *c == b'\n').count();// Merged paragraphs keep a table whose anchor survives the deletion.@@ -314,7 +328,8 @@ impl Story {return Err(format!("run boundary {pos} splits a character"));}}- self.check_tables()+ self.check_tables()?;+ self.check_notes()}// ---------- run helpers ----------diff --git a/crates/doc/src/table.rs b/crates/doc/src/table.rsindex 853cf6a61..38caa5f5c 100644--- a/crates/doc/src/table.rs+++ b/crates/doc/src/table.rs@@ -695,6 +695,7 @@ impl crate::Document {pub fn text_story(&self, story: StoryId, cell: Option<crate::CellAddr>) -> Option<&Story> {let st = self.story(story)?;match cell {+ Some(c) if c.table == crate::FOOTNOTE_TABLE => st.note(c.row as u64).map(|n| &n.text),Some(c) => st.tables.get(&c.table)?.cell(c.row, c.col).map(|x| &x.text),None => Some(st),}@@ -704,6 +705,7 @@ impl crate::Document {pub fn text_story_mut(&mut self, story: StoryId, cell: Option<crate::CellAddr>) -> Option<&mut Story> {let st = self.story_mut(story)?;match cell {+ Some(c) if c.table == crate::FOOTNOTE_TABLE => st.note_mut(c.row as u64).map(|n| &mut n.text),Some(c) => st.table_mut(c.table)?.cell_mut(c.row, c.col).map(|x| &mut x.text),None => Some(st),}diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rsindex 7b8593576..a93b9ab0a 100644--- a/crates/engine/src/cmd/mod.rs+++ b/crates/engine/src/cmd/mod.rs@@ -9,6 +9,7 @@ mod inspect;mod interactive;pub mod interchange;mod layout;+mod notes;mod object;pub mod preflight;pub mod spelling;@@ -122,6 +123,7 @@ pub fn command_specs() -> &'static [CommandSpec] {v.extend(find::specs());v.extend(variables::specs());v.extend(toc::specs());+ v.extend(notes::specs());v.extend(spelling::specs());v.extend(datamerge::specs());v.extend(interactive::specs());diff --git a/crates/engine/src/cmd/notes.rs b/crates/engine/src/cmd/notes.rsnew file mode 100644index 000000000..4d7b0f13f--- /dev/null+++ b/crates/engine/src/cmd/notes.rs@@ -0,0 +1,224 @@+//! Type › Insert Footnote, Document Footnote Options, footnote inspection and editing.++use designcraft_doc::{CellAddr, FootnoteOptions, ParaFormat, StoryId, TextSel};+use serde_json::{Value, json};++use super::{CommandSpec, bad, cmd, has_doc, str_param};+use crate::{Result, Session};++pub fn specs() -> Vec<CommandSpec> {+ vec![+ cmd!(+ "footnote.insert",+ "Insert Footnote",+ ["Type"],+ None,+ "{text?} — a footnote reference at the insertion point; the caret moves into the new footnote's text",+ in_story_text,+ insert+ ),+ cmd!(+ "footnote.options",+ "Document Footnote Options…",+ ["Type"],+ None,+ "{style?: arabic|upperRoman|lowerRoman|upperLetters|lowerLetters|symbols, startAt?, restart?: never|page|spread|section, prefix?, suffix?, affixIn?: none|reference|text|both, refPosition?: superscript|subscript|normal|otSuperscript, refCharStyle?, paraStyle?, separator?, spaceBefore?, spaceBetween?, firstBaseline?, firstBaselineMin?, spanColumns?, rule?: {on, weight, color, tint, width, offset, leftIndent}} → the options (no params: just read them)",+ has_doc,+ options+ ),+ cmd!(query "footnote.list", "Footnotes", [], None, "{story?} → [{story, id, index, anchor, text}] in story order", has_doc, list),+ cmd!("footnote.setText", "Set Footnote Text", [], None, "{story, id, text} — replaces the footnote's text", has_doc, set_text),+ cmd!("footnote.delete", "Delete Footnote", [], None, "{story, id} — deletes the reference (and so the footnote)", has_doc, delete),+ cmd!(+ noundo "footnote.goToReference",+ "Go to Footnote Reference",+ ["Type"],+ None,+ "{} — from footnote text, puts the caret after the footnote's reference",+ in_note,+ go_to_reference+ ),+ ]+}++fn in_story_text(s: &Session) -> std::result::Result<(), String> {+ super::has_text(s)?;+ match s.active().and_then(|d| d.selection.text) {+ Some(t) if t.cell.is_some() => Err("footnotes can't be inserted in table cells or other footnotes".into()),+ _ => Ok(()),+ }+}++fn in_note(s: &Session) -> std::result::Result<(), String> {+ super::has_text(s)?;+ match s.active().and_then(|d| d.selection.text) {+ Some(t) if t.cell.is_some_and(|c| c.footnote_id().is_some()) => Ok(()),+ _ => Err("the insertion point is not in footnote text".into()),+ }+}++fn insert(s: &mut Session, p: &Value) -> Result<Value> {+ let text = str_param(p, "text").unwrap_or("").to_string();+ s.edit(|d, sel| {+ let t = sel.text.ok_or_else(|| bad("footnote.insert", "no insertion point"))?;+ let para = ParaFormat { style: d.footnote_options.para_style.clone(), ..Default::default() };+ let st = d.story_mut(t.story).ok_or(designcraft_doc::DocError::NoStory(t.story))?;+ let r = t.range();+ let r = r.start.min(st.len())..r.end.min(st.len());+ st.delete(r.clone());+ let id = st.insert_note(r.start, &text, para);+ sel.text = Some(TextSel { story: t.story, anchor: text.len(), focus: text.len(), frame: t.frame, cell: Some(CellAddr::footnote(id)) });+ Ok(json!({"story": t.story.0, "id": id}))+ })+}++/// Overlay `p` onto `base` (objects merge key by key).+fn merge(base: &mut Value, p: &Value) {+ match (base, p) {+ (Value::Object(b), Value::Object(o)) => {+ for (k, v) in o {+ match b.get_mut(k) {+ Some(slot) if slot.is_object() && v.is_object() => merge(slot, v),+ _ => {+ b.insert(k.clone(), v.clone());+ }+ }+ }+ }+ (b, v) => *b = v.clone(),+ }+}++fn options(s: &mut Session, p: &Value) -> Result<Value> {+ let cur = s.doc()?.doc.footnote_options.clone();+ if p.as_object().is_none_or(|o| o.is_empty()) {+ return Ok(serde_json::to_value(&cur).unwrap_or_default());+ }+ let mut v = serde_json::to_value(&cur).unwrap_or_default();+ merge(&mut v, p);+ let next: FootnoteOptions = serde_json::from_value(v).map_err(|e| bad("footnote.options", e.to_string()))?;+ let out = serde_json::to_value(&next).unwrap_or_default();+ if next != cur {+ s.edit(|d, _| {+ d.footnote_options = next;+ Ok(Value::Null)+ })?;+ }+ Ok(out)+}++fn story_id(p: &Value, cmd: &str) -> Result<StoryId> {+ p.get("story").and_then(Value::as_u64).map(StoryId).ok_or_else(|| bad(cmd, "missing story"))+}++fn note_id(p: &Value, cmd: &str) -> Result<u64> {+ p.get("id").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "missing id"))+}++fn list(s: &mut Session, p: &Value) -> Result<Value> {+ let d = &s.doc()?.doc;+ let only = p.get("story").and_then(Value::as_u64).map(StoryId);+ let mut out = Vec::new();+ for st in d.stories.values().filter(|st| only.is_none_or(|o| o == st.id)) {+ for (k, n) in st.notes.iter().enumerate() {+ out.push(json!({"story": st.id.0, "id": n.id, "index": k, "anchor": st.note_anchor(n.id), "text": n.text.text}));+ }+ }+ Ok(Value::Array(out))+}++fn set_text(s: &mut Session, p: &Value) -> Result<Value> {+ let sid = story_id(p, "footnote.setText")?;+ let id = note_id(p, "footnote.setText")?;+ let text = str_param(p, "text").unwrap_or("").to_string();+ s.edit(|d, _| {+ let st = d.story_mut(sid).ok_or(designcraft_doc::DocError::NoStory(sid))?;+ let n = st.note_mut(id).ok_or_else(|| bad("footnote.setText", format!("no footnote {id}")))?;+ let len = n.text.len();+ n.text.replace(0..len, &text);+ Ok(Value::Null)+ })+}++fn delete(s: &mut Session, p: &Value) -> Result<Value> {+ let sid = story_id(p, "footnote.delete")?;+ let id = note_id(p, "footnote.delete")?;+ s.edit(|d, sel| {+ let st = d.story_mut(sid).ok_or(designcraft_doc::DocError::NoStory(sid))?;+ let at = st.note_anchor(id).ok_or_else(|| bad("footnote.delete", format!("no footnote {id}")))?;+ st.delete(at..at + designcraft_doc::FOOTNOTE_REF.len_utf8());+ if sel.text.is_some_and(|t| t.story == sid && t.cell == Some(CellAddr::footnote(id))) {+ sel.text = Some(TextSel::caret(sid, at));+ }+ Ok(Value::Null)+ })+}++fn go_to_reference(s: &mut Session, _: &Value) -> Result<Value> {+ let st = s.doc_mut()?;+ let t = st.selection.text.ok_or_else(|| bad("footnote.goToReference", "no caret"))?;+ let id = t.cell.and_then(|c| c.footnote_id()).ok_or_else(|| bad("footnote.goToReference", "not in footnote text"))?;+ let at = st.doc.story(t.story).and_then(|x| x.note_anchor(id)).ok_or_else(|| bad("footnote.goToReference", "footnote not found"))?;+ let pos = at + designcraft_doc::FOOTNOTE_REF.len_utf8();+ st.selection.text = Some(TextSel { anchor: pos, focus: pos, cell: None, ..t });+ st.revision += 1;+ Ok(json!({"story": t.story.0, "pos": pos}))+}++#[cfg(test)]+mod tests {+ use super::*;++ fn session_with_text() -> (Session, StoryId) {+ let mut s = Session::new();+ s.execute("file.new", &json!({"pages": 1})).unwrap();+ let r = s.execute("frame.create", &json!({"rect": [72, 72, 300, 400], "content": "text", "text": "Body text with a note here."})).unwrap();+ let sid = s.doc().unwrap().doc.item(designcraft_doc::ItemId(r["id"].as_u64().unwrap())).unwrap().text_frame().unwrap().story;+ (s, sid)+ }++ #[test]+ fn insert_type_and_undo_footnotes() {+ let (mut s, sid) = session_with_text();+ s.execute("text.select", &json!({"story": sid.0, "anchor": 16, "focus": 16})).unwrap();+ let r = s.execute("footnote.insert", &json!({})).unwrap();+ let id = r["id"].as_u64().unwrap();+ // Typing goes into the footnote.+ s.execute("text.insert", &json!({"text": "A source."})).unwrap();+ let st = s.doc().unwrap().doc.story(sid).unwrap().clone();+ assert_eq!(st.notes.len(), 1);+ assert_eq!(st.notes[0].text.text, "A source.");+ assert_eq!(st.text.matches(designcraft_doc::FOOTNOTE_REF).count(), 1);+ // The footnote is laid out in the frame.+ let d = s.doc().unwrap().doc.clone();+ let cs = s.cache.get(&d, sid, None);+ assert_eq!(cs.frames[0].notes.len(), 1);+ // Back to the reference.+ let r = s.execute("footnote.goToReference", &json!({})).unwrap();+ assert_eq!(r["pos"], json!(16 + designcraft_doc::FOOTNOTE_REF.len_utf8()));+ // Listing, editing, options.+ let l = s.execute("footnote.list", &json!({})).unwrap();+ assert_eq!(l[0]["text"], "A source.");+ s.execute("footnote.setText", &json!({"story": sid.0, "id": id, "text": "Changed."})).unwrap();+ assert_eq!(s.doc().unwrap().doc.story(sid).unwrap().notes[0].text.text, "Changed.");+ let o = s.execute("footnote.options", &json!({"style": "lowerRoman", "rule": {"width": 100.0}})).unwrap();+ assert_eq!(o["style"], "lowerRoman");+ assert_eq!(o["rule"]["width"], 100.0);+ assert_eq!(o["rule"]["on"], true);+ assert!(s.execute("footnote.options", &json!({"restart": "bogus"})).is_err());+ // Deleting removes the reference; undo brings everything back.+ s.execute("footnote.delete", &json!({"story": sid.0, "id": id})).unwrap();+ assert!(s.doc().unwrap().doc.story(sid).unwrap().notes.is_empty());+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc.story(sid).unwrap().notes.len(), 1);+ }++ #[test]+ fn not_in_cells() {+ let (mut s, sid) = session_with_text();+ s.execute("text.select", &json!({"story": sid.0, "anchor": 0, "focus": 0})).unwrap();+ s.execute("footnote.insert", &json!({"text": "x"})).unwrap();+ // Caret is now in footnote text: no nested footnotes.+ assert!(s.execute("footnote.insert", &json!({})).is_err());+ }+}diff --git a/crates/engine/src/cmd/text.rs b/crates/engine/src/cmd/text.rsindex 7c7b90710..a88624334 100644--- a/crates/engine/src/cmd/text.rs+++ b/crates/engine/src/cmd/text.rs@@ -160,6 +160,9 @@ fn hit_byte(s: &Session, frame: ItemId, pt: Point) -> Option<(StoryId, usize, Opif let Some((table, row, col, b)) = compose::hit_cell(&cs, fi, inner) {return Some((sid, b, Some(CellAddr { table, row, col })));}+ if let Some((id, b)) = compose::hit_note(&cs, fi, inner) {+ return Some((sid, b, Some(CellAddr::footnote(id))));+ }let b = compose::hit(&cs, fi, inner).unwrap_or(0);Some((sid, b, None))}@@ -354,6 +357,7 @@ fn move_caret(s: &mut Session, p: &Value) -> Result<Value> {let cs = s.cache.get(&st.doc, t.story, None);// In a cell, lines come from the cell's own composition.let cs = match t.cell {+ Some(c) if c.footnote_id().is_some() => compose::find_note(&cs, c.row as u64).map(|(_, n)| n.text.clone()).unwrap_or(cs),Some(c) => compose::find_cell(&cs, c.table, c.row, c.col).map(|(_, _, pc)| pc.text.clone()).unwrap_or(cs),None => cs,};diff --git a/crates/engine/src/sample.rs b/crates/engine/src/sample.rsindex e6689e0ae..467fc1f99 100644--- a/crates/engine/src/sample.rs+++ b/crates/engine/src/sample.rs@@ -102,6 +102,7 @@ pub fn magazine() -> Document {..Default::default()});d.title = "Quarterly — Spring Issue".into();+ d.footnote_options.para_style = "Footnote".into();// Swatches.d.swatches.push(Swatch::color("Ink Plum", Color::cmyk(0.62, 0.95, 0.30, 0.25)));d.swatches.push(Swatch::color("Sunset", Color::cmyk(0.0, 0.62, 0.78, 0.0)));@@ -141,6 +142,22 @@ pub fn magazine() -> Document {ParaAttrs { align: Some(Align::LeftJustified), first_line_indent: Some(12.0), hyph_min_word: Some(6), ..Default::default() },CharAttrs { leading: Some(Leading::Points(13.5)), ..serif("Regular", 9.75) },));+ st.paragraph.push(para_style(+ "Footnote",+ Some(story::BASIC_PARAGRAPH),+ ParaAttrs {+ left_indent: Some(10.0),+ first_line_indent: Some(-10.0),+ tabs: Some(vec![designcraft_doc::TabStop {+ position: 10.0,+ align: Default::default(),+ leader: String::new(),+ align_on: String::new(),+ }]),+ ..Default::default()+ },+ CharAttrs { leading: Some(Leading::Points(9.0)), ..serif("Regular", 7.0) },+ ));st.paragraph.push(para_style("Body First",Some("Body"),@@ -305,6 +322,14 @@ pub fn magazine() -> Document {let more = format!("\n{BODY}\n{BODY}");let end = st.len();st.insert(end, &more);+ // A footnote on the last sentence of the article.+ if let Some(at) = st.text.trim_end().rfind('.') {+ st.insert_note(+ at + 1,+ "Every image, swatch and paragraph in this sample is generated in code — no stock assets.",+ ParaFormat { style: "Footnote".into(), ..Default::default() },+ );+ }}// Pull quote with shading, wrapped.let (pq, pqs) = text(diff --git a/crates/idml/src/export.rs b/crates/idml/src/export.rsindex 26f6460ec..4161a4d17 100644--- a/crates/idml/src/export.rs+++ b/crates/idml/src/export.rs@@ -637,6 +637,7 @@ impl<'a> Ex<'a> {),);root.push(El::new("PasteboardPreference").attr("PasteboardMargins", pt(s.pasteboard.0, s.pasteboard.1)));+ root.push(self.footnote_option_el());document(&root)}@@ -1227,6 +1228,79 @@ impl<'a> Ex<'a> {el}+ fn footnote_option_el(&self) -> El {+ let o = &self.d.footnote_options;+ let marker = if o.ref_char_style == st::NO_CHAR_STYLE {+ NO_CHAR_ID.to_string()+ } else {+ names::style_self("CharacterStyle", CHAR_BUILTINS, &o.ref_char_style)+ };+ let enumv = |name: &str, v: &str| {+ let mut e = El::new(name).attr("type", "enumeration");+ e.children.push(Node::Text(v.into()));+ e+ };+ let mut color = El::new("RuleColor").attr("type", "object");+ color.children.push(Node::Text(self.sw(&o.rule.color)));+ let mut el = El::new("FootnoteOption")+ .attr("StartAt", o.start_at)+ .attr("Prefix", &o.prefix)+ .attr("Suffix", &o.suffix)+ .attr("FootnoteTextStyle", names::style_self("ParagraphStyle", PARA_BUILTINS, &o.para_style))+ .attr("FootnoteMarkerStyle", marker)+ .attr("SeparatorText", &o.separator)+ .attr("SpaceBetween", num(o.space_between))+ .attr("Spacer", num(o.space_before))+ .attr("FootnoteFirstBaselineOffset", names::first_baseline_out(o.first_baseline))+ .attr("FootnoteMinimumFirstBaselineOffset", num(o.first_baseline_min))+ .attr("EnableStraddling", bool_s(o.span_columns))+ .attr("RuleOn", bool_s(o.rule.on))+ .attr("RuleLineWeight", num(o.rule.weight))+ .attr("RuleTint", num(o.rule.tint as f64 * 100.0))+ .attr("RuleLeftIndent", num(o.rule.left_indent))+ .attr("RuleWidth", num(o.rule.width))+ .attr("RuleOffset", num(o.rule.offset));+ let restart = names::NOTE_RESTART.iter().find(|r| r.0 == o.restart).map_or("DontRestart", |r| r.1);+ let affix = names::NOTE_AFFIX.iter().find(|r| r.0 == o.affix_in).map_or("NoPrefixSuffix", |r| r.1);+ let mut props = El::new("Properties");+ props.push(enumv("FootnoteNumberingStyle", names::note_style_out(o.style)));+ props.push(enumv("RestartNumbering", restart));+ props.push(enumv("ShowPrefixSuffix", affix));+ props.push(enumv("MarkerPositioning", names::note_marker_out(o.ref_position)));+ props.push(color);+ el.push(props);+ el+ }++ /// `<Footnote>`: the footnote's paragraphs, the first starting with the footnote number marker+ /// and the separator (as InDesign stores them).+ fn footnote_el(&mut self, note: &Story) -> El {+ let mut el = El::new("Footnote");+ let mut paras = self.story_paras(note);+ let lead = vec![Node::Pi("ACE".into(), "4".into()), Node::Text(self.d.footnote_options.separator.clone())];+ if let Some(Node::El(csr)) =+ paras.first_mut().and_then(|p| p.children.iter_mut().find(|n| matches!(n, Node::El(e) if e.name == "CharacterStyleRange")))+ {+ match csr.children.iter_mut().find_map(|n| match n {+ Node::El(c) if c.name == "Content" => Some(c),+ _ => None,+ }) {+ Some(c) => {+ c.children.splice(0..0, lead);+ }+ None => {+ let mut c = El::new("Content");+ c.children = lead;+ csr.children.insert(0, Node::El(c));+ }+ }+ }+ for p in paras {+ el.push(p);+ }+ el+ }+// ---------- stories ----------fn story_el(&mut self, s: &Story) -> El {@@ -1269,6 +1343,7 @@ impl<'a> Ex<'a> {}let nseg = segs.len();for (k, (rr, f)) in segs.into_iter().enumerate() {+ let seg_start = rr.start;let text = &s.text[rr];// Split at break characters.let mut cur = String::new();@@ -1287,7 +1362,7 @@ impl<'a> Ex<'a> {}};let mut out: Vec<Node> = Vec::new();- for ch in text.chars() {+ for (ci, ch) in text.char_indices() {let ace = match ch {st::PAGE_NUMBER | st::NEXT_PAGE_NUMBER | st::PREV_PAGE_NUMBER => Some("18"),st::SECTION_MARKER => Some("19"),@@ -1310,6 +1385,24 @@ impl<'a> Ex<'a> {if let Some(t) = s.para_table(pi) {out.push(Node::El(self.table_el(t)));}+ } else if ch == designcraft_doc::FOOTNOTE_REF {+ // The reference: its own range carrying the reference position.+ flush_text(&mut cur, &mut pending);+ flush_content(&mut pending, &mut out);+ if !out.is_empty() {+ let mut c = self.csr_el(&f);+ c.children.append(&mut out);+ csrs.push(c);+ }+ if let Some(n) = s.notes.get(s.notes_before(seg_start + ci)) {+ let mut c = self.csr_el(&f);+ let pos = self.d.footnote_options.ref_position;+ if pos != designcraft_doc::Position::Normal {+ c.set("Position", names::position_out(pos));+ }+ c.push(self.footnote_el(&n.text));+ csrs.push(c);+ }} else if let Some(bt) = brk {flush_text(&mut cur, &mut pending);flush_content(&mut pending, &mut out);diff --git a/crates/idml/src/import.rs b/crates/idml/src/import.rsindex 6489d9c2d..060fa17e3 100644--- a/crates/idml/src/import.rs+++ b/crates/idml/src/import.rs@@ -115,6 +115,7 @@ struct Importer<'r> {assets: BTreeMap<AssetId, Arc<Asset>>,ctx: ItemCtx,sections: Vec<Section>,+ footnote_options: designcraft_doc::FootnoteOptions,}fn lab_to_color(l: f32, a: f32, b: f32) -> Color {@@ -180,6 +181,7 @@ impl<'r> Importer<'r> {assets: BTreeMap::new(),ctx: ItemCtx { threads: Vec::new() },sections: Vec::new(),+ footnote_options: Default::default(),}}@@ -223,6 +225,9 @@ impl<'r> Importer<'r> {}self.graphics(top);self.styles(top);+ if let Some(e) = top.iter().find(|e| e.local() == "FootnoteOption") {+ self.footnote_option(e);+ }for e in top.iter().filter(|e| e.local() == "Layer") {let id = LayerId(self.alloc());let color = match e.prop_el("LayerColor") {@@ -650,6 +655,54 @@ impl<'r> Importer<'r> {}}+ /// Preferences › `FootnoteOption` (after styles: it names the footnote text and marker styles).+ fn footnote_option(&mut self, e: &El) {+ let mut o = designcraft_doc::FootnoteOptions::default();+ if let Some(v) = e.num("StartAt") {+ o.start_at = v.max(0.0) as u32;+ }+ o.prefix = e.get("Prefix").unwrap_or("").into();+ o.suffix = e.get("Suffix").unwrap_or("").into();+ if let Some(r) = e.get("FootnoteTextStyle") {+ o.para_style = self.para_style_ref(r);+ }+ if let Some(r) = e.get("FootnoteMarkerStyle") {+ o.ref_char_style = self.char_style_ref(r);+ }+ if let Some(v) = e.get("SeparatorText") {+ o.separator = v.into();+ }+ o.space_between = e.num("SpaceBetween").unwrap_or(0.0);+ o.space_before = e.num("Spacer").unwrap_or(0.0);+ if let Some(v) = e.prop("FootnoteFirstBaselineOffset") {+ o.first_baseline = names::first_baseline_in(v.trim());+ }+ o.first_baseline_min = e.num("FootnoteMinimumFirstBaselineOffset").unwrap_or(0.0);+ o.span_columns = e.boolean("EnableStraddling").unwrap_or(false);+ o.rule.on = e.boolean("RuleOn").unwrap_or(true);+ o.rule.weight = e.num("RuleLineWeight").unwrap_or(1.0);+ o.rule.tint = (e.num("RuleTint").unwrap_or(100.0) / 100.0).clamp(0.0, 1.0) as f32;+ o.rule.left_indent = e.num("RuleLeftIndent").unwrap_or(0.0);+ o.rule.width = e.num("RuleWidth").unwrap_or(72.0);+ o.rule.offset = e.num("RuleOffset").unwrap_or(0.0);+ if let Some(c) = e.prop("RuleColor") {+ o.rule.color = self.swatch_ref(c.trim());+ }+ if let Some(v) = e.prop("FootnoteNumberingStyle") {+ o.style = names::note_style_in(v.trim());+ }+ if let Some(v) = e.prop("RestartNumbering") {+ o.restart = names::NOTE_RESTART.iter().find(|r| r.1 == v.trim()).map_or(Default::default(), |r| r.0);+ }+ if let Some(v) = e.prop("ShowPrefixSuffix") {+ o.affix_in = names::NOTE_AFFIX.iter().find(|r| r.1 == v.trim()).map_or(Default::default(), |r| r.0);+ }+ if let Some(v) = e.prop("MarkerPositioning") {+ o.ref_position = names::note_marker_in(v.trim());+ }+ self.footnote_options = o;+ }+fn para_style_ref(&self, r: &str) -> String {self.para_names.get(r).cloned().unwrap_or_else(|| names::style_name_in(PARA_BUILTINS, &unescape_id(r.trim_start_matches("ParagraphStyle/"))))}@@ -827,9 +880,10 @@ impl<'r> Importer<'r> {last: CharFormat::default(),tables: Vec::new(),after_table: None,+ notes: Vec::new(),};self.walk_story(e, &mut b, &ParaFormat::default(), &CharAttrs::default(), &CharFormat::default(), None);- let StoryBuilder { text, mut paras, runs, last, tables: tbls, .. } = b;+ let StoryBuilder { text, mut paras, runs, last, tables: tbls, notes, .. } = b;let mut chars: Vec<CharRun> = runs.into_iter().filter(|r| r.len > 0).collect();if chars.is_empty() {chars.push(CharRun { len: 0, format: last });@@ -841,7 +895,9 @@ impl<'r> Importer<'r> {tables.insert(t.id, Arc::new(t));}}- let mut st = Story { id, text, paras, chars, frames: vec![], rev: 0, tables };+ let notes = notes.into_iter().enumerate().map(|(i, text)| Arc::new(designcraft_doc::Footnote { id: i as u64 + 1, text })).collect();+ let mut st = Story { id, text, paras, chars, frames: vec![], rev: 0, tables, notes };+ st.fix_notes();// Drop anything inconsistent (e.g. a table sharing a paragraph with another).if st.check().is_err() {st.tables.retain(|_, _| false);@@ -1022,9 +1078,21 @@ impl<'r> Importer<'r> {let t = self.table(c);b.push_table(t, pf, cf);}+ "Footnote" => {+ // The text starts with the number marker (ACE 4, dropped) and the separator.+ let mut note = self.story(StoryId(0), c);+ let sep = self.footnote_options.separator.clone();+ if !sep.is_empty() && note.text.starts_with(&sep) {+ note.delete(0..sep.len());+ }+ b.notes.push(note);+ // The reference's position comes from the footnote options.+ let mut rcf = cf.clone();+ rcf.over.position = None;+ b.push(&designcraft_doc::FOOTNOTE_REF.to_string(), &rcf);+ }// Not supported yet: skip their content entirely."Properties"- | "Footnote"| "Note"| "Rectangle"| "Oval"@@ -1488,6 +1556,7 @@ impl<'r> Importer<'r> {user_words: vec![],toc: None,text_variables: designcraft_doc::vars::defaults(),+ footnote_options: std::mem::take(&mut self.footnote_options),created: designcraft_doc::vars::now(),modified: 0,next_id: self.next_id,@@ -1516,6 +1585,8 @@ struct StoryBuilder {tables: Vec<(usize, Table)>,/// Content after a table anchor starts a new paragraph (with this format).after_table: Option<ParaFormat>,+ /// Footnote texts in reference order.+ notes: Vec<Story>,}impl StoryBuilder {diff --git a/crates/idml/src/names.rs b/crates/idml/src/names.rsindex d41a81c8a..878c84103 100644--- a/crates/idml/src/names.rs+++ b/crates/idml/src/names.rs@@ -391,6 +391,7 @@ pub fn number_style_out(n: NumberStyle) -> &'static str {NumberStyle::LowerRoman => "LowerRoman",NumberStyle::UpperLetters => "UpperLetters",NumberStyle::LowerLetters => "LowerLetters",+ NumberStyle::Symbols => "Symbols",}}pub fn number_style_in(s: &str) -> NumberStyle {@@ -399,6 +400,7 @@ pub fn number_style_in(s: &str) -> NumberStyle {"LowerRoman" => NumberStyle::LowerRoman,"UpperLetters" => NumberStyle::UpperLetters,"LowerLetters" => NumberStyle::LowerLetters,+ "Symbols" => NumberStyle::Symbols,_ => NumberStyle::Arabic,}}@@ -462,3 +464,45 @@ pub fn num(v: f64) -> String {pub fn pt(x: f64, y: f64) -> String {format!("{} {}", num(x), num(y))}++// ---------- footnote options ----------++pub fn note_style_out(n: NumberStyle) -> &'static str {+ match n {+ NumberStyle::ArabicLeadingZero => "SingleLeadingZeros",+ n => number_style_out(n),+ }+}+pub fn note_style_in(s: &str) -> NumberStyle {+ match s {+ "SingleLeadingZeros" | "DoubleLeadingZeros" => NumberStyle::ArabicLeadingZero,+ "Asterisks" => NumberStyle::Symbols,+ s => number_style_in(s),+ }+}+pub const NOTE_RESTART: [(designcraft_doc::notes::NoteRestart, &str); 4] = [+ (designcraft_doc::notes::NoteRestart::Never, "DontRestart"),+ (designcraft_doc::notes::NoteRestart::Page, "PageRestart"),+ (designcraft_doc::notes::NoteRestart::Spread, "SpreadRestart"),+ (designcraft_doc::notes::NoteRestart::Section, "SectionRestart"),+];+pub const NOTE_AFFIX: [(designcraft_doc::notes::AffixIn, &str); 4] = [+ (designcraft_doc::notes::AffixIn::None, "NoPrefixSuffix"),+ (designcraft_doc::notes::AffixIn::Reference, "PrefixSuffixReference"),+ (designcraft_doc::notes::AffixIn::Text, "PrefixSuffixMarker"),+ (designcraft_doc::notes::AffixIn::Both, "PrefixSuffixBoth"),+];+pub fn note_marker_out(p: Position) -> &'static str {+ match p {+ Position::Superscript | Position::OtSuperscript => "SuperscriptMarker",+ Position::Subscript | Position::OtSubscript => "SubscriptMarker",+ _ => "NormalMarker",+ }+}+pub fn note_marker_in(s: &str) -> Position {+ match s {+ "SuperscriptMarker" => Position::Superscript,+ "SubscriptMarker" => Position::Subscript,+ _ => Position::Normal,+ }+}diff --git a/crates/idml/src/tests.rs b/crates/idml/src/tests.rsindex 33395750f..1c799e03b 100644--- a/crates/idml/src/tests.rs+++ b/crates/idml/src/tests.rs@@ -182,6 +182,18 @@ fn fixture() -> Vec<u8> {])}+fn fixture_with_story(story: &str) -> Vec<u8> {+ zip_files(&[+ ("designmap.xml", DESIGNMAP),+ ("Resources/Graphic.xml", GRAPHIC),+ ("Resources/Styles.xml", STYLES),+ ("Resources/Preferences.xml", PREFS),+ ("MasterSpreads/MasterSpread_m1.xml", MASTER),+ ("Spreads/Spread_sp1.xml", SPREAD),+ ("Stories/Story_s1.xml", story),+ ])+}+#[test]fn imports_hand_written_fixture() {let d = import_idml_with(&fixture(), &|_| None).unwrap();@@ -364,3 +376,53 @@ fn round_trips_tables() {assert!((bt.columns[0].width - 50.0).abs() < 1e-6);assert_eq!(bt.options.alt_rows.as_ref().map(|a| a.first_color.as_str()), Some("Brand"));}++#[test]+fn round_trips_footnotes_and_options() {+ let mut d = Document::new(&NewDocument::default());+ let lid = d.default_layer();+ let (_, sid) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(40.0, 40.0, 400.0, 400.0), lid, "Body text here.", ParaFormat::default()).unwrap();+ {+ let s = d.story_mut(sid).unwrap();+ s.insert_note(4, "First note.", ParaFormat::default());+ s.insert_note(9, "Second\nnote.", ParaFormat::default());+ }+ d.footnote_options.style = designcraft_doc::NumberStyle::LowerRoman;+ d.footnote_options.restart = designcraft_doc::notes::NoteRestart::Page;+ d.footnote_options.affix_in = designcraft_doc::notes::AffixIn::Both;+ d.footnote_options.prefix = "[".into();+ d.footnote_options.rule.width = 100.0;+ d.footnote_options.space_before = 4.0;+ d.check().unwrap();+ let bytes = export_idml(&d);+ let back = import_idml(&bytes).unwrap();+ back.check().unwrap();+ let s = back.stories.values().next().unwrap();+ assert_eq!(s.text, d.story(sid).unwrap().text);+ assert_eq!(s.notes.len(), 2);+ assert_eq!(s.notes[0].text.text, "First note.");+ assert_eq!(s.notes[1].text.text, "Second\nnote.");+ assert_eq!(back.footnote_options, d.footnote_options);+}++/// The structure InDesign writes: the footnote in its own superscript range, its text starting+/// with the number marker and the separator.+#[test]+fn imports_indesign_style_footnote() {+ let story = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>+<idPkg:Story xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" DOMVersion="16.0">+<Story Self="s1"><ParagraphStyleRange AppliedParagraphStyle="ParagraphStyle/$ID/NormalParagraphStyle">+<CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content>Body text with a</Content></CharacterStyleRange>+<CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]" Position="Superscript"><Footnote>+<ParagraphStyleRange AppliedParagraphStyle="ParagraphStyle/$ID/NormalParagraphStyle"><CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content><?ACE 4?>	A source note.</Content></CharacterStyleRange></ParagraphStyleRange>+</Footnote></CharacterStyleRange>+<CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content> note here.</Content></CharacterStyleRange>+</ParagraphStyleRange></Story></idPkg:Story>"#;+ let d = import_idml(&fixture_with_story(story)).unwrap();+ d.check().unwrap();+ let s = d.stories.values().find(|s| !s.notes.is_empty()).expect("story with a footnote");+ assert_eq!(s.text, format!("Body text with a{} note here.", designcraft_doc::FOOTNOTE_REF));+ assert_eq!(s.notes[0].text.text, "A source note.");+ // One run: the reference takes its position from the options, not an override.+ assert_eq!(s.chars.len(), 1);+}diff --git a/crates/pdf/src/text.rs b/crates/pdf/src/text.rsindex 5a7930f00..cb9521e15 100644--- a/crates/pdf/src/text.rs+++ b/crates/pdf/src/text.rs@@ -106,6 +106,13 @@ impl Exporter<'_> {self.fill_rect(s, r, c);}}+ for n in &ft.notes {+ if let Some(nft) = n.text.frames.first() {+ s.push_transform(&tf(Affine::translate(n.origin.to_vec2())));+ self.frame_text(s, &n.text, nft, &n.source);+ s.pop();+ }+ }}/// Table fragments: cell fills, cell text (real text), edges and the border.diff --git a/crates/render/src/text.rs b/crates/render/src/text.rsindex 98f0b1005..988687576 100644--- a/crates/render/src/text.rs+++ b/crates/render/src/text.rs@@ -263,6 +263,11 @@ impl Renderer {ctx.set_paint(color_of(&designcraft_color::Color::gray(0.35), 0.5));ctx.fill_path(&greek);}+ for n in &ft.notes {+ if let Some(nft) = n.text.frames.first() {+ self.draw_text(ctx, f, &n.text, nft, xf * Affine::translate(n.origin.to_vec2()));+ }+ }}}diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex 540fd58d2..9af474345 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -783,13 +783,18 @@ fn draw_cell_selection(ts: designcraft_doc::TextSel,cell: designcraft_doc::CellAddr,) {- let Some((fi, _, pc)) = compose::find_cell(cs, cell.table, cell.row, cell.col) else { return };+ // Footnote text or a cell: its composed story and where it sits in the frame.+ let found = match cell.footnote_id() {+ Some(id) => compose::find_note(cs, id).map(|(fi, n)| (fi, n.origin, n.text.clone())),+ None => compose::find_cell(cs, cell.table, cell.row, cell.col).map(|(fi, _, pc)| (fi, pc.origin, pc.text.clone())),+ };+ let Some((fi, origin, text)) = found else { return };let Some(ft) = cs.frames.get(fi) else { return };let (Some((a, _)), Some(it)) = (item_canvas_xf(doc, layout, ft.frame), doc.item(ft.frame)) else { return };- let m = a * it.xf * designcraft_geom::Affine::translate(pc.origin.to_vec2());+ let m = a * it.xf * designcraft_geom::Affine::translate(origin.to_vec2());let range = ts.range();if !range.is_empty()- && let Some(cft) = pc.text.frames.first()+ && let Some(cft) = text.frames.first(){for l in &cft.lines {let s = range.start.max(l.range.start);@@ -809,7 +814,10 @@ fn draw_cell_selection(}}if ts.is_caret()- && let Some((_, x, bl, asc, desc)) = compose::cell_caret(cs, cell.table, cell.row, cell.col, ts.focus)+ && let Some((_, x, bl, asc, desc)) = match cell.footnote_id() {+ Some(id) => compose::note_caret(cs, id, ts.focus),+ None => compose::cell_caret(cs, cell.table, cell.row, cell.col, ts.focus),+ }{let m = a * it.xf;let blink = (painter.ctx().input(|i| i.time) * 1.6) as i64 % 2 == 0;diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rsindex 1d5975d17..09f9441b5 100644--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@ -103,6 +103,12 @@ pub fn handle(app: &mut DesignApp, ctx: &egui::Context, req: &ControlRequest) ->let p = &req.params;let s = |k: &str| p.get(k).and_then(Value::as_str);match req.method.as_str() {+ "ui.menu.invoke" if p.get("params").is_none_or(Value::is_null) => {+ // Exactly like choosing the menu item (commands ending in "…" open their dialog).+ let Some(id) = s("command").or(s("id")) else { return err("missing `command`") };+ menus::activate(app, id, &Value::Null);+ ok(json!({"dialog": app.ui.dialog.as_ref().map(|d| d.id.clone())}))+ }"engine.execute" | "ui.menu.invoke" | "command" => {let Some(id) = s("command").or(s("id")) else { return err("missing `command`") };let params = p.get("params").cloned().unwrap_or(json!({}));diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rsindex 77fe43009..c50c38e6e 100644--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@ -37,6 +37,17 @@ impl Dialog {fields.entry(k).or_insert(v);}}+ if id == "footnoteOptions" {+ // Flatten the rule and show special characters as InDesign metacharacters.+ if let Some(Value::Object(r)) = fields.remove("rule") {+ for (k, v) in r {+ fields.insert(format!("rule.{k}"), v);+ }+ }+ let sep = fields.get("separator").and_then(Value::as_str).unwrap_or("").to_string();+ fields.insert("separator".into(), json!(sep.replace('\t', "^t").replace('\u{2003}', "^m").replace('\u{2002}', "^>")));+ fields.entry("tab".to_string()).or_insert(json!("numbering"));+ }if id == "paragraphStyleOptions" {fields.entry("section".to_string()).or_insert(json!("general"));}@@ -63,6 +74,14 @@ impl Dialog {_ => None,}}+ /// A measure in points ("6", "6 pt", "0p6", "2 mm").+ fn pt(&self, k: &str) -> Option<f64> {+ match self.fields.get(k) {+ Some(Value::Number(n)) => n.as_f64(),+ Some(Value::String(s)) => parse_measure(s, Unit::Points).ok(),+ _ => None,+ }+ }fn b(&self, k: &str) -> bool {self.fields.get(k).and_then(Value::as_bool).unwrap_or(false)}@@ -101,7 +120,11 @@ pub fn show(app: &mut DesignApp, ctx: &egui::Context) {"documentSetup" => "Document Setup","findChange" => "Find/Change","paragraphStyleOptions" => "Paragraph Style Options",- _ => "Dialog",+ "footnoteOptions" => "Footnote Options",+ id => match id.strip_prefix("cmd:").and_then(designcraft_engine::find_command) {+ Some(c) => c.label.trim_end_matches('…'),+ None => "Dialog",+ },};egui::Modal::new(egui::Id::new("dialog")).show(ctx, |ui| {ui.set_min_width(380.0);@@ -228,6 +251,8 @@ pub fn show(app: &mut DesignApp, ctx: &egui::Context) {}}"paragraphStyleOptions" => paragraph_style_options(app, ui, &mut d),+ "footnoteOptions" => footnote_options(app, ui, &mut d),+ id if id.starts_with("cmd:") => command_form(ui, &mut d),"goToPage" => {ui.horizontal(|ui| {ui.label("Page");@@ -376,7 +401,55 @@ pub fn confirm(app: &mut DesignApp) -> Result<Value, String> {}app.run("style.paragraph.edit", params)}+ "footnoteOptions" => {+ let pt = |k: &str| d.pt(k).map_or(Value::Null, |v| json!(v));+ let mut p = json!({+ "style": d.s("style"), "startAt": d.n("startAt").unwrap_or(1.0).max(0.0) as u32, "restart": d.s("restart"),+ "prefix": d.s("prefix"), "suffix": d.s("suffix"), "affixIn": d.s("affixIn"), "refPosition": d.s("refPosition"),+ "refCharStyle": d.s("refCharStyle"), "paraStyle": d.s("paraStyle"),+ "separator": d.s("separator").replace("^t", "\t").replace("^m", "\u{2003}").replace("^>", "\u{2002}"),+ "spaceBefore": pt("spaceBefore"), "spaceBetween": pt("spaceBetween"), "firstBaseline": d.s("firstBaseline"),+ "firstBaselineMin": pt("firstBaselineMin"), "spanColumns": d.b("spanColumns"),+ "rule": {"on": d.b("rule.on"), "weight": pt("rule.weight"), "color": d.s("rule.color"), "width": pt("rule.width"),+ "offset": pt("rule.offset"), "leftIndent": pt("rule.leftIndent")},+ });+ // Unparsable measures keep their current values.+ if let Some(o) = p.as_object_mut() {+ o.retain(|_, v| !v.is_null());+ }+ if let Some(r) = p.get_mut("rule").and_then(Value::as_object_mut) {+ r.retain(|_, v| !v.is_null());+ }+ app.run("footnote.options", p)+ }"findChange" => app.run("find.change", json!({"find": d.s("find"), "change": d.s("change"), "grep": d.b("grep"), "caseSensitive": d.b("caseSensitive"), "wholeWord": d.b("wholeWord"), "scope": d.s("scope")})),+ id if id.starts_with("cmd:") => {+ let cid = &id[4..];+ let doc = designcraft_engine::find_command(cid).map_or("", |c| c.params);+ let mut p = Map::new();+ for f in command_fields(doc) {+ match d.fields.get(&f.key) {+ Some(Value::String(v)) if !v.trim().is_empty() => {+ let v = v.trim();+ // Numbers, booleans, arrays and objects as JSON; anything else is a string.+ let parsed = serde_json::from_str::<Value>(v).ok().filter(|x| !x.is_string());+ p.insert(f.key, parsed.unwrap_or_else(|| json!(v)));+ }+ Some(Value::Bool(b)) => {+ p.insert(f.key, json!(b));+ }+ _ => {}+ }+ }+ let r = app.run(cid, Value::Object(p));+ if let Err(e) = &r {+ // Keep the dialog open with the error.+ let mut d = d.clone();+ d.fields.insert("status".into(), json!(e));+ app.ui.dialog = Some(d);+ }+ r+ }other => Err(format!("unknown dialog {other}")),}}@@ -587,3 +660,292 @@ fn paragraph_style_options(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialo});});}++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(shown).width(170.0).show_ui(ui, |ui| {+ for (v, label) in opts {+ if ui.selectable_label(cur == *v, *label).clicked() {+ d.fields.insert(key.into(), json!(v));+ }+ }+ });+}++/// 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(), n.as_str())).collect();+ if character && !names.iter().any(|n| n == designcraft_doc::NO_CHAR_STYLE) {+ opts.insert(0, (designcraft_doc::NO_CHAR_STYLE, designcraft_doc::NO_CHAR_STYLE));+ }+ combo(ui, d, key, &opts);+}++/// 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, label).clicked() {+ d.fields.insert("tab".into(), json!(tab));+ }+ }+ });+ ui.separator();+ let head = |ui: &mut egui::Ui, t: &str| {+ ui.add_space(4.0);+ ui.label(egui::RichText::new(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| {+ ui.label("Minimum Space Before First Footnote:");+ text_field(ui, d, "spaceBefore", 70.0);+ ui.end_row();+ ui.label("Space Between Footnotes:");+ text_field(ui, d, "spaceBetween", 70.0);+ ui.end_row();+ });+ head(ui, "First Baseline");+ egui::Grid::new("fn_fb").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ ui.label("Offset:");+ combo(+ ui,+ d,+ "firstBaseline",+ &[("ascent", "Ascent"), ("capHeight", "Cap Height"), ("leading", "Leading"), ("xHeight", "x Height"), ("fixed", "Fixed")],+ );+ ui.end_row();+ ui.label("Min:");+ text_field(ui, d, "firstBaselineMin", 70.0);+ ui.end_row();+ });+ check(ui, d, "spanColumns", "Span Footnotes Across Columns");+ head(ui, "Rule Above");+ check(ui, d, "rule.on", "Rule On");+ egui::Grid::new("fn_rule").num_columns(4).spacing([8.0, 6.0]).show(ui, |ui| {+ ui.label("Weight:");+ text_field(ui, d, "rule.weight", 60.0);+ ui.label("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();+ ui.label("Width:");+ text_field(ui, d, "rule.width", 60.0);+ ui.label("Offset:");+ text_field(ui, d, "rule.offset", 60.0);+ ui.end_row();+ ui.label("Left Indent:");+ text_field(ui, d, "rule.leftIndent", 60.0);+ ui.end_row();+ });+ return;+ }+ head(ui, "Numbering");+ egui::Grid::new("fn_num").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {+ ui.label("Style:");+ combo(+ 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", "*, †, ‡, §..."),+ ],+ );+ ui.end_row();+ ui.label("Start at:");+ text_field(ui, d, "startAt", 60.0);+ ui.end_row();+ ui.label("Restart Numbering Every:");+ combo(ui, d, "restart", &[("never", "Never (continuous)"), ("page", "Page"), ("spread", "Spread"), ("section", "Section")]);+ ui.end_row();+ ui.label("Show Prefix/Suffix in:");+ combo(ui, d, "affixIn", &[("none", "None"), ("reference", "Footnote Reference"), ("text", "Footnote Text"), ("both", "Both")]);+ ui.end_row();+ ui.label("Prefix:");+ text_field(ui, d, "prefix", 60.0);+ ui.end_row();+ ui.label("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| {+ ui.label("Position:");+ combo(+ ui,+ d,+ "refPosition",+ &[+ ("superscript", "Apply Superscript"),+ ("subscript", "Apply Subscript"),+ ("normal", "Apply Normal"),+ ("otSuperscript", "OpenType Superscript"),+ ],+ );+ ui.end_row();+ ui.label("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| {+ ui.label("Paragraph Style:");+ style_combo(app, ui, d, "paraStyle", false);+ ui.end_row();+ ui.label("Separator:");+ text_field(ui, d, "separator", 60.0);+ ui.end_row();+ });+}++/// One parameter of a command, parsed from its params documentation+/// (`{name, type?: a|b|c, count?, flag?: bool, …}`).+#[derive(Clone, Debug, PartialEq)]+pub struct CommandField {+ pub key: String,+ pub optional: bool,+ /// Enumerated values (`a|b|c`).+ pub choices: Vec<String>,+ pub boolean: bool,+ /// The documented value spec (shown as a hint).+ pub hint: String,+}++/// Parameters of a command from its documentation string: the top-level keys of the first `{…}`.+pub fn command_fields(doc: &str) -> Vec<CommandField> {+ let Some(start) = doc.find('{') else { return vec![] };+ let mut depth = 0i32;+ let mut end = doc.len();+ for (i, c) in doc[start..].char_indices() {+ match c {+ '{' | '[' | '(' => depth += 1,+ '}' | ']' | ')' => {+ depth -= 1;+ if depth == 0 {+ end = start + i;+ break;+ }+ }+ _ => {}+ }+ }+ let body = &doc[start + 1..end];+ let mut parts = Vec::new();+ let (mut depth, mut from) = (0i32, 0usize);+ for (i, c) in body.char_indices() {+ match c {+ '{' | '[' | '(' => depth += 1,+ '}' | ']' | ')' => depth -= 1,+ ',' if depth == 0 => {+ parts.push(&body[from..i]);+ from = i + 1;+ }+ _ => {}+ }+ }+ parts.push(&body[from..]);+ let ident = |s: &str| !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') && !s.starts_with(|c: char| c.is_ascii_digit());+ let mut out = Vec::new();+ for part in parts {+ let part = part.trim();+ let (k, spec) = match part.split_once(':') {+ Some((k, v)) => (k.trim(), v.trim()),+ None => (part, ""),+ };+ 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(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(format!("{}{}", 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![("", "—")];+ opts.extend(f.choices.iter().map(|c| (c.as_str(), c.as_str())));+ 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));+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn parses_command_params() {+ let f = command_fields("{name, type: custom|lastPageNumber|chapterNumber, text?, rule?: {on, weight}, flag?: bool} — creates");+ let keys: Vec<&str> = f.iter().map(|f| f.key.as_str()).collect();+ assert_eq!(keys, ["name", "type", "text", "rule", "flag"]);+ assert_eq!(f[1].choices, ["custom", "lastPageNumber", "chapterNumber"]);+ assert!(!f[0].optional && f[2].optional);+ assert!(f[4].boolean);+ assert!(command_fields("{}").is_empty());+ assert!(command_fields("no params").is_empty());+ // Every command with a "…" label parses without panicking.+ for c in designcraft_engine::command_specs() {+ let _ = command_fields(c.params);+ }+ }+}diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rsindex edb683e32..8733dd2cf 100644--- a/crates/ui-egui/src/menus.rs+++ b/crates/ui-egui/src/menus.rs@@ -17,6 +17,7 @@ pub const UI_COMMANDS: &[(&str, &str, Option<&str>, &str)] = &[("app.palette", "Command Palette…", Some("Cmd+K"), "{}"),("app.findChange", "Find/Change…", Some("Cmd+F"), "{}"),("app.insertTableDialog", "Create Table…", None, "{} — Insert Table dialog (body/header/footer rows, columns)"),+ ("app.footnoteOptionsDialog", "Document Footnote Options…", None, "{} — numbering, formatting and layout of footnotes"),("app.tablePanel", "Table Panel", Some("Shift+F9"), "{}"),("app.storyEditor", "Edit in Story Editor", Some("Cmd+Y"), "{story?}"),("view.zoomIn", "Zoom In", Some("Cmd+="), "{}"),@@ -125,6 +126,10 @@ pub const MENUS: &[(&str, &[&str])] = &["cmd:type.sizeDown","-","ui:view.hiddenCharacters",+ "-",+ "cmd:footnote.insert",+ "ui:app.footnoteOptionsDialog",+ "cmd:footnote.goToReference",],),(@@ -283,6 +288,12 @@ pub fn run_ui(app: &mut DesignApp, id: &str, p: &Value) -> Option<Result<Value,app.ui.dialog = Some(crate::dialogs::Dialog::new("insertTable", p.clone()));Ok(Value::Null)}+ "app.footnoteOptionsDialog" => {+ let Some(st) = app.session.active() else { return Some(Err("no document open".into())) };+ let o = serde_json::to_value(&st.doc.footnote_options).unwrap_or_default();+ app.ui.dialog = Some(crate::dialogs::Dialog::new("footnoteOptions", o));+ Ok(Value::Null)+ }"app.tablePanel" => {app.ui.open_panel = if app.ui.open_panel.as_deref() == Some("table") { None } else { Some("table".into()) };Ok(Value::Null)@@ -602,6 +613,22 @@ pub fn menu_enabled(app: &DesignApp, id: &str) -> bool {enabled(app, id)}+/// A menu item was chosen. An engine command whose label ends in "…" and that takes parameters+/// opens a dialog built from its parameter documentation (see [`crate::dialogs::command_fields`]).+pub fn activate(app: &mut DesignApp, id: &str, params: &Value) {+ if params.is_null()+ && ui_label(id).is_none()+ && let Some(c) = designcraft_engine::find_command(id)+ && c.label.ends_with('…')+ && !crate::dialogs::command_fields(c.params).is_empty()+ {+ app.ui.dialog = Some(crate::dialogs::Dialog::new(&format!("cmd:{id}"), json!({})));+ return;+ }+ let p = if params.is_null() { json!({}) } else { params.clone() };+ let _ = app.run(id, p);+}+/// The menu bar contents (inside the app bar; macOS uses the native menu instead).pub fn menu_bar(app: &mut DesignApp, ui: &mut egui::Ui) {for (menu, entries) in menu_tree() {@@ -632,8 +659,7 @@ fn menu_items(app: &mut DesignApp, ui: &mut egui::Ui, items: &[Item]) {b = b.shortcut_text(shortcut_text(sc));}if ui.add_enabled(menu_enabled(app, id), b).clicked() {- let p = if params.is_null() { json!({}) } else { params.clone() };- let _ = app.run(id, p);+ activate(app, id, params);ui.close();}}diff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex d1a9ef798..8beab07b7 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -10,7 +10,7 @@ Start the app with `--control <port>` (or `DESIGNCRAFT_CONTROL_PORT`). The serve| Method | Params | What it does ||---|---|---|-| `engine.execute` / `ui.menu.invoke` | `{command, params}` | Run any engine or UI command (see `engine.commands`) |+| `engine.execute` / `ui.menu.invoke` | `{command, params}` | Run any engine or UI command (see `engine.commands`). `ui.menu.invoke` without `params` acts like choosing the menu item: a command labelled "…" that takes parameters opens its dialog || `engine.commands` | — | Every command: id, label, menu path, shortcut, params doc, enabled || `document.inspect` | — | Pages, spreads, items, stories (overset), styles, swatches, selection || `ui.inspect` | — | Tool, UI state, view (zoom/origin), canvas rect, perf |