internal SLGroupDataLabelOptions Clone()
        {
            var gdlo = new SLGroupDataLabelOptions(ShapeProperties.listThemeColors);

            gdlo.Rotation           = Rotation;
            gdlo.Vertical           = Vertical;
            gdlo.Anchor             = Anchor;
            gdlo.AnchorCenter       = AnchorCenter;
            gdlo.HasNumberingFormat = HasNumberingFormat;
            gdlo.sFormatCode        = sFormatCode;
            gdlo.bSourceLinked      = bSourceLinked;
            gdlo.vLabelPosition     = vLabelPosition;
            gdlo.ShapeProperties    = ShapeProperties.Clone();
            gdlo.ShowLegendKey      = ShowLegendKey;
            gdlo.ShowValue          = ShowValue;
            gdlo.ShowCategoryName   = ShowCategoryName;
            gdlo.ShowSeriesName     = ShowSeriesName;
            gdlo.ShowPercentage     = ShowPercentage;
            gdlo.ShowBubbleSize     = ShowBubbleSize;
            gdlo.Separator          = Separator;
            gdlo.ShowLeaderLines    = ShowLeaderLines;

            return(gdlo);
        }
        internal C.PieChartSeries ToPieChartSeries(bool IsStylish = false)
        {
            var pcs = new C.PieChartSeries();

            pcs.Index = new C.Index {
                Val = Index
            };
            pcs.Order = new C.Order {
                Val = Order
            };

            if (IsStringReference != null)
            {
                pcs.SeriesText = new C.SeriesText();
                if (IsStringReference.Value)
                {
                    pcs.SeriesText.StringReference = StringReference.ToStringReference();
                }
                else
                {
                    pcs.SeriesText.NumericValue = new C.NumericValue(NumericValue);
                }
            }

            if (Options.ShapeProperties.HasShapeProperties)
            {
                pcs.ChartShapeProperties = Options.ShapeProperties.ToChartShapeProperties(IsStylish);
            }

            if (Options.iExplosion != null)
            {
                pcs.Explosion = new C.Explosion {
                    Val = Options.Explosion
                }
            }
            ;

            if (DataPointOptionsList.Count > 0)
            {
                var indexlist = DataPointOptionsList.Keys.ToList();
                indexlist.Sort();
                int index;
                for (var i = 0; i < indexlist.Count; ++i)
                {
                    index = indexlist[i];
                    pcs.Append(DataPointOptionsList[index].ToDataPoint(index, IsStylish));
                }
            }

            if ((GroupDataLabelOptions != null) || (DataLabelOptionsList.Count > 0))
            {
                if (GroupDataLabelOptions == null)
                {
                    var gdloptions = new SLGroupDataLabelOptions(new List <Color>());
                    pcs.Append(gdloptions.ToDataLabels(DataLabelOptionsList, true));
                }
                else
                {
                    pcs.Append(GroupDataLabelOptions.ToDataLabels(DataLabelOptionsList, false));
                }
            }

            pcs.Append(AxisData.ToCategoryAxisData());
            pcs.Append(NumberData.ToValues());

            return(pcs);
        }
        internal C.ScatterChartSeries ToScatterChartSeries(bool IsStylish = false)
        {
            var scs = new C.ScatterChartSeries();

            scs.Index = new C.Index {
                Val = Index
            };
            scs.Order = new C.Order {
                Val = Order
            };

            if (IsStringReference != null)
            {
                scs.SeriesText = new C.SeriesText();
                if (IsStringReference.Value)
                {
                    scs.SeriesText.StringReference = StringReference.ToStringReference();
                }
                else
                {
                    scs.SeriesText.NumericValue = new C.NumericValue(NumericValue);
                }
            }

            if (Options.ShapeProperties.HasShapeProperties)
            {
                scs.ChartShapeProperties = Options.ShapeProperties.ToChartShapeProperties(IsStylish);
            }

            if (Options.Marker.HasMarker)
            {
                scs.Marker = Options.Marker.ToMarker(IsStylish);
            }

            if (DataPointOptionsList.Count > 0)
            {
                var indexlist = DataPointOptionsList.Keys.ToList();
                indexlist.Sort();
                int index;
                for (var i = 0; i < indexlist.Count; ++i)
                {
                    index = indexlist[i];
                    scs.Append(DataPointOptionsList[index].ToDataPoint(index, IsStylish));
                }
            }

            if ((GroupDataLabelOptions != null) || (DataLabelOptionsList.Count > 0))
            {
                if (GroupDataLabelOptions == null)
                {
                    var gdloptions = new SLGroupDataLabelOptions(new List <Color>());
                    scs.Append(gdloptions.ToDataLabels(DataLabelOptionsList, true));
                }
                else
                {
                    scs.Append(GroupDataLabelOptions.ToDataLabels(DataLabelOptionsList, false));
                }
            }

            scs.Append(AxisData.ToXValues());
            scs.Append(NumberData.ToYValues());

            scs.Append(new C.Smooth {
                Val = Options.Smooth
            });

            return(scs);
        }
        internal C.BubbleChartSeries ToBubbleChartSeries(bool IsStylish = false)
        {
            var bcs = new C.BubbleChartSeries();

            bcs.Index = new C.Index {
                Val = Index
            };
            bcs.Order = new C.Order {
                Val = Order
            };

            if (IsStringReference != null)
            {
                bcs.SeriesText = new C.SeriesText();
                if (IsStringReference.Value)
                {
                    bcs.SeriesText.StringReference = StringReference.ToStringReference();
                }
                else
                {
                    bcs.SeriesText.NumericValue = new C.NumericValue(NumericValue);
                }
            }

            if (Options.ShapeProperties.HasShapeProperties)
            {
                bcs.ChartShapeProperties = Options.ShapeProperties.ToChartShapeProperties(IsStylish);
            }

            bcs.InvertIfNegative = new C.InvertIfNegative {
                Val = Options.InvertIfNegative ?? false
            };

            if (DataPointOptionsList.Count > 0)
            {
                var indexlist = DataPointOptionsList.Keys.ToList();
                indexlist.Sort();
                int index;
                for (var i = 0; i < indexlist.Count; ++i)
                {
                    index = indexlist[i];
                    bcs.Append(DataPointOptionsList[index].ToDataPoint(index, IsStylish));
                }
            }

            if ((GroupDataLabelOptions != null) || (DataLabelOptionsList.Count > 0))
            {
                if (GroupDataLabelOptions == null)
                {
                    var gdloptions = new SLGroupDataLabelOptions(new List <Color>());
                    bcs.Append(gdloptions.ToDataLabels(DataLabelOptionsList, true));
                }
                else
                {
                    bcs.Append(GroupDataLabelOptions.ToDataLabels(DataLabelOptionsList, false));
                }
            }

            bcs.Append(AxisData.ToXValues());
            bcs.Append(NumberData.ToYValues());
            bcs.Append(BubbleSize.ToBubbleSize());

            if (Options.bBubble3D != null)
            {
                bcs.Append(new C.Bubble3D {
                    Val = Options.Bubble3D
                });
            }

            return(bcs);
        }
        internal C.PlotArea ToPlotArea(bool IsStylish = false)
        {
            var pa = new C.PlotArea();

            pa.Append(Layout.ToLayout());

            int iChartType;
            int i;

            // TODO: the rendering order is sort of listed in the following.
            // But apparently if you plot data series for doughnut first before bar-of-pie
            // it's different than if you plot bar-of-pie then doughnut.
            // Find out the "correct" order next version I suppose...

            // Excel 2010 apparently sets this by default for any chart...
            var gdlo = new SLGroupDataLabelOptions(ShapeProperties.listThemeColors);

            gdlo.ShowLegendKey    = false;
            gdlo.ShowValue        = false;
            gdlo.ShowCategoryName = false;
            gdlo.ShowSeriesName   = false;
            gdlo.ShowPercentage   = false;
            gdlo.ShowBubbleSize   = false;

            #region Doughnut

            iChartType = (int)SLDataSeriesChartType.DoughnutChart;
            if (UsedChartTypes[iChartType])
            {
                var dc = new C.DoughnutChart();
                dc.VaryColors = new C.VaryColors {
                    Val = UsedChartOptions[iChartType].VaryColors ?? true
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        dc.Append(DataSeries[i].ToPieChartSeries(IsStylish));
                    }
                }

                dc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                dc.Append(new C.FirstSliceAngle {
                    Val = UsedChartOptions[iChartType].FirstSliceAngle
                });
                dc.Append(new C.HoleSize {
                    Val = UsedChartOptions[iChartType].HoleSize
                });

                pa.Append(dc);
            }

            #endregion

            #region Bar-of-pie

            iChartType = (int)SLDataSeriesChartType.OfPieChartBar;
            if (UsedChartTypes[iChartType])
            {
                var opc = new C.OfPieChart();
                opc.OfPieType = new C.OfPieType {
                    Val = C.OfPieValues.Bar
                };
                opc.VaryColors = new C.VaryColors {
                    Val = UsedChartOptions[iChartType].VaryColors ?? true
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        opc.Append(DataSeries[i].ToPieChartSeries(IsStylish));
                    }
                }

                opc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                opc.Append(new C.GapWidth {
                    Val = UsedChartOptions[iChartType].GapWidth
                });

                if (UsedChartOptions[iChartType].HasSplit)
                {
                    opc.Append(new C.SplitType {
                        Val = UsedChartOptions[iChartType].SplitType
                    });
                    if (UsedChartOptions[iChartType].SplitType != C.SplitValues.Custom)
                    {
                        opc.Append(new C.SplitPosition {
                            Val = UsedChartOptions[iChartType].SplitPosition
                        });
                    }
                    else
                    {
                        var custsplit = new C.CustomSplit();
                        foreach (var iPiePoint in UsedChartOptions[iChartType].SecondPiePoints)
                        {
                            custsplit.Append(new C.SecondPiePoint {
                                Val = (uint)iPiePoint
                            });
                        }
                        opc.Append(custsplit);
                    }
                }

                opc.Append(new C.SecondPieSize {
                    Val = UsedChartOptions[iChartType].SecondPieSize
                });

                if (UsedChartOptions[iChartType].SeriesLinesShapeProperties.HasShapeProperties)
                {
                    opc.Append(new C.SeriesLines
                    {
                        ChartShapeProperties =
                            UsedChartOptions[iChartType].SeriesLinesShapeProperties.ToChartShapeProperties()
                    });
                }
                else
                {
                    opc.Append(new C.SeriesLines());
                }

                pa.Append(opc);
            }

            #endregion

            #region Pie-of-pie

            iChartType = (int)SLDataSeriesChartType.OfPieChartPie;
            if (UsedChartTypes[iChartType])
            {
                var opc = new C.OfPieChart();
                opc.OfPieType = new C.OfPieType {
                    Val = C.OfPieValues.Pie
                };
                opc.VaryColors = new C.VaryColors {
                    Val = UsedChartOptions[iChartType].VaryColors ?? true
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        opc.Append(DataSeries[i].ToPieChartSeries(IsStylish));
                    }
                }

                opc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                opc.Append(new C.GapWidth {
                    Val = UsedChartOptions[iChartType].GapWidth
                });

                if (UsedChartOptions[iChartType].HasSplit)
                {
                    opc.Append(new C.SplitType {
                        Val = UsedChartOptions[iChartType].SplitType
                    });
                    if (UsedChartOptions[iChartType].SplitType != C.SplitValues.Custom)
                    {
                        opc.Append(new C.SplitPosition {
                            Val = UsedChartOptions[iChartType].SplitPosition
                        });
                    }
                    else
                    {
                        var custsplit = new C.CustomSplit();
                        foreach (var iPiePoint in UsedChartOptions[iChartType].SecondPiePoints)
                        {
                            custsplit.Append(new C.SecondPiePoint {
                                Val = (uint)iPiePoint
                            });
                        }
                        opc.Append(custsplit);
                    }
                }

                opc.Append(new C.SecondPieSize {
                    Val = UsedChartOptions[iChartType].SecondPieSize
                });

                if (UsedChartOptions[iChartType].SeriesLinesShapeProperties.HasShapeProperties)
                {
                    opc.Append(new C.SeriesLines
                    {
                        ChartShapeProperties =
                            UsedChartOptions[iChartType].SeriesLinesShapeProperties.ToChartShapeProperties()
                    });
                }
                else
                {
                    opc.Append(new C.SeriesLines());
                }

                pa.Append(opc);
            }

            #endregion

            #region Pie

            iChartType = (int)SLDataSeriesChartType.PieChart;
            if (UsedChartTypes[iChartType])
            {
                var pc = new C.PieChart();
                pc.VaryColors = new C.VaryColors {
                    Val = UsedChartOptions[iChartType].VaryColors ?? true
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        pc.Append(DataSeries[i].ToPieChartSeries(IsStylish));
                    }
                }

                pc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                pc.Append(new C.FirstSliceAngle {
                    Val = UsedChartOptions[iChartType].FirstSliceAngle
                });

                pa.Append(pc);
            }

            #endregion

            #region Radar primary

            iChartType = (int)SLDataSeriesChartType.RadarChartPrimary;
            if (UsedChartTypes[iChartType])
            {
                var rc = new C.RadarChart();
                rc.RadarStyle = new C.RadarStyle {
                    Val = UsedChartOptions[iChartType].RadarStyle
                };
                rc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        rc.Append(DataSeries[i].ToRadarChartSeries(IsStylish));
                    }
                }

                rc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                rc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                rc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });

                pa.Append(rc);
            }

            #endregion

            #region Radar secondary

            iChartType = (int)SLDataSeriesChartType.RadarChartSecondary;
            if (UsedChartTypes[iChartType])
            {
                var rc = new C.RadarChart();
                rc.RadarStyle = new C.RadarStyle {
                    Val = UsedChartOptions[iChartType].RadarStyle
                };
                rc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        rc.Append(DataSeries[i].ToRadarChartSeries(IsStylish));
                    }
                }

                rc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                rc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis1
                });
                rc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis2
                });

                pa.Append(rc);
            }

            #endregion

            #region Area primary

            iChartType = (int)SLDataSeriesChartType.AreaChartPrimary;
            if (UsedChartTypes[iChartType])
            {
                var ac = new C.AreaChart();
                ac.Grouping = new C.Grouping {
                    Val = UsedChartOptions[iChartType].Grouping
                };
                ac.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        ac.Append(DataSeries[i].ToAreaChartSeries(IsStylish));
                    }
                }

                ac.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                if (UsedChartOptions[iChartType].HasDropLines)
                {
                    ac.Append(UsedChartOptions[iChartType].DropLines.ToDropLines(IsStylish));
                }

                ac.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                ac.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });

                pa.Append(ac);
            }

            #endregion

            #region Area secondary

            iChartType = (int)SLDataSeriesChartType.AreaChartSecondary;
            if (UsedChartTypes[iChartType])
            {
                var ac = new C.AreaChart();
                ac.Grouping = new C.Grouping {
                    Val = UsedChartOptions[iChartType].Grouping
                };
                ac.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        ac.Append(DataSeries[i].ToAreaChartSeries(IsStylish));
                    }
                }

                ac.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                if (UsedChartOptions[iChartType].HasDropLines)
                {
                    ac.Append(UsedChartOptions[iChartType].DropLines.ToDropLines(IsStylish));
                }

                ac.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis1
                });
                ac.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis2
                });

                pa.Append(ac);
            }

            #endregion

            #region Column primary

            iChartType = (int)SLDataSeriesChartType.BarChartColumnPrimary;
            if (UsedChartTypes[iChartType])
            {
                var bc = new C.BarChart();
                bc.BarDirection = new C.BarDirection {
                    Val = C.BarDirectionValues.Column
                };
                bc.BarGrouping = new C.BarGrouping {
                    Val = UsedChartOptions[iChartType].BarGrouping
                };
                bc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        bc.Append(DataSeries[i].ToBarChartSeries(IsStylish));
                    }
                }

                bc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                bc.Append(new C.GapWidth {
                    Val = UsedChartOptions[iChartType].GapWidth
                });

                if (UsedChartOptions[iChartType].Overlap != 0)
                {
                    bc.Append(new C.Overlap {
                        Val = UsedChartOptions[iChartType].Overlap
                    });
                }

                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });

                pa.Append(bc);
            }

            #endregion

            #region Column secondary

            iChartType = (int)SLDataSeriesChartType.BarChartColumnSecondary;
            if (UsedChartTypes[iChartType])
            {
                var bc = new C.BarChart();
                bc.BarDirection = new C.BarDirection {
                    Val = C.BarDirectionValues.Column
                };
                bc.BarGrouping = new C.BarGrouping {
                    Val = UsedChartOptions[iChartType].BarGrouping
                };
                bc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        bc.Append(DataSeries[i].ToBarChartSeries(IsStylish));
                    }
                }

                bc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                bc.Append(new C.GapWidth {
                    Val = UsedChartOptions[iChartType].GapWidth
                });

                if (UsedChartOptions[iChartType].Overlap != 0)
                {
                    bc.Append(new C.Overlap {
                        Val = UsedChartOptions[iChartType].Overlap
                    });
                }

                bc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis1
                });
                bc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis2
                });

                pa.Append(bc);
            }

            #endregion

            #region Bar primary

            iChartType = (int)SLDataSeriesChartType.BarChartBarPrimary;
            if (UsedChartTypes[iChartType])
            {
                var bc = new C.BarChart();
                bc.BarDirection = new C.BarDirection {
                    Val = C.BarDirectionValues.Bar
                };
                bc.BarGrouping = new C.BarGrouping {
                    Val = UsedChartOptions[iChartType].BarGrouping
                };
                bc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        bc.Append(DataSeries[i].ToBarChartSeries(IsStylish));
                    }
                }

                bc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                bc.Append(new C.GapWidth {
                    Val = UsedChartOptions[iChartType].GapWidth
                });

                if (UsedChartOptions[iChartType].Overlap != 0)
                {
                    bc.Append(new C.Overlap {
                        Val = UsedChartOptions[iChartType].Overlap
                    });
                }

                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });

                pa.Append(bc);
            }

            #endregion

            #region Bar secondary

            iChartType = (int)SLDataSeriesChartType.BarChartBarSecondary;
            if (UsedChartTypes[iChartType])
            {
                var bc = new C.BarChart();
                bc.BarDirection = new C.BarDirection {
                    Val = C.BarDirectionValues.Bar
                };
                bc.BarGrouping = new C.BarGrouping {
                    Val = UsedChartOptions[iChartType].BarGrouping
                };
                bc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        bc.Append(DataSeries[i].ToBarChartSeries(IsStylish));
                    }
                }

                bc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                bc.Append(new C.GapWidth {
                    Val = UsedChartOptions[iChartType].GapWidth
                });

                if (UsedChartOptions[iChartType].Overlap != 0)
                {
                    bc.Append(new C.Overlap {
                        Val = UsedChartOptions[iChartType].Overlap
                    });
                }

                bc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis1
                });
                bc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis2
                });

                pa.Append(bc);
            }

            #endregion

            #region Scatter primary

            iChartType = (int)SLDataSeriesChartType.ScatterChartPrimary;
            if (UsedChartTypes[iChartType])
            {
                var sc = new C.ScatterChart();
                sc.ScatterStyle = new C.ScatterStyle {
                    Val = UsedChartOptions[iChartType].ScatterStyle
                };
                sc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        sc.Append(DataSeries[i].ToScatterChartSeries(IsStylish));
                    }
                }

                sc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                sc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                sc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });

                pa.Append(sc);
            }

            #endregion

            #region Scatter secondary

            iChartType = (int)SLDataSeriesChartType.ScatterChartSecondary;
            if (UsedChartTypes[iChartType])
            {
                var sc = new C.ScatterChart();
                sc.ScatterStyle = new C.ScatterStyle {
                    Val = UsedChartOptions[iChartType].ScatterStyle
                };
                sc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        sc.Append(DataSeries[i].ToScatterChartSeries(IsStylish));
                    }
                }

                sc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                sc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis1
                });
                sc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis2
                });

                pa.Append(sc);
            }

            #endregion

            #region Line primary

            iChartType = (int)SLDataSeriesChartType.LineChartPrimary;
            if (UsedChartTypes[iChartType])
            {
                var lc = new C.LineChart();
                lc.Grouping = new C.Grouping {
                    Val = UsedChartOptions[iChartType].Grouping
                };
                lc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        lc.Append(DataSeries[i].ToLineChartSeries(IsStylish));
                    }
                }

                lc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                if (UsedChartOptions[iChartType].HasDropLines)
                {
                    lc.Append(UsedChartOptions[iChartType].DropLines.ToDropLines(IsStylish));
                }

                lc.Append(new C.ShowMarker {
                    Val = UsedChartOptions[iChartType].ShowMarker
                });
                lc.Append(new C.Smooth {
                    Val = UsedChartOptions[iChartType].Smooth
                });

                lc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                lc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });

                pa.Append(lc);
            }

            #endregion

            #region Line secondary

            iChartType = (int)SLDataSeriesChartType.LineChartSecondary;
            if (UsedChartTypes[iChartType])
            {
                var lc = new C.LineChart();
                lc.Grouping = new C.Grouping {
                    Val = UsedChartOptions[iChartType].Grouping
                };
                lc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        lc.Append(DataSeries[i].ToLineChartSeries(IsStylish));
                    }
                }

                lc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                if (UsedChartOptions[iChartType].HasDropLines)
                {
                    lc.Append(UsedChartOptions[iChartType].DropLines.ToDropLines(IsStylish));
                }

                lc.Append(new C.ShowMarker {
                    Val = UsedChartOptions[iChartType].ShowMarker
                });
                lc.Append(new C.Smooth {
                    Val = UsedChartOptions[iChartType].Smooth
                });

                lc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis1
                });
                lc.Append(new C.AxisId {
                    Val = SLConstants.SecondaryAxis2
                });

                pa.Append(lc);
            }

            #endregion

            #region Area3D

            iChartType = (int)SLDataSeriesChartType.Area3DChart;
            if (UsedChartTypes[iChartType])
            {
                var ac = new C.Area3DChart();
                ac.Grouping = new C.Grouping {
                    Val = UsedChartOptions[iChartType].Grouping
                };
                ac.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        ac.Append(DataSeries[i].ToAreaChartSeries(IsStylish));
                    }
                }

                ac.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                if (UsedChartOptions[iChartType].GapDepth != 150)
                {
                    ac.Append(new C.GapDepth {
                        Val = UsedChartOptions[iChartType].GapDepth
                    });
                }

                ac.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                ac.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });
                ac.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis3
                });

                pa.Append(ac);
            }

            #endregion

            #region Bar3D

            iChartType = (int)SLDataSeriesChartType.Bar3DChart;
            if (UsedChartTypes[iChartType])
            {
                var bc = new C.Bar3DChart();
                bc.BarDirection = new C.BarDirection {
                    Val = UsedChartOptions[iChartType].BarDirection
                };
                bc.BarGrouping = new C.BarGrouping {
                    Val = UsedChartOptions[iChartType].BarGrouping
                };
                bc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        bc.Append(DataSeries[i].ToBarChartSeries(IsStylish));
                    }
                }

                bc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                bc.Append(new C.GapWidth {
                    Val = UsedChartOptions[iChartType].GapWidth
                });

                if (UsedChartOptions[iChartType].GapDepth != 150)
                {
                    bc.Append(new C.GapDepth {
                        Val = UsedChartOptions[iChartType].GapDepth
                    });
                }

                bc.Append(new C.Shape {
                    Val = UsedChartOptions[iChartType].Shape
                });

                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });
                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis3
                });

                pa.Append(bc);
            }

            #endregion

            #region Bubble

            iChartType = (int)SLDataSeriesChartType.BubbleChart;
            if (UsedChartTypes[iChartType])
            {
                var bc = new C.BubbleChart();
                bc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        bc.Append(DataSeries[i].ToBubbleChartSeries(IsStylish));
                    }
                }

                bc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                if (!UsedChartOptions[iChartType].Bubble3D)
                {
                    bc.Append(new C.Bubble3D {
                        Val = UsedChartOptions[iChartType].Bubble3D
                    });
                }

                if (UsedChartOptions[iChartType].BubbleScale != 100)
                {
                    bc.Append(new C.BubbleScale {
                        Val = UsedChartOptions[iChartType].BubbleScale
                    });
                }

                if (!UsedChartOptions[iChartType].ShowNegativeBubbles)
                {
                    bc.Append(new C.ShowNegativeBubbles {
                        Val = UsedChartOptions[iChartType].ShowNegativeBubbles
                    });
                }

                if (UsedChartOptions[iChartType].SizeRepresents != C.SizeRepresentsValues.Area)
                {
                    bc.Append(new C.SizeRepresents {
                        Val = UsedChartOptions[iChartType].SizeRepresents
                    });
                }

                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                bc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });

                pa.Append(bc);
            }

            #endregion

            #region Line3D

            iChartType = (int)SLDataSeriesChartType.Line3DChart;
            if (UsedChartTypes[iChartType])
            {
                var lc = new C.Line3DChart();
                lc.Grouping = new C.Grouping {
                    Val = UsedChartOptions[iChartType].Grouping
                };
                lc.VaryColors = new C.VaryColors {
                    Val = false
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        lc.Append(DataSeries[i].ToLineChartSeries(IsStylish));
                    }
                }

                lc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                if (UsedChartOptions[iChartType].HasDropLines)
                {
                    lc.Append(UsedChartOptions[iChartType].DropLines.ToDropLines(IsStylish));
                }

                if (UsedChartOptions[iChartType].GapDepth != 150)
                {
                    lc.Append(new C.GapDepth {
                        Val = UsedChartOptions[iChartType].GapDepth
                    });
                }

                lc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                lc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });
                lc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis3
                });

                pa.Append(lc);
            }

            #endregion

            #region Pie3D

            iChartType = (int)SLDataSeriesChartType.Pie3DChart;
            if (UsedChartTypes[iChartType])
            {
                var pc = new C.Pie3DChart();
                pc.VaryColors = new C.VaryColors {
                    Val = UsedChartOptions[iChartType].VaryColors ?? true
                };

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        pc.Append(DataSeries[i].ToPieChartSeries(IsStylish));
                    }
                }

                pc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                pa.Append(pc);
            }

            #endregion

            #region Surface

            iChartType = (int)SLDataSeriesChartType.SurfaceChart;
            if (UsedChartTypes[iChartType])
            {
                var sc = new C.SurfaceChart();
                if (UsedChartOptions[iChartType].bWireframe != null)
                {
                    sc.Wireframe = new C.Wireframe {
                        Val = UsedChartOptions[iChartType].Wireframe
                    }
                }
                ;

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        sc.Append(DataSeries[i].ToSurfaceChartSeries(IsStylish));
                    }
                }

                sc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                sc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });
                sc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis3
                });

                pa.Append(sc);
            }

            #endregion

            #region Surface3D

            iChartType = (int)SLDataSeriesChartType.Surface3DChart;
            if (UsedChartTypes[iChartType])
            {
                var sc = new C.Surface3DChart();
                if (UsedChartOptions[iChartType].bWireframe != null)
                {
                    sc.Wireframe = new C.Wireframe {
                        Val = UsedChartOptions[iChartType].Wireframe
                    }
                }
                ;

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        sc.Append(DataSeries[i].ToSurfaceChartSeries(IsStylish));
                    }
                }

                sc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis1
                });
                sc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis2
                });
                sc.Append(new C.AxisId {
                    Val = SLConstants.PrimaryAxis3
                });

                pa.Append(sc);
            }

            #endregion

            #region Stock

            iChartType = (int)SLDataSeriesChartType.StockChart;
            if (UsedChartTypes[iChartType])
            {
                var sc = new C.StockChart();

                for (i = 0; i < DataSeries.Count; ++i)
                {
                    if ((int)DataSeries[i].ChartType == iChartType)
                    {
                        sc.Append(DataSeries[i].ToLineChartSeries(IsStylish));
                    }
                }

                sc.Append(gdlo.ToDataLabels(new Dictionary <int, SLDataLabelOptions>(), false));

                if (UsedChartOptions[iChartType].HasDropLines)
                {
                    sc.Append(UsedChartOptions[iChartType].DropLines.ToDropLines(IsStylish));
                }

                if (UsedChartOptions[iChartType].HasHighLowLines)
                {
                    sc.Append(UsedChartOptions[iChartType].HighLowLines.ToHighLowLines(IsStylish));
                }

                if (UsedChartOptions[iChartType].HasUpDownBars)
                {
                    sc.Append(UsedChartOptions[iChartType].UpDownBars.ToUpDownBars(IsStylish));
                }

                // stock charts either have a bar chart as the primary chart (the Volume) or doesn't.
                // If there is, then it's either a Volume-High-Low-Close or Volumn-Open-High-Low-Close,
                // so we use the secondary axis IDs.
                if (UsedChartTypes[(int)SLDataSeriesChartType.BarChartColumnPrimary])
                {
                    sc.Append(new C.AxisId {
                        Val = SLConstants.SecondaryAxis1
                    });
                    sc.Append(new C.AxisId {
                        Val = SLConstants.SecondaryAxis2
                    });
                }
                else
                {
                    sc.Append(new C.AxisId {
                        Val = SLConstants.PrimaryAxis1
                    });
                    sc.Append(new C.AxisId {
                        Val = SLConstants.PrimaryAxis2
                    });
                }

                pa.Append(sc);
            }

            #endregion

            if (HasPrimaryAxes)
            {
                PrimaryTextAxis.IsCrosses = PrimaryValueAxis.OtherAxisIsCrosses;
                PrimaryTextAxis.Crosses   = PrimaryValueAxis.OtherAxisCrosses;
                PrimaryTextAxis.CrossesAt = PrimaryValueAxis.OtherAxisCrossesAt;

                PrimaryTextAxis.OtherAxisIsInReverseOrder = PrimaryValueAxis.InReverseOrder;

                if ((PrimaryValueAxis.OtherAxisIsCrosses != null) &&
                    PrimaryValueAxis.OtherAxisIsCrosses.Value &&
                    (PrimaryValueAxis.OtherAxisCrosses == C.CrossesValues.Maximum))
                {
                    PrimaryTextAxis.OtherAxisCrossedAtMaximum = true;
                }
                else
                {
                    PrimaryTextAxis.OtherAxisCrossedAtMaximum = false;
                }

                PrimaryValueAxis.IsCrosses = PrimaryTextAxis.OtherAxisIsCrosses;
                PrimaryValueAxis.Crosses   = PrimaryTextAxis.OtherAxisCrosses;
                PrimaryValueAxis.CrossesAt = PrimaryTextAxis.OtherAxisCrossesAt;

                PrimaryValueAxis.OtherAxisIsInReverseOrder = PrimaryTextAxis.InReverseOrder;

                if ((PrimaryTextAxis.OtherAxisIsCrosses != null) &&
                    PrimaryTextAxis.OtherAxisIsCrosses.Value &&
                    (PrimaryTextAxis.OtherAxisCrosses == C.CrossesValues.Maximum))
                {
                    PrimaryValueAxis.OtherAxisCrossedAtMaximum = true;
                }
                else
                {
                    PrimaryValueAxis.OtherAxisCrossedAtMaximum = false;
                }

                switch (PrimaryTextAxis.AxisType)
                {
                case SLAxisType.Category:
                    pa.Append(PrimaryTextAxis.ToCategoryAxis(IsStylish));
                    break;

                case SLAxisType.Date:
                    pa.Append(PrimaryTextAxis.ToDateAxis(IsStylish));
                    break;

                case SLAxisType.Value:
                    pa.Append(PrimaryTextAxis.ToValueAxis(IsStylish));
                    break;
                }
                pa.Append(PrimaryValueAxis.ToValueAxis(IsStylish));
            }

            if (HasDepthAxis)
            {
                pa.Append(DepthAxis.ToSeriesAxis(IsStylish));
            }

            if (HasSecondaryAxes)
            {
                SecondaryTextAxis.IsCrosses = SecondaryValueAxis.OtherAxisIsCrosses;
                SecondaryTextAxis.Crosses   = SecondaryValueAxis.OtherAxisCrosses;
                SecondaryTextAxis.CrossesAt = SecondaryValueAxis.OtherAxisCrossesAt;

                SecondaryTextAxis.OtherAxisIsInReverseOrder = SecondaryValueAxis.InReverseOrder;

                if ((SecondaryValueAxis.OtherAxisIsCrosses != null) &&
                    SecondaryValueAxis.OtherAxisIsCrosses.Value &&
                    (SecondaryValueAxis.OtherAxisCrosses == C.CrossesValues.Maximum))
                {
                    SecondaryTextAxis.OtherAxisCrossedAtMaximum = true;
                }
                else
                {
                    SecondaryTextAxis.OtherAxisCrossedAtMaximum = false;
                }

                SecondaryValueAxis.IsCrosses = SecondaryTextAxis.OtherAxisIsCrosses;
                SecondaryValueAxis.Crosses   = SecondaryTextAxis.OtherAxisCrosses;
                SecondaryValueAxis.CrossesAt = SecondaryTextAxis.OtherAxisCrossesAt;

                SecondaryValueAxis.OtherAxisIsInReverseOrder = SecondaryTextAxis.InReverseOrder;

                if ((SecondaryTextAxis.OtherAxisIsCrosses != null) &&
                    SecondaryTextAxis.OtherAxisIsCrosses.Value &&
                    (SecondaryTextAxis.OtherAxisCrosses == C.CrossesValues.Maximum))
                {
                    SecondaryValueAxis.OtherAxisCrossedAtMaximum = true;
                }
                else
                {
                    SecondaryValueAxis.OtherAxisCrossedAtMaximum = false;
                }

                // the order of axes is:
                // 1) primary category/date/value axis
                // 2) primary value axis
                // 3) secondary value axis
                // 4) secondary category/date/value axis
                pa.Append(SecondaryValueAxis.ToValueAxis(IsStylish));
                switch (SecondaryTextAxis.AxisType)
                {
                case SLAxisType.Category:
                    pa.Append(SecondaryTextAxis.ToCategoryAxis(IsStylish));
                    break;

                case SLAxisType.Date:
                    pa.Append(SecondaryTextAxis.ToDateAxis(IsStylish));
                    break;

                case SLAxisType.Value:
                    pa.Append(SecondaryTextAxis.ToValueAxis(IsStylish));
                    break;
                }
            }

            if (ShowDataTable)
            {
                pa.Append(DataTable.ToDataTable(IsStylish));
            }

            if (ShapeProperties.HasShapeProperties)
            {
                pa.Append(ShapeProperties.ToChartShapeProperties(IsStylish));
            }

            return(pa);
        }