use std::io::Cursor;
use quick_xml::{
Reader,
Writer,
events::{
BytesStart,
Event,
},
};
use super::super::{
BlipFill,
EffectList,
ExtensionList,
NoFill,
Outline,
PresetGeometry,
SolidFill,
Transform2D,
};
use crate::{
EnumValue,
drawing::{
BlackWhiteModeValues,
GradientFill,
},
reader::driver::{
get_attribute,
set_string_from_xml,
xml_read_loop,
},
structs::raw::RawRelationships,
writer::driver::{
write_end_tag,
write_start_tag,
},
};
#[derive(Clone, Default, Debug)]
pub struct ShapeProperties {
transform2d: Option<Box<Transform2D>>,
preset_geometry: PresetGeometry,
blip_fill: Option<Box<BlipFill>>,
solid_fill: Option<Box<SolidFill>>,
gradient_fill: Option<Box<GradientFill>>,
outline: Option<Box<Outline>>,
effect_list: Option<Box<EffectList>>,
no_fill: Option<NoFill>,
extension_list: Option<ExtensionList>,
black_white_mode: EnumValue<BlackWhiteModeValues>,
}
impl ShapeProperties {
#[inline]
#[must_use]
pub fn transform2d(&self) -> Option<&Transform2D> {
self.transform2d.as_deref()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use transform2d()")]
pub fn get_transform2d(&self) -> Option<&Transform2D> {
self.transform2d()
}
#[inline]
pub fn transform2d_mut(&mut self) -> Option<&mut Transform2D> {
self.transform2d.as_deref_mut()
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use transform2d_mut()")]
pub fn get_transform2d_mut(&mut self) -> Option<&mut Transform2D> {
self.transform2d_mut()
}
#[inline]
pub fn set_transform2d(&mut self, value: Transform2D) -> &mut Self {
self.transform2d = Some(Box::new(value));
self
}
#[inline]
#[must_use]
pub fn geometry(&self) -> &PresetGeometry {
&self.preset_geometry
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use geometry()")]
pub fn get_geometry(&self) -> &PresetGeometry {
self.geometry()
}
#[inline]
pub fn geometry_mut(&mut self) -> &mut PresetGeometry {
&mut self.preset_geometry
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use geometry_mut()")]
pub fn get_geometry_mut(&mut self) -> &mut PresetGeometry {
self.geometry_mut()
}
#[inline]
pub fn set_geometry(&mut self, value: PresetGeometry) -> &mut Self {
self.preset_geometry = value;
self
}
#[inline]
#[must_use]
pub fn blip_fill(&self) -> Option<&BlipFill> {
self.blip_fill.as_deref()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use blip_fill()")]
pub fn get_blip_fill(&self) -> Option<&BlipFill> {
self.blip_fill()
}
#[inline]
pub fn blip_fill_mut(&mut self) -> Option<&mut BlipFill> {
self.blip_fill.as_deref_mut()
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use blip_fill_mut()")]
pub fn get_blip_fill_mut(&mut self) -> Option<&mut BlipFill> {
self.blip_fill_mut()
}
#[inline]
pub fn set_blip_fill(&mut self, value: BlipFill) -> &mut Self {
self.blip_fill = Some(Box::new(value));
self
}
#[inline]
#[must_use]
pub fn solid_fill(&self) -> Option<&SolidFill> {
self.solid_fill.as_deref()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use solid_fill()")]
pub fn get_solid_fill(&self) -> Option<&SolidFill> {
self.solid_fill()
}
#[inline]
pub fn solid_fill_mut(&mut self) -> Option<&mut SolidFill> {
self.solid_fill.as_deref_mut()
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use solid_fill_mut()")]
pub fn get_solid_fill_mut(&mut self) -> Option<&mut SolidFill> {
self.solid_fill_mut()
}
#[inline]
pub fn set_solid_fill(&mut self, value: SolidFill) -> &mut Self {
self.solid_fill = Some(Box::new(value));
self
}
#[inline]
#[must_use]
pub fn gradient_fill(&self) -> Option<&GradientFill> {
self.gradient_fill.as_deref()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use gradient_fill()")]
pub fn get_gradient_fill(&self) -> Option<&GradientFill> {
self.gradient_fill()
}
#[inline]
pub fn gradient_fill_mut(&mut self) -> Option<&mut GradientFill> {
self.gradient_fill.as_deref_mut()
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use gradient_fill_mut()")]
pub fn get_gradient_fill_mut(&mut self) -> Option<&mut GradientFill> {
self.gradient_fill_mut()
}
#[inline]
pub fn set_gradient_fill(&mut self, value: GradientFill) -> &mut Self {
self.gradient_fill = Some(Box::new(value));
self
}
#[inline]
#[must_use]
pub fn outline(&self) -> Option<&Outline> {
self.outline.as_deref()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use outline()")]
pub fn get_outline(&self) -> Option<&Outline> {
self.outline()
}
#[inline]
pub fn outline_mut(&mut self) -> Option<&mut Outline> {
self.outline.as_deref_mut()
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use outline_mut()")]
pub fn get_outline_mut(&mut self) -> Option<&mut Outline> {
self.outline_mut()
}
#[inline]
pub fn set_outline(&mut self, value: Outline) -> &mut Self {
self.outline = Some(Box::new(value));
self
}
#[inline]
#[must_use]
pub fn effect_list(&self) -> Option<&EffectList> {
self.effect_list.as_deref()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use effect_list()")]
pub fn get_effect_list(&self) -> Option<&EffectList> {
self.effect_list()
}
#[inline]
pub fn effect_list_mut(&mut self) -> Option<&mut EffectList> {
self.effect_list.as_deref_mut()
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use effect_list_mut()")]
pub fn get_effect_list_mut(&mut self) -> Option<&mut EffectList> {
self.effect_list_mut()
}
#[inline]
pub fn set_effect_list(&mut self, value: EffectList) -> &mut Self {
self.effect_list = Some(Box::new(value));
self
}
#[inline]
#[must_use]
pub fn no_fill(&self) -> Option<&NoFill> {
self.no_fill.as_ref()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use no_fill()")]
pub fn get_no_fill(&self) -> Option<&NoFill> {
self.no_fill()
}
#[inline]
pub fn no_fill_mut(&mut self) -> Option<&mut NoFill> {
self.no_fill.as_mut()
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use no_fill_mut()")]
pub fn get_no_fill_mut(&mut self) -> Option<&mut NoFill> {
self.no_fill_mut()
}
#[inline]
pub fn set_no_fill(&mut self, value: NoFill) -> &mut Self {
self.no_fill = Some(value);
self
}
#[inline]
#[must_use]
pub fn extension_list(&self) -> Option<&ExtensionList> {
self.extension_list.as_ref()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use extension_list()")]
pub fn get_extension_list(&self) -> Option<&ExtensionList> {
self.extension_list()
}
#[inline]
pub fn extension_list_mut(&mut self) -> Option<&mut ExtensionList> {
self.extension_list.as_mut()
}
#[inline]
#[deprecated(since = "3.0.0", note = "Use extension_list_mut()")]
pub fn get_extension_list_mut(&mut self) -> Option<&mut ExtensionList> {
self.extension_list_mut()
}
#[inline]
pub fn set_extension_list(&mut self, value: ExtensionList) -> &mut Self {
self.extension_list = Some(value);
self
}
#[inline]
#[must_use]
pub fn black_white_mode(&self) -> &BlackWhiteModeValues {
self.black_white_mode.value()
}
#[inline]
#[must_use]
#[deprecated(since = "3.0.0", note = "Use black_white_mode()")]
pub fn get_black_white_mode(&self) -> &BlackWhiteModeValues {
self.black_white_mode()
}
#[inline]
pub fn set_black_white_mode(&mut self, value: BlackWhiteModeValues) -> &mut Self {
self.black_white_mode.set_value(value);
self
}
pub(crate) fn set_attributes<R: std::io::BufRead>(
&mut self,
reader: &mut Reader<R>,
e: &BytesStart,
drawing_relationships: Option<&RawRelationships>,
) {
set_string_from_xml!(self, e, black_white_mode, "bwMode");
xml_read_loop!(
reader,
Event::Start(ref e) => {
match e.name().into_inner() {
b"a:xfrm" => {
let mut obj = Transform2D::default();
obj.set_attributes(reader, e);
self.set_transform2d(obj);
}
b"a:prstGeom" => {
self.preset_geometry.set_attributes(reader, e);
}
b"a:blipFill" => {
let mut obj = BlipFill::default();
obj.set_attributes(reader, e, drawing_relationships);
self.set_blip_fill(obj);
}
b"a:gradFill" => {
let mut obj = GradientFill::default();
obj.set_attributes(reader, e);
self.set_gradient_fill(obj);
}
b"a:ln" => {
let mut outline = Outline::default();
outline.set_attributes(reader, e);
self.set_outline(outline);
}
b"a:solidFill" => {
let mut solid_fill = SolidFill::default();
solid_fill.set_attributes(reader, e);
self.set_solid_fill(solid_fill);
}
b"a:effectLst" => {
let mut effect_list = EffectList::default();
effect_list.set_attributes(reader, e, false);
self.set_effect_list(effect_list);
}
b"a:extLst" => {
let obj = ExtensionList::default();
ExtensionList::set_attributes(reader, e);
self.set_extension_list(obj);
}
_ => (),
}
},
Event::Empty(ref e) => {
if e.name().into_inner() == b"a:noFill" {
let obj = NoFill::default();
NoFill::set_attributes(reader, e, true);
self.set_no_fill(obj);
}
},
Event::End(ref e) => {
if matches!(e.name().into_inner(), b"xdr:spPr" | b"spPr") {
return;
}
},
Event::Eof => panic!("Error: Could not find {} end element", "spPr")
);
}
pub(crate) fn write_to(
&self,
writer: &mut Writer<Cursor<Vec<u8>>>,
rel_list: &mut Vec<(String, String)>,
) {
let mut attributes: crate::structs::AttrCollection = Vec::new();
if self.black_white_mode.has_value() {
attributes.push(("bwMode", self.black_white_mode.hash_string()).into());
}
write_start_tag(writer, "xdr:spPr", attributes, false);
if let Some(v) = &self.transform2d {
v.write_to(writer);
}
self.preset_geometry.write_to(writer);
if let Some(v) = &self.blip_fill {
v.write_to(writer, rel_list);
}
if let Some(v) = &self.solid_fill {
v.write_to(writer);
}
if self.no_fill.is_some() {
NoFill::write_to(writer);
}
if let Some(v) = &self.outline {
v.write_to(writer);
}
if let Some(v) = &self.effect_list {
v.write_to(writer);
}
write_end_tag(writer, "xdr:spPr");
}
}