umya_spreadsheet/structs/drawing/spreadsheet/
blip_fill.rs

1// xdr:blipFill
2use super::super::super::BooleanValue;
3use super::super::Blip;
4use super::super::SourceRectangle;
5use super::super::Stretch;
6use crate::reader::driver::*;
7use crate::structs::raw::RawRelationships;
8use crate::writer::driver::*;
9use quick_xml::events::{BytesStart, Event};
10use quick_xml::Reader;
11use quick_xml::Writer;
12use std::io::Cursor;
13
14#[derive(Clone, Default, Debug)]
15pub struct BlipFill {
16    rotate_with_shape: BooleanValue,
17    blip: Blip,
18    source_rectangle: Option<Box<SourceRectangle>>,
19    stretch: Stretch,
20}
21
22impl BlipFill {
23    #[inline]
24    pub fn get_rotate_with_shape(&self) -> &bool {
25        self.rotate_with_shape.get_value()
26    }
27
28    #[inline]
29    pub fn set_rotate_with_shape(&mut self, value: bool) -> &mut BlipFill {
30        self.rotate_with_shape.set_value(value);
31        self
32    }
33
34    #[inline]
35    pub fn get_source_rectangle(&self) -> Option<&SourceRectangle> {
36        self.source_rectangle.as_deref()
37    }
38
39    #[inline]
40    pub fn get_source_rectangle_mut(&mut self) -> Option<&mut SourceRectangle> {
41        self.source_rectangle.as_deref_mut()
42    }
43
44    #[inline]
45    pub fn set_source_rectangle(&mut self, value: SourceRectangle) -> &mut BlipFill {
46        self.source_rectangle = Some(Box::new(value));
47        self
48    }
49
50    #[inline]
51    pub fn get_blip(&self) -> &Blip {
52        &self.blip
53    }
54
55    #[inline]
56    pub fn get_blip_mut(&mut self) -> &mut Blip {
57        &mut self.blip
58    }
59
60    #[inline]
61    pub fn set_blip(&mut self, value: Blip) -> &mut BlipFill {
62        self.blip = value;
63        self
64    }
65
66    #[inline]
67    pub fn get_stretch(&self) -> &Stretch {
68        &self.stretch
69    }
70
71    #[inline]
72    pub fn get_stretch_mut(&mut self) -> &mut Stretch {
73        &mut self.stretch
74    }
75
76    #[inline]
77    pub fn set_stretch(&mut self, value: Stretch) -> &mut BlipFill {
78        self.stretch = value;
79        self
80    }
81
82    pub(crate) fn set_attributes<R: std::io::BufRead>(
83        &mut self,
84        reader: &mut Reader<R>,
85        e: &BytesStart,
86        drawing_relationships: Option<&RawRelationships>,
87    ) {
88        set_string_from_xml!(self, e, rotate_with_shape, "rotWithShape");
89
90        xml_read_loop!(
91            reader,
92            Event::Start(ref e) => {
93                match e.name().into_inner() {
94                    b"a:blip" => {
95                        self.blip
96                            .set_attributes(reader, e, drawing_relationships.unwrap(), false);
97                        }
98                    b"a:stretch" => {
99                        self.stretch.set_attributes(reader, e);
100                    }
101                    _ => (),
102                }
103            },
104            Event::Empty(ref e) => {
105                match e.name().into_inner() {
106                    b"a:blip" => {
107                        self.blip
108                            .set_attributes(reader, e, drawing_relationships.unwrap(), true);
109                        }
110                    b"a:srcRect" => {
111                        let mut source_rectangle = SourceRectangle::default();
112                        source_rectangle.set_attributes(reader, e);
113                        self.set_source_rectangle(source_rectangle);
114                    }
115                    _ => (),
116                }
117            },
118            Event::End(ref e) => {
119                if e.name().into_inner() == b"xdr:blipFill" {
120                    return;
121                }
122            },
123            Event::Eof => panic!("Error: Could not find {} end element", "xdr:blipFill")
124        );
125    }
126
127    pub(crate) fn write_to(
128        &self,
129        writer: &mut Writer<Cursor<Vec<u8>>>,
130        rel_list: &mut Vec<(String, String)>,
131    ) {
132        // xdr:blipFill
133        let mut attributes: Vec<(&str, &str)> = Vec::new();
134        if self.rotate_with_shape.has_value() {
135            attributes.push(("rotWithShape", self.rotate_with_shape.get_value_string()))
136        }
137        write_start_tag(writer, "xdr:blipFill", attributes, false);
138
139        // a:blip
140        self.blip.write_to(writer, rel_list);
141
142        // a:srcRect
143        if let Some(v) = &self.source_rectangle {
144            v.write_to(writer);
145        }
146
147        // a:stretch
148        self.stretch.write_to(writer);
149
150        write_end_tag(writer, "xdr:blipFill");
151    }
152}