Skip to main content

umya_spreadsheet/structs/drawing/
run.rs

1use std::io::Cursor;
2
3use quick_xml::{
4    Reader,
5    Writer,
6    events::{
7        BytesStart,
8        Event,
9    },
10};
11
12use super::run_properties::RunProperties;
13use crate::{
14    reader::driver::xml_read_loop,
15    writer::driver::{
16        write_end_tag,
17        write_start_tag,
18        write_text_node,
19    },
20};
21
22#[derive(Clone, Default, Debug)]
23pub struct Run {
24    text:           Box<str>,
25    run_properties: RunProperties,
26}
27
28impl Run {
29    #[inline]
30    #[must_use]
31    pub fn text(&self) -> &str {
32        &self.text
33    }
34
35    #[inline]
36    #[must_use]
37    #[deprecated(since = "3.0.0", note = "Use text()")]
38    pub fn get_text(&self) -> &str {
39        self.text()
40    }
41
42    #[inline]
43    pub fn set_text<S: Into<String>>(&mut self, value: S) {
44        self.text = value.into().into_boxed_str();
45    }
46
47    #[inline]
48    #[must_use]
49    pub fn run_properties(&self) -> &RunProperties {
50        &self.run_properties
51    }
52
53    #[inline]
54    #[must_use]
55    #[deprecated(since = "3.0.0", note = "Use run_properties()")]
56    pub fn get_run_properties(&self) -> &RunProperties {
57        self.run_properties()
58    }
59
60    #[inline]
61    pub fn run_properties_mut(&mut self) -> &mut RunProperties {
62        &mut self.run_properties
63    }
64
65    #[inline]
66    #[deprecated(since = "3.0.0", note = "Use run_properties_mut()")]
67    pub fn get_run_properties_mut(&mut self) -> &mut RunProperties {
68        self.run_properties_mut()
69    }
70
71    #[inline]
72    pub fn set_run_properties(&mut self, value: RunProperties) {
73        self.run_properties = value;
74    }
75
76    pub(crate) fn set_attributes<R: std::io::BufRead>(
77        &mut self,
78        reader: &mut Reader<R>,
79        _e: &BytesStart,
80    ) {
81        xml_read_loop!(
82            reader,
83            ref n @ (Event::Empty(ref e) | Event::Start(ref e)) => {
84                let is_empty = matches!(n, Event::Empty(_));
85                match e.name().into_inner(){
86                    b"a:rPr"=> {
87                        self.run_properties.set_attributes(reader, e, is_empty);
88                    }
89                    b"a:t"=> {
90                        if !is_empty {
91                            let mut buf = Vec::new();
92                            let text = crate::helper::utils::unescape_xml_text(
93                                &reader.read_text_into(e.name(), &mut buf).unwrap()
94                            );
95                            self.set_text(text);
96                        }
97                    }
98                    _=>{}
99                }
100            },
101            Event::End(ref e) => {
102                if e.name().0 == b"a:r" {
103                    return;
104                }
105            },
106            Event::Eof => panic!("Error: Could not find {} end element", "a:r")
107        );
108    }
109
110    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
111        // a:r
112        write_start_tag(writer, "a:r", vec![], false);
113
114        // a:rPr
115        self.run_properties.write_to_rpr(writer);
116
117        // a:t
118        write_start_tag(writer, "a:t", vec![], false);
119        write_text_node(writer, &*self.text);
120        write_end_tag(writer, "a:t");
121
122        write_end_tag(writer, "a:r");
123    }
124}