File Coverage

blib/lib/Excel/Writer/XLSX/Chart.pm

Criterion	Covered	Total	%
statement	1887	1964	96.0
branch	592	668	88.6
condition	120	157	76.4
subroutine	217	218	99.5
pod	18	20	90.0
total	2834	3027	93.6

package Excel::Writer::XLSX::Chart;

###############################################################################
#
# Chart - A class for writing Excel Charts.
#
#
# Used in conjunction with Excel::Writer::XLSX.
#
# Copyright 2000-2019, John McNamara, [e-mail]
#
# Documentation after __END__
#

# perltidy with the following options: -mbl=2 -pt=0 -nola

use 5.008002;
use strict;
use warnings;
use Carp;
use Excel::Writer::XLSX::Format;
use Excel::Writer::XLSX::Package::XMLwriter;
use Excel::Writer::XLSX::Utility qw(xl_cell_to_rowcol
  xl_rowcol_to_cell
  xl_col_to_name xl_range
  xl_range_formula
  quote_sheetname );

our @ISA     = qw(Excel::Writer::XLSX::Package::XMLwriter);
our $VERSION = '1.03';


###############################################################################
#
# factory()
#
# Factory method for returning chart objects based on their class type.
#
sub factory {

    my $current_class  = shift;
    my $chart_subclass = shift;

    $chart_subclass = ucfirst lc $chart_subclass;

    my $module = "Excel::Writer::XLSX::Chart::" . $chart_subclass;

    eval "require $module";

    # TODO. Need to re-raise this error from Workbook::add_chart().
    die "Chart type '$chart_subclass' not supported in add_chart()\n" if $@;

    my $fh = undef;
    return $module->new( $fh, @_ );
}


###############################################################################
#
# new()
#
# Default constructor for sub-classes.
#
sub new {

    my $class = shift;
    my $fh    = shift;
    my $self  = Excel::Writer::XLSX::Package::XMLwriter->new( $fh );

    $self->{_subtype}           = shift;
    $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} = 0;
    $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_hidden_data}  = 0;
    $self->{_show_crosses}      = 1;
    $self->{_width}             = 480;
    $self->{_height}            = 288;
    $self->{_x_scale}           = 1;
    $self->{_y_scale}           = 1;
    $self->{_x_offset}          = 0;
    $self->{_y_offset}          = 0;
    $self->{_table}             = undef;
    $self->{_smooth_allowed}    = 0;
    $self->{_cross_between}     = 'between';
    $self->{_date_category}     = 0;
    $self->{_already_inserted}  = 0;
    $self->{_combined}          = undef;
    $self->{_is_secondary}      = 0;

    $self->{_label_positions}          = {};
    $self->{_label_position_default}   = '';

    bless $self, $class;
    $self->_set_default_properties();
    return $self;
}


###############################################################################
#
# _assemble_xml_file()
#
# Assemble and write the XML file.
#
sub _assemble_xml_file {

    my $self = shift;

    $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.
    $self->_write_print_settings() if $self->{_embedded};

    # Close the worksheet tag.
    $self->xml_end_tag( 'c:chartSpace' );

    # Close the XML writer filehandle.
    $self->xml_get_fh()->close();
}


###############################################################################
#
# Public methods.
#
###############################################################################


###############################################################################
#
# add_series()
#
# Add a series and it's properties to a chart.
#
sub add_series {

    my $self = shift;
    my %arg  = @_;

    # Check that the required input has been specified.
    if ( !exists $arg{values} ) {
        croak "Must specify 'values' in add_series()";
    }

    if ( $self->{_requires_category} && !exists $arg{categories} ) {
        croak "Must specify 'categories' in add_series() for this chart type";
    }

    if ( @{ $self->{_series} } == 255 ) {
        carp "The maxiumn number of series that can be added to an "
          . "Excel Chart is 255";
        return
    }

    # Convert aref params into a formula string.
    my $values     = $self->_aref_to_formula( $arg{values} );
    my $categories = $self->_aref_to_formula( $arg{categories} );

    # Switch name and name_formula parameters if required.
    my ( $name, $name_formula ) =
      $self->_process_names( $arg{name}, $arg{name_formula} );

    # Get an id for the data equivalent to the range formula.
    my $cat_id  = $self->_get_data_id( $categories,   $arg{categories_data} );
    my $val_id  = $self->_get_data_id( $values,       $arg{values_data} );
    my $name_id = $self->_get_data_id( $name_formula, $arg{name_data} );

    # Set the line properties for the series.
    my $line = $self->_get_line_properties( $arg{line} );

    # Allow 'border' as a synonym for 'line' in bar/column style charts.
    if ( $arg{border} ) {
        $line = $self->_get_line_properties( $arg{border} );
    }

    # Set the fill properties for the series.
    my $fill = $self->_get_fill_properties( $arg{fill} );

    # Set the pattern properties for the series.
    my $pattern = $self->_get_pattern_properties( $arg{pattern} );

    # Set the gradient fill properties for the series.
    my $gradient = $self->_get_gradient_properties( $arg{gradient} );

    # Pattern fill overrides solid fill.
    if ( $pattern ) {
        $fill = undef;
    }

    # Gradient fill overrides solid and pattern fills.
    if ( $gradient ) {
        $pattern = undef;
        $fill    = undef;
    }

    # Set the marker properties for the series.
    my $marker = $self->_get_marker_properties( $arg{marker} );

    # Set the trendline properties for the series.
    my $trendline = $self->_get_trendline_properties( $arg{trendline} );

    # Set the line smooth property for the series.
    my $smooth = $arg{smooth};

    # Set the error bars properties for the series.
    my $y_error_bars = $self->_get_error_bars_properties( $arg{y_error_bars} );
    my $x_error_bars = $self->_get_error_bars_properties( $arg{x_error_bars} );

    # Set the point properties for the series.
    my $points = $self->_get_points_properties($arg{points});

    # Set the labels properties for the series.
    my $labels = $self->_get_labels_properties( $arg{data_labels} );

    # Set the "invert if negative" fill property.
    my $invert_if_neg = $arg{invert_if_negative};

    # Set the secondary axis properties.
    my $x2_axis = $arg{x2_axis};
    my $y2_axis = $arg{y2_axis};

    # Store secondary status for combined charts.
    if ($x2_axis || $y2_axis) {
        $self->{_is_secondary} = 1;
    }

    # Set the gap for Bar/Column charts.
    if ( defined $arg{gap} ) {
        if ($y2_axis) {
            $self->{_series_gap_2} = $arg{gap};
        }
        else {
            $self->{_series_gap_1} = $arg{gap};
        }
    }

    # Set the overlap for Bar/Column charts.
    if ( defined $arg{overlap} ) {
        if ($y2_axis) {
            $self->{_series_overlap_2} = $arg{overlap};
        }
        else {
            $self->{_series_overlap_1} = $arg{overlap};
        }
    }

    # Add the user supplied data to the internal structures.
    %arg = (
        _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,
        _smooth        => $smooth,
        _labels        => $labels,
        _invert_if_neg => $invert_if_neg,
        _x2_axis       => $x2_axis,
        _y2_axis       => $y2_axis,
        _points        => $points,
        _error_bars =>
          { _x_error_bars => $x_error_bars, _y_error_bars => $y_error_bars },
    );


    push @{ $self->{_series} }, \%arg;
}


###############################################################################
#
# set_x_axis()
#
# Set the properties of the X-axis.
#
sub set_x_axis {

    my $self = shift;

    my $axis = $self->_convert_axis_args( $self->{_x_axis}, @_ );

    $self->{_x_axis} = $axis;
}


###############################################################################
#
# set_y_axis()
#
# Set the properties of the Y-axis.
#
sub set_y_axis {

    my $self = shift;

    my $axis = $self->_convert_axis_args( $self->{_y_axis}, @_ );

    $self->{_y_axis} = $axis;
}


###############################################################################
#
# set_x2_axis()
#
# Set the properties of the secondary X-axis.
#
sub set_x2_axis {

    my $self = shift;

    my $axis = $self->_convert_axis_args( $self->{_x2_axis}, @_ );

    $self->{_x2_axis} = $axis;
}


###############################################################################
#
# set_y2_axis()
#
# Set the properties of the secondary Y-axis.
#
sub set_y2_axis {

    my $self = shift;

    my $axis = $self->_convert_axis_args( $self->{_y2_axis}, @_ );

    $self->{_y2_axis} = $axis;
}


