AF2C
/
CCR
23
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
CCR/.venv/lib/python3.12/site-packages/xlsxwriter/chart.py

4383 lines
127 KiB
Python
Raw Blame History

###############################################################################
#
# Chart - A class for writing the Excel XLSX Worksheet file.
#
# SPDX-License-Identifier: BSD-2-Clause
#
# Copyright (c) 2013-2025, John McNamara, jmcnamara@cpan.org
#
import copy
import re
from warnings import warn
from . import xmlwriter
from .shape import Shape
from .utility import (
_datetime_to_excel_datetime,
_get_rgb_color,
_supported_datetime,
quote_sheetname,
xl_range_formula,
xl_rowcol_to_cell,
)
class Chart(xmlwriter.XMLwriter):
"""
A class for writing the Excel XLSX Chart file.
"""
###########################################################################
#
# Public API.
#
###########################################################################
def __init__(self):
"""
Constructor.
"""
super().__init__()
self.subtype = None
self.sheet_type = 0x0200
self.orientation = 0x0
self.series = []
self.embedded = 0
self.id = -1
self.series_index = 0
self.style_id = 2
self.axis_ids = []
self.axis2_ids = []
self.cat_has_num_fmt = 0
self.requires_category = False
self.legend = {}
self.cat_axis_position = "b"
self.val_axis_position = "l"
self.formula_ids = {}
self.formula_data = []
self.horiz_cat_axis = 0
self.horiz_val_axis = 1
self.protection = 0
self.chartarea = {}
self.plotarea = {}
self.x_axis = {}
self.y_axis = {}
self.y2_axis = {}
self.x2_axis = {}
self.chart_name = ""
self.show_blanks = "gap"
self.show_na_as_empty = False
self.show_hidden = False
self.show_crosses = True
self.width = 480
self.height = 288
self.x_scale = 1
self.y_scale = 1
self.x_offset = 0
self.y_offset = 0
self.table = None
self.cross_between = "between"
self.default_marker = None
self.series_gap_1 = None
self.series_gap_2 = None
self.series_overlap_1 = None
self.series_overlap_2 = None
self.drop_lines = None
self.hi_low_lines = None
self.up_down_bars = None
self.smooth_allowed = False
self.title_font = None
self.title_name = None
self.title_formula = None
self.title_data_id = None
self.title_layout = None
self.title_overlay = None
self.title_none = False
self.date_category = False
self.date_1904 = False
self.remove_timezone = False
self.label_positions = {}
self.label_position_default = ""
self.already_inserted = False
self.combined = None
self.is_secondary = False
self.warn_sheetname = True
self._set_default_properties()
self.fill = {}
def add_series(self, options=None):
"""
Add a data series to a chart.
Args:
options: A dictionary of chart series options.
Returns:
Nothing.
"""
# Add a series and it's properties to a chart.
if options is None:
options = {}
# Check that the required input has been specified.
if "values" not in options:
warn("Must specify 'values' in add_series()")
return
if self.requires_category and "categories" not in options:
warn("Must specify 'categories' in add_series() for this chart type")
return
if len(self.series) == 255:
warn(
"The maximum number of series that can be added to an "
"Excel Chart is 255"
)
return
# Convert list into a formula string.
values = self._list_to_formula(options.get("values"))
categories = self._list_to_formula(options.get("categories"))
# Switch name and name_formula parameters if required.
name, name_formula = self._process_names(
options.get("name"), options.get("name_formula")
)
# Get an id for the data equivalent to the range formula.
cat_id = self._get_data_id(categories, options.get("categories_data"))
val_id = self._get_data_id(values, options.get("values_data"))
name_id = self._get_data_id(name_formula, options.get("name_data"))
# Set the line properties for the series.
line = Shape._get_line_properties(options.get("line"))
# Allow 'border' as a synonym for 'line' in bar/column style charts.
if options.get("border"):
line = Shape._get_line_properties(options["border"])
# Set the fill properties for the series.
fill = Shape._get_fill_properties(options.get("fill"))
# Set the pattern fill properties for the series.
pattern = Shape._get_pattern_properties(options.get("pattern"))
# Set the gradient fill properties for the series.
gradient = Shape._get_gradient_properties(options.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
# Set the marker properties for the series.
marker = self._get_marker_properties(options.get("marker"))
# Set the trendline properties for the series.
trendline = self._get_trendline_properties(options.get("trendline"))
# Set the line smooth property for the series.
smooth = options.get("smooth")
# Set the error bars properties for the series.
y_error_bars = self._get_error_bars_props(options.get("y_error_bars"))
x_error_bars = self._get_error_bars_props(options.get("x_error_bars"))
error_bars = {"x_error_bars": x_error_bars, "y_error_bars": y_error_bars}
# Set the point properties for the series.
points = self._get_points_properties(options.get("points"))
# Set the labels properties for the series.
labels = self._get_labels_properties(options.get("data_labels"))
# Set the "invert if negative" fill property.
invert_if_neg = options.get("invert_if_negative", False)
inverted_color = options.get("invert_if_negative_color", False)
# Set the secondary axis properties.
x2_axis = options.get("x2_axis")
y2_axis = options.get("y2_axis")
# Store secondary status for combined charts.
if x2_axis or y2_axis:
self.is_secondary = True
# Set the gap for Bar/Column charts.
if options.get("gap") is not None:
if y2_axis:
self.series_gap_2 = options["gap"]
else:
self.series_gap_1 = options["gap"]
# Set the overlap for Bar/Column charts.
if options.get("overlap"):
if y2_axis:
self.series_overlap_2 = options["overlap"]
else:
self.series_overlap_1 = options["overlap"]
# Add the user supplied data to the internal structures.
series = {
"values": values,
"categories": categories,
"name": name,
"name_formula": name_formula,
"name_id": name_id,
"val_data_id": val_id,
"cat_data_id": cat_id,
"line": line,
"fill": fill,
"pattern": pattern,
"gradient": gradient,
"marker": marker,
"trendline": trendline,
"labels": labels,
"invert_if_neg": invert_if_neg,
"inverted_color": inverted_color,
"x2_axis": x2_axis,
"y2_axis": y2_axis,
"points": points,
"error_bars": error_bars,
"smooth": smooth,
}
self.series.append(series)
def set_x_axis(self, options):
"""
Set the chart X axis options.
Args:
options: A dictionary of axis options.
Returns:
Nothing.
"""
axis = self._convert_axis_args(self.x_axis, options)
self.x_axis = axis
def set_y_axis(self, options):
"""
Set the chart Y axis options.
Args:
options: A dictionary of axis options.
Returns:
Nothing.
"""
axis = self._convert_axis_args(self.y_axis, options)
self.y_axis = axis
def set_x2_axis(self, options):
"""
Set the chart secondary X axis options.
Args:
options: A dictionary of axis options.
Returns:
Nothing.
"""
axis = self._convert_axis_args(self.x2_axis, options)
self.x2_axis = axis
def set_y2_axis(self, options):
"""
Set the chart secondary Y axis options.
Args:
options: A dictionary of axis options.
Returns:
Nothing.
"""
axis = self._convert_axis_args(self.y2_axis, options)
self.y2_axis = axis
def set_title(self, options=None):
"""
Set the chart title options.
Args:
options: A dictionary of chart title options.
Returns:
Nothing.
"""
if options is None:
options = {}
name, name_formula = self._process_names(
options.get("name"), options.get("name_formula")
)
data_id = self._get_data_id(name_formula, options.get("data"))
self.title_name = name
self.title_formula = name_formula
self.title_data_id = data_id
# Set the font properties if present.
self.title_font = self._convert_font_args(options.get("name_font"))
# Set the axis name layout.
self.title_layout = self._get_layout_properties(options.get("layout"), True)
# Set the title overlay option.
self.title_overlay = options.get("overlay")
# Set the automatic title option.
self.title_none = options.get("none")
def set_legend(self, options):
"""
Set the chart legend options.
Args:
options: A dictionary of chart legend options.
Returns:
Nothing.
"""
# Convert the user defined properties to internal properties.
self.legend = self._get_legend_properties(options)
def set_plotarea(self, options):
"""
Set the chart plot area options.
Args:
options: A dictionary of chart plot area options.
Returns:
Nothing.
"""
# Convert the user defined properties to internal properties.
self.plotarea = self._get_area_properties(options)
def set_chartarea(self, options):
"""
Set the chart area options.
Args:
options: A dictionary of chart area options.
Returns:
Nothing.
"""
# Convert the user defined properties to internal properties.
self.chartarea = self._get_area_properties(options)
def set_style(self, style_id):
"""
Set the chart style type.
Args:
style_id: An int representing the chart style.
Returns:
Nothing.
"""
# Set one of the 48 built-in Excel chart styles. The default is 2.
if style_id is None:
style_id = 2
if style_id < 1 or style_id > 48:
style_id = 2
self.style_id = style_id
def show_blanks_as(self, option):
"""
Set the option for displaying blank data in a chart.
Args:
option: A string representing the display option.
Returns:
Nothing.
"""
if not option:
return
valid_options = {
"gap": 1,
"zero": 1,
"span": 1,
}
if option not in valid_options:
warn(f"Unknown show_blanks_as() option '{option}'")
return
self.show_blanks = option
def show_na_as_empty_cell(self):
"""
Display ``#N/A`` on charts as blank/empty cells.
Args:
None.
Returns:
Nothing.
"""
self.show_na_as_empty = True
def show_hidden_data(self):
"""
Display data on charts from hidden rows or columns.
Args:
None.
Returns:
Nothing.
"""
self.show_hidden = True
def set_size(self, options=None):
"""
Set size or scale of the chart.
Args:
options: A dictionary of chart size options.
Returns:
Nothing.
"""
if options is None:
options = {}
# Set dimensions or scale for the chart.
self.width = options.get("width", self.width)
self.height = options.get("height", self.height)
self.x_scale = options.get("x_scale", 1)
self.y_scale = options.get("y_scale", 1)
self.x_offset = options.get("x_offset", 0)
self.y_offset = options.get("y_offset", 0)
def set_table(self, options=None):
"""
Set properties for an axis data table.
Args:
options: A dictionary of axis table options.
Returns:
Nothing.
"""
if options is None:
options = {}
table = {}
table["horizontal"] = options.get("horizontal", 1)
table["vertical"] = options.get("vertical", 1)
table["outline"] = options.get("outline", 1)
table["show_keys"] = options.get("show_keys", 0)
table["font"] = self._convert_font_args(options.get("font"))
self.table = table
def set_up_down_bars(self, options=None):
"""
Set properties for the chart up-down bars.
Args:
options: A dictionary of options.
Returns:
Nothing.
"""
if options is None:
options = {}
# Defaults.
up_line = None
up_fill = None
down_line = None
down_fill = None
# Set properties for 'up' bar.
if options.get("up"):
if "border" in options["up"]:
# Map border to line.
up_line = Shape._get_line_properties(options["up"]["border"])
if "line" in options["up"]:
up_line = Shape._get_line_properties(options["up"]["line"])
if "fill" in options["up"]:
up_fill = Shape._get_fill_properties(options["up"]["fill"])
# Set properties for 'down' bar.
if options.get("down"):
if "border" in options["down"]:
# Map border to line.
down_line = Shape._get_line_properties(options["down"]["border"])
if "line" in options["down"]:
down_line = Shape._get_line_properties(options["down"]["line"])
if "fill" in options["down"]:
down_fill = Shape._get_fill_properties(options["down"]["fill"])
self.up_down_bars = {
"up": {
"line": up_line,
"fill": up_fill,
},
"down": {
"line": down_line,
"fill": down_fill,
},
}
def set_drop_lines(self, options=None):
"""
Set properties for the chart drop lines.
Args:
options: A dictionary of options.
Returns:
Nothing.
"""
if options is None:
options = {}
line = Shape._get_line_properties(options.get("line"))
fill = Shape._get_fill_properties(options.get("fill"))
# Set the pattern fill properties for the series.
pattern = Shape._get_pattern_properties(options.get("pattern"))
# Set the gradient fill properties for the series.
gradient = Shape._get_gradient_properties(options.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
self.drop_lines = {
"line": line,
"fill": fill,
"pattern": pattern,
"gradient": gradient,
}
def set_high_low_lines(self, options=None):
"""
Set properties for the chart high-low lines.
Args:
options: A dictionary of options.
Returns:
Nothing.
"""
if options is None:
options = {}
line = Shape._get_line_properties(options.get("line"))
fill = Shape._get_fill_properties(options.get("fill"))
# Set the pattern fill properties for the series.
pattern = Shape._get_pattern_properties(options.get("pattern"))
# Set the gradient fill properties for the series.
gradient = Shape._get_gradient_properties(options.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
self.hi_low_lines = {
"line": line,
"fill": fill,
"pattern": pattern,
"gradient": gradient,
}
def combine(self, chart=None):
"""
Create a combination chart with a secondary chart.
Args:
chart: The secondary chart to combine with the primary chart.
Returns:
Nothing.
"""
if chart is None:
return
self.combined = chart
###########################################################################
#
# Private API.
#
###########################################################################
def _assemble_xml_file(self):
# Assemble and write the XML file.
# Write the XML declaration.
self._xml_declaration()
# Write the c:chartSpace element.
self._write_chart_space()
# Write the c:lang element.
self._write_lang()
# Write the c:style element.
self._write_style()
# Write the c:protection element.
self._write_protection()
# Write the c:chart element.
self._write_chart()
# Write the c:spPr element for the chartarea formatting.
self._write_sp_pr(self.chartarea)
# Write the c:printSettings element.
if self.embedded:
self._write_print_settings()
# Close the worksheet tag.
self._xml_end_tag("c:chartSpace")
# Close the file.
self._xml_close()
def _convert_axis_args(self, axis, user_options):
# Convert user defined axis values into private hash values.
options = axis["defaults"].copy()
options.update(user_options)
name, name_formula = self._process_names(
options.get("name"), options.get("name_formula")
)
data_id = self._get_data_id(name_formula, options.get("data"))
axis = {
"defaults": axis["defaults"],
"name": name,
"formula": name_formula,
"data_id": data_id,
"reverse": options.get("reverse"),
"min": options.get("min"),
"max": options.get("max"),
"minor_unit": options.get("minor_unit"),
"major_unit": options.get("major_unit"),
"minor_unit_type": options.get("minor_unit_type"),
"major_unit_type": options.get("major_unit_type"),
"display_units": options.get("display_units"),
"log_base": options.get("log_base"),
"crossing": options.get("crossing"),
"position_axis": options.get("position_axis"),
"position": options.get("position"),
"label_position": options.get("label_position"),
"label_align": options.get("label_align"),
"num_format": options.get("num_format"),
"num_format_linked": options.get("num_format_linked"),
"interval_unit": options.get("interval_unit"),
"interval_tick": options.get("interval_tick"),
"text_axis": False,
}
axis["visible"] = options.get("visible", True)
# Convert the display units.
axis["display_units"] = self._get_display_units(axis["display_units"])
axis["display_units_visible"] = options.get("display_units_visible", True)
# Map major_gridlines properties.
if options.get("major_gridlines") and options["major_gridlines"]["visible"]:
axis["major_gridlines"] = self._get_gridline_properties(
options["major_gridlines"]
)
# Map minor_gridlines properties.
if options.get("minor_gridlines") and options["minor_gridlines"]["visible"]:
axis["minor_gridlines"] = self._get_gridline_properties(
options["minor_gridlines"]
)
# Only use the first letter of bottom, top, left or right.
if axis.get("position"):
axis["position"] = axis["position"].lower()[0]
# Set the position for a category axis on or between the tick marks.
if axis.get("position_axis"):
if axis["position_axis"] == "on_tick":
axis["position_axis"] = "midCat"
elif axis["position_axis"] == "between":
# Doesn't need to be modified.
pass
else:
# Otherwise use the default value.
axis["position_axis"] = None
# Set the category axis as a date axis.
if options.get("date_axis"):
self.date_category = True
# Set the category axis as a text axis.
if options.get("text_axis"):
self.date_category = False
axis["text_axis"] = True
# Convert datetime args if required.
if axis.get("min") and _supported_datetime(axis["min"]):
axis["min"] = _datetime_to_excel_datetime(
axis["min"], self.date_1904, self.remove_timezone
)
if axis.get("max") and _supported_datetime(axis["max"]):
axis["max"] = _datetime_to_excel_datetime(
axis["max"], self.date_1904, self.remove_timezone
)
if axis.get("crossing") and _supported_datetime(axis["crossing"]):
axis["crossing"] = _datetime_to_excel_datetime(
axis["crossing"], self.date_1904, self.remove_timezone
)
# Set the font properties if present.
axis["num_font"] = self._convert_font_args(options.get("num_font"))
axis["name_font"] = self._convert_font_args(options.get("name_font"))
# Set the axis name layout.
axis["name_layout"] = self._get_layout_properties(
options.get("name_layout"), True
)
# Set the line properties for the axis.
axis["line"] = Shape._get_line_properties(options.get("line"))
# Set the fill properties for the axis.
axis["fill"] = Shape._get_fill_properties(options.get("fill"))
# Set the pattern fill properties for the series.
axis["pattern"] = Shape._get_pattern_properties(options.get("pattern"))
# Set the gradient fill properties for the series.
axis["gradient"] = Shape._get_gradient_properties(options.get("gradient"))
# Pattern fill overrides solid fill.
if axis.get("pattern"):
axis["fill"] = None
# Gradient fill overrides the solid and pattern fill.
if axis.get("gradient"):
axis["pattern"] = None
axis["fill"] = None
# Set the tick marker types.
axis["minor_tick_mark"] = self._get_tick_type(options.get("minor_tick_mark"))
axis["major_tick_mark"] = self._get_tick_type(options.get("major_tick_mark"))
return axis
def _convert_font_args(self, options):
# Convert user defined font values into private dict values.
if not options:
return {}
font = {
"name": options.get("name"),
"color": options.get("color"),
"size": options.get("size"),
"bold": options.get("bold"),
"italic": options.get("italic"),
"underline": options.get("underline"),
"pitch_family": options.get("pitch_family"),
"charset": options.get("charset"),
"baseline": options.get("baseline", 0),
"rotation": options.get("rotation"),
}
# Convert font size units.
if font["size"]:
font["size"] = int(font["size"] * 100)
# Convert rotation into 60,000ths of a degree.
if font["rotation"]:
font["rotation"] = 60000 * int(font["rotation"])
return font
def _list_to_formula(self, data):
# Convert and list of row col values to a range formula.
# If it isn't an array ref it is probably a formula already.
if not isinstance(data, list):
# Check for unquoted sheetnames.
if data and " " in data and "'" not in data and self.warn_sheetname:
warn(
f"Sheetname in '{data}' contains spaces but isn't quoted. "
f"This may cause an error in Excel."
)
return data
formula = xl_range_formula(*data)
return formula
def _process_names(self, name, name_formula):
# Switch name and name_formula parameters if required.
if name is not None:
if isinstance(name, list):
# Convert a list of values into a name formula.
cell = xl_rowcol_to_cell(name[1], name[2], True, True)
name_formula = quote_sheetname(name[0]) + "!" + cell
name = ""
elif re.match(r"^=?[^!]+!\$?[A-Z]+\$?\d+", name):
# Name looks like a formula, use it to set name_formula.
name_formula = name
name = ""
return name, name_formula
def _get_data_type(self, data):
# Find the overall type of the data associated with a series.
# Check for no data in the series.
if data is None or len(data) == 0:
return "none"
if isinstance(data[0], list):
return "multi_str"
# Determine if data is numeric or strings.
for token in data:
if token is None:
continue
# Check for strings that would evaluate to float like
# '1.1_1' of ' 1'.
if isinstance(token, str) and re.search("[_ ]", token):
# Assume entire data series is string data.
return "str"
try:
float(token)
except ValueError:
# Not a number. Assume entire data series is string data.
return "str"
# The series data was all numeric.
return "num"
def _get_data_id(self, formula, data):
# Assign an id to a each unique series formula or title/axis formula.
# Repeated formulas such as for categories get the same id. If the
# series or title has user specified data associated with it then
# that is also stored. This data is used to populate cached Excel
# data when creating a chart. If there is no user defined data then
# it will be populated by the parent Workbook._add_chart_data().
# Ignore series without a range formula.
if not formula:
return None
# Strip the leading '=' from the formula.
if formula.startswith("="):
formula = formula.lstrip("=")
# Store the data id in a hash keyed by the formula and store the data
# in a separate array with the same id.
if formula not in self.formula_ids:
# Haven't seen this formula before.
formula_id = len(self.formula_data)
self.formula_data.append(data)
self.formula_ids[formula] = formula_id
else:
# Formula already seen. Return existing id.
formula_id = self.formula_ids[formula]
# Store user defined data if it isn't already there.
if self.formula_data[formula_id] is None:
self.formula_data[formula_id] = data
return formula_id
def _get_marker_properties(self, marker):
# Convert user marker properties to the structure required internally.
if not marker:
return None
# Copy the user defined properties since they will be modified.
marker = copy.deepcopy(marker)
types = {
"automatic": "automatic",
"none": "none",
"square": "square",
"diamond": "diamond",
"triangle": "triangle",
"x": "x",
"star": "star",
"dot": "dot",
"short_dash": "dot",
"dash": "dash",
"long_dash": "dash",
"circle": "circle",
"plus": "plus",
"picture": "picture",
}
# Check for valid types.
marker_type = marker.get("type")
if marker_type is not None:
if marker_type in types:
marker["type"] = types[marker_type]
else:
warn(f"Unknown marker type '{marker_type}")
return None
# Set the line properties for the marker.
line = Shape._get_line_properties(marker.get("line"))
# Allow 'border' as a synonym for 'line'.
if "border" in marker:
line = Shape._get_line_properties(marker["border"])
# Set the fill properties for the marker.
fill = Shape._get_fill_properties(marker.get("fill"))
# Set the pattern fill properties for the series.
pattern = Shape._get_pattern_properties(marker.get("pattern"))
# Set the gradient fill properties for the series.
gradient = Shape._get_gradient_properties(marker.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
marker["line"] = line
marker["fill"] = fill
marker["pattern"] = pattern
marker["gradient"] = gradient
return marker
def _get_trendline_properties(self, trendline):
# Convert user trendline properties to structure required internally.
if not trendline:
return None
# Copy the user defined properties since they will be modified.
trendline = copy.deepcopy(trendline)
types = {
"exponential": "exp",
"linear": "linear",
"log": "log",
"moving_average": "movingAvg",
"polynomial": "poly",
"power": "power",
}
# Check the trendline type.
trend_type = trendline.get("type")
if trend_type in types:
trendline["type"] = types[trend_type]
else:
warn(f"Unknown trendline type '{trend_type}'")
return None
# Set the line properties for the trendline.
line = Shape._get_line_properties(trendline.get("line"))
# Allow 'border' as a synonym for 'line'.
if "border" in trendline:
line = Shape._get_line_properties(trendline["border"])
# Set the fill properties for the trendline.
fill = Shape._get_fill_properties(trendline.get("fill"))
# Set the pattern fill properties for the trendline.
pattern = Shape._get_pattern_properties(trendline.get("pattern"))
# Set the gradient fill properties for the trendline.
gradient = Shape._get_gradient_properties(trendline.get("gradient"))
# Set the format properties for the trendline label.
label = self._get_trendline_label_properties(trendline.get("label"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
trendline["line"] = line
trendline["fill"] = fill
trendline["pattern"] = pattern
trendline["gradient"] = gradient
trendline["label"] = label
return trendline
def _get_trendline_label_properties(self, label):
# Convert user trendline properties to structure required internally.
if not label:
return {}
# Copy the user defined properties since they will be modified.
label = copy.deepcopy(label)
# Set the font properties if present.
font = self._convert_font_args(label.get("font"))
# Set the line properties for the label.
line = Shape._get_line_properties(label.get("line"))
# Allow 'border' as a synonym for 'line'.
if "border" in label:
line = Shape._get_line_properties(label["border"])
# Set the fill properties for the label.
fill = Shape._get_fill_properties(label.get("fill"))
# Set the pattern fill properties for the label.
pattern = Shape._get_pattern_properties(label.get("pattern"))
# Set the gradient fill properties for the label.
gradient = Shape._get_gradient_properties(label.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
label["font"] = font
label["line"] = line
label["fill"] = fill
label["pattern"] = pattern
label["gradient"] = gradient
return label
def _get_error_bars_props(self, options):
# Convert user error bars properties to structure required internally.
if not options:
return {}
# Default values.
error_bars = {"type": "fixedVal", "value": 1, "endcap": 1, "direction": "both"}
types = {
"fixed": "fixedVal",
"percentage": "percentage",
"standard_deviation": "stdDev",
"standard_error": "stdErr",
"custom": "cust",
}
# Check the error bars type.
error_type = options["type"]
if error_type in types:
error_bars["type"] = types[error_type]
else:
warn(f"Unknown error bars type '{error_type}")
return {}
# Set the value for error types that require it.
if "value" in options:
error_bars["value"] = options["value"]
# Set the end-cap style.
if "end_style" in options:
error_bars["endcap"] = options["end_style"]
# Set the error bar direction.
if "direction" in options:
if options["direction"] == "minus":
error_bars["direction"] = "minus"
elif options["direction"] == "plus":
error_bars["direction"] = "plus"
else:
# Default to 'both'.
pass
# Set any custom values.
error_bars["plus_values"] = options.get("plus_values")
error_bars["minus_values"] = options.get("minus_values")
error_bars["plus_data"] = options.get("plus_data")
error_bars["minus_data"] = options.get("minus_data")
# Set the line properties for the error bars.
error_bars["line"] = Shape._get_line_properties(options.get("line"))
return error_bars
def _get_gridline_properties(self, options):
# Convert user gridline properties to structure required internally.
# Set the visible property for the gridline.
gridline = {"visible": options.get("visible")}
# Set the line properties for the gridline.
gridline["line"] = Shape._get_line_properties(options.get("line"))
return gridline
def _get_labels_properties(self, labels):
# Convert user labels properties to the structure required internally.
if not labels:
return None
# Copy the user defined properties since they will be modified.
labels = copy.deepcopy(labels)
# Map user defined label positions to Excel positions.
position = labels.get("position")
if position:
if position in self.label_positions:
if position == self.label_position_default:
labels["position"] = None
else:
labels["position"] = self.label_positions[position]
else:
warn(f"Unsupported label position '{position}' for this chart type")
return None
# Map the user defined label separator to the Excel separator.
separator = labels.get("separator")
separators = {
",": ", ",
";": "; ",
".": ". ",
"\n": "\n",
" ": " ",
}
if separator:
if separator in separators:
labels["separator"] = separators[separator]
else:
warn("Unsupported label separator")
return None
# Set the font properties if present.
labels["font"] = self._convert_font_args(labels.get("font"))
# Set the line properties for the labels.
line = Shape._get_line_properties(labels.get("line"))
# Allow 'border' as a synonym for 'line'.
if "border" in labels:
line = Shape._get_line_properties(labels["border"])
# Set the fill properties for the labels.
fill = Shape._get_fill_properties(labels.get("fill"))
# Set the pattern fill properties for the labels.
pattern = Shape._get_pattern_properties(labels.get("pattern"))
# Set the gradient fill properties for the labels.
gradient = Shape._get_gradient_properties(labels.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
labels["line"] = line
labels["fill"] = fill
labels["pattern"] = pattern
labels["gradient"] = gradient
if labels.get("custom"):
for label in labels["custom"]:
if label is None:
continue
value = label.get("value")
if value and re.match(r"^=?[^!]+!\$?[A-Z]+\$?\d+", str(value)):
label["formula"] = value
formula = label.get("formula")
if formula and formula.startswith("="):
label["formula"] = formula.lstrip("=")
data_id = self._get_data_id(formula, label.get("data"))
label["data_id"] = data_id
label["font"] = self._convert_font_args(label.get("font"))
# Set the line properties for the label.
line = Shape._get_line_properties(label.get("line"))
# Allow 'border' as a synonym for 'line'.
if "border" in label:
line = Shape._get_line_properties(label["border"])
# Set the fill properties for the label.
fill = Shape._get_fill_properties(label.get("fill"))
# Set the pattern fill properties for the label.
pattern = Shape._get_pattern_properties(label.get("pattern"))
# Set the gradient fill properties for the label.
gradient = Shape._get_gradient_properties(label.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
label["line"] = line
label["fill"] = fill
label["pattern"] = pattern
label["gradient"] = gradient
return labels
def _get_area_properties(self, options):
# Convert user area properties to the structure required internally.
area = {}
# Set the line properties for the chartarea.
line = Shape._get_line_properties(options.get("line"))
# Allow 'border' as a synonym for 'line'.
if options.get("border"):
line = Shape._get_line_properties(options["border"])
# Set the fill properties for the chartarea.
fill = Shape._get_fill_properties(options.get("fill"))
# Set the pattern fill properties for the series.
pattern = Shape._get_pattern_properties(options.get("pattern"))
# Set the gradient fill properties for the series.
gradient = Shape._get_gradient_properties(options.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
# Set the plotarea layout.
layout = self._get_layout_properties(options.get("layout"), False)
area["line"] = line
area["fill"] = fill
area["pattern"] = pattern
area["layout"] = layout
area["gradient"] = gradient
return area
def _get_legend_properties(self, options=None):
# Convert user legend properties to the structure required internally.
legend = {}
if options is None:
options = {}
legend["position"] = options.get("position", "right")
legend["delete_series"] = options.get("delete_series")
legend["font"] = self._convert_font_args(options.get("font"))
legend["layout"] = self._get_layout_properties(options.get("layout"), False)
# Turn off the legend.
if options.get("none"):
legend["position"] = "none"
# Set the line properties for the legend.
line = Shape._get_line_properties(options.get("line"))
# Allow 'border' as a synonym for 'line'.
if options.get("border"):
line = Shape._get_line_properties(options["border"])
# Set the fill properties for the legend.
fill = Shape._get_fill_properties(options.get("fill"))
# Set the pattern fill properties for the series.
pattern = Shape._get_pattern_properties(options.get("pattern"))
# Set the gradient fill properties for the series.
gradient = Shape._get_gradient_properties(options.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
# Set the legend layout.
layout = self._get_layout_properties(options.get("layout"), False)
legend["line"] = line
legend["fill"] = fill
legend["pattern"] = pattern
legend["layout"] = layout
legend["gradient"] = gradient
return legend
def _get_layout_properties(self, args, is_text):
# Convert user defined layout properties to format used internally.
layout = {}
if not args:
return {}
if is_text:
properties = ("x", "y")
else:
properties = ("x", "y", "width", "height")
# Check for valid properties.
for key in args.keys():
if key not in properties:
warn(f"Property '{key}' not supported in layout options")
return {}
# Set the layout properties.
for prop in properties:
if prop not in args.keys():
warn(f"Property '{prop}' must be specified in layout options")
return {}
value = args[prop]
try:
float(value)
except ValueError:
warn(f"Property '{prop}' value '{value}' must be numeric in layout")
return {}
if value < 0 or value > 1:
warn(
f"Property '{prop}' value '{value}' must be in range "
f"0 < x <= 1 in layout options"
)
return {}
# Convert to the format used by Excel for easier testing
layout[prop] = f"{value:.17g}"
return layout
def _get_points_properties(self, user_points):
# Convert user points properties to structure required internally.
points = []
if not user_points:
return []
for user_point in user_points:
point = {}
if user_point is not None:
# Set the line properties for the point.
line = Shape._get_line_properties(user_point.get("line"))
# Allow 'border' as a synonym for 'line'.
if "border" in user_point:
line = Shape._get_line_properties(user_point["border"])
# Set the fill properties for the chartarea.
fill = Shape._get_fill_properties(user_point.get("fill"))
# Set the pattern fill properties for the series.
pattern = Shape._get_pattern_properties(user_point.get("pattern"))
# Set the gradient fill properties for the series.
gradient = Shape._get_gradient_properties(user_point.get("gradient"))
# Pattern fill overrides solid fill.
if pattern:
self.fill = None
# Gradient fill overrides the solid and pattern fill.
if gradient:
pattern = None
fill = None
point["line"] = line
point["fill"] = fill
point["pattern"] = pattern
point["gradient"] = gradient
points.append(point)
return points
def _has_fill_formatting(self, element):
# Check if a chart element has line, fill or gradient formatting.
has_fill = False
has_line = False
has_pattern = element.get("pattern")
has_gradient = element.get("gradient")
if element.get("fill") and element["fill"]["defined"]:
has_fill = True
if element.get("line") and element["line"]["defined"]:
has_line = True
return has_fill or has_line or has_pattern or has_gradient
def _get_display_units(self, display_units):
# Convert user defined display units to internal units.
if not display_units:
return None
types = {
"hundreds": "hundreds",
"thousands": "thousands",
"ten_thousands": "tenThousands",
"hundred_thousands": "hundredThousands",
"millions": "millions",
"ten_millions": "tenMillions",
"hundred_millions": "hundredMillions",
"billions": "billions",
"trillions": "trillions",
}
if display_units in types:
display_units = types[display_units]
else:
warn(f"Unknown display_units type '{display_units}'")
return None
return display_units
def _get_tick_type(self, tick_type):
# Convert user defined display units to internal units.
if not tick_type:
return None
types = {
"outside": "out",
"inside": "in",
"none": "none",
"cross": "cross",
}
if tick_type in types:
tick_type = types[tick_type]
else:
warn(f"Unknown tick_type '{tick_type}'")
return None
return tick_type
def _get_primary_axes_series(self):
# Returns series which use the primary axes.
primary_axes_series = []
for series in self.series:
if not series["y2_axis"]:
primary_axes_series.append(series)
return primary_axes_series
def _get_secondary_axes_series(self):
# Returns series which use the secondary axes.
secondary_axes_series = []
for series in self.series:
if series["y2_axis"]:
secondary_axes_series.append(series)
return secondary_axes_series
def _add_axis_ids(self, args):
# Add unique ids for primary or secondary axes
chart_id = 5001 + int(self.id)
axis_count = 1 + len(self.axis2_ids) + len(self.axis_ids)
id1 = f"{chart_id:04d}{axis_count:04d}"
id2 = f"{chart_id:04d}{axis_count + 1:04d}"
if args["primary_axes"]:
self.axis_ids.append(id1)
self.axis_ids.append(id2)
if not args["primary_axes"]:
self.axis2_ids.append(id1)
self.axis2_ids.append(id2)
def _set_default_properties(self):
# Setup the default properties for a chart.
self.x_axis["defaults"] = {
"num_format": "General",
"major_gridlines": {"visible": 0},
}
self.y_axis["defaults"] = {
"num_format": "General",
"major_gridlines": {"visible": 1},
}
self.x2_axis["defaults"] = {
"num_format": "General",
"label_position": "none",
"crossing": "max",
"visible": 0,
}
self.y2_axis["defaults"] = {
"num_format": "General",
"major_gridlines": {"visible": 0},
"position": "right",
"visible": 1,
}
self.set_x_axis({})
self.set_y_axis({})
self.set_x2_axis({})
self.set_y2_axis({})
###########################################################################
#
# XML methods.
#
###########################################################################
def _write_chart_space(self):
# Write the <c:chartSpace> element.
schema = "http://schemas.openxmlformats.org/"
xmlns_c = schema + "drawingml/2006/chart"
xmlns_a = schema + "drawingml/2006/main"
xmlns_r = schema + "officeDocument/2006/relationships"
attributes = [
("xmlns:c", xmlns_c),
("xmlns:a", xmlns_a),
("xmlns:r", xmlns_r),
]
self._xml_start_tag("c:chartSpace", attributes)
def _write_lang(self):
# Write the <c:lang> element.
val = "en-US"
attributes = [("val", val)]
self._xml_empty_tag("c:lang", attributes)
def _write_style(self):
# Write the <c:style> element.
style_id = self.style_id
# Don't write an element for the default style, 2.
if style_id == 2:
return
attributes = [("val", style_id)]
self._xml_empty_tag("c:style", attributes)
def _write_chart(self):
# Write the <c:chart> element.
self._xml_start_tag("c:chart")
if self.title_none:
# Turn off the title.
self._write_c_auto_title_deleted()
else:
# Write the chart title elements.
if self.title_formula is not None:
self._write_title_formula(
self.title_formula,
self.title_data_id,
None,
self.title_font,
self.title_layout,
self.title_overlay,
)
elif self.title_name is not None:
self._write_title_rich(
self.title_name,
None,
self.title_font,
self.title_layout,
self.title_overlay,
)
# Write the c:plotArea element.
self._write_plot_area()
# Write the c:legend element.
self._write_legend()
# Write the c:plotVisOnly element.
self._write_plot_vis_only()
# Write the c:dispBlanksAs element.
self._write_disp_blanks_as()
# Write the c:extLst element.
if self.show_na_as_empty:
self._write_c_ext_lst_display_na()
self._xml_end_tag("c:chart")
def _write_disp_blanks_as(self):
# Write the <c:dispBlanksAs> element.
val = self.show_blanks
# Ignore the default value.
if val == "gap":
return
attributes = [("val", val)]
self._xml_empty_tag("c:dispBlanksAs", attributes)
def _write_plot_area(self):
# Write the <c:plotArea> element.
self._xml_start_tag("c:plotArea")
# Write the c:layout element.
self._write_layout(self.plotarea.get("layout"), "plot")
# Write subclass chart type elements for primary and secondary axes.
self._write_chart_type({"primary_axes": True})
self._write_chart_type({"primary_axes": False})
# Configure a combined chart if present.
second_chart = self.combined
if second_chart:
# Secondary axis has unique id otherwise use same as primary.
if second_chart.is_secondary:
second_chart.id = 1000 + self.id
else:
second_chart.id = self.id
# Share the same filehandle for writing.
second_chart.fh = self.fh
# Share series index with primary chart.
second_chart.series_index = self.series_index
# Write the subclass chart type elements for combined chart.
second_chart._write_chart_type({"primary_axes": True})
second_chart._write_chart_type({"primary_axes": False})
# Write the category and value elements for the primary axes.
args = {"x_axis": self.x_axis, "y_axis": self.y_axis, "axis_ids": self.axis_ids}
if self.date_category:
self._write_date_axis(args)
else:
self._write_cat_axis(args)
self._write_val_axis(args)
# Write the category and value elements for the secondary axes.
args = {
"x_axis": self.x2_axis,
"y_axis": self.y2_axis,
"axis_ids": self.axis2_ids,
}
self._write_val_axis(args)
# Write the secondary axis for the secondary chart.
if second_chart and second_chart.is_secondary:
args = {
"x_axis": second_chart.x2_axis,
"y_axis": second_chart.y2_axis,
"axis_ids": second_chart.axis2_ids,
}
second_chart._write_val_axis(args)
if self.date_category:
self._write_date_axis(args)
else:
self._write_cat_axis(args)
# Write the c:dTable element.
self._write_d_table()
# Write the c:spPr element for the plotarea formatting.
self._write_sp_pr(self.plotarea)
self._xml_end_tag("c:plotArea")
def _write_layout(self, layout, layout_type):
# Write the <c:layout> element.
if not layout:
# Automatic layout.
self._xml_empty_tag("c:layout")
else:
# User defined manual layout.
self._xml_start_tag("c:layout")
self._write_manual_layout(layout, layout_type)
self._xml_end_tag("c:layout")
def _write_manual_layout(self, layout, layout_type):
# Write the <c:manualLayout> element.
self._xml_start_tag("c:manualLayout")
# Plotarea has a layoutTarget element.
if layout_type == "plot":
self._xml_empty_tag("c:layoutTarget", [("val", "inner")])
# Set the x, y positions.
self._xml_empty_tag("c:xMode", [("val", "edge")])
self._xml_empty_tag("c:yMode", [("val", "edge")])
self._xml_empty_tag("c:x", [("val", layout["x"])])
self._xml_empty_tag("c:y", [("val", layout["y"])])
# For plotarea and legend set the width and height.
if layout_type != "text":
self._xml_empty_tag("c:w", [("val", layout["width"])])
self._xml_empty_tag("c:h", [("val", layout["height"])])
self._xml_end_tag("c:manualLayout")
def _write_chart_type(self, args):
# pylint: disable=unused-argument
# Write the chart type element. This method should be overridden
# by the subclasses.
return
def _write_grouping(self, val):
# Write the <c:grouping> element.
attributes = [("val", val)]
self._xml_empty_tag("c:grouping", attributes)
def _write_series(self, series):
# Write the series elements.
self._write_ser(series)
def _write_ser(self, series):
# Write the <c:ser> element.
index = self.series_index
self.series_index += 1
self._xml_start_tag("c:ser")
# Write the c:idx element.
self._write_idx(index)
# Write the c:order element.
self._write_order(index)
# Write the series name.
self._write_series_name(series)
# Write the c:spPr element.
self._write_sp_pr(series)
# Write the c:marker element.
self._write_marker(series["marker"])
# Write the c:invertIfNegative element.
self._write_c_invert_if_negative(series["invert_if_neg"])
# Write the c:dPt element.
self._write_d_pt(series["points"])
# Write the c:dLbls element.
self._write_d_lbls(series["labels"])
# Write the c:trendline element.
self._write_trendline(series["trendline"])
# Write the c:errBars element.
self._write_error_bars(series["error_bars"])
# Write the c:cat element.
self._write_cat(series)
# Write the c:val element.
self._write_val(series)
# Write the c:smooth element.
if self.smooth_allowed:
self._write_c_smooth(series["smooth"])
# Write the c:extLst element.
if series.get("inverted_color"):
self._write_c_ext_lst_inverted_color(series["inverted_color"])
self._xml_end_tag("c:ser")
def _write_c_ext_lst_inverted_color(self, color):
# Write the <c:extLst> element for the inverted fill color.
uri = "{6F2FDCE9-48DA-4B69-8628-5D25D57E5C99}"
xmlns_c_14 = "http://schemas.microsoft.com/office/drawing/2007/8/2/chart"
attributes1 = [
("uri", uri),
("xmlns:c14", xmlns_c_14),
]
attributes2 = [("xmlns:c14", xmlns_c_14)]
self._xml_start_tag("c:extLst")
self._xml_start_tag("c:ext", attributes1)
self._xml_start_tag("c14:invertSolidFillFmt")
self._xml_start_tag("c14:spPr", attributes2)
self._write_a_solid_fill({"color": color})
self._xml_end_tag("c14:spPr")
self._xml_end_tag("c14:invertSolidFillFmt")
self._xml_end_tag("c:ext")
self._xml_end_tag("c:extLst")
def _write_c_ext_lst_display_na(self):
# Write the <c:extLst> element for the display NA as empty cell option.
uri = "{56B9EC1D-385E-4148-901F-78D8002777C0}"
xmlns_c_16 = "http://schemas.microsoft.com/office/drawing/2017/03/chart"
attributes1 = [
("uri", uri),
("xmlns:c16r3", xmlns_c_16),
]
attributes2 = [("val", 1)]
self._xml_start_tag("c:extLst")
self._xml_start_tag("c:ext", attributes1)
self._xml_start_tag("c16r3:dataDisplayOptions16")
self._xml_empty_tag("c16r3:dispNaAsBlank", attributes2)
self._xml_end_tag("c16r3:dataDisplayOptions16")
self._xml_end_tag("c:ext")
self._xml_end_tag("c:extLst")
def _write_idx(self, val):
# Write the <c:idx> element.
attributes = [("val", val)]
self._xml_empty_tag("c:idx", attributes)
def _write_order(self, val):
# Write the <c:order> element.
attributes = [("val", val)]
self._xml_empty_tag("c:order", attributes)
def _write_series_name(self, series):
# Write the series name.
if series["name_formula"] is not None:
self._write_tx_formula(series["name_formula"], series["name_id"])
elif series["name"] is not None:
self._write_tx_value(series["name"])
def _write_c_smooth(self, smooth):
# Write the <c:smooth> element.
if smooth:
self._xml_empty_tag("c:smooth", [("val", "1")])
def _write_cat(self, series):
# Write the <c:cat> element.
formula = series["categories"]
data_id = series["cat_data_id"]
data = None
if data_id is not None:
data = self.formula_data[data_id]
# Ignore <c:cat> elements for charts without category values.
if not formula:
return
self._xml_start_tag("c:cat")
# Check the type of cached data.
cat_type = self._get_data_type(data)
if cat_type == "str":
self.cat_has_num_fmt = 0
# Write the c:numRef element.
self._write_str_ref(formula, data, cat_type)
elif cat_type == "multi_str":
self.cat_has_num_fmt = 0
# Write the c:numRef element.
self._write_multi_lvl_str_ref(formula, data)
else:
self.cat_has_num_fmt = 1
# Write the c:numRef element.
self._write_num_ref(formula, data, cat_type)
self._xml_end_tag("c:cat")
def _write_val(self, series):
# Write the <c:val> element.
formula = series["values"]
data_id = series["val_data_id"]
data = self.formula_data[data_id]
self._xml_start_tag("c:val")
# Unlike Cat axes data should only be numeric.
# Write the c:numRef element.
self._write_num_ref(formula, data, "num")
self._xml_end_tag("c:val")
def _write_num_ref(self, formula, data, ref_type):
# Write the <c:numRef> element.
self._xml_start_tag("c:numRef")
# Write the c:f element.
self._write_series_formula(formula)
if ref_type == "num":
# Write the c:numCache element.
self._write_num_cache(data)
elif ref_type == "str":
# Write the c:strCache element.
self._write_str_cache(data)
self._xml_end_tag("c:numRef")
def _write_str_ref(self, formula, data, ref_type):
# Write the <c:strRef> element.
self._xml_start_tag("c:strRef")
# Write the c:f element.
self._write_series_formula(formula)
if ref_type == "num":
# Write the c:numCache element.
self._write_num_cache(data)
elif ref_type == "str":
# Write the c:strCache element.
self._write_str_cache(data)
self._xml_end_tag("c:strRef")
def _write_multi_lvl_str_ref(self, formula, data):
# Write the <c:multiLvlStrRef> element.
if not data:
return
self._xml_start_tag("c:multiLvlStrRef")
# Write the c:f element.
self._write_series_formula(formula)
self._xml_start_tag("c:multiLvlStrCache")
# Write the c:ptCount element.
count = len(data[-1])
self._write_pt_count(count)
for cat_data in reversed(data):
self._xml_start_tag("c:lvl")
for i, point in enumerate(cat_data):
# Write the c:pt element.
self._write_pt(i, point)
self._xml_end_tag("c:lvl")
self._xml_end_tag("c:multiLvlStrCache")
self._xml_end_tag("c:multiLvlStrRef")
def _write_series_formula(self, formula):
# Write the <c:f> element.
# Strip the leading '=' from the formula.
if formula.startswith("="):
formula = formula.lstrip("=")
self._xml_data_element("c:f", formula)
def _write_axis_ids(self, args):
# Write the <c:axId> elements for the primary or secondary axes.
# Generate the axis ids.
self._add_axis_ids(args)
if args["primary_axes"]:
# Write the axis ids for the primary axes.
self._write_axis_id(self.axis_ids[0])
self._write_axis_id(self.axis_ids[1])
else:
# Write the axis ids for the secondary axes.
self._write_axis_id(self.axis2_ids[0])
self._write_axis_id(self.axis2_ids[1])
def _write_axis_id(self, val):
# Write the <c:axId> element.
attributes = [("val", val)]
self._xml_empty_tag("c:axId", attributes)
def _write_cat_axis(self, args):
# Write the <c:catAx> element. Usually the X axis.
x_axis = args["x_axis"]
y_axis = args["y_axis"]
axis_ids = args["axis_ids"]
# If there are no axis_ids then we don't need to write this element.
if axis_ids is None or not axis_ids:
return
position = self.cat_axis_position
is_y_axis = self.horiz_cat_axis
# Overwrite the default axis position with a user supplied value.
if x_axis.get("position"):
position = x_axis["position"]
self._xml_start_tag("c:catAx")
self._write_axis_id(axis_ids[0])
# Write the c:scaling element.
self._write_scaling(x_axis.get("reverse"), None, None, None)
if not x_axis.get("visible"):
self._write_delete(1)
# Write the c:axPos element.
self._write_axis_pos(position, y_axis.get("reverse"))
# Write the c:majorGridlines element.
self._write_major_gridlines(x_axis.get("major_gridlines"))
# Write the c:minorGridlines element.
self._write_minor_gridlines(x_axis.get("minor_gridlines"))
# Write the axis title elements.
if x_axis["formula"] is not None:
self._write_title_formula(
x_axis["formula"],
x_axis["data_id"],
is_y_axis,
x_axis["name_font"],
x_axis["name_layout"],
)
elif x_axis["name"] is not None:
self._write_title_rich(
x_axis["name"], is_y_axis, x_axis["name_font"], x_axis["name_layout"]
)
# Write the c:numFmt element.
self._write_cat_number_format(x_axis)
# Write the c:majorTickMark element.
self._write_major_tick_mark(x_axis.get("major_tick_mark"))
# Write the c:minorTickMark element.
self._write_minor_tick_mark(x_axis.get("minor_tick_mark"))
# Write the c:tickLblPos element.
self._write_tick_label_pos(x_axis.get("label_position"))
# Write the c:spPr element for the axis line.
self._write_sp_pr(x_axis)
# Write the axis font elements.
self._write_axis_font(x_axis.get("num_font"))
# Write the c:crossAx element.
self._write_cross_axis(axis_ids[1])
if self.show_crosses or x_axis.get("visible"):
# Note, the category crossing comes from the value axis.
if (
y_axis.get("crossing") is None
or y_axis.get("crossing") == "max"
or y_axis["crossing"] == "min"
):
# Write the c:crosses element.
self._write_crosses(y_axis.get("crossing"))
else:
# Write the c:crossesAt element.
self._write_c_crosses_at(y_axis.get("crossing"))
# Write the c:auto element.
if not x_axis.get("text_axis"):
self._write_auto(1)
# Write the c:labelAlign element.
self._write_label_align(x_axis.get("label_align"))
# Write the c:labelOffset element.
self._write_label_offset(100)
# Write the c:tickLblSkip element.
self._write_c_tick_lbl_skip(x_axis.get("interval_unit"))
# Write the c:tickMarkSkip element.
self._write_c_tick_mark_skip(x_axis.get("interval_tick"))
self._xml_end_tag("c:catAx")
def _write_val_axis(self, args):
# Write the <c:valAx> element. Usually the Y axis.
x_axis = args["x_axis"]
y_axis = args["y_axis"]
axis_ids = args["axis_ids"]
position = args.get("position", self.val_axis_position)
is_y_axis = self.horiz_val_axis
# If there are no axis_ids then we don't need to write this element.
if axis_ids is None or not axis_ids:
return
# Overwrite the default axis position with a user supplied value.
position = y_axis.get("position") or position
self._xml_start_tag("c:valAx")
self._write_axis_id(axis_ids[1])
# Write the c:scaling element.
self._write_scaling(
y_axis.get("reverse"),
y_axis.get("min"),
y_axis.get("max"),
y_axis.get("log_base"),
)
if not y_axis.get("visible"):
self._write_delete(1)
# Write the c:axPos element.
self._write_axis_pos(position, x_axis.get("reverse"))
# Write the c:majorGridlines element.
self._write_major_gridlines(y_axis.get("major_gridlines"))
# Write the c:minorGridlines element.
self._write_minor_gridlines(y_axis.get("minor_gridlines"))
# Write the axis title elements.
if y_axis["formula"] is not None:
self._write_title_formula(
y_axis["formula"],
y_axis["data_id"],
is_y_axis,
y_axis["name_font"],
y_axis["name_layout"],
)
elif y_axis["name"] is not None:
self._write_title_rich(
y_axis["name"],
is_y_axis,
y_axis.get("name_font"),
y_axis.get("name_layout"),
)
# Write the c:numberFormat element.
self._write_number_format(y_axis)
# Write the c:majorTickMark element.
self._write_major_tick_mark(y_axis.get("major_tick_mark"))
# Write the c:minorTickMark element.
self._write_minor_tick_mark(y_axis.get("minor_tick_mark"))
# Write the c:tickLblPos element.
self._write_tick_label_pos(y_axis.get("label_position"))
# Write the c:spPr element for the axis line.
self._write_sp_pr(y_axis)
# Write the axis font elements.
self._write_axis_font(y_axis.get("num_font"))
# Write the c:crossAx element.
self._write_cross_axis(axis_ids[0])
# Note, the category crossing comes from the value axis.
if (
x_axis.get("crossing") is None
or x_axis["crossing"] == "max"
or x_axis["crossing"] == "min"
):
# Write the c:crosses element.
self._write_crosses(x_axis.get("crossing"))
else:
# Write the c:crossesAt element.
self._write_c_crosses_at(x_axis.get("crossing"))
# Write the c:crossBetween element.
self._write_cross_between(x_axis.get("position_axis"))
# Write the c:majorUnit element.
self._write_c_major_unit(y_axis.get("major_unit"))
# Write the c:minorUnit element.
self._write_c_minor_unit(y_axis.get("minor_unit"))
# Write the c:dispUnits element.
self._write_disp_units(
y_axis.get("display_units"), y_axis.get("display_units_visible")
)
self._xml_end_tag("c:valAx")
def _write_cat_val_axis(self, args):
# Write the <c:valAx> element. This is for the second valAx
# in scatter plots. Usually the X axis.
x_axis = args["x_axis"]
y_axis = args["y_axis"]
axis_ids = args["axis_ids"]
position = args["position"] or self.val_axis_position
is_y_axis = self.horiz_val_axis
# If there are no axis_ids then we don't need to write this element.
if axis_ids is None or not axis_ids:
return
# Overwrite the default axis position with a user supplied value.
position = x_axis.get("position") or position
self._xml_start_tag("c:valAx")
self._write_axis_id(axis_ids[0])
# Write the c:scaling element.
self._write_scaling(
x_axis.get("reverse"),
x_axis.get("min"),
x_axis.get("max"),
x_axis.get("log_base"),
)
if not x_axis.get("visible"):
self._write_delete(1)
# Write the c:axPos element.
self._write_axis_pos(position, y_axis.get("reverse"))
# Write the c:majorGridlines element.
self._write_major_gridlines(x_axis.get("major_gridlines"))
# Write the c:minorGridlines element.
self._write_minor_gridlines(x_axis.get("minor_gridlines"))
# Write the axis title elements.
if x_axis["formula"] is not None:
self._write_title_formula(
x_axis["formula"],
x_axis["data_id"],
is_y_axis,
x_axis["name_font"],
x_axis["name_layout"],
)
elif x_axis["name"] is not None:
self._write_title_rich(
x_axis["name"], is_y_axis, x_axis["name_font"], x_axis["name_layout"]
)
# Write the c:numberFormat element.
self._write_number_format(x_axis)
# Write the c:majorTickMark element.
self._write_major_tick_mark(x_axis.get("major_tick_mark"))
# Write the c:minorTickMark element.
self._write_minor_tick_mark(x_axis.get("minor_tick_mark"))
# Write the c:tickLblPos element.
self._write_tick_label_pos(x_axis.get("label_position"))
# Write the c:spPr element for the axis line.
self._write_sp_pr(x_axis)
# Write the axis font elements.
self._write_axis_font(x_axis.get("num_font"))
# Write the c:crossAx element.
self._write_cross_axis(axis_ids[1])
# Note, the category crossing comes from the value axis.
if (
y_axis.get("crossing") is None
or y_axis["crossing"] == "max"
or y_axis["crossing"] == "min"
):
# Write the c:crosses element.
self._write_crosses(y_axis.get("crossing"))
else:
# Write the c:crossesAt element.
self._write_c_crosses_at(y_axis.get("crossing"))
# Write the c:crossBetween element.
self._write_cross_between(y_axis.get("position_axis"))
# Write the c:majorUnit element.
self._write_c_major_unit(x_axis.get("major_unit"))
# Write the c:minorUnit element.
self._write_c_minor_unit(x_axis.get("minor_unit"))
# Write the c:dispUnits element.
self._write_disp_units(
x_axis.get("display_units"), x_axis.get("display_units_visible")
)
self._xml_end_tag("c:valAx")
def _write_date_axis(self, args):
# Write the <c:dateAx> element. Usually the X axis.
x_axis = args["x_axis"]
y_axis = args["y_axis"]
axis_ids = args["axis_ids"]
# If there are no axis_ids then we don't need to write this element.
if axis_ids is None or not axis_ids:
return
position = self.cat_axis_position
# Overwrite the default axis position with a user supplied value.
position = x_axis.get("position") or position
self._xml_start_tag("c:dateAx")
self._write_axis_id(axis_ids[0])
# Write the c:scaling element.
self._write_scaling(
x_axis.get("reverse"),
x_axis.get("min"),
x_axis.get("max"),
x_axis.get("log_base"),
)
if not x_axis.get("visible"):
self._write_delete(1)
# Write the c:axPos element.
self._write_axis_pos(position, y_axis.get("reverse"))
# Write the c:majorGridlines element.
self._write_major_gridlines(x_axis.get("major_gridlines"))
# Write the c:minorGridlines element.
self._write_minor_gridlines(x_axis.get("minor_gridlines"))
# Write the axis title elements.
if x_axis["formula"] is not None:
self._write_title_formula(
x_axis["formula"],
x_axis["data_id"],
None,
x_axis["name_font"],
x_axis["name_layout"],
)
elif x_axis["name"] is not None:
self._write_title_rich(
x_axis["name"], None, x_axis["name_font"], x_axis["name_layout"]
)
# Write the c:numFmt element.
self._write_number_format(x_axis)
# Write the c:majorTickMark element.
self._write_major_tick_mark(x_axis.get("major_tick_mark"))
# Write the c:minorTickMark element.
self._write_minor_tick_mark(x_axis.get("minor_tick_mark"))
# Write the c:tickLblPos element.
self._write_tick_label_pos(x_axis.get("label_position"))
# Write the c:spPr element for the axis line.
self._write_sp_pr(x_axis)
# Write the axis font elements.
self._write_axis_font(x_axis.get("num_font"))
# Write the c:crossAx element.
self._write_cross_axis(axis_ids[1])
if self.show_crosses or x_axis.get("visible"):
# Note, the category crossing comes from the value axis.
if (
y_axis.get("crossing") is None
or y_axis.get("crossing") == "max"
or y_axis["crossing"] == "min"
):
# Write the c:crosses element.
self._write_crosses(y_axis.get("crossing"))
else:
# Write the c:crossesAt element.
self._write_c_crosses_at(y_axis.get("crossing"))
# Write the c:auto element.
self._write_auto(1)
# Write the c:labelOffset element.
self._write_label_offset(100)
# Write the c:tickLblSkip element.
self._write_c_tick_lbl_skip(x_axis.get("interval_unit"))
# Write the c:tickMarkSkip element.
self._write_c_tick_mark_skip(x_axis.get("interval_tick"))
# Write the c:majorUnit element.
self._write_c_major_unit(x_axis.get("major_unit"))
# Write the c:majorTimeUnit element.
if x_axis.get("major_unit"):
self._write_c_major_time_unit(x_axis["major_unit_type"])
# Write the c:minorUnit element.
self._write_c_minor_unit(x_axis.get("minor_unit"))
# Write the c:minorTimeUnit element.
if x_axis.get("minor_unit"):
self._write_c_minor_time_unit(x_axis["minor_unit_type"])
self._xml_end_tag("c:dateAx")
def _write_scaling(self, reverse, min_val, max_val, log_base):
# Write the <c:scaling> element.
self._xml_start_tag("c:scaling")
# Write the c:logBase element.
self._write_c_log_base(log_base)
# Write the c:orientation element.
self._write_orientation(reverse)
# Write the c:max element.
self._write_c_max(max_val)
# Write the c:min element.
self._write_c_min(min_val)
self._xml_end_tag("c:scaling")
def _write_c_log_base(self, val):
# Write the <c:logBase> element.
if not val:
return
attributes = [("val", val)]
self._xml_empty_tag("c:logBase", attributes)
def _write_orientation(self, reverse):
# Write the <c:orientation> element.
val = "minMax"
if reverse:
val = "maxMin"
attributes = [("val", val)]
self._xml_empty_tag("c:orientation", attributes)
def _write_c_max(self, max_val):
# Write the <c:max> element.
if max_val is None:
return
attributes = [("val", max_val)]
self._xml_empty_tag("c:max", attributes)
def _write_c_min(self, min_val):
# Write the <c:min> element.
if min_val is None:
return
attributes = [("val", min_val)]
self._xml_empty_tag("c:min", attributes)
def _write_axis_pos(self, val, reverse):
# Write the <c:axPos> element.
if reverse:
if val == "l":
val = "r"
if val == "b":
val = "t"
attributes = [("val", val)]
self._xml_empty_tag("c:axPos", attributes)
def _write_number_format(self, axis):
# Write the <c:numberFormat> element. Note: It is assumed that if
# a user defined number format is supplied (i.e., non-default) then
# the sourceLinked attribute is 0.
# The user can override this if required.
format_code = axis.get("num_format")
source_linked = 1
# Check if a user defined number format has been set.
if format_code is not None and format_code != axis["defaults"]["num_format"]:
source_linked = 0
# User override of sourceLinked.
if axis.get("num_format_linked"):
source_linked = 1
attributes = [
("formatCode", format_code),
("sourceLinked", source_linked),
]
self._xml_empty_tag("c:numFmt", attributes)
def _write_cat_number_format(self, axis):
# Write the <c:numFmt> element. Special case handler for category
# axes which don't always have a number format.
format_code = axis.get("num_format")
source_linked = 1
default_format = 1
# Check if a user defined number format has been set.
if format_code is not None and format_code != axis["defaults"]["num_format"]:
source_linked = 0
default_format = 0
# User override of sourceLinked.
if axis.get("num_format_linked"):
source_linked = 1
# Skip if cat doesn't have a num format (unless it is non-default).
if not self.cat_has_num_fmt and default_format:
return
attributes = [
("formatCode", format_code),
("sourceLinked", source_linked),
]
self._xml_empty_tag("c:numFmt", attributes)
def _write_data_label_number_format(self, format_code):
# Write the <c:numberFormat> element for data labels.
source_linked = 0
attributes = [
("formatCode", format_code),
("sourceLinked", source_linked),
]
self._xml_empty_tag("c:numFmt", attributes)
def _write_major_tick_mark(self, val):
# Write the <c:majorTickMark> element.
if not val:
return
attributes = [("val", val)]
self._xml_empty_tag("c:majorTickMark", attributes)
def _write_minor_tick_mark(self, val):
# Write the <c:minorTickMark> element.
if not val:
return
attributes = [("val", val)]
self._xml_empty_tag("c:minorTickMark", attributes)
def _write_tick_label_pos(self, val=None):
# Write the <c:tickLblPos> element.
if val is None or val == "next_to":
val = "nextTo"
attributes = [("val", val)]
self._xml_empty_tag("c:tickLblPos", attributes)
def _write_cross_axis(self, val):
# Write the <c:crossAx> element.
attributes = [("val", val)]
self._xml_empty_tag("c:crossAx", attributes)
def _write_crosses(self, val=None):
# Write the <c:crosses> element.
if val is None:
val = "autoZero"
attributes = [("val", val)]
self._xml_empty_tag("c:crosses", attributes)
def _write_c_crosses_at(self, val):
# Write the <c:crossesAt> element.
attributes = [("val", val)]
self._xml_empty_tag("c:crossesAt", attributes)
def _write_auto(self, val):
# Write the <c:auto> element.
attributes = [("val", val)]
self._xml_empty_tag("c:auto", attributes)
def _write_label_align(self, val=None):
# Write the <c:labelAlign> element.
if val is None:
val = "ctr"
if val == "right":
val = "r"
if val == "left":
val = "l"
attributes = [("val", val)]
self._xml_empty_tag("c:lblAlgn", attributes)
def _write_label_offset(self, val):
# Write the <c:labelOffset> element.
attributes = [("val", val)]
self._xml_empty_tag("c:lblOffset", attributes)
def _write_c_tick_lbl_skip(self, val):
# Write the <c:tickLblSkip> element.
if val is None:
return
attributes = [("val", val)]
self._xml_empty_tag("c:tickLblSkip", attributes)
def _write_c_tick_mark_skip(self, val):
# Write the <c:tickMarkSkip> element.
if val is None:
return
attributes = [("val", val)]
self._xml_empty_tag("c:tickMarkSkip", attributes)
def _write_major_gridlines(self, gridlines):
# Write the <c:majorGridlines> element.
if not gridlines:
return
if not gridlines["visible"]:
return
if gridlines["line"]["defined"]:
self._xml_start_tag("c:majorGridlines")
# Write the c:spPr element.
self._write_sp_pr(gridlines)
self._xml_end_tag("c:majorGridlines")
else:
self._xml_empty_tag("c:majorGridlines")
def _write_minor_gridlines(self, gridlines):
# Write the <c:minorGridlines> element.
if not gridlines:
return
if not gridlines["visible"]:
return
if gridlines["line"]["defined"]:
self._xml_start_tag("c:minorGridlines")
# Write the c:spPr element.
self._write_sp_pr(gridlines)
self._xml_end_tag("c:minorGridlines")
else:
self._xml_empty_tag("c:minorGridlines")
def _write_cross_between(self, val):
# Write the <c:crossBetween> element.
if val is None:
val = self.cross_between
attributes = [("val", val)]
self._xml_empty_tag("c:crossBetween", attributes)
def _write_c_major_unit(self, val):
# Write the <c:majorUnit> element.
if not val:
return
attributes = [("val", val)]
self._xml_empty_tag("c:majorUnit", attributes)
def _write_c_minor_unit(self, val):
# Write the <c:minorUnit> element.
if not val:
return
attributes = [("val", val)]
self._xml_empty_tag("c:minorUnit", attributes)
def _write_c_major_time_unit(self, val=None):
# Write the <c:majorTimeUnit> element.
if val is None:
val = "days"
attributes = [("val", val)]
self._xml_empty_tag("c:majorTimeUnit", attributes)
def _write_c_minor_time_unit(self, val=None):
# Write the <c:minorTimeUnit> element.
if val is None:
val = "days"
attributes = [("val", val)]
self._xml_empty_tag("c:minorTimeUnit", attributes)
def _write_legend(self):
# Write the <c:legend> element.
legend = self.legend
position = legend.get("position", "right")
font = legend.get("font")
delete_series = []
overlay = 0
if legend.get("delete_series") and isinstance(legend["delete_series"], list):
delete_series = legend["delete_series"]
if position.startswith("overlay_"):
position = position.replace("overlay_", "")
overlay = 1
allowed = {
"right": "r",
"left": "l",
"top": "t",
"bottom": "b",
"top_right": "tr",
}
if position == "none":
return
if position not in allowed:
return
position = allowed[position]
self._xml_start_tag("c:legend")
# Write the c:legendPos element.
self._write_legend_pos(position)
# Remove series labels from the legend.
for index in delete_series:
# Write the c:legendEntry element.
self._write_legend_entry(index)
# Write the c:layout element.
self._write_layout(legend.get("layout"), "legend")
# Write the c:overlay element.
if overlay:
self._write_overlay()
if font:
self._write_tx_pr(font)
# Write the c:spPr element.
self._write_sp_pr(legend)
self._xml_end_tag("c:legend")
def _write_legend_pos(self, val):
# Write the <c:legendPos> element.
attributes = [("val", val)]
self._xml_empty_tag("c:legendPos", attributes)
def _write_legend_entry(self, index):
# Write the <c:legendEntry> element.
self._xml_start_tag("c:legendEntry")
# Write the c:idx element.
self._write_idx(index)
# Write the c:delete element.
self._write_delete(1)
self._xml_end_tag("c:legendEntry")
def _write_overlay(self):
# Write the <c:overlay> element.
val = 1
attributes = [("val", val)]
self._xml_empty_tag("c:overlay", attributes)
def _write_plot_vis_only(self):
# Write the <c:plotVisOnly> element.
val = 1
# Ignore this element if we are plotting hidden data.
if self.show_hidden:
return
attributes = [("val", val)]
self._xml_empty_tag("c:plotVisOnly", attributes)
def _write_print_settings(self):
# Write the <c:printSettings> element.
self._xml_start_tag("c:printSettings")
# Write the c:headerFooter element.
self._write_header_footer()
# Write the c:pageMargins element.
self._write_page_margins()
# Write the c:pageSetup element.
self._write_page_setup()
self._xml_end_tag("c:printSettings")
def _write_header_footer(self):
# Write the <c:headerFooter> element.
self._xml_empty_tag("c:headerFooter")
def _write_page_margins(self):
# Write the <c:pageMargins> element.
bottom = 0.75
left = 0.7
right = 0.7
top = 0.75
header = 0.3
footer = 0.3
attributes = [
("b", bottom),
("l", left),
("r", right),
("t", top),
("header", header),
("footer", footer),
]
self._xml_empty_tag("c:pageMargins", attributes)
def _write_page_setup(self):
# Write the <c:pageSetup> element.
self._xml_empty_tag("c:pageSetup")
def _write_c_auto_title_deleted(self):
# Write the <c:autoTitleDeleted> element.
self._xml_empty_tag("c:autoTitleDeleted", [("val", 1)])
def _write_title_rich(self, title, is_y_axis, font, layout, overlay=False):
# Write the <c:title> element for a rich string.
self._xml_start_tag("c:title")
# Write the c:tx element.
self._write_tx_rich(title, is_y_axis, font)
# Write the c:layout element.
self._write_layout(layout, "text")
# Write the c:overlay element.
if overlay:
self._write_overlay()
self._xml_end_tag("c:title")
def _write_title_formula(
self, title, data_id, is_y_axis, font, layout, overlay=False
):
# Write the <c:title> element for a rich string.
self._xml_start_tag("c:title")
# Write the c:tx element.
self._write_tx_formula(title, data_id)
# Write the c:layout element.
self._write_layout(layout, "text")
# Write the c:overlay element.
if overlay:
self._write_overlay()
# Write the c:txPr element.
self._write_tx_pr(font, is_y_axis)
self._xml_end_tag("c:title")
def _write_tx_rich(self, title, is_y_axis, font):
# Write the <c:tx> element.
self._xml_start_tag("c:tx")
# Write the c:rich element.
self._write_rich(title, font, is_y_axis, ignore_rich_pr=False)
self._xml_end_tag("c:tx")
def _write_tx_value(self, title):
# Write the <c:tx> element with a value such as for series names.
self._xml_start_tag("c:tx")
# Write the c:v element.
self._write_v(title)
self._xml_end_tag("c:tx")
def _write_tx_formula(self, title, data_id):
# Write the <c:tx> element.
data = None
if data_id is not None:
data = self.formula_data[data_id]
self._xml_start_tag("c:tx")
# Write the c:strRef element.
self._write_str_ref(title, data, "str")
self._xml_end_tag("c:tx")
def _write_rich(self, title, font, is_y_axis, ignore_rich_pr):
# Write the <c:rich> element.
if font and font.get("rotation") is not None:
rotation = font["rotation"]
else:
rotation = None
self._xml_start_tag("c:rich")
# Write the a:bodyPr element.
self._write_a_body_pr(rotation, is_y_axis)
# Write the a:lstStyle element.
self._write_a_lst_style()
# Write the a:p element.
self._write_a_p_rich(title, font, ignore_rich_pr)
self._xml_end_tag("c:rich")
def _write_a_body_pr(self, rotation, is_y_axis):
# Write the <a:bodyPr> element.
attributes = []
if rotation is None and is_y_axis:
rotation = -5400000
if rotation is not None:
if rotation == 16200000:
# 270 deg/stacked angle.
attributes.append(("rot", 0))
attributes.append(("vert", "wordArtVert"))
elif rotation == 16260000:
# 271 deg/East Asian vertical.
attributes.append(("rot", 0))
attributes.append(("vert", "eaVert"))
else:
attributes.append(("rot", rotation))
attributes.append(("vert", "horz"))
self._xml_empty_tag("a:bodyPr", attributes)
def _write_a_lst_style(self):
# Write the <a:lstStyle> element.
self._xml_empty_tag("a:lstStyle")
def _write_a_p_rich(self, title, font, ignore_rich_pr):
# Write the <a:p> element for rich string titles.
self._xml_start_tag("a:p")
# Write the a:pPr element.
if not ignore_rich_pr:
self._write_a_p_pr_rich(font)
# Write the a:r element.
self._write_a_r(title, font)
self._xml_end_tag("a:p")
def _write_a_p_formula(self, font):
# Write the <a:p> element for formula titles.
self._xml_start_tag("a:p")
# Write the a:pPr element.
self._write_a_p_pr_rich(font)
# Write the a:endParaRPr element.
self._write_a_end_para_rpr()
self._xml_end_tag("a:p")
def _write_a_p_pr_rich(self, font):
# Write the <a:pPr> element for rich string titles.
self._xml_start_tag("a:pPr")
# Write the a:defRPr element.
self._write_a_def_rpr(font)
self._xml_end_tag("a:pPr")
def _write_a_def_rpr(self, font):
# Write the <a:defRPr> element.
has_color = 0
style_attributes = Shape._get_font_style_attributes(font)
latin_attributes = Shape._get_font_latin_attributes(font)
if font and font.get("color") is not None:
has_color = 1
if latin_attributes or has_color:
self._xml_start_tag("a:defRPr", style_attributes)
if has_color:
self._write_a_solid_fill({"color": font["color"]})
if latin_attributes:
self._write_a_latin(latin_attributes)
self._xml_end_tag("a:defRPr")
else:
self._xml_empty_tag("a:defRPr", style_attributes)
def _write_a_end_para_rpr(self):
# Write the <a:endParaRPr> element.
lang = "en-US"
attributes = [("lang", lang)]
self._xml_empty_tag("a:endParaRPr", attributes)
def _write_a_r(self, title, font):
# Write the <a:r> element.
self._xml_start_tag("a:r")
# Write the a:rPr element.
self._write_a_r_pr(font)
# Write the a:t element.
self._write_a_t(title)
self._xml_end_tag("a:r")
def _write_a_r_pr(self, font):
# Write the <a:rPr> element.
has_color = 0
lang = "en-US"
style_attributes = Shape._get_font_style_attributes(font)
latin_attributes = Shape._get_font_latin_attributes(font)
if font and font["color"] is not None:
has_color = 1
# Add the lang type to the attributes.
style_attributes.insert(0, ("lang", lang))
if latin_attributes or has_color:
self._xml_start_tag("a:rPr", style_attributes)
if has_color:
self._write_a_solid_fill({"color": font["color"]})
if latin_attributes:
self._write_a_latin(latin_attributes)
self._xml_end_tag("a:rPr")
else:
self._xml_empty_tag("a:rPr", style_attributes)
def _write_a_t(self, title):
# Write the <a:t> element.
self._xml_data_element("a:t", title)
def _write_tx_pr(self, font, is_y_axis=False):
# Write the <c:txPr> element.
if font and font.get("rotation") is not None:
rotation = font["rotation"]
else:
rotation = None
self._xml_start_tag("c:txPr")
# Write the a:bodyPr element.
self._write_a_body_pr(rotation, is_y_axis)
# Write the a:lstStyle element.
self._write_a_lst_style()
# Write the a:p element.
self._write_a_p_formula(font)
self._xml_end_tag("c:txPr")
def _write_marker(self, marker):
# Write the <c:marker> element.
if marker is None:
marker = self.default_marker
if not marker:
return
if marker["type"] == "automatic":
return
self._xml_start_tag("c:marker")
# Write the c:symbol element.
self._write_symbol(marker["type"])
# Write the c:size element.
if marker.get("size"):
self._write_marker_size(marker["size"])
# Write the c:spPr element.
self._write_sp_pr(marker)
self._xml_end_tag("c:marker")
def _write_marker_size(self, val):
# Write the <c:size> element.
attributes = [("val", val)]
self._xml_empty_tag("c:size", attributes)
def _write_symbol(self, val):
# Write the <c:symbol> element.
attributes = [("val", val)]
self._xml_empty_tag("c:symbol", attributes)
def _write_sp_pr(self, series):
# Write the <c:spPr> element.
if not self._has_fill_formatting(series):
return
self._xml_start_tag("c:spPr")
# Write the fill elements for solid charts such as pie and bar.
if series.get("fill") and series["fill"]["defined"]:
if "none" in series["fill"]:
# Write the a:noFill element.
self._write_a_no_fill()
else:
# Write the a:solidFill element.
self._write_a_solid_fill(series["fill"])
if series.get("pattern"):
# Write the a:gradFill element.
self._write_a_patt_fill(series["pattern"])
if series.get("gradient"):
# Write the a:gradFill element.
self._write_a_grad_fill(series["gradient"])
# Write the a:ln element.
if series.get("line") and series["line"]["defined"]:
self._write_a_ln(series["line"])
self._xml_end_tag("c:spPr")
def _write_a_ln(self, line):
# Write the <a:ln> element.
attributes = []
# Add the line width as an attribute.
width = line.get("width")
if width is not None:
# Round width to nearest 0.25, like Excel.
width = int((width + 0.125) * 4) / 4.0
# Convert to internal units.
width = int(0.5 + (12700 * width))
attributes = [("w", width)]
if line.get("none") or line.get("color") or line.get("dash_type"):
self._xml_start_tag("a:ln", attributes)
# Write the line fill.
if "none" in line:
# Write the a:noFill element.
self._write_a_no_fill()
elif "color" in line:
# Write the a:solidFill element.
self._write_a_solid_fill(line)
# Write the line/dash type.
line_type = line.get("dash_type")
if line_type:
# Write the a:prstDash element.
self._write_a_prst_dash(line_type)
self._xml_end_tag("a:ln")
else:
self._xml_empty_tag("a:ln", attributes)
def _write_a_no_fill(self):
# Write the <a:noFill> element.
self._xml_empty_tag("a:noFill")
def _write_a_solid_fill(self, fill):
# Write the <a:solidFill> element.
self._xml_start_tag("a:solidFill")
if "color" in fill:
color = _get_rgb_color(fill["color"])
transparency = fill.get("transparency")
# Write the a:srgbClr element.
self._write_a_srgb_clr(color, transparency)
self._xml_end_tag("a:solidFill")
def _write_a_srgb_clr(self, val, transparency=None):
# Write the <a:srgbClr> element.
attributes = [("val", val)]
if transparency:
self._xml_start_tag("a:srgbClr", attributes)
# Write the a:alpha element.
self._write_a_alpha(transparency)
self._xml_end_tag("a:srgbClr")
else:
self._xml_empty_tag("a:srgbClr", attributes)
def _write_a_alpha(self, val):
# Write the <a:alpha> element.
val = int((100 - int(val)) * 1000)
attributes = [("val", val)]
self._xml_empty_tag("a:alpha", attributes)
def _write_a_prst_dash(self, val):
# Write the <a:prstDash> element.
attributes = [("val", val)]
self._xml_empty_tag("a:prstDash", attributes)
def _write_trendline(self, trendline):
# Write the <c:trendline> element.
if not trendline:
return
self._xml_start_tag("c:trendline")
# Write the c:name element.
self._write_name(trendline.get("name"))
# Write the c:spPr element.
self._write_sp_pr(trendline)
# Write the c:trendlineType element.
self._write_trendline_type(trendline["type"])
# Write the c:order element for polynomial trendlines.
if trendline["type"] == "poly":
self._write_trendline_order(trendline.get("order"))
# Write the c:period element for moving average trendlines.
if trendline["type"] == "movingAvg":
self._write_period(trendline.get("period"))
# Write the c:forward element.
self._write_forward(trendline.get("forward"))
# Write the c:backward element.
self._write_backward(trendline.get("backward"))
if "intercept" in trendline:
# Write the c:intercept element.
self._write_c_intercept(trendline["intercept"])
if trendline.get("display_r_squared"):
# Write the c:dispRSqr element.
self._write_c_disp_rsqr()
if trendline.get("display_equation"):
# Write the c:dispEq element.
self._write_c_disp_eq()
# Write the c:trendlineLbl element.
self._write_c_trendline_lbl(trendline)
self._xml_end_tag("c:trendline")
def _write_trendline_type(self, val):
# Write the <c:trendlineType> element.
attributes = [("val", val)]
self._xml_empty_tag("c:trendlineType", attributes)
def _write_name(self, data):
# Write the <c:name> element.
if data is None:
return
self._xml_data_element("c:name", data)
def _write_trendline_order(self, val):
# Write the <c:order> element.
val = max(val, 2)
attributes = [("val", val)]
self._xml_empty_tag("c:order", attributes)
def _write_period(self, val):
# Write the <c:period> element.
val = max(val, 2)
attributes = [("val", val)]
self._xml_empty_tag("c:period", attributes)
def _write_forward(self, val):
# Write the <c:forward> element.
if not val:
return
attributes = [("val", val)]
self._xml_empty_tag("c:forward", attributes)
def _write_backward(self, val):
# Write the <c:backward> element.
if not val:
return
attributes = [("val", val)]
self._xml_empty_tag("c:backward", attributes)
def _write_c_intercept(self, val):
# Write the <c:intercept> element.
attributes = [("val", val)]
self._xml_empty_tag("c:intercept", attributes)
def _write_c_disp_eq(self):
# Write the <c:dispEq> element.
attributes = [("val", 1)]
self._xml_empty_tag("c:dispEq", attributes)
def _write_c_disp_rsqr(self):
# Write the <c:dispRSqr> element.
attributes = [("val", 1)]
self._xml_empty_tag("c:dispRSqr", attributes)
def _write_c_trendline_lbl(self, trendline):
# Write the <c:trendlineLbl> element.
self._xml_start_tag("c:trendlineLbl")
# Write the c:layout element.
self._write_layout(None, None)
# Write the c:numFmt element.
self._write_trendline_num_fmt()
# Write the c:spPr element.
self._write_sp_pr(trendline["label"])
# Write the data label font elements.
if trendline["label"]:
font = trendline["label"].get("font")
if font:
self._write_axis_font(font)
self._xml_end_tag("c:trendlineLbl")
def _write_trendline_num_fmt(self):
# Write the <c:numFmt> element.
attributes = [
("formatCode", "General"),
("sourceLinked", 0),
]
self._xml_empty_tag("c:numFmt", attributes)
def _write_hi_low_lines(self):
# Write the <c:hiLowLines> element.
hi_low_lines = self.hi_low_lines
if hi_low_lines is None:
return
if "line" in hi_low_lines and hi_low_lines["line"]["defined"]:
self._xml_start_tag("c:hiLowLines")
# Write the c:spPr element.
self._write_sp_pr(hi_low_lines)
self._xml_end_tag("c:hiLowLines")
else:
self._xml_empty_tag("c:hiLowLines")
def _write_drop_lines(self):
# Write the <c:dropLines> element.
drop_lines = self.drop_lines
if drop_lines is None:
return
if drop_lines["line"]["defined"]:
self._xml_start_tag("c:dropLines")
# Write the c:spPr element.
self._write_sp_pr(drop_lines)
self._xml_end_tag("c:dropLines")
else:
self._xml_empty_tag("c:dropLines")
def _write_overlap(self, val):
# Write the <c:overlap> element.
if val is None:
return
attributes = [("val", val)]
self._xml_empty_tag("c:overlap", attributes)
def _write_num_cache(self, data):
# Write the <c:numCache> element.
if data:
count = len(data)
else:
count = 0
self._xml_start_tag("c:numCache")
# Write the c:formatCode element.
self._write_format_code("General")
# Write the c:ptCount element.
self._write_pt_count(count)
for i in range(count):
token = data[i]
if token is None:
continue
try:
float(token)
except ValueError:
# Write non-numeric data as 0.
token = 0
# Write the c:pt element.
self._write_pt(i, token)
self._xml_end_tag("c:numCache")
def _write_str_cache(self, data):
# Write the <c:strCache> element.
count = len(data)
self._xml_start_tag("c:strCache")
# Write the c:ptCount element.
self._write_pt_count(count)
for i in range(count):
# Write the c:pt element.
self._write_pt(i, data[i])
self._xml_end_tag("c:strCache")
def _write_format_code(self, data):
# Write the <c:formatCode> element.
self._xml_data_element("c:formatCode", data)
def _write_pt_count(self, val):
# Write the <c:ptCount> element.
attributes = [("val", val)]
self._xml_empty_tag("c:ptCount", attributes)
def _write_pt(self, idx, value):
# Write the <c:pt> element.
if value is None:
return
attributes = [("idx", idx)]
self._xml_start_tag("c:pt", attributes)
# Write the c:v element.
self._write_v(value)
self._xml_end_tag("c:pt")
def _write_v(self, data):
# Write the <c:v> element.
self._xml_data_element("c:v", data)
def _write_protection(self):
# Write the <c:protection> element.
if not self.protection:
return
self._xml_empty_tag("c:protection")
def _write_d_pt(self, points):
# Write the <c:dPt> elements.
index = -1
if not points:
return
for point in points:
index += 1
if not point:
continue
self._write_d_pt_point(index, point)
def _write_d_pt_point(self, index, point):
# Write an individual <c:dPt> element.
self._xml_start_tag("c:dPt")
# Write the c:idx element.
self._write_idx(index)
# Write the c:spPr element.
self._write_sp_pr(point)
self._xml_end_tag("c:dPt")
def _write_d_lbls(self, labels):
# Write the <c:dLbls> element.
if not labels:
return
self._xml_start_tag("c:dLbls")
# Write the custom c:dLbl elements.
if labels.get("custom"):
self._write_custom_labels(labels, labels["custom"])
# Write the c:numFmt element.
if labels.get("num_format"):
self._write_data_label_number_format(labels["num_format"])
# Write the c:spPr element for the plotarea formatting.
self._write_sp_pr(labels)
# Write the data label font elements.
if labels.get("font"):
self._write_axis_font(labels["font"])
# Write the c:dLblPos element.
if labels.get("position"):
self._write_d_lbl_pos(labels["position"])
# Write the c:showLegendKey element.
if labels.get("legend_key"):
self._write_show_legend_key()
# Write the c:showVal element.
if labels.get("value"):
self._write_show_val()
# Write the c:showCatName element.
if labels.get("category"):
self._write_show_cat_name()
# Write the c:showSerName element.
if labels.get("series_name"):
self._write_show_ser_name()
# Write the c:showPercent element.
if labels.get("percentage"):
self._write_show_percent()
# Write the c:separator element.
if labels.get("separator"):
self._write_separator(labels["separator"])
# Write the c:showLeaderLines element.
if labels.get("leader_lines"):
self._write_show_leader_lines()
self._xml_end_tag("c:dLbls")
def _write_custom_labels(self, parent, labels):
# Write the <c:showLegendKey> element.
index = 0
for label in labels:
index += 1
if label is None:
continue
self._xml_start_tag("c:dLbl")
# Write the c:idx element.
self._write_idx(index - 1)
delete_label = label.get("delete")
if delete_label:
self._write_delete(1)
elif label.get("formula"):
self._write_custom_label_formula(label)
if parent.get("position"):
self._write_d_lbl_pos(parent["position"])
if parent.get("value"):
self._write_show_val()
if parent.get("category"):
self._write_show_cat_name()
if parent.get("series_name"):
self._write_show_ser_name()
elif label.get("value"):
self._write_custom_label_str(label)
if parent.get("position"):
self._write_d_lbl_pos(parent["position"])
if parent.get("value"):
self._write_show_val()
if parent.get("category"):
self._write_show_cat_name()
if parent.get("series_name"):
self._write_show_ser_name()
else:
self._write_custom_label_format_only(label)
self._xml_end_tag("c:dLbl")
def _write_custom_label_str(self, label):
# Write parts of the <c:dLbl> element for strings.
title = label.get("value")
font = label.get("font")
has_formatting = self._has_fill_formatting(label)
# Write the c:layout element.
self._write_layout(None, None)
self._xml_start_tag("c:tx")
# Write the c:rich element.
self._write_rich(title, font, False, not has_formatting)
self._xml_end_tag("c:tx")
# Write the c:spPr element.
self._write_sp_pr(label)
def _write_custom_label_formula(self, label):
# Write parts of the <c:dLbl> element for formulas.
formula = label.get("formula")
data_id = label.get("data_id")
data = None
if data_id is not None:
data = self.formula_data[data_id]
# Write the c:layout element.
self._write_layout(None, None)
self._xml_start_tag("c:tx")
# Write the c:strRef element.
self._write_str_ref(formula, data, "str")
self._xml_end_tag("c:tx")
# Write the data label formatting, if any.
self._write_custom_label_format_only(label)
def _write_custom_label_format_only(self, label):
# Write parts of the <c:dLbl> labels with changed formatting.
font = label.get("font")
has_formatting = self._has_fill_formatting(label)
if has_formatting:
self._write_sp_pr(label)
self._write_tx_pr(font)
elif font:
self._xml_empty_tag("c:spPr")
self._write_tx_pr(font)
def _write_show_legend_key(self):
# Write the <c:showLegendKey> element.
val = "1"
attributes = [("val", val)]
self._xml_empty_tag("c:showLegendKey", attributes)
def _write_show_val(self):
# Write the <c:showVal> element.
val = 1
attributes = [("val", val)]
self._xml_empty_tag("c:showVal", attributes)
def _write_show_cat_name(self):
# Write the <c:showCatName> element.
val = 1
attributes = [("val", val)]
self._xml_empty_tag("c:showCatName", attributes)
def _write_show_ser_name(self):
# Write the <c:showSerName> element.
val = 1
attributes = [("val", val)]
self._xml_empty_tag("c:showSerName", attributes)
def _write_show_percent(self):
# Write the <c:showPercent> element.
val = 1
attributes = [("val", val)]
self._xml_empty_tag("c:showPercent", attributes)
def _write_separator(self, data):
# Write the <c:separator> element.
self._xml_data_element("c:separator", data)
def _write_show_leader_lines(self):
# Write the <c:showLeaderLines> element.
#
# This is different for Pie/Doughnut charts. Other chart types only
# supported leader lines after Excel 2015 via an extension element.
#
uri = "{CE6537A1-D6FC-4f65-9D91-7224C49458BB}"
xmlns_c_15 = "http://schemas.microsoft.com/office/drawing/2012/chart"
attributes = [
("uri", uri),
("xmlns:c15", xmlns_c_15),
]
self._xml_start_tag("c:extLst")
self._xml_start_tag("c:ext", attributes)
self._xml_empty_tag("c15:showLeaderLines", [("val", 1)])
self._xml_end_tag("c:ext")
self._xml_end_tag("c:extLst")
def _write_d_lbl_pos(self, val):
# Write the <c:dLblPos> element.
attributes = [("val", val)]
self._xml_empty_tag("c:dLblPos", attributes)
def _write_delete(self, val):
# Write the <c:delete> element.
attributes = [("val", val)]
self._xml_empty_tag("c:delete", attributes)
def _write_c_invert_if_negative(self, invert):
# Write the <c:invertIfNegative> element.
val = 1
if not invert:
return
attributes = [("val", val)]
self._xml_empty_tag("c:invertIfNegative", attributes)
def _write_axis_font(self, font):
# Write the axis font elements.
if not font:
return
self._xml_start_tag("c:txPr")
self._write_a_body_pr(font.get("rotation"), None)
self._write_a_lst_style()
self._xml_start_tag("a:p")
self._write_a_p_pr_rich(font)
self._write_a_end_para_rpr()
self._xml_end_tag("a:p")
self._xml_end_tag("c:txPr")
def _write_a_latin(self, attributes):
# Write the <a:latin> element.
self._xml_empty_tag("a:latin", attributes)
def _write_d_table(self):
# Write the <c:dTable> element.
table = self.table
if not table:
return
self._xml_start_tag("c:dTable")
if table["horizontal"]:
# Write the c:showHorzBorder element.
self._write_show_horz_border()
if table["vertical"]:
# Write the c:showVertBorder element.
self._write_show_vert_border()
if table["outline"]:
# Write the c:showOutline element.
self._write_show_outline()
if table["show_keys"]:
# Write the c:showKeys element.
self._write_show_keys()
if table["font"]:
# Write the table font.
self._write_tx_pr(table["font"])
self._xml_end_tag("c:dTable")
def _write_show_horz_border(self):
# Write the <c:showHorzBorder> element.
attributes = [("val", 1)]
self._xml_empty_tag("c:showHorzBorder", attributes)
def _write_show_vert_border(self):
# Write the <c:showVertBorder> element.
attributes = [("val", 1)]
self._xml_empty_tag("c:showVertBorder", attributes)
def _write_show_outline(self):
# Write the <c:showOutline> element.
attributes = [("val", 1)]
self._xml_empty_tag("c:showOutline", attributes)
def _write_show_keys(self):
# Write the <c:showKeys> element.
attributes = [("val", 1)]
self._xml_empty_tag("c:showKeys", attributes)
def _write_error_bars(self, error_bars):
# Write the X and Y error bars.
if not error_bars:
return
if error_bars["x_error_bars"]:
self._write_err_bars("x", error_bars["x_error_bars"])
if error_bars["y_error_bars"]:
self._write_err_bars("y", error_bars["y_error_bars"])
def _write_err_bars(self, direction, error_bars):
# Write the <c:errBars> element.
if not error_bars:
return
self._xml_start_tag("c:errBars")
# Write the c:errDir element.
self._write_err_dir(direction)
# Write the c:errBarType element.
self._write_err_bar_type(error_bars["direction"])
# Write the c:errValType element.
self._write_err_val_type(error_bars["type"])
if not error_bars["endcap"]:
# Write the c:noEndCap element.
self._write_no_end_cap()
if error_bars["type"] == "stdErr":
# Don't need to write a c:errValType tag.
pass
elif error_bars["type"] == "cust":
# Write the custom error tags.
self._write_custom_error(error_bars)
else:
# Write the c:val element.
self._write_error_val(error_bars["value"])
# Write the c:spPr element.
self._write_sp_pr(error_bars)
self._xml_end_tag("c:errBars")
def _write_err_dir(self, val):
# Write the <c:errDir> element.
attributes = [("val", val)]
self._xml_empty_tag("c:errDir", attributes)
def _write_err_bar_type(self, val):
# Write the <c:errBarType> element.
attributes = [("val", val)]
self._xml_empty_tag("c:errBarType", attributes)
def _write_err_val_type(self, val):
# Write the <c:errValType> element.
attributes = [("val", val)]
self._xml_empty_tag("c:errValType", attributes)
def _write_no_end_cap(self):
# Write the <c:noEndCap> element.
attributes = [("val", 1)]
self._xml_empty_tag("c:noEndCap", attributes)
def _write_error_val(self, val):
# Write the <c:val> element for error bars.
attributes = [("val", val)]
self._xml_empty_tag("c:val", attributes)
def _write_custom_error(self, error_bars):
# Write the custom error bars tags.
if error_bars["plus_values"]:
# Write the c:plus element.
self._xml_start_tag("c:plus")
if isinstance(error_bars["plus_values"], list):
self._write_num_lit(error_bars["plus_values"])
else:
self._write_num_ref(
error_bars["plus_values"], error_bars["plus_data"], "num"
)
self._xml_end_tag("c:plus")
if error_bars["minus_values"]:
# Write the c:minus element.
self._xml_start_tag("c:minus")
if isinstance(error_bars["minus_values"], list):
self._write_num_lit(error_bars["minus_values"])
else:
self._write_num_ref(
error_bars["minus_values"], error_bars["minus_data"], "num"
)
self._xml_end_tag("c:minus")
def _write_num_lit(self, data):
# Write the <c:numLit> element for literal number list elements.
count = len(data)
# Write the c:numLit element.
self._xml_start_tag("c:numLit")
# Write the c:formatCode element.
self._write_format_code("General")
# Write the c:ptCount element.
self._write_pt_count(count)
for i in range(count):
token = data[i]
if token is None:
continue
try:
float(token)
except ValueError:
# Write non-numeric data as 0.
token = 0
# Write the c:pt element.
self._write_pt(i, token)
self._xml_end_tag("c:numLit")
def _write_up_down_bars(self):
# Write the <c:upDownBars> element.
up_down_bars = self.up_down_bars
if up_down_bars is None:
return
self._xml_start_tag("c:upDownBars")
# Write the c:gapWidth element.
self._write_gap_width(150)
# Write the c:upBars element.
self._write_up_bars(up_down_bars.get("up"))
# Write the c:downBars element.
self._write_down_bars(up_down_bars.get("down"))
self._xml_end_tag("c:upDownBars")
def _write_gap_width(self, val):
# Write the <c:gapWidth> element.
if val is None:
return
attributes = [("val", val)]
self._xml_empty_tag("c:gapWidth", attributes)
def _write_up_bars(self, bar_format):
# Write the <c:upBars> element.
if bar_format["line"] and bar_format["line"]["defined"]:
self._xml_start_tag("c:upBars")
# Write the c:spPr element.
self._write_sp_pr(bar_format)
self._xml_end_tag("c:upBars")
else:
self._xml_empty_tag("c:upBars")
def _write_down_bars(self, bar_format):
# Write the <c:downBars> element.
if bar_format["line"] and bar_format["line"]["defined"]:
self._xml_start_tag("c:downBars")
# Write the c:spPr element.
self._write_sp_pr(bar_format)
self._xml_end_tag("c:downBars")
else:
self._xml_empty_tag("c:downBars")
def _write_disp_units(self, units, display):
# Write the <c:dispUnits> element.
if not units:
return
attributes = [("val", units)]
self._xml_start_tag("c:dispUnits")
self._xml_empty_tag("c:builtInUnit", attributes)
if display:
self._xml_start_tag("c:dispUnitsLbl")
self._xml_empty_tag("c:layout")
self._xml_end_tag("c:dispUnitsLbl")
self._xml_end_tag("c:dispUnits")
def _write_a_grad_fill(self, gradient):
# Write the <a:gradFill> element.
attributes = [("flip", "none"), ("rotWithShape", "1")]
if gradient["type"] == "linear":
attributes = []
self._xml_start_tag("a:gradFill", attributes)
# Write the a:gsLst element.
self._write_a_gs_lst(gradient)
if gradient["type"] == "linear":
# Write the a:lin element.
self._write_a_lin(gradient["angle"])
else:
# Write the a:path element.
self._write_a_path(gradient["type"])
# Write the a:tileRect element.
self._write_a_tile_rect(gradient["type"])
self._xml_end_tag("a:gradFill")
def _write_a_gs_lst(self, gradient):
# Write the <a:gsLst> element.
positions = gradient["positions"]
colors = gradient["colors"]
self._xml_start_tag("a:gsLst")
for i, color in enumerate(colors):
pos = int(positions[i] * 1000)
attributes = [("pos", pos)]
self._xml_start_tag("a:gs", attributes)
# Write the a:srgbClr element.
color = _get_rgb_color(color)
self._write_a_srgb_clr(color)
self._xml_end_tag("a:gs")
self._xml_end_tag("a:gsLst")
def _write_a_lin(self, angle):
# Write the <a:lin> element.
angle = int(60000 * angle)
attributes = [
("ang", angle),
("scaled", "0"),
]
self._xml_empty_tag("a:lin", attributes)
def _write_a_path(self, gradient_type):
# Write the <a:path> element.
attributes = [("path", gradient_type)]
self._xml_start_tag("a:path", attributes)
# Write the a:fillToRect element.
self._write_a_fill_to_rect(gradient_type)
self._xml_end_tag("a:path")
def _write_a_fill_to_rect(self, gradient_type):
# Write the <a:fillToRect> element.
if gradient_type == "shape":
attributes = [
("l", "50000"),
("t", "50000"),
("r", "50000"),
("b", "50000"),
]
else:
attributes = [
("l", "100000"),
("t", "100000"),
]
self._xml_empty_tag("a:fillToRect", attributes)
def _write_a_tile_rect(self, gradient_type):
# Write the <a:tileRect> element.
if gradient_type == "shape":
attributes = []
else:
attributes = [
("r", "-100000"),
("b", "-100000"),
]
self._xml_empty_tag("a:tileRect", attributes)
def _write_a_patt_fill(self, pattern):
# Write the <a:pattFill> element.
attributes = [("prst", pattern["pattern"])]
self._xml_start_tag("a:pattFill", attributes)
# Write the a:fgClr element.
self._write_a_fg_clr(pattern["fg_color"])
# Write the a:bgClr element.
self._write_a_bg_clr(pattern["bg_color"])
self._xml_end_tag("a:pattFill")
def _write_a_fg_clr(self, color):
# Write the <a:fgClr> element.
color = _get_rgb_color(color)
self._xml_start_tag("a:fgClr")
# Write the a:srgbClr element.
self._write_a_srgb_clr(color)
self._xml_end_tag("a:fgClr")
def _write_a_bg_clr(self, color):
# Write the <a:bgClr> element.
color = _get_rgb_color(color)
self._xml_start_tag("a:bgClr")
# Write the a:srgbClr element.
self._write_a_srgb_clr(color)
self._xml_end_tag("a:bgClr")
Reference in New Issue View Git Blame Copy Permalink