﻿/*******************************************************************************
 * You may amend and distribute as you like, but don't remove this header!
 *
 * EPPlus provides server-side generation of Excel 2007/2010 spreadsheets.
 * See http://www.codeplex.com/EPPlus for details.
 *
 * Copyright (C) 2011  Jan Källman
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 * See the GNU Lesser General Public License for more details.
 *
 * The GNU Lesser General Public License can be viewed at http://www.opensource.org/licenses/lgpl-license.php
 * If you unfamiliar with this license or have questions about it, here is an http://www.gnu.org/licenses/gpl-faq.html
 *
 * All code and executables are provided "as is" with no warranty either express or implied. 
 * The author accepts no liability for any damage or loss of business that this product may cause.
 *
 * Code change notes:
 * 
 * Author							Change						Date
 *******************************************************************************
 * Jan Källman		Added		2009-10-01
 * Jan Källman		License changed GPL-->LGPL 2011-12-16
 *******************************************************************************/
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Xml;
using System.IO;
using OfficeOpenXml.Table.PivotTable;
using OfficeOpenXml.Utils;
using OfficeOpenXml.Packaging;

namespace OfficeOpenXml.Drawing.Chart
{
    #region "Chart Enums"
    /// <summary>
    /// Chart type
    /// </summary>
    public enum eChartType
    {
        Area3D=-4098,
        AreaStacked3D=78,
        AreaStacked1003D=79,
        BarClustered3D= 60,
        BarStacked3D=61,
        BarStacked1003D=62,
        Column3D=-4100,
        ColumnClustered3D=54,
        ColumnStacked3D=55,
        ColumnStacked1003D=56,
        Line3D=-4101,
        Pie3D=-4102,
        PieExploded3D=70,
        Area=1,
        AreaStacked=76,
        AreaStacked100=77,
        BarClustered=57,
        BarOfPie=71,
        BarStacked=58,
        BarStacked100=59,
        Bubble=15,
        Bubble3DEffect=87,
        ColumnClustered=51,
        ColumnStacked=52,
        ColumnStacked100=53,
        ConeBarClustered=102,
        ConeBarStacked=103,
        ConeBarStacked100=104,
        ConeCol=105,
        ConeColClustered=99,
        ConeColStacked=100,
        ConeColStacked100=101,
        CylinderBarClustered=95,
        CylinderBarStacked=96,
        CylinderBarStacked100=97,
        CylinderCol=98,
        CylinderColClustered=92,
        CylinderColStacked=93,
        CylinderColStacked100=94,
        Doughnut=-4120,
        DoughnutExploded=80,
        Line=4,
        LineMarkers=65,
        LineMarkersStacked=66,
        LineMarkersStacked100=67,
        LineStacked=63,
        LineStacked100=64,
        Pie=5,
        PieExploded=69,
        PieOfPie=68,
        PyramidBarClustered=109,
        PyramidBarStacked=110,
        PyramidBarStacked100=111,
        PyramidCol=112,
        PyramidColClustered=106,
        PyramidColStacked=107,
        PyramidColStacked100=108,
        Radar=-4151,
        RadarFilled=82,
        RadarMarkers=81,
        StockHLC=88,
        StockOHLC=89,
        StockVHLC=90,
        StockVOHLC=91,
        Surface=83,
        SurfaceTopView=85,
        SurfaceTopViewWireframe=86,
        SurfaceWireframe=84,
        XYScatter=-4169,
        XYScatterLines=74,
        XYScatterLinesNoMarkers=75,
        XYScatterSmooth=72,
        XYScatterSmoothNoMarkers=73
}
    /// <summary>
    /// Bar or column
    /// </summary>
    public enum eDirection
    {
        Column,
        Bar
    }
    /// <summary>
    /// How the series are grouped
    /// </summary>
    public enum eGrouping
    {
        Standard,
        Clustered,
        Stacked,
        PercentStacked
    }
    /// <summary>
    /// Shape for bar charts
    /// </summary>
    public enum eShape
    {
        Box,
        Cone,
        ConeToMax,
        Cylinder,
        Pyramid,
        PyramidToMax
    }
    /// <summary>
    /// Smooth or lines markers
    /// </summary>
    public enum eScatterStyle
    {
        LineMarker,
        SmoothMarker,
     }
    public enum eRadarStyle
    {
        /// <summary>
        /// Specifies that the radar chart shall be filled and have lines but no markers.
        /// </summary>
        Filled,
        /// <summary>
        /// Specifies that the radar chart shall have lines and markers but no fill.
        /// </summary>
        Marker,
        /// <summary>
        /// Specifies that the radar chart shall have lines but no markers and no fill.
        /// </summary>
        Standard 
    }
    /// <summary>
    /// Bar or pie
    /// </summary>
    public enum ePieType
    {
        Bar,
        Pie
    }
    /// <summary>
    /// Position of the labels
    /// </summary>
    public enum eLabelPosition
    {
        BestFit,
        Left,
        Right,
        Center,
        Top,
        Bottom,
        InBase,
        InEnd,
        OutEnd
    }
    /// <summary>
    /// Axis label position
    /// </summary>
    public enum eTickLabelPosition
    {
        High,
        Low,
        NextTo,
        None
    }
    /// <summary>
    /// Markerstyle
    /// </summary>
    public enum eMarkerStyle
    {        
        Circle,
        Dash,
        Diamond,
        Dot,
        None,
        Picture,
        Plus,
        Square,
        Star,
        Triangle,
        X,
    }
    /// <summary>
    /// The build in style of the chart.
    /// </summary>
    public enum eChartStyle
    {
        None,
        Style1,
        Style2,
        Style3,
        Style4,
        Style5,
        Style6,
        Style7,
        Style8,
        Style9,
        Style10,
        Style11,
        Style12,
        Style13,
        Style14,
        Style15,
        Style16,
        Style17,
        Style18,
        Style19,
        Style20,
        Style21,
        Style22,
        Style23,
        Style24,
        Style25,
        Style26,
        Style27,
        Style28,
        Style29,
        Style30,
        Style31,
        Style32,
        Style33,
        Style34,
        Style35,
        Style36,
        Style37,
        Style38,
        Style39,
        Style40,
        Style41,
        Style42,
        Style43,
        Style44,
        Style45,
        Style46,
        Style47,
        Style48
    }
    /// <summary>
    /// Type of Trendline for a chart
    /// </summary>
    public enum eTrendLine
    {
        /// <summary>
        /// Specifies the trendline shall be an exponential curve in the form
        /// </summary>
        Exponential,
        /// <summary>
        /// Specifies the trendline shall be a logarithmic curve in the form , where log is the natural
        /// </summary>
        Linear,
        /// <summary>
        /// Specifies the trendline shall be a logarithmic curve in the form , where log is the natural
        /// </summary>
        Logarithmic,
        /// <summary>
        /// Specifies the trendline shall be a moving average of period Period
        /// </summary>
        MovingAvgerage,
        /// <summary>
        /// Specifies the trendline shall be a polynomial curve of order Order in the form 
        /// </summary>
        Polynomial,
        /// <summary>
        /// Specifies the trendline shall be a power curve in the form
        /// </summary>
        Power
    }
    /// <summary>
    /// Specifies the possible ways to display blanks
    /// </summary>
    public enum eDisplayBlanksAs
    {
        /// <summary>
        /// Blank values shall be left as a gap
        /// </summary>
        Gap,
        /// <summary>
        /// Blank values shall be spanned with a line (Line charts)
        /// </summary>
        Span,
        /// <summary>
        /// Blank values shall be treated as zero
        /// </summary>
        Zero
    }
    public enum eSizeRepresents
    {
        /// <summary>
        /// Specifies the area of the bubbles shall be proportional to the bubble size value.
        /// </summary>
        Area,
        /// <summary>
        /// Specifies the radius of the bubbles shall be proportional to the bubble size value.
        /// </summary>
        Width
    }
    #endregion
    
    
    /// <summary>
   /// Base class for Chart object.
   /// </summary>
    public class ExcelChart : ExcelDrawing
    {
       const string rootPath = "c:chartSpace/c:chart/c:plotArea";
       //string _chartPath;
       protected internal ExcelChartSeries _chartSeries;
       internal ExcelChartAxis[] _axis;
       protected XmlHelper _chartXmlHelper;
       #region "Constructors"
       internal ExcelChart(ExcelDrawings drawings, XmlNode node, eChartType type, bool isPivot) :
           base(drawings, node, "xdr:graphicFrame/xdr:nvGraphicFramePr/xdr:cNvPr/@name")
       {
           ChartType = type;
           CreateNewChart(drawings, type, null);

           Init(drawings, _chartNode);

           _chartSeries = new ExcelChartSeries(this, drawings.NameSpaceManager, _chartNode, isPivot);

           SetTypeProperties();
           LoadAxis();
       }
       internal ExcelChart(ExcelDrawings drawings, XmlNode node, eChartType type, ExcelChart topChart, ExcelPivotTable PivotTableSource) :
           base(drawings, node, "xdr:graphicFrame/xdr:nvGraphicFramePr/xdr:cNvPr/@name")
       {
           ChartType = type;
           CreateNewChart(drawings, type, topChart);

           Init(drawings, _chartNode);

           _chartSeries = new ExcelChartSeries(this, drawings.NameSpaceManager, _chartNode, PivotTableSource!=null);
           if (PivotTableSource != null) SetPivotSource(PivotTableSource);

           SetTypeProperties();
           if (topChart == null)
               LoadAxis();
           else
           {
               _axis = topChart.Axis;
               if (_axis.Length > 0)
               {
                   XAxis = _axis[0];
                   YAxis = _axis[1];
               }
           }
       }
       internal ExcelChart(ExcelDrawings drawings, XmlNode node, Uri uriChart, ZipPackagePart part, XmlDocument chartXml, XmlNode chartNode) :
           base(drawings, node, "xdr:graphicFrame/xdr:nvGraphicFramePr/xdr:cNvPr/@name")
       {
           UriChart = uriChart;
           Part = part;
           ChartXml = chartXml;
           _chartNode = chartNode;
           InitChartLoad(drawings, chartNode);
           ChartType = GetChartType(chartNode.LocalName);
       }
       internal ExcelChart(ExcelChart topChart, XmlNode chartNode) :
           base(topChart._drawings, topChart.TopNode, "xdr:graphicFrame/xdr:nvGraphicFramePr/xdr:cNvPr/@name")
       {
           UriChart = topChart.UriChart;
           Part = topChart.Part;
           ChartXml = topChart.ChartXml;
           _plotArea = topChart.PlotArea;
           _chartNode = chartNode;

           InitChartLoad(topChart._drawings, chartNode);
       }
       private void InitChartLoad(ExcelDrawings drawings, XmlNode chartNode)
       {
           //SetChartType();
           bool isPivot = false;
           Init(drawings, chartNode);
           _chartSeries = new ExcelChartSeries(this, drawings.NameSpaceManager, _chartNode, isPivot /*ChartXml.SelectSingleNode(_chartPath, drawings.NameSpaceManager)*/);
           LoadAxis();
       }