###############################################################################
#
# set_title()
#
# Set the properties of the chart title.
#
sub set_title {

    my $self = shift;
    my %arg  = @_;

    my ( $name, $name_formula ) =
      $self->_process_names( $arg{name}, $arg{name_formula} );

    my $data_id = $self->_get_data_id( $name_formula, $arg{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( $arg{name_font} );

    # Set the title layout.
    $self->{_title_layout} = $self->_get_layout_properties( $arg{layout}, 1 );

    # Set the title overlay option.
    $self->{_title_overlay} = $arg{overlay};

    # Set the no automatic title option.
    $self->{_title_none} = $arg{none};
}


###############################################################################
#
# set_legend()
#
# Set the properties of the chart legend.
#
sub set_legend {

    my $self = shift;

    # Convert the user defined properties to internal properties.
    $self->{_legend} = $self->_get_legend_properties( @_ );
}


###############################################################################
#
# set_plotarea()
#
# Set the properties of the chart plotarea.
#
sub set_plotarea {

    my $self = shift;

    # Convert the user defined properties to internal properties.
    $self->{_plotarea} = $self->_get_area_properties( @_ );
}


###############################################################################
#
# set_chartarea()
#
# Set the properties of the chart chartarea.
#
sub set_chartarea {

    my $self = shift;

    # Convert the user defined properties to internal properties.
    $self->{_chartarea} = $self->_get_area_properties( @_ );
}


###############################################################################
#
# set_style()
#
# Set on of the 48 built-in Excel chart styles. The default style is 2.
#
sub set_style {

    my $self = shift;
    my $style_id = defined $_[0] ? $_[0] : 2;

    if ( $style_id < 0 || $style_id > 48 ) {
        $style_id = 2;
    }

    $self->{_style_id} = $style_id;
}


###############################################################################
#
# show_blanks_as()
#
# Set the option for displaying blank data in a chart. The default is 'gap'.
#
sub show_blanks_as {

    my $self   = shift;
    my $option = shift;

    return unless $option;

    my %valid = (
        gap  => 1,
        zero => 1,
        span => 1,

    );

    if ( !exists $valid{$option} ) {
        warn "Unknown show_blanks_as() option '$option'\n";
        return;
    }

    $self->{_show_blanks} = $option;
}


###############################################################################
#
# show_hidden_data()
#
# Display data in hidden rows or columns.
#
sub show_hidden_data {

    my $self = shift;

    $self->{_show_hidden_data} = 1;
}


###############################################################################
#
# set_size()
#
# Set dimensions or scale for the chart.
#
sub set_size {

    my $self = shift;
    my %args = @_;

    $self->{_width}    = $args{width}    if $args{width};
    $self->{_height}   = $args{height}   if $args{height};
    $self->{_x_scale}  = $args{x_scale}  if $args{x_scale};
    $self->{_y_scale}  = $args{y_scale}  if $args{y_scale};
    $self->{_x_offset} = $args{x_offset} if $args{x_offset};
    $self->{_y_offset} = $args{y_offset} if $args{y_offset};

}

# Backward compatibility with poorly chosen method name.
*size = *set_size;


###############################################################################
#
# set_table()
#
# Set properties for an axis data table.
#
sub set_table {

    my $self = shift;
    my %args = @_;

    my %table = (
        _horizontal => 1,
        _vertical   => 1,
        _outline    => 1,
        _show_keys  => 0,
    );

    $table{_horizontal} = $args{horizontal} if defined $args{horizontal};
    $table{_vertical}   = $args{vertical}   if defined $args{vertical};
    $table{_outline}    = $args{outline}    if defined $args{outline};
    $table{_show_keys}  = $args{show_keys}  if defined $args{show_keys};
    $table{_font}       = $self->_convert_font_args( $args{font} );

    $self->{_table} = \%table;
}


###############################################################################
#
# set_up_down_bars()
#
# Set properties for the chart up-down bars.
#
sub set_up_down_bars {

    my $self = shift;
    my %args = @_;

    # Map border to line.
    if ( defined $args{up}->{border} ) {
        $args{up}->{line} = $args{up}->{border};
    }
    if ( defined $args{down}->{border} ) {
        $args{down}->{line} = $args{down}->{border};
    }

    # Set the up and down bar properties.
    my $up_line   = $self->_get_line_properties( $args{up}->{line} );
    my $down_line = $self->_get_line_properties( $args{down}->{line} );
    my $up_fill   = $self->_get_fill_properties( $args{up}->{fill} );
    my $down_fill = $self->_get_fill_properties( $args{down}->{fill} );

    $self->{_up_down_bars} = {
        _up => {
            _line => $up_line,
            _fill => $up_fill,
        },
        _down => {
            _line => $down_line,
            _fill => $down_fill,
        },
    };
}


###############################################################################
#
# set_drop_lines()
#
# Set properties for the chart drop lines.
#
sub set_drop_lines {

    my $self = shift;
    my %args = @_;

    # Set the drop line properties.
    my $line = $self->_get_line_properties( $args{line} );

    $self->{_drop_lines} = { _line => $line };
}


###############################################################################
#
# set_high_low_lines()
#
# Set properties for the chart high-low lines.
#
sub set_high_low_lines {

    my $self = shift;
    my %args = @_;

    # Set the drop line properties.
    my $line = $self->_get_line_properties( $args{line} );

    $self->{_hi_low_lines} = { _line => $line };
}


###############################################################################
#
# combine()
#
# Add another chart to create a combined chart.
#
sub combine {

    my $self  = shift;
    my $chart = shift;

    $self->{_combined} = $chart;
}


###############################################################################
#
# Internal methods. The following section of methods are used for the internal
# structuring of the Chart object and file format.
#
###############################################################################


###############################################################################
#
# _convert_axis_args()
#
# Convert user defined axis values into private hash values.
#
sub _convert_axis_args {

    my $self = shift;
    my $axis = shift;
    my %arg  = ( %{ $axis->{_defaults} }, @_ );

    my ( $name, $name_formula ) =
      $self->_process_names( $arg{name}, $arg{name_formula} );

    my $data_id = $self->_get_data_id( $name_formula, $arg{data} );

    $axis = {
        _defaults          => $axis->{_defaults},
        _name              => $name,
        _formula           => $name_formula,
        _data_id           => $data_id,
        _reverse           => $arg{reverse},
        _min               => $arg{min},
        _max               => $arg{max},
        _minor_unit        => $arg{minor_unit},
        _major_unit        => $arg{major_unit},
        _minor_unit_type   => $arg{minor_unit_type},
        _major_unit_type   => $arg{major_unit_type},
        _log_base          => $arg{log_base},
        _crossing          => $arg{crossing},
        _position_axis     => $arg{position_axis},
        _position          => $arg{position},
        _label_position    => $arg{label_position},
        _label_align       => $arg{label_align},
        _num_format        => $arg{num_format},
        _num_format_linked => $arg{num_format_linked},
        _interval_unit     => $arg{interval_unit},
        _interval_tick     => $arg{interval_tick},
        _visible           => defined $arg{visible} ? $arg{visible} : 1,
        _text_axis         => 0,
    };

    # Map major_gridlines properties.
    if ( $arg{major_gridlines} && $arg{major_gridlines}->{visible} ) {
        $axis->{_major_gridlines} =
          $self->_get_gridline_properties( $arg{major_gridlines} );
    }

    # Map minor_gridlines properties.
    if ( $arg{minor_gridlines} && $arg{minor_gridlines}->{visible} ) {
        $axis->{_minor_gridlines} =
          $self->_get_gridline_properties( $arg{minor_gridlines} );
    }

    # Convert the display units.
    $axis->{_display_units} = $self->_get_display_units( $arg{display_units} );
    if ( defined $arg{display_units_visible} ) {
        $axis->{_display_units_visible} = $arg{display_units_visible};
    }
    else {
        $axis->{_display_units_visible} = 1;
    }

    # Only use the first letter of bottom, top, left or right.
    if ( defined $axis->{_position} ) {
        $axis->{_position} = substr lc $axis->{_position}, 0, 1;
    }

    # Set the position for a category axis on or between the tick marks.
    if ( defined $axis->{_position_axis} ) {
        if ( $axis->{_position_axis} eq 'on_tick' ) {
            $axis->{_position_axis} = 'midCat';
        }
        elsif ( $axis->{_position_axis} eq 'between' ) {

            # Doesn't need to be modified.
        }
        else {
            # Otherwise use the default value.
            $axis->{_position_axis} = undef;
        }
    }

    # Set the category axis as a date axis.
    if ( $arg{date_axis} ) {
        $self->{_date_category} = 1;
    }

    # Set the category axis as a text axis.
    if ( $arg{text_axis} ) {
        $self->{_date_category} = 0;
        $axis->{_text_axis} = 1;
    }


    # Set the font properties if present.
    $axis->{_num_font}  = $self->_convert_font_args( $arg{num_font} );
    $axis->{_name_font} = $self->_convert_font_args( $arg{name_font} );

    # Set the axis name layout.
    $axis->{_layout} = $self->_get_layout_properties( $arg{name_layout}, 1 );

    # Set the line properties for the axis.
    $axis->{_line} = $self->_get_line_properties( $arg{line} );

    # Set the fill properties for the axis.
    $axis->{_fill} = $self->_get_fill_properties( $arg{fill} );

    # Set the tick marker types.
    $axis->{_minor_tick_mark} = $self->_get_tick_type($arg{minor_tick_mark});
    $axis->{_major_tick_mark} = $self->_get_tick_type($arg{major_tick_mark});


    return $axis;
}


###############################################################################
#
# _convert_fonts_args()
#
# Convert user defined font values into private hash values.
#
sub _convert_font_args {

    my $self = shift;
    my $args = shift;

    return unless $args;

    my $font = {
        _name         => $args->{name},
        _color        => $args->{color},
        _size         => $args->{size},
        _bold         => $args->{bold},
        _italic       => $args->{italic},
        _underline    => $args->{underline},
        _pitch_family => $args->{pitch_family},
        _charset      => $args->{charset},
        _baseline     => $args->{baseline} || 0,
        _rotation     => $args->{rotation},
    };

    # Convert font size units.
    $font->{_size} *= 100 if $font->{_size};

    # Convert rotation into 60,000ths of a degree.
    if ( $font->{_rotation} ) {
        $font->{_rotation} = 60_000 * int( $font->{_rotation} );
    }

    return $font;
}


###############################################################################
#
# _aref_to_formula()
#
# Convert and aref of row col values to a range formula.
#
sub _aref_to_formula {

    my $self = shift;
    my $data = shift;

    # If it isn't an array ref it is probably a formula already.
    return $data if !ref $data;

    my $formula = xl_range_formula( @$data );

    return $formula;
}


###############################################################################
#
# _process_names()
#
# Switch name and name_formula parameters if required.
#
sub _process_names {

    my $self         = shift;
    my $name         = shift;
    my $name_formula = shift;

    if ( defined $name ) {

        if ( ref $name eq 'ARRAY' ) {
            my $cell = xl_rowcol_to_cell( $name->[1], $name->[2], 1, 1 );
            $name_formula = quote_sheetname( $name->[0] ) . '!' . $cell;
            $name         = '';
        }
        elsif ( $name =~ m/^=[^!]+!\$/ ) {

            # Name looks like a formula, use it to set name_formula.
            $name_formula = $name;
            $name         = '';
        }
    }

    return ( $name, $name_formula );
}


###############################################################################
#
# _get_data_type()
#
# Find the overall type of the data associated with a series.
#
# TODO. Need to handle date type.
#
sub _get_data_type {

    my $self = shift;
    my $data = shift;

    # Check for no data in the series.
    return 'none' if !defined $data;
    return 'none' if @$data == 0;

    if (ref $data->[0] eq 'ARRAY') {
        return 'multi_str'
    }

    # If the token isn't a number assume it is a string.
    for my $token ( @$data ) {
        next if !defined $token;
        return 'str'
          if $token !~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
    }

    # The series data was all numeric.
    return 'num';
}


###############################################################################
#
# _get_data_id()
#
# 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 in Workbook::_add_chart_data()
#
sub _get_data_id {

    my $self    = shift;
    my $formula = shift;
    my $data    = shift;
    my $id;

    # Ignore series without a range formula.
    return unless $formula;

    # Strip the leading '=' from the formula.
    $formula =~ s/^=//;

    # Store the data id in a hash keyed by the formula and store the data
    # in a separate array with the same id.
    if ( !exists $self->{_formula_ids}->{$formula} ) {

        # Haven't seen this formula before.
        $id = @{ $self->{_formula_data} };

        push @{ $self->{_formula_data} }, $data;
        $self->{_formula_ids}->{$formula} = $id;
    }
    else {

        # Formula already seen. Return existing id.
        $id = $self->{_formula_ids}->{$formula};

        # Store user defined data if it isn't already there.
        if ( !defined $self->{_formula_data}->[$id] ) {
            $self->{_formula_data}->[$id] = $data;
        }
    }

    return $id;
}


###############################################################################
#
# _get_color()
#
# Convert the user specified colour index or string to a rgb colour.
#
sub _get_color {

    my $self  = shift;
    my $color = shift;

    # Convert a HTML style #RRGGBB color.
    if ( defined $color and $color =~ /^#[0-9a-fA-F]{6}$/ ) {
        $color =~ s/^#//;
        return uc $color;
    }

    my $index = &Excel::Writer::XLSX::Format::_get_color( $color );

    # Set undefined colors to black.
    if ( !$index ) {
        $index = 0x08;
        warn "Unknown color '$color' used in chart formatting. "
          . "Converting to black.\n";
    }

    return $self->_get_palette_color( $index );
}


###############################################################################
#
# _get_palette_color()
#
# Convert from an Excel internal colour index to a XML style #RRGGBB index
# based on the default or user defined values in the Workbook palette.
# Note: This version doesn't add an alpha channel.
#
sub _get_palette_color {

    my $self    = shift;
    my $index   = shift;
    my $palette = $self->{_palette};

    # Adjust the colour index.
    $index -= 8;

    # Palette is passed in from the Workbook class.
    my @rgb = @{ $palette->[$index] };

    return sprintf "%02X%02X%02X", @rgb[0, 1, 2];
}


###############################################################################
#
# _get_swe_line_pattern()
#
# Get the Spreadsheet::WriteExcel line pattern for backward compatibility.
#
sub _get_swe_line_pattern {

    my $self    = shift;
    my $value   = lc shift;
    my $default = 'solid';
    my $pattern;

    my %patterns = (
        0              => 'solid',
        1              => 'dash',
        2              => 'dot',
        3              => 'dash_dot',
        4              => 'long_dash_dot_dot',
        5              => 'none',
        6              => 'solid',
        7              => 'solid',
        8              => 'solid',
        'solid'        => 'solid',
        'dash'         => 'dash',
        'dot'          => 'dot',
        'dash-dot'     => 'dash_dot',
        'dash-dot-dot' => 'long_dash_dot_dot',
        'none'         => 'none',
        'dark-gray'    => 'solid',
        'medium-gray'  => 'solid',
        'light-gray'   => 'solid',
    );

    if ( exists $patterns{$value} ) {
        $pattern = $patterns{$value};
    }
    else {
        $pattern = $default;
    }

    return $pattern;
}


###############################################################################
#
# _get_swe_line_weight()
#
# Get the Spreadsheet::WriteExcel line weight for backward compatibility.
#
sub _get_swe_line_weight {

    my $self    = shift;
    my $value   = lc shift;
    my $default = 1;
    my $weight;

    my %weights = (
        1          => 0.25,
        2          => 1,
        3          => 2,
        4          => 3,
        'hairline' => 0.25,
        'narrow'   => 1,
        'medium'   => 2,
        'wide'     => 3,
    );

    if ( exists $weights{$value} ) {
        $weight = $weights{$value};
    }
    else {
        $weight = $default;
    }

    return $weight;
}


###############################################################################
#
# _get_line_properties()
#
# Convert user defined line properties to the structure required internally.
#
sub _get_line_properties {

    my $self = shift;
    my $line = shift;

    return { _defined => 0 } unless $line;

    # Copy the user supplied properties.
    $line = { %$line };

    my %dash_types = (
        solid               => 'solid',
        round_dot           => 'sysDot',
        square_dot          => 'sysDash',
        dash                => 'dash',
        dash_dot            => 'dashDot',
        long_dash           => 'lgDash',
        long_dash_dot       => 'lgDashDot',
        long_dash_dot_dot   => 'lgDashDotDot',
        dot                 => 'dot',
        system_dash_dot     => 'sysDashDot',
        system_dash_dot_dot => 'sysDashDotDot',
    );

    # Check the dash type.
    my $dash_type = $line->{dash_type};

    if ( defined $dash_type ) {
        if ( exists $dash_types{$dash_type} ) {
            $line->{dash_type} = $dash_types{$dash_type};
        }
        else {
            warn "Unknown dash type '$dash_type'\n";
            return;
        }
    }

    $line->{_defined} = 1;

    return $line;
}


###############################################################################
#
# _get_fill_properties()
#
# Convert user defined fill properties to the structure required internally.
#
sub _get_fill_properties {

    my $self = shift;
    my $fill = shift;

    return { _defined => 0 } unless $fill;

    $fill->{_defined} = 1;

    return $fill;
}


###############################################################################
#
# _get_pattern_properties()
#
# Convert user defined pattern properties to the structure required internally.
#
sub _get_pattern_properties {

    my $self    = shift;
    my $args    = shift;
    my $pattern = {};

    return unless $args;

    # Check the pattern type is present.
    if ( !$args->{pattern} ) {
        carp "Pattern must include 'pattern'";
        return;
    }

    # Check the foreground color is present.
    if ( !$args->{fg_color} ) {
        carp "Pattern must include 'fg_color'";
        return;
    }

    my %types = (
        'percent_5'                 => 'pct5',
        'percent_10'                => 'pct10',
        'percent_20'                => 'pct20',
        'percent_25'                => 'pct25',
        'percent_30'                => 'pct30',
        'percent_40'                => 'pct40',

        'percent_50'                => 'pct50',
        'percent_60'                => 'pct60',
        'percent_70'                => 'pct70',
        'percent_75'                => 'pct75',
        'percent_80'                => 'pct80',
        'percent_90'                => 'pct90',

        'light_downward_diagonal'   => 'ltDnDiag',
        'light_upward_diagonal'     => 'ltUpDiag',
        'dark_downward_diagonal'    => 'dkDnDiag',
        'dark_upward_diagonal'      => 'dkUpDiag',
        'wide_downward_diagonal'    => 'wdDnDiag',
        'wide_upward_diagonal'      => 'wdUpDiag',

        'light_vertical'            => 'ltVert',
        'light_horizontal'          => 'ltHorz',
        'narrow_vertical'           => 'narVert',
        'narrow_horizontal'         => 'narHorz',
        'dark_vertical'             => 'dkVert',
        'dark_horizontal'           => 'dkHorz',

        'dashed_downward_diagonal'  => 'dashDnDiag',
        'dashed_upward_diagonal'    => 'dashUpDiag',
        'dashed_horizontal'         => 'dashHorz',
        'dashed_vertical'           => 'dashVert',
        'small_confetti'            => 'smConfetti',
        'large_confetti'            => 'lgConfetti',

        'zigzag'                    => 'zigZag',
        'wave'                      => 'wave',
        'diagonal_brick'            => 'diagBrick',
        'horizontal_brick'          => 'horzBrick',
        'weave'                     => 'weave',
        'plaid'                     => 'plaid',

        'divot'                     => 'divot',
        'dotted_grid'               => 'dotGrid',
        'dotted_diamond'            => 'dotDmnd',
        'shingle'                   => 'shingle',
        'trellis'                   => 'trellis',
        'sphere'                    => 'sphere',

        'small_grid'                => 'smGrid',
        'large_grid'                => 'lgGrid',
        'small_check'               => 'smCheck',
        'large_check'               => 'lgCheck',
        'outlined_diamond'          => 'openDmnd',
        'solid_diamond'             => 'solidDmnd',
    );

    # Check for valid types.
    my $pattern_type = $args->{pattern};

    if ( exists $types{$pattern_type} ) {
        $pattern->{pattern} = $types{$pattern_type};
    }
    else {
        carp "Unknown pattern type '$pattern_type'";
        return;
    }

    # Specify a default background color.
    if ( !$args->{bg_color} ) {
        $pattern->{bg_color} = '#FFFFFF';
    }
    else {
        $pattern->{bg_color} = $args->{bg_color};
    }

    $pattern->{fg_color} = $args->{fg_color};

    return $pattern;
}


###############################################################################
#
# _get_gradient_properties()
#
# Convert user defined gradient to the structure required internally.
#
sub _get_gradient_properties {

    my $self     = shift;
    my $args     = shift;
    my $gradient = {};

    my %types    = (
        linear      => 'linear',
        radial      => 'circle',
        rectangular => 'rect',
        path        => 'shape'
    );

    return unless $args;

    # Check the colors array exists and is valid.
    if ( !$args->{colors} || ref $args->{colors} ne 'ARRAY' ) {
        carp "Gradient must include colors array";
        return;
    }

    # Check the colors array has the required number of entries.
    if ( @{ $args->{colors} } < 2 ) {
        carp "Gradient colors array must at least 2 values";
        return;
    }

    $gradient->{_colors} = $args->{colors};

    if ( $args->{positions} ) {

        # Check the positions array has the right number of entries.
        if ( @{ $args->{positions} } != @{ $args->{colors} } ) {
            carp "Gradient positions not equal to number of colors";
            return;
        }

        # Check the positions are in the correct range.
        for my $pos ( @{ $args->{positions} } ) {
            if ( $pos < 0 || $pos > 100 ) {
                carp "Gradient position '", $pos,
                  "' must be in range 0 <= pos <= 100";
                return;
            }
        }

        $gradient->{_positions} = $args->{positions};
    }
    else {
        # Use the default gradient positions.
        if ( @{ $args->{colors} } == 2 ) {
            $gradient->{_positions} = [ 0, 100 ];
        }
        elsif ( @{ $args->{colors} } == 3 ) {
            $gradient->{_positions} = [ 0, 50, 100 ];
        }
        elsif ( @{ $args->{colors} } == 4 ) {
            $gradient->{_positions} = [ 0, 33, 66, 100 ];
        }
        else {
            carp "Must specify gradient positions";
            return;
        }
    }

    # Set the gradient angle.
    if ( defined $args->{angle} ) {
        my $angle = $args->{angle};

        if ( $angle < 0 || $angle > 359.9 ) {
            carp "Gradient angle '", $angle,
              "' must be in range 0 <= pos < 360";
            return;
        }
        $gradient->{_angle} = $angle;
    }
    else {
        $gradient->{_angle} = 90;
    }

    # Set the gradient type.
    if ( defined $args->{type} ) {
        my $type = $args->{type};

        if ( !exists $types{$type} ) {
            carp "Unknown gradient type '", $type, "'";
            return;
        }
        $gradient->{_type} = $types{$type};
    }
    else {
        $gradient->{_type} = 'linear';
    }

    return $gradient;
}


###############################################################################
#
# _get_marker_properties()
#
# Convert user defined marker properties to the structure required internally.
#
sub _get_marker_properties {

    my $self   = shift;
    my $marker = shift;

    return if !$marker && ref $marker ne 'HASH';

    # Copy the user supplied properties.
    $marker = { %$marker };

    my %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.
    my $marker_type = $marker->{type};

    if ( defined $marker_type ) {
        if ( $marker_type eq 'automatic' ) {
            $marker->{automatic} = 1;
        }

        if ( exists $types{$marker_type} ) {
            $marker->{type} = $types{$marker_type};
        }
        else {
            warn "Unknown marker type '$marker_type'\n";
            return;
        }
    }

    # Set the line properties for the marker..
    my $line = $self->_get_line_properties( $marker->{line} );

    # Allow 'border' as a synonym for 'line'.
    if ( $marker->{border} ) {
        $line = $self->_get_line_properties( $marker->{border} );
    }

    # Set the fill properties for the marker.
    my $fill = $self->_get_fill_properties( $marker->{fill} );

    # Set the pattern properties for the series.
    my $pattern = $self->_get_pattern_properties( $marker->{pattern} );

    # Set the gradient fill properties for the series.
    my $gradient = $self->_get_gradient_properties( $marker->{gradient} );

    # Pattern fill overrides solid fill.
    if ( $pattern ) {
        $fill = undef;
    }

    # Gradient fill overrides solid and pattern fills.
    if ( $gradient ) {
        $pattern = undef;
        $fill    = undef;
    }

    $marker->{_line}     = $line;
    $marker->{_fill}     = $fill;
    $marker->{_pattern}  = $pattern;
    $marker->{_gradient} = $gradient;

    return $marker;
}


###############################################################################
#
# _get_trendline_properties()
#
# Convert user defined trendline properties to the structure required
# internally.
#
sub _get_trendline_properties {

    my $self      = shift;
    my $trendline = shift;

    return if !$trendline && ref $trendline ne 'HASH';

    # Copy the user supplied properties.
    $trendline = { %$trendline };

    my %types = (
        exponential    => 'exp',
        linear         => 'linear',
        log            => 'log',
        moving_average => 'movingAvg',
        polynomial     => 'poly',
        power          => 'power',
    );

    # Check the trendline type.
    my $trend_type = $trendline->{type};

    if ( exists $types{$trend_type} ) {
        $trendline->{type} = $types{$trend_type};
    }
    else {
        warn "Unknown trendline type '$trend_type'\n";
        return;
    }

    # Set the line properties for the trendline..
    my $line = $self->_get_line_properties( $trendline->{line} );

    # Allow 'border' as a synonym for 'line'.
    if ( $trendline->{border} ) {
        $line = $self->_get_line_properties( $trendline->{border} );
    }

    # Set the fill properties for the trendline.
    my $fill = $self->_get_fill_properties( $trendline->{fill} );

    # Set the pattern properties for the series.
    my $pattern = $self->_get_pattern_properties( $trendline->{pattern} );

    # Set the gradient fill properties for the series.
    my $gradient = $self->_get_gradient_properties( $trendline->{gradient} );

    # Pattern fill overrides solid fill.
    if ( $pattern ) {
        $fill = undef;
    }

    # Gradient fill overrides solid and pattern fills.
    if ( $gradient ) {
        $pattern = undef;
        $fill    = undef;
    }

    $trendline->{_line}     = $line;
    $trendline->{_fill}     = $fill;
    $trendline->{_pattern}  = $pattern;
    $trendline->{_gradient} = $gradient;

    return $trendline;
}


###############################################################################
#
# _get_error_bars_properties()
#
# Convert user defined error bars properties to structure required internally.
#
sub _get_error_bars_properties {

    my $self = shift;
    my $args = shift;

    return if !$args && ref $args ne 'HASH';

    # Copy the user supplied properties.
    $args = { %$args };


    # Default values.
    my $error_bars = {
        _type         => 'fixedVal',
        _value        => 1,
        _endcap       => 1,
        _direction    => 'both',
        _plus_values  => [1],
        _minus_values => [1],
        _plus_data    => [],
        _minus_data   => [],
    };

    my %types = (
        fixed              => 'fixedVal',
        percentage         => 'percentage',
        standard_deviation => 'stdDev',
        standard_error     => 'stdErr',
        custom             => 'cust',
    );

    # Check the error bars type.
    my $error_type = $args->{type};

    if ( exists $types{$error_type} ) {
        $error_bars->{_type} = $types{$error_type};
    }
    else {
        warn "Unknown error bars type '$error_type'\n";
        return;
    }

    # Set the value for error types that require it.
    if ( defined $args->{value} ) {
        $error_bars->{_value} = $args->{value};
    }

    # Set the end-cap style.
    if ( defined $args->{end_style} ) {
        $error_bars->{_endcap} = $args->{end_style};
    }

    # Set the error bar direction.
    if ( defined $args->{direction} ) {
        if ( $args->{direction} eq 'minus' ) {
            $error_bars->{_direction} = 'minus';
        }
        elsif ( $args->{direction} eq 'plus' ) {
            $error_bars->{_direction} = 'plus';
        }
        else {
            # Default to 'both'.
        }
    }

    # Set any custom values.
    if ( defined $args->{plus_values} ) {
        $error_bars->{_plus_values} = $args->{plus_values};
    }
    if ( defined $args->{minus_values} ) {
        $error_bars->{_minus_values} = $args->{minus_values};
    }
    if ( defined $args->{plus_data} ) {
        $error_bars->{_plus_data} = $args->{plus_data};
    }
    if ( defined $args->{minus_data} ) {
        $error_bars->{_minus_data} = $args->{minus_data};
    }

    # Set the line properties for the error bars.
    $error_bars->{_line} = $self->_get_line_properties( $args->{line} );

    return $error_bars;
}


###############################################################################
#
# _get_gridline_properties()
#
# Convert user defined gridline properties to the structure required internally.
#
sub _get_gridline_properties {

    my $self = shift;
    my $args = shift;
    my $gridline;

    # Set the visible property for the gridline.
    $gridline->{_visible} = $args->{visible};

    # Set the line properties for the gridline..
    $gridline->{_line} = $self->_get_line_properties( $args->{line} );

    return $gridline;
}


###############################################################################
#
# _get_labels_properties()
#
# Convert user defined labels properties to the structure required internally.
#
sub _get_labels_properties {

    my $self   = shift;
    my $labels = shift;

    return if !$labels && ref $labels ne 'HASH';

    # Copy the user supplied properties.
    $labels = { %$labels };

    # Map user defined label positions to Excel positions.
    if ( my $position = $labels->{position} ) {

        if ( exists $self->{_label_positions}->{$position} ) {
            if ($position eq $self->{_label_position_default}) {
                $labels->{position} = undef;
            }
            else {
                $labels->{position} = $self->{_label_positions}->{$position};
            }
        }
        else {
            carp "Unsupported label position '$position' for this chart type";
            return undef
        }
    }

    # Map the user defined label separator to the Excel separator.
    if ( my $separator = $labels->{separator} ) {

        my %separators = (
            ','  => ', ',
            ';'  => '; ',
            '.'  => '. ',
            "\n" => "\n",
            ' '  => ' '
        );

        if ( exists $separators{$separator} ) {
            $labels->{separator} = $separators{$separator};
        }
        else {
            carp "Unsupported label separator";
            return undef
        }
    }

    if ($labels->{font}) {
        $labels->{font} = $self->_convert_font_args( $labels->{font} );
    }

    return $labels;
}


###############################################################################
#
# _get_area_properties()
#
# Convert user defined area properties to the structure required internally.
#
sub _get_area_properties {

    my $self = shift;
    my %arg  = @_;
    my $area = {};


    # Map deprecated Spreadsheet::WriteExcel fill colour.
    if ( $arg{color} ) {
        $arg{fill}->{color} = $arg{color};
    }

    # Map deprecated Spreadsheet::WriteExcel line_weight.
    if ( $arg{line_weight} ) {
        my $width = $self->_get_swe_line_weight( $arg{line_weight} );
        $arg{border}->{width} = $width;
    }

    # Map deprecated Spreadsheet::WriteExcel line_pattern.
    if ( $arg{line_pattern} ) {
        my $pattern = $self->_get_swe_line_pattern( $arg{line_pattern} );

        if ( $pattern eq 'none' ) {
            $arg{border}->{none} = 1;
        }
        else {
            $arg{border}->{dash_type} = $pattern;
        }
    }

    # Map deprecated Spreadsheet::WriteExcel line colour.
    if ( $arg{line_color} ) {
        $arg{border}->{color} = $arg{line_color};
    }


    # Handle Excel::Writer::XLSX style properties.

    # Set the line properties for the chartarea.
    my $line = $self->_get_line_properties( $arg{line} );

    # Allow 'border' as a synonym for 'line'.
    if ( $arg{border} ) {
        $line = $self->_get_line_properties( $arg{border} );
    }

    # Set the fill properties for the chartarea.
    my $fill = $self->_get_fill_properties( $arg{fill} );

    # Set the pattern properties for the series.
    my $pattern = $self->_get_pattern_properties( $arg{pattern} );

    # Set the gradient fill properties for the series.
    my $gradient = $self->_get_gradient_properties( $arg{gradient} );

    # Pattern fill overrides solid fill.
    if ( $pattern ) {
        $fill = undef;
    }

    # Gradient fill overrides solid and pattern fills.
    if ( $gradient ) {
        $pattern = undef;
        $fill    = undef;
    }

    # Set the plotarea layout.
    my $layout = $self->_get_layout_properties( $arg{layout} );

    $area->{_line}     = $line;
    $area->{_fill}     = $fill;
    $area->{_pattern}  = $pattern;
    $area->{_gradient} = $gradient;
    $area->{_layout}   = $layout;

    return $area;
}


###############################################################################
#
# _get_legend_properties()
#
# Convert user defined legend properties to the structure required internally.
#
sub _get_legend_properties {

    my $self = shift;
    my %arg  = @_;
    my $legend = {};

    $legend->{_position}      = $arg{position} || 'right';
    $legend->{_delete_series} = $arg{delete_series};
    $legend->{_font}          = $self->_convert_font_args( $arg{font} );

    # Set the legend layout.
    $legend->{_layout} = $self->_get_layout_properties( $arg{layout} );

    # Turn off the legend.
    if ( $arg{none} ) {
        $legend->{_position} = 'none';
    }

    # Set the line properties for the legend.
    my $line = $self->_get_line_properties( $arg{line} );

    # Allow 'border' as a synonym for 'line'.
    if ( $arg{border} ) {
        $line = $self->_get_line_properties( $arg{border} );
    }

    # Set the fill properties for the legend.
    my $fill = $self->_get_fill_properties( $arg{fill} );

    # Set the pattern properties for the legend.
    my $pattern = $self->_get_pattern_properties( $arg{pattern} );

    # Set the gradient fill properties for the legend.
    my $gradient = $self->_get_gradient_properties( $arg{gradient} );

    # Pattern fill overrides solid fill.
    if ( $pattern ) {
        $fill = undef;
    }

    # Gradient fill overrides solid and pattern fills.
    if ( $gradient ) {
        $pattern = undef;
        $fill    = undef;
    }

    # Set the legend layout.
    my $layout = $self->_get_layout_properties( $arg{layout} );

    $legend->{_line}     = $line;
    $legend->{_fill}     = $fill;
    $legend->{_pattern}  = $pattern;
    $legend->{_gradient} = $gradient;
    $legend->{_layout}   = $layout;

    return $legend;
}


###############################################################################
#
# _get_layout_properties()
#
# Convert user defined layout properties to the format required internally.
#
sub _get_layout_properties {

    my $self    = shift;
    my $args    = shift;
    my $is_text = shift;
    my $layout  = {};
    my @properties;
    my %allowable;

    return if !$args;

    if ( $is_text ) {
        @properties = ( 'x', 'y' );
    }
    else {
        @properties = ( 'x', 'y', 'width', 'height' );
    }

    # Check for valid properties.
    @allowable{@properties} = undef;

    for my $key ( keys %$args ) {

        if ( !exists $allowable{$key} ) {
            warn "Property '$key' not allowed in layout options\n";
            return;
        }
    }

    # Set the layout properties.
    for my $property ( @properties ) {

        if ( !exists $args->{$property} ) {
            warn "Property '$property' must be specified in layout options\n";
            return;
        }

        my $value = $args->{$property};

        if ( $value !~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/ ) {
            warn "Property '$property' value '$value' must be numeric"
              . " in layout options\n";
            return;
        }

        if ( $value < 0 || $value > 1 ) {
            warn "Property '$property' value '$value' must be in range "
              . "0 < x <= 1 in layout options\n";
            return;
        }

        # Convert to the format used by Excel for easier testing
        $layout->{$property} = sprintf "%.17g", $value;
    }

    return $layout;
}


###############################################################################
#
# _get_points_properties()
#
# Convert user defined points properties to structure required internally.
#
sub _get_points_properties {

    my $self        = shift;
    my $user_points = shift;
    my @points;

    return unless $user_points;

    for my $user_point ( @$user_points ) {

        my $point;

        if ( defined $user_point ) {

            # Set the line properties for the point.
            my $line = $self->_get_line_properties( $user_point->{line} );

            # Allow 'border' as a synonym for 'line'.
            if ( $user_point->{border} ) {
                $line = $self->_get_line_properties( $user_point->{border} );
            }

            # Set the fill properties for the chartarea.
            my $fill = $self->_get_fill_properties( $user_point->{fill} );


            # Set the pattern properties for the series.
            my $pattern =
              $self->_get_pattern_properties( $user_point->{pattern} );

            # Set the gradient fill properties for the series.
            my $gradient =
              $self->_get_gradient_properties( $user_point->{gradient} );

            # Pattern fill overrides solid fill.
            if ( $pattern ) {
                $fill = undef;
            }

            # Gradient fill overrides solid and pattern fills.
            if ( $gradient ) {
                $pattern = undef;
                $fill    = undef;
            }
                        # Gradient fill overrides solid fill.
            if ( $gradient ) {
                $fill = undef;
            }

            $point->{_line}     = $line;
            $point->{_fill}     = $fill;
            $point->{_pattern}  = $pattern;
            $point->{_gradient} = $gradient;
        }

        push @points, $point;
    }

    return \@points;
}


###############################################################################
#
# _get_display_units()
#
# Convert user defined display units to internal units.
#
sub _get_display_units {

    my $self          = shift;
    my $display_units = shift;

    return if !$display_units;

    my %types = (
        'hundreds'          => 'hundreds',
        'thousands'         => 'thousands',
        'ten_thousands'     => 'tenThousands',
        'hundred_thousands' => 'hundredThousands',
        'millions'          => 'millions',
        'ten_millions'      => 'tenMillions',
        'hundred_millions'  => 'hundredMillions',
        'billions'          => 'billions',
        'trillions'         => 'trillions',
    );

    if ( exists $types{$display_units} ) {
        $display_units = $types{$display_units};
    }
    else {
        warn "Unknown display_units type '$display_units'\n";
        return;
    }

    return $display_units;
}



###############################################################################
#
# _get_tick_type()
#
# Convert user tick types to internal units.
#
sub _get_tick_type {

    my $self      = shift;
    my $tick_type = shift;

    return if !$tick_type;

    my %types = (
        'outside' => 'out',
        'inside'  => 'in',
        'none'    => 'none',
        'cross'   => 'cross',
    );

    if ( exists $types{$tick_type} ) {
        $tick_type = $types{$tick_type};
    }
    else {
        warn "Unknown tick_type type '$tick_type'\n";
        return;
    }

    return $tick_type;
}


###############################################################################
#
# _get_primary_axes_series()
#
# Returns series which use the primary axes.
#
sub _get_primary_axes_series {

    my $self = shift;
    my @primary_axes_series;

    for my $series ( @{ $self->{_series} } ) {
        push @primary_axes_series, $series unless $series->{_y2_axis};
    }

    return @primary_axes_series;
}


###############################################################################
#
# _get_secondary_axes_series()
#
# Returns series which use the secondary axes.
#
sub _get_secondary_axes_series {

    my $self = shift;
    my @secondary_axes_series;

    for my $series ( @{ $self->{_series} } ) {
        push @secondary_axes_series, $series if $series->{_y2_axis};
    }

    return @secondary_axes_series;
}


###############################################################################
#
# _add_axis_ids()
#
# Add unique ids for primary or secondary axes
#
sub _add_axis_ids {

    my $self       = shift;
    my %args       = @_;
    my $chart_id   = 5001 + $self->{_id};
    my $axis_count = 1 + @{ $self->{_axis2_ids} } + @{ $self->{_axis_ids} };

    my $id1 = sprintf '%04d%04d', $chart_id, $axis_count;
    my $id2 = sprintf '%04d%04d', $chart_id, $axis_count + 1;

    push @{ $self->{_axis_ids} },  $id1, $id2 if $args{primary_axes};
    push @{ $self->{_axis2_ids} }, $id1, $id2 if !$args{primary_axes};
}


##############################################################################
#
# _get_font_style_attributes.
#
# Get the font style attributes from a font hashref.
#
sub _get_font_style_attributes {

    my $self = shift;
    my $font = shift;

    return () unless $font;

    my @attributes;
    push @attributes, ( 'sz' => $font->{_size} )   if $font->{_size};
    push @attributes, ( 'b'  => $font->{_bold} )   if defined $font->{_bold};
    push @attributes, ( 'i'  => $font->{_italic} ) if defined $font->{_italic};
    push @attributes, ( 'u' => 'sng' ) if defined $font->{_underline};

    # Turn off baseline when testing fonts that don't have it.
    if ($font->{_baseline} != -1) {
        push @attributes, ( 'baseline' => $font->{_baseline} );
    }

    return @attributes;
}


##############################################################################
#
# _get_font_latin_attributes.
#
# Get the font latin attributes from a font hashref.
#
sub _get_font_latin_attributes {

    my $self = shift;
    my $font = shift;

    return () unless $font;

    my @attributes;
    push @attributes, ( 'typeface' => $font->{_name} ) if $font->{_name};

    push @attributes, ( 'pitchFamily' => $font->{_pitch_family} )
      if defined $font->{_pitch_family};

    push @attributes, ( 'charset' => $font->{_charset} )
      if defined $font->{_charset};

    return @attributes;
}


###############################################################################
#
# Config data.
#
###############################################################################

###############################################################################
#
# _set_default_properties()
#
# Setup the default properties for a chart.
#
sub _set_default_properties {

    my $self = shift;

    # Set the default axis properties.
    $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();
}


###############################################################################
#
# _set_embedded_config_data()
#
# Setup the default configuration data for an embedded chart.
#
sub _set_embedded_config_data {

    my $self = shift;

    $self->{_embedded} = 1;
}


###############################################################################
#
# XML writing methods.
#
###############################################################################


##############################################################################
#
# _write_chart_space()
#
# Write the  element.
#
sub _write_chart_space {

    my $self    = shift;
    my $schema  = 'http://schemas.openxmlformats.org/';
    my $xmlns_c = $schema . 'drawingml/2006/chart';
    my $xmlns_a = $schema . 'drawingml/2006/main';
    my $xmlns_r = $schema . 'officeDocument/2006/relationships';

    my @attributes = (
        'xmlns:c' => $xmlns_c,
        'xmlns:a' => $xmlns_a,
        'xmlns:r' => $xmlns_r,
    );

    $self->xml_start_tag( 'c:chartSpace', @attributes );
}


##############################################################################
#
# _write_lang()
#
# Write the  element.
#
sub _write_lang {

    my $self = shift;
    my $val  = 'en-US';

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:lang', @attributes );
}


##############################################################################
#
# _write_style()
#
# Write the  element.
#
sub _write_style {

    my $self     = shift;
    my $style_id = $self->{_style_id};

    # Don't write an element for the default style, 2.
    return if $style_id == 2;

    my @attributes = ( 'val' => $style_id );

    $self->xml_empty_tag( 'c:style', @attributes );
}


##############################################################################
#
# _write_chart()
#
# Write the  element.
#
sub _write_chart {

    my $self = shift;

    $self->xml_start_tag( 'c:chart' );

    # Write the chart title elements.

    if ( $self->{_title_none} ) {

        # Turn off the title.
        $self->_write_auto_title_deleted();
    }
    else {
        my $title;
        if ( $title = $self->{_title_formula} ) {
            $self->_write_title_formula(

                $title,
                $self->{_title_data_id},
                undef,
                $self->{_title_font},
                $self->{_title_layout},
                $self->{_title_overlay}
            );
        }
        elsif ( $title = $self->{_title_name} ) {
            $self->_write_title_rich(

                $title,
                undef,
                $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();

    $self->xml_end_tag( 'c:chart' );
}


##############################################################################
#
# _write_disp_blanks_as()
#
# Write the  element.
#
sub _write_disp_blanks_as {

    my $self = shift;
    my $val  = $self->{_show_blanks};

    # Ignore the default value.
    return if $val eq 'gap';

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:dispBlanksAs', @attributes );
}


##############################################################################
#
# _write_plot_area()
#
# Write the  element.
#
sub _write_plot_area {

    my $self = shift;
    my $second_chart = $self->{_combined};

    $self->xml_start_tag( 'c:plotArea' );

    # Write the c:layout element.
    $self->_write_layout( $self->{_plotarea}->{_layout}, 'plot' );

    # Write the subclass chart type elements for primary and secondary axes.
    $self->_write_chart_type( primary_axes => 1 );
    $self->_write_chart_type( primary_axes => 0 );


    # Configure a combined chart if present.
    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};
        }

        # Shart 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 => 1 );
        $second_chart->_write_chart_type( primary_axes => 0 );
    }

    # Write the category and value elements for the primary axes.
    my @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 && $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' );
}


##############################################################################
#
# _write_layout()
#
# Write the  element.
#
sub _write_layout {

    my $self   = shift;
    my $layout = shift;
    my $type   = shift;

    if ( !$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, $type );
        $self->xml_end_tag( 'c:layout' );
    }
}

##############################################################################
#
# _write_manual_layout()
#
# Write the  element.
#
sub _write_manual_layout {

    my $self   = shift;
    my $layout = shift;
    my $type   = shift;

    $self->xml_start_tag( 'c:manualLayout' );

    # Plotarea has a layoutTarget element.
    if ( $type eq '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 ( $type ne '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' );
}

##############################################################################
#
# _write_chart_type()
#
# Write the chart type element. This method should be overridden by the
# subclasses.
#
sub _write_chart_type {

    my $self = shift;
}


##############################################################################
#
# _write_grouping()
#
# Write the  element.
#
sub _write_grouping {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:grouping', @attributes );
}


##############################################################################
#
# _write_series()
#
# Write the series elements.
#
sub _write_series {

    my $self   = shift;
    my $series = shift;

    $self->_write_ser( $series );
}


##############################################################################
#
# _write_ser()
#
# Write the  element.
#
sub _write_ser {

    my $self   = shift;
    my $series = shift;
    my $index  = $self->{_series_index}++;

    $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} );
    }

    $self->xml_end_tag( 'c:ser' );
}


