umya_spreadsheet/structs/drawing/
scheme_color.rs

1// a:schemeClr
2use super::super::EnumValue;
3use super::PercentageType;
4use super::PositiveFixedPercentageType;
5use super::SchemeColorValues;
6use crate::reader::driver::*;
7use crate::writer::driver::*;
8use quick_xml::events::{BytesStart, Event};
9use quick_xml::Reader;
10use quick_xml::Writer;
11use std::io::Cursor;
12
13#[derive(Clone, Default, Debug)]
14pub struct SchemeColor {
15    val: EnumValue<SchemeColorValues>,
16    luminance: Option<PercentageType>,
17    luminance_modulation: Option<PercentageType>,
18    luminance_offset: Option<PercentageType>,
19    saturation: Option<PercentageType>,
20    saturation_modulation: Option<PercentageType>,
21    shade: Option<PositiveFixedPercentageType>,
22    alpha: Option<PositiveFixedPercentageType>,
23    tint: Option<PositiveFixedPercentageType>,
24}
25
26impl SchemeColor {
27    #[inline]
28    pub fn get_val(&self) -> &SchemeColorValues {
29        self.val.get_value()
30    }
31
32    #[inline]
33    pub fn set_val(&mut self, value: SchemeColorValues) -> &mut Self {
34        self.val.set_value(value);
35        self
36    }
37
38    #[inline]
39    pub fn get_luminance(&self) -> Option<&PercentageType> {
40        self.luminance.as_ref()
41    }
42
43    #[inline]
44    pub fn get_luminance_mut(&mut self) -> Option<&mut PercentageType> {
45        self.luminance.as_mut()
46    }
47
48    #[inline]
49    pub fn set_luminance(&mut self, value: PercentageType) {
50        self.luminance = Some(value);
51    }
52
53    #[inline]
54    pub fn get_luminance_modulation(&self) -> Option<&PercentageType> {
55        self.luminance_modulation.as_ref()
56    }
57
58    #[inline]
59    pub fn get_luminance_modulation_mut(&mut self) -> Option<&mut PercentageType> {
60        self.luminance_modulation.as_mut()
61    }
62
63    #[inline]
64    pub fn set_luminance_modulation(&mut self, value: PercentageType) {
65        self.luminance_modulation = Some(value);
66    }
67
68    #[inline]
69    pub fn get_luminance_offset(&self) -> Option<&PercentageType> {
70        self.luminance_offset.as_ref()
71    }
72
73    #[inline]
74    pub fn get_luminance_offset_mut(&mut self) -> Option<&mut PercentageType> {
75        self.luminance_offset.as_mut()
76    }
77
78    #[inline]
79    pub fn set_luminance_offset(&mut self, value: PercentageType) {
80        self.luminance_offset = Some(value);
81    }
82
83    #[inline]
84    pub fn get_saturation(&self) -> Option<&PercentageType> {
85        self.saturation.as_ref()
86    }
87
88    #[inline]
89    pub fn get_saturation_mut(&mut self) -> Option<&mut PercentageType> {
90        self.saturation.as_mut()
91    }
92
93    #[inline]
94    pub fn set_saturation(&mut self, value: PercentageType) {
95        self.saturation = Some(value);
96    }
97
98    #[inline]
99    pub fn get_saturation_modulation(&self) -> Option<&PercentageType> {
100        self.saturation_modulation.as_ref()
101    }
102
103    #[inline]
104    pub fn get_saturation_modulation_mut(&mut self) -> Option<&mut PercentageType> {
105        self.saturation_modulation.as_mut()
106    }
107
108    #[inline]
109    pub fn set_saturation_modulation(&mut self, value: PercentageType) {
110        self.saturation_modulation = Some(value);
111    }
112
113    #[inline]
114    pub fn get_shade(&self) -> Option<&PositiveFixedPercentageType> {
115        self.shade.as_ref()
116    }
117
118    #[inline]
119    pub fn get_shade_mut(&mut self) -> Option<&mut PositiveFixedPercentageType> {
120        self.shade.as_mut()
121    }
122
123    #[inline]
124    pub fn set_shade(&mut self, value: PositiveFixedPercentageType) {
125        self.shade = Some(value);
126    }
127
128    #[inline]
129    pub fn get_alpha(&self) -> Option<&PositiveFixedPercentageType> {
130        self.alpha.as_ref()
131    }
132
133    #[inline]
134    pub fn get_alpha_mut(&mut self) -> Option<&mut PositiveFixedPercentageType> {
135        self.alpha.as_mut()
136    }
137
138    #[inline]
139    pub fn set_alpha(&mut self, value: PositiveFixedPercentageType) {
140        self.alpha = Some(value);
141    }
142
143    #[inline]
144    pub fn get_tint(&self) -> Option<&PositiveFixedPercentageType> {
145        self.tint.as_ref()
146    }
147
148    #[inline]
149    pub fn get_tint_mut(&mut self) -> Option<&mut PositiveFixedPercentageType> {
150        self.tint.as_mut()
151    }
152
153    #[inline]
154    pub fn set_tint(&mut self, value: PositiveFixedPercentageType) {
155        self.tint = Some(value);
156    }
157
158    #[inline]
159    pub(crate) fn with_inner_params(&self) -> bool {
160        self.luminance.is_some()
161            || self.luminance_modulation.is_some()
162            || self.luminance_offset.is_some()
163            || self.saturation.is_some()
164            || self.saturation_modulation.is_some()
165            || self.shade.is_some()
166            || self.alpha.is_some()
167            || self.tint.is_some()
168    }
169
170    pub(crate) fn set_attributes<R: std::io::BufRead>(
171        &mut self,
172        reader: &mut Reader<R>,
173        e: &BytesStart,
174        empty_flag: bool,
175    ) {
176        self.val.set_value_string(get_attribute(e, b"val").unwrap());
177
178        if empty_flag {
179            return;
180        }
181
182        xml_read_loop!(
183            reader,
184            Event::Empty(ref e) => {
185                match e.name().into_inner() {
186                    b"a:lum" => {
187                        let mut obj = PercentageType::default();
188                        obj.set_attributes(reader, e, true);
189                        self.luminance = Some(obj);
190                    }
191                    b"a:lumMod" => {
192                        let mut obj = PercentageType::default();
193                        obj.set_attributes(reader, e, true);
194                        self.luminance_modulation = Some(obj);
195                    }
196                    b"a:lumOff" => {
197                        let mut obj = PercentageType::default();
198                        obj.set_attributes(reader, e, true);
199                        self.luminance_offset = Some(obj);
200                    }
201                    b"a:sat" => {
202                        let mut obj = PercentageType::default();
203                        obj.set_attributes(reader, e, true);
204                        self.saturation = Some(obj);
205                    }
206                    b"a:satMod" => {
207                        let mut obj = PercentageType::default();
208                        obj.set_attributes(reader, e, true);
209                        self.saturation_modulation = Some(obj);
210                    }
211                    b"a:shade" => {
212                        let mut obj = PositiveFixedPercentageType::default();
213                        obj.set_attributes(reader, e, true);
214                        self.shade = Some(obj);
215                    }
216                    b"a:alpha" => {
217                        let mut obj = PositiveFixedPercentageType::default();
218                        obj.set_attributes(reader, e, true);
219                        self.alpha = Some(obj);
220                    }
221                    b"a:tint" => {
222                        let mut obj = PositiveFixedPercentageType::default();
223                        obj.set_attributes(reader, e, true);
224                        self.tint = Some(obj);
225                    }
226                    _ => (),
227                }
228            },
229            Event::Start(ref e) => {
230                match e.name().into_inner() {
231                    b"a:lum" => {
232                        let mut obj = PercentageType::default();
233                        obj.set_attributes(reader, e, false);
234                        self.luminance = Some(obj);
235                    }
236                    b"a:lumMod" => {
237                        let mut obj = PercentageType::default();
238                        obj.set_attributes(reader, e, false);
239                        self.luminance_modulation = Some(obj);
240                    }
241                    b"a:lumOff" => {
242                        let mut obj = PercentageType::default();
243                        obj.set_attributes(reader, e, false);
244                        self.luminance_offset = Some(obj);
245                    }
246                    b"a:sat" => {
247                        let mut obj = PercentageType::default();
248                        obj.set_attributes(reader, e, false);
249                        self.saturation = Some(obj);
250                    }
251                    b"a:satMod" => {
252                        let mut obj = PercentageType::default();
253                        obj.set_attributes(reader, e, false);
254                        self.saturation_modulation = Some(obj);
255                    }
256                    b"a:shade" => {
257                        let mut obj = PositiveFixedPercentageType::default();
258                        obj.set_attributes(reader, e, false);
259                        self.shade = Some(obj);
260                    }
261                    b"a:alpha" => {
262                        let mut obj = PositiveFixedPercentageType::default();
263                        obj.set_attributes(reader, e, false);
264                        self.alpha = Some(obj);
265                    }
266                    b"a:tint" => {
267                        let mut obj = PositiveFixedPercentageType::default();
268                        obj.set_attributes(reader, e, false);
269                        self.tint = Some(obj);
270                    }
271                    _ => (),
272                }
273            },
274            Event::End(ref e) => {
275                if e.name().into_inner() == b"a:schemeClr" {
276                    return;
277                }
278            },
279            Event::Eof => panic!("Error: Could not find {} end element", "a:schemeClr")
280        );
281    }
282
283    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
284        // a:schemeClr
285        if self.with_inner_params() {
286            write_start_tag(
287                writer,
288                "a:schemeClr",
289                vec![("val", (self.val.get_value_string()))],
290                false,
291            );
292
293            // a:luminance
294            if let Some(v) = &self.luminance {
295                v.write_to_lum(writer);
296            }
297
298            // a:lumMod
299            if let Some(v) = &self.luminance_modulation {
300                v.write_to_lum_mod(writer);
301            }
302
303            // a:lumOff
304            if let Some(v) = &self.luminance_offset {
305                v.write_to_lum_off(writer);
306            }
307
308            // a:sat
309            if let Some(v) = &self.saturation {
310                v.write_to_sat(writer);
311            }
312
313            // a:satMod
314            if let Some(v) = &self.saturation_modulation {
315                v.write_to_sat_mod(writer);
316            }
317
318            // a:shade
319            if let Some(v) = &self.shade {
320                v.write_to_shade(writer);
321            }
322
323            // a:alpha
324            if let Some(v) = &self.alpha {
325                v.write_to_alpha(writer);
326            }
327
328            // a:tint
329            if let Some(v) = &self.tint {
330                v.write_to_tint(writer);
331            }
332
333            write_end_tag(writer, "a:schemeClr");
334        } else {
335            write_start_tag(
336                writer,
337                "a:schemeClr",
338                vec![("val", (self.val.get_value_string()))],
339                true,
340            );
341        }
342    }
343}
umya_spreadsheet/structs/drawing/scheme_color.rs

umya_spreadsheet/structs/drawing/
scheme_color.rs
