docx_reader/reader/

drawing.rs

use std::io::Read;
use std::str::FromStr;
use xml::attribute::OwnedAttribute;
use xml::reader::{EventReader, XmlEvent};

use crate::types::*;
use crate::{DrawingPositionType, RelativeFromHType, RelativeFromVType};

use super::*;

fn read_position_h<R: Read>(
	r: &mut EventReader<R>,
	attrs: &[OwnedAttribute],
) -> Result<(RelativeFromHType, i32), ReaderError> {
	let mut offset: i32 = 0;
	let mut relative_from_h = RelativeFromHType::default();

	loop {
		if let Some(h) = read(attrs, "relativeFrom") {
			if let Ok(h) = RelativeFromHType::from_str(&h) {
				relative_from_h = h;
			}
		}
		let e = r.next();
		match e {
			Ok(XmlEvent::Characters(c)) => {
				if let Ok(p) = f64::from_str(&c) {
					offset = p as i32;
				}
			}
			Ok(XmlEvent::EndElement { name, .. }) => {
				let e = WpXMLElement::from_str(&name.local_name).unwrap();
				if e == WpXMLElement::PositionH {
					return Ok((relative_from_h, offset));
				}
			}
			Err(_) => return Err(ReaderError::XMLReadError),
			_ => {}
		}
	}
}

fn read_position_v<R: Read>(
	r: &mut EventReader<R>,
	attrs: &[OwnedAttribute],
) -> Result<(RelativeFromVType, i32), ReaderError> {
	let mut offset: i32 = 0;
	let mut relative_from_v = RelativeFromVType::default();
	loop {
		if let Some(v) = read(attrs, "relativeFrom") {
			if let Ok(v) = RelativeFromVType::from_str(&v) {
				relative_from_v = v;
			}
		}

		let e = r.next();
		match e {
			Ok(XmlEvent::Characters(c)) => {
				if let Ok(p) = f64::from_str(&c) {
					offset = p as i32;
				}
			}
			Ok(XmlEvent::EndElement { name, .. }) => {
				let e = WpXMLElement::from_str(&name.local_name).unwrap();
				if e == WpXMLElement::PositionV {
					return Ok((relative_from_v, offset));
				}
			}
			Err(_) => return Err(ReaderError::XMLReadError),
			_ => {}
		}
	}
}

fn read_textbox_content<R: Read>(
	r: &mut EventReader<R>,
	_attrs: &[OwnedAttribute],
) -> Result<Vec<TextBoxContentChild>, ReaderError> {
	let mut children = vec![];
	loop {
		let e = r.next();
		match e {
			Ok(XmlEvent::StartElement {
				attributes, name, ..
			}) => {
				let e = XMLElement::from_str(&name.local_name).unwrap();
				match e {
					XMLElement::Paragraph => {
						let p = Paragraph::read(r, &attributes)?;
						children.push(TextBoxContentChild::Paragraph(Box::new(p)));
						continue;
					}
					XMLElement::Table => {
						let t = Table::read(r, &attributes)?;
						children.push(TextBoxContentChild::Table(Box::new(t)));
						continue;
					}
					_ => {}
				}
			}
			Ok(XmlEvent::EndElement { name, .. }) => {
				let e = WpsXMLElement::from_str(&name.local_name).unwrap();
				if e == WpsXMLElement::Txbx {
					return Ok(children);
				}
			}
			Err(_) => return Err(ReaderError::XMLReadError),
			_ => {}
		}
	}
}