##############################################################################
#
# _write_idx()
#
# Write the  element.
#
sub _write_idx {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:idx', @attributes );
}


##############################################################################
#
# _write_order()
#
# Write the  element.
#
sub _write_order {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:order', @attributes );
}


##############################################################################
#
# _write_series_name()
#
# Write the series name.
#
sub _write_series_name {

    my $self   = shift;
    my $series = shift;

    my $name;
    if ( $name = $series->{_name_formula} ) {
        $self->_write_tx_formula( $name, $series->{_name_id} );
    }
    elsif ( $name = $series->{_name} ) {
        $self->_write_tx_value( $name );
    }

}


##############################################################################
#
# _write_cat()
#
# Write the  element.
#
sub _write_cat {

    my $self    = shift;
    my $series  = shift;
    my $formula = $series->{_categories};
    my $data_id = $series->{_cat_data_id};
    my $data;

    if ( defined $data_id ) {
        $data = $self->{_formula_data}->[$data_id];
    }

    # Ignore  elements for charts without category values.
    return unless $formula;

    $self->xml_start_tag( 'c:cat' );

    # Check the type of cached data.
    my $type = $self->_get_data_type( $data );

    if ( $type eq 'str' ) {

        $self->{_cat_has_num_fmt} = 0;

        # Write the c:numRef element.
        $self->_write_str_ref( $formula, $data, $type );
    }
    elsif ( $type eq 'multi_str') {

        $self->{_cat_has_num_fmt} = 0;

        # Write the c:multiLvLStrRef 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, $type );
    }


    $self->xml_end_tag( 'c:cat' );
}


