, /// Custom stroke styles (Object › Stroke Styles). #[serde(default, skip_serializing_if = "Vec::is_empty")] pub stroke_styles: Vec, /// Ink Manager: spot inks printed as process, and spot inks aliased to others. #[serde(default, skip_serializing_if = "InkManager::is_default")] pub inks: InkManager, /// Document Endnote Options, and the story shown in the endnote frame (generated). #[serde(default)] pub endnote_options: EndnoteOptions, #[serde(default, skip_serializing_if = "Option::is_none")] pub endnote_story: Option, /// Conditional text conditions; text whose conditions are all hidden isn't composed. #[serde(default, skip_serializing_if = "Vec::is_empty")] pub conditions: Vec, pub sections: Vec

, #[serde(default)] pub assets: BTreeMap>, /// Hyperlinks (Window → Interactive → Hyperlinks). #[serde(default, skip_serializing_if = "Vec::is_empty")] pub hyperlinks: Vec, /// Data merge: the linked table, placeholders, and the last merge options. #[serde(default, skip_serializing_if = "DataMerge::is_empty")] pub data_merge: DataMerge, /// PDF bookmarks (Window → Interactive → Bookmarks). #[serde(default, skip_serializing_if = "Vec::is_empty")] pub bookmarks: Vec, /// Words added to the document's user dictionary (spelling). #[serde(default, skip_serializing_if = "Vec::is_empty")] pub user_words: Vec, /// User dictionary hyphenation exceptions: `ex~am~ple` (breaks only at `~`), or a word with /// no `~` that never hyphenates. #[serde(default, skip_serializing_if = "Vec::is_empty")] pub hyphenation_exceptions: Vec, /// The generated table of contents (Layout → Table of Contents), kept for Update. #[serde(default, skip_serializing_if = "Option::is_none")] pub toc: Option, /// Text variable definitions (instances in stories are `vars::var_char(index)`). #[serde(default = "vars::defaults")] pub text_variables: Vec, /// Type › Document Footnote Options. #[serde(default)] pub footnote_options: FootnoteOptions, /// Cross-reference formats (Type › Hyperlinks & Cross-References › Cross-Reference Formats). #[serde(default = "xref::default_formats")] pub xref_formats: Vec, /// The generated index (kept for Update Index). #[serde(default, skip_serializing_if = "Option::is_none")] pub index: Option, /// Creation / last save time (Unix seconds, UTC). #[serde(default)] pub created: i64, #[serde(default)] pub modified: i64, pub next_id: u64, /// While the document is open, the font scope of the fonts it brought (its `Document Fonts` /// folder): composition, export and the font menus look its fonts up there. 0: none. Not /// saved. #[serde(skip)] pub font_scope: u32, } /// What a hyperlink is attached to. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase", tag = "kind")] pub enum HyperlinkSource { Item { id: ItemId }, Text { story: StoryId, start: usize, end: usize }, } /// Where a hyperlink goes. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase", tag = "kind", content = "value")] pub enum HyperlinkDest { Url(String), Email(String), /// Absolute page index. Page(usize), } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Hyperlink { pub id: u64, pub name: String, pub source: HyperlinkSource, pub dest: HyperlinkDest, } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct TocEntry { /// Paragraph style whose paragraphs are listed. pub style: String, /// 1-based nesting level. #[serde(default = "one")] pub level: u8, /// Paragraph style of this style's entries; `None` is the generated "TOC Level n" style. #[serde(default, skip_serializing_if = "Option::is_none")] pub entry_style: Option, #[serde(default)] pub page_number: TocPageNumber, /// Text between the entry and its page number; `None` is a tab. #[serde(default, skip_serializing_if = "Option::is_none")] pub separator: Option, /// Character style of the page number; `None` is [None]. #[serde(default, skip_serializing_if = "Option::is_none")] pub page_number_style: Option, /// Character style of the separator; `None` is [None]. #[serde(default, skip_serializing_if = "Option::is_none")] pub separator_style: Option, /// Sort Entries in Alphabetical Order: this style's entries are listed alphabetically among /// their siblings instead of in page order. #[serde(default, skip_serializing_if = "std::ops::Not::not")] pub sort: bool, } impl TocEntry { pub fn new(style: impl Into, level: u8) -> Self { Self { style: style.into(), level, entry_style: None, page_number: TocPageNumber::After, separator: None, page_number_style: None, separator_style: None, sort: false, } } } /// Where an entry's page number goes. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum TocPageNumber { #[default] After, Before, None, } fn one() -> u8 { 1 } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Toc { pub story: StoryId, pub title: String, pub entries: Vec, #[serde(default)] pub page_numbers: bool, /// Paragraph style of the title; `None` is the generated "TOC Title" style. #[serde(default, skip_serializing_if = "Option::is_none")] pub title_style: Option, } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Bookmark { pub name: String, /// Absolute page index. pub page: usize, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub children: Vec, } impl Document { /// Allocate a fresh id. pub fn alloc(&mut self) -> u64 { self.next_id += 1; self.next_id } pub fn page_count(&self) -> usize { self.spreads.iter().map(|s| s.pages.len()).sum() } /// (spread index, page index within spread) for an absolute page index. pub fn page_loc(&self, abs: usize) -> Option<(usize, usize)> { let mut n = 0; for (si, s) in self.spreads.iter().enumerate() { if abs < n + s.pages.len() { return Some((si, abs - n)); } n += s.pages.len(); } None } /// Absolute index of the first page of spread `si`. pub fn first_page_of_spread(&self, si: usize) -> usize { self.spreads[..si.min(self.spreads.len())].iter().map(|s| s.pages.len()).sum() } pub fn page(&self, abs: usize) -> Option<&Page> { let (s, p) = self.page_loc(abs)?; self.spreads[s].pages.get(p) } /// Iterate all pages with their absolute index and spread index. pub fn pages(&self) -> impl Iterator { self.spreads.iter().enumerate().flat_map(|(si, s)| s.pages.iter().map(move |p| (si, p))).enumerate().map(|(i, (si, p))| (i, si, p)) } /// The section containing absolute page `abs`. pub fn section_of(&self, abs: usize) -> Option<&Section> { self.sections.iter().filter(|s| s.start <= abs).max_by_key(|s| s.start) } /// The page number (before formatting) of absolute page `abs`, per sections. A section without /// a start number continues from the previous section. /// Saturates at `u32::MAX`, so start numbers loaded from a file can't overflow it. pub fn page_number(&self, abs: usize) -> u32 { // Walks back through continuing sections iteratively: one section per step, never recursing. let (mut abs, mut offset) = (abs, 0u32); loop { let Some(sec) = self.section_of(abs) else { return u32::try_from(abs).unwrap_or(u32::MAX).saturating_add(1).saturating_add(offset); }; let into = u32::try_from(abs - sec.start).unwrap_or(u32::MAX).saturating_add(offset); match sec.start_number { Some(n) => return n.saturating_add(into), None if sec.start == 0 => return into.saturating_add(1), None => { offset = into.saturating_add(1); abs = sec.start - 1; } } } } /// The displayed page name ("1", "iv", "A-3"…) for an absolute page index, per sections. /// The chapter number in its style (`3`, `III`, `c`, `03`). pub fn chapter_label(&self) -> String { self.settings.chapter_style.format(self.settings.chapter_number.max(1)) } pub fn page_name(&self, abs: usize) -> String { let Some(sec) = self.section_of(abs) else { return (abs + 1).to_string() }; let num = sec.style.format(self.page_number(abs)); if sec.include_prefix { format!("{}{}", sec.prefix, num) } else { num } } pub fn layer(&self, id: LayerId) -> Option<&Layer> { self.layers.iter().find(|l| l.id == id) } pub fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer> { self.layers.iter_mut().find(|l| l.id == id) } /// Stacking rank of a layer: 0 = backmost. pub fn layer_rank(&self, id: LayerId) -> usize { self.layers.iter().position(|l| l.id == id).map(|i| self.layers.len() - 1 - i).unwrap_or(0) } pub fn default_layer(&self) -> LayerId { self.layers.first().map(|l| l.id).unwrap_or_default() } pub fn story(&self, id: StoryId) -> Option<&Story> { self.stories.get(&id).map(|s| &**s) } pub fn story_mut(&mut self, id: StoryId) -> Option<&mut Story> { self.stories.get_mut(&id).map(Arc::make_mut) } pub fn swatch(&self, name: &str) -> Option<&Swatch> { self.swatches.iter().find(|s| s.name == name) } /// Resolve a swatch reference to a display colour. /// A shadow's light angle: its own, or the document's Global Light. pub fn light_angle(&self, angle: f64, global: bool) -> f64 { if global { self.settings.global_light } else { angle } } pub fn resolve_color(&self, swatch: &str, tint: f32) -> Option { designcraft_color::swatch::resolve(&self.swatches, swatch, tint) } /// Give items that reuse an earlier item's id (spreads, then parents, then items anchored in /// stories) fresh ids, so a file holding such duplicates opens. The first item keeps the id and /// what refers to it by id; a renumbered text frame takes its place in its story's thread. pub fn renumber_duplicate_items(&mut self) { fn walk_mut(it: &mut Item, f: &mut impl FnMut(&mut Item)) { f(it); for c in it.children_mut().into_iter().flatten() { walk_mut(Arc::make_mut(c), f); } } fn story_items(st: &mut Story, f: &mut impl FnMut(&mut Item)) { for o in &mut st.objects { walk_mut(&mut Arc::make_mut(o).item, f); } for t in st.tables.values_mut() { for c in &mut Arc::make_mut(t).cells { story_items(&mut c.text, f); } } for n in st.notes.iter_mut().chain(st.endnotes.iter_mut()) { story_items(&mut Arc::make_mut(n).text, f); } } let mut seen = std::collections::HashSet::new(); let mut dups = std::collections::HashSet::new(); let mut next = self.next_id; let mut note = |id: ItemId| { next = next.max(id.0); if !seen.insert(id) { dups.insert(id); } }; for sp in self.spreads.iter().chain(self.parents.iter()) { for it in &sp.items { it.walk(&mut |i| note(i.id)); } } for (_, i) in self.anchored_items() { note(i.id); } if dups.is_empty() { return; } let mut seen = std::collections::HashSet::new(); // (story, id in the file) → the ids its frames carry now, in walk order. let mut threads: std::collections::HashMap<(StoryId, ItemId), Vec> = std::collections::HashMap::new(); let mut fix = |it: &mut Item| { let old = it.id; if !dups.contains(&old) { return; } if !seen.insert(old) { // An id at the top of the range has no successor: leave the duplicate for // `check()` to refuse rather than overflow. let Some(n) = next.checked_add(1) else { return }; next = n; it.id = ItemId(next); } if let Some(t) = it.text_frame() { threads.entry((t.story, old)).or_default().push(it.id); } }; for sp in self.spreads.iter_mut().chain(self.parents.iter_mut()) { for it in &mut Arc::make_mut(sp).items { walk_mut(Arc::make_mut(it), &mut fix); } } for st in self.stories.values_mut() { story_items(Arc::make_mut(st), &mut fix); } self.next_id = next; for ((sid, old), ids) in threads { let Some(st) = self.stories.get_mut(&sid) else { continue }; let st = Arc::make_mut(st); let mut ids = ids.into_iter(); for f in st.frames.iter_mut().filter(|f| **f == old) { match ids.next() { Some(id) => *f = id, None => break, } } st.frames.extend(ids); } } /// Validate structural invariants (ids unique, threads consistent, stories well-formed). pub fn check(&self) -> Result<()> { for f in &self.styles.composite_fonts { if f.entries.iter().any(|e| { ![e.relative_size, e.horizontal_scale, e.vertical_scale].iter().all(|v| v.is_finite() && *v > 0.0) || !e.baseline_shift.is_finite() }) { return Err(DocError::Invalid(format!("invalid composite font metrics: {}", f.name))); } } for t in &self.styles.mojikumi_tables { if t.overrides.iter().any(|r| ![r.minimum, r.desired, r.maximum].iter().all(|v| v.is_finite())) { return Err(DocError::Invalid(format!("non-finite mojikumi spacing: {}", t.name))); } } let mut ids = std::collections::HashSet::new(); for sp in self.spreads.iter().chain(self.parents.iter()) { for it in &sp.items { let mut dup = None; it.walk(&mut |i| { if !ids.insert(i.id.0) { dup = Some(i.id); } }); if let Some(d) = dup { return Err(DocError::Invalid(format!("duplicate item id {d}"))); } } } for (sid, st) in &self.stories { st.check().map_err(DocError::Invalid)?; if st.id != *sid { return Err(DocError::Invalid(format!("story key {sid} != id {}", st.id))); } for f in &st.frames { let item = self.item(*f).or_else(|| self.anchored_item(*f)).ok_or(DocError::NoItem(*f))?; match item.text_frame().map(|t| t.story) { Some(s) if s == *sid => {} other => return Err(DocError::Invalid(format!("frame {f} in story {sid} points at {other:?}"))), } } } // Every text frame is in its story's thread. for sp in self.spreads.iter().chain(self.parents.iter()) { for it in &sp.items { let mut bad = None; it.walk(&mut |i| { if let Some(t) = i.text_frame() && !self.stories.get(&t.story).is_some_and(|s| s.frames.contains(&i.id)) { bad = Some(i.id); } }); if let Some(b) = bad { return Err(DocError::Invalid(format!("text frame {b} not in its story's thread"))); } } } let embedded = self.anchored_items(); let mut edges: std::collections::HashMap> = std::collections::HashMap::new(); for (owner, item) in embedded { if !ids.insert(item.id.0) { return Err(DocError::Invalid(format!("duplicate item id {}", item.id))); } if let Some(tf) = item.text_frame() { if !self.stories.get(&tf.story).is_some_and(|s| s.frames.contains(&item.id)) { return Err(DocError::Invalid(format!("embedded text frame {} not in its story's thread", item.id))); } edges.entry(owner).or_default().push(tf.story); } } // Reject cycles and excessive nesting before renderers follow embedded frames. fn visit( id: StoryId, edges: &std::collections::HashMap>, path: &mut Vec, done: &mut std::collections::HashMap, ) -> Result { if path.contains(&id) || path.len() >= 64 { return Err(DocError::Invalid("cyclic or excessively nested anchored text frames".into())); } if let Some(&height) = done.get(&id) { return Ok(height); } path.push(id); let mut height = 1; if let Some(children) = edges.get(&id) { for &child in children { height = height.max(1 + visit(child, edges, path, done)?); } } path.pop(); if height > 64 { return Err(DocError::Invalid("excessively nested anchored text frames".into())); } done.insert(id, height); Ok(height) } let mut done = std::collections::HashMap::new(); for &id in edges.keys() { visit(id, &edges, &mut Vec::new(), &mut done)?; } if self.next_id < ids.iter().copied().max().unwrap_or(0) { return Err(DocError::Invalid("next_id behind existing ids".into())); } // Ids are allocated by counting up from `next_id`: leave room so that can't overflow. if self.next_id > MAX_NEXT_ID { return Err(DocError::Invalid(format!("next_id {} out of range", self.next_id))); } Ok(()) } } #[cfg(test)] mod tests; impl Document { /// Mutable styles (copy-on-write). pub fn styles_mut(&mut self) -> &mut Styles { Arc::make_mut(&mut self.styles) } }