umya_spreadsheet/structs/
comment_text.rs

1// text
2use super::vml::office::InsetMarginValues;
3use super::vml::spreadsheet::Anchor;
4use super::vml::spreadsheet::CommentColumnTarget;
5use super::vml::spreadsheet::CommentRowTarget;
6use super::vml::spreadsheet::MoveWithCells;
7use super::vml::spreadsheet::ResizeWithCells;
8use super::vml::Fill as VmlFill;
9use super::vml::Path;
10use super::vml::Shadow;
11use super::vml::TextBox;
12use super::Coordinate;
13use super::Fill;
14use super::PhoneticRun;
15use super::RichText;
16use super::Text;
17use super::TextElement;
18use crate::helper::coordinate::*;
19use crate::reader::driver::*;
20use crate::structs::vml::Shape;
21use crate::traits::AdjustmentCoordinate;
22use crate::writer::driver::*;
23use crate::xml_read_loop;
24use quick_xml::events::{BytesStart, Event};
25use quick_xml::Reader;
26use quick_xml::Writer;
27use std::io::Cursor;
28
29#[derive(Clone, Default, Debug)]
30pub struct CommentText {
31    text: Option<Text>,
32    rich_text: Option<RichText>,
33}
34
35impl CommentText {
36    #[inline]
37    pub(crate) fn get_text(&self) -> Option<&Text> {
38        self.text.as_ref()
39    }
40
41    #[inline]
42    pub(crate) fn get_text_mut(&mut self) -> Option<&mut Text> {
43        self.text.as_mut()
44    }
45
46    #[inline]
47    pub(crate) fn set_text(&mut self, value: Text) -> &mut Self {
48        self.text = Some(value);
49        self
50    }
51
52    #[inline]
53    pub(crate) fn remove_text(&mut self) -> &mut Self {
54        self.text = None;
55        self
56    }
57
58    #[inline]
59    pub(crate) fn get_rich_text(&self) -> Option<&RichText> {
60        self.rich_text.as_ref()
61    }
62
63    #[inline]
64    pub(crate) fn get_rich_text_mut(&mut self) -> Option<&mut RichText> {
65        self.rich_text.as_mut()
66    }
67
68    #[inline]
69    pub(crate) fn set_rich_text(&mut self, value: RichText) -> &mut Self {
70        self.rich_text = Some(value);
71        self
72    }
73
74    #[inline]
75    pub(crate) fn remove_rich_text(&mut self) -> &mut Self {
76        self.rich_text = None;
77        self
78    }
79
80    #[inline]
81    pub fn set_text_string<S: Into<String>>(&mut self, value: S) -> &mut Self {
82        let mut obj = Text::default();
83        obj.set_value(value);
84        self.set_text(obj);
85        self
86    }
87
88    #[inline]
89    pub(crate) fn set_attributes<R: std::io::BufRead>(
90        &mut self,
91        reader: &mut Reader<R>,
92        e: &BytesStart,
93    ) {
94        let mut vec_text_element: Vec<TextElement> = Vec::new();
95
96        xml_read_loop!(
97            reader,
98            Event::Start(ref e) => {
99                match e.name().into_inner() {
100                    b"t" => {
101                        let mut obj = Text::default();
102                        obj.set_attributes(reader, e);
103                        self.set_text(obj);
104                    }
105                    b"r" => {
106                        let mut obj = TextElement::default();
107                        obj.set_attributes(reader, e);
108                        vec_text_element.push(obj);
109                    }
110                    b"rPh" => {
111                        let mut obj = PhoneticRun::default();
112                        obj.set_attributes(reader, e);
113                    }
114                    _ => (),
115                }
116            },
117            Event::End(ref e) => {
118                if e.name().into_inner() == b"text" {
119                    if !vec_text_element.is_empty() {
120                        let mut obj = RichText::default();
121                        obj.set_rich_text_elements(vec_text_element);
122                        self.set_rich_text(obj);
123                    }
124                    return;
125                }
126            },
127            Event::Eof => panic!("Error: Could not find {} end element", "text")
128        );
129    }
130
131    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
132        // text
133        write_start_tag(writer, "text", vec![], false);
134
135        // t
136        if let Some(v) = &self.text {
137            v.write_to(writer);
138        }
139
140        // r
141        if let Some(v) = &self.rich_text {
142            v.write_to(writer);
143        }
144
145        write_end_tag(writer, "text");
146    }
147}