##############################################################################
#
# _write_val()
#
# Write the  element.
#
sub _write_val {

    my $self    = shift;
    my $series  = shift;
    my $formula = $series->{_values};
    my $data_id = $series->{_val_data_id};
    my $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' );
}


##############################################################################
#
# _write_num_ref()
#
# Write the  element.
#
sub _write_num_ref {

    my $self    = shift;
    my $formula = shift;
    my $data    = shift;
    my $type    = shift;

    $self->xml_start_tag( 'c:numRef' );

    # Write the c:f element.
    $self->_write_series_formula( $formula );

    if ( $type eq 'num' ) {

        # Write the c:numCache element.
        $self->_write_num_cache( $data );
    }
    elsif ( $type eq 'str' ) {

        # Write the c:strCache element.
        $self->_write_str_cache( $data );
    }

    $self->xml_end_tag( 'c:numRef' );
}


##############################################################################
#
# _write_str_ref()
#
# Write the  element.
#
sub _write_str_ref {

    my $self    = shift;
    my $formula = shift;
    my $data    = shift;
    my $type    = shift;

    $self->xml_start_tag( 'c:strRef' );

    # Write the c:f element.
    $self->_write_series_formula( $formula );

    if ( $type eq 'num' ) {

        # Write the c:numCache element.
        $self->_write_num_cache( $data );
    }
    elsif ( $type eq 'str' ) {

        # Write the c:strCache element.
        $self->_write_str_cache( $data );
    }

    $self->xml_end_tag( 'c:strRef' );
}