       private void Init(ExcelDrawings drawings, XmlNode chartNode)
       {
           //_chartXmlHelper = new XmlHelper(drawings.NameSpaceManager, chartNode);
           _chartXmlHelper = XmlHelperFactory.Create(drawings.NameSpaceManager, chartNode);
           _chartXmlHelper.SchemaNodeOrder = new string[] { "title", "pivotFmt", "autoTitleDeleted", "view3D", "floor", "sideWall", "backWall", "plotArea", "wireframe", "barDir", "grouping", "scatterStyle", "radarStyle", "varyColors", "ser", "dLbls", "bubbleScale", "showNegBubbles", "dropLines", "upDownBars", "marker", "smooth", "shape", "legend", "plotVisOnly", "dispBlanksAs", "showDLblsOverMax", "overlap", "bandFmts", "axId", "spPr", "printSettings" };
           WorkSheet = drawings.Worksheet;
       }
       #endregion
       #region "Private functions"
       private void SetTypeProperties()
       {
           /******* Grouping *******/
           if (IsTypeClustered())
           {
               Grouping = eGrouping.Clustered;
           }
           else if (
               IsTypeStacked())
           {
               Grouping = eGrouping.Stacked;
           }
           else if (
           IsTypePercentStacked())
           {
               Grouping = eGrouping.PercentStacked;
           }

           /***** 3D Perspective *****/
           if (IsType3D())             
           {
               View3D.RotY = 20;
               View3D.Perspective = 30;    //Default to 30
               if (IsTypePieDoughnut())
               {
                   View3D.RotX = 30;
               }
               else
               {
                   View3D.RotX = 15;
               }
           }
       }
       private void CreateNewChart(ExcelDrawings drawings, eChartType type, ExcelChart topChart)
       {
           if (topChart == null)
           {
               XmlElement graphFrame = TopNode.OwnerDocument.CreateElement("graphicFrame", ExcelPackage.schemaSheetDrawings);
               graphFrame.SetAttribute("macro", "");
               TopNode.AppendChild(graphFrame); 
               graphFrame.InnerXml = string.Format("<xdr:nvGraphicFramePr><xdr:cNvPr id=\"{0}\" name=\"Chart 1\" /><xdr:cNvGraphicFramePr /></xdr:nvGraphicFramePr><xdr:xfrm><a:off x=\"0\" y=\"0\" /> <a:ext cx=\"0\" cy=\"0\" /></xdr:xfrm><a:graphic><a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/chart\"><c:chart xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" r:id=\"rId1\" />   </a:graphicData>  </a:graphic>",_id);
               TopNode.AppendChild(TopNode.OwnerDocument.CreateElement("clientData", ExcelPackage.schemaSheetDrawings));

               var package = drawings.Worksheet._package.Package;
               UriChart = GetNewUri(package, "/xl/charts/chart{0}.xml");

               ChartXml = new XmlDocument();
               ChartXml.PreserveWhitespace = ExcelPackage.preserveWhitespace;
               LoadXmlSafe(ChartXml, ChartStartXml(type), Encoding.UTF8);

               // save it to the package
               Part = package.CreatePart(UriChart, "application/vnd.openxmlformats-officedocument.drawingml.chart+xml", _drawings._package.Compression);

               StreamWriter streamChart = new StreamWriter(Part.GetStream(FileMode.Create, FileAccess.Write));
               ChartXml.Save(streamChart);
               streamChart.Close();
               package.Flush();

               var chartRelation = drawings.Part.CreateRelationship(UriHelper.GetRelativeUri(drawings.UriDrawing, UriChart), Packaging.TargetMode.Internal, ExcelPackage.schemaRelationships + "/chart");
               graphFrame.SelectSingleNode("a:graphic/a:graphicData/c:chart", NameSpaceManager).Attributes["r:id"].Value = chartRelation.Id;
               package.Flush();
               _chartNode = ChartXml.SelectSingleNode(string.Format("c:chartSpace/c:chart/c:plotArea/{0}", GetChartNodeText()), NameSpaceManager);
           }
           else
           {
               ChartXml = topChart.ChartXml;
               Part = topChart.Part;
               _plotArea = topChart.PlotArea;
               UriChart = topChart.UriChart;
               _axis = topChart._axis;

               XmlNode preNode = _plotArea.ChartTypes[_plotArea.ChartTypes.Count - 1].ChartNode;
               _chartNode = ((XmlDocument)ChartXml).CreateElement(GetChartNodeText(), ExcelPackage.schemaChart);
               preNode.ParentNode.InsertAfter(_chartNode, preNode);
               if (topChart.Axis.Length == 0)
               {
                   AddAxis();
               }
               string serieXML = GetChartSerieStartXml(type, int.Parse(topChart.Axis[0].Id), int.Parse(topChart.Axis[1].Id), topChart.Axis.Length>2?int.Parse(topChart.Axis[2].Id) : -1);
               _chartNode.InnerXml = serieXML;
           }
       }
       private void LoadAxis()
       {
           XmlNodeList nl = _chartNode.SelectNodes("c:axId", NameSpaceManager);
           List<ExcelChartAxis> l = new List<ExcelChartAxis>();
           foreach (XmlNode node in nl)
           {
               string id = node.Attributes["val"].Value;
               var axNode = ChartXml.SelectNodes(rootPath + string.Format("/*/c:axId[@val=\"{0}\"]", id), NameSpaceManager);
               if (axNode != null && axNode.Count>1)
               {
                   foreach (XmlNode axn in axNode)
                   {
                       if (axn.ParentNode.LocalName.EndsWith("Ax"))
                       {
                           XmlNode axisNode = axNode[1].ParentNode;
                           ExcelChartAxis ax = new ExcelChartAxis(NameSpaceManager, axisNode);
                           l.Add(ax);
                       }
                   }
               }
           }
           _axis = l.ToArray();

           if(_axis.Length > 0) XAxis = _axis[0];
           if (_axis.Length > 1) YAxis = _axis[1];
       }
       //private void SetChartType()
       //{
       //    ChartType = 0;
       //    //_plotArea = new ExcelChartPlotArea(NameSpaceManager, ChartXml.SelectSingleNode("c:chartSpace/c:chart/c:plotArea", NameSpaceManager));
       //    int pos=0;
       //    foreach (XmlElement n in ChartXml.SelectSingleNode(rootPath, _drawings.NameSpaceManager).ChildNodes)
       //    {
       //        if (pos == 0)
       //        {
       //            ChartType = GetChartType(n.Name);
       //            if (ChartType != 0)
       //            {
       //                //_chartPath = rootPath + "/" + n.Name;
       //                PlotArea.ChartTypes.Add(this);
       //            }
       //        }
       //        else
       //        {
       //            var chartSerieType = GetChart(_drawings, TopNode/*, n*/);
       //            chartSerieType = GetChart(n, _drawings, TopNode, UriChart, Part, ChartXml, null, isPivot);
       //            PlotArea.ChartTypes.Add(chartSerieType);
       //            //var chartType = GetChartType(n.Name);
       //        }
       //        if (ChartType != 0)
       //        {
       //            pos++;
       //        }
       //    }
       //}
       internal virtual eChartType GetChartType(string name)
       {
           
           switch (name)
           {
               case "area3DChart":
                   if(Grouping==eGrouping.Stacked)
                   {
                       return eChartType.AreaStacked3D;
                   }
                   else if (Grouping == eGrouping.PercentStacked)
                   {
                       return eChartType.AreaStacked1003D;
                   }
                   else
                   {
                       return eChartType.Area3D;
                   }
               case "areaChart":
                   if (Grouping == eGrouping.Stacked)
                   {
                       return eChartType.AreaStacked;
                   }
                   else if (Grouping == eGrouping.PercentStacked)
                   {
                       return eChartType.AreaStacked100;
                   }
                   else
                   {
                       return eChartType.Area;
                   }
               case "doughnutChart":
                   return eChartType.Doughnut;
               case "pie3DChart":
                   return eChartType.Pie3D;
               case "pieChart":
                   return eChartType.Pie;
               case "radarChart":
                   return eChartType.Radar;
               case "scatterChart":
                   return eChartType.XYScatter;
               case "surface3DChart":
               case "surfaceChart":
                   return eChartType.Surface;
               case "stockChart":
                   return eChartType.StockHLC;
               default:
                   return 0;
           }           
       }
       #region "Xml init Functions"
       private string ChartStartXml(eChartType type)
       {
           StringBuilder xml=new StringBuilder();
           int axID=1;
           int xAxID=2;
           int serAxID = IsTypeSurface() ? 3 : -1;

           xml.Append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
           xml.AppendFormat("<c:chartSpace xmlns:c=\"{0}\" xmlns:a=\"{1}\" xmlns:r=\"{2}\">", ExcelPackage.schemaChart, ExcelPackage.schemaDrawings, ExcelPackage.schemaRelationships);       
           xml.Append("<c:chart>");
           xml.AppendFormat("{0}{1}<c:plotArea><c:layout/>",AddPerspectiveXml(type), AddSurfaceXml(type));

           string chartNodeText = GetChartNodeText();
           xml.AppendFormat("<{0}>", chartNodeText);
           xml.Append(GetChartSerieStartXml(type, axID, xAxID, serAxID));
           xml.AppendFormat("</{0}>", chartNodeText);

           //Axis
           if (!IsTypePieDoughnut())
           {
               if (IsTypeScatterBubble())
               {
                   xml.AppendFormat("<c:valAx><c:axId val=\"{0}\"/><c:scaling><c:orientation val=\"minMax\"/></c:scaling><c:delete val=\"0\"/><c:axPos val=\"b\"/><c:tickLblPos val=\"nextTo\"/><c:crossAx val=\"{1}\"/><c:crosses val=\"autoZero\"/></c:valAx>", axID, xAxID);
               }
               else
               {
                   xml.AppendFormat("<c:catAx><c:axId val=\"{0}\"/><c:scaling><c:orientation val=\"minMax\"/></c:scaling><c:delete val=\"0\"/><c:axPos val=\"b\"/><c:tickLblPos val=\"nextTo\"/><c:crossAx val=\"{1}\"/><c:crosses val=\"autoZero\"/><c:auto val=\"1\"/><c:lblAlgn val=\"ctr\"/><c:lblOffset val=\"100\"/></c:catAx>", axID, xAxID);
               }
               xml.AppendFormat("<c:valAx><c:axId val=\"{1}\"/><c:scaling><c:orientation val=\"minMax\"/></c:scaling><c:delete val=\"0\"/><c:axPos val=\"l\"/><c:majorGridlines/><c:tickLblPos val=\"nextTo\"/><c:crossAx val=\"{0}\"/><c:crosses val=\"autoZero\"/><c:crossBetween val=\"between\"/></c:valAx>", axID, xAxID);
               if (serAxID==3) //Sureface Chart
               {
                   xml.AppendFormat("<c:serAx><c:axId val=\"{0}\"/><c:scaling><c:orientation val=\"minMax\"/></c:scaling><c:delete val=\"0\"/><c:axPos val=\"b\"/><c:tickLblPos val=\"nextTo\"/><c:crossAx val=\"{1}\"/><c:crosses val=\"autoZero\"/></c:serAx>", serAxID, xAxID);
               }
           }

           xml.AppendFormat("</c:plotArea><c:legend><c:legendPos val=\"r\"/><c:layout/><c:overlay val=\"0\" /></c:legend><c:plotVisOnly val=\"1\"/></c:chart>", axID, xAxID);

           xml.Append("<c:printSettings><c:headerFooter/><c:pageMargins b=\"0.75\" l=\"0.7\" r=\"0.7\" t=\"0.75\" header=\"0.3\" footer=\"0.3\"/><c:pageSetup/></c:printSettings></c:chartSpace>");          
           return xml.ToString();
       }

