docx_reader/reader/
run_property.rs

1use std::io::Read;
2use std::str::FromStr;
3use xml::attribute::OwnedAttribute;
4use xml::reader::{EventReader, XmlEvent};
5
6use crate::VertAlignType;
7
8use super::*;
9
10fn read_run_fonts(attributes: &[OwnedAttribute]) -> Result<RunFonts, ReaderError> {
11	let mut f = RunFonts::new();
12	for a in attributes {
13		let local_name = &a.name.local_name;
14		match local_name.as_str() {
15			"asciiTheme" => {
16				f = f.ascii_theme(&a.value);
17			}
18			"eastAsiaTheme" => {
19				f = f.east_asia_theme(&a.value);
20			}
21			"hAnsiTheme" => {
22				f = f.hi_ansi_theme(&a.value);
23			}
24			"cstheme" => {
25				f = f.cs_theme(&a.value);
26			}
27			"ascii" => {
28				f = f.ascii(&a.value);
29			}
30			"eastAsia" => {
31				f = f.east_asia(&a.value);
32			}
33			"hAnsi" => {
34				f = f.hi_ansi(&a.value);
35			}
36			"cs" => {
37				f = f.cs(&a.value);
38			}
39			"hint" => {
40				f = f.hint(&a.value);
41			}
42			_ => {}
43		}
44	}
45	Ok(f)
46}
47
48impl ElementReader for RunProperty {
49	fn read<R: Read>(
50		r: &mut EventReader<R>,
51		_attrs: &[OwnedAttribute],
52	) -> Result<Self, ReaderError> {
53		let mut rp = RunProperty::new();
54		loop {
55			let e = r.next();
56			match e {
57				Ok(XmlEvent::StartElement {
58					attributes, name, ..
59				}) => {
60					let e = XMLElement::from_str(&name.local_name).unwrap();
61					match e {
62						XMLElement::RunStyle => {
63							if let Some(v) = read_val(&attributes) {
64								rp = rp.style(&v);
65							}
66						}
67						XMLElement::Bold => {
68							if !read_bool(&attributes) {
69								rp = rp.disable_bold();
70								continue;
71							}
72							rp = rp.bold();
73						}
74						XMLElement::Caps => {
75							if !read_bool(&attributes) {
76								rp.caps = Some(Caps::new().disable());
77								continue;
78							}
79							rp = rp.caps();
80						}
81						XMLElement::Highlight => rp = rp.highlight(attributes[0].value.clone()),
82						XMLElement::Strike => {
83							if !read_bool(&attributes) {
84								rp.strike = Some(Strike::new().disable());
85								continue;
86							}
87							rp = rp.strike();
88						}
89						XMLElement::VertAlign => {
90							if let Ok(v) = VertAlignType::from_str(&attributes[0].value) {
91								rp = rp.vert_align(v)
92							}
93						}
94						XMLElement::Color => rp = rp.color(attributes[0].value.clone()),
95						XMLElement::Size => {
96							rp = rp.size(f64::from_str(&attributes[0].value)? as usize)
97						}
98						XMLElement::Spacing => {
99							if let Some(v) = read_val(&attributes) {
100								if let Ok(s) = f64::from_str(&v) {
101									rp = rp.spacing(s as i32)
102								}
103							}
104						}
105						XMLElement::RunFonts => {
106							if let Ok(f) = read_run_fonts(&attributes) {
107								rp = rp.fonts(f);
108							}
109						}
110						XMLElement::Underline => rp = rp.underline(&attributes[0].value.clone()),
111						XMLElement::Italic => {
112							if !read_bool(&attributes) {
113								rp = rp.disable_italic();
114								continue;
115							}
116							rp = rp.italic();
117						}
118						XMLElement::Vanish => rp = rp.vanish(),
119						XMLElement::SpecVanish => rp = rp.spec_vanish(),
120						XMLElement::TextBorder => {
121							if let Ok(attr) = read_border(&attributes) {
122								let mut border = TextBorder::new()
123									.border_type(attr.border_type)
124									.color(attr.color);
125								if let Some(size) = attr.size {
126									border = border.size(size as usize);
127								};
128								rp = rp.text_border(border);
129								continue;
130							}
131						}
132						XMLElement::Insert => {
133							if let Ok(ins) = Insert::read(r, &attributes) {
134								rp = rp.insert(ins);
135							}
136						}
137						XMLElement::Delete => {
138							if let Ok(del) = Delete::read(r, &attributes) {
139								rp = rp.delete(del);
140							}
141						}
142						_ => {}
143					}
144				}
145				Ok(XmlEvent::EndElement { name, .. }) => {
146					let e = XMLElement::from_str(&name.local_name).unwrap();
147					if e == XMLElement::RunProperty {
148						return Ok(rp);
149					}
150				}
151				Err(_) => return Err(ReaderError::XMLReadError),
152				_ => {}
153			}
154		}
155	}
156}