##############################################################################
#
# _write_multi_lvl_str_ref()
#
# Write the  element.
#
sub _write_multi_lvl_str_ref {

    my $self    = shift;
    my $formula = shift;
    my $data    = shift;
    my $count   = @$data;

    return if !$count;

    $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 = @{ $data->[-1] };
    $self->_write_pt_count( $count );

    # Write the data arrays in reverse order.
    for my $aref ( reverse @$data ) {
        $self->xml_start_tag( 'c:lvl' );

        for my $i ( 0 .. @$aref - 1 ) {
            # Write the c:pt element.
            $self->_write_pt( $i, $aref->[$i] );
        }

        $self->xml_end_tag( 'c:lvl' );
    }

    $self->xml_end_tag( 'c:multiLvlStrCache' );

    $self->xml_end_tag( 'c:multiLvlStrRef' );
}


##############################################################################
#
# _write_series_formula()
#
# Write the  element.
#
sub _write_series_formula {

    my $self    = shift;
    my $formula = shift;

    # Strip the leading '=' from the formula.
    $formula =~ s/^=//;

    $self->xml_data_element( 'c:f', $formula );
}


##############################################################################
#
# _write_axis_ids()
#
# Write the  elements for the primary or secondary axes.
#
sub _write_axis_ids {

    my $self = shift;
    my %args = @_;

    # 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] );
    }
}


##############################################################################
#
# _write_axis_id()
#
# Write the  element.
#
sub _write_axis_id {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:axId', @attributes );
}


