umya_spreadsheet/structs/drawing/charts/
marker.rs

1// c:marker
2use super::ShapeProperties;
3use super::Size;
4use super::Symbol;
5use crate::reader::driver::*;
6use crate::writer::driver::*;
7use quick_xml::events::{BytesStart, Event};
8use quick_xml::Reader;
9use quick_xml::Writer;
10use std::io::Cursor;
11
12#[derive(Clone, Default, Debug)]
13pub struct Marker {
14    symbol: Option<Symbol>,
15    size: Option<Size>,
16    shape_properties: Option<ShapeProperties>,
17}
18
19impl Marker {
20    pub fn get_symbol(&self) -> Option<&Symbol> {
21        self.symbol.as_ref()
22    }
23
24    pub fn get_symbol_mut(&mut self) -> Option<&mut Symbol> {
25        self.symbol.as_mut()
26    }
27
28    pub fn set_symbol(&mut self, value: Symbol) -> &mut Marker {
29        self.symbol = Some(value);
30        self
31    }
32
33    pub fn get_size(&self) -> Option<&Size> {
34        self.size.as_ref()
35    }
36
37    pub fn get_size_mut(&mut self) -> Option<&mut Size> {
38        self.size.as_mut()
39    }
40
41    pub fn set_size(&mut self, value: Size) -> &mut Marker {
42        self.size = Some(value);
43        self
44    }
45
46    pub fn get_shape_properties(&self) -> Option<&ShapeProperties> {
47        self.shape_properties.as_ref()
48    }
49
50    pub fn get_shape_properties_mut(&mut self) -> Option<&mut ShapeProperties> {
51        self.shape_properties.as_mut()
52    }
53
54    pub fn set_shape_properties(&mut self, value: ShapeProperties) -> &mut Self {
55        self.shape_properties = Some(value);
56        self
57    }
58
59    pub(crate) fn set_attributes<R: std::io::BufRead>(
60        &mut self,
61        reader: &mut Reader<R>,
62        _: &BytesStart,
63        empty_flag: bool,
64    ) {
65        if empty_flag {
66            return;
67        }
68
69        xml_read_loop!(
70            reader,
71            Event::Empty(ref e) => {
72                if e.name().0 == b"c:symbol" {
73                    let mut obj = Symbol::default();
74                    obj.set_attributes(reader, e);
75                    self.set_symbol(obj);
76                }
77                if e.name().0 == b"c:size" {
78                    let mut obj = Size::default();
79                    obj.set_attributes(reader, e);
80                    self.set_size(obj);
81                }
82            },
83            Event::Start(ref e) => {
84                if e.name().0 == b"c:spPr" {
85                    let mut obj = ShapeProperties::default();
86                    obj.set_attributes(reader, e);
87                    self.set_shape_properties(obj);
88                }
89            },
90            Event::End(ref e) => {
91                if e.name().0 == b"c:marker" {
92                    return;
93                }
94            },
95            Event::Eof => panic!("Error: Could not find {} end element", "c:marker")
96        );
97    }
98
99    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
100        // c:marker
101        if self.symbol.is_some() {
102            write_start_tag(writer, "c:marker", vec![], false);
103
104            // a:symbol
105            if let Some(v) = &self.symbol {
106                v.write_to(writer);
107            }
108
109            // c:size
110            if let Some(v) = &self.size {
111                v.write_to(writer);
112            }
113
114            // c:spPr
115            if let Some(v) = &self.shape_properties {
116                v.write_to(writer);
117            }
118
119            write_end_tag(writer, "c:marker");
120        } else {
121            write_start_tag(writer, "c:marker", vec![], true);
122        }
123    }
124}