//! 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); } }