text: ﻿using NPOI.OpenXml4Net.Util;
  using System;
  using System.Collections.Generic;
  using System.ComponentModel;
  using System.IO;
  using System.Text;
  using System.Xml;
  using System.Xml.Serialization;
  
  namespace NPOI.OpenXmlFormats.Dml.Chart
  {
  
  
      [Serializable]
  
      [System.ComponentModel.DesignerCategoryAttribute("code")]
      [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
      [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
      public class CT_RadarSer
      {
  
          private CT_UnsignedInt idxField;
  
          private CT_UnsignedInt orderField;
  
          private CT_SerTx txField;
  
          private CT_ShapeProperties spPrField;
  
          private CT_Marker markerField;
  
          private List<CT_DPt> dPtField;
  
          private CT_DLbls dLblsField;
  
          private CT_AxDataSource catField;
  
          private CT_NumDataSource valField;
  
          private List<CT_Extension> extLstField;
  
          public CT_RadarSer()
          {
  
          }
          public static CT_RadarSer Parse(XmlNode node, XmlNamespaceManager namespaceManager)
          {
              if (node == null)
                  return null;
              CT_RadarSer ctObj = new CT_RadarSer();
              ctObj.dPt = new List<CT_DPt>();
              ctObj.extLst = new List<CT_Extension>();
              foreach (XmlNode childNode in node.ChildNodes)
              {
                  if (childNode.LocalName == "idx")
                      ctObj.idx = CT_UnsignedInt.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "order")
                      ctObj.order = CT_UnsignedInt.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "tx")
                      ctObj.tx = CT_SerTx.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "spPr")
                      ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "marker")
                      ctObj.marker = CT_Marker.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "dLbls")
                      ctObj.dLbls = CT_DLbls.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "cat")
                      ctObj.cat = CT_AxDataSource.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "val")
                      ctObj.val = CT_NumDataSource.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "dPt")
                      ctObj.dPt.Add(CT_DPt.Parse(childNode, namespaceManager));
                  else if (childNode.LocalName == "extLst")
                      ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
              }
              return ctObj;
          }
  
  
  
          internal void Write(StreamWriter sw, string nodeName)
          {
              sw.Write(string.Format("<c:{0}", nodeName));
              sw.Write(">");
              if (this.idx != null)
                  this.idx.Write(sw, "idx");
              if (this.order != null)
                  this.order.Write(sw, "order");
              if (this.tx != null)
                  this.tx.Write(sw, "tx");
              if (this.spPr != null)
                  this.spPr.Write(sw, "spPr");
              if (this.marker != null)
                  this.marker.Write(sw, "marker");
              if (this.dLbls != null)
                  this.dLbls.Write(sw, "dLbls");
              if (this.cat != null)
                  this.cat.Write(sw, "cat");
              if (this.val != null)
                  this.val.Write(sw, "val");
              if (this.dPt != null)
              {
                  foreach (CT_DPt x in this.dPt)
                  {
                      x.Write(sw, "dPt");
                  }
              }
              if (this.extLst != null)
              {
                  foreach (CT_Extension x in this.extLst)
                  {
                      x.Write(sw, "extLst");
                  }
              }
              sw.Write(string.Format("</c:{0}>", nodeName));
          }
  
  
          [XmlElement(Order = 0)]
          public CT_UnsignedInt idx
          {
              get
              {
                  return this.idxField;
              }
              set
              {
                  this.idxField = value;
              }
          }
  
          [XmlElement(Order = 1)]
          public CT_UnsignedInt order
          {
              get
              {
                  return this.orderField;
              }
              set
              {
                  this.orderField = value;
              }
          }
  
          [XmlElement(Order = 2)]
          public CT_SerTx tx
          {
              get
              {
                  return this.txField;
              }
              set
              {
                  this.txField = value;
              }
          }
  
          [XmlElement(Order = 3)]
          public CT_ShapeProperties spPr
          {
              get
              {
                  return this.spPrField;
              }
              set
              {
                  this.spPrField = value;
              }
          }
  
          [XmlElement(Order = 4)]
          public CT_Marker marker
          {
              get
              {
                  return this.markerField;
              }
              set
              {
                  this.markerField = value;
              }
          }
  
          [XmlElement("dPt", Order = 5)]
          public List<CT_DPt> dPt
          {
              get
              {
                  return this.dPtField;
              }
              set
              {
                  this.dPtField = value;
              }
          }
  
          [XmlElement(Order = 6)]
          public CT_DLbls dLbls
          {
              get
              {
                  return this.dLblsField;
              }
              set
              {
                  this.dLblsField = value;
              }
          }
  
          [XmlElement(Order = 7)]
          public CT_AxDataSource cat
          {
              get
              {
                  return this.catField;
              }
              set
              {
                  this.catField = value;
              }
          }
  
          [XmlElement(Order = 8)]
          public CT_NumDataSource val
          {
              get
              {
                  return this.valField;
              }
              set
              {
                  this.valField = value;
              }
          }
  
          [XmlElement(Order = 9)]
          public List<CT_Extension> extLst
          {
              get
              {
                  return this.extLstField;
              }
              set
              {
                  this.extLstField = value;
              }
          }
      }
      [Serializable]
  
      [System.ComponentModel.DesignerCategoryAttribute("code")]
      [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
      [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
      public class CT_RadarStyle
      {
  
          private ST_RadarStyle valField;
  
          public CT_RadarStyle()
          {
              this.valField = ST_RadarStyle.standard;
          }
          public static CT_RadarStyle Parse(XmlNode node, XmlNamespaceManager namespaceManager)
          {
              if (node == null)
                  return null;
              CT_RadarStyle ctObj = new CT_RadarStyle();
              if (node.Attributes["val"] != null)
                  ctObj.val = (ST_RadarStyle)Enum.Parse(typeof(ST_RadarStyle), node.Attributes["val"].Value);
              return ctObj;
          }
  
  
  
          internal void Write(StreamWriter sw, string nodeName)
          {
              sw.Write(string.Format("<c:{0}", nodeName));
              XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
              sw.Write(">");
              sw.Write(string.Format("</c:{0}>", nodeName));
          }
  
          [XmlAttribute]
          [DefaultValue(ST_RadarStyle.standard)]
          public ST_RadarStyle val
          {
              get
              {
                  return this.valField;
              }
              set
              {
                  this.valField = value;
              }
          }
      }
  
  
      [Serializable]
      [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
      public enum ST_RadarStyle
      {
  
          /// <remarks/>
          standard,
  
          /// <remarks/>
          marker,
  
          /// <remarks/>
          filled,
      }
  
  
      [Serializable]
  
      [System.ComponentModel.DesignerCategoryAttribute("code")]
      [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
      [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
      public class CT_RadarChart
      {
  
          private CT_RadarStyle radarStyleField;
  
          private CT_Boolean varyColorsField;
  
          private List<CT_RadarSer> serField;
  
          private CT_DLbls dLblsField;
  
          private List<CT_UnsignedInt> axIdField;
  
          private List<CT_Extension> extLstField;
  
          public CT_RadarChart()
          {
          }
          public static CT_RadarChart Parse(XmlNode node, XmlNamespaceManager namespaceManager)
          {
              if (node == null)
                  return null;
              CT_RadarChart ctObj = new CT_RadarChart();
              ctObj.ser = new List<CT_RadarSer>();
              ctObj.axId = new List<CT_UnsignedInt>();
              ctObj.extLst = new List<CT_Extension>();
              foreach (XmlNode childNode in node.ChildNodes)
              {
                  if (childNode.LocalName == "radarStyle")
                      ctObj.radarStyle = CT_RadarStyle.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "varyColors")
                      ctObj.varyColors = CT_Boolean.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "dLbls")
                      ctObj.dLbls = CT_DLbls.Parse(childNode, namespaceManager);
                  else if (childNode.LocalName == "ser")
                      ctObj.ser.Add(CT_RadarSer.Parse(childNode, namespaceManager));
                  else if (childNode.LocalName == "axId")
                      ctObj.axId.Add(CT_UnsignedInt.Parse(childNode, namespaceManager));
                  else if (childNode.LocalName == "extLst")
                      ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
              }
              return ctObj;
          }
  
  
  
          internal void Write(StreamWriter sw, string nodeName)
          {
              sw.Write(string.Format("<c:{0}", nodeName));
              sw.Write(">");
              if (this.radarStyle != null)
                  this.radarStyle.Write(sw, "radarStyle");
              if (this.varyColors != null)
                  this.varyColors.Write(sw, "varyColors");
              if (this.ser != null)
              {
                  foreach (CT_RadarSer x in this.ser)
                  {
                      x.Write(sw, "ser");
                  }
              }
              if (this.dLbls != null)
                  this.dLbls.Write(sw, "dLbls");
              if (this.axId != null)
              {
                  foreach (CT_UnsignedInt x in this.axId)
                  {
                      x.Write(sw, "axId");
                  }
              }
              if (this.extLst != null)
              {
                  foreach (CT_Extension x in this.extLst)
                  {
                      x.Write(sw, "extLst");
                  }
              }
              sw.Write(string.Format("</c:{0}>", nodeName));
          }
  
  
          [XmlElement(Order = 0)]
          public CT_RadarStyle radarStyle
          {
              get
              {
                  return this.radarStyleField;
              }
              set
              {
                  this.radarStyleField = value;
              }
          }
  
          [XmlElement(Order = 1)]
          public CT_Boolean varyColors
          {
              get
              {
                  return this.varyColorsField;
              }
              set
              {
                  this.varyColorsField = value;
              }
          }
  
          [XmlElement("ser", Order = 2)]
          public List<CT_RadarSer> ser
          {
              get
              {
                  return this.serField;
              }
              set
              {
                  this.serField = value;
              }
          }
  
          [XmlElement(Order = 3)]
          public CT_DLbls dLbls
          {
              get
              {
                  return this.dLblsField;
              }
              set
              {
                  this.dLblsField = value;
              }
          }
  
          [XmlElement("axId", Order = 4)]
          public List<CT_UnsignedInt> axId
          {
              get
              {
                  return this.axIdField;
              }
              set
              {
                  this.axIdField = value;
              }
          }
  
          [XmlElement(Order = 5)]
          public List<CT_Extension> extLst
          {
              get
              {
                  return this.extLstField;
              }
              set
              {
                  this.extLstField = value;
              }
          }
      }
  
  }
  