umya_spreadsheet/structs/
conditional_formatting_rule.rs1use super::BooleanValue;
2use super::ColorScale;
3use super::ConditionalFormatValues;
4use super::ConditionalFormattingOperatorValues;
5use super::DataBar;
6use super::DifferentialFormats;
7use super::EnumValue;
8use super::Formula;
9use super::IconSet;
10use super::Int32Value;
11use super::StringValue;
12use super::Style;
13use super::TimePeriodValues;
14use super::UInt32Value;
15use crate::reader::driver::*;
16use crate::writer::driver::*;
17use quick_xml::events::BytesStart;
18use quick_xml::events::Event;
19use quick_xml::Reader;
20use quick_xml::Writer;
21use std::io::Cursor;
22
23#[derive(Clone, Default, Debug)]
24pub struct ConditionalFormattingRule {
25 r#type: EnumValue<ConditionalFormatValues>,
26 operator: EnumValue<ConditionalFormattingOperatorValues>,
27 text: StringValue,
28 priority: Int32Value,
29 percent: BooleanValue,
30 bottom: BooleanValue,
31 rank: UInt32Value,
32 stop_if_true: BooleanValue,
33 std_dev: Int32Value,
34 above_average: BooleanValue,
35 equal_average: BooleanValue,
36 time_period: EnumValue<TimePeriodValues>,
37 style: Option<Box<Style>>,
38 color_scale: Option<ColorScale>,
39 data_bar: Option<DataBar>,
40 icon_set: Option<IconSet>,
41 formula: Option<Box<Formula>>,
42}
43
44impl ConditionalFormattingRule {
45 #[inline]
46 pub fn get_type(&self) -> &ConditionalFormatValues {
47 self.r#type.get_value()
48 }
49
50 #[inline]
51 pub fn set_type(&mut self, value: ConditionalFormatValues) -> &mut Self {
52 self.r#type.set_value(value);
53 self
54 }
55
56 #[inline]
57 pub fn get_operator(&self) -> &ConditionalFormattingOperatorValues {
58 self.operator.get_value()
59 }
60
61 #[inline]
62 pub fn set_operator(&mut self, value: ConditionalFormattingOperatorValues) -> &mut Self {
63 self.operator.set_value(value);
64 self
65 }
66
67 #[inline]
68 pub fn get_text(&self) -> &str {
69 self.text.get_value_str()
70 }
71
72 #[inline]
73 pub fn set_text<S: Into<String>>(&mut self, value: S) -> &mut Self {
74 self.text.set_value(value.into());
75 self
76 }
77
78 #[inline]
79 pub fn get_priority(&self) -> &i32 {
80 self.priority.get_value()
81 }
82
83 #[inline]
84 pub fn set_priority(&mut self, value: i32) -> &mut Self {
85 self.priority.set_value(value);
86 self
87 }
88
89 #[inline]
90 pub fn get_percent(&self) -> &bool {
91 self.percent.get_value()
92 }
93
94 #[inline]
95 pub fn set_percent(&mut self, value: bool) -> &mut Self {
96 self.percent.set_value(value);
97 self
98 }
99
100 #[inline]
101 pub fn get_bottom(&self) -> &bool {
102 self.bottom.get_value()
103 }
104
105 #[inline]
106 pub fn set_bottom(&mut self, value: bool) -> &mut Self {
107 self.bottom.set_value(value);
108 self
109 }
110
111 #[inline]
112 pub fn get_rank(&self) -> &u32 {
113 self.rank.get_value()
114 }
115
116 #[inline]
117 pub fn set_rank(&mut self, value: u32) -> &mut Self {
118 self.rank.set_value(value);
119 self
120 }
121
122 #[inline]
123 pub fn get_stop_if_true(&self) -> &bool {
124 self.stop_if_true.get_value()
125 }
126
127 #[inline]
128 pub fn set_stop_if_true(&mut self, value: bool) -> &mut Self {
129 self.stop_if_true.set_value(value);
130 self
131 }
132
133 #[inline]
134 pub fn get_std_dev(&self) -> &i32 {
135 self.std_dev.get_value()
136 }
137
138 #[inline]
139 pub fn set_std_dev(&mut self, value: i32) -> &mut Self {
140 self.std_dev.set_value(value);
141 self
142 }
143
144 #[inline]
145 pub fn get_above_average(&self) -> &bool {
146 self.above_average.get_value()
147 }
148
149 #[inline]
150 pub fn set_above_average(&mut self, value: bool) -> &mut Self {
151 self.above_average.set_value(value);
152 self
153 }
154
155 #[inline]
156 pub fn get_equal_average(&self) -> &bool {
157 self.equal_average.get_value()
158 }
159
160 #[inline]
161 pub fn set_equal_average(&mut self, value: bool) -> &mut Self {
162 self.equal_average.set_value(value);
163 self
164 }
165
166 #[inline]
167 pub fn get_time_period(&self) -> &TimePeriodValues {
168 self.time_period.get_value()
169 }
170
171 #[inline]
172 pub fn set_time_period(&mut self, value: TimePeriodValues) -> &mut Self {
173 self.time_period.set_value(value);
174 self
175 }
176
177 #[inline]
178 pub fn get_style(&self) -> Option<&Style> {
179 self.style.as_deref()
180 }
181
182 #[inline]
183 pub fn set_style(&mut self, value: Style) -> &mut Self {
184 self.style = Some(Box::new(value));
185 self
186 }
187
188 #[inline]
189 pub fn remove_style(&mut self) -> &mut Self {
190 self.style = None;
191 self
192 }
193
194 #[inline]
195 pub fn get_color_scale(&self) -> Option<&ColorScale> {
196 self.color_scale.as_ref()
197 }
198
199 #[inline]
200 pub fn set_color_scale(&mut self, value: ColorScale) -> &mut Self {
201 self.color_scale = Some(value);
202 self
203 }
204
205 #[inline]
206 pub fn remove_color_scale(&mut self) -> &mut Self {
207 self.color_scale = None;
208 self
209 }
210
211 #[inline]
212 pub fn get_data_bar(&self) -> Option<&DataBar> {
213 self.data_bar.as_ref()
214 }
215
216 #[inline]
217 pub fn set_data_bar(&mut self, value: DataBar) -> &mut Self {
218 self.data_bar = Some(value);
219 self
220 }
221
222 #[inline]
223 pub fn remove_data_bar(&mut self) -> &mut Self {
224 self.data_bar = None;
225 self
226 }
227
228 #[inline]
229 pub fn get_icon_set(&self) -> Option<&IconSet> {
230 self.icon_set.as_ref()
231 }
232
233 #[inline]
234 pub fn set_icon_set(&mut self, value: IconSet) -> &mut Self {
235 self.icon_set = Some(value);
236 self
237 }
238
239 #[inline]
240 pub fn remove_icon_set(&mut self) -> &mut Self {
241 self.icon_set = None;
242 self
243 }
244
245 #[inline]
246 pub fn get_formula(&self) -> Option<&Formula> {
247 self.formula.as_deref()
248 }
249
250 #[inline]
251 pub fn set_formula(&mut self, value: Formula) -> &mut Self {
252 self.formula = Some(Box::new(value));
253 self
254 }
255
256 #[inline]
257 pub fn remove_formula(&mut self) -> &mut Self {
258 self.formula = None;
259 self
260 }
261
262 pub(crate) fn set_attributes<R: std::io::BufRead>(
263 &mut self,
264 reader: &mut Reader<R>,
265 e: &BytesStart,
266 differential_formats: &DifferentialFormats,
267 empty_flag: bool,
268 ) {
269 set_string_from_xml!(self, e, r#type, "type");
270 set_string_from_xml!(self, e, operator, "operator");
271
272 if let Some(v) = get_attribute(e, b"dxfId") {
273 let dxf_id = v.parse::<usize>().unwrap();
274 let style = differential_formats.get_style(dxf_id);
275 self.set_style(style);
276 }
277
278 set_string_from_xml!(self, e, priority, "priority");
279 set_string_from_xml!(self, e, percent, "percent");
280 set_string_from_xml!(self, e, bottom, "bottom");
281 set_string_from_xml!(self, e, rank, "rank");
282 set_string_from_xml!(self, e, stop_if_true, "stopIfTrue");
283 set_string_from_xml!(self, e, std_dev, "stdDev");
284 set_string_from_xml!(self, e, time_period, "timePeriod");
285 set_string_from_xml!(self, e, above_average, "aboveAverage");
286 set_string_from_xml!(self, e, equal_average, "equalAverage");
287
288 if empty_flag {
289 return;
290 }
291
292 xml_read_loop!(
293 reader,
294 Event::Start(ref e) => {
295 match e.name().into_inner() {
296 b"colorScale" => {
297 let mut obj = ColorScale::default();
298 obj.set_attributes(reader, e);
299 self.color_scale = Some(obj);
300 }
301 b"dataBar" => {
302 let mut obj = DataBar::default();
303 obj.set_attributes(reader, e);
304 self.data_bar = Some(obj);
305 }
306 b"iconSet" => {
307 let mut obj = IconSet::default();
308 obj.set_attributes(reader, e);
309 self.icon_set = Some(obj);
310 }
311 b"formula" => {
312 let mut obj = Formula::default();
313 obj.set_attributes(reader, e);
314 self.formula = Some(Box::new(obj));
315 }
316 _ => (),
317 }
318 },
319 Event::End(ref e) => {
320 if e.name().into_inner() == b"cfRule" {
321 return
322 }
323 },
324 Event::Eof => panic!("Error: Could not find {} end element", "cfRule")
325 );
326 }
327
328 pub(crate) fn write_to(
329 &self,
330 writer: &mut Writer<Cursor<Vec<u8>>>,
331 differential_formats: &mut DifferentialFormats,
332 ) {
333 let is_inner = self.color_scale.is_some()
334 || self.data_bar.is_some()
335 || self.icon_set.is_some()
336 || self.formula.is_some();
337
338 let mut attributes: Vec<(&str, &str)> = Vec::new();
340
341 let r#type = self.r#type.get_value_string();
342 if self.r#type.has_value() {
343 attributes.push(("type", r#type));
344 }
345
346 let operator = self.operator.get_value_string();
347 if self.operator.has_value() {
348 attributes.push(("operator", operator));
349 }
350
351 let dxf_id_str: String;
352 if let Some(v) = &self.style {
353 let dxf_id = differential_formats.set_style(v);
354 dxf_id_str = dxf_id.to_string();
355 attributes.push(("dxfId", &dxf_id_str));
356 }
357
358 let priority = self.priority.get_value_string();
359 if self.priority.has_value() {
360 attributes.push(("priority", &priority));
361 }
362
363 let percent = self.percent.get_value_string();
364 if self.percent.has_value() {
365 attributes.push(("percent", percent));
366 }
367
368 let bottom = self.bottom.get_value_string();
369 if self.bottom.has_value() {
370 attributes.push(("bottom", bottom));
371 }
372
373 let rank = self.rank.get_value_string();
374 if self.rank.has_value() {
375 attributes.push(("rank", &rank));
376 }
377
378 let stop_if_true = self.stop_if_true.get_value_string();
379 if self.stop_if_true.has_value() {
380 attributes.push(("stopIfTrue", stop_if_true));
381 }
382
383 let std_dev = self.std_dev.get_value_string();
384 if self.std_dev.has_value() {
385 attributes.push(("stdDev", &std_dev));
386 }
387
388 let time_period = self.time_period.get_value_string();
389 if self.time_period.has_value() {
390 attributes.push(("timePeriod", time_period));
391 }
392
393 let above_average = self.above_average.get_value_string();
394 if self.above_average.has_value() {
395 attributes.push(("aboveAverage", above_average));
396 }
397
398 let equal_average = self.equal_average.get_value_string();
399 if self.equal_average.has_value() {
400 attributes.push(("equalAverage", equal_average));
401 }
402
403 write_start_tag(writer, "cfRule", attributes, !is_inner);
404
405 if is_inner {
406 if let Some(v) = &self.color_scale {
408 v.write_to(writer)
409 }
410
411 if let Some(v) = &self.data_bar {
413 v.write_to(writer)
414 }
415
416 if let Some(v) = &self.icon_set {
418 v.write_to(writer)
419 }
420
421 if let Some(v) = &self.formula {
423 v.write_to(writer)
424 }
425
426 write_end_tag(writer, "cfRule");
427 }
428 }
429}