Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/xlsxwriter/chart.py: 11%
Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1###############################################################################
2#
3# Chart - A class for writing the Excel XLSX Worksheet file.
4#
5# SPDX-License-Identifier: BSD-2-Clause
6#
7# Copyright (c) 2013-2025, John McNamara, jmcnamara@cpan.org
8#
10import copy
11import re
12from typing import Any, Dict, Optional
13from warnings import warn
15from xlsxwriter.color import Color, ColorTypes
17from . import xmlwriter
18from .shape import Shape
19from .utility import (
20 _datetime_to_excel_datetime,
21 _supported_datetime,
22 quote_sheetname,
23 xl_range_formula,
24 xl_rowcol_to_cell,
25)
28class Chart(xmlwriter.XMLwriter):
29 """
30 A class for writing the Excel XLSX Chart file.
33 """
35 ###########################################################################
36 #
37 # Public API.
38 #
39 ###########################################################################
41 def __init__(self) -> None:
42 """
43 Constructor.
45 """
47 super().__init__()
49 self.subtype = None
50 self.sheet_type = 0x0200
51 self.orientation = 0x0
52 self.series = []
53 self.embedded = 0
54 self.id = -1
55 self.series_index = 0
56 self.style_id = 2
57 self.axis_ids = []
58 self.axis2_ids = []
59 self.cat_has_num_fmt = False
60 self.requires_category = False
61 self.legend = {}
62 self.cat_axis_position = "b"
63 self.val_axis_position = "l"
64 self.formula_ids = {}
65 self.formula_data = []
66 self.horiz_cat_axis = 0
67 self.horiz_val_axis = 1
68 self.protection = 0
69 self.chartarea = {}
70 self.plotarea = {}
71 self.x_axis = {}
72 self.y_axis = {}
73 self.y2_axis = {}
74 self.x2_axis = {}
75 self.chart_name = ""
76 self.show_blanks = "gap"
77 self.show_na_as_empty = False
78 self.show_hidden = False
79 self.show_crosses = True
80 self.width = 480
81 self.height = 288
82 self.x_scale = 1
83 self.y_scale = 1
84 self.x_offset = 0
85 self.y_offset = 0
86 self.table = None
87 self.cross_between = "between"
88 self.default_marker = None
89 self.series_gap_1 = None
90 self.series_gap_2 = None
91 self.series_overlap_1 = None
92 self.series_overlap_2 = None
93 self.drop_lines = None
94 self.hi_low_lines = None
95 self.up_down_bars = None
96 self.smooth_allowed = False
97 self.title_font = None
98 self.title_name = None
99 self.title_formula = None
100 self.title_data_id = None
101 self.title_layout = None
102 self.title_overlay = None
103 self.title_none = False
104 self.date_category = False
105 self.date_1904 = False
106 self.remove_timezone = False
107 self.label_positions = {}
108 self.label_position_default = ""
109 self.already_inserted = False
110 self.combined = None
111 self.is_secondary = False
112 self.warn_sheetname = True
113 self._set_default_properties()
114 self.fill = {}
116 def add_series(self, options: Optional[Dict[str, Any]] = None) -> None:
117 """
118 Add a data series to a chart.
120 Args:
121 options: A dictionary of chart series options.
123 Returns:
124 Nothing.
126 """
127 # Add a series and it's properties to a chart.
128 if options is None:
129 options = {}
131 # Check that the required input has been specified.
132 if "values" not in options:
133 warn("Must specify 'values' in add_series()")
134 return
136 if self.requires_category and "categories" not in options:
137 warn("Must specify 'categories' in add_series() for this chart type")
138 return
140 if len(self.series) == 255:
141 warn(
142 "The maximum number of series that can be added to an "
143 "Excel Chart is 255"
144 )
145 return
147 # Convert list into a formula string.
148 values = self._list_to_formula(options.get("values"))
149 categories = self._list_to_formula(options.get("categories"))
151 # Switch name and name_formula parameters if required.
152 name, name_formula = self._process_names(
153 options.get("name"), options.get("name_formula")
154 )
156 # Get an id for the data equivalent to the range formula.
157 cat_id = self._get_data_id(categories, options.get("categories_data"))
158 val_id = self._get_data_id(values, options.get("values_data"))
159 name_id = self._get_data_id(name_formula, options.get("name_data"))
161 # Set the line properties for the series.
162 line = Shape._get_line_properties(options.get("line"))
164 # Allow 'border' as a synonym for 'line' in bar/column style charts.
165 if options.get("border"):
166 line = Shape._get_line_properties(options["border"])
168 # Set the fill properties for the series.
169 fill = Shape._get_fill_properties(options.get("fill"))
171 # Set the pattern fill properties for the series.
172 pattern = Shape._get_pattern_properties(options.get("pattern"))
174 # Set the gradient fill properties for the series.
175 gradient = Shape._get_gradient_properties(options.get("gradient"))
177 # Pattern fill overrides solid fill.
178 if pattern:
179 self.fill = None
181 # Gradient fill overrides the solid and pattern fill.
182 if gradient:
183 pattern = None
184 fill = None
186 # Set the marker properties for the series.
187 marker = self._get_marker_properties(options.get("marker"))
189 # Set the trendline properties for the series.
190 trendline = self._get_trendline_properties(options.get("trendline"))
192 # Set the line smooth property for the series.
193 smooth = options.get("smooth")
195 # Set the error bars properties for the series.
196 y_error_bars = self._get_error_bars_props(options.get("y_error_bars"))
197 x_error_bars = self._get_error_bars_props(options.get("x_error_bars"))
199 error_bars = {"x_error_bars": x_error_bars, "y_error_bars": y_error_bars}
201 # Set the point properties for the series.
202 points = self._get_points_properties(options.get("points"))
204 # Set the labels properties for the series.
205 labels = self._get_labels_properties(options.get("data_labels"))
207 # Set the "invert if negative" fill property.
208 invert_if_neg = options.get("invert_if_negative", False)
209 inverted_color = options.get("invert_if_negative_color")
211 if inverted_color:
212 inverted_color = Color._from_value(inverted_color)
214 # Set the secondary axis properties.
215 x2_axis = options.get("x2_axis")
216 y2_axis = options.get("y2_axis")
218 # Store secondary status for combined charts.
219 if x2_axis or y2_axis:
220 self.is_secondary = True
222 # Set the gap for Bar/Column charts.
223 if options.get("gap") is not None:
224 if y2_axis:
225 self.series_gap_2 = options["gap"]
226 else:
227 self.series_gap_1 = options["gap"]
229 # Set the overlap for Bar/Column charts.
230 if options.get("overlap"):
231 if y2_axis:
232 self.series_overlap_2 = options["overlap"]
233 else:
234 self.series_overlap_1 = options["overlap"]
236 # Add the user supplied data to the internal structures.
237 series = {
238 "values": values,
239 "categories": categories,
240 "name": name,
241 "name_formula": name_formula,
242 "name_id": name_id,
243 "val_data_id": val_id,
244 "cat_data_id": cat_id,
245 "line": line,
246 "fill": fill,
247 "pattern": pattern,
248 "gradient": gradient,
249 "marker": marker,
250 "trendline": trendline,
251 "labels": labels,
252 "invert_if_neg": invert_if_neg,
253 "inverted_color": inverted_color,
254 "x2_axis": x2_axis,
255 "y2_axis": y2_axis,
256 "points": points,
257 "error_bars": error_bars,
258 "smooth": smooth,
259 }
261 self.series.append(series)
263 def set_x_axis(self, options: Dict[str, Any]) -> None:
264 """
265 Set the chart X axis options.
267 Args:
268 options: A dictionary of axis options.
270 Returns:
271 Nothing.
273 """
274 axis = self._convert_axis_args(self.x_axis, options)
276 self.x_axis = axis
278 def set_y_axis(self, options: Dict[str, Any]) -> None:
279 """
280 Set the chart Y axis options.
282 Args:
283 options: A dictionary of axis options.
285 Returns:
286 Nothing.
288 """
289 axis = self._convert_axis_args(self.y_axis, options)
291 self.y_axis = axis
293 def set_x2_axis(self, options: Dict[str, Any]) -> None:
294 """
295 Set the chart secondary X axis options.
297 Args:
298 options: A dictionary of axis options.
300 Returns:
301 Nothing.
303 """
304 axis = self._convert_axis_args(self.x2_axis, options)
306 self.x2_axis = axis
308 def set_y2_axis(self, options: Dict[str, Any]) -> None:
309 """
310 Set the chart secondary Y axis options.
312 Args:
313 options: A dictionary of axis options.
315 Returns:
316 Nothing.
318 """
319 axis = self._convert_axis_args(self.y2_axis, options)
321 self.y2_axis = axis
323 def set_title(self, options: Optional[Dict[str, Any]] = None) -> None:
324 """
325 Set the chart title options.
327 Args:
328 options: A dictionary of chart title options.
330 Returns:
331 Nothing.
333 """
334 if options is None:
335 options = {}
337 name, name_formula = self._process_names(
338 options.get("name"), options.get("name_formula")
339 )
341 data_id = self._get_data_id(name_formula, options.get("data"))
343 self.title_name = name
344 self.title_formula = name_formula
345 self.title_data_id = data_id
347 # Set the font properties if present.
348 self.title_font = self._convert_font_args(options.get("name_font"))
350 # Set the axis name layout.
351 self.title_layout = self._get_layout_properties(options.get("layout"), True)
352 # Set the title overlay option.
353 self.title_overlay = options.get("overlay")
355 # Set the automatic title option.
356 self.title_none = options.get("none")
358 def set_legend(self, options: Dict[str, Any]) -> None:
359 """
360 Set the chart legend options.
362 Args:
363 options: A dictionary of chart legend options.
365 Returns:
366 Nothing.
367 """
368 # Convert the user defined properties to internal properties.
369 self.legend = self._get_legend_properties(options)
371 def set_plotarea(self, options: Dict[str, Any]) -> None:
372 """
373 Set the chart plot area options.
375 Args:
376 options: A dictionary of chart plot area options.
378 Returns:
379 Nothing.
380 """
381 # Convert the user defined properties to internal properties.
382 self.plotarea = self._get_area_properties(options)
384 def set_chartarea(self, options: Dict[str, Any]) -> None:
385 """
386 Set the chart area options.
388 Args:
389 options: A dictionary of chart area options.
391 Returns:
392 Nothing.
393 """
394 # Convert the user defined properties to internal properties.
395 self.chartarea = self._get_area_properties(options)
397 def set_style(self, style_id: int = 2) -> None:
398 """
399 Set the chart style type.
401 Args:
402 style_id: An int representing the chart style.
404 Returns:
405 Nothing.
406 """
407 # Set one of the 48 built-in Excel chart styles. The default is 2.
408 if style_id is None:
409 style_id = 2
411 if style_id < 1 or style_id > 48:
412 style_id = 2
414 self.style_id = style_id
416 def show_blanks_as(self, option: str) -> None:
417 """
418 Set the option for displaying blank data in a chart.
420 Args:
421 option: A string representing the display option.
423 Returns:
424 Nothing.
425 """
426 if not option:
427 return
429 valid_options = {
430 "gap": 1,
431 "zero": 1,
432 "span": 1,
433 }
435 if option not in valid_options:
436 warn(f"Unknown show_blanks_as() option '{option}'")
437 return
439 self.show_blanks = option
441 def show_na_as_empty_cell(self) -> None:
442 """
443 Display ``#N/A`` on charts as blank/empty cells.
445 Args:
446 None.
448 Returns:
449 Nothing.
450 """
451 self.show_na_as_empty = True
453 def show_hidden_data(self) -> None:
454 """
455 Display data on charts from hidden rows or columns.
457 Args:
458 None.
460 Returns:
461 Nothing.
462 """
463 self.show_hidden = True
465 def set_size(self, options: Optional[Dict[str, Any]] = None) -> None:
466 """
467 Set size or scale of the chart.
469 Args:
470 options: A dictionary of chart size options.
472 Returns:
473 Nothing.
474 """
475 if options is None:
476 options = {}
478 # Set dimensions or scale for the chart.
479 self.width = options.get("width", self.width)
480 self.height = options.get("height", self.height)
481 self.x_scale = options.get("x_scale", 1)
482 self.y_scale = options.get("y_scale", 1)
483 self.x_offset = options.get("x_offset", 0)
484 self.y_offset = options.get("y_offset", 0)
486 def set_table(self, options: Optional[Dict[str, Any]] = None) -> None:
487 """
488 Set properties for an axis data table.
490 Args:
491 options: A dictionary of axis table options.
493 Returns:
494 Nothing.
496 """
497 if options is None:
498 options = {}
500 table = {}
502 table["horizontal"] = options.get("horizontal", 1)
503 table["vertical"] = options.get("vertical", 1)
504 table["outline"] = options.get("outline", 1)
505 table["show_keys"] = options.get("show_keys", 0)
506 table["font"] = self._convert_font_args(options.get("font"))
508 self.table = table
510 def set_up_down_bars(self, options: Optional[Dict[str, Any]] = None) -> None:
511 """
512 Set properties for the chart up-down bars.
514 Args:
515 options: A dictionary of options.
517 Returns:
518 Nothing.
520 """
521 if options is None:
522 options = {}
524 # Defaults.
525 up_line = None
526 up_fill = None
527 down_line = None
528 down_fill = None
530 # Set properties for 'up' bar.
531 if options.get("up"):
532 if "border" in options["up"]:
533 # Map border to line.
534 up_line = Shape._get_line_properties(options["up"]["border"])
536 if "line" in options["up"]:
537 up_line = Shape._get_line_properties(options["up"]["line"])
539 if "fill" in options["up"]:
540 up_fill = Shape._get_fill_properties(options["up"]["fill"])
542 # Set properties for 'down' bar.
543 if options.get("down"):
544 if "border" in options["down"]:
545 # Map border to line.
546 down_line = Shape._get_line_properties(options["down"]["border"])
548 if "line" in options["down"]:
549 down_line = Shape._get_line_properties(options["down"]["line"])
551 if "fill" in options["down"]:
552 down_fill = Shape._get_fill_properties(options["down"]["fill"])
554 self.up_down_bars = {
555 "up": {
556 "line": up_line,
557 "fill": up_fill,
558 },
559 "down": {
560 "line": down_line,
561 "fill": down_fill,
562 },
563 }
565 def set_drop_lines(self, options: Optional[Dict[str, Any]] = None) -> None:
566 """
567 Set properties for the chart drop lines.
569 Args:
570 options: A dictionary of options.
572 Returns:
573 Nothing.
575 """
576 if options is None:
577 options = {}
579 line = Shape._get_line_properties(options.get("line"))
580 fill = Shape._get_fill_properties(options.get("fill"))
582 # Set the pattern fill properties for the series.
583 pattern = Shape._get_pattern_properties(options.get("pattern"))
585 # Set the gradient fill properties for the series.
586 gradient = Shape._get_gradient_properties(options.get("gradient"))
588 # Pattern fill overrides solid fill.
589 if pattern:
590 self.fill = None
592 # Gradient fill overrides the solid and pattern fill.
593 if gradient:
594 pattern = None
595 fill = None
597 self.drop_lines = {
598 "line": line,
599 "fill": fill,
600 "pattern": pattern,
601 "gradient": gradient,
602 }
604 def set_high_low_lines(self, options: Optional[Dict[str, Any]] = None) -> None:
605 """
606 Set properties for the chart high-low lines.
608 Args:
609 options: A dictionary of options.
611 Returns:
612 Nothing.
614 """
615 if options is None:
616 options = {}
618 line = Shape._get_line_properties(options.get("line"))
619 fill = Shape._get_fill_properties(options.get("fill"))
621 # Set the pattern fill properties for the series.
622 pattern = Shape._get_pattern_properties(options.get("pattern"))
624 # Set the gradient fill properties for the series.
625 gradient = Shape._get_gradient_properties(options.get("gradient"))
627 # Pattern fill overrides solid fill.
628 if pattern:
629 self.fill = None
631 # Gradient fill overrides the solid and pattern fill.
632 if gradient:
633 pattern = None
634 fill = None
636 self.hi_low_lines = {
637 "line": line,
638 "fill": fill,
639 "pattern": pattern,
640 "gradient": gradient,
641 }
643 def combine(self, chart: Optional["Chart"] = None) -> None:
644 """
645 Create a combination chart with a secondary chart.
647 Args:
648 chart: The secondary chart to combine with the primary chart.
650 Returns:
651 Nothing.
653 """
654 if chart is None:
655 return
657 self.combined = chart
659 ###########################################################################
660 #
661 # Private API.
662 #
663 ###########################################################################
665 def _assemble_xml_file(self) -> None:
666 # Assemble and write the XML file.
668 # Write the XML declaration.
669 self._xml_declaration()
671 # Write the c:chartSpace element.
672 self._write_chart_space()
674 # Write the c:lang element.
675 self._write_lang()
677 # Write the c:style element.
678 self._write_style()
680 # Write the c:protection element.
681 self._write_protection()
683 # Write the c:chart element.
684 self._write_chart()
686 # Write the c:spPr element for the chartarea formatting.
687 self._write_sp_pr(self.chartarea)
689 # Write the c:printSettings element.
690 if self.embedded:
691 self._write_print_settings()
693 # Close the worksheet tag.
694 self._xml_end_tag("c:chartSpace")
695 # Close the file.
696 self._xml_close()
698 def _convert_axis_args(self, axis, user_options):
699 # Convert user defined axis values into private hash values.
700 options = axis["defaults"].copy()
701 options.update(user_options)
703 name, name_formula = self._process_names(
704 options.get("name"), options.get("name_formula")
705 )
707 data_id = self._get_data_id(name_formula, options.get("data"))
709 axis = {
710 "defaults": axis["defaults"],
711 "name": name,
712 "formula": name_formula,
713 "data_id": data_id,
714 "reverse": options.get("reverse"),
715 "min": options.get("min"),
716 "max": options.get("max"),
717 "minor_unit": options.get("minor_unit"),
718 "major_unit": options.get("major_unit"),
719 "minor_unit_type": options.get("minor_unit_type"),
720 "major_unit_type": options.get("major_unit_type"),
721 "display_units": options.get("display_units"),
722 "log_base": options.get("log_base"),
723 "crossing": options.get("crossing"),
724 "position_axis": options.get("position_axis"),
725 "position": options.get("position"),
726 "label_position": options.get("label_position"),
727 "label_align": options.get("label_align"),
728 "num_format": options.get("num_format"),
729 "num_format_linked": options.get("num_format_linked"),
730 "interval_unit": options.get("interval_unit"),
731 "interval_tick": options.get("interval_tick"),
732 "text_axis": False,
733 }
735 axis["visible"] = options.get("visible", True)
737 # Convert the display units.
738 axis["display_units"] = self._get_display_units(axis["display_units"])
739 axis["display_units_visible"] = options.get("display_units_visible", True)
741 # Map major_gridlines properties.
742 if options.get("major_gridlines") and options["major_gridlines"]["visible"]:
743 axis["major_gridlines"] = self._get_gridline_properties(
744 options["major_gridlines"]
745 )
747 # Map minor_gridlines properties.
748 if options.get("minor_gridlines") and options["minor_gridlines"]["visible"]:
749 axis["minor_gridlines"] = self._get_gridline_properties(
750 options["minor_gridlines"]
751 )
753 # Only use the first letter of bottom, top, left or right.
754 if axis.get("position"):
755 axis["position"] = axis["position"].lower()[0]
757 # Set the position for a category axis on or between the tick marks.
758 if axis.get("position_axis"):
759 if axis["position_axis"] == "on_tick":
760 axis["position_axis"] = "midCat"
761 elif axis["position_axis"] == "between":
762 # Doesn't need to be modified.
763 pass
764 else:
765 # Otherwise use the default value.
766 axis["position_axis"] = None
768 # Set the category axis as a date axis.
769 if options.get("date_axis"):
770 self.date_category = True
772 # Set the category axis as a text axis.
773 if options.get("text_axis"):
774 self.date_category = False
775 axis["text_axis"] = True
777 # Convert datetime args if required.
778 if axis.get("min") and _supported_datetime(axis["min"]):
779 axis["min"] = _datetime_to_excel_datetime(
780 axis["min"], self.date_1904, self.remove_timezone
781 )
782 if axis.get("max") and _supported_datetime(axis["max"]):
783 axis["max"] = _datetime_to_excel_datetime(
784 axis["max"], self.date_1904, self.remove_timezone
785 )
786 if axis.get("crossing") and _supported_datetime(axis["crossing"]):
787 axis["crossing"] = _datetime_to_excel_datetime(
788 axis["crossing"], self.date_1904, self.remove_timezone
789 )
791 # Set the font properties if present.
792 axis["num_font"] = self._convert_font_args(options.get("num_font"))
793 axis["name_font"] = self._convert_font_args(options.get("name_font"))
795 # Set the axis name layout.
796 axis["name_layout"] = self._get_layout_properties(
797 options.get("name_layout"), True
798 )
800 # Set the line properties for the axis.
801 axis["line"] = Shape._get_line_properties(options.get("line"))
803 # Set the fill properties for the axis.
804 axis["fill"] = Shape._get_fill_properties(options.get("fill"))
806 # Set the pattern fill properties for the series.
807 axis["pattern"] = Shape._get_pattern_properties(options.get("pattern"))
809 # Set the gradient fill properties for the series.
810 axis["gradient"] = Shape._get_gradient_properties(options.get("gradient"))
812 # Pattern fill overrides solid fill.
813 if axis.get("pattern"):
814 axis["fill"] = None
816 # Gradient fill overrides the solid and pattern fill.
817 if axis.get("gradient"):
818 axis["pattern"] = None
819 axis["fill"] = None
821 # Set the tick marker types.
822 axis["minor_tick_mark"] = self._get_tick_type(options.get("minor_tick_mark"))
823 axis["major_tick_mark"] = self._get_tick_type(options.get("major_tick_mark"))
825 return axis
827 def _convert_font_args(self, options):
828 # Convert user defined font values into private dict values.
829 if not options:
830 return {}
832 font = {
833 "name": options.get("name"),
834 "color": options.get("color"),
835 "size": options.get("size"),
836 "bold": options.get("bold"),
837 "italic": options.get("italic"),
838 "underline": options.get("underline"),
839 "pitch_family": options.get("pitch_family"),
840 "charset": options.get("charset"),
841 "baseline": options.get("baseline", 0),
842 "rotation": options.get("rotation"),
843 }
845 # Convert font size units.
846 if font["size"]:
847 font["size"] = int(font["size"] * 100)
849 # Convert rotation into 60,000ths of a degree.
850 if font["rotation"]:
851 font["rotation"] = 60000 * int(font["rotation"])
853 if font.get("color"):
854 font["color"] = Color._from_value(font["color"])
856 return font
858 def _list_to_formula(self, data):
859 # Convert and list of row col values to a range formula.
861 # If it isn't an array ref it is probably a formula already.
862 if not isinstance(data, list):
863 # Check for unquoted sheetnames.
864 if data and " " in data and "'" not in data and self.warn_sheetname:
865 warn(
866 f"Sheetname in '{data}' contains spaces but isn't quoted. "
867 f"This may cause an error in Excel."
868 )
869 return data
871 formula = xl_range_formula(*data)
873 return formula
875 def _process_names(self, name, name_formula):
876 # Switch name and name_formula parameters if required.
878 if name is not None:
879 if isinstance(name, list):
880 # Convert a list of values into a name formula.
881 cell = xl_rowcol_to_cell(name[1], name[2], True, True)
882 name_formula = quote_sheetname(name[0]) + "!" + cell
883 name = ""
884 elif re.match(r"^=?[^!]+!\$?[A-Z]+\$?\d+", name):
885 # Name looks like a formula, use it to set name_formula.
886 name_formula = name
887 name = ""
889 return name, name_formula
891 def _get_data_type(self, data) -> str:
892 # Find the overall type of the data associated with a series.
894 # Check for no data in the series.
895 if data is None or len(data) == 0:
896 return "none"
898 if isinstance(data[0], list):
899 return "multi_str"
901 # Determine if data is numeric or strings.
902 for token in data:
903 if token is None:
904 continue
906 # Check for strings that would evaluate to float like
907 # '1.1_1' of ' 1'.
908 if isinstance(token, str) and re.search("[_ ]", token):
909 # Assume entire data series is string data.
910 return "str"
912 try:
913 float(token)
914 except ValueError:
915 # Not a number. Assume entire data series is string data.
916 return "str"
918 # The series data was all numeric.
919 return "num"
921 def _get_data_id(self, formula, data):
922 # Assign an id to a each unique series formula or title/axis formula.
923 # Repeated formulas such as for categories get the same id. If the
924 # series or title has user specified data associated with it then
925 # that is also stored. This data is used to populate cached Excel
926 # data when creating a chart. If there is no user defined data then
927 # it will be populated by the parent Workbook._add_chart_data().
929 # Ignore series without a range formula.
930 if not formula:
931 return None
933 # Strip the leading '=' from the formula.
934 if formula.startswith("="):
935 formula = formula.lstrip("=")
937 # Store the data id in a hash keyed by the formula and store the data
938 # in a separate array with the same id.
939 if formula not in self.formula_ids:
940 # Haven't seen this formula before.
941 formula_id = len(self.formula_data)
943 self.formula_data.append(data)
944 self.formula_ids[formula] = formula_id
945 else:
946 # Formula already seen. Return existing id.
947 formula_id = self.formula_ids[formula]
949 # Store user defined data if it isn't already there.
950 if self.formula_data[formula_id] is None:
951 self.formula_data[formula_id] = data
953 return formula_id
955 def _get_marker_properties(self, marker):
956 # Convert user marker properties to the structure required internally.
958 if not marker:
959 return None
961 # Copy the user defined properties since they will be modified.
962 marker = copy.deepcopy(marker)
964 types = {
965 "automatic": "automatic",
966 "none": "none",
967 "square": "square",
968 "diamond": "diamond",
969 "triangle": "triangle",
970 "x": "x",
971 "star": "star",
972 "dot": "dot",
973 "short_dash": "dot",
974 "dash": "dash",
975 "long_dash": "dash",
976 "circle": "circle",
977 "plus": "plus",
978 "picture": "picture",
979 }
981 # Check for valid types.
982 marker_type = marker.get("type")
984 if marker_type is not None:
985 if marker_type in types:
986 marker["type"] = types[marker_type]
987 else:
988 warn(f"Unknown marker type '{marker_type}")
989 return None
991 # Set the line properties for the marker.
992 line = Shape._get_line_properties(marker.get("line"))
994 # Allow 'border' as a synonym for 'line'.
995 if "border" in marker:
996 line = Shape._get_line_properties(marker["border"])
998 # Set the fill properties for the marker.
999 fill = Shape._get_fill_properties(marker.get("fill"))
1001 # Set the pattern fill properties for the series.
1002 pattern = Shape._get_pattern_properties(marker.get("pattern"))
1004 # Set the gradient fill properties for the series.
1005 gradient = Shape._get_gradient_properties(marker.get("gradient"))
1007 # Pattern fill overrides solid fill.
1008 if pattern:
1009 self.fill = None
1011 # Gradient fill overrides the solid and pattern fill.
1012 if gradient:
1013 pattern = None
1014 fill = None
1016 marker["line"] = line
1017 marker["fill"] = fill
1018 marker["pattern"] = pattern
1019 marker["gradient"] = gradient
1021 return marker
1023 def _get_trendline_properties(self, trendline):
1024 # Convert user trendline properties to structure required internally.
1026 if not trendline:
1027 return None
1029 # Copy the user defined properties since they will be modified.
1030 trendline = copy.deepcopy(trendline)
1032 types = {
1033 "exponential": "exp",
1034 "linear": "linear",
1035 "log": "log",
1036 "moving_average": "movingAvg",
1037 "polynomial": "poly",
1038 "power": "power",
1039 }
1041 # Check the trendline type.
1042 trend_type = trendline.get("type")
1044 if trend_type in types:
1045 trendline["type"] = types[trend_type]
1046 else:
1047 warn(f"Unknown trendline type '{trend_type}'")
1048 return None
1050 # Set the line properties for the trendline.
1051 line = Shape._get_line_properties(trendline.get("line"))
1053 # Allow 'border' as a synonym for 'line'.
1054 if "border" in trendline:
1055 line = Shape._get_line_properties(trendline["border"])
1057 # Set the fill properties for the trendline.
1058 fill = Shape._get_fill_properties(trendline.get("fill"))
1060 # Set the pattern fill properties for the trendline.
1061 pattern = Shape._get_pattern_properties(trendline.get("pattern"))
1063 # Set the gradient fill properties for the trendline.
1064 gradient = Shape._get_gradient_properties(trendline.get("gradient"))
1066 # Set the format properties for the trendline label.
1067 label = self._get_trendline_label_properties(trendline.get("label"))
1069 # Pattern fill overrides solid fill.
1070 if pattern:
1071 self.fill = None
1073 # Gradient fill overrides the solid and pattern fill.
1074 if gradient:
1075 pattern = None
1076 fill = None
1078 trendline["line"] = line
1079 trendline["fill"] = fill
1080 trendline["pattern"] = pattern
1081 trendline["gradient"] = gradient
1082 trendline["label"] = label
1084 return trendline
1086 def _get_trendline_label_properties(self, label):
1087 # Convert user trendline properties to structure required internally.
1089 if not label:
1090 return {}
1092 # Copy the user defined properties since they will be modified.
1093 label = copy.deepcopy(label)
1095 # Set the font properties if present.
1096 font = self._convert_font_args(label.get("font"))
1098 # Set the line properties for the label.
1099 line = Shape._get_line_properties(label.get("line"))
1101 # Allow 'border' as a synonym for 'line'.
1102 if "border" in label:
1103 line = Shape._get_line_properties(label["border"])
1105 # Set the fill properties for the label.
1106 fill = Shape._get_fill_properties(label.get("fill"))
1108 # Set the pattern fill properties for the label.
1109 pattern = Shape._get_pattern_properties(label.get("pattern"))
1111 # Set the gradient fill properties for the label.
1112 gradient = Shape._get_gradient_properties(label.get("gradient"))
1114 # Pattern fill overrides solid fill.
1115 if pattern:
1116 self.fill = None
1118 # Gradient fill overrides the solid and pattern fill.
1119 if gradient:
1120 pattern = None
1121 fill = None
1123 label["font"] = font
1124 label["line"] = line
1125 label["fill"] = fill
1126 label["pattern"] = pattern
1127 label["gradient"] = gradient
1129 return label
1131 def _get_error_bars_props(self, options):
1132 # Convert user error bars properties to structure required internally.
1133 if not options:
1134 return {}
1136 # Default values.
1137 error_bars = {"type": "fixedVal", "value": 1, "endcap": 1, "direction": "both"}
1139 types = {
1140 "fixed": "fixedVal",
1141 "percentage": "percentage",
1142 "standard_deviation": "stdDev",
1143 "standard_error": "stdErr",
1144 "custom": "cust",
1145 }
1147 # Check the error bars type.
1148 error_type = options["type"]
1150 if error_type in types:
1151 error_bars["type"] = types[error_type]
1152 else:
1153 warn(f"Unknown error bars type '{error_type}")
1154 return {}
1156 # Set the value for error types that require it.
1157 if "value" in options:
1158 error_bars["value"] = options["value"]
1160 # Set the end-cap style.
1161 if "end_style" in options:
1162 error_bars["endcap"] = options["end_style"]
1164 # Set the error bar direction.
1165 if "direction" in options:
1166 if options["direction"] == "minus":
1167 error_bars["direction"] = "minus"
1168 elif options["direction"] == "plus":
1169 error_bars["direction"] = "plus"
1170 else:
1171 # Default to 'both'.
1172 pass
1174 # Set any custom values.
1175 error_bars["plus_values"] = options.get("plus_values")
1176 error_bars["minus_values"] = options.get("minus_values")
1177 error_bars["plus_data"] = options.get("plus_data")
1178 error_bars["minus_data"] = options.get("minus_data")
1180 # Set the line properties for the error bars.
1181 error_bars["line"] = Shape._get_line_properties(options.get("line"))
1183 return error_bars
1185 def _get_gridline_properties(self, options):
1186 # Convert user gridline properties to structure required internally.
1188 # Set the visible property for the gridline.
1189 gridline = {"visible": options.get("visible")}
1191 # Set the line properties for the gridline.
1192 gridline["line"] = Shape._get_line_properties(options.get("line"))
1194 return gridline
1196 def _get_labels_properties(self, labels):
1197 # Convert user labels properties to the structure required internally.
1199 if not labels:
1200 return None
1202 # Copy the user defined properties since they will be modified.
1203 labels = copy.deepcopy(labels)
1205 # Map user defined label positions to Excel positions.
1206 position = labels.get("position")
1208 if position:
1209 if position in self.label_positions:
1210 if position == self.label_position_default:
1211 labels["position"] = None
1212 else:
1213 labels["position"] = self.label_positions[position]
1214 else:
1215 warn(f"Unsupported label position '{position}' for this chart type")
1216 return None
1218 # Map the user defined label separator to the Excel separator.
1219 separator = labels.get("separator")
1220 separators = {
1221 ",": ", ",
1222 ";": "; ",
1223 ".": ". ",
1224 "\n": "\n",
1225 " ": " ",
1226 }
1228 if separator:
1229 if separator in separators:
1230 labels["separator"] = separators[separator]
1231 else:
1232 warn("Unsupported label separator")
1233 return None
1235 # Set the font properties if present.
1236 labels["font"] = self._convert_font_args(labels.get("font"))
1238 # Set the line properties for the labels.
1239 line = Shape._get_line_properties(labels.get("line"))
1241 # Allow 'border' as a synonym for 'line'.
1242 if "border" in labels:
1243 line = Shape._get_line_properties(labels["border"])
1245 # Set the fill properties for the labels.
1246 fill = Shape._get_fill_properties(labels.get("fill"))
1248 # Set the pattern fill properties for the labels.
1249 pattern = Shape._get_pattern_properties(labels.get("pattern"))
1251 # Set the gradient fill properties for the labels.
1252 gradient = Shape._get_gradient_properties(labels.get("gradient"))
1254 # Pattern fill overrides solid fill.
1255 if pattern:
1256 self.fill = None
1258 # Gradient fill overrides the solid and pattern fill.
1259 if gradient:
1260 pattern = None
1261 fill = None
1263 labels["line"] = line
1264 labels["fill"] = fill
1265 labels["pattern"] = pattern
1266 labels["gradient"] = gradient
1268 if labels.get("custom"):
1269 for label in labels["custom"]:
1270 if label is None:
1271 continue
1273 value = label.get("value")
1274 if value and re.match(r"^=?[^!]+!\$?[A-Z]+\$?\d+", str(value)):
1275 label["formula"] = value
1277 formula = label.get("formula")
1278 if formula and formula.startswith("="):
1279 label["formula"] = formula.lstrip("=")
1281 data_id = self._get_data_id(formula, label.get("data"))
1282 label["data_id"] = data_id
1284 label["font"] = self._convert_font_args(label.get("font"))
1286 # Set the line properties for the label.
1287 line = Shape._get_line_properties(label.get("line"))
1289 # Allow 'border' as a synonym for 'line'.
1290 if "border" in label:
1291 line = Shape._get_line_properties(label["border"])
1293 # Set the fill properties for the label.
1294 fill = Shape._get_fill_properties(label.get("fill"))
1296 # Set the pattern fill properties for the label.
1297 pattern = Shape._get_pattern_properties(label.get("pattern"))
1299 # Set the gradient fill properties for the label.
1300 gradient = Shape._get_gradient_properties(label.get("gradient"))
1302 # Pattern fill overrides solid fill.
1303 if pattern:
1304 self.fill = None
1306 # Gradient fill overrides the solid and pattern fill.
1307 if gradient:
1308 pattern = None
1309 fill = None
1311 # Map user defined label positions to Excel positions.
1312 position = label.get("position")
1314 if position:
1315 if position in self.label_positions:
1316 if position == self.label_position_default:
1317 label["position"] = None
1318 else:
1319 label["position"] = self.label_positions[position]
1320 else:
1321 warn(f"Unsupported label position '{position}' for chart type")
1322 return None
1324 label["line"] = line
1325 label["fill"] = fill
1326 label["pattern"] = pattern
1327 label["gradient"] = gradient
1329 return labels
1331 def _get_area_properties(self, options):
1332 # Convert user area properties to the structure required internally.
1333 area = {}
1335 # Set the line properties for the chartarea.
1336 line = Shape._get_line_properties(options.get("line"))
1338 # Allow 'border' as a synonym for 'line'.
1339 if options.get("border"):
1340 line = Shape._get_line_properties(options["border"])
1342 # Set the fill properties for the chartarea.
1343 fill = Shape._get_fill_properties(options.get("fill"))
1345 # Set the pattern fill properties for the series.
1346 pattern = Shape._get_pattern_properties(options.get("pattern"))
1348 # Set the gradient fill properties for the series.
1349 gradient = Shape._get_gradient_properties(options.get("gradient"))
1351 # Pattern fill overrides solid fill.
1352 if pattern:
1353 self.fill = None
1355 # Gradient fill overrides the solid and pattern fill.
1356 if gradient:
1357 pattern = None
1358 fill = None
1360 # Set the plotarea layout.
1361 layout = self._get_layout_properties(options.get("layout"), False)
1363 area["line"] = line
1364 area["fill"] = fill
1365 area["pattern"] = pattern
1366 area["layout"] = layout
1367 area["gradient"] = gradient
1369 return area
1371 def _get_legend_properties(self, options: Optional[Dict[str, Any]] = None):
1372 # Convert user legend properties to the structure required internally.
1373 legend = {}
1375 if options is None:
1376 options = {}
1378 legend["position"] = options.get("position", "right")
1379 legend["delete_series"] = options.get("delete_series")
1380 legend["font"] = self._convert_font_args(options.get("font"))
1381 legend["layout"] = self._get_layout_properties(options.get("layout"), False)
1383 # Turn off the legend.
1384 if options.get("none"):
1385 legend["position"] = "none"
1387 # Set the line properties for the legend.
1388 line = Shape._get_line_properties(options.get("line"))
1390 # Allow 'border' as a synonym for 'line'.
1391 if options.get("border"):
1392 line = Shape._get_line_properties(options["border"])
1394 # Set the fill properties for the legend.
1395 fill = Shape._get_fill_properties(options.get("fill"))
1397 # Set the pattern fill properties for the series.
1398 pattern = Shape._get_pattern_properties(options.get("pattern"))
1400 # Set the gradient fill properties for the series.
1401 gradient = Shape._get_gradient_properties(options.get("gradient"))
1403 # Pattern fill overrides solid fill.
1404 if pattern:
1405 self.fill = None
1407 # Gradient fill overrides the solid and pattern fill.
1408 if gradient:
1409 pattern = None
1410 fill = None
1412 # Set the legend layout.
1413 layout = self._get_layout_properties(options.get("layout"), False)
1415 legend["line"] = line
1416 legend["fill"] = fill
1417 legend["pattern"] = pattern
1418 legend["layout"] = layout
1419 legend["gradient"] = gradient
1421 return legend
1423 def _get_layout_properties(self, args, is_text):
1424 # Convert user defined layout properties to format used internally.
1425 layout = {}
1427 if not args:
1428 return {}
1430 if is_text:
1431 properties = ("x", "y")
1432 else:
1433 properties = ("x", "y", "width", "height")
1435 # Check for valid properties.
1436 for key in args.keys():
1437 if key not in properties:
1438 warn(f"Property '{key}' not supported in layout options")
1439 return {}
1441 # Set the layout properties.
1442 for prop in properties:
1443 if prop not in args.keys():
1444 warn(f"Property '{prop}' must be specified in layout options")
1445 return {}
1447 value = args[prop]
1449 try:
1450 float(value)
1451 except ValueError:
1452 warn(f"Property '{prop}' value '{value}' must be numeric in layout")
1453 return {}
1455 if value < 0 or value > 1:
1456 warn(
1457 f"Property '{prop}' value '{value}' must be in range "
1458 f"0 < x <= 1 in layout options"
1459 )
1460 return {}
1462 # Convert to the format used by Excel for easier testing
1463 layout[prop] = f"{value:.17g}"
1465 return layout
1467 def _get_points_properties(self, user_points):
1468 # Convert user points properties to structure required internally.
1469 points = []
1471 if not user_points:
1472 return []
1474 for user_point in user_points:
1475 point = {}
1477 if user_point is not None:
1478 # Set the line properties for the point.
1479 line = Shape._get_line_properties(user_point.get("line"))
1481 # Allow 'border' as a synonym for 'line'.
1482 if "border" in user_point:
1483 line = Shape._get_line_properties(user_point["border"])
1485 # Set the fill properties for the chartarea.
1486 fill = Shape._get_fill_properties(user_point.get("fill"))
1488 # Set the pattern fill properties for the series.
1489 pattern = Shape._get_pattern_properties(user_point.get("pattern"))
1491 # Set the gradient fill properties for the series.
1492 gradient = Shape._get_gradient_properties(user_point.get("gradient"))
1494 # Pattern fill overrides solid fill.
1495 if pattern:
1496 self.fill = None
1498 # Gradient fill overrides the solid and pattern fill.
1499 if gradient:
1500 pattern = None
1501 fill = None
1503 point["line"] = line
1504 point["fill"] = fill
1505 point["pattern"] = pattern
1506 point["gradient"] = gradient
1508 points.append(point)
1510 return points
1512 def _has_fill_formatting(self, element):
1513 # Check if a chart element has line, fill or gradient formatting.
1514 has_fill = False
1515 has_line = False
1516 has_pattern = element.get("pattern")
1517 has_gradient = element.get("gradient")
1519 if element.get("fill") and element["fill"]["defined"]:
1520 has_fill = True
1522 if element.get("line") and element["line"]["defined"]:
1523 has_line = True
1525 return has_fill or has_line or has_pattern or has_gradient
1527 def _get_display_units(self, display_units):
1528 # Convert user defined display units to internal units.
1529 if not display_units:
1530 return None
1532 types = {
1533 "hundreds": "hundreds",
1534 "thousands": "thousands",
1535 "ten_thousands": "tenThousands",
1536 "hundred_thousands": "hundredThousands",
1537 "millions": "millions",
1538 "ten_millions": "tenMillions",
1539 "hundred_millions": "hundredMillions",
1540 "billions": "billions",
1541 "trillions": "trillions",
1542 }
1544 if display_units in types:
1545 display_units = types[display_units]
1546 else:
1547 warn(f"Unknown display_units type '{display_units}'")
1548 return None
1550 return display_units
1552 def _get_tick_type(self, tick_type):
1553 # Convert user defined display units to internal units.
1554 if not tick_type:
1555 return None
1557 types = {
1558 "outside": "out",
1559 "inside": "in",
1560 "none": "none",
1561 "cross": "cross",
1562 }
1564 if tick_type in types:
1565 tick_type = types[tick_type]
1566 else:
1567 warn(f"Unknown tick_type '{tick_type}'")
1568 return None
1570 return tick_type
1572 def _get_primary_axes_series(self):
1573 # Returns series which use the primary axes.
1574 primary_axes_series = []
1576 for series in self.series:
1577 if not series["y2_axis"]:
1578 primary_axes_series.append(series)
1580 return primary_axes_series
1582 def _get_secondary_axes_series(self):
1583 # Returns series which use the secondary axes.
1584 secondary_axes_series = []
1586 for series in self.series:
1587 if series["y2_axis"]:
1588 secondary_axes_series.append(series)
1590 return secondary_axes_series
1592 def _add_axis_ids(self, args) -> None:
1593 # Add unique ids for primary or secondary axes
1594 chart_id = 5001 + int(self.id)
1595 axis_count = 1 + len(self.axis2_ids) + len(self.axis_ids)
1597 id1 = f"{chart_id:04d}{axis_count:04d}"
1598 id2 = f"{chart_id:04d}{axis_count + 1:04d}"
1600 if args["primary_axes"]:
1601 self.axis_ids.append(id1)
1602 self.axis_ids.append(id2)
1604 if not args["primary_axes"]:
1605 self.axis2_ids.append(id1)
1606 self.axis2_ids.append(id2)
1608 def _set_default_properties(self) -> None:
1609 # Setup the default properties for a chart.
1611 self.x_axis["defaults"] = {
1612 "num_format": "General",
1613 "major_gridlines": {"visible": 0},
1614 }
1616 self.y_axis["defaults"] = {
1617 "num_format": "General",
1618 "major_gridlines": {"visible": 1},
1619 }
1621 self.x2_axis["defaults"] = {
1622 "num_format": "General",
1623 "label_position": "none",
1624 "crossing": "max",
1625 "visible": 0,
1626 }
1628 self.y2_axis["defaults"] = {
1629 "num_format": "General",
1630 "major_gridlines": {"visible": 0},
1631 "position": "right",
1632 "visible": 1,
1633 }
1635 self.set_x_axis({})
1636 self.set_y_axis({})
1638 self.set_x2_axis({})
1639 self.set_y2_axis({})
1641 ###########################################################################
1642 #
1643 # XML methods.
1644 #
1645 ###########################################################################
1647 def _write_chart_space(self) -> None:
1648 # Write the <c:chartSpace> element.
1649 schema = "http://schemas.openxmlformats.org/"
1650 xmlns_c = schema + "drawingml/2006/chart"
1651 xmlns_a = schema + "drawingml/2006/main"
1652 xmlns_r = schema + "officeDocument/2006/relationships"
1654 attributes = [
1655 ("xmlns:c", xmlns_c),
1656 ("xmlns:a", xmlns_a),
1657 ("xmlns:r", xmlns_r),
1658 ]
1660 self._xml_start_tag("c:chartSpace", attributes)
1662 def _write_lang(self) -> None:
1663 # Write the <c:lang> element.
1664 val = "en-US"
1666 attributes = [("val", val)]
1668 self._xml_empty_tag("c:lang", attributes)
1670 def _write_style(self) -> None:
1671 # Write the <c:style> element.
1672 style_id = self.style_id
1674 # Don't write an element for the default style, 2.
1675 if style_id == 2:
1676 return
1678 attributes = [("val", style_id)]
1680 self._xml_empty_tag("c:style", attributes)
1682 def _write_chart(self) -> None:
1683 # Write the <c:chart> element.
1684 self._xml_start_tag("c:chart")
1686 if self.title_none:
1687 # Turn off the title.
1688 self._write_c_auto_title_deleted()
1689 else:
1690 # Write the chart title elements.
1691 if self.title_formula is not None:
1692 self._write_title_formula(
1693 self.title_formula,
1694 self.title_data_id,
1695 None,
1696 self.title_font,
1697 self.title_layout,
1698 self.title_overlay,
1699 )
1700 elif self.title_name is not None:
1701 self._write_title_rich(
1702 self.title_name,
1703 None,
1704 self.title_font,
1705 self.title_layout,
1706 self.title_overlay,
1707 )
1709 # Write the c:plotArea element.
1710 self._write_plot_area()
1712 # Write the c:legend element.
1713 self._write_legend()
1715 # Write the c:plotVisOnly element.
1716 self._write_plot_vis_only()
1718 # Write the c:dispBlanksAs element.
1719 self._write_disp_blanks_as()
1721 # Write the c:extLst element.
1722 if self.show_na_as_empty:
1723 self._write_c_ext_lst_display_na()
1725 self._xml_end_tag("c:chart")
1727 def _write_disp_blanks_as(self) -> None:
1728 # Write the <c:dispBlanksAs> element.
1729 val = self.show_blanks
1731 # Ignore the default value.
1732 if val == "gap":
1733 return
1735 attributes = [("val", val)]
1737 self._xml_empty_tag("c:dispBlanksAs", attributes)
1739 def _write_plot_area(self) -> None:
1740 # Write the <c:plotArea> element.
1741 self._xml_start_tag("c:plotArea")
1743 # Write the c:layout element.
1744 self._write_layout(self.plotarea.get("layout"), "plot")
1746 # Write subclass chart type elements for primary and secondary axes.
1747 self._write_chart_type({"primary_axes": True})
1748 self._write_chart_type({"primary_axes": False})
1750 # Configure a combined chart if present.
1751 second_chart = self.combined
1752 if second_chart:
1753 # Secondary axis has unique id otherwise use same as primary.
1754 if second_chart.is_secondary:
1755 second_chart.id = 1000 + self.id
1756 else:
1757 second_chart.id = self.id
1759 # Share the same filehandle for writing.
1760 second_chart.fh = self.fh
1762 # Share series index with primary chart.
1763 second_chart.series_index = self.series_index
1765 # Write the subclass chart type elements for combined chart.
1766 second_chart._write_chart_type({"primary_axes": True})
1767 second_chart._write_chart_type({"primary_axes": False})
1769 # Write the category and value elements for the primary axes.
1770 args = {"x_axis": self.x_axis, "y_axis": self.y_axis, "axis_ids": self.axis_ids}
1772 if self.date_category:
1773 self._write_date_axis(args)
1774 else:
1775 self._write_cat_axis(args)
1777 self._write_val_axis(args)
1779 # Write the category and value elements for the secondary axes.
1780 args = {
1781 "x_axis": self.x2_axis,
1782 "y_axis": self.y2_axis,
1783 "axis_ids": self.axis2_ids,
1784 }
1786 self._write_val_axis(args)
1788 # Write the secondary axis for the secondary chart.
1789 if second_chart and second_chart.is_secondary:
1790 args = {
1791 "x_axis": second_chart.x2_axis,
1792 "y_axis": second_chart.y2_axis,
1793 "axis_ids": second_chart.axis2_ids,
1794 }
1796 second_chart._write_val_axis(args)
1798 if self.date_category:
1799 self._write_date_axis(args)
1800 else:
1801 self._write_cat_axis(args)
1803 # Write the c:dTable element.
1804 self._write_d_table()
1806 # Write the c:spPr element for the plotarea formatting.
1807 self._write_sp_pr(self.plotarea)
1809 self._xml_end_tag("c:plotArea")
1811 def _write_layout(self, layout, layout_type) -> None:
1812 # Write the <c:layout> element.
1814 if not layout:
1815 # Automatic layout.
1816 self._xml_empty_tag("c:layout")
1817 else:
1818 # User defined manual layout.
1819 self._xml_start_tag("c:layout")
1820 self._write_manual_layout(layout, layout_type)
1821 self._xml_end_tag("c:layout")
1823 def _write_manual_layout(self, layout, layout_type) -> None:
1824 # Write the <c:manualLayout> element.
1825 self._xml_start_tag("c:manualLayout")
1827 # Plotarea has a layoutTarget element.
1828 if layout_type == "plot":
1829 self._xml_empty_tag("c:layoutTarget", [("val", "inner")])
1831 # Set the x, y positions.
1832 self._xml_empty_tag("c:xMode", [("val", "edge")])
1833 self._xml_empty_tag("c:yMode", [("val", "edge")])
1834 self._xml_empty_tag("c:x", [("val", layout["x"])])
1835 self._xml_empty_tag("c:y", [("val", layout["y"])])
1837 # For plotarea and legend set the width and height.
1838 if layout_type != "text":
1839 self._xml_empty_tag("c:w", [("val", layout["width"])])
1840 self._xml_empty_tag("c:h", [("val", layout["height"])])
1842 self._xml_end_tag("c:manualLayout")
1844 def _write_chart_type(self, args) -> None:
1845 # pylint: disable=unused-argument
1846 # Write the chart type element. This method should be overridden
1847 # by the subclasses.
1848 return
1850 def _write_grouping(self, val) -> None:
1851 # Write the <c:grouping> element.
1852 attributes = [("val", val)]
1854 self._xml_empty_tag("c:grouping", attributes)
1856 def _write_series(self, series) -> None:
1857 # Write the series elements.
1858 self._write_ser(series)
1860 def _write_ser(self, series) -> None:
1861 # Write the <c:ser> element.
1862 index = self.series_index
1863 self.series_index += 1
1865 self._xml_start_tag("c:ser")
1867 # Write the c:idx element.
1868 self._write_idx(index)
1870 # Write the c:order element.
1871 self._write_order(index)
1873 # Write the series name.
1874 self._write_series_name(series)
1876 # Write the c:spPr element.
1877 self._write_sp_pr(series)
1879 # Write the c:marker element.
1880 self._write_marker(series["marker"])
1882 # Write the c:invertIfNegative element.
1883 self._write_c_invert_if_negative(series["invert_if_neg"])
1885 # Write the c:dPt element.
1886 self._write_d_pt(series["points"])
1888 # Write the c:dLbls element.
1889 self._write_d_lbls(series["labels"])
1891 # Write the c:trendline element.
1892 self._write_trendline(series["trendline"])
1894 # Write the c:errBars element.
1895 self._write_error_bars(series["error_bars"])
1897 # Write the c:cat element.
1898 self._write_cat(series)
1900 # Write the c:val element.
1901 self._write_val(series)
1903 # Write the c:smooth element.
1904 if self.smooth_allowed:
1905 self._write_c_smooth(series["smooth"])
1907 # Write the c:extLst element.
1908 if series.get("inverted_color"):
1909 self._write_c_ext_lst_inverted_color(series["inverted_color"])
1911 self._xml_end_tag("c:ser")
1913 def _write_c_ext_lst_inverted_color(self, color: Color) -> None:
1914 # Write the <c:extLst> element for the inverted fill color.
1916 uri = "{6F2FDCE9-48DA-4B69-8628-5D25D57E5C99}"
1917 xmlns_c_14 = "http://schemas.microsoft.com/office/drawing/2007/8/2/chart"
1919 attributes1 = [
1920 ("uri", uri),
1921 ("xmlns:c14", xmlns_c_14),
1922 ]
1924 attributes2 = [("xmlns:c14", xmlns_c_14)]
1926 self._xml_start_tag("c:extLst")
1927 self._xml_start_tag("c:ext", attributes1)
1928 self._xml_start_tag("c14:invertSolidFillFmt")
1929 self._xml_start_tag("c14:spPr", attributes2)
1931 self._write_a_solid_fill({"color": color})
1933 self._xml_end_tag("c14:spPr")
1934 self._xml_end_tag("c14:invertSolidFillFmt")
1935 self._xml_end_tag("c:ext")
1936 self._xml_end_tag("c:extLst")
1938 def _write_c_ext_lst_display_na(self) -> None:
1939 # Write the <c:extLst> element for the display NA as empty cell option.
1941 uri = "{56B9EC1D-385E-4148-901F-78D8002777C0}"
1942 xmlns_c_16 = "http://schemas.microsoft.com/office/drawing/2017/03/chart"
1944 attributes1 = [
1945 ("uri", uri),
1946 ("xmlns:c16r3", xmlns_c_16),
1947 ]
1949 attributes2 = [("val", 1)]
1951 self._xml_start_tag("c:extLst")
1952 self._xml_start_tag("c:ext", attributes1)
1953 self._xml_start_tag("c16r3:dataDisplayOptions16")
1954 self._xml_empty_tag("c16r3:dispNaAsBlank", attributes2)
1955 self._xml_end_tag("c16r3:dataDisplayOptions16")
1956 self._xml_end_tag("c:ext")
1957 self._xml_end_tag("c:extLst")
1959 def _write_idx(self, val) -> None:
1960 # Write the <c:idx> element.
1962 attributes = [("val", val)]
1964 self._xml_empty_tag("c:idx", attributes)
1966 def _write_order(self, val) -> None:
1967 # Write the <c:order> element.
1969 attributes = [("val", val)]
1971 self._xml_empty_tag("c:order", attributes)
1973 def _write_series_name(self, series) -> None:
1974 # Write the series name.
1976 if series["name_formula"] is not None:
1977 self._write_tx_formula(series["name_formula"], series["name_id"])
1978 elif series["name"] is not None:
1979 self._write_tx_value(series["name"])
1981 def _write_c_smooth(self, smooth) -> None:
1982 # Write the <c:smooth> element.
1984 if smooth:
1985 self._xml_empty_tag("c:smooth", [("val", "1")])
1987 def _write_cat(self, series) -> None:
1988 # Write the <c:cat> element.
1989 formula = series["categories"]
1990 data_id = series["cat_data_id"]
1991 data = None
1993 if data_id is not None:
1994 data = self.formula_data[data_id]
1996 # Ignore <c:cat> elements for charts without category values.
1997 if not formula:
1998 return
2000 self._xml_start_tag("c:cat")
2002 # Check the type of cached data.
2003 cat_type = self._get_data_type(data)
2005 if cat_type == "str":
2006 self.cat_has_num_fmt = False
2007 # Write the c:numRef element.
2008 self._write_str_ref(formula, data, cat_type)
2010 elif cat_type == "multi_str":
2011 self.cat_has_num_fmt = False
2012 # Write the c:numRef element.
2013 self._write_multi_lvl_str_ref(formula, data)
2015 else:
2016 self.cat_has_num_fmt = True
2017 # Write the c:numRef element.
2018 self._write_num_ref(formula, data, cat_type)
2020 self._xml_end_tag("c:cat")
2022 def _write_val(self, series) -> None:
2023 # Write the <c:val> element.
2024 formula = series["values"]
2025 data_id = series["val_data_id"]
2026 data = self.formula_data[data_id]
2028 self._xml_start_tag("c:val")
2030 # Unlike Cat axes data should only be numeric.
2031 # Write the c:numRef element.
2032 self._write_num_ref(formula, data, "num")
2034 self._xml_end_tag("c:val")
2036 def _write_num_ref(self, formula, data, ref_type) -> None:
2037 # Write the <c:numRef> element.
2038 self._xml_start_tag("c:numRef")
2040 # Write the c:f element.
2041 self._write_series_formula(formula)
2043 if ref_type == "num":
2044 # Write the c:numCache element.
2045 self._write_num_cache(data)
2046 elif ref_type == "str":
2047 # Write the c:strCache element.
2048 self._write_str_cache(data)
2050 self._xml_end_tag("c:numRef")
2052 def _write_str_ref(self, formula, data, ref_type) -> None:
2053 # Write the <c:strRef> element.
2055 self._xml_start_tag("c:strRef")
2057 # Write the c:f element.
2058 self._write_series_formula(formula)
2060 if ref_type == "num":
2061 # Write the c:numCache element.
2062 self._write_num_cache(data)
2063 elif ref_type == "str":
2064 # Write the c:strCache element.
2065 self._write_str_cache(data)
2067 self._xml_end_tag("c:strRef")
2069 def _write_multi_lvl_str_ref(self, formula, data) -> None:
2070 # Write the <c:multiLvlStrRef> element.
2072 if not data:
2073 return
2075 self._xml_start_tag("c:multiLvlStrRef")
2077 # Write the c:f element.
2078 self._write_series_formula(formula)
2080 self._xml_start_tag("c:multiLvlStrCache")
2082 # Write the c:ptCount element.
2083 count = len(data[-1])
2084 self._write_pt_count(count)
2086 for cat_data in reversed(data):
2087 self._xml_start_tag("c:lvl")
2089 for i, point in enumerate(cat_data):
2090 # Write the c:pt element.
2091 self._write_pt(i, point)
2093 self._xml_end_tag("c:lvl")
2095 self._xml_end_tag("c:multiLvlStrCache")
2096 self._xml_end_tag("c:multiLvlStrRef")
2098 def _write_series_formula(self, formula) -> None:
2099 # Write the <c:f> element.
2101 # Strip the leading '=' from the formula.
2102 if formula.startswith("="):
2103 formula = formula.lstrip("=")
2105 self._xml_data_element("c:f", formula)
2107 def _write_axis_ids(self, args) -> None:
2108 # Write the <c:axId> elements for the primary or secondary axes.
2110 # Generate the axis ids.
2111 self._add_axis_ids(args)
2113 if args["primary_axes"]:
2114 # Write the axis ids for the primary axes.
2115 self._write_axis_id(self.axis_ids[0])
2116 self._write_axis_id(self.axis_ids[1])
2117 else:
2118 # Write the axis ids for the secondary axes.
2119 self._write_axis_id(self.axis2_ids[0])
2120 self._write_axis_id(self.axis2_ids[1])
2122 def _write_axis_id(self, val) -> None:
2123 # Write the <c:axId> element.
2125 attributes = [("val", val)]
2127 self._xml_empty_tag("c:axId", attributes)
2129 def _write_cat_axis(self, args) -> None:
2130 # Write the <c:catAx> element. Usually the X axis.
2131 x_axis = args["x_axis"]
2132 y_axis = args["y_axis"]
2133 axis_ids = args["axis_ids"]
2135 # If there are no axis_ids then we don't need to write this element.
2136 if axis_ids is None or not axis_ids:
2137 return
2139 position = self.cat_axis_position
2140 is_y_axis = self.horiz_cat_axis
2142 # Overwrite the default axis position with a user supplied value.
2143 if x_axis.get("position"):
2144 position = x_axis["position"]
2146 self._xml_start_tag("c:catAx")
2148 self._write_axis_id(axis_ids[0])
2150 # Write the c:scaling element.
2151 self._write_scaling(x_axis.get("reverse"), None, None, None)
2153 if not x_axis.get("visible"):
2154 self._write_delete(1)
2156 # Write the c:axPos element.
2157 self._write_axis_pos(position, y_axis.get("reverse"))
2159 # Write the c:majorGridlines element.
2160 self._write_major_gridlines(x_axis.get("major_gridlines"))
2162 # Write the c:minorGridlines element.
2163 self._write_minor_gridlines(x_axis.get("minor_gridlines"))
2165 # Write the axis title elements.
2166 if x_axis["formula"] is not None:
2167 self._write_title_formula(
2168 x_axis["formula"],
2169 x_axis["data_id"],
2170 is_y_axis,
2171 x_axis["name_font"],
2172 x_axis["name_layout"],
2173 )
2174 elif x_axis["name"] is not None:
2175 self._write_title_rich(
2176 x_axis["name"], is_y_axis, x_axis["name_font"], x_axis["name_layout"]
2177 )
2179 # Write the c:numFmt element.
2180 self._write_cat_number_format(x_axis)
2182 # Write the c:majorTickMark element.
2183 self._write_major_tick_mark(x_axis.get("major_tick_mark"))
2185 # Write the c:minorTickMark element.
2186 self._write_minor_tick_mark(x_axis.get("minor_tick_mark"))
2188 # Write the c:tickLblPos element.
2189 self._write_tick_label_pos(x_axis.get("label_position"))
2191 # Write the c:spPr element for the axis line.
2192 self._write_sp_pr(x_axis)
2194 # Write the axis font elements.
2195 self._write_axis_font(x_axis.get("num_font"))
2197 # Write the c:crossAx element.
2198 self._write_cross_axis(axis_ids[1])
2200 if self.show_crosses or x_axis.get("visible"):
2201 # Note, the category crossing comes from the value axis.
2202 if (
2203 y_axis.get("crossing") is None
2204 or y_axis.get("crossing") == "max"
2205 or y_axis["crossing"] == "min"
2206 ):
2207 # Write the c:crosses element.
2208 self._write_crosses(y_axis.get("crossing"))
2209 else:
2210 # Write the c:crossesAt element.
2211 self._write_c_crosses_at(y_axis.get("crossing"))
2213 # Write the c:auto element.
2214 if not x_axis.get("text_axis"):
2215 self._write_auto(1)
2217 # Write the c:labelAlign element.
2218 self._write_label_align(x_axis.get("label_align"))
2220 # Write the c:labelOffset element.
2221 self._write_label_offset(100)
2223 # Write the c:tickLblSkip element.
2224 self._write_c_tick_lbl_skip(x_axis.get("interval_unit"))
2226 # Write the c:tickMarkSkip element.
2227 self._write_c_tick_mark_skip(x_axis.get("interval_tick"))
2229 self._xml_end_tag("c:catAx")
2231 def _write_val_axis(self, args) -> None:
2232 # Write the <c:valAx> element. Usually the Y axis.
2233 x_axis = args["x_axis"]
2234 y_axis = args["y_axis"]
2235 axis_ids = args["axis_ids"]
2236 position = args.get("position", self.val_axis_position)
2237 is_y_axis = self.horiz_val_axis
2239 # If there are no axis_ids then we don't need to write this element.
2240 if axis_ids is None or not axis_ids:
2241 return
2243 # Overwrite the default axis position with a user supplied value.
2244 position = y_axis.get("position") or position
2246 self._xml_start_tag("c:valAx")
2248 self._write_axis_id(axis_ids[1])
2250 # Write the c:scaling element.
2251 self._write_scaling(
2252 y_axis.get("reverse"),
2253 y_axis.get("min"),
2254 y_axis.get("max"),
2255 y_axis.get("log_base"),
2256 )
2258 if not y_axis.get("visible"):
2259 self._write_delete(1)
2261 # Write the c:axPos element.
2262 self._write_axis_pos(position, x_axis.get("reverse"))
2264 # Write the c:majorGridlines element.
2265 self._write_major_gridlines(y_axis.get("major_gridlines"))
2267 # Write the c:minorGridlines element.
2268 self._write_minor_gridlines(y_axis.get("minor_gridlines"))
2270 # Write the axis title elements.
2271 if y_axis["formula"] is not None:
2272 self._write_title_formula(
2273 y_axis["formula"],
2274 y_axis["data_id"],
2275 is_y_axis,
2276 y_axis["name_font"],
2277 y_axis["name_layout"],
2278 )
2279 elif y_axis["name"] is not None:
2280 self._write_title_rich(
2281 y_axis["name"],
2282 is_y_axis,
2283 y_axis.get("name_font"),
2284 y_axis.get("name_layout"),
2285 )
2287 # Write the c:numberFormat element.
2288 self._write_number_format(y_axis)
2290 # Write the c:majorTickMark element.
2291 self._write_major_tick_mark(y_axis.get("major_tick_mark"))
2293 # Write the c:minorTickMark element.
2294 self._write_minor_tick_mark(y_axis.get("minor_tick_mark"))
2296 # Write the c:tickLblPos element.
2297 self._write_tick_label_pos(y_axis.get("label_position"))
2299 # Write the c:spPr element for the axis line.
2300 self._write_sp_pr(y_axis)
2302 # Write the axis font elements.
2303 self._write_axis_font(y_axis.get("num_font"))
2305 # Write the c:crossAx element.
2306 self._write_cross_axis(axis_ids[0])
2308 # Note, the category crossing comes from the value axis.
2309 if (
2310 x_axis.get("crossing") is None
2311 or x_axis["crossing"] == "max"
2312 or x_axis["crossing"] == "min"
2313 ):
2314 # Write the c:crosses element.
2315 self._write_crosses(x_axis.get("crossing"))
2316 else:
2317 # Write the c:crossesAt element.
2318 self._write_c_crosses_at(x_axis.get("crossing"))
2320 # Write the c:crossBetween element.
2321 self._write_cross_between(x_axis.get("position_axis"))
2323 # Write the c:majorUnit element.
2324 self._write_c_major_unit(y_axis.get("major_unit"))
2326 # Write the c:minorUnit element.
2327 self._write_c_minor_unit(y_axis.get("minor_unit"))
2329 # Write the c:dispUnits element.
2330 self._write_disp_units(
2331 y_axis.get("display_units"), y_axis.get("display_units_visible")
2332 )
2334 self._xml_end_tag("c:valAx")
2336 def _write_cat_val_axis(self, args) -> None:
2337 # Write the <c:valAx> element. This is for the second valAx
2338 # in scatter plots. Usually the X axis.
2339 x_axis = args["x_axis"]
2340 y_axis = args["y_axis"]
2341 axis_ids = args["axis_ids"]
2342 position = args["position"] or self.val_axis_position
2343 is_y_axis = self.horiz_val_axis
2345 # If there are no axis_ids then we don't need to write this element.
2346 if axis_ids is None or not axis_ids:
2347 return
2349 # Overwrite the default axis position with a user supplied value.
2350 position = x_axis.get("position") or position
2352 self._xml_start_tag("c:valAx")
2354 self._write_axis_id(axis_ids[0])
2356 # Write the c:scaling element.
2357 self._write_scaling(
2358 x_axis.get("reverse"),
2359 x_axis.get("min"),
2360 x_axis.get("max"),
2361 x_axis.get("log_base"),
2362 )
2364 if not x_axis.get("visible"):
2365 self._write_delete(1)
2367 # Write the c:axPos element.
2368 self._write_axis_pos(position, y_axis.get("reverse"))
2370 # Write the c:majorGridlines element.
2371 self._write_major_gridlines(x_axis.get("major_gridlines"))
2373 # Write the c:minorGridlines element.
2374 self._write_minor_gridlines(x_axis.get("minor_gridlines"))
2376 # Write the axis title elements.
2377 if x_axis["formula"] is not None:
2378 self._write_title_formula(
2379 x_axis["formula"],
2380 x_axis["data_id"],
2381 is_y_axis,
2382 x_axis["name_font"],
2383 x_axis["name_layout"],
2384 )
2385 elif x_axis["name"] is not None:
2386 self._write_title_rich(
2387 x_axis["name"], is_y_axis, x_axis["name_font"], x_axis["name_layout"]
2388 )
2390 # Write the c:numberFormat element.
2391 self._write_number_format(x_axis)
2393 # Write the c:majorTickMark element.
2394 self._write_major_tick_mark(x_axis.get("major_tick_mark"))
2396 # Write the c:minorTickMark element.
2397 self._write_minor_tick_mark(x_axis.get("minor_tick_mark"))
2399 # Write the c:tickLblPos element.
2400 self._write_tick_label_pos(x_axis.get("label_position"))
2402 # Write the c:spPr element for the axis line.
2403 self._write_sp_pr(x_axis)
2405 # Write the axis font elements.
2406 self._write_axis_font(x_axis.get("num_font"))
2408 # Write the c:crossAx element.
2409 self._write_cross_axis(axis_ids[1])
2411 # Note, the category crossing comes from the value axis.
2412 if (
2413 y_axis.get("crossing") is None
2414 or y_axis["crossing"] == "max"
2415 or y_axis["crossing"] == "min"
2416 ):
2417 # Write the c:crosses element.
2418 self._write_crosses(y_axis.get("crossing"))
2419 else:
2420 # Write the c:crossesAt element.
2421 self._write_c_crosses_at(y_axis.get("crossing"))
2423 # Write the c:crossBetween element.
2424 self._write_cross_between(y_axis.get("position_axis"))
2426 # Write the c:majorUnit element.
2427 self._write_c_major_unit(x_axis.get("major_unit"))
2429 # Write the c:minorUnit element.
2430 self._write_c_minor_unit(x_axis.get("minor_unit"))
2432 # Write the c:dispUnits element.
2433 self._write_disp_units(
2434 x_axis.get("display_units"), x_axis.get("display_units_visible")
2435 )
2437 self._xml_end_tag("c:valAx")
2439 def _write_date_axis(self, args) -> None:
2440 # Write the <c:dateAx> element. Usually the X axis.
2441 x_axis = args["x_axis"]
2442 y_axis = args["y_axis"]
2443 axis_ids = args["axis_ids"]
2445 # If there are no axis_ids then we don't need to write this element.
2446 if axis_ids is None or not axis_ids:
2447 return
2449 position = self.cat_axis_position
2451 # Overwrite the default axis position with a user supplied value.
2452 position = x_axis.get("position") or position
2454 self._xml_start_tag("c:dateAx")
2456 self._write_axis_id(axis_ids[0])
2458 # Write the c:scaling element.
2459 self._write_scaling(
2460 x_axis.get("reverse"),
2461 x_axis.get("min"),
2462 x_axis.get("max"),
2463 x_axis.get("log_base"),
2464 )
2466 if not x_axis.get("visible"):
2467 self._write_delete(1)
2469 # Write the c:axPos element.
2470 self._write_axis_pos(position, y_axis.get("reverse"))
2472 # Write the c:majorGridlines element.
2473 self._write_major_gridlines(x_axis.get("major_gridlines"))
2475 # Write the c:minorGridlines element.
2476 self._write_minor_gridlines(x_axis.get("minor_gridlines"))
2478 # Write the axis title elements.
2479 if x_axis["formula"] is not None:
2480 self._write_title_formula(
2481 x_axis["formula"],
2482 x_axis["data_id"],
2483 None,
2484 x_axis["name_font"],
2485 x_axis["name_layout"],
2486 )
2487 elif x_axis["name"] is not None:
2488 self._write_title_rich(
2489 x_axis["name"], None, x_axis["name_font"], x_axis["name_layout"]
2490 )
2492 # Write the c:numFmt element.
2493 self._write_number_format(x_axis)
2495 # Write the c:majorTickMark element.
2496 self._write_major_tick_mark(x_axis.get("major_tick_mark"))
2498 # Write the c:minorTickMark element.
2499 self._write_minor_tick_mark(x_axis.get("minor_tick_mark"))
2501 # Write the c:tickLblPos element.
2502 self._write_tick_label_pos(x_axis.get("label_position"))
2504 # Write the c:spPr element for the axis line.
2505 self._write_sp_pr(x_axis)
2507 # Write the axis font elements.
2508 self._write_axis_font(x_axis.get("num_font"))
2510 # Write the c:crossAx element.
2511 self._write_cross_axis(axis_ids[1])
2513 if self.show_crosses or x_axis.get("visible"):
2514 # Note, the category crossing comes from the value axis.
2515 if (
2516 y_axis.get("crossing") is None
2517 or y_axis.get("crossing") == "max"
2518 or y_axis["crossing"] == "min"
2519 ):
2520 # Write the c:crosses element.
2521 self._write_crosses(y_axis.get("crossing"))
2522 else:
2523 # Write the c:crossesAt element.
2524 self._write_c_crosses_at(y_axis.get("crossing"))
2526 # Write the c:auto element.
2527 self._write_auto(1)
2529 # Write the c:labelOffset element.
2530 self._write_label_offset(100)
2532 # Write the c:tickLblSkip element.
2533 self._write_c_tick_lbl_skip(x_axis.get("interval_unit"))
2535 # Write the c:tickMarkSkip element.
2536 self._write_c_tick_mark_skip(x_axis.get("interval_tick"))
2538 # Write the c:majorUnit element.
2539 self._write_c_major_unit(x_axis.get("major_unit"))
2541 # Write the c:majorTimeUnit element.
2542 if x_axis.get("major_unit"):
2543 self._write_c_major_time_unit(x_axis["major_unit_type"])
2545 # Write the c:minorUnit element.
2546 self._write_c_minor_unit(x_axis.get("minor_unit"))
2548 # Write the c:minorTimeUnit element.
2549 if x_axis.get("minor_unit"):
2550 self._write_c_minor_time_unit(x_axis["minor_unit_type"])
2552 self._xml_end_tag("c:dateAx")
2554 def _write_scaling(self, reverse, min_val, max_val, log_base) -> None:
2555 # Write the <c:scaling> element.
2557 self._xml_start_tag("c:scaling")
2559 # Write the c:logBase element.
2560 self._write_c_log_base(log_base)
2562 # Write the c:orientation element.
2563 self._write_orientation(reverse)
2565 # Write the c:max element.
2566 self._write_c_max(max_val)
2568 # Write the c:min element.
2569 self._write_c_min(min_val)
2571 self._xml_end_tag("c:scaling")
2573 def _write_c_log_base(self, val) -> None:
2574 # Write the <c:logBase> element.
2576 if not val:
2577 return
2579 attributes = [("val", val)]
2581 self._xml_empty_tag("c:logBase", attributes)
2583 def _write_orientation(self, reverse) -> None:
2584 # Write the <c:orientation> element.
2585 val = "minMax"
2587 if reverse:
2588 val = "maxMin"
2590 attributes = [("val", val)]
2592 self._xml_empty_tag("c:orientation", attributes)
2594 def _write_c_max(self, max_val) -> None:
2595 # Write the <c:max> element.
2597 if max_val is None:
2598 return
2600 attributes = [("val", max_val)]
2602 self._xml_empty_tag("c:max", attributes)
2604 def _write_c_min(self, min_val) -> None:
2605 # Write the <c:min> element.
2607 if min_val is None:
2608 return
2610 attributes = [("val", min_val)]
2612 self._xml_empty_tag("c:min", attributes)
2614 def _write_axis_pos(self, val, reverse) -> None:
2615 # Write the <c:axPos> element.
2617 if reverse:
2618 if val == "l":
2619 val = "r"
2620 if val == "b":
2621 val = "t"
2623 attributes = [("val", val)]
2625 self._xml_empty_tag("c:axPos", attributes)
2627 def _write_number_format(self, axis) -> None:
2628 # Write the <c:numberFormat> element. Note: It is assumed that if
2629 # a user defined number format is supplied (i.e., non-default) then
2630 # the sourceLinked attribute is 0.
2631 # The user can override this if required.
2632 format_code = axis.get("num_format")
2633 source_linked = 1
2635 # Check if a user defined number format has been set.
2636 if format_code is not None and format_code != axis["defaults"]["num_format"]:
2637 source_linked = 0
2639 # User override of sourceLinked.
2640 if axis.get("num_format_linked"):
2641 source_linked = 1
2643 attributes = [
2644 ("formatCode", format_code),
2645 ("sourceLinked", source_linked),
2646 ]
2648 self._xml_empty_tag("c:numFmt", attributes)
2650 def _write_cat_number_format(self, axis) -> None:
2651 # Write the <c:numFmt> element. Special case handler for category
2652 # axes which don't always have a number format.
2653 format_code = axis.get("num_format")
2654 source_linked = 1
2655 default_format = 1
2657 # Check if a user defined number format has been set.
2658 if format_code is not None and format_code != axis["defaults"]["num_format"]:
2659 source_linked = 0
2660 default_format = 0
2662 # User override of sourceLinked.
2663 if axis.get("num_format_linked"):
2664 source_linked = 1
2666 # Skip if cat doesn't have a num format (unless it is non-default).
2667 if not self.cat_has_num_fmt and default_format:
2668 return
2670 attributes = [
2671 ("formatCode", format_code),
2672 ("sourceLinked", source_linked),
2673 ]
2675 self._xml_empty_tag("c:numFmt", attributes)
2677 def _write_data_label_number_format(self, format_code) -> None:
2678 # Write the <c:numberFormat> element for data labels.
2679 source_linked = 0
2681 attributes = [
2682 ("formatCode", format_code),
2683 ("sourceLinked", source_linked),
2684 ]
2686 self._xml_empty_tag("c:numFmt", attributes)
2688 def _write_major_tick_mark(self, val) -> None:
2689 # Write the <c:majorTickMark> element.
2691 if not val:
2692 return
2694 attributes = [("val", val)]
2696 self._xml_empty_tag("c:majorTickMark", attributes)
2698 def _write_minor_tick_mark(self, val) -> None:
2699 # Write the <c:minorTickMark> element.
2701 if not val:
2702 return
2704 attributes = [("val", val)]
2706 self._xml_empty_tag("c:minorTickMark", attributes)
2708 def _write_tick_label_pos(self, val=None) -> None:
2709 # Write the <c:tickLblPos> element.
2710 if val is None or val == "next_to":
2711 val = "nextTo"
2713 attributes = [("val", val)]
2715 self._xml_empty_tag("c:tickLblPos", attributes)
2717 def _write_cross_axis(self, val) -> None:
2718 # Write the <c:crossAx> element.
2720 attributes = [("val", val)]
2722 self._xml_empty_tag("c:crossAx", attributes)
2724 def _write_crosses(self, val=None) -> None:
2725 # Write the <c:crosses> element.
2726 if val is None:
2727 val = "autoZero"
2729 attributes = [("val", val)]
2731 self._xml_empty_tag("c:crosses", attributes)
2733 def _write_c_crosses_at(self, val) -> None:
2734 # Write the <c:crossesAt> element.
2736 attributes = [("val", val)]
2738 self._xml_empty_tag("c:crossesAt", attributes)
2740 def _write_auto(self, val) -> None:
2741 # Write the <c:auto> element.
2743 attributes = [("val", val)]
2745 self._xml_empty_tag("c:auto", attributes)
2747 def _write_label_align(self, val=None) -> None:
2748 # Write the <c:labelAlign> element.
2750 if val is None:
2751 val = "ctr"
2753 if val == "right":
2754 val = "r"
2756 if val == "left":
2757 val = "l"
2759 attributes = [("val", val)]
2761 self._xml_empty_tag("c:lblAlgn", attributes)
2763 def _write_label_offset(self, val) -> None:
2764 # Write the <c:labelOffset> element.
2766 attributes = [("val", val)]
2768 self._xml_empty_tag("c:lblOffset", attributes)
2770 def _write_c_tick_lbl_skip(self, val) -> None:
2771 # Write the <c:tickLblSkip> element.
2772 if val is None:
2773 return
2775 attributes = [("val", val)]
2777 self._xml_empty_tag("c:tickLblSkip", attributes)
2779 def _write_c_tick_mark_skip(self, val) -> None:
2780 # Write the <c:tickMarkSkip> element.
2781 if val is None:
2782 return
2784 attributes = [("val", val)]
2786 self._xml_empty_tag("c:tickMarkSkip", attributes)
2788 def _write_major_gridlines(self, gridlines) -> None:
2789 # Write the <c:majorGridlines> element.
2791 if not gridlines:
2792 return
2794 if not gridlines["visible"]:
2795 return
2797 if gridlines["line"]["defined"]:
2798 self._xml_start_tag("c:majorGridlines")
2800 # Write the c:spPr element.
2801 self._write_sp_pr(gridlines)
2803 self._xml_end_tag("c:majorGridlines")
2804 else:
2805 self._xml_empty_tag("c:majorGridlines")
2807 def _write_minor_gridlines(self, gridlines) -> None:
2808 # Write the <c:minorGridlines> element.
2810 if not gridlines:
2811 return
2813 if not gridlines["visible"]:
2814 return
2816 if gridlines["line"]["defined"]:
2817 self._xml_start_tag("c:minorGridlines")
2819 # Write the c:spPr element.
2820 self._write_sp_pr(gridlines)
2822 self._xml_end_tag("c:minorGridlines")
2823 else:
2824 self._xml_empty_tag("c:minorGridlines")
2826 def _write_cross_between(self, val) -> None:
2827 # Write the <c:crossBetween> element.
2828 if val is None:
2829 val = self.cross_between
2831 attributes = [("val", val)]
2833 self._xml_empty_tag("c:crossBetween", attributes)
2835 def _write_c_major_unit(self, val) -> None:
2836 # Write the <c:majorUnit> element.
2838 if not val:
2839 return
2841 attributes = [("val", val)]
2843 self._xml_empty_tag("c:majorUnit", attributes)
2845 def _write_c_minor_unit(self, val) -> None:
2846 # Write the <c:minorUnit> element.
2848 if not val:
2849 return
2851 attributes = [("val", val)]
2853 self._xml_empty_tag("c:minorUnit", attributes)
2855 def _write_c_major_time_unit(self, val=None) -> None:
2856 # Write the <c:majorTimeUnit> element.
2857 if val is None:
2858 val = "days"
2860 attributes = [("val", val)]
2862 self._xml_empty_tag("c:majorTimeUnit", attributes)
2864 def _write_c_minor_time_unit(self, val=None) -> None:
2865 # Write the <c:minorTimeUnit> element.
2866 if val is None:
2867 val = "days"
2869 attributes = [("val", val)]
2871 self._xml_empty_tag("c:minorTimeUnit", attributes)
2873 def _write_legend(self) -> None:
2874 # Write the <c:legend> element.
2875 legend = self.legend
2876 position = legend.get("position", "right")
2877 font = legend.get("font")
2878 delete_series = []
2879 overlay = 0
2881 if legend.get("delete_series") and isinstance(legend["delete_series"], list):
2882 delete_series = legend["delete_series"]
2884 if position.startswith("overlay_"):
2885 position = position.replace("overlay_", "")
2886 overlay = 1
2888 allowed = {
2889 "right": "r",
2890 "left": "l",
2891 "top": "t",
2892 "bottom": "b",
2893 "top_right": "tr",
2894 }
2896 if position == "none":
2897 return
2899 if position not in allowed:
2900 return
2902 position = allowed[position]
2904 self._xml_start_tag("c:legend")
2906 # Write the c:legendPos element.
2907 self._write_legend_pos(position)
2909 # Remove series labels from the legend.
2910 for index in delete_series:
2911 # Write the c:legendEntry element.
2912 self._write_legend_entry(index)
2914 # Write the c:layout element.
2915 self._write_layout(legend.get("layout"), "legend")
2917 # Write the c:overlay element.
2918 if overlay:
2919 self._write_overlay()
2921 if font:
2922 self._write_tx_pr(font)
2924 # Write the c:spPr element.
2925 self._write_sp_pr(legend)
2927 self._xml_end_tag("c:legend")
2929 def _write_legend_pos(self, val) -> None:
2930 # Write the <c:legendPos> element.
2932 attributes = [("val", val)]
2934 self._xml_empty_tag("c:legendPos", attributes)
2936 def _write_legend_entry(self, index) -> None:
2937 # Write the <c:legendEntry> element.
2939 self._xml_start_tag("c:legendEntry")
2941 # Write the c:idx element.
2942 self._write_idx(index)
2944 # Write the c:delete element.
2945 self._write_delete(1)
2947 self._xml_end_tag("c:legendEntry")
2949 def _write_overlay(self) -> None:
2950 # Write the <c:overlay> element.
2951 val = 1
2953 attributes = [("val", val)]
2955 self._xml_empty_tag("c:overlay", attributes)
2957 def _write_plot_vis_only(self) -> None:
2958 # Write the <c:plotVisOnly> element.
2959 val = 1
2961 # Ignore this element if we are plotting hidden data.
2962 if self.show_hidden:
2963 return
2965 attributes = [("val", val)]
2967 self._xml_empty_tag("c:plotVisOnly", attributes)
2969 def _write_print_settings(self) -> None:
2970 # Write the <c:printSettings> element.
2971 self._xml_start_tag("c:printSettings")
2973 # Write the c:headerFooter element.
2974 self._write_header_footer()
2976 # Write the c:pageMargins element.
2977 self._write_page_margins()
2979 # Write the c:pageSetup element.
2980 self._write_page_setup()
2982 self._xml_end_tag("c:printSettings")
2984 def _write_header_footer(self) -> None:
2985 # Write the <c:headerFooter> element.
2986 self._xml_empty_tag("c:headerFooter")
2988 def _write_page_margins(self) -> None:
2989 # Write the <c:pageMargins> element.
2990 bottom = 0.75
2991 left = 0.7
2992 right = 0.7
2993 top = 0.75
2994 header = 0.3
2995 footer = 0.3
2997 attributes = [
2998 ("b", bottom),
2999 ("l", left),
3000 ("r", right),
3001 ("t", top),
3002 ("header", header),
3003 ("footer", footer),
3004 ]
3006 self._xml_empty_tag("c:pageMargins", attributes)
3008 def _write_page_setup(self) -> None:
3009 # Write the <c:pageSetup> element.
3010 self._xml_empty_tag("c:pageSetup")
3012 def _write_c_auto_title_deleted(self) -> None:
3013 # Write the <c:autoTitleDeleted> element.
3014 self._xml_empty_tag("c:autoTitleDeleted", [("val", 1)])
3016 def _write_title_rich(self, title, is_y_axis, font, layout, overlay=False) -> None:
3017 # Write the <c:title> element for a rich string.
3019 self._xml_start_tag("c:title")
3021 # Write the c:tx element.
3022 self._write_tx_rich(title, is_y_axis, font)
3024 # Write the c:layout element.
3025 self._write_layout(layout, "text")
3027 # Write the c:overlay element.
3028 if overlay:
3029 self._write_overlay()
3031 self._xml_end_tag("c:title")
3033 def _write_title_formula(
3034 self, title, data_id, is_y_axis, font, layout, overlay=False
3035 ) -> None:
3036 # Write the <c:title> element for a rich string.
3038 self._xml_start_tag("c:title")
3040 # Write the c:tx element.
3041 self._write_tx_formula(title, data_id)
3043 # Write the c:layout element.
3044 self._write_layout(layout, "text")
3046 # Write the c:overlay element.
3047 if overlay:
3048 self._write_overlay()
3050 # Write the c:txPr element.
3051 self._write_tx_pr(font, is_y_axis)
3053 self._xml_end_tag("c:title")
3055 def _write_tx_rich(self, title, is_y_axis, font) -> None:
3056 # Write the <c:tx> element.
3058 self._xml_start_tag("c:tx")
3060 # Write the c:rich element.
3061 self._write_rich(title, font, is_y_axis, ignore_rich_pr=False)
3063 self._xml_end_tag("c:tx")
3065 def _write_tx_value(self, title) -> None:
3066 # Write the <c:tx> element with a value such as for series names.
3068 self._xml_start_tag("c:tx")
3070 # Write the c:v element.
3071 self._write_v(title)
3073 self._xml_end_tag("c:tx")
3075 def _write_tx_formula(self, title, data_id) -> None:
3076 # Write the <c:tx> element.
3077 data = None
3079 if data_id is not None:
3080 data = self.formula_data[data_id]
3082 self._xml_start_tag("c:tx")
3084 # Write the c:strRef element.
3085 self._write_str_ref(title, data, "str")
3087 self._xml_end_tag("c:tx")
3089 def _write_rich(self, title, font, is_y_axis, ignore_rich_pr) -> None:
3090 # Write the <c:rich> element.
3092 if font and font.get("rotation") is not None:
3093 rotation = font["rotation"]
3094 else:
3095 rotation = None
3097 self._xml_start_tag("c:rich")
3099 # Write the a:bodyPr element.
3100 self._write_a_body_pr(rotation, is_y_axis)
3102 # Write the a:lstStyle element.
3103 self._write_a_lst_style()
3105 # Write the a:p element.
3106 self._write_a_p_rich(title, font, ignore_rich_pr)
3108 self._xml_end_tag("c:rich")
3110 def _write_a_body_pr(self, rotation, is_y_axis) -> None:
3111 # Write the <a:bodyPr> element.
3112 attributes = []
3114 if rotation is None and is_y_axis:
3115 rotation = -5400000
3117 if rotation is not None:
3118 if rotation == 16200000:
3119 # 270 deg/stacked angle.
3120 attributes.append(("rot", 0))
3121 attributes.append(("vert", "wordArtVert"))
3122 elif rotation == 16260000:
3123 # 271 deg/East Asian vertical.
3124 attributes.append(("rot", 0))
3125 attributes.append(("vert", "eaVert"))
3126 else:
3127 attributes.append(("rot", rotation))
3128 attributes.append(("vert", "horz"))
3130 self._xml_empty_tag("a:bodyPr", attributes)
3132 def _write_a_lst_style(self) -> None:
3133 # Write the <a:lstStyle> element.
3134 self._xml_empty_tag("a:lstStyle")
3136 def _write_a_p_rich(self, title, font, ignore_rich_pr) -> None:
3137 # Write the <a:p> element for rich string titles.
3139 self._xml_start_tag("a:p")
3141 # Write the a:pPr element.
3142 if not ignore_rich_pr:
3143 self._write_a_p_pr_rich(font)
3145 # Write the a:r element.
3146 self._write_a_r(title, font)
3148 self._xml_end_tag("a:p")
3150 def _write_a_p_formula(self, font) -> None:
3151 # Write the <a:p> element for formula titles.
3153 self._xml_start_tag("a:p")
3155 # Write the a:pPr element.
3156 self._write_a_p_pr_rich(font)
3158 # Write the a:endParaRPr element.
3159 self._write_a_end_para_rpr()
3161 self._xml_end_tag("a:p")
3163 def _write_a_p_pr_rich(self, font) -> None:
3164 # Write the <a:pPr> element for rich string titles.
3166 self._xml_start_tag("a:pPr")
3168 # Write the a:defRPr element.
3169 self._write_a_def_rpr(font)
3171 self._xml_end_tag("a:pPr")
3173 def _write_a_def_rpr(self, font) -> None:
3174 # Write the <a:defRPr> element.
3175 has_color = False
3177 style_attributes = Shape._get_font_style_attributes(font)
3178 latin_attributes = Shape._get_font_latin_attributes(font)
3180 if font and font.get("color"):
3181 has_color = True
3183 if latin_attributes or has_color:
3184 self._xml_start_tag("a:defRPr", style_attributes)
3186 if has_color:
3187 self._write_a_solid_fill({"color": font["color"]})
3189 if latin_attributes:
3190 self._write_a_latin(latin_attributes)
3192 self._xml_end_tag("a:defRPr")
3193 else:
3194 self._xml_empty_tag("a:defRPr", style_attributes)
3196 def _write_a_end_para_rpr(self) -> None:
3197 # Write the <a:endParaRPr> element.
3198 lang = "en-US"
3200 attributes = [("lang", lang)]
3202 self._xml_empty_tag("a:endParaRPr", attributes)
3204 def _write_a_r(self, title, font) -> None:
3205 # Write the <a:r> element.
3207 self._xml_start_tag("a:r")
3209 # Write the a:rPr element.
3210 self._write_a_r_pr(font)
3212 # Write the a:t element.
3213 self._write_a_t(title)
3215 self._xml_end_tag("a:r")
3217 def _write_a_r_pr(self, font) -> None:
3218 # Write the <a:rPr> element.
3219 has_color = False
3220 lang = "en-US"
3222 style_attributes = Shape._get_font_style_attributes(font)
3223 latin_attributes = Shape._get_font_latin_attributes(font)
3225 if font and font["color"]:
3226 has_color = True
3228 # Add the lang type to the attributes.
3229 style_attributes.insert(0, ("lang", lang))
3231 if latin_attributes or has_color:
3232 self._xml_start_tag("a:rPr", style_attributes)
3234 if has_color:
3235 self._write_a_solid_fill({"color": font["color"]})
3237 if latin_attributes:
3238 self._write_a_latin(latin_attributes)
3240 self._xml_end_tag("a:rPr")
3241 else:
3242 self._xml_empty_tag("a:rPr", style_attributes)
3244 def _write_a_t(self, title) -> None:
3245 # Write the <a:t> element.
3247 self._xml_data_element("a:t", title)
3249 def _write_tx_pr(self, font, is_y_axis=False) -> None:
3250 # Write the <c:txPr> element.
3252 if font and font.get("rotation") is not None:
3253 rotation = font["rotation"]
3254 else:
3255 rotation = None
3257 self._xml_start_tag("c:txPr")
3259 # Write the a:bodyPr element.
3260 self._write_a_body_pr(rotation, is_y_axis)
3262 # Write the a:lstStyle element.
3263 self._write_a_lst_style()
3265 # Write the a:p element.
3266 self._write_a_p_formula(font)
3268 self._xml_end_tag("c:txPr")
3270 def _write_marker(self, marker) -> None:
3271 # Write the <c:marker> element.
3272 if marker is None:
3273 marker = self.default_marker
3275 if not marker:
3276 return
3278 if marker["type"] == "automatic":
3279 return
3281 self._xml_start_tag("c:marker")
3283 # Write the c:symbol element.
3284 self._write_symbol(marker["type"])
3286 # Write the c:size element.
3287 if marker.get("size"):
3288 self._write_marker_size(marker["size"])
3290 # Write the c:spPr element.
3291 self._write_sp_pr(marker)
3293 self._xml_end_tag("c:marker")
3295 def _write_marker_size(self, val) -> None:
3296 # Write the <c:size> element.
3298 attributes = [("val", val)]
3300 self._xml_empty_tag("c:size", attributes)
3302 def _write_symbol(self, val) -> None:
3303 # Write the <c:symbol> element.
3305 attributes = [("val", val)]
3307 self._xml_empty_tag("c:symbol", attributes)
3309 def _write_sp_pr(self, series) -> None:
3310 # Write the <c:spPr> element.
3312 if not self._has_fill_formatting(series):
3313 return
3315 self._xml_start_tag("c:spPr")
3317 # Write the fill elements for solid charts such as pie and bar.
3318 if series.get("fill") and series["fill"]["defined"]:
3319 if "none" in series["fill"]:
3320 # Write the a:noFill element.
3321 self._write_a_no_fill()
3322 else:
3323 # Write the a:solidFill element.
3324 self._write_a_solid_fill(series["fill"])
3326 if series.get("pattern"):
3327 # Write the a:gradFill element.
3328 self._write_a_patt_fill(series["pattern"])
3330 if series.get("gradient"):
3331 # Write the a:gradFill element.
3332 self._write_a_grad_fill(series["gradient"])
3334 # Write the a:ln element.
3335 if series.get("line") and series["line"]["defined"]:
3336 self._write_a_ln(series["line"])
3338 self._xml_end_tag("c:spPr")
3340 def _write_a_ln(self, line) -> None:
3341 # Write the <a:ln> element.
3342 attributes = []
3344 # Add the line width as an attribute.
3345 width = line.get("width")
3347 if width is not None:
3348 # Round width to nearest 0.25, like Excel.
3349 width = int((width + 0.125) * 4) / 4.0
3351 # Convert to internal units.
3352 width = int(0.5 + (12700 * width))
3354 attributes = [("w", width)]
3356 if line.get("none") or line.get("color") or line.get("dash_type"):
3357 self._xml_start_tag("a:ln", attributes)
3359 # Write the line fill.
3360 if "none" in line:
3361 # Write the a:noFill element.
3362 self._write_a_no_fill()
3363 elif "color" in line:
3364 # Write the a:solidFill element.
3365 self._write_a_solid_fill(line)
3367 # Write the line/dash type.
3368 line_type = line.get("dash_type")
3369 if line_type:
3370 # Write the a:prstDash element.
3371 self._write_a_prst_dash(line_type)
3373 self._xml_end_tag("a:ln")
3374 else:
3375 self._xml_empty_tag("a:ln", attributes)
3377 def _write_a_no_fill(self) -> None:
3378 # Write the <a:noFill> element.
3379 self._xml_empty_tag("a:noFill")
3381 def _write_a_solid_fill(self, fill) -> None:
3382 # Write the <a:solidFill> element.
3384 self._xml_start_tag("a:solidFill")
3386 if fill.get("color"):
3387 self._write_color(fill["color"], fill.get("transparency"))
3389 self._xml_end_tag("a:solidFill")
3391 def _write_color(self, color: Color, transparency=None) -> None:
3392 # Write the appropriate chart color element.
3394 if not color:
3395 return
3397 if color._is_automatic:
3398 # Write the a:sysClr element.
3399 self._write_a_sys_clr()
3400 elif color._type == ColorTypes.RGB:
3401 # Write the a:srgbClr element.
3402 self._write_a_srgb_clr(color, transparency)
3403 elif color._type == ColorTypes.THEME:
3404 self._write_a_scheme_clr(color, transparency)
3406 def _write_a_sys_clr(self) -> None:
3407 # Write the <a:sysClr> element.
3409 val = "window"
3410 last_clr = "FFFFFF"
3412 attributes = [
3413 ("val", val),
3414 ("lastClr", last_clr),
3415 ]
3417 self._xml_empty_tag("a:sysClr", attributes)
3419 def _write_a_srgb_clr(self, color: Color, transparency=None) -> None:
3420 # Write the <a:srgbClr> element.
3422 if not color:
3423 return
3425 attributes = [("val", color._rgb_hex_value())]
3427 if transparency:
3428 self._xml_start_tag("a:srgbClr", attributes)
3430 # Write the a:alpha element.
3431 self._write_a_alpha(transparency)
3433 self._xml_end_tag("a:srgbClr")
3434 else:
3435 self._xml_empty_tag("a:srgbClr", attributes)
3437 def _write_a_scheme_clr(self, color: Color, transparency=None) -> None:
3438 # Write the <a:schemeClr> element.
3439 scheme, lum_mod, lum_off = color._chart_scheme()
3440 attributes = [("val", scheme)]
3442 if lum_mod > 0 or lum_off > 0 or transparency:
3443 self._xml_start_tag("a:schemeClr", attributes)
3445 if lum_mod > 0:
3446 # Write the a:lumMod element.
3447 self._write_a_lum_mod(lum_mod)
3449 if lum_off > 0:
3450 # Write the a:lumOff element.
3451 self._write_a_lum_off(lum_off)
3453 if transparency:
3454 # Write the a:alpha element.
3455 self._write_a_alpha(transparency)
3457 self._xml_end_tag("a:schemeClr")
3458 else:
3459 self._xml_empty_tag("a:schemeClr", attributes)
3461 def _write_a_lum_mod(self, value: int) -> None:
3462 # Write the <a:lumMod> element.
3463 attributes = [("val", value)]
3465 self._xml_empty_tag("a:lumMod", attributes)
3467 def _write_a_lum_off(self, value: int) -> None:
3468 # Write the <a:lumOff> element.
3469 attributes = [("val", value)]
3471 self._xml_empty_tag("a:lumOff", attributes)
3473 def _write_a_alpha(self, val) -> None:
3474 # Write the <a:alpha> element.
3476 val = int((100 - int(val)) * 1000)
3478 attributes = [("val", val)]
3480 self._xml_empty_tag("a:alpha", attributes)
3482 def _write_a_prst_dash(self, val) -> None:
3483 # Write the <a:prstDash> element.
3485 attributes = [("val", val)]
3487 self._xml_empty_tag("a:prstDash", attributes)
3489 def _write_trendline(self, trendline) -> None:
3490 # Write the <c:trendline> element.
3492 if not trendline:
3493 return
3495 self._xml_start_tag("c:trendline")
3497 # Write the c:name element.
3498 self._write_name(trendline.get("name"))
3500 # Write the c:spPr element.
3501 self._write_sp_pr(trendline)
3503 # Write the c:trendlineType element.
3504 self._write_trendline_type(trendline["type"])
3506 # Write the c:order element for polynomial trendlines.
3507 if trendline["type"] == "poly":
3508 self._write_trendline_order(trendline.get("order"))
3510 # Write the c:period element for moving average trendlines.
3511 if trendline["type"] == "movingAvg":
3512 self._write_period(trendline.get("period"))
3514 # Write the c:forward element.
3515 self._write_forward(trendline.get("forward"))
3517 # Write the c:backward element.
3518 self._write_backward(trendline.get("backward"))
3520 if "intercept" in trendline:
3521 # Write the c:intercept element.
3522 self._write_c_intercept(trendline["intercept"])
3524 if trendline.get("display_r_squared"):
3525 # Write the c:dispRSqr element.
3526 self._write_c_disp_rsqr()
3528 if trendline.get("display_equation"):
3529 # Write the c:dispEq element.
3530 self._write_c_disp_eq()
3532 # Write the c:trendlineLbl element.
3533 self._write_c_trendline_lbl(trendline)
3535 self._xml_end_tag("c:trendline")
3537 def _write_trendline_type(self, val) -> None:
3538 # Write the <c:trendlineType> element.
3540 attributes = [("val", val)]
3542 self._xml_empty_tag("c:trendlineType", attributes)
3544 def _write_name(self, data) -> None:
3545 # Write the <c:name> element.
3547 if data is None:
3548 return
3550 self._xml_data_element("c:name", data)
3552 def _write_trendline_order(self, val) -> None:
3553 # Write the <c:order> element.
3554 val = max(val, 2)
3556 attributes = [("val", val)]
3558 self._xml_empty_tag("c:order", attributes)
3560 def _write_period(self, val) -> None:
3561 # Write the <c:period> element.
3562 val = max(val, 2)
3564 attributes = [("val", val)]
3566 self._xml_empty_tag("c:period", attributes)
3568 def _write_forward(self, val) -> None:
3569 # Write the <c:forward> element.
3571 if not val:
3572 return
3574 attributes = [("val", val)]
3576 self._xml_empty_tag("c:forward", attributes)
3578 def _write_backward(self, val) -> None:
3579 # Write the <c:backward> element.
3581 if not val:
3582 return
3584 attributes = [("val", val)]
3586 self._xml_empty_tag("c:backward", attributes)
3588 def _write_c_intercept(self, val) -> None:
3589 # Write the <c:intercept> element.
3590 attributes = [("val", val)]
3592 self._xml_empty_tag("c:intercept", attributes)
3594 def _write_c_disp_eq(self) -> None:
3595 # Write the <c:dispEq> element.
3596 attributes = [("val", 1)]
3598 self._xml_empty_tag("c:dispEq", attributes)
3600 def _write_c_disp_rsqr(self) -> None:
3601 # Write the <c:dispRSqr> element.
3602 attributes = [("val", 1)]
3604 self._xml_empty_tag("c:dispRSqr", attributes)
3606 def _write_c_trendline_lbl(self, trendline) -> None:
3607 # Write the <c:trendlineLbl> element.
3608 self._xml_start_tag("c:trendlineLbl")
3610 # Write the c:layout element.
3611 self._write_layout(None, None)
3613 # Write the c:numFmt element.
3614 self._write_trendline_num_fmt()
3616 # Write the c:spPr element.
3617 self._write_sp_pr(trendline["label"])
3619 # Write the data label font elements.
3620 if trendline["label"]:
3621 font = trendline["label"].get("font")
3622 if font:
3623 self._write_axis_font(font)
3625 self._xml_end_tag("c:trendlineLbl")
3627 def _write_trendline_num_fmt(self) -> None:
3628 # Write the <c:numFmt> element.
3629 attributes = [
3630 ("formatCode", "General"),
3631 ("sourceLinked", 0),
3632 ]
3634 self._xml_empty_tag("c:numFmt", attributes)
3636 def _write_hi_low_lines(self) -> None:
3637 # Write the <c:hiLowLines> element.
3638 hi_low_lines = self.hi_low_lines
3640 if hi_low_lines is None:
3641 return
3643 if "line" in hi_low_lines and hi_low_lines["line"]["defined"]:
3644 self._xml_start_tag("c:hiLowLines")
3646 # Write the c:spPr element.
3647 self._write_sp_pr(hi_low_lines)
3649 self._xml_end_tag("c:hiLowLines")
3650 else:
3651 self._xml_empty_tag("c:hiLowLines")
3653 def _write_drop_lines(self) -> None:
3654 # Write the <c:dropLines> element.
3655 drop_lines = self.drop_lines
3657 if drop_lines is None:
3658 return
3660 if drop_lines["line"]["defined"]:
3661 self._xml_start_tag("c:dropLines")
3663 # Write the c:spPr element.
3664 self._write_sp_pr(drop_lines)
3666 self._xml_end_tag("c:dropLines")
3667 else:
3668 self._xml_empty_tag("c:dropLines")
3670 def _write_overlap(self, val) -> None:
3671 # Write the <c:overlap> element.
3673 if val is None:
3674 return
3676 attributes = [("val", val)]
3678 self._xml_empty_tag("c:overlap", attributes)
3680 def _write_num_cache(self, data) -> None:
3681 # Write the <c:numCache> element.
3682 if data:
3683 count = len(data)
3684 else:
3685 count = 0
3687 self._xml_start_tag("c:numCache")
3689 # Write the c:formatCode element.
3690 self._write_format_code("General")
3692 # Write the c:ptCount element.
3693 self._write_pt_count(count)
3695 for i in range(count):
3696 token = data[i]
3698 if token is None:
3699 continue
3701 try:
3702 float(token)
3703 except ValueError:
3704 # Write non-numeric data as 0.
3705 token = 0
3707 # Write the c:pt element.
3708 self._write_pt(i, token)
3710 self._xml_end_tag("c:numCache")
3712 def _write_str_cache(self, data) -> None:
3713 # Write the <c:strCache> element.
3714 count = len(data)
3716 self._xml_start_tag("c:strCache")
3718 # Write the c:ptCount element.
3719 self._write_pt_count(count)
3721 for i in range(count):
3722 # Write the c:pt element.
3723 self._write_pt(i, data[i])
3725 self._xml_end_tag("c:strCache")
3727 def _write_format_code(self, data) -> None:
3728 # Write the <c:formatCode> element.
3730 self._xml_data_element("c:formatCode", data)
3732 def _write_pt_count(self, val) -> None:
3733 # Write the <c:ptCount> element.
3735 attributes = [("val", val)]
3737 self._xml_empty_tag("c:ptCount", attributes)
3739 def _write_pt(self, idx, value) -> None:
3740 # Write the <c:pt> element.
3742 if value is None:
3743 return
3745 attributes = [("idx", idx)]
3747 self._xml_start_tag("c:pt", attributes)
3749 # Write the c:v element.
3750 self._write_v(value)
3752 self._xml_end_tag("c:pt")
3754 def _write_v(self, data) -> None:
3755 # Write the <c:v> element.
3757 self._xml_data_element("c:v", data)
3759 def _write_protection(self) -> None:
3760 # Write the <c:protection> element.
3761 if not self.protection:
3762 return
3764 self._xml_empty_tag("c:protection")
3766 def _write_d_pt(self, points) -> None:
3767 # Write the <c:dPt> elements.
3768 index = -1
3770 if not points:
3771 return
3773 for point in points:
3774 index += 1
3775 if not point:
3776 continue
3778 self._write_d_pt_point(index, point)
3780 def _write_d_pt_point(self, index, point) -> None:
3781 # Write an individual <c:dPt> element.
3783 self._xml_start_tag("c:dPt")
3785 # Write the c:idx element.
3786 self._write_idx(index)
3788 # Write the c:spPr element.
3789 self._write_sp_pr(point)
3791 self._xml_end_tag("c:dPt")
3793 def _write_d_lbls(self, labels) -> None:
3794 # Write the <c:dLbls> element.
3796 if not labels:
3797 return
3799 self._xml_start_tag("c:dLbls")
3801 # Write the custom c:dLbl elements.
3802 if labels.get("custom"):
3803 self._write_custom_labels(labels, labels["custom"])
3805 # Write the c:numFmt element.
3806 if labels.get("num_format"):
3807 self._write_data_label_number_format(labels["num_format"])
3809 # Write the c:spPr element for the plotarea formatting.
3810 self._write_sp_pr(labels)
3812 # Write the data label font elements.
3813 if labels.get("font"):
3814 self._write_axis_font(labels["font"])
3816 # Write the c:dLblPos element.
3817 if labels.get("position"):
3818 self._write_d_lbl_pos(labels["position"])
3820 # Write the c:showLegendKey element.
3821 if labels.get("legend_key"):
3822 self._write_show_legend_key()
3824 # Write the c:showVal element.
3825 if labels.get("value"):
3826 self._write_show_val()
3828 # Write the c:showCatName element.
3829 if labels.get("category"):
3830 self._write_show_cat_name()
3832 # Write the c:showSerName element.
3833 if labels.get("series_name"):
3834 self._write_show_ser_name()
3836 # Write the c:showPercent element.
3837 if labels.get("percentage"):
3838 self._write_show_percent()
3840 # Write the c:separator element.
3841 if labels.get("separator"):
3842 self._write_separator(labels["separator"])
3844 # Write the c:showLeaderLines element.
3845 if labels.get("leader_lines"):
3846 self._write_show_leader_lines()
3848 self._xml_end_tag("c:dLbls")
3850 def _write_custom_labels(self, parent, labels) -> None:
3851 # Write the <c:showLegendKey> element.
3852 index = 0
3854 for label in labels:
3855 index += 1
3857 if label is None:
3858 continue
3860 use_custom_formatting = True
3862 self._xml_start_tag("c:dLbl")
3864 # Write the c:idx element.
3865 self._write_idx(index - 1)
3867 delete_label = label.get("delete")
3869 if delete_label:
3870 self._write_delete(1)
3872 elif label.get("formula") or label.get("value") or label.get("position"):
3874 # Write the c:layout element.
3875 self._write_layout(None, None)
3877 if label.get("formula"):
3878 self._write_custom_label_formula(label)
3879 elif label.get("value"):
3880 self._write_custom_label_str(label)
3881 # String values use spPr formatting.
3882 use_custom_formatting = False
3884 if use_custom_formatting:
3885 self._write_custom_label_format(label)
3887 if label.get("position"):
3888 self._write_d_lbl_pos(label["position"])
3889 elif parent.get("position"):
3890 self._write_d_lbl_pos(parent["position"])
3892 if parent.get("value"):
3893 self._write_show_val()
3895 if parent.get("category"):
3896 self._write_show_cat_name()
3898 if parent.get("series_name"):
3899 self._write_show_ser_name()
3901 else:
3902 self._write_custom_label_format(label)
3904 self._xml_end_tag("c:dLbl")
3906 def _write_custom_label_str(self, label) -> None:
3907 # Write parts of the <c:dLbl> element for strings.
3908 title = label.get("value")
3909 font = label.get("font")
3910 has_formatting = self._has_fill_formatting(label)
3912 self._xml_start_tag("c:tx")
3914 # Write the c:rich element.
3915 self._write_rich(title, font, False, not has_formatting)
3917 self._xml_end_tag("c:tx")
3919 # Write the c:spPr element.
3920 self._write_sp_pr(label)
3922 def _write_custom_label_formula(self, label) -> None:
3923 # Write parts of the <c:dLbl> element for formulas.
3924 formula = label.get("formula")
3925 data_id = label.get("data_id")
3926 data = None
3928 if data_id is not None:
3929 data = self.formula_data[data_id]
3931 self._xml_start_tag("c:tx")
3933 # Write the c:strRef element.
3934 self._write_str_ref(formula, data, "str")
3936 self._xml_end_tag("c:tx")
3938 def _write_custom_label_format(self, label) -> None:
3939 # Write the formatting and font elements for the custom labels.
3940 font = label.get("font")
3941 has_formatting = self._has_fill_formatting(label)
3943 if has_formatting:
3944 self._write_sp_pr(label)
3945 self._write_tx_pr(font)
3946 elif font:
3947 self._xml_empty_tag("c:spPr")
3948 self._write_tx_pr(font)
3950 def _write_show_legend_key(self) -> None:
3951 # Write the <c:showLegendKey> element.
3952 val = "1"
3954 attributes = [("val", val)]
3956 self._xml_empty_tag("c:showLegendKey", attributes)
3958 def _write_show_val(self) -> None:
3959 # Write the <c:showVal> element.
3960 val = 1
3962 attributes = [("val", val)]
3964 self._xml_empty_tag("c:showVal", attributes)
3966 def _write_show_cat_name(self) -> None:
3967 # Write the <c:showCatName> element.
3968 val = 1
3970 attributes = [("val", val)]
3972 self._xml_empty_tag("c:showCatName", attributes)
3974 def _write_show_ser_name(self) -> None:
3975 # Write the <c:showSerName> element.
3976 val = 1
3978 attributes = [("val", val)]
3980 self._xml_empty_tag("c:showSerName", attributes)
3982 def _write_show_percent(self) -> None:
3983 # Write the <c:showPercent> element.
3984 val = 1
3986 attributes = [("val", val)]
3988 self._xml_empty_tag("c:showPercent", attributes)
3990 def _write_separator(self, data) -> None:
3991 # Write the <c:separator> element.
3992 self._xml_data_element("c:separator", data)
3994 def _write_show_leader_lines(self) -> None:
3995 # Write the <c:showLeaderLines> element.
3996 #
3997 # This is different for Pie/Doughnut charts. Other chart types only
3998 # supported leader lines after Excel 2015 via an extension element.
3999 #
4000 uri = "{CE6537A1-D6FC-4f65-9D91-7224C49458BB}"
4001 xmlns_c_15 = "http://schemas.microsoft.com/office/drawing/2012/chart"
4003 attributes = [
4004 ("uri", uri),
4005 ("xmlns:c15", xmlns_c_15),
4006 ]
4008 self._xml_start_tag("c:extLst")
4009 self._xml_start_tag("c:ext", attributes)
4010 self._xml_empty_tag("c15:showLeaderLines", [("val", 1)])
4011 self._xml_end_tag("c:ext")
4012 self._xml_end_tag("c:extLst")
4014 def _write_d_lbl_pos(self, val) -> None:
4015 # Write the <c:dLblPos> element.
4017 attributes = [("val", val)]
4019 self._xml_empty_tag("c:dLblPos", attributes)
4021 def _write_delete(self, val) -> None:
4022 # Write the <c:delete> element.
4024 attributes = [("val", val)]
4026 self._xml_empty_tag("c:delete", attributes)
4028 def _write_c_invert_if_negative(self, invert) -> None:
4029 # Write the <c:invertIfNegative> element.
4030 val = 1
4032 if not invert:
4033 return
4035 attributes = [("val", val)]
4037 self._xml_empty_tag("c:invertIfNegative", attributes)
4039 def _write_axis_font(self, font) -> None:
4040 # Write the axis font elements.
4042 if not font:
4043 return
4045 self._xml_start_tag("c:txPr")
4046 self._write_a_body_pr(font.get("rotation"), None)
4047 self._write_a_lst_style()
4048 self._xml_start_tag("a:p")
4050 self._write_a_p_pr_rich(font)
4052 self._write_a_end_para_rpr()
4053 self._xml_end_tag("a:p")
4054 self._xml_end_tag("c:txPr")
4056 def _write_a_latin(self, attributes) -> None:
4057 # Write the <a:latin> element.
4058 self._xml_empty_tag("a:latin", attributes)
4060 def _write_d_table(self) -> None:
4061 # Write the <c:dTable> element.
4062 table = self.table
4064 if not table:
4065 return
4067 self._xml_start_tag("c:dTable")
4069 if table["horizontal"]:
4070 # Write the c:showHorzBorder element.
4071 self._write_show_horz_border()
4073 if table["vertical"]:
4074 # Write the c:showVertBorder element.
4075 self._write_show_vert_border()
4077 if table["outline"]:
4078 # Write the c:showOutline element.
4079 self._write_show_outline()
4081 if table["show_keys"]:
4082 # Write the c:showKeys element.
4083 self._write_show_keys()
4085 if table["font"]:
4086 # Write the table font.
4087 self._write_tx_pr(table["font"])
4089 self._xml_end_tag("c:dTable")
4091 def _write_show_horz_border(self) -> None:
4092 # Write the <c:showHorzBorder> element.
4093 attributes = [("val", 1)]
4095 self._xml_empty_tag("c:showHorzBorder", attributes)
4097 def _write_show_vert_border(self) -> None:
4098 # Write the <c:showVertBorder> element.
4099 attributes = [("val", 1)]
4101 self._xml_empty_tag("c:showVertBorder", attributes)
4103 def _write_show_outline(self) -> None:
4104 # Write the <c:showOutline> element.
4105 attributes = [("val", 1)]
4107 self._xml_empty_tag("c:showOutline", attributes)
4109 def _write_show_keys(self) -> None:
4110 # Write the <c:showKeys> element.
4111 attributes = [("val", 1)]
4113 self._xml_empty_tag("c:showKeys", attributes)
4115 def _write_error_bars(self, error_bars) -> None:
4116 # Write the X and Y error bars.
4118 if not error_bars:
4119 return
4121 if error_bars["x_error_bars"]:
4122 self._write_err_bars("x", error_bars["x_error_bars"])
4124 if error_bars["y_error_bars"]:
4125 self._write_err_bars("y", error_bars["y_error_bars"])
4127 def _write_err_bars(self, direction, error_bars) -> None:
4128 # Write the <c:errBars> element.
4130 if not error_bars:
4131 return
4133 self._xml_start_tag("c:errBars")
4135 # Write the c:errDir element.
4136 self._write_err_dir(direction)
4138 # Write the c:errBarType element.
4139 self._write_err_bar_type(error_bars["direction"])
4141 # Write the c:errValType element.
4142 self._write_err_val_type(error_bars["type"])
4144 if not error_bars["endcap"]:
4145 # Write the c:noEndCap element.
4146 self._write_no_end_cap()
4148 if error_bars["type"] == "stdErr":
4149 # Don't need to write a c:errValType tag.
4150 pass
4151 elif error_bars["type"] == "cust":
4152 # Write the custom error tags.
4153 self._write_custom_error(error_bars)
4154 else:
4155 # Write the c:val element.
4156 self._write_error_val(error_bars["value"])
4158 # Write the c:spPr element.
4159 self._write_sp_pr(error_bars)
4161 self._xml_end_tag("c:errBars")
4163 def _write_err_dir(self, val) -> None:
4164 # Write the <c:errDir> element.
4166 attributes = [("val", val)]
4168 self._xml_empty_tag("c:errDir", attributes)
4170 def _write_err_bar_type(self, val) -> None:
4171 # Write the <c:errBarType> element.
4173 attributes = [("val", val)]
4175 self._xml_empty_tag("c:errBarType", attributes)
4177 def _write_err_val_type(self, val) -> None:
4178 # Write the <c:errValType> element.
4180 attributes = [("val", val)]
4182 self._xml_empty_tag("c:errValType", attributes)
4184 def _write_no_end_cap(self) -> None:
4185 # Write the <c:noEndCap> element.
4186 attributes = [("val", 1)]
4188 self._xml_empty_tag("c:noEndCap", attributes)
4190 def _write_error_val(self, val) -> None:
4191 # Write the <c:val> element for error bars.
4193 attributes = [("val", val)]
4195 self._xml_empty_tag("c:val", attributes)
4197 def _write_custom_error(self, error_bars) -> None:
4198 # Write the custom error bars tags.
4200 if error_bars["plus_values"]:
4201 # Write the c:plus element.
4202 self._xml_start_tag("c:plus")
4204 if isinstance(error_bars["plus_values"], list):
4205 self._write_num_lit(error_bars["plus_values"])
4206 else:
4207 self._write_num_ref(
4208 error_bars["plus_values"], error_bars["plus_data"], "num"
4209 )
4210 self._xml_end_tag("c:plus")
4212 if error_bars["minus_values"]:
4213 # Write the c:minus element.
4214 self._xml_start_tag("c:minus")
4216 if isinstance(error_bars["minus_values"], list):
4217 self._write_num_lit(error_bars["minus_values"])
4218 else:
4219 self._write_num_ref(
4220 error_bars["minus_values"], error_bars["minus_data"], "num"
4221 )
4222 self._xml_end_tag("c:minus")
4224 def _write_num_lit(self, data) -> None:
4225 # Write the <c:numLit> element for literal number list elements.
4226 count = len(data)
4228 # Write the c:numLit element.
4229 self._xml_start_tag("c:numLit")
4231 # Write the c:formatCode element.
4232 self._write_format_code("General")
4234 # Write the c:ptCount element.
4235 self._write_pt_count(count)
4237 for i in range(count):
4238 token = data[i]
4240 if token is None:
4241 continue
4243 try:
4244 float(token)
4245 except ValueError:
4246 # Write non-numeric data as 0.
4247 token = 0
4249 # Write the c:pt element.
4250 self._write_pt(i, token)
4252 self._xml_end_tag("c:numLit")
4254 def _write_up_down_bars(self) -> None:
4255 # Write the <c:upDownBars> element.
4256 up_down_bars = self.up_down_bars
4258 if up_down_bars is None:
4259 return
4261 self._xml_start_tag("c:upDownBars")
4263 # Write the c:gapWidth element.
4264 self._write_gap_width(150)
4266 # Write the c:upBars element.
4267 self._write_up_bars(up_down_bars.get("up"))
4269 # Write the c:downBars element.
4270 self._write_down_bars(up_down_bars.get("down"))
4272 self._xml_end_tag("c:upDownBars")
4274 def _write_gap_width(self, val) -> None:
4275 # Write the <c:gapWidth> element.
4277 if val is None:
4278 return
4280 attributes = [("val", val)]
4282 self._xml_empty_tag("c:gapWidth", attributes)
4284 def _write_up_bars(self, bar_format) -> None:
4285 # Write the <c:upBars> element.
4287 if bar_format["line"] and bar_format["line"]["defined"]:
4288 self._xml_start_tag("c:upBars")
4290 # Write the c:spPr element.
4291 self._write_sp_pr(bar_format)
4293 self._xml_end_tag("c:upBars")
4294 else:
4295 self._xml_empty_tag("c:upBars")
4297 def _write_down_bars(self, bar_format) -> None:
4298 # Write the <c:downBars> element.
4300 if bar_format["line"] and bar_format["line"]["defined"]:
4301 self._xml_start_tag("c:downBars")
4303 # Write the c:spPr element.
4304 self._write_sp_pr(bar_format)
4306 self._xml_end_tag("c:downBars")
4307 else:
4308 self._xml_empty_tag("c:downBars")
4310 def _write_disp_units(self, units, display) -> None:
4311 # Write the <c:dispUnits> element.
4313 if not units:
4314 return
4316 attributes = [("val", units)]
4318 self._xml_start_tag("c:dispUnits")
4319 self._xml_empty_tag("c:builtInUnit", attributes)
4321 if display:
4322 self._xml_start_tag("c:dispUnitsLbl")
4323 self._xml_empty_tag("c:layout")
4324 self._xml_end_tag("c:dispUnitsLbl")
4326 self._xml_end_tag("c:dispUnits")
4328 def _write_a_grad_fill(self, gradient) -> None:
4329 # Write the <a:gradFill> element.
4331 attributes = [("flip", "none"), ("rotWithShape", "1")]
4333 if gradient["type"] == "linear":
4334 attributes = []
4336 self._xml_start_tag("a:gradFill", attributes)
4338 # Write the a:gsLst element.
4339 self._write_a_gs_lst(gradient)
4341 if gradient["type"] == "linear":
4342 # Write the a:lin element.
4343 self._write_a_lin(gradient["angle"])
4344 else:
4345 # Write the a:path element.
4346 self._write_a_path(gradient["type"])
4348 # Write the a:tileRect element.
4349 self._write_a_tile_rect(gradient["type"])
4351 self._xml_end_tag("a:gradFill")
4353 def _write_a_gs_lst(self, gradient) -> None:
4354 # Write the <a:gsLst> element.
4355 positions = gradient["positions"]
4356 colors = gradient["colors"]
4358 self._xml_start_tag("a:gsLst")
4360 for i, color in enumerate(colors):
4361 pos = int(positions[i] * 1000)
4362 attributes = [("pos", pos)]
4363 self._xml_start_tag("a:gs", attributes)
4365 self._write_color(color)
4367 self._xml_end_tag("a:gs")
4369 self._xml_end_tag("a:gsLst")
4371 def _write_a_lin(self, angle) -> None:
4372 # Write the <a:lin> element.
4374 angle = int(60000 * angle)
4376 attributes = [
4377 ("ang", angle),
4378 ("scaled", "0"),
4379 ]
4381 self._xml_empty_tag("a:lin", attributes)
4383 def _write_a_path(self, gradient_type) -> None:
4384 # Write the <a:path> element.
4386 attributes = [("path", gradient_type)]
4388 self._xml_start_tag("a:path", attributes)
4390 # Write the a:fillToRect element.
4391 self._write_a_fill_to_rect(gradient_type)
4393 self._xml_end_tag("a:path")
4395 def _write_a_fill_to_rect(self, gradient_type) -> None:
4396 # Write the <a:fillToRect> element.
4398 if gradient_type == "shape":
4399 attributes = [
4400 ("l", "50000"),
4401 ("t", "50000"),
4402 ("r", "50000"),
4403 ("b", "50000"),
4404 ]
4405 else:
4406 attributes = [
4407 ("l", "100000"),
4408 ("t", "100000"),
4409 ]
4411 self._xml_empty_tag("a:fillToRect", attributes)
4413 def _write_a_tile_rect(self, gradient_type) -> None:
4414 # Write the <a:tileRect> element.
4416 if gradient_type == "shape":
4417 attributes = []
4418 else:
4419 attributes = [
4420 ("r", "-100000"),
4421 ("b", "-100000"),
4422 ]
4424 self._xml_empty_tag("a:tileRect", attributes)
4426 def _write_a_patt_fill(self, pattern) -> None:
4427 # Write the <a:pattFill> element.
4429 attributes = [("prst", pattern["pattern"])]
4431 self._xml_start_tag("a:pattFill", attributes)
4433 # Write the a:fgClr element.
4434 self._write_a_fg_clr(pattern["fg_color"])
4436 # Write the a:bgClr element.
4437 self._write_a_bg_clr(pattern["bg_color"])
4439 self._xml_end_tag("a:pattFill")
4441 def _write_a_fg_clr(self, color: Color) -> None:
4442 # Write the <a:fgClr> element.
4443 self._xml_start_tag("a:fgClr")
4444 self._write_color(color)
4445 self._xml_end_tag("a:fgClr")
4447 def _write_a_bg_clr(self, color: Color) -> None:
4448 # Write the <a:bgClr> element.
4449 self._xml_start_tag("a:bgClr")
4450 self._write_color(color)
4451 self._xml_end_tag("a:bgClr")