##############################################################################
#
# _write_cat_axis()
#
# Write the  element. Usually the X axis.
#
sub _write_cat_axis {

    my $self     = shift;
    my %args     = @_;
    my $x_axis   = $args{x_axis};
    my $y_axis   = $args{y_axis};
    my $axis_ids = $args{axis_ids};

    # if there are no axis_ids then we don't need to write this element
    return unless $axis_ids;
    return unless scalar @$axis_ids;

    my $position  = $self->{_cat_axis_position};
    my $is_y_axis = $self->{_horiz_cat_axis};

    # Overwrite the default axis position with a user supplied value.
    $position = $x_axis->{_position} || $position;

    $self->xml_start_tag( 'c:catAx' );

    $self->_write_axis_id( $axis_ids->[0] );

    # Write the c:scaling element.
    $self->_write_scaling( $x_axis->{_reverse} );

    $self->_write_delete( 1 ) unless $x_axis->{_visible};

    # Write the c:axPos element.
    $self->_write_axis_pos( $position, $y_axis->{_reverse} );

    # Write the c:majorGridlines element.
    $self->_write_major_gridlines( $x_axis->{_major_gridlines} );

    # Write the c:minorGridlines element.
    $self->_write_minor_gridlines( $x_axis->{_minor_gridlines} );

    # Write the axis title elements.
    my $title;
    if ( $title = $x_axis->{_formula} ) {

        $self->_write_title_formula( $title, $x_axis->{_data_id}, $is_y_axis,
            $x_axis->{_name_font}, $x_axis->{_layout} );
    }
    elsif ( $title = $x_axis->{_name} ) {
        $self->_write_title_rich( $title, $is_y_axis, $x_axis->{_name_font},
            $x_axis->{_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->{_major_tick_mark} );

    # Write the c:minorTickMark element.
    $self->_write_minor_tick_mark( $x_axis->{_minor_tick_mark} );

    # Write the c:tickLblPos element.
    $self->_write_tick_label_pos( $x_axis->{_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->{_num_font} );

    # Write the c:crossAx element.
    $self->_write_cross_axis( $axis_ids->[1] );

    if ( $self->{_show_crosses} || $x_axis->{_visible} ) {

        # Note, the category crossing comes from the value axis.
        if ( !defined $y_axis->{_crossing} || $y_axis->{_crossing} eq 'max' ) {

            # Write the c:crosses element.
            $self->_write_crosses( $y_axis->{_crossing} );
        }
        else {

            # Write the c:crossesAt element.
            $self->_write_c_crosses_at( $y_axis->{_crossing} );
        }
    }

    # Write the c:auto element.
    if (!$x_axis->{_text_axis}) {
        $self->_write_auto( 1 );
    }

    # Write the c:labelAlign element.
    $self->_write_label_align( $x_axis->{_label_align} );

    # Write the c:labelOffset element.
    $self->_write_label_offset( 100 );

    # Write the c:tickLblSkip element.
    $self->_write_tick_lbl_skip( $x_axis->{_interval_unit} );

    # Write the c:tickMarkSkip element.
    $self->_write_tick_mark_skip( $x_axis->{_interval_tick} );

    $self->xml_end_tag( 'c:catAx' );
}


##############################################################################
#
# _write_val_axis()
#
# Write the  element. Usually the Y axis.
#
# TODO. Maybe should have a _write_cat_val_axis() method as well for scatter.
#
sub _write_val_axis {

    my $self      = shift;
    my %args      = @_;
    my $x_axis    = $args{x_axis};
    my $y_axis    = $args{y_axis};
    my $axis_ids  = $args{axis_ids};
    my $position  = $args{position} || $self->{_val_axis_position};
    my $is_y_axis = $self->{_horiz_val_axis};

    return unless $axis_ids && scalar @$axis_ids;

    # Overwrite the default axis position with a user supplied value.
    $position = $y_axis->{_position} || $position;

    $self->xml_start_tag( 'c:valAx' );

    $self->_write_axis_id( $axis_ids->[1] );

    # Write the c:scaling element.
    $self->_write_scaling(
        $y_axis->{_reverse}, $y_axis->{_min},
        $y_axis->{_max},     $y_axis->{_log_base}
    );

    $self->_write_delete( 1 ) unless $y_axis->{_visible};

    # Write the c:axPos element.
    $self->_write_axis_pos( $position, $x_axis->{_reverse} );

    # Write the c:majorGridlines element.
    $self->_write_major_gridlines( $y_axis->{_major_gridlines} );

    # Write the c:minorGridlines element.
    $self->_write_minor_gridlines( $y_axis->{_minor_gridlines} );

    # Write the axis title elements.
    my $title;
    if ( $title = $y_axis->{_formula} ) {
        $self->_write_title_formula( $title, $y_axis->{_data_id}, $is_y_axis,
            $y_axis->{_name_font}, $y_axis->{_layout} );
    }
    elsif ( $title = $y_axis->{_name} ) {
        $self->_write_title_rich( $title, $is_y_axis, $y_axis->{_name_font},
            $y_axis->{_layout} );
    }

    # Write the c:numberFormat element.
    $self->_write_number_format( $y_axis );

    # Write the c:majorTickMark element.
    $self->_write_major_tick_mark( $y_axis->{_major_tick_mark} );

    # Write the c:minorTickMark element.
    $self->_write_minor_tick_mark( $y_axis->{_minor_tick_mark} );

    # Write the c:tickLblPos element.
    $self->_write_tick_label_pos( $y_axis->{_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->{_num_font} );

    # Write the c:crossAx element.
    $self->_write_cross_axis( $axis_ids->[0] );

    # Note, the category crossing comes from the value axis.
    if ( !defined $x_axis->{_crossing} || $x_axis->{_crossing} eq 'max' ) {

        # Write the c:crosses element.
        $self->_write_crosses( $x_axis->{_crossing} );
    }
    else {

        # Write the c:crossesAt element.
        $self->_write_c_crosses_at( $x_axis->{_crossing} );
    }

    # Write the c:crossBetween element.
    $self->_write_cross_between( $x_axis->{_position_axis} );

    # Write the c:majorUnit element.
    $self->_write_c_major_unit( $y_axis->{_major_unit} );

    # Write the c:minorUnit element.
    $self->_write_c_minor_unit( $y_axis->{_minor_unit} );

    # Write the c:dispUnits element.
    $self->_write_disp_units( $y_axis->{_display_units},
        $y_axis->{_display_units_visible} );

    $self->xml_end_tag( 'c:valAx' );
}


##############################################################################
#
# _write_cat_val_axis()
#
# Write the  element. This is for the second valAx in scatter plots.
# Usually the X axis.
#
sub _write_cat_val_axis {

    my $self      = shift;
    my %args      = @_;
    my $x_axis    = $args{x_axis};
    my $y_axis    = $args{y_axis};
    my $axis_ids  = $args{axis_ids};
    my $position  = $args{position} || $self->{_val_axis_position};
    my $is_y_axis = $self->{_horiz_val_axis};

    return unless $axis_ids && scalar @$axis_ids;

    # Overwrite the default axis position with a user supplied value.
    $position = $x_axis->{_position} || $position;

    $self->xml_start_tag( 'c:valAx' );

    $self->_write_axis_id( $axis_ids->[0] );

    # Write the c:scaling element.
    $self->_write_scaling(
        $x_axis->{_reverse}, $x_axis->{_min},
        $x_axis->{_max},     $x_axis->{_log_base}
    );

    $self->_write_delete( 1 ) unless $x_axis->{_visible};

    # Write the c:axPos element.
    $self->_write_axis_pos( $position, $y_axis->{_reverse} );

    # Write the c:majorGridlines element.
    $self->_write_major_gridlines( $x_axis->{_major_gridlines} );

    # Write the c:minorGridlines element.
    $self->_write_minor_gridlines( $x_axis->{_minor_gridlines} );

    # Write the axis title elements.
    my $title;
    if ( $title = $x_axis->{_formula} ) {
        $self->_write_title_formula( $title, $x_axis->{_data_id}, $is_y_axis,
            $x_axis->{_name_font}, $x_axis->{_layout} );
    }
    elsif ( $title = $x_axis->{_name} ) {
        $self->_write_title_rich( $title, $is_y_axis, $x_axis->{_name_font},
            $x_axis->{_layout} );
    }

    # Write the c:numberFormat element.
    $self->_write_number_format( $x_axis );

    # Write the c:majorTickMark element.
    $self->_write_major_tick_mark( $x_axis->{_major_tick_mark} );

    # Write the c:minorTickMark element.
    $self->_write_minor_tick_mark( $x_axis->{_minor_tick_mark} );

    # Write the c:tickLblPos element.
    $self->_write_tick_label_pos( $x_axis->{_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->{_num_font} );

    # Write the c:crossAx element.
    $self->_write_cross_axis( $axis_ids->[1] );

    # Note, the category crossing comes from the value axis.
    if ( !defined $y_axis->{_crossing} || $y_axis->{_crossing} eq 'max' ) {

        # Write the c:crosses element.
        $self->_write_crosses( $y_axis->{_crossing} );
    }
    else {

        # Write the c:crossesAt element.
        $self->_write_c_crosses_at( $y_axis->{_crossing} );
    }

    # Write the c:crossBetween element.
    $self->_write_cross_between( $y_axis->{_position_axis} );

    # Write the c:majorUnit element.
    $self->_write_c_major_unit( $x_axis->{_major_unit} );

    # Write the c:minorUnit element.
    $self->_write_c_minor_unit( $x_axis->{_minor_unit} );

    # Write the c:dispUnits element.
    $self->_write_disp_units( $x_axis->{_display_units},
        $x_axis->{_display_units_visible} );

    $self->xml_end_tag( 'c:valAx' );
}


##############################################################################
#
# _write_date_axis()
#
# Write the  element. Usually the X axis.
#
sub _write_date_axis {

    my $self     = shift;
    my %args     = @_;
    my $x_axis   = $args{x_axis};
    my $y_axis   = $args{y_axis};
    my $axis_ids = $args{axis_ids};

    return unless $axis_ids && scalar @$axis_ids;

    my $position = $self->{_cat_axis_position};

    # Overwrite the default axis position with a user supplied value.
    $position = $x_axis->{_position} || $position;

    $self->xml_start_tag( 'c:dateAx' );

    $self->_write_axis_id( $axis_ids->[0] );

    # Write the c:scaling element.
    $self->_write_scaling(
        $x_axis->{_reverse}, $x_axis->{_min},
        $x_axis->{_max},     $x_axis->{_log_base}
    );

    $self->_write_delete( 1 ) unless $x_axis->{_visible};

    # Write the c:axPos element.
    $self->_write_axis_pos( $position, $y_axis->{_reverse} );

    # Write the c:majorGridlines element.
    $self->_write_major_gridlines( $x_axis->{_major_gridlines} );

    # Write the c:minorGridlines element.
    $self->_write_minor_gridlines( $x_axis->{_minor_gridlines} );

    # Write the axis title elements.
    my $title;
    if ( $title = $x_axis->{_formula} ) {
        $self->_write_title_formula( $title, $x_axis->{_data_id}, undef,
            $x_axis->{_name_font}, $x_axis->{_layout} );
    }
    elsif ( $title = $x_axis->{_name} ) {
        $self->_write_title_rich( $title, undef, $x_axis->{_name_font},
            $x_axis->{_layout} );
    }

    # Write the c:numFmt element.
    $self->_write_number_format( $x_axis );

    # Write the c:majorTickMark element.
    $self->_write_major_tick_mark( $x_axis->{_major_tick_mark} );

    # Write the c:minorTickMark element.
    $self->_write_minor_tick_mark( $x_axis->{_minor_tick_mark} );

    # Write the c:tickLblPos element.
    $self->_write_tick_label_pos( $x_axis->{_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->{_num_font} );

    # Write the c:crossAx element.
    $self->_write_cross_axis( $axis_ids->[1] );

    if ( $self->{_show_crosses} || $x_axis->{_visible} ) {

        # Note, the category crossing comes from the value axis.
        if ( !defined $y_axis->{_crossing} || $y_axis->{_crossing} eq 'max' ) {

            # Write the c:crosses element.
            $self->_write_crosses( $y_axis->{_crossing} );
        }
        else {

            # Write the c:crossesAt element.
            $self->_write_c_crosses_at( $y_axis->{_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_tick_lbl_skip( $x_axis->{_interval_unit} );

    # Write the c:tickMarkSkip element.
    $self->_write_tick_mark_skip( $x_axis->{_interval_tick} );

    # Write the c:majorUnit element.
    $self->_write_c_major_unit( $x_axis->{_major_unit} );

    # Write the c:majorTimeUnit element.
    if ( defined $x_axis->{_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->{_minor_unit} );

    # Write the c:minorTimeUnit element.
    if ( defined $x_axis->{_minor_unit} ) {
        $self->_write_c_minor_time_unit( $x_axis->{_minor_unit_type} );
    }

    $self->xml_end_tag( 'c:dateAx' );
}


##############################################################################
#
# _write_scaling()
#
# Write the  element.
#
sub _write_scaling {

    my $self     = shift;
    my $reverse  = shift;
    my $min      = shift;
    my $max      = shift;
    my $log_base = shift;

    $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 );

    # Write the c:min element.
    $self->_write_c_min( $min );

    $self->xml_end_tag( 'c:scaling' );
}


##############################################################################
#
# _write_c_log_base()
#
# Write the  element.
#
sub _write_c_log_base {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:logBase', @attributes );
}


##############################################################################
#
# _write_orientation()
#
# Write the  element.
#
sub _write_orientation {

    my $self    = shift;
    my $reverse = shift;
    my $val     = 'minMax';

    $val = 'maxMin' if $reverse;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:orientation', @attributes );
}


##############################################################################
#
# _write_c_max()
#
# Write the  element.
#
sub _write_c_max {

    my $self = shift;
    my $max  = shift;

    return unless defined $max;

    my @attributes = ( 'val' => $max );

    $self->xml_empty_tag( 'c:max', @attributes );
}


##############################################################################
#
# _write_c_min()
#
# Write the  element.
#
sub _write_c_min {

    my $self = shift;
    my $min  = shift;

    return unless defined $min;

    my @attributes = ( 'val' => $min );

    $self->xml_empty_tag( 'c:min', @attributes );
}


##############################################################################
#
# _write_axis_pos()
#
# Write the  element.
#
sub _write_axis_pos {

    my $self    = shift;
    my $val     = shift;
    my $reverse = shift;

    if ( $reverse ) {
        $val = 'r' if $val eq 'l';
        $val = 't' if $val eq 'b';
    }

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:axPos', @attributes );
}


##############################################################################
#
# _write_number_format()
#
# Write the  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.
#
sub _write_number_format {

    my $self          = shift;
    my $axis          = shift;
    my $format_code   = $axis->{_num_format};
    my $source_linked = 1;

    # Check if a user defined number format has been set.
    if ( $format_code ne $axis->{_defaults}->{num_format} ) {
        $source_linked = 0;
    }

    # User override of sourceLinked.
    if ( $axis->{_num_format_linked} ) {
        $source_linked = 1;
    }

    my @attributes = (
        'formatCode'   => $format_code,
        'sourceLinked' => $source_linked,
    );

    $self->xml_empty_tag( 'c:numFmt', @attributes );
}


##############################################################################
#
# _write_cat_number_format()
#
# Write the  element. Special case handler for category axes which
# don't always have a number format.
#
sub _write_cat_number_format {

    my $self           = shift;
    my $axis           = shift;
    my $format_code    = $axis->{_num_format};
    my $source_linked  = 1;
    my $default_format = 1;

    # Check if a user defined number format has been set.
    if ( $format_code ne $axis->{_defaults}->{num_format} ) {
        $source_linked  = 0;
        $default_format = 0;
    }

    # User override of linkedSource.
    if ( $axis->{_num_format_linked} ) {
        $source_linked = 1;
    }

    # Skip if cat doesn't have a num format (unless it is non-default).
    if ( !$self->{_cat_has_num_fmt} && $default_format ) {
        return;
    }

    my @attributes = (
        'formatCode'   => $format_code,
        'sourceLinked' => $source_linked,
    );

    $self->xml_empty_tag( 'c:numFmt', @attributes );
}


##############################################################################
#
# _write_number_format()
#
# Write the  element for data labels.
#
sub _write_data_label_number_format {

    my $self          = shift;
    my $format_code   = shift;
    my $source_linked = 0;

    my @attributes = (
        'formatCode'   => $format_code,
        'sourceLinked' => $source_linked,
    );

    $self->xml_empty_tag( 'c:numFmt', @attributes );
}


##############################################################################
#
# _write_major_tick_mark()
#
# Write the  element.
#
sub _write_major_tick_mark {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:majorTickMark', @attributes );
}


##############################################################################
#
# _write_minor_tick_mark()
#
# Write the  element.
#
sub _write_minor_tick_mark {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:minorTickMark', @attributes );
}


##############################################################################
#
# _write_tick_label_pos()
#
# Write the  element.
#
sub _write_tick_label_pos {

    my $self = shift;
    my $val = shift || 'nextTo';

    if ( $val eq 'next_to' ) {
        $val = 'nextTo';
    }

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:tickLblPos', @attributes );
}


##############################################################################
#
# _write_cross_axis()
#
# Write the  element.
#
sub _write_cross_axis {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:crossAx', @attributes );
}


##############################################################################
#
# _write_crosses()
#
# Write the  element.
#
sub _write_crosses {

    my $self = shift;
    my $val = shift || 'autoZero';

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:crosses', @attributes );
}


##############################################################################
#
# _write_c_crosses_at()
#
# Write the  element.
#
sub _write_c_crosses_at {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:crossesAt', @attributes );
}


##############################################################################
#
# _write_auto()
#
# Write the  element.
#
sub _write_auto {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:auto', @attributes );
}


##############################################################################
#
# _write_label_align()
#
# Write the  element.
#
sub _write_label_align {

    my $self = shift;
    my $val  = shift || 'ctr';

    if ( $val eq 'right' ) {
        $val = 'r';
    }

    if ( $val eq 'left' ) {
        $val = 'l';
    }

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:lblAlgn', @attributes );
}


##############################################################################
#
# _write_label_offset()
#
# Write the  element.
#
sub _write_label_offset {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:lblOffset', @attributes );
}


##############################################################################
#
# _write_tick_lbl_skip()
#
# Write the  element.
#
sub _write_tick_lbl_skip {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:tickLblSkip', @attributes );
}


##############################################################################
#
# _write_tick_mark_skip()
#
# Write the  element.
#
sub _write_tick_mark_skip {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:tickMarkSkip', @attributes );
}


##############################################################################
#
# _write_major_gridlines()
#
# Write the  element.
#
sub _write_major_gridlines {

    my $self      = shift;
    my $gridlines = shift;

    return unless $gridlines;
    return unless $gridlines->{_visible};

    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' );
    }
}


##############################################################################
#
# _write_minor_gridlines()
#
# Write the  element.
#
sub _write_minor_gridlines {

    my $self      = shift;
    my $gridlines = shift;

    return unless $gridlines;
    return unless $gridlines->{_visible};

    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' );
    }
}


##############################################################################
#
# _write_cross_between()
#
# Write the  element.
#
sub _write_cross_between {

    my $self = shift;

    my $val = shift || $self->{_cross_between};

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:crossBetween', @attributes );
}


##############################################################################
#
# _write_c_major_unit()
#
# Write the  element.
#
sub _write_c_major_unit {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:majorUnit', @attributes );
}


##############################################################################
#
# _write_c_minor_unit()
#
# Write the  element.
#
sub _write_c_minor_unit {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:minorUnit', @attributes );
}


##############################################################################
#
# _write_c_major_time_unit()
#
# Write the  element.
#
sub _write_c_major_time_unit {

    my $self = shift;
    my $val = shift || 'days';

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:majorTimeUnit', @attributes );
}


##############################################################################
#
# _write_c_minor_time_unit()
#
# Write the  element.
#
sub _write_c_minor_time_unit {

    my $self = shift;
    my $val = shift || 'days';

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:minorTimeUnit', @attributes );
}


##############################################################################
#
# _write_legend()
#
# Write the  element.
#
sub _write_legend {

    my $self          = shift;
    my $legend        = $self->{_legend};
    my $position      = $legend->{_position} || 'right';
    my $font          = $legend->{_font};
    my @delete_series = ();
    my $overlay       = 0;

    if ( defined $legend->{_delete_series}
        && ref $legend->{_delete_series} eq 'ARRAY' )
    {
        @delete_series = @{ $legend->{_delete_series} };
    }

    if ( $position =~ s/^overlay_// ) {
        $overlay = 1;
    }

    my %allowed = (
        right     => 'r',
        left      => 'l',
        top       => 't',
        bottom    => 'b',
        top_right => 'tr',
    );

    return if $position eq 'none';
    return unless exists $allowed{$position};

    $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 my $index ( @delete_series ) {

        # Write the c:legendEntry element.
        $self->_write_legend_entry( $index );
    }

    # Write the c:layout element.
    $self->_write_layout( $legend->{_layout}, 'legend' );

    # Write the c:overlay element.
    $self->_write_overlay() if $overlay;

    # Write the c:spPr element.
    $self->_write_sp_pr( $legend );

    # Write the c:txPr element.
    if ( $font ) {
        $self->_write_tx_pr( undef, $font );
    }

    $self->xml_end_tag( 'c:legend' );
}


##############################################################################
#
# _write_legend_pos()
#
# Write the  element.
#
sub _write_legend_pos {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:legendPos', @attributes );
}


##############################################################################
#
# _write_legend_entry()
#
# Write the  element.
#
sub _write_legend_entry {

    my $self  = shift;
    my $index = shift;

    $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' );
}


##############################################################################
#
# _write_overlay()
#
# Write the  element.
#
sub _write_overlay {

    my $self = shift;
    my $val  = 1;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:overlay', @attributes );
}


##############################################################################
#
# _write_plot_vis_only()
#
# Write the  element.
#
sub _write_plot_vis_only {

    my $self = shift;
    my $val  = 1;

    # Ignore this element if we are plotting hidden data.
    return if $self->{_show_hidden_data};

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:plotVisOnly', @attributes );
}


##############################################################################
#
# _write_print_settings()
#
# Write the  element.
#
sub _write_print_settings {

    my $self = shift;

    $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' );
}


##############################################################################
#
# _write_header_footer()
#
# Write the  element.
#
sub _write_header_footer {

    my $self = shift;

    $self->xml_empty_tag( 'c:headerFooter' );
}


##############################################################################
#
# _write_page_margins()
#
# Write the  element.
#
sub _write_page_margins {

    my $self   = shift;
    my $b      = 0.75;
    my $l      = 0.7;
    my $r      = 0.7;
    my $t      = 0.75;
    my $header = 0.3;
    my $footer = 0.3;

    my @attributes = (
        'b'      => $b,
        'l'      => $l,
        'r'      => $r,
        't'      => $t,
        'header' => $header,
        'footer' => $footer,
    );

    $self->xml_empty_tag( 'c:pageMargins', @attributes );
}


##############################################################################
#
# _write_page_setup()
#
# Write the  element.
#
sub _write_page_setup {

    my $self = shift;

    $self->xml_empty_tag( 'c:pageSetup' );
}


##############################################################################
#
# _write_auto_title_deleted()
#
# Write the  element.
#
sub _write_auto_title_deleted {

    my $self = shift;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:autoTitleDeleted', @attributes );
}


##############################################################################
#
# _write_title_rich()
#
# Write the  element for a rich string.
#
sub _write_title_rich {

    my $self      = shift;
    my $title     = shift;
    my $is_y_axis = shift;
    my $font      = shift;
    my $layout    = shift;
    my $overlay   = shift;

    $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.
    $self->_write_overlay() if $overlay;

    $self->xml_end_tag( 'c:title' );
}


##############################################################################
#
# _write_title_formula()
#
# Write the  element for a rich string.
#
sub _write_title_formula {

    my $self      = shift;
    my $title     = shift;
    my $data_id   = shift;
    my $is_y_axis = shift;
    my $font      = shift;
    my $layout    = shift;
    my $overlay   = shift;

    $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.
    $self->_write_overlay() if $overlay;

    # Write the c:txPr element.
    $self->_write_tx_pr( $is_y_axis, $font );

    $self->xml_end_tag( 'c:title' );
}


##############################################################################
#
# _write_tx_rich()
#
# Write the  element.
#
sub _write_tx_rich {

    my $self      = shift;
    my $title     = shift;
    my $is_y_axis = shift;
    my $font      = shift;

    $self->xml_start_tag( 'c:tx' );

    # Write the c:rich element.
    $self->_write_rich( $title, $is_y_axis, $font );

    $self->xml_end_tag( 'c:tx' );
}


##############################################################################
#
# _write_tx_value()
#
# Write the  element with a simple value such as for series names.
#
sub _write_tx_value {

    my $self  = shift;
    my $title = shift;

    $self->xml_start_tag( 'c:tx' );

    # Write the c:v element.
    $self->_write_v( $title );

    $self->xml_end_tag( 'c:tx' );
}


##############################################################################
#
# _write_tx_formula()
#
# Write the  element.
#
sub _write_tx_formula {

    my $self    = shift;
    my $title   = shift;
    my $data_id = shift;
    my $data;

    if ( defined $data_id ) {
        $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' );
}


##############################################################################
#
# _write_rich()
#
# Write the  element.
#
sub _write_rich {

    my $self      = shift;
    my $title     = shift;
    my $is_y_axis = shift;
    my $rotation  = undef;
    my $font      = shift;

    if ( $font && exists $font->{_rotation} ) {
        $rotation = $font->{_rotation};
    }

    $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 );

    $self->xml_end_tag( 'c:rich' );
}


##############################################################################
#
# _write_a_body_pr()
#
# Write the  element.
sub _write_a_body_pr {

    my $self      = shift;
    my $rot       = shift;
    my $is_y_axis = shift;

    my @attributes = ();

    if ( !defined $rot && $is_y_axis ) {
        $rot = -5400000;
    }

    if (defined $rot) {
        if ($rot == 16_200_000) {
            # 270 deg/stacked angle.
            push @attributes, ( 'rot' => 0 );
            push @attributes, ( 'vert' => 'wordArtVert' );

        }
        elsif ($rot == 16_260_000) {
            # 271 deg/East Asian vertical.
            push @attributes, ( 'rot' => 0 );
            push @attributes, ( 'vert' => 'eaVert' );

        }
        else {
            push @attributes, ( 'rot' => $rot );
            push @attributes, ( 'vert' => 'horz' );
        }
    }

    $self->xml_empty_tag( 'a:bodyPr', @attributes );
}


##############################################################################
#
# _write_a_lst_style()
#
# Write the  element.
#
sub _write_a_lst_style {

    my $self = shift;

    $self->xml_empty_tag( 'a:lstStyle' );
}


##############################################################################
#
# _write_a_p_rich()
#
# Write the  element for rich string titles.
#
sub _write_a_p_rich {

    my $self  = shift;
    my $title = shift;
    my $font  = shift;

    $self->xml_start_tag( 'a:p' );

    # Write the a:pPr element.
    $self->_write_a_p_pr_rich( $font );

    # Write the a:r element.
    $self->_write_a_r( $title, $font );

    $self->xml_end_tag( 'a:p' );
}


##############################################################################
#
# _write_a_p_formula()
#
# Write the  element for formula titles.
#
sub _write_a_p_formula {

    my $self = shift;
    my $font = shift;

    $self->xml_start_tag( 'a:p' );

    # Write the a:pPr element.
    $self->_write_a_p_pr_formula( $font );

    # Write the a:endParaRPr element.
    $self->_write_a_end_para_rpr();

    $self->xml_end_tag( 'a:p' );
}


##############################################################################
#
# _write_a_p_pr_rich()
#
# Write the  element for rich string titles.
#
sub _write_a_p_pr_rich {

    my $self = shift;
    my $font = shift;

    $self->xml_start_tag( 'a:pPr' );

    # Write the a:defRPr element.
    $self->_write_a_def_rpr( $font );

    $self->xml_end_tag( 'a:pPr' );
}


##############################################################################
#
# _write_a_p_pr_formula()
#
# Write the  element for formula titles.
#
sub _write_a_p_pr_formula {

    my $self = shift;
    my $font = shift;

    $self->xml_start_tag( 'a:pPr' );

    # Write the a:defRPr element.
    $self->_write_a_def_rpr( $font );

    $self->xml_end_tag( 'a:pPr' );
}


##############################################################################
#
# _write_a_def_rpr()
#
# Write the  element.
#
sub _write_a_def_rpr {

    my $self      = shift;
    my $font      = shift;
    my $has_color = 0;

    my @style_attributes = $self->_get_font_style_attributes( $font );
    my @latin_attributes = $self->_get_font_latin_attributes( $font );

    $has_color = 1 if $font && $font->{_color};

    if ( @latin_attributes || $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 );
    }
}


##############################################################################
#
# _write_a_end_para_rpr()
#
# Write the  element.
#
sub _write_a_end_para_rpr {

    my $self = shift;
    my $lang = 'en-US';

    my @attributes = ( 'lang' => $lang );

    $self->xml_empty_tag( 'a:endParaRPr', @attributes );
}


##############################################################################
#
# _write_a_r()
#
# Write the  element.
#
sub _write_a_r {

    my $self  = shift;
    my $title = shift;
    my $font  = shift;

    $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' );
}


##############################################################################
#
# _write_a_r_pr()
#
# Write the  element.
#
sub _write_a_r_pr {

    my $self      = shift;
    my $font      = shift;
    my $has_color = 0;
    my $lang      = 'en-US';

    my @style_attributes = $self->_get_font_style_attributes( $font );
    my @latin_attributes = $self->_get_font_latin_attributes( $font );

    $has_color = 1 if $font && $font->{_color};

    # Add the lang type to the attributes.
    @style_attributes = ( 'lang' => $lang, @style_attributes );


    if ( @latin_attributes || $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 );
    }


}


##############################################################################
#
# _write_a_t()
#
# Write the  element.
#
sub _write_a_t {

    my $self  = shift;
    my $title = shift;

    $self->xml_data_element( 'a:t', $title );
}


##############################################################################
#
# _write_tx_pr()
#
# Write the  element.
#
sub _write_tx_pr {

    my $self      = shift;
    my $is_y_axis = shift;
    my $font      = shift;
    my $rotation  = undef;

    if ( $font && exists $font->{_rotation} ) {
        $rotation = $font->{_rotation};
    }

    $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' );
}


##############################################################################
#
# _write_marker()
#
# Write the  element.
#
sub _write_marker {

    my $self = shift;
    my $marker = shift || $self->{_default_marker};

    return unless $marker;
    return if $marker->{automatic};

    $self->xml_start_tag( 'c:marker' );

    # Write the c:symbol element.
    $self->_write_symbol( $marker->{type} );

    # Write the c:size element.
    my $size = $marker->{size};
    $self->_write_marker_size( $size ) if $size;

    # Write the c:spPr element.
    $self->_write_sp_pr( $marker );

    $self->xml_end_tag( 'c:marker' );
}


##############################################################################
#
# _write_marker_size()
#
# Write the  element.
#
sub _write_marker_size {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:size', @attributes );
}


##############################################################################
#
# _write_symbol()
#
# Write the  element.
#
sub _write_symbol {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:symbol', @attributes );
}


##############################################################################
#
# _write_sp_pr()
#
# Write the  element.
#
sub _write_sp_pr {

    my $self   = shift;
    my $series = shift;

    if (    !$series->{_line}->{_defined}
        and !$series->{_fill}->{_defined}
        and !$series->{_pattern}
        and !$series->{_gradient} )
    {
        return;
    }

    $self->xml_start_tag( 'c:spPr' );

    # Write the fill elements for solid charts such as pie/doughnut and bar.
    if ( $series->{_fill}->{_defined} ) {

        if ( $series->{_fill}->{none} ) {

            # 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->{_pattern} ) {

        # Write the a:pattFill element.
        $self->_write_a_patt_fill( $series->{_pattern} );
    }

    if ( $series->{_gradient} ) {

        # Write the a:gradFill element.
        $self->_write_a_grad_fill( $series->{_gradient} );
    }


    # Write the a:ln element.
    if ( $series->{_line}->{_defined} ) {
        $self->_write_a_ln( $series->{_line} );
    }

    $self->xml_end_tag( 'c:spPr' );
}


##############################################################################
#
# _write_a_ln()
#
# Write the  element.
#
sub _write_a_ln {

    my $self       = shift;
    my $line       = shift;
    my @attributes = ();

    # Add the line width as an attribute.
    if ( my $width = $line->{width} ) {

        # Round width to nearest 0.25, like Excel.
        $width = int( ( $width + 0.125 ) * 4 ) / 4;

        # Convert to internal units.
        $width = int( 0.5 + ( 12700 * $width ) );

        @attributes = ( 'w' => $width );
    }

    $self->xml_start_tag( 'a:ln', @attributes );

    # Write the line fill.
    if ( $line->{none} ) {

        # Write the a:noFill element.
        $self->_write_a_no_fill();
    }
    elsif ( $line->{color} ) {

        # Write the a:solidFill element.
        $self->_write_a_solid_fill( $line );
    }

    # Write the line/dash type.
    if ( my $type = $line->{dash_type} ) {

        # Write the a:prstDash element.
        $self->_write_a_prst_dash( $type );
    }

    $self->xml_end_tag( 'a:ln' );
}


##############################################################################
#
# _write_a_no_fill()
#
# Write the  element.
#
sub _write_a_no_fill {

    my $self = shift;

    $self->xml_empty_tag( 'a:noFill' );
}


##############################################################################
#
# _write_a_solid_fill()
#
# Write the  element.
#
sub _write_a_solid_fill {

    my $self = shift;
    my $fill = shift;

    $self->xml_start_tag( 'a:solidFill' );

    if ( $fill->{color} ) {

        my $color = $self->_get_color( $fill->{color} );

        # Write the a:srgbClr element.
        $self->_write_a_srgb_clr( $color, $fill->{transparency} );
    }

    $self->xml_end_tag( 'a:solidFill' );
}


##############################################################################
#
# _write_a_srgb_clr()
#
# Write the  element.
#
sub _write_a_srgb_clr {

    my $self         = shift;
    my $color        = shift;
    my $transparency = shift;

    my @attributes = ( 'val' => $color );

    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 );
    }
}


##############################################################################
#
# _write_a_alpha()
#
# Write the  element.
#
sub _write_a_alpha {

    my $self = shift;
    my $val  = shift;

    $val = ( 100 - int( $val ) ) * 1000;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'a:alpha', @attributes );
}


##############################################################################
#
# _write_a_prst_dash()
#
# Write the  element.
#
sub _write_a_prst_dash {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'a:prstDash', @attributes );
}


##############################################################################
#
# _write_trendline()
#
# Write the  element.
#
sub _write_trendline {

    my $self      = shift;
    my $trendline = shift;

    return unless $trendline;

    $self->xml_start_tag( 'c:trendline' );

    # Write the c:name element.
    $self->_write_name( $trendline->{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} eq 'poly' ) {
        $self->_write_trendline_order( $trendline->{order} );
    }

    # Write the c:period element for moving average trendlines.
    if ( $trendline->{type} eq 'movingAvg' ) {
        $self->_write_period( $trendline->{period} );
    }

    # Write the c:forward element.
    $self->_write_forward( $trendline->{forward} );

    # Write the c:backward element.
    $self->_write_backward( $trendline->{backward} );

    if ( defined $trendline->{intercept} ) {
        # Write the c:intercept element.
        $self->_write_intercept( $trendline->{intercept} );
    }

    if ($trendline->{display_r_squared}) {
        # Write the c:dispRSqr element.
        $self->_write_disp_rsqr();
    }

    if ($trendline->{display_equation}) {
        # Write the c:dispEq element.
        $self->_write_disp_eq();

        # Write the c:trendlineLbl element.
        $self->_write_trendline_lbl();
    }

    $self->xml_end_tag( 'c:trendline' );
}


##############################################################################
#
# _write_trendline_type()
#
# Write the  element.
#
sub _write_trendline_type {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:trendlineType', @attributes );
}


##############################################################################
#
# _write_name()
#
# Write the  element.
#
sub _write_name {

    my $self = shift;
    my $data = shift;

    return unless defined $data;

    $self->xml_data_element( 'c:name', $data );
}


##############################################################################
#
# _write_trendline_order()
#
# Write the  element.
#
sub _write_trendline_order {

    my $self = shift;
    my $val = defined $_[0] ? $_[0] : 2;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:order', @attributes );
}


##############################################################################
#
# _write_period()
#
# Write the  element.
#
sub _write_period {

    my $self = shift;
    my $val = defined $_[0] ? $_[0] : 2;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:period', @attributes );
}


##############################################################################
#
# _write_forward()
#
# Write the  element.
#
sub _write_forward {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:forward', @attributes );
}


##############################################################################
#
# _write_backward()
#
# Write the  element.
#
sub _write_backward {

    my $self = shift;
    my $val  = shift;

    return unless $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:backward', @attributes );
}


##############################################################################
#
# _write_intercept()
#
# Write the  element.
#
sub _write_intercept {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:intercept', @attributes );
}


##############################################################################
#
# _write_disp_eq()
#
# Write the  element.
#
sub _write_disp_eq {

    my $self = shift;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:dispEq', @attributes );
}


##############################################################################
#
# _write_disp_rsqr()
#
# Write the  element.
#
sub _write_disp_rsqr {

    my $self = shift;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:dispRSqr', @attributes );
}

##############################################################################
#
# _write_trendline_lbl()
#
# Write the  element.
#
sub _write_trendline_lbl {

    my $self = shift;

    $self->xml_start_tag( 'c:trendlineLbl' );

    # Write the c:layout element.
    $self->_write_layout();

    # Write the c:numFmt element.
    $self->_write_trendline_num_fmt();

    $self->xml_end_tag( 'c:trendlineLbl' );
}

##############################################################################
#
# _write_trendline_num_fmt()
#
# Write the  element.
#
sub _write_trendline_num_fmt {

    my $self          = shift;
    my $format_code   = 'General';
    my $source_linked = 0;

    my @attributes = (
        'formatCode'   => $format_code,
        'sourceLinked' => $source_linked,
    );

    $self->xml_empty_tag( 'c:numFmt', @attributes );
}

##############################################################################
#
# _write_hi_low_lines()
#
# Write the  element.
#
sub _write_hi_low_lines {

    my $self = shift;

    my $hi_low_lines = $self->{_hi_low_lines};

    return unless $hi_low_lines;

    if ( $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' );
    }
}


#############################################################################
#
# _write_drop_lines()
#
# Write the  element.
#
sub _write_drop_lines {

    my $self = shift;

    my $drop_lines = $self->{_drop_lines};

    return unless $drop_lines;

    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' );
    }
}


##############################################################################
#
# _write_overlap()
#
# Write the  element.
#
sub _write_overlap {

    my $self = shift;
    my $val  = shift;

    return if !defined $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:overlap', @attributes );
}


##############################################################################
#
# _write_num_cache()
#
# Write the  element.
#
sub _write_num_cache {

    my $self  = shift;
    my $data  = shift;
    my $count = 0;

    if (defined $data) {
        $count = @$data;
    }

    $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 my $i ( 0 .. $count - 1 ) {
        my $token = $data->[$i];

        # Write non-numeric data as 0.
        if ( defined $token
            && $token !~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/ )
        {
            $token = 0;
        }

        # Write the c:pt element.
        $self->_write_pt( $i, $token );
    }

    $self->xml_end_tag( 'c:numCache' );
}


##############################################################################
#
# _write_str_cache()
#
# Write the  element.
#
sub _write_str_cache {

    my $self  = shift;
    my $data  = shift;
    my $count = @$data;

    $self->xml_start_tag( 'c:strCache' );

    # Write the c:ptCount element.
    $self->_write_pt_count( $count );

    for my $i ( 0 .. $count - 1 ) {

        # Write the c:pt element.
        $self->_write_pt( $i, $data->[$i] );
    }

    $self->xml_end_tag( 'c:strCache' );
}


##############################################################################
#
# _write_format_code()
#
# Write the  element.
#
sub _write_format_code {

    my $self = shift;
    my $data = shift;

    $self->xml_data_element( 'c:formatCode', $data );
}


##############################################################################
#
# _write_pt_count()
#
# Write the  element.
#
sub _write_pt_count {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:ptCount', @attributes );
}


##############################################################################
#
# _write_pt()
#
# Write the  element.
#
sub _write_pt {

    my $self  = shift;
    my $idx   = shift;
    my $value = shift;

    return if !defined $value;

    my @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' );
}


##############################################################################
#
# _write_v()
#
# Write the  element.
#
sub _write_v {

    my $self = shift;
    my $data = shift;

    $self->xml_data_element( 'c:v', $data );
}


##############################################################################
#
# _write_protection()
#
# Write the  element.
#
sub _write_protection {

    my $self = shift;

    return unless $self->{_protection};

    $self->xml_empty_tag( 'c:protection' );
}


##############################################################################
#
# _write_d_pt()
#
# Write the  elements.
#
sub _write_d_pt {

    my $self   = shift;
    my $points = shift;
    my $index  = -1;

    return unless $points;

    for my $point ( @$points ) {

        $index++;
        next unless $point;

        $self->_write_d_pt_point( $index, $point );
    }
}


##############################################################################
#
# _write_d_pt_point()
#
# Write an individual  element.
#
sub _write_d_pt_point {

    my $self   = shift;
    my $index = shift;
    my $point = shift;

        $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' );

}


##############################################################################
#
# _write_d_lbls()
#
# Write the  element.
#
sub _write_d_lbls {

    my $self   = shift;
    my $labels = shift;

    return unless $labels;

    $self->xml_start_tag( 'c:dLbls' );

    # Write the c:numFmt element.
    if ( $labels->{num_format} ) {
        $self->_write_data_label_number_format( $labels->{num_format} );
    }

    # Write the data label font elements.
    if ($labels->{font} ) {
        $self->_write_axis_font( $labels->{font} );
    }

    # Write the c:dLblPos element.
    $self->_write_d_lbl_pos( $labels->{position} ) if $labels->{position};

    # Write the c:showLegendKey element.
    $self->_write_show_legend_key() if $labels->{legend_key};

    # Write the c:showVal element.
    $self->_write_show_val() if $labels->{value};

    # Write the c:showCatName element.
    $self->_write_show_cat_name() if $labels->{category};

    # Write the c:showSerName element.
    $self->_write_show_ser_name() if $labels->{series_name};

    # Write the c:showPercent element.
    $self->_write_show_percent() if $labels->{percentage};

    # Write the c:separator element.
    $self->_write_separator($labels->{separator}) if $labels->{separator};

    # Write the c:showLeaderLines element.
    $self->_write_show_leader_lines() if $labels->{leader_lines};

    $self->xml_end_tag( 'c:dLbls' );
}

##############################################################################
#
# _write_show_legend_key()
#
# Write the  element.
#
sub _write_show_legend_key {

    my $self = shift;
    my $val  = 1;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:showLegendKey', @attributes );
}

##############################################################################
#
# _write_show_val()
#
# Write the  element.
#
sub _write_show_val {

    my $self = shift;
    my $val  = 1;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:showVal', @attributes );
}


##############################################################################
#
# _write_show_cat_name()
#
# Write the  element.
#
sub _write_show_cat_name {

    my $self = shift;
    my $val  = 1;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:showCatName', @attributes );
}


##############################################################################
#
# _write_show_ser_name()
#
# Write the  element.
#
sub _write_show_ser_name {

    my $self = shift;
    my $val  = 1;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:showSerName', @attributes );
}


##############################################################################
#
# _write_show_percent()
#
# Write the  element.
#
sub _write_show_percent {

    my $self = shift;
    my $val  = 1;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:showPercent', @attributes );
}

##############################################################################
#
# _write_separator()
#
# Write the  element.
#
sub _write_separator {

    my $self = shift;
    my $data = shift;

    $self->xml_data_element( 'c:separator', $data );
}

##############################################################################
#
# _write_show_leader_lines()
#
# Write the  element.
#
sub _write_show_leader_lines {

    my $self = shift;
    my $val  = 1;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:showLeaderLines', @attributes );
}


##############################################################################
#
# _write_d_lbl_pos()
#
# Write the  element.
#
sub _write_d_lbl_pos {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:dLblPos', @attributes );
}


##############################################################################
#
# _write_delete()
#
# Write the  element.
#
sub _write_delete {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:delete', @attributes );
}


##############################################################################
#
# _write_c_invert_if_negative()
#
# Write the  element.
#
sub _write_c_invert_if_negative {

    my $self   = shift;
    my $invert = shift;
    my $val    = 1;

    return unless $invert;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:invertIfNegative', @attributes );
}


##############################################################################
#
# _write_axis_font()
#
# Write the axis font elements.
#
sub _write_axis_font {

    my $self = shift;
    my $font = shift;

    return unless $font;

    $self->xml_start_tag( 'c:txPr' );
    $self->_write_a_body_pr($font->{_rotation});
    $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' );
}


##############################################################################
#
# _write_a_latin()
#
# Write the  element.
#
sub _write_a_latin {

    my $self       = shift;
    my @attributes = @_;

    $self->xml_empty_tag( 'a:latin', @attributes );
}


##############################################################################
#
# _write_d_table()
#
# Write the  element.
#
sub _write_d_table {

    my $self  = shift;
    my $table = $self->{_table};

    return if !$table;

    $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( undef, $table->{_font} );
    }

    $self->xml_end_tag( 'c:dTable' );
}


##############################################################################
#
# _write_show_horz_border()
#
# Write the  element.
#
sub _write_show_horz_border {

    my $self = shift;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:showHorzBorder', @attributes );
}

##############################################################################
#
# _write_show_vert_border()
#
# Write the  element.
#
sub _write_show_vert_border {

    my $self = shift;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:showVertBorder', @attributes );
}


##############################################################################
#
# _write_show_outline()
#
# Write the  element.
#
sub _write_show_outline {

    my $self = shift;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:showOutline', @attributes );
}


##############################################################################
#
# _write_show_keys()
#
# Write the  element.
#
sub _write_show_keys {

    my $self = shift;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:showKeys', @attributes );
}


##############################################################################
#
# _write_error_bars()
#
# Write the X and Y error bars.
#
sub _write_error_bars {

    my $self       = shift;
    my $error_bars = shift;

    return unless $error_bars;

    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} );
    }

}


