umya_spreadsheet/structs/drawing/charts/
title.rs

1// c:title
2use super::ChartText;
3use super::Layout;
4use super::Overlay;
5use super::ShapeProperties;
6use crate::structs::Spreadsheet;
7use crate::writer::driver::*;
8use crate::xml_read_loop;
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 Title {
16    chart_text: Option<ChartText>,
17    layout: Option<Layout>,
18    overlay: Overlay,
19    shape_properties: Option<ShapeProperties>,
20}
21
22impl Title {
23    pub fn get_chart_text(&self) -> Option<&ChartText> {
24        self.chart_text.as_ref()
25    }
26
27    pub fn get_chart_text_mut(&mut self) -> Option<&mut ChartText> {
28        self.chart_text.as_mut()
29    }
30
31    pub fn set_chart_text(&mut self, value: ChartText) -> &mut Title {
32        self.chart_text = Some(value);
33        self
34    }
35
36    pub fn get_layout(&self) -> Option<&Layout> {
37        self.layout.as_ref()
38    }
39
40    pub fn get_layout_mut(&mut self) -> Option<&mut Layout> {
41        self.layout.as_mut()
42    }
43
44    pub fn set_layout(&mut self, value: Layout) -> &mut Title {
45        self.layout = Some(value);
46        self
47    }
48
49    pub fn get_overlay(&self) -> &Overlay {
50        &self.overlay
51    }
52
53    pub fn get_overlay_mut(&mut self) -> &mut Overlay {
54        &mut self.overlay
55    }
56
57    pub fn set_overlay(&mut self, value: Overlay) -> &mut Title {
58        self.overlay = value;
59        self
60    }
61
62    pub fn get_shape_properties(&self) -> Option<&ShapeProperties> {
63        self.shape_properties.as_ref()
64    }
65
66    pub fn get_shape_properties_mut(&mut self) -> Option<&mut ShapeProperties> {
67        self.shape_properties.as_mut()
68    }
69
70    pub fn set_shape_properties(&mut self, value: ShapeProperties) -> &mut Self {
71        self.shape_properties = Some(value);
72        self
73    }
74
75    pub(crate) fn set_attributes<R: std::io::BufRead>(
76        &mut self,
77        reader: &mut Reader<R>,
78        _e: &BytesStart,
79    ) {
80        xml_read_loop!(
81            reader,
82            Event::Start(ref e) => match e.name().0 {
83                b"c:tx" => {
84                    let mut obj = ChartText::default();
85                    obj.set_attributes(reader, e);
86                    self.set_chart_text(obj);
87                }
88                b"c:layout" => {
89                    let mut obj = Layout::default();
90                    obj.set_attributes(reader, e, false);
91                    self.set_layout(obj);
92                }
93                b"c:spPr" => {
94                    let mut obj = ShapeProperties::default();
95                    obj.set_attributes(reader, e);
96                    self.set_shape_properties(obj);
97                }
98                _ => (),
99            },
100            Event::Empty(ref e) => match e.name().0 {
101                b"c:overlay" => {
102                    self.overlay.set_attributes(reader, e);
103                }
104                b"c:layout" => {
105                    let mut obj = Layout::default();
106                    obj.set_attributes(reader, e, true);
107                    self.set_layout(obj);
108                }
109                _ => (),
110            },
111            Event::End(ref e) => {
112                if e.name().0 == b"c:title" {
113                    return;
114                }
115            },
116            Event::Eof => panic!("Error: Could not find {} end element", "c:title"),
117        );
118    }
119
120    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>, spreadsheet: &Spreadsheet) {
121        // c:title
122        write_start_tag(writer, "c:title", vec![], false);
123
124        // c:tx
125        if let Some(v) = &self.chart_text {
126            v.write_to(writer, spreadsheet);
127        }
128
129        // c:layout
130        if let Some(v) = &self.layout {
131            v.write_to(writer);
132        }
133
134        // c:overlay
135        self.overlay.write_to(writer);
136
137        // c:spPr
138        if let Some(v) = &self.shape_properties {
139            v.write_to(writer);
140        }
141
142        write_end_tag(writer, "c:title");
143    }
144}