diff --git a/crates/xfl/src/lib.rs b/crates/xfl/src/lib.rs index 9dd43fd5d..5c1bf12df 100644 --- a/crates/xfl/src/lib.rs +++ b/crates/xfl/src/lib.rs @@ -31,6 +31,8 @@ pub mod edges; pub mod media; /// Borrowed views of native XFL shape and style elements. pub mod shape; +/// Borrowed views of native XFL text-field and text-run schema. +pub mod text; /// Largest single entry inflated (bytes). pub const MAX_ENTRY: usize = 256 * 1024 * 1024; diff --git a/crates/xfl/src/shape.rs b/crates/xfl/src/shape.rs index bcd3e9373..030719554 100644 --- a/crates/xfl/src/shape.rs +++ b/crates/xfl/src/shape.rs @@ -5,6 +5,7 @@ //! compatible borrowed element adapters implemented by consumers. use crate::edges::{self, Segment}; +use std::borrow::Cow; /// An element source used by the borrowed XFL schema views. /// @@ -27,6 +28,9 @@ pub trait XflElement { /// Direct child elements in document order. fn elements(&self) -> Self::Elements<'_>; + /// This element's direct character data, with XML references resolved. + fn text_content(&self) -> Cow<'_, str>; + /// The first direct child whose local name matches. fn child(&self, name: &str) -> Option<&Self> { self.elements().find(|element| element.local_name() == name) @@ -68,6 +72,10 @@ impl XflElement for craft_xml::El { fn elements(&self) -> Self::Elements<'_> { XmlElements { nodes: self.children.iter() } } + + fn text_content(&self) -> Cow<'_, str> { + self.text() + } } /// XFL matrix coefficients, in the native units stored in XML. @@ -565,6 +573,9 @@ mod tests { fn elements(&self) -> Self::Elements<'_> { self.children.iter() } + fn text_content(&self) -> Cow<'_, str> { + Cow::Borrowed("") + } } let app = AppElement { name: "x:DOMShape".into(), attrs: vec![("isDrawingObject".into(), "true".into())], children: Vec::new() }; assert_eq!(Shape::new(&app).unwrap().is_drawing_object(), Some(true)); diff --git a/crates/xfl/src/text.rs b/crates/xfl/src/text.rs new file mode 100644 index 000000000..8d883fc0c --- /dev/null +++ b/crates/xfl/src/text.rs @@ -0,0 +1,273 @@ +//! Borrowed views of native XFL text-field, run and style records. +//! +//! The views expose format attributes and direct text only. Text layout, font selection, +//! unsupported-style reporting and conversion into an application's text model stay with the +//! consumer. + +use crate::shape::{self, Color, XflElement}; +use std::borrow::Cow; + +/// A native static, dynamic or input text field. +#[derive(Clone, Copy, Debug)] +pub struct TextField<'a, E: XflElement> { + element: &'a E, + kind: TextFieldKind, +} + +/// Kind of native XFL text field. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum TextFieldKind { + Static, + Dynamic, + Input, +} + +impl<'a, E: XflElement> TextField<'a, E> { + /// Views a recognized XFL text field. + pub fn new(element: &'a E) -> Option { + let kind = match element.local_name() { + "DOMStaticText" => TextFieldKind::Static, + "DOMDynamicText" => TextFieldKind::Dynamic, + "DOMInputText" => TextFieldKind::Input, + _ => return None, + }; + Some(Self { element, kind }) + } + + pub fn kind(&self) -> TextFieldKind { + self.kind + } + + /// Native field orientation (`horizontal`, `vertical`, etc.). + pub fn orientation(&self) -> Option<&'a str> { + self.element.attr("orientation") + } + + /// Native `autoExpand` flag, if present and parseable. + pub fn auto_expand(&self) -> Option { + boolean(self.element, "autoExpand") + } + + pub fn width(&self) -> Option { + number(self.element, "width") + } + + pub fn height(&self) -> Option { + number(self.element, "height") + } + + pub fn left(&self) -> Option { + number(self.element, "left") + } + + pub fn top(&self) -> Option { + number(self.element, "top") + } + + pub fn line_type(&self) -> Option<&'a str> { + self.element.attr("lineType") + } + + pub fn border(&self) -> Option { + boolean(self.element, "border") + } + + pub fn is_selectable(&self) -> Option { + boolean(self.element, "isSelectable") + } + + pub fn render_as_html(&self) -> Option { + boolean(self.element, "renderAsHTML") + } + + pub fn max_characters(&self) -> Option { + number(self.element, "maxCharacters") + } + + pub fn variable_name(&self) -> Option<&'a str> { + self.element.attr("variableName") + } + + /// Whether the native field has any filter records, which consumers may need to report as + /// unsupported while keeping the field. + pub fn has_filters(&self) -> bool { + self.element.child("filters").is_some_and(|wrapper| wrapper.elements().next().is_some()) + } + + /// Text runs in document order. Non-`DOMTextRun` children are ignored. + pub fn runs(&self) -> impl Iterator> + 'a { + self.element.child("textRuns").into_iter().flat_map(|wrapper| wrapper.elements_named("DOMTextRun")).map(|element| TextRun { element }) + } + + /// Number of element records inside the native `` wrapper, including unknown + /// records. This lets consumers retain their prior malformed-record and resource-limit + /// policy while parsing recognized runs through [`Self::runs`]. + pub fn run_entries_count(&self) -> usize { + self.element.child("textRuns").map_or(0, |wrapper| wrapper.elements().count()) + } +} + +/// One native text run and its optional style record. +#[derive(Clone, Copy, Debug)] +pub struct TextRun<'a, E: XflElement> { + element: &'a E, +} + +impl<'a, E: XflElement> TextRun<'a, E> { + /// Direct character data of this run's `` element. + pub fn characters(&self) -> Cow<'a, str> { + self.element.child("characters").map_or(Cow::Borrowed(""), XflElement::text_content) + } + + /// The native text attributes nested under ``. + pub fn style(&self) -> Option> { + self.element.child("textAttrs").and_then(|wrapper| wrapper.child("DOMTextAttrs")).map(|element| TextStyle { element }) + } +} + +/// Native `DOMTextAttrs` fields. Values are parsed from the wire schema but not laid out or +/// normalized for any application. +#[derive(Clone, Copy, Debug)] +pub struct TextStyle<'a, E: XflElement> { + element: &'a E, +} + +impl<'a, E: XflElement> TextStyle<'a, E> { + pub fn face(&self) -> Option<&'a str> { + self.element.attr("face") + } + + pub fn size(&self) -> Option { + number(self.element, "size") + } + + pub fn bold(&self) -> Option { + boolean(self.element, "bold") + } + + pub fn italic(&self) -> Option { + boolean(self.element, "italic") + } + + pub fn fill_color(&self) -> Option<&'a str> { + self.element.attr("fillColor") + } + + /// Parsed native fill color and alpha, with XFL's black/full-opacity defaults. + pub fn color(&self) -> Color { + shape::color(self.element, "fillColor", "alpha") + } + + pub fn alpha(&self) -> Option { + number(self.element, "alpha") + } + + pub fn alignment(&self) -> Option<&'a str> { + self.element.attr("alignment") + } + + pub fn indent(&self) -> Option { + number(self.element, "indent") + } + + pub fn character_position(&self) -> Option<&'a str> { + self.element.attr("characterPosition") + } + + pub fn letter_spacing(&self) -> Option { + number(self.element, "letterSpacing") + } + + pub fn line_spacing(&self) -> Option { + number(self.element, "lineSpacing") + } + + pub fn left_margin(&self) -> Option { + number(self.element, "leftMargin") + } + + pub fn right_margin(&self) -> Option { + number(self.element, "rightMargin") + } +} + +fn number(element: &impl XflElement, name: &str) -> Option { + element.attr(name)?.trim().parse::().ok().filter(|value| value.is_finite()) +} + +fn boolean(element: &impl XflElement, name: &str) -> Option { + element.attr(name).map(|value| value.trim() == "true") +} + +#[cfg(test)] +mod tests { + use super::*; + + fn parse(source: &[u8]) -> craft_xml::El { + craft_xml::parse(source).expect("well-formed test XML") + } + + #[test] + fn reads_prefixed_text_fields_runs_and_native_style_values() { + let root = parse( + br##"one & two"##, + ); + let field = TextField::new(&root).expect("dynamic text field"); + assert_eq!(field.kind(), TextFieldKind::Dynamic); + assert_eq!(field.orientation(), Some("horizontal")); + assert_eq!(field.auto_expand(), Some(true)); + assert_eq!((field.width(), field.height(), field.left(), field.top()), (Some(320.0), Some(40.0), Some(12.0), Some(3.0))); + assert_eq!(field.line_type(), Some("multiline")); + assert_eq!(field.border(), Some(true)); + assert_eq!(field.is_selectable(), Some(false)); + assert_eq!(field.render_as_html(), Some(false)); + assert_eq!(field.max_characters(), Some(45.0)); + assert_eq!(field.variable_name(), Some("message")); + assert!(field.has_filters()); + + let mut runs = field.runs(); + let first = runs.next().expect("first run"); + assert_eq!(first.characters(), "one & two"); + let style = first.style().expect("text style"); + assert_eq!(style.face(), Some("Arial")); + assert_eq!(style.size(), Some(24.0)); + assert_eq!(style.bold(), Some(true)); + assert_eq!(style.italic(), Some(false)); + assert_eq!(style.fill_color(), Some("#123456")); + assert_eq!(style.alpha(), Some(0.5)); + assert_eq!(style.alignment(), Some("center")); + assert_eq!(style.indent(), Some(3.0)); + assert_eq!(style.character_position(), Some("superscript")); + assert_eq!(style.letter_spacing(), Some(1.25)); + assert_eq!(style.line_spacing(), Some(2.0)); + assert_eq!(style.left_margin(), Some(4.0)); + assert_eq!(style.right_margin(), Some(5.0)); + + let second = runs.next().expect("second run"); + assert_eq!(second.characters(), "third"); + assert!(second.style().is_none()); + assert!(runs.next().is_none()); + } + + #[test] + fn recognizes_all_native_field_kinds_and_ignores_non_text_elements() { + for (name, expected) in + [("DOMStaticText", TextFieldKind::Static), ("DOMDynamicText", TextFieldKind::Dynamic), ("DOMInputText", TextFieldKind::Input)] + { + let xml = format!("<{name}/>"); + let root = craft_xml::parse(xml.as_bytes()).expect("test XML"); + assert_eq!(TextField::new(&root).map(|field| field.kind()), Some(expected)); + } + let root = parse(b""); + assert!(TextField::new(&root).is_none()); + } + + #[test] + fn malformed_and_non_finite_numbers_remain_absent() { + let root = parse(b""); + let field = TextField::new(&root).expect("text field"); + let style = field.runs().next().and_then(|run| run.style()).expect("style"); + assert_eq!(style.size(), None); + assert_eq!(style.letter_spacing(), None); + } +}