From 6883798c2d57ddbb30deb7d970ce8dd965d7390f Mon Sep 17 00:00:00 2001 From: aiongg <67543387+aiongg@users.noreply.github.com> Date: Wed, 7 Oct 2026 18:58:05 +0000 Subject: [PATCH] refactor: split src/model/mod.rs into modules by area Pure moves: IDs (ids), the Reader core (reader), Document and Reader::document (document), spreads and pages (spread), page items and graphics (item), stories (story), styles (style), document-level settings (settings) and name searches (strings). tools/diff_outputs.py: 0 of 4,274 outputs differ. --- CLAUDE.md | 6 + src/model/document.rs | 593 +++++++ src/model/ids.rs | 233 +++ src/model/item.rs | 798 ++++++++++ src/model/mod.rs | 3427 +---------------------------------------- src/model/reader.rs | 87 ++ src/model/settings.rs | 291 ++++ src/model/spread.rs | 598 +++++++ src/model/story.rs | 585 +++++++ src/model/strings.rs | 62 + src/model/style.rs | 228 +++ 11 files changed, 3506 insertions(+), 3402 deletions(-) create mode 100644 src/model/document.rs create mode 100644 src/model/ids.rs create mode 100644 src/model/item.rs create mode 100644 src/model/reader.rs create mode 100644 src/model/settings.rs create mode 100644 src/model/spread.rs create mode 100644 src/model/story.rs create mode 100644 src/model/strings.rs create mode 100644 src/model/style.rs diff --git a/CLAUDE.md b/CLAUDE.md index 6734024..3c4789d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -29,6 +29,12 @@ now). Licence: MIT OR Apache-2.0. - `src/header.rs`, `src/container.rs`: decoded layers (see `docs/format/`). - `src/audit.rs`: records what a conversion reads, for `indd audit`. +- `src/model/`: the document model. `reader` (typed object access), + `document` (`Reader::document`), and one module per area: `spread`, + `item`, `story`, `style`, `settings`, `table`, `color`, `font`, … +- `src/idml/`: the IDML writer. `mod.rs` has `write`; one module per + package part (`designmap`, `resources`, `styles`, `spread`, `story`), + plus `attrs` (attribute tables), `format`, `pages`, `values`. - `docs/measurement.md`: how `compare.py` and the audit measure the converter (stale pairs, value coverage, exclusions). - `tests/fixtures.rs`: smoke tests on open-licensed samples listed in diff --git a/src/model/document.rs b/src/model/document.rs new file mode 100644 index 0000000..0ddae4b --- /dev/null +++ b/src/model/document.rs @@ -0,0 +1,593 @@ +//! The `Document` model and `Reader::document`, which reads the document +//! object and every class the converter knows into it. +//! +//! Evidence: `docs/format/objects.md` (document object and classes). + +use super::*; + +/// The XML structure of the document. +#[derive(Debug, Clone, Default, PartialEq)] +pub struct XmlStructure { + /// The backing story, IDML `XmlStory`. + pub story: Option, + pub elements: BTreeMap, +} + +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Document { + pub version: Version, + pub layers: Vec, + pub active_layer: Option, + /// Document users (chunk 0xA443): flag byte and name. + pub users: Vec<(u8, String)>, + /// Index sort groups (preferences chunk 0x1307E), in order: name, + /// include flag and header variant. + pub index_groups: Vec<(String, bool, u16)>, + /// The constant shade the document lists (the class 0x5533 object of + /// lowest UID with a constant shade in chunk 0x5532): its UID and its + /// u32 and three f64; and its name (chunk 0x5531: a flag byte, 1 for + /// a built-in key, and the name). + pub constant_shade: Option, + /// Assignment objects (class 0x1BE01), in UID order. + pub assignments: Vec, + /// Named grids (class 0xCD12, chunk 0xCD28: u32, a flag byte, 1 for + /// a built-in key, and the name), in UID order. + pub named_grids: Vec<(bool, String)>, + pub spreads: Vec, + pub master_spreads: Vec, + pub stories: Vec, + pub styles: BTreeMap, + pub toc_styles: Vec, + pub colors: Vec, + /// Tint swatches, with their IDML reference and name. + pub tints: Vec<(Tint, String, String)>, + pub gradients: Vec, + /// IDML reference (`Color/...`, `Swatch/None`) for each swatch UID. + pub swatches: BTreeMap, + /// Font families by UID. + pub fonts: BTreeMap, + /// The language objects (class 0x2D07) in UID order. + pub language_list: Vec, + /// Language name (IDML `AppliedLanguage` without `$ID/`) for each + /// language UID. + pub languages: BTreeMap, + /// Style groups, including the root groups (empty name). + pub style_groups: BTreeMap, + pub object_styles: BTreeMap, + pub cell_styles: BTreeMap, + pub table_styles: BTreeMap, + pub sections: Vec
, + pub text_variables: Vec, + pub hyperlinks: Vec, + pub text_sources: BTreeMap, + pub destinations: Vec, + pub bookmarks: BTreeMap, + /// All bookmarks in document order (document chunk 0x13501). + pub bookmark_order: Vec, + /// Cross-reference formats, by UID. + pub cross_reference_formats: BTreeMap, + /// Problems that did not stop the conversion (content left out). + pub warnings: Vec, + pub preferences: Option, + /// Other preference values (`prefs.rs`). + pub prefs: prefs::Prefs, + pub composite_fonts: Vec, + /// Kinsoku and mojikumi tables, in UID order. + pub cjk_tables: Vec, + /// Inks, in UID order. + pub inks: Vec, + /// Colour groups in document order, the root group first. + pub color_groups: Vec, + /// The bullet characters offered for lists (preferences chunk 0x1A488). + pub bullets: Vec, + /// XML tags (class 0xBF19): name and colour (red, green, blue). + pub xml_tags: Vec<(String, Option<[f64; 3]>)>, + pub xml: XmlStructure, +} + +impl<'a> Reader<'a> { + pub fn document(&self, version: Version) -> Result { + let doc = 1; + let layers = self + .uid_list(doc, chunk::DOC_LAYERS)? + .into_iter() + .map(|uid| self.layer(uid)) + .collect::, _>>()?; + let active_layer = self + .chunk(doc, chunk::DOC_ACTIVE_LAYER)? + .map(|d| Cursor::new(&d).u32()) + .transpose()?; + let mut spreads = self + .uid_list(doc, chunk::DOC_SPREADS)? + .into_iter() + .map(|uid| self.spread(uid)) + .collect::, _>>()?; + let mut master_spreads = self + .uid_list(doc, chunk::DOC_MASTER_SPREADS)? + .into_iter() + .map(|uid| self.spread(uid)) + .collect::, _>>()?; + resolve_page_layout(&mut spreads, &mut master_spreads); + let stories = self + .uid_list(doc, chunk::DOC_STORIES)? + .into_iter() + .filter(|&uid| self.class(uid) == Some(class::STORY)) + .map(|uid| self.story(uid)) + .collect::, _>>()?; + let mut styles = BTreeMap::new(); + let mut colors = Vec::new(); + let mut tint_objects = Vec::new(); + let mut gradients = Vec::new(); + let mut swatches = BTreeMap::new(); + let mut fonts = BTreeMap::new(); + let mut languages = BTreeMap::new(); + let mut language_list = Vec::new(); + let mut style_groups = BTreeMap::new(); + let mut object_styles = BTreeMap::new(); + let mut cell_styles = BTreeMap::new(); + let mut table_styles = BTreeMap::new(); + let mut text_variables = Vec::new(); + let mut hyperlinks = Vec::new(); + let mut text_sources = BTreeMap::new(); + let mut destinations = Vec::new(); + let mut bookmarks = BTreeMap::new(); + let mut cross_reference_formats = BTreeMap::new(); + let mut composite_fonts = Vec::new(); + let mut composite_entries = HashMap::new(); + let mut cjk_tables = Vec::new(); + let mut xml_tags = Vec::new(); + let mut xml_tag_names = HashMap::new(); + let mut inks = Vec::new(); + let mut color_groups = HashMap::new(); + for &(uid, cls) in self.db.classes() { + if self.db.object(uid)?.is_none() { + continue; + } + // An object that cannot be read is left out with a warning. + let read = (|| -> Result<(), Error> { + match cls { + class::STYLE_ROOT_GROUP + | class::OBJECT_STYLE_ROOT_GROUP + | class::CELL_STYLE_ROOT_GROUP + | class::TABLE_STYLE_ROOT_GROUP => { + let kind = match self.chunk(uid, chunk::ROOT_GROUP_KIND)? { + Some(d) => Cursor::new(&d).u32()?, + None => 0, + }; + let mut children = Vec::new(); + for id in [ + chunk::STYLE_ROOT_CHILDREN, + chunk::OBJECT_STYLE_ROOT_CHILDREN, + table::chunk::CELL_STYLE_ROOT_CHILDREN, + table::chunk::TABLE_STYLE_ROOT_CHILDREN, + ] { + if children.is_empty() { + children = self.children(uid, id)?; + } + } + style_groups.insert( + uid, + StyleGroup { + uid, + name: String::new(), + root: Some(kind), + children, + }, + ); + } + class::STYLE_GROUP => { + let name = match self.chunk(uid, chunk::STYLE_GROUP_NAME)? { + Some(d) if d.len() > 1 => { + let mut c = Cursor::new(&d); + c.flag()?; + c.string()? + } + _ => String::new(), + }; + let children = self.children(uid, chunk::STYLE_GROUP_CHILDREN)?; + style_groups.insert( + uid, + StyleGroup { + uid, + name, + root: None, + children, + }, + ); + } + class::OBJECT_STYLE => { + if let Some(d) = self.chunk(uid, chunk::OBJECT_STYLE_INFO)? { + let mut c = Cursor::new(&d); + let based_on = c.u32()?; + let builtin = c.flag()? == 1; + let name = c.string()?; + object_styles.insert( + uid, + ObjectStyle { + uid, + name, + builtin, + based_on: uid_or_none(based_on), + fitting: match self.chunk(uid, chunk::OBJECT_STYLE_FITTING)? { + Some(d) => Attrs::parse_short(&d, List::ObjectStyleFitting) + .unwrap_or_default(), + None => Attrs::default(), + }, + attrs: match self.chunk(uid, chunk::OBJECT_STYLE_ATTRS)? { + Some(d) => Attrs::parse_short(&d, List::ObjectStyle) + .unwrap_or_default(), + None => Attrs::default(), + }, + // The layout is known for these sizes + // only (`docs/format/big-endian.md`). + frame: match self.chunk(uid, chunk::OBJECT_STYLE_FRAME)? { + Some(d) if !matches!(d.len(), 106 | 142 | 162 | 222) => { + self.warn(format!( + "object style {uid}: text frame settings of {} bytes are not known; left out", + d.len() + )); + None + } + d => d, + }, + story: self.chunk(uid, chunk::OBJECT_STYLE_STORY)?, + direction: match self + .chunk(uid, chunk::OBJECT_STYLE_DIRECTION)? + { + Some(d) if d.len() >= 2 => Some(Cursor::new(&d).u16()?), + _ => None, + }, + text_wrap: self.wrap_chunk(uid, chunk::OBJECT_STYLE_WRAP)?, + contour_type: match self + .chunk(uid, chunk::OBJECT_STYLE_CONTOUR)? + { + Some(d) if d.len() >= 4 => Some(Cursor::new(&d).u32()?), + _ => None, + }, + enabled: match self.chunk(uid, chunk::OBJECT_STYLE_ENABLED)? { + Some(d) => Some(Cursor::new(&d).u32_list()?), + None => None, + }, + paragraph_style: match self + .chunk(uid, chunk::OBJECT_STYLE_PARAGRAPH_STYLE)? + { + Some(d) if d.len() >= 4 => Some(Cursor::new(&d).u32()?), + _ => None, + }, + anchor: self.chunk(uid, chunk::ANCHOR_SETTINGS)?, + }, + ); + } + } + class::STYLE => { + if let Some(style) = self.style(uid)? { + styles.insert(uid, style); + } + } + table::class::CELL_STYLE => { + if let Some(s) = self.table_style(uid, table::chunk::CELL_STYLE_ATTRS)? { + cell_styles.insert(uid, s); + } + } + table::class::TABLE_STYLE => { + if let Some(s) = self.table_style(uid, table::chunk::TABLE_STYLE_ATTRS)? { + table_styles.insert(uid, s); + } + } + color::class::COLOR => { + if self.db.object(uid)?.is_none() { + return Ok(()); + } + let obj = self.object(uid)?; + if let Some(c) = Color::read(uid, &obj)? { + if c.model_name().is_none() { + self.warn(format!( + "colour {uid}: colour model code {} is not known; left out", + c.model + )); + } + swatches.insert(uid, c.reference()); + colors.push(c); + } else if let Some(t) = Tint::read(uid, &obj)? { + tint_objects.push(t); + } + } + color::class::SWATCH_NONE => { + swatches.insert(uid, "Swatch/None".into()); + } + color::class::GRADIENT => { + if let Some(g) = Gradient::read(uid, &*self.object(uid)?)? { + for i in 1..g.stops.len() { + if g.idml_midpoint(i).is_none() { + self.warn(format!( + "gradient {uid}: midpoint before stop {i} is not \ + within 13–87 %; left out" + )); + } + } + swatches.insert(uid, g.reference()); + gradients.push(g); + } + } + class::FONT_FAMILY => match FontFamily::read(uid, &*self.object(uid)?) { + Ok(Some(f)) => { + if i32::try_from(f.writing_script).is_err() { + self.warn(format!( + "font family {uid}: writing script {:#x} is not an IDML \ + integer; left out", + f.writing_script + )); + } + fonts.insert(uid, f); + } + Ok(None) => {} + // Keep the name, which text formatting refers to. + Err(e) => { + self.warn(format!("font family {uid}: fonts left out: {e}")); + if let Some(d) = self.chunk(uid, font::chunk::FAMILY)? { + fonts.insert( + uid, + FontFamily { + uid, + name: find_string(&d, 0)?, + fonts: Vec::new(), + writing_script: 0, + }, + ); + } + } + }, + class::TEXT_VARIABLE => { + if let Some(v) = TextVariable::read(uid, &*self.object(uid)?)? { + text_variables.push(v); + } + } + hyperlink::class::HYPERLINK => { + if let Some(h) = Hyperlink::read(uid, &*self.object(uid)?)? { + hyperlinks.push(h); + } + } + hyperlink::class::TEXT_SOURCE => { + if let Some(s) = TextSource::read(uid, &*self.object(uid)?)? { + text_sources.insert(uid, s); + } + } + hyperlink::class::PAGE_DESTINATION | hyperlink::class::URL_DESTINATION => { + if let Some(d) = Destination::read(uid, cls, &*self.object(uid)?)? { + if let hyperlink::DestinationKind::Page { zoom: None, .. } = d.kind { + self.warn(format!( + "destination {uid}: view zoom is outside 5–4000 %; left out" + )); + } + destinations.push(d); + } + } + xref::CLASS => { + if let Some(f) = CrossReferenceFormat::read(uid, &*self.object(uid)?)? { + cross_reference_formats.insert(uid, f); + } + } + hyperlink::class::BOOKMARK => { + if let Some(b) = Bookmark::read(uid, &*self.object(uid)?)? { + bookmarks.insert(uid, b); + } + } + cjk::class::COMPOSITE_FONT => { + if let Some((name, entries)) = CompositeFont::read(&*self.object(uid)?)? { + composite_fonts.push((uid, name, entries)); + } + } + cjk::class::COMPOSITE_FONT_ENTRY => { + if let Some(e) = CompositeFontEntry::read(uid, &*self.object(uid)?)? { + composite_entries.insert(uid, e); + } + } + c if c == cjk::class::MOJIKUMI || cjk::class::KINSOKU.contains(&c) => { + if let Some(t) = CjkTable::read(uid, c, &*self.object(uid)?)? { + cjk_tables.push(t); + } + } + color::class::INK => { + if let Some(i) = Ink::read(uid, &*self.object(uid)?)? { + if i.neutral_density.is_none() { + self.warn(format!( + "ink {uid}: neutral density is outside 0.001–10; left out" + )); + } + inks.push(i); + } + } + color::class::COLOR_GROUP => { + if let Some(g) = ColorGroup::read(uid, &*self.object(uid)?)? { + color_groups.insert(uid, g); + } + } + class::XML_TAG => { + // Chunk 0xBF2F: u32 length, then the name as text + // segments; chunk 0x117: the UID of the tag's colour. + if let Some(d) = self.chunk(uid, chunk::XML_TAG_NAME)? { + let mut c = Cursor::new(&d); + let n = c.u32()? as usize; + // Files from InDesign 2.0 to 4.0 hold a flag byte and + // an in-object string instead. + let name = match c.segments(n) { + Ok(name) => name, + Err(_) => { + let mut c = Cursor::new(&d); + c.flag()?; + c.string()? + } + }; + let color = match self.chunk(uid, chunk::XML_TAG_COLOR)? { + Some(d) if d.len() >= 4 => self.ui_color(Cursor::new(&d).u32()?)?, + _ => None, + }; + xml_tag_names.insert(uid, name.clone()); + xml_tags.push((name, color)); + } + } + class::LANGUAGE => { + if let Some(d) = self.chunk(uid, chunk::LANGUAGE_NAME)? + && d.len() > 1 + { + let mut c = Cursor::new(&d); + c.flag()?; + let name = c.string()?; + languages.insert(uid, name.clone()); + // Then the primary and secondary names, u16 + // ID, and two vendors (flag, u32, string). + let rest = (|| -> Result<_, Error> { + c.flag()?; + let primary = c.string()?; + c.flag()?; + let sub = c.string()?; + let id = c.u16()?; + let mut vendor = || -> Result<(u8, String), Error> { + let flag = c.u8()?; + c.u32()?; + Ok((flag, c.string()?)) + }; + let spelling = vendor()?; + let hyphenation = vendor()?; + Ok((primary, sub, id, [spelling, hyphenation])) + })(); + if let Ok((primary, sub, id, vendors)) = rest { + language_list.push(Language { + uid, + name, + primary, + sub, + id, + vendors: Some(vendors), + }); + } + } + } + _ => {} + } + Ok(()) + })(); + if let Err(e) = read { + self.warn(format!("object {uid} (class {cls:#x}) left out: {e}")); + } + } + // The backing story: the document's chunk 0xBF14 names it and the + // document node. + let xml_story = match self.chunk(doc, xml::chunk::NODE_REF)? { + Some(d) if d.len() >= 4 => { + let s = Cursor::new(&d).u32()?; + match self.class(s) { + Some(class::STORY) => Some(self.story(s)?), + _ => None, + } + } + _ => None, + }; + let mut stories = stories; + for story in &mut stories { + story.orientation = self.story_orientation(story.uid); + } + let xml = XmlStructure { + story: xml_story, + elements: self.xml_elements(&xml_tag_names)?, + }; + let mut tints = Vec::new(); + for t in tint_objects { + match colors + .iter() + .find(|c| c.uid == t.base && !c.name.is_empty()) + { + Some(base) => { + let reference = t.reference(base); + swatches.insert(t.uid, reference.clone()); + tints.push((t.clone(), reference, t.idml_name(base))); + } + None => self.warn(format!( + "tint {}: left out: base colour {} has no name", + t.uid, t.base + )), + } + } + prune_style_groups(&mut style_groups, |m| self.warn(m)); + let preferences = self.document_preferences()?; + let prefs = self.prefs(version.major)?; + Ok(Document { + version, + layers, + active_layer, + spreads, + master_spreads, + stories, + styles, + colors, + tints, + gradients, + swatches, + fonts, + languages, + language_list, + toc_styles: self.toc_styles(), + named_grids: self.named_grids(), + index_groups: self.index_groups(), + constant_shade: self.constant_shade(), + assignments: { + let mut a: Vec = self + .db + .classes() + .iter() + .filter(|&&(_, c)| c == class::ASSIGNMENT) + .map(|&(u, _)| u) + .collect(); + a.sort_unstable(); + a + }, + style_groups, + object_styles, + cell_styles, + table_styles, + users: self.users(doc).unwrap_or_else(|e| { + self.warn(format!("document users left out: {e}")); + Vec::new() + }), + sections: self + .uid_list(doc, chunk::DOC_SECTIONS)? + .into_iter() + .map(|uid| self.section(uid)) + .collect::, _>>()?, + text_variables, + hyperlinks, + text_sources, + destinations, + bookmarks, + bookmark_order: match self.chunk(doc, hyperlink::chunk::DOCUMENT_LISTS)? { + Some(d) => hyperlink::document_bookmarks(&d, version.major)?, + None => Vec::new(), + }, + cross_reference_formats, + warnings: self.warnings.borrow().clone(), + preferences, + prefs, + composite_fonts: composite_fonts + .into_iter() + .map(|(uid, name, entries)| CompositeFont { + uid, + name, + entries: entries + .iter() + .filter_map(|e| composite_entries.get(e).cloned()) + .collect(), + }) + .collect(), + cjk_tables, + inks, + color_groups: self + .color_group_order()? + .into_iter() + .filter_map(|u| color_groups.remove(&u)) + .collect(), + bullets: self.bullets()?, + xml_tags, + xml, + }) + } +} diff --git a/src/model/ids.rs b/src/model/ids.rs new file mode 100644 index 0000000..eb7fb80 --- /dev/null +++ b/src/model/ids.rs @@ -0,0 +1,233 @@ +//! Class, chunk and strand IDs and the enumeration codes the model reads. +//! +//! Evidence: each constant's section in `docs/format/` (mostly +//! `objects.md`). + +/// Class IDs. +pub mod class { + pub const DOCUMENT: u32 = 0xE01; + pub const SPREAD: u32 = 0x501; + pub const MASTER_SPREAD: u32 = 0x1401; + pub const SPREAD_LAYER: u32 = 0x301; + pub const LAYER: u32 = 0x302; + pub const PAGE: u32 = 0x50F; + pub const SPLINE_ITEM: u32 = 0x6201; + pub const GROUP: u32 = 0x401; + pub const MULTI_COLUMN_FRAME: u32 = 0x263; + pub const FRAME_COLUMN: u32 = 0x227; + pub const FRAME_LIST: u32 = 0x228; + pub const STORY: u32 = 0x201; + pub const STYLE: u32 = 0x205; + pub const SECTION: u32 = 0x4C01; + pub const IMAGE: u32 = 0x1702; + pub const PDF: u32 = 0x2501; + pub const EPS: u32 = 0x6601; + pub const SVG: u32 = 0x6639; + /// A plain byte stream, such as the file of an embedded graphic. + pub const RAW_DATA: u32 = 0x129; + pub const FONT_FAMILY: u32 = 0x3E03; + pub const LANGUAGE: u32 = 0x2D07; + pub const TOC_STYLE: u32 = 0x11605; + pub const NAMED_GRID: u32 = 0xCD12; + pub const ASSIGNMENT: u32 = 0x1BE01; + pub const SMOOTH_SHADE: u32 = 0x5533; + /// Holds an item anchored in text. + pub const ANCHOR: u32 = 0x262; + pub const TEXT_VARIABLE_INSTANCE: u32 = 0xCA64; + pub const TEXT_VARIABLE: u32 = 0xCAB4; + pub const STYLE_ROOT_GROUP: u32 = 0xCA8C; + pub const STYLE_GROUP: u32 = 0xCA8B; + pub const OBJECT_STYLE: u32 = 0x1B901; + pub const OBJECT_STYLE_ROOT_GROUP: u32 = 0x1B972; + pub const CELL_STYLE_ROOT_GROUP: u32 = 0x20241; + pub const TABLE_STYLE_ROOT_GROUP: u32 = 0x1044F; + /// Document-wide preferences. + pub const PREFERENCES: u32 = 0x2202; + pub const GUIDE: u32 = 0x3301; + pub const XML_TAG: u32 = 0xBF19; + /// A colour used in the interface (XML tags). + pub const UI_COLOR: u32 = 0x1F11; + /// A colour profile: its name (chunk 0x13C). + pub const COLOR_PROFILE: u32 = 0x7D03; + /// Page item defaults. + pub const ITEM_DEFAULTS: u32 = 0x6E07; +} + +/// Chunk IDs. +pub mod chunk { + pub const DOC_SPREADS: u32 = 0x501; + pub const DOC_MASTER_SPREADS: u32 = 0x1401; + pub const DOC_LAYERS: u32 = 0x301; + pub const DOC_ACTIVE_LAYER: u32 = 0x313; + pub const DOC_STORIES: u32 = 0x222; + pub const DOC_SECTIONS: u32 = 0x4C01; + /// Document users: u32 count, then per user a flag byte, the name + /// and u32 colour. + pub const DOC_USERS: u32 = 0xA443; + pub const SPREAD_CHILDREN: u32 = 0x503; + pub const SPREAD_TRANSFORM: u32 = 0x56E; + pub const SPREAD_BINDING: u32 = 0x1B8; + pub const SPREAD_LAYER_LAYER: u32 = 0x302; + pub const SPREAD_LAYER_CHILDREN: u32 = 0x303; + pub const LAYER_PROPS: u32 = 0x304; + /// u16 0 if document pages may shuffle across the spread. + pub const SPREAD_SHUFFLE: u32 = 0x1A8; + /// Flattener settings of a spread. + pub const SPREAD_FLATTENER: u32 = 0x10833; + /// Tab orders: u32 count, then per page u32 page and a UID list. + pub const SPREAD_TAB_ORDERS: u32 = 0x14580; + /// u16 0 if a master spread hides the items of its own master. + pub const MASTER_SHOW_ITEMS: u32 = 0x140D; + /// Overridden master page items: u32 count, two UID lists. + pub const PAGE_OVERRIDES: u32 = 0x1404; + /// Layout grid use: six bytes, the last u16 1 to use the master's. + pub const PAGE_GRID_USE: u32 = 0xCD04; + /// Layout rule: u32, then u32 code. + pub const PAGE_LAYOUT_RULE: u32 = 0x563; + /// Page colour: u32 0 none, 1 the master's, else an interface colour. + pub const PAGE_COLOR: u32 = 0x5FF; + pub const PAGE_MASTER: u32 = 0x140F; + pub const PAGE_TRANSFORM: u32 = 0x5CC; + pub const PAGE_BOUNDS: u32 = 0x5DD; + /// Page bounds in files from InDesign 3.0 and 4.0. + pub const OLD_PAGE_BOUNDS: u32 = 0x154; + pub const PAGE_MARGINS: u32 = 0x51A; + pub const PAGE_COLUMNS: u32 = 0x528; + pub const PAGE_GRID: u32 = 0xCD02; + pub const ITEM_TRANSFORM: u32 = 0x151; + /// A group's transform when it has no chunk 0x151. + pub const GROUP_TRANSFORM: u32 = 0x40D; + /// u16 1 for a frame meant for a graphic. + pub const ITEM_CONTENT: u32 = 0x1623; + pub const ITEM_PATHS: u32 = 0x162B; + pub const ITEM_HIERARCHY: u32 = 0x15B; + pub const COLUMN_FRAME_LIST: u32 = 0x220; + pub const FRAME_LIST_FRAMES: u32 = 0x205; + pub const STORY_STRANDS: u32 = 0x223; + /// The table of contents (class 0x8C20) that made a story. + pub const STORY_TOC: u32 = 0x8C40; + /// The TOC style of a table of contents. + pub const TOC_STYLE_OF: u32 = 0x11613; + pub const TOC_STYLE: u32 = 0x11605; + pub const NAMED_GRID: u32 = 0xCD28; + pub const STRAND_DATA: u32 = 0x261; + pub const STRAND_RUNS: u32 = 0x262; + pub const STYLE_INFO: u32 = 0x230; + pub const ITEM_ATTRS: u32 = 0x6E03; + pub const STYLE_ATTRS: u32 = 0x23F; + pub const LANGUAGE_NAME: u32 = 0x2D0F; + pub const ANCHOR_CHILDREN: u32 = 0x2C8; + /// Anchored object settings, of an anchor or an object style. + pub const ANCHOR_SETTINGS: u32 = 0x2800; + pub const MASTER_NAME: u32 = 0x1402; + pub const STYLE_ROOT_CHILDREN: u32 = 0x28DC; + pub const STYLE_GROUP_CHILDREN: u32 = 0x28D3; + pub const STYLE_GROUP_NAME: u32 = 0x28D2; + pub const OBJECT_STYLE_INFO: u32 = 0x1B907; + pub const OBJECT_STYLE_ROOT_CHILDREN: u32 = 0x1B95A; + pub const ITEM_OBJECT_STYLE: u32 = 0x1B916; + /// Page item name: u8 1 if a built-in key, then an in-object string. + pub const ITEM_NAME: u32 = 0x2C10; + /// The same for a group. + pub const GROUP_NAME: u32 = 0x418; + /// u16, then u32 shape code: 1 line, 2 or 3 rectangle, 4 or 5 + /// oval, 0 or 6 to 8 polygon, 9 none. + pub const ITEM_SHAPE: u32 = 0x6204; + /// u32 1 if the page item is locked. + pub const ITEM_LOCKED: u32 = 0x2C2D; + /// u16 0 if the page item is hidden. + pub const ITEM_VISIBLE: u32 = 0x2C32; + /// Override of a master page item: u32 master item, then a list of + /// attribute IDs. + pub const ITEM_OVERRIDE: u32 = 0x1424; + /// Interface change counts: u32 count *n*, then *n* pairs of u32. + pub const ITEM_PARENT_CHANGES: u32 = 0x21D4E; + pub const ITEM_TARGET_CHANGES: u32 = 0x21D50; + pub const ITEM_UPDATED_CHANGES: u32 = 0x21D53; + /// u8 layout constraint flags. + pub const ITEM_LAYOUT_CONSTRAINTS: u32 = 0x22228; + pub const ROOT_GROUP_KIND: u32 = 0x28C2; + pub const SECTION_INFO: u32 = 0x4C02; + pub const DOCUMENT_PREFERENCES: u32 = 0x533; + /// Shading of a pasted smooth shade. + pub const SMOOTH_SHADE: u32 = 0x5532; + pub const SMOOTH_SHADE_NAME: u32 = 0x5531; + /// Index sort groups, in the preferences object. + pub const INDEX_GROUPS: u32 = 0x1307E; + pub const XML_TAG_NAME: u32 = 0xBF2F; + pub const XML_TAG_COLOR: u32 = 0x117; + /// Bullet characters, in the preferences object. + pub const BULLETS: u32 = 0x1A488; + pub const FRAME_COLUMNS: u32 = 0x2D1; + pub const FRAME_COLUMN_RULE: u32 = 0x22646; + pub const FRAME_COLUMN_RULE_OVERRIDE: u32 = 0x2265A; + pub const FRAME_FOOTNOTES: u32 = 0x22608; + pub const FRAME_IGNORE_WRAP: u32 = 0x3730; + /// Inset spacing of a text frame (on the frame, not its columns). + pub const FRAME_INSET: u32 = 0x3723; + pub const FRAME_JUSTIFICATION: u32 = 0x2CE; + /// Matrix of a multi-column frame; its first four values give the + /// text orientation. + pub const FRAME_TEXT_TRANSFORM: u32 = 0x2DE; + pub const GRAPHIC_BOUNDS: u32 = 0x1633; + pub const GRAPHIC_LINK: u32 = 0x8CBC; + pub const LINK_INFO: u32 = 0x8C9B; + pub const LINK_RESOURCE_URI: u32 = 0x8C92; + /// Pasted image without a link: u32 raw data object. + pub const IMAGE_DATA: u32 = 0x8C23; + /// Pasted PDF without a link: u32 raw data object. + pub const PDF_DATA: u32 = 0x2521; + pub const SWATCH_NAME: u32 = 0x1F30; + pub const TEXT_WRAP: u32 = 0x3703; + pub const CONTOUR_OPTION: u32 = 0x373D; + pub const CLIPPING_PATH: u32 = 0x2C1A; + pub const PHOTOSHOP_CLIPPING: u32 = 0x8C39; + /// Frame fitting attributes of an object style (u16 count, records). + pub const OBJECT_STYLE_FITTING: u32 = 0x1B956; + /// Page item attributes of an object style (u16 count, records). + pub const OBJECT_STYLE_ATTRS: u32 = 0x1B92B; + pub const OBJECT_STYLE_FRAME: u32 = 0x1B924; + pub const OBJECT_STYLE_STORY: u32 = 0x285B; + pub const OBJECT_STYLE_DIRECTION: u32 = 0x50F28; + pub const OBJECT_STYLE_WRAP: u32 = 0x3776; + pub const OBJECT_STYLE_CONTOUR: u32 = 0x3777; + pub const OBJECT_STYLE_ENABLED: u32 = 0x1B92E; + pub const OBJECT_STYLE_PARAGRAPH_STYLE: u32 = 0x1B946; + pub const GUIDE: u32 = 0x3308; +} + +/// Kinds of strand run data (first u32 of chunk 0x262). +pub mod strand { + pub const TEXT: u32 = 0x202; + pub const CHARACTER_STYLE: u32 = 0x203; + pub const PARAGRAPH_STYLE: u32 = 0x204; + /// Objects owned by text positions (anchored items, tables, ...). + pub const OWNED_ITEMS: u32 = 0x209; + /// Which object (story, or table and cell) each stretch of text belongs to. + pub const TEXT_OWNER: u32 = 0x2A4; +} + +/// Text wrap mode codes. +pub mod wrap_mode { + pub const NONE: u32 = 0; + pub const JUMP_OBJECT: u32 = 1; + pub const BOUNDING_BOX: u32 = 3; + pub const CONTOUR: u32 = 6; +} + +/// Values of chunk 0x28C2, the kind of a root style group. +pub mod root_kind { + pub const PARAGRAPH: u32 = 0xCA0C; + pub const CHARACTER: u32 = 0xCA0D; + pub const OBJECT: u32 = 0x1B924; + pub const TABLE: u32 = 0xB668; + pub const CELL: u32 = 0xB669; +} + +/// Page number style codes of sections. +pub mod numbering { + pub const ARABIC: u32 = 0x4C15; + pub const LOWER_ROMAN: u32 = 0x4C17; + /// Chinese numerals, written digit by digit. + pub const KANJI: u32 = 0x4C12; +} diff --git a/src/model/item.rs b/src/model/item.rs new file mode 100644 index 0000000..a61d15d --- /dev/null +++ b/src/model/item.rs @@ -0,0 +1,798 @@ +//! Page items: geometry (transforms and paths), groups, frames and shapes, +//! their settings, text wrap, text frame preferences, placed graphics and +//! links. +//! +//! Evidence: `docs/format/objects.md` (page items, graphics, links), +//! `attributes.md` (page item attributes) and `transparency.md`. + +use super::*; + +/// A 2D affine transform `[a b c d tx ty]`, as in IDML `ItemTransform`. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct Matrix(pub [f64; 6]); + +impl Matrix { + pub const IDENTITY: Matrix = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, 0.0]); + + pub(super) fn read(c: &mut Cursor) -> Result { + let mut m = [0.0; 6]; + for v in &mut m { + *v = c.f64()?; + } + Ok(Matrix(m)) + } +} + +pub type Point = (f64, f64); + +#[derive(Debug, Clone, PartialEq)] +pub struct PathPoint { + pub anchor: Point, + pub left: Point, + pub right: Point, + /// The stored point type: 2 a corner without direction points, 0 or + /// 1 a point with them. + pub kind: u32, +} + +#[derive(Debug, Clone, PartialEq)] +pub struct Path { + pub points: Vec, + pub open: bool, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Shape { + Rectangle, + Oval, + Polygon, + GraphicLine, +} + +#[derive(Debug, Clone, PartialEq)] +pub enum ItemKind { + TextFrame { + story: Option, + previous: Option, + next: Option, + preferences: Option, + }, + Shape(Shape), + Group, +} + +#[derive(Debug, Clone, PartialEq)] +pub struct PageItem { + pub uid: u32, + /// Placed graphics (images, PDF, EPS, SVG) inside a frame. + pub graphics: Vec, + pub kind: ItemKind, + pub transform: Matrix, + pub paths: Vec, + /// Document layer; `None` for items anchored in text. + pub layer: Option, + /// Local formatting (fill, stroke, corners, ...). + pub attrs: Attrs, + pub object_style: Option, + pub children: Vec, + /// Text wrap (chunk 0x3703); `None` if the item has none. + pub text_wrap: Option, + /// Anchored object settings (chunk 0x2800 of the anchor), for an item + /// anchored in text. + pub anchor: Option>, + pub props: ItemProps, +} + +/// Settings every page item has. See `docs/format/objects.md`, page item +/// settings. +#[derive(Debug, Clone, PartialEq, Default)] +pub struct ItemProps { + /// The name (chunk 0x2C10, of a group 0x418); `None` without the + /// chunk. + pub name: Option, + /// Chunk 0x2C32 is 0. + pub hidden: bool, + /// Chunk 0x2C2D is 1. + pub locked: bool, + /// Layout constraint flags (chunk 0x22228). + pub layout_constraints: Option, + /// The parent, target and last updated interface change counts + /// (chunks 0x21D4E, 0x21D50, 0x21D53), each a list of numbers. + pub change_counts: [Vec; 3], + /// The overridden master page item (0 for none) and the IDs of the + /// attributes overridden (chunk 0x1424). + pub overridden: Option<(u32, Vec)>, + /// Chunk 0x1623 is 1: a frame for a graphic (`ContentType` + /// `GraphicType` without a graphic). + pub graphic_frame: bool, +} + +/// A page item name: a built-in key or a name given by the user. +#[derive(Debug, Clone, PartialEq)] +pub struct ItemName { + pub builtin: bool, + pub name: String, +} + +/// Text wrap settings of a page item or graphic (chunk 0x3703). +#[derive(Debug, Clone, PartialEq)] +pub struct TextWrap { + /// Wrap mode code (see `wrap_mode`). + pub mode: u32, + /// The four offsets: left, top, right, bottom. + pub offsets: [f64; 4], + /// The u32 at offset 40; 1 in every sample whose IDML has + /// `Inverse="false"`, `ApplyToMasterPageOnly="false"` and + /// `TextWrapSide="BothSides"`. + pub flags: u32, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum GraphicKind { + Image, + Pdf, + Eps, + Svg, +} + +#[derive(Debug, Clone, PartialEq)] +pub struct Link { + pub uid: u32, + /// `LinkResourceURI`, for example `file:/Users/me/image.jpg`. + pub uri: String, + /// The linked file is stored in the document (`StoredState="Embedded"`). + pub embedded: bool, +} + +/// The bytes of a file stored in the document, if there is one. +pub(super) type EmbeddedFile = Option>; + +#[derive(Debug, Clone, PartialEq)] +pub struct Graphic { + pub uid: u32, + pub kind: GraphicKind, + pub transform: Matrix, + /// Left, top, right, bottom in the graphic's own coordinates. + pub bounds: [f64; 4], + pub link: Option, + /// The graphic's file, when the document holds it: an embedded link or + /// a graphic pasted without a link. IDML writes it as `Contents`. + pub contents: Option>, + pub text_wrap: Option, + /// Contour type code of the text wrap (chunk 0x373D): 5 = SameAsClipping. + pub contour_type: Option, + /// Clipping path settings (chunk 0x2C1A), if stored. + pub clipping: Option, + /// Chunk 0x8C39, u16 at 0: apply the Photoshop clipping path (1 true). + pub photoshop_clipping: Option, +} + +/// Clipping path settings of a graphic (chunk 0x2C1A, 37 bytes): u32 type +/// at 0, f64 tolerance at 4, f64 inset at 12, u8 threshold at 20, i16 +/// index at 23, u8 at 25 (2 = use the high-resolution image). See +/// `docs/format/objects.md`. +#[derive(Debug, Clone, PartialEq)] +pub struct ClippingPath { + pub kind: u32, + pub tolerance: f64, + pub inset: f64, + pub threshold: u8, + pub index: i16, + pub high_resolution: u8, +} + +/// Text frame settings, from the frame's multi-column frame object. +#[derive(Debug, Clone, PartialEq)] +pub struct TextFramePreferences { + pub column_count: u32, + pub column_gutter: f64, + pub column_fixed_width: f64, + /// First baseline offset code (chunk 0x2CE, u16 at 0): 0 LeadingOffset, + /// 1 AscentOffset, 2 CapHeight, 3 EmboxHeight. + pub first_baseline_offset: u16, + pub vertical_justification: u16, + pub vertical_balance_columns: bool, + pub auto_sizing_type: u16, + pub auto_sizing_reference_point: u16, + /// Chunk 0x2D1: u8 at 12 and, in 40-byte chunks, f64 at 32. + pub use_fixed_width: bool, + pub max_width: Option, + /// Chunk 0x2CE (48 bytes): u16 at 26 and f64 at 28 (minimum height), + /// u16 at 36 and f64 at 38 (minimum width), u16 at 46 (no line + /// breaks). + pub minimum_sizes: Option<([bool; 2], [f64; 2], bool)>, + /// Chunk 0x3730: u16 ignore text wrap. + pub ignore_wrap: Option, + /// Column rule (chunk 0x22646): f64 width at 28, u32 colour at 36. + pub column_rule: Option<(f64, u32)>, + /// Chunk 0x2265A: all zero in every sample but one. + pub column_rule_override: Option, + /// Footnote options (chunk 0x22608): u32, f64 minimum spacing, f64 + /// space between. + pub footnotes: Option<[f64; 2]>, + /// Inset spacing (the frame's chunk 0x3723): top, left, bottom, right. + pub inset: [f64; 4], +} + +/// Groups nested deeper than this are left out, with a warning, so that a +/// damaged file cannot exhaust the stack. +pub(super) const MAX_ITEM_DEPTH: usize = 100; + +/// The IDML element of a frame or shape: by the shape code of chunk +/// 0x6204 (`code`), and where it has none (9, or no chunk), by the path. +/// See `docs/format/objects.md`, page items. +pub(super) fn classify(paths: &[Path], code: Option) -> Shape { + match code { + Some(1) => return Shape::GraphicLine, + Some(2 | 3) => return Shape::Rectangle, + Some(4 | 5) => return Shape::Oval, + Some(0 | 6..=8) => return Shape::Polygon, + _ => {} + } + let [path] = paths else { + return Shape::Polygon; + }; + let corners = path + .points + .iter() + .all(|p| p.left == p.anchor && p.right == p.anchor); + if path.open && path.points.len() == 2 { + return Shape::GraphicLine; + } + if !path.open && path.points.len() == 4 && corners { + let xs: Vec = path.points.iter().map(|p| p.anchor.0).collect(); + let ys: Vec = path.points.iter().map(|p| p.anchor.1).collect(); + let distinct = |v: &[f64]| { + let mut v: Vec = v.iter().map(|x| (x * 1e6).round() as i64).collect(); + v.sort_unstable(); + v.dedup(); + v.len() + }; + if distinct(&xs) == 2 && distinct(&ys) == 2 { + return Shape::Rectangle; + } + } + if !path.open + && path.points.len() == 4 + && path + .points + .iter() + .all(|p| p.left != p.anchor && p.kind == 0) + { + return Shape::Oval; + } + Shape::Polygon +} + +impl<'a> Reader<'a> { + /// Text orientation of a multi-column frame (chunk 0x2DE): the + /// identity gives horizontal text, the rotation 0 1 −1 0 vertical + /// text (`docs/format/objects.md`). `None` without the chunk; + /// `Some(None)` for another matrix. + pub(super) fn frame_orientation(&self, mcf: u32) -> Result>, Error> { + let Some(d) = self.chunk(mcf, chunk::FRAME_TEXT_TRANSFORM)? else { + return Ok(None); + }; + if d.len() < 48 { + return Ok(Some(None)); + } + let Matrix([a, b, c, dd, _, _]) = Matrix::read(&mut Cursor::new(&d))?; + Ok(Some(match [a, b, c, dd] { + [1.0, 0.0, 0.0, 1.0] => Some(Orientation::Horizontal), + [0.0, 1.0, -1.0, 0.0] => Some(Orientation::Vertical), + _ => None, + })) + } + + /// Text frame settings of frame `frame`, from its multi-column frame + /// `mcf` and the frame itself. + pub(super) fn text_frame_preferences( + &self, + frame: u32, + mcf: u32, + ) -> Result, Error> { + let (Some(cols), Some(just)) = ( + self.chunk(mcf, chunk::FRAME_COLUMNS)?, + self.chunk(mcf, chunk::FRAME_JUSTIFICATION)?, + ) else { + return Ok(None); + }; + if cols.len() < 22 || just.len() < 28 { + return Ok(None); + } + let minimum_sizes = (just.len() >= 48).then(|| { + let flag = |at| u16_at(&just, at).is_some_and(|v| v != 0); + ( + [flag(26), flag(36)], + [ + f64_at(&just, 28).unwrap_or(0.0), + f64_at(&just, 38).unwrap_or(0.0), + ], + flag(46), + ) + }); + let column_rule = match self.chunk(mcf, chunk::FRAME_COLUMN_RULE)? { + Some(d) => match (f64_at(&d, 28), u32_at(&d, 36)) { + (Some(w), Some(c)) => Some((w, c)), + _ => None, + }, + None => None, + }; + let footnotes = match self.chunk(mcf, chunk::FRAME_FOOTNOTES)? { + Some(d) => match (f64_at(&d, 4), f64_at(&d, 12)) { + (Some(a), Some(b)) => Some([a, b]), + _ => None, + }, + None => None, + }; + // The frame's chunk 0x3723: f64, u32, then four f64: left, top, + // right, bottom. + let inset = match self.chunk(frame, chunk::FRAME_INSET)? { + Some(d) if d.len() >= 44 => { + let f = |at| f64_at(&d, at).unwrap_or(0.0); + [f(20), f(12), f(36), f(28)] + } + _ => [0.0; 4], + }; + Ok(Some(TextFramePreferences { + column_count: Cursor::new(&cols).u32()?, + column_gutter: Cursor::new(&cols[4..]).f64()?, + column_fixed_width: Cursor::new(&cols[14..]).f64()?, + first_baseline_offset: Cursor::new(&just).u16()?, + vertical_justification: Cursor::new(&just[2..]).u16()?, + vertical_balance_columns: Cursor::new(&just[20..]).u16()? != 0, + auto_sizing_type: Cursor::new(&just[22..]).u16()?, + auto_sizing_reference_point: Cursor::new(&just[24..]).u16()?, + use_fixed_width: cols.get(12).is_some_and(|&b| b != 0), + max_width: if cols.len() >= 40 { + f64_at(&cols, 32) + } else { + None + }, + minimum_sizes, + ignore_wrap: self + .chunk(mcf, chunk::FRAME_IGNORE_WRAP)? + .and_then(|d| u16_at(&d, 0)) + .map(|v| v != 0), + column_rule, + column_rule_override: self + .chunk(mcf, chunk::FRAME_COLUMN_RULE_OVERRIDE)? + .map(|d| d.iter().any(|&b| b != 0)), + footnotes, + inset, + })) + } + + /// The settings every page item has (`ItemProps`). + pub(super) fn item_props(&self, uid: u32) -> Result { + let name_chunk = if self.class(uid) == Some(class::GROUP) { + chunk::GROUP_NAME + } else { + chunk::ITEM_NAME + }; + let name = match self.chunk(uid, name_chunk)? { + Some(d) => { + let mut c = Cursor::new(&d); + let builtin = c.flag()? == 1; + Some(ItemName { + builtin, + name: c.string()?, + }) + } + None => None, + }; + let counts = |id: u32| -> Result, Error> { + let Some(d) = self.chunk(uid, id)? else { + return Ok(Vec::new()); + }; + let mut c = Cursor::new(&d); + let n = c.u32()? as usize; + if n > d.len() / 8 { + return Err(Error::Corrupt(format!("item {uid}: {n} change counts"))); + } + (0..2 * n).map(|_| c.u32()).collect() + }; + let overridden = match self.chunk(uid, chunk::ITEM_OVERRIDE)? { + Some(d) => { + let mut c = Cursor::new(&d); + let master = c.u32()?; + Some((master, c.u32_list()?)) + } + None => None, + }; + Ok(ItemProps { + name, + hidden: self + .chunk(uid, chunk::ITEM_VISIBLE)? + .is_some_and(|d| d.len() >= 2 && Cursor::new(&d).u16().ok() == Some(0)), + locked: self + .chunk(uid, chunk::ITEM_LOCKED)? + .is_some_and(|d| d.len() >= 4 && Cursor::new(&d).u32().ok() == Some(1)), + layout_constraints: self + .chunk(uid, chunk::ITEM_LAYOUT_CONSTRAINTS)? + .and_then(|d| d.first().copied()), + change_counts: [ + counts(chunk::ITEM_PARENT_CHANGES)?, + counts(chunk::ITEM_TARGET_CHANGES)?, + counts(chunk::ITEM_UPDATED_CHANGES)?, + ], + overridden, + graphic_frame: self + .chunk(uid, chunk::ITEM_CONTENT)? + .is_some_and(|d| d.len() >= 2 && Cursor::new(&d).u16().ok() == Some(1)), + }) + } + + /// Text wrap of a page item or graphic, from chunk 0x3703: u32 mode, + /// u32 contour path object, four f64 offsets, u32 flags. + pub(super) fn text_wrap(&self, uid: u32) -> Result, Error> { + self.wrap_chunk(uid, chunk::TEXT_WRAP) + } + + /// A text wrap record in chunk `id` of object `uid`. + pub(super) fn wrap_chunk(&self, uid: u32, id: u32) -> Result, Error> { + let Some(d) = self.chunk(uid, id)? else { + return Ok(None); + }; + if d.len() < 44 { + return Ok(None); + } + let mut c = Cursor::new(&d); + let mode = c.u32()?; + c.skip(4)?; + let offsets = [c.f64()?, c.f64()?, c.f64()?, c.f64()?]; + let flags = c.u32()?; + if !matches!( + mode, + wrap_mode::NONE | wrap_mode::JUMP_OBJECT | wrap_mode::BOUNDING_BOX | wrap_mode::CONTOUR + ) { + self.warn(format!( + "item {uid}: text wrap mode {mode} is not known; left out" + )); + } + Ok(Some(TextWrap { + mode, + offsets, + flags, + })) + } + + pub(super) fn paths(&self, uid: u32) -> Result, Error> { + let Some(data) = self.chunk(uid, chunk::ITEM_PATHS)? else { + return Ok(Vec::new()); + }; + let mut c = Cursor::new(&data); + let n = c.u32()?; + let mut paths = Vec::new(); + for _ in 0..n { + let count = c.u32()?; + let mut points = Vec::new(); + for _ in 0..count { + let kind = c.u32()?; + let p = match kind { + 2 => { + let a = (c.f64()?, c.f64()?); + PathPoint { + anchor: a, + left: a, + right: a, + kind, + } + } + 0 | 1 => { + let left = (c.f64()?, c.f64()?); + let anchor = (c.f64()?, c.f64()?); + let right = (c.f64()?, c.f64()?); + PathPoint { + anchor, + left, + right, + kind, + } + } + other => { + return Err(Error::Corrupt(format!( + "object {uid}: unknown path point type {other}" + ))); + } + }; + points.push(p); + } + let open = c.u16()? != 0; + paths.push(Path { points, open }); + } + Ok(paths) + } + + /// A page item and the items it contains. An item that contains + /// itself, or one nested more than [`MAX_ITEM_DEPTH`] deep, is left + /// out with a warning. + pub(super) fn page_item( + &self, + uid: u32, + layer: Option, + ) -> Result, Error> { + let cls = self.class(uid); + if cls != Some(class::SPLINE_ITEM) && cls != Some(class::GROUP) { + return Ok(None); + } + { + let path = self.item_path.borrow(); + if path.contains(&uid) { + drop(path); + self.warn(format!("item {uid} contains itself; left out")); + return Ok(None); + } + if path.len() >= MAX_ITEM_DEPTH { + drop(path); + self.warn(format!( + "item {uid} is nested more than {MAX_ITEM_DEPTH} deep; left out" + )); + return Ok(None); + } + } + self.item_path.borrow_mut().push(uid); + let item = self.page_item_contents(uid, cls, layer); + self.item_path.borrow_mut().pop(); + item + } + + pub(super) fn page_item_contents( + &self, + uid: u32, + cls: Option, + layer: Option, + ) -> Result, Error> { + // Groups without chunk 0x151 have their transform in chunk 0x40D. + let transform = match self.chunk(uid, chunk::ITEM_TRANSFORM)? { + Some(d) => Matrix::read(&mut Cursor::new(&d))?, + None => match self.chunk(uid, chunk::GROUP_TRANSFORM)? { + Some(d) if cls == Some(class::GROUP) && d.len() >= 48 => { + Matrix::read(&mut Cursor::new(&d))? + } + _ => Matrix::IDENTITY, + }, + }; + let child_uids = self.children(uid, chunk::ITEM_HIERARCHY)?; + let mut children = Vec::new(); + let mut graphics = Vec::new(); + let mut text_column = None; + let mut frame_prefs = None; + let mut frame_mcf = None; + for &child in &child_uids { + if let Some(g) = self.graphic(child)? { + graphics.push(g); + } else if self.class(child) == Some(class::MULTI_COLUMN_FRAME) { + frame_prefs = self.text_frame_preferences(uid, child)?; + frame_mcf = Some(child); + text_column = self + .children(child, chunk::ITEM_HIERARCHY)? + .into_iter() + .find(|&c| self.class(c) == Some(class::FRAME_COLUMN)); + } else if let Some(item) = self.page_item(child, layer)? { + children.push(item); + } + } + let paths = self.paths(uid)?; + let attrs = match self.chunk(uid, chunk::ITEM_ATTRS)? { + Some(d) => Attrs::parse(&d, List::Item).unwrap_or_default(), + None => Attrs::default(), + }; + let object_style = match self.chunk(uid, chunk::ITEM_OBJECT_STYLE)? { + Some(d) => uid_or_none(Cursor::new(&d).u32()?), + None => None, + }; + let kind = if cls == Some(class::GROUP) { + ItemKind::Group + } else if let Some(column) = text_column { + let mut kind = self.text_frame_links(column)?; + if let ItemKind::TextFrame { + preferences, story, .. + } = &mut kind + { + *preferences = frame_prefs; + if let (Some(story), Some(mcf)) = (*story, frame_mcf) + && let Some(o) = self.frame_orientation(mcf)? + { + self.frame_orientations + .borrow_mut() + .entry(story) + .or_default() + .push(o); + } + } + kind + } else { + let code = self + .chunk(uid, chunk::ITEM_SHAPE)? + .and_then(|d| u32_at(&d, 2)); + ItemKind::Shape(classify(&paths, code)) + }; + Ok(Some(PageItem { + uid, + graphics, + kind, + transform, + paths, + layer, + attrs, + object_style, + children, + text_wrap: self.text_wrap(uid)?, + anchor: None, + props: self.item_props(uid).unwrap_or_else(|e| { + self.warn(format!("item {uid}: settings left out: {e}")); + ItemProps::default() + }), + })) + } + + pub(super) fn graphic(&self, uid: u32) -> Result, Error> { + let kind = match self.class(uid) { + Some(class::IMAGE) => GraphicKind::Image, + Some(class::PDF) => GraphicKind::Pdf, + Some(class::EPS) => GraphicKind::Eps, + Some(class::SVG) => GraphicKind::Svg, + _ => return Ok(None), + }; + let transform = match self.chunk(uid, chunk::ITEM_TRANSFORM)? { + Some(d) => Matrix::read(&mut Cursor::new(&d))?, + None => Matrix::IDENTITY, + }; + let bounds = match self.chunk(uid, chunk::GRAPHIC_BOUNDS)? { + Some(d) => { + let mut c = Cursor::new(&d); + [c.f64()?, c.f64()?, c.f64()?, c.f64()?] + } + None => [0.0; 4], + }; + let link = match self.chunk(uid, chunk::GRAPHIC_LINK)? { + Some(d) if d.len() >= 12 => self.link(Cursor::new(&d[8..]).u32()?)?, + _ => None, + }; + let (link, contents) = match link { + Some((link, data)) => (Some(link), data), + None => { + let id = match kind { + GraphicKind::Image => Some(chunk::IMAGE_DATA), + GraphicKind::Pdf => Some(chunk::PDF_DATA), + _ => None, + }; + let data = match id { + Some(id) => match self.chunk(uid, id)? { + Some(d) if d.len() >= 4 => self.raw_data(Cursor::new(&d).u32()?)?, + _ => None, + }, + None => None, + }; + (None, data) + } + }; + Ok(Some(Graphic { + uid, + kind, + transform, + bounds, + link, + contents, + text_wrap: self.text_wrap(uid)?, + contour_type: match self.chunk(uid, chunk::CONTOUR_OPTION)? { + Some(d) if d.len() >= 4 => Some(Cursor::new(&d).u32()?), + _ => None, + }, + clipping: match self.chunk(uid, chunk::CLIPPING_PATH)? { + Some(d) if d.len() >= 26 => { + let f = |o: usize| Cursor::new(&d[o..]).f64(); + Some(ClippingPath { + kind: Cursor::new(&d).u32()?, + tolerance: f(4)?, + inset: f(12)?, + threshold: d[20], + index: i16_from([d[23], d[24]]), + high_resolution: d[25], + }) + } + _ => None, + }, + photoshop_clipping: match self.chunk(uid, chunk::PHOTOSHOP_CLIPPING)? { + Some(d) if d.len() >= 2 => Some(Cursor::new(&d).u16()?), + _ => None, + }, + })) + } + + /// The bytes of raw data object `uid` (`None` if `uid` is not one). + pub(super) fn raw_data(&self, uid: u32) -> Result { + if uid == 0 || self.class(uid) != Some(class::RAW_DATA) { + return Ok(None); + } + crate::audit::object_read(uid); + self.db.object(uid) + } + + /// A link, the URI of its resource and, for an embedded link, the + /// embedded file. + pub(super) fn link(&self, uid: u32) -> Result, Error> { + if uid == 0 || self.db.object(uid)?.is_none() { + return Ok(None); + } + let Some(info) = self.chunk(uid, chunk::LINK_INFO)? else { + return Ok(None); + }; + if info.len() < 12 { + return Ok(None); + } + let resource = Cursor::new(&info[8..]).u32()?; + let (uri, data) = match self.chunk(resource, chunk::LINK_RESOURCE_URI)? { + Some(d) if d.len() >= 5 => { + let mut c = Cursor::new(&d); + c.u8()?; + let n = c.u32()? as usize; + let uri = String::from_utf8_lossy(c.bytes(n.min(c.remaining()))?).into_owned(); + // After the URI: 12 bytes, then the UID of the embedded + // file's raw data object (0 for a normal link). + let data = if c.remaining() >= 16 { + c.skip(12)?; + self.raw_data(c.u32()?)? + } else { + None + }; + (uri, data) + } + _ => (String::new(), None), + }; + let link = Link { + uid, + uri, + embedded: data.is_some(), + }; + Ok(Some((link, data))) + } + + /// Story and threading of the text frame owning `column`. + pub(super) fn text_frame_links(&self, column: u32) -> Result { + let none = ItemKind::TextFrame { + story: None, + previous: None, + next: None, + preferences: None, + }; + let Some(d) = self.chunk(column, chunk::COLUMN_FRAME_LIST)? else { + return Ok(none); + }; + let list = Cursor::new(&d).u32()?; + let Some(d) = self.chunk(list, chunk::FRAME_LIST_FRAMES)? else { + return Ok(none); + }; + let mut c = Cursor::new(&d); + let story = uid_or_none(c.u32()?); + let columns = c.u32_list()?; + // Columns belong to frames: column -> multi-column frame -> spline item. + let frame_of = |col: u32| -> Result, Error> { + let Some(h) = self.chunk(col, chunk::ITEM_HIERARCHY)? else { + return Ok(None); + }; + let mcf = Cursor::new(&h[4..]).u32()?; + let Some(h) = self.chunk(mcf, chunk::ITEM_HIERARCHY)? else { + return Ok(None); + }; + Ok(uid_or_none(Cursor::new(&h[4..]).u32()?)) + }; + let mut frames: Vec = Vec::new(); + for col in columns.iter().copied() { + if let Some(f) = frame_of(col)? + && frames.last() != Some(&f) + { + frames.push(f); + } + } + let me = frame_of(column)?; + let pos = me.and_then(|m| frames.iter().position(|&f| f == m)); + Ok(ItemKind::TextFrame { + story, + previous: pos.and_then(|i| i.checked_sub(1)).map(|i| frames[i]), + next: pos.and_then(|i| frames.get(i + 1).copied()), + preferences: None, + }) + } +} diff --git a/src/model/mod.rs b/src/model/mod.rs index 0d715f7..9a1d5fd 100644 --- a/src/model/mod.rs +++ b/src/model/mod.rs @@ -1,17 +1,42 @@ //! A document model built from database objects. See //! `docs/format/objects.md` for the class and chunk layouts used here. +//! +//! `Reader` (`reader`) reads typed objects; `Reader::document` (`document`) +//! builds the `Document`. The areas it reads are in `spread` (spreads, +//! pages, layers, sections), `item` (page items and graphics), `story`, +//! `style`, `settings` (document-level settings and lists) and the other +//! child modules; `ids` holds the class and chunk IDs. pub mod attrs; pub mod cjk; pub mod color; +mod document; pub mod font; pub mod hyperlink; +mod ids; +mod item; pub mod prefs; +mod reader; +mod settings; +mod spread; +mod story; +mod strings; +mod style; pub mod table; pub mod variable; pub mod xml; pub mod xref; +pub use document::*; +pub use ids::*; +pub use item::*; +pub use reader::*; +pub use settings::*; +pub use spread::*; +pub use story::*; +use strings::*; +pub use style::*; + use std::collections::{BTreeMap, HashMap}; pub use attrs::{Attrs, Value}; @@ -27,3408 +52,6 @@ use crate::audit::List; use crate::object::{Cursor, Object, f64_at, i16_from, u16_at, u16_from, u32_at, u32_from}; use crate::{Database, Error, Version}; -/// Class IDs. -pub mod class { - pub const DOCUMENT: u32 = 0xE01; - pub const SPREAD: u32 = 0x501; - pub const MASTER_SPREAD: u32 = 0x1401; - pub const SPREAD_LAYER: u32 = 0x301; - pub const LAYER: u32 = 0x302; - pub const PAGE: u32 = 0x50F; - pub const SPLINE_ITEM: u32 = 0x6201; - pub const GROUP: u32 = 0x401; - pub const MULTI_COLUMN_FRAME: u32 = 0x263; - pub const FRAME_COLUMN: u32 = 0x227; - pub const FRAME_LIST: u32 = 0x228; - pub const STORY: u32 = 0x201; - pub const STYLE: u32 = 0x205; - pub const SECTION: u32 = 0x4C01; - pub const IMAGE: u32 = 0x1702; - pub const PDF: u32 = 0x2501; - pub const EPS: u32 = 0x6601; - pub const SVG: u32 = 0x6639; - /// A plain byte stream, such as the file of an embedded graphic. - pub const RAW_DATA: u32 = 0x129; - pub const FONT_FAMILY: u32 = 0x3E03; - pub const LANGUAGE: u32 = 0x2D07; - pub const TOC_STYLE: u32 = 0x11605; - pub const NAMED_GRID: u32 = 0xCD12; - pub const ASSIGNMENT: u32 = 0x1BE01; - pub const SMOOTH_SHADE: u32 = 0x5533; - /// Holds an item anchored in text. - pub const ANCHOR: u32 = 0x262; - pub const TEXT_VARIABLE_INSTANCE: u32 = 0xCA64; - pub const TEXT_VARIABLE: u32 = 0xCAB4; - pub const STYLE_ROOT_GROUP: u32 = 0xCA8C; - pub const STYLE_GROUP: u32 = 0xCA8B; - pub const OBJECT_STYLE: u32 = 0x1B901; - pub const OBJECT_STYLE_ROOT_GROUP: u32 = 0x1B972; - pub const CELL_STYLE_ROOT_GROUP: u32 = 0x20241; - pub const TABLE_STYLE_ROOT_GROUP: u32 = 0x1044F; - /// Document-wide preferences. - pub const PREFERENCES: u32 = 0x2202; - pub const GUIDE: u32 = 0x3301; - pub const XML_TAG: u32 = 0xBF19; - /// A colour used in the interface (XML tags). - pub const UI_COLOR: u32 = 0x1F11; - /// A colour profile: its name (chunk 0x13C). - pub const COLOR_PROFILE: u32 = 0x7D03; - /// Page item defaults. - pub const ITEM_DEFAULTS: u32 = 0x6E07; -} - -/// Chunk IDs. -pub mod chunk { - pub const DOC_SPREADS: u32 = 0x501; - pub const DOC_MASTER_SPREADS: u32 = 0x1401; - pub const DOC_LAYERS: u32 = 0x301; - pub const DOC_ACTIVE_LAYER: u32 = 0x313; - pub const DOC_STORIES: u32 = 0x222; - pub const DOC_SECTIONS: u32 = 0x4C01; - /// Document users: u32 count, then per user a flag byte, the name - /// and u32 colour. - pub const DOC_USERS: u32 = 0xA443; - pub const SPREAD_CHILDREN: u32 = 0x503; - pub const SPREAD_TRANSFORM: u32 = 0x56E; - pub const SPREAD_BINDING: u32 = 0x1B8; - pub const SPREAD_LAYER_LAYER: u32 = 0x302; - pub const SPREAD_LAYER_CHILDREN: u32 = 0x303; - pub const LAYER_PROPS: u32 = 0x304; - /// u16 0 if document pages may shuffle across the spread. - pub const SPREAD_SHUFFLE: u32 = 0x1A8; - /// Flattener settings of a spread. - pub const SPREAD_FLATTENER: u32 = 0x10833; - /// Tab orders: u32 count, then per page u32 page and a UID list. - pub const SPREAD_TAB_ORDERS: u32 = 0x14580; - /// u16 0 if a master spread hides the items of its own master. - pub const MASTER_SHOW_ITEMS: u32 = 0x140D; - /// Overridden master page items: u32 count, two UID lists. - pub const PAGE_OVERRIDES: u32 = 0x1404; - /// Layout grid use: six bytes, the last u16 1 to use the master's. - pub const PAGE_GRID_USE: u32 = 0xCD04; - /// Layout rule: u32, then u32 code. - pub const PAGE_LAYOUT_RULE: u32 = 0x563; - /// Page colour: u32 0 none, 1 the master's, else an interface colour. - pub const PAGE_COLOR: u32 = 0x5FF; - pub const PAGE_MASTER: u32 = 0x140F; - pub const PAGE_TRANSFORM: u32 = 0x5CC; - pub const PAGE_BOUNDS: u32 = 0x5DD; - /// Page bounds in files from InDesign 3.0 and 4.0. - pub const OLD_PAGE_BOUNDS: u32 = 0x154; - pub const PAGE_MARGINS: u32 = 0x51A; - pub const PAGE_COLUMNS: u32 = 0x528; - pub const PAGE_GRID: u32 = 0xCD02; - pub const ITEM_TRANSFORM: u32 = 0x151; - /// A group's transform when it has no chunk 0x151. - pub const GROUP_TRANSFORM: u32 = 0x40D; - /// u16 1 for a frame meant for a graphic. - pub const ITEM_CONTENT: u32 = 0x1623; - pub const ITEM_PATHS: u32 = 0x162B; - pub const ITEM_HIERARCHY: u32 = 0x15B; - pub const COLUMN_FRAME_LIST: u32 = 0x220; - pub const FRAME_LIST_FRAMES: u32 = 0x205; - pub const STORY_STRANDS: u32 = 0x223; - /// The table of contents (class 0x8C20) that made a story. - pub const STORY_TOC: u32 = 0x8C40; - /// The TOC style of a table of contents. - pub const TOC_STYLE_OF: u32 = 0x11613; - pub const TOC_STYLE: u32 = 0x11605; - pub const NAMED_GRID: u32 = 0xCD28; - pub const STRAND_DATA: u32 = 0x261; - pub const STRAND_RUNS: u32 = 0x262; - pub const STYLE_INFO: u32 = 0x230; - pub const ITEM_ATTRS: u32 = 0x6E03; - pub const STYLE_ATTRS: u32 = 0x23F; - pub const LANGUAGE_NAME: u32 = 0x2D0F; - pub const ANCHOR_CHILDREN: u32 = 0x2C8; - /// Anchored object settings, of an anchor or an object style. - pub const ANCHOR_SETTINGS: u32 = 0x2800; - pub const MASTER_NAME: u32 = 0x1402; - pub const STYLE_ROOT_CHILDREN: u32 = 0x28DC; - pub const STYLE_GROUP_CHILDREN: u32 = 0x28D3; - pub const STYLE_GROUP_NAME: u32 = 0x28D2; - pub const OBJECT_STYLE_INFO: u32 = 0x1B907; - pub const OBJECT_STYLE_ROOT_CHILDREN: u32 = 0x1B95A; - pub const ITEM_OBJECT_STYLE: u32 = 0x1B916; - /// Page item name: u8 1 if a built-in key, then an in-object string. - pub const ITEM_NAME: u32 = 0x2C10; - /// The same for a group. - pub const GROUP_NAME: u32 = 0x418; - /// u16, then u32 shape code: 1 line, 2 or 3 rectangle, 4 or 5 - /// oval, 0 or 6 to 8 polygon, 9 none. - pub const ITEM_SHAPE: u32 = 0x6204; - /// u32 1 if the page item is locked. - pub const ITEM_LOCKED: u32 = 0x2C2D; - /// u16 0 if the page item is hidden. - pub const ITEM_VISIBLE: u32 = 0x2C32; - /// Override of a master page item: u32 master item, then a list of - /// attribute IDs. - pub const ITEM_OVERRIDE: u32 = 0x1424; - /// Interface change counts: u32 count *n*, then *n* pairs of u32. - pub const ITEM_PARENT_CHANGES: u32 = 0x21D4E; - pub const ITEM_TARGET_CHANGES: u32 = 0x21D50; - pub const ITEM_UPDATED_CHANGES: u32 = 0x21D53; - /// u8 layout constraint flags. - pub const ITEM_LAYOUT_CONSTRAINTS: u32 = 0x22228; - pub const ROOT_GROUP_KIND: u32 = 0x28C2; - pub const SECTION_INFO: u32 = 0x4C02; - pub const DOCUMENT_PREFERENCES: u32 = 0x533; - /// Shading of a pasted smooth shade. - pub const SMOOTH_SHADE: u32 = 0x5532; - pub const SMOOTH_SHADE_NAME: u32 = 0x5531; - /// Index sort groups, in the preferences object. - pub const INDEX_GROUPS: u32 = 0x1307E; - pub const XML_TAG_NAME: u32 = 0xBF2F; - pub const XML_TAG_COLOR: u32 = 0x117; - /// Bullet characters, in the preferences object. - pub const BULLETS: u32 = 0x1A488; - pub const FRAME_COLUMNS: u32 = 0x2D1; - pub const FRAME_COLUMN_RULE: u32 = 0x22646; - pub const FRAME_COLUMN_RULE_OVERRIDE: u32 = 0x2265A; - pub const FRAME_FOOTNOTES: u32 = 0x22608; - pub const FRAME_IGNORE_WRAP: u32 = 0x3730; - /// Inset spacing of a text frame (on the frame, not its columns). - pub const FRAME_INSET: u32 = 0x3723; - pub const FRAME_JUSTIFICATION: u32 = 0x2CE; - /// Matrix of a multi-column frame; its first four values give the - /// text orientation. - pub const FRAME_TEXT_TRANSFORM: u32 = 0x2DE; - pub const GRAPHIC_BOUNDS: u32 = 0x1633; - pub const GRAPHIC_LINK: u32 = 0x8CBC; - pub const LINK_INFO: u32 = 0x8C9B; - pub const LINK_RESOURCE_URI: u32 = 0x8C92; - /// Pasted image without a link: u32 raw data object. - pub const IMAGE_DATA: u32 = 0x8C23; - /// Pasted PDF without a link: u32 raw data object. - pub const PDF_DATA: u32 = 0x2521; - pub const SWATCH_NAME: u32 = 0x1F30; - pub const TEXT_WRAP: u32 = 0x3703; - pub const CONTOUR_OPTION: u32 = 0x373D; - pub const CLIPPING_PATH: u32 = 0x2C1A; - pub const PHOTOSHOP_CLIPPING: u32 = 0x8C39; - /// Frame fitting attributes of an object style (u16 count, records). - pub const OBJECT_STYLE_FITTING: u32 = 0x1B956; - /// Page item attributes of an object style (u16 count, records). - pub const OBJECT_STYLE_ATTRS: u32 = 0x1B92B; - pub const OBJECT_STYLE_FRAME: u32 = 0x1B924; - pub const OBJECT_STYLE_STORY: u32 = 0x285B; - pub const OBJECT_STYLE_DIRECTION: u32 = 0x50F28; - pub const OBJECT_STYLE_WRAP: u32 = 0x3776; - pub const OBJECT_STYLE_CONTOUR: u32 = 0x3777; - pub const OBJECT_STYLE_ENABLED: u32 = 0x1B92E; - pub const OBJECT_STYLE_PARAGRAPH_STYLE: u32 = 0x1B946; - pub const GUIDE: u32 = 0x3308; -} - -/// Kinds of strand run data (first u32 of chunk 0x262). -pub mod strand { - pub const TEXT: u32 = 0x202; - pub const CHARACTER_STYLE: u32 = 0x203; - pub const PARAGRAPH_STYLE: u32 = 0x204; - /// Objects owned by text positions (anchored items, tables, ...). - pub const OWNED_ITEMS: u32 = 0x209; - /// Which object (story, or table and cell) each stretch of text belongs to. - pub const TEXT_OWNER: u32 = 0x2A4; -} - -/// A 2D affine transform `[a b c d tx ty]`, as in IDML `ItemTransform`. -#[derive(Debug, Clone, Copy, PartialEq)] -pub struct Matrix(pub [f64; 6]); - -impl Matrix { - pub const IDENTITY: Matrix = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, 0.0]); - - fn read(c: &mut Cursor) -> Result { - let mut m = [0.0; 6]; - for v in &mut m { - *v = c.f64()?; - } - Ok(Matrix(m)) - } -} - -pub type Point = (f64, f64); - -#[derive(Debug, Clone, PartialEq)] -pub struct PathPoint { - pub anchor: Point, - pub left: Point, - pub right: Point, - /// The stored point type: 2 a corner without direction points, 0 or - /// 1 a point with them. - pub kind: u32, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct Path { - pub points: Vec, - pub open: bool, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct Layer { - pub uid: u32, - pub name: String, - pub visible: bool, - pub locked: bool, - /// The hidden layer that holds pages; not written to IDML. - pub internal: bool, - /// The other settings, when chunk 0x304 has the layout of the samples. - pub settings: Option, -} - -/// Layer settings in chunk 0x304. See `docs/format/objects.md`. -#[derive(Debug, Clone, PartialEq)] -pub struct LayerSettings { - pub printable: bool, - pub lock_guides: bool, - pub ui: bool, - pub ignore_wrap: bool, - /// The layer colour (an interface colour object). - pub color: Option<[f64; 3]>, -} - -/// A colour setting that names an interface colour (class 0x1F11), or -/// one of two codes. See `docs/format/objects.md`. -#[derive(Debug, Clone, Copy, PartialEq, Default)] -pub enum UiColorRef { - /// Code 1, or no chunk: the colour of the master. - #[default] - UseMaster, - /// Code 0. - Nothing, - Rgb([f64; 3]), - /// Any other value. - Unknown, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct Page { - pub uid: u32, - /// Left, top, right, bottom in page coordinates. - pub bounds: [f64; 4], - pub transform: Matrix, - pub master: Option, - pub master_transform: Matrix, - /// Margins and columns (chunks 0x51A and 0x528). After - /// `resolve_page_layout`, these are the values in effect: the page's - /// own, or its master page's. - pub margins: Option, - pub columns: Option, - /// Layout grid settings (chunk 0xCD02). - pub grid: Option, - pub settings: PageSettings, -} - -/// Settings of a page. See `docs/format/objects.md`, page settings. -#[derive(Debug, Clone, PartialEq, Default)] -pub struct PageSettings { - /// Master page items overridden on the page, each with its override - /// (0 for none), from chunk 0x1404. - pub overrides: Vec<(u32, u32)>, - /// Chunk 0xCD04: whether the page uses its master's layout grid. - pub use_master_grid: Option, - /// Layout rule code (chunk 0x563); `None` without the chunk. - pub layout_rule: Option, - pub color: UiColorRef, - /// Page items in tab order (the spread's chunk 0x14580). - pub tab_order: Vec, -} - -/// Page margins from chunk 0x51A: four f64 (left, top, right, bottom), -/// then u16 1 if the page has its own margins, 0 if it uses its master -/// page's. -#[derive(Debug, Clone, PartialEq)] -pub struct Margins { - pub left: f64, - pub top: f64, - pub right: f64, - pub bottom: f64, - pub own: bool, -} - -/// Page columns from chunk 0x528: u32 count *n*, *n* f64 column edge -/// positions, f64 gutter, then u16 1 if the page has its own columns. -#[derive(Debug, Clone, PartialEq)] -pub struct Columns { - pub positions: Vec, - pub gutter: f64, - pub own: bool, -} - -/// Layout grid settings of a page (chunk 0xCD02): u32 font family, a flag -/// byte, the font style as an in-object string, five f64 and four u32. -/// See `docs/format/objects.md`. -#[derive(Debug, Clone, PartialEq)] -pub struct GridData { - pub font: u32, - pub font_style: String, - pub numbers: [f64; 5], - pub codes: [u32; 4], -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum Shape { - Rectangle, - Oval, - Polygon, - GraphicLine, -} - -#[derive(Debug, Clone, PartialEq)] -pub enum ItemKind { - TextFrame { - story: Option, - previous: Option, - next: Option, - preferences: Option, - }, - Shape(Shape), - Group, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct PageItem { - pub uid: u32, - /// Placed graphics (images, PDF, EPS, SVG) inside a frame. - pub graphics: Vec, - pub kind: ItemKind, - pub transform: Matrix, - pub paths: Vec, - /// Document layer; `None` for items anchored in text. - pub layer: Option, - /// Local formatting (fill, stroke, corners, ...). - pub attrs: Attrs, - pub object_style: Option, - pub children: Vec, - /// Text wrap (chunk 0x3703); `None` if the item has none. - pub text_wrap: Option, - /// Anchored object settings (chunk 0x2800 of the anchor), for an item - /// anchored in text. - pub anchor: Option>, - pub props: ItemProps, -} - -/// Settings every page item has. See `docs/format/objects.md`, page item -/// settings. -#[derive(Debug, Clone, PartialEq, Default)] -pub struct ItemProps { - /// The name (chunk 0x2C10, of a group 0x418); `None` without the - /// chunk. - pub name: Option, - /// Chunk 0x2C32 is 0. - pub hidden: bool, - /// Chunk 0x2C2D is 1. - pub locked: bool, - /// Layout constraint flags (chunk 0x22228). - pub layout_constraints: Option, - /// The parent, target and last updated interface change counts - /// (chunks 0x21D4E, 0x21D50, 0x21D53), each a list of numbers. - pub change_counts: [Vec; 3], - /// The overridden master page item (0 for none) and the IDs of the - /// attributes overridden (chunk 0x1424). - pub overridden: Option<(u32, Vec)>, - /// Chunk 0x1623 is 1: a frame for a graphic (`ContentType` - /// `GraphicType` without a graphic). - pub graphic_frame: bool, -} - -/// A page item name: a built-in key or a name given by the user. -#[derive(Debug, Clone, PartialEq)] -pub struct ItemName { - pub builtin: bool, - pub name: String, -} - -/// Text wrap settings of a page item or graphic (chunk 0x3703). -#[derive(Debug, Clone, PartialEq)] -pub struct TextWrap { - /// Wrap mode code (see `wrap_mode`). - pub mode: u32, - /// The four offsets: left, top, right, bottom. - pub offsets: [f64; 4], - /// The u32 at offset 40; 1 in every sample whose IDML has - /// `Inverse="false"`, `ApplyToMasterPageOnly="false"` and - /// `TextWrapSide="BothSides"`. - pub flags: u32, -} - -/// Text wrap mode codes. -pub mod wrap_mode { - pub const NONE: u32 = 0; - pub const JUMP_OBJECT: u32 = 1; - pub const BOUNDING_BOX: u32 = 3; - pub const CONTOUR: u32 = 6; -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum GraphicKind { - Image, - Pdf, - Eps, - Svg, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct Link { - pub uid: u32, - /// `LinkResourceURI`, for example `file:/Users/me/image.jpg`. - pub uri: String, - /// The linked file is stored in the document (`StoredState="Embedded"`). - pub embedded: bool, -} - -/// The bytes of a file stored in the document, if there is one. -type EmbeddedFile = Option>; - -#[derive(Debug, Clone, PartialEq)] -pub struct Graphic { - pub uid: u32, - pub kind: GraphicKind, - pub transform: Matrix, - /// Left, top, right, bottom in the graphic's own coordinates. - pub bounds: [f64; 4], - pub link: Option, - /// The graphic's file, when the document holds it: an embedded link or - /// a graphic pasted without a link. IDML writes it as `Contents`. - pub contents: Option>, - pub text_wrap: Option, - /// Contour type code of the text wrap (chunk 0x373D): 5 = SameAsClipping. - pub contour_type: Option, - /// Clipping path settings (chunk 0x2C1A), if stored. - pub clipping: Option, - /// Chunk 0x8C39, u16 at 0: apply the Photoshop clipping path (1 true). - pub photoshop_clipping: Option, -} - -/// Clipping path settings of a graphic (chunk 0x2C1A, 37 bytes): u32 type -/// at 0, f64 tolerance at 4, f64 inset at 12, u8 threshold at 20, i16 -/// index at 23, u8 at 25 (2 = use the high-resolution image). See -/// `docs/format/objects.md`. -#[derive(Debug, Clone, PartialEq)] -pub struct ClippingPath { - pub kind: u32, - pub tolerance: f64, - pub inset: f64, - pub threshold: u8, - pub index: i16, - pub high_resolution: u8, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct Spread { - pub uid: u32, - /// Master spreads only: name prefix (for example "A") and base name. - pub master_name: Option<(String, String)>, - pub transform: Matrix, - pub binding_location: u32, - pub pages: Vec, - pub items: Vec, - pub guides: Vec, - /// Chunk 0x1A8: `None` without it. - pub shuffle: Option, - /// The two resolutions in chunk 0x10833, when it is there. - pub flattener_resolution: Option<[f64; 2]>, - /// Master spreads: chunk 0x140D. - pub show_master_items: Option, -} - -/// A ruler guide (class 0x3301, chunk 0x3308). See `docs/format/objects.md`. -#[derive(Debug, Clone, PartialEq)] -pub struct Guide { - pub uid: u32, - pub horizontal: bool, - /// Position in spread coordinates: y for a horizontal guide, x for a - /// vertical one. - pub position: f64, - /// The page the guide belongs to, or the spread. - pub owner: u32, - pub fit_to_page: bool, - /// Stored view threshold (0.05 in every sample). - pub view_threshold: f64, - /// Colour code (6 in every sample). - pub color: u32, - /// 0 ruler guide, 1 liquid guide; none in 40-byte records. - pub guide_type: Option, - /// Document layer. - pub layer: u32, - /// Chunk 0x2C2D, as for page items. - pub locked: bool, - /// f64 at 44 of the 52-byte record (`GuideZone`). - pub zone: Option, - /// Chunk 0x1424, as for page items. - pub overridden: Option<(u32, Vec)>, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct Style { - pub uid: u32, - pub name: String, - /// The name is an InDesign built-in key, written with `$ID/` in IDML. - pub builtin: bool, - pub paragraph: bool, - pub based_on: Option, - pub next: Option, - pub attrs: Attrs, - /// The u16 after the kind, before the name (IDML `Imported`). - pub imported: bool, - /// The GUID string after the name in newer files (`StyleUniqueId`). - pub unique_id: Option, - /// Keyboard shortcut: u32 key 10 bytes before the name's flag byte, - /// then the two bytes 6 and 5 before it (`docs/format/objects.md`). - pub shortcut: Option<(u32, u8, u8)>, -} - -/// A stretch of story text with one paragraph style and one character style. -#[derive(Debug, Clone, PartialEq)] -pub struct TextRun { - /// UTF-16 offset of the run in the story text. - pub start: usize, - pub text: String, - pub paragraph_style: Option, - pub character_style: Option, - /// Local paragraph formatting. - pub paragraph_attrs: Attrs, - /// Local character formatting. - pub character_attrs: Attrs, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct Story { - pub uid: u32, - pub runs: Vec, - /// Page items anchored in the text, by UTF-16 offset of their U+FFFC. - pub anchors: BTreeMap>, - /// Tables, by UTF-16 offset of their U+0016. - pub tables: BTreeMap, - /// Text variable instances, by UTF-16 offset of their U+0018. - pub text_variables: BTreeMap, - /// Hyperlink text sources, sorted by start. - pub sources: Vec, - /// XML markers, by UTF-16 offset of their U+FEFF. - pub xml_markers: BTreeMap, - /// The XML element whose content is this story. - pub xml_element: Option, - /// Text orientation, from the frames that show the story; `None` when - /// it has no frame or its frames disagree. - pub orientation: Option, - /// The TOC style that made the story (chunk 0x8C40). - pub toc_style: Option, -} - -/// A pasted smooth shade with a constant shading. See -/// `docs/format/objects.md`, pasted smooth shades. -#[derive(Debug, Clone, PartialEq)] -pub struct ConstantShade { - pub uid: u32, - pub count: u32, - pub values: [f64; 3], - /// Flag (built-in key) and name. - pub name: Option<(bool, String)>, -} - -/// A table of contents style (class 0x11605), from chunk 0x11605: a flag -/// byte and the name, three u32 (the third the title style), a flag byte -/// and the title. See `docs/format/objects.md`. -#[derive(Debug, Clone, PartialEq)] -pub struct TocStyle { - pub uid: u32, - pub name: String, - pub builtin: bool, - pub title: String, - pub title_style: u32, - /// After a flag byte and a string: u16 at 2 numbered paragraphs, at 4 - /// make anchor and at 6 remove forced line breaks, where the chunk - /// has them. - pub flags: Vec, -} - -/// Text orientation of a story (IDML `StoryOrientation`). -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum Orientation { - Horizontal, - Vertical, -} - -/// What an XML marker character (U+FEFF) in story text stands for. -#[derive(Debug, Clone, Copy, PartialEq)] -pub enum XmlMarker { - /// The start of an element that holds the text up to its end marker. - Start(xml::Key), - End(xml::Key), - /// An element that is a single marker; its content is elsewhere. - Placeholder(xml::Key), - /// A marker that IDML does not write: the start of the document node, - /// or a marker of an element that is left out. - Hidden, -} - -/// An XML element that can be written, with its IDML values. -#[derive(Debug, Clone, PartialEq)] -pub struct XmlElement { - /// IDML `Self`. - pub name: String, - /// Tag name (IDML `MarkupTag` without `XMLTag/`). - pub tag: String, - /// UID written as `XMLContent`. - pub content: Option, - /// The content is a story. - pub story_content: bool, - /// Written between character ranges rather than inside one: the - /// element holds an element whose content is a story. - pub block: bool, -} - -/// The XML structure of the document. -#[derive(Debug, Clone, Default, PartialEq)] -pub struct XmlStructure { - /// The backing story, IDML `XmlStory`. - pub story: Option, - pub elements: BTreeMap, -} - -#[derive(Debug, Clone, Default, PartialEq)] -pub struct Document { - pub version: Version, - pub layers: Vec, - pub active_layer: Option, - /// Document users (chunk 0xA443): flag byte and name. - pub users: Vec<(u8, String)>, - /// Index sort groups (preferences chunk 0x1307E), in order: name, - /// include flag and header variant. - pub index_groups: Vec<(String, bool, u16)>, - /// The constant shade the document lists (the class 0x5533 object of - /// lowest UID with a constant shade in chunk 0x5532): its UID and its - /// u32 and three f64; and its name (chunk 0x5531: a flag byte, 1 for - /// a built-in key, and the name). - pub constant_shade: Option, - /// Assignment objects (class 0x1BE01), in UID order. - pub assignments: Vec, - /// Named grids (class 0xCD12, chunk 0xCD28: u32, a flag byte, 1 for - /// a built-in key, and the name), in UID order. - pub named_grids: Vec<(bool, String)>, - pub spreads: Vec, - pub master_spreads: Vec, - pub stories: Vec, - pub styles: BTreeMap, - pub toc_styles: Vec, - pub colors: Vec, - /// Tint swatches, with their IDML reference and name. - pub tints: Vec<(Tint, String, String)>, - pub gradients: Vec, - /// IDML reference (`Color/...`, `Swatch/None`) for each swatch UID. - pub swatches: BTreeMap, - /// Font families by UID. - pub fonts: BTreeMap, - /// The language objects (class 0x2D07) in UID order. - pub language_list: Vec, - /// Language name (IDML `AppliedLanguage` without `$ID/`) for each - /// language UID. - pub languages: BTreeMap, - /// Style groups, including the root groups (empty name). - pub style_groups: BTreeMap, - pub object_styles: BTreeMap, - pub cell_styles: BTreeMap, - pub table_styles: BTreeMap, - pub sections: Vec
, - pub text_variables: Vec, - pub hyperlinks: Vec, - pub text_sources: BTreeMap, - pub destinations: Vec, - pub bookmarks: BTreeMap, - /// All bookmarks in document order (document chunk 0x13501). - pub bookmark_order: Vec, - /// Cross-reference formats, by UID. - pub cross_reference_formats: BTreeMap, - /// Problems that did not stop the conversion (content left out). - pub warnings: Vec, - pub preferences: Option, - /// Other preference values (`prefs.rs`). - pub prefs: prefs::Prefs, - pub composite_fonts: Vec, - /// Kinsoku and mojikumi tables, in UID order. - pub cjk_tables: Vec, - /// Inks, in UID order. - pub inks: Vec, - /// Colour groups in document order, the root group first. - pub color_groups: Vec, - /// The bullet characters offered for lists (preferences chunk 0x1A488). - pub bullets: Vec, - /// XML tags (class 0xBF19): name and colour (red, green, blue). - pub xml_tags: Vec<(String, Option<[f64; 3]>)>, - pub xml: XmlStructure, -} - -/// Document setup, from chunk 0x533 of the preferences object. -#[derive(Debug, Clone, PartialEq)] -pub struct DocumentPreferences { - pub page_width: f64, - pub page_height: f64, - pub facing_pages: bool, - /// Top, bottom, inside, outside (stored as inside, top, outside, bottom). - pub bleed: [f64; 4], - /// 0 print, 1 web, 2 mobile. - pub intent: u32, - /// Page binding (u16 at 64): 0 left to right, 1 right to left. - pub page_binding: u16, -} - -/// Text frame settings, from the frame's multi-column frame object. -#[derive(Debug, Clone, PartialEq)] -pub struct TextFramePreferences { - pub column_count: u32, - pub column_gutter: f64, - pub column_fixed_width: f64, - /// First baseline offset code (chunk 0x2CE, u16 at 0): 0 LeadingOffset, - /// 1 AscentOffset, 2 CapHeight, 3 EmboxHeight. - pub first_baseline_offset: u16, - pub vertical_justification: u16, - pub vertical_balance_columns: bool, - pub auto_sizing_type: u16, - pub auto_sizing_reference_point: u16, - /// Chunk 0x2D1: u8 at 12 and, in 40-byte chunks, f64 at 32. - pub use_fixed_width: bool, - pub max_width: Option, - /// Chunk 0x2CE (48 bytes): u16 at 26 and f64 at 28 (minimum height), - /// u16 at 36 and f64 at 38 (minimum width), u16 at 46 (no line - /// breaks). - pub minimum_sizes: Option<([bool; 2], [f64; 2], bool)>, - /// Chunk 0x3730: u16 ignore text wrap. - pub ignore_wrap: Option, - /// Column rule (chunk 0x22646): f64 width at 28, u32 colour at 36. - pub column_rule: Option<(f64, u32)>, - /// Chunk 0x2265A: all zero in every sample but one. - pub column_rule_override: Option, - /// Footnote options (chunk 0x22608): u32, f64 minimum spacing, f64 - /// space between. - pub footnotes: Option<[f64; 2]>, - /// Inset spacing (the frame's chunk 0x3723): top, left, bottom, right. - pub inset: [f64; 4], -} - -/// A style group: a root group of styles, or a named group in it. -#[derive(Debug, Clone, PartialEq)] -pub struct StyleGroup { - pub uid: u32, - /// Empty for root groups. - pub name: String, - /// Root groups: what they hold, from chunk 0x28C2 (see `root_kind`). - pub root: Option, - pub children: Vec, -} - -/// Values of chunk 0x28C2, the kind of a root style group. -pub mod root_kind { - pub const PARAGRAPH: u32 = 0xCA0C; - pub const CHARACTER: u32 = 0xCA0D; - pub const OBJECT: u32 = 0x1B924; - pub const TABLE: u32 = 0xB668; - pub const CELL: u32 = 0xB669; -} - -/// Numbering of a section. -#[derive(Debug, Clone, PartialEq)] -pub struct Section { - pub uid: u32, - /// The section's first page; `None` for the first section, which - /// starts at the first page of the document. - pub page: Option, - pub continue_numbering: bool, - pub start: u32, - /// Page number style code (see `numbering`). - pub style: u32, - /// `SectionPrefix` and `Marker`; empty if the chunk is missing. - pub prefix: String, - pub marker: String, - /// The alternate layout name after the numbers, with the flag byte - /// before it (1: a built-in key); `None` if the chunk ends before it. - pub alternate_layout: Option<(u8, String)>, -} - -/// Page number style codes of sections. -pub mod numbering { - pub const ARABIC: u32 = 0x4C15; - pub const LOWER_ROMAN: u32 = 0x4C17; - /// Chinese numerals, written digit by digit. - pub const KANJI: u32 = 0x4C12; -} - -/// A language object (class 0x2D07), chunk 0x2D0F. See -/// `docs/format/objects.md`, languages. -#[derive(Debug, Clone, PartialEq)] -pub struct Language { - pub uid: u32, - pub name: String, - pub primary: String, - pub sub: String, - pub id: u16, - /// The spelling and hyphenation vendors, each with its flag byte. - pub vendors: Option<[(u8, String); 2]>, -} - -/// A bullet character of the document's list (IDML `ABullet`): u32 -/// character type, u32 character value, u32 font family (0 = none), the -/// font style as a flag byte and string, then a byte (0 in every sample). -#[derive(Debug, Clone, PartialEq)] -pub struct Bullet { - /// 0 `UnicodeOnly`, 1 `UnicodeWithFont`, 2 `GlyphWithFont`. - pub kind: u32, - pub value: u32, - pub font: u32, - /// The IDML font style, with `$ID/` for a built-in name. - pub font_style: String, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct ObjectStyle { - pub uid: u32, - pub name: String, - pub builtin: bool, - pub based_on: Option, - /// Frame fitting attributes (chunk 0x1B956), same IDs as on page items. - pub fitting: Attrs, - /// Page item attributes (chunk 0x1B92B): fill, stroke, corners. - pub attrs: Attrs, - /// Text frame settings (chunk 0x1B924); see `docs/format/objects.md`. - pub frame: Option>, - /// Story settings (chunk 0x285B). - pub story: Option>, - /// Story direction (chunk 0x50F28, u16). - pub direction: Option, - /// Text wrap (chunk 0x3776, the layout of chunk 0x3703). - pub text_wrap: Option, - /// Contour type of the text wrap (chunk 0x3777). - pub contour_type: Option, - /// IDs of the setting categories the style turns on (chunk 0x1B92E). - pub enabled: Option>, - /// Paragraph style applied to text frames (chunk 0x1B946). - pub paragraph_style: Option, - /// Anchored object settings (chunk 0x2800). - pub anchor: Option>, -} - -/// Reads typed objects from a database, caching them. -pub struct Reader<'a> { - db: &'a Database<'a>, - cache: std::cell::RefCell>>, - warnings: std::cell::RefCell>, - /// XML nodes found in the stories read so far. - xml_nodes: std::cell::RefCell>, - /// Text orientation of each text frame read so far, by story. - frame_orientations: std::cell::RefCell>>>, - /// The groups whose page items are being read, outermost first. - item_path: std::cell::RefCell>, -} - -/// Groups nested deeper than this are left out, with a warning, so that a -/// damaged file cannot exhaust the stack. -const MAX_ITEM_DEPTH: usize = 100; - -fn uid_or_none(v: u32) -> Option { - (v != 0).then_some(v) -} - -impl<'a> Reader<'a> { - pub fn new(db: &'a Database<'a>) -> Reader<'a> { - Reader { - db, - cache: Default::default(), - warnings: Default::default(), - xml_nodes: Default::default(), - frame_orientations: Default::default(), - item_path: Default::default(), - } - } - - pub fn object(&self, uid: u32) -> Result, Error> { - if let Some(o) = self.cache.borrow().get(&uid) { - return Ok(o.clone()); - } - let obj = self - .db - .get(uid)? - .ok_or_else(|| Error::Corrupt(format!("object {uid} has no data")))?; - let obj = std::rc::Rc::new(obj); - crate::audit::object_read(uid); - self.cache.borrow_mut().insert(uid, obj.clone()); - Ok(obj) - } - - /// Record a problem that does not stop the conversion. - pub fn warn(&self, msg: String) { - self.warnings.borrow_mut().push(msg); - } - - pub fn class(&self, uid: u32) -> Option { - self.db.class_of(uid) - } - - fn chunk(&self, uid: u32, id: u32) -> Result>, Error> { - Ok(self.object(uid)?.chunk(id).map(<[u8]>::to_vec)) - } - - fn required(&self, uid: u32, id: u32) -> Result, Error> { - self.chunk(uid, id)? - .ok_or_else(|| Error::Corrupt(format!("object {uid} has no chunk {id:#x}"))) - } - - fn uid_list(&self, uid: u32, id: u32) -> Result, Error> { - match self.chunk(uid, id)? { - Some(data) => Cursor::new(&data).u32_list(), - None => Ok(Vec::new()), - } - } - - pub fn document(&self, version: Version) -> Result { - let doc = 1; - let layers = self - .uid_list(doc, chunk::DOC_LAYERS)? - .into_iter() - .map(|uid| self.layer(uid)) - .collect::, _>>()?; - let active_layer = self - .chunk(doc, chunk::DOC_ACTIVE_LAYER)? - .map(|d| Cursor::new(&d).u32()) - .transpose()?; - let mut spreads = self - .uid_list(doc, chunk::DOC_SPREADS)? - .into_iter() - .map(|uid| self.spread(uid)) - .collect::, _>>()?; - let mut master_spreads = self - .uid_list(doc, chunk::DOC_MASTER_SPREADS)? - .into_iter() - .map(|uid| self.spread(uid)) - .collect::, _>>()?; - resolve_page_layout(&mut spreads, &mut master_spreads); - let stories = self - .uid_list(doc, chunk::DOC_STORIES)? - .into_iter() - .filter(|&uid| self.class(uid) == Some(class::STORY)) - .map(|uid| self.story(uid)) - .collect::, _>>()?; - let mut styles = BTreeMap::new(); - let mut colors = Vec::new(); - let mut tint_objects = Vec::new(); - let mut gradients = Vec::new(); - let mut swatches = BTreeMap::new(); - let mut fonts = BTreeMap::new(); - let mut languages = BTreeMap::new(); - let mut language_list = Vec::new(); - let mut style_groups = BTreeMap::new(); - let mut object_styles = BTreeMap::new(); - let mut cell_styles = BTreeMap::new(); - let mut table_styles = BTreeMap::new(); - let mut text_variables = Vec::new(); - let mut hyperlinks = Vec::new(); - let mut text_sources = BTreeMap::new(); - let mut destinations = Vec::new(); - let mut bookmarks = BTreeMap::new(); - let mut cross_reference_formats = BTreeMap::new(); - let mut composite_fonts = Vec::new(); - let mut composite_entries = HashMap::new(); - let mut cjk_tables = Vec::new(); - let mut xml_tags = Vec::new(); - let mut xml_tag_names = HashMap::new(); - let mut inks = Vec::new(); - let mut color_groups = HashMap::new(); - for &(uid, cls) in self.db.classes() { - if self.db.object(uid)?.is_none() { - continue; - } - // An object that cannot be read is left out with a warning. - let read = (|| -> Result<(), Error> { - match cls { - class::STYLE_ROOT_GROUP - | class::OBJECT_STYLE_ROOT_GROUP - | class::CELL_STYLE_ROOT_GROUP - | class::TABLE_STYLE_ROOT_GROUP => { - let kind = match self.chunk(uid, chunk::ROOT_GROUP_KIND)? { - Some(d) => Cursor::new(&d).u32()?, - None => 0, - }; - let mut children = Vec::new(); - for id in [ - chunk::STYLE_ROOT_CHILDREN, - chunk::OBJECT_STYLE_ROOT_CHILDREN, - table::chunk::CELL_STYLE_ROOT_CHILDREN, - table::chunk::TABLE_STYLE_ROOT_CHILDREN, - ] { - if children.is_empty() { - children = self.children(uid, id)?; - } - } - style_groups.insert( - uid, - StyleGroup { - uid, - name: String::new(), - root: Some(kind), - children, - }, - ); - } - class::STYLE_GROUP => { - let name = match self.chunk(uid, chunk::STYLE_GROUP_NAME)? { - Some(d) if d.len() > 1 => { - let mut c = Cursor::new(&d); - c.flag()?; - c.string()? - } - _ => String::new(), - }; - let children = self.children(uid, chunk::STYLE_GROUP_CHILDREN)?; - style_groups.insert( - uid, - StyleGroup { - uid, - name, - root: None, - children, - }, - ); - } - class::OBJECT_STYLE => { - if let Some(d) = self.chunk(uid, chunk::OBJECT_STYLE_INFO)? { - let mut c = Cursor::new(&d); - let based_on = c.u32()?; - let builtin = c.flag()? == 1; - let name = c.string()?; - object_styles.insert( - uid, - ObjectStyle { - uid, - name, - builtin, - based_on: uid_or_none(based_on), - fitting: match self.chunk(uid, chunk::OBJECT_STYLE_FITTING)? { - Some(d) => Attrs::parse_short(&d, List::ObjectStyleFitting) - .unwrap_or_default(), - None => Attrs::default(), - }, - attrs: match self.chunk(uid, chunk::OBJECT_STYLE_ATTRS)? { - Some(d) => Attrs::parse_short(&d, List::ObjectStyle) - .unwrap_or_default(), - None => Attrs::default(), - }, - // The layout is known for these sizes - // only (`docs/format/big-endian.md`). - frame: match self.chunk(uid, chunk::OBJECT_STYLE_FRAME)? { - Some(d) if !matches!(d.len(), 106 | 142 | 162 | 222) => { - self.warn(format!( - "object style {uid}: text frame settings of {} bytes are not known; left out", - d.len() - )); - None - } - d => d, - }, - story: self.chunk(uid, chunk::OBJECT_STYLE_STORY)?, - direction: match self - .chunk(uid, chunk::OBJECT_STYLE_DIRECTION)? - { - Some(d) if d.len() >= 2 => Some(Cursor::new(&d).u16()?), - _ => None, - }, - text_wrap: self.wrap_chunk(uid, chunk::OBJECT_STYLE_WRAP)?, - contour_type: match self - .chunk(uid, chunk::OBJECT_STYLE_CONTOUR)? - { - Some(d) if d.len() >= 4 => Some(Cursor::new(&d).u32()?), - _ => None, - }, - enabled: match self.chunk(uid, chunk::OBJECT_STYLE_ENABLED)? { - Some(d) => Some(Cursor::new(&d).u32_list()?), - None => None, - }, - paragraph_style: match self - .chunk(uid, chunk::OBJECT_STYLE_PARAGRAPH_STYLE)? - { - Some(d) if d.len() >= 4 => Some(Cursor::new(&d).u32()?), - _ => None, - }, - anchor: self.chunk(uid, chunk::ANCHOR_SETTINGS)?, - }, - ); - } - } - class::STYLE => { - if let Some(style) = self.style(uid)? { - styles.insert(uid, style); - } - } - table::class::CELL_STYLE => { - if let Some(s) = self.table_style(uid, table::chunk::CELL_STYLE_ATTRS)? { - cell_styles.insert(uid, s); - } - } - table::class::TABLE_STYLE => { - if let Some(s) = self.table_style(uid, table::chunk::TABLE_STYLE_ATTRS)? { - table_styles.insert(uid, s); - } - } - color::class::COLOR => { - if self.db.object(uid)?.is_none() { - return Ok(()); - } - let obj = self.object(uid)?; - if let Some(c) = Color::read(uid, &obj)? { - if c.model_name().is_none() { - self.warn(format!( - "colour {uid}: colour model code {} is not known; left out", - c.model - )); - } - swatches.insert(uid, c.reference()); - colors.push(c); - } else if let Some(t) = Tint::read(uid, &obj)? { - tint_objects.push(t); - } - } - color::class::SWATCH_NONE => { - swatches.insert(uid, "Swatch/None".into()); - } - color::class::GRADIENT => { - if let Some(g) = Gradient::read(uid, &*self.object(uid)?)? { - for i in 1..g.stops.len() { - if g.idml_midpoint(i).is_none() { - self.warn(format!( - "gradient {uid}: midpoint before stop {i} is not \ - within 13–87 %; left out" - )); - } - } - swatches.insert(uid, g.reference()); - gradients.push(g); - } - } - class::FONT_FAMILY => match FontFamily::read(uid, &*self.object(uid)?) { - Ok(Some(f)) => { - if i32::try_from(f.writing_script).is_err() { - self.warn(format!( - "font family {uid}: writing script {:#x} is not an IDML \ - integer; left out", - f.writing_script - )); - } - fonts.insert(uid, f); - } - Ok(None) => {} - // Keep the name, which text formatting refers to. - Err(e) => { - self.warn(format!("font family {uid}: fonts left out: {e}")); - if let Some(d) = self.chunk(uid, font::chunk::FAMILY)? { - fonts.insert( - uid, - FontFamily { - uid, - name: find_string(&d, 0)?, - fonts: Vec::new(), - writing_script: 0, - }, - ); - } - } - }, - class::TEXT_VARIABLE => { - if let Some(v) = TextVariable::read(uid, &*self.object(uid)?)? { - text_variables.push(v); - } - } - hyperlink::class::HYPERLINK => { - if let Some(h) = Hyperlink::read(uid, &*self.object(uid)?)? { - hyperlinks.push(h); - } - } - hyperlink::class::TEXT_SOURCE => { - if let Some(s) = TextSource::read(uid, &*self.object(uid)?)? { - text_sources.insert(uid, s); - } - } - hyperlink::class::PAGE_DESTINATION | hyperlink::class::URL_DESTINATION => { - if let Some(d) = Destination::read(uid, cls, &*self.object(uid)?)? { - if let hyperlink::DestinationKind::Page { zoom: None, .. } = d.kind { - self.warn(format!( - "destination {uid}: view zoom is outside 5–4000 %; left out" - )); - } - destinations.push(d); - } - } - xref::CLASS => { - if let Some(f) = CrossReferenceFormat::read(uid, &*self.object(uid)?)? { - cross_reference_formats.insert(uid, f); - } - } - hyperlink::class::BOOKMARK => { - if let Some(b) = Bookmark::read(uid, &*self.object(uid)?)? { - bookmarks.insert(uid, b); - } - } - cjk::class::COMPOSITE_FONT => { - if let Some((name, entries)) = CompositeFont::read(&*self.object(uid)?)? { - composite_fonts.push((uid, name, entries)); - } - } - cjk::class::COMPOSITE_FONT_ENTRY => { - if let Some(e) = CompositeFontEntry::read(uid, &*self.object(uid)?)? { - composite_entries.insert(uid, e); - } - } - c if c == cjk::class::MOJIKUMI || cjk::class::KINSOKU.contains(&c) => { - if let Some(t) = CjkTable::read(uid, c, &*self.object(uid)?)? { - cjk_tables.push(t); - } - } - color::class::INK => { - if let Some(i) = Ink::read(uid, &*self.object(uid)?)? { - if i.neutral_density.is_none() { - self.warn(format!( - "ink {uid}: neutral density is outside 0.001–10; left out" - )); - } - inks.push(i); - } - } - color::class::COLOR_GROUP => { - if let Some(g) = ColorGroup::read(uid, &*self.object(uid)?)? { - color_groups.insert(uid, g); - } - } - class::XML_TAG => { - // Chunk 0xBF2F: u32 length, then the name as text - // segments; chunk 0x117: the UID of the tag's colour. - if let Some(d) = self.chunk(uid, chunk::XML_TAG_NAME)? { - let mut c = Cursor::new(&d); - let n = c.u32()? as usize; - // Files from InDesign 2.0 to 4.0 hold a flag byte and - // an in-object string instead. - let name = match c.segments(n) { - Ok(name) => name, - Err(_) => { - let mut c = Cursor::new(&d); - c.flag()?; - c.string()? - } - }; - let color = match self.chunk(uid, chunk::XML_TAG_COLOR)? { - Some(d) if d.len() >= 4 => self.ui_color(Cursor::new(&d).u32()?)?, - _ => None, - }; - xml_tag_names.insert(uid, name.clone()); - xml_tags.push((name, color)); - } - } - class::LANGUAGE => { - if let Some(d) = self.chunk(uid, chunk::LANGUAGE_NAME)? - && d.len() > 1 - { - let mut c = Cursor::new(&d); - c.flag()?; - let name = c.string()?; - languages.insert(uid, name.clone()); - // Then the primary and secondary names, u16 - // ID, and two vendors (flag, u32, string). - let rest = (|| -> Result<_, Error> { - c.flag()?; - let primary = c.string()?; - c.flag()?; - let sub = c.string()?; - let id = c.u16()?; - let mut vendor = || -> Result<(u8, String), Error> { - let flag = c.u8()?; - c.u32()?; - Ok((flag, c.string()?)) - }; - let spelling = vendor()?; - let hyphenation = vendor()?; - Ok((primary, sub, id, [spelling, hyphenation])) - })(); - if let Ok((primary, sub, id, vendors)) = rest { - language_list.push(Language { - uid, - name, - primary, - sub, - id, - vendors: Some(vendors), - }); - } - } - } - _ => {} - } - Ok(()) - })(); - if let Err(e) = read { - self.warn(format!("object {uid} (class {cls:#x}) left out: {e}")); - } - } - // The backing story: the document's chunk 0xBF14 names it and the - // document node. - let xml_story = match self.chunk(doc, xml::chunk::NODE_REF)? { - Some(d) if d.len() >= 4 => { - let s = Cursor::new(&d).u32()?; - match self.class(s) { - Some(class::STORY) => Some(self.story(s)?), - _ => None, - } - } - _ => None, - }; - let mut stories = stories; - for story in &mut stories { - story.orientation = self.story_orientation(story.uid); - } - let xml = XmlStructure { - story: xml_story, - elements: self.xml_elements(&xml_tag_names)?, - }; - let mut tints = Vec::new(); - for t in tint_objects { - match colors - .iter() - .find(|c| c.uid == t.base && !c.name.is_empty()) - { - Some(base) => { - let reference = t.reference(base); - swatches.insert(t.uid, reference.clone()); - tints.push((t.clone(), reference, t.idml_name(base))); - } - None => self.warn(format!( - "tint {}: left out: base colour {} has no name", - t.uid, t.base - )), - } - } - prune_style_groups(&mut style_groups, |m| self.warn(m)); - let preferences = self.document_preferences()?; - let prefs = self.prefs(version.major)?; - Ok(Document { - version, - layers, - active_layer, - spreads, - master_spreads, - stories, - styles, - colors, - tints, - gradients, - swatches, - fonts, - languages, - language_list, - toc_styles: self.toc_styles(), - named_grids: self.named_grids(), - index_groups: self.index_groups(), - constant_shade: self.constant_shade(), - assignments: { - let mut a: Vec = self - .db - .classes() - .iter() - .filter(|&&(_, c)| c == class::ASSIGNMENT) - .map(|&(u, _)| u) - .collect(); - a.sort_unstable(); - a - }, - style_groups, - object_styles, - cell_styles, - table_styles, - users: self.users(doc).unwrap_or_else(|e| { - self.warn(format!("document users left out: {e}")); - Vec::new() - }), - sections: self - .uid_list(doc, chunk::DOC_SECTIONS)? - .into_iter() - .map(|uid| self.section(uid)) - .collect::, _>>()?, - text_variables, - hyperlinks, - text_sources, - destinations, - bookmarks, - bookmark_order: match self.chunk(doc, hyperlink::chunk::DOCUMENT_LISTS)? { - Some(d) => hyperlink::document_bookmarks(&d, version.major)?, - None => Vec::new(), - }, - cross_reference_formats, - warnings: self.warnings.borrow().clone(), - preferences, - prefs, - composite_fonts: composite_fonts - .into_iter() - .map(|(uid, name, entries)| CompositeFont { - uid, - name, - entries: entries - .iter() - .filter_map(|e| composite_entries.get(e).cloned()) - .collect(), - }) - .collect(), - cjk_tables, - inks, - color_groups: self - .color_group_order()? - .into_iter() - .filter_map(|u| color_groups.remove(&u)) - .collect(), - bullets: self.bullets()?, - xml_tags, - xml, - }) - } - - /// The text orientation shared by all frames of a story. A story - /// whose frames disagree, or have an orientation that is not known, - /// gets none, with a warning. - fn story_orientation(&self, story: u32) -> Option { - let map = self.frame_orientations.borrow(); - let frames = map.get(&story)?; - let first = frames[0]; - if first.is_none() || frames.iter().any(|&o| o != first) { - self.warn(format!( - "story {story}: text orientation of its frames is not known or differs; written as horizontal" - )); - return None; - } - first - } - - /// An interface colour (class 0x1F11): chunk 0x1F01 holds u32 space - /// (5 = RGB), u16 count and the components as f64 fractions. - fn ui_color(&self, uid: u32) -> Result, Error> { - if self.class(uid) != Some(class::UI_COLOR) { - return Ok(None); - } - let Some(d) = self.chunk(uid, color::chunk::COLOR_VALUE)? else { - return Ok(None); - }; - let mut c = Cursor::new(&d); - if c.u32()? != 5 || c.u16()? != 3 { - return Ok(None); - } - Ok(Some([c.f64()?, c.f64()?, c.f64()?])) - } - - /// The bullet characters in the preferences object (chunk 0x1A488): - /// u16 1, u32 count, then the bullets. - fn bullets(&self) -> Result, Error> { - let Some(&(uid, _)) = self - .db - .classes() - .iter() - .find(|(_, c)| *c == class::PREFERENCES) - else { - return Ok(Vec::new()); - }; - let Some(d) = self.chunk(uid, chunk::BULLETS)? else { - return Ok(Vec::new()); - }; - let mut c = Cursor::new(&d); - if c.u16()? != 1 { - return Ok(Vec::new()); - } - let n = c.u32()?; - let mut out = Vec::new(); - for _ in 0..n { - let kind = c.u32()?; - let value = c.u32()?; - let font = c.u32()?; - let builtin = c.flag()? == 1; - let style = c.string()?; - // 0, or 1 and four bytes of unknown meaning (objects.md). - match c.u8()? { - 0 => {} - 1 => c.skip(4)?, - other => { - return Err(Error::Corrupt(format!( - "bullet font style followed by {other} at {}", - c.pos() - 1 - ))); - } - } - out.push(Bullet { - kind, - value, - font, - font_style: if builtin { - format!("$ID/{style}") - } else { - style - }, - }); - } - Ok(out) - } - - /// The colour groups listed in the preferences object (chunk 0x1F61). - fn color_group_order(&self) -> Result, Error> { - let Some(&(uid, _)) = self - .db - .classes() - .iter() - .find(|(_, c)| *c == class::PREFERENCES) - else { - return Ok(Vec::new()); - }; - self.uid_list(uid, color::chunk::COLOR_GROUPS) - } - - fn document_preferences(&self) -> Result, Error> { - let Some(&(uid, _)) = self - .db - .classes() - .iter() - .find(|(_, c)| *c == class::PREFERENCES) - else { - return Ok(None); - }; - let Some(d) = self.chunk(uid, chunk::DOCUMENT_PREFERENCES)? else { - return Ok(None); - }; - if d.len() < 146 { - self.warn(format!( - "document preferences of {} bytes are not known; left out", - d.len() - )); - return Ok(None); - } - let f = |o: usize| Cursor::new(&d[o..]).f64(); - let u = |o: usize| Cursor::new(&d[o..]).u32(); - let binding = Cursor::new(&d[64..]).u16()?; - if binding > 1 { - self.warn(format!( - "document preferences: page binding code {binding} is not known; left out" - )); - } - Ok(Some(DocumentPreferences { - page_width: f(0)?, - page_height: f(8)?, - facing_pages: d[58] == 2, - bleed: [f(78)?, f(94)?, f(70)?, f(86)?], - intent: u(142)?, - page_binding: binding, - })) - } - - /// Text orientation of a multi-column frame (chunk 0x2DE): the - /// identity gives horizontal text, the rotation 0 1 −1 0 vertical - /// text (`docs/format/objects.md`). `None` without the chunk; - /// `Some(None)` for another matrix. - fn frame_orientation(&self, mcf: u32) -> Result>, Error> { - let Some(d) = self.chunk(mcf, chunk::FRAME_TEXT_TRANSFORM)? else { - return Ok(None); - }; - if d.len() < 48 { - return Ok(Some(None)); - } - let Matrix([a, b, c, dd, _, _]) = Matrix::read(&mut Cursor::new(&d))?; - Ok(Some(match [a, b, c, dd] { - [1.0, 0.0, 0.0, 1.0] => Some(Orientation::Horizontal), - [0.0, 1.0, -1.0, 0.0] => Some(Orientation::Vertical), - _ => None, - })) - } - - /// Text frame settings of frame `frame`, from its multi-column frame - /// `mcf` and the frame itself. - fn text_frame_preferences( - &self, - frame: u32, - mcf: u32, - ) -> Result, Error> { - let (Some(cols), Some(just)) = ( - self.chunk(mcf, chunk::FRAME_COLUMNS)?, - self.chunk(mcf, chunk::FRAME_JUSTIFICATION)?, - ) else { - return Ok(None); - }; - if cols.len() < 22 || just.len() < 28 { - return Ok(None); - } - let minimum_sizes = (just.len() >= 48).then(|| { - let flag = |at| u16_at(&just, at).is_some_and(|v| v != 0); - ( - [flag(26), flag(36)], - [ - f64_at(&just, 28).unwrap_or(0.0), - f64_at(&just, 38).unwrap_or(0.0), - ], - flag(46), - ) - }); - let column_rule = match self.chunk(mcf, chunk::FRAME_COLUMN_RULE)? { - Some(d) => match (f64_at(&d, 28), u32_at(&d, 36)) { - (Some(w), Some(c)) => Some((w, c)), - _ => None, - }, - None => None, - }; - let footnotes = match self.chunk(mcf, chunk::FRAME_FOOTNOTES)? { - Some(d) => match (f64_at(&d, 4), f64_at(&d, 12)) { - (Some(a), Some(b)) => Some([a, b]), - _ => None, - }, - None => None, - }; - // The frame's chunk 0x3723: f64, u32, then four f64: left, top, - // right, bottom. - let inset = match self.chunk(frame, chunk::FRAME_INSET)? { - Some(d) if d.len() >= 44 => { - let f = |at| f64_at(&d, at).unwrap_or(0.0); - [f(20), f(12), f(36), f(28)] - } - _ => [0.0; 4], - }; - Ok(Some(TextFramePreferences { - column_count: Cursor::new(&cols).u32()?, - column_gutter: Cursor::new(&cols[4..]).f64()?, - column_fixed_width: Cursor::new(&cols[14..]).f64()?, - first_baseline_offset: Cursor::new(&just).u16()?, - vertical_justification: Cursor::new(&just[2..]).u16()?, - vertical_balance_columns: Cursor::new(&just[20..]).u16()? != 0, - auto_sizing_type: Cursor::new(&just[22..]).u16()?, - auto_sizing_reference_point: Cursor::new(&just[24..]).u16()?, - use_fixed_width: cols.get(12).is_some_and(|&b| b != 0), - max_width: if cols.len() >= 40 { - f64_at(&cols, 32) - } else { - None - }, - minimum_sizes, - ignore_wrap: self - .chunk(mcf, chunk::FRAME_IGNORE_WRAP)? - .and_then(|d| u16_at(&d, 0)) - .map(|v| v != 0), - column_rule, - column_rule_override: self - .chunk(mcf, chunk::FRAME_COLUMN_RULE_OVERRIDE)? - .map(|d| d.iter().any(|&b| b != 0)), - footnotes, - inset, - })) - } - - fn section(&self, uid: u32) -> Result { - let mut section = Section { - uid, - page: None, - continue_numbering: true, - start: 1, - style: numbering::ARABIC, - prefix: String::new(), - marker: String::new(), - alternate_layout: None, - }; - // u8, string (prefix), u8, string (marker), u32 first page, u32 - // page number start, u32 numbering style, u32 continue, u32, then - // u8 and string (alternate layout). - if let Some(d) = self.chunk(uid, chunk::SECTION_INFO)? { - let mut c = Cursor::new(&d); - let parsed = (|| -> Result<(String, String, [u32; 4]), Error> { - c.u8()?; - let prefix = c.string()?; - c.u8()?; - let marker = c.string()?; - Ok((prefix, marker, [c.u32()?, c.u32()?, c.u32()?, c.u32()?])) - })(); - if let Ok((prefix, marker, [page, start, style, cont])) = parsed { - section.page = uid_or_none(page); - section.start = start; - section.style = style; - section.continue_numbering = cont != 0; - section.prefix = prefix; - section.marker = marker; - section.alternate_layout = (|| -> Result<(u8, String), Error> { - c.u32()?; - let flag = c.flag()?; - Ok((flag, c.string()?)) - })() - .ok(); - } - } - if ![numbering::ARABIC, numbering::LOWER_ROMAN, numbering::KANJI].contains(§ion.style) { - self.warn(format!( - "section {uid}: page number style {:#x} is not known; left out", - section.style - )); - } - Ok(section) - } - - fn layer(&self, uid: u32) -> Result { - let data = self.required(uid, chunk::LAYER_PROPS)?; - let mut c = Cursor::new(&data); - let locked = c.u16()? != 0; - let visible = c.u16()? != 0; - c.skip(14)?; - // A string follows; its position varies, so search for the tag. - let name = find_string(&data, 18)?; - let settings = self.layer_settings(&data)?; - Ok(Layer { - uid, - internal: name == "Internal_pages_layer_name", - name, - visible, - locked, - settings, - }) - } - - /// The settings in chunk 0x304 when the name is at offset 19, as in - /// all corpus pairs: u16 printable at 4, u16 lock guides at 6, u32 - /// colour at 10, u16 UI at 14; after the name, u16 ignore wrap. - fn layer_settings(&self, data: &[u8]) -> Result, Error> { - if crate::object::big_endian() || data.len() < 23 || data[19] != 2 { - return Ok(None); - } - let mut c = Cursor::new(&data[19..]); - c.string()?; - let ignore_wrap = c.u16()? != 0; - let flag = |at: usize| u16_at(data, at).is_some_and(|v| v != 0); - let color = match u32_at(data, 10) { - Some(u) => self.ui_color(u)?, - None => None, - }; - Ok(Some(LayerSettings { - printable: flag(4), - lock_guides: flag(6), - ui: flag(14), - ignore_wrap, - color, - })) - } - - /// A colour setting: 0 none, 1 the master's, else an interface colour. - fn ui_color_ref(&self, code: u32) -> Result { - Ok(match code { - 0 => UiColorRef::Nothing, - 1 => UiColorRef::UseMaster, - u => match self.ui_color(u)? { - Some(rgb) => UiColorRef::Rgb(rgb), - None => UiColorRef::Unknown, - }, - }) - } - - fn spread(&self, uid: u32) -> Result { - let transform = match self.chunk(uid, chunk::SPREAD_TRANSFORM)? { - Some(d) => Matrix::read(&mut Cursor::new(&d))?, - None => Matrix::IDENTITY, - }; - let binding_location = match self.chunk(uid, chunk::SPREAD_BINDING)? { - Some(d) => Cursor::new(&d).u32()?, - None => 0, - }; - let master_name = match self.chunk(uid, chunk::MASTER_NAME)? { - Some(d) => { - let mut c = Cursor::new(&d); - c.u8()?; - let prefix = c.string()?; - c.u8()?; - let base = c.string()?; - Some((prefix, base)) - } - None => None, - }; - let children = self.required(uid, chunk::SPREAD_CHILDREN)?; - let mut c = Cursor::new(&children); - c.skip(8)?; - let spread_layers = c.u32_list()?; - let mut pages = Vec::new(); - let mut items = Vec::new(); - let mut guides = Vec::new(); - for sl in spread_layers { - let layer = match self.chunk(sl, chunk::SPREAD_LAYER_LAYER)? { - Some(d) => Cursor::new(&d).u32()?, - None => 0, - }; - for child in self.children(sl, chunk::SPREAD_LAYER_CHILDREN)? { - match self.class(child) { - Some(class::PAGE) => pages.push(self.page(child)?), - Some(class::GUIDE) => guides.extend(self.guide(child, layer)?), - _ => { - if let Some(item) = self.page_item(child, Some(layer))? { - items.push(item); - } - } - } - } - } - if let Some(d) = self.chunk(uid, chunk::SPREAD_TAB_ORDERS)? { - let mut c = Cursor::new(&d); - let n = c.u32()?; - for _ in 0..n { - let page = c.u32()?; - let order = c.u32_list()?; - if let Some(p) = pages.iter_mut().find(|p| p.uid == page) { - p.settings.tab_order = order; - } - } - } - let flattener_resolution = match self.chunk(uid, chunk::SPREAD_FLATTENER)? { - Some(d) => match (f64_at(&d, 20), f64_at(&d, 28)) { - (Some(a), Some(b)) => Some([a, b]), - _ => None, - }, - None => None, - }; - let short = |id: u32| -> Result, Error> { - Ok(self.chunk(uid, id)?.and_then(|d| u16_at(&d, 0))) - }; - Ok(Spread { - uid, - master_name, - transform, - binding_location, - pages, - items, - guides, - shuffle: short(chunk::SPREAD_SHUFFLE)?, - flattener_resolution, - show_master_items: short(chunk::MASTER_SHOW_ITEMS)?, - }) - } - - /// A ruler guide from chunk 0x3308: f64 position, u32 owner (page or - /// spread), u16 orientation (1 horizontal), f64 view threshold, u32 - /// colour, u16 fit to page, f64, u32, u32 guide type, f64. Records of - /// 40 bytes, from InDesign 3.0 to 7.0, end before the guide type. - fn guide(&self, uid: u32, layer: u32) -> Result, Error> { - let Some(d) = self.chunk(uid, chunk::GUIDE)? else { - return Ok(None); - }; - if d.len() != 40 && d.len() < 52 { - self.warn(format!( - "guide {uid}: guide record of {} bytes is not known; left out", - d.len() - )); - return Ok(None); - } - let f = |o: usize| Cursor::new(&d[o..]).f64(); - let u = |o: usize| Cursor::new(&d[o..]).u32(); - let h = |o: usize| Cursor::new(&d[o..]).u16(); - Ok(Some(Guide { - uid, - position: f(0)?, - owner: u(8)?, - horizontal: h(12)? == 1, - view_threshold: f(14)?, - color: u(22)?, - fit_to_page: h(26)? == 1, - guide_type: if d.len() >= 52 { Some(u(40)?) } else { None }, - layer, - locked: self - .chunk(uid, chunk::ITEM_LOCKED)? - .is_some_and(|d| u32_at(&d, 0) == Some(1)), - zone: if d.len() >= 52 { Some(f(44)?) } else { None }, - overridden: match self.chunk(uid, chunk::ITEM_OVERRIDE)? { - Some(o) => { - let mut c = Cursor::new(&o); - let master = c.u32()?; - Some((master, c.u32_list()?)) - } - None => None, - }, - })) - } - - /// Children listed in a hierarchy chunk: parent, owner, then a u32 list. - fn children(&self, uid: u32, id: u32) -> Result, Error> { - match self.chunk(uid, id)? { - Some(d) => { - let mut c = Cursor::new(&d); - c.skip(8)?; - c.u32_list() - } - None => Ok(Vec::new()), - } - } - - fn page(&self, uid: u32) -> Result { - // Files from InDesign 3.0 and 4.0 store the transform and bounds in - // the chunks page items use (docs/format/big-endian.md). - let transform = match self.chunk(uid, chunk::PAGE_TRANSFORM)? { - Some(d) => d, - None => self.required(uid, chunk::ITEM_TRANSFORM)?, - }; - let transform = Matrix::read(&mut Cursor::new(&transform))?; - let b = match self.chunk(uid, chunk::PAGE_BOUNDS)? { - Some(d) => d, - None => self.required(uid, chunk::OLD_PAGE_BOUNDS)?, - }; - let mut c = Cursor::new(&b); - let bounds = [c.f64()?, c.f64()?, c.f64()?, c.f64()?]; - let (master, master_transform) = match self.chunk(uid, chunk::PAGE_MASTER)? { - Some(d) => { - let mut c = Cursor::new(&d); - let m = c.u32()?; - c.skip(2)?; - // The matrix is missing in files from InDesign 3.0 and 4.0. - let t = match c.remaining() { - 0 => Matrix::IDENTITY, - _ => Matrix::read(&mut c)?, - }; - (uid_or_none(m), t) - } - None => (None, Matrix::IDENTITY), - }; - let margins = match self.chunk(uid, chunk::PAGE_MARGINS)? { - Some(d) if d.len() >= 34 => { - let mut c = Cursor::new(&d); - Some(Margins { - left: c.f64()?, - top: c.f64()?, - right: c.f64()?, - bottom: c.f64()?, - own: c.u16()? == 1, - }) - } - _ => None, - }; - let columns = match self.chunk(uid, chunk::PAGE_COLUMNS)? { - Some(d) => { - let mut c = Cursor::new(&d); - let n = c.u32()? as usize; - if n > d.len() / 8 { - return Err(Error::Corrupt(format!("page {uid}: {n} column positions"))); - } - let positions = (0..n).map(|_| c.f64()).collect::, _>>()?; - Some(Columns { - positions, - gutter: c.f64()?, - own: c.u16()? == 1, - }) - } - None => None, - }; - let grid = match self.chunk(uid, chunk::PAGE_GRID)? { - Some(d) => { - let mut c = Cursor::new(&d); - let font = c.u32()?; - c.u8()?; - let font_style = c.string()?; - let numbers = [c.f64()?, c.f64()?, c.f64()?, c.f64()?, c.f64()?]; - let codes = [c.u32()?, c.u32()?, c.u32()?, c.u32()?]; - Some(GridData { - font, - font_style, - numbers, - codes, - }) - } - None => None, - }; - // u32 count, then (unless it is 0) the two lists. - let overrides = match self.chunk(uid, chunk::PAGE_OVERRIDES)? { - Some(d) if u32_at(&d, 0).is_some_and(|n| n > 0) => { - let mut c = Cursor::new(&d[4..]); - let items = c.u32_list()?; - let with = c.u32_list()?; - items.into_iter().zip(with).collect() - } - _ => Vec::new(), - }; - let settings = PageSettings { - overrides, - use_master_grid: self - .chunk(uid, chunk::PAGE_GRID_USE)? - .and_then(|d| u16_at(&d, 4)) - .map(|v| v != 0), - layout_rule: self - .chunk(uid, chunk::PAGE_LAYOUT_RULE)? - .and_then(|d| u32_at(&d, 4)), - color: match self - .chunk(uid, chunk::PAGE_COLOR)? - .and_then(|d| u32_at(&d, 0)) - { - Some(code) => self.ui_color_ref(code)?, - None => UiColorRef::UseMaster, - }, - tab_order: Vec::new(), - }; - Ok(Page { - uid, - bounds, - transform, - master, - master_transform, - margins, - columns, - grid, - settings, - }) - } - - /// The document's users, from chunk 0xA443 of the document. - fn users(&self, doc: u32) -> Result, Error> { - let Some(d) = self.chunk(doc, chunk::DOC_USERS)? else { - return Ok(Vec::new()); - }; - let mut c = Cursor::new(&d); - let n = c.u32()?; - if n as usize > d.len() / 9 { - return Err(Error::Corrupt(format!("{n} document users"))); - } - (0..n) - .map(|_| { - let flag = c.flag()?; - let name = c.string()?; - c.u32()?; - Ok((flag, name)) - }) - .collect() - } - - /// The settings every page item has (`ItemProps`). - fn item_props(&self, uid: u32) -> Result { - let name_chunk = if self.class(uid) == Some(class::GROUP) { - chunk::GROUP_NAME - } else { - chunk::ITEM_NAME - }; - let name = match self.chunk(uid, name_chunk)? { - Some(d) => { - let mut c = Cursor::new(&d); - let builtin = c.flag()? == 1; - Some(ItemName { - builtin, - name: c.string()?, - }) - } - None => None, - }; - let counts = |id: u32| -> Result, Error> { - let Some(d) = self.chunk(uid, id)? else { - return Ok(Vec::new()); - }; - let mut c = Cursor::new(&d); - let n = c.u32()? as usize; - if n > d.len() / 8 { - return Err(Error::Corrupt(format!("item {uid}: {n} change counts"))); - } - (0..2 * n).map(|_| c.u32()).collect() - }; - let overridden = match self.chunk(uid, chunk::ITEM_OVERRIDE)? { - Some(d) => { - let mut c = Cursor::new(&d); - let master = c.u32()?; - Some((master, c.u32_list()?)) - } - None => None, - }; - Ok(ItemProps { - name, - hidden: self - .chunk(uid, chunk::ITEM_VISIBLE)? - .is_some_and(|d| d.len() >= 2 && Cursor::new(&d).u16().ok() == Some(0)), - locked: self - .chunk(uid, chunk::ITEM_LOCKED)? - .is_some_and(|d| d.len() >= 4 && Cursor::new(&d).u32().ok() == Some(1)), - layout_constraints: self - .chunk(uid, chunk::ITEM_LAYOUT_CONSTRAINTS)? - .and_then(|d| d.first().copied()), - change_counts: [ - counts(chunk::ITEM_PARENT_CHANGES)?, - counts(chunk::ITEM_TARGET_CHANGES)?, - counts(chunk::ITEM_UPDATED_CHANGES)?, - ], - overridden, - graphic_frame: self - .chunk(uid, chunk::ITEM_CONTENT)? - .is_some_and(|d| d.len() >= 2 && Cursor::new(&d).u16().ok() == Some(1)), - }) - } - - /// Text wrap of a page item or graphic, from chunk 0x3703: u32 mode, - /// u32 contour path object, four f64 offsets, u32 flags. - fn text_wrap(&self, uid: u32) -> Result, Error> { - self.wrap_chunk(uid, chunk::TEXT_WRAP) - } - - /// A text wrap record in chunk `id` of object `uid`. - fn wrap_chunk(&self, uid: u32, id: u32) -> Result, Error> { - let Some(d) = self.chunk(uid, id)? else { - return Ok(None); - }; - if d.len() < 44 { - return Ok(None); - } - let mut c = Cursor::new(&d); - let mode = c.u32()?; - c.skip(4)?; - let offsets = [c.f64()?, c.f64()?, c.f64()?, c.f64()?]; - let flags = c.u32()?; - if !matches!( - mode, - wrap_mode::NONE | wrap_mode::JUMP_OBJECT | wrap_mode::BOUNDING_BOX | wrap_mode::CONTOUR - ) { - self.warn(format!( - "item {uid}: text wrap mode {mode} is not known; left out" - )); - } - Ok(Some(TextWrap { - mode, - offsets, - flags, - })) - } - - fn paths(&self, uid: u32) -> Result, Error> { - let Some(data) = self.chunk(uid, chunk::ITEM_PATHS)? else { - return Ok(Vec::new()); - }; - let mut c = Cursor::new(&data); - let n = c.u32()?; - let mut paths = Vec::new(); - for _ in 0..n { - let count = c.u32()?; - let mut points = Vec::new(); - for _ in 0..count { - let kind = c.u32()?; - let p = match kind { - 2 => { - let a = (c.f64()?, c.f64()?); - PathPoint { - anchor: a, - left: a, - right: a, - kind, - } - } - 0 | 1 => { - let left = (c.f64()?, c.f64()?); - let anchor = (c.f64()?, c.f64()?); - let right = (c.f64()?, c.f64()?); - PathPoint { - anchor, - left, - right, - kind, - } - } - other => { - return Err(Error::Corrupt(format!( - "object {uid}: unknown path point type {other}" - ))); - } - }; - points.push(p); - } - let open = c.u16()? != 0; - paths.push(Path { points, open }); - } - Ok(paths) - } - - /// A page item and the items it contains. An item that contains - /// itself, or one nested more than [`MAX_ITEM_DEPTH`] deep, is left - /// out with a warning. - fn page_item(&self, uid: u32, layer: Option) -> Result, Error> { - let cls = self.class(uid); - if cls != Some(class::SPLINE_ITEM) && cls != Some(class::GROUP) { - return Ok(None); - } - { - let path = self.item_path.borrow(); - if path.contains(&uid) { - drop(path); - self.warn(format!("item {uid} contains itself; left out")); - return Ok(None); - } - if path.len() >= MAX_ITEM_DEPTH { - drop(path); - self.warn(format!( - "item {uid} is nested more than {MAX_ITEM_DEPTH} deep; left out" - )); - return Ok(None); - } - } - self.item_path.borrow_mut().push(uid); - let item = self.page_item_contents(uid, cls, layer); - self.item_path.borrow_mut().pop(); - item - } - - fn page_item_contents( - &self, - uid: u32, - cls: Option, - layer: Option, - ) -> Result, Error> { - // Groups without chunk 0x151 have their transform in chunk 0x40D. - let transform = match self.chunk(uid, chunk::ITEM_TRANSFORM)? { - Some(d) => Matrix::read(&mut Cursor::new(&d))?, - None => match self.chunk(uid, chunk::GROUP_TRANSFORM)? { - Some(d) if cls == Some(class::GROUP) && d.len() >= 48 => { - Matrix::read(&mut Cursor::new(&d))? - } - _ => Matrix::IDENTITY, - }, - }; - let child_uids = self.children(uid, chunk::ITEM_HIERARCHY)?; - let mut children = Vec::new(); - let mut graphics = Vec::new(); - let mut text_column = None; - let mut frame_prefs = None; - let mut frame_mcf = None; - for &child in &child_uids { - if let Some(g) = self.graphic(child)? { - graphics.push(g); - } else if self.class(child) == Some(class::MULTI_COLUMN_FRAME) { - frame_prefs = self.text_frame_preferences(uid, child)?; - frame_mcf = Some(child); - text_column = self - .children(child, chunk::ITEM_HIERARCHY)? - .into_iter() - .find(|&c| self.class(c) == Some(class::FRAME_COLUMN)); - } else if let Some(item) = self.page_item(child, layer)? { - children.push(item); - } - } - let paths = self.paths(uid)?; - let attrs = match self.chunk(uid, chunk::ITEM_ATTRS)? { - Some(d) => Attrs::parse(&d, List::Item).unwrap_or_default(), - None => Attrs::default(), - }; - let object_style = match self.chunk(uid, chunk::ITEM_OBJECT_STYLE)? { - Some(d) => uid_or_none(Cursor::new(&d).u32()?), - None => None, - }; - let kind = if cls == Some(class::GROUP) { - ItemKind::Group - } else if let Some(column) = text_column { - let mut kind = self.text_frame_links(column)?; - if let ItemKind::TextFrame { - preferences, story, .. - } = &mut kind - { - *preferences = frame_prefs; - if let (Some(story), Some(mcf)) = (*story, frame_mcf) - && let Some(o) = self.frame_orientation(mcf)? - { - self.frame_orientations - .borrow_mut() - .entry(story) - .or_default() - .push(o); - } - } - kind - } else { - let code = self - .chunk(uid, chunk::ITEM_SHAPE)? - .and_then(|d| u32_at(&d, 2)); - ItemKind::Shape(classify(&paths, code)) - }; - Ok(Some(PageItem { - uid, - graphics, - kind, - transform, - paths, - layer, - attrs, - object_style, - children, - text_wrap: self.text_wrap(uid)?, - anchor: None, - props: self.item_props(uid).unwrap_or_else(|e| { - self.warn(format!("item {uid}: settings left out: {e}")); - ItemProps::default() - }), - })) - } - - fn graphic(&self, uid: u32) -> Result, Error> { - let kind = match self.class(uid) { - Some(class::IMAGE) => GraphicKind::Image, - Some(class::PDF) => GraphicKind::Pdf, - Some(class::EPS) => GraphicKind::Eps, - Some(class::SVG) => GraphicKind::Svg, - _ => return Ok(None), - }; - let transform = match self.chunk(uid, chunk::ITEM_TRANSFORM)? { - Some(d) => Matrix::read(&mut Cursor::new(&d))?, - None => Matrix::IDENTITY, - }; - let bounds = match self.chunk(uid, chunk::GRAPHIC_BOUNDS)? { - Some(d) => { - let mut c = Cursor::new(&d); - [c.f64()?, c.f64()?, c.f64()?, c.f64()?] - } - None => [0.0; 4], - }; - let link = match self.chunk(uid, chunk::GRAPHIC_LINK)? { - Some(d) if d.len() >= 12 => self.link(Cursor::new(&d[8..]).u32()?)?, - _ => None, - }; - let (link, contents) = match link { - Some((link, data)) => (Some(link), data), - None => { - let id = match kind { - GraphicKind::Image => Some(chunk::IMAGE_DATA), - GraphicKind::Pdf => Some(chunk::PDF_DATA), - _ => None, - }; - let data = match id { - Some(id) => match self.chunk(uid, id)? { - Some(d) if d.len() >= 4 => self.raw_data(Cursor::new(&d).u32()?)?, - _ => None, - }, - None => None, - }; - (None, data) - } - }; - Ok(Some(Graphic { - uid, - kind, - transform, - bounds, - link, - contents, - text_wrap: self.text_wrap(uid)?, - contour_type: match self.chunk(uid, chunk::CONTOUR_OPTION)? { - Some(d) if d.len() >= 4 => Some(Cursor::new(&d).u32()?), - _ => None, - }, - clipping: match self.chunk(uid, chunk::CLIPPING_PATH)? { - Some(d) if d.len() >= 26 => { - let f = |o: usize| Cursor::new(&d[o..]).f64(); - Some(ClippingPath { - kind: Cursor::new(&d).u32()?, - tolerance: f(4)?, - inset: f(12)?, - threshold: d[20], - index: i16_from([d[23], d[24]]), - high_resolution: d[25], - }) - } - _ => None, - }, - photoshop_clipping: match self.chunk(uid, chunk::PHOTOSHOP_CLIPPING)? { - Some(d) if d.len() >= 2 => Some(Cursor::new(&d).u16()?), - _ => None, - }, - })) - } - - /// The bytes of raw data object `uid` (`None` if `uid` is not one). - fn raw_data(&self, uid: u32) -> Result { - if uid == 0 || self.class(uid) != Some(class::RAW_DATA) { - return Ok(None); - } - crate::audit::object_read(uid); - self.db.object(uid) - } - - /// A link, the URI of its resource and, for an embedded link, the - /// embedded file. - fn link(&self, uid: u32) -> Result, Error> { - if uid == 0 || self.db.object(uid)?.is_none() { - return Ok(None); - } - let Some(info) = self.chunk(uid, chunk::LINK_INFO)? else { - return Ok(None); - }; - if info.len() < 12 { - return Ok(None); - } - let resource = Cursor::new(&info[8..]).u32()?; - let (uri, data) = match self.chunk(resource, chunk::LINK_RESOURCE_URI)? { - Some(d) if d.len() >= 5 => { - let mut c = Cursor::new(&d); - c.u8()?; - let n = c.u32()? as usize; - let uri = String::from_utf8_lossy(c.bytes(n.min(c.remaining()))?).into_owned(); - // After the URI: 12 bytes, then the UID of the embedded - // file's raw data object (0 for a normal link). - let data = if c.remaining() >= 16 { - c.skip(12)?; - self.raw_data(c.u32()?)? - } else { - None - }; - (uri, data) - } - _ => (String::new(), None), - }; - let link = Link { - uid, - uri, - embedded: data.is_some(), - }; - Ok(Some((link, data))) - } - - /// Story and threading of the text frame owning `column`. - fn text_frame_links(&self, column: u32) -> Result { - let none = ItemKind::TextFrame { - story: None, - previous: None, - next: None, - preferences: None, - }; - let Some(d) = self.chunk(column, chunk::COLUMN_FRAME_LIST)? else { - return Ok(none); - }; - let list = Cursor::new(&d).u32()?; - let Some(d) = self.chunk(list, chunk::FRAME_LIST_FRAMES)? else { - return Ok(none); - }; - let mut c = Cursor::new(&d); - let story = uid_or_none(c.u32()?); - let columns = c.u32_list()?; - // Columns belong to frames: column -> multi-column frame -> spline item. - let frame_of = |col: u32| -> Result, Error> { - let Some(h) = self.chunk(col, chunk::ITEM_HIERARCHY)? else { - return Ok(None); - }; - let mcf = Cursor::new(&h[4..]).u32()?; - let Some(h) = self.chunk(mcf, chunk::ITEM_HIERARCHY)? else { - return Ok(None); - }; - Ok(uid_or_none(Cursor::new(&h[4..]).u32()?)) - }; - let mut frames: Vec = Vec::new(); - for col in columns.iter().copied() { - if let Some(f) = frame_of(col)? - && frames.last() != Some(&f) - { - frames.push(f); - } - } - let me = frame_of(column)?; - let pos = me.and_then(|m| frames.iter().position(|&f| f == m)); - Ok(ItemKind::TextFrame { - story, - previous: pos.and_then(|i| i.checked_sub(1)).map(|i| frames[i]), - next: pos.and_then(|i| frames.get(i + 1).copied()), - preferences: None, - }) - } - - fn style(&self, uid: u32) -> Result, Error> { - let Some(data) = self.chunk(uid, chunk::STYLE_INFO)? else { - return Ok(None); - }; - let mut c = Cursor::new(&data); - let next = c.u32()?; - let based_on = c.u32()?; - // The header before the name is 4 bytes shorter in files from - // InDesign 13 and earlier, so locate the name by its structure: a - // flag byte (1 = built-in name), then an in-object string. Four - // bytes before the flag, a u16 is 1 for paragraph styles and 0 for - // character styles; the u16 after it is not identified. - let Some((at, builtin, name)) = find_flagged_string(&data, 12, |_| true) else { - return Err(Error::Corrupt(format!("style {uid}: no name"))); - }; - let paragraph = Cursor::new(&data[at - 4..]).u16()? != 0; - let imported = Cursor::new(&data[at - 2..]).u16()? != 0; - let shortcut = if at >= 10 { - Some(( - Cursor::new(&data[at - 10..]).u32()?, - data[at - 6], - data[at - 5], - )) - } else { - None - }; - // A 36-character in-object string after the name: a GUID. - const GUID: [u8; 6] = [2, 0, 36, 0, 36, 0x40]; - let unique_id = if crate::object::big_endian() { - None - } else { - data[at..] - .windows(GUID.len()) - .position(|w| w == GUID) - .and_then(|i| Cursor::new(&data[at + i..]).string().ok()) - }; - let attrs = match self.chunk(uid, chunk::STYLE_ATTRS)? { - Some(d) if d.len() >= 2 => { - let mut c = Cursor::new(&d); - let n = c.u16()? as usize; - Attrs::parse_text(&mut c, n, List::Style).unwrap_or_default() - } - _ => Attrs::default(), - }; - Ok(Some(Style { - uid, - name, - builtin, - paragraph, - based_on: uid_or_none(based_on), - next: uid_or_none(next), - attrs, - imported, - unique_id, - shortcut, - })) - } - - fn story(&self, uid: u32) -> Result { - let data = self.required(uid, chunk::STORY_STRANDS)?; - let mut c = Cursor::new(&data); - c.skip(6)?; - let mut strands = vec![c.u32()?]; - strands.extend(c.u32_list()?); - let mut text: Vec = Vec::new(); - let mut para: Vec = Vec::new(); - let mut chars: Vec = Vec::new(); - let mut owned: Vec<(usize, u32, u32)> = Vec::new(); - // (start, length, owner, cell) for each stretch of text. - let mut owners: Vec<(usize, usize, u32, u32)> = Vec::new(); - let mut sources = Vec::new(); - let mut marker_strand = None; - for strand in strands { - // A strand without data occurs in a file from InDesign 3.0. - if self.db.object(strand)?.is_none() { - continue; - } - if self.class(strand) == Some(xml::class::MARKER_STRAND) { - marker_strand = Some(strand); - } - if self.class(strand) == Some(hyperlink::class::RANGE_STRAND) - && let Some(tree) = self.chunk(strand, hyperlink::chunk::RANGE_TREE)? - && tree.len() >= 4 - { - let first = u32_from(tree[..4].try_into().unwrap()); - let pages = |uid| self.chunk(uid, hyperlink::chunk::RANGE_PAGE); - match hyperlink::source_ranges(first, pages) { - Ok(r) => sources.extend(r), - Err(e) => self.warn(format!("story {uid}: hyperlink sources left out: {e}")), - } - } - let Some(list) = self.chunk(strand, chunk::STRAND_DATA)? else { - continue; - }; - let mut c = Cursor::new(&list); - let n = c.u16()?; - let mut base = 0usize; - for _ in 0..n { - let data_len = c.u32()? as usize; - let data_uid = c.u32()?; - let runs = self.required(data_uid, chunk::STRAND_RUNS)?; - let mut r = Cursor::new(&runs); - let kind = r.u32()?; - r.skip(4)?; - let count = r.u16()?; - let mut pos = base; - base += data_len; - for _ in 0..count { - let size = r.u32()? as usize; - let rec = r.bytes(size)?; - let mut rc = Cursor::new(rec); - let len = rc.u32()? as usize; - let start = pos; - pos += len; - match kind { - strand::OWNED_ITEMS => { - let n = rc.u16()?; - for _ in 0..n { - let class = rc.u32()?; - let item = rc.u32()?; - owned.push((start, class, item)); - } - } - strand::TEXT => { - text.extend(rc.segment_units(len)?); - } - strand::TEXT_OWNER => { - let owner = rc.u32()?; - let cell = rc.u32()?; - owners.push((start, len, owner, cell)); - } - strand::PARAGRAPH_STYLE | strand::CHARACTER_STYLE => { - let style = rc.u32()?; - let n = rc.u16()? as usize; - let attrs = - Attrs::parse_text(&mut rc, n, List::Text).unwrap_or_default(); - let list = if kind == strand::PARAGRAPH_STYLE { - &mut para - } else { - &mut chars - }; - list.push((len, style, attrs)); - } - _ => crate::audit::unknown_strand_kind(kind), - } - } - } - } - // Text records count UTF-16 code units, every other strand counts - // characters (a surrogate pair is one position). Convert the - // positions to UTF-16 offsets. - let offsets = char_offsets(&text); - let unit = |p: usize| match offsets.get(p) { - Some(&u) => u, - None => text.len() + (p + 1 - offsets.len()), - }; - let to_units = |list: Vec| -> Vec { - let mut at = 0; - list.into_iter() - .map(|(len, style, attrs)| { - let n = unit(at + len) - unit(at); - at += len; - (n, style, attrs) - }) - .collect() - }; - let para = to_units(para); - let chars = to_units(chars); - let owned: Vec<_> = owned - .into_iter() - .map(|(p, cls, item)| (unit(p), cls, item)) - .collect(); - let owners: Vec<_> = owners - .into_iter() - .map(|(p, len, owner, cell)| (unit(p), unit(p + len) - unit(p), owner, cell)) - .collect(); - for r in &mut sources { - let start = unit(r.start); - r.len = unit(r.start + r.len) - start; - r.start = start; - } - let xml_markers = match self.story_xml(uid, marker_strand, ¶, &unit) { - Ok(m) => m, - Err(e) => { - self.warn(format!("story {uid}: XML structure left out: {e}")); - BTreeMap::new() - } - }; - let xml_element = match self.chunk(uid, xml::chunk::NODE_REF)? { - Some(d) if d.len() >= 8 => { - let mut c = Cursor::new(&d); - Some((c.u32()?, c.u32()?)) - } - _ => None, - }; - let mut anchors: BTreeMap> = BTreeMap::new(); - let mut tables: BTreeMap = BTreeMap::new(); - let mut text_variables = BTreeMap::new(); - for (pos, cls, item) in owned { - match cls { - class::TEXT_VARIABLE_INSTANCE => { - let v = variable::Instance::read(item, &*self.object(item)?)?; - text_variables.insert(pos, v); - } - class::ANCHOR => { - let settings = self.chunk(item, chunk::ANCHOR_SETTINGS)?; - for child in self.children(item, chunk::ANCHOR_CHILDREN)? { - if let Some(mut pi) = self.page_item(child, None)? { - pi.anchor = settings.clone(); - anchors.entry(pos).or_default().push(pi); - } - } - } - table::class::TABLE_ANCHOR => { - // A table that cannot be read is left out, with a - // warning, rather than failing the whole document. - match self.table_of_anchor(item) { - Ok(Some(t)) => { - tables.insert(pos, t); - } - Ok(None) => {} - Err(e) => self.warn(format!("story {uid}: table left out: {e}")), - } - } - _ => {} - } - } - let cuts: Vec = owners.iter().map(|o| o.0).collect(); - let all = split_runs(&text, ¶, &chars, &cuts); - // Text not owned by the story belongs to table cells. - let owner_at = |at: usize| { - owners - .iter() - .find(|o| at >= o.0 && at < o.0 + o.1) - .map(|o| (o.2, o.3)) - }; - let mut runs = Vec::new(); - for run in all { - match owner_at(run.start) { - Some((owner, cell)) if owner != uid => { - if let Some(t) = tables.values_mut().find(|t| t.uid == owner) - && let Some(c) = t.cells.iter_mut().find(|c| c.id == cell) - { - c.runs.push(run); - } - } - _ => runs.push(run), - } - } - // IDML writes a text source inside one character range; keep the - // sources that lie within one run. - sources.sort_by_key(|r| r.start); - let cell_runs = tables - .values() - .flat_map(|t| t.cells.iter().flat_map(|c| &c.runs)); - let spans: Vec<(usize, usize)> = runs - .iter() - .chain(cell_runs) - .map(|r| (r.start, r.start + r.text.encode_utf16().count())) - .collect(); - sources.retain(|r| { - let inside = spans - .iter() - .any(|&(a, b)| r.start >= a && r.start + r.len <= b); - if !inside && r.len > 0 { - self.warn(format!( - "story {uid}: hyperlink source {} spans several text ranges; left out", - r.source - )); - } - // The IDML schema allows no page item inside a text source. - let anchored = anchors.range(r.start..r.start + r.len).next().is_some(); - if inside && anchored { - self.warn(format!( - "story {uid}: hyperlink source {} holds an anchored object; left out", - r.source - )); - } - inside && r.len > 0 && !anchored - }); - Ok(Story { - uid, - runs, - anchors, - tables, - text_variables, - sources, - xml_markers, - xml_element, - orientation: None, - // The story names an object (class 0x8C20) whose chunk 0x11613 - // is the TOC style. - toc_style: match self - .chunk(uid, chunk::STORY_TOC)? - .and_then(|d| u32_at(&d, 0)) - .and_then(uid_or_none) - { - Some(toc) => self - .chunk(toc, chunk::TOC_STYLE_OF)? - .and_then(|d| u32_at(&d, 0)) - .and_then(uid_or_none), - None => None, - }, - }) - } - - /// The index sort groups of the preferences object, chunk 0x1307E: u32 - /// group count, then the groups with their sections. Each group is - /// found by its name, a flag byte and an in-object string starting with - /// `kIndexGroup_` or `kWRIndexGroup_`, at its first occurrence; after - /// the name come u8 include, u8, u16 header variant. Empty unless the - /// names found are as many as the count. See `docs/format/objects.md`. - fn index_groups(&self) -> Vec<(String, bool, u16)> { - let Some(&(uid, _)) = self - .db - .classes() - .iter() - .find(|(_, c)| *c == class::PREFERENCES) - else { - return Vec::new(); - }; - let Ok(Some(d)) = self.chunk(uid, chunk::INDEX_GROUPS) else { - return Vec::new(); - }; - if crate::object::big_endian() { - return Vec::new(); - } - let Some(count) = u32_at(&d, 0) else { - return Vec::new(); - }; - let mut out: Vec<(String, bool, u16)> = Vec::new(); - for i in 4..d.len().saturating_sub(6) { - if d[i] != 1 || d[i + 1] != 2 { - continue; - } - let mut c = Cursor::new(&d[i + 1..]); - let Ok(name) = c.string() else { continue }; - if !(name.starts_with("kIndexGroup_") || name.starts_with("kWRIndexGroup_")) - || out.iter().any(|(n, _, _)| *n == name) - { - continue; - } - let at = i + 1 + c.pos(); - let (Some(&include), Some(header)) = (d.get(at), u16_at(&d, at + 2)) else { - continue; - }; - out.push((name, include != 0, header)); - } - if out.len() == count as usize { - out - } else { - Vec::new() - } - } - - /// The first pasted smooth shade (class 0x5533) whose chunk 0x5532 - /// holds a constant shade: 92 bytes, with u32 28 at offset 60 and then - /// a u32 and three f64. See `docs/format/objects.md`. - fn constant_shade(&self) -> Option { - let mut uids: Vec = self - .db - .classes() - .iter() - .filter(|&&(_, c)| c == class::SMOOTH_SHADE) - .map(|&(u, _)| u) - .collect(); - uids.sort_unstable(); - uids.into_iter().find_map(|uid| { - let d = self.chunk(uid, chunk::SMOOTH_SHADE).ok()??; - if d.len() != 92 || u32_at(&d, 60) != Some(28) { - return None; - } - let name = self - .chunk(uid, chunk::SMOOTH_SHADE_NAME) - .ok() - .flatten() - .and_then(|n| { - let mut c = Cursor::new(&n); - let builtin = c.flag().ok()? == 1; - Some((builtin, c.string().ok()?)) - }); - Some(ConstantShade { - uid, - count: u32_at(&d, 64)?, - values: [f64_at(&d, 68)?, f64_at(&d, 76)?, f64_at(&d, 84)?], - name, - }) - }) - } - - /// The named grids, in UID order. - fn named_grids(&self) -> Vec<(bool, String)> { - let mut out = Vec::new(); - for &(uid, cls) in self.db.classes() { - if cls != class::NAMED_GRID { - continue; - } - let read = (|| -> Result, Error> { - let Some(d) = self.chunk(uid, chunk::NAMED_GRID)? else { - return Ok(None); - }; - let mut c = Cursor::new(&d); - c.u32()?; - let builtin = c.flag()? == 1; - Ok(Some((uid, builtin, c.string()?))) - })(); - match read { - Ok(Some(g)) => out.push(g), - Ok(None) => {} - Err(e) => self.warn(format!("named grid {uid} left out: {e}")), - } - } - out.sort_by_key(|g| g.0); - out.into_iter().map(|(_, b, n)| (b, n)).collect() - } - - /// The table of contents styles, in UID order. - fn toc_styles(&self) -> Vec { - let mut out = Vec::new(); - for &(uid, cls) in self.db.classes() { - if cls != class::TOC_STYLE { - continue; - } - let read = (|| -> Result, Error> { - let Some(d) = self.chunk(uid, chunk::TOC_STYLE)? else { - return Ok(None); - }; - let mut c = Cursor::new(&d); - let builtin = c.flag()? == 1; - let name = c.string()?; - c.skip(8)?; - let title_style = c.u32()?; - c.flag()?; - let title = c.string()?; - c.flag()?; - c.string()?; - let mut flags = Vec::new(); - while flags.len() < 4 && c.remaining() >= 2 { - flags.push(c.u16()?); - } - Ok(Some(TocStyle { - uid, - name, - builtin, - title, - title_style, - flags, - })) - })(); - match read { - Ok(Some(t)) => out.push(t), - Ok(None) => {} - Err(e) => self.warn(format!("TOC style {uid} left out: {e}")), - } - } - out.sort_by_key(|t| t.uid); - out - } - - /// Read the XML nodes stored with story `uid` and place their markers. - /// `unit` converts a character position to a UTF-16 offset; `para` are - /// the paragraph runs, in UTF-16 units. An element whose start and end - /// lie in different paragraph runs is left out. - fn story_xml( - &self, - uid: u32, - marker_strand: Option, - para: &[StyleRun], - unit: &dyn Fn(usize) -> usize, - ) -> Result, Error> { - let mut out = BTreeMap::new(); - let first = match self.chunk(uid, xml::chunk::STORE)? { - Some(d) if d.len() >= 4 => Cursor::new(&d).u32()?, - _ => return Ok(out), - }; - let nodes = xml::read_store(first, |p| self.chunk(p, xml::chunk::PAGE))?; - if nodes.is_empty() { - return Ok(out); - } - let positions = match marker_strand.map(|s| self.chunk(s, xml::chunk::MARKER_TREE)) { - Some(r) => match r? { - Some(d) => xml::marker_positions(&d)?, - None => BTreeMap::new(), - }, - None => BTreeMap::new(), - }; - let para_of = |at: usize| { - let mut end = 0; - para.iter().position(|(len, _, _)| { - end += len; - at < end - }) - }; - for node in nodes { - let at = |m: Option| m.and_then(|m| positions.get(&m)).map(|&p| unit(p)); - let (start, end) = (at(node.start), at(node.end)); - if node.start.is_some() != start.is_some() || node.end.is_some() != end.is_some() { - self.warn(format!( - "story {uid}: XML node {:?} left out: marker not found", - node.key - )); - } else if node.document { - if let Some(s) = start { - out.insert(s, XmlMarker::Hidden); - } - } else { - match (start, end) { - (Some(s), Some(e)) if para_of(s) == para_of(e) => { - out.insert(s, XmlMarker::Start(node.key)); - out.insert(e, XmlMarker::End(node.key)); - } - (Some(s), Some(e)) => { - self.warn(format!( - "story {uid}: XML element {:?} spans paragraphs; left out", - node.key - )); - out.insert(s, XmlMarker::Hidden); - out.insert(e, XmlMarker::Hidden); - } - (Some(s), None) => { - out.insert(s, XmlMarker::Placeholder(node.key)); - } - _ => {} - } - } - self.xml_nodes.borrow_mut().insert(node.key, node); - } - Ok(out) - } - - /// The XML elements that can be written: those whose parents lead to - /// the document node and whose tag is known. See `docs/format/xml.md`. - fn xml_elements( - &self, - tags: &HashMap, - ) -> Result, Error> { - let nodes = self.xml_nodes.borrow(); - let mut out = BTreeMap::new(); - for (key, node) in nodes.iter().filter(|(_, n)| !n.document) { - // `Self`: "d", then "i" and the hex ID of each element from the - // root down to this one. - let mut path = vec![key.1]; - let mut parent = node.parent; - let mut reached = false; - while let Some(p) = nodes.get(&parent) { - if p.document { - reached = true; - break; - } - if path.len() > nodes.len() { - break; - } - path.push(p.key.1); - parent = p.parent; - } - let Some(tag) = tags.get(&node.tag) else { - self.warn(format!( - "XML element {key:?} left out: tag {} unknown", - node.tag - )); - continue; - }; - if !reached { - self.warn(format!("XML element {key:?} left out: no path to the root")); - continue; - } - let name = path.iter().rev().fold(String::from("d"), |mut s, id| { - s.push_str(&format!("i{id:x}")); - s - }); - let (content, story_content) = match self.class(node.content) { - _ if node.content == 0 => (None, false), - Some(class::STORY) => (Some(node.content), true), - // A content holder stands for its parent page item. - Some(xml::class::CONTENT_HOLDER) => { - match self.chunk(node.content, chunk::ITEM_HIERARCHY)? { - Some(d) if d.len() >= 8 => { - (uid_or_none(Cursor::new(&d[4..]).u32()?), false) - } - _ => (None, false), - } - } - c => { - self.warn(format!( - "XML element {key:?}: content {} of class {c:x?} left out", - node.content - )); - (None, false) - } - }; - out.insert( - *key, - XmlElement { - name, - tag: tag.clone(), - content, - story_content, - block: false, - }, - ); - } - // An element is written as a block when it holds, at any depth, an - // element that is a single marker with a story as content. - let holds_story = |key: &xml::Key| { - let mut stack = vec![*key]; - let mut seen = Vec::new(); - while let Some(k) = stack.pop() { - if seen.contains(&k) { - continue; - } - seen.push(k); - let Some(n) = nodes.get(&k) else { continue }; - for c in &n.children { - if let Some(child) = nodes.get(c) - && child.end.is_none() - && out.get(c).is_some_and(|e: &XmlElement| e.story_content) - { - return true; - } - stack.push(*c); - } - } - false - }; - let blocks: Vec = out.keys().filter(|k| holds_story(k)).copied().collect(); - for k in blocks { - if let Some(e) = out.get_mut(&k) { - e.block = true; - } - } - Ok(out) - } -} - -/// The UTF-16 offset of each character of `text`, where a surrogate pair is -/// one character, followed by the length of `text`. -fn char_offsets(text: &[u16]) -> Vec { - let mut out = Vec::with_capacity(text.len() + 1); - let mut i = 0; - while i < text.len() { - out.push(i); - let pair = (0xD800..0xDC00).contains(&text[i]) - && text - .get(i + 1) - .is_some_and(|u| (0xDC00..0xE000).contains(u)); - i += if pair { 2 } else { 1 }; - } - out.push(text.len()); - out -} - -/// A master page's applied master and its own margins and columns. -type MasterPageLayout = (Option, Option, Option); - -/// Replace the margins and columns that pages take from their master page -/// (flag 0) with the values in effect on that master page. A page's master -/// page is the page at the same position, counted from the left, in its -/// applied master spread, or that spread's only page. See -/// `docs/format/objects.md`. -fn resolve_page_layout(spreads: &mut [Spread], masters: &mut [Spread]) { - fn left_to_right(s: &Spread) -> Vec { - let mut order: Vec = (0..s.pages.len()).collect(); - order.sort_by(|&a, &b| s.pages[a].transform.0[4].total_cmp(&s.pages[b].transform.0[4])); - order - } - fn master_page( - raw: &HashMap>, - master: Option, - index: usize, - ) -> Option<(usize, &MasterPageLayout)> { - let pages = raw.get(&master?)?; - let i = if pages.len() == 1 { 0 } else { index }; - pages.get(i).map(|p| (i, p)) - } - fn effective( - raw: &HashMap>, - get: fn(&MasterPageLayout) -> (Option<&T>, bool), - page: &MasterPageLayout, - index: usize, - depth: usize, - ) -> Option { - let (own, is_own) = get(page); - if is_own || depth > 8 { - return own.cloned(); - } - match master_page(raw, page.0, index) { - Some((i, m)) => effective(raw, get, m, i, depth + 1).or_else(|| own.cloned()), - None => own.cloned(), - } - } - let raw: HashMap> = masters - .iter() - .map(|s| { - let pages = left_to_right(s) - .into_iter() - .map(|i| { - let p = &s.pages[i]; - (p.master, p.margins.clone(), p.columns.clone()) - }) - .collect(); - (s.uid, pages) - }) - .collect(); - fn margins(p: &MasterPageLayout) -> (Option<&Margins>, bool) { - (p.1.as_ref(), p.1.as_ref().is_some_and(|m| m.own)) - } - fn columns(p: &MasterPageLayout) -> (Option<&Columns>, bool) { - (p.2.as_ref(), p.2.as_ref().is_some_and(|c| c.own)) - } - for s in spreads.iter_mut().chain(masters.iter_mut()) { - for (index, i) in left_to_right(s).into_iter().enumerate() { - let p = &mut s.pages[i]; - let layout = (p.master, p.margins.clone(), p.columns.clone()); - p.margins = effective(&raw, margins, &layout, index, 0); - p.columns = effective(&raw, columns, &layout, index, 0); - } - } -} - -/// Find a flag byte (1 = built-in name) followed by an in-object string -/// that `accept` takes, at or after `from`. Returns the offset of the pair, -/// whether the flag is 1, and the string. In big-endian data the flag and -/// the string's tag (2) are swapped (`docs/format/big-endian.md`). -fn find_flagged_string( - data: &[u8], - from: usize, - accept: impl Fn(&str) -> bool, -) -> Option<(usize, bool, String)> { - let big = crate::object::big_endian(); - (from..data.len().saturating_sub(6)).find_map(|i| { - let header = match big { - false => data[i] <= 2 && data[i + 1] == 2, - true => data[i] == 2 && data[i + 1] <= 2, - }; - if !header { - return None; - } - let mut c = Cursor::new(&data[i..]); - let builtin = c.flag().ok()? == 1; - let s = c.string().ok()?; - accept(&s).then_some((i, builtin, s)) - }) -} - -/// Find the first in-object string at or after `from`. -fn find_string(data: &[u8], from: usize) -> Result { - if crate::object::big_endian() { - // The tag (2), the byte before it in little-endian data, then the - // rest of the header (`Cursor::string`). - for i in from..data.len().saturating_sub(5) { - if data[i] == 2 - && data[i + 1] <= 2 - && u16_from([data[i + 3], data[i + 4]]) > 0 - && let Ok(s) = Cursor::new(&data[i..]).string() - { - return Ok(s); - } - } - return Ok(String::new()); - } - for i in from..data.len().saturating_sub(4) { - if data[i] == 2 && data[i + 1] == 0 { - let n = u16_from([data[i + 2], data[i + 3]]) as usize; - if n > 0 - && i + 6 <= data.len() - && (u16_from([data[i + 4], data[i + 5]]) & 0xC000) != 0 - && let Ok(s) = Cursor::new(&data[i..]).string() - { - return Ok(s); - } - } - } - Ok(String::new()) -} - -/// Combine text with paragraph-style and character-style run lengths -/// (counted in UTF-16 code units) into runs with both styles constant. -type StyleRun = (usize, u32, Attrs); - -fn split_runs( - utf16: &[u16], - para: &[StyleRun], - chars: &[StyleRun], - extra: &[usize], -) -> Vec { - let mut cuts: Vec = vec![0, utf16.len()]; - cuts.extend(extra.iter().map(|&c| c.min(utf16.len()))); - for list in [para, chars] { - let mut pos = 0; - for (len, _, _) in list { - pos += len; - cuts.push(pos.min(utf16.len())); - } - } - cuts.sort_unstable(); - cuts.dedup(); - let run_at = |list: &[StyleRun], at: usize| -> Option<(Option, Attrs)> { - let mut pos = 0; - for (len, style, attrs) in list { - if at < pos + len { - return Some((uid_or_none(*style), attrs.clone())); - } - pos += len; - } - None - }; - cuts.windows(2) - .filter(|w| w[0] < w[1]) - .map(|w| { - let (paragraph_style, paragraph_attrs) = run_at(para, w[0]).unwrap_or_default(); - let (character_style, character_attrs) = run_at(chars, w[0]).unwrap_or_default(); - TextRun { - start: w[0], - text: String::from_utf16_lossy(&utf16[w[0]..w[1]]), - paragraph_style, - character_style, - paragraph_attrs, - character_attrs, - } - }) - .collect() -} - -/// The IDML element of a frame or shape: by the shape code of chunk -/// 0x6204 (`code`), and where it has none (9, or no chunk), by the path. -/// See `docs/format/objects.md`, page items. -fn classify(paths: &[Path], code: Option) -> Shape { - match code { - Some(1) => return Shape::GraphicLine, - Some(2 | 3) => return Shape::Rectangle, - Some(4 | 5) => return Shape::Oval, - Some(0 | 6..=8) => return Shape::Polygon, - _ => {} - } - let [path] = paths else { - return Shape::Polygon; - }; - let corners = path - .points - .iter() - .all(|p| p.left == p.anchor && p.right == p.anchor); - if path.open && path.points.len() == 2 { - return Shape::GraphicLine; - } - if !path.open && path.points.len() == 4 && corners { - let xs: Vec = path.points.iter().map(|p| p.anchor.0).collect(); - let ys: Vec = path.points.iter().map(|p| p.anchor.1).collect(); - let distinct = |v: &[f64]| { - let mut v: Vec = v.iter().map(|x| (x * 1e6).round() as i64).collect(); - v.sort_unstable(); - v.dedup(); - v.len() - }; - if distinct(&xs) == 2 && distinct(&ys) == 2 { - return Shape::Rectangle; - } - } - if !path.open - && path.points.len() == 4 - && path - .points - .iter() - .all(|p| p.left != p.anchor && p.kind == 0) - { - return Shape::Oval; - } - Shape::Polygon -} - -/// Style groups nested deeper than this are left out, with a warning. -const MAX_GROUP_DEPTH: usize = 100; - -/// Make the style groups a tree under their root groups, so that walking -/// them ends: a group listed a second time (in a cycle, or under a second -/// parent) or nested deeper than [`MAX_GROUP_DEPTH`] is removed from the -/// children of the group that lists it, with a warning. -fn prune_style_groups(groups: &mut BTreeMap, warn: impl Fn(String)) { - let roots: Vec = groups - .iter() - .filter(|(_, g)| g.root.is_some()) - .map(|(&uid, _)| uid) - .collect(); - let mut seen: std::collections::HashSet = roots.iter().copied().collect(); - let mut stack: Vec<(u32, usize)> = roots.iter().map(|&r| (r, 0)).collect(); - while let Some((uid, depth)) = stack.pop() { - let Some(g) = groups.get_mut(&uid) else { - continue; - }; - let children = std::mem::take(&mut g.children); - let mut kept = Vec::with_capacity(children.len()); - for c in children { - if groups.contains_key(&c) { - if !seen.insert(c) { - warn(format!( - "style group {c} is listed twice; left out of group {uid}" - )); - continue; - } - if depth + 1 > MAX_GROUP_DEPTH { - warn(format!( - "style group {c} is nested more than {MAX_GROUP_DEPTH} deep; left out" - )); - continue; - } - stack.push((c, depth + 1)); - } - kept.push(c); - } - if let Some(g) = groups.get_mut(&uid) { - g.children = kept; - } - } -} - #[cfg(test)] mod tests { use crate::database::synthetic; diff --git a/src/model/reader.rs b/src/model/reader.rs new file mode 100644 index 0000000..6fba54e --- /dev/null +++ b/src/model/reader.rs @@ -0,0 +1,87 @@ +//! The `Reader`: typed access to the objects of a database, with a cache, +//! chunk lookup, child lists and the warnings of a conversion. +//! +//! Evidence: `docs/format/database.md` and `objects.md` (child lists). + +use super::*; + +/// Reads typed objects from a database, caching them. +pub struct Reader<'a> { + pub(super) db: &'a Database<'a>, + pub(super) cache: std::cell::RefCell>>, + pub(super) warnings: std::cell::RefCell>, + /// XML nodes found in the stories read so far. + pub(super) xml_nodes: std::cell::RefCell>, + /// Text orientation of each text frame read so far, by story. + pub(super) frame_orientations: std::cell::RefCell>>>, + /// The groups whose page items are being read, outermost first. + pub(super) item_path: std::cell::RefCell>, +} + +pub(super) fn uid_or_none(v: u32) -> Option { + (v != 0).then_some(v) +} + +impl<'a> Reader<'a> { + pub fn new(db: &'a Database<'a>) -> Reader<'a> { + Reader { + db, + cache: Default::default(), + warnings: Default::default(), + xml_nodes: Default::default(), + frame_orientations: Default::default(), + item_path: Default::default(), + } + } + + pub fn object(&self, uid: u32) -> Result, Error> { + if let Some(o) = self.cache.borrow().get(&uid) { + return Ok(o.clone()); + } + let obj = self + .db + .get(uid)? + .ok_or_else(|| Error::Corrupt(format!("object {uid} has no data")))?; + let obj = std::rc::Rc::new(obj); + crate::audit::object_read(uid); + self.cache.borrow_mut().insert(uid, obj.clone()); + Ok(obj) + } + + /// Record a problem that does not stop the conversion. + pub fn warn(&self, msg: String) { + self.warnings.borrow_mut().push(msg); + } + + pub fn class(&self, uid: u32) -> Option { + self.db.class_of(uid) + } + + pub(super) fn chunk(&self, uid: u32, id: u32) -> Result>, Error> { + Ok(self.object(uid)?.chunk(id).map(<[u8]>::to_vec)) + } + + pub(super) fn required(&self, uid: u32, id: u32) -> Result, Error> { + self.chunk(uid, id)? + .ok_or_else(|| Error::Corrupt(format!("object {uid} has no chunk {id:#x}"))) + } + + pub(super) fn uid_list(&self, uid: u32, id: u32) -> Result, Error> { + match self.chunk(uid, id)? { + Some(data) => Cursor::new(&data).u32_list(), + None => Ok(Vec::new()), + } + } + + /// Children listed in a hierarchy chunk: parent, owner, then a u32 list. + pub(super) fn children(&self, uid: u32, id: u32) -> Result, Error> { + match self.chunk(uid, id)? { + Some(d) => { + let mut c = Cursor::new(&d); + c.skip(8)?; + c.u32_list() + } + None => Ok(Vec::new()), + } + } +} diff --git a/src/model/settings.rs b/src/model/settings.rs new file mode 100644 index 0000000..9136994 --- /dev/null +++ b/src/model/settings.rs @@ -0,0 +1,291 @@ +//! Document-level settings and lists: document preferences, bullets, +//! colour group order, index groups, constant shade, named grids, document +//! users and languages. +//! +//! Evidence: `docs/format/objects.md` and `preferences.md`. + +use super::*; + +/// A pasted smooth shade with a constant shading. See +/// `docs/format/objects.md`, pasted smooth shades. +#[derive(Debug, Clone, PartialEq)] +pub struct ConstantShade { + pub uid: u32, + pub count: u32, + pub values: [f64; 3], + /// Flag (built-in key) and name. + pub name: Option<(bool, String)>, +} + +/// Document setup, from chunk 0x533 of the preferences object. +#[derive(Debug, Clone, PartialEq)] +pub struct DocumentPreferences { + pub page_width: f64, + pub page_height: f64, + pub facing_pages: bool, + /// Top, bottom, inside, outside (stored as inside, top, outside, bottom). + pub bleed: [f64; 4], + /// 0 print, 1 web, 2 mobile. + pub intent: u32, + /// Page binding (u16 at 64): 0 left to right, 1 right to left. + pub page_binding: u16, +} + +/// A language object (class 0x2D07), chunk 0x2D0F. See +/// `docs/format/objects.md`, languages. +#[derive(Debug, Clone, PartialEq)] +pub struct Language { + pub uid: u32, + pub name: String, + pub primary: String, + pub sub: String, + pub id: u16, + /// The spelling and hyphenation vendors, each with its flag byte. + pub vendors: Option<[(u8, String); 2]>, +} + +/// A bullet character of the document's list (IDML `ABullet`): u32 +/// character type, u32 character value, u32 font family (0 = none), the +/// font style as a flag byte and string, then a byte (0 in every sample). +#[derive(Debug, Clone, PartialEq)] +pub struct Bullet { + /// 0 `UnicodeOnly`, 1 `UnicodeWithFont`, 2 `GlyphWithFont`. + pub kind: u32, + pub value: u32, + pub font: u32, + /// The IDML font style, with `$ID/` for a built-in name. + pub font_style: String, +} + +impl<'a> Reader<'a> { + /// The bullet characters in the preferences object (chunk 0x1A488): + /// u16 1, u32 count, then the bullets. + pub(super) fn bullets(&self) -> Result, Error> { + let Some(&(uid, _)) = self + .db + .classes() + .iter() + .find(|(_, c)| *c == class::PREFERENCES) + else { + return Ok(Vec::new()); + }; + let Some(d) = self.chunk(uid, chunk::BULLETS)? else { + return Ok(Vec::new()); + }; + let mut c = Cursor::new(&d); + if c.u16()? != 1 { + return Ok(Vec::new()); + } + let n = c.u32()?; + let mut out = Vec::new(); + for _ in 0..n { + let kind = c.u32()?; + let value = c.u32()?; + let font = c.u32()?; + let builtin = c.flag()? == 1; + let style = c.string()?; + // 0, or 1 and four bytes of unknown meaning (objects.md). + match c.u8()? { + 0 => {} + 1 => c.skip(4)?, + other => { + return Err(Error::Corrupt(format!( + "bullet font style followed by {other} at {}", + c.pos() - 1 + ))); + } + } + out.push(Bullet { + kind, + value, + font, + font_style: if builtin { + format!("$ID/{style}") + } else { + style + }, + }); + } + Ok(out) + } + + /// The colour groups listed in the preferences object (chunk 0x1F61). + pub(super) fn color_group_order(&self) -> Result, Error> { + let Some(&(uid, _)) = self + .db + .classes() + .iter() + .find(|(_, c)| *c == class::PREFERENCES) + else { + return Ok(Vec::new()); + }; + self.uid_list(uid, color::chunk::COLOR_GROUPS) + } + + pub(super) fn document_preferences(&self) -> Result, Error> { + let Some(&(uid, _)) = self + .db + .classes() + .iter() + .find(|(_, c)| *c == class::PREFERENCES) + else { + return Ok(None); + }; + let Some(d) = self.chunk(uid, chunk::DOCUMENT_PREFERENCES)? else { + return Ok(None); + }; + if d.len() < 146 { + self.warn(format!( + "document preferences of {} bytes are not known; left out", + d.len() + )); + return Ok(None); + } + let f = |o: usize| Cursor::new(&d[o..]).f64(); + let u = |o: usize| Cursor::new(&d[o..]).u32(); + let binding = Cursor::new(&d[64..]).u16()?; + if binding > 1 { + self.warn(format!( + "document preferences: page binding code {binding} is not known; left out" + )); + } + Ok(Some(DocumentPreferences { + page_width: f(0)?, + page_height: f(8)?, + facing_pages: d[58] == 2, + bleed: [f(78)?, f(94)?, f(70)?, f(86)?], + intent: u(142)?, + page_binding: binding, + })) + } + + /// The document's users, from chunk 0xA443 of the document. + pub(super) fn users(&self, doc: u32) -> Result, Error> { + let Some(d) = self.chunk(doc, chunk::DOC_USERS)? else { + return Ok(Vec::new()); + }; + let mut c = Cursor::new(&d); + let n = c.u32()?; + if n as usize > d.len() / 9 { + return Err(Error::Corrupt(format!("{n} document users"))); + } + (0..n) + .map(|_| { + let flag = c.flag()?; + let name = c.string()?; + c.u32()?; + Ok((flag, name)) + }) + .collect() + } + + /// The index sort groups of the preferences object, chunk 0x1307E: u32 + /// group count, then the groups with their sections. Each group is + /// found by its name, a flag byte and an in-object string starting with + /// `kIndexGroup_` or `kWRIndexGroup_`, at its first occurrence; after + /// the name come u8 include, u8, u16 header variant. Empty unless the + /// names found are as many as the count. See `docs/format/objects.md`. + pub(super) fn index_groups(&self) -> Vec<(String, bool, u16)> { + let Some(&(uid, _)) = self + .db + .classes() + .iter() + .find(|(_, c)| *c == class::PREFERENCES) + else { + return Vec::new(); + }; + let Ok(Some(d)) = self.chunk(uid, chunk::INDEX_GROUPS) else { + return Vec::new(); + }; + if crate::object::big_endian() { + return Vec::new(); + } + let Some(count) = u32_at(&d, 0) else { + return Vec::new(); + }; + let mut out: Vec<(String, bool, u16)> = Vec::new(); + for i in 4..d.len().saturating_sub(6) { + if d[i] != 1 || d[i + 1] != 2 { + continue; + } + let mut c = Cursor::new(&d[i + 1..]); + let Ok(name) = c.string() else { continue }; + if !(name.starts_with("kIndexGroup_") || name.starts_with("kWRIndexGroup_")) + || out.iter().any(|(n, _, _)| *n == name) + { + continue; + } + let at = i + 1 + c.pos(); + let (Some(&include), Some(header)) = (d.get(at), u16_at(&d, at + 2)) else { + continue; + }; + out.push((name, include != 0, header)); + } + if out.len() == count as usize { + out + } else { + Vec::new() + } + } + + /// The first pasted smooth shade (class 0x5533) whose chunk 0x5532 + /// holds a constant shade: 92 bytes, with u32 28 at offset 60 and then + /// a u32 and three f64. See `docs/format/objects.md`. + pub(super) fn constant_shade(&self) -> Option { + let mut uids: Vec = self + .db + .classes() + .iter() + .filter(|&&(_, c)| c == class::SMOOTH_SHADE) + .map(|&(u, _)| u) + .collect(); + uids.sort_unstable(); + uids.into_iter().find_map(|uid| { + let d = self.chunk(uid, chunk::SMOOTH_SHADE).ok()??; + if d.len() != 92 || u32_at(&d, 60) != Some(28) { + return None; + } + let name = self + .chunk(uid, chunk::SMOOTH_SHADE_NAME) + .ok() + .flatten() + .and_then(|n| { + let mut c = Cursor::new(&n); + let builtin = c.flag().ok()? == 1; + Some((builtin, c.string().ok()?)) + }); + Some(ConstantShade { + uid, + count: u32_at(&d, 64)?, + values: [f64_at(&d, 68)?, f64_at(&d, 76)?, f64_at(&d, 84)?], + name, + }) + }) + } + + /// The named grids, in UID order. + pub(super) fn named_grids(&self) -> Vec<(bool, String)> { + let mut out = Vec::new(); + for &(uid, cls) in self.db.classes() { + if cls != class::NAMED_GRID { + continue; + } + let read = (|| -> Result, Error> { + let Some(d) = self.chunk(uid, chunk::NAMED_GRID)? else { + return Ok(None); + }; + let mut c = Cursor::new(&d); + c.u32()?; + let builtin = c.flag()? == 1; + Ok(Some((uid, builtin, c.string()?))) + })(); + match read { + Ok(Some(g)) => out.push(g), + Ok(None) => {} + Err(e) => self.warn(format!("named grid {uid} left out: {e}")), + } + } + out.sort_by_key(|g| g.0); + out.into_iter().map(|(_, b, n)| (b, n)).collect() + } +} diff --git a/src/model/spread.rs b/src/model/spread.rs new file mode 100644 index 0000000..22585c0 --- /dev/null +++ b/src/model/spread.rs @@ -0,0 +1,598 @@ +//! Spreads, pages, page settings, guides, layers, sections and UI colours, +//! and the page layout that pages take from their masters. +//! +//! Evidence: `docs/format/objects.md` (spreads, pages, guides, layers, +//! sections) and `big-endian.md` (older page chunks). + +use super::*; + +#[derive(Debug, Clone, PartialEq)] +pub struct Layer { + pub uid: u32, + pub name: String, + pub visible: bool, + pub locked: bool, + /// The hidden layer that holds pages; not written to IDML. + pub internal: bool, + /// The other settings, when chunk 0x304 has the layout of the samples. + pub settings: Option, +} + +/// Layer settings in chunk 0x304. See `docs/format/objects.md`. +#[derive(Debug, Clone, PartialEq)] +pub struct LayerSettings { + pub printable: bool, + pub lock_guides: bool, + pub ui: bool, + pub ignore_wrap: bool, + /// The layer colour (an interface colour object). + pub color: Option<[f64; 3]>, +} + +/// A colour setting that names an interface colour (class 0x1F11), or +/// one of two codes. See `docs/format/objects.md`. +#[derive(Debug, Clone, Copy, PartialEq, Default)] +pub enum UiColorRef { + /// Code 1, or no chunk: the colour of the master. + #[default] + UseMaster, + /// Code 0. + Nothing, + Rgb([f64; 3]), + /// Any other value. + Unknown, +} + +#[derive(Debug, Clone, PartialEq)] +pub struct Page { + pub uid: u32, + /// Left, top, right, bottom in page coordinates. + pub bounds: [f64; 4], + pub transform: Matrix, + pub master: Option, + pub master_transform: Matrix, + /// Margins and columns (chunks 0x51A and 0x528). After + /// `resolve_page_layout`, these are the values in effect: the page's + /// own, or its master page's. + pub margins: Option, + pub columns: Option, + /// Layout grid settings (chunk 0xCD02). + pub grid: Option, + pub settings: PageSettings, +} + +/// Settings of a page. See `docs/format/objects.md`, page settings. +#[derive(Debug, Clone, PartialEq, Default)] +pub struct PageSettings { + /// Master page items overridden on the page, each with its override + /// (0 for none), from chunk 0x1404. + pub overrides: Vec<(u32, u32)>, + /// Chunk 0xCD04: whether the page uses its master's layout grid. + pub use_master_grid: Option, + /// Layout rule code (chunk 0x563); `None` without the chunk. + pub layout_rule: Option, + pub color: UiColorRef, + /// Page items in tab order (the spread's chunk 0x14580). + pub tab_order: Vec, +} + +/// Page margins from chunk 0x51A: four f64 (left, top, right, bottom), +/// then u16 1 if the page has its own margins, 0 if it uses its master +/// page's. +#[derive(Debug, Clone, PartialEq)] +pub struct Margins { + pub left: f64, + pub top: f64, + pub right: f64, + pub bottom: f64, + pub own: bool, +} + +/// Page columns from chunk 0x528: u32 count *n*, *n* f64 column edge +/// positions, f64 gutter, then u16 1 if the page has its own columns. +#[derive(Debug, Clone, PartialEq)] +pub struct Columns { + pub positions: Vec, + pub gutter: f64, + pub own: bool, +} + +/// Layout grid settings of a page (chunk 0xCD02): u32 font family, a flag +/// byte, the font style as an in-object string, five f64 and four u32. +/// See `docs/format/objects.md`. +#[derive(Debug, Clone, PartialEq)] +pub struct GridData { + pub font: u32, + pub font_style: String, + pub numbers: [f64; 5], + pub codes: [u32; 4], +} + +#[derive(Debug, Clone, PartialEq)] +pub struct Spread { + pub uid: u32, + /// Master spreads only: name prefix (for example "A") and base name. + pub master_name: Option<(String, String)>, + pub transform: Matrix, + pub binding_location: u32, + pub pages: Vec, + pub items: Vec, + pub guides: Vec, + /// Chunk 0x1A8: `None` without it. + pub shuffle: Option, + /// The two resolutions in chunk 0x10833, when it is there. + pub flattener_resolution: Option<[f64; 2]>, + /// Master spreads: chunk 0x140D. + pub show_master_items: Option, +} + +/// A ruler guide (class 0x3301, chunk 0x3308). See `docs/format/objects.md`. +#[derive(Debug, Clone, PartialEq)] +pub struct Guide { + pub uid: u32, + pub horizontal: bool, + /// Position in spread coordinates: y for a horizontal guide, x for a + /// vertical one. + pub position: f64, + /// The page the guide belongs to, or the spread. + pub owner: u32, + pub fit_to_page: bool, + /// Stored view threshold (0.05 in every sample). + pub view_threshold: f64, + /// Colour code (6 in every sample). + pub color: u32, + /// 0 ruler guide, 1 liquid guide; none in 40-byte records. + pub guide_type: Option, + /// Document layer. + pub layer: u32, + /// Chunk 0x2C2D, as for page items. + pub locked: bool, + /// f64 at 44 of the 52-byte record (`GuideZone`). + pub zone: Option, + /// Chunk 0x1424, as for page items. + pub overridden: Option<(u32, Vec)>, +} + +/// Numbering of a section. +#[derive(Debug, Clone, PartialEq)] +pub struct Section { + pub uid: u32, + /// The section's first page; `None` for the first section, which + /// starts at the first page of the document. + pub page: Option, + pub continue_numbering: bool, + pub start: u32, + /// Page number style code (see `numbering`). + pub style: u32, + /// `SectionPrefix` and `Marker`; empty if the chunk is missing. + pub prefix: String, + pub marker: String, + /// The alternate layout name after the numbers, with the flag byte + /// before it (1: a built-in key); `None` if the chunk ends before it. + pub alternate_layout: Option<(u8, String)>, +} + +/// A master page's applied master and its own margins and columns. +pub(super) type MasterPageLayout = (Option, Option, Option); + +/// Replace the margins and columns that pages take from their master page +/// (flag 0) with the values in effect on that master page. A page's master +/// page is the page at the same position, counted from the left, in its +/// applied master spread, or that spread's only page. See +/// `docs/format/objects.md`. +pub(super) fn resolve_page_layout(spreads: &mut [Spread], masters: &mut [Spread]) { + fn left_to_right(s: &Spread) -> Vec { + let mut order: Vec = (0..s.pages.len()).collect(); + order.sort_by(|&a, &b| s.pages[a].transform.0[4].total_cmp(&s.pages[b].transform.0[4])); + order + } + fn master_page( + raw: &HashMap>, + master: Option, + index: usize, + ) -> Option<(usize, &MasterPageLayout)> { + let pages = raw.get(&master?)?; + let i = if pages.len() == 1 { 0 } else { index }; + pages.get(i).map(|p| (i, p)) + } + fn effective( + raw: &HashMap>, + get: fn(&MasterPageLayout) -> (Option<&T>, bool), + page: &MasterPageLayout, + index: usize, + depth: usize, + ) -> Option { + let (own, is_own) = get(page); + if is_own || depth > 8 { + return own.cloned(); + } + match master_page(raw, page.0, index) { + Some((i, m)) => effective(raw, get, m, i, depth + 1).or_else(|| own.cloned()), + None => own.cloned(), + } + } + let raw: HashMap> = masters + .iter() + .map(|s| { + let pages = left_to_right(s) + .into_iter() + .map(|i| { + let p = &s.pages[i]; + (p.master, p.margins.clone(), p.columns.clone()) + }) + .collect(); + (s.uid, pages) + }) + .collect(); + fn margins(p: &MasterPageLayout) -> (Option<&Margins>, bool) { + (p.1.as_ref(), p.1.as_ref().is_some_and(|m| m.own)) + } + fn columns(p: &MasterPageLayout) -> (Option<&Columns>, bool) { + (p.2.as_ref(), p.2.as_ref().is_some_and(|c| c.own)) + } + for s in spreads.iter_mut().chain(masters.iter_mut()) { + for (index, i) in left_to_right(s).into_iter().enumerate() { + let p = &mut s.pages[i]; + let layout = (p.master, p.margins.clone(), p.columns.clone()); + p.margins = effective(&raw, margins, &layout, index, 0); + p.columns = effective(&raw, columns, &layout, index, 0); + } + } +} + +impl<'a> Reader<'a> { + /// An interface colour (class 0x1F11): chunk 0x1F01 holds u32 space + /// (5 = RGB), u16 count and the components as f64 fractions. + pub(super) fn ui_color(&self, uid: u32) -> Result, Error> { + if self.class(uid) != Some(class::UI_COLOR) { + return Ok(None); + } + let Some(d) = self.chunk(uid, color::chunk::COLOR_VALUE)? else { + return Ok(None); + }; + let mut c = Cursor::new(&d); + if c.u32()? != 5 || c.u16()? != 3 { + return Ok(None); + } + Ok(Some([c.f64()?, c.f64()?, c.f64()?])) + } + + pub(super) fn section(&self, uid: u32) -> Result { + let mut section = Section { + uid, + page: None, + continue_numbering: true, + start: 1, + style: numbering::ARABIC, + prefix: String::new(), + marker: String::new(), + alternate_layout: None, + }; + // u8, string (prefix), u8, string (marker), u32 first page, u32 + // page number start, u32 numbering style, u32 continue, u32, then + // u8 and string (alternate layout). + if let Some(d) = self.chunk(uid, chunk::SECTION_INFO)? { + let mut c = Cursor::new(&d); + let parsed = (|| -> Result<(String, String, [u32; 4]), Error> { + c.u8()?; + let prefix = c.string()?; + c.u8()?; + let marker = c.string()?; + Ok((prefix, marker, [c.u32()?, c.u32()?, c.u32()?, c.u32()?])) + })(); + if let Ok((prefix, marker, [page, start, style, cont])) = parsed { + section.page = uid_or_none(page); + section.start = start; + section.style = style; + section.continue_numbering = cont != 0; + section.prefix = prefix; + section.marker = marker; + section.alternate_layout = (|| -> Result<(u8, String), Error> { + c.u32()?; + let flag = c.flag()?; + Ok((flag, c.string()?)) + })() + .ok(); + } + } + if ![numbering::ARABIC, numbering::LOWER_ROMAN, numbering::KANJI].contains(§ion.style) { + self.warn(format!( + "section {uid}: page number style {:#x} is not known; left out", + section.style + )); + } + Ok(section) + } + + pub(super) fn layer(&self, uid: u32) -> Result { + let data = self.required(uid, chunk::LAYER_PROPS)?; + let mut c = Cursor::new(&data); + let locked = c.u16()? != 0; + let visible = c.u16()? != 0; + c.skip(14)?; + // A string follows; its position varies, so search for the tag. + let name = find_string(&data, 18)?; + let settings = self.layer_settings(&data)?; + Ok(Layer { + uid, + internal: name == "Internal_pages_layer_name", + name, + visible, + locked, + settings, + }) + } + + /// The settings in chunk 0x304 when the name is at offset 19, as in + /// all corpus pairs: u16 printable at 4, u16 lock guides at 6, u32 + /// colour at 10, u16 UI at 14; after the name, u16 ignore wrap. + pub(super) fn layer_settings(&self, data: &[u8]) -> Result, Error> { + if crate::object::big_endian() || data.len() < 23 || data[19] != 2 { + return Ok(None); + } + let mut c = Cursor::new(&data[19..]); + c.string()?; + let ignore_wrap = c.u16()? != 0; + let flag = |at: usize| u16_at(data, at).is_some_and(|v| v != 0); + let color = match u32_at(data, 10) { + Some(u) => self.ui_color(u)?, + None => None, + }; + Ok(Some(LayerSettings { + printable: flag(4), + lock_guides: flag(6), + ui: flag(14), + ignore_wrap, + color, + })) + } + + /// A colour setting: 0 none, 1 the master's, else an interface colour. + pub(super) fn ui_color_ref(&self, code: u32) -> Result { + Ok(match code { + 0 => UiColorRef::Nothing, + 1 => UiColorRef::UseMaster, + u => match self.ui_color(u)? { + Some(rgb) => UiColorRef::Rgb(rgb), + None => UiColorRef::Unknown, + }, + }) + } + + pub(super) fn spread(&self, uid: u32) -> Result { + let transform = match self.chunk(uid, chunk::SPREAD_TRANSFORM)? { + Some(d) => Matrix::read(&mut Cursor::new(&d))?, + None => Matrix::IDENTITY, + }; + let binding_location = match self.chunk(uid, chunk::SPREAD_BINDING)? { + Some(d) => Cursor::new(&d).u32()?, + None => 0, + }; + let master_name = match self.chunk(uid, chunk::MASTER_NAME)? { + Some(d) => { + let mut c = Cursor::new(&d); + c.u8()?; + let prefix = c.string()?; + c.u8()?; + let base = c.string()?; + Some((prefix, base)) + } + None => None, + }; + let children = self.required(uid, chunk::SPREAD_CHILDREN)?; + let mut c = Cursor::new(&children); + c.skip(8)?; + let spread_layers = c.u32_list()?; + let mut pages = Vec::new(); + let mut items = Vec::new(); + let mut guides = Vec::new(); + for sl in spread_layers { + let layer = match self.chunk(sl, chunk::SPREAD_LAYER_LAYER)? { + Some(d) => Cursor::new(&d).u32()?, + None => 0, + }; + for child in self.children(sl, chunk::SPREAD_LAYER_CHILDREN)? { + match self.class(child) { + Some(class::PAGE) => pages.push(self.page(child)?), + Some(class::GUIDE) => guides.extend(self.guide(child, layer)?), + _ => { + if let Some(item) = self.page_item(child, Some(layer))? { + items.push(item); + } + } + } + } + } + if let Some(d) = self.chunk(uid, chunk::SPREAD_TAB_ORDERS)? { + let mut c = Cursor::new(&d); + let n = c.u32()?; + for _ in 0..n { + let page = c.u32()?; + let order = c.u32_list()?; + if let Some(p) = pages.iter_mut().find(|p| p.uid == page) { + p.settings.tab_order = order; + } + } + } + let flattener_resolution = match self.chunk(uid, chunk::SPREAD_FLATTENER)? { + Some(d) => match (f64_at(&d, 20), f64_at(&d, 28)) { + (Some(a), Some(b)) => Some([a, b]), + _ => None, + }, + None => None, + }; + let short = |id: u32| -> Result, Error> { + Ok(self.chunk(uid, id)?.and_then(|d| u16_at(&d, 0))) + }; + Ok(Spread { + uid, + master_name, + transform, + binding_location, + pages, + items, + guides, + shuffle: short(chunk::SPREAD_SHUFFLE)?, + flattener_resolution, + show_master_items: short(chunk::MASTER_SHOW_ITEMS)?, + }) + } + + /// A ruler guide from chunk 0x3308: f64 position, u32 owner (page or + /// spread), u16 orientation (1 horizontal), f64 view threshold, u32 + /// colour, u16 fit to page, f64, u32, u32 guide type, f64. Records of + /// 40 bytes, from InDesign 3.0 to 7.0, end before the guide type. + pub(super) fn guide(&self, uid: u32, layer: u32) -> Result, Error> { + let Some(d) = self.chunk(uid, chunk::GUIDE)? else { + return Ok(None); + }; + if d.len() != 40 && d.len() < 52 { + self.warn(format!( + "guide {uid}: guide record of {} bytes is not known; left out", + d.len() + )); + return Ok(None); + } + let f = |o: usize| Cursor::new(&d[o..]).f64(); + let u = |o: usize| Cursor::new(&d[o..]).u32(); + let h = |o: usize| Cursor::new(&d[o..]).u16(); + Ok(Some(Guide { + uid, + position: f(0)?, + owner: u(8)?, + horizontal: h(12)? == 1, + view_threshold: f(14)?, + color: u(22)?, + fit_to_page: h(26)? == 1, + guide_type: if d.len() >= 52 { Some(u(40)?) } else { None }, + layer, + locked: self + .chunk(uid, chunk::ITEM_LOCKED)? + .is_some_and(|d| u32_at(&d, 0) == Some(1)), + zone: if d.len() >= 52 { Some(f(44)?) } else { None }, + overridden: match self.chunk(uid, chunk::ITEM_OVERRIDE)? { + Some(o) => { + let mut c = Cursor::new(&o); + let master = c.u32()?; + Some((master, c.u32_list()?)) + } + None => None, + }, + })) + } + + pub(super) fn page(&self, uid: u32) -> Result { + // Files from InDesign 3.0 and 4.0 store the transform and bounds in + // the chunks page items use (docs/format/big-endian.md). + let transform = match self.chunk(uid, chunk::PAGE_TRANSFORM)? { + Some(d) => d, + None => self.required(uid, chunk::ITEM_TRANSFORM)?, + }; + let transform = Matrix::read(&mut Cursor::new(&transform))?; + let b = match self.chunk(uid, chunk::PAGE_BOUNDS)? { + Some(d) => d, + None => self.required(uid, chunk::OLD_PAGE_BOUNDS)?, + }; + let mut c = Cursor::new(&b); + let bounds = [c.f64()?, c.f64()?, c.f64()?, c.f64()?]; + let (master, master_transform) = match self.chunk(uid, chunk::PAGE_MASTER)? { + Some(d) => { + let mut c = Cursor::new(&d); + let m = c.u32()?; + c.skip(2)?; + // The matrix is missing in files from InDesign 3.0 and 4.0. + let t = match c.remaining() { + 0 => Matrix::IDENTITY, + _ => Matrix::read(&mut c)?, + }; + (uid_or_none(m), t) + } + None => (None, Matrix::IDENTITY), + }; + let margins = match self.chunk(uid, chunk::PAGE_MARGINS)? { + Some(d) if d.len() >= 34 => { + let mut c = Cursor::new(&d); + Some(Margins { + left: c.f64()?, + top: c.f64()?, + right: c.f64()?, + bottom: c.f64()?, + own: c.u16()? == 1, + }) + } + _ => None, + }; + let columns = match self.chunk(uid, chunk::PAGE_COLUMNS)? { + Some(d) => { + let mut c = Cursor::new(&d); + let n = c.u32()? as usize; + if n > d.len() / 8 { + return Err(Error::Corrupt(format!("page {uid}: {n} column positions"))); + } + let positions = (0..n).map(|_| c.f64()).collect::, _>>()?; + Some(Columns { + positions, + gutter: c.f64()?, + own: c.u16()? == 1, + }) + } + None => None, + }; + let grid = match self.chunk(uid, chunk::PAGE_GRID)? { + Some(d) => { + let mut c = Cursor::new(&d); + let font = c.u32()?; + c.u8()?; + let font_style = c.string()?; + let numbers = [c.f64()?, c.f64()?, c.f64()?, c.f64()?, c.f64()?]; + let codes = [c.u32()?, c.u32()?, c.u32()?, c.u32()?]; + Some(GridData { + font, + font_style, + numbers, + codes, + }) + } + None => None, + }; + // u32 count, then (unless it is 0) the two lists. + let overrides = match self.chunk(uid, chunk::PAGE_OVERRIDES)? { + Some(d) if u32_at(&d, 0).is_some_and(|n| n > 0) => { + let mut c = Cursor::new(&d[4..]); + let items = c.u32_list()?; + let with = c.u32_list()?; + items.into_iter().zip(with).collect() + } + _ => Vec::new(), + }; + let settings = PageSettings { + overrides, + use_master_grid: self + .chunk(uid, chunk::PAGE_GRID_USE)? + .and_then(|d| u16_at(&d, 4)) + .map(|v| v != 0), + layout_rule: self + .chunk(uid, chunk::PAGE_LAYOUT_RULE)? + .and_then(|d| u32_at(&d, 4)), + color: match self + .chunk(uid, chunk::PAGE_COLOR)? + .and_then(|d| u32_at(&d, 0)) + { + Some(code) => self.ui_color_ref(code)?, + None => UiColorRef::UseMaster, + }, + tab_order: Vec::new(), + }; + Ok(Page { + uid, + bounds, + transform, + master, + master_transform, + margins, + columns, + grid, + settings, + }) + } +} diff --git a/src/model/story.rs b/src/model/story.rs new file mode 100644 index 0000000..2be4089 --- /dev/null +++ b/src/model/story.rs @@ -0,0 +1,585 @@ +//! Stories: text, paragraph and character runs, anchored objects, tables, +//! text variables, orientation and XML markers. +//! +//! Evidence: `docs/format/objects.md` (stories and strands), +//! `attributes.md`, `tables.md` and `xml.md`. + +use super::*; + +/// A stretch of story text with one paragraph style and one character style. +#[derive(Debug, Clone, PartialEq)] +pub struct TextRun { + /// UTF-16 offset of the run in the story text. + pub start: usize, + pub text: String, + pub paragraph_style: Option, + pub character_style: Option, + /// Local paragraph formatting. + pub paragraph_attrs: Attrs, + /// Local character formatting. + pub character_attrs: Attrs, +} + +#[derive(Debug, Clone, PartialEq)] +pub struct Story { + pub uid: u32, + pub runs: Vec, + /// Page items anchored in the text, by UTF-16 offset of their U+FFFC. + pub anchors: BTreeMap>, + /// Tables, by UTF-16 offset of their U+0016. + pub tables: BTreeMap, + /// Text variable instances, by UTF-16 offset of their U+0018. + pub text_variables: BTreeMap, + /// Hyperlink text sources, sorted by start. + pub sources: Vec, + /// XML markers, by UTF-16 offset of their U+FEFF. + pub xml_markers: BTreeMap, + /// The XML element whose content is this story. + pub xml_element: Option, + /// Text orientation, from the frames that show the story; `None` when + /// it has no frame or its frames disagree. + pub orientation: Option, + /// The TOC style that made the story (chunk 0x8C40). + pub toc_style: Option, +} + +/// Text orientation of a story (IDML `StoryOrientation`). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Orientation { + Horizontal, + Vertical, +} + +/// What an XML marker character (U+FEFF) in story text stands for. +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum XmlMarker { + /// The start of an element that holds the text up to its end marker. + Start(xml::Key), + End(xml::Key), + /// An element that is a single marker; its content is elsewhere. + Placeholder(xml::Key), + /// A marker that IDML does not write: the start of the document node, + /// or a marker of an element that is left out. + Hidden, +} + +/// An XML element that can be written, with its IDML values. +#[derive(Debug, Clone, PartialEq)] +pub struct XmlElement { + /// IDML `Self`. + pub name: String, + /// Tag name (IDML `MarkupTag` without `XMLTag/`). + pub tag: String, + /// UID written as `XMLContent`. + pub content: Option, + /// The content is a story. + pub story_content: bool, + /// Written between character ranges rather than inside one: the + /// element holds an element whose content is a story. + pub block: bool, +} + +/// The UTF-16 offset of each character of `text`, where a surrogate pair is +/// one character, followed by the length of `text`. +pub(super) fn char_offsets(text: &[u16]) -> Vec { + let mut out = Vec::with_capacity(text.len() + 1); + let mut i = 0; + while i < text.len() { + out.push(i); + let pair = (0xD800..0xDC00).contains(&text[i]) + && text + .get(i + 1) + .is_some_and(|u| (0xDC00..0xE000).contains(u)); + i += if pair { 2 } else { 1 }; + } + out.push(text.len()); + out +} + +/// Combine text with paragraph-style and character-style run lengths +/// (counted in UTF-16 code units) into runs with both styles constant. +pub(super) type StyleRun = (usize, u32, Attrs); + +pub(super) fn split_runs( + utf16: &[u16], + para: &[StyleRun], + chars: &[StyleRun], + extra: &[usize], +) -> Vec { + let mut cuts: Vec = vec![0, utf16.len()]; + cuts.extend(extra.iter().map(|&c| c.min(utf16.len()))); + for list in [para, chars] { + let mut pos = 0; + for (len, _, _) in list { + pos += len; + cuts.push(pos.min(utf16.len())); + } + } + cuts.sort_unstable(); + cuts.dedup(); + let run_at = |list: &[StyleRun], at: usize| -> Option<(Option, Attrs)> { + let mut pos = 0; + for (len, style, attrs) in list { + if at < pos + len { + return Some((uid_or_none(*style), attrs.clone())); + } + pos += len; + } + None + }; + cuts.windows(2) + .filter(|w| w[0] < w[1]) + .map(|w| { + let (paragraph_style, paragraph_attrs) = run_at(para, w[0]).unwrap_or_default(); + let (character_style, character_attrs) = run_at(chars, w[0]).unwrap_or_default(); + TextRun { + start: w[0], + text: String::from_utf16_lossy(&utf16[w[0]..w[1]]), + paragraph_style, + character_style, + paragraph_attrs, + character_attrs, + } + }) + .collect() +} + +impl<'a> Reader<'a> { + /// The text orientation shared by all frames of a story. A story + /// whose frames disagree, or have an orientation that is not known, + /// gets none, with a warning. + pub(super) fn story_orientation(&self, story: u32) -> Option { + let map = self.frame_orientations.borrow(); + let frames = map.get(&story)?; + let first = frames[0]; + if first.is_none() || frames.iter().any(|&o| o != first) { + self.warn(format!( + "story {story}: text orientation of its frames is not known or differs; written as horizontal" + )); + return None; + } + first + } + + pub(super) fn story(&self, uid: u32) -> Result { + let data = self.required(uid, chunk::STORY_STRANDS)?; + let mut c = Cursor::new(&data); + c.skip(6)?; + let mut strands = vec![c.u32()?]; + strands.extend(c.u32_list()?); + let mut text: Vec = Vec::new(); + let mut para: Vec = Vec::new(); + let mut chars: Vec = Vec::new(); + let mut owned: Vec<(usize, u32, u32)> = Vec::new(); + // (start, length, owner, cell) for each stretch of text. + let mut owners: Vec<(usize, usize, u32, u32)> = Vec::new(); + let mut sources = Vec::new(); + let mut marker_strand = None; + for strand in strands { + // A strand without data occurs in a file from InDesign 3.0. + if self.db.object(strand)?.is_none() { + continue; + } + if self.class(strand) == Some(xml::class::MARKER_STRAND) { + marker_strand = Some(strand); + } + if self.class(strand) == Some(hyperlink::class::RANGE_STRAND) + && let Some(tree) = self.chunk(strand, hyperlink::chunk::RANGE_TREE)? + && tree.len() >= 4 + { + let first = u32_from(tree[..4].try_into().unwrap()); + let pages = |uid| self.chunk(uid, hyperlink::chunk::RANGE_PAGE); + match hyperlink::source_ranges(first, pages) { + Ok(r) => sources.extend(r), + Err(e) => self.warn(format!("story {uid}: hyperlink sources left out: {e}")), + } + } + let Some(list) = self.chunk(strand, chunk::STRAND_DATA)? else { + continue; + }; + let mut c = Cursor::new(&list); + let n = c.u16()?; + let mut base = 0usize; + for _ in 0..n { + let data_len = c.u32()? as usize; + let data_uid = c.u32()?; + let runs = self.required(data_uid, chunk::STRAND_RUNS)?; + let mut r = Cursor::new(&runs); + let kind = r.u32()?; + r.skip(4)?; + let count = r.u16()?; + let mut pos = base; + base += data_len; + for _ in 0..count { + let size = r.u32()? as usize; + let rec = r.bytes(size)?; + let mut rc = Cursor::new(rec); + let len = rc.u32()? as usize; + let start = pos; + pos += len; + match kind { + strand::OWNED_ITEMS => { + let n = rc.u16()?; + for _ in 0..n { + let class = rc.u32()?; + let item = rc.u32()?; + owned.push((start, class, item)); + } + } + strand::TEXT => { + text.extend(rc.segment_units(len)?); + } + strand::TEXT_OWNER => { + let owner = rc.u32()?; + let cell = rc.u32()?; + owners.push((start, len, owner, cell)); + } + strand::PARAGRAPH_STYLE | strand::CHARACTER_STYLE => { + let style = rc.u32()?; + let n = rc.u16()? as usize; + let attrs = + Attrs::parse_text(&mut rc, n, List::Text).unwrap_or_default(); + let list = if kind == strand::PARAGRAPH_STYLE { + &mut para + } else { + &mut chars + }; + list.push((len, style, attrs)); + } + _ => crate::audit::unknown_strand_kind(kind), + } + } + } + } + // Text records count UTF-16 code units, every other strand counts + // characters (a surrogate pair is one position). Convert the + // positions to UTF-16 offsets. + let offsets = char_offsets(&text); + let unit = |p: usize| match offsets.get(p) { + Some(&u) => u, + None => text.len() + (p + 1 - offsets.len()), + }; + let to_units = |list: Vec| -> Vec { + let mut at = 0; + list.into_iter() + .map(|(len, style, attrs)| { + let n = unit(at + len) - unit(at); + at += len; + (n, style, attrs) + }) + .collect() + }; + let para = to_units(para); + let chars = to_units(chars); + let owned: Vec<_> = owned + .into_iter() + .map(|(p, cls, item)| (unit(p), cls, item)) + .collect(); + let owners: Vec<_> = owners + .into_iter() + .map(|(p, len, owner, cell)| (unit(p), unit(p + len) - unit(p), owner, cell)) + .collect(); + for r in &mut sources { + let start = unit(r.start); + r.len = unit(r.start + r.len) - start; + r.start = start; + } + let xml_markers = match self.story_xml(uid, marker_strand, ¶, &unit) { + Ok(m) => m, + Err(e) => { + self.warn(format!("story {uid}: XML structure left out: {e}")); + BTreeMap::new() + } + }; + let xml_element = match self.chunk(uid, xml::chunk::NODE_REF)? { + Some(d) if d.len() >= 8 => { + let mut c = Cursor::new(&d); + Some((c.u32()?, c.u32()?)) + } + _ => None, + }; + let mut anchors: BTreeMap> = BTreeMap::new(); + let mut tables: BTreeMap = BTreeMap::new(); + let mut text_variables = BTreeMap::new(); + for (pos, cls, item) in owned { + match cls { + class::TEXT_VARIABLE_INSTANCE => { + let v = variable::Instance::read(item, &*self.object(item)?)?; + text_variables.insert(pos, v); + } + class::ANCHOR => { + let settings = self.chunk(item, chunk::ANCHOR_SETTINGS)?; + for child in self.children(item, chunk::ANCHOR_CHILDREN)? { + if let Some(mut pi) = self.page_item(child, None)? { + pi.anchor = settings.clone(); + anchors.entry(pos).or_default().push(pi); + } + } + } + table::class::TABLE_ANCHOR => { + // A table that cannot be read is left out, with a + // warning, rather than failing the whole document. + match self.table_of_anchor(item) { + Ok(Some(t)) => { + tables.insert(pos, t); + } + Ok(None) => {} + Err(e) => self.warn(format!("story {uid}: table left out: {e}")), + } + } + _ => {} + } + } + let cuts: Vec = owners.iter().map(|o| o.0).collect(); + let all = split_runs(&text, ¶, &chars, &cuts); + // Text not owned by the story belongs to table cells. + let owner_at = |at: usize| { + owners + .iter() + .find(|o| at >= o.0 && at < o.0 + o.1) + .map(|o| (o.2, o.3)) + }; + let mut runs = Vec::new(); + for run in all { + match owner_at(run.start) { + Some((owner, cell)) if owner != uid => { + if let Some(t) = tables.values_mut().find(|t| t.uid == owner) + && let Some(c) = t.cells.iter_mut().find(|c| c.id == cell) + { + c.runs.push(run); + } + } + _ => runs.push(run), + } + } + // IDML writes a text source inside one character range; keep the + // sources that lie within one run. + sources.sort_by_key(|r| r.start); + let cell_runs = tables + .values() + .flat_map(|t| t.cells.iter().flat_map(|c| &c.runs)); + let spans: Vec<(usize, usize)> = runs + .iter() + .chain(cell_runs) + .map(|r| (r.start, r.start + r.text.encode_utf16().count())) + .collect(); + sources.retain(|r| { + let inside = spans + .iter() + .any(|&(a, b)| r.start >= a && r.start + r.len <= b); + if !inside && r.len > 0 { + self.warn(format!( + "story {uid}: hyperlink source {} spans several text ranges; left out", + r.source + )); + } + // The IDML schema allows no page item inside a text source. + let anchored = anchors.range(r.start..r.start + r.len).next().is_some(); + if inside && anchored { + self.warn(format!( + "story {uid}: hyperlink source {} holds an anchored object; left out", + r.source + )); + } + inside && r.len > 0 && !anchored + }); + Ok(Story { + uid, + runs, + anchors, + tables, + text_variables, + sources, + xml_markers, + xml_element, + orientation: None, + // The story names an object (class 0x8C20) whose chunk 0x11613 + // is the TOC style. + toc_style: match self + .chunk(uid, chunk::STORY_TOC)? + .and_then(|d| u32_at(&d, 0)) + .and_then(uid_or_none) + { + Some(toc) => self + .chunk(toc, chunk::TOC_STYLE_OF)? + .and_then(|d| u32_at(&d, 0)) + .and_then(uid_or_none), + None => None, + }, + }) + } + + /// Read the XML nodes stored with story `uid` and place their markers. + /// `unit` converts a character position to a UTF-16 offset; `para` are + /// the paragraph runs, in UTF-16 units. An element whose start and end + /// lie in different paragraph runs is left out. + pub(super) fn story_xml( + &self, + uid: u32, + marker_strand: Option, + para: &[StyleRun], + unit: &dyn Fn(usize) -> usize, + ) -> Result, Error> { + let mut out = BTreeMap::new(); + let first = match self.chunk(uid, xml::chunk::STORE)? { + Some(d) if d.len() >= 4 => Cursor::new(&d).u32()?, + _ => return Ok(out), + }; + let nodes = xml::read_store(first, |p| self.chunk(p, xml::chunk::PAGE))?; + if nodes.is_empty() { + return Ok(out); + } + let positions = match marker_strand.map(|s| self.chunk(s, xml::chunk::MARKER_TREE)) { + Some(r) => match r? { + Some(d) => xml::marker_positions(&d)?, + None => BTreeMap::new(), + }, + None => BTreeMap::new(), + }; + let para_of = |at: usize| { + let mut end = 0; + para.iter().position(|(len, _, _)| { + end += len; + at < end + }) + }; + for node in nodes { + let at = |m: Option| m.and_then(|m| positions.get(&m)).map(|&p| unit(p)); + let (start, end) = (at(node.start), at(node.end)); + if node.start.is_some() != start.is_some() || node.end.is_some() != end.is_some() { + self.warn(format!( + "story {uid}: XML node {:?} left out: marker not found", + node.key + )); + } else if node.document { + if let Some(s) = start { + out.insert(s, XmlMarker::Hidden); + } + } else { + match (start, end) { + (Some(s), Some(e)) if para_of(s) == para_of(e) => { + out.insert(s, XmlMarker::Start(node.key)); + out.insert(e, XmlMarker::End(node.key)); + } + (Some(s), Some(e)) => { + self.warn(format!( + "story {uid}: XML element {:?} spans paragraphs; left out", + node.key + )); + out.insert(s, XmlMarker::Hidden); + out.insert(e, XmlMarker::Hidden); + } + (Some(s), None) => { + out.insert(s, XmlMarker::Placeholder(node.key)); + } + _ => {} + } + } + self.xml_nodes.borrow_mut().insert(node.key, node); + } + Ok(out) + } + + /// The XML elements that can be written: those whose parents lead to + /// the document node and whose tag is known. See `docs/format/xml.md`. + pub(super) fn xml_elements( + &self, + tags: &HashMap, + ) -> Result, Error> { + let nodes = self.xml_nodes.borrow(); + let mut out = BTreeMap::new(); + for (key, node) in nodes.iter().filter(|(_, n)| !n.document) { + // `Self`: "d", then "i" and the hex ID of each element from the + // root down to this one. + let mut path = vec![key.1]; + let mut parent = node.parent; + let mut reached = false; + while let Some(p) = nodes.get(&parent) { + if p.document { + reached = true; + break; + } + if path.len() > nodes.len() { + break; + } + path.push(p.key.1); + parent = p.parent; + } + let Some(tag) = tags.get(&node.tag) else { + self.warn(format!( + "XML element {key:?} left out: tag {} unknown", + node.tag + )); + continue; + }; + if !reached { + self.warn(format!("XML element {key:?} left out: no path to the root")); + continue; + } + let name = path.iter().rev().fold(String::from("d"), |mut s, id| { + s.push_str(&format!("i{id:x}")); + s + }); + let (content, story_content) = match self.class(node.content) { + _ if node.content == 0 => (None, false), + Some(class::STORY) => (Some(node.content), true), + // A content holder stands for its parent page item. + Some(xml::class::CONTENT_HOLDER) => { + match self.chunk(node.content, chunk::ITEM_HIERARCHY)? { + Some(d) if d.len() >= 8 => { + (uid_or_none(Cursor::new(&d[4..]).u32()?), false) + } + _ => (None, false), + } + } + c => { + self.warn(format!( + "XML element {key:?}: content {} of class {c:x?} left out", + node.content + )); + (None, false) + } + }; + out.insert( + *key, + XmlElement { + name, + tag: tag.clone(), + content, + story_content, + block: false, + }, + ); + } + // An element is written as a block when it holds, at any depth, an + // element that is a single marker with a story as content. + let holds_story = |key: &xml::Key| { + let mut stack = vec![*key]; + let mut seen = Vec::new(); + while let Some(k) = stack.pop() { + if seen.contains(&k) { + continue; + } + seen.push(k); + let Some(n) = nodes.get(&k) else { continue }; + for c in &n.children { + if let Some(child) = nodes.get(c) + && child.end.is_none() + && out.get(c).is_some_and(|e: &XmlElement| e.story_content) + { + return true; + } + stack.push(*c); + } + } + false + }; + let blocks: Vec = out.keys().filter(|k| holds_story(k)).copied().collect(); + for k in blocks { + if let Some(e) = out.get_mut(&k) { + e.block = true; + } + } + Ok(out) + } +} diff --git a/src/model/strings.rs b/src/model/strings.rs new file mode 100644 index 0000000..16c8a7e --- /dev/null +++ b/src/model/strings.rs @@ -0,0 +1,62 @@ +//! Searches for names stored as in-object strings at positions that are +//! not decoded: layer, style and table style names. +//! +//! Evidence: `docs/format/objects.md`. + +use super::*; + +/// Find a flag byte (1 = built-in name) followed by an in-object string +/// that `accept` takes, at or after `from`. Returns the offset of the pair, +/// whether the flag is 1, and the string. In big-endian data the flag and +/// the string's tag (2) are swapped (`docs/format/big-endian.md`). +pub(super) fn find_flagged_string( + data: &[u8], + from: usize, + accept: impl Fn(&str) -> bool, +) -> Option<(usize, bool, String)> { + let big = crate::object::big_endian(); + (from..data.len().saturating_sub(6)).find_map(|i| { + let header = match big { + false => data[i] <= 2 && data[i + 1] == 2, + true => data[i] == 2 && data[i + 1] <= 2, + }; + if !header { + return None; + } + let mut c = Cursor::new(&data[i..]); + let builtin = c.flag().ok()? == 1; + let s = c.string().ok()?; + accept(&s).then_some((i, builtin, s)) + }) +} + +/// Find the first in-object string at or after `from`. +pub(super) fn find_string(data: &[u8], from: usize) -> Result { + if crate::object::big_endian() { + // The tag (2), the byte before it in little-endian data, then the + // rest of the header (`Cursor::string`). + for i in from..data.len().saturating_sub(5) { + if data[i] == 2 + && data[i + 1] <= 2 + && u16_from([data[i + 3], data[i + 4]]) > 0 + && let Ok(s) = Cursor::new(&data[i..]).string() + { + return Ok(s); + } + } + return Ok(String::new()); + } + for i in from..data.len().saturating_sub(4) { + if data[i] == 2 && data[i + 1] == 0 { + let n = u16_from([data[i + 2], data[i + 3]]) as usize; + if n > 0 + && i + 6 <= data.len() + && (u16_from([data[i + 4], data[i + 5]]) & 0xC000) != 0 + && let Ok(s) = Cursor::new(&data[i..]).string() + { + return Ok(s); + } + } + } + Ok(String::new()) +} diff --git a/src/model/style.rs b/src/model/style.rs new file mode 100644 index 0000000..734f14a --- /dev/null +++ b/src/model/style.rs @@ -0,0 +1,228 @@ +//! Text, object and TOC styles and style groups. +//! +//! Evidence: `docs/format/objects.md` (styles, style groups, object +//! styles, TOC styles) and `attributes.md`. + +use super::*; + +#[derive(Debug, Clone, PartialEq)] +pub struct Style { + pub uid: u32, + pub name: String, + /// The name is an InDesign built-in key, written with `$ID/` in IDML. + pub builtin: bool, + pub paragraph: bool, + pub based_on: Option, + pub next: Option, + pub attrs: Attrs, + /// The u16 after the kind, before the name (IDML `Imported`). + pub imported: bool, + /// The GUID string after the name in newer files (`StyleUniqueId`). + pub unique_id: Option, + /// Keyboard shortcut: u32 key 10 bytes before the name's flag byte, + /// then the two bytes 6 and 5 before it (`docs/format/objects.md`). + pub shortcut: Option<(u32, u8, u8)>, +} + +/// A table of contents style (class 0x11605), from chunk 0x11605: a flag +/// byte and the name, three u32 (the third the title style), a flag byte +/// and the title. See `docs/format/objects.md`. +#[derive(Debug, Clone, PartialEq)] +pub struct TocStyle { + pub uid: u32, + pub name: String, + pub builtin: bool, + pub title: String, + pub title_style: u32, + /// After a flag byte and a string: u16 at 2 numbered paragraphs, at 4 + /// make anchor and at 6 remove forced line breaks, where the chunk + /// has them. + pub flags: Vec, +} + +/// A style group: a root group of styles, or a named group in it. +#[derive(Debug, Clone, PartialEq)] +pub struct StyleGroup { + pub uid: u32, + /// Empty for root groups. + pub name: String, + /// Root groups: what they hold, from chunk 0x28C2 (see `root_kind`). + pub root: Option, + pub children: Vec, +} + +#[derive(Debug, Clone, PartialEq)] +pub struct ObjectStyle { + pub uid: u32, + pub name: String, + pub builtin: bool, + pub based_on: Option, + /// Frame fitting attributes (chunk 0x1B956), same IDs as on page items. + pub fitting: Attrs, + /// Page item attributes (chunk 0x1B92B): fill, stroke, corners. + pub attrs: Attrs, + /// Text frame settings (chunk 0x1B924); see `docs/format/objects.md`. + pub frame: Option>, + /// Story settings (chunk 0x285B). + pub story: Option>, + /// Story direction (chunk 0x50F28, u16). + pub direction: Option, + /// Text wrap (chunk 0x3776, the layout of chunk 0x3703). + pub text_wrap: Option, + /// Contour type of the text wrap (chunk 0x3777). + pub contour_type: Option, + /// IDs of the setting categories the style turns on (chunk 0x1B92E). + pub enabled: Option>, + /// Paragraph style applied to text frames (chunk 0x1B946). + pub paragraph_style: Option, + /// Anchored object settings (chunk 0x2800). + pub anchor: Option>, +} + +/// Style groups nested deeper than this are left out, with a warning. +pub(super) const MAX_GROUP_DEPTH: usize = 100; + +/// Make the style groups a tree under their root groups, so that walking +/// them ends: a group listed a second time (in a cycle, or under a second +/// parent) or nested deeper than [`MAX_GROUP_DEPTH`] is removed from the +/// children of the group that lists it, with a warning. +pub(super) fn prune_style_groups(groups: &mut BTreeMap, warn: impl Fn(String)) { + let roots: Vec = groups + .iter() + .filter(|(_, g)| g.root.is_some()) + .map(|(&uid, _)| uid) + .collect(); + let mut seen: std::collections::HashSet = roots.iter().copied().collect(); + let mut stack: Vec<(u32, usize)> = roots.iter().map(|&r| (r, 0)).collect(); + while let Some((uid, depth)) = stack.pop() { + let Some(g) = groups.get_mut(&uid) else { + continue; + }; + let children = std::mem::take(&mut g.children); + let mut kept = Vec::with_capacity(children.len()); + for c in children { + if groups.contains_key(&c) { + if !seen.insert(c) { + warn(format!( + "style group {c} is listed twice; left out of group {uid}" + )); + continue; + } + if depth + 1 > MAX_GROUP_DEPTH { + warn(format!( + "style group {c} is nested more than {MAX_GROUP_DEPTH} deep; left out" + )); + continue; + } + stack.push((c, depth + 1)); + } + kept.push(c); + } + if let Some(g) = groups.get_mut(&uid) { + g.children = kept; + } + } +} + +impl<'a> Reader<'a> { + pub(super) fn style(&self, uid: u32) -> Result, Error> { + let Some(data) = self.chunk(uid, chunk::STYLE_INFO)? else { + return Ok(None); + }; + let mut c = Cursor::new(&data); + let next = c.u32()?; + let based_on = c.u32()?; + // The header before the name is 4 bytes shorter in files from + // InDesign 13 and earlier, so locate the name by its structure: a + // flag byte (1 = built-in name), then an in-object string. Four + // bytes before the flag, a u16 is 1 for paragraph styles and 0 for + // character styles; the u16 after it is not identified. + let Some((at, builtin, name)) = find_flagged_string(&data, 12, |_| true) else { + return Err(Error::Corrupt(format!("style {uid}: no name"))); + }; + let paragraph = Cursor::new(&data[at - 4..]).u16()? != 0; + let imported = Cursor::new(&data[at - 2..]).u16()? != 0; + let shortcut = if at >= 10 { + Some(( + Cursor::new(&data[at - 10..]).u32()?, + data[at - 6], + data[at - 5], + )) + } else { + None + }; + // A 36-character in-object string after the name: a GUID. + const GUID: [u8; 6] = [2, 0, 36, 0, 36, 0x40]; + let unique_id = if crate::object::big_endian() { + None + } else { + data[at..] + .windows(GUID.len()) + .position(|w| w == GUID) + .and_then(|i| Cursor::new(&data[at + i..]).string().ok()) + }; + let attrs = match self.chunk(uid, chunk::STYLE_ATTRS)? { + Some(d) if d.len() >= 2 => { + let mut c = Cursor::new(&d); + let n = c.u16()? as usize; + Attrs::parse_text(&mut c, n, List::Style).unwrap_or_default() + } + _ => Attrs::default(), + }; + Ok(Some(Style { + uid, + name, + builtin, + paragraph, + based_on: uid_or_none(based_on), + next: uid_or_none(next), + attrs, + imported, + unique_id, + shortcut, + })) + } + + /// The table of contents styles, in UID order. + pub(super) fn toc_styles(&self) -> Vec { + let mut out = Vec::new(); + for &(uid, cls) in self.db.classes() { + if cls != class::TOC_STYLE { + continue; + } + let read = (|| -> Result, Error> { + let Some(d) = self.chunk(uid, chunk::TOC_STYLE)? else { + return Ok(None); + }; + let mut c = Cursor::new(&d); + let builtin = c.flag()? == 1; + let name = c.string()?; + c.skip(8)?; + let title_style = c.u32()?; + c.flag()?; + let title = c.string()?; + c.flag()?; + c.string()?; + let mut flags = Vec::new(); + while flags.len() < 4 && c.remaining() >= 2 { + flags.push(c.u16()?); + } + Ok(Some(TocStyle { + uid, + name, + builtin, + title, + title_style, + flags, + })) + })(); + match read { + Ok(Some(t)) => out.push(t), + Ok(None) => {} + Err(e) => self.warn(format!("TOC style {uid} left out: {e}")), + } + } + out.sort_by_key(|t| t.uid); + out + } +}