##############################################################################
#
# _write_err_bars()
#
# Write the  element.
#
sub _write_err_bars {

    my $self       = shift;
    my $direction  = shift;
    my $error_bars = shift;

    return unless $error_bars;

    $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 ( !$error_bars->{_endcap} ) {

        # Write the c:noEndCap element.
        $self->_write_no_end_cap();
    }

    if ( $error_bars->{_type} eq 'stdErr' ) {

        # Don't need to write a c:errValType tag.
    }
    elsif ( $error_bars->{_type} eq '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' );
}


##############################################################################
#
# _write_err_dir()
#
# Write the  element.
#
sub _write_err_dir {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:errDir', @attributes );
}


##############################################################################
#
# _write_err_bar_type()
#
# Write the  element.
#
sub _write_err_bar_type {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:errBarType', @attributes );
}


##############################################################################
#
# _write_err_val_type()
#
# Write the  element.
#
sub _write_err_val_type {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:errValType', @attributes );
}


##############################################################################
#
# _write_no_end_cap()
#
# Write the  element.
#
sub _write_no_end_cap {

    my $self = shift;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:noEndCap', @attributes );
}


##############################################################################
#
# _write_error_val()
#
# Write the  element for error bars.
#
sub _write_error_val {

    my $self = shift;
    my $val  = shift;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:val', @attributes );
}


