1use sheetkit_xml::chart::{
7 Area3DChart, AreaChart, Bar3DChart, BarChart, BodyPr, BoolVal, BubbleChart, BubbleSeries,
8 CatAx, CategoryRef, Chart, ChartSpace, ChartTitle, DoughnutChart, HighLowLines, IntVal, Layout,
9 Legend, Line3DChart, LineChart, NumRef, OfPieChart, Paragraph, Pie3DChart, PieChart, PlotArea,
10 RadarChart, RichText, Run, Scaling, ScatterChart, ScatterSeries, SerAx, SerLines, Series,
11 SeriesText, StockChart, StrRef, StringVal, Surface3DChart, SurfaceChart, TitleTx, UintVal,
12 UpDownBars, ValAx, ValueRef, View3D,
13};
14use sheetkit_xml::drawing::{
15 AExt, CNvGraphicFramePr, CNvPr, ChartRef, ClientData, Graphic, GraphicData, GraphicFrame,
16 MarkerType, NvGraphicFramePr, Offset, TwoCellAnchor, WsDr, Xfrm,
17};
18use sheetkit_xml::namespaces;
19
20#[derive(Debug, Clone, PartialEq)]
22pub enum ChartType {
23 Col,
25 ColStacked,
27 ColPercentStacked,
29 Bar,
31 BarStacked,
33 BarPercentStacked,
35 Line,
37 Pie,
39 Area,
41 AreaStacked,
43 AreaPercentStacked,
45 Area3D,
47 Area3DStacked,
49 Area3DPercentStacked,
51 Col3D,
53 Col3DStacked,
55 Col3DPercentStacked,
57 Bar3D,
59 Bar3DStacked,
61 Bar3DPercentStacked,
63 LineStacked,
65 LinePercentStacked,
67 Line3D,
69 Pie3D,
71 Doughnut,
73 Scatter,
75 ScatterLine,
77 ScatterSmooth,
79 Radar,
81 RadarFilled,
83 RadarMarker,
85 StockHLC,
87 StockOHLC,
89 StockVHLC,
91 StockVOHLC,
93 Bubble,
95 Surface,
97 Surface3D,
99 SurfaceWireframe,
101 SurfaceWireframe3D,
103 ColLine,
105 ColLineStacked,
107 ColLinePercentStacked,
109 PieOfPie,
111 BarOfPie,
113 Col3DCone,
115 Col3DConeStacked,
117 Col3DConePercentStacked,
119 Col3DPyramid,
121 Col3DPyramidStacked,
123 Col3DPyramidPercentStacked,
125 Col3DCylinder,
127 Col3DCylinderStacked,
129 Col3DCylinderPercentStacked,
131 Contour,
133 WireframeContour,
135 Bubble3D,
137}
138
139#[derive(Debug, Clone, Default)]
141pub struct View3DConfig {
142 pub rot_x: Option<i32>,
144 pub rot_y: Option<i32>,
146 pub depth_percent: Option<u32>,
148 pub right_angle_axes: Option<bool>,
150 pub perspective: Option<u32>,
152}
153
154#[derive(Debug, Clone)]
156pub struct ChartConfig {
157 pub chart_type: ChartType,
159 pub title: Option<String>,
161 pub series: Vec<ChartSeries>,
163 pub show_legend: bool,
165 pub view_3d: Option<View3DConfig>,
167}
168
169#[derive(Debug, Clone)]
171pub struct ChartSeries {
172 pub name: String,
174 pub categories: String,
176 pub values: String,
178 pub x_values: Option<String>,
180 pub bubble_sizes: Option<String>,
182}
183
184pub fn build_chart_xml(config: &ChartConfig) -> ChartSpace {
186 let title = config.title.as_ref().map(|t| build_chart_title(t));
187 let legend = if config.show_legend {
188 Some(Legend {
189 legend_pos: StringVal {
190 val: "b".to_string(),
191 },
192 })
193 } else {
194 None
195 };
196 let view_3d = build_view_3d(config);
197 let plot_area = build_plot_area(config);
198
199 ChartSpace {
200 chart: Chart {
201 title,
202 view_3d,
203 plot_area,
204 legend,
205 plot_vis_only: Some(BoolVal { val: true }),
206 },
207 ..ChartSpace::default()
208 }
209}
210
211pub fn build_drawing_with_chart(chart_ref_id: &str, from: MarkerType, to: MarkerType) -> WsDr {
213 build_drawing_with_chart_id(chart_ref_id, from, to, 2)
214}
215
216pub fn build_drawing_with_chart_id(
219 chart_ref_id: &str,
220 from: MarkerType,
221 to: MarkerType,
222 object_id: u32,
223) -> WsDr {
224 let graphic_frame = GraphicFrame {
225 nv_graphic_frame_pr: NvGraphicFramePr {
226 c_nv_pr: CNvPr {
227 id: object_id,
228 name: format!("Chart {}", object_id.saturating_sub(1)),
229 },
230 c_nv_graphic_frame_pr: CNvGraphicFramePr {},
231 },
232 xfrm: Xfrm {
233 off: Offset { x: 0, y: 0 },
234 ext: AExt { cx: 0, cy: 0 },
235 },
236 graphic: Graphic {
237 graphic_data: GraphicData {
238 uri: namespaces::DRAWING_ML_CHART.to_string(),
239 chart: ChartRef {
240 xmlns_c: namespaces::DRAWING_ML_CHART.to_string(),
241 r_id: chart_ref_id.to_string(),
242 },
243 },
244 },
245 };
246 let anchor = TwoCellAnchor {
247 from,
248 to,
249 graphic_frame: Some(graphic_frame),
250 pic: None,
251 shape: None,
252 client_data: ClientData {},
253 };
254 WsDr {
255 two_cell_anchors: vec![anchor],
256 ..WsDr::default()
257 }
258}
259
260fn is_no_axis_chart(ct: &ChartType) -> bool {
261 matches!(
262 ct,
263 ChartType::Pie
264 | ChartType::Pie3D
265 | ChartType::Doughnut
266 | ChartType::PieOfPie
267 | ChartType::BarOfPie
268 )
269}
270
271fn is_3d_chart(ct: &ChartType) -> bool {
272 matches!(
273 ct,
274 ChartType::Area3D
275 | ChartType::Area3DStacked
276 | ChartType::Area3DPercentStacked
277 | ChartType::Col3D
278 | ChartType::Col3DStacked
279 | ChartType::Col3DPercentStacked
280 | ChartType::Bar3D
281 | ChartType::Bar3DStacked
282 | ChartType::Bar3DPercentStacked
283 | ChartType::Line3D
284 | ChartType::Pie3D
285 | ChartType::Surface3D
286 | ChartType::SurfaceWireframe3D
287 | ChartType::Col3DCone
288 | ChartType::Col3DConeStacked
289 | ChartType::Col3DConePercentStacked
290 | ChartType::Col3DPyramid
291 | ChartType::Col3DPyramidStacked
292 | ChartType::Col3DPyramidPercentStacked
293 | ChartType::Col3DCylinder
294 | ChartType::Col3DCylinderStacked
295 | ChartType::Col3DCylinderPercentStacked
296 )
297}
298
299fn needs_ser_ax(ct: &ChartType) -> bool {
300 matches!(
301 ct,
302 ChartType::Surface
303 | ChartType::Surface3D
304 | ChartType::SurfaceWireframe
305 | ChartType::SurfaceWireframe3D
306 | ChartType::Contour
307 | ChartType::WireframeContour
308 )
309}
310
311fn build_view_3d(config: &ChartConfig) -> Option<View3D> {
312 if let Some(v) = &config.view_3d {
313 return Some(View3D {
314 rot_x: v.rot_x.map(|val| IntVal { val }),
315 rot_y: v.rot_y.map(|val| IntVal { val }),
316 depth_percent: v.depth_percent.map(|val| UintVal { val }),
317 r_ang_ax: v.right_angle_axes.map(|val| BoolVal { val }),
318 perspective: v.perspective.map(|val| UintVal { val }),
319 });
320 }
321 if is_3d_chart(&config.chart_type) {
322 Some(View3D {
323 rot_x: Some(IntVal { val: 15 }),
324 rot_y: Some(IntVal { val: 20 }),
325 depth_percent: None,
326 r_ang_ax: Some(BoolVal { val: true }),
327 perspective: Some(UintVal { val: 30 }),
328 })
329 } else {
330 None
331 }
332}
333
334fn build_series_text(series: &ChartSeries) -> Option<SeriesText> {
335 if series.name.is_empty() {
336 None
337 } else if series.name.contains('!') {
338 Some(SeriesText {
339 str_ref: Some(StrRef {
340 f: series.name.clone(),
341 }),
342 v: None,
343 })
344 } else {
345 Some(SeriesText {
346 str_ref: None,
347 v: Some(series.name.clone()),
348 })
349 }
350}
351
352fn build_series(index: u32, series: &ChartSeries) -> Series {
353 let tx = build_series_text(series);
354 let cat = if series.categories.is_empty() {
355 None
356 } else {
357 Some(CategoryRef {
358 str_ref: Some(StrRef {
359 f: series.categories.clone(),
360 }),
361 num_ref: None,
362 })
363 };
364 let val = if series.values.is_empty() {
365 None
366 } else {
367 Some(ValueRef {
368 num_ref: Some(NumRef {
369 f: series.values.clone(),
370 }),
371 })
372 };
373 Series {
374 idx: UintVal { val: index },
375 order: UintVal { val: index },
376 tx,
377 cat,
378 val,
379 }
380}
381
382fn build_scatter_series(index: u32, series: &ChartSeries) -> ScatterSeries {
383 let tx = build_series_text(series);
384 let x_val = series
385 .x_values
386 .as_ref()
387 .or(if series.categories.is_empty() {
388 None
389 } else {
390 Some(&series.categories)
391 })
392 .map(|ref_str| CategoryRef {
393 str_ref: None,
394 num_ref: Some(NumRef { f: ref_str.clone() }),
395 });
396 let y_val = if series.values.is_empty() {
397 None
398 } else {
399 Some(ValueRef {
400 num_ref: Some(NumRef {
401 f: series.values.clone(),
402 }),
403 })
404 };
405 ScatterSeries {
406 idx: UintVal { val: index },
407 order: UintVal { val: index },
408 tx,
409 x_val,
410 y_val,
411 }
412}
413
414fn build_bubble_series(index: u32, series: &ChartSeries, is_3d: bool) -> BubbleSeries {
415 let tx = build_series_text(series);
416 let x_val = series
417 .x_values
418 .as_ref()
419 .or(if series.categories.is_empty() {
420 None
421 } else {
422 Some(&series.categories)
423 })
424 .map(|ref_str| CategoryRef {
425 str_ref: None,
426 num_ref: Some(NumRef { f: ref_str.clone() }),
427 });
428 let y_val = if series.values.is_empty() {
429 None
430 } else {
431 Some(ValueRef {
432 num_ref: Some(NumRef {
433 f: series.values.clone(),
434 }),
435 })
436 };
437 let bubble_size = series.bubble_sizes.as_ref().map(|ref_str| ValueRef {
438 num_ref: Some(NumRef { f: ref_str.clone() }),
439 });
440 BubbleSeries {
441 idx: UintVal { val: index },
442 order: UintVal { val: index },
443 tx,
444 x_val,
445 y_val,
446 bubble_size,
447 bubble_3d: if is_3d {
448 Some(BoolVal { val: true })
449 } else {
450 None
451 },
452 }
453}
454
455fn build_chart_title(text: &str) -> ChartTitle {
456 ChartTitle {
457 tx: TitleTx {
458 rich: RichText {
459 body_pr: BodyPr {},
460 paragraphs: vec![Paragraph {
461 runs: vec![Run {
462 t: text.to_string(),
463 }],
464 }],
465 },
466 },
467 }
468}
469
470fn build_standard_axes() -> (Option<CatAx>, Option<ValAx>) {
471 (
472 Some(CatAx {
473 ax_id: UintVal { val: 1 },
474 scaling: Scaling {
475 orientation: StringVal {
476 val: "minMax".to_string(),
477 },
478 },
479 delete: BoolVal { val: false },
480 ax_pos: StringVal {
481 val: "b".to_string(),
482 },
483 cross_ax: UintVal { val: 2 },
484 }),
485 Some(ValAx {
486 ax_id: UintVal { val: 2 },
487 scaling: Scaling {
488 orientation: StringVal {
489 val: "minMax".to_string(),
490 },
491 },
492 delete: BoolVal { val: false },
493 ax_pos: StringVal {
494 val: "l".to_string(),
495 },
496 cross_ax: UintVal { val: 1 },
497 }),
498 )
499}
500
501fn build_ser_ax() -> SerAx {
502 SerAx {
503 ax_id: UintVal { val: 3 },
504 scaling: Scaling {
505 orientation: StringVal {
506 val: "minMax".to_string(),
507 },
508 },
509 delete: BoolVal { val: false },
510 ax_pos: StringVal {
511 val: "b".to_string(),
512 },
513 cross_ax: UintVal { val: 1 },
514 }
515}
516
517fn standard_ax_ids() -> Vec<UintVal> {
518 vec![UintVal { val: 1 }, UintVal { val: 2 }]
519}
520
521fn volume_ax_ids() -> Vec<UintVal> {
522 vec![UintVal { val: 1 }, UintVal { val: 3 }]
523}
524
525fn build_volume_val_ax() -> ValAx {
526 ValAx {
527 ax_id: UintVal { val: 3 },
528 scaling: Scaling {
529 orientation: StringVal {
530 val: "minMax".to_string(),
531 },
532 },
533 delete: BoolVal { val: false },
534 ax_pos: StringVal {
535 val: "r".to_string(),
536 },
537 cross_ax: UintVal { val: 1 },
538 }
539}
540
541fn surface_ax_ids() -> Vec<UintVal> {
542 vec![UintVal { val: 1 }, UintVal { val: 2 }, UintVal { val: 3 }]
543}
544
545fn build_plot_area(config: &ChartConfig) -> PlotArea {
546 let ct = &config.chart_type;
547 let no_axes = is_no_axis_chart(ct);
548 let (cat_ax, val_ax) = if no_axes {
549 (None, None)
550 } else {
551 build_standard_axes()
552 };
553 let ser_ax = if needs_ser_ax(ct) {
554 Some(build_ser_ax())
555 } else {
556 None
557 };
558 let ax_ids = if no_axes {
559 vec![]
560 } else if needs_ser_ax(ct) {
561 surface_ax_ids()
562 } else {
563 standard_ax_ids()
564 };
565
566 let xml_series: Vec<Series> = config
567 .series
568 .iter()
569 .enumerate()
570 .map(|(i, s)| build_series(i as u32, s))
571 .collect();
572
573 let mut plot_area = PlotArea {
574 layout: Some(Layout {}),
575 bar_chart: None,
576 bar_3d_chart: None,
577 line_chart: None,
578 line_3d_chart: None,
579 pie_chart: None,
580 pie_3d_chart: None,
581 doughnut_chart: None,
582 area_chart: None,
583 area_3d_chart: None,
584 scatter_chart: None,
585 bubble_chart: None,
586 radar_chart: None,
587 stock_chart: None,
588 surface_chart: None,
589 surface_3d_chart: None,
590 of_pie_chart: None,
591 cat_ax,
592 val_ax,
593 additional_val_axes: vec![],
594 ser_ax,
595 };
596
597 match ct {
598 ChartType::Col => {
599 plot_area.bar_chart = Some(BarChart {
600 bar_dir: StringVal { val: "col".into() },
601 grouping: StringVal {
602 val: "clustered".into(),
603 },
604 series: xml_series,
605 ax_ids,
606 });
607 }
608 ChartType::ColStacked => {
609 plot_area.bar_chart = Some(BarChart {
610 bar_dir: StringVal { val: "col".into() },
611 grouping: StringVal {
612 val: "stacked".into(),
613 },
614 series: xml_series,
615 ax_ids,
616 });
617 }
618 ChartType::ColPercentStacked => {
619 plot_area.bar_chart = Some(BarChart {
620 bar_dir: StringVal { val: "col".into() },
621 grouping: StringVal {
622 val: "percentStacked".into(),
623 },
624 series: xml_series,
625 ax_ids,
626 });
627 }
628 ChartType::Bar => {
629 plot_area.bar_chart = Some(BarChart {
630 bar_dir: StringVal { val: "bar".into() },
631 grouping: StringVal {
632 val: "clustered".into(),
633 },
634 series: xml_series,
635 ax_ids,
636 });
637 }
638 ChartType::BarStacked => {
639 plot_area.bar_chart = Some(BarChart {
640 bar_dir: StringVal { val: "bar".into() },
641 grouping: StringVal {
642 val: "stacked".into(),
643 },
644 series: xml_series,
645 ax_ids,
646 });
647 }
648 ChartType::BarPercentStacked => {
649 plot_area.bar_chart = Some(BarChart {
650 bar_dir: StringVal { val: "bar".into() },
651 grouping: StringVal {
652 val: "percentStacked".into(),
653 },
654 series: xml_series,
655 ax_ids,
656 });
657 }
658 ChartType::Line => {
659 plot_area.line_chart = Some(LineChart {
660 grouping: StringVal {
661 val: "standard".into(),
662 },
663 series: xml_series,
664 ax_ids,
665 });
666 }
667 ChartType::LineStacked => {
668 plot_area.line_chart = Some(LineChart {
669 grouping: StringVal {
670 val: "stacked".into(),
671 },
672 series: xml_series,
673 ax_ids,
674 });
675 }
676 ChartType::LinePercentStacked => {
677 plot_area.line_chart = Some(LineChart {
678 grouping: StringVal {
679 val: "percentStacked".into(),
680 },
681 series: xml_series,
682 ax_ids,
683 });
684 }
685 ChartType::Line3D => {
686 plot_area.line_3d_chart = Some(Line3DChart {
687 grouping: StringVal {
688 val: "standard".into(),
689 },
690 series: xml_series,
691 ax_ids,
692 });
693 }
694 ChartType::Pie => {
695 plot_area.pie_chart = Some(PieChart { series: xml_series });
696 }
697 ChartType::Pie3D => {
698 plot_area.pie_3d_chart = Some(Pie3DChart { series: xml_series });
699 }
700 ChartType::Doughnut => {
701 plot_area.doughnut_chart = Some(DoughnutChart {
702 series: xml_series,
703 hole_size: Some(UintVal { val: 50 }),
704 });
705 }
706 ChartType::Area => {
707 plot_area.area_chart = Some(AreaChart {
708 grouping: StringVal {
709 val: "standard".into(),
710 },
711 series: xml_series,
712 ax_ids,
713 });
714 }
715 ChartType::AreaStacked => {
716 plot_area.area_chart = Some(AreaChart {
717 grouping: StringVal {
718 val: "stacked".into(),
719 },
720 series: xml_series,
721 ax_ids,
722 });
723 }
724 ChartType::AreaPercentStacked => {
725 plot_area.area_chart = Some(AreaChart {
726 grouping: StringVal {
727 val: "percentStacked".into(),
728 },
729 series: xml_series,
730 ax_ids,
731 });
732 }
733 ChartType::Area3D => {
734 plot_area.area_3d_chart = Some(Area3DChart {
735 grouping: StringVal {
736 val: "standard".into(),
737 },
738 series: xml_series,
739 ax_ids,
740 });
741 }
742 ChartType::Area3DStacked => {
743 plot_area.area_3d_chart = Some(Area3DChart {
744 grouping: StringVal {
745 val: "stacked".into(),
746 },
747 series: xml_series,
748 ax_ids,
749 });
750 }
751 ChartType::Area3DPercentStacked => {
752 plot_area.area_3d_chart = Some(Area3DChart {
753 grouping: StringVal {
754 val: "percentStacked".into(),
755 },
756 series: xml_series,
757 ax_ids,
758 });
759 }
760 ChartType::Col3D => {
761 plot_area.bar_3d_chart = Some(Bar3DChart {
762 bar_dir: StringVal { val: "col".into() },
763 grouping: StringVal {
764 val: "clustered".into(),
765 },
766 series: xml_series,
767 shape: None,
768 ax_ids,
769 });
770 }
771 ChartType::Col3DStacked => {
772 plot_area.bar_3d_chart = Some(Bar3DChart {
773 bar_dir: StringVal { val: "col".into() },
774 grouping: StringVal {
775 val: "stacked".into(),
776 },
777 series: xml_series,
778 shape: None,
779 ax_ids,
780 });
781 }
782 ChartType::Col3DPercentStacked => {
783 plot_area.bar_3d_chart = Some(Bar3DChart {
784 bar_dir: StringVal { val: "col".into() },
785 grouping: StringVal {
786 val: "percentStacked".into(),
787 },
788 series: xml_series,
789 shape: None,
790 ax_ids,
791 });
792 }
793 ChartType::Bar3D => {
794 plot_area.bar_3d_chart = Some(Bar3DChart {
795 bar_dir: StringVal { val: "bar".into() },
796 grouping: StringVal {
797 val: "clustered".into(),
798 },
799 series: xml_series,
800 shape: None,
801 ax_ids,
802 });
803 }
804 ChartType::Bar3DStacked => {
805 plot_area.bar_3d_chart = Some(Bar3DChart {
806 bar_dir: StringVal { val: "bar".into() },
807 grouping: StringVal {
808 val: "stacked".into(),
809 },
810 series: xml_series,
811 shape: None,
812 ax_ids,
813 });
814 }
815 ChartType::Bar3DPercentStacked => {
816 plot_area.bar_3d_chart = Some(Bar3DChart {
817 bar_dir: StringVal { val: "bar".into() },
818 grouping: StringVal {
819 val: "percentStacked".into(),
820 },
821 series: xml_series,
822 shape: None,
823 ax_ids,
824 });
825 }
826 ChartType::Scatter => {
827 let ss: Vec<ScatterSeries> = config
828 .series
829 .iter()
830 .enumerate()
831 .map(|(i, s)| build_scatter_series(i as u32, s))
832 .collect();
833 plot_area.scatter_chart = Some(ScatterChart {
834 scatter_style: StringVal {
835 val: "lineMarker".into(),
836 },
837 series: ss,
838 ax_ids,
839 });
840 }
841 ChartType::ScatterLine => {
842 let ss: Vec<ScatterSeries> = config
843 .series
844 .iter()
845 .enumerate()
846 .map(|(i, s)| build_scatter_series(i as u32, s))
847 .collect();
848 plot_area.scatter_chart = Some(ScatterChart {
849 scatter_style: StringVal { val: "line".into() },
850 series: ss,
851 ax_ids,
852 });
853 }
854 ChartType::ScatterSmooth => {
855 let ss: Vec<ScatterSeries> = config
856 .series
857 .iter()
858 .enumerate()
859 .map(|(i, s)| build_scatter_series(i as u32, s))
860 .collect();
861 plot_area.scatter_chart = Some(ScatterChart {
862 scatter_style: StringVal {
863 val: "smoothMarker".into(),
864 },
865 series: ss,
866 ax_ids,
867 });
868 }
869 ChartType::Bubble => {
870 let bs: Vec<BubbleSeries> = config
871 .series
872 .iter()
873 .enumerate()
874 .map(|(i, s)| build_bubble_series(i as u32, s, false))
875 .collect();
876 plot_area.bubble_chart = Some(BubbleChart { series: bs, ax_ids });
877 }
878 ChartType::Bubble3D => {
879 let bs: Vec<BubbleSeries> = config
880 .series
881 .iter()
882 .enumerate()
883 .map(|(i, s)| build_bubble_series(i as u32, s, true))
884 .collect();
885 plot_area.bubble_chart = Some(BubbleChart { series: bs, ax_ids });
886 }
887 ChartType::Radar => {
888 plot_area.radar_chart = Some(RadarChart {
889 radar_style: StringVal {
890 val: "standard".into(),
891 },
892 series: xml_series,
893 ax_ids,
894 });
895 }
896 ChartType::RadarFilled => {
897 plot_area.radar_chart = Some(RadarChart {
898 radar_style: StringVal {
899 val: "filled".into(),
900 },
901 series: xml_series,
902 ax_ids,
903 });
904 }
905 ChartType::RadarMarker => {
906 plot_area.radar_chart = Some(RadarChart {
907 radar_style: StringVal {
908 val: "marker".into(),
909 },
910 series: xml_series,
911 ax_ids,
912 });
913 }
914 ChartType::StockHLC => {
915 plot_area.stock_chart = Some(StockChart {
916 series: xml_series,
917 hi_low_lines: Some(HighLowLines {}),
918 up_down_bars: None,
919 ax_ids,
920 });
921 }
922 ChartType::StockOHLC => {
923 plot_area.stock_chart = Some(StockChart {
924 series: xml_series,
925 hi_low_lines: Some(HighLowLines {}),
926 up_down_bars: Some(UpDownBars {}),
927 ax_ids,
928 });
929 }
930 ChartType::StockVHLC | ChartType::StockVOHLC => {
931 let (volume_series, stock_series) = match xml_series.split_first() {
932 Some((volume, stock)) => (vec![volume.clone()], stock.to_vec()),
933 None => (vec![], vec![]),
934 };
935 plot_area.bar_chart = Some(BarChart {
936 bar_dir: StringVal { val: "col".into() },
937 grouping: StringVal {
938 val: "clustered".into(),
939 },
940 series: volume_series,
941 ax_ids: volume_ax_ids(),
942 });
943 plot_area.additional_val_axes.push(build_volume_val_ax());
944 plot_area.stock_chart = Some(StockChart {
945 series: stock_series,
946 hi_low_lines: Some(HighLowLines {}),
947 up_down_bars: matches!(ct, ChartType::StockVOHLC).then_some(UpDownBars {}),
948 ax_ids,
949 });
950 }
951 ChartType::Surface => {
952 plot_area.surface_chart = Some(SurfaceChart {
953 wireframe: None,
954 series: xml_series,
955 ax_ids,
956 });
957 }
958 ChartType::SurfaceWireframe => {
959 plot_area.surface_chart = Some(SurfaceChart {
960 wireframe: Some(BoolVal { val: true }),
961 series: xml_series,
962 ax_ids,
963 });
964 }
965 ChartType::Surface3D => {
966 plot_area.surface_3d_chart = Some(Surface3DChart {
967 wireframe: None,
968 series: xml_series,
969 ax_ids,
970 });
971 }
972 ChartType::SurfaceWireframe3D => {
973 plot_area.surface_3d_chart = Some(Surface3DChart {
974 wireframe: Some(BoolVal { val: true }),
975 series: xml_series,
976 ax_ids,
977 });
978 }
979 ChartType::PieOfPie => {
980 plot_area.of_pie_chart = Some(OfPieChart {
981 of_pie_type: StringVal { val: "pie".into() },
982 series: xml_series,
983 ser_lines: Some(SerLines {}),
984 });
985 }
986 ChartType::BarOfPie => {
987 plot_area.of_pie_chart = Some(OfPieChart {
988 of_pie_type: StringVal { val: "bar".into() },
989 series: xml_series,
990 ser_lines: Some(SerLines {}),
991 });
992 }
993 ChartType::Col3DCone => {
994 plot_area.bar_3d_chart = Some(Bar3DChart {
995 bar_dir: StringVal { val: "col".into() },
996 grouping: StringVal {
997 val: "clustered".into(),
998 },
999 series: xml_series,
1000 shape: Some(StringVal { val: "cone".into() }),
1001 ax_ids,
1002 });
1003 }
1004 ChartType::Col3DConeStacked => {
1005 plot_area.bar_3d_chart = Some(Bar3DChart {
1006 bar_dir: StringVal { val: "col".into() },
1007 grouping: StringVal {
1008 val: "stacked".into(),
1009 },
1010 series: xml_series,
1011 shape: Some(StringVal { val: "cone".into() }),
1012 ax_ids,
1013 });
1014 }
1015 ChartType::Col3DConePercentStacked => {
1016 plot_area.bar_3d_chart = Some(Bar3DChart {
1017 bar_dir: StringVal { val: "col".into() },
1018 grouping: StringVal {
1019 val: "percentStacked".into(),
1020 },
1021 series: xml_series,
1022 shape: Some(StringVal { val: "cone".into() }),
1023 ax_ids,
1024 });
1025 }
1026 ChartType::Col3DPyramid => {
1027 plot_area.bar_3d_chart = Some(Bar3DChart {
1028 bar_dir: StringVal { val: "col".into() },
1029 grouping: StringVal {
1030 val: "clustered".into(),
1031 },
1032 series: xml_series,
1033 shape: Some(StringVal {
1034 val: "pyramid".into(),
1035 }),
1036 ax_ids,
1037 });
1038 }
1039 ChartType::Col3DPyramidStacked => {
1040 plot_area.bar_3d_chart = Some(Bar3DChart {
1041 bar_dir: StringVal { val: "col".into() },
1042 grouping: StringVal {
1043 val: "stacked".into(),
1044 },
1045 series: xml_series,
1046 shape: Some(StringVal {
1047 val: "pyramid".into(),
1048 }),
1049 ax_ids,
1050 });
1051 }
1052 ChartType::Col3DPyramidPercentStacked => {
1053 plot_area.bar_3d_chart = Some(Bar3DChart {
1054 bar_dir: StringVal { val: "col".into() },
1055 grouping: StringVal {
1056 val: "percentStacked".into(),
1057 },
1058 series: xml_series,
1059 shape: Some(StringVal {
1060 val: "pyramid".into(),
1061 }),
1062 ax_ids,
1063 });
1064 }
1065 ChartType::Col3DCylinder => {
1066 plot_area.bar_3d_chart = Some(Bar3DChart {
1067 bar_dir: StringVal { val: "col".into() },
1068 grouping: StringVal {
1069 val: "clustered".into(),
1070 },
1071 series: xml_series,
1072 shape: Some(StringVal {
1073 val: "cylinder".into(),
1074 }),
1075 ax_ids,
1076 });
1077 }
1078 ChartType::Col3DCylinderStacked => {
1079 plot_area.bar_3d_chart = Some(Bar3DChart {
1080 bar_dir: StringVal { val: "col".into() },
1081 grouping: StringVal {
1082 val: "stacked".into(),
1083 },
1084 series: xml_series,
1085 shape: Some(StringVal {
1086 val: "cylinder".into(),
1087 }),
1088 ax_ids,
1089 });
1090 }
1091 ChartType::Col3DCylinderPercentStacked => {
1092 plot_area.bar_3d_chart = Some(Bar3DChart {
1093 bar_dir: StringVal { val: "col".into() },
1094 grouping: StringVal {
1095 val: "percentStacked".into(),
1096 },
1097 series: xml_series,
1098 shape: Some(StringVal {
1099 val: "cylinder".into(),
1100 }),
1101 ax_ids,
1102 });
1103 }
1104 ChartType::Contour => {
1105 plot_area.surface_chart = Some(SurfaceChart {
1106 wireframe: Some(BoolVal { val: false }),
1107 series: xml_series,
1108 ax_ids,
1109 });
1110 }
1111 ChartType::WireframeContour => {
1112 plot_area.surface_chart = Some(SurfaceChart {
1113 wireframe: Some(BoolVal { val: true }),
1114 series: xml_series,
1115 ax_ids,
1116 });
1117 }
1118 ChartType::ColLine | ChartType::ColLineStacked | ChartType::ColLinePercentStacked => {
1119 let grouping = match ct {
1120 ChartType::ColLineStacked => "stacked",
1121 ChartType::ColLinePercentStacked => "percentStacked",
1122 _ => "clustered",
1123 };
1124 let total = xml_series.len();
1125 let bar_count = total.div_ceil(2);
1126 let bar_series: Vec<Series> = xml_series.iter().take(bar_count).cloned().collect();
1127 let line_series: Vec<Series> = xml_series.iter().skip(bar_count).cloned().collect();
1128 plot_area.bar_chart = Some(BarChart {
1129 bar_dir: StringVal { val: "col".into() },
1130 grouping: StringVal {
1131 val: grouping.into(),
1132 },
1133 series: bar_series,
1134 ax_ids: ax_ids.clone(),
1135 });
1136 plot_area.line_chart = Some(LineChart {
1137 grouping: StringVal {
1138 val: "standard".into(),
1139 },
1140 series: line_series,
1141 ax_ids,
1142 });
1143 }
1144 }
1145
1146 plot_area
1147}
1148
1149#[cfg(test)]
1150mod tests {
1151 use super::*;
1152
1153 fn ss() -> Vec<ChartSeries> {
1154 vec![ChartSeries {
1155 name: "Revenue".into(),
1156 categories: "Sheet1!$A$2:$A$6".into(),
1157 values: "Sheet1!$B$2:$B$6".into(),
1158 x_values: None,
1159 bubble_sizes: None,
1160 }]
1161 }
1162
1163 fn mc(chart_type: ChartType) -> ChartConfig {
1164 ChartConfig {
1165 chart_type,
1166 title: None,
1167 series: ss(),
1168 show_legend: false,
1169 view_3d: None,
1170 }
1171 }
1172
1173 #[test]
1174 fn test_build_chart_xml_col() {
1175 let config = ChartConfig {
1176 chart_type: ChartType::Col,
1177 title: Some("Sales Chart".into()),
1178 series: ss(),
1179 show_legend: true,
1180 view_3d: None,
1181 };
1182 let cs = build_chart_xml(&config);
1183 assert!(cs.chart.title.is_some());
1184 assert!(cs.chart.legend.is_some());
1185 assert!(cs.chart.plot_area.bar_chart.is_some());
1186 assert!(cs.chart.plot_area.line_chart.is_none());
1187 assert!(cs.chart.plot_area.pie_chart.is_none());
1188 assert!(cs.chart.view_3d.is_none());
1189 let bar = cs.chart.plot_area.bar_chart.unwrap();
1190 assert_eq!(bar.bar_dir.val, "col");
1191 assert_eq!(bar.grouping.val, "clustered");
1192 assert_eq!(bar.series.len(), 1);
1193 assert_eq!(bar.ax_ids.len(), 2);
1194 }
1195
1196 #[test]
1197 fn test_build_chart_xml_bar() {
1198 let cs = build_chart_xml(&ChartConfig {
1199 chart_type: ChartType::Bar,
1200 title: None,
1201 series: vec![],
1202 show_legend: false,
1203 view_3d: None,
1204 });
1205 assert!(cs.chart.title.is_none());
1206 assert!(cs.chart.legend.is_none());
1207 let bar = cs.chart.plot_area.bar_chart.unwrap();
1208 assert_eq!(bar.bar_dir.val, "bar");
1209 assert_eq!(bar.grouping.val, "clustered");
1210 }
1211
1212 #[test]
1213 fn test_bar_stacked() {
1214 let cs = build_chart_xml(&mc(ChartType::BarStacked));
1215 let bar = cs.chart.plot_area.bar_chart.unwrap();
1216 assert_eq!(bar.bar_dir.val, "bar");
1217 assert_eq!(bar.grouping.val, "stacked");
1218 }
1219
1220 #[test]
1221 fn test_col_stacked() {
1222 let cs = build_chart_xml(&mc(ChartType::ColStacked));
1223 let bar = cs.chart.plot_area.bar_chart.unwrap();
1224 assert_eq!(bar.bar_dir.val, "col");
1225 assert_eq!(bar.grouping.val, "stacked");
1226 }
1227
1228 #[test]
1229 fn test_col_percent_stacked() {
1230 let cs = build_chart_xml(&mc(ChartType::ColPercentStacked));
1231 let bar = cs.chart.plot_area.bar_chart.unwrap();
1232 assert_eq!(bar.grouping.val, "percentStacked");
1233 }
1234
1235 #[test]
1236 fn test_bar_percent_stacked() {
1237 let cs = build_chart_xml(&mc(ChartType::BarPercentStacked));
1238 let bar = cs.chart.plot_area.bar_chart.unwrap();
1239 assert_eq!(bar.bar_dir.val, "bar");
1240 assert_eq!(bar.grouping.val, "percentStacked");
1241 }
1242
1243 #[test]
1244 fn test_line() {
1245 let cs = build_chart_xml(&ChartConfig {
1246 chart_type: ChartType::Line,
1247 title: Some("Trend".into()),
1248 series: vec![ChartSeries {
1249 name: "Sheet1!$A$1".into(),
1250 categories: "Sheet1!$A$2:$A$6".into(),
1251 values: "Sheet1!$B$2:$B$6".into(),
1252 x_values: None,
1253 bubble_sizes: None,
1254 }],
1255 show_legend: true,
1256 view_3d: None,
1257 });
1258 assert!(cs.chart.plot_area.line_chart.is_some());
1259 let line = cs.chart.plot_area.line_chart.unwrap();
1260 assert_eq!(line.grouping.val, "standard");
1261 assert_eq!(line.series.len(), 1);
1262 let tx = line.series[0].tx.as_ref().unwrap();
1263 assert!(tx.str_ref.is_some());
1264 assert!(tx.v.is_none());
1265 }
1266
1267 #[test]
1268 fn test_pie() {
1269 let cs = build_chart_xml(&ChartConfig {
1270 chart_type: ChartType::Pie,
1271 title: Some("Distribution".into()),
1272 series: vec![ChartSeries {
1273 name: "Data".into(),
1274 categories: "Sheet1!$A$2:$A$6".into(),
1275 values: "Sheet1!$B$2:$B$6".into(),
1276 x_values: None,
1277 bubble_sizes: None,
1278 }],
1279 show_legend: true,
1280 view_3d: None,
1281 });
1282 assert!(cs.chart.plot_area.pie_chart.is_some());
1283 assert!(cs.chart.plot_area.cat_ax.is_none());
1284 assert!(cs.chart.plot_area.val_ax.is_none());
1285 let pie = cs.chart.plot_area.pie_chart.unwrap();
1286 let tx = pie.series[0].tx.as_ref().unwrap();
1287 assert!(tx.str_ref.is_none());
1288 assert_eq!(tx.v.as_deref(), Some("Data"));
1289 }
1290
1291 #[test]
1292 fn test_no_legend() {
1293 let cs = build_chart_xml(&mc(ChartType::Col));
1294 assert!(cs.chart.legend.is_none());
1295 }
1296
1297 #[test]
1298 fn test_axes_present_for_non_pie() {
1299 let cs = build_chart_xml(&mc(ChartType::Line));
1300 assert!(cs.chart.plot_area.cat_ax.is_some());
1301 assert!(cs.chart.plot_area.val_ax.is_some());
1302 }
1303
1304 #[test]
1305 fn test_drawing_with_chart() {
1306 let from = MarkerType {
1307 col: 1,
1308 col_off: 0,
1309 row: 1,
1310 row_off: 0,
1311 };
1312 let to = MarkerType {
1313 col: 10,
1314 col_off: 0,
1315 row: 15,
1316 row_off: 0,
1317 };
1318 let dr = build_drawing_with_chart("rId1", from, to);
1319 assert_eq!(dr.two_cell_anchors.len(), 1);
1320 let anchor = &dr.two_cell_anchors[0];
1321 assert!(anchor.graphic_frame.is_some());
1322 assert_eq!(anchor.from.col, 1);
1323 assert_eq!(anchor.to.col, 10);
1324 let gf = anchor.graphic_frame.as_ref().unwrap();
1325 assert_eq!(gf.graphic.graphic_data.chart.r_id, "rId1");
1326 }
1327
1328 #[test]
1329 fn test_series_literal_name() {
1330 let s = ChartSeries {
1331 name: "MyName".into(),
1332 categories: "Sheet1!$A$2:$A$6".into(),
1333 values: "Sheet1!$B$2:$B$6".into(),
1334 x_values: None,
1335 bubble_sizes: None,
1336 };
1337 let xs = build_series(0, &s);
1338 let tx = xs.tx.as_ref().unwrap();
1339 assert!(tx.str_ref.is_none());
1340 assert_eq!(tx.v.as_deref(), Some("MyName"));
1341 }
1342
1343 #[test]
1344 fn test_series_cell_ref_name() {
1345 let s = ChartSeries {
1346 name: "Sheet1!$C$1".into(),
1347 categories: "".into(),
1348 values: "Sheet1!$B$2:$B$6".into(),
1349 x_values: None,
1350 bubble_sizes: None,
1351 };
1352 let xs = build_series(0, &s);
1353 let tx = xs.tx.as_ref().unwrap();
1354 assert!(tx.str_ref.is_some());
1355 assert!(tx.v.is_none());
1356 assert!(xs.cat.is_none());
1357 }
1358
1359 #[test]
1360 fn test_series_empty_name() {
1361 let s = ChartSeries {
1362 name: "".into(),
1363 categories: "Sheet1!$A$2:$A$6".into(),
1364 values: "Sheet1!$B$2:$B$6".into(),
1365 x_values: None,
1366 bubble_sizes: None,
1367 };
1368 let xs = build_series(0, &s);
1369 assert!(xs.tx.is_none());
1370 }
1371
1372 #[test]
1373 fn test_multiple_series() {
1374 let cs = build_chart_xml(&ChartConfig {
1375 chart_type: ChartType::Col,
1376 title: None,
1377 series: vec![
1378 ChartSeries {
1379 name: "A".into(),
1380 categories: "Sheet1!$A$2:$A$6".into(),
1381 values: "Sheet1!$B$2:$B$6".into(),
1382 x_values: None,
1383 bubble_sizes: None,
1384 },
1385 ChartSeries {
1386 name: "B".into(),
1387 categories: "Sheet1!$A$2:$A$6".into(),
1388 values: "Sheet1!$C$2:$C$6".into(),
1389 x_values: None,
1390 bubble_sizes: None,
1391 },
1392 ],
1393 show_legend: true,
1394 view_3d: None,
1395 });
1396 let bar = cs.chart.plot_area.bar_chart.unwrap();
1397 assert_eq!(bar.series.len(), 2);
1398 assert_eq!(bar.series[0].idx.val, 0);
1399 assert_eq!(bar.series[1].idx.val, 1);
1400 }
1401
1402 #[test]
1403 fn test_area_chart() {
1404 let cs = build_chart_xml(&mc(ChartType::Area));
1405 assert!(cs.chart.plot_area.area_chart.is_some());
1406 let a = cs.chart.plot_area.area_chart.unwrap();
1407 assert_eq!(a.grouping.val, "standard");
1408 assert_eq!(a.ax_ids.len(), 2);
1409 assert!(cs.chart.view_3d.is_none());
1410 }
1411
1412 #[test]
1413 fn test_area_stacked() {
1414 let cs = build_chart_xml(&mc(ChartType::AreaStacked));
1415 assert_eq!(
1416 cs.chart.plot_area.area_chart.unwrap().grouping.val,
1417 "stacked"
1418 );
1419 }
1420
1421 #[test]
1422 fn test_area_percent_stacked() {
1423 let cs = build_chart_xml(&mc(ChartType::AreaPercentStacked));
1424 assert_eq!(
1425 cs.chart.plot_area.area_chart.unwrap().grouping.val,
1426 "percentStacked"
1427 );
1428 }
1429
1430 #[test]
1431 fn test_area_3d() {
1432 let cs = build_chart_xml(&mc(ChartType::Area3D));
1433 assert!(cs.chart.view_3d.is_some());
1434 assert_eq!(
1435 cs.chart.plot_area.area_3d_chart.unwrap().grouping.val,
1436 "standard"
1437 );
1438 }
1439
1440 #[test]
1441 fn test_area_3d_stacked() {
1442 let cs = build_chart_xml(&mc(ChartType::Area3DStacked));
1443 assert!(cs.chart.view_3d.is_some());
1444 assert_eq!(
1445 cs.chart.plot_area.area_3d_chart.unwrap().grouping.val,
1446 "stacked"
1447 );
1448 }
1449
1450 #[test]
1451 fn test_area_3d_percent_stacked() {
1452 let cs = build_chart_xml(&mc(ChartType::Area3DPercentStacked));
1453 assert!(cs.chart.view_3d.is_some());
1454 assert_eq!(
1455 cs.chart.plot_area.area_3d_chart.unwrap().grouping.val,
1456 "percentStacked"
1457 );
1458 }
1459
1460 #[test]
1461 fn test_col_3d() {
1462 let cs = build_chart_xml(&mc(ChartType::Col3D));
1463 assert!(cs.chart.view_3d.is_some());
1464 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
1465 assert_eq!(b.bar_dir.val, "col");
1466 assert_eq!(b.grouping.val, "clustered");
1467 }
1468
1469 #[test]
1470 fn test_col_3d_stacked() {
1471 let cs = build_chart_xml(&mc(ChartType::Col3DStacked));
1472 assert_eq!(
1473 cs.chart.plot_area.bar_3d_chart.unwrap().grouping.val,
1474 "stacked"
1475 );
1476 }
1477
1478 #[test]
1479 fn test_col_3d_percent_stacked() {
1480 let cs = build_chart_xml(&mc(ChartType::Col3DPercentStacked));
1481 assert_eq!(
1482 cs.chart.plot_area.bar_3d_chart.unwrap().grouping.val,
1483 "percentStacked"
1484 );
1485 }
1486
1487 #[test]
1488 fn test_bar_3d() {
1489 let cs = build_chart_xml(&mc(ChartType::Bar3D));
1490 assert!(cs.chart.view_3d.is_some());
1491 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
1492 assert_eq!(b.bar_dir.val, "bar");
1493 assert_eq!(b.grouping.val, "clustered");
1494 }
1495
1496 #[test]
1497 fn test_bar_3d_stacked() {
1498 let cs = build_chart_xml(&mc(ChartType::Bar3DStacked));
1499 assert_eq!(
1500 cs.chart.plot_area.bar_3d_chart.unwrap().grouping.val,
1501 "stacked"
1502 );
1503 }
1504
1505 #[test]
1506 fn test_bar_3d_percent_stacked() {
1507 let cs = build_chart_xml(&mc(ChartType::Bar3DPercentStacked));
1508 assert_eq!(
1509 cs.chart.plot_area.bar_3d_chart.unwrap().grouping.val,
1510 "percentStacked"
1511 );
1512 }
1513
1514 #[test]
1515 fn test_line_stacked() {
1516 let cs = build_chart_xml(&mc(ChartType::LineStacked));
1517 assert_eq!(
1518 cs.chart.plot_area.line_chart.unwrap().grouping.val,
1519 "stacked"
1520 );
1521 }
1522
1523 #[test]
1524 fn test_line_percent_stacked() {
1525 let cs = build_chart_xml(&mc(ChartType::LinePercentStacked));
1526 assert_eq!(
1527 cs.chart.plot_area.line_chart.unwrap().grouping.val,
1528 "percentStacked"
1529 );
1530 }
1531
1532 #[test]
1533 fn test_line_3d() {
1534 let cs = build_chart_xml(&mc(ChartType::Line3D));
1535 assert!(cs.chart.view_3d.is_some());
1536 assert!(cs.chart.plot_area.line_3d_chart.is_some());
1537 }
1538
1539 #[test]
1540 fn test_pie_3d() {
1541 let cs = build_chart_xml(&mc(ChartType::Pie3D));
1542 assert!(cs.chart.view_3d.is_some());
1543 assert!(cs.chart.plot_area.pie_3d_chart.is_some());
1544 assert!(cs.chart.plot_area.cat_ax.is_none());
1545 }
1546
1547 #[test]
1548 fn test_doughnut() {
1549 let cs = build_chart_xml(&mc(ChartType::Doughnut));
1550 assert!(cs.chart.plot_area.doughnut_chart.is_some());
1551 assert!(cs.chart.plot_area.cat_ax.is_none());
1552 let d = cs.chart.plot_area.doughnut_chart.unwrap();
1553 assert_eq!(d.hole_size.as_ref().unwrap().val, 50);
1554 }
1555
1556 #[test]
1557 fn test_scatter() {
1558 let cs = build_chart_xml(&ChartConfig {
1559 chart_type: ChartType::Scatter,
1560 title: None,
1561 series: vec![ChartSeries {
1562 name: "XY".into(),
1563 categories: "Sheet1!$A$2:$A$6".into(),
1564 values: "Sheet1!$B$2:$B$6".into(),
1565 x_values: None,
1566 bubble_sizes: None,
1567 }],
1568 show_legend: false,
1569 view_3d: None,
1570 });
1571 let sc = cs.chart.plot_area.scatter_chart.unwrap();
1572 assert_eq!(sc.scatter_style.val, "lineMarker");
1573 assert_eq!(sc.series.len(), 1);
1574 let s = &sc.series[0];
1575 assert_eq!(
1576 s.x_val.as_ref().unwrap().num_ref.as_ref().unwrap().f,
1577 "Sheet1!$A$2:$A$6"
1578 );
1579 assert_eq!(
1580 s.y_val.as_ref().unwrap().num_ref.as_ref().unwrap().f,
1581 "Sheet1!$B$2:$B$6"
1582 );
1583 }
1584
1585 #[test]
1586 fn test_scatter_explicit_x() {
1587 let cs = build_chart_xml(&ChartConfig {
1588 chart_type: ChartType::Scatter,
1589 title: None,
1590 series: vec![ChartSeries {
1591 name: "".into(),
1592 categories: "Sheet1!$A$2:$A$6".into(),
1593 values: "Sheet1!$B$2:$B$6".into(),
1594 x_values: Some("Sheet1!$D$2:$D$6".into()),
1595 bubble_sizes: None,
1596 }],
1597 show_legend: false,
1598 view_3d: None,
1599 });
1600 let s = &cs.chart.plot_area.scatter_chart.unwrap().series[0];
1601 assert_eq!(
1602 s.x_val.as_ref().unwrap().num_ref.as_ref().unwrap().f,
1603 "Sheet1!$D$2:$D$6"
1604 );
1605 }
1606
1607 #[test]
1608 fn test_scatter_line() {
1609 let cs = build_chart_xml(&mc(ChartType::ScatterLine));
1610 assert_eq!(
1611 cs.chart.plot_area.scatter_chart.unwrap().scatter_style.val,
1612 "line"
1613 );
1614 }
1615
1616 #[test]
1617 fn test_scatter_smooth() {
1618 let cs = build_chart_xml(&mc(ChartType::ScatterSmooth));
1619 assert_eq!(
1620 cs.chart.plot_area.scatter_chart.unwrap().scatter_style.val,
1621 "smoothMarker"
1622 );
1623 }
1624
1625 #[test]
1626 fn test_bubble() {
1627 let cs = build_chart_xml(&ChartConfig {
1628 chart_type: ChartType::Bubble,
1629 title: None,
1630 series: vec![ChartSeries {
1631 name: "B".into(),
1632 categories: "Sheet1!$A$2:$A$6".into(),
1633 values: "Sheet1!$B$2:$B$6".into(),
1634 x_values: None,
1635 bubble_sizes: Some("Sheet1!$C$2:$C$6".into()),
1636 }],
1637 show_legend: false,
1638 view_3d: None,
1639 });
1640 let b = cs.chart.plot_area.bubble_chart.unwrap();
1641 assert_eq!(b.series.len(), 1);
1642 assert_eq!(
1643 b.series[0]
1644 .bubble_size
1645 .as_ref()
1646 .unwrap()
1647 .num_ref
1648 .as_ref()
1649 .unwrap()
1650 .f,
1651 "Sheet1!$C$2:$C$6"
1652 );
1653 }
1654
1655 #[test]
1656 fn test_radar() {
1657 let cs = build_chart_xml(&mc(ChartType::Radar));
1658 assert_eq!(
1659 cs.chart.plot_area.radar_chart.unwrap().radar_style.val,
1660 "standard"
1661 );
1662 }
1663
1664 #[test]
1665 fn test_radar_filled() {
1666 let cs = build_chart_xml(&mc(ChartType::RadarFilled));
1667 assert_eq!(
1668 cs.chart.plot_area.radar_chart.unwrap().radar_style.val,
1669 "filled"
1670 );
1671 }
1672
1673 #[test]
1674 fn test_radar_marker() {
1675 let cs = build_chart_xml(&mc(ChartType::RadarMarker));
1676 assert_eq!(
1677 cs.chart.plot_area.radar_chart.unwrap().radar_style.val,
1678 "marker"
1679 );
1680 }
1681
1682 #[test]
1683 fn test_stock_hlc() {
1684 let cs = build_chart_xml(&mc(ChartType::StockHLC));
1685 assert!(cs.chart.plot_area.stock_chart.is_some());
1686 }
1687
1688 #[test]
1689 fn test_stock_ohlc() {
1690 let cs = build_chart_xml(&mc(ChartType::StockOHLC));
1691 assert!(cs.chart.plot_area.stock_chart.is_some());
1692 }
1693
1694 #[test]
1695 fn test_stock_vhlc() {
1696 let cs = build_chart_xml(&mc(ChartType::StockVHLC));
1697 assert!(cs.chart.plot_area.stock_chart.is_some());
1698 }
1699
1700 #[test]
1701 fn test_stock_vohlc() {
1702 let cs = build_chart_xml(&mc(ChartType::StockVOHLC));
1703 assert!(cs.chart.plot_area.stock_chart.is_some());
1704 }
1705
1706 #[test]
1707 fn test_surface() {
1708 let cs = build_chart_xml(&mc(ChartType::Surface));
1709 assert!(cs.chart.plot_area.surface_chart.is_some());
1710 assert!(cs.chart.plot_area.ser_ax.is_some());
1711 let sf = cs.chart.plot_area.surface_chart.unwrap();
1712 assert!(sf.wireframe.is_none());
1713 assert_eq!(sf.ax_ids.len(), 3);
1714 }
1715
1716 #[test]
1717 fn test_surface_wireframe() {
1718 let cs = build_chart_xml(&mc(ChartType::SurfaceWireframe));
1719 let sf = cs.chart.plot_area.surface_chart.unwrap();
1720 assert!(sf.wireframe.as_ref().unwrap().val);
1721 assert_eq!(sf.ax_ids.len(), 3);
1722 }
1723
1724 #[test]
1725 fn test_surface_3d() {
1726 let cs = build_chart_xml(&mc(ChartType::Surface3D));
1727 assert!(cs.chart.view_3d.is_some());
1728 assert!(cs.chart.plot_area.surface_3d_chart.is_some());
1729 assert!(cs.chart.plot_area.ser_ax.is_some());
1730 }
1731
1732 #[test]
1733 fn test_surface_wireframe_3d() {
1734 let cs = build_chart_xml(&mc(ChartType::SurfaceWireframe3D));
1735 assert!(cs.chart.view_3d.is_some());
1736 let sf = cs.chart.plot_area.surface_3d_chart.unwrap();
1737 assert!(sf.wireframe.as_ref().unwrap().val);
1738 }
1739
1740 #[test]
1741 fn test_col_line_combo() {
1742 let cs = build_chart_xml(&ChartConfig {
1743 chart_type: ChartType::ColLine,
1744 title: None,
1745 series: vec![
1746 ChartSeries {
1747 name: "A".into(),
1748 categories: "Sheet1!$A$2:$A$6".into(),
1749 values: "Sheet1!$B$2:$B$6".into(),
1750 x_values: None,
1751 bubble_sizes: None,
1752 },
1753 ChartSeries {
1754 name: "B".into(),
1755 categories: "Sheet1!$A$2:$A$6".into(),
1756 values: "Sheet1!$C$2:$C$6".into(),
1757 x_values: None,
1758 bubble_sizes: None,
1759 },
1760 ],
1761 show_legend: true,
1762 view_3d: None,
1763 });
1764 assert!(cs.chart.plot_area.bar_chart.is_some());
1765 assert!(cs.chart.plot_area.line_chart.is_some());
1766 let bar = cs.chart.plot_area.bar_chart.unwrap();
1767 assert_eq!(bar.grouping.val, "clustered");
1768 assert_eq!(bar.series.len(), 1);
1769 assert_eq!(cs.chart.plot_area.line_chart.unwrap().series.len(), 1);
1770 }
1771
1772 #[test]
1773 fn test_col_line_stacked_combo() {
1774 let cs = build_chart_xml(&ChartConfig {
1775 chart_type: ChartType::ColLineStacked,
1776 title: None,
1777 series: vec![
1778 ChartSeries {
1779 name: "A".into(),
1780 categories: "".into(),
1781 values: "Sheet1!$B$2:$B$6".into(),
1782 x_values: None,
1783 bubble_sizes: None,
1784 },
1785 ChartSeries {
1786 name: "B".into(),
1787 categories: "".into(),
1788 values: "Sheet1!$C$2:$C$6".into(),
1789 x_values: None,
1790 bubble_sizes: None,
1791 },
1792 ChartSeries {
1793 name: "C".into(),
1794 categories: "".into(),
1795 values: "Sheet1!$D$2:$D$6".into(),
1796 x_values: None,
1797 bubble_sizes: None,
1798 },
1799 ],
1800 show_legend: false,
1801 view_3d: None,
1802 });
1803 let bar = cs.chart.plot_area.bar_chart.unwrap();
1804 assert_eq!(bar.grouping.val, "stacked");
1805 assert_eq!(bar.series.len(), 2);
1806 assert_eq!(cs.chart.plot_area.line_chart.unwrap().series.len(), 1);
1807 }
1808
1809 #[test]
1810 fn test_col_line_percent_stacked_combo() {
1811 let cs = build_chart_xml(&ChartConfig {
1812 chart_type: ChartType::ColLinePercentStacked,
1813 title: None,
1814 series: vec![ChartSeries {
1815 name: "A".into(),
1816 categories: "".into(),
1817 values: "Sheet1!$B$2:$B$6".into(),
1818 x_values: None,
1819 bubble_sizes: None,
1820 }],
1821 show_legend: false,
1822 view_3d: None,
1823 });
1824 let bar = cs.chart.plot_area.bar_chart.unwrap();
1825 assert_eq!(bar.grouping.val, "percentStacked");
1826 assert_eq!(bar.series.len(), 1);
1827 assert_eq!(cs.chart.plot_area.line_chart.unwrap().series.len(), 0);
1828 }
1829
1830 #[test]
1831 fn test_view_3d_explicit() {
1832 let cs = build_chart_xml(&ChartConfig {
1833 chart_type: ChartType::Col3D,
1834 title: None,
1835 series: vec![],
1836 show_legend: false,
1837 view_3d: Some(View3DConfig {
1838 rot_x: Some(30),
1839 rot_y: Some(40),
1840 depth_percent: Some(200),
1841 right_angle_axes: Some(false),
1842 perspective: Some(10),
1843 }),
1844 });
1845 let v = cs.chart.view_3d.unwrap();
1846 assert_eq!(v.rot_x.unwrap().val, 30);
1847 assert_eq!(v.rot_y.unwrap().val, 40);
1848 assert_eq!(v.depth_percent.unwrap().val, 200);
1849 assert!(!v.r_ang_ax.unwrap().val);
1850 assert_eq!(v.perspective.unwrap().val, 10);
1851 }
1852
1853 #[test]
1854 fn test_view_3d_auto_defaults() {
1855 let cs = build_chart_xml(&mc(ChartType::Col3D));
1856 let v = cs.chart.view_3d.unwrap();
1857 assert_eq!(v.rot_x.unwrap().val, 15);
1858 assert_eq!(v.rot_y.unwrap().val, 20);
1859 assert!(v.r_ang_ax.unwrap().val);
1860 assert_eq!(v.perspective.unwrap().val, 30);
1861 }
1862
1863 #[test]
1864 fn test_non_3d_no_view() {
1865 let cs = build_chart_xml(&mc(ChartType::Col));
1866 assert!(cs.chart.view_3d.is_none());
1867 }
1868
1869 #[test]
1870 fn test_chart_type_enum_coverage() {
1871 let types = [
1872 ChartType::Col,
1873 ChartType::ColStacked,
1874 ChartType::ColPercentStacked,
1875 ChartType::Bar,
1876 ChartType::BarStacked,
1877 ChartType::BarPercentStacked,
1878 ChartType::Line,
1879 ChartType::Pie,
1880 ChartType::Area,
1881 ChartType::AreaStacked,
1882 ChartType::AreaPercentStacked,
1883 ChartType::Area3D,
1884 ChartType::Area3DStacked,
1885 ChartType::Area3DPercentStacked,
1886 ChartType::Col3D,
1887 ChartType::Col3DStacked,
1888 ChartType::Col3DPercentStacked,
1889 ChartType::Bar3D,
1890 ChartType::Bar3DStacked,
1891 ChartType::Bar3DPercentStacked,
1892 ChartType::LineStacked,
1893 ChartType::LinePercentStacked,
1894 ChartType::Line3D,
1895 ChartType::Pie3D,
1896 ChartType::Doughnut,
1897 ChartType::Scatter,
1898 ChartType::ScatterLine,
1899 ChartType::ScatterSmooth,
1900 ChartType::Radar,
1901 ChartType::RadarFilled,
1902 ChartType::RadarMarker,
1903 ChartType::StockHLC,
1904 ChartType::StockOHLC,
1905 ChartType::StockVHLC,
1906 ChartType::StockVOHLC,
1907 ChartType::Bubble,
1908 ChartType::Surface,
1909 ChartType::Surface3D,
1910 ChartType::SurfaceWireframe,
1911 ChartType::SurfaceWireframe3D,
1912 ChartType::ColLine,
1913 ChartType::ColLineStacked,
1914 ChartType::ColLinePercentStacked,
1915 ChartType::PieOfPie,
1916 ChartType::BarOfPie,
1917 ChartType::Col3DCone,
1918 ChartType::Col3DConeStacked,
1919 ChartType::Col3DConePercentStacked,
1920 ChartType::Col3DPyramid,
1921 ChartType::Col3DPyramidStacked,
1922 ChartType::Col3DPyramidPercentStacked,
1923 ChartType::Col3DCylinder,
1924 ChartType::Col3DCylinderStacked,
1925 ChartType::Col3DCylinderPercentStacked,
1926 ChartType::Contour,
1927 ChartType::WireframeContour,
1928 ChartType::Bubble3D,
1929 ];
1930 for ct in &types {
1931 let _ = build_chart_xml(&ChartConfig {
1932 chart_type: ct.clone(),
1933 title: None,
1934 series: vec![],
1935 show_legend: false,
1936 view_3d: None,
1937 });
1938 }
1939 }
1940
1941 #[test]
1942 fn test_scatter_empty_categories() {
1943 let cs = build_chart_xml(&ChartConfig {
1944 chart_type: ChartType::Scatter,
1945 title: None,
1946 series: vec![ChartSeries {
1947 name: "".into(),
1948 categories: "".into(),
1949 values: "Sheet1!$B$2:$B$6".into(),
1950 x_values: None,
1951 bubble_sizes: None,
1952 }],
1953 show_legend: false,
1954 view_3d: None,
1955 });
1956 let s = &cs.chart.plot_area.scatter_chart.unwrap().series[0];
1957 assert!(s.x_val.is_none());
1958 assert!(s.y_val.is_some());
1959 }
1960
1961 #[test]
1962 fn test_bubble_no_sizes() {
1963 let cs = build_chart_xml(&ChartConfig {
1964 chart_type: ChartType::Bubble,
1965 title: None,
1966 series: vec![ChartSeries {
1967 name: "".into(),
1968 categories: "Sheet1!$A$2:$A$6".into(),
1969 values: "Sheet1!$B$2:$B$6".into(),
1970 x_values: None,
1971 bubble_sizes: None,
1972 }],
1973 show_legend: false,
1974 view_3d: None,
1975 });
1976 assert!(cs.chart.plot_area.bubble_chart.unwrap().series[0]
1977 .bubble_size
1978 .is_none());
1979 }
1980
1981 #[test]
1982 fn test_pie_of_pie() {
1983 let cs = build_chart_xml(&mc(ChartType::PieOfPie));
1984 assert!(cs.chart.plot_area.of_pie_chart.is_some());
1985 assert!(cs.chart.plot_area.cat_ax.is_none());
1986 assert!(cs.chart.plot_area.val_ax.is_none());
1987 let op = cs.chart.plot_area.of_pie_chart.unwrap();
1988 assert_eq!(op.of_pie_type.val, "pie");
1989 assert!(op.ser_lines.is_some());
1990 assert_eq!(op.series.len(), 1);
1991 }
1992
1993 #[test]
1994 fn test_bar_of_pie() {
1995 let cs = build_chart_xml(&mc(ChartType::BarOfPie));
1996 assert!(cs.chart.plot_area.of_pie_chart.is_some());
1997 assert!(cs.chart.plot_area.cat_ax.is_none());
1998 let op = cs.chart.plot_area.of_pie_chart.unwrap();
1999 assert_eq!(op.of_pie_type.val, "bar");
2000 assert!(op.ser_lines.is_some());
2001 }
2002
2003 #[test]
2004 fn test_col_3d_cone() {
2005 let cs = build_chart_xml(&mc(ChartType::Col3DCone));
2006 assert!(cs.chart.view_3d.is_some());
2007 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2008 assert_eq!(b.bar_dir.val, "col");
2009 assert_eq!(b.grouping.val, "clustered");
2010 assert_eq!(b.shape.as_ref().unwrap().val, "cone");
2011 }
2012
2013 #[test]
2014 fn test_col_3d_cone_stacked() {
2015 let cs = build_chart_xml(&mc(ChartType::Col3DConeStacked));
2016 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2017 assert_eq!(b.grouping.val, "stacked");
2018 assert_eq!(b.shape.as_ref().unwrap().val, "cone");
2019 }
2020
2021 #[test]
2022 fn test_col_3d_cone_percent_stacked() {
2023 let cs = build_chart_xml(&mc(ChartType::Col3DConePercentStacked));
2024 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2025 assert_eq!(b.grouping.val, "percentStacked");
2026 assert_eq!(b.shape.as_ref().unwrap().val, "cone");
2027 }
2028
2029 #[test]
2030 fn test_col_3d_pyramid() {
2031 let cs = build_chart_xml(&mc(ChartType::Col3DPyramid));
2032 assert!(cs.chart.view_3d.is_some());
2033 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2034 assert_eq!(b.bar_dir.val, "col");
2035 assert_eq!(b.grouping.val, "clustered");
2036 assert_eq!(b.shape.as_ref().unwrap().val, "pyramid");
2037 }
2038
2039 #[test]
2040 fn test_col_3d_pyramid_stacked() {
2041 let cs = build_chart_xml(&mc(ChartType::Col3DPyramidStacked));
2042 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2043 assert_eq!(b.grouping.val, "stacked");
2044 assert_eq!(b.shape.as_ref().unwrap().val, "pyramid");
2045 }
2046
2047 #[test]
2048 fn test_col_3d_pyramid_percent_stacked() {
2049 let cs = build_chart_xml(&mc(ChartType::Col3DPyramidPercentStacked));
2050 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2051 assert_eq!(b.grouping.val, "percentStacked");
2052 assert_eq!(b.shape.as_ref().unwrap().val, "pyramid");
2053 }
2054
2055 #[test]
2056 fn test_col_3d_cylinder() {
2057 let cs = build_chart_xml(&mc(ChartType::Col3DCylinder));
2058 assert!(cs.chart.view_3d.is_some());
2059 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2060 assert_eq!(b.bar_dir.val, "col");
2061 assert_eq!(b.grouping.val, "clustered");
2062 assert_eq!(b.shape.as_ref().unwrap().val, "cylinder");
2063 }
2064
2065 #[test]
2066 fn test_col_3d_cylinder_stacked() {
2067 let cs = build_chart_xml(&mc(ChartType::Col3DCylinderStacked));
2068 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2069 assert_eq!(b.grouping.val, "stacked");
2070 assert_eq!(b.shape.as_ref().unwrap().val, "cylinder");
2071 }
2072
2073 #[test]
2074 fn test_col_3d_cylinder_percent_stacked() {
2075 let cs = build_chart_xml(&mc(ChartType::Col3DCylinderPercentStacked));
2076 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2077 assert_eq!(b.grouping.val, "percentStacked");
2078 assert_eq!(b.shape.as_ref().unwrap().val, "cylinder");
2079 }
2080
2081 #[test]
2082 fn test_contour() {
2083 let cs = build_chart_xml(&mc(ChartType::Contour));
2084 assert!(cs.chart.plot_area.surface_chart.is_some());
2085 assert!(cs.chart.plot_area.ser_ax.is_some());
2086 let sf = cs.chart.plot_area.surface_chart.unwrap();
2087 assert!(!sf.wireframe.as_ref().unwrap().val);
2088 assert_eq!(sf.ax_ids.len(), 3);
2089 }
2090
2091 #[test]
2092 fn test_wireframe_contour() {
2093 let cs = build_chart_xml(&mc(ChartType::WireframeContour));
2094 assert!(cs.chart.plot_area.surface_chart.is_some());
2095 assert!(cs.chart.plot_area.ser_ax.is_some());
2096 let sf = cs.chart.plot_area.surface_chart.unwrap();
2097 assert!(sf.wireframe.as_ref().unwrap().val);
2098 assert_eq!(sf.ax_ids.len(), 3);
2099 }
2100
2101 #[test]
2102 fn test_bubble_3d() {
2103 let cs = build_chart_xml(&ChartConfig {
2104 chart_type: ChartType::Bubble3D,
2105 title: None,
2106 series: vec![ChartSeries {
2107 name: "B3D".into(),
2108 categories: "Sheet1!$A$2:$A$6".into(),
2109 values: "Sheet1!$B$2:$B$6".into(),
2110 x_values: None,
2111 bubble_sizes: Some("Sheet1!$C$2:$C$6".into()),
2112 }],
2113 show_legend: false,
2114 view_3d: None,
2115 });
2116 let b = cs.chart.plot_area.bubble_chart.unwrap();
2117 assert_eq!(b.series.len(), 1);
2118 assert!(b.series[0].bubble_3d.as_ref().unwrap().val);
2119 }
2120
2121 #[test]
2122 fn test_bubble_no_3d_flag() {
2123 let cs = build_chart_xml(&mc(ChartType::Bubble));
2124 let b = cs.chart.plot_area.bubble_chart.unwrap();
2125 assert!(b.series[0].bubble_3d.is_none());
2126 }
2127
2128 #[test]
2129 fn test_col_3d_no_shape() {
2130 let cs = build_chart_xml(&mc(ChartType::Col3D));
2131 let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2132 assert!(b.shape.is_none());
2133 }
2134}