Skip to main content

umya_spreadsheet/structs/drawing/spreadsheet/
shape_style.rs

1// xdr:style
2use std::io::Cursor;
3
4use quick_xml::{
5    Reader,
6    Writer,
7    events::{
8        BytesStart,
9        Event,
10    },
11};
12
13use super::super::StyleMatrixReferenceType;
14use crate::{
15    reader::driver::xml_read_loop,
16    writer::driver::{
17        write_end_tag,
18        write_start_tag,
19    },
20};
21
22#[derive(Clone, Default, Debug)]
23pub struct ShapeStyle {
24    line_reference:   Option<Box<StyleMatrixReferenceType>>,
25    fill_reference:   Option<Box<StyleMatrixReferenceType>>,
26    effect_reference: Option<Box<StyleMatrixReferenceType>>,
27    font_reference:   Option<Box<StyleMatrixReferenceType>>,
28}
29
30impl ShapeStyle {
31    #[inline]
32    #[must_use]
33    pub fn line_reference(&self) -> Option<&StyleMatrixReferenceType> {
34        self.line_reference.as_deref()
35    }
36
37    #[inline]
38    #[must_use]
39    #[deprecated(since = "3.0.0", note = "Use line_reference()")]
40    pub fn get_line_reference(&self) -> Option<&StyleMatrixReferenceType> {
41        self.line_reference()
42    }
43
44    #[inline]
45    pub fn set_line_reference(&mut self, value: StyleMatrixReferenceType) {
46        self.line_reference = Some(Box::new(value));
47    }
48
49    #[inline]
50    #[must_use]
51    pub fn fill_reference(&self) -> Option<&StyleMatrixReferenceType> {
52        self.fill_reference.as_deref()
53    }
54
55    #[inline]
56    #[must_use]
57    #[deprecated(since = "3.0.0", note = "Use fill_reference()")]
58    pub fn get_fill_reference(&self) -> Option<&StyleMatrixReferenceType> {
59        self.fill_reference()
60    }
61
62    #[inline]
63    pub fn set_fill_reference(&mut self, value: StyleMatrixReferenceType) {
64        self.fill_reference = Some(Box::new(value));
65    }
66
67    #[inline]
68    #[must_use]
69    pub fn effect_reference(&self) -> Option<&StyleMatrixReferenceType> {
70        self.effect_reference.as_deref()
71    }
72
73    #[inline]
74    #[must_use]
75    #[deprecated(since = "3.0.0", note = "Use effect_reference()")]
76    pub fn get_effect_reference(&self) -> Option<&StyleMatrixReferenceType> {
77        self.effect_reference()
78    }
79
80    #[inline]
81    pub fn set_effect_reference(&mut self, value: StyleMatrixReferenceType) {
82        self.effect_reference = Some(Box::new(value));
83    }
84
85    #[inline]
86    #[must_use]
87    pub fn font_reference(&self) -> Option<&StyleMatrixReferenceType> {
88        self.font_reference.as_deref()
89    }
90
91    #[inline]
92    #[must_use]
93    #[deprecated(since = "3.0.0", note = "Use font_reference()")]
94    pub fn get_font_reference(&self) -> Option<&StyleMatrixReferenceType> {
95        self.font_reference()
96    }
97
98    #[inline]
99    pub fn set_font_reference(&mut self, value: StyleMatrixReferenceType) {
100        self.font_reference = Some(Box::new(value));
101    }
102
103    pub(crate) fn set_attributes<R: std::io::BufRead>(
104        &mut self,
105        reader: &mut Reader<R>,
106        _e: &BytesStart,
107    ) {
108        xml_read_loop!(
109            reader,
110            Event::Start(ref e) => {
111                match e.name().into_inner() {
112                    b"a:lnRef" => {
113                        let mut style_matrix_reference_type = StyleMatrixReferenceType::default();
114                        style_matrix_reference_type.set_attributes(reader, e, false);
115                        self.set_line_reference(style_matrix_reference_type);
116                    }
117                    b"a:fillRef" => {
118                        let mut style_matrix_reference_type = StyleMatrixReferenceType::default();
119                        style_matrix_reference_type.set_attributes(reader, e, false);
120                        self.set_fill_reference(style_matrix_reference_type);
121                    }
122                    b"a:effectRef" => {
123                        let mut style_matrix_reference_type = StyleMatrixReferenceType::default();
124                        style_matrix_reference_type.set_attributes(reader, e, false);
125                        self.set_effect_reference(style_matrix_reference_type);
126                    }
127                    b"a:fontRef" => {
128                        let mut style_matrix_reference_type = StyleMatrixReferenceType::default();
129                        style_matrix_reference_type.set_attributes(reader, e, false);
130                        self.set_font_reference(style_matrix_reference_type);
131                    }
132                    _ => (),
133                }
134            },
135            Event::Empty(ref e) => {
136                match e.name().into_inner() {
137                    b"a:lnRef" => {
138                        let mut style_matrix_reference_type = StyleMatrixReferenceType::default();
139                        style_matrix_reference_type.set_attributes(reader, e, true);
140                        self.set_line_reference(style_matrix_reference_type);
141                    }
142                    b"a:fillRef" => {
143                        let mut style_matrix_reference_type = StyleMatrixReferenceType::default();
144                        style_matrix_reference_type.set_attributes(reader, e, true);
145                        self.set_fill_reference(style_matrix_reference_type);
146                    }
147                    b"a:effectRef" => {
148                        let mut style_matrix_reference_type = StyleMatrixReferenceType::default();
149                        style_matrix_reference_type.set_attributes(reader, e, true);
150                        self.set_effect_reference(style_matrix_reference_type);
151                    }
152                    b"a:fontRef" => {
153                        let mut style_matrix_reference_type = StyleMatrixReferenceType::default();
154                        style_matrix_reference_type.set_attributes(reader, e, true);
155                        self.set_font_reference(style_matrix_reference_type);
156                    }
157                    _ => (),
158                }
159            },
160            Event::End(ref e) => {
161                if e.name().into_inner() == b"xdr:style" {
162                    return;
163                }
164            },
165            Event::Eof => panic!("Error: Could not find {} end element", "xdr:style")
166        );
167    }
168
169    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
170        // xdr:style
171        write_start_tag(writer, "xdr:style", vec![], false);
172
173        // a:lnRef
174        if let Some(style) = &self.line_reference {
175            style.write_to(writer, "a:lnRef");
176        }
177
178        // a:fillRef
179        if let Some(style) = &self.fill_reference {
180            style.write_to(writer, "a:fillRef");
181        }
182
183        // a:effectRef
184        if let Some(style) = &self.effect_reference {
185            style.write_to(writer, "a:effectRef");
186        }
187
188        // a:fontRef
189        if let Some(style) = &self.font_reference {
190            style.write_to(writer, "a:fontRef");
191        }
192
193        write_end_tag(writer, "xdr:style");
194    }
195}