diff --git a/Cargo.lock b/Cargo.lock
index 7b965e3f7..722a8f1f9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1848,6 +1848,7 @@ version = "0.1.0"
dependencies = [
"craft-heif",
"craft-jpeg",
+ "craft-metadata",
"exr",
"flate2",
"half",
diff --git a/crates/idml/src/lib.rs b/crates/idml/src/lib.rs
index 07405a959..3b2cf45f7 100644
--- a/crates/idml/src/lib.rs
+++ b/crates/idml/src/lib.rs
@@ -39,7 +39,10 @@ pub mod value;
pub use craft_xml::{El, Local, Node};
pub use package::{Document, Limits, Package, write_package};
-pub use part::{CONTAINER_XML, Props, designmap_xml, parse_part, part_root, part_xml, prop, with_props, xml_limits};
+pub use part::{
+ CONTAINER_XML, Props, designmap_include, designmap_root, designmap_xml, designmap_xml_with_pi, parse_part, part_root, part_xml, prop, with_props,
+ xml_limits,
+};
/// The IDML package mimetype (content of the first, stored `mimetype` entry).
pub const MIMETYPE: &str = "application/vnd.adobe.indesign-idml-package";
@@ -48,6 +51,14 @@ pub const DOM_VERSION: &str = "16.0";
/// The namespace of the `idPkg` prefix.
pub const PACKAGING_NS: &str = "http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging";
+/// Writes the bounded XMP metadata packet used by an IDML package. Dates are already normalized
+/// ISO-8601 values supplied by the caller; this function owns the XML vocabulary and envelope.
+pub fn xmp_metadata(create_date: &str, modify_date: &str) -> String {
+ format!(
+ "\n\n \n \n {create_date}\n {modify_date}\n \n \n\n"
+ )
+}
+
/// Why a package was not read or not written.
#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
pub enum Error {
diff --git a/crates/idml/src/model/document.rs b/crates/idml/src/model/document.rs
new file mode 100644
index 000000000..3937a4501
--- /dev/null
+++ b/crates/idml/src/model/document.rs
@@ -0,0 +1,524 @@
+//! The `Document` tree: root values and included designmap nodes in source order.
+
+use craft_xml::El;
+
+use super::{AlternatingFillValues, AlternatingStrokeValues, Spread, Story, StrokeValues, Values};
+
+/// One IDML table-of-contents style entry before document style names are resolved.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct TocStyleEntryValues {
+ pub style: Option,
+ pub level: Option,
+ pub page_number_position: Option,
+ pub separator: Option,
+ pub entry_style: Option,
+ pub page_number_style: Option,
+ pub separator_style: Option,
+ pub sort: Option,
+}
+
+/// An IDML table-of-contents style and its entry grammar.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct TocStyleValues {
+ pub self_id: Option,
+ pub title: Option,
+ pub title_style: Option,
+ pub create_bookmarks: Option,
+ pub entries: Vec,
+}
+
+/// Date-based IDML text variable kinds.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TextDateKind {
+ Creation,
+ Modification,
+ Output,
+}
+
+/// Semantically classified `TextVariable` definitions before caller model mapping.
+#[derive(Clone, Debug, PartialEq)]
+pub enum TextVariableKind {
+ CustomText { text: String },
+ LastPageNumber { section: bool },
+ ChapterNumber,
+ FileName { extension: bool },
+ Date { kind: TextDateKind, format: String },
+ RunningHeader { style: String, character: bool, last_on_page: bool },
+ CrossReference { page_number: bool },
+ Imported { variable_type: String, settings_element: String, settings: Vec<(String, String)> },
+}
+
+/// Parsed values from an IDML `TextVariable` definition.
+#[derive(Clone, Debug, PartialEq)]
+pub struct TextVariableValues {
+ pub self_id: Option,
+ pub name: String,
+ pub before: String,
+ pub after: String,
+ pub kind: TextVariableKind,
+}
+
+/// A recognized IDML cross-reference format building block.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum CrossReferenceBuildingBlock {
+ CustomText(String),
+ FullParagraph,
+ ParagraphText,
+ ParagraphNumber,
+ PageNumber,
+ BookmarkName,
+ ChapterNumber,
+ FileName,
+ PartialParagraph { delimiter: String, include_delimiter: bool },
+}
+
+/// Parsed IDML cross-reference format definition.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct CrossReferenceFormatValues {
+ pub self_id: Option,
+ pub name: String,
+ pub blocks: Vec,
+}
+
+impl CrossReferenceFormatValues {
+ /// Reads a `CrossReferenceFormat` and recognizes its building-block grammar.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ let mut result =
+ Self { self_id: values.self_id().map(str::to_owned), name: values.get("Name").unwrap_or("Format").to_owned(), blocks: Vec::new() };
+ for block in el.elements().filter(|child| child.local() == "BuildingBlock") {
+ let values = Values::of(block);
+ let text = |key: &str| values.get(key).filter(|value| *value != "$ID/").unwrap_or("").to_owned();
+ let parsed = match values.get("BlockType").unwrap_or("") {
+ "CustomStringBuildingBlock" => Some(CrossReferenceBuildingBlock::CustomText(text("CustomText"))),
+ "FullParagraphBuildingBlock" => Some(CrossReferenceBuildingBlock::FullParagraph),
+ "ParagraphTextBuildingBlock" => Some(CrossReferenceBuildingBlock::ParagraphText),
+ "ParagraphNumberBuildingBlock" => Some(CrossReferenceBuildingBlock::ParagraphNumber),
+ "PageNumberBuildingBlock" => Some(CrossReferenceBuildingBlock::PageNumber),
+ "BookmarkNameBuildingBlock" => Some(CrossReferenceBuildingBlock::BookmarkName),
+ "ChapterNumberBuildingBlock" => Some(CrossReferenceBuildingBlock::ChapterNumber),
+ "FileNameBuildingBlock" => Some(CrossReferenceBuildingBlock::FileName),
+ "PartialParagraphBuildingBlock" => Some(CrossReferenceBuildingBlock::PartialParagraph {
+ delimiter: text("AppliedDelimiter"),
+ include_delimiter: values.get("IncludeDelimiter") == Some("true"),
+ }),
+ _ => None,
+ };
+ if let Some(parsed) = parsed {
+ result.blocks.push(parsed);
+ }
+ }
+ result
+ }
+
+ /// Builds an IDML cross-reference format from DesignCraft's stored token definition.
+ pub fn to_el(self_id: &str, name: &str, definition: &str) -> El {
+ let mut root = El::new("CrossReferenceFormat").with_attr("Self", self_id).with_attr("Name", name).with_attr("AppliedCharacterStyle", "n");
+ let mut index = 0;
+ let mut block = |root: &mut El, kind: &str, text: &str, delimiter: &str, include: bool| {
+ root.push(
+ El::new("BuildingBlock")
+ .with_attr("Self", format!("{self_id}BuildingBlock{index}"))
+ .with_attr("BlockType", kind)
+ .with_attr("AppliedCharacterStyle", "n")
+ .with_attr("CustomText", if text.is_empty() { "$ID/" } else { text })
+ .with_attr("AppliedDelimiter", if delimiter.is_empty() { "$ID/" } else { delimiter })
+ .with_attr("IncludeDelimiter", if include { "true" } else { "false" }),
+ );
+ index += 1;
+ };
+ let mut rest = definition;
+ while let Some(start) = rest.find('<') {
+ let Some(end) = rest[start..].find('>') else { break };
+ if start > 0 {
+ block(&mut root, "CustomStringBuildingBlock", &rest[..start], "", false);
+ }
+ let tag = rest[start + 1..start + end].trim().trim_end_matches('/').trim();
+ let attr =
+ |key: &str| tag.find(&format!("{key}=\"")).and_then(|position| tag[position + key.len() + 2..].split('"').next()).unwrap_or("");
+ match tag.split_whitespace().next().unwrap_or("") {
+ "fullPara" => block(&mut root, "FullParagraphBuildingBlock", "", "", false),
+ "paraText" => block(&mut root, "ParagraphTextBuildingBlock", "", "", false),
+ "paraNum" => block(&mut root, "ParagraphNumberBuildingBlock", "", "", false),
+ "pageNum" => block(&mut root, "PageNumberBuildingBlock", "", "", false),
+ "txtAnchrName" => block(&mut root, "BookmarkNameBuildingBlock", "", "", false),
+ "chapNum" => block(&mut root, "ChapterNumberBuildingBlock", "", "", false),
+ "fileName" => block(&mut root, "FileNameBuildingBlock", "", "", false),
+ "partialPara" => block(&mut root, "PartialParagraphBuildingBlock", "", attr("delim"), attr("includeDelim") == "true"),
+ _ => block(&mut root, "CustomStringBuildingBlock", &rest[start..start + end + 1], "", false),
+ }
+ rest = &rest[start + end + 1..];
+ }
+ if !rest.is_empty() {
+ block(&mut root, "CustomStringBuildingBlock", rest, "", false);
+ }
+ root
+ }
+}
+
+/// Parsed EPUB document-splitting preference.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct EpubSplitValues {
+ pub break_document: bool,
+ pub paragraph_style: Option,
+}
+
+/// Parsed IDML condition metadata.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConditionValues {
+ pub self_id: Option,
+ pub name: Option,
+ pub indicator_rgb: Option<[u8; 3]>,
+ pub visible: bool,
+}
+
+impl ConditionValues {
+ /// Reads condition fields and its optional three-channel indicator color.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ let rgb: Vec = values
+ .get("IndicatorColor")
+ .unwrap_or("")
+ .split_whitespace()
+ .filter_map(|value| value.parse::().ok())
+ .map(|value| value.clamp(0.0, 255.0) as u8)
+ .collect();
+ Self {
+ self_id: values.self_id().map(str::to_owned),
+ name: values.get("Name").map(str::to_owned),
+ indicator_rgb: (rgb.len() == 3).then(|| [rgb[0], rgb[1], rgb[2]]),
+ visible: values.get("Visible") != Some("false"),
+ }
+ }
+}
+
+/// Parsed IDML numbering-list metadata.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct NumberingListValues {
+ pub name: String,
+ pub continue_across_stories: bool,
+}
+
+/// Parsed cell-style assignments that are independent of DesignCraft's style resolution.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct CellStyleValues {
+ pub self_id: Option,
+ pub name: Option,
+ pub based_on: Option,
+ pub fill: Option,
+ pub fill_tint: Option,
+ pub insets: [Option; 4],
+ pub vertical_justification: Option,
+ pub first_baseline: Option,
+ pub first_baseline_min: Option,
+ pub paragraph_style: Option,
+ pub edge_strokes: [StrokeValues; 4],
+}
+
+impl CellStyleValues {
+ /// Reads the cell-style value assignments and supports the older inset property names.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ let inset = |modern, legacy| values.num(modern).or_else(|| values.num(legacy)).map(|v| v.max(0.0));
+ Self {
+ self_id: values.self_id().map(str::to_owned),
+ name: values.name().map(str::to_owned),
+ based_on: values.prop("BasedOn"),
+ fill: values.prop("FillColor"),
+ fill_tint: values.num("FillTint"),
+ insets: [
+ inset("TextTopInset", "TopInset"),
+ inset("TextLeftInset", "LeftInset"),
+ inset("TextBottomInset", "BottomInset"),
+ inset("TextRightInset", "RightInset"),
+ ],
+ vertical_justification: values.get("VerticalJustification").map(str::to_owned),
+ first_baseline: values.get("FirstBaselineOffset").map(str::to_owned),
+ first_baseline_min: values.num("MinimumFirstBaselineOffset").filter(|v| v.is_finite()).map(|v| v.clamp(0.0, 8640.0)),
+ paragraph_style: values.get("AppliedParagraphStyle").map(str::to_owned),
+ edge_strokes: ["TopEdge", "LeftEdge", "BottomEdge", "RightEdge"].map(|edge| values.stroke_values(edge)),
+ }
+ }
+}
+
+/// Parsed table-style assignments that are independent of DesignCraft's style resolution.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct TableStyleValues {
+ pub name: Option,
+ pub based_on: Option,
+ pub header_cell_style: Option,
+ pub body_cell_style: Option,
+ pub footer_cell_style: Option,
+ pub left_column_cell_style: Option,
+ pub right_column_cell_style: Option,
+ pub header_same_as_body: Option,
+ pub footer_same_as_body: Option,
+ pub left_column_same_as_body: Option,
+ pub right_column_same_as_body: Option,
+ pub space_before: Option,
+ pub space_after: Option,
+ pub border_strokes: [StrokeValues; 4],
+ pub row_fills: AlternatingFillValues,
+ pub column_fills: AlternatingFillValues,
+ pub row_strokes: AlternatingStrokeValues,
+ pub column_strokes: AlternatingStrokeValues,
+}
+
+impl TableStyleValues {
+ /// Reads table-style regions, inheritance, spacing, and region reuse values.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ Self {
+ name: values.name().map(str::to_owned),
+ based_on: values.prop("BasedOn"),
+ header_cell_style: values.get("HeaderRegionCellStyle").map(str::to_owned),
+ body_cell_style: values.get("BodyRegionCellStyle").map(str::to_owned),
+ footer_cell_style: values.get("FooterRegionCellStyle").map(str::to_owned),
+ left_column_cell_style: values.get("LeftColumnRegionCellStyle").map(str::to_owned),
+ right_column_cell_style: values.get("RightColumnRegionCellStyle").map(str::to_owned),
+ header_same_as_body: values.boolean("HeaderRegionSameAsBodyRegion"),
+ footer_same_as_body: values.boolean("FooterRegionSameAsBodyRegion"),
+ left_column_same_as_body: values.boolean("LeftColumnRegionSameAsBodyRegion"),
+ right_column_same_as_body: values.boolean("RightColumnRegionSameAsBodyRegion"),
+ space_before: values.num("SpaceBefore"),
+ space_after: values.num("SpaceAfter"),
+ border_strokes: ["TopBorder", "LeftBorder", "BottomBorder", "RightBorder"].map(|border| values.stroke_values(border)),
+ row_fills: values.alternating_fill_values("Row"),
+ column_fills: values.alternating_fill_values("Column"),
+ row_strokes: values.alternating_stroke_values("Row"),
+ column_strokes: values.alternating_stroke_values("Column"),
+ }
+ }
+}
+
+impl NumberingListValues {
+ /// Reads a `NumberingList` element.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ Self {
+ name: values.get("Name").unwrap_or("").to_owned(),
+ continue_across_stories: values.boolean("ContinueNumbersAcrossStories") == Some(true),
+ }
+ }
+}
+
+impl EpubSplitValues {
+ /// Reads an `EPubExportPreference` element.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ Self { break_document: values.boolean("BreakDocument") == Some(true), paragraph_style: values.get("ParagraphStyleName").map(str::to_owned) }
+ }
+}
+
+impl TextVariableValues {
+ /// Reads a `TextVariable` and its preference record.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ let preference = el.elements().find(|child| child.name.ends_with("Preference"));
+ let attr = |key: &str| preference.and_then(|child| child.attr(key)).unwrap_or("");
+ let variable_type = values.get("VariableType").unwrap_or("");
+ let date = |kind| TextVariableKind::Date { kind, format: if attr("Format").is_empty() { "MM/dd/yy".into() } else { attr("Format").into() } };
+ let kind = match variable_type {
+ "CustomTextType" => TextVariableKind::CustomText { text: attr("Contents").into() },
+ "LastPageNumberType" => TextVariableKind::LastPageNumber { section: attr("Scope") == "SectionScope" },
+ "ChapterNumberType" => TextVariableKind::ChapterNumber,
+ "FileNameType" if attr("IncludePath") != "true" => TextVariableKind::FileName { extension: attr("IncludeExtension") == "true" },
+ "CreationDateType" => date(TextDateKind::Creation),
+ "ModificationDateType" => date(TextDateKind::Modification),
+ "OutputDateType" => date(TextDateKind::Output),
+ "MatchParagraphStyleType" | "MatchCharacterStyleType" => {
+ let character = variable_type == "MatchCharacterStyleType";
+ let style = attr(if character { "AppliedCharacterStyle" } else { "AppliedParagraphStyle" });
+ if style.is_empty() {
+ TextVariableKind::Imported {
+ variable_type: variable_type.into(),
+ settings_element: preference.map(|child| child.name.clone()).unwrap_or_default(),
+ settings: preference.map(|child| child.attrs.clone()).unwrap_or_default(),
+ }
+ } else {
+ TextVariableKind::RunningHeader { style: style.into(), character, last_on_page: attr("SearchStrategy") == "LastOnPage" }
+ }
+ }
+ _ if variable_type.starts_with("Xref") => TextVariableKind::CrossReference { page_number: variable_type == "XrefPageNumberType" },
+ _ => TextVariableKind::Imported {
+ variable_type: variable_type.into(),
+ settings_element: preference.map(|child| child.name.clone()).unwrap_or_default(),
+ settings: preference.map(|child| child.attrs.clone()).unwrap_or_default(),
+ },
+ };
+ Self {
+ self_id: values.self_id().map(str::to_owned),
+ name: values.get("Name").unwrap_or("").to_owned(),
+ before: values.get("TextBefore").unwrap_or("").to_owned(),
+ after: values.get("TextAfter").unwrap_or("").to_owned(),
+ kind,
+ }
+ }
+}
+
+impl TocStyleValues {
+ /// Reads a `TOCStyle` element and its bounded `TOCStyleEntry` children.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ let mut result = Self {
+ self_id: values.self_id().map(str::to_owned),
+ title: values.get("Title").map(str::to_owned),
+ title_style: values.get("TitleStyle").map(str::to_owned),
+ create_bookmarks: values.get("CreateBookmarks").or_else(|| values.get("CreatePdfBookmarks")).map(|value| value == "true"),
+ entries: Vec::new(),
+ };
+ result.entries.extend(el.elements().filter(|entry| entry.local() == "TOCStyleEntry").take(64).map(|entry| {
+ let values = Values::of(entry);
+ TocStyleEntryValues {
+ style: values.get("Name").map(str::to_owned),
+ level: values.get("Level").and_then(|value| value.trim().parse().ok()),
+ page_number_position: values.get("PageNumberPosition").map(str::to_owned),
+ separator: values.get("Separator").map(str::to_owned),
+ entry_style: values.prop("FormatStyle"),
+ page_number_style: values.prop("PageNumberStyle"),
+ separator_style: values.prop("SeparatorStyle"),
+ sort: values.get("Sort").map(|value| value.trim() == "true"),
+ }
+ }));
+ result
+ }
+}
+
+/// The top-level IDML elements consumed by document importers.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TopLevelKind {
+ DocumentPreference,
+ TransparencyPreference,
+ TextPreference,
+ MarginPreference,
+ ViewPreference,
+ GridPreference,
+ PasteboardPreference,
+ CompositeFont,
+ KinsokuTable,
+ MojikumiTable,
+ FootnoteOption,
+ EpubExportPreference,
+ Layer,
+ CrossReferenceFormat,
+ Index,
+ TextVariable,
+ Story,
+ Hyperlink,
+ HyperlinkUrlDestination,
+ HyperlinkPageDestination,
+ HyperlinkPageItemSource,
+ HyperlinkOtherDestination,
+ MasterSpread,
+ Spread,
+ Section,
+ TocStyle,
+ Condition,
+ NumberingList,
+ StyleGroup,
+ Other,
+}
+
+/// One included node in `designmap.xml`, classified by the shared IDML grammar.
+#[derive(Clone, Debug, PartialEq)]
+pub struct TopLevelNode {
+ pub kind: TopLevelKind,
+ data: TopLevelData,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum TopLevelData {
+ Story(Story),
+ Spread(Spread),
+ Raw(El),
+}
+
+impl TopLevelNode {
+ fn from_el(el: El) -> TopLevelNode {
+ let kind = top_level_kind(el.local());
+ let data = match kind {
+ TopLevelKind::Story => TopLevelData::Story(Story::from_el(&el)),
+ TopLevelKind::Spread | TopLevelKind::MasterSpread => TopLevelData::Spread(Spread::from_el(&el)),
+ _ => TopLevelData::Raw(el),
+ };
+ TopLevelNode { kind, data }
+ }
+
+ /// The typed story or spread tree when this is one of those parts.
+ pub fn story(&self) -> Option<&Story> {
+ if let TopLevelData::Story(story) = &self.data { Some(story) } else { None }
+ }
+
+ pub fn spread(&self) -> Option<&Spread> {
+ if let TopLevelData::Spread(spread) = &self.data { Some(spread) } else { None }
+ }
+
+ /// The original element, reconstructed from the typed story/spread model where applicable.
+ pub fn to_el(&self) -> El {
+ match &self.data {
+ TopLevelData::Story(story) => story.to_el(),
+ TopLevelData::Spread(spread) => spread.to_el(),
+ TopLevelData::Raw(el) => el.clone(),
+ }
+ }
+
+ pub fn values(&self) -> Values {
+ Values::of(&self.to_el())
+ }
+}
+
+/// A neutral view of an IDML package's designmap and included top-level parts.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ModelDocument {
+ pub root: Values,
+ pub top: Vec,
+ pub warnings: Vec,
+ pub metadata: Option,
+}
+
+impl ModelDocument {
+ /// Converts the shared bounded package reader's parsed document into typed document nodes.
+ pub fn from_package(document: crate::Document) -> ModelDocument {
+ ModelDocument {
+ root: Values::of(&document.root),
+ top: document.top.into_iter().map(TopLevelNode::from_el).collect(),
+ warnings: document.warnings,
+ metadata: document.metadata,
+ }
+ }
+}
+
+fn top_level_kind(name: &str) -> TopLevelKind {
+ match name {
+ "DocumentPreference" => TopLevelKind::DocumentPreference,
+ "TransparencyPreference" => TopLevelKind::TransparencyPreference,
+ "TextPreference" => TopLevelKind::TextPreference,
+ "MarginPreference" => TopLevelKind::MarginPreference,
+ "ViewPreference" => TopLevelKind::ViewPreference,
+ "GridPreference" => TopLevelKind::GridPreference,
+ "PasteboardPreference" => TopLevelKind::PasteboardPreference,
+ "CompositeFont" => TopLevelKind::CompositeFont,
+ "KinsokuTable" => TopLevelKind::KinsokuTable,
+ "MojikumiTable" => TopLevelKind::MojikumiTable,
+ "FootnoteOption" => TopLevelKind::FootnoteOption,
+ "EPubExportPreference" => TopLevelKind::EpubExportPreference,
+ "Layer" => TopLevelKind::Layer,
+ "CrossReferenceFormat" => TopLevelKind::CrossReferenceFormat,
+ "Index" => TopLevelKind::Index,
+ "TextVariable" => TopLevelKind::TextVariable,
+ "Story" => TopLevelKind::Story,
+ "Hyperlink" => TopLevelKind::Hyperlink,
+ "HyperlinkURLDestination" => TopLevelKind::HyperlinkUrlDestination,
+ "HyperlinkPageDestination" => TopLevelKind::HyperlinkPageDestination,
+ "HyperlinkPageItemSource" => TopLevelKind::HyperlinkPageItemSource,
+ "MasterSpread" => TopLevelKind::MasterSpread,
+ "Spread" => TopLevelKind::Spread,
+ "Section" => TopLevelKind::Section,
+ "TOCStyle" => TopLevelKind::TocStyle,
+ "Condition" => TopLevelKind::Condition,
+ "NumberingList" => TopLevelKind::NumberingList,
+ name if name.starts_with("Root") && name.ends_with("StyleGroup") => TopLevelKind::StyleGroup,
+ name if name.starts_with("Hyperlink") && name.ends_with("Destination") => TopLevelKind::HyperlinkOtherDestination,
+ _ => TopLevelKind::Other,
+ }
+}
diff --git a/crates/idml/src/model/effects.rs b/crates/idml/src/model/effects.rs
new file mode 100644
index 000000000..8f5fa9530
--- /dev/null
+++ b/crates/idml/src/model/effects.rs
@@ -0,0 +1,404 @@
+//! The IDML transparency/effect settings found on page items and object styles.
+
+use craft_xml::{El, Local, Node};
+
+use super::Values;
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct DropShadowValues {
+ pub mode: Option,
+ pub x_offset: Option,
+ pub y_offset: Option,
+ pub color: Option,
+ pub opacity: Option,
+ pub size: Option,
+ pub spread: Option,
+ pub blend_mode: Option,
+}
+
+impl DropShadowValues {
+ pub fn to_el(&self) -> El {
+ let mut element = El::new("DropShadowSetting");
+ if let Some(value) = &self.mode {
+ element.set_attr("Mode", value);
+ }
+ for (key, value) in
+ [("XOffset", self.x_offset), ("YOffset", self.y_offset), ("Size", self.size), ("Spread", self.spread), ("Opacity", self.opacity)]
+ {
+ if let Some(value) = value {
+ element.set_attr(key, crate::value::num(value));
+ }
+ }
+ if let Some(value) = &self.blend_mode {
+ element.set_attr("BlendMode", value);
+ }
+ if let Some(value) = &self.color {
+ element.set_attr("EffectColor", value);
+ }
+ element
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct FeatherValues {
+ pub mode: Option,
+ pub width: Option,
+ pub choke_amount: Option,
+ pub corner_type: Option,
+}
+
+impl FeatherValues {
+ pub fn to_el(&self) -> El {
+ let mut element = El::new("FeatherSetting");
+ if let Some(value) = &self.mode {
+ element.set_attr("Mode", value);
+ }
+ for (key, value) in [("Width", self.width), ("ChokeAmount", self.choke_amount)] {
+ if let Some(value) = value {
+ element.set_attr(key, crate::value::num(value));
+ }
+ }
+ if let Some(value) = &self.corner_type {
+ element.set_attr("CornerType", value);
+ }
+ element
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct OpacityStopValues {
+ pub location: Option,
+ pub opacity: Option,
+}
+
+impl OpacityStopValues {
+ pub fn to_el(&self, self_id: &str, midpoint: bool) -> El {
+ let mut element = El::new("OpacityGradientStop").with_attr("Self", self_id);
+ if let Some(value) = self.opacity {
+ element.set_attr("Opacity", crate::value::num(value));
+ }
+ if let Some(value) = self.location {
+ element.set_attr("Location", crate::value::num(value));
+ }
+ if midpoint {
+ element.set_attr("Midpoint", "50");
+ }
+ element
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct GradientFeatherValues {
+ pub applied: bool,
+ pub radial: bool,
+ pub angle: Option,
+ pub length: Option,
+ pub start: Option<[f64; 2]>,
+ pub stops: Vec,
+}
+
+impl GradientFeatherValues {
+ pub fn to_el(&self, id_prefix: &str) -> El {
+ let mut element =
+ El::new("GradientFeatherSetting").with_attr("Applied", "true").with_attr("Type", if self.radial { "Radial" } else { "Linear" });
+ if let Some(value) = self.angle {
+ element.set_attr("Angle", crate::value::num(value));
+ }
+ if let Some(value) = self.length {
+ element.set_attr("Length", crate::value::num(value));
+ }
+ if let Some([x, y]) = self.start {
+ element.set_attr("GradientStart", format!("{} {}", crate::value::num(x), crate::value::num(y)));
+ }
+ for (index, stop) in self.stops.iter().enumerate() {
+ let stop_id = format!("{id_prefix}TransparencySetting1GradientFeatherSetting1OpacityGradientStop{index}");
+ element.push(stop.to_el(&stop_id, index > 0));
+ }
+ element
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct DirectionalFeatherValues {
+ pub applied: bool,
+ pub widths: [Option; 4],
+}
+
+impl DirectionalFeatherValues {
+ pub fn to_el(&self) -> El {
+ let mut element = El::new("DirectionalFeatherSetting").with_attr("Applied", "true");
+ for (key, value) in
+ [("LeftWidth", self.widths[1]), ("RightWidth", self.widths[3]), ("TopWidth", self.widths[0]), ("BottomWidth", self.widths[2])]
+ {
+ if let Some(value) = value {
+ element.set_attr(key, crate::value::num(value));
+ }
+ }
+ element
+ }
+}
+
+/// A typed view of an IDML `TransparencySetting` and its effect elements.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct TransparencySetting {
+ pub blend_mode: Option,
+ pub opacity: Option,
+ pub drop_shadow: Option,
+ pub feather: Option,
+ pub gradient_feather: Option,
+ pub directional_feather: Option,
+}
+
+impl TransparencySetting {
+ pub fn to_el(&self, id_prefix: &str) -> El {
+ let mut element = El::new("TransparencySetting");
+ if self.blend_mode.is_some() || self.opacity.is_some() {
+ let mut blending = El::new("BlendingSetting");
+ if let Some(value) = &self.blend_mode {
+ blending.set_attr("BlendMode", value);
+ }
+ if let Some(value) = self.opacity {
+ blending.set_attr("Opacity", crate::value::num(value));
+ }
+ element.push(blending);
+ }
+ if let Some(effect) = &self.drop_shadow {
+ element.push(effect.to_el());
+ }
+ if let Some(effect) = &self.feather {
+ element.push(effect.to_el());
+ }
+ if let Some(effect) = &self.directional_feather {
+ element.push(effect.to_el());
+ }
+ if let Some(effect) = &self.gradient_feather {
+ element.push(effect.to_el(id_prefix));
+ }
+ element
+ }
+
+ pub fn from_el(el: &El) -> Self {
+ let child = |name: &str| el.child(Local(name));
+ let blending = child("BlendingSetting").map(Values::of);
+ let drop_shadow = child("DropShadowSetting").map(|el| {
+ let values = Values::of(el);
+ DropShadowValues {
+ mode: values.get("Mode").map(str::to_owned),
+ x_offset: values.num("XOffset"),
+ y_offset: values.num("YOffset"),
+ color: values.get("EffectColor").map(str::to_owned),
+ opacity: values.num("Opacity"),
+ size: values.num("Size"),
+ spread: values.num("Spread"),
+ blend_mode: values.get("BlendMode").map(str::to_owned),
+ }
+ });
+ let feather = child("FeatherSetting").map(|el| {
+ let values = Values::of(el);
+ FeatherValues {
+ mode: values.get("Mode").map(str::to_owned),
+ width: values.num("Width"),
+ choke_amount: values.num("ChokeAmount"),
+ corner_type: values.get("CornerType").map(str::to_owned),
+ }
+ });
+ let gradient_feather = child("GradientFeatherSetting").map(|el| {
+ let values = Values::of(el);
+ let start = values
+ .prop("GradientStart")
+ .and_then(|value| value.split_whitespace().map(|part| part.parse::().ok().filter(|n| n.is_finite())).collect::>>())
+ .and_then(|parts| <[f64; 2]>::try_from(parts).ok());
+ GradientFeatherValues {
+ applied: values.boolean("Applied") == Some(true),
+ radial: values.get("Type") == Some("Radial"),
+ angle: values.num("Angle"),
+ length: values.num("Length"),
+ start,
+ stops: el
+ .elements()
+ .filter(|stop| stop.local() == "OpacityGradientStop")
+ .map(|stop| {
+ let values = Values::of(stop);
+ OpacityStopValues { location: values.num("Location"), opacity: values.num("Opacity") }
+ })
+ .collect(),
+ }
+ });
+ let directional_feather = child("DirectionalFeatherSetting").map(|el| {
+ let values = Values::of(el);
+ DirectionalFeatherValues {
+ applied: values.boolean("Applied") == Some(true),
+ widths: [values.num("TopWidth"), values.num("LeftWidth"), values.num("BottomWidth"), values.num("RightWidth")],
+ }
+ });
+ Self {
+ blend_mode: blending.as_ref().and_then(|values| values.get("BlendMode").map(str::to_owned)),
+ opacity: blending.as_ref().and_then(|values| values.num("Opacity")),
+ drop_shadow,
+ feather,
+ gradient_feather,
+ directional_feather,
+ }
+ }
+}
+
+/// Resolved object-style chain used to inherit item-level IDML settings.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ObjectStyleStack {
+ chain: Vec,
+}
+
+impl ObjectStyleStack {
+ /// Resolves a style reference and its `BasedOn` chain (nearest first, cycle-safe, max 16).
+ pub fn from_styles(styles: &[El], reference: Option<&str>, include_none: bool) -> Self {
+ let find = |reference: &str| {
+ styles.iter().find(|style| Values::of(style).self_id() == Some(reference)).or_else(|| {
+ let normalized = if reference.starts_with("ObjectStyle/") {
+ reference.to_owned()
+ } else {
+ format!("ObjectStyle/{}", crate::value::escape_id(reference.trim()))
+ };
+ styles.iter().find(|style| Values::of(style).self_id() == Some(normalized.as_str()))
+ })
+ };
+ let mut chain = Vec::new();
+ let mut next = reference.map(str::to_owned);
+ while let Some(id) = next {
+ let Some(style) = find(&id) else { break };
+ let self_id = Values::of(style).self_id().map(str::to_owned);
+ if chain.len() >= 16 || self_id.as_deref().is_some_and(|id| chain.iter().any(|entry: &El| Values::of(entry).self_id() == Some(id))) {
+ break;
+ }
+ chain.push(style.clone());
+ next = Values::of(style).prop("BasedOn").map(|base| {
+ let base = base.trim();
+ if base.starts_with("ObjectStyle/") { base.to_owned() } else { format!("ObjectStyle/{}", crate::value::escape_id(base)) }
+ });
+ }
+ if include_none
+ && !chain.iter().any(|style| Values::of(style).self_id() == Some("ObjectStyle/$ID/[None]"))
+ && let Some(none) = find("ObjectStyle/$ID/[None]")
+ {
+ chain.push(none.clone());
+ }
+ Self { chain }
+ }
+
+ /// The resolved style elements, nearest first.
+ pub fn styles(&self) -> &[El] {
+ &self.chain
+ }
+
+ /// Merges an item's child over the corresponding elements in the resolved style chain.
+ pub fn merged_child(&self, item: &El, name: &str) -> Option {
+ let category = match name {
+ "TransparencySetting" => Some("ObjectStyleObjectEffectsCategorySettings"),
+ "StrokeTransparencySetting" => Some("ObjectStyleStrokeEffectsCategorySettings"),
+ "FillTransparencySetting" => Some("ObjectStyleFillEffectsCategorySettings"),
+ "ContentTransparencySetting" => Some("ObjectStyleContentEffectsCategorySettings"),
+ _ => None,
+ };
+ let enabled = |effect: &str| {
+ let (Some(category), Some(flag)) = (category, effect_flag(effect)) else { return true };
+ self.chain.iter().find_map(|style| style.child(Local(category)).and_then(|c| Values::of(c).get(flag).map(str::to_owned))).as_deref()
+ != Some("false")
+ };
+ let mut result = None;
+ for style in self.chain.iter().rev() {
+ let Some(child) = style.child(Local(name)) else { continue };
+ let mut child = child.clone();
+ child.children.retain(|node| !matches!(node, Node::El(element) if !enabled(element.local())));
+ match &mut result {
+ Some(current) => overlay(current, &child, 0),
+ None => result = Some(child),
+ }
+ }
+ if let Some(child) = item.child(Local(name)) {
+ match &mut result {
+ Some(current) => overlay(current, child, 0),
+ None => result = Some(child.clone()),
+ }
+ }
+ result
+ }
+
+ /// Returns the drop-shadow and feather records enabled by the style's effect category.
+ pub fn enabled_shadow_feather(&self) -> Option {
+ let category = self.chain.iter().find_map(|style| style.child(Local("ObjectStyleObjectEffectsCategorySettings")));
+ let setting = |name: &str| self.chain.iter().find_map(|style| style.child(Local("TransparencySetting"))?.child(Local(name)).cloned());
+ let mut result = El::new("TransparencySetting");
+ let mut any = false;
+ for (name, flag) in [("DropShadowSetting", "EnableDropShadow"), ("FeatherSetting", "EnableFeather")] {
+ let element = setting(name);
+ let on = match category {
+ Some(category) => Values::of(category).get(flag) == Some("true"),
+ None => element.as_ref().and_then(|element| Values::of(element).get("Mode").map(str::to_owned)).is_some_and(|mode| mode != "None"),
+ };
+ any |= on;
+ if let (true, Some(element)) = (on, element) {
+ result.push(element);
+ }
+ }
+ any.then_some(result)
+ }
+}
+
+fn effect_flag(effect: &str) -> Option<&'static str> {
+ Some(match effect {
+ "BlendingSetting" => "EnableTransparency",
+ "DropShadowSetting" => "EnableDropShadow",
+ "FeatherSetting" => "EnableFeather",
+ "InnerShadowSetting" => "EnableInnerShadow",
+ "OuterGlowSetting" => "EnableOuterGlow",
+ "InnerGlowSetting" => "EnableInnerGlow",
+ "BevelAndEmbossSetting" => "EnableBevelEmboss",
+ "SatinSetting" => "EnableSatin",
+ "DirectionalFeatherSetting" => "EnableDirectionalFeather",
+ "GradientFeatherSetting" => "EnableGradientFeather",
+ _ => return None,
+ })
+}
+
+fn overlay(base: &mut El, top: &El, depth: usize) {
+ if depth > 32 {
+ *base = top.clone();
+ return;
+ }
+ for (key, value) in &top.attrs {
+ base.set_attr(key, value);
+ if let Some(Node::El(properties)) = base.children.iter_mut().find(|node| matches!(node, Node::El(el) if el.local() == "Properties")) {
+ properties.children.retain(|node| !matches!(node, Node::El(el) if el.local() == key));
+ }
+ }
+ if let Some(properties) = top.child(Local("Properties")) {
+ let names: Vec<&str> = properties.elements().map(El::local).collect();
+ base.attrs.retain(|(key, _)| !names.contains(&key.as_str()));
+ }
+ let has_text = top.children.iter().any(|node| matches!(node, Node::Text(text) | Node::CData(text) if !text.trim().is_empty()));
+ if has_text {
+ base.children.retain(|node| !matches!(node, Node::Text(_) | Node::CData(_)));
+ }
+ let mut seen: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
+ for node in &top.children {
+ match node {
+ Node::El(child) => {
+ let index = seen.entry(child.local()).or_insert(0);
+ let slot = base
+ .children
+ .iter_mut()
+ .filter_map(|node| match node {
+ Node::El(el) if el.local() == child.local() => Some(el),
+ _ => None,
+ })
+ .nth(*index);
+ *index += 1;
+ match slot {
+ Some(slot) => overlay(slot, child, depth + 1),
+ None => base.children.push(node.clone()),
+ }
+ }
+ Node::Text(_) | Node::CData(_) if has_text => base.children.push(node.clone()),
+ Node::Text(_) | Node::CData(_) | Node::Comment(_) | Node::Pi { .. } => {}
+ }
+ }
+}
diff --git a/crates/idml/src/model/geometry.rs b/crates/idml/src/model/geometry.rs
index 02b00ddaf..804774291 100644
--- a/crates/idml/src/model/geometry.rs
+++ b/crates/idml/src/model/geometry.rs
@@ -5,6 +5,19 @@ use craft_xml::{El, Local};
use crate::value::{nums, point_str};
+/// Why a bounded path geometry was refused.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum PathGeometryError {
+ #[error("too many points")]
+ TooManyPoints,
+ #[error("point without an anchor")]
+ MissingAnchor,
+ #[error("malformed point")]
+ MalformedPoint,
+ #[error("non-finite point")]
+ NonFinitePoint,
+}
+
/// Most points one geometry keeps by default; points past it are dropped.
pub const MAX_PATH_POINTS: usize = 1_000_000;
@@ -84,6 +97,45 @@ impl PathGeometry {
PathGeometry { paths }
}
+ /// Parse a path geometry without silently discarding malformed points, keeping at most
+ /// `max` point elements. Missing direction handles default to the anchor.
+ pub fn try_from_el_capped(pg: &El, max: usize) -> Result {
+ let point = |value: Option<&str>, required: bool| -> Result, PathGeometryError> {
+ let Some(value) = value else {
+ return if required { Err(PathGeometryError::MissingAnchor) } else { Ok(None) };
+ };
+ let mut nums = value.split_whitespace();
+ let Some(x) = nums.next().and_then(|n| n.parse::().ok()) else { return Err(PathGeometryError::MalformedPoint) };
+ let Some(y) = nums.next().and_then(|n| n.parse::().ok()) else { return Err(PathGeometryError::MalformedPoint) };
+ if nums.next().is_some() {
+ return Err(PathGeometryError::MalformedPoint);
+ }
+ if !(x.is_finite() && y.is_finite()) {
+ return Err(PathGeometryError::NonFinitePoint);
+ }
+ Ok(Some([x, y]))
+ };
+ let mut count = 0usize;
+ let mut paths = Vec::new();
+ for geometry in pg.children(Local("GeometryPathType")) {
+ let mut points = Vec::new();
+ if let Some(array) = geometry.child(Local("PathPointArray")) {
+ for el in array.children(Local("PathPointType")) {
+ count = count.saturating_add(1);
+ if count > max {
+ return Err(PathGeometryError::TooManyPoints);
+ }
+ let anchor = point(el.attr("Anchor"), true)?.ok_or(PathGeometryError::MissingAnchor)?;
+ let left = point(el.attr("LeftDirection"), false)?.unwrap_or(anchor);
+ let right = point(el.attr("RightDirection"), false)?.unwrap_or(anchor);
+ points.push(PathPoint { anchor, left, right });
+ }
+ }
+ paths.push(SubPath { open: geometry.attr("PathOpen") == Some("true"), points });
+ }
+ Ok(PathGeometry { paths })
+ }
+
/// The `PathGeometry` element.
pub fn to_el(&self) -> El {
let mut pg = El::new("PathGeometry");
diff --git a/crates/idml/src/model/mod.rs b/crates/idml/src/model/mod.rs
index 049f10175..a4560b22e 100644
--- a/crates/idml/src/model/mod.rs
+++ b/crates/idml/src/model/mod.rs
@@ -12,20 +12,44 @@
//! Nodes are built from the elements [`crate::Package::document`] gives ([`Spread::from_el`],
//! [`spreads`]) and written back with `to_el`, then [`crate::part_xml`].
+mod document;
+mod effects;
mod geometry;
+mod preferences;
mod resources;
mod spread;
mod story;
-pub use geometry::{MAX_PATH_POINTS, PathGeometry, PathPoint, SubPath};
-pub use resources::{
- ColorGroup, ColorSpace, GradientStop, StrokeStyle, StrokeStyleKind, Style, StyleGroup, StyleKind, StyleNode, Swatch, SwatchKind, color_groups,
- named, preference, stroke_styles, style_groups, swatches,
-};
-pub use spread::{Graphic, GraphicChild, GraphicKind, Guide, ItemChild, ItemKind, Link, Page, PageChild, PageItem, Spread, SpreadChild, spreads};
-pub use story::{Ace, CONTAINERS, Cell, Container, ContentPart, Range, Story, Table, TableChild, TextNode, stories};
-
use craft_xml::{El, Local, Node};
+pub use document::{
+ CellStyleValues, ConditionValues, CrossReferenceBuildingBlock, CrossReferenceFormatValues, EpubSplitValues, ModelDocument, NumberingListValues,
+ TableStyleValues, TextDateKind, TextVariableKind, TextVariableValues, TocStyleEntryValues, TocStyleValues, TopLevelKind, TopLevelNode,
+};
+pub use effects::{
+ DirectionalFeatherValues, DropShadowValues, FeatherValues, GradientFeatherValues, ObjectStyleStack, OpacityStopValues, TransparencySetting,
+};
+pub use geometry::{MAX_PATH_POINTS, PathGeometry, PathGeometryError, PathPoint, SubPath};
+pub use preferences::{DocumentPreferences, FootnotePreferences, GridPreferences, TextFramePreferences};
+pub use resources::{
+ CharacterAppearanceValues, CharacterSpecialValues, CharacterTypographyValues, CjkCharacterValues, CjkParagraphValues, ColorDefinition,
+ ColorGroup, ColorGroupDefinition, ColorGroupMember, ColorSpace, CompositeFontDefinition, CompositeFontEntryDefinition, EpubExportTagMap,
+ FontDefinition, FontFamilyDefinition, FontsPart, GradientDefinition, GradientStop, GradientStopDefinition, GradientStopValue, GraphicPart,
+ GrepStyleValue, Ink, InkDefinition, MojikumiRow, NestedLineStyleValue, NestedStyleValue, NestedStyleValues, ObjectStyleValues,
+ OpenTypeFeatureValues, ParagraphAlignmentValues, ParagraphBoxValues, ParagraphFlowValues, ParagraphListValues, ParagraphSpanValues, RubyValues,
+ StrokeDefinition, StrokeStyle, StrokeStyleKind, Style, StyleGroup, StyleGroupWriter, StyleKind, StyleNode, Swatch, SwatchKind, TabStopValues,
+ TextDecorationValues, TintDefinition, color_groups, inks, named, preference, stroke_styles, style_groups, swatches,
+};
+pub use spread::{
+ BaselineFrameGridOption, BaselineFrameGridRelative, ClippingPathValues, FrameFittingOption, Graphic, GraphicChild, GraphicKind,
+ GraphicLayerOptions, Guide, ItemChild, ItemKind, Link, MarginPreference, Page, PageChild, PageItem, PdfAttribute, Spread, SpreadChild, TextPath,
+ TextWrapPreference, spreads,
+};
+pub use story::{
+ Ace, AnchoredObjectSetting, AnchoredObjectValues, CONTAINERS, Cell, CellOptions, Container, ContainerKind, ContentPart, CrossReferenceSource,
+ IndexCrossReferenceValues, IndexDocument, IndexReference, IndexTopicPath, IndexValues, PageReference, Range, SavedCrossReference,
+ SavedCrossReferencePart, Story, StoryAnchor, StoryPreference, Table, TableChild, TableColumn, TableLayout, TableRow, TextNode, TrackedChangeKind,
+ stories,
+};
use crate::value::{matrix, nums};
@@ -43,6 +67,157 @@ pub struct Values {
pub properties: Vec,
}
+/// Raw IDML stroke values before the caller maps swatches and stroke styles into its model.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct StrokeValues {
+ pub weight: Option,
+ pub color: Option,
+ pub tint: Option,
+ pub kind: Option,
+ pub alignment: Option,
+ pub cap: Option,
+ pub join: Option,
+ pub miter_limit: Option,
+ pub start: Option,
+ pub end: Option,
+ pub gap_color: Option,
+ pub gap_tint: Option,
+ pub overprint: Option,
+ pub gap_overprint: Option,
+}
+
+impl StrokeValues {
+ /// Reads stroke properties from elements in precedence order (item first, then nearer styles).
+ pub fn from_elements(elements: &[&El]) -> StrokeValues {
+ let mut result = StrokeValues::default();
+ for el in elements {
+ let values = Values::of(el);
+ let num_attr = |key: &str| values.get(key).and_then(|value| value.parse::().ok()).filter(|value| value.is_finite());
+ let bool_attr = |key: &str| match values.get(key) {
+ Some("true") => Some(true),
+ Some("false") => Some(false),
+ _ => None,
+ };
+ if result.weight.is_none() {
+ result.weight = num_attr("StrokeWeight");
+ }
+ if result.color.is_none() {
+ result.color = values.get("StrokeColor").map(str::to_owned);
+ }
+ if result.tint.is_none() {
+ result.tint = num_attr("StrokeTint");
+ }
+ if result.kind.is_none() {
+ result.kind = values.get("StrokeType").map(str::to_owned);
+ }
+ if result.alignment.is_none() {
+ result.alignment = values.get("StrokeAlignment").map(str::to_owned);
+ }
+ if result.cap.is_none() {
+ result.cap = values.get("EndCap").map(str::to_owned);
+ }
+ if result.join.is_none() {
+ result.join = values.get("EndJoin").map(str::to_owned);
+ }
+ if result.miter_limit.is_none() {
+ result.miter_limit = num_attr("MiterLimit");
+ }
+ if result.start.is_none() {
+ result.start = values.get("LeftLineEnd").map(str::to_owned);
+ }
+ if result.end.is_none() {
+ result.end = values.get("RightLineEnd").map(str::to_owned);
+ }
+ if result.gap_color.is_none() {
+ result.gap_color = values.get("GapColor").map(str::to_owned);
+ }
+ if result.gap_tint.is_none() {
+ result.gap_tint = num_attr("GapTint");
+ }
+ if result.overprint.is_none() {
+ result.overprint = bool_attr("OverprintStroke");
+ }
+ if result.gap_overprint.is_none() {
+ result.gap_overprint = bool_attr("OverprintGap");
+ }
+ }
+ result
+ }
+}
+
+/// Raw fill properties before a caller resolves swatch names to its own colour model.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct FillValues {
+ pub color: Option,
+ pub tint: Option,
+ pub overprint: Option,
+}
+
+impl FillValues {
+ /// Reads fill attributes in precedence order (item first, then nearer styles).
+ pub fn from_elements(elements: &[&El]) -> FillValues {
+ let mut result = FillValues::default();
+ for el in elements {
+ let values = Values::of(el);
+ if result.color.is_none() {
+ result.color = values.get("FillColor").map(str::to_owned);
+ }
+ if result.tint.is_none() {
+ result.tint = values.get("FillTint").and_then(|value| value.parse::().ok());
+ }
+ if result.overprint.is_none() {
+ result.overprint = match values.get("OverprintFill") {
+ Some("true") => Some(true),
+ Some("false") => Some(false),
+ _ => None,
+ };
+ }
+ }
+ result
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct AlternatingFillValues {
+ pub first_count: Option,
+ pub first_color: Option,
+ pub first_tint: Option,
+ pub next_count: Option,
+ pub next_color: Option,
+ pub next_tint: Option,
+ pub skip_first: Option,
+ pub skip_last: Option,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct AlternatingStrokeValues {
+ pub first_count: Option,
+ pub next_count: Option,
+ pub first: StrokeValues,
+ pub next: StrokeValues,
+ pub skip_first: Option,
+ pub skip_last: Option,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct TableOptions {
+ pub direction: Option,
+ pub header_rows: Option,
+ pub footer_rows: Option,
+ pub applied_style: Option,
+ pub space_before: Option,
+ pub space_after: Option,
+ pub repeat_header: bool,
+ pub repeat_footer: bool,
+ pub borders: [StrokeValues; 4],
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct CornerValues {
+ pub option: Option,
+ pub radius: Option,
+}
+
impl Values {
/// The attributes and `` of `el`.
pub fn of(el: &El) -> Values {
@@ -104,6 +279,13 @@ impl Values {
self.prop(key).and_then(|v| v.trim().parse::().ok()).filter(|v| v.is_finite())
}
+ /// A two-number value (for properties such as `GradientFillStart`), bounded to three tokens.
+ pub fn pair(&self, key: &str) -> Option<[f64; 2]> {
+ let source = self.prop(key)?;
+ let values: Vec = source.split_whitespace().take(3).filter_map(|v| v.parse::().ok()).collect();
+ <[f64; 2]>::try_from(values).ok().filter(|v| v.iter().all(|n| n.is_finite()))
+ }
+
/// `true` or `false`; anything else counts as absent.
pub fn boolean(&self, key: &str) -> Option {
match self.prop(key)?.trim() {
@@ -154,6 +336,77 @@ impl Values {
}
el
}
+
+ /// Read an IDML stroke attribute family such as `TopEdgeStrokeWeight` or
+ /// `StartRowStrokeColor`.
+ pub fn stroke_values(&self, prefix: &str) -> StrokeValues {
+ StrokeValues {
+ weight: self.num(&format!("{prefix}StrokeWeight")).map(|v| v.max(0.0)),
+ color: self.value(&format!("{prefix}StrokeColor")),
+ tint: self.num(&format!("{prefix}StrokeTint")),
+ kind: self.value(&format!("{prefix}StrokeType")),
+ gap_color: self.value(&format!("{prefix}StrokeGapColor")),
+ gap_tint: self.num(&format!("{prefix}StrokeGapTint")),
+ ..StrokeValues::default()
+ }
+ }
+
+ pub fn alternating_fill_values(&self, kind: &str) -> AlternatingFillValues {
+ let num = |key: &str| self.num(key).map(|v| v.max(0.0));
+ AlternatingFillValues {
+ first_count: num(&format!("Start{kind}FillCount")),
+ first_color: self.value(&format!("Start{kind}FillColor")),
+ first_tint: self.num(&format!("Start{kind}FillTint")),
+ next_count: num(&format!("End{kind}FillCount")),
+ next_color: self.value(&format!("End{kind}FillColor")),
+ next_tint: self.num(&format!("End{kind}FillTint")),
+ skip_first: num(&format!("SkipFirstAlternatingFill{kind}s")),
+ skip_last: num(&format!("SkipLastAlternatingFill{kind}s")),
+ }
+ }
+
+ pub fn alternating_stroke_values(&self, kind: &str) -> AlternatingStrokeValues {
+ let num = |key: &str| self.num(key).map(|v| v.max(0.0));
+ let mut next = self.stroke_values(&format!("End{kind}"));
+ // IDML writes this one table-column value as LineStyle rather than StrokeType.
+ if kind == "Column" {
+ next.kind = self.value("EndColumnLineStyle").or(next.kind);
+ }
+ AlternatingStrokeValues {
+ first_count: num(&format!("Start{kind}StrokeCount")),
+ next_count: num(&format!("End{kind}StrokeCount")),
+ first: self.stroke_values(&format!("Start{kind}")),
+ next,
+ skip_first: num(&format!("SkipFirstAlternatingStroke{kind}s")),
+ skip_last: num(&format!("SkipLastAlternatingStroke{kind}s")),
+ }
+ }
+
+ pub fn table_options(&self) -> TableOptions {
+ TableOptions {
+ direction: self.value("TableDirection"),
+ header_rows: self.num("HeaderRowCount"),
+ footer_rows: self.num("FooterRowCount"),
+ applied_style: self.value("AppliedTableStyle"),
+ space_before: self.num("SpaceBefore"),
+ space_after: self.num("SpaceAfter"),
+ repeat_header: self.get("HeaderBehavior") != Some("RepeatOnce"),
+ repeat_footer: self.get("FooterBehavior") != Some("RepeatOnce"),
+ borders: [
+ self.stroke_values("TopBorder"),
+ self.stroke_values("LeftBorder"),
+ self.stroke_values("BottomBorder"),
+ self.stroke_values("RightBorder"),
+ ],
+ }
+ }
+
+ pub fn corner_values(&self, corner: &str) -> CornerValues {
+ CornerValues {
+ option: self.value(&format!("{corner}CornerOption")).or_else(|| self.value("CornerOption")),
+ radius: self.num(&format!("{corner}CornerRadius")).or_else(|| self.num("CornerRadius")),
+ }
+ }
}
/// `el` without its indentation: the whitespace-only text between the children of an element
diff --git a/crates/idml/src/model/preferences.rs b/crates/idml/src/model/preferences.rs
new file mode 100644
index 000000000..b32317cbd
--- /dev/null
+++ b/crates/idml/src/model/preferences.rs
@@ -0,0 +1,420 @@
+//! Typed views of IDML's reusable text-frame preference grammar.
+
+use craft_xml::El;
+
+use super::Values;
+
+/// Parsed values from IDML `DocumentPreference` elements.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct DocumentPreferences {
+ pub overprint_black: Option,
+ pub page_width: Option,
+ pub page_height: Option,
+ pub facing_pages: Option,
+ pub page_binding: Option,
+ pub bleed: [Option; 4],
+ pub slug: [Option; 4],
+ pub intent: Option,
+ pub primary_text_frame: Option,
+ pub column_guides_locked: Option,
+}
+
+impl DocumentPreferences {
+ /// Reads the document-level page, bleed, slug, and intent values.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ Self {
+ overprint_black: values.get("OverprintBlack").map(|value| value != "false"),
+ page_width: values.num("PageWidth"),
+ page_height: values.num("PageHeight"),
+ facing_pages: values.boolean("FacingPages"),
+ page_binding: values.prop("PageBinding"),
+ bleed: [
+ values.num("DocumentBleedTopOffset"),
+ values.num("DocumentBleedBottomOffset"),
+ values.num("DocumentBleedInsideOrLeftOffset"),
+ values.num("DocumentBleedOutsideOrRightOffset"),
+ ],
+ slug: [
+ values.num("SlugTopOffset"),
+ values.num("SlugBottomOffset"),
+ values.num("SlugInsideOrLeftOffset"),
+ values.num("SlugRightOrOutsideOffset"),
+ ],
+ intent: values.prop("Intent"),
+ primary_text_frame: values.boolean("CreatePrimaryTextFrame"),
+ column_guides_locked: values.boolean("ColumnGuideLocked"),
+ }
+ }
+
+ /// Full canonical attributes for an exported IDML `DocumentPreference`.
+ pub fn to_export_attrs(&self) -> Vec<(String, String)> {
+ let mut attrs = Vec::new();
+ for (key, value) in [("PageHeight", self.page_height), ("PageWidth", self.page_width)] {
+ if let Some(value) = value {
+ attrs.push((key.into(), crate::value::num(value)));
+ }
+ }
+ attrs.push(("PagesPerDocument".into(), "1".into()));
+ if let Some(value) = self.facing_pages {
+ attrs.push(("FacingPages".into(), if value { "true" } else { "false" }.into()));
+ }
+ for (key, value) in [
+ ("DocumentBleedTopOffset", self.bleed[0]),
+ ("DocumentBleedBottomOffset", self.bleed[1]),
+ ("DocumentBleedInsideOrLeftOffset", self.bleed[2]),
+ ("DocumentBleedOutsideOrRightOffset", self.bleed[3]),
+ ] {
+ if let Some(value) = value {
+ attrs.push((key.into(), crate::value::num(value)));
+ }
+ }
+ if self.bleed.iter().all(Option::is_some) {
+ attrs.push((
+ "DocumentBleedUniformSize".into(),
+ bool_string(self.bleed.iter().flatten().all(|value| *value == self.bleed[0].unwrap_or_default())),
+ ));
+ }
+ for (key, value) in [
+ ("SlugTopOffset", self.slug[0]),
+ ("SlugBottomOffset", self.slug[1]),
+ ("SlugInsideOrLeftOffset", self.slug[2]),
+ ("SlugRightOrOutsideOffset", self.slug[3]),
+ ] {
+ if let Some(value) = value {
+ attrs.push((key.into(), crate::value::num(value)));
+ }
+ }
+ if self.slug.iter().all(Option::is_some) {
+ attrs.push((
+ "DocumentSlugUniformSize".into(),
+ bool_string(self.slug.iter().flatten().all(|value| *value == self.slug[0].unwrap_or_default())),
+ ));
+ }
+ attrs.push(("PreserveLayoutWhenShuffling".into(), "true".into()));
+ attrs.push(("AllowPageShuffle".into(), "true".into()));
+ if let Some(value) = self.overprint_black {
+ attrs.push(("OverprintBlack".into(), bool_string(value)));
+ }
+ if let Some(value) = &self.page_binding {
+ attrs.push(("PageBinding".into(), value.clone()));
+ }
+ attrs.push(("ColumnDirection".into(), "Horizontal".into()));
+ if let Some(value) = &self.intent {
+ attrs.push(("Intent".into(), value.clone()));
+ }
+ if let Some(value) = self.primary_text_frame {
+ attrs.push(("CreatePrimaryTextFrame".into(), bool_string(value)));
+ }
+ if let Some(value) = self.column_guides_locked {
+ attrs.push(("ColumnGuideLocked".into(), bool_string(value)));
+ }
+ if let Some(value) = self.primary_text_frame {
+ attrs.push(("MasterTextFrame".into(), bool_string(value)));
+ }
+ attrs.push(("SnippetImportUsesOriginalLocation".into(), "false".into()));
+ attrs
+ }
+}
+
+/// Parsed document and baseline-grid preference values.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct GridPreferences {
+ pub baseline_start: Option,
+ pub baseline_division: Option,
+ pub baseline_view_threshold: Option,
+ pub baseline_relative_option: Option,
+ pub horizontal_division: Option,
+ pub vertical_division: Option,
+ pub horizontal_subdivision: Option,
+ pub vertical_subdivision: Option,
+ pub grids_in_back: Option,
+}
+
+/// Parsed values from IDML `FootnoteOption` elements.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct FootnotePreferences {
+ pub start_at: Option,
+ pub prefix: Option,
+ pub suffix: Option,
+ pub paragraph_style: Option,
+ pub marker_style: Option,
+ pub separator: Option,
+ pub space_between: Option,
+ pub space_before: Option,
+ pub first_baseline: Option,
+ pub first_baseline_minimum: Option,
+ pub span_columns: Option,
+ pub rule_on: Option,
+ pub rule_weight: Option,
+ pub rule_tint: Option,
+ pub rule_left_indent: Option,
+ pub rule_width: Option,
+ pub rule_offset: Option,
+ pub rule_color: Option,
+ pub numbering_style: Option,
+ pub restart_numbering: Option,
+ pub show_prefix_suffix: Option,
+ pub marker_positioning: Option,
+}
+
+impl FootnotePreferences {
+ /// Reads footnote preference attributes and properties from IDML.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ Self {
+ start_at: values.num("StartAt"),
+ prefix: values.get("Prefix").map(str::to_owned),
+ suffix: values.get("Suffix").map(str::to_owned),
+ paragraph_style: values.get("FootnoteTextStyle").map(str::to_owned),
+ marker_style: values.get("FootnoteMarkerStyle").map(str::to_owned),
+ separator: values.get("SeparatorText").map(str::to_owned),
+ space_between: values.num("SpaceBetween"),
+ space_before: values.num("Spacer"),
+ first_baseline: values.prop("FootnoteFirstBaselineOffset"),
+ first_baseline_minimum: values.num("FootnoteMinimumFirstBaselineOffset"),
+ span_columns: values.boolean("EnableStraddling"),
+ rule_on: values.boolean("RuleOn"),
+ rule_weight: values.num("RuleLineWeight"),
+ rule_tint: values.num("RuleTint"),
+ rule_left_indent: values.num("RuleLeftIndent"),
+ rule_width: values.num("RuleWidth"),
+ rule_offset: values.num("RuleOffset"),
+ rule_color: values.prop("RuleColor"),
+ numbering_style: values.prop("FootnoteNumberingStyle"),
+ restart_numbering: values.prop("RestartNumbering"),
+ show_prefix_suffix: values.prop("ShowPrefixSuffix"),
+ marker_positioning: values.prop("MarkerPositioning"),
+ }
+ }
+
+ /// Writes one canonical IDML `FootnoteOption` using caller-resolved style, colour, and enum
+ /// references.
+ pub fn to_el(&self) -> El {
+ let mut el = El::new("FootnoteOption")
+ .with_attr("StartAt", crate::value::num(self.start_at.unwrap_or(1.0)))
+ .with_attr("Prefix", self.prefix.as_deref().unwrap_or(""))
+ .with_attr("Suffix", self.suffix.as_deref().unwrap_or(""))
+ .with_attr("FootnoteTextStyle", self.paragraph_style.as_deref().unwrap_or("$ID/NormalParagraphStyle"))
+ .with_attr("FootnoteMarkerStyle", self.marker_style.as_deref().unwrap_or("$ID/[None]"))
+ .with_attr("SeparatorText", self.separator.as_deref().unwrap_or(""))
+ .with_attr("SpaceBetween", crate::value::num(self.space_between.unwrap_or(0.0)))
+ .with_attr("Spacer", crate::value::num(self.space_before.unwrap_or(0.0)))
+ .with_attr("FootnoteFirstBaselineOffset", self.first_baseline.as_deref().unwrap_or("Ascent"))
+ .with_attr("FootnoteMinimumFirstBaselineOffset", crate::value::num(self.first_baseline_minimum.unwrap_or(0.0)))
+ .with_attr("EnableStraddling", bool_text(self.span_columns.unwrap_or(false)))
+ .with_attr("RuleOn", bool_text(self.rule_on.unwrap_or(true)))
+ .with_attr("RuleLineWeight", crate::value::num(self.rule_weight.unwrap_or(1.0)))
+ .with_attr("RuleTint", crate::value::num(self.rule_tint.unwrap_or(1.0)))
+ .with_attr("RuleLeftIndent", crate::value::num(self.rule_left_indent.unwrap_or(0.0)))
+ .with_attr("RuleWidth", crate::value::num(self.rule_width.unwrap_or(72.0)))
+ .with_attr("RuleOffset", crate::value::num(self.rule_offset.unwrap_or(0.0)));
+ let mut properties = El::new("Properties");
+ for (name, value) in [
+ ("FootnoteNumberingStyle", self.numbering_style.as_deref().unwrap_or("Arabic")),
+ ("RestartNumbering", self.restart_numbering.as_deref().unwrap_or("DontRestart")),
+ ("ShowPrefixSuffix", self.show_prefix_suffix.as_deref().unwrap_or("NoPrefixSuffix")),
+ ("MarkerPositioning", self.marker_positioning.as_deref().unwrap_or("Superscript")),
+ ] {
+ properties.push(El::new(name).with_attr("type", "enumeration").with_text(value));
+ }
+ properties.push(El::new("RuleColor").with_attr("type", "object").with_text(self.rule_color.as_deref().unwrap_or("Swatch/Black")));
+ el.push(properties);
+ el
+ }
+}
+
+impl GridPreferences {
+ /// Reads baseline and document-grid values.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ Self {
+ baseline_start: values.num("BaselineStart"),
+ baseline_division: values.num("BaselineDivision"),
+ baseline_view_threshold: values.num("BaselineViewThreshold"),
+ baseline_relative_option: values.prop("BaselineGridRelativeOption"),
+ horizontal_division: values.num("HorizontalGridlineDivision"),
+ vertical_division: values.num("VerticalGridlineDivision"),
+ horizontal_subdivision: values.num("HorizontalGridSubdivision"),
+ vertical_subdivision: values.num("VerticalGridSubdivision"),
+ grids_in_back: values.boolean("GridsInBack"),
+ }
+ }
+
+ /// IDML attributes represented by this grid preference record.
+ pub fn to_attrs(&self) -> Vec<(String, String)> {
+ let mut attrs = Vec::new();
+ for (key, value) in [
+ ("HorizontalGridlineDivision", self.horizontal_division),
+ ("VerticalGridlineDivision", self.vertical_division),
+ ("HorizontalGridSubdivision", self.horizontal_subdivision),
+ ("VerticalGridSubdivision", self.vertical_subdivision),
+ ] {
+ if let Some(value) = value {
+ attrs.push((key.into(), crate::value::num(value)));
+ }
+ }
+ if let Some(value) = self.grids_in_back {
+ attrs.push(("GridsInBack".into(), if value { "true" } else { "false" }.into()));
+ }
+ for (key, value) in [
+ ("BaselineStart", self.baseline_start),
+ ("BaselineDivision", self.baseline_division),
+ ("BaselineViewThreshold", self.baseline_view_threshold),
+ ] {
+ if let Some(value) = value {
+ attrs.push((key.into(), crate::value::num(value)));
+ }
+ }
+ if let Some(value) = self.baseline_relative_option.as_deref() {
+ attrs.push(("BaselineGridRelativeOption".into(), value.into()));
+ }
+ attrs
+ }
+}
+
+fn bool_string(value: bool) -> String {
+ if value { "true" } else { "false" }.into()
+}
+
+/// Parsed `TextFramePreference` values in nearest-to-farthest precedence order.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct TextFramePreferences {
+ pub column_count: Option,
+ pub column_gutter: Option,
+ pub fixed_column_width: Option,
+ pub fixed_width: bool,
+ pub flexible_width: bool,
+ pub balance_columns: bool,
+ pub inset: Option<[f64; 4]>,
+ pub vertical_justification: Option,
+ pub vertical_threshold: Option,
+ pub first_baseline: Option,
+ pub minimum_first_baseline: Option,
+ pub ignore_wrap: bool,
+ pub auto_sizing_type: Option,
+ pub auto_sizing_reference: Option,
+ pub use_minimum_height: bool,
+ pub minimum_height: Option,
+ pub use_minimum_width: bool,
+ pub minimum_width: Option,
+ pub no_line_breaks: bool,
+ pub column_rule_override: bool,
+ pub column_rule_width: Option,
+ pub column_rule_tint: Option,
+ pub column_rule_offset: Option,
+ pub column_rule_top_inset: Option,
+ pub column_rule_bottom_inset: Option,
+}
+
+impl TextFramePreferences {
+ /// Reads preference levels nearest first. A malformed explicit value still masks an inherited
+ /// one, matching IDML's item-over-object-style precedence.
+ pub fn from_elements(elements: &[&El]) -> Self {
+ let prop = |key: &str| elements.iter().find_map(|el| Values::of(el).prop(key));
+ let num = |key: &str| prop(key).and_then(|v| v.trim().parse::().ok()).filter(|v| v.is_finite());
+ let boolean = |key: &str| matches!(prop(key).as_deref().map(str::trim), Some("true"));
+ Self {
+ column_count: num("TextColumnCount"),
+ column_gutter: num("TextColumnGutter"),
+ fixed_column_width: num("TextColumnFixedWidth"),
+ fixed_width: boolean("UseFixedColumnWidth"),
+ flexible_width: boolean("UseFlexibleColumnWidth"),
+ balance_columns: boolean("VerticalBalanceColumns"),
+ inset: inset(elements),
+ vertical_justification: prop("VerticalJustification"),
+ vertical_threshold: num("VerticalThreshold"),
+ first_baseline: prop("FirstBaselineOffset"),
+ minimum_first_baseline: num("MinimumFirstBaselineOffset"),
+ ignore_wrap: boolean("IgnoreWrap"),
+ auto_sizing_type: prop("AutoSizingType"),
+ auto_sizing_reference: prop("AutoSizingReferencePoint"),
+ use_minimum_height: boolean("UseMinimumHeightForAutoSizing"),
+ minimum_height: num("MinimumHeightForAutoSizing"),
+ use_minimum_width: boolean("UseMinimumWidthForAutoSizing"),
+ minimum_width: num("MinimumWidthForAutoSizing"),
+ no_line_breaks: boolean("UseNoLineBreaksForAutoSizing"),
+ column_rule_override: boolean("ColumnRuleOverride"),
+ column_rule_width: num("ColumnRuleStrokeWidth"),
+ column_rule_tint: num("ColumnRuleStrokeTint"),
+ column_rule_offset: num("ColumnRuleOffset"),
+ column_rule_top_inset: num("ColumnRuleTopInset"),
+ column_rule_bottom_inset: num("ColumnRuleBottomInset"),
+ }
+ }
+
+ /// Writes one IDML `TextFramePreference`, including its inset list and column-rule
+ /// properties. Enumeration strings are supplied by the caller because they are model policy.
+ pub fn to_el(&self, column_rule_color: &str) -> El {
+ use crate::value::num;
+
+ let mut inset = El::new("InsetSpacing").with_attr("type", "list");
+ for value in self.inset.unwrap_or([0.0; 4]) {
+ inset.push(El::new("ListItem").with_attr("type", "unit").with_text(num(value)));
+ }
+ let el = El::new("TextFramePreference")
+ .with_attr("TextColumnCount", num(self.column_count.unwrap_or(1.0).max(1.0)))
+ .with_attr("TextColumnGutter", num(self.column_gutter.unwrap_or(0.0)))
+ .with_attr("UseFixedColumnWidth", bool_text(self.fixed_width))
+ .with_attr("UseFlexibleColumnWidth", bool_text(self.flexible_width))
+ .with_attr("VerticalBalanceColumns", bool_text(self.balance_columns))
+ .with_attr("FirstBaselineOffset", self.first_baseline.as_deref().unwrap_or("Ascent"))
+ .with_attr("MinimumFirstBaselineOffset", num(self.minimum_first_baseline.unwrap_or(0.0)))
+ .with_attr("VerticalJustification", self.vertical_justification.as_deref().unwrap_or("TopAlign"))
+ .with_attr("VerticalThreshold", num(self.vertical_threshold.unwrap_or(0.0)))
+ .with_attr("IgnoreWrap", bool_text(self.ignore_wrap))
+ .with_attr("AutoSizingType", self.auto_sizing_type.as_deref().unwrap_or("Off"))
+ .with_attr("AutoSizingReferencePoint", self.auto_sizing_reference.as_deref().unwrap_or("CenterPoint"))
+ .with_attr("UseMinimumHeightForAutoSizing", bool_text(self.use_minimum_height))
+ .with_attr("MinimumHeightForAutoSizing", num(self.minimum_height.unwrap_or(0.0)))
+ .with_attr("UseMinimumWidthForAutoSizing", bool_text(self.use_minimum_width))
+ .with_attr("MinimumWidthForAutoSizing", num(self.minimum_width.unwrap_or(0.0)))
+ .with_attr("UseNoLineBreaksForAutoSizing", bool_text(self.no_line_breaks));
+ let el = if let Some(width) = self.fixed_column_width.filter(|width| *width > 0.0) {
+ el.with_attr("TextColumnFixedWidth", num(width))
+ } else {
+ el
+ };
+ let el = el
+ .with_attr("ColumnRuleOverride", bool_text(self.column_rule_override))
+ .with_attr("ColumnRuleStrokeWidth", num(self.column_rule_width.unwrap_or(0.0)))
+ .with_attr("ColumnRuleStrokeColor", column_rule_color)
+ .with_attr("ColumnRuleStrokeTint", num(self.column_rule_tint.unwrap_or(0.0)))
+ .with_attr("ColumnRuleOffset", num(self.column_rule_offset.unwrap_or(0.0)))
+ .with_attr("ColumnRuleTopInset", num(self.column_rule_top_inset.unwrap_or(0.0)))
+ .with_attr("ColumnRuleBottomInset", num(self.column_rule_bottom_inset.unwrap_or(0.0)))
+ .with_attr("ColumnRuleInsetChainOverride", bool_text(self.column_rule_top_inset == self.column_rule_bottom_inset));
+ el.with_child(El::new("Properties").with_child(inset))
+ }
+}
+
+fn bool_text(value: bool) -> &'static str {
+ if value { "true" } else { "false" }
+}
+
+fn inset(elements: &[&El]) -> Option<[f64; 4]> {
+ let element = elements.iter().find(|el| Values::of(el).prop("InsetSpacing").is_some())?;
+ let values = Values::of(element);
+ let number = |s: &str| s.trim().parse::().ok().filter(|v| v.is_finite());
+ let Some(property) = values.prop_el("InsetSpacing") else {
+ return values.get("InsetSpacing").and_then(number).map(|v| [v; 4]);
+ };
+ let items: Vec<_> = property.elements().collect();
+ if property.attr("type") == Some("list") || items.iter().any(|item| item.local() == "ListItem") {
+ if items.len() != 4 {
+ return None;
+ }
+ let mut result = [0.0; 4];
+ for (slot, item) in result.iter_mut().zip(items) {
+ if item.local() != "ListItem" || item.elements().next().is_some() {
+ return None;
+ }
+ *slot = number(&item.deep_text())?;
+ }
+ Some(result)
+ } else if items.is_empty() {
+ number(&property.deep_text()).map(|v| [v; 4])
+ } else {
+ None
+ }
+}
diff --git a/crates/idml/src/model/resources.rs b/crates/idml/src/model/resources.rs
index 6a66f6f91..11a76b186 100644
--- a/crates/idml/src/model/resources.rs
+++ b/crates/idml/src/model/resources.rs
@@ -11,6 +11,1193 @@ fn others(el: &El) -> impl Iterator- {
el.elements().filter(|e| !e.is(Local("Properties")))
}
+/// Raw bullet and numbering properties on an IDML paragraph style or range.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ParagraphListValues {
+ pub applied_list: Option,
+ pub list_type: Option,
+ pub numbering_format: Option,
+ pub expression: Option,
+ pub separator: Option,
+ pub bullet_type: Option,
+ pub bullet_value: Option,
+ pub balance_ragged: Option,
+ pub level: Option,
+ pub bullet_character_style: Option,
+ pub numbering_character_style: Option,
+ pub bullet_alignment: Option,
+ pub numbering_alignment: Option,
+ pub restart_numbers: Option,
+ pub restart_after_level: Option,
+ pub restart_after_specific_level: bool,
+ pub numbering_continue: Option,
+ pub numbering_start_at: Option,
+ pub bullet_font: Option,
+ pub bullet_font_style: Option,
+}
+
+/// Paragraph border and shading values after the caller resolves model colours and enums.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ParagraphBoxValues {
+ pub shading_on: Option,
+ pub shading_color: Option,
+ pub shading_tint: Option,
+ pub shading_offsets: Option<[f64; 4]>,
+ pub shading_overprint: Option,
+ pub border_on: Option,
+ pub border_color: Option,
+ pub border_tint: Option,
+ pub border_weights: Option<[f64; 4]>,
+ pub border_offsets: Option<[f64; 4]>,
+ pub border_type: Option,
+ pub border_cap: Option,
+ pub border_join: Option,
+ pub border_corners: Option<[(String, f64); 4]>,
+ pub border_width: Option,
+ pub border_top: Option,
+ pub border_bottom: Option,
+ pub border_display_if_splits: Option,
+ pub border_merge: Option,
+ pub border_gap_color: Option,
+ pub border_gap_tint: Option,
+ pub border_overprint: Option,
+ pub border_gap_overprint: Option,
+ pub shading_width: Option,
+ pub shading_top: Option,
+ pub shading_bottom: Option,
+ pub shading_clip: Option,
+ pub shading_nonprinting: Option,
+ pub shading_corners: Option<[(String, f64); 4]>,
+}
+
+/// CJK paragraph composition settings read from an IDML style or text range.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct CjkParagraphValues {
+ pub kinsoku_hang: Option,
+ pub mojikumi: Option,
+ pub kinsoku_type: Option,
+ pub bunri_kinshi: Option,
+ pub rensuuji: Option,
+ pub treat_ideographic_space_as_space: Option,
+ pub kinsoku_set: Option,
+ pub auto_tcy: Option,
+ pub auto_tcy_include_roman: Option,
+ pub rotate_single_byte_characters: Option,
+ pub allow_arbitrary_hyphenation: Option,
+ pub grid_gyoudori: Option,
+ pub paragraph_gyoudori: Option,
+}
+
+impl CjkParagraphValues {
+ /// Reads CJK paragraph composition properties from IDML.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ let bounded_count = |key: &str| values.num(key).map(|value| value.clamp(0.0, 1000.0));
+ Self {
+ kinsoku_hang: values.prop("KinsokuHangType"),
+ mojikumi: values.prop("Mojikumi"),
+ kinsoku_type: values.prop("KinsokuType"),
+ bunri_kinshi: values.boolean("BunriKinshi"),
+ rensuuji: values.boolean("Rensuuji"),
+ treat_ideographic_space_as_space: values.boolean("TreatIdeographicSpaceAsSpace"),
+ kinsoku_set: values.prop("KinsokuSet"),
+ auto_tcy: bounded_count("AutoTcy"),
+ auto_tcy_include_roman: values.boolean("AutoTcyIncludeRoman"),
+ rotate_single_byte_characters: values.boolean("RotateSingleByteCharacters"),
+ allow_arbitrary_hyphenation: values.boolean("AllowArbitraryHyphenation"),
+ grid_gyoudori: bounded_count("GridGyoudori"),
+ paragraph_gyoudori: values.boolean("ParagraphGyoudori"),
+ }
+ }
+
+ /// Encodes a semantic kinsoku-set name as its IDML property value.
+ pub fn kinsoku_reference(name: &str) -> String {
+ if name.is_empty() { "Nothing".into() } else { format!("KinsokuTable/{}", crate::value::escape_id(name)) }
+ }
+
+ /// Writes CJK paragraph attributes and properties.
+ pub fn to_parts(&self) -> (Vec<(String, String)>, Vec) {
+ let mut attrs = Vec::new();
+ let mut properties = Vec::new();
+ for (key, value) in [("KinsokuHangType", &self.kinsoku_hang), ("KinsokuType", &self.kinsoku_type)] {
+ if let Some(value) = value {
+ attrs.push((key.into(), value.clone()));
+ }
+ }
+ if let Some(value) = &self.mojikumi {
+ let kind = if value.starts_with("MojikumiTable/") { "object" } else { "enumeration" };
+ properties.push(property("Mojikumi", kind, value.clone()));
+ }
+ for (key, value) in [
+ ("BunriKinshi", self.bunri_kinshi),
+ ("Rensuuji", self.rensuuji),
+ ("TreatIdeographicSpaceAsSpace", self.treat_ideographic_space_as_space),
+ ("AutoTcyIncludeRoman", self.auto_tcy_include_roman),
+ ("RotateSingleByteCharacters", self.rotate_single_byte_characters),
+ ("AllowArbitraryHyphenation", self.allow_arbitrary_hyphenation),
+ ("ParagraphGyoudori", self.paragraph_gyoudori),
+ ] {
+ push_boolean(&mut attrs, key, value);
+ }
+ push_number(&mut attrs, "AutoTcy", self.auto_tcy);
+ push_number(&mut attrs, "GridGyoudori", self.grid_gyoudori);
+ if let Some(value) = &self.kinsoku_set {
+ properties.push(property("KinsokuSet", if value == "Nothing" { "enumeration" } else { "object" }, value.clone()));
+ }
+ (attrs, properties)
+ }
+}
+
+/// Paragraph span and split-column properties read from IDML.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ParagraphSpanValues {
+ pub kind: Option,
+ pub split_column_count: Option,
+ pub inside_gutter: Option,
+ pub outside_gutter: Option,
+ pub space_before: Option,
+ pub space_after: Option,
+}
+
+impl ParagraphSpanValues {
+ /// Reads paragraph span and split-column properties from IDML.
+ pub fn from_el(el: &El) -> Self {
+ let values = Values::of(el);
+ Self {
+ kind: values.prop("SpanColumnType"),
+ split_column_count: values.prop("SpanSplitColumnCount").and_then(|value| value.trim().parse().ok()),
+ inside_gutter: values.num("SplitColumnInsideGutter"),
+ outside_gutter: values.num("SplitColumnOutsideGutter"),
+ space_before: values.num("SpanColumnMinSpaceBefore"),
+ space_after: values.num("SpanColumnMinSpaceAfter"),
+ }
+ }
+
+ /// Writes paragraph span and split-column attributes and properties.
+ pub fn to_parts(&self) -> (Vec<(String, String)>, Vec) {
+ let mut attrs = Vec::new();
+ let mut properties = Vec::new();
+ if let Some(kind) = &self.kind {
+ attrs.push(("SpanColumnType".into(), kind.clone()));
+ }
+ if let Some(count) = self.split_column_count {
+ properties.push(if count == 0 {
+ property("SpanSplitColumnCount", "enumeration", "All")
+ } else {
+ property("SpanSplitColumnCount", "long", count.to_string())
+ });
+ }
+ for (key, value) in [
+ ("SplitColumnInsideGutter", self.inside_gutter),
+ ("SplitColumnOutsideGutter", self.outside_gutter),
+ ("SpanColumnMinSpaceBefore", self.space_before),
+ ("SpanColumnMinSpaceAfter", self.space_after),
+ ] {
+ push_number(&mut attrs, key, value);
+ }
+ (attrs, properties)
+ }
+}
+
+/// Paragraph alignment, spacing, drop cap, baseline grid and composer values after the caller
+/// maps application semantics to IDML enumerations.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ParagraphAlignmentValues {
+ pub justification: Option,
+ pub direction: Option,
+ pub kashidas: Option,
+ pub paragraph_justification: Option,
+ pub paragraph_kashida_width: Option