umya_spreadsheet/structs/
fill.rs

1use super::GradientFill;
2use super::PatternFill;
3use super::PatternValues;
4use crate::reader::driver::*;
5use crate::writer::driver::*;
6use md5::Digest;
7use quick_xml::events::{BytesStart, Event};
8use quick_xml::Reader;
9use quick_xml::Writer;
10use std::io::Cursor;
11
12#[derive(Default, Debug, Clone, PartialEq, PartialOrd)]
13pub struct Fill {
14    pattern_fill: Option<Box<PatternFill>>,
15    gradient_fill: Option<Box<GradientFill>>,
16}
17
18impl Fill {
19    #[inline]
20    pub fn get_pattern_fill(&self) -> Option<&PatternFill> {
21        self.pattern_fill.as_deref()
22    }
23
24    #[inline]
25    pub fn get_pattern_fill_mut(&mut self) -> &mut PatternFill {
26        if self.pattern_fill.is_some() {
27            return self.pattern_fill.as_mut().unwrap();
28        }
29        self.set_pattern_fill(PatternFill::default());
30        self.pattern_fill.as_mut().unwrap()
31    }
32
33    #[inline]
34    pub fn set_pattern_fill(&mut self, value: PatternFill) -> &mut Self {
35        self.pattern_fill = Some(Box::new(value));
36        self.gradient_fill = None;
37        self
38    }
39
40    #[inline]
41    pub fn get_gradient_fill(&self) -> Option<&GradientFill> {
42        self.gradient_fill.as_deref()
43    }
44
45    #[inline]
46    pub fn get_gradient_fill_mut(&mut self) -> &mut GradientFill {
47        if self.gradient_fill.is_some() {
48            return self.gradient_fill.as_mut().unwrap();
49        }
50        self.set_gradient_fill(GradientFill::default());
51        self.gradient_fill.as_mut().unwrap()
52    }
53
54    #[inline]
55    pub fn set_gradient_fill(&mut self, value: GradientFill) -> &mut Self {
56        self.pattern_fill = None;
57        self.gradient_fill = Some(Box::new(value));
58        self
59    }
60
61    #[inline]
62    pub(crate) fn get_default_value() -> Self {
63        let mut def = Self::default();
64        let mut pfill = PatternFill::default();
65        pfill.set_pattern_type(PatternValues::None);
66        def.set_pattern_fill(pfill);
67        def
68    }
69
70    #[inline]
71    pub(crate) fn get_default_value_2() -> Self {
72        let mut def = Self::default();
73        let mut pfill = PatternFill::default();
74        pfill.set_pattern_type(PatternValues::Gray125);
75        def.set_pattern_fill(pfill);
76        def
77    }
78
79    pub(crate) fn get_hash_code(&self) -> String {
80        format!(
81            "{:x}",
82            md5::Md5::digest(format!(
83                "{}{}",
84                match &self.pattern_fill {
85                    Some(v) => {
86                        v.get_hash_code()
87                    }
88                    None => {
89                        "NONE".to_string()
90                    }
91                },
92                match &self.gradient_fill {
93                    Some(v) => {
94                        v.get_hash_code()
95                    }
96                    None => {
97                        "NONE".to_string()
98                    }
99                },
100            ))
101        )
102    }
103
104    // When opened in software such as Excel, it is visually blank.
105    #[inline]
106    pub(crate) fn is_visually_empty(&self) -> bool {
107        !(self
108            .pattern_fill
109            .as_ref()
110            .is_some_and(|x| !x.is_visually_empty())
111            || self.gradient_fill.as_ref().is_some())
112    }
113
114    pub(crate) fn set_attributes<R: std::io::BufRead>(
115        &mut self,
116        reader: &mut Reader<R>,
117        _e: &BytesStart,
118    ) {
119        xml_read_loop!(
120            reader,
121            Event::Empty(ref e) => {
122                if e.name().into_inner() == b"patternFill" {
123                    let mut obj = PatternFill::default();
124                    obj.set_attributes(reader, e, true);
125                    self.set_pattern_fill(obj);
126                }
127            },
128            Event::Start(ref e) => {
129                match e.name().into_inner() {
130                    b"patternFill" => {
131                        let mut obj = PatternFill::default();
132                        obj.set_attributes(reader, e, false);
133                        self.set_pattern_fill(obj);
134                    }
135                    b"gradientFill" => {
136                        let mut obj = GradientFill::default();
137                        obj.set_attributes(reader, e);
138                        self.set_gradient_fill(obj);
139                    }
140                    _ => (),
141                }
142            },
143            Event::End(ref e) => {
144                if e.name().into_inner() == b"fill" {
145                    return
146                }
147            },
148            Event::Eof => panic!("Error: Could not find {} end element", "fill")
149        );
150    }
151
152    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
153        // fill
154        write_start_tag(writer, "fill", vec![], false);
155
156        // gradientFill
157        if let Some(v) = &self.pattern_fill {
158            v.write_to(writer);
159        }
160
161        // patternFill
162        if let Some(v) = &self.gradient_fill {
163            v.write_to(writer);
164        }
165
166        write_end_tag(writer, "fill");
167    }
168}
umya_spreadsheet/structs/fill.rs

umya_spreadsheet/structs/
fill.rs