       private string GetChartSerieStartXml(eChartType type, int axID, int xAxID, int serAxID)
       {
           StringBuilder xml = new StringBuilder();

           xml.Append(AddScatterType(type));
           xml.Append(AddRadarType(type));
           xml.Append(AddBarDir(type));
           xml.Append(AddGrouping());
           xml.Append(AddVaryColors());
           xml.Append(AddHasMarker(type));
           xml.Append(AddShape(type));
           xml.Append(AddFirstSliceAng(type));
           xml.Append(AddHoleSize(type));
           if (ChartType == eChartType.BarStacked100 || 
               ChartType == eChartType.BarStacked ||
               ChartType == eChartType.ColumnStacked ||
               ChartType == eChartType.ColumnStacked100)
           {
               xml.Append("<c:overlap val=\"100\"/>");
           }
           if (IsTypeSurface())
           {
               xml.Append("<c:bandFmts/>");
           }
           xml.Append(AddAxisId(axID, xAxID, serAxID));

           return xml.ToString();
       }
       private string AddAxisId(int axID,int xAxID, int serAxID)
       {
           if (!IsTypePieDoughnut())
           {
               if (IsTypeSurface())
               {                                      
                   return string.Format("<c:axId val=\"{0}\"/><c:axId val=\"{1}\"/><c:axId val=\"{2}\"/>", axID, xAxID, serAxID);
               }
               else
               {
                   return string.Format("<c:axId val=\"{0}\"/><c:axId val=\"{1}\"/>", axID, xAxID);
               }
           }
           else
           {
               return "";
           }
       }
       private string AddAxType()
       {
           switch(ChartType)
           {
               case eChartType.XYScatter:
               case eChartType.XYScatterLines:
               case eChartType.XYScatterLinesNoMarkers:
               case eChartType.XYScatterSmooth:
               case eChartType.XYScatterSmoothNoMarkers:
               case eChartType.Bubble:
               case eChartType.Bubble3DEffect:
                   return "valAx";
               default:
                   return "catAx";
           }
       }
       private string AddScatterType(eChartType type)
       {
           if (type == eChartType.XYScatter ||
               type == eChartType.XYScatterLines ||
               type == eChartType.XYScatterLinesNoMarkers ||
               type == eChartType.XYScatterSmooth ||
               type == eChartType.XYScatterSmoothNoMarkers)
           {
               return "<c:scatterStyle val=\"\" />";
           }
           else
           {
               return "";
           }
       }
       private string AddRadarType(eChartType type)
       {
           if (type == eChartType.Radar ||
               type == eChartType.RadarFilled||
               type == eChartType.RadarMarkers)
           {
               return "<c:radarStyle val=\"\" />";
           }
           else
           {
               return "";
           }
       }
       private string AddGrouping()
       {
           //IsTypeClustered() || IsTypePercentStacked() || IsTypeStacked() || 
           if(IsTypeShape() || IsTypeLine())
           {
               return "<c:grouping val=\"standard\"/>";
           }
           else
           {
               return "";
           }
       }
       private string AddHoleSize(eChartType type)
       {
           if (type == eChartType.Doughnut ||
               type == eChartType.DoughnutExploded)
           {
               return "<c:holeSize val=\"50\" />";
           }
           else
           {
               return "";
           }
       }
       private string AddFirstSliceAng(eChartType type)
       {
           if (type == eChartType.Doughnut ||
               type == eChartType.DoughnutExploded)
           {
               return "<c:firstSliceAng val=\"0\" />";
           }
           else
           {
               return "";
           }
       }
       private string AddVaryColors()
       {
           if (IsTypePieDoughnut())
           {
               return "<c:varyColors val=\"1\" />";
           }
           else
           {
               return "<c:varyColors val=\"0\" />";
           }
       }
       private string AddHasMarker(eChartType type)
       {
           if (type == eChartType.LineMarkers ||
               type == eChartType.LineMarkersStacked ||
               type == eChartType.LineMarkersStacked100 /*||
               type == eChartType.XYScatterLines ||
               type == eChartType.XYScatterSmooth*/)
           {
               return "<c:marker val=\"1\"/>";
           }
           else
           {
               return "";
           }
       }
       private string AddShape(eChartType type)
       {
           if (IsTypeShape())
           {
               return "<c:shape val=\"box\" />";
           }
           else
           {
               return "";
           }
       }
       private string AddBarDir(eChartType type)
       {
           if (IsTypeShape())
            {
                return "<c:barDir val=\"col\" />";
            }
            else
            {
                return "";
            }
       }
       private string AddPerspectiveXml(eChartType type)
        {
 	        //Add for 3D sharts
            if (IsType3D())
            {
                return "<c:view3D><c:perspective val=\"30\" /></c:view3D>";
            }
            else
            {
                return "";
            }
        }
       private string AddSurfaceXml(eChartType type)
       {
           if (IsTypeSurface())
           {
               return AddSurfacePart("floor") + AddSurfacePart("sideWall") + AddSurfacePart("backWall");
           }
           else
           {
               return "";
           }
       }