impl ElementReader for Drawing {
	fn read<R: Read>(
		r: &mut EventReader<R>,
		_attrs: &[OwnedAttribute],
	) -> Result<Self, ReaderError> {
		let mut drawing = Drawing::new();
		let mut drawing_position_type = DrawingPositionType::Inline;

		let mut simple_pos = false;
		let mut simple_pos_x = 0;
		let mut simple_pos_y = 0;
		let mut layout_in_cell = true;
		let mut relative_height = 0;
		let mut position_h = 0;
		let mut position_v = 0;
		let mut relative_from_h = RelativeFromHType::default();
		let mut relative_from_v = RelativeFromVType::default();
		let mut allow_overlap = true;
		let mut dist_t = 0;
		let mut dist_b = 0;
		let mut dist_l = 0;
		let mut dist_r = 0;

		loop {
			let e = r.next();
			match e {
				Ok(XmlEvent::StartElement {
					name, attributes, ..
				}) => {
					// wp:
					if let Ok(wpe) = WpXMLElement::from_str(&name.local_name) {
						match wpe {
							WpXMLElement::Anchor => {
								drawing_position_type = DrawingPositionType::Anchor;
								if let Some(v) = read(&attributes, "simplePos") {
									if !is_false(&v) {
										simple_pos = true;
									}
								}
								if let Some(d) = read(&attributes, "distT") {
									if let Ok(d) = f64::from_str(&d) {
										dist_t = d as i32;
									}
								}
								if let Some(d) = read(&attributes, "distB") {
									if let Ok(d) = f64::from_str(&d) {
										dist_b = d as i32;
									}
								}
								if let Some(d) = read(&attributes, "distL") {
									if let Ok(d) = f64::from_str(&d) {
										dist_l = d as i32;
									}
								}
								if let Some(d) = read(&attributes, "distR") {
									if let Ok(d) = f64::from_str(&d) {
										dist_r = d as i32;
									}
								}
								if let Some(d) = read(&attributes, "layoutInCell") {
									if is_false(&d) {
										layout_in_cell = false;
									}
								}
								if let Some(d) = read(&attributes, "relativeHeight") {
									if let Ok(d) = f64::from_str(&d) {
										relative_height = d as u32;
									}
								}
								if let Some(d) = read(&attributes, "allowOverlap") {
									if is_false(&d) {
										allow_overlap = false;
									}
								}
							}
							WpXMLElement::Inline => {
								drawing_position_type = DrawingPositionType::Inline;
								if let Some(d) = read(&attributes, "distT") {
									if let Ok(d) = f64::from_str(&d) {
										dist_t = d as i32;
									}
								}
								if let Some(d) = read(&attributes, "distB") {
									if let Ok(d) = f64::from_str(&d) {
										dist_b = d as i32;
									}
								}
								if let Some(d) = read(&attributes, "distL") {
									if let Ok(d) = f64::from_str(&d) {
										dist_l = d as i32;
									}
								}
								if let Some(d) = read(&attributes, "distR") {
									if let Ok(d) = i32::from_str(&d) {
										dist_r = d;
									}
								}
							}
							WpXMLElement::SimplePos => {
								if let Some(x) = read(&attributes, "x") {
									if let Ok(x) = f64::from_str(&x) {
										simple_pos_x = x as i32;
									}
								}
								if let Some(y) = read(&attributes, "y") {
									if let Ok(y) = f64::from_str(&y) {
										simple_pos_y = y as i32;
									}
								}
							}
							WpXMLElement::PositionH => {
								if let Ok(p) = read_position_h(r, &attributes) {
									relative_from_h = p.0;
									position_h = p.1;
								}
							}
							WpXMLElement::PositionV => {
								if let Ok(p) = read_position_v(r, &attributes) {
									relative_from_v = p.0;
									position_v = p.1;
								}
							}
							_ => {}
						}
					}
					// pic:
					if let Ok(PicXMLElement::Pic) = PicXMLElement::from_str(&name.local_name) {
						if let Ok(mut pic) = Pic::read(r, &attributes) {
							pic.position_type = drawing_position_type;
							pic.simple_pos = simple_pos;
							pic.simple_pos_x = simple_pos_x;
							pic.simple_pos_y = simple_pos_y;
							pic.layout_in_cell = layout_in_cell;
							pic.relative_height = relative_height;
							pic.allow_overlap = allow_overlap;
							pic.dist_r = dist_r;
							pic.dist_t = dist_t;
							pic.dist_b = dist_b;
							pic.dist_l = dist_l;
							pic.dist_r = dist_r;
							pic.relative_from_h = relative_from_h;
							pic.relative_from_v = relative_from_v;
							pic.position_v = DrawingPosition::Offset(position_v);
							pic.position_h = DrawingPosition::Offset(position_h);
							drawing = drawing.pic(pic);
						}
					}

					// wps:
					if let Ok(WpsXMLElement::Txbx) = WpsXMLElement::from_str(&name.local_name) {
						if let Ok(children) = read_textbox_content(r, &attributes) {
							let mut text_box = TextBox::new();
							text_box.position_type = drawing_position_type;
							text_box.simple_pos = simple_pos;
							text_box.simple_pos_x = simple_pos_x;
							text_box.simple_pos_y = simple_pos_y;
							text_box.layout_in_cell = layout_in_cell;
							text_box.relative_height = relative_height;
							text_box.allow_overlap = allow_overlap;
							text_box.dist_r = dist_r;
							text_box.dist_t = dist_t;
							text_box.dist_b = dist_b;
							text_box.dist_l = dist_l;
							text_box.dist_r = dist_r;
							text_box.relative_from_h = relative_from_h;
							text_box.relative_from_v = relative_from_v;
							text_box.position_v = DrawingPosition::Offset(position_v);
							text_box.position_h = DrawingPosition::Offset(position_h);
							text_box.children = children;
							drawing = drawing.text_box(text_box);
						}
					}
				}
				Ok(XmlEvent::EndElement { name, .. }) => {
					let e = XMLElement::from_str(&name.local_name).unwrap();
					if e == XMLElement::Drawing {
						return Ok(drawing);
					}
				}
				Err(_) => return Err(ReaderError::XMLReadError),
				_ => {}
			}
		}
	}
}