umya_spreadsheet/structs/drawing/charts/
plot_area.rs

1// c:plotArea
2use std::io::Cursor;
3
4use quick_xml::{
5    Reader,
6    Writer,
7    events::{
8        BytesStart,
9        Event,
10    },
11};
12
13use super::{
14    Area3DChart,
15    AreaChart,
16    AreaChartSeriesList,
17    Bar3DChart,
18    BarChart,
19    BubbleChart,
20    CategoryAxis,
21    DoughnutChart,
22    Formula,
23    GroupingValues,
24    Layout,
25    Line3DChart,
26    LineChart,
27    OfPieChart,
28    Pie3DChart,
29    PieChart,
30    RadarChart,
31    ScatterChart,
32    SeriesAxis,
33    ShapeProperties,
34    ValueAxis,
35};
36use crate::{
37    drawing::charts::DateAxis,
38    structs::Workbook,
39    traits::AdjustmentCoordinateWithSheet,
40    writer::driver::{
41        write_end_tag,
42        write_start_tag,
43    },
44    xml_read_loop,
45};
46
47#[derive(Clone, Default, Debug)]
48pub struct PlotArea {
49    layout:           Layout,
50    line_chart:       Option<LineChart>,
51    line_3d_chart:    Option<Line3DChart>,
52    pie_chart:        Option<PieChart>,
53    pie_3d_chart:     Option<Pie3DChart>,
54    doughnut_chart:   Option<DoughnutChart>,
55    scatter_chart:    Option<ScatterChart>,
56    bar_chart:        Option<BarChart>,
57    bar_3d_chart:     Option<Bar3DChart>,
58    radar_chart:      Option<RadarChart>,
59    bubble_chart:     Option<BubbleChart>,
60    area_chart:       Option<AreaChart>,
61    area_3d_chart:    Option<Area3DChart>,
62    of_pie_chart:     Option<OfPieChart>,
63    category_axis:    Vec<CategoryAxis>,
64    date_axis:        Vec<DateAxis>,
65    value_axis:       Vec<ValueAxis>,
66    series_axis:      Vec<SeriesAxis>,
67    shape_properties: Option<ShapeProperties>,
68}
69
70impl PlotArea {
71    #[must_use]
72    pub fn layout(&self) -> &Layout {
73        &self.layout
74    }
75
76    #[must_use]
77    #[deprecated(since = "3.0.0", note = "Use layout()")]
78    pub fn get_layout(&self) -> &Layout {
79        self.layout()
80    }
81
82    pub fn layout_mut(&mut self) -> &mut Layout {
83        &mut self.layout
84    }
85
86    #[deprecated(since = "3.0.0", note = "Use layout_mut()")]
87    pub fn get_layout_mut(&mut self) -> &mut Layout {
88        self.layout_mut()
89    }
90
91    pub fn set_layout(&mut self, value: Layout) -> &mut Self {
92        self.layout = value;
93        self
94    }
95
96    #[must_use]
97    pub fn line_chart(&self) -> Option<&LineChart> {
98        self.line_chart.as_ref()
99    }
100
101    #[must_use]
102    #[deprecated(since = "3.0.0", note = "Use line_chart()")]
103    pub fn get_line_chart(&self) -> Option<&LineChart> {
104        self.line_chart()
105    }
106
107    pub fn line_chart_mut(&mut self) -> Option<&mut LineChart> {
108        self.line_chart.as_mut()
109    }
110
111    #[deprecated(since = "3.0.0", note = "Use line_chart_mut()")]
112    pub fn get_line_chart_mut(&mut self) -> Option<&mut LineChart> {
113        self.line_chart_mut()
114    }
115
116    pub fn set_line_chart(&mut self, value: LineChart) -> &mut Self {
117        self.line_chart = Some(value);
118        self
119    }
120
121    #[must_use]
122    pub fn line_3d_chart(&self) -> Option<&Line3DChart> {
123        self.line_3d_chart.as_ref()
124    }
125
126    #[must_use]
127    #[deprecated(since = "3.0.0", note = "Use line_3d_chart()")]
128    pub fn get_line_3d_chart(&self) -> Option<&Line3DChart> {
129        self.line_3d_chart()
130    }
131
132    pub fn line_3d_chart_mut(&mut self) -> Option<&mut Line3DChart> {
133        self.line_3d_chart.as_mut()
134    }
135
136    #[deprecated(since = "3.0.0", note = "Use line_3d_chart_mut()")]
137    pub fn get_line_3d_chart_mut(&mut self) -> Option<&mut Line3DChart> {
138        self.line_3d_chart_mut()
139    }
140
141    pub fn set_line_3d_chart(&mut self, value: Line3DChart) -> &mut Self {
142        self.line_3d_chart = Some(value);
143        self
144    }
145
146    #[must_use]
147    pub fn pie_chart(&self) -> Option<&PieChart> {
148        self.pie_chart.as_ref()
149    }
150
151    #[must_use]
152    #[deprecated(since = "3.0.0", note = "Use pie_chart()")]
153    pub fn get_pie_chart(&self) -> Option<&PieChart> {
154        self.pie_chart()
155    }
156
157    pub fn pie_chart_mut(&mut self) -> Option<&mut PieChart> {
158        self.pie_chart.as_mut()
159    }
160
161    #[deprecated(since = "3.0.0", note = "Use pie_chart_mut()")]
162    pub fn get_pie_chart_mut(&mut self) -> Option<&mut PieChart> {
163        self.pie_chart_mut()
164    }
165
166    pub fn set_pie_chart(&mut self, value: PieChart) -> &mut Self {
167        self.pie_chart = Some(value);
168        self
169    }
170
171    #[must_use]
172    pub fn pie_3d_chart(&self) -> Option<&Pie3DChart> {
173        self.pie_3d_chart.as_ref()
174    }
175
176    #[must_use]
177    #[deprecated(since = "3.0.0", note = "Use pie_3d_chart()")]
178    pub fn get_pie_3d_chart(&self) -> Option<&Pie3DChart> {
179        self.pie_3d_chart()
180    }
181
182    pub fn pie_3d_chart_mut(&mut self) -> Option<&mut Pie3DChart> {
183        self.pie_3d_chart.as_mut()
184    }
185
186    #[deprecated(since = "3.0.0", note = "Use pie_3d_chart_mut()")]
187    pub fn get_pie_3d_chart_mut(&mut self) -> Option<&mut Pie3DChart> {
188        self.pie_3d_chart_mut()
189    }
190
191    pub fn set_pie_3d_chart(&mut self, value: Pie3DChart) -> &mut Self {
192        self.pie_3d_chart = Some(value);
193        self
194    }
195
196    #[must_use]
197    pub fn doughnut_chart(&self) -> Option<&DoughnutChart> {
198        self.doughnut_chart.as_ref()
199    }
200
201    #[must_use]
202    #[deprecated(since = "3.0.0", note = "Use doughnut_chart()")]
203    pub fn get_doughnut_chart(&self) -> Option<&DoughnutChart> {
204        self.doughnut_chart()
205    }
206
207    pub fn doughnut_chart_mut(&mut self) -> Option<&mut DoughnutChart> {
208        self.doughnut_chart.as_mut()
209    }
210
211    #[deprecated(since = "3.0.0", note = "Use doughnut_chart_mut()")]
212    pub fn get_doughnut_chart_mut(&mut self) -> Option<&mut DoughnutChart> {
213        self.doughnut_chart_mut()
214    }
215
216    pub fn set_doughnut_chart(&mut self, value: DoughnutChart) -> &mut Self {
217        self.doughnut_chart = Some(value);
218        self
219    }
220
221    #[must_use]
222    pub fn scatter_chart(&self) -> Option<&ScatterChart> {
223        self.scatter_chart.as_ref()
224    }
225
226    #[must_use]
227    #[deprecated(since = "3.0.0", note = "Use scatter_chart()")]
228    pub fn get_scatter_chart(&self) -> Option<&ScatterChart> {
229        self.scatter_chart()
230    }
231
232    pub fn scatter_chart_mut(&mut self) -> Option<&mut ScatterChart> {
233        self.scatter_chart.as_mut()
234    }
235
236    #[deprecated(since = "3.0.0", note = "Use scatter_chart_mut()")]
237    pub fn get_scatter_chart_mut(&mut self) -> Option<&mut ScatterChart> {
238        self.scatter_chart_mut()
239    }
240
241    pub fn set_scatter_chart(&mut self, value: ScatterChart) -> &mut Self {
242        self.scatter_chart = Some(value);
243        self
244    }
245
246    #[must_use]
247    pub fn bar_chart(&self) -> Option<&BarChart> {
248        self.bar_chart.as_ref()
249    }
250
251    #[must_use]
252    #[deprecated(since = "3.0.0", note = "Use bar_chart()")]
253    pub fn get_bar_chart(&self) -> Option<&BarChart> {
254        self.bar_chart()
255    }
256
257    pub fn bar_chart_mut(&mut self) -> Option<&mut BarChart> {
258        self.bar_chart.as_mut()
259    }
260
261    #[deprecated(since = "3.0.0", note = "Use bar_chart_mut()")]
262    pub fn get_bar_chart_mut(&mut self) -> Option<&mut BarChart> {
263        self.bar_chart_mut()
264    }
265
266    pub fn set_bar_chart(&mut self, value: BarChart) -> &mut Self {
267        self.bar_chart = Some(value);
268        self
269    }
270
271    #[must_use]
272    pub fn bar_3d_chart(&self) -> Option<&Bar3DChart> {
273        self.bar_3d_chart.as_ref()
274    }
275
276    #[must_use]
277    #[deprecated(since = "3.0.0", note = "Use bar_3d_chart()")]
278    pub fn get_bar_3d_chart(&self) -> Option<&Bar3DChart> {
279        self.bar_3d_chart()
280    }
281
282    pub fn bar_3d_chart_mut(&mut self) -> Option<&mut Bar3DChart> {
283        self.bar_3d_chart.as_mut()
284    }
285
286    #[deprecated(since = "3.0.0", note = "Use bar_3d_chart_mut()")]
287    pub fn get_bar_3d_chart_mut(&mut self) -> Option<&mut Bar3DChart> {
288        self.bar_3d_chart_mut()
289    }
290
291    pub fn set_bar_3d_chart(&mut self, value: Bar3DChart) -> &mut Self {
292        self.bar_3d_chart = Some(value);
293        self
294    }
295
296    #[must_use]
297    pub fn radar_chart(&self) -> Option<&RadarChart> {
298        self.radar_chart.as_ref()
299    }
300
301    #[must_use]
302    #[deprecated(since = "3.0.0", note = "Use radar_chart()")]
303    pub fn get_radar_chart(&self) -> Option<&RadarChart> {
304        self.radar_chart()
305    }
306
307    pub fn radar_chart_mut(&mut self) -> Option<&mut RadarChart> {
308        self.radar_chart.as_mut()
309    }
310
311    #[deprecated(since = "3.0.0", note = "Use radar_chart_mut()")]
312    pub fn get_radar_chart_mut(&mut self) -> Option<&mut RadarChart> {
313        self.radar_chart_mut()
314    }
315
316    pub fn set_radar_chart(&mut self, value: RadarChart) -> &mut Self {
317        self.radar_chart = Some(value);
318        self
319    }
320
321    #[must_use]
322    pub fn bubble_chart(&self) -> Option<&BubbleChart> {
323        self.bubble_chart.as_ref()
324    }
325
326    #[must_use]
327    #[deprecated(since = "3.0.0", note = "Use bubble_chart()")]
328    pub fn get_bubble_chart(&self) -> Option<&BubbleChart> {
329        self.bubble_chart()
330    }
331
332    pub fn bubble_chart_mut(&mut self) -> Option<&mut BubbleChart> {
333        self.bubble_chart.as_mut()
334    }
335
336    #[deprecated(since = "3.0.0", note = "Use bubble_chart_mut()")]
337    pub fn get_bubble_chart_mut(&mut self) -> Option<&mut BubbleChart> {
338        self.bubble_chart_mut()
339    }
340
341    pub fn set_bubble_chart(&mut self, value: BubbleChart) -> &mut Self {
342        self.bubble_chart = Some(value);
343        self
344    }
345
346    #[must_use]
347    pub fn area_chart(&self) -> Option<&AreaChart> {
348        self.area_chart.as_ref()
349    }
350
351    #[must_use]
352    #[deprecated(since = "3.0.0", note = "Use area_chart()")]
353    pub fn get_area_chart(&self) -> Option<&AreaChart> {
354        self.area_chart()
355    }
356
357    pub fn area_chart_mut(&mut self) -> Option<&mut AreaChart> {
358        self.area_chart.as_mut()
359    }
360
361    #[deprecated(since = "3.0.0", note = "Use area_chart_mut()")]
362    pub fn get_area_chart_mut(&mut self) -> Option<&mut AreaChart> {
363        self.area_chart_mut()
364    }
365
366    pub fn set_area_chart(&mut self, value: AreaChart) -> &mut Self {
367        self.area_chart = Some(value);
368        self
369    }
370
371    #[must_use]
372    pub fn area_3d_chart(&self) -> Option<&Area3DChart> {
373        self.area_3d_chart.as_ref()
374    }
375
376    #[must_use]
377    #[deprecated(since = "3.0.0", note = "Use area_3d_chart()")]
378    pub fn get_area_3d_chart(&self) -> Option<&Area3DChart> {
379        self.area_3d_chart()
380    }
381
382    pub fn area_3d_chart_mut(&mut self) -> Option<&mut Area3DChart> {
383        self.area_3d_chart.as_mut()
384    }
385
386    #[deprecated(since = "3.0.0", note = "Use area_3d_chart_mut()")]
387    pub fn get_area_3d_chart_mut(&mut self) -> Option<&mut Area3DChart> {
388        self.area_3d_chart_mut()
389    }
390
391    pub fn set_area_3d_chart(&mut self, value: Area3DChart) -> &mut Self {
392        self.area_3d_chart = Some(value);
393        self
394    }
395
396    #[must_use]
397    pub fn of_pie_chart(&self) -> Option<&OfPieChart> {
398        self.of_pie_chart.as_ref()
399    }
400
401    #[must_use]
402    #[deprecated(since = "3.0.0", note = "Use of_pie_chart()")]
403    pub fn get_of_pie_chart(&self) -> Option<&OfPieChart> {
404        self.of_pie_chart()
405    }
406
407    pub fn of_pie_chart_mut(&mut self) -> Option<&mut OfPieChart> {
408        self.of_pie_chart.as_mut()
409    }
410
411    #[deprecated(since = "3.0.0", note = "Use of_pie_chart_mut()")]
412    pub fn get_of_pie_chart_mut(&mut self) -> Option<&mut OfPieChart> {
413        self.of_pie_chart_mut()
414    }
415
416    pub fn set_of_pie_chart(&mut self, value: OfPieChart) -> &mut Self {
417        self.of_pie_chart = Some(value);
418        self
419    }
420
421    #[must_use]
422    pub fn category_axis(&self) -> &[CategoryAxis] {
423        &self.category_axis
424    }
425
426    #[must_use]
427    #[deprecated(since = "3.0.0", note = "Use category_axis()")]
428    pub fn get_category_axis(&self) -> &[CategoryAxis] {
429        self.category_axis()
430    }
431
432    pub fn category_axis_mut(&mut self) -> &mut Vec<CategoryAxis> {
433        &mut self.category_axis
434    }
435
436    #[deprecated(since = "3.0.0", note = "Use category_axis_mut()")]
437    pub fn get_category_axis_mut(&mut self) -> &mut Vec<CategoryAxis> {
438        self.category_axis_mut()
439    }
440
441    pub fn set_category_axis(&mut self, value: impl Into<Vec<CategoryAxis>>) -> &mut Self {
442        self.category_axis = value.into();
443        self
444    }
445
446    pub fn add_category_axis(&mut self, value: CategoryAxis) -> &mut Self {
447        self.category_axis.push(value);
448        self
449    }
450
451    #[must_use]
452    pub fn date_axis(&self) -> &[DateAxis] {
453        &self.date_axis
454    }
455
456    #[must_use]
457    #[deprecated(since = "3.0.0", note = "Use date_axis()")]
458    pub fn get_date_axis(&self) -> &[DateAxis] {
459        self.date_axis()
460    }
461
462    pub fn date_axis_mut(&mut self) -> &mut Vec<DateAxis> {
463        &mut self.date_axis
464    }
465
466    #[deprecated(since = "3.0.0", note = "Use date_axis_mut()")]
467    pub fn get_date_axis_mut(&mut self) -> &mut Vec<DateAxis> {
468        self.date_axis_mut()
469    }
470
471    pub fn set_date_axis(&mut self, value: impl Into<Vec<DateAxis>>) -> &mut Self {
472        self.date_axis = value.into();
473        self
474    }
475
476    pub fn add_date_axis(&mut self, value: DateAxis) -> &mut Self {
477        self.date_axis.push(value);
478        self
479    }
480
481    #[must_use]
482    pub fn value_axis(&self) -> &[ValueAxis] {
483        &self.value_axis
484    }
485
486    #[must_use]
487    #[deprecated(since = "3.0.0", note = "Use value_axis()")]
488    pub fn get_value_axis(&self) -> &[ValueAxis] {
489        self.value_axis()
490    }
491
492    pub fn value_axis_mut(&mut self) -> &mut Vec<ValueAxis> {
493        &mut self.value_axis
494    }
495
496    #[deprecated(since = "3.0.0", note = "Use value_axis_mut()")]
497    pub fn get_value_axis_mut(&mut self) -> &mut Vec<ValueAxis> {
498        self.value_axis_mut()
499    }
500
501    pub fn set_value_axis(&mut self, value: impl Into<Vec<ValueAxis>>) -> &mut Self {
502        self.value_axis = value.into();
503        self
504    }
505
506    pub fn add_value_axis(&mut self, value: ValueAxis) -> &mut Self {
507        self.value_axis.push(value);
508        self
509    }
510
511    #[must_use]
512    pub fn series_axis(&self) -> &[SeriesAxis] {
513        &self.series_axis
514    }
515
516    #[must_use]
517    #[deprecated(since = "3.0.0", note = "Use series_axis()")]
518    pub fn get_series_axis(&self) -> &[SeriesAxis] {
519        self.series_axis()
520    }
521
522    pub fn series_axis_mut(&mut self) -> &mut Vec<SeriesAxis> {
523        &mut self.series_axis
524    }
525
526    #[deprecated(since = "3.0.0", note = "Use series_axis_mut()")]
527    pub fn get_series_axis_mut(&mut self) -> &mut Vec<SeriesAxis> {
528        self.series_axis_mut()
529    }
530
531    pub fn set_series_axis(&mut self, value: impl Into<Vec<SeriesAxis>>) -> &mut Self {
532        self.series_axis = value.into();
533        self
534    }
535
536    pub fn add_series_axis(&mut self, value: SeriesAxis) -> &mut Self {
537        self.series_axis.push(value);
538        self
539    }
540
541    #[must_use]
542    pub fn shape_properties(&self) -> Option<&ShapeProperties> {
543        self.shape_properties.as_ref()
544    }
545
546    #[must_use]
547    #[deprecated(since = "3.0.0", note = "Use shape_properties()")]
548    pub fn get_shape_properties(&self) -> Option<&ShapeProperties> {
549        self.shape_properties()
550    }
551
552    pub fn shape_properties_mut(&mut self) -> Option<&mut ShapeProperties> {
553        self.shape_properties.as_mut()
554    }
555
556    #[deprecated(since = "3.0.0", note = "Use shape_properties_mut()")]
557    pub fn get_shape_properties_mut(&mut self) -> Option<&mut ShapeProperties> {
558        self.shape_properties_mut()
559    }
560
561    pub fn set_shape_properties(&mut self, value: ShapeProperties) -> &mut Self {
562        self.shape_properties = Some(value);
563        self
564    }
565
566    pub fn set_grouping(&mut self, value: GroupingValues) -> &mut Self {
567        if let Some(chart) = &mut self.line_chart {
568            chart.grouping_mut().set_val(value);
569            return self;
570        }
571        if let Some(chart) = &mut self.line_3d_chart {
572            chart.grouping_mut().set_val(value);
573            return self;
574        }
575        if let Some(chart) = &mut self.bar_chart {
576            chart.grouping_mut().set_val(value);
577            return self;
578        }
579        if let Some(chart) = &mut self.bar_3d_chart {
580            chart.grouping_mut().set_val(value);
581            return self;
582        }
583        if let Some(chart) = &mut self.area_chart {
584            chart.grouping_mut().set_val(value);
585            return self;
586        }
587        if let Some(chart) = &mut self.area_3d_chart {
588            chart.grouping_mut().set_val(value);
589            return self;
590        }
591        panic! {"Non-Grouping."};
592    }
593
594    pub fn area_chart_series_list_mut(&mut self) -> &mut AreaChartSeriesList {
595        if let Some(chart) = &mut self.line_chart {
596            return chart.area_chart_series_list_mut();
597        }
598        if let Some(chart) = &mut self.line_3d_chart {
599            return chart.area_chart_series_list_mut();
600        }
601        if let Some(chart) = &mut self.pie_chart {
602            return chart.area_chart_series_list_mut();
603        }
604        if let Some(chart) = &mut self.pie_3d_chart {
605            return chart.area_chart_series_list_mut();
606        }
607        if let Some(chart) = &mut self.doughnut_chart {
608            return chart.area_chart_series_list_mut();
609        }
610        if let Some(chart) = &mut self.scatter_chart {
611            return chart.area_chart_series_list_mut();
612        }
613        if let Some(chart) = &mut self.bar_chart {
614            return chart.area_chart_series_list_mut();
615        }
616        if let Some(chart) = &mut self.bar_3d_chart {
617            return chart.area_chart_series_list_mut();
618        }
619        if let Some(chart) = &mut self.radar_chart {
620            return chart.area_chart_series_list_mut();
621        }
622        if let Some(chart) = &mut self.bubble_chart {
623            return chart.area_chart_series_list_mut();
624        }
625        if let Some(chart) = &mut self.area_chart {
626            return chart.area_chart_series_list_mut();
627        }
628        if let Some(chart) = &mut self.area_3d_chart {
629            return chart.area_chart_series_list_mut();
630        }
631        if let Some(chart) = &mut self.of_pie_chart {
632            return chart.area_chart_series_list_mut();
633        }
634        panic! {"Non-ChartSeriesList."};
635    }
636
637    #[deprecated(since = "3.0.0", note = "Use area_chart_series_list_mut()")]
638    pub fn get_area_chart_series_list_mut(&mut self) -> &mut AreaChartSeriesList {
639        self.area_chart_series_list_mut()
640    }
641
642    pub fn formula_mut(&mut self) -> Vec<&mut Formula> {
643        macro_rules! collect_formulas {
644            ($result:expr, $($field:expr),+ $(,)?) => {
645                $(
646                    if let Some(v) = $field {
647                        for ser in v.area_chart_series_list_mut().area_chart_series_mut() {
648                            $result.extend(ser.formula_mut());
649                        }
650                    }
651                )+
652            };
653        }
654
655        let mut result: Vec<&mut Formula> = Vec::default();
656        collect_formulas!(
657            result,
658            &mut self.line_chart,
659            &mut self.line_3d_chart,
660            &mut self.pie_chart,
661            &mut self.pie_3d_chart,
662            &mut self.doughnut_chart,
663            &mut self.scatter_chart,
664            &mut self.bar_chart,
665            &mut self.bar_3d_chart,
666            &mut self.radar_chart,
667            &mut self.bubble_chart,
668            &mut self.area_chart,
669            &mut self.area_3d_chart,
670            &mut self.of_pie_chart,
671        );
672        result
673    }
674
675    #[deprecated(since = "3.0.0", note = "Use formula_mut()")]
676    pub fn get_formula_mut(&mut self) -> Vec<&mut Formula> {
677        self.formula_mut()
678    }
679
680    pub(crate) fn is_support(&self) -> bool {
681        self.line_chart.is_some()
682            || self.line_3d_chart.is_some()
683            || self.pie_chart.is_some()
684            || self.pie_3d_chart.is_some()
685            || self.doughnut_chart.is_some()
686            || self.scatter_chart.is_some()
687            || self.bar_chart.is_some()
688            || self.bar_3d_chart.is_some()
689            || self.radar_chart.is_some()
690            || self.bubble_chart.is_some()
691            || self.area_chart.is_some()
692            || self.area_3d_chart.is_some()
693            || self.of_pie_chart.is_some()
694    }
695
696    pub(crate) fn set_attributes<R: std::io::BufRead>(
697        &mut self,
698        reader: &mut Reader<R>,
699        _e: &BytesStart,
700    ) {
701        xml_read_loop!(
702            reader,
703            Event::Start(ref e) => match e.name().0 {
704                b"c:layout" => {
705                    self.layout.set_attributes(reader, e, false);
706                }
707                b"c:lineChart" => {
708                    let mut obj = LineChart::default();
709                    obj.set_attributes(reader, e);
710                    self.set_line_chart(obj);
711                }
712                b"c:line3DChart" => {
713                    let mut obj = Line3DChart::default();
714                    obj.set_attributes(reader, e);
715                    self.set_line_3d_chart(obj);
716                }
717                b"c:pieChart" => {
718                    let mut obj = PieChart::default();
719                    obj.set_attributes(reader, e);
720                    self.set_pie_chart(obj);
721                }
722                b"c:pie3DChart" => {
723                    let mut obj = Pie3DChart::default();
724                    obj.set_attributes(reader, e);
725                    self.set_pie_3d_chart(obj);
726                }
727                b"c:doughnutChart" => {
728                    let mut obj = DoughnutChart::default();
729                    obj.set_attributes(reader, e);
730                    self.set_doughnut_chart(obj);
731                }
732                b"c:scatterChart" => {
733                    let mut obj = ScatterChart::default();
734                    obj.set_attributes(reader, e);
735                    self.set_scatter_chart(obj);
736                }
737                b"c:barChart" => {
738                    let mut obj = BarChart::default();
739                    obj.set_attributes(reader, e);
740                    self.set_bar_chart(obj);
741                }
742                b"c:bar3DChart" => {
743                    let mut obj = Bar3DChart::default();
744                    obj.set_attributes(reader, e);
745                    self.set_bar_3d_chart(obj);
746                }
747                b"c:radarChart" => {
748                    let mut obj = RadarChart::default();
749                    obj.set_attributes(reader, e);
750                    self.set_radar_chart(obj);
751                }
752                b"c:bubbleChart" => {
753                    let mut obj = BubbleChart::default();
754                    obj.set_attributes(reader, e);
755                    self.set_bubble_chart(obj);
756                }
757                b"c:areaChart" => {
758                    let mut obj = AreaChart::default();
759                    obj.set_attributes(reader, e);
760                    self.set_area_chart(obj);
761                }
762                b"c:area3DChart" => {
763                    let mut obj = Area3DChart::default();
764                    obj.set_attributes(reader, e);
765                    self.set_area_3d_chart(obj);
766                }
767                b"c:ofPieChart" => {
768                    let mut obj = OfPieChart::default();
769                    obj.set_attributes(reader, e);
770                    self.set_of_pie_chart(obj);
771                }
772                b"c:catAx" => {
773                    let mut obj = CategoryAxis::default();
774                    obj.set_attributes(reader, e);
775                    self.add_category_axis(obj);
776                }
777                b"c:dateAx" => {
778                    let mut obj = DateAxis::default();
779                    obj.set_attributes(reader, e);
780                    self.add_date_axis(obj);
781                }
782                b"c:valAx" => {
783                    let mut obj = ValueAxis::default();
784                    obj.set_attributes(reader, e);
785                    self.add_value_axis(obj);
786                }
787                b"c:serAx" => {
788                    let mut obj = SeriesAxis::default();
789                    obj.set_attributes(reader, e);
790                    self.add_series_axis(obj);
791                }
792                b"c:spPr" => {
793                    let mut obj = ShapeProperties::default();
794                    obj.set_attributes(reader, e);
795                    self.set_shape_properties(obj);
796                }
797                _ => (),
798            },
799            Event::End(ref e) => {
800                if e.name().0 == b"c:plotArea" {
801                    return;
802                }
803            },
804            Event::Eof => panic!("Error: Could not find {} end element", "c:plotArea"),
805        );
806    }
807
808    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>, wb: &Workbook) {
809        // c:plotArea
810        write_start_tag(writer, "c:plotArea", vec![], false);
811
812        // c:layout
813        self.layout.write_to(writer);
814
815        // c:lineChart
816        if let Some(v) = &self.line_chart {
817            v.write_to(writer, wb);
818        }
819
820        // c:line3DChart
821        if let Some(v) = &self.line_3d_chart {
822            v.write_to(writer, wb);
823        }
824
825        // c:pieChart
826        if let Some(v) = &self.pie_chart {
827            v.write_to(writer, wb);
828        }
829
830        // c:pie3DChart
831        if let Some(v) = &self.pie_3d_chart {
832            v.write_to(writer, wb);
833        }
834
835        // c:doughnutChart
836        if let Some(v) = &self.doughnut_chart {
837            v.write_to(writer, wb);
838        }
839
840        // c:scatterChart
841        if let Some(v) = &self.scatter_chart {
842            v.write_to(writer, wb);
843        }
844
845        // c:barChart
846        if let Some(v) = &self.bar_chart {
847            v.write_to(writer, wb);
848        }
849
850        // c:bar3DChart
851        if let Some(v) = &self.bar_3d_chart {
852            v.write_to(writer, wb);
853        }
854
855        // c:radarChart
856        if let Some(v) = &self.radar_chart {
857            v.write_to(writer, wb);
858        }
859
860        // c:bubbleChart
861        if let Some(v) = &self.bubble_chart {
862            v.write_to(writer, wb);
863        }
864
865        // c:areaChart
866        if let Some(v) = &self.area_chart {
867            v.write_to(writer, wb);
868        }
869
870        // c:area3DChart
871        if let Some(v) = &self.area_3d_chart {
872            v.write_to(writer, wb);
873        }
874
875        // c:ofPieChart
876        if let Some(v) = &self.of_pie_chart {
877            v.write_to(writer, wb);
878        }
879
880        // c:catAx
881        for v in &self.category_axis {
882            v.write_to(writer, wb);
883        }
884
885        // c:dateAx
886        for v in &self.date_axis {
887            v.write_to(writer, wb);
888        }
889
890        // c:valAx
891        for v in &self.value_axis {
892            v.write_to(writer, wb);
893        }
894
895        // c:serAx
896        for v in &self.series_axis {
897            v.write_to(writer, wb);
898        }
899
900        // c:spPr
901        if let Some(v) = &self.shape_properties {
902            v.write_to(writer);
903        }
904
905        write_end_tag(writer, "c:plotArea");
906    }
907}
908impl AdjustmentCoordinateWithSheet for PlotArea {
909    fn adjustment_insert_coordinate_with_sheet(
910        &mut self,
911        sheet_name: &str,
912        root_col_num: u32,
913        offset_col_num: u32,
914        root_row_num: u32,
915        offset_row_num: u32,
916    ) {
917        for formula in self.formula_mut() {
918            formula.adjustment_insert_coordinate_with_sheet(
919                sheet_name,
920                root_col_num,
921                offset_col_num,
922                root_row_num,
923                offset_row_num,
924            );
925        }
926    }
927
928    fn adjustment_remove_coordinate_with_sheet(
929        &mut self,
930        sheet_name: &str,
931        root_col_num: u32,
932        offset_col_num: u32,
933        root_row_num: u32,
934        offset_row_num: u32,
935    ) {
936        for formula in self.formula_mut() {
937            formula.adjustment_remove_coordinate_with_sheet(
938                sheet_name,
939                root_col_num,
940                offset_col_num,
941                root_row_num,
942                offset_row_num,
943            );
944        }
945    }
946}
umya_spreadsheet/structs/drawing/charts/plot_area.rs

umya_spreadsheet/structs/drawing/charts/
plot_area.rs