       private string AddSurfacePart(string name)
       {
           return string.Format("<c:{0}><c:thickness val=\"0\"/><c:spPr><a:noFill/><a:ln><a:noFill/></a:ln><a:effectLst/><a:sp3d/></c:spPr></c:{0}>", name);
       }
       #endregion
       #endregion
       #region "Chart type functions
       internal static bool IsType3D(eChartType chartType)
        {
            return chartType == eChartType.Area3D ||
                            chartType == eChartType.AreaStacked3D ||
                            chartType == eChartType.AreaStacked1003D ||
                            chartType == eChartType.BarClustered3D ||
                            chartType == eChartType.BarStacked3D ||
                            chartType == eChartType.BarStacked1003D ||
                            chartType == eChartType.Column3D ||
                            chartType == eChartType.ColumnClustered3D ||
                            chartType == eChartType.ColumnStacked3D ||
                            chartType == eChartType.ColumnStacked1003D ||
                            chartType == eChartType.Line3D ||
                            chartType == eChartType.Pie3D ||
                            chartType == eChartType.PieExploded3D ||
                            chartType == eChartType.ConeBarClustered ||
                            chartType == eChartType.ConeBarStacked ||
                            chartType == eChartType.ConeBarStacked100 ||
                            chartType == eChartType.ConeCol ||
                            chartType == eChartType.ConeColClustered ||
                            chartType == eChartType.ConeColStacked ||
                            chartType == eChartType.ConeColStacked100 ||
                            chartType == eChartType.CylinderBarClustered ||
                            chartType == eChartType.CylinderBarStacked ||
                            chartType == eChartType.CylinderBarStacked100 ||
                            chartType == eChartType.CylinderCol ||
                            chartType == eChartType.CylinderColClustered ||
                            chartType == eChartType.CylinderColStacked ||
                            chartType == eChartType.CylinderColStacked100 ||
                            chartType == eChartType.PyramidBarClustered ||
                            chartType == eChartType.PyramidBarStacked ||
                            chartType == eChartType.PyramidBarStacked100 ||
                            chartType == eChartType.PyramidCol ||
                            chartType == eChartType.PyramidColClustered ||
                            chartType == eChartType.PyramidColStacked ||
                            chartType == eChartType.PyramidColStacked100 ||
                            chartType == eChartType.Surface ||
                            chartType == eChartType.SurfaceTopView ||
                            chartType == eChartType.SurfaceTopViewWireframe ||
                            chartType == eChartType.SurfaceWireframe;
        }
       internal protected bool IsType3D()
       {
            return IsType3D(ChartType);
       }
        protected bool IsTypeLine()
       {
           return ChartType == eChartType.Line ||
                   ChartType == eChartType.LineMarkers ||
                   ChartType == eChartType.LineMarkersStacked100 ||
                   ChartType == eChartType.LineStacked ||
                   ChartType == eChartType.LineStacked100 ||
                   ChartType == eChartType.Line3D;
       }
       protected bool IsTypeScatterBubble()
       {
           return ChartType == eChartType.XYScatter ||
                   ChartType == eChartType.XYScatterLines ||
                   ChartType == eChartType.XYScatterLinesNoMarkers ||
                   ChartType == eChartType.XYScatterSmooth ||
                   ChartType == eChartType.XYScatterSmoothNoMarkers ||
                   ChartType == eChartType.Bubble ||
                   ChartType == eChartType.Bubble3DEffect;
       }
        protected bool IsTypeSurface()
        {
            return ChartType == eChartType.Surface ||
                   ChartType == eChartType.SurfaceTopView ||
                   ChartType == eChartType.SurfaceTopViewWireframe ||
                   ChartType == eChartType.SurfaceWireframe;
        }
       protected bool IsTypeShape()
       {
            return ChartType == eChartType.BarClustered3D ||
                    ChartType == eChartType.BarStacked3D ||
                    ChartType == eChartType.BarStacked1003D ||
                    ChartType == eChartType.BarClustered3D ||
                    ChartType == eChartType.BarStacked3D ||
                    ChartType == eChartType.BarStacked1003D ||
                    ChartType == eChartType.Column3D ||
                    ChartType == eChartType.ColumnClustered3D ||
                    ChartType == eChartType.ColumnStacked3D ||
                    ChartType == eChartType.ColumnStacked1003D ||
                //ChartType == eChartType.3DPie ||
                //ChartType == eChartType.3DPieExploded ||
                    //ChartType == eChartType.Bubble3DEffect ||
                    ChartType == eChartType.ConeBarClustered ||
                    ChartType == eChartType.ConeBarStacked ||
                    ChartType == eChartType.ConeBarStacked100 ||
                    ChartType == eChartType.ConeCol ||
                    ChartType == eChartType.ConeColClustered ||
                    ChartType == eChartType.ConeColStacked ||
                    ChartType == eChartType.ConeColStacked100 ||
                    ChartType == eChartType.CylinderBarClustered ||
                    ChartType == eChartType.CylinderBarStacked ||
                    ChartType == eChartType.CylinderBarStacked100 ||
                    ChartType == eChartType.CylinderCol ||
                    ChartType == eChartType.CylinderColClustered ||
                    ChartType == eChartType.CylinderColStacked ||
                    ChartType == eChartType.CylinderColStacked100 ||
                    ChartType == eChartType.PyramidBarClustered ||
                    ChartType == eChartType.PyramidBarStacked ||
                    ChartType == eChartType.PyramidBarStacked100 ||
                    ChartType == eChartType.PyramidCol ||
                    ChartType == eChartType.PyramidColClustered ||
                    ChartType == eChartType.PyramidColStacked ||
                    ChartType == eChartType.PyramidColStacked100; //||
                    //ChartType == eChartType.Doughnut ||
                    //ChartType == eChartType.DoughnutExploded;
        }
        protected internal bool IsTypePercentStacked()
        {
            return ChartType == eChartType.AreaStacked100 ||
                           ChartType == eChartType.BarStacked100 ||
                           ChartType == eChartType.BarStacked1003D ||
                           ChartType == eChartType.ColumnStacked100 ||
                           ChartType == eChartType.ColumnStacked1003D ||
                           ChartType == eChartType.ConeBarStacked100 ||
                           ChartType == eChartType.ConeColStacked100 ||
                           ChartType == eChartType.CylinderBarStacked100 ||
                           ChartType == eChartType.CylinderColStacked ||
                           ChartType == eChartType.LineMarkersStacked100 ||
                           ChartType == eChartType.LineStacked100 ||
                           ChartType == eChartType.PyramidBarStacked100 ||
                           ChartType == eChartType.PyramidColStacked100;
        }
        protected internal bool IsTypeStacked()
        {
            return ChartType == eChartType.AreaStacked ||
                           ChartType == eChartType.AreaStacked3D ||
                           ChartType == eChartType.BarStacked ||
                           ChartType == eChartType.BarStacked3D ||
                           ChartType == eChartType.ColumnStacked3D ||
                           ChartType == eChartType.ColumnStacked ||
                           ChartType == eChartType.ConeBarStacked ||
                           ChartType == eChartType.ConeColStacked ||
                           ChartType == eChartType.CylinderBarStacked ||
                           ChartType == eChartType.CylinderColStacked ||
                           ChartType == eChartType.LineMarkersStacked ||
                           ChartType == eChartType.LineStacked ||
                           ChartType == eChartType.PyramidBarStacked ||
                           ChartType == eChartType.PyramidColStacked;
        }
        protected bool IsTypeClustered()
        {
            return ChartType == eChartType.BarClustered ||
                           ChartType == eChartType.BarClustered3D ||
                           ChartType == eChartType.ColumnClustered3D ||
                           ChartType == eChartType.ColumnClustered ||
                           ChartType == eChartType.ConeBarClustered ||
                           ChartType == eChartType.ConeColClustered ||
                           ChartType == eChartType.CylinderBarClustered ||
                           ChartType == eChartType.CylinderColClustered ||
                           ChartType == eChartType.PyramidBarClustered ||
                           ChartType == eChartType.PyramidColClustered;
        }
        protected internal bool IsTypePieDoughnut()
        {
            return ChartType == eChartType.Pie ||
                           ChartType == eChartType.PieExploded ||
                           ChartType == eChartType.PieOfPie ||
                           ChartType == eChartType.Pie3D ||
                           ChartType == eChartType.PieExploded3D ||
                           ChartType == eChartType.BarOfPie ||
                           ChartType == eChartType.Doughnut ||
                           ChartType == eChartType.DoughnutExploded;
        }
        #endregion
       /// <summary>
       /// Get the name of the chart node
       /// </summary>
       /// <returns>The name</returns>
        protected string GetChartNodeText()
        {
            switch (ChartType)
            {
                case eChartType.Area3D:
                case eChartType.AreaStacked3D:
                case eChartType.AreaStacked1003D:
                    return "c:area3DChart";
                case eChartType.Area:
                case eChartType.AreaStacked:
                case eChartType.AreaStacked100:
                    return "c:areaChart";
                case eChartType.BarClustered:
                case eChartType.BarStacked:
                case eChartType.BarStacked100:
                case eChartType.ColumnClustered:
                case eChartType.ColumnStacked:
                case eChartType.ColumnStacked100:
                    return "c:barChart";
                case eChartType.BarClustered3D:
                case eChartType.BarStacked3D:
                case eChartType.BarStacked1003D:
                case eChartType.ColumnClustered3D:
                case eChartType.ColumnStacked3D:
                case eChartType.ColumnStacked1003D:
                case eChartType.ConeBarClustered:
                case eChartType.ConeBarStacked:
                case eChartType.ConeBarStacked100:
                case eChartType.ConeCol:
                case eChartType.ConeColClustered:
                case eChartType.ConeColStacked:
                case eChartType.ConeColStacked100:
                case eChartType.CylinderBarClustered:
                case eChartType.CylinderBarStacked:
                case eChartType.CylinderBarStacked100:
                case eChartType.CylinderCol:
                case eChartType.CylinderColClustered:
                case eChartType.CylinderColStacked:
                case eChartType.CylinderColStacked100:
                case eChartType.PyramidBarClustered:
                case eChartType.PyramidBarStacked:
                case eChartType.PyramidBarStacked100:
                case eChartType.PyramidCol:
                case eChartType.PyramidColClustered:
                case eChartType.PyramidColStacked:
                case eChartType.PyramidColStacked100:
                    return "c:bar3DChart";
                case eChartType.Bubble:
                case eChartType.Bubble3DEffect:
                    return "c:bubbleChart";
                case eChartType.Doughnut:
                case eChartType.DoughnutExploded:
                    return "c:doughnutChart";
                case eChartType.Line:
                case eChartType.LineMarkers:
                case eChartType.LineMarkersStacked:
                case eChartType.LineMarkersStacked100:
                case eChartType.LineStacked:
                case eChartType.LineStacked100:
                    return "c:lineChart";
                case eChartType.Line3D:
                    return "c:line3DChart";
                case eChartType.Pie:
                case eChartType.PieExploded:
                    return "c:pieChart";
                case eChartType.BarOfPie:
                case eChartType.PieOfPie:
                    return "c:ofPieChart";
                case eChartType.Pie3D:
                case eChartType.PieExploded3D:
                    return "c:pie3DChart";
                case eChartType.Radar:
                case eChartType.RadarFilled:
                case eChartType.RadarMarkers:
                    return "c:radarChart";
                case eChartType.XYScatter:
                case eChartType.XYScatterLines:
                case eChartType.XYScatterLinesNoMarkers:
                case eChartType.XYScatterSmooth:
                case eChartType.XYScatterSmoothNoMarkers:
                    return "c:scatterChart";
                case eChartType.Surface:
                case eChartType.SurfaceWireframe:
                    return "c:surface3DChart";
                case eChartType.SurfaceTopView:
                case eChartType.SurfaceTopViewWireframe:
                    return "c:surfaceChart";
                case eChartType.StockHLC:
                    return "c:stockChart";
                default:
                    throw(new NotImplementedException("Chart type not implemented"));
            }
        }
        /// <summary>
        /// Add a secondary axis
        /// </summary>
        internal void AddAxis()
        {
            XmlElement catAx = ChartXml.CreateElement(string.Format("c:{0}",AddAxType()), ExcelPackage.schemaChart);
            int axID;
            if (_axis.Length == 0)
            {
                _plotArea.TopNode.AppendChild(catAx);
                axID = 1;
            }
            else
            {
                _axis[0].TopNode.ParentNode.InsertAfter(catAx, _axis[_axis.Length-1].TopNode);
                axID = int.Parse(_axis[0].Id) < int.Parse(_axis[1].Id) ? int.Parse(_axis[1].Id) + 1 : int.Parse(_axis[0].Id) + 1;
            }


            XmlElement valAx = ChartXml.CreateElement("c:valAx", ExcelPackage.schemaChart);
            catAx.ParentNode.InsertAfter(valAx, catAx);

            if (_axis.Length == 0)
            {
                catAx.InnerXml = string.Format("<c:axId val=\"{0}\"/><c:scaling><c:orientation val=\"minMax\"/></c:scaling><c:delete val=\"0\" /><c:axPos val=\"b\"/><c:tickLblPos val=\"nextTo\"/><c:crossAx val=\"{1}\"/><c:crosses val=\"autoZero\"/><c:auto val=\"1\"/><c:lblAlgn val=\"ctr\"/><c:lblOffset val=\"100\"/>", axID, axID + 1);
                valAx.InnerXml = string.Format("<c:axId val=\"{1}\"/><c:scaling><c:orientation val=\"minMax\"/></c:scaling><c:delete val=\"0\" /><c:axPos val=\"l\"/><c:majorGridlines/><c:tickLblPos val=\"nextTo\"/><c:crossAx val=\"{0}\"/><c:crosses val=\"autoZero\"/><c:crossBetween val=\"between\"/>", axID, axID + 1);
            }
            else
            {
                catAx.InnerXml = string.Format("<c:axId val=\"{0}\"/><c:scaling><c:orientation val=\"minMax\"/></c:scaling><c:delete val=\"1\" /><c:axPos val=\"b\"/><c:tickLblPos val=\"none\"/><c:crossAx val=\"{1}\"/><c:crosses val=\"autoZero\"/>", axID, axID + 1);
                valAx.InnerXml = string.Format("<c:axId val=\"{0}\"/><c:scaling><c:orientation val=\"minMax\"/></c:scaling><c:delete val=\"0\" /><c:axPos val=\"r\"/><c:tickLblPos val=\"nextTo\"/><c:crossAx val=\"{1}\"/><c:crosses val=\"max\"/><c:crossBetween val=\"between\"/>", axID + 1, axID);
            }

            if (_axis.Length == 0)
            {
                _axis = new ExcelChartAxis[2];
            }
            else
            {
                ExcelChartAxis[] newAxis = new ExcelChartAxis[_axis.Length + 2];
                Array.Copy(_axis, newAxis, _axis.Length);
                _axis = newAxis;
            }

            _axis[_axis.Length - 2] = new ExcelChartAxis(NameSpaceManager, catAx);
            _axis[_axis.Length - 1] = new ExcelChartAxis(NameSpaceManager, valAx);
            foreach (var chart in _plotArea.ChartTypes)
            {
                chart._axis = _axis;
            }
        }
        internal void RemoveSecondaryAxis()
        {
            throw (new NotImplementedException("Not yet implemented"));
        }
        #region "Properties"
        /// <summary>
        /// Reference to the worksheet
        /// </summary>
        public ExcelWorksheet WorkSheet { get; internal set; }
        /// <summary>
        /// The chart xml document
        /// </summary>
        public XmlDocument ChartXml { get; internal set; }
        /// <summary>
        /// Type of chart
        /// </summary>
        public eChartType ChartType { get; internal set; }
        internal protected XmlNode _chartNode = null;
        internal XmlNode ChartNode
        {
            get
            {
                return _chartNode;
            }
        }
        /// <summary>
        /// Titel of the chart
        /// </summary>
        public ExcelChartTitle Title
        {
            get
            {
                if (_title == null)
                {
                    _title = new ExcelChartTitle(NameSpaceManager, ChartXml.SelectSingleNode("c:chartSpace/c:chart", NameSpaceManager));
                }
                return _title;
            }
        }
        /// <summary>
        /// Chart series
        /// </summary>
        public virtual ExcelChartSeries Series
        {
            get
            {
                return _chartSeries;
            }
        }
        /// <summary>
        /// An array containg all axis of all Charttypes
        /// </summary>
        public ExcelChartAxis[] Axis
        {
            get
            {
                return _axis;
            }
        }
        /// <summary>
        /// The XAxis
        /// </summary>
        public ExcelChartAxis XAxis
        {
            get;
            private set;
        }
        /// <summary>
        /// The YAxis
        /// </summary>
        public ExcelChartAxis YAxis
        {
            get;
            private set;
        }
        bool _secondaryAxis=false;
        /// <summary>
        /// If true the charttype will use the secondary axis.
        /// The chart must contain a least one other charttype that uses the primary axis.
        /// </summary>
        public bool UseSecondaryAxis
        {
            get
            {
                return _secondaryAxis;
            }
            set
            {
                 if (_secondaryAxis != value)
                {
                    if (value)
                    {
                        if (IsTypePieDoughnut())
                        {
                            throw (new Exception("Pie charts do not support axis"));
                        }
                        else if (HasPrimaryAxis() == false)
                        {
                            throw (new Exception("Can't set to secondary axis when no serie uses the primary axis"));
                        }
                        if (Axis.Length == 2)
                        {
                            AddAxis();
                        }
                        var nl = ChartNode.SelectNodes("c:axId", NameSpaceManager);
                        nl[0].Attributes["val"].Value = Axis[2].Id;
                        nl[1].Attributes["val"].Value = Axis[3].Id;
                        XAxis = Axis[2];
                        YAxis = Axis[3];
                    }
                    else
                    {
                        var nl = ChartNode.SelectNodes("c:axId", NameSpaceManager);
                        nl[0].Attributes["val"].Value = Axis[0].Id;
                        nl[1].Attributes["val"].Value = Axis[1].Id;
                        XAxis = Axis[0];
                        YAxis = Axis[1];
                    }
                    _secondaryAxis = value;
                }
            }
        }
        /// <summary>
        /// The build-in chart styles. 
        /// </summary>
        public eChartStyle Style
        {
            get
            {
                XmlNode node = ChartXml.SelectSingleNode("c:chartSpace/c:style/@val", NameSpaceManager);
                if (node == null)
                {
                    return eChartStyle.None;
                }
                else
                {
                    int v;
                    if (int.TryParse(node.Value, out v))
                    {
                        return (eChartStyle)v;
                    }
                    else
                    {
                        return eChartStyle.None;
                    }
                }

            }
            set
            {
                if (value == eChartStyle.None)
                {
                    XmlElement element = ChartXml.SelectSingleNode("c:chartSpace/c:style", NameSpaceManager) as XmlElement;
                    if (element != null)
                    {
                        element.ParentNode.RemoveChild(element);
                    }
                }
                else
                {
                    XmlElement element = ChartXml.CreateElement("c:style", ExcelPackage.schemaChart);
                    element.SetAttribute("val", ((int)value).ToString());
                    XmlElement parent = ChartXml.SelectSingleNode("c:chartSpace", NameSpaceManager) as XmlElement;
                    parent.InsertBefore(element, parent.SelectSingleNode("c:chart", NameSpaceManager));
                }
            }
        }
        const string _plotVisibleOnlyPath="../../c:plotVisOnly/@val";
        /// <summary>
        /// Show data in hidden rows and columns
        /// </summary>
        public bool ShowHiddenData
        {
            get
            {
                //!!Inverted value!!
                return !_chartXmlHelper.GetXmlNodeBool(_plotVisibleOnlyPath);
            }
            set
            {
                //!!Inverted value!!
                _chartXmlHelper.SetXmlNodeBool(_plotVisibleOnlyPath, !value);
            }
        }
        const string _displayBlanksAsPath = "../../c:dispBlanksAs/@val";
        /// <summary>
        /// Specifies the possible ways to display blanks
        /// </summary>
        public eDisplayBlanksAs DisplayBlanksAs
        {
            get
            {
                string v=_chartXmlHelper.GetXmlNodeString(_displayBlanksAsPath);
                if (string.IsNullOrEmpty(v))
                {
                    return eDisplayBlanksAs.Zero; //Issue 14715 Changed in Office 2010-?
                }
                else
                {
                    return (eDisplayBlanksAs)Enum.Parse(typeof(eDisplayBlanksAs), v, true);
                }
            }
            set
            {
                _chartSeries.SetXmlNodeString(_displayBlanksAsPath, value.ToString().ToLower(CultureInfo.InvariantCulture));
            }
        }
        const string _showDLblsOverMax = "../../c:showDLblsOverMax/@val";
        /// <summary>
        /// Specifies data labels over the maximum of the chart shall be shown
        /// </summary>
        public bool ShowDataLabelsOverMaximum
        {
            get
            {
                return _chartXmlHelper.GetXmlNodeBool(_showDLblsOverMax, true);
            }
            set
            {
                _chartXmlHelper.SetXmlNodeBool(_showDLblsOverMax,value, true);
            }
        }
        private bool HasPrimaryAxis()
        {
            if (_plotArea.ChartTypes.Count == 1)
            {
                return false;
            }
            foreach (var chart in _plotArea.ChartTypes)
            {
                if (chart != this)
                {
                    if (chart.UseSecondaryAxis == false && chart.IsTypePieDoughnut()==false)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        ///// <summary>
        ///// Sets position of the axis of a chart-serie
        ///// </summary>
        ///// <param name="XAxis">Left or Right</param>
        ///// <param name="YAxis">Top or Bottom</param>
        //internal void SetAxis(eXAxisPosition XAxis, eYAxisPosition YAxis)
        //{
        //    bool xAxisExists = false, yAxisExists = false;
        //    foreach (var axis in _axis)
        //    {
        //        if (axis.AxisPosition == (eAxisPosition)XAxis)
        //        {
        //            //Found
        //            xAxisExists=true;
        //            if (axis != this.XAxis)
        //            {
        //                CheckRemoveAxis(this.XAxis);
        //                this.XAxis = axis;
        //            }
        //        }
        //        else if (axis.AxisPosition == (eAxisPosition)YAxis)
        //        {
        //            yAxisExists = true;
        //            if (axis != this.YAxis)
        //            {
        //                CheckRemoveAxis(this.YAxis);
        //                this.YAxis = axis;
        //            }
        //        }
        //    }

        //    if (!xAxisExists)
        //    {
        //        if (ExistsAxis(this.XAxis))
        //        {
        //            AddAxis((eAxisPosition)XAxis);
        //            this.XAxis = Axis[Axis.Length - 1];
        //        }
        //        else
        //        {
        //            this.XAxis.AxisPosition = (eAxisPosition)XAxis;
        //        }
        //    }
        //    if (!yAxisExists)
        //    {
        //        if (ExistsAxis(this.XAxis))
        //        {
        //            AddAxis((eAxisPosition)YAxis);
        //            this.YAxis = Axis[Axis.Length - 1];
        //        }
        //        else
        //        {
        //            this.YAxis.AxisPosition = (eAxisPosition)YAxis;
        //        }
        //    }
        //}

        /// <summary>
        /// Remove all axis that are not used any more
        /// </summary>
        /// <param name="excelChartAxis"></param>
        private void CheckRemoveAxis(ExcelChartAxis excelChartAxis)
        {
            if (ExistsAxis(excelChartAxis))
            {
                //Remove the axis
                ExcelChartAxis[] newAxis = new ExcelChartAxis[Axis.Length - 1];
                int pos = 0;
                foreach (var ax in Axis)
                {
                    if (ax != excelChartAxis)
                    {
                        newAxis[pos] = ax;
                    }
                }

                //Update all charttypes.
                foreach (ExcelChart chartType in _plotArea.ChartTypes)
                {
                    chartType._axis = newAxis;
                }
            }
        }

        private bool ExistsAxis(ExcelChartAxis excelChartAxis)
        {
            foreach (ExcelChart chartType in _plotArea.ChartTypes)
            {
                if (chartType != this)
                {
                    if (chartType.XAxis.AxisPosition == excelChartAxis.AxisPosition ||
                       chartType.YAxis.AxisPosition == excelChartAxis.AxisPosition)
                    {
                        //The axis exists
                        return true;
                    }
                }
            }
            return false;
        }
        ExcelChartPlotArea _plotArea = null;
        /// <summary>
        /// Plotarea
        /// </summary>
        public ExcelChartPlotArea PlotArea
        {
            get
            {
                if (_plotArea == null)
                {
                    _plotArea = new ExcelChartPlotArea(NameSpaceManager, ChartXml.SelectSingleNode("c:chartSpace/c:chart/c:plotArea", NameSpaceManager), this); 
                }
                return _plotArea;
            }
        }
        ExcelChartLegend _legend = null;
        /// <summary>
        /// Legend
        /// </summary>
        public ExcelChartLegend Legend
        {
            get
            {
                if (_legend == null)
                {
                    _legend = new ExcelChartLegend(NameSpaceManager, ChartXml.SelectSingleNode("c:chartSpace/c:chart/c:legend", NameSpaceManager), this);
                }
                return _legend;
            }

        }
        ExcelDrawingBorder _border = null;
        /// <summary>
        /// Border
        /// </summary>
        public ExcelDrawingBorder Border
        {
            get
            {
                if (_border == null)
                {
                    _border = new ExcelDrawingBorder(NameSpaceManager, ChartXml.SelectSingleNode("c:chartSpace",NameSpaceManager), "c:spPr/a:ln"); 
                }
                return _border;
            }
        }
        ExcelDrawingFill _fill = null;
        /// <summary>
        /// Fill
        /// </summary>
        public ExcelDrawingFill Fill
        {
            get
            {
                if (_fill == null)
                {
                    _fill = new ExcelDrawingFill(NameSpaceManager, ChartXml.SelectSingleNode("c:chartSpace", NameSpaceManager), "c:spPr");
                }
                return _fill;
            }
        }
        /// <summary>
        /// 3D-settings
        /// </summary>
        public ExcelView3D View3D
        {
            get
            {
                if (IsType3D())
                {
                    return new ExcelView3D(NameSpaceManager, ChartXml.SelectSingleNode("//c:view3D", NameSpaceManager));
                }
                else
                {
                    throw (new Exception("Charttype does not support 3D"));
                }

            }
        }
        //string _groupingPath = "c:chartSpace/c:chart/c:plotArea/{0}/c:grouping/@val";
        string _groupingPath = "c:grouping/@val";
        public eGrouping Grouping
        {
            get
            {
                return GetGroupingEnum(_chartXmlHelper.GetXmlNodeString(_groupingPath));
            }
            internal set
            {
                _chartXmlHelper.SetXmlNodeString(_groupingPath, GetGroupingText(value));
            }
        }
        //string _varyColorsPath = "c:chartSpace/c:chart/c:plotArea/{0}/c:varyColors/@val";
        string _varyColorsPath = "c:varyColors/@val";
        /// <summary>
        /// If the chart has only one serie this varies the colors for each point.
        /// </summary>
        public bool VaryColors
        {
            get
            {
                return _chartXmlHelper.GetXmlNodeBool(_varyColorsPath);
            }
            set
            {
                if (value)
                {
                    _chartXmlHelper.SetXmlNodeString(_varyColorsPath, "1");
                }
                else
                {
                    _chartXmlHelper.SetXmlNodeString(_varyColorsPath, "0");
                }
            }
        }
        internal Packaging.ZipPackagePart Part { get; set; }
        /// <summary>
        /// Package internal URI
        /// </summary>
        internal Uri UriChart { get; set; }
        internal new string Id
        {
            get { return ""; }
        }
        ExcelChartTitle _title = null;
        #endregion
       #region "Grouping Enum Translation"
        private string GetGroupingText(eGrouping grouping)
       {
           switch (grouping)
           {
               case eGrouping.Clustered:
                   return "clustered";
               case eGrouping.Stacked:
                   return "stacked";
               case eGrouping.PercentStacked:
                   return "percentStacked";
               default:
                   return "standard";

           }
       }
       private eGrouping GetGroupingEnum(string grouping)
       {
           switch (grouping)
           {
               case "stacked":
                   return eGrouping.Stacked;
               case "percentStacked":
                   return eGrouping.PercentStacked;
               default: //"clustered":               
                   return eGrouping.Clustered;
           }         
       }
       #endregion
       internal static ExcelChart GetChart(ExcelDrawings drawings, XmlNode node/*, XmlNode chartTypeNode*/)
       {
           XmlNode chartNode = node.SelectSingleNode("xdr:graphicFrame/a:graphic/a:graphicData/c:chart", drawings.NameSpaceManager);
           if (chartNode != null)
           {
               var drawingRelation = drawings.Part.GetRelationship(chartNode.Attributes["r:id"].Value);
               var uriChart = UriHelper.ResolvePartUri(drawings.UriDrawing, drawingRelation.TargetUri);

               var part = drawings.Part.Package.GetPart(uriChart);
               var chartXml = new XmlDocument();
               LoadXmlSafe(chartXml, part.GetStream()); 

               ExcelChart topChart = null;
               foreach (XmlElement n in chartXml.SelectSingleNode(rootPath, drawings.NameSpaceManager).ChildNodes)
                {
                    if (topChart == null)
                    {
                        topChart = GetChart(n, drawings, node, uriChart, part, chartXml, null);
                        if(topChart!=null)
                        {
                            topChart.PlotArea.ChartTypes.Add(topChart);
                        }
                    }
                    else
                    {
                        var subChart = GetChart(n, null, null, null, null, null, topChart);
                        if (subChart != null)
                        {
                            topChart.PlotArea.ChartTypes.Add(subChart);
                        }
                    }
                }               
                return topChart;
           }
           else
           {
               return null;
           }           
       }
       internal static ExcelChart GetChart(XmlElement chartNode, ExcelDrawings drawings, XmlNode node,  Uri uriChart, Packaging.ZipPackagePart part, XmlDocument chartXml, ExcelChart topChart)
       {
           switch (chartNode.LocalName)
           {
               case "area3DChart":
               case "areaChart":
               case "stockChart":
                   if (topChart == null)
                   {
                       return new ExcelChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelChart(topChart, chartNode);
                   }
               case "surface3DChart":
               case "surfaceChart":
                   if (topChart == null)
                   {
                       return new ExcelSurfaceChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelSurfaceChart(topChart, chartNode);
                   }
               case "radarChart":
                   if (topChart == null)
                   {
                       return new ExcelRadarChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelRadarChart(topChart, chartNode);
                   }
               case "bubbleChart":
                   if (topChart == null)
                   {
                       return new ExcelBubbleChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelBubbleChart(topChart, chartNode);
                   }
               case "barChart":
               case "bar3DChart":
                   if (topChart == null)
                   {
                       return new ExcelBarChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelBarChart(topChart, chartNode);
                   }
               case "doughnutChart":
                   if (topChart == null)
                   {
                       return new ExcelDoughnutChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelDoughnutChart(topChart, chartNode);
                   }
               case "pie3DChart":
               case "pieChart":
                   if (topChart == null)
                   {
                       return new ExcelPieChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelPieChart(topChart, chartNode);
                   }
           case "ofPieChart":
                   if (topChart == null)
                   {
                       return new ExcelOfPieChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelBarChart(topChart, chartNode);
                   }
               case "lineChart":
               case "line3DChart":
                   if (topChart == null)
                   {
                       return new ExcelLineChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelLineChart(topChart, chartNode);
                   }
               case "scatterChart":
                   if (topChart == null)
                   {
                       return new ExcelScatterChart(drawings, node, uriChart, part, chartXml, chartNode);
                   }
                   else
                   {
                       return new ExcelScatterChart(topChart, chartNode);
                   }
               default:
                   return null;
           }       
       }
       internal static ExcelChart GetNewChart(ExcelDrawings drawings, XmlNode drawNode, eChartType chartType, ExcelChart topChart, ExcelPivotTable PivotTableSource)
       {
            switch(chartType)
            {
                case eChartType.Pie:
                case eChartType.PieExploded:
                case eChartType.Pie3D:
                case eChartType.PieExploded3D:
                    return new ExcelPieChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                case eChartType.BarOfPie:
                case eChartType.PieOfPie:
                    return new ExcelOfPieChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                case eChartType.Doughnut:
                case eChartType.DoughnutExploded:
                    return new ExcelDoughnutChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                case eChartType.BarClustered:
                case eChartType.BarStacked:
                case eChartType.BarStacked100:
                case eChartType.BarClustered3D:
                case eChartType.BarStacked3D:
                case eChartType.BarStacked1003D:
                case eChartType.ConeBarClustered:
                case eChartType.ConeBarStacked:
                case eChartType.ConeBarStacked100:
                case eChartType.CylinderBarClustered:
                case eChartType.CylinderBarStacked:
                case eChartType.CylinderBarStacked100:
                case eChartType.PyramidBarClustered:
                case eChartType.PyramidBarStacked:
                case eChartType.PyramidBarStacked100:
                case eChartType.ColumnClustered:
                case eChartType.ColumnStacked:
                case eChartType.ColumnStacked100:
                case eChartType.Column3D:
                case eChartType.ColumnClustered3D:
                case eChartType.ColumnStacked3D:
                case eChartType.ColumnStacked1003D:
                case eChartType.ConeCol:
                case eChartType.ConeColClustered:
                case eChartType.ConeColStacked:
                case eChartType.ConeColStacked100:
                case eChartType.CylinderCol:
                case eChartType.CylinderColClustered:
                case eChartType.CylinderColStacked:
                case eChartType.CylinderColStacked100:
                case eChartType.PyramidCol:
                case eChartType.PyramidColClustered:
                case eChartType.PyramidColStacked:
                case eChartType.PyramidColStacked100:
                    return new ExcelBarChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                case eChartType.XYScatter:
                case eChartType.XYScatterLines:
                case eChartType.XYScatterLinesNoMarkers:
                case eChartType.XYScatterSmooth:
                case eChartType.XYScatterSmoothNoMarkers:
                    return new ExcelScatterChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                case eChartType.Line:
                case eChartType.Line3D:
                case eChartType.LineMarkers:
                case eChartType.LineMarkersStacked:
                case eChartType.LineMarkersStacked100:
                case eChartType.LineStacked:
                case eChartType.LineStacked100:
                    return new ExcelLineChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                case eChartType.Bubble:
                case eChartType.Bubble3DEffect:
                    return new ExcelBubbleChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                case eChartType.Radar:
                case eChartType.RadarFilled:
                case eChartType.RadarMarkers:
                    return new ExcelRadarChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                case eChartType.Surface:
                case eChartType.SurfaceTopView:
                case eChartType.SurfaceTopViewWireframe:
                case eChartType.SurfaceWireframe:
                    return new ExcelSurfaceChart(drawings, drawNode, chartType, topChart, PivotTableSource);
                default:
                    return new ExcelChart(drawings, drawNode, chartType, topChart, PivotTableSource);
            }
        }
        public ExcelPivotTable PivotTableSource
        {
            get;
            private set;
        }
       internal void SetPivotSource(ExcelPivotTable pivotTableSource)
       {
           PivotTableSource = pivotTableSource;
           XmlElement chart = ChartXml.SelectSingleNode("c:chartSpace/c:chart", NameSpaceManager) as XmlElement;

           var pivotSource = ChartXml.CreateElement("pivotSource", ExcelPackage.schemaChart);
           chart.ParentNode.InsertBefore(pivotSource, chart);
           pivotSource.InnerXml = string.Format("<c:name>[]{0}!{1}</c:name><c:fmtId val=\"0\"/>", PivotTableSource.WorkSheet.Name, pivotTableSource.Name);

           var fmts = ChartXml.CreateElement("pivotFmts", ExcelPackage.schemaChart);
           chart.PrependChild(fmts);
           fmts.InnerXml = "<c:pivotFmt><c:idx val=\"0\"/><c:marker><c:symbol val=\"none\"/></c:marker></c:pivotFmt>";

           Series.AddPivotSerie(pivotTableSource);
       }
       internal override void DeleteMe()
       {
           try
           {
               Part.Package.DeletePart(UriChart);
           }
           catch (Exception ex)
           {
               throw (new InvalidDataException("EPPlus internal error when deleteing chart.", ex));
           }
           base.DeleteMe();
       }
    }
}