umya_spreadsheet/structs/drawing/
gradient_stop.rs

1// a:gs
2use super::RgbColorModelHex;
3use super::SchemeColor;
4use crate::reader::driver::*;
5use crate::writer::driver::*;
6use quick_xml::events::{BytesStart, Event};
7use quick_xml::Reader;
8use quick_xml::Writer;
9use std::io::Cursor;
10
11#[derive(Clone, Default, Debug)]
12pub struct GradientStop {
13    position: i32,
14    scheme_color: Option<Box<SchemeColor>>,
15    rgb_color_model_hex: Option<Box<RgbColorModelHex>>,
16}
17
18impl GradientStop {
19    #[inline]
20    pub fn get_position(&self) -> &i32 {
21        &self.position
22    }
23
24    #[inline]
25    pub fn set_position(&mut self, value: i32) -> &mut GradientStop {
26        self.position = value;
27        self
28    }
29
30    #[inline]
31    pub fn get_scheme_color(&self) -> Option<&SchemeColor> {
32        self.scheme_color.as_deref()
33    }
34
35    #[inline]
36    pub fn get_scheme_color_mut(&mut self) -> Option<&mut SchemeColor> {
37        self.scheme_color.as_deref_mut()
38    }
39
40    #[inline]
41    pub fn set_scheme_color(&mut self, value: SchemeColor) -> &mut GradientStop {
42        self.scheme_color = Some(Box::new(value));
43        self
44    }
45
46    #[inline]
47    pub fn get_rgb_color_model_hex(&self) -> Option<&RgbColorModelHex> {
48        self.rgb_color_model_hex.as_deref()
49    }
50
51    #[inline]
52    pub fn get_rgb_color_model_hex_mut(&mut self) -> Option<&mut RgbColorModelHex> {
53        self.rgb_color_model_hex.as_deref_mut()
54    }
55
56    #[inline]
57    pub fn set_rgb_color_model_hex(&mut self, value: RgbColorModelHex) -> &mut GradientStop {
58        self.rgb_color_model_hex = Some(Box::new(value));
59        self
60    }
61
62    pub(crate) fn set_attributes<R: std::io::BufRead>(
63        &mut self,
64        reader: &mut Reader<R>,
65        e: &BytesStart,
66    ) {
67        if let Some(v) = get_attribute(e, b"pos") {
68            self.set_position(v.parse::<i32>().unwrap());
69        }
70
71        xml_read_loop!(
72            reader,
73            Event::Start(ref e) => {
74                match e.name().into_inner() {
75                    b"a:schemeClr" => {
76                        let mut obj = SchemeColor::default();
77                        obj.set_attributes(reader, e, false);
78                        self.set_scheme_color(obj);
79                    }
80                    b"a:srgbClr" => {
81                        let mut obj = RgbColorModelHex::default();
82                        obj.set_attributes(reader, e, false);
83                        self.set_rgb_color_model_hex(obj);
84                    }
85                    _ => (),
86                }
87            },
88            Event::Empty(ref e) => {
89                match e.name().into_inner() {
90                    b"a:schemeClr" => {
91                        let mut obj = SchemeColor::default();
92                        obj.set_attributes(reader, e, true);
93                        self.set_scheme_color(obj);
94                    }
95                    b"a:srgbClr" => {
96                        let mut obj = RgbColorModelHex::default();
97                        obj.set_attributes(reader, e, true);
98                        self.set_rgb_color_model_hex(obj);
99                    }
100                    _ => (),
101                }
102            },
103            Event::End(ref e) => {
104                if e.name().into_inner() == b"a:gs" {
105                    return
106                }
107            },
108            Event::Eof => panic!("Error: Could not find {} end element", "a:gs")
109        );
110    }
111
112    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
113        // a:gs
114        write_start_tag(
115            writer,
116            "a:gs",
117            vec![("pos", &self.position.to_string())],
118            false,
119        );
120
121        // a:schemeClr
122        for v in &self.scheme_color {
123            v.write_to(writer);
124        }
125
126        // a:srgbClr
127        for v in &self.rgb_color_model_hex {
128            v.write_to(writer);
129        }
130
131        write_end_tag(writer, "a:gs");
132    }
133}