, /// 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, } 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 } } } /// 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. pub fn page_number(&self, abs: usize) -> u32 { let Some(sec) = self.section_of(abs) else { return abs as u32 + 1 }; let start = match sec.start_number { Some(n) => n, None if sec.start == 0 => 1, None => self.page_number(sec.start - 1) + 1, }; start + (abs - sec.start) as u32 } /// The displayed page name ("1", "iv", "A-3"…) for an absolute page index, per sections. 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) } /// 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.find(*f).ok_or(DocError::NoItem(*f))?; match self.item_at(&item).and_then(|i| i.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"))); } } } 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) } }