##############################################################################
#
# _write_custom_error()
#
# Write the custom error bars tags.
#
sub _write_custom_error {

    my $self       = shift;
    my $error_bars = shift;

    if ( $error_bars->{_plus_values} ) {

        # Write the c:plus element.
        $self->xml_start_tag( 'c:plus' );

        if ( ref $error_bars->{_plus_values} eq 'ARRAY' ) {
            $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 ( ref $error_bars->{_minus_values} eq 'ARRAY' ) {
            $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' );
    }
}



##############################################################################
#
# _write_num_lit()
#
# Write the  element for literal number list elements.
#
sub _write_num_lit {

    my $self = shift;
    my $data  = shift;
    my $count = @$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 my $i ( 0 .. $count - 1 ) {
        my $token = $data->[$i];

        # Write non-numeric data as 0.
        if ( defined $token
            && $token !~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/ )
        {
            $token = 0;
        }

        # Write the c:pt element.
        $self->_write_pt( $i, $token );
    }

    $self->xml_end_tag( 'c:numLit' );


}


##############################################################################
#
# _write_up_down_bars()
#
# Write the  element.
#
sub _write_up_down_bars {

    my $self         = shift;
    my $up_down_bars = $self->{_up_down_bars};

    return unless $up_down_bars;

    $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->{_up} );

    # Write the c:downBars element.
    $self->_write_down_bars( $up_down_bars->{_down} );

    $self->xml_end_tag( 'c:upDownBars' );
}


##############################################################################
#
# _write_gap_width()
#
# Write the  element.
#
sub _write_gap_width {

    my $self = shift;
    my $val  = shift;

    return if !defined $val;

    my @attributes = ( 'val' => $val );

    $self->xml_empty_tag( 'c:gapWidth', @attributes );
}

##############################################################################
#
# _write_up_bars()
#
# Write the  element.
#
sub _write_up_bars {

    my $self   = shift;
    my $format = shift;

    if ( $format->{_line}->{_defined} || $format->{_fill}->{_defined} ) {

        $self->xml_start_tag( 'c:upBars' );

        # Write the c:spPr element.
        $self->_write_sp_pr( $format );

        $self->xml_end_tag( 'c:upBars' );
    }
    else {
        $self->xml_empty_tag( 'c:upBars' );
    }
}


##############################################################################
#
# _write_down_bars()
#
# Write the  element.
#
sub _write_down_bars {

    my $self   = shift;
    my $format = shift;

    if ( $format->{_line}->{_defined} || $format->{_fill}->{_defined} ) {

        $self->xml_start_tag( 'c:downBars' );

        # Write the c:spPr element.
        $self->_write_sp_pr( $format );

        $self->xml_end_tag( 'c:downBars' );
    }
    else {
        $self->xml_empty_tag( 'c:downBars' );
    }
}


##############################################################################
#
# _write_c_smooth()
#
# Write the  element.
#
sub _write_c_smooth {

    my $self    = shift;
    my $smooth  = shift;

    return unless $smooth;

    my @attributes = ( 'val' => 1 );

    $self->xml_empty_tag( 'c:smooth', @attributes );
}

##############################################################################
#
# _write_disp_units()
#
# Write the  element.
#
sub _write_disp_units {

    my $self    = shift;
    my $units   = shift;
    my $display = shift;

    return if not $units;

    my @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' );
}


##############################################################################
#
# _write_a_grad_fill()
#
# Write the  element.
#
sub _write_a_grad_fill {

    my $self     = shift;
    my $gradient = shift;


    my @attributes = (
        'flip'         => 'none',
        'rotWithShape' => 1,
    );


    if ( $gradient->{_type} eq 'linear' ) {
        @attributes = ();
    }

    $self->xml_start_tag( 'a:gradFill', @attributes );

    # Write the a:gsLst element.
    $self->_write_a_gs_lst( $gradient );

    if ( $gradient->{_type} eq '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' );
}


##############################################################################
#
# _write_a_gs_lst()
#
# Write the  element.
#
sub _write_a_gs_lst {

    my $self      = shift;
    my $gradient  = shift;
    my $positions = $gradient->{_positions};
    my $colors    = $gradient->{_colors};

    $self->xml_start_tag( 'a:gsLst' );

    for my $i ( 0 .. @$colors -1 ) {

        my $pos = int($positions->[$i] * 1000);

        my @attributes = ( 'pos' => $pos );
        $self->xml_start_tag( 'a:gs', @attributes );

        my $color = $self->_get_color( $colors->[$i] );

        # Write the a:srgbClr element.
        # TODO: Wait for a feature request to support transparency.
        $self->_write_a_srgb_clr( $color );

        $self->xml_end_tag( 'a:gs' );
    }

    $self->xml_end_tag( 'a:gsLst' );
}


##############################################################################
#
# _write_a_lin()
#
# Write the  element.
#
sub _write_a_lin {

    my $self   = shift;
    my $angle  = shift;
    my $scaled = 0;

    $angle = int( 60000 * $angle );

    my @attributes = (
        'ang'    => $angle,
        'scaled' => $scaled,
    );

    $self->xml_empty_tag( 'a:lin', @attributes );
}

##############################################################################
#
# _write_a_path()
#
# Write the  element.
#
sub _write_a_path {

    my $self = shift;
    my $type = shift;


    my @attributes = ( 'path' => $type );

    $self->xml_start_tag( 'a:path', @attributes );

    # Write the a:fillToRect element.
    $self->_write_a_fill_to_rect( $type );

    $self->xml_end_tag( 'a:path' );
}


##############################################################################
#
# _write_a_fill_to_rect()
#
# Write the  element.
#
sub _write_a_fill_to_rect {

    my $self       = shift;
    my $type       = shift;
    my @attributes = ();

    if ( $type eq 'shape' ) {
        @attributes = (
            'l' => 50000,
            't' => 50000,
            'r' => 50000,
            'b' => 50000,
        );

    }
    else {
        @attributes = (
            'l' => 100000,
            't' => 100000,
        );
    }


    $self->xml_empty_tag( 'a:fillToRect', @attributes );
}


##############################################################################
#
# _write_a_tile_rect()
#
# Write the  element.
#
sub _write_a_tile_rect {

    my $self       = shift;
    my $type       = shift;
    my @attributes = ();

    if ( $type eq 'shape' ) {
        @attributes = ();
    }
    else {
        @attributes = (
            'r' => -100000,
            'b' => -100000,
        );
    }

    $self->xml_empty_tag( 'a:tileRect', @attributes );
}


##############################################################################
#
# _write_a_patt_fill()
#
# Write the  element.
#
sub _write_a_patt_fill {

    my $self     = shift;
    my $pattern  = shift;

    my @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' );
}


##############################################################################
#
# _write_a_fg_clr()
#
# Write the  element.
#
sub _write_a_fg_clr {

    my $self  = shift;
    my $color = shift;

    $color = $self->_get_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' );
}



##############################################################################
#
# _write_a_bg_clr()
#
# Write the  element.
#
sub _write_a_bg_clr {

    my $self  = shift;
    my $color = shift;

    $color = $self->_get_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' );
}


1;

__END__