npoi

1
// ------------------------------------------------------------------------------
2
//  <auto-generated>
3
//    Generated by Xsd2Code. Version 3.4.0.38967
4
//    <NameSpace>NPOI.OpenXmlFormats.Dml.Chart</NameSpace><Collection>List</Collection><codeType>CSharp</codeType><EnableDataBinding>False</EnableDataBinding><EnableLazyLoading>False</EnableLazyLoading><TrackingChangesEnable>False</TrackingChangesEnable><GenTrackingClasses>False</GenTrackingClasses><HidePrivateFieldInIDE>False</HidePrivateFieldInIDE><EnableSummaryComment>False</EnableSummaryComment><VirtualProp>False</VirtualProp><IncludeSerializeMethod>False</IncludeSerializeMethod><UseBaseClass>False</UseBaseClass><GenBaseClass>False</GenBaseClass><GenerateCloneMethod>False</GenerateCloneMethod><GenerateDataContracts>False</GenerateDataContracts><CodeBaseTag>Net20</CodeBaseTag><SerializeMethodName>Serialize</SerializeMethodName><DeserializeMethodName>Deserialize</DeserializeMethodName><SaveToFileMethodName>SaveToFile</SaveToFileMethodName><LoadFromFileMethodName>LoadFromFile</LoadFromFileMethodName><GenerateXMLAttributes>True</GenerateXMLAttributes><EnableEncoding>False</EnableEncoding><AutomaticProperties>False</AutomaticProperties><GenerateShouldSerialize>False</GenerateShouldSerialize><DisableDebug>True</DisableDebug><PropNameSpecified>Default</PropNameSpecified><Encoder>UTF8</Encoder><CustomUsings></CustomUsings><ExcludeIncludedTypes>True</ExcludeIncludedTypes><EnableInitializeFields>True</EnableInitializeFields>
5
//  </auto-generated>
6
// ------------------------------------------------------------------------------
7
namespace NPOI.OpenXmlFormats.Dml.Chart
8
{
9
    using System;
10
    using System.Diagnostics;
11
    using System.Xml.Serialization;
12
    using System.Collections;
13
    using System.Xml.Schema;
14
    using System.ComponentModel;
15
    using System.Collections.Generic;
16
    using System.IO;
17
    using System.Linq;
18
    using System.Xml;
19
    using NPOI.OpenXml4Net.Util;
20
    using System.Text;
21
    using System.Globalization;
22

23
    [Serializable]
24

25
    [System.ComponentModel.DesignerCategoryAttribute("code")]
26
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
27
    [XmlRoot("chartSpace", Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = false)]
28
    public class CT_ChartSpace
29
    {
30

31
        private CT_Boolean date1904Field;
32

33
        private CT_TextLanguageID langField;
34

35
        private CT_Boolean roundedCornersField;
36

37
        private CT_Style styleField;
38

39
        private CT_ColorMapping clrMapOvrField;
40

41
        private CT_PivotSource pivotSourceField;
42

43
        private CT_Protection protectionField;
44

45
        private CT_Chart chartField;
46

47
        private CT_ShapeProperties spPrField;
48

49
        private CT_TextBody txPrField;
50

51
        private CT_ExternalData externalDataField;
52

53
        private CT_PrintSettings printSettingsField;
54

55
        private CT_RelId userShapesField;
56

57
        private List<CT_Extension> extLstField;
58

59
        public CT_ChartSpace()
60
        {
61
        }
62
        public static CT_ChartSpace Parse(XmlNode node, XmlNamespaceManager namespaceManager)
63
        {
64
            if (node == null)
65
                return null;
66
            CT_ChartSpace ctObj = new CT_ChartSpace();
67
            ctObj.extLst = new List<CT_Extension>();
68
            foreach (XmlNode childNode in node.ChildNodes)
69
            {
70
                if (childNode.LocalName == "date1904")
71
                    ctObj.date1904 = CT_Boolean.Parse(childNode, namespaceManager);
72
                else if (childNode.LocalName == "lang")
73
                    ctObj.lang = CT_TextLanguageID.Parse(childNode, namespaceManager);
74
                else if (childNode.LocalName == "roundedCorners")
75
                    ctObj.roundedCorners = CT_Boolean.Parse(childNode, namespaceManager);
76
                else if (childNode.LocalName == "AlternateContent")
77
                    ctObj.alternateContent = Vml.CT_AlternateContent.Parse(childNode, namespaceManager);
78
                else if (childNode.LocalName == "style")
79
                    ctObj.style = CT_Style.Parse(childNode, namespaceManager);
80
                else if (childNode.LocalName == "clrMapOvr")
81
                    ctObj.clrMapOvr = CT_ColorMapping.Parse(childNode, namespaceManager);
82
                else if (childNode.LocalName == "pivotSource")
83
                    ctObj.pivotSource = CT_PivotSource.Parse(childNode, namespaceManager);
84
                else if (childNode.LocalName == "protection")
85
                    ctObj.protection = CT_Protection.Parse(childNode, namespaceManager);
86
                else if (childNode.LocalName == "chart")
87
                    ctObj.chart = CT_Chart.Parse(childNode, namespaceManager);
88
                else if (childNode.LocalName == "spPr")
89
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
90
                else if (childNode.LocalName == "txPr")
91
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
92
                else if (childNode.LocalName == "externalData")
93
                    ctObj.externalData = CT_ExternalData.Parse(childNode, namespaceManager);
94
                else if (childNode.LocalName == "printSettings")
95
                    ctObj.printSettings = CT_PrintSettings.Parse(childNode, namespaceManager);
96
                else if (childNode.LocalName == "userShapes")
97
                    ctObj.userShapes = CT_RelId.Parse(childNode, namespaceManager);
98
                else if (childNode.LocalName == "extLst")
99
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
100
            }
101
            return ctObj;
102
        }
103

104

105

106
        internal void Write(Stream stream)
107
        {
108
            using (StreamWriter sw = new StreamWriter(stream))
109
            {
110
                sw.Write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
111
                sw.Write("<c:chartSpace");
112
                sw.Write(" xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\"");
113
                sw.Write(" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"");
114
                sw.Write(">");
115
                if (this.date1904 != null)
116
                    this.date1904.Write(sw, "date1904");
117
                if (this.lang != null)
118
                    this.lang.Write(sw, "lang");
119
                if (this.roundedCorners != null)
120
                    this.roundedCorners.Write(sw, "roundedCorners");
121
                if (this.alternateContent != null)
122
                    this.alternateContent.Write(sw, "AlternateContent");
123
                if (this.style != null)
124
                    this.style.Write(sw, "style");
125
                if (this.clrMapOvr != null)
126
                    this.clrMapOvr.Write(sw, "clrMapOvr");
127
                if (this.pivotSource != null)
128
                    this.pivotSource.Write(sw, "pivotSource");
129
                if (this.protection != null)
130
                    this.protection.Write(sw, "protection");
131
                if (this.chart != null)
132
                    this.chart.Write(sw, "chart");
133
                if (this.spPr != null)
134
                    this.spPr.Write(sw, "spPr");
135
                if (this.txPr != null)
136
                    this.txPr.Write(sw, "txPr");
137
                if (this.externalData != null)
138
                    this.externalData.Write(sw, "externalData");
139
                if (this.printSettings != null)
140
                    this.printSettings.Write(sw, "printSettings");
141
                if (this.userShapes != null)
142
                    this.userShapes.Write(sw, "userShapes");
143
                if (this.extLst != null)
144
                {
145
                    foreach (CT_Extension x in this.extLst)
146
                    {
147
                        x.Write(sw, "extLst");
148
                    }
149
                }
150
                sw.Write("</c:chartSpace>");
151
            }
152
        }
153

154
        public CT_Chart AddNewChart()
155
        {
156
            this.chartField=new CT_Chart();
157
            return this.chartField;
158
        }
159
        public CT_PrintSettings AddNewPrintSettings()
160
        {
161
            this.printSettingsField = new CT_PrintSettings();
162
            return this.printSettingsField;
163
        }
164
        [XmlElement(Order = 0)]
165
        public CT_Boolean date1904
166
        {
167
            get
168
            {
169
                return this.date1904Field;
170
            }
171
            set
172
            {
173
                this.date1904Field = value;
174
            }
175
        }
176

177
        [XmlElement(Order = 1)]
178
        public CT_TextLanguageID lang
179
        {
180
            get
181
            {
182
                return this.langField;
183
            }
184
            set
185
            {
186
                this.langField = value;
187
            }
188
        }
189

190
        [XmlElement(Order = 2)]
191
        public CT_Boolean roundedCorners
192
        {
193
            get
194
            {
195
                return this.roundedCornersField;
196
            }
197
            set
198
            {
199
                this.roundedCornersField = value;
200
            }
201
        }
202

203
        Vml.CT_AlternateContent alternateContentField = null;
204
        public Vml.CT_AlternateContent alternateContent
205
        {
206
            get
207
            {
208
                return alternateContentField;
209
            }
210
            set
211
            {
212
                this.alternateContentField = value;
213
            }
214
        }
215

216
        [XmlElement(Order = 3)]
217
        public CT_Style style
218
        {
219
            get
220
            {
221
                return this.styleField;
222
            }
223
            set
224
            {
225
                this.styleField = value;
226
            }
227
        }
228

229
        [XmlElement(Order = 4)]
230
        public CT_ColorMapping clrMapOvr
231
        {
232
            get
233
            {
234
                return this.clrMapOvrField;
235
            }
236
            set
237
            {
238
                this.clrMapOvrField = value;
239
            }
240
        }
241

242
        [XmlElement(Order = 5)]
243
        public CT_PivotSource pivotSource
244
        {
245
            get
246
            {
247
                return this.pivotSourceField;
248
            }
249
            set
250
            {
251
                this.pivotSourceField = value;
252
            }
253
        }
254

255
        [XmlElement(Order = 6)]
256
        public CT_Protection protection
257
        {
258
            get
259
            {
260
                return this.protectionField;
261
            }
262
            set
263
            {
264
                this.protectionField = value;
265
            }
266
        }
267

268
        [XmlElement(Order = 7)]
269
        public CT_Chart chart
270
        {
271
            get
272
            {
273
                return this.chartField;
274
            }
275
            set
276
            {
277
                this.chartField = value;
278
            }
279
        }
280

281
        [XmlElement(Order = 8)]
282
        public CT_ShapeProperties spPr
283
        {
284
            get
285
            {
286
                return this.spPrField;
287
            }
288
            set
289
            {
290
                this.spPrField = value;
291
            }
292
        }
293

294
        [XmlElement(Order = 9)]
295
        public CT_TextBody txPr
296
        {
297
            get
298
            {
299
                return this.txPrField;
300
            }
301
            set
302
            {
303
                this.txPrField = value;
304
            }
305
        }
306

307
        [XmlElement(Order = 10)]
308
        public CT_ExternalData externalData
309
        {
310
            get
311
            {
312
                return this.externalDataField;
313
            }
314
            set
315
            {
316
                this.externalDataField = value;
317
            }
318
        }
319

320
        [XmlElement(Order = 11)]
321
        public CT_PrintSettings printSettings
322
        {
323
            get
324
            {
325
                return this.printSettingsField;
326
            }
327
            set
328
            {
329
                this.printSettingsField = value;
330
            }
331
        }
332

333
        [XmlElement(Order = 12)]
334
        public CT_RelId userShapes
335
        {
336
            get
337
            {
338
                return this.userShapesField;
339
            }
340
            set
341
            {
342
                this.userShapesField = value;
343
            }
344
        }
345

346
        [XmlArray(Order = 13)]
347
        [XmlArrayItem("ext", IsNullable = false)]
348
        public List<CT_Extension> extLst
349
        {
350
            get
351
            {
352
                return this.extLstField;
353
            }
354
            set
355
            {
356
                this.extLstField = value;
357
            }
358
        }
359
    }
360

361

362
    [Serializable]
363

364
    [System.ComponentModel.DesignerCategoryAttribute("code")]
365
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
366
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
367
    public class CT_Boolean
368
    {
369

370
        private bool valField;
371

372
        public CT_Boolean()
373
        {
374
            this.valField = true;
375
        }
376

377
        [XmlAttribute]
378
        public int val
379
        {
380
            get
381
            {
382
                return this.valField?1:0;
383
            }
384
            set
385
            {
386
                this.valField = value==1?true:false;
387
            }
388
        }
389
        public static CT_Boolean Parse(XmlNode node, XmlNamespaceManager namespaceManager)
390
        {
391
            if (node == null)
392
                return null;
393
            CT_Boolean ctObj = new CT_Boolean();
394
            ctObj.val = XmlHelper.ReadInt(node.Attributes["val"]);
395
            return ctObj;
396
        }
397

398

399

400
        internal void Write(StreamWriter sw, string nodeName)
401
        {
402
            sw.Write(string.Format("<c:{0}", nodeName));
403
            XmlHelper.WriteAttribute(sw, "val", this.val,true);
404
            sw.Write("/>");
405
        }
406

407
    }
408

409

410
    [Serializable]
411

412
    [System.ComponentModel.DesignerCategoryAttribute("code")]
413
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
414
    [XmlRoot("chart", Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = false)]
415
    public class CT_RelId
416
    {
417

418
        private string idField;
419

420
        [System.Xml.Serialization.XmlAttributeAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships")]
421
        public string id
422
        {
423
            get
424
            {
425
                return this.idField;
426
            }
427
            set
428
            {
429
                this.idField = value;
430
            }
431
        }
432
        public static CT_RelId Parse(XmlNode node, XmlNamespaceManager namespaceManager)
433
        {
434
            if (node == null)
435
                return null;
436
            CT_RelId ctObj = new CT_RelId();
437
            ctObj.id = XmlHelper.ReadString(node.Attributes["r:id"]);
438
            return ctObj;
439
        }
440

441

442

443
        internal void Write(StreamWriter sw, string nodeName)
444
        {
445
            sw.Write(string.Format("<c:{0}", nodeName));
446
            XmlHelper.WriteAttribute(sw, "r:id", this.id);
447
            sw.Write("/>");
448
        }
449

450
    }
451

452

453
    [Serializable]
454

455
    [System.ComponentModel.DesignerCategoryAttribute("code")]
456
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
457
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
458
    public class CT_PageSetup
459
    {
460

461
        private uint paperSizeField;
462

463
        private uint firstPageNumberField;
464

465
        private ST_PageSetupOrientation orientationField;
466

467
        private bool blackAndWhiteField;
468

469
        private bool draftField;
470

471
        private bool useFirstPageNumberField;
472

473
        private int horizontalDpiField;
474

475
        private int verticalDpiField;
476

477
        private uint copiesField;
478

479
        public CT_PageSetup()
480
        {
481
            this.paperSizeField = ((uint)(1));
482
            this.firstPageNumberField = ((uint)(1));
483
            this.orientationField = ST_PageSetupOrientation.@default;
484
            this.blackAndWhiteField = false;
485
            this.draftField = false;
486
            this.useFirstPageNumberField = false;
487
            this.horizontalDpiField = 600;
488
            this.verticalDpiField = 600;
489
            this.copiesField = ((uint)(1));
490
        }
491
        public static CT_PageSetup Parse(XmlNode node, XmlNamespaceManager namespaceManager)
492
        {
493
            if (node == null)
494
                return null;
495
            CT_PageSetup ctObj = new CT_PageSetup();
496
            if (node.Attributes["paperSize"] != null)
497
                ctObj.paperSize = XmlHelper.ReadUInt(node.Attributes["paperSize"]);
498
            if (node.Attributes["firstPageNumber"] != null)
499
                ctObj.firstPageNumber = XmlHelper.ReadUInt(node.Attributes["firstPageNumber"]);
500
            if (node.Attributes["orientation"] != null)
501
                ctObj.orientation = (ST_PageSetupOrientation)Enum.Parse(typeof(ST_PageSetupOrientation), node.Attributes["orientation"].Value);
502
            if (node.Attributes["blackAndWhite"] != null)
503
                ctObj.blackAndWhite = XmlHelper.ReadBool(node.Attributes["blackAndWhite"]);
504
            if (node.Attributes["draft"] != null)
505
                ctObj.draft = XmlHelper.ReadBool(node.Attributes["draft"]);
506
            if (node.Attributes["useFirstPageNumber"] != null)
507
                ctObj.useFirstPageNumber = XmlHelper.ReadBool(node.Attributes["useFirstPageNumber"]);
508
            if (node.Attributes["horizontalDpi"] != null)
509
                ctObj.horizontalDpi = XmlHelper.ReadInt(node.Attributes["horizontalDpi"]);
510
            if (node.Attributes["verticalDpi"] != null)
511
                ctObj.verticalDpi = XmlHelper.ReadInt(node.Attributes["verticalDpi"]);
512
            if (node.Attributes["copies"] != null)
513
                ctObj.copies = XmlHelper.ReadUInt(node.Attributes["copies"]);
514
            return ctObj;
515
        }
516

517

518

519
        internal void Write(StreamWriter sw, string nodeName)
520
        {
521
            sw.Write(string.Format("<c:{0}", nodeName));
522
            XmlHelper.WriteAttribute(sw, "paperSize", this.paperSize);
523
            XmlHelper.WriteAttribute(sw, "firstPageNumber", this.firstPageNumber);
524
            XmlHelper.WriteAttribute(sw, "orientation", this.orientation.ToString());
525
            XmlHelper.WriteAttribute(sw, "blackAndWhite", this.blackAndWhite);
526
            XmlHelper.WriteAttribute(sw, "draft", this.draft);
527
            XmlHelper.WriteAttribute(sw, "useFirstPageNumber", this.useFirstPageNumber);
528
            XmlHelper.WriteAttribute(sw, "horizontalDpi", this.horizontalDpi);
529
            XmlHelper.WriteAttribute(sw, "verticalDpi", this.verticalDpi);
530
            XmlHelper.WriteAttribute(sw, "copies", this.copies);
531
            sw.Write("/>");
532
        }
533

534
        [XmlAttribute]
535
        [DefaultValue(typeof(uint), "1")]
536
        public uint paperSize
537
        {
538
            get
539
            {
540
                return this.paperSizeField;
541
            }
542
            set
543
            {
544
                this.paperSizeField = value;
545
            }
546
        }
547

548
        [XmlAttribute]
549
        [DefaultValue(typeof(uint), "1")]
550
        public uint firstPageNumber
551
        {
552
            get
553
            {
554
                return this.firstPageNumberField;
555
            }
556
            set
557
            {
558
                this.firstPageNumberField = value;
559
            }
560
        }
561

562
        [XmlAttribute]
563
        [DefaultValue(ST_PageSetupOrientation.@default)]
564
        public ST_PageSetupOrientation orientation
565
        {
566
            get
567
            {
568
                return this.orientationField;
569
            }
570
            set
571
            {
572
                this.orientationField = value;
573
            }
574
        }
575

576
        [XmlAttribute]
577
        [DefaultValue(false)]
578
        public bool blackAndWhite
579
        {
580
            get
581
            {
582
                return this.blackAndWhiteField;
583
            }
584
            set
585
            {
586
                this.blackAndWhiteField = value;
587
            }
588
        }
589

590
        [XmlAttribute]
591
        [DefaultValue(false)]
592
        public bool draft
593
        {
594
            get
595
            {
596
                return this.draftField;
597
            }
598
            set
599
            {
600
                this.draftField = value;
601
            }
602
        }
603

604
        [XmlAttribute]
605
        [DefaultValue(false)]
606
        public bool useFirstPageNumber
607
        {
608
            get
609
            {
610
                return this.useFirstPageNumberField;
611
            }
612
            set
613
            {
614
                this.useFirstPageNumberField = value;
615
            }
616
        }
617

618
        [XmlAttribute]
619
        [DefaultValue(600)]
620
        public int horizontalDpi
621
        {
622
            get
623
            {
624
                return this.horizontalDpiField;
625
            }
626
            set
627
            {
628
                this.horizontalDpiField = value;
629
            }
630
        }
631

632
        [XmlAttribute]
633
        [DefaultValue(600)]
634
        public int verticalDpi
635
        {
636
            get
637
            {
638
                return this.verticalDpiField;
639
            }
640
            set
641
            {
642
                this.verticalDpiField = value;
643
            }
644
        }
645

646
        [XmlAttribute]
647
        [DefaultValue(typeof(uint), "1")]
648
        public uint copies
649
        {
650
            get
651
            {
652
                return this.copiesField;
653
            }
654
            set
655
            {
656
                this.copiesField = value;
657
            }
658
        }
659
    }
660

661

662
    [Serializable]
663
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
664
    public enum ST_PageSetupOrientation
665
    {
666

667
        /// <remarks/>
668
        @default,
669

670
        /// <remarks/>
671
        portrait,
672

673
        /// <remarks/>
674
        landscape,
675
    }
676

677

678
    [Serializable]
679

680
    [System.ComponentModel.DesignerCategoryAttribute("code")]
681
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
682
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
683
    public class CT_PageMargins
684
    {
685

686
        private double lField;
687

688
        private double rField;
689

690
        private double tField;
691

692
        private double bField;
693

694
        private double headerField;
695

696
        private double footerField;
697
        public static CT_PageMargins Parse(XmlNode node, XmlNamespaceManager namespaceManager)
698
        {
699
            if (node == null)
700
                return null;
701
            CT_PageMargins ctObj = new CT_PageMargins();
702
            if (node.Attributes["l"] != null)
703
                ctObj.l = XmlHelper.ReadDouble(node.Attributes["l"]);
704
            if (node.Attributes["r"] != null)
705
                ctObj.r = XmlHelper.ReadDouble(node.Attributes["r"]);
706
            if (node.Attributes["t"] != null)
707
                ctObj.t = XmlHelper.ReadDouble(node.Attributes["t"]);
708
            if (node.Attributes["b"] != null)
709
                ctObj.b = XmlHelper.ReadDouble(node.Attributes["b"]);
710
            if (node.Attributes["header"] != null)
711
                ctObj.header = XmlHelper.ReadDouble(node.Attributes["header"]);
712
            if (node.Attributes["footer"] != null)
713
                ctObj.footer = XmlHelper.ReadDouble(node.Attributes["footer"]);
714
            return ctObj;
715
        }
716

717

718

719
        internal void Write(StreamWriter sw, string nodeName)
720
        {
721
            sw.Write(string.Format("<c:{0}", nodeName));
722
            XmlHelper.WriteAttribute(sw, "l", this.l);
723
            XmlHelper.WriteAttribute(sw, "r", this.r);
724
            XmlHelper.WriteAttribute(sw, "t", this.t);
725
            XmlHelper.WriteAttribute(sw, "b", this.b);
726
            XmlHelper.WriteAttribute(sw, "header", this.header);
727
            XmlHelper.WriteAttribute(sw, "footer", this.footer);
728
            sw.Write("/>");
729
        }
730

731
        [XmlAttribute]
732
        public double l
733
        {
734
            get
735
            {
736
                return this.lField;
737
            }
738
            set
739
            {
740
                this.lField = value;
741
            }
742
        }
743

744
        [XmlAttribute]
745
        public double r
746
        {
747
            get
748
            {
749
                return this.rField;
750
            }
751
            set
752
            {
753
                this.rField = value;
754
            }
755
        }
756

757
        [XmlAttribute]
758
        public double t
759
        {
760
            get
761
            {
762
                return this.tField;
763
            }
764
            set
765
            {
766
                this.tField = value;
767
            }
768
        }
769

770
        [XmlAttribute]
771
        public double b
772
        {
773
            get
774
            {
775
                return this.bField;
776
            }
777
            set
778
            {
779
                this.bField = value;
780
            }
781
        }
782

783
        [XmlAttribute]
784
        public double header
785
        {
786
            get
787
            {
788
                return this.headerField;
789
            }
790
            set
791
            {
792
                this.headerField = value;
793
            }
794
        }
795

796
        [XmlAttribute]
797
        public double footer
798
        {
799
            get
800
            {
801
                return this.footerField;
802
            }
803
            set
804
            {
805
                this.footerField = value;
806
            }
807
        }
808
    }
809

810

811
    [Serializable]
812

813
    [System.ComponentModel.DesignerCategoryAttribute("code")]
814
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
815
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
816
    public class CT_HeaderFooter
817
    {
818

819
        private string oddHeaderField;
820

821
        private string oddFooterField;
822

823
        private string evenHeaderField;
824

825
        private string evenFooterField;
826

827
        private string firstHeaderField;
828

829
        private string firstFooterField;
830

831
        private bool alignWithMarginsField;
832

833
        private bool differentOddEvenField;
834

835
        private bool differentFirstField;
836

837
        public CT_HeaderFooter()
838
        {
839
            this.alignWithMarginsField = true;
840
            this.differentOddEvenField = false;
841
            this.differentFirstField = false;
842
        }
843
        public static CT_HeaderFooter Parse(XmlNode node, XmlNamespaceManager namespaceManager)
844
        {
845
            if (node == null)
846
                return null;
847
            CT_HeaderFooter ctObj = new CT_HeaderFooter();
848
            if (node.Attributes["alignWithMargins"] != null)
849
                ctObj.alignWithMargins = XmlHelper.ReadBool(node.Attributes["alignWithMargins"]);
850
            else
851
                ctObj.alignWithMargins = true;
852
            if (node.Attributes["differentOddEven"] != null)
853
                ctObj.differentOddEven = XmlHelper.ReadBool(node.Attributes["differentOddEven"]);
854
            if (node.Attributes["differentFirst"] != null)
855
                ctObj.differentFirst = XmlHelper.ReadBool(node.Attributes["differentFirst"]);
856
            foreach (XmlNode childNode in node.ChildNodes)
857
            {
858
                if (childNode.LocalName == "oddHeader")
859
                    ctObj.oddHeader = childNode.InnerText;
860
                else if (childNode.LocalName == "oddFooter")
861
                    ctObj.oddFooter = childNode.InnerText;
862
                else if (childNode.LocalName == "evenHeader")
863
                    ctObj.evenHeader = childNode.InnerText;
864
                else if (childNode.LocalName == "evenFooter")
865
                    ctObj.evenFooter = childNode.InnerText;
866
                else if (childNode.LocalName == "firstHeader")
867
                    ctObj.firstHeader = childNode.InnerText;
868
                else if (childNode.LocalName == "firstFooter")
869
                    ctObj.firstFooter = childNode.InnerText;
870
            }
871
            return ctObj;
872
        }
873

874

875

876
        internal void Write(StreamWriter sw, string nodeName)
877
        {
878
            sw.Write(string.Format("<c:{0}", nodeName));
879
            if(!this.alignWithMargins)
880
                XmlHelper.WriteAttribute(sw, "alignWithMargins", this.alignWithMargins, true);
881
            if(this.differentOddEven)
882
                XmlHelper.WriteAttribute(sw, "differentOddEven", this.differentOddEven);
883
            if(this.differentFirst)
884
                XmlHelper.WriteAttribute(sw, "differentFirst", this.differentFirst);
885
            sw.Write(">");
886
            if (this.oddHeader != null)
887
                sw.Write(string.Format("<oddHeader>{0}</oddHeader>", this.oddHeader));
888
            if (this.oddFooter != null)
889
                sw.Write(string.Format("<oddFooter>{0}</oddFooter>", this.oddFooter));
890
            if (this.evenHeader != null)
891
                sw.Write(string.Format("<evenHeader>{0}</evenHeader>", this.evenHeader));
892
            if (this.evenFooter != null)
893
                sw.Write(string.Format("<evenFooter>{0}</evenFooter>", this.evenFooter));
894
            if (this.firstHeader != null)
895
                sw.Write(string.Format("<firstHeader>{0}</firstHeader>", this.firstHeader));
896
            if (this.firstFooter != null)
897
                sw.Write(string.Format("<firstFooter>{0}</firstFooter>", this.firstFooter));
898
            sw.Write(string.Format("</c:{0}>", nodeName));
899
        }
900

901
        [XmlElement(Order = 0)]
902
        public string oddHeader
903
        {
904
            get
905
            {
906
                return this.oddHeaderField;
907
            }
908
            set
909
            {
910
                this.oddHeaderField = value;
911
            }
912
        }
913

914
        [XmlElement(Order = 1)]
915
        public string oddFooter
916
        {
917
            get
918
            {
919
                return this.oddFooterField;
920
            }
921
            set
922
            {
923
                this.oddFooterField = value;
924
            }
925
        }
926

927
        [XmlElement(Order = 2)]
928
        public string evenHeader
929
        {
930
            get
931
            {
932
                return this.evenHeaderField;
933
            }
934
            set
935
            {
936
                this.evenHeaderField = value;
937
            }
938
        }
939

940
        [XmlElement(Order = 3)]
941
        public string evenFooter
942
        {
943
            get
944
            {
945
                return this.evenFooterField;
946
            }
947
            set
948
            {
949
                this.evenFooterField = value;
950
            }
951
        }
952

953
        [XmlElement(Order = 4)]
954
        public string firstHeader
955
        {
956
            get
957
            {
958
                return this.firstHeaderField;
959
            }
960
            set
961
            {
962
                this.firstHeaderField = value;
963
            }
964
        }
965

966
        [XmlElement(Order = 5)]
967
        public string firstFooter
968
        {
969
            get
970
            {
971
                return this.firstFooterField;
972
            }
973
            set
974
            {
975
                this.firstFooterField = value;
976
            }
977
        }
978

979
        [XmlAttribute]
980
        [DefaultValue(true)]
981
        public bool alignWithMargins
982
        {
983
            get
984
            {
985
                return this.alignWithMarginsField;
986
            }
987
            set
988
            {
989
                this.alignWithMarginsField = value;
990
            }
991
        }
992

993
        [XmlAttribute]
994
        [DefaultValue(false)]
995
        public bool differentOddEven
996
        {
997
            get
998
            {
999
                return this.differentOddEvenField;
1000
            }
1001
            set
1002
            {
1003
                this.differentOddEvenField = value;
1004
            }
1005
        }
1006

1007
        [XmlAttribute]
1008
        [DefaultValue(false)]
1009
        public bool differentFirst
1010
        {
1011
            get
1012
            {
1013
                return this.differentFirstField;
1014
            }
1015
            set
1016
            {
1017
                this.differentFirstField = value;
1018
            }
1019
        }
1020
    }
1021

1022

1023
    [Serializable]
1024

1025
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1026
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1027
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1028
    public class CT_PrintSettings
1029
    {
1030

1031
        private CT_HeaderFooter headerFooterField;
1032

1033
        private CT_PageMargins pageMarginsField;
1034

1035
        private CT_PageSetup pageSetupField;
1036

1037
        private CT_RelId legacyDrawingHFField;
1038

1039
        public CT_PrintSettings()
1040
        {
1041
            //this.legacyDrawingHFField = new CT_RelId();
1042

1043
        }
1044
        public static CT_PrintSettings Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1045
        {
1046
            if (node == null)
1047
                return null;
1048
            CT_PrintSettings ctObj = new CT_PrintSettings();
1049
            foreach (XmlNode childNode in node.ChildNodes)
1050
            {
1051
                if (childNode.LocalName == "headerFooter")
1052
                    ctObj.headerFooter = CT_HeaderFooter.Parse(childNode, namespaceManager);
1053
                else if (childNode.LocalName == "pageMargins")
1054
                    ctObj.pageMargins = CT_PageMargins.Parse(childNode, namespaceManager);
1055
                else if (childNode.LocalName == "pageSetup")
1056
                    ctObj.pageSetup = CT_PageSetup.Parse(childNode, namespaceManager);
1057
                else if (childNode.LocalName == "legacyDrawingHF")
1058
                    ctObj.legacyDrawingHF = CT_RelId.Parse(childNode, namespaceManager);
1059
            }
1060
            return ctObj;
1061
        }
1062

1063

1064

1065
        internal void Write(StreamWriter sw, string nodeName)
1066
        {
1067
            sw.Write(string.Format("<c:{0}", nodeName));
1068
            sw.Write(">");
1069
            if (this.headerFooter != null)
1070
                this.headerFooter.Write(sw, "headerFooter");
1071
            if (this.pageMargins != null)
1072
                this.pageMargins.Write(sw, "pageMargins");
1073
            if (this.pageSetup != null)
1074
                this.pageSetup.Write(sw, "pageSetup");
1075
            if (this.legacyDrawingHF != null)
1076
                this.legacyDrawingHF.Write(sw, "legacyDrawingHF");
1077
            sw.Write(string.Format("</c:{0}>", nodeName));
1078
        }
1079

1080
        public CT_HeaderFooter AddNewHeaderFooter()
1081
        {
1082
            this.headerFooterField = new CT_HeaderFooter();
1083
            return this.headerFooterField;
1084
        }
1085
        public CT_PageSetup AddNewPageSetup()
1086
        {
1087
            this.pageSetupField = new CT_PageSetup();
1088
            return this.pageSetupField;
1089
        }
1090
        public CT_PageMargins AddNewPageMargins()
1091
        {
1092
            this.pageMarginsField = new CT_PageMargins();
1093
            return this.pageMarginsField;
1094
        }
1095

1096
        [XmlElement(Order = 0)]
1097
        public CT_HeaderFooter headerFooter
1098
        {
1099
            get
1100
            {
1101
                return this.headerFooterField;
1102
            }
1103
            set
1104
            {
1105
                this.headerFooterField = value;
1106
            }
1107
        }
1108

1109
        [XmlElement(Order = 1)]
1110
        public CT_PageMargins pageMargins
1111
        {
1112
            get
1113
            {
1114
                return this.pageMarginsField;
1115
            }
1116
            set
1117
            {
1118
                this.pageMarginsField = value;
1119
            }
1120
        }
1121

1122
        [XmlElement(Order = 2)]
1123
        public CT_PageSetup pageSetup
1124
        {
1125
            get
1126
            {
1127
                return this.pageSetupField;
1128
            }
1129
            set
1130
            {
1131
                this.pageSetupField = value;
1132
            }
1133
        }
1134

1135
        [XmlElement(Order = 3)]
1136
        public CT_RelId legacyDrawingHF
1137
        {
1138
            get
1139
            {
1140
                return this.legacyDrawingHFField;
1141
            }
1142
            set
1143
            {
1144
                this.legacyDrawingHFField = value;
1145
            }
1146
        }
1147
    }
1148

1149

1150
    [Serializable]
1151

1152
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1153
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1154
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1155
    public class CT_ExternalData
1156
    {
1157

1158
        private CT_Boolean autoUpdateField;
1159

1160
        private string idField;
1161

1162
        public CT_ExternalData()
1163
        {
1164
        }
1165
        public static CT_ExternalData Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1166
        {
1167
            if (node == null)
1168
                return null;
1169
            CT_ExternalData ctObj = new CT_ExternalData();
1170
            ctObj.id = XmlHelper.ReadString(node.Attributes["r:id"]);
1171
            foreach (XmlNode childNode in node.ChildNodes)
1172
            {
1173
                if (childNode.LocalName == "autoUpdate")
1174
                    ctObj.autoUpdate = CT_Boolean.Parse(childNode, namespaceManager);
1175
            }
1176
            return ctObj;
1177
        }
1178

1179

1180

1181
        internal void Write(StreamWriter sw, string nodeName)
1182
        {
1183
            sw.Write(string.Format("<c:{0}", nodeName));
1184
            XmlHelper.WriteAttribute(sw, "r:id", this.id);
1185
            sw.Write(">");
1186
            if (this.autoUpdate != null)
1187
                this.autoUpdate.Write(sw, "autoUpdate");
1188
            sw.Write(string.Format("</c:{0}>", nodeName));
1189
        }
1190

1191
        [XmlElement(Order = 0)]
1192
        public CT_Boolean autoUpdate
1193
        {
1194
            get
1195
            {
1196
                return this.autoUpdateField;
1197
            }
1198
            set
1199
            {
1200
                this.autoUpdateField = value;
1201
            }
1202
        }
1203

1204
        [System.Xml.Serialization.XmlAttributeAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships")]
1205
        public string id
1206
        {
1207
            get
1208
            {
1209
                return this.idField;
1210
            }
1211
            set
1212
            {
1213
                this.idField = value;
1214
            }
1215
        }
1216

1217
    }
1218

1219

1220
    [Serializable]
1221

1222
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1223
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1224
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1225
    public class CT_DispBlanksAs
1226
    {
1227

1228
        private ST_DispBlanksAs valField;
1229

1230
        public CT_DispBlanksAs()
1231
        {
1232
            this.valField = ST_DispBlanksAs.zero;
1233
        }
1234
        public static CT_DispBlanksAs Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1235
        {
1236
            if (node == null)
1237
                return null;
1238
            CT_DispBlanksAs ctObj = new CT_DispBlanksAs();
1239
            if (node.Attributes["val"] != null)
1240
                ctObj.val = (ST_DispBlanksAs)Enum.Parse(typeof(ST_DispBlanksAs), node.Attributes["val"].Value);
1241
            return ctObj;
1242
        }
1243

1244

1245

1246
        internal void Write(StreamWriter sw, string nodeName)
1247
        {
1248
            sw.Write(string.Format("<c:{0}", nodeName));
1249
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
1250
            sw.Write("/>");
1251
        }
1252

1253
        [XmlAttribute]
1254
        [DefaultValue(ST_DispBlanksAs.zero)]
1255
        public ST_DispBlanksAs val
1256
        {
1257
            get
1258
            {
1259
                return this.valField;
1260
            }
1261
            set
1262
            {
1263
                this.valField = value;
1264
            }
1265
        }
1266
    }
1267

1268

1269
    [Serializable]
1270
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1271
    public enum ST_DispBlanksAs
1272
    {
1273

1274
        /// <remarks/>
1275
        span,
1276

1277
        /// <remarks/>
1278
        gap,
1279

1280
        /// <remarks/>
1281
        zero,
1282
    }
1283

1284

1285
    [Serializable]
1286

1287
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1288
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1289
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1290
    public class CT_LegendEntry
1291
    {
1292

1293
        private CT_UnsignedInt idxField;
1294

1295
        private object itemField;
1296

1297
        private List<CT_Extension> extLstField;
1298

1299
        public CT_LegendEntry()
1300
        {
1301

1302
        }
1303

1304
        public static CT_LegendEntry Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1305
        {
1306
            if (node == null)
1307
                return null;
1308
            CT_LegendEntry ctObj = new CT_LegendEntry();
1309
            ctObj.extLst = new List<CT_Extension>();
1310
            foreach (XmlNode childNode in node.ChildNodes)
1311
            {
1312
                if (childNode.LocalName == "idx")
1313
                    ctObj.idx = CT_UnsignedInt.Parse(childNode, namespaceManager);
1314
                else if (childNode.LocalName == "Item")
1315
                    ctObj.Item = new Object();
1316
                else if (childNode.LocalName == "extLst")
1317
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
1318
            }
1319
            return ctObj;
1320
        }
1321

1322

1323

1324
        internal void Write(StreamWriter sw, string nodeName)
1325
        {
1326
            sw.Write(string.Format("<c:{0}", nodeName));
1327
            sw.Write(">");
1328
            if (this.idx != null)
1329
                this.idx.Write(sw, "idx");
1330
            if (this.Item != null)
1331
                sw.Write("<Item/>");
1332
            if (this.extLst != null)
1333
            {
1334
                foreach (CT_Extension x in this.extLst)
1335
                {
1336
                    x.Write(sw, "extLst");
1337
                }
1338
            }
1339
            sw.Write(string.Format("</c:{0}>", nodeName));
1340
        }
1341

1342
        [XmlElement(Order = 0)]
1343
        public CT_UnsignedInt idx
1344
        {
1345
            get
1346
            {
1347
                return this.idxField;
1348
            }
1349
            set
1350
            {
1351
                this.idxField = value;
1352
            }
1353
        }
1354

1355
        [XmlElement("delete", typeof(CT_Boolean), Order = 1)]
1356
        [XmlElement("txPr", typeof(CT_TextBody), Order = 1)]
1357
        public object Item
1358
        {
1359
            get
1360
            {
1361
                return this.itemField;
1362
            }
1363
            set
1364
            {
1365
                this.itemField = value;
1366
            }
1367
        }
1368

1369
        [XmlArray(Order = 2)]
1370
        [XmlArrayItem("ext", IsNullable = false)]
1371
        public List<CT_Extension> extLst
1372
        {
1373
            get
1374
            {
1375
                return this.extLstField;
1376
            }
1377
            set
1378
            {
1379
                this.extLstField = value;
1380
            }
1381
        }
1382
    }
1383

1384

1385
    [Serializable]
1386

1387
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1388
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1389
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1390
    public class CT_UnsignedInt
1391
    {
1392

1393
        private uint valField;
1394

1395
        [XmlAttribute]
1396
        public uint val
1397
        {
1398
            get
1399
            {
1400
                return this.valField;
1401
            }
1402
            set
1403
            {
1404
                this.valField = value;
1405
            }
1406
        }
1407
        public static CT_UnsignedInt Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1408
        {
1409
            if (node == null)
1410
                return null;
1411
            CT_UnsignedInt ctObj = new CT_UnsignedInt();
1412
            ctObj.val = XmlHelper.ReadUInt(node.Attributes["val"]);
1413
            return ctObj;
1414
        }
1415

1416

1417

1418
        internal void Write(StreamWriter sw, string nodeName)
1419
        {
1420
            sw.Write(string.Format("<c:{0}", nodeName));
1421
            XmlHelper.WriteAttribute(sw, "val", this.val, true);
1422
            sw.Write("/>");
1423
        }
1424

1425
    }
1426

1427

1428
    [Serializable]
1429

1430
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1431
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1432
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1433
    public class CT_Extension
1434
    {
1435

1436
        private string anyField;
1437

1438
        private string uriField;
1439

1440
        [XmlText]
1441
        public string Any
1442
        {
1443
            get
1444
            {
1445
                return this.anyField;
1446
            }
1447
            set
1448
            {
1449
                this.anyField = value;
1450
            }
1451
        }
1452

1453
        [System.Xml.Serialization.XmlAttributeAttribute(DataType = "token")]
1454
        public string uri
1455
        {
1456
            get
1457
            {
1458
                return this.uriField;
1459
            }
1460
            set
1461
            {
1462
                this.uriField = value;
1463
            }
1464
        }
1465
        public static CT_Extension Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1466
        {
1467
            if (node == null)
1468
                return null;
1469
            CT_Extension ctObj = new CT_Extension();
1470
            ctObj.uri = XmlHelper.ReadString(node.Attributes["uri"]);
1471
            ctObj.Any = node.InnerXml;
1472

1473
            return ctObj;
1474
        }
1475

1476

1477

1478
        internal void Write(StreamWriter sw, string nodeName)
1479
        {
1480
            sw.Write(string.Format("<c:{0}", nodeName));
1481
            XmlHelper.WriteAttribute(sw, "uri", this.uri);
1482
            sw.Write(">");
1483
            if (this.Any != null)
1484
                sw.Write(this.Any);
1485
            sw.Write(string.Format("</c:{0}>", nodeName));
1486
        }
1487

1488
    }
1489

1490

1491
    [Serializable]
1492

1493
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1494
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1495
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1496
    public class CT_LegendPos
1497
    {
1498

1499
        private ST_LegendPos valField;
1500

1501
        public CT_LegendPos()
1502
        {
1503
            this.valField = ST_LegendPos.r;
1504
        }
1505

1506
        [XmlAttribute]
1507
        [DefaultValue(ST_LegendPos.r)]
1508
        public ST_LegendPos val
1509
        {
1510
            get
1511
            {
1512
                return this.valField;
1513
            }
1514
            set
1515
            {
1516
                this.valField = value;
1517
            }
1518
        }
1519
        public static CT_LegendPos Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1520
        {
1521
            if (node == null)
1522
                return null;
1523
            CT_LegendPos ctObj = new CT_LegendPos();
1524
            if (node.Attributes["val"] != null)
1525
                ctObj.val = (ST_LegendPos)Enum.Parse(typeof(ST_LegendPos), node.Attributes["val"].Value);
1526
            return ctObj;
1527
        }
1528

1529

1530

1531
        internal void Write(StreamWriter sw, string nodeName)
1532
        {
1533
            sw.Write(string.Format("<c:{0}", nodeName));
1534
            if(this.val!= ST_LegendPos.r)
1535
                XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
1536
            sw.Write("/>");
1537
        }
1538

1539
    }
1540

1541

1542
    [Serializable]
1543
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1544
    public enum ST_LegendPos
1545
    {
1546

1547
        /// <remarks/>
1548
        b,
1549

1550
        /// <remarks/>
1551
        tr,
1552

1553
        /// <remarks/>
1554
        l,
1555

1556
        /// <remarks/>
1557
        r,
1558

1559
        /// <remarks/>
1560
        t,
1561
    }
1562

1563

1564
    [Serializable]
1565

1566
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1567
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1568
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1569
    public class CT_Legend
1570
    {
1571

1572
        private CT_LegendPos legendPosField;
1573

1574
        private List<CT_LegendEntry> legendEntryField;
1575

1576
        private CT_Layout layoutField;
1577

1578
        private CT_Boolean overlayField;
1579

1580
        private CT_ShapeProperties spPrField;
1581

1582
        private CT_TextBody txPrField;
1583

1584
        private List<CT_Extension> extLstField;
1585

1586
        public CT_Legend()
1587
        {
1588

1589
        }
1590
        public static CT_Legend Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1591
        {
1592
            if (node == null)
1593
                return null;
1594
            CT_Legend ctObj = new CT_Legend();
1595
            ctObj.legendEntry = new List<CT_LegendEntry>();
1596
            ctObj.extLst = new List<CT_Extension>();
1597
            foreach (XmlNode childNode in node.ChildNodes)
1598
            {
1599
                if (childNode.LocalName == "legendPos")
1600
                    ctObj.legendPos = CT_LegendPos.Parse(childNode, namespaceManager);
1601
                else if (childNode.LocalName == "layout")
1602
                    ctObj.layout = CT_Layout.Parse(childNode, namespaceManager);
1603
                else if (childNode.LocalName == "overlay")
1604
                    ctObj.overlay = CT_Boolean.Parse(childNode, namespaceManager);
1605
                else if (childNode.LocalName == "spPr")
1606
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
1607
                else if (childNode.LocalName == "txPr")
1608
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
1609
                else if (childNode.LocalName == "legendEntry")
1610
                    ctObj.legendEntry.Add(CT_LegendEntry.Parse(childNode, namespaceManager));
1611
                else if (childNode.LocalName == "extLst")
1612
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
1613
            }
1614
            return ctObj;
1615
        }
1616

1617

1618

1619
        internal void Write(StreamWriter sw, string nodeName)
1620
        {
1621
            sw.Write(string.Format("<c:{0}", nodeName));
1622
            sw.Write(">");
1623
            if (this.legendPos != null)
1624
                this.legendPos.Write(sw, "legendPos");
1625
            if (this.layout != null)
1626
                this.layout.Write(sw, "layout");
1627
            if (this.overlay != null)
1628
                this.overlay.Write(sw, "overlay");
1629
            if (this.spPr != null)
1630
                this.spPr.Write(sw, "spPr");
1631
            if (this.txPr != null)
1632
                this.txPr.Write(sw, "txPr");
1633
            if (this.legendEntry != null)
1634
            {
1635
                foreach (CT_LegendEntry x in this.legendEntry)
1636
                {
1637
                    x.Write(sw, "legendEntry");
1638
                }
1639
            }
1640
            if (this.extLst != null)
1641
            {
1642
                foreach (CT_Extension x in this.extLst)
1643
                {
1644
                    x.Write(sw, "extLst");
1645
                }
1646
            }
1647
            sw.Write(string.Format("</c:{0}>", nodeName));
1648
        }
1649

1650
        public CT_Layout AddNewLayout()
1651
        {
1652
            this.layoutField = new CT_Layout();
1653
            return this.layoutField;
1654
        }
1655
        public bool IsSetLegendPos()
1656
        {
1657
            return legendPosSpecifiedField;
1658
        }
1659
        public CT_LegendPos AddNewLegendPos()
1660
        {
1661
            if (this.legendPosField == null)
1662
                this.legendPosField = new CT_LegendPos();
1663
            return this.legendPosField;
1664
        }
1665

1666
        private bool legendPosSpecifiedField=false;
1667
        [XmlIgnore]
1668
        public bool legendPosSpecified
1669
        {
1670
            get { return legendPosSpecifiedField; }
1671
            set { legendPosSpecifiedField = value; }
1672
        }
1673
        [XmlElement(Order = 0)]
1674
        public CT_LegendPos legendPos
1675
        {
1676
            get
1677
            {
1678
                return this.legendPosField;
1679
            }
1680
            set
1681
            {
1682
                this.legendPosField = value;
1683
            }
1684
        }
1685

1686
        [XmlElement("legendEntry", Order = 1)]
1687
        public List<CT_LegendEntry> legendEntry
1688
        {
1689
            get
1690
            {
1691
                return this.legendEntryField;
1692
            }
1693
            set
1694
            {
1695
                this.legendEntryField = value;
1696
            }
1697
        }
1698
        public bool IsSetLayout()
1699
        {
1700
            return layoutSpecifiedField;
1701
        }
1702
        private bool layoutSpecifiedField;
1703
        [XmlIgnore]
1704
        public bool layoutSpecified
1705
        {
1706
            get { return layoutSpecifiedField; }
1707
            set { layoutSpecifiedField = value; }
1708
        }
1709
        [XmlElement(Order = 2)]
1710
        public CT_Layout layout
1711
        {
1712
            get
1713
            {
1714
                return this.layoutField;
1715
            }
1716
            set
1717
            {
1718
                this.layoutField = value;
1719
            }
1720
        }
1721

1722
        [XmlElement(Order = 3)]
1723
        public CT_Boolean overlay
1724
        {
1725
            get
1726
            {
1727
                return this.overlayField;
1728
            }
1729
            set
1730
            {
1731
                this.overlayField = value;
1732
            }
1733
        }
1734

1735
        [XmlElement(Order = 4)]
1736
        public CT_ShapeProperties spPr
1737
        {
1738
            get
1739
            {
1740
                return this.spPrField;
1741
            }
1742
            set
1743
            {
1744
                this.spPrField = value;
1745
            }
1746
        }
1747

1748
        [XmlElement(Order = 5)]
1749
        public CT_TextBody txPr
1750
        {
1751
            get
1752
            {
1753
                return this.txPrField;
1754
            }
1755
            set
1756
            {
1757
                this.txPrField = value;
1758
            }
1759
        }
1760

1761
        [XmlArray(Order = 6)]
1762
        [XmlArrayItem("ext", IsNullable = false)]
1763
        public List<CT_Extension> extLst
1764
        {
1765
            get
1766
            {
1767
                return this.extLstField;
1768
            }
1769
            set
1770
            {
1771
                this.extLstField = value;
1772
            }
1773
        }
1774

1775
        public bool IsSetOverlay()
1776
        {
1777
            return this.overlayField != null && this.overlayField.val > 0;
1778
        }
1779

1780
        public void AddNewOverlay()
1781
        {
1782
            this.overlayField = new CT_Boolean();
1783
            //return this.overlayField;
1784
        }
1785
    }
1786

1787

1788
    [Serializable]
1789

1790
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1791
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1792
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1793
    public class CT_Layout
1794
    {
1795

1796
        private CT_ManualLayout manualLayoutField;
1797

1798
        private List<CT_Extension> extLstField;
1799

1800
        public CT_Layout()
1801
        {
1802
            //this.extLstField = new List<CT_Extension>();
1803
            //this.manualLayoutField = new CT_ManualLayout();
1804
        }
1805
        public static CT_Layout Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1806
        {
1807
            if (node == null)
1808
                return null;
1809
            CT_Layout ctObj = new CT_Layout();
1810
            ctObj.extLst = new List<CT_Extension>();
1811
            foreach (XmlNode childNode in node.ChildNodes)
1812
            {
1813
                if (childNode.LocalName == "manualLayout")
1814
                    ctObj.manualLayout = CT_ManualLayout.Parse(childNode, namespaceManager);
1815
                else if (childNode.LocalName == "extLst")
1816
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
1817
            }
1818
            return ctObj;
1819
        }
1820

1821

1822

1823
        internal void Write(StreamWriter sw, string nodeName)
1824
        {
1825
            sw.Write(string.Format("<c:{0}", nodeName));
1826
            sw.Write(">");
1827
            if (this.manualLayout != null)
1828
                this.manualLayout.Write(sw, "manualLayout");
1829
            if (this.extLst != null)
1830
            {
1831
                foreach (CT_Extension x in this.extLst)
1832
                {
1833
                    x.Write(sw, "extLst");
1834
                }
1835
            }
1836
            sw.Write(string.Format("</c:{0}>", nodeName));
1837
        }
1838

1839
        public bool IsSetManualLayout()
1840
        {
1841
            return this.manualLayout!=null;
1842
        }
1843
        public CT_ManualLayout AddNewManualLayout()
1844
        {
1845
            this.manualLayoutField = new CT_ManualLayout();
1846
            return this.manualLayoutField;
1847
        }
1848
        [XmlElement(Order = 0)]
1849
        public CT_ManualLayout manualLayout
1850
        {
1851
            get
1852
            {
1853
                return this.manualLayoutField;
1854
            }
1855
            set
1856
            {
1857
                this.manualLayoutField = value;
1858
            }
1859
        }
1860

1861
        [XmlElement(Order = 1)]
1862
        public List<CT_Extension> extLst
1863
        {
1864
            get
1865
            {
1866
                return this.extLstField;
1867
            }
1868
            set
1869
            {
1870
                this.extLstField = value;
1871
            }
1872
        }
1873
    }
1874

1875

1876
    [Serializable]
1877

1878
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1879
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
1880
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
1881
    public class CT_ManualLayout
1882
    {
1883

1884
        private CT_LayoutTarget layoutTargetField;
1885

1886
        private CT_LayoutMode xModeField;
1887

1888
        private CT_LayoutMode yModeField;
1889

1890
        private CT_LayoutMode wModeField;
1891

1892
        private CT_LayoutMode hModeField;
1893

1894
        private CT_Double xField;
1895

1896
        private CT_Double yField;
1897

1898
        private CT_Double wField;
1899

1900
        private CT_Double hField;
1901

1902
        private List<CT_Extension> extLstField;
1903
        public static CT_ManualLayout Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1904
        {
1905
            if (node == null)
1906
                return null;
1907
            CT_ManualLayout ctObj = new CT_ManualLayout();
1908
            ctObj.extLst = new List<CT_Extension>();
1909
            foreach (XmlNode childNode in node.ChildNodes)
1910
            {
1911
                if (childNode.LocalName == "layoutTarget")
1912
                    ctObj.layoutTarget = CT_LayoutTarget.Parse(childNode, namespaceManager);
1913
                else if (childNode.LocalName == "xMode")
1914
                    ctObj.xMode = CT_LayoutMode.Parse(childNode, namespaceManager);
1915
                else if (childNode.LocalName == "yMode")
1916
                    ctObj.yMode = CT_LayoutMode.Parse(childNode, namespaceManager);
1917
                else if (childNode.LocalName == "wMode")
1918
                    ctObj.wMode = CT_LayoutMode.Parse(childNode, namespaceManager);
1919
                else if (childNode.LocalName == "hMode")
1920
                    ctObj.hMode = CT_LayoutMode.Parse(childNode, namespaceManager);
1921
                else if (childNode.LocalName == "x")
1922
                    ctObj.x = CT_Double.Parse(childNode, namespaceManager);
1923
                else if (childNode.LocalName == "y")
1924
                    ctObj.y = CT_Double.Parse(childNode, namespaceManager);
1925
                else if (childNode.LocalName == "w")
1926
                    ctObj.w = CT_Double.Parse(childNode, namespaceManager);
1927
                else if (childNode.LocalName == "h")
1928
                    ctObj.h = CT_Double.Parse(childNode, namespaceManager);
1929
                else if (childNode.LocalName == "extLst")
1930
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
1931
            }
1932
            return ctObj;
1933
        }
1934

1935

1936

1937
        internal void Write(StreamWriter sw, string nodeName)
1938
        {
1939
            sw.Write(string.Format("<c:{0}", nodeName));
1940
            sw.Write(">");
1941
            if (this.layoutTarget != null)
1942
                this.layoutTarget.Write(sw, "layoutTarget");
1943
            if (this.xMode != null)
1944
                this.xMode.Write(sw, "xMode");
1945
            if (this.yMode != null)
1946
                this.yMode.Write(sw, "yMode");
1947
            if (this.wMode != null)
1948
                this.wMode.Write(sw, "wMode");
1949
            if (this.hMode != null)
1950
                this.hMode.Write(sw, "hMode");
1951
            if (this.x != null)
1952
                this.x.Write(sw, "x");
1953
            if (this.y != null)
1954
                this.y.Write(sw, "y");
1955
            if (this.w != null)
1956
                this.w.Write(sw, "w");
1957
            if (this.h != null)
1958
                this.h.Write(sw, "h");
1959
            if (this.extLst != null)
1960
            {
1961
                foreach (CT_Extension x in this.extLst)
1962
                {
1963
                    x.Write(sw, "extLst");
1964
                }
1965
            }
1966
            sw.Write(string.Format("</c:{0}>", nodeName));
1967
        }
1968

1969
        public CT_ManualLayout()
1970
        {
1971
            //this.extLstField = new List<CT_Extension>();
1972
            //this.hField = new CT_Double();
1973
            //this.wField = new CT_Double();
1974
            //this.yField = new CT_Double();
1975
            //this.xField = new CT_Double();
1976
            //this.hModeField = new CT_LayoutMode();
1977
            //this.wModeField = new CT_LayoutMode();
1978
            //this.yModeField = new CT_LayoutMode();
1979
            //this.xModeField = new CT_LayoutMode();
1980
            //this.layoutTargetField = new CT_LayoutTarget();
1981
        }
1982
        public bool IsSetLayoutTarget()
1983
        {
1984
            return this.layoutTargetField != null;
1985
        }
1986
        public CT_LayoutTarget AddNewLayoutTarget()
1987
        {
1988
            this.layoutTargetField = new CT_LayoutTarget();
1989
            return this.layoutTargetField;
1990
        }
1991
        public bool IsSetY()
1992
        {
1993
            return this.yField != null;
1994
        }
1995
        public bool IsSetX()
1996
        {
1997
            return this.xField != null;
1998
        }
1999

2000
        public bool IsSetW()
2001
        {
2002
            return this.wField != null;
2003
        }
2004
        public bool IsSetH()
2005
        {
2006
            return this.hField != null;
2007
        }
2008
        public bool IsSetXMode()
2009
        {
2010
            return this.xModeField != null;
2011
        }
2012
        public CT_LayoutMode AddNewXMode()
2013
        {
2014
            this.xModeField = new CT_LayoutMode();
2015
            return xModeField;
2016
        }
2017
        public bool IsSetYMode()
2018
        {
2019
            return this.yModeField != null;
2020
        }
2021
        public CT_LayoutMode AddNewYMode()
2022
        {
2023
            this.yModeField = new CT_LayoutMode();
2024
            return yModeField;
2025
        }
2026
        public bool IsSetWMode()
2027
        {
2028
            return this.wModeField != null;
2029
        }
2030
        public bool IsSetHMode()
2031
        {
2032
            return this.hModeField != null;
2033
        }
2034

2035
        public CT_LayoutMode AddNewHMode()
2036
        {
2037
            if(this.hModeField == null)
2038
                this.hModeField = new CT_LayoutMode();
2039
            return hModeField;
2040
        }
2041
        public CT_LayoutMode AddNewWMode()
2042
        {
2043
            if (this.wModeField == null)
2044
                this.wModeField = new CT_LayoutMode();
2045
            return wModeField;
2046
        }
2047
        public CT_Double AddNewW()
2048
        {
2049
            if (this.wField == null)
2050
                this.wField = new CT_Double();
2051
            return wField;
2052
        }
2053
        public CT_Double AddNewH()
2054
        {
2055
            if (this.hField == null)
2056
                this.hField = new CT_Double();
2057
            return hField;
2058
        }
2059
        public CT_Double AddNewY()
2060
        {
2061
            if (this.yField == null)
2062
                this.yField = new CT_Double();
2063
            return yField;
2064
        }
2065
        public CT_Double AddNewX()
2066
        {
2067
            if (this.xField == null)
2068
                this.xField = new CT_Double();
2069
            return xField;
2070
        }
2071
        [XmlElement(Order = 0)]
2072
        public CT_LayoutTarget layoutTarget
2073
        {
2074
            get
2075
            {
2076
                return this.layoutTargetField;
2077
            }
2078
            set
2079
            {
2080
                this.layoutTargetField = value;
2081
            }
2082
        }
2083

2084
        [XmlElement(Order = 1)]
2085
        public CT_LayoutMode xMode
2086
        {
2087
            get
2088
            {
2089
                return this.xModeField;
2090
            }
2091
            set
2092
            {
2093
                this.xModeField = value;
2094
            }
2095
        }
2096

2097
        [XmlElement(Order = 2)]
2098
        public CT_LayoutMode yMode
2099
        {
2100
            get
2101
            {
2102
                return this.yModeField;
2103
            }
2104
            set
2105
            {
2106
                this.yModeField = value;
2107
            }
2108
        }
2109

2110
        [XmlElement(Order = 3)]
2111
        public CT_LayoutMode wMode
2112
        {
2113
            get
2114
            {
2115
                return this.wModeField;
2116
            }
2117
            set
2118
            {
2119
                this.wModeField = value;
2120
            }
2121
        }
2122

2123
        [XmlElement(Order = 4)]
2124
        public CT_LayoutMode hMode
2125
        {
2126
            get
2127
            {
2128
                return this.hModeField;
2129
            }
2130
            set
2131
            {
2132
                this.hModeField = value;
2133
            }
2134
        }
2135

2136
        [XmlElement(Order = 5)]
2137
        public CT_Double x
2138
        {
2139
            get
2140
            {
2141
                return this.xField;
2142
            }
2143
            set
2144
            {
2145
                this.xField = value;
2146
            }
2147
        }
2148

2149
        [XmlElement(Order = 6)]
2150
        public CT_Double y
2151
        {
2152
            get
2153
            {
2154
                return this.yField;
2155
            }
2156
            set
2157
            {
2158
                this.yField = value;
2159
            }
2160
        }
2161

2162
        [XmlElement(Order = 7)]
2163
        public CT_Double w
2164
        {
2165
            get
2166
            {
2167
                return this.wField;
2168
            }
2169
            set
2170
            {
2171
                this.wField = value;
2172
            }
2173
        }
2174

2175
        [XmlElement(Order = 8)]
2176
        public CT_Double h
2177
        {
2178
            get
2179
            {
2180
                return this.hField;
2181
            }
2182
            set
2183
            {
2184
                this.hField = value;
2185
            }
2186
        }
2187

2188
        [XmlElement(Order = 9)]
2189
        public List<CT_Extension> extLst
2190
        {
2191
            get
2192
            {
2193
                return this.extLstField;
2194
            }
2195
            set
2196
            {
2197
                this.extLstField = value;
2198
            }
2199
        }
2200
    }
2201

2202

2203
    [Serializable]
2204

2205
    [System.ComponentModel.DesignerCategoryAttribute("code")]
2206
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
2207
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
2208
    public class CT_LayoutTarget
2209
    {
2210

2211
        private ST_LayoutTarget valField;
2212

2213
        public CT_LayoutTarget()
2214
        {
2215
            this.valField = ST_LayoutTarget.outer;
2216
        }
2217
        public static CT_LayoutTarget Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2218
        {
2219
            if (node == null)
2220
                return null;
2221
            CT_LayoutTarget ctObj = new CT_LayoutTarget();
2222
            if (node.Attributes["val"] != null)
2223
                ctObj.val = (ST_LayoutTarget)Enum.Parse(typeof(ST_LayoutTarget), node.Attributes["val"].Value);
2224
            return ctObj;
2225
        }
2226

2227

2228

2229
        internal void Write(StreamWriter sw, string nodeName)
2230
        {
2231
            sw.Write(string.Format("<c:{0}", nodeName));
2232
            if(this.val!= ST_LayoutTarget.outer)
2233
                XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
2234
            sw.Write("/>");
2235
        }
2236

2237
        [XmlAttribute]
2238
        [DefaultValue(ST_LayoutTarget.outer)]
2239
        public ST_LayoutTarget val
2240
        {
2241
            get
2242
            {
2243
                return this.valField;
2244
            }
2245
            set
2246
            {
2247
                this.valField = value;
2248
            }
2249
        }
2250
    }
2251

2252

2253
    [Serializable]
2254
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
2255
    public enum ST_LayoutTarget
2256
    {
2257

2258
        /// <remarks/>
2259
        inner,
2260

2261
        /// <remarks/>
2262
        outer,
2263
    }
2264

2265

2266
    [Serializable]
2267

2268
    [System.ComponentModel.DesignerCategoryAttribute("code")]
2269
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
2270
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
2271
    public class CT_LayoutMode
2272
    {
2273

2274
        private ST_LayoutMode valField;
2275

2276
        public CT_LayoutMode()
2277
        {
2278
            this.valField = ST_LayoutMode.factor;
2279
        }
2280

2281
        [XmlAttribute]
2282
        [DefaultValue(ST_LayoutMode.factor)]
2283
        public ST_LayoutMode val
2284
        {
2285
            get
2286
            {
2287
                return this.valField;
2288
            }
2289
            set
2290
            {
2291
                this.valField = value;
2292
            }
2293
        }
2294
        public static CT_LayoutMode Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2295
        {
2296
            if (node == null)
2297
                return null;
2298
            CT_LayoutMode ctObj = new CT_LayoutMode();
2299
            if (node.Attributes["val"] != null)
2300
                ctObj.val = (ST_LayoutMode)Enum.Parse(typeof(ST_LayoutMode), node.Attributes["val"].Value);
2301
            return ctObj;
2302
        }
2303

2304

2305

2306
        internal void Write(StreamWriter sw, string nodeName)
2307
        {
2308
            sw.Write(string.Format("<c:{0}", nodeName));
2309
            if(this.val!= ST_LayoutMode.factor)
2310
                XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
2311
            sw.Write("/>");
2312
        }
2313

2314
    }
2315

2316

2317
    [Serializable]
2318
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
2319
    public enum ST_LayoutMode
2320
    {
2321

2322
        /// <remarks/>
2323
        edge,
2324

2325
        /// <remarks/>
2326
        factor,
2327
    }
2328

2329

2330
    [Serializable]
2331

2332
    [System.ComponentModel.DesignerCategoryAttribute("code")]
2333
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
2334
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
2335
    public class CT_Double
2336
    {
2337

2338
        private double valField;
2339
        public static CT_Double Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2340
        {
2341
            if (node == null)
2342
                return null;
2343
            CT_Double ctObj = new CT_Double();
2344
            ctObj.val = XmlHelper.ReadDouble(node.Attributes["val"]);
2345
            return ctObj;
2346
        }
2347

2348

2349

2350
        internal void Write(StreamWriter sw, string nodeName)
2351
        {
2352
            sw.Write(string.Format("<c:{0}", nodeName));
2353
            XmlHelper.WriteAttribute(sw, "val", this.val);
2354
            sw.Write("/>");
2355
        }
2356

2357
        [XmlAttribute]
2358
        public double val
2359
        {
2360
            get
2361
            {
2362
                return this.valField;
2363
            }
2364
            set
2365
            {
2366
                this.valField = value;
2367
            }
2368
        }
2369
    }
2370

2371

2372
    [Serializable]
2373

2374
    [System.ComponentModel.DesignerCategoryAttribute("code")]
2375
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
2376
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
2377
    public class CT_DTable
2378
    {
2379

2380
        private CT_Boolean showHorzBorderField;
2381

2382
        private CT_Boolean showVertBorderField;
2383

2384
        private CT_Boolean showOutlineField;
2385

2386
        private CT_Boolean showKeysField;
2387

2388
        private CT_ShapeProperties spPrField;
2389

2390
        private CT_TextBody txPrField;
2391

2392
        private List<CT_Extension> extLstField;
2393

2394
        public CT_DTable()
2395
        {
2396
        }
2397
        public static CT_DTable Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2398
        {
2399
            if (node == null)
2400
                return null;
2401
            CT_DTable ctObj = new CT_DTable();
2402
            ctObj.extLst = new List<CT_Extension>();
2403
            foreach (XmlNode childNode in node.ChildNodes)
2404
            {
2405
                if (childNode.LocalName == "showHorzBorder")
2406
                    ctObj.showHorzBorder = CT_Boolean.Parse(childNode, namespaceManager);
2407
                else if (childNode.LocalName == "showVertBorder")
2408
                    ctObj.showVertBorder = CT_Boolean.Parse(childNode, namespaceManager);
2409
                else if (childNode.LocalName == "showOutline")
2410
                    ctObj.showOutline = CT_Boolean.Parse(childNode, namespaceManager);
2411
                else if (childNode.LocalName == "showKeys")
2412
                    ctObj.showKeys = CT_Boolean.Parse(childNode, namespaceManager);
2413
                else if (childNode.LocalName == "spPr")
2414
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
2415
                else if (childNode.LocalName == "txPr")
2416
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
2417
                else if (childNode.LocalName == "extLst")
2418
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
2419
            }
2420
            return ctObj;
2421
        }
2422

2423

2424

2425
        internal void Write(StreamWriter sw, string nodeName)
2426
        {
2427
            sw.Write(string.Format("<c:{0}", nodeName));
2428
            sw.Write(">");
2429
            if (this.showHorzBorder != null)
2430
                this.showHorzBorder.Write(sw, "showHorzBorder");
2431
            if (this.showVertBorder != null)
2432
                this.showVertBorder.Write(sw, "showVertBorder");
2433
            if (this.showOutline != null)
2434
                this.showOutline.Write(sw, "showOutline");
2435
            if (this.showKeys != null)
2436
                this.showKeys.Write(sw, "showKeys");
2437
            if (this.spPr != null)
2438
                this.spPr.Write(sw, "spPr");
2439
            if (this.txPr != null)
2440
                this.txPr.Write(sw, "txPr");
2441
            if (this.extLst != null)
2442
            {
2443
                foreach (CT_Extension x in this.extLst)
2444
                {
2445
                    x.Write(sw, "extLst");
2446
                }
2447
            }
2448
            sw.Write(string.Format("</c:{0}>", nodeName));
2449
        }
2450

2451

2452
        [XmlElement(Order = 0)]
2453
        public CT_Boolean showHorzBorder
2454
        {
2455
            get
2456
            {
2457
                return this.showHorzBorderField;
2458
            }
2459
            set
2460
            {
2461
                this.showHorzBorderField = value;
2462
            }
2463
        }
2464

2465
        [XmlElement(Order = 1)]
2466
        public CT_Boolean showVertBorder
2467
        {
2468
            get
2469
            {
2470
                return this.showVertBorderField;
2471
            }
2472
            set
2473
            {
2474
                this.showVertBorderField = value;
2475
            }
2476
        }
2477

2478
        [XmlElement(Order = 2)]
2479
        public CT_Boolean showOutline
2480
        {
2481
            get
2482
            {
2483
                return this.showOutlineField;
2484
            }
2485
            set
2486
            {
2487
                this.showOutlineField = value;
2488
            }
2489
        }
2490

2491
        [XmlElement(Order = 3)]
2492
        public CT_Boolean showKeys
2493
        {
2494
            get
2495
            {
2496
                return this.showKeysField;
2497
            }
2498
            set
2499
            {
2500
                this.showKeysField = value;
2501
            }
2502
        }
2503

2504
        [XmlElement(Order = 4)]
2505
        public CT_ShapeProperties spPr
2506
        {
2507
            get
2508
            {
2509
                return this.spPrField;
2510
            }
2511
            set
2512
            {
2513
                this.spPrField = value;
2514
            }
2515
        }
2516

2517
        [XmlElement(Order = 5)]
2518
        public CT_TextBody txPr
2519
        {
2520
            get
2521
            {
2522
                return this.txPrField;
2523
            }
2524
            set
2525
            {
2526
                this.txPrField = value;
2527
            }
2528
        }
2529

2530
        [XmlElement(Order = 6)]
2531
        public List<CT_Extension> extLst
2532
        {
2533
            get
2534
            {
2535
                return this.extLstField;
2536
            }
2537
            set
2538
            {
2539
                this.extLstField = value;
2540
            }
2541
        }
2542
    }
2543

2544

2545
    [Serializable]
2546

2547
    [System.ComponentModel.DesignerCategoryAttribute("code")]
2548
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
2549
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
2550
    public class CT_SerAx
2551
    {
2552

2553
        private CT_UnsignedInt axIdField;
2554

2555
        private CT_Scaling scalingField;
2556

2557
        private CT_Boolean deleteField;
2558

2559
        private CT_AxPos axPosField;
2560

2561
        private CT_ChartLines majorGridlinesField;
2562

2563
        private CT_ChartLines minorGridlinesField;
2564

2565
        private CT_Title titleField;
2566

2567
        private CT_NumFmt numFmtField;
2568

2569
        private CT_TickMark majorTickMarkField;
2570

2571
        private CT_TickMark minorTickMarkField;
2572

2573
        private CT_TickLblPos tickLblPosField;
2574

2575
        private CT_ShapeProperties spPrField;
2576

2577
        private CT_TextBody txPrField;
2578

2579
        private CT_UnsignedInt crossAxField;
2580

2581

2582
        private CT_Skip tickLblSkipField;
2583

2584
        private CT_Skip tickMarkSkipField;
2585

2586
        private List<CT_Extension> extLstField;
2587

2588
        public CT_SerAx()
2589
        {
2590
        }
2591

2592
        public static CT_SerAx Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2593
        {
2594
            if (node == null)
2595
                return null;
2596
            CT_SerAx ctObj = new CT_SerAx();
2597
            ctObj.extLst = new List<CT_Extension>();
2598
            foreach (XmlNode childNode in node.ChildNodes)
2599
            {
2600
                if (childNode.LocalName == "axId")
2601
                    ctObj.axId = CT_UnsignedInt.Parse(childNode, namespaceManager);
2602
                else if (childNode.LocalName == "scaling")
2603
                    ctObj.scaling = CT_Scaling.Parse(childNode, namespaceManager);
2604
                else if (childNode.LocalName == "delete")
2605
                    ctObj.delete = CT_Boolean.Parse(childNode, namespaceManager);
2606
                else if (childNode.LocalName == "axPos")
2607
                    ctObj.axPos = CT_AxPos.Parse(childNode, namespaceManager);
2608
                else if (childNode.LocalName == "majorGridlines")
2609
                    ctObj.majorGridlines = CT_ChartLines.Parse(childNode, namespaceManager);
2610
                else if (childNode.LocalName == "minorGridlines")
2611
                    ctObj.minorGridlines = CT_ChartLines.Parse(childNode, namespaceManager);
2612
                else if (childNode.LocalName == "title")
2613
                    ctObj.title = CT_Title.Parse(childNode, namespaceManager);
2614
                else if (childNode.LocalName == "numFmt")
2615
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
2616
                else if (childNode.LocalName == "majorTickMark")
2617
                    ctObj.majorTickMark = CT_TickMark.Parse(childNode, namespaceManager);
2618
                else if (childNode.LocalName == "minorTickMark")
2619
                    ctObj.minorTickMark = CT_TickMark.Parse(childNode, namespaceManager);
2620
                else if (childNode.LocalName == "tickLblPos")
2621
                    ctObj.tickLblPos = CT_TickLblPos.Parse(childNode, namespaceManager);
2622
                else if (childNode.LocalName == "spPr")
2623
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
2624
                else if (childNode.LocalName == "txPr")
2625
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
2626
                else if (childNode.LocalName == "crossAx")
2627
                    ctObj.crossAx = CT_UnsignedInt.Parse(childNode, namespaceManager);
2628
                else if (childNode.LocalName == "crosses")
2629
                    ctObj.crosses = CT_Crosses.Parse(childNode, namespaceManager);
2630
                else if (childNode.LocalName == "crossesAt")
2631
                    ctObj.crossesAt = CT_Double.Parse(childNode, namespaceManager);
2632
                else if (childNode.LocalName == "tickLblSkip")
2633
                    ctObj.tickLblSkip = CT_Skip.Parse(childNode, namespaceManager);
2634
                else if (childNode.LocalName == "tickMarkSkip")
2635
                    ctObj.tickMarkSkip = CT_Skip.Parse(childNode, namespaceManager);
2636
                else if (childNode.LocalName == "extLst")
2637
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
2638
            }
2639
            return ctObj;
2640
        }
2641

2642

2643

2644
        internal void Write(StreamWriter sw, string nodeName)
2645
        {
2646
            sw.Write(string.Format("<c:{0}", nodeName));
2647
            sw.Write(">");
2648
            if (this.axId != null)
2649
                this.axId.Write(sw, "axId");
2650
            if (this.scaling != null)
2651
                this.scaling.Write(sw, "scaling");
2652
            if (this.delete != null)
2653
                this.delete.Write(sw, "delete");
2654
            if (this.axPos != null)
2655
                this.axPos.Write(sw, "axPos");
2656
            if (this.majorGridlines != null)
2657
                this.majorGridlines.Write(sw, "majorGridlines");
2658
            if (this.minorGridlines != null)
2659
                this.minorGridlines.Write(sw, "minorGridlines");
2660
            if (this.title != null)
2661
                this.title.Write(sw, "title");
2662
            if (this.numFmt != null)
2663
                this.numFmt.Write(sw, "numFmt");
2664
            if (this.majorTickMark != null)
2665
                this.majorTickMark.Write(sw, "majorTickMark");
2666
            if (this.minorTickMark != null)
2667
                this.minorTickMark.Write(sw, "minorTickMark");
2668
            if (this.tickLblPos != null)
2669
                this.tickLblPos.Write(sw, "tickLblPos");
2670
            if (this.spPr != null)
2671
                this.spPr.Write(sw, "spPr");
2672
            if (this.txPr != null)
2673
                this.txPr.Write(sw, "txPr");
2674
            if (this.crossAx != null)
2675
                this.crossAx.Write(sw, "crossAx");
2676
            if (this.crosses != null)
2677
                this.crosses.Write(sw, "crosses");
2678
            if (this.crossesAt != null)
2679
                this.crossesAt.Write(sw, "crossesAt");
2680
            if (this.tickLblSkip != null)
2681
                this.tickLblSkip.Write(sw, "tickLblSkip");
2682
            if (this.tickMarkSkip != null)
2683
                this.tickMarkSkip.Write(sw, "tickMarkSkip");
2684
            if (this.extLst != null)
2685
            {
2686
                foreach (CT_Extension x in this.extLst)
2687
                {
2688
                    x.Write(sw, "extLst");
2689
                }
2690
            }
2691
            sw.Write(string.Format("</c:{0}>", nodeName));
2692
        }
2693

2694
        [XmlElement(Order = 0)]
2695
        public CT_UnsignedInt axId
2696
        {
2697
            get
2698
            {
2699
                return this.axIdField;
2700
            }
2701
            set
2702
            {
2703
                this.axIdField = value;
2704
            }
2705
        }
2706

2707
        [XmlElement(Order = 1)]
2708
        public CT_Scaling scaling
2709
        {
2710
            get
2711
            {
2712
                return this.scalingField;
2713
            }
2714
            set
2715
            {
2716
                this.scalingField = value;
2717
            }
2718
        }
2719

2720
        [XmlElement(Order = 2)]
2721
        public CT_Boolean delete
2722
        {
2723
            get
2724
            {
2725
                return this.deleteField;
2726
            }
2727
            set
2728
            {
2729
                this.deleteField = value;
2730
            }
2731
        }
2732

2733
        [XmlElement(Order = 3)]
2734
        public CT_AxPos axPos
2735
        {
2736
            get
2737
            {
2738
                return this.axPosField;
2739
            }
2740
            set
2741
            {
2742
                this.axPosField = value;
2743
            }
2744
        }
2745

2746
        [XmlElement(Order = 4)]
2747
        public CT_ChartLines majorGridlines
2748
        {
2749
            get
2750
            {
2751
                return this.majorGridlinesField;
2752
            }
2753
            set
2754
            {
2755
                this.majorGridlinesField = value;
2756
            }
2757
        }
2758

2759
        [XmlElement(Order = 5)]
2760
        public CT_ChartLines minorGridlines
2761
        {
2762
            get
2763
            {
2764
                return this.minorGridlinesField;
2765
            }
2766
            set
2767
            {
2768
                this.minorGridlinesField = value;
2769
            }
2770
        }
2771

2772
        [XmlElement(Order = 6)]
2773
        public CT_Title title
2774
        {
2775
            get
2776
            {
2777
                return this.titleField;
2778
            }
2779
            set
2780
            {
2781
                this.titleField = value;
2782
            }
2783
        }
2784

2785
        [XmlElement(Order = 7)]
2786
        public CT_NumFmt numFmt
2787
        {
2788
            get
2789
            {
2790
                return this.numFmtField;
2791
            }
2792
            set
2793
            {
2794
                this.numFmtField = value;
2795
            }
2796
        }
2797

2798
        [XmlElement(Order = 8)]
2799
        public CT_TickMark majorTickMark
2800
        {
2801
            get
2802
            {
2803
                return this.majorTickMarkField;
2804
            }
2805
            set
2806
            {
2807
                this.majorTickMarkField = value;
2808
            }
2809
        }
2810

2811
        [XmlElement(Order = 9)]
2812
        public CT_TickMark minorTickMark
2813
        {
2814
            get
2815
            {
2816
                return this.minorTickMarkField;
2817
            }
2818
            set
2819
            {
2820
                this.minorTickMarkField = value;
2821
            }
2822
        }
2823

2824
        [XmlElement(Order = 10)]
2825
        public CT_TickLblPos tickLblPos
2826
        {
2827
            get
2828
            {
2829
                return this.tickLblPosField;
2830
            }
2831
            set
2832
            {
2833
                this.tickLblPosField = value;
2834
            }
2835
        }
2836

2837
        [XmlElement(Order = 11)]
2838
        public CT_ShapeProperties spPr
2839
        {
2840
            get
2841
            {
2842
                return this.spPrField;
2843
            }
2844
            set
2845
            {
2846
                this.spPrField = value;
2847
            }
2848
        }
2849

2850
        [XmlElement(Order = 12)]
2851
        public CT_TextBody txPr
2852
        {
2853
            get
2854
            {
2855
                return this.txPrField;
2856
            }
2857
            set
2858
            {
2859
                this.txPrField = value;
2860
            }
2861
        }
2862

2863
        [XmlElement(Order = 13)]
2864
        public CT_UnsignedInt crossAx
2865
        {
2866
            get
2867
            {
2868
                return this.crossAxField;
2869
            }
2870
            set
2871
            {
2872
                this.crossAxField = value;
2873
            }
2874
        }
2875
        CT_Crosses crossesField;
2876
        [XmlElement(Order = 14)]
2877
        public CT_Crosses crosses
2878
        {
2879
            get
2880
            {
2881
                return this.crossesField;
2882
            }
2883
            set
2884
            {
2885
                this.crossesField = value;
2886
            }
2887
        }
2888
        CT_Double crossesAtField;
2889
        [XmlElement(Order = 15)]
2890
        public CT_Double crossesAt
2891
        {
2892
            get
2893
            {
2894
                return this.crossesAtField;
2895
            }
2896
            set
2897
            {
2898
                this.crossesAtField = value;
2899
            }
2900
        }
2901

2902
        [XmlElement(Order = 16)]
2903
        public CT_Skip tickLblSkip
2904
        {
2905
            get
2906
            {
2907
                return this.tickLblSkipField;
2908
            }
2909
            set
2910
            {
2911
                this.tickLblSkipField = value;
2912
            }
2913
        }
2914

2915
        [XmlElement(Order = 17)]
2916
        public CT_Skip tickMarkSkip
2917
        {
2918
            get
2919
            {
2920
                return this.tickMarkSkipField;
2921
            }
2922
            set
2923
            {
2924
                this.tickMarkSkipField = value;
2925
            }
2926
        }
2927

2928
        [XmlElement(Order = 18)]
2929
        public List<CT_Extension> extLst
2930
        {
2931
            get
2932
            {
2933
                return this.extLstField;
2934
            }
2935
            set
2936
            {
2937
                this.extLstField = value;
2938
            }
2939
        }
2940
    }
2941

2942

2943
    [Serializable]
2944

2945
    [System.ComponentModel.DesignerCategoryAttribute("code")]
2946
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
2947
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
2948
    public class CT_Scaling
2949
    {
2950

2951
        private CT_LogBase logBaseField;
2952

2953
        private CT_Orientation orientationField;
2954

2955
        private CT_Double maxField;
2956

2957
        private CT_Double minField;
2958

2959
        private List<CT_Extension> extLstField;
2960

2961
        public CT_Scaling()
2962
        {
2963
        }
2964
        public static CT_Scaling Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2965
        {
2966
            if (node == null)
2967
                return null;
2968
            CT_Scaling ctObj = new CT_Scaling();
2969
            ctObj.extLst = new List<CT_Extension>();
2970
            foreach (XmlNode childNode in node.ChildNodes)
2971
            {
2972
                if (childNode.LocalName == "logBase")
2973
                    ctObj.logBase = CT_LogBase.Parse(childNode, namespaceManager);
2974
                else if (childNode.LocalName == "orientation")
2975
                    ctObj.orientation = CT_Orientation.Parse(childNode, namespaceManager);
2976
                else if (childNode.LocalName == "max")
2977
                    ctObj.max = CT_Double.Parse(childNode, namespaceManager);
2978
                else if (childNode.LocalName == "min")
2979
                    ctObj.min = CT_Double.Parse(childNode, namespaceManager);
2980
                else if (childNode.LocalName == "extLst")
2981
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
2982
            }
2983
            return ctObj;
2984
        }
2985

2986

2987

2988
        internal void Write(StreamWriter sw, string nodeName)
2989
        {
2990
            sw.Write(string.Format("<c:{0}>", nodeName));
2991
            if (this.logBase != null)
2992
                this.logBase.Write(sw, "logBase");
2993
            if (this.orientation != null)
2994
                this.orientation.Write(sw, "orientation");
2995
            if (this.max != null)
2996
                this.max.Write(sw, "max");
2997
            if (this.min != null)
2998
                this.min.Write(sw, "min");
2999
            if (this.extLst != null)
3000
            {
3001
                foreach (CT_Extension x in this.extLst)
3002
                {
3003
                    x.Write(sw, "extLst");
3004
                }
3005
            }
3006
            sw.Write(string.Format("</c:{0}>", nodeName));
3007
        }
3008

3009
        public bool IsSetOrientation()
3010
        {
3011
            return this.orientationField != null;
3012
        }
3013
        public CT_Orientation AddNewOrientation()
3014
        {
3015
            this.orientationField = new CT_Orientation();
3016
            return this.orientationField;
3017
        }
3018
        public bool IsSetLogBase()
3019
        {
3020
            return logBaseField != null;
3021
        }
3022
        public CT_LogBase AddNewLogBase()
3023
        {
3024
            this.logBaseField = new CT_LogBase();
3025
            return this.logBaseField;
3026
        }
3027
        public bool IsSetMax()
3028
        {
3029
            return maxField != null;
3030
        }
3031
        public CT_Double AddNewMax()
3032
        {
3033
            this.maxField = new CT_Double();
3034
            return this.maxField;
3035
        }
3036
        public bool IsSetMin()
3037
        {
3038
            return minField != null;
3039
        }
3040
        public CT_Double AddNewMin()
3041
        {
3042
            this.minField = new CT_Double();
3043
            return this.minField;
3044
        }
3045
        [XmlElement(Order = 0)]
3046
        public CT_LogBase logBase
3047
        {
3048
            get
3049
            {
3050
                return this.logBaseField;
3051
            }
3052
            set
3053
            {
3054
                this.logBaseField = value;
3055
            }
3056
        }
3057

3058
        [XmlElement(Order = 1)]
3059
        public CT_Orientation orientation
3060
        {
3061
            get
3062
            {
3063
                return this.orientationField;
3064
            }
3065
            set
3066
            {
3067
                this.orientationField = value;
3068
            }
3069
        }
3070

3071
        [XmlElement(Order = 2)]
3072
        public CT_Double max
3073
        {
3074
            get
3075
            {
3076
                return this.maxField;
3077
            }
3078
            set
3079
            {
3080
                this.maxField = value;
3081
            }
3082
        }
3083

3084
        [XmlElement(Order = 3)]
3085
        public CT_Double min
3086
        {
3087
            get
3088
            {
3089
                return this.minField;
3090
            }
3091
            set
3092
            {
3093
                this.minField = value;
3094
            }
3095
        }
3096

3097
        [XmlElement(Order = 4)]
3098
        public List<CT_Extension> extLst
3099
        {
3100
            get
3101
            {
3102
                return this.extLstField;
3103
            }
3104
            set
3105
            {
3106
                this.extLstField = value;
3107
            }
3108
        }
3109
    }
3110

3111

3112
    [Serializable]
3113

3114
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3115
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3116
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3117
    public class CT_LogBase
3118
    {
3119
        public static CT_LogBase Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3120
        {
3121
            if (node == null)
3122
                return null;
3123
            CT_LogBase ctObj = new CT_LogBase();
3124
            if (node.Attributes["val"] != null)
3125
                ctObj.val = XmlHelper.ReadDouble(node.Attributes["val"]);
3126
            return ctObj;
3127
        }
3128

3129

3130

3131
        internal void Write(StreamWriter sw, string nodeName)
3132
        {
3133
            sw.Write(string.Format("<c:{0}", nodeName));
3134
            XmlHelper.WriteAttribute(sw, "val", this.val);
3135
            sw.Write("/>");
3136
        }
3137

3138
        private double valField;
3139

3140
        [XmlAttribute]
3141
        public double val
3142
        {
3143
            get
3144
            {
3145
                return this.valField;
3146
            }
3147
            set
3148
            {
3149
                this.valField = value;
3150
            }
3151
        }
3152
    }
3153

3154

3155
    [Serializable]
3156

3157
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3158
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3159
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3160
    public class CT_Orientation
3161
    {
3162

3163
        private ST_Orientation valField;
3164

3165
        public CT_Orientation()
3166
        {
3167
            this.valField = ST_Orientation.minMax;
3168
        }
3169
        public static CT_Orientation Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3170
        {
3171
            if (node == null)
3172
                return null;
3173
            CT_Orientation ctObj = new CT_Orientation();
3174
            if (node.Attributes["val"] != null)
3175
                ctObj.val = (ST_Orientation)Enum.Parse(typeof(ST_Orientation), node.Attributes["val"].Value);
3176
            return ctObj;
3177
        }
3178

3179

3180

3181
        internal void Write(StreamWriter sw, string nodeName)
3182
        {
3183
            sw.Write(string.Format("<c:{0}", nodeName));
3184
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
3185
            sw.Write("/>");
3186
        }
3187

3188
        [XmlAttribute]
3189
        public ST_Orientation val
3190
        {
3191
            get
3192
            {
3193
                return this.valField;
3194
            }
3195
            set
3196
            {
3197
                this.valField = value;
3198
            }
3199
        }
3200
    }
3201

3202

3203
    [Serializable]
3204
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3205
    public enum ST_Orientation
3206
    {
3207

3208
        /// <remarks/>
3209
        maxMin,
3210

3211
        /// <remarks/>
3212
        minMax,
3213
    }
3214

3215

3216
    [Serializable]
3217

3218
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3219
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3220
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3221
    public class CT_AxPos
3222
    {
3223

3224
        private ST_AxPos valField;
3225
        public static CT_AxPos Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3226
        {
3227
            if (node == null)
3228
                return null;
3229
            CT_AxPos ctObj = new CT_AxPos();
3230
            if (node.Attributes["val"] != null)
3231
                ctObj.val = (ST_AxPos)Enum.Parse(typeof(ST_AxPos), node.Attributes["val"].Value);
3232
            return ctObj;
3233
        }
3234

3235

3236

3237
        internal void Write(StreamWriter sw, string nodeName)
3238
        {
3239
            sw.Write(string.Format("<c:{0}", nodeName));
3240
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
3241
            sw.Write("/>");
3242
        }
3243

3244
        [XmlAttribute]
3245
        public ST_AxPos val
3246
        {
3247
            get
3248
            {
3249
                return this.valField;
3250
            }
3251
            set
3252
            {
3253
                this.valField = value;
3254
            }
3255
        }
3256
    }
3257

3258

3259
    [Serializable]
3260
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3261
    public enum ST_AxPos
3262
    {
3263

3264
        /// <remarks/>
3265
        b,
3266

3267
        /// <remarks/>
3268
        l,
3269

3270
        /// <remarks/>
3271
        r,
3272

3273
        /// <remarks/>
3274
        t,
3275
    }
3276

3277

3278
    [Serializable]
3279

3280
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3281
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3282
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3283
    public class CT_ChartLines
3284
    {
3285
        public static CT_ChartLines Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3286
        {
3287
            if (node == null)
3288
                return null;
3289
            CT_ChartLines ctObj = new CT_ChartLines();
3290
            foreach (XmlNode childNode in node.ChildNodes)
3291
            {
3292
                if (childNode.LocalName == "spPr")
3293
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
3294
            }
3295
            return ctObj;
3296
        }
3297

3298

3299

3300
        internal void Write(StreamWriter sw, string nodeName)
3301
        {
3302
            sw.Write(string.Format("<c:{0}", nodeName));
3303
            sw.Write(">");
3304
            if (this.spPr != null)
3305
                this.spPr.Write(sw, "spPr");
3306
            sw.Write(string.Format("</c:{0}>", nodeName));
3307
        }
3308

3309
        private CT_ShapeProperties spPrField;
3310

3311
        [XmlElement(Order = 0)]
3312
        public CT_ShapeProperties spPr
3313
        {
3314
            get
3315
            {
3316
                return this.spPrField;
3317
            }
3318
            set
3319
            {
3320
                this.spPrField = value;
3321
            }
3322
        }
3323
    }
3324

3325

3326
    [Serializable]
3327

3328
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3329
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3330
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3331
    public class CT_Title
3332
    {
3333

3334
        private CT_Tx txField;
3335

3336
        private CT_Layout layoutField;
3337

3338
        private CT_Boolean overlayField;
3339

3340
        private CT_ShapeProperties spPrField;
3341

3342
        private CT_TextBody txPrField;
3343

3344
        private List<CT_Extension> extLstField;
3345

3346
        public CT_Title()
3347
        {
3348
            //this.extLstField = new List<CT_Extension>();
3349
            //this.overlayField = new CT_Boolean();
3350
            //this.layoutField = new CT_Layout();
3351
            //this.txField = new CT_Tx();
3352
        }
3353
        public static CT_Title Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3354
        {
3355
            if (node == null)
3356
                return null;
3357
            CT_Title ctObj = new CT_Title();
3358
            ctObj.extLst = new List<CT_Extension>();
3359
            foreach (XmlNode childNode in node.ChildNodes)
3360
            {
3361
                if (childNode.LocalName == "tx")
3362
                    ctObj.tx = CT_Tx.Parse(childNode, namespaceManager);
3363
                else if (childNode.LocalName == "layout")
3364
                    ctObj.layout = CT_Layout.Parse(childNode, namespaceManager);
3365
                else if (childNode.LocalName == "overlay")
3366
                    ctObj.overlay = CT_Boolean.Parse(childNode, namespaceManager);
3367
                else if (childNode.LocalName == "spPr")
3368
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
3369
                else if (childNode.LocalName == "txPr")
3370
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
3371
                else if (childNode.LocalName == "extLst")
3372
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
3373
            }
3374
            return ctObj;
3375
        }
3376

3377

3378

3379
        internal void Write(StreamWriter sw, string nodeName)
3380
        {
3381
            sw.Write(string.Format("<c:{0}", nodeName));
3382
            sw.Write(">");
3383
            if (this.tx != null)
3384
                this.tx.Write(sw, "tx");
3385
            if (this.layout != null)
3386
                this.layout.Write(sw, "layout");
3387
            if (this.overlay != null)
3388
                this.overlay.Write(sw, "overlay");
3389
            if (this.spPr != null)
3390
                this.spPr.Write(sw, "spPr");
3391
            if (this.txPr != null)
3392
                this.txPr.Write(sw, "txPr");
3393
            if (this.extLst != null)
3394
            {
3395
                foreach (CT_Extension x in this.extLst)
3396
                {
3397
                    x.Write(sw, "extLst");
3398
                }
3399
            }
3400
            sw.Write(string.Format("</c:{0}>", nodeName));
3401
        }
3402

3403
        public bool IsSetTx()
3404
        {
3405
            return this.txField != null;
3406
        }
3407

3408
        public CT_Tx AddNewTx()
3409
        {
3410
            this.txField = new CT_Tx();
3411
            return this.txField;
3412
        }
3413

3414
        [XmlElement(Order = 0)]
3415
        public CT_Tx tx
3416
        {
3417
            get
3418
            {
3419
                return this.txField;
3420
            }
3421
            set
3422
            {
3423
                this.txField = value;
3424
            }
3425
        }
3426

3427
        [XmlElement(Order = 1)]
3428
        public CT_Layout layout
3429
        {
3430
            get
3431
            {
3432
                return this.layoutField;
3433
            }
3434
            set
3435
            {
3436
                this.layoutField = value;
3437
            }
3438
        }
3439

3440
        [XmlElement(Order = 2)]
3441
        public CT_Boolean overlay
3442
        {
3443
            get
3444
            {
3445
                return this.overlayField;
3446
            }
3447
            set
3448
            {
3449
                this.overlayField = value;
3450
            }
3451
        }
3452

3453
        [XmlElement(Order = 3)]
3454
        public CT_ShapeProperties spPr
3455
        {
3456
            get
3457
            {
3458
                return this.spPrField;
3459
            }
3460
            set
3461
            {
3462
                this.spPrField = value;
3463
            }
3464
        }
3465

3466
        [XmlElement(Order = 4)]
3467
        public CT_TextBody txPr
3468
        {
3469
            get
3470
            {
3471
                return this.txPrField;
3472
            }
3473
            set
3474
            {
3475
                this.txPrField = value;
3476
            }
3477
        }
3478

3479
        [XmlElement(Order = 5)]
3480
        public List<CT_Extension> extLst
3481
        {
3482
            get
3483
            {
3484
                return this.extLstField;
3485
            }
3486
            set
3487
            {
3488
                this.extLstField = value;
3489
            }
3490
        }
3491
    }
3492

3493

3494
    [Serializable]
3495

3496
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3497
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3498
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3499
    public class CT_Tx
3500
    {
3501
        CT_StrRef strRefField;
3502
        public CT_StrRef strRef
3503
        {
3504
            get { return this.strRefField; }
3505
            set { this.strRefField = value; }
3506
        }
3507

3508
        CT_TextBody richField;
3509
        public CT_TextBody rich
3510
        {
3511
            get { return this.richField; }
3512
            set { this.richField = value; }
3513
        }
3514

3515
        public static CT_Tx Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3516
        {
3517
            if (node == null)
3518
                return null;
3519
            CT_Tx ctObj = new CT_Tx();
3520
            foreach (XmlNode childNode in node.ChildNodes)
3521
            {
3522
                if (childNode.LocalName == "strRef")
3523
                    ctObj.strRef = CT_StrRef.Parse(childNode, namespaceManager);
3524
                else if (childNode.LocalName == "rich")
3525
                    ctObj.rich = CT_TextBody.Parse(childNode, namespaceManager);
3526
            }
3527
            return ctObj;
3528
        }
3529

3530

3531

3532
        internal void Write(StreamWriter sw, string nodeName)
3533
        {
3534
            sw.Write(string.Format("<c:{0}", nodeName));
3535
            sw.Write(">");
3536
            if (this.strRef != null)
3537
                this.strRef.Write(sw, "strRef");
3538
            if (this.rich != null)
3539
                this.rich.Write(sw, "rich");
3540
            sw.Write(string.Format("</c:{0}>", nodeName));
3541
        }
3542

3543
        public bool IsSetStrRef()
3544
        {
3545
            return this.strRefField != null;
3546
        }
3547

3548
        public void UnsetStrRef()
3549
        {
3550
            this.strRefField = null;
3551
        }
3552

3553
        public bool IsSetRich()
3554
        {
3555
            return rich != null;
3556
        }
3557

3558
        public CT_TextBody AddNewRich()
3559
        {
3560
            this.richField = new CT_TextBody();
3561
            return this.richField;
3562
        }
3563
    }
3564

3565

3566
    [Serializable]
3567

3568
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3569
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3570
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3571
    public class CT_StrRef
3572
    {
3573

3574
        private string fField;
3575

3576
        private CT_StrData strCacheField;
3577

3578
        private List<CT_Extension> extLstField;
3579

3580
        public CT_StrRef()
3581
        {
3582

3583
        }
3584
        public static CT_StrRef Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3585
        {
3586
            if (node == null)
3587
                return null;
3588
            CT_StrRef ctObj = new CT_StrRef();
3589
            ctObj.extLst = new List<CT_Extension>();
3590
            foreach (XmlNode childNode in node.ChildNodes)
3591
            {
3592
                if (childNode.LocalName == "f")
3593
                    ctObj.f = childNode.InnerText;
3594
                else if (childNode.LocalName == "strCache")
3595
                    ctObj.strCache = CT_StrData.Parse(childNode, namespaceManager);
3596
                else if (childNode.LocalName == "extLst")
3597
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
3598
            }
3599
            return ctObj;
3600
        }
3601

3602

3603

3604
        internal void Write(StreamWriter sw, string nodeName)
3605
        {
3606
            sw.Write(string.Format("<c:{0}", nodeName));
3607
            sw.Write(">");
3608
            if (this.f != null)
3609
                sw.Write(string.Format("<c:f>{0}</c:f>", this.f));
3610
            if (this.strCache != null)
3611
                this.strCache.Write(sw, "strCache");
3612
            if (this.extLst != null)
3613
            {
3614
                foreach (CT_Extension x in this.extLst)
3615
                {
3616
                    x.Write(sw, "extLst");
3617
                }
3618
            }
3619
            sw.Write(string.Format("</c:{0}>", nodeName));
3620
        }
3621

3622

3623
        [XmlElement(Order = 0)]
3624
        public string f
3625
        {
3626
            get
3627
            {
3628
                return this.fField;
3629
            }
3630
            set
3631
            {
3632
                this.fField = value;
3633
            }
3634
        }
3635

3636
        [XmlElement(Order = 1)]
3637
        public CT_StrData strCache
3638
        {
3639
            get
3640
            {
3641
                return this.strCacheField;
3642
            }
3643
            set
3644
            {
3645
                this.strCacheField = value;
3646
            }
3647
        }
3648
        [XmlElement(Order = 2)]
3649
        public List<CT_Extension> extLst
3650
        {
3651
            get
3652
            {
3653
                return this.extLstField;
3654
            }
3655
            set
3656
            {
3657
                this.extLstField = value;
3658
            }
3659
        }
3660

3661
        public CT_StrData AddNewStrCache()
3662
        {
3663
            strCache = new CT_StrData();
3664
            return strCache;
3665
        }
3666
    }
3667

3668

3669
    [Serializable]
3670

3671
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3672
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3673
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3674
    public class CT_StrData
3675
    {
3676

3677
        private CT_UnsignedInt ptCountField;
3678

3679
        private List<CT_StrVal> ptField;
3680

3681
        private List<CT_Extension> extLstField;
3682

3683
        public CT_StrData()
3684
        {
3685

3686
        }
3687

3688
        public static CT_StrData Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3689
        {
3690
            if (node == null)
3691
                return null;
3692
            CT_StrData ctObj = new CT_StrData();
3693
            ctObj.pt = new List<CT_StrVal>();
3694
            ctObj.extLst = new List<CT_Extension>();
3695
            foreach (XmlNode childNode in node.ChildNodes)
3696
            {
3697
                if (childNode.LocalName == "ptCount")
3698
                    ctObj.ptCount = CT_UnsignedInt.Parse(childNode, namespaceManager);
3699
                else if (childNode.LocalName == "pt")
3700
                    ctObj.pt.Add(CT_StrVal.Parse(childNode, namespaceManager));
3701
                else if (childNode.LocalName == "extLst")
3702
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
3703
            }
3704
            return ctObj;
3705
        }
3706

3707

3708

3709
        internal void Write(StreamWriter sw, string nodeName)
3710
        {
3711
            sw.Write(string.Format("<c:{0}", nodeName));
3712
            sw.Write(">");
3713
            if (this.ptCount != null)
3714
                this.ptCount.Write(sw, "ptCount");
3715
            if (this.pt != null)
3716
            {
3717
                foreach (CT_StrVal x in this.pt)
3718
                {
3719
                    x.Write(sw, "pt");
3720
                }
3721
            }
3722
            if (this.extLst != null)
3723
            {
3724
                foreach (CT_Extension x in this.extLst)
3725
                {
3726
                    x.Write(sw, "extLst");
3727
                }
3728
            }
3729
            sw.Write(string.Format("</c:{0}>", nodeName));
3730
        }
3731

3732

3733
        [XmlElement(Order = 0)]
3734
        public CT_UnsignedInt ptCount
3735
        {
3736
            get
3737
            {
3738
                return this.ptCountField;
3739
            }
3740
            set
3741
            {
3742
                this.ptCountField = value;
3743
            }
3744
        }
3745

3746
        [XmlElement("pt", Order = 1)]
3747
        public List<CT_StrVal> pt
3748
        {
3749
            get
3750
            {
3751
                return this.ptField;
3752
            }
3753
            set
3754
            {
3755
                this.ptField = value;
3756
            }
3757
        }
3758

3759
        [XmlElement(Order = 2)]
3760
        public List<CT_Extension> extLst
3761
        {
3762
            get
3763
            {
3764
                return this.extLstField;
3765
            }
3766
            set
3767
            {
3768
                this.extLstField = value;
3769
            }
3770
        }
3771

3772
        public CT_UnsignedInt AddNewPtCount()
3773
        {
3774
            ptCount = new CT_UnsignedInt();
3775
            return ptCount;
3776
        }
3777

3778
        public CT_StrVal AddNewPt()
3779
        {
3780
            if (pt == null)
3781
                pt = new List<CT_StrVal>();
3782
            CT_StrVal strVal = new CT_StrVal();
3783
            pt.Add(strVal);
3784
            return strVal;
3785
        }
3786
    }
3787

3788

3789
    [Serializable]
3790

3791
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3792
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3793
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3794
    public class CT_StrVal
3795
    {
3796

3797
        private string vField;
3798

3799
        private uint idxField;
3800
        public static CT_StrVal Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3801
        {
3802
            if (node == null)
3803
                return null;
3804
            CT_StrVal ctObj = new CT_StrVal();
3805
            ctObj.idx = XmlHelper.ReadUInt(node.Attributes["idx"]);
3806
            foreach (XmlNode childNode in node.ChildNodes)
3807
            {
3808
                if (childNode.LocalName == "v")
3809
                    ctObj.v = childNode.InnerText;
3810
            }
3811
            return ctObj;
3812
        }
3813

3814

3815

3816
        internal void Write(StreamWriter sw, string nodeName)
3817
        {
3818
            sw.Write(string.Format("<c:{0}", nodeName));
3819
            XmlHelper.WriteAttribute(sw, "idx", this.idx, true);
3820
            sw.Write(">");
3821
            if (this.v != null)
3822
                sw.Write(string.Format("<c:v>{0}</c:v>", XmlHelper.EncodeXml(this.v)));
3823
            sw.Write(string.Format("</c:{0}>", nodeName));
3824
        }
3825

3826
        [XmlElement(Order = 0)]
3827
        public string v
3828
        {
3829
            get
3830
            {
3831
                return this.vField;
3832
            }
3833
            set
3834
            {
3835
                this.vField = value;
3836
            }
3837
        }
3838

3839
        [XmlAttribute]
3840
        public uint idx
3841
        {
3842
            get
3843
            {
3844
                return this.idxField;
3845
            }
3846
            set
3847
            {
3848
                this.idxField = value;
3849
            }
3850
        }
3851
    }
3852

3853

3854
    [Serializable]
3855

3856
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3857
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3858
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3859
    public class CT_NumFmt
3860
    {
3861

3862
        private string formatCodeField;
3863

3864
        private bool sourceLinkedField;
3865

3866
        public static CT_NumFmt Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3867
        {
3868
            if (node == null)
3869
                return null;
3870
            CT_NumFmt ctObj = new CT_NumFmt();
3871
            ctObj.formatCode = XmlHelper.ReadString(node.Attributes["formatCode"]);
3872
            ctObj.sourceLinked = XmlHelper.ReadBool(node.Attributes["sourceLinked"]);
3873
            return ctObj;
3874
        }
3875

3876

3877

3878
        internal void Write(StreamWriter sw, string nodeName)
3879
        {
3880
            sw.Write(string.Format("<c:{0}", nodeName));
3881
            XmlHelper.WriteAttribute(sw, "formatCode", this.formatCode);
3882
            XmlHelper.WriteAttribute(sw, "sourceLinked", this.sourceLinked, false);
3883
            sw.Write("/>");
3884
        }
3885

3886
        [XmlAttribute]
3887
        public string formatCode
3888
        {
3889
            get
3890
            {
3891
                return this.formatCodeField;
3892
            }
3893
            set
3894
            {
3895
                this.formatCodeField = value;
3896
            }
3897
        }
3898

3899
        [XmlAttribute]
3900
        public bool sourceLinked
3901
        {
3902
            get
3903
            {
3904
                return this.sourceLinkedField;
3905
            }
3906
            set
3907
            {
3908
                this.sourceLinkedField = value;
3909
            }
3910
        }
3911
    }
3912

3913

3914
    [Serializable]
3915

3916
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3917
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3918
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3919
    public class CT_TickMark
3920
    {
3921

3922
        private ST_TickMark valField;
3923

3924
        public CT_TickMark()
3925
        {
3926
            this.valField = ST_TickMark.cross;
3927
        }
3928
        public static CT_TickMark Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3929
        {
3930
            if (node == null)
3931
                return null;
3932
            CT_TickMark ctObj = new CT_TickMark();
3933
            if (node.Attributes["val"] != null)
3934
                ctObj.val = (ST_TickMark)Enum.Parse(typeof(ST_TickMark), node.Attributes["val"].Value);
3935
            return ctObj;
3936
        }
3937

3938

3939

3940
        internal void Write(StreamWriter sw, string nodeName)
3941
        {
3942
            sw.Write(string.Format("<c:{0}", nodeName));
3943
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
3944
            sw.Write("/>");
3945
        }
3946

3947
        [XmlAttribute]
3948
        [DefaultValue(ST_TickMark.cross)]
3949
        public ST_TickMark val
3950
        {
3951
            get
3952
            {
3953
                return this.valField;
3954
            }
3955
            set
3956
            {
3957
                this.valField = value;
3958
            }
3959
        }
3960
    }
3961

3962

3963
    [Serializable]
3964
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3965
    public enum ST_TickMark
3966
    {
3967

3968
        /// <remarks/>
3969
        cross,
3970

3971
        /// <remarks/>
3972
        @in,
3973

3974
        /// <remarks/>
3975
        none,
3976

3977
        /// <remarks/>
3978
        @out,
3979
    }
3980

3981

3982
    [Serializable]
3983

3984
    [System.ComponentModel.DesignerCategoryAttribute("code")]
3985
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
3986
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
3987
    public class CT_TickLblPos
3988
    {
3989

3990
        private ST_TickLblPos valField;
3991

3992
        public CT_TickLblPos()
3993
        {
3994
            this.valField = ST_TickLblPos.nextTo;
3995
        }
3996
        public static CT_TickLblPos Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3997
        {
3998
            if (node == null)
3999
                return null;
4000
            CT_TickLblPos ctObj = new CT_TickLblPos();
4001
            if (node.Attributes["val"] != null)
4002
                ctObj.val = (ST_TickLblPos)Enum.Parse(typeof(ST_TickLblPos), node.Attributes["val"].Value);
4003
            return ctObj;
4004
        }
4005

4006

4007

4008
        internal void Write(StreamWriter sw, string nodeName)
4009
        {
4010
            sw.Write(string.Format("<c:{0}", nodeName));
4011
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
4012
            sw.Write("/>");
4013
        }
4014

4015
        [XmlAttribute]
4016
        [DefaultValue(ST_TickLblPos.nextTo)]
4017
        public ST_TickLblPos val
4018
        {
4019
            get
4020
            {
4021
                return this.valField;
4022
            }
4023
            set
4024
            {
4025
                this.valField = value;
4026
            }
4027
        }
4028
    }
4029

4030

4031
    [Serializable]
4032
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4033
    public enum ST_TickLblPos
4034
    {
4035

4036
        /// <remarks/>
4037
        high,
4038

4039
        /// <remarks/>
4040
        low,
4041

4042
        /// <remarks/>
4043
        nextTo,
4044

4045
        /// <remarks/>
4046
        none,
4047
    }
4048

4049

4050
    [Serializable]
4051

4052
    [System.ComponentModel.DesignerCategoryAttribute("code")]
4053
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4054
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
4055
    public class CT_Crosses
4056
    {
4057
        public static CT_Crosses Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4058
        {
4059
            if (node == null)
4060
                return null;
4061
            CT_Crosses ctObj = new CT_Crosses();
4062
            if (node.Attributes["val"] != null)
4063
                ctObj.val = (ST_Crosses)Enum.Parse(typeof(ST_Crosses), node.Attributes["val"].Value);
4064
            return ctObj;
4065
        }
4066

4067

4068

4069
        internal void Write(StreamWriter sw, string nodeName)
4070
        {
4071
            sw.Write(string.Format("<c:{0}", nodeName));
4072
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
4073
            sw.Write("/>");
4074
        }
4075

4076
        private ST_Crosses valField;
4077

4078
        [XmlAttribute]
4079
        public ST_Crosses val
4080
        {
4081
            get
4082
            {
4083
                return this.valField;
4084
            }
4085
            set
4086
            {
4087
                this.valField = value;
4088
            }
4089
        }
4090
    }
4091

4092

4093
    [Serializable]
4094
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4095
    public enum ST_Crosses
4096
    {
4097

4098
        /// <remarks/>
4099
        autoZero,
4100

4101
        /// <remarks/>
4102
        max,
4103

4104
        /// <remarks/>
4105
        min,
4106
    }
4107

4108

4109
    [Serializable]
4110

4111
    [System.ComponentModel.DesignerCategoryAttribute("code")]
4112
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4113
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
4114
    public class CT_Skip
4115
    {
4116

4117
        private ushort valField;
4118
        public static CT_Skip Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4119
        {
4120
            if (node == null)
4121
                return null;
4122
            CT_Skip ctObj = new CT_Skip();
4123
            if (node.Attributes["val"] != null)
4124
                ctObj.val = XmlHelper.ReadUShort(node.Attributes["val"]);
4125
            return ctObj;
4126
        }
4127

4128

4129

4130
        internal void Write(StreamWriter sw, string nodeName)
4131
        {
4132
            sw.Write(string.Format("<c:{0}", nodeName));
4133
            XmlHelper.WriteAttribute(sw, "val", this.val);
4134
            sw.Write("/>");
4135
        }
4136

4137
        [XmlAttribute]
4138
        public ushort val
4139
        {
4140
            get
4141
            {
4142
                return this.valField;
4143
            }
4144
            set
4145
            {
4146
                this.valField = value;
4147
            }
4148
        }
4149
    }
4150

4151

4152
    [Serializable]
4153

4154
    [System.ComponentModel.DesignerCategoryAttribute("code")]
4155
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4156
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
4157
    public class CT_TimeUnit
4158
    {
4159
        public static CT_TimeUnit Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4160
        {
4161
            if (node == null)
4162
                return null;
4163
            CT_TimeUnit ctObj = new CT_TimeUnit();
4164
            if (node.Attributes["val"] != null)
4165
                ctObj.val = (ST_TimeUnit)Enum.Parse(typeof(ST_TimeUnit), node.Attributes["val"].Value);
4166
            return ctObj;
4167
        }
4168

4169

4170

4171
        internal void Write(StreamWriter sw, string nodeName)
4172
        {
4173
            sw.Write(string.Format("<c:{0}", nodeName));
4174
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
4175
            sw.Write("/>");
4176
        }
4177

4178
        private ST_TimeUnit valField;
4179

4180
        public CT_TimeUnit()
4181
        {
4182
            this.valField = ST_TimeUnit.days;
4183
        }
4184

4185
        [XmlAttribute]
4186
        [DefaultValue(ST_TimeUnit.days)]
4187
        public ST_TimeUnit val
4188
        {
4189
            get
4190
            {
4191
                return this.valField;
4192
            }
4193
            set
4194
            {
4195
                this.valField = value;
4196
            }
4197
        }
4198
    }
4199

4200

4201
    [Serializable]
4202
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4203
    public enum ST_TimeUnit
4204
    {
4205

4206
        /// <remarks/>
4207
        days,
4208

4209
        /// <remarks/>
4210
        months,
4211

4212
        /// <remarks/>
4213
        years,
4214
    }
4215

4216

4217
    [Serializable]
4218

4219
    [System.ComponentModel.DesignerCategoryAttribute("code")]
4220
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4221
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
4222
    public class CT_DateAx
4223
    {
4224

4225
        private CT_UnsignedInt axIdField;
4226

4227
        private CT_Scaling scalingField;
4228

4229
        private CT_Boolean deleteField;
4230

4231
        private CT_AxPos axPosField;
4232

4233
        private CT_ChartLines majorGridlinesField;
4234

4235
        private CT_ChartLines minorGridlinesField;
4236

4237
        private CT_Title titleField;
4238

4239
        private CT_NumFmt numFmtField;
4240

4241
        private CT_TickMark majorTickMarkField;
4242

4243
        private CT_TickMark minorTickMarkField;
4244

4245
        private CT_TickLblPos tickLblPosField;
4246

4247
        private CT_ShapeProperties spPrField;
4248

4249
        private CT_TextBody txPrField;
4250

4251
        private CT_UnsignedInt crossAxField;
4252

4253
        //private object itemField;
4254

4255
        private CT_Boolean autoField;
4256

4257
        private CT_LblOffset lblOffsetField;
4258

4259
        private CT_TimeUnit baseTimeUnitField;
4260

4261
        private CT_AxisUnit majorUnitField;
4262

4263
        private CT_TimeUnit majorTimeUnitField;
4264

4265
        private CT_AxisUnit minorUnitField;
4266

4267
        private CT_TimeUnit minorTimeUnitField;
4268

4269
        private List<CT_Extension> extLstField;
4270

4271
        public CT_DateAx()
4272
        {
4273
        }
4274
        public static CT_DateAx Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4275
        {
4276
            if (node == null)
4277
                return null;
4278
            CT_DateAx ctObj = new CT_DateAx();
4279
            ctObj.extLst = new List<CT_Extension>();
4280
            foreach (XmlNode childNode in node.ChildNodes)
4281
            {
4282
                if (childNode.LocalName == "axId")
4283
                    ctObj.axId = CT_UnsignedInt.Parse(childNode, namespaceManager);
4284
                else if (childNode.LocalName == "scaling")
4285
                    ctObj.scaling = CT_Scaling.Parse(childNode, namespaceManager);
4286
                else if (childNode.LocalName == "delete")
4287
                    ctObj.delete = CT_Boolean.Parse(childNode, namespaceManager);
4288
                else if (childNode.LocalName == "axPos")
4289
                    ctObj.axPos = CT_AxPos.Parse(childNode, namespaceManager);
4290
                else if (childNode.LocalName == "majorGridlines")
4291
                    ctObj.majorGridlines = CT_ChartLines.Parse(childNode, namespaceManager);
4292
                else if (childNode.LocalName == "minorGridlines")
4293
                    ctObj.minorGridlines = CT_ChartLines.Parse(childNode, namespaceManager);
4294
                else if (childNode.LocalName == "title")
4295
                    ctObj.title = CT_Title.Parse(childNode, namespaceManager);
4296
                else if (childNode.LocalName == "numFmt")
4297
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
4298
                else if (childNode.LocalName == "majorTickMark")
4299
                    ctObj.majorTickMark = CT_TickMark.Parse(childNode, namespaceManager);
4300
                else if (childNode.LocalName == "minorTickMark")
4301
                    ctObj.minorTickMark = CT_TickMark.Parse(childNode, namespaceManager);
4302
                else if (childNode.LocalName == "tickLblPos")
4303
                    ctObj.tickLblPos = CT_TickLblPos.Parse(childNode, namespaceManager);
4304
                else if (childNode.LocalName == "spPr")
4305
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
4306
                else if (childNode.LocalName == "txPr")
4307
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
4308
                else if (childNode.LocalName == "crossAx")
4309
                    ctObj.crossAx = CT_UnsignedInt.Parse(childNode, namespaceManager);
4310
                else if (childNode.LocalName == "crosses")
4311
                    ctObj.crosses = CT_Crosses.Parse(childNode, namespaceManager);
4312
                else if (childNode.LocalName == "auto")
4313
                    ctObj.auto = CT_Boolean.Parse(childNode, namespaceManager);
4314
                else if (childNode.LocalName == "lblOffset")
4315
                    ctObj.lblOffset = CT_LblOffset.Parse(childNode, namespaceManager);
4316
                else if (childNode.LocalName == "baseTimeUnit")
4317
                    ctObj.baseTimeUnit = CT_TimeUnit.Parse(childNode, namespaceManager);
4318
                else if (childNode.LocalName == "majorUnit")
4319
                    ctObj.majorUnit = CT_AxisUnit.Parse(childNode, namespaceManager);
4320
                else if (childNode.LocalName == "majorTimeUnit")
4321
                    ctObj.majorTimeUnit = CT_TimeUnit.Parse(childNode, namespaceManager);
4322
                else if (childNode.LocalName == "minorUnit")
4323
                    ctObj.minorUnit = CT_AxisUnit.Parse(childNode, namespaceManager);
4324
                else if (childNode.LocalName == "minorTimeUnit")
4325
                    ctObj.minorTimeUnit = CT_TimeUnit.Parse(childNode, namespaceManager);
4326
                else if (childNode.LocalName == "extLst")
4327
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
4328
            }
4329
            return ctObj;
4330
        }
4331

4332

4333

4334
        internal void Write(StreamWriter sw, string nodeName)
4335
        {
4336
            sw.Write(string.Format("<c:{0}", nodeName));
4337
            sw.Write(">");
4338
            if (this.axId != null)
4339
                this.axId.Write(sw, "axId");
4340
            if (this.scaling != null)
4341
                this.scaling.Write(sw, "scaling");
4342
            if (this.delete != null)
4343
                this.delete.Write(sw, "delete");
4344
            if (this.axPos != null)
4345
                this.axPos.Write(sw, "axPos");
4346
            if (this.majorGridlines != null)
4347
                this.majorGridlines.Write(sw, "majorGridlines");
4348
            if (this.minorGridlines != null)
4349
                this.minorGridlines.Write(sw, "minorGridlines");
4350
            if (this.title != null)
4351
                this.title.Write(sw, "title");
4352
            if (this.numFmt != null)
4353
                this.numFmt.Write(sw, "numFmt");
4354
            if (this.majorTickMark != null)
4355
                this.majorTickMark.Write(sw, "majorTickMark");
4356
            if (this.minorTickMark != null)
4357
                this.minorTickMark.Write(sw, "minorTickMark");
4358
            if (this.tickLblPos != null)
4359
                this.tickLblPos.Write(sw, "tickLblPos");
4360
            if (this.spPr != null)
4361
                this.spPr.Write(sw, "spPr");
4362
            if (this.txPr != null)
4363
                this.txPr.Write(sw, "txPr");
4364
            if (this.crossAx != null)
4365
                this.crossAx.Write(sw, "crossAx");
4366
            if (this.crosses != null)
4367
                this.crosses.Write(sw, "crosses");
4368
            if (this.auto != null)
4369
                this.auto.Write(sw, "auto");
4370
            if (this.lblOffset != null)
4371
                this.lblOffset.Write(sw, "lblOffset");
4372
            if (this.baseTimeUnit != null)
4373
                this.baseTimeUnit.Write(sw, "baseTimeUnit");
4374
            if (this.majorUnit != null)
4375
                this.majorUnit.Write(sw, "majorUnit");
4376
            if (this.majorTimeUnit != null)
4377
                this.majorTimeUnit.Write(sw, "majorTimeUnit");
4378
            if (this.minorUnit != null)
4379
                this.minorUnit.Write(sw, "minorUnit");
4380
            if (this.minorTimeUnit != null)
4381
                this.minorTimeUnit.Write(sw, "minorTimeUnit");
4382
            if (this.extLst != null)
4383
            {
4384
                foreach (CT_Extension x in this.extLst)
4385
                {
4386
                    x.Write(sw, "extLst");
4387
                }
4388
            }
4389
            sw.Write(string.Format("</c:{0}>", nodeName));
4390
        }
4391

4392

4393
        [XmlElement(Order = 0)]
4394
        public CT_UnsignedInt axId
4395
        {
4396
            get
4397
            {
4398
                return this.axIdField;
4399
            }
4400
            set
4401
            {
4402
                this.axIdField = value;
4403
            }
4404
        }
4405

4406
        [XmlElement(Order = 1)]
4407
        public CT_Scaling scaling
4408
        {
4409
            get
4410
            {
4411
                return this.scalingField;
4412
            }
4413
            set
4414
            {
4415
                this.scalingField = value;
4416
            }
4417
        }
4418

4419
        [XmlElement(Order = 2)]
4420
        public CT_Boolean delete
4421
        {
4422
            get
4423
            {
4424
                return this.deleteField;
4425
            }
4426
            set
4427
            {
4428
                this.deleteField = value;
4429
            }
4430
        }
4431

4432
        [XmlElement(Order = 3)]
4433
        public CT_AxPos axPos
4434
        {
4435
            get
4436
            {
4437
                return this.axPosField;
4438
            }
4439
            set
4440
            {
4441
                this.axPosField = value;
4442
            }
4443
        }
4444

4445
        [XmlElement(Order = 4)]
4446
        public CT_ChartLines majorGridlines
4447
        {
4448
            get
4449
            {
4450
                return this.majorGridlinesField;
4451
            }
4452
            set
4453
            {
4454
                this.majorGridlinesField = value;
4455
            }
4456
        }
4457

4458
        [XmlElement(Order = 5)]
4459
        public CT_ChartLines minorGridlines
4460
        {
4461
            get
4462
            {
4463
                return this.minorGridlinesField;
4464
            }
4465
            set
4466
            {
4467
                this.minorGridlinesField = value;
4468
            }
4469
        }
4470

4471
        [XmlElement(Order = 6)]
4472
        public CT_Title title
4473
        {
4474
            get
4475
            {
4476
                return this.titleField;
4477
            }
4478
            set
4479
            {
4480
                this.titleField = value;
4481
            }
4482
        }
4483

4484
        [XmlElement(Order = 7)]
4485
        public CT_NumFmt numFmt
4486
        {
4487
            get
4488
            {
4489
                return this.numFmtField;
4490
            }
4491
            set
4492
            {
4493
                this.numFmtField = value;
4494
            }
4495
        }
4496

4497
        [XmlElement(Order = 8)]
4498
        public CT_TickMark majorTickMark
4499
        {
4500
            get
4501
            {
4502
                return this.majorTickMarkField;
4503
            }
4504
            set
4505
            {
4506
                this.majorTickMarkField = value;
4507
            }
4508
        }
4509

4510
        [XmlElement(Order = 9)]
4511
        public CT_TickMark minorTickMark
4512
        {
4513
            get
4514
            {
4515
                return this.minorTickMarkField;
4516
            }
4517
            set
4518
            {
4519
                this.minorTickMarkField = value;
4520
            }
4521
        }
4522

4523
        [XmlElement(Order = 10)]
4524
        public CT_TickLblPos tickLblPos
4525
        {
4526
            get
4527
            {
4528
                return this.tickLblPosField;
4529
            }
4530
            set
4531
            {
4532
                this.tickLblPosField = value;
4533
            }
4534
        }
4535

4536
        [XmlElement(Order = 11)]
4537
        public CT_ShapeProperties spPr
4538
        {
4539
            get
4540
            {
4541
                return this.spPrField;
4542
            }
4543
            set
4544
            {
4545
                this.spPrField = value;
4546
            }
4547
        }
4548

4549
        [XmlElement(Order = 12)]
4550
        public CT_TextBody txPr
4551
        {
4552
            get
4553
            {
4554
                return this.txPrField;
4555
            }
4556
            set
4557
            {
4558
                this.txPrField = value;
4559
            }
4560
        }
4561

4562
        [XmlElement(Order = 13)]
4563
        public CT_UnsignedInt crossAx
4564
        {
4565
            get
4566
            {
4567
                return this.crossAxField;
4568
            }
4569
            set
4570
            {
4571
                this.crossAxField = value;
4572
            }
4573
        }
4574

4575
        CT_Double crossesAtField;
4576
        [XmlElement(Order = 14)]
4577
        public CT_Double crossesAt
4578
        {
4579
            get { return this.crossesAtField; }
4580
            set { this.crossesAtField = value; }
4581
        }
4582

4583
        CT_Crosses crossesField;
4584
        [XmlElement(Order = 14)]
4585
        public CT_Crosses crosses
4586
        {
4587
            get { return this.crossesField; }
4588
            set { this.crossesField = value; }
4589
        }
4590

4591
        [XmlElement(Order = 15)]
4592
        public CT_Boolean auto
4593
        {
4594
            get
4595
            {
4596
                return this.autoField;
4597
            }
4598
            set
4599
            {
4600
                this.autoField = value;
4601
            }
4602
        }
4603

4604
        [XmlElement(Order = 16)]
4605
        public CT_LblOffset lblOffset
4606
        {
4607
            get
4608
            {
4609
                return this.lblOffsetField;
4610
            }
4611
            set
4612
            {
4613
                this.lblOffsetField = value;
4614
            }
4615
        }
4616

4617
        [XmlElement(Order = 17)]
4618
        public CT_TimeUnit baseTimeUnit
4619
        {
4620
            get
4621
            {
4622
                return this.baseTimeUnitField;
4623
            }
4624
            set
4625
            {
4626
                this.baseTimeUnitField = value;
4627
            }
4628
        }
4629

4630
        [XmlElement(Order = 18)]
4631
        public CT_AxisUnit majorUnit
4632
        {
4633
            get
4634
            {
4635
                return this.majorUnitField;
4636
            }
4637
            set
4638
            {
4639
                this.majorUnitField = value;
4640
            }
4641
        }
4642

4643
        [XmlElement(Order = 19)]
4644
        public CT_TimeUnit majorTimeUnit
4645
        {
4646
            get
4647
            {
4648
                return this.majorTimeUnitField;
4649
            }
4650
            set
4651
            {
4652
                this.majorTimeUnitField = value;
4653
            }
4654
        }
4655

4656
        [XmlElement(Order = 20)]
4657
        public CT_AxisUnit minorUnit
4658
        {
4659
            get
4660
            {
4661
                return this.minorUnitField;
4662
            }
4663
            set
4664
            {
4665
                this.minorUnitField = value;
4666
            }
4667
        }
4668

4669
        [XmlElement(Order = 21)]
4670
        public CT_TimeUnit minorTimeUnit
4671
        {
4672
            get
4673
            {
4674
                return this.minorTimeUnitField;
4675
            }
4676
            set
4677
            {
4678
                this.minorTimeUnitField = value;
4679
            }
4680
        }
4681

4682
        [XmlElement(Order = 22)]
4683
        public List<CT_Extension> extLst
4684
        {
4685
            get
4686
            {
4687
                return this.extLstField;
4688
            }
4689
            set
4690
            {
4691
                this.extLstField = value;
4692
            }
4693
        }
4694

4695
        public CT_NumFmt AddNewNumFmt()
4696
        {
4697
            this.numFmtField = new CT_NumFmt();
4698
            return numFmtField;
4699
        }
4700

4701
        public bool IsSetNumFmt()
4702
        {
4703
            return this.numFmtField != null;
4704
        }
4705

4706
        public CT_UnsignedInt AddNewAxId()
4707
        {
4708
            this.axIdField = new CT_UnsignedInt();
4709
            return this.axIdField;
4710
        }
4711

4712
        public CT_AxPos AddNewAxPos()
4713
        {
4714
            this.axPosField = new CT_AxPos();
4715
            return this.axPosField;
4716
        }
4717

4718
        public CT_Scaling AddNewScaling()
4719
        {
4720
            this.scalingField = new CT_Scaling();
4721
            return this.scalingField;
4722
        }
4723

4724
        public CT_Crosses AddNewCrosses()
4725
        {
4726
            this.crossesField = new CT_Crosses();
4727
            return this.crossesField;
4728
        }
4729

4730
        public CT_UnsignedInt AddNewCrossAx()
4731
        {
4732
            this.crossAxField = new CT_UnsignedInt();
4733
            return this.crossAxField;
4734
        }
4735

4736
        public CT_TickLblPos AddNewTickLblPos()
4737
        {
4738
            this.tickLblPosField = new CT_TickLblPos();
4739
            return this.tickLblPosField;
4740
        }
4741

4742
        public CT_Boolean AddNewDelete()
4743
        {
4744
            this.deleteField = new CT_Boolean();
4745
            return this.deleteField;
4746
        }
4747

4748
        public CT_TickMark AddNewMajorTickMark()
4749
        {
4750
            this.majorTickMarkField = new CT_TickMark();
4751
            return this.majorTickMarkField;
4752
        }
4753

4754
        public CT_TickMark AddNewMinorTickMark()
4755
        {
4756
            this.minorTickMarkField = new CT_TickMark();
4757
            return this.minorTickMarkField;
4758
        }
4759
    }
4760

4761

4762
    [Serializable]
4763

4764
    [System.ComponentModel.DesignerCategoryAttribute("code")]
4765
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4766
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
4767
    public class CT_LblOffset
4768
    {
4769

4770
        private ushort valField;
4771

4772
        public CT_LblOffset()
4773
        {
4774
            this.valField = ((ushort)(100));
4775
        }
4776
        public static CT_LblOffset Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4777
        {
4778
            if (node == null)
4779
                return null;
4780
            CT_LblOffset ctObj = new CT_LblOffset();
4781
            if (node.Attributes["val"] != null)
4782
                ctObj.val = XmlHelper.ReadUShort(node.Attributes["val"]);
4783
            return ctObj;
4784
        }
4785

4786

4787

4788
        internal void Write(StreamWriter sw, string nodeName)
4789
        {
4790
            sw.Write(string.Format("<c:{0}", nodeName));
4791
            XmlHelper.WriteAttribute(sw, "val", this.val);
4792
            sw.Write("/>");
4793
        }
4794

4795
        [XmlAttribute]
4796
        [DefaultValue(typeof(ushort), "100")]
4797
        public ushort val
4798
        {
4799
            get
4800
            {
4801
                return this.valField;
4802
            }
4803
            set
4804
            {
4805
                this.valField = value;
4806
            }
4807
        }
4808
    }
4809

4810

4811
    [Serializable]
4812

4813
    [System.ComponentModel.DesignerCategoryAttribute("code")]
4814
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4815
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
4816
    public class CT_AxisUnit
4817
    {
4818

4819
        private double valField;
4820
        public static CT_AxisUnit Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4821
        {
4822
            if (node == null)
4823
                return null;
4824
            CT_AxisUnit ctObj = new CT_AxisUnit();
4825
            if (node.Attributes["val"] != null)
4826
                ctObj.val = XmlHelper.ReadDouble(node.Attributes["val"]);
4827
            return ctObj;
4828
        }
4829

4830

4831

4832
        internal void Write(StreamWriter sw, string nodeName)
4833
        {
4834
            sw.Write(string.Format("<c:{0}", nodeName));
4835
            XmlHelper.WriteAttribute(sw, "val", this.val);
4836
            sw.Write("/>");
4837
        }
4838

4839
        [XmlAttribute]
4840
        public double val
4841
        {
4842
            get
4843
            {
4844
                return this.valField;
4845
            }
4846
            set
4847
            {
4848
                this.valField = value;
4849
            }
4850
        }
4851
    }
4852

4853

4854
    [Serializable]
4855

4856
    [System.ComponentModel.DesignerCategoryAttribute("code")]
4857
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4858
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
4859
    public class CT_LblAlgn
4860
    {
4861
        public static CT_LblAlgn Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4862
        {
4863
            if (node == null)
4864
                return null;
4865
            CT_LblAlgn ctObj = new CT_LblAlgn();
4866
            if (node.Attributes["val"] != null)
4867
                ctObj.val = (ST_LblAlgn)Enum.Parse(typeof(ST_LblAlgn), node.Attributes["val"].Value);
4868
            return ctObj;
4869
        }
4870

4871

4872

4873
        internal void Write(StreamWriter sw, string nodeName)
4874
        {
4875
            sw.Write(string.Format("<c:{0}", nodeName));
4876
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
4877
            sw.Write("/>");
4878
        }
4879

4880
        private ST_LblAlgn valField;
4881

4882
        [XmlAttribute]
4883
        public ST_LblAlgn val
4884
        {
4885
            get
4886
            {
4887
                return this.valField;
4888
            }
4889
            set
4890
            {
4891
                this.valField = value;
4892
            }
4893
        }
4894
    }
4895

4896

4897
    [Serializable]
4898
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4899
    public enum ST_LblAlgn
4900
    {
4901

4902
        /// <remarks/>
4903
        ctr,
4904

4905
        /// <remarks/>
4906
        l,
4907

4908
        /// <remarks/>
4909
        r,
4910
    }
4911

4912

4913
    [Serializable]
4914

4915
    [System.ComponentModel.DesignerCategoryAttribute("code")]
4916
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
4917
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
4918
    public class CT_CatAx
4919
    {
4920

4921
        private CT_UnsignedInt axIdField;
4922

4923
        private CT_Scaling scalingField;
4924

4925
        private CT_Boolean deleteField;
4926

4927
        private CT_AxPos axPosField;
4928

4929
        private CT_ChartLines majorGridlinesField;
4930

4931
        private CT_ChartLines minorGridlinesField;
4932

4933
        private CT_Title titleField;
4934

4935
        private CT_NumFmt numFmtField;
4936

4937
        private CT_TickMark majorTickMarkField;
4938

4939
        private CT_TickMark minorTickMarkField;
4940

4941
        private CT_TickLblPos tickLblPosField;
4942

4943
        private CT_ShapeProperties spPrField;
4944

4945
        private CT_TextBody txPrField;
4946

4947
        private CT_UnsignedInt crossAxField;
4948

4949
        private CT_Boolean autoField;
4950

4951
        private CT_LblAlgn lblAlgnField;
4952

4953
        private CT_LblOffset lblOffsetField;
4954

4955
        private CT_Skip tickLblSkipField;
4956

4957
        private CT_Skip tickMarkSkipField;
4958

4959
        private CT_Boolean noMultiLvlLblField;
4960

4961
        private List<CT_Extension> extLstField;
4962

4963
        public CT_CatAx()
4964
        {
4965
        }
4966
        public static CT_CatAx Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4967
        {
4968
            if (node == null)
4969
                return null;
4970
            CT_CatAx ctObj = new CT_CatAx();
4971
            ctObj.extLst = new List<CT_Extension>();
4972
            foreach (XmlNode childNode in node.ChildNodes)
4973
            {
4974
                if (childNode.LocalName == "axId")
4975
                    ctObj.axId = CT_UnsignedInt.Parse(childNode, namespaceManager);
4976
                else if (childNode.LocalName == "scaling")
4977
                    ctObj.scaling = CT_Scaling.Parse(childNode, namespaceManager);
4978
                else if (childNode.LocalName == "delete")
4979
                    ctObj.delete = CT_Boolean.Parse(childNode, namespaceManager);
4980
                else if (childNode.LocalName == "axPos")
4981
                    ctObj.axPos = CT_AxPos.Parse(childNode, namespaceManager);
4982
                else if (childNode.LocalName == "majorGridlines")
4983
                    ctObj.majorGridlines = CT_ChartLines.Parse(childNode, namespaceManager);
4984
                else if (childNode.LocalName == "minorGridlines")
4985
                    ctObj.minorGridlines = CT_ChartLines.Parse(childNode, namespaceManager);
4986
                else if (childNode.LocalName == "title")
4987
                    ctObj.title = CT_Title.Parse(childNode, namespaceManager);
4988
                else if (childNode.LocalName == "numFmt")
4989
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
4990
                else if (childNode.LocalName == "majorTickMark")
4991
                    ctObj.majorTickMark = CT_TickMark.Parse(childNode, namespaceManager);
4992
                else if (childNode.LocalName == "minorTickMark")
4993
                    ctObj.minorTickMark = CT_TickMark.Parse(childNode, namespaceManager);
4994
                else if (childNode.LocalName == "tickLblPos")
4995
                    ctObj.tickLblPos = CT_TickLblPos.Parse(childNode, namespaceManager);
4996
                else if (childNode.LocalName == "spPr")
4997
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
4998
                else if (childNode.LocalName == "txPr")
4999
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
5000
                else if (childNode.LocalName == "crossAx")
5001
                    ctObj.crossAx = CT_UnsignedInt.Parse(childNode, namespaceManager);
5002
                else if (childNode.LocalName == "crosses")
5003
                    ctObj.crosses = CT_Crosses.Parse(childNode, namespaceManager);
5004
                else if (childNode.LocalName == "crossesAt")
5005
                    ctObj.crossesAt = CT_Double.Parse(childNode, namespaceManager);
5006
                else if (childNode.LocalName == "auto")
5007
                    ctObj.auto = CT_Boolean.Parse(childNode, namespaceManager);
5008
                else if (childNode.LocalName == "lblAlgn")
5009
                    ctObj.lblAlgn = CT_LblAlgn.Parse(childNode, namespaceManager);
5010
                else if (childNode.LocalName == "lblOffset")
5011
                    ctObj.lblOffset = CT_LblOffset.Parse(childNode, namespaceManager);
5012
                else if (childNode.LocalName == "tickLblSkip")
5013
                    ctObj.tickLblSkip = CT_Skip.Parse(childNode, namespaceManager);
5014
                else if (childNode.LocalName == "tickMarkSkip")
5015
                    ctObj.tickMarkSkip = CT_Skip.Parse(childNode, namespaceManager);
5016
                else if (childNode.LocalName == "noMultiLvlLbl")
5017
                    ctObj.noMultiLvlLbl = CT_Boolean.Parse(childNode, namespaceManager);
5018
                else if (childNode.LocalName == "extLst")
5019
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
5020
            }
5021
            return ctObj;
5022
        }
5023

5024

5025

5026
        internal void Write(StreamWriter sw, string nodeName)
5027
        {
5028
            sw.Write(string.Format("<c:{0}>", nodeName));
5029
            if (this.axId != null)
5030
                this.axId.Write(sw, "axId");
5031
            if (this.scaling != null)
5032
                this.scaling.Write(sw, "scaling");
5033
            if (this.delete != null)
5034
                this.delete.Write(sw, "delete");
5035
            if (this.axPos != null)
5036
                this.axPos.Write(sw, "axPos");
5037
            if (this.majorGridlines != null)
5038
                this.majorGridlines.Write(sw, "majorGridlines");
5039
            if (this.minorGridlines != null)
5040
                this.minorGridlines.Write(sw, "minorGridlines");
5041
            if (this.title != null)
5042
                this.title.Write(sw, "title");
5043
            if (this.numFmt != null)
5044
                this.numFmt.Write(sw, "numFmt");
5045
            if (this.majorTickMark != null)
5046
                this.majorTickMark.Write(sw, "majorTickMark");
5047
            if (this.minorTickMark != null)
5048
                this.minorTickMark.Write(sw, "minorTickMark");
5049
            if (this.tickLblPos != null)
5050
                this.tickLblPos.Write(sw, "tickLblPos");
5051
            if (this.spPr != null)
5052
                this.spPr.Write(sw, "spPr");
5053
            if (this.txPr != null)
5054
                this.txPr.Write(sw, "txPr");
5055
            if (this.crossAx != null)
5056
                this.crossAx.Write(sw, "crossAx");
5057
            if (this.crossesAt != null)
5058
                this.crossesAt.Write(sw, "crossesAt");
5059
            if (this.crosses != null)
5060
                this.crosses.Write(sw, "crosses");
5061
            if (this.auto != null)
5062
                this.auto.Write(sw, "auto");
5063
            if (this.lblAlgn != null)
5064
                this.lblAlgn.Write(sw, "lblAlgn");
5065
            if (this.lblOffset != null)
5066
                this.lblOffset.Write(sw, "lblOffset");
5067
            if (this.tickLblSkip != null)
5068
                this.tickLblSkip.Write(sw, "tickLblSkip");
5069
            if (this.tickMarkSkip != null)
5070
                this.tickMarkSkip.Write(sw, "tickMarkSkip");
5071
            if (this.noMultiLvlLbl != null)
5072
                this.noMultiLvlLbl.Write(sw, "noMultiLvlLbl");
5073
            if (this.extLst != null)
5074
            {
5075
                foreach (CT_Extension x in this.extLst)
5076
                {
5077
                    x.Write(sw, "extLst");
5078
                }
5079
            }
5080
            sw.Write(string.Format("</c:{0}>", nodeName));
5081
        }
5082

5083
        [XmlElement(Order = 0)]
5084
        public CT_UnsignedInt axId
5085
        {
5086
            get
5087
            {
5088
                return this.axIdField;
5089
            }
5090
            set
5091
            {
5092
                this.axIdField = value;
5093
            }
5094
        }
5095

5096
        [XmlElement(Order = 1)]
5097
        public CT_Scaling scaling
5098
        {
5099
            get
5100
            {
5101
                return this.scalingField;
5102
            }
5103
            set
5104
            {
5105
                this.scalingField = value;
5106
            }
5107
        }
5108

5109
        [XmlElement(Order = 2)]
5110
        public CT_Boolean delete
5111
        {
5112
            get
5113
            {
5114
                return this.deleteField;
5115
            }
5116
            set
5117
            {
5118
                this.deleteField = value;
5119
            }
5120
        }
5121

5122
        [XmlElement(Order = 3)]
5123
        public CT_AxPos axPos
5124
        {
5125
            get
5126
            {
5127
                return this.axPosField;
5128
            }
5129
            set
5130
            {
5131
                this.axPosField = value;
5132
            }
5133
        }
5134

5135
        [XmlElement(Order = 4)]
5136
        public CT_ChartLines majorGridlines
5137
        {
5138
            get
5139
            {
5140
                return this.majorGridlinesField;
5141
            }
5142
            set
5143
            {
5144
                this.majorGridlinesField = value;
5145
            }
5146
        }
5147

5148
        [XmlElement(Order = 5)]
5149
        public CT_ChartLines minorGridlines
5150
        {
5151
            get
5152
            {
5153
                return this.minorGridlinesField;
5154
            }
5155
            set
5156
            {
5157
                this.minorGridlinesField = value;
5158
            }
5159
        }
5160

5161
        [XmlElement(Order = 6)]
5162
        public CT_Title title
5163
        {
5164
            get
5165
            {
5166
                return this.titleField;
5167
            }
5168
            set
5169
            {
5170
                this.titleField = value;
5171
            }
5172
        }
5173

5174
        [XmlElement(Order = 7)]
5175
        public CT_NumFmt numFmt
5176
        {
5177
            get
5178
            {
5179
                return this.numFmtField;
5180
            }
5181
            set
5182
            {
5183
                this.numFmtField = value;
5184
            }
5185
        }
5186

5187
        [XmlElement(Order = 8)]
5188
        public CT_TickMark majorTickMark
5189
        {
5190
            get
5191
            {
5192
                return this.majorTickMarkField;
5193
            }
5194
            set
5195
            {
5196
                this.majorTickMarkField = value;
5197
            }
5198
        }
5199

5200
        [XmlElement(Order = 9)]
5201
        public CT_TickMark minorTickMark
5202
        {
5203
            get
5204
            {
5205
                return this.minorTickMarkField;
5206
            }
5207
            set
5208
            {
5209
                this.minorTickMarkField = value;
5210
            }
5211
        }
5212

5213
        [XmlElement(Order = 10)]
5214
        public CT_TickLblPos tickLblPos
5215
        {
5216
            get
5217
            {
5218
                return this.tickLblPosField;
5219
            }
5220
            set
5221
            {
5222
                this.tickLblPosField = value;
5223
            }
5224
        }
5225

5226
        [XmlElement(Order = 11)]
5227
        public CT_ShapeProperties spPr
5228
        {
5229
            get
5230
            {
5231
                return this.spPrField;
5232
            }
5233
            set
5234
            {
5235
                this.spPrField = value;
5236
            }
5237
        }
5238

5239
        [XmlElement(Order = 12)]
5240
        public CT_TextBody txPr
5241
        {
5242
            get
5243
            {
5244
                return this.txPrField;
5245
            }
5246
            set
5247
            {
5248
                this.txPrField = value;
5249
            }
5250
        }
5251

5252
        [XmlElement(Order = 13)]
5253
        public CT_UnsignedInt crossAx
5254
        {
5255
            get
5256
            {
5257
                return this.crossAxField;
5258
            }
5259
            set
5260
            {
5261
                this.crossAxField = value;
5262
            }
5263
        }
5264
        CT_Double crossesAtField;
5265
        [XmlElement(Order = 14)]
5266
        public CT_Double crossesAt
5267
        {
5268
            get { return this.crossesAtField; }
5269
            set { this.crossesAtField = value; }
5270
        }
5271

5272
        CT_Crosses crossesField;
5273
        [XmlElement(Order = 14)]
5274
        public CT_Crosses crosses
5275
        {
5276
            get { return this.crossesField; }
5277
            set { this.crossesField = value; }
5278
        }
5279

5280

5281
        [XmlElement(Order = 15)]
5282
        public CT_Boolean auto
5283
        {
5284
            get
5285
            {
5286
                return this.autoField;
5287
            }
5288
            set
5289
            {
5290
                this.autoField = value;
5291
            }
5292
        }
5293

5294
        [XmlElement(Order = 16)]
5295
        public CT_LblAlgn lblAlgn
5296
        {
5297
            get
5298
            {
5299
                return this.lblAlgnField;
5300
            }
5301
            set
5302
            {
5303
                this.lblAlgnField = value;
5304
            }
5305
        }
5306

5307
        [XmlElement(Order = 17)]
5308
        public CT_LblOffset lblOffset
5309
        {
5310
            get
5311
            {
5312
                return this.lblOffsetField;
5313
            }
5314
            set
5315
            {
5316
                this.lblOffsetField = value;
5317
            }
5318
        }
5319

5320
        [XmlElement(Order = 18)]
5321
        public CT_Skip tickLblSkip
5322
        {
5323
            get
5324
            {
5325
                return this.tickLblSkipField;
5326
            }
5327
            set
5328
            {
5329
                this.tickLblSkipField = value;
5330
            }
5331
        }
5332

5333
        [XmlElement(Order = 19)]
5334
        public CT_Skip tickMarkSkip
5335
        {
5336
            get
5337
            {
5338
                return this.tickMarkSkipField;
5339
            }
5340
            set
5341
            {
5342
                this.tickMarkSkipField = value;
5343
            }
5344
        }
5345

5346
        [XmlElement(Order = 20)]
5347
        public CT_Boolean noMultiLvlLbl
5348
        {
5349
            get
5350
            {
5351
                return this.noMultiLvlLblField;
5352
            }
5353
            set
5354
            {
5355
                this.noMultiLvlLblField = value;
5356
            }
5357
        }
5358

5359
        [XmlElement(Order = 21)]
5360
        public List<CT_Extension> extLst
5361
        {
5362
            get
5363
            {
5364
                return this.extLstField;
5365
            }
5366
            set
5367
            {
5368
                this.extLstField = value;
5369
            }
5370
        }
5371

5372
        public CT_NumFmt AddNewNumFmt()
5373
        {
5374
            this.numFmtField = new CT_NumFmt();
5375
            return numFmtField;
5376
        }
5377

5378
        public bool IsSetNumFmt()
5379
        {
5380
            return this.numFmtField != null;
5381
        }
5382

5383
        public CT_UnsignedInt AddNewAxId()
5384
        {
5385
            this.axIdField = new CT_UnsignedInt();
5386
            return this.axIdField;
5387
        }
5388

5389
        public CT_AxPos AddNewAxPos()
5390
        {
5391
            this.axPosField = new CT_AxPos();
5392
            return this.axPosField;
5393
        }
5394

5395
        public CT_Scaling AddNewScaling()
5396
        {
5397
            this.scalingField = new CT_Scaling();
5398
            return this.scalingField;
5399
        }
5400

5401
        public CT_Crosses AddNewCrosses()
5402
        {
5403
            this.crossesField = new CT_Crosses();
5404
            return this.crossesField;
5405
        }
5406

5407
        public CT_UnsignedInt AddNewCrossAx()
5408
        {
5409
            this.crossAxField = new CT_UnsignedInt();
5410
            return this.crossAxField;
5411
        }
5412

5413
        public CT_TickLblPos AddNewTickLblPos()
5414
        {
5415
            this.tickLblPosField = new CT_TickLblPos();
5416
            return this.tickLblPosField;
5417
        }
5418

5419
        public CT_Boolean AddNewDelete()
5420
        {
5421
            this.deleteField = new CT_Boolean();
5422
            return this.deleteField;
5423
        }
5424

5425
        public CT_TickMark AddNewMajorTickMark()
5426
        {
5427
            this.majorTickMarkField = new CT_TickMark();
5428
            return this.majorTickMarkField;
5429
        }
5430

5431
        public CT_ChartLines AddNewMajorGridlines()
5432
        {
5433
            this.majorGridlinesField = new CT_ChartLines();
5434
            return this.majorGridlinesField;
5435
        }
5436
        public CT_ChartLines AddNewMinorGridlines()
5437
        {
5438
            this.minorGridlinesField = new CT_ChartLines();
5439
            return this.minorGridlinesField;
5440
        }
5441
        public CT_TickMark AddNewMinorTickMark()
5442
        {
5443
            this.minorTickMarkField = new CT_TickMark();
5444
            return this.minorTickMarkField;
5445
        }
5446
    }
5447

5448

5449
    [Serializable]
5450

5451
    [System.ComponentModel.DesignerCategoryAttribute("code")]
5452
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
5453
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
5454
    public class CT_DispUnitsLbl
5455
    {
5456

5457
        private CT_Layout layoutField;
5458

5459
        private CT_Tx txField;
5460

5461
        private CT_ShapeProperties spPrField;
5462

5463
        private CT_TextBody txPrField;
5464

5465
        public CT_DispUnitsLbl()
5466
        {
5467
        }
5468
        public static CT_DispUnitsLbl Parse(XmlNode node, XmlNamespaceManager namespaceManager)
5469
        {
5470
            if (node == null)
5471
                return null;
5472
            CT_DispUnitsLbl ctObj = new CT_DispUnitsLbl();
5473
            foreach (XmlNode childNode in node.ChildNodes)
5474
            {
5475
                if (childNode.LocalName == "layout")
5476
                    ctObj.layout = CT_Layout.Parse(childNode, namespaceManager);
5477
                else if (childNode.LocalName == "tx")
5478
                    ctObj.tx = CT_Tx.Parse(childNode, namespaceManager);
5479
                else if (childNode.LocalName == "spPr")
5480
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
5481
                else if (childNode.LocalName == "txPr")
5482
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
5483
            }
5484
            return ctObj;
5485
        }
5486

5487

5488

5489
        internal void Write(StreamWriter sw, string nodeName)
5490
        {
5491
            sw.Write(string.Format("<c:{0}", nodeName));
5492
            sw.Write(">");
5493
            if (this.layout != null)
5494
                this.layout.Write(sw, "layout");
5495
            if (this.tx != null)
5496
                this.tx.Write(sw, "tx");
5497
            if (this.spPr != null)
5498
                this.spPr.Write(sw, "spPr");
5499
            if (this.txPr != null)
5500
                this.txPr.Write(sw, "txPr");
5501
            sw.Write(string.Format("</c:{0}>", nodeName));
5502
        }
5503

5504

5505
        [XmlElement(Order = 0)]
5506
        public CT_Layout layout
5507
        {
5508
            get
5509
            {
5510
                return this.layoutField;
5511
            }
5512
            set
5513
            {
5514
                this.layoutField = value;
5515
            }
5516
        }
5517

5518
        [XmlElement(Order = 1)]
5519
        public CT_Tx tx
5520
        {
5521
            get
5522
            {
5523
                return this.txField;
5524
            }
5525
            set
5526
            {
5527
                this.txField = value;
5528
            }
5529
        }
5530

5531
        [XmlElement(Order = 2)]
5532
        public CT_ShapeProperties spPr
5533
        {
5534
            get
5535
            {
5536
                return this.spPrField;
5537
            }
5538
            set
5539
            {
5540
                this.spPrField = value;
5541
            }
5542
        }
5543

5544
        [XmlElement(Order = 3)]
5545
        public CT_TextBody txPr
5546
        {
5547
            get
5548
            {
5549
                return this.txPrField;
5550
            }
5551
            set
5552
            {
5553
                this.txPrField = value;
5554
            }
5555
        }
5556
    }
5557

5558

5559
    [Serializable]
5560

5561
    [System.ComponentModel.DesignerCategoryAttribute("code")]
5562
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
5563
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
5564
    public class CT_BuiltInUnit
5565
    {
5566

5567
        private ST_BuiltInUnit valField;
5568

5569
        public CT_BuiltInUnit()
5570
        {
5571
            this.valField = ST_BuiltInUnit.thousands;
5572
        }
5573

5574
        [XmlAttribute]
5575
        [DefaultValue(ST_BuiltInUnit.thousands)]
5576
        public ST_BuiltInUnit val
5577
        {
5578
            get
5579
            {
5580
                return this.valField;
5581
            }
5582
            set
5583
            {
5584
                this.valField = value;
5585
            }
5586
        }
5587
    }
5588

5589

5590
    [Serializable]
5591
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
5592
    public enum ST_BuiltInUnit
5593
    {
5594

5595
        /// <remarks/>
5596
        hundreds,
5597

5598
        /// <remarks/>
5599
        thousands,
5600

5601
        /// <remarks/>
5602
        tenThousands,
5603

5604
        /// <remarks/>
5605
        hundredThousands,
5606

5607
        /// <remarks/>
5608
        millions,
5609

5610
        /// <remarks/>
5611
        tenMillions,
5612

5613
        /// <remarks/>
5614
        hundredMillions,
5615

5616
        /// <remarks/>
5617
        billions,
5618

5619
        /// <remarks/>
5620
        trillions,
5621
    }
5622

5623

5624
    [Serializable]
5625

5626
    [System.ComponentModel.DesignerCategoryAttribute("code")]
5627
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
5628
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
5629
    public class CT_DispUnits
5630
    {
5631

5632
        //private object itemField;
5633

5634
        private CT_DispUnitsLbl dispUnitsLblField;
5635

5636
        private List<CT_Extension> extLstField;
5637

5638
        public CT_DispUnits()
5639
        {
5640
        }
5641

5642
        CT_BuiltInUnit builtInUnitField;
5643
        //[XmlElement(Order = 0)]
5644
        public CT_BuiltInUnit builtInUnit
5645
        {
5646
            get { return this.builtInUnitField; }
5647
            set { this.builtInUnitField = value; }
5648
        }
5649

5650
        CT_Double custUnitField;
5651
        [XmlElement(Order = 0)]
5652
        public CT_Double custUnit
5653
        {
5654
            get { return this.custUnitField; }
5655
            set { this.custUnitField = value; }
5656
        }
5657

5658

5659
        [XmlElement(Order = 1)]
5660
        public CT_DispUnitsLbl dispUnitsLbl
5661
        {
5662
            get
5663
            {
5664
                return this.dispUnitsLblField;
5665
            }
5666
            set
5667
            {
5668
                this.dispUnitsLblField = value;
5669
            }
5670
        }
5671

5672
        [XmlElement(Order = 2)]
5673
        public List<CT_Extension> extLst
5674
        {
5675
            get
5676
            {
5677
                return this.extLstField;
5678
            }
5679
            set
5680
            {
5681
                this.extLstField = value;
5682
            }
5683
        }
5684

5685
        internal static CT_DispUnits Parse(XmlNode childNode, XmlNamespaceManager namespaceManager)
5686
        {
5687
            throw new NotImplementedException();
5688
        }
5689

5690
        internal void Write(StreamWriter sw, string p)
5691
        {
5692
            throw new NotImplementedException();
5693
        }
5694
    }
5695

5696

5697
    [Serializable]
5698

5699
    [System.ComponentModel.DesignerCategoryAttribute("code")]
5700
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
5701
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
5702
    public class CT_CrossBetween
5703
    {
5704

5705
        private ST_CrossBetween valField;
5706
        public static CT_CrossBetween Parse(XmlNode node, XmlNamespaceManager namespaceManager)
5707
        {
5708
            if (node == null)
5709
                return null;
5710
            CT_CrossBetween ctObj = new CT_CrossBetween();
5711
            if (node.Attributes["val"] != null)
5712
                ctObj.val = (ST_CrossBetween)Enum.Parse(typeof(ST_CrossBetween), node.Attributes["val"].Value);
5713
            return ctObj;
5714
        }
5715

5716

5717

5718
        internal void Write(StreamWriter sw, string nodeName)
5719
        {
5720
            sw.Write(string.Format("<c:{0}", nodeName));
5721
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
5722
            sw.Write("/>");
5723
        }
5724

5725
        [XmlAttribute]
5726
        public ST_CrossBetween val
5727
        {
5728
            get
5729
            {
5730
                return this.valField;
5731
            }
5732
            set
5733
            {
5734
                this.valField = value;
5735
            }
5736
        }
5737
    }
5738

5739

5740
    [Serializable]
5741
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
5742
    public enum ST_CrossBetween
5743
    {
5744

5745
        /// <remarks/>
5746
        between,
5747

5748
        /// <remarks/>
5749
        midCat,
5750
    }
5751

5752

5753
    [Serializable]
5754

5755
    [System.ComponentModel.DesignerCategoryAttribute("code")]
5756
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
5757
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
5758
    public class CT_ValAx
5759
    {
5760

5761
        private CT_UnsignedInt axIdField;
5762

5763
        private CT_Scaling scalingField;
5764

5765
        private CT_Boolean deleteField;
5766

5767
        private CT_AxPos axPosField;
5768

5769
        private CT_ChartLines majorGridlinesField;
5770

5771
        private CT_ChartLines minorGridlinesField;
5772

5773
        private CT_Title titleField;
5774

5775
        private CT_NumFmt numFmtField;
5776

5777
        private CT_TickMark majorTickMarkField;
5778

5779
        private CT_TickMark minorTickMarkField;
5780

5781
        private CT_TickLblPos tickLblPosField;
5782

5783
        private CT_ShapeProperties spPrField;
5784

5785
        private CT_TextBody txPrField;
5786

5787
        private CT_UnsignedInt crossAxField;
5788

5789

5790
        private CT_CrossBetween crossBetweenField;
5791

5792
        private CT_AxisUnit majorUnitField;
5793

5794
        private CT_AxisUnit minorUnitField;
5795

5796
        private CT_DispUnits dispUnitsField;
5797

5798
        private List<CT_Extension> extLstField;
5799

5800
        public CT_ValAx()
5801
        {
5802
        }
5803
        public static CT_ValAx Parse(XmlNode node, XmlNamespaceManager namespaceManager)
5804
        {
5805
            if (node == null)
5806
                return null;
5807
            CT_ValAx ctObj = new CT_ValAx();
5808
            ctObj.extLst = new List<CT_Extension>();
5809
            foreach (XmlNode childNode in node.ChildNodes)
5810
            {
5811
                if (childNode.LocalName == "axId")
5812
                    ctObj.axId = CT_UnsignedInt.Parse(childNode, namespaceManager);
5813
                else if (childNode.LocalName == "scaling")
5814
                    ctObj.scaling = CT_Scaling.Parse(childNode, namespaceManager);
5815
                else if (childNode.LocalName == "delete")
5816
                    ctObj.delete = CT_Boolean.Parse(childNode, namespaceManager);
5817
                else if (childNode.LocalName == "axPos")
5818
                    ctObj.axPos = CT_AxPos.Parse(childNode, namespaceManager);
5819
                else if (childNode.LocalName == "majorGridlines")
5820
                    ctObj.majorGridlines = CT_ChartLines.Parse(childNode, namespaceManager);
5821
                else if (childNode.LocalName == "minorGridlines")
5822
                    ctObj.minorGridlines = CT_ChartLines.Parse(childNode, namespaceManager);
5823
                else if (childNode.LocalName == "title")
5824
                    ctObj.title = CT_Title.Parse(childNode, namespaceManager);
5825
                else if (childNode.LocalName == "numFmt")
5826
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
5827
                else if (childNode.LocalName == "majorTickMark")
5828
                    ctObj.majorTickMark = CT_TickMark.Parse(childNode, namespaceManager);
5829
                else if (childNode.LocalName == "minorTickMark")
5830
                    ctObj.minorTickMark = CT_TickMark.Parse(childNode, namespaceManager);
5831
                else if (childNode.LocalName == "tickLblPos")
5832
                    ctObj.tickLblPos = CT_TickLblPos.Parse(childNode, namespaceManager);
5833
                else if (childNode.LocalName == "spPr")
5834
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
5835
                else if (childNode.LocalName == "txPr")
5836
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
5837
                else if (childNode.LocalName == "crossAx")
5838
                    ctObj.crossAx = CT_UnsignedInt.Parse(childNode, namespaceManager);
5839
                else if (childNode.LocalName == "crosses")
5840
                    ctObj.crosses = CT_Crosses.Parse(childNode, namespaceManager);
5841
                else if (childNode.LocalName == "crossesAt")
5842
                    ctObj.crossesAt = CT_Double.Parse(childNode, namespaceManager);
5843
                else if (childNode.LocalName == "crossBetween")
5844
                    ctObj.crossBetween = CT_CrossBetween.Parse(childNode, namespaceManager);
5845
                else if (childNode.LocalName == "majorUnit")
5846
                    ctObj.majorUnit = CT_AxisUnit.Parse(childNode, namespaceManager);
5847
                else if (childNode.LocalName == "minorUnit")
5848
                    ctObj.minorUnit = CT_AxisUnit.Parse(childNode, namespaceManager);
5849
                else if (childNode.LocalName == "dispUnits")
5850
                    ctObj.dispUnits = CT_DispUnits.Parse(childNode, namespaceManager);
5851
                else if (childNode.LocalName == "extLst")
5852
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
5853
            }
5854
            return ctObj;
5855
        }
5856

5857

5858

5859
        internal void Write(StreamWriter sw, string nodeName)
5860
        {
5861
            sw.Write(string.Format("<c:{0}>", nodeName));
5862
            if (this.axId != null)
5863
                this.axId.Write(sw, "axId");
5864
            if (this.scaling != null)
5865
                this.scaling.Write(sw, "scaling");
5866
            if (this.delete != null)
5867
                this.delete.Write(sw, "delete");
5868
            if (this.axPos != null)
5869
                this.axPos.Write(sw, "axPos");
5870
            if (this.majorGridlines != null)
5871
                this.majorGridlines.Write(sw, "majorGridlines");
5872
            if (this.minorGridlines != null)
5873
                this.minorGridlines.Write(sw, "minorGridlines");
5874
            if (this.title != null)
5875
                this.title.Write(sw, "title");
5876
            if (this.numFmt != null)
5877
                this.numFmt.Write(sw, "numFmt");
5878
            if (this.majorTickMark != null)
5879
                this.majorTickMark.Write(sw, "majorTickMark");
5880
            if (this.minorTickMark != null)
5881
                this.minorTickMark.Write(sw, "minorTickMark");
5882
            if (this.tickLblPos != null)
5883
                this.tickLblPos.Write(sw, "tickLblPos");
5884
            if (this.spPr != null)
5885
                this.spPr.Write(sw, "spPr");
5886
            if (this.txPr != null)
5887
                this.txPr.Write(sw, "txPr");
5888
            if (this.crossAx != null)
5889
                this.crossAx.Write(sw, "crossAx");
5890
            if (this.crosses != null)
5891
                this.crosses.Write(sw, "crosses");
5892
            if (this.crossesAt != null)
5893
                this.crossesAt.Write(sw, "crossesAt");
5894
            if (this.crossBetween != null)
5895
                this.crossBetween.Write(sw, "crossBetween");
5896
            if (this.majorUnit != null)
5897
                this.majorUnit.Write(sw, "majorUnit");
5898
            if (this.minorUnit != null)
5899
                this.minorUnit.Write(sw, "minorUnit");
5900
            if (this.dispUnits != null)
5901
                this.dispUnits.Write(sw, "dispUnits");
5902
            if (this.extLst != null)
5903
            {
5904
                foreach (CT_Extension x in this.extLst)
5905
                {
5906
                    x.Write(sw, "extLst");
5907
                }
5908
            }
5909
            sw.Write(string.Format("</c:{0}>", nodeName));
5910
        }
5911

5912
        public bool IsSetNumFmt()
5913
        {
5914
            return this.numFmtField!=null;
5915
        }
5916
        public CT_NumFmt AddNewNumFmt()
5917
        {
5918
            this.numFmtField=new CT_NumFmt();
5919
            return this.numFmtField;
5920
        }
5921
        public CT_Crosses AddNewCrosses()
5922
        {
5923
            this.crossesField = new CT_Crosses();
5924
            return this.crossesField;
5925
        }
5926

5927
        public CT_UnsignedInt AddNewAxId()
5928
        {
5929
            this.axIdField=new CT_UnsignedInt();
5930
            return this.axIdField;
5931
        }
5932
        public CT_AxPos AddNewAxPos()
5933
        {
5934
            this.axPosField=new CT_AxPos();
5935
            return this.axPosField;
5936
        }
5937
        public CT_Scaling AddNewScaling()
5938
        {
5939
            this.scalingField=new CT_Scaling();
5940
            return this.scalingField;
5941
        }
5942
        public CT_CrossBetween AddNewCrossBetween()
5943
        {
5944
            this.crossBetweenField=new CT_CrossBetween();
5945
            return this.crossBetweenField;
5946
        }
5947
        public CT_UnsignedInt AddNewCrossAx()
5948
        {
5949
            this.crossAxField= new CT_UnsignedInt();
5950
            return this.crossAxField;
5951
        }
5952
        public CT_TickLblPos AddNewTickLblPos()
5953
        {
5954
            this.tickLblPosField = new CT_TickLblPos();
5955
            return this.tickLblPosField;
5956
        }
5957
        [XmlElement(Order = 0)]
5958
        public CT_UnsignedInt axId
5959
        {
5960
            get
5961
            {
5962
                return this.axIdField;
5963
            }
5964
            set
5965
            {
5966
                this.axIdField = value;
5967
            }
5968
        }
5969

5970
        [XmlElement(Order = 1)]
5971
        public CT_Scaling scaling
5972
        {
5973
            get
5974
            {
5975
                return this.scalingField;
5976
            }
5977
            set
5978
            {
5979
                this.scalingField = value;
5980
            }
5981
        }
5982

5983
        [XmlElement(Order = 2)]
5984
        public CT_Boolean delete
5985
        {
5986
            get
5987
            {
5988
                return this.deleteField;
5989
            }
5990
            set
5991
            {
5992
                this.deleteField = value;
5993
            }
5994
        }
5995

5996
        [XmlElement(Order = 3)]
5997
        public CT_AxPos axPos
5998
        {
5999
            get
6000
            {
6001
                return this.axPosField;
6002
            }
6003
            set
6004
            {
6005
                this.axPosField = value;
6006
            }
6007
        }
6008

6009
        [XmlElement(Order = 4)]
6010
        public CT_ChartLines majorGridlines
6011
        {
6012
            get
6013
            {
6014
                return this.majorGridlinesField;
6015
            }
6016
            set
6017
            {
6018
                this.majorGridlinesField = value;
6019
            }
6020
        }
6021

6022
        [XmlElement(Order = 5)]
6023
        public CT_ChartLines minorGridlines
6024
        {
6025
            get
6026
            {
6027
                return this.minorGridlinesField;
6028
            }
6029
            set
6030
            {
6031
                this.minorGridlinesField = value;
6032
            }
6033
        }
6034

6035
        [XmlElement(Order = 6)]
6036
        public CT_Title title
6037
        {
6038
            get
6039
            {
6040
                return this.titleField;
6041
            }
6042
            set
6043
            {
6044
                this.titleField = value;
6045
            }
6046
        }
6047

6048
        [XmlElement(Order = 7)]
6049
        public CT_NumFmt numFmt
6050
        {
6051
            get
6052
            {
6053
                return this.numFmtField;
6054
            }
6055
            set
6056
            {
6057
                this.numFmtField = value;
6058
            }
6059
        }
6060

6061
        [XmlElement(Order = 8)]
6062
        public CT_TickMark majorTickMark
6063
        {
6064
            get
6065
            {
6066
                return this.majorTickMarkField;
6067
            }
6068
            set
6069
            {
6070
                this.majorTickMarkField = value;
6071
            }
6072
        }
6073

6074
        [XmlElement(Order = 9)]
6075
        public CT_TickMark minorTickMark
6076
        {
6077
            get
6078
            {
6079
                return this.minorTickMarkField;
6080
            }
6081
            set
6082
            {
6083
                this.minorTickMarkField = value;
6084
            }
6085
        }
6086

6087
        [XmlElement(Order = 10)]
6088
        public CT_TickLblPos tickLblPos
6089
        {
6090
            get
6091
            {
6092
                return this.tickLblPosField;
6093
            }
6094
            set
6095
            {
6096
                this.tickLblPosField = value;
6097
            }
6098
        }
6099

6100
        [XmlElement(Order = 11)]
6101
        public CT_ShapeProperties spPr
6102
        {
6103
            get
6104
            {
6105
                return this.spPrField;
6106
            }
6107
            set
6108
            {
6109
                this.spPrField = value;
6110
            }
6111
        }
6112

6113
        [XmlElement(Order = 12)]
6114
        public CT_TextBody txPr
6115
        {
6116
            get
6117
            {
6118
                return this.txPrField;
6119
            }
6120
            set
6121
            {
6122
                this.txPrField = value;
6123
            }
6124
        }
6125

6126
        [XmlElement(Order = 13)]
6127
        public CT_UnsignedInt crossAx
6128
        {
6129
            get
6130
            {
6131
                return this.crossAxField;
6132
            }
6133
            set
6134
            {
6135
                this.crossAxField = value;
6136
            }
6137
        }
6138
        CT_Crosses crossesField;
6139
        [XmlElement(Order = 14)]
6140
        public CT_Crosses crosses
6141
        {
6142
            get
6143
            {
6144
                return this.crossesField;
6145
            }
6146
            set
6147
            {
6148
                this.crossesField = value;
6149
            }
6150
        }
6151
        CT_Double crossesAtField;
6152
        [XmlElement(Order = 15)]
6153
        public CT_Double crossesAt
6154
        {
6155
            get
6156
            {
6157
                return this.crossesAtField;
6158
            }
6159
            set
6160
            {
6161
                this.crossesAtField = value;
6162
            }
6163
        }
6164

6165
        [XmlElement(Order = 16)]
6166
        public CT_CrossBetween crossBetween
6167
        {
6168
            get
6169
            {
6170
                return this.crossBetweenField;
6171
            }
6172
            set
6173
            {
6174
                this.crossBetweenField = value;
6175
            }
6176
        }
6177

6178
        [XmlElement(Order = 17)]
6179
        public CT_AxisUnit majorUnit
6180
        {
6181
            get
6182
            {
6183
                return this.majorUnitField;
6184
            }
6185
            set
6186
            {
6187
                this.majorUnitField = value;
6188
            }
6189
        }
6190

6191
        [XmlElement(Order = 18)]
6192
        public CT_AxisUnit minorUnit
6193
        {
6194
            get
6195
            {
6196
                return this.minorUnitField;
6197
            }
6198
            set
6199
            {
6200
                this.minorUnitField = value;
6201
            }
6202
        }
6203

6204
        [XmlElement(Order = 19)]
6205
        public CT_DispUnits dispUnits
6206
        {
6207
            get
6208
            {
6209
                return this.dispUnitsField;
6210
            }
6211
            set
6212
            {
6213
                this.dispUnitsField = value;
6214
            }
6215
        }
6216

6217
        [XmlElement(Order = 20)]
6218
        public List<CT_Extension> extLst
6219
        {
6220
            get
6221
            {
6222
                return this.extLstField;
6223
            }
6224
            set
6225
            {
6226
                this.extLstField = value;
6227
            }
6228
        }
6229

6230
        public CT_Boolean AddNewDelete()
6231
        {
6232
            this.deleteField = new CT_Boolean();
6233
            return this.deleteField;
6234
        }
6235

6236
        public CT_TickMark AddNewMajorTickMark()
6237
        {
6238
            this.majorTickMarkField = new CT_TickMark();
6239
            return this.majorTickMarkField;
6240
        }
6241
        public CT_TickMark AddNewMinorTickMark()
6242
        {
6243
            this.minorTickMarkField = new CT_TickMark();
6244
            return this.minorTickMarkField;
6245
        }
6246
        public CT_ChartLines AddNewMajorGridlines()
6247
        {
6248
            this.majorGridlinesField = new CT_ChartLines();
6249
            return this.majorGridlinesField;
6250
        }
6251
        public CT_ChartLines AddNewMinorGridlines()
6252
        {
6253
            this.minorGridlinesField = new CT_ChartLines();
6254
            return this.minorGridlinesField;
6255
        }
6256
    }
6257

6258

6259

6260
    [Serializable]
6261

6262
    [System.ComponentModel.DesignerCategoryAttribute("code")]
6263
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6264
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
6265
    public class CT_SerTx
6266
    {
6267

6268
        CT_StrRef strRefField;
6269
        public CT_StrRef strRef
6270
        {
6271
            get { return this.strRefField; }
6272
            set { this.strRefField = value; }
6273
        }
6274

6275
        String vField;
6276
        public String v
6277
        {
6278
            get { return this.vField; }
6279
            set { this.vField = value; }
6280
        }
6281
        public static CT_SerTx Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6282
        {
6283
            if (node == null)
6284
                return null;
6285
            CT_SerTx ctObj = new CT_SerTx();
6286
            foreach (XmlNode childNode in node.ChildNodes)
6287
            {
6288
                if (childNode.LocalName == "strRef")
6289
                    ctObj.strRef = CT_StrRef.Parse(childNode, namespaceManager);
6290
                else if (childNode.LocalName == "v")
6291
                    ctObj.v = childNode.InnerText;
6292
            }
6293
            return ctObj;
6294
        }
6295

6296

6297

6298
        internal void Write(StreamWriter sw, string nodeName)
6299
        {
6300
            sw.Write(string.Format("<c:{0}", nodeName));
6301
            sw.Write(">");
6302
            if (this.strRef != null)
6303
                this.strRef.Write(sw, "strRef");
6304
            if (this.v != null)
6305
                sw.Write(string.Format("<c:v>{0}</c:v>", XmlHelper.EncodeXml(this.v)));
6306
            sw.Write(string.Format("</c:{0}>", nodeName));
6307
        }
6308

6309

6310
        public CT_StrRef AddNewStrRef()
6311
        {
6312
            this.strRefField = new CT_StrRef();
6313
            return this.strRefField;
6314
        }
6315
    }
6316

6317

6318
    [Serializable]
6319

6320
    [System.ComponentModel.DesignerCategoryAttribute("code")]
6321
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6322
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
6323
    public class CT_DPt
6324
    {
6325

6326
        private CT_UnsignedInt idxField;
6327

6328
        private CT_Boolean invertIfNegativeField;
6329

6330
        private CT_Marker markerField;
6331

6332
        private CT_Boolean bubble3DField;
6333

6334
        private CT_UnsignedInt explosionField;
6335

6336
        private CT_ShapeProperties spPrField;
6337

6338
        private CT_PictureOptions pictureOptionsField;
6339

6340
        private List<CT_Extension> extLstField;
6341
        public static CT_DPt Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6342
        {
6343
            if (node == null)
6344
                return null;
6345
            CT_DPt ctObj = new CT_DPt();
6346
            ctObj.extLst = new List<CT_Extension>();
6347
            foreach (XmlNode childNode in node.ChildNodes)
6348
            {
6349
                if (childNode.LocalName == "idx")
6350
                    ctObj.idx = CT_UnsignedInt.Parse(childNode, namespaceManager);
6351
                else if (childNode.LocalName == "invertIfNegative")
6352
                    ctObj.invertIfNegative = CT_Boolean.Parse(childNode, namespaceManager);
6353
                else if (childNode.LocalName == "marker")
6354
                    ctObj.marker = CT_Marker.Parse(childNode, namespaceManager);
6355
                else if (childNode.LocalName == "bubble3D")
6356
                    ctObj.bubble3D = CT_Boolean.Parse(childNode, namespaceManager);
6357
                else if (childNode.LocalName == "explosion")
6358
                    ctObj.explosion = CT_UnsignedInt.Parse(childNode, namespaceManager);
6359
                else if (childNode.LocalName == "spPr")
6360
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
6361
                else if (childNode.LocalName == "pictureOptions")
6362
                    ctObj.pictureOptions = CT_PictureOptions.Parse(childNode, namespaceManager);
6363
                else if (childNode.LocalName == "extLst")
6364
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
6365
            }
6366
            return ctObj;
6367
        }
6368

6369

6370

6371
        internal void Write(StreamWriter sw, string nodeName)
6372
        {
6373
            sw.Write(string.Format("<c:{0}", nodeName));
6374
            sw.Write(">");
6375
            if (this.idx != null)
6376
                this.idx.Write(sw, "idx");
6377
            if (this.invertIfNegative != null)
6378
                this.invertIfNegative.Write(sw, "invertIfNegative");
6379
            if (this.marker != null)
6380
                this.marker.Write(sw, "marker");
6381
            if (this.bubble3D != null)
6382
                this.bubble3D.Write(sw, "bubble3D");
6383
            if (this.explosion != null)
6384
                this.explosion.Write(sw, "explosion");
6385
            if (this.spPr != null)
6386
                this.spPr.Write(sw, "spPr");
6387
            if (this.pictureOptions != null)
6388
                this.pictureOptions.Write(sw, "pictureOptions");
6389
            if (this.extLst != null)
6390
            {
6391
                foreach (CT_Extension x in this.extLst)
6392
                {
6393
                    x.Write(sw, "extLst");
6394
                }
6395
            }
6396
            sw.Write(string.Format("</c:{0}>", nodeName));
6397
        }
6398

6399
        public CT_DPt()
6400
        {
6401
            //this.extLstField = new List<CT_Extension>();
6402
            //this.pictureOptionsField = new CT_PictureOptions();
6403
            //this.explosionField = new CT_UnsignedInt();
6404
            //this.bubble3DField = new CT_Boolean();
6405
            //this.markerField = new CT_Marker();
6406
            //this.invertIfNegativeField = new CT_Boolean();
6407
            //this.idxField = new CT_UnsignedInt();
6408
        }
6409

6410
        [XmlElement(Order = 0)]
6411
        public CT_UnsignedInt idx
6412
        {
6413
            get
6414
            {
6415
                return this.idxField;
6416
            }
6417
            set
6418
            {
6419
                this.idxField = value;
6420
            }
6421
        }
6422

6423
        [XmlElement(Order = 1)]
6424
        public CT_Boolean invertIfNegative
6425
        {
6426
            get
6427
            {
6428
                return this.invertIfNegativeField;
6429
            }
6430
            set
6431
            {
6432
                this.invertIfNegativeField = value;
6433
            }
6434
        }
6435

6436
        [XmlElement(Order = 2)]
6437
        public CT_Marker marker
6438
        {
6439
            get
6440
            {
6441
                return this.markerField;
6442
            }
6443
            set
6444
            {
6445
                this.markerField = value;
6446
            }
6447
        }
6448

6449
        [XmlElement(Order = 3)]
6450
        public CT_Boolean bubble3D
6451
        {
6452
            get
6453
            {
6454
                return this.bubble3DField;
6455
            }
6456
            set
6457
            {
6458
                this.bubble3DField = value;
6459
            }
6460
        }
6461

6462
        [XmlElement(Order = 4)]
6463
        public CT_UnsignedInt explosion
6464
        {
6465
            get
6466
            {
6467
                return this.explosionField;
6468
            }
6469
            set
6470
            {
6471
                this.explosionField = value;
6472
            }
6473
        }
6474

6475
        [XmlElement(Order = 5)]
6476
        public CT_ShapeProperties spPr
6477
        {
6478
            get
6479
            {
6480
                return this.spPrField;
6481
            }
6482
            set
6483
            {
6484
                this.spPrField = value;
6485
            }
6486
        }
6487

6488
        [XmlElement(Order = 6)]
6489
        public CT_PictureOptions pictureOptions
6490
        {
6491
            get
6492
            {
6493
                return this.pictureOptionsField;
6494
            }
6495
            set
6496
            {
6497
                this.pictureOptionsField = value;
6498
            }
6499
        }
6500

6501
        [XmlElement(Order = 7)]
6502
        public List<CT_Extension> extLst
6503
        {
6504
            get
6505
            {
6506
                return this.extLstField;
6507
            }
6508
            set
6509
            {
6510
                this.extLstField = value;
6511
            }
6512
        }
6513
    }
6514

6515

6516
    [Serializable]
6517

6518
    [System.ComponentModel.DesignerCategoryAttribute("code")]
6519
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6520
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
6521
    public class CT_Marker
6522
    {
6523

6524
        private CT_MarkerStyle symbolField;
6525

6526
        private CT_MarkerSize sizeField;
6527

6528
        private CT_ShapeProperties spPrField;
6529

6530
        private List<CT_Extension> extLstField;
6531

6532
        public CT_Marker()
6533
        {
6534
            //this.extLstField = new List<CT_Extension>();
6535
            //this.sizeField = new CT_MarkerSize();
6536
            //this.symbolField = new CT_MarkerStyle();
6537
        }
6538
        public static CT_Marker Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6539
        {
6540
            if (node == null)
6541
                return null;
6542
            CT_Marker ctObj = new CT_Marker();
6543
            ctObj.extLst = new List<CT_Extension>();
6544
            foreach (XmlNode childNode in node.ChildNodes)
6545
            {
6546
                if (childNode.LocalName == "symbol")
6547
                    ctObj.symbol = CT_MarkerStyle.Parse(childNode, namespaceManager);
6548
                else if (childNode.LocalName == "size")
6549
                    ctObj.size = CT_MarkerSize.Parse(childNode, namespaceManager);
6550
                else if (childNode.LocalName == "spPr")
6551
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
6552
                else if (childNode.LocalName == "extLst")
6553
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
6554
            }
6555
            return ctObj;
6556
        }
6557

6558

6559

6560
        internal void Write(StreamWriter sw, string nodeName)
6561
        {
6562
            sw.Write(string.Format("<c:{0}", nodeName));
6563
            sw.Write(">");
6564
            if (this.symbol != null)
6565
                this.symbol.Write(sw, "symbol");
6566
            if (this.size != null)
6567
                this.size.Write(sw, "size");
6568
            if (this.spPr != null)
6569
                this.spPr.Write(sw, "spPr");
6570
            if (this.extLst != null)
6571
            {
6572
                foreach (CT_Extension x in this.extLst)
6573
                {
6574
                    x.Write(sw, "extLst");
6575
                }
6576
            }
6577
            sw.Write(string.Format("</c:{0}>", nodeName));
6578
        }
6579

6580
        [XmlElement(Order = 0)]
6581
        public CT_MarkerStyle symbol
6582
        {
6583
            get
6584
            {
6585
                return this.symbolField;
6586
            }
6587
            set
6588
            {
6589
                this.symbolField = value;
6590
            }
6591
        }
6592

6593
        [XmlElement(Order = 1)]
6594
        public CT_MarkerSize size
6595
        {
6596
            get
6597
            {
6598
                return this.sizeField;
6599
            }
6600
            set
6601
            {
6602
                this.sizeField = value;
6603
            }
6604
        }
6605

6606
        [XmlElement(Order = 2)]
6607
        public CT_ShapeProperties spPr
6608
        {
6609
            get
6610
            {
6611
                return this.spPrField;
6612
            }
6613
            set
6614
            {
6615
                this.spPrField = value;
6616
            }
6617
        }
6618

6619
        [XmlElement(Order = 3)]
6620
        public List<CT_Extension> extLst
6621
        {
6622
            get
6623
            {
6624
                return this.extLstField;
6625
            }
6626
            set
6627
            {
6628
                this.extLstField = value;
6629
            }
6630
        }
6631

6632
        public CT_MarkerStyle AddNewSymbol()
6633
        {
6634
            this.symbolField = new CT_MarkerStyle();
6635
            return this.symbolField;
6636
        }
6637
    }
6638

6639

6640
    [Serializable]
6641

6642
    [System.ComponentModel.DesignerCategoryAttribute("code")]
6643
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6644
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
6645
    public class CT_MarkerStyle
6646
    {
6647

6648
        private ST_MarkerStyle valField;
6649

6650
        [XmlAttribute]
6651
        public ST_MarkerStyle val
6652
        {
6653
            get
6654
            {
6655
                return this.valField;
6656
            }
6657
            set
6658
            {
6659
                this.valField = value;
6660
            }
6661
        }
6662
        public static CT_MarkerStyle Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6663
        {
6664
            if (node == null)
6665
                return null;
6666
            CT_MarkerStyle ctObj = new CT_MarkerStyle();
6667
            if (node.Attributes["val"] != null)
6668
                ctObj.val = (ST_MarkerStyle)Enum.Parse(typeof(ST_MarkerStyle), node.Attributes["val"].Value);
6669
            return ctObj;
6670
        }
6671

6672

6673

6674
        internal void Write(StreamWriter sw, string nodeName)
6675
        {
6676
            sw.Write(string.Format("<c:{0}", nodeName));
6677
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
6678
            sw.Write("/>");
6679
        }
6680

6681
    }
6682

6683

6684
    [Serializable]
6685
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6686
    public enum ST_MarkerStyle
6687
    {
6688

6689
        /// <remarks/>
6690
        circle,
6691

6692
        /// <remarks/>
6693
        dash,
6694

6695
        /// <remarks/>
6696
        diamond,
6697

6698
        /// <remarks/>
6699
        dot,
6700

6701
        /// <remarks/>
6702
        none,
6703

6704
        /// <remarks/>
6705
        picture,
6706

6707
        /// <remarks/>
6708
        plus,
6709

6710
        /// <remarks/>
6711
        square,
6712

6713
        /// <remarks/>
6714
        star,
6715

6716
        /// <remarks/>
6717
        triangle,
6718

6719
        /// <remarks/>
6720
        x,
6721

6722
        auto
6723
    }
6724

6725

6726
    [Serializable]
6727

6728
    [System.ComponentModel.DesignerCategoryAttribute("code")]
6729
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6730
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
6731
    public class CT_MarkerSize
6732
    {
6733

6734
        private byte valField;
6735

6736
        public CT_MarkerSize()
6737
        {
6738
            this.valField = ((byte)(5));
6739
        }
6740

6741
        [XmlAttribute]
6742
        [DefaultValue(typeof(byte), "5")]
6743
        public byte val
6744
        {
6745
            get
6746
            {
6747
                return this.valField;
6748
            }
6749
            set
6750
            {
6751
                this.valField = value;
6752
            }
6753
        }
6754
        public static CT_MarkerSize Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6755
        {
6756
            if (node == null)
6757
                return null;
6758
            CT_MarkerSize ctObj = new CT_MarkerSize();
6759
            ctObj.val = XmlHelper.ReadByte(node.Attributes["val"]);
6760
            return ctObj;
6761
        }
6762

6763

6764

6765
        internal void Write(StreamWriter sw, string nodeName)
6766
        {
6767
            sw.Write(string.Format("<c:{0}", nodeName));
6768
            XmlHelper.WriteAttribute(sw, "val", this.val);
6769
            sw.Write("/>");
6770
        }
6771

6772

6773
    }
6774

6775

6776
    [Serializable]
6777

6778
    [System.ComponentModel.DesignerCategoryAttribute("code")]
6779
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6780
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
6781
    public class CT_PictureOptions
6782
    {
6783

6784
        private CT_Boolean applyToFrontField;
6785

6786
        private CT_Boolean applyToSidesField;
6787

6788
        private CT_Boolean applyToEndField;
6789

6790
        private CT_PictureFormat pictureFormatField;
6791

6792
        private CT_PictureStackUnit pictureStackUnitField;
6793

6794
        public CT_PictureOptions()
6795
        {
6796

6797
        }
6798
        public static CT_PictureOptions Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6799
        {
6800
            if (node == null)
6801
                return null;
6802
            CT_PictureOptions ctObj = new CT_PictureOptions();
6803
            foreach (XmlNode childNode in node.ChildNodes)
6804
            {
6805
                if (childNode.LocalName == "applyToFront")
6806
                    ctObj.applyToFront = CT_Boolean.Parse(childNode, namespaceManager);
6807
                else if (childNode.LocalName == "applyToSides")
6808
                    ctObj.applyToSides = CT_Boolean.Parse(childNode, namespaceManager);
6809
                else if (childNode.LocalName == "applyToEnd")
6810
                    ctObj.applyToEnd = CT_Boolean.Parse(childNode, namespaceManager);
6811
                else if (childNode.LocalName == "pictureFormat")
6812
                    ctObj.pictureFormat = CT_PictureFormat.Parse(childNode, namespaceManager);
6813
                else if (childNode.LocalName == "pictureStackUnit")
6814
                    ctObj.pictureStackUnit = CT_PictureStackUnit.Parse(childNode, namespaceManager);
6815
            }
6816
            return ctObj;
6817
        }
6818

6819

6820

6821
        internal void Write(StreamWriter sw, string nodeName)
6822
        {
6823
            sw.Write(string.Format("<c:{0}", nodeName));
6824
            sw.Write(">");
6825
            if (this.applyToFront != null)
6826
                this.applyToFront.Write(sw, "applyToFront");
6827
            if (this.applyToSides != null)
6828
                this.applyToSides.Write(sw, "applyToSides");
6829
            if (this.applyToEnd != null)
6830
                this.applyToEnd.Write(sw, "applyToEnd");
6831
            if (this.pictureFormat != null)
6832
                this.pictureFormat.Write(sw, "pictureFormat");
6833
            if (this.pictureStackUnit != null)
6834
                this.pictureStackUnit.Write(sw, "pictureStackUnit");
6835
            sw.Write(string.Format("</c:{0}>", nodeName));
6836
        }
6837

6838
        [XmlElement(Order = 0)]
6839
        public CT_Boolean applyToFront
6840
        {
6841
            get
6842
            {
6843
                return this.applyToFrontField;
6844
            }
6845
            set
6846
            {
6847
                this.applyToFrontField = value;
6848
            }
6849
        }
6850

6851
        [XmlElement(Order = 1)]
6852
        public CT_Boolean applyToSides
6853
        {
6854
            get
6855
            {
6856
                return this.applyToSidesField;
6857
            }
6858
            set
6859
            {
6860
                this.applyToSidesField = value;
6861
            }
6862
        }
6863

6864
        [XmlElement(Order = 2)]
6865
        public CT_Boolean applyToEnd
6866
        {
6867
            get
6868
            {
6869
                return this.applyToEndField;
6870
            }
6871
            set
6872
            {
6873
                this.applyToEndField = value;
6874
            }
6875
        }
6876

6877
        [XmlElement(Order = 3)]
6878
        public CT_PictureFormat pictureFormat
6879
        {
6880
            get
6881
            {
6882
                return this.pictureFormatField;
6883
            }
6884
            set
6885
            {
6886
                this.pictureFormatField = value;
6887
            }
6888
        }
6889

6890
        [XmlElement(Order = 4)]
6891
        public CT_PictureStackUnit pictureStackUnit
6892
        {
6893
            get
6894
            {
6895
                return this.pictureStackUnitField;
6896
            }
6897
            set
6898
            {
6899
                this.pictureStackUnitField = value;
6900
            }
6901
        }
6902
    }
6903

6904

6905
    [Serializable]
6906

6907
    [System.ComponentModel.DesignerCategoryAttribute("code")]
6908
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6909
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
6910
    public class CT_PictureFormat
6911
    {
6912
        public static CT_PictureFormat Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6913
        {
6914
            if (node == null)
6915
                return null;
6916
            CT_PictureFormat ctObj = new CT_PictureFormat();
6917
            if (node.Attributes["val"] != null)
6918
                ctObj.val = (ST_PictureFormat)Enum.Parse(typeof(ST_PictureFormat), node.Attributes["val"].Value);
6919
            return ctObj;
6920
        }
6921

6922

6923

6924
        internal void Write(StreamWriter sw, string nodeName)
6925
        {
6926
            sw.Write(string.Format("<c:{0}", nodeName));
6927
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
6928
            sw.Write("/>");
6929
        }
6930

6931
        private ST_PictureFormat valField;
6932

6933
        [XmlAttribute]
6934
        public ST_PictureFormat val
6935
        {
6936
            get
6937
            {
6938
                return this.valField;
6939
            }
6940
            set
6941
            {
6942
                this.valField = value;
6943
            }
6944
        }
6945
    }
6946

6947

6948
    [Serializable]
6949
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6950
    public enum ST_PictureFormat
6951
    {
6952

6953
        /// <remarks/>
6954
        stretch,
6955

6956
        /// <remarks/>
6957
        stack,
6958

6959
        /// <remarks/>
6960
        stackScale,
6961
    }
6962

6963

6964
    [Serializable]
6965

6966
    [System.ComponentModel.DesignerCategoryAttribute("code")]
6967
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
6968
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
6969
    public class CT_PictureStackUnit
6970
    {
6971
        public static CT_PictureStackUnit Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6972
        {
6973
            if (node == null)
6974
                return null;
6975
            CT_PictureStackUnit ctObj = new CT_PictureStackUnit();
6976
            ctObj.val = XmlHelper.ReadDouble(node.Attributes["val"]);
6977
            return ctObj;
6978
        }
6979

6980

6981

6982
        internal void Write(StreamWriter sw, string nodeName)
6983
        {
6984
            sw.Write(string.Format("<c:{0}", nodeName));
6985
            XmlHelper.WriteAttribute(sw, "val", this.val);
6986
            sw.Write("/>");
6987
        }
6988

6989
        private double valField;
6990

6991
        [XmlAttribute]
6992
        public double val
6993
        {
6994
            get
6995
            {
6996
                return this.valField;
6997
            }
6998
            set
6999
            {
7000
                this.valField = value;
7001
            }
7002
        }
7003
    }
7004

7005

7006
    [Serializable]
7007

7008
    [System.ComponentModel.DesignerCategoryAttribute("code")]
7009
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
7010
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
7011
    public class CT_DLbls
7012
    {
7013

7014
        private List<CT_DLbl> dLblField;
7015

7016
        private string separatorField;
7017
        private CT_NumFmt numFmtField;
7018
        private CT_Boolean showBubbleSizeField;
7019
        private CT_Boolean showCatNameField;
7020
        private CT_Boolean showLeaderLinesField;
7021
        private CT_Boolean showLegendKeyField;
7022
        private CT_Boolean showPercentField;
7023
        private CT_Boolean showSerNameField;
7024
        private CT_Boolean showValField;
7025
        private CT_Boolean deleteField;
7026
        private CT_DLblPos dLblPosField;
7027

7028
        private List<CT_Extension> extLstField;
7029

7030
        public CT_DLbls()
7031
        {
7032
            //this.dLblField = new List<CT_DLbl>();
7033
        }
7034
        public static CT_DLbls Parse(XmlNode node, XmlNamespaceManager namespaceManager)
7035
        {
7036
            if (node == null)
7037
                return null;
7038
            CT_DLbls ctObj = new CT_DLbls();
7039
            ctObj.dLbl = new List<CT_DLbl>();
7040
            ctObj.extLst = new List<CT_Extension>();
7041
            foreach (XmlNode childNode in node.ChildNodes)
7042
            {
7043
                if (childNode.LocalName == "dLblPos")
7044
                    ctObj.dLblPos = CT_DLblPos.Parse(childNode, namespaceManager);
7045
                else if (childNode.LocalName == "numFmt")
7046
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
7047
                else if (childNode.LocalName == "spPr")
7048
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
7049
                else if (childNode.LocalName == "txPr")
7050
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
7051
                else if (childNode.LocalName == "showBubbleSize")
7052
                    ctObj.showBubbleSize = CT_Boolean.Parse(childNode, namespaceManager);
7053
                else if (childNode.LocalName == "showCatName")
7054
                    ctObj.showCatName = CT_Boolean.Parse(childNode, namespaceManager);
7055
                else if (childNode.LocalName == "showLegendKey")
7056
                    ctObj.showLegendKey = CT_Boolean.Parse(childNode, namespaceManager);
7057
                else if (childNode.LocalName == "showPercent")
7058
                    ctObj.showPercent = CT_Boolean.Parse(childNode, namespaceManager);
7059
                else if (childNode.LocalName == "showSerName")
7060
                    ctObj.showSerName = CT_Boolean.Parse(childNode, namespaceManager);
7061
                else if (childNode.LocalName == "showVal")
7062
                    ctObj.showVal = CT_Boolean.Parse(childNode, namespaceManager);
7063
                else if (childNode.LocalName == "delete")
7064
                    ctObj.delete = CT_Boolean.Parse(childNode, namespaceManager);
7065
                else if (childNode.LocalName == "separator")
7066
                    ctObj.separator = childNode.InnerText;
7067
                else if (childNode.LocalName == "showLeaderLines")
7068
                    ctObj.showLeaderLines = CT_Boolean.Parse(childNode, namespaceManager);
7069
                else if (childNode.LocalName == "dLbl")
7070
                    ctObj.dLbl.Add(CT_DLbl.Parse(childNode, namespaceManager));
7071
                else if (childNode.LocalName == "extLst")
7072
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
7073
            }
7074
            return ctObj;
7075
        }
7076

7077

7078

7079
        internal void Write(StreamWriter sw, string nodeName)
7080
        {
7081
            //if (this.dLbl.Count == 0 || this.extLst.Count == 0)
7082
            //    return;
7083
            sw.Write(string.Format("<c:{0}", nodeName));
7084
            sw.Write(">");
7085

7086
            if (this.numFmt != null)
7087
                this.numFmt.Write(sw, "numFmt");
7088
            if (this.spPr != null)
7089
                this.spPr.Write(sw, "spPr");
7090
            if (this.txPr != null)
7091
                this.txPr.Write(sw, "txPr");
7092
            if (this.showLegendKey != null)
7093
                this.showLegendKey.Write(sw, "showLegendKey");
7094
            if (this.showVal != null)
7095
                this.showVal.Write(sw, "showVal");
7096
            if (this.showCatName != null)
7097
                this.showCatName.Write(sw, "showCatName");
7098
            if (this.showSerName != null)
7099
                this.showSerName.Write(sw, "showSerName");
7100
            if (this.showPercent != null)
7101
                this.showPercent.Write(sw, "showPercent");
7102
            if (this.showBubbleSize != null)
7103
                this.showBubbleSize.Write(sw, "showBubbleSize");
7104
            if (this.delete != null)
7105
                this.delete.Write(sw, "delete");
7106
            if (this.separator != null)
7107
                sw.Write(string.Format("<separator>{0}</separator>", this.separator));
7108
            if (this.showLeaderLines != null)
7109
                this.showLeaderLines.Write(sw, "showLeaderLines");
7110
            if (this.dLbl != null)
7111
            {
7112
                foreach (CT_DLbl x in this.dLbl)
7113
                {
7114
                    x.Write(sw, "dLbl");
7115
                }
7116
            }
7117
            if (this.dLblPos != null)
7118
                this.dLblPos.Write(sw, "dLblPos");
7119
            if (this.extLst != null)
7120
            {
7121
                foreach (CT_Extension x in this.extLst)
7122
                {
7123
                    x.Write(sw, "extLst");
7124
                }
7125
            }
7126
            sw.Write(string.Format("</c:{0}>", nodeName));
7127
        }
7128

7129
        [XmlElement("dLbl", Order = 0)]
7130
        public List<CT_DLbl> dLbl
7131
        {
7132
            get
7133
            {
7134
                return this.dLblField;
7135
            }
7136
            set
7137
            {
7138
                this.dLblField = value;
7139
            }
7140
        }
7141
        [XmlElement(Order = 1)]
7142
        public CT_DLblPos dLblPos
7143
        {
7144
            get
7145
            {
7146
                return this.dLblPosField;
7147
            }
7148
            set
7149
            {
7150
                this.dLblPosField = value;
7151
            }
7152
        }
7153
        [XmlElement(Order = 2)]
7154
        public CT_NumFmt numFmt
7155
        {
7156
            get
7157
            {
7158
                return this.numFmtField;
7159
            }
7160
            set
7161
            {
7162
                this.numFmtField = value;
7163
            }
7164
        }
7165
        CT_ShapeProperties spPrField;
7166
        [XmlElement(Order = 4)]
7167
        public CT_ShapeProperties spPr
7168
        {
7169
            get
7170
            {
7171
                return this.spPrField;
7172
            }
7173
            set
7174
            {
7175
                this.spPrField = value;
7176
            }
7177
        }
7178
        CT_TextBody txPrField;
7179
        [XmlElement(Order = 5)]
7180
        public CT_TextBody txPr
7181
        {
7182
            get
7183
            {
7184
                return this.txPrField;
7185
            }
7186
            set
7187
            {
7188
                this.txPrField = value;
7189
            }
7190
        }
7191
        [XmlElement(Order = 8)]
7192
        public CT_Boolean showBubbleSize
7193
        {
7194
            get
7195
            {
7196
                return this.showBubbleSizeField;
7197
            }
7198
            set
7199
            {
7200
                this.showBubbleSizeField = value;
7201
            }
7202
        }
7203
        [XmlElement(Order = 9)]
7204
        public CT_Boolean showCatName
7205
        {
7206
            get
7207
            {
7208
                return this.showCatNameField;
7209
            }
7210
            set
7211
            {
7212
                this.showCatNameField = value;
7213
            }
7214
        }
7215

7216
        [XmlElement(Order = 11)]
7217
        public CT_Boolean showLegendKey
7218
        {
7219
            get
7220
            {
7221
                return this.showLegendKeyField;
7222
            }
7223
            set
7224
            {
7225
                this.showLegendKeyField = value;
7226
            }
7227
        }
7228
        [XmlElement(Order = 12)]
7229
        public CT_Boolean showPercent
7230
        {
7231
            get
7232
            {
7233
                return this.showPercentField;
7234
            }
7235
            set
7236
            {
7237
                this.showPercentField = value;
7238
            }
7239
        }
7240
        [XmlElement(Order = 13)]
7241
        public CT_Boolean showSerName
7242
        {
7243
            get
7244
            {
7245
                return this.showSerNameField;
7246
            }
7247
            set
7248
            {
7249
                this.showSerNameField = value;
7250
            }
7251
        }
7252
        [XmlElement(Order = 14)]
7253
        public CT_Boolean showVal
7254
        {
7255
            get
7256
            {
7257
                return this.showValField;
7258
            }
7259
            set
7260
            {
7261
                this.showValField = value;
7262
            }
7263
        }
7264
        [XmlElement(Order = 15)]
7265
        public CT_Boolean delete
7266
        {
7267
            get
7268
            {
7269
                return this.deleteField;
7270
            }
7271
            set
7272
            {
7273
                this.deleteField = value;
7274
            }
7275
        }
7276
        [XmlElement(Order = 16)]
7277
        public string separator
7278
        {
7279
            get
7280
            {
7281
                return this.separatorField;
7282
            }
7283
            set
7284
            {
7285
                this.separatorField = value;
7286
            }
7287
        }
7288

7289
        //[XmlElement("leaderLines", typeof(CT_ChartLines), Order = 1)]
7290
        [XmlElement(Order = 17)]
7291
        public CT_Boolean showLeaderLines
7292
        {
7293
            get
7294
            {
7295
                return this.showLeaderLinesField;
7296
            }
7297
            set
7298
            {
7299
                this.showLeaderLinesField = value;
7300
            }
7301
        }
7302

7303
        [XmlElement(Order = 18)]
7304
        public List<CT_Extension> extLst
7305
        {
7306
            get
7307
            {
7308
                return this.extLstField;
7309
            }
7310
            set
7311
            {
7312
                this.extLstField = value;
7313
            }
7314
        }
7315
    }
7316

7317

7318
    [Serializable]
7319

7320
    [System.ComponentModel.DesignerCategoryAttribute("code")]
7321
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
7322
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
7323
    public class CT_DLbl
7324
    {
7325

7326
        private CT_UnsignedInt idxField;
7327
        private string separatorField;
7328
        private CT_NumFmt numFmtField;
7329
        private CT_Boolean showBubbleSizeField;
7330
        private CT_Boolean showCatNameField;
7331
        private CT_Boolean showLegendKeyField;
7332
        private CT_Boolean showPercentField;
7333
        private CT_Boolean showSerNameField;
7334
        private CT_Boolean showValField;
7335
        private CT_Boolean deleteField;
7336
        private CT_DLblPos dLblPosField;
7337
        private CT_Layout layoutField;
7338
        private List<CT_Extension> extLstField;
7339

7340
        public CT_DLbl()
7341
        {
7342
            //this.idxField = new CT_UnsignedInt();
7343
        }
7344
        public static CT_DLbl Parse(XmlNode node, XmlNamespaceManager namespaceManager)
7345
        {
7346
            if (node == null)
7347
                return null;
7348
            CT_DLbl ctObj = new CT_DLbl();
7349
            ctObj.extLst = new List<CT_Extension>();
7350
            foreach (XmlNode childNode in node.ChildNodes)
7351
            {
7352
                if (childNode.LocalName == "idx")
7353
                    ctObj.idx = CT_UnsignedInt.Parse(childNode, namespaceManager);
7354
                else if (childNode.LocalName == "layout")
7355
                    ctObj.layout = CT_Layout.Parse(childNode, namespaceManager);
7356
                else if (childNode.LocalName == "dLblPos")
7357
                    ctObj.dLblPos = CT_DLblPos.Parse(childNode, namespaceManager);
7358
                else if (childNode.LocalName == "numFmt")
7359
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
7360
                else if (childNode.LocalName == "spPr")
7361
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
7362
                else if (childNode.LocalName == "txPr")
7363
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
7364
                else if (childNode.LocalName == "delete")
7365
                    ctObj.delete = CT_Boolean.Parse(childNode, namespaceManager);
7366
                else if (childNode.LocalName == "showBubbleSize")
7367
                    ctObj.showBubbleSize = CT_Boolean.Parse(childNode, namespaceManager);
7368
                else if (childNode.LocalName == "showCatName")
7369
                    ctObj.showCatName = CT_Boolean.Parse(childNode, namespaceManager);
7370
                else if (childNode.LocalName == "showLegendKey")
7371
                    ctObj.showLegendKey = CT_Boolean.Parse(childNode, namespaceManager);
7372
                else if (childNode.LocalName == "showPercent")
7373
                    ctObj.showPercent = CT_Boolean.Parse(childNode, namespaceManager);
7374
                else if (childNode.LocalName == "showSerName")
7375
                    ctObj.showSerName = CT_Boolean.Parse(childNode, namespaceManager);
7376
                else if (childNode.LocalName == "showVal")
7377
                    ctObj.showVal = CT_Boolean.Parse(childNode, namespaceManager);
7378
                else if (childNode.LocalName == "separator")
7379
                    ctObj.separator = childNode.InnerText;
7380
                else if (childNode.LocalName == "extLst")
7381
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
7382
            }
7383
            return ctObj;
7384
        }
7385

7386

7387

7388
        internal void Write(StreamWriter sw, string nodeName)
7389
        {
7390
            sw.Write(string.Format("<c:{0}", nodeName));
7391
            sw.Write(">");
7392
            if (this.idx != null)
7393
                this.idx.Write(sw, "idx");
7394
            if (this.layout != null)
7395
                this.layout.Write(sw, "layout");
7396
            if (this.dLblPos != null)
7397
                this.dLblPos.Write(sw, "dLblPos");
7398
            if (this.numFmt != null)
7399
                this.numFmt.Write(sw, "numFmt");
7400
            if (this.spPr != null)
7401
                this.spPr.Write(sw, "spPr");
7402
            if (this.txPr != null)
7403
                this.txPr.Write(sw, "txPr");
7404
            if (this.delete != null)
7405
                this.delete.Write(sw, "delete");
7406
            if (this.showBubbleSize != null)
7407
                this.showBubbleSize.Write(sw, "showBubbleSize");
7408
            if (this.showCatName != null)
7409
                this.showCatName.Write(sw, "showCatName");
7410
            if (this.showLegendKey != null)
7411
                this.showLegendKey.Write(sw, "showLegendKey");
7412
            if (this.showPercent != null)
7413
                this.showPercent.Write(sw, "showPercent");
7414
            if (this.showSerName != null)
7415
                this.showSerName.Write(sw, "showSerName");
7416
            if (this.showVal != null)
7417
                this.showVal.Write(sw, "showVal");
7418
            if (this.separator != null)
7419
                sw.Write(string.Format("<separator>{0}</separator>", this.separator));
7420
            if (this.extLst != null)
7421
            {
7422
                foreach (CT_Extension x in this.extLst)
7423
                {
7424
                    x.Write(sw, "extLst");
7425
                }
7426
            }
7427
            sw.Write(string.Format("</c:{0}>", nodeName));
7428
        }
7429

7430
        [XmlElement(Order = 0)]
7431
        public CT_UnsignedInt idx
7432
        {
7433
            get
7434
            {
7435
                return this.idxField;
7436
            }
7437
            set
7438
            {
7439
                this.idxField = value;
7440
            }
7441
        }
7442
        [XmlElement(Order = 1)]
7443
        public CT_Layout layout
7444
        {
7445
            get
7446
            {
7447
                return this.layoutField;
7448
            }
7449
            set
7450
            {
7451
                this.layoutField = value;
7452
            }
7453
        }
7454
        [XmlElement(Order = 2)]
7455
        public CT_DLblPos dLblPos
7456
        {
7457
            get
7458
            {
7459
                return this.dLblPosField;
7460
            }
7461
            set
7462
            {
7463
                this.dLblPosField = value;
7464
            }
7465
        }
7466
        [XmlElement(Order = 3)]
7467
        public CT_NumFmt numFmt
7468
        {
7469
            get
7470
            {
7471
                return this.numFmtField;
7472
            }
7473
            set
7474
            {
7475
                this.numFmtField = value;
7476
            }
7477
        }
7478

7479
        CT_ShapeProperties spPrField;
7480
        [XmlElement(Order = 4)]
7481
        public CT_ShapeProperties spPr
7482
        {
7483
            get
7484
            {
7485
                return this.spPrField;
7486
            }
7487
            set
7488
            {
7489
                this.spPrField = value;
7490
            }
7491
        }
7492
        CT_TextBody txPrField;
7493
        [XmlElement(Order = 5)]
7494
        public CT_TextBody txPr
7495
        {
7496
            get
7497
            {
7498
                return this.txPrField;
7499
            }
7500
            set
7501
            {
7502
                this.txPrField = value;
7503
            }
7504
        }
7505

7506
        [XmlElement(Order = 8)]
7507
        public CT_Boolean delete
7508
        {
7509
            get
7510
            {
7511
                return this.deleteField;
7512
            }
7513
            set
7514
            {
7515
                this.deleteField = value;
7516
            }
7517
        }
7518
        [XmlElement(Order = 9)]
7519
        public CT_Boolean showBubbleSize
7520
        {
7521
            get
7522
            {
7523
                return this.showBubbleSizeField;
7524
            }
7525
            set
7526
            {
7527
                this.showBubbleSizeField = value;
7528
            }
7529
        }
7530
        [XmlElement(Order = 10)]
7531
        public CT_Boolean showCatName
7532
        {
7533
            get
7534
            {
7535
                return this.showCatNameField;
7536
            }
7537
            set
7538
            {
7539
                this.showCatNameField = value;
7540
            }
7541
        }
7542
        [XmlElement(Order =11)]
7543
        public CT_Boolean showLegendKey
7544
        {
7545
            get
7546
            {
7547
                return this.showLegendKeyField;
7548
            }
7549
            set
7550
            {
7551
                this.showLegendKeyField = value;
7552
            }
7553
        }
7554
        [XmlElement(Order = 12)]
7555
        public CT_Boolean showPercent
7556
        {
7557
            get
7558
            {
7559
                return this.showPercentField;
7560
            }
7561
            set
7562
            {
7563
                this.showPercentField = value;
7564
            }
7565
        }
7566
        [XmlElement(Order = 13)]
7567
        public CT_Boolean showSerName
7568
        {
7569
            get
7570
            {
7571
                return this.showSerNameField;
7572
            }
7573
            set
7574
            {
7575
                this.showSerNameField = value;
7576
            }
7577
        }
7578
        [XmlElement(Order = 14)]
7579
        public CT_Boolean showVal
7580
        {
7581
            get
7582
            {
7583
                return this.showValField;
7584
            }
7585
            set
7586
            {
7587
                this.showValField = value;
7588
            }
7589
        }
7590
        [XmlElement(Order = 15)]
7591
        public string separator
7592
        {
7593
            get
7594
            {
7595
                return this.separatorField;
7596
            }
7597
            set
7598
            {
7599
                this.separatorField = value;
7600
            }
7601
        }
7602

7603

7604
        //[XmlElement("tx", typeof(CT_Tx), Order = 1)]
7605

7606
        [XmlElement(Order = 18)]
7607
        public List<CT_Extension> extLst
7608
        {
7609
            get
7610
            {
7611
                return this.extLstField;
7612
            }
7613
            set
7614
            {
7615
                this.extLstField = value;
7616
            }
7617
        }
7618
    }
7619

7620

7621
    [Serializable]
7622

7623
    [System.ComponentModel.DesignerCategoryAttribute("code")]
7624
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
7625
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
7626
    public class CT_DLblPos
7627
    {
7628

7629
        private ST_DLblPos valField;
7630

7631
        [XmlAttribute]
7632
        public ST_DLblPos val
7633
        {
7634
            get
7635
            {
7636
                return this.valField;
7637
            }
7638
            set
7639
            {
7640
                this.valField = value;
7641
            }
7642
        }
7643
        public static CT_DLblPos Parse(XmlNode node, XmlNamespaceManager namespaceManager)
7644
        {
7645
            if (node == null)
7646
                return null;
7647
            CT_DLblPos ctObj = new CT_DLblPos();
7648
            if (node.Attributes["val"] != null)
7649
                ctObj.val = (ST_DLblPos)Enum.Parse(typeof(ST_DLblPos), node.Attributes["val"].Value);
7650
            return ctObj;
7651
        }
7652

7653

7654

7655
        internal void Write(StreamWriter sw, string nodeName)
7656
        {
7657
            sw.Write(string.Format("<c:{0}", nodeName));
7658
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
7659
            sw.Write("/>");
7660
        }
7661

7662
    }
7663

7664

7665
    [Serializable]
7666
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
7667
    public enum ST_DLblPos
7668
    {
7669

7670
        /// <remarks/>
7671
        bestFit,
7672

7673
        /// <remarks/>
7674
        b,
7675

7676
        /// <remarks/>
7677
        ctr,
7678

7679
        /// <remarks/>
7680
        inBase,
7681

7682
        /// <remarks/>
7683
        inEnd,
7684

7685
        /// <remarks/>
7686
        l,
7687

7688
        /// <remarks/>
7689
        outEnd,
7690

7691
        /// <remarks/>
7692
        r,
7693

7694
        /// <remarks/>
7695
        t,
7696
    }
7697

7698

7699

7700
    [Serializable]
7701

7702
    [System.ComponentModel.DesignerCategoryAttribute("code")]
7703
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
7704
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
7705
    public class CT_Trendline
7706
    {
7707

7708
        private string nameField;
7709

7710
        private CT_ShapeProperties spPrField;
7711

7712
        private CT_TrendlineType trendlineTypeField;
7713

7714
        private CT_Order orderField;
7715

7716
        private CT_Period periodField;
7717

7718
        private CT_Double forwardField;
7719

7720
        private CT_Double backwardField;
7721

7722
        private CT_Double interceptField;
7723

7724
        private CT_Boolean dispRSqrField;
7725

7726
        private CT_Boolean dispEqField;
7727

7728
        private CT_TrendlineLbl trendlineLblField;
7729

7730
        private List<CT_Extension> extLstField;
7731

7732
        public CT_Trendline()
7733
        {
7734

7735
        }
7736
        public static CT_Trendline Parse(XmlNode node, XmlNamespaceManager namespaceManager)
7737
        {
7738
            if (node == null)
7739
                return null;
7740
            CT_Trendline ctObj = new CT_Trendline();
7741
            ctObj.extLst = new List<CT_Extension>();
7742
            foreach (XmlNode childNode in node.ChildNodes)
7743
            {
7744
                if (childNode.LocalName == "name")
7745
                    ctObj.name = childNode.InnerText;
7746
                else if (childNode.LocalName == "spPr")
7747
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
7748
                else if (childNode.LocalName == "trendlineType")
7749
                    ctObj.trendlineType = CT_TrendlineType.Parse(childNode, namespaceManager);
7750
                else if (childNode.LocalName == "order")
7751
                    ctObj.order = CT_Order.Parse(childNode, namespaceManager);
7752
                else if (childNode.LocalName == "period")
7753
                    ctObj.period = CT_Period.Parse(childNode, namespaceManager);
7754
                else if (childNode.LocalName == "forward")
7755
                    ctObj.forward = CT_Double.Parse(childNode, namespaceManager);
7756
                else if (childNode.LocalName == "backward")
7757
                    ctObj.backward = CT_Double.Parse(childNode, namespaceManager);
7758
                else if (childNode.LocalName == "intercept")
7759
                    ctObj.intercept = CT_Double.Parse(childNode, namespaceManager);
7760
                else if (childNode.LocalName == "dispRSqr")
7761
                    ctObj.dispRSqr = CT_Boolean.Parse(childNode, namespaceManager);
7762
                else if (childNode.LocalName == "dispEq")
7763
                    ctObj.dispEq = CT_Boolean.Parse(childNode, namespaceManager);
7764
                else if (childNode.LocalName == "trendlineLbl")
7765
                    ctObj.trendlineLbl = CT_TrendlineLbl.Parse(childNode, namespaceManager);
7766
                else if (childNode.LocalName == "extLst")
7767
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
7768
            }
7769
            return ctObj;
7770
        }
7771

7772

7773

7774
        internal void Write(StreamWriter sw, string nodeName)
7775
        {
7776
            sw.Write(string.Format("<c:{0}", nodeName));
7777
            sw.Write(">");
7778
            if (this.name != null)
7779
                sw.Write(string.Format("<name>{0}</name>", this.name));
7780
            if (this.spPr != null)
7781
                this.spPr.Write(sw, "spPr");
7782
            if (this.trendlineType != null)
7783
                this.trendlineType.Write(sw, "trendlineType");
7784
            if (this.order != null)
7785
                this.order.Write(sw, "order");
7786
            if (this.period != null)
7787
                this.period.Write(sw, "period");
7788
            if (this.forward != null)
7789
                this.forward.Write(sw, "forward");
7790
            if (this.backward != null)
7791
                this.backward.Write(sw, "backward");
7792
            if (this.intercept != null)
7793
                this.intercept.Write(sw, "intercept");
7794
            if (this.dispRSqr != null)
7795
                this.dispRSqr.Write(sw, "dispRSqr");
7796
            if (this.dispEq != null)
7797
                this.dispEq.Write(sw, "dispEq");
7798
            if (this.trendlineLbl != null)
7799
                this.trendlineLbl.Write(sw, "trendlineLbl");
7800
            if (this.extLst != null)
7801
            {
7802
                foreach (CT_Extension x in this.extLst)
7803
                {
7804
                    x.Write(sw, "extLst");
7805
                }
7806
            }
7807
            sw.Write(string.Format("</c:{0}>", nodeName));
7808
        }
7809

7810

7811
        [XmlElement(Order = 0)]
7812
        public string name
7813
        {
7814
            get
7815
            {
7816
                return this.nameField;
7817
            }
7818
            set
7819
            {
7820
                this.nameField = value;
7821
            }
7822
        }
7823

7824
        [XmlElement(Order = 1)]
7825
        public CT_ShapeProperties spPr
7826
        {
7827
            get
7828
            {
7829
                return this.spPrField;
7830
            }
7831
            set
7832
            {
7833
                this.spPrField = value;
7834
            }
7835
        }
7836

7837
        [XmlElement(Order = 2)]
7838
        public CT_TrendlineType trendlineType
7839
        {
7840
            get
7841
            {
7842
                return this.trendlineTypeField;
7843
            }
7844
            set
7845
            {
7846
                this.trendlineTypeField = value;
7847
            }
7848
        }
7849

7850
        [XmlElement(Order = 3)]
7851
        public CT_Order order
7852
        {
7853
            get
7854
            {
7855
                return this.orderField;
7856
            }
7857
            set
7858
            {
7859
                this.orderField = value;
7860
            }
7861
        }
7862

7863
        [XmlElement(Order = 4)]
7864
        public CT_Period period
7865
        {
7866
            get
7867
            {
7868
                return this.periodField;
7869
            }
7870
            set
7871
            {
7872
                this.periodField = value;
7873
            }
7874
        }
7875

7876
        [XmlElement(Order = 5)]
7877
        public CT_Double forward
7878
        {
7879
            get
7880
            {
7881
                return this.forwardField;
7882
            }
7883
            set
7884
            {
7885
                this.forwardField = value;
7886
            }
7887
        }
7888

7889
        [XmlElement(Order = 6)]
7890
        public CT_Double backward
7891
        {
7892
            get
7893
            {
7894
                return this.backwardField;
7895
            }
7896
            set
7897
            {
7898
                this.backwardField = value;
7899
            }
7900
        }
7901

7902
        [XmlElement(Order = 7)]
7903
        public CT_Double intercept
7904
        {
7905
            get
7906
            {
7907
                return this.interceptField;
7908
            }
7909
            set
7910
            {
7911
                this.interceptField = value;
7912
            }
7913
        }
7914

7915
        [XmlElement(Order = 8)]
7916
        public CT_Boolean dispRSqr
7917
        {
7918
            get
7919
            {
7920
                return this.dispRSqrField;
7921
            }
7922
            set
7923
            {
7924
                this.dispRSqrField = value;
7925
            }
7926
        }
7927

7928
        [XmlElement(Order = 9)]
7929
        public CT_Boolean dispEq
7930
        {
7931
            get
7932
            {
7933
                return this.dispEqField;
7934
            }
7935
            set
7936
            {
7937
                this.dispEqField = value;
7938
            }
7939
        }
7940

7941
        [XmlElement(Order = 10)]
7942
        public CT_TrendlineLbl trendlineLbl
7943
        {
7944
            get
7945
            {
7946
                return this.trendlineLblField;
7947
            }
7948
            set
7949
            {
7950
                this.trendlineLblField = value;
7951
            }
7952
        }
7953

7954
        [XmlElement(Order = 11)]
7955
        public List<CT_Extension> extLst
7956
        {
7957
            get
7958
            {
7959
                return this.extLstField;
7960
            }
7961
            set
7962
            {
7963
                this.extLstField = value;
7964
            }
7965
        }
7966
    }
7967

7968

7969
    [Serializable]
7970

7971
    [System.ComponentModel.DesignerCategoryAttribute("code")]
7972
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
7973
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
7974
    public class CT_TrendlineType
7975
    {
7976

7977
        private ST_TrendlineType valField;
7978

7979
        public CT_TrendlineType()
7980
        {
7981
            this.valField = ST_TrendlineType.linear;
7982
        }
7983
        public static CT_TrendlineType Parse(XmlNode node, XmlNamespaceManager namespaceManager)
7984
        {
7985
            if (node == null)
7986
                return null;
7987
            CT_TrendlineType ctObj = new CT_TrendlineType();
7988
            if (node.Attributes["val"] != null)
7989
                ctObj.val = (ST_TrendlineType)Enum.Parse(typeof(ST_TrendlineType), node.Attributes["val"].Value);
7990
            return ctObj;
7991
        }
7992

7993

7994

7995
        internal void Write(StreamWriter sw, string nodeName)
7996
        {
7997
            sw.Write(string.Format("<c:{0}", nodeName));
7998
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
7999
            sw.Write("/>");
8000
        }
8001

8002
        [XmlAttribute]
8003
        [DefaultValue(ST_TrendlineType.linear)]
8004
        public ST_TrendlineType val
8005
        {
8006
            get
8007
            {
8008
                return this.valField;
8009
            }
8010
            set
8011
            {
8012
                this.valField = value;
8013
            }
8014
        }
8015
    }
8016

8017

8018
    [Serializable]
8019
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8020
    public enum ST_TrendlineType
8021
    {
8022

8023
        /// <remarks/>
8024
        exp,
8025

8026
        /// <remarks/>
8027
        linear,
8028

8029
        /// <remarks/>
8030
        log,
8031

8032
        /// <remarks/>
8033
        movingAvg,
8034

8035
        /// <remarks/>
8036
        poly,
8037

8038
        /// <remarks/>
8039
        power,
8040
    }
8041

8042

8043
    [Serializable]
8044

8045
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8046
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8047
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8048
    public class CT_Order
8049
    {
8050

8051
        private byte valField;
8052
        public static CT_Order Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8053
        {
8054
            if (node == null)
8055
                return null;
8056
            CT_Order ctObj = new CT_Order();
8057
            if (node.Attributes["val"] != null)
8058
                ctObj.val = XmlHelper.ReadByte(node.Attributes["val"]);
8059
            return ctObj;
8060
        }
8061

8062

8063

8064
        internal void Write(StreamWriter sw, string nodeName)
8065
        {
8066
            sw.Write(string.Format("<c:{0}", nodeName));
8067
            XmlHelper.WriteAttribute(sw, "val", this.val, true);
8068
            sw.Write("/>");
8069
        }
8070

8071
        public CT_Order()
8072
        {
8073
            this.valField = ((byte)(2));
8074
        }
8075

8076
        [XmlAttribute]
8077
        [DefaultValue(typeof(byte), "2")]
8078
        public byte val
8079
        {
8080
            get
8081
            {
8082
                return this.valField;
8083
            }
8084
            set
8085
            {
8086
                this.valField = value;
8087
            }
8088
        }
8089
    }
8090

8091

8092
    [Serializable]
8093

8094
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8095
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8096
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8097
    public class CT_Period
8098
    {
8099

8100
        private byte valField;
8101

8102
        public CT_Period()
8103
        {
8104
            this.valField = ((byte)(2));
8105
        }
8106
        public static CT_Period Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8107
        {
8108
            if (node == null)
8109
                return null;
8110
            CT_Period ctObj = new CT_Period();
8111
            if (node.Attributes["val"] != null)
8112
                ctObj.val = XmlHelper.ReadByte(node.Attributes["val"]);
8113
            return ctObj;
8114
        }
8115

8116

8117

8118
        internal void Write(StreamWriter sw, string nodeName)
8119
        {
8120
            sw.Write(string.Format("<c:{0}", nodeName));
8121
            XmlHelper.WriteAttribute(sw, "val", this.val);
8122
            sw.Write("/>");
8123
        }
8124

8125
        [XmlAttribute]
8126
        [DefaultValue(typeof(byte), "2")]
8127
        public byte val
8128
        {
8129
            get
8130
            {
8131
                return this.valField;
8132
            }
8133
            set
8134
            {
8135
                this.valField = value;
8136
            }
8137
        }
8138
    }
8139

8140

8141
    [Serializable]
8142

8143
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8144
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8145
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8146
    public class CT_TrendlineLbl
8147
    {
8148

8149
        private CT_Layout layoutField;
8150

8151
        private CT_Tx txField;
8152

8153
        private CT_NumFmt numFmtField;
8154

8155
        private CT_ShapeProperties spPrField;
8156

8157
        private CT_TextBody txPrField;
8158

8159
        private List<CT_Extension> extLstField;
8160

8161
        public CT_TrendlineLbl()
8162
        {
8163
            //this.extLstField = new List<CT_Extension>();
8164
            //this.numFmtField = new CT_NumFmt();
8165
            //this.txField = new CT_Tx();
8166
            //this.layoutField = new CT_Layout();
8167
        }
8168
        public static CT_TrendlineLbl Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8169
        {
8170
            if (node == null)
8171
                return null;
8172
            CT_TrendlineLbl ctObj = new CT_TrendlineLbl();
8173
            ctObj.extLst = new List<CT_Extension>();
8174
            foreach (XmlNode childNode in node.ChildNodes)
8175
            {
8176
                if (childNode.LocalName == "layout")
8177
                    ctObj.layout = CT_Layout.Parse(childNode, namespaceManager);
8178
                else if (childNode.LocalName == "tx")
8179
                    ctObj.tx = CT_Tx.Parse(childNode, namespaceManager);
8180
                else if (childNode.LocalName == "numFmt")
8181
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
8182
                else if (childNode.LocalName == "spPr")
8183
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
8184
                else if (childNode.LocalName == "txPr")
8185
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
8186
                else if (childNode.LocalName == "extLst")
8187
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
8188
            }
8189
            return ctObj;
8190
        }
8191

8192

8193

8194
        internal void Write(StreamWriter sw, string nodeName)
8195
        {
8196
            sw.Write(string.Format("<c:{0}", nodeName));
8197
            sw.Write(">");
8198
            if (this.layout != null)
8199
                this.layout.Write(sw, "layout");
8200
            if (this.tx != null)
8201
                this.tx.Write(sw, "tx");
8202
            if (this.numFmt != null)
8203
                this.numFmt.Write(sw, "numFmt");
8204
            if (this.spPr != null)
8205
                this.spPr.Write(sw, "spPr");
8206
            if (this.txPr != null)
8207
                this.txPr.Write(sw, "txPr");
8208
            if (this.extLst != null)
8209
            {
8210
                foreach (CT_Extension x in this.extLst)
8211
                {
8212
                    x.Write(sw, "extLst");
8213
                }
8214
            }
8215
            sw.Write(string.Format("</c:{0}>", nodeName));
8216
        }
8217

8218
        [XmlElement(Order = 0)]
8219
        public CT_Layout layout
8220
        {
8221
            get
8222
            {
8223
                return this.layoutField;
8224
            }
8225
            set
8226
            {
8227
                this.layoutField = value;
8228
            }
8229
        }
8230

8231
        [XmlElement(Order = 1)]
8232
        public CT_Tx tx
8233
        {
8234
            get
8235
            {
8236
                return this.txField;
8237
            }
8238
            set
8239
            {
8240
                this.txField = value;
8241
            }
8242
        }
8243

8244
        [XmlElement(Order = 2)]
8245
        public CT_NumFmt numFmt
8246
        {
8247
            get
8248
            {
8249
                return this.numFmtField;
8250
            }
8251
            set
8252
            {
8253
                this.numFmtField = value;
8254
            }
8255
        }
8256

8257
        [XmlElement(Order = 3)]
8258
        public CT_ShapeProperties spPr
8259
        {
8260
            get
8261
            {
8262
                return this.spPrField;
8263
            }
8264
            set
8265
            {
8266
                this.spPrField = value;
8267
            }
8268
        }
8269

8270
        [XmlElement(Order = 4)]
8271
        public CT_TextBody txPr
8272
        {
8273
            get
8274
            {
8275
                return this.txPrField;
8276
            }
8277
            set
8278
            {
8279
                this.txPrField = value;
8280
            }
8281
        }
8282

8283
        [XmlElement(Order = 5)]
8284
        public List<CT_Extension> extLst
8285
        {
8286
            get
8287
            {
8288
                return this.extLstField;
8289
            }
8290
            set
8291
            {
8292
                this.extLstField = value;
8293
            }
8294
        }
8295
    }
8296

8297

8298
    [Serializable]
8299

8300
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8301
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8302
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8303
    public class CT_ErrBars
8304
    {
8305

8306
        private CT_ErrDir errDirField;
8307

8308
        private CT_ErrBarType errBarTypeField;
8309

8310
        private CT_ErrValType errValTypeField;
8311

8312
        private CT_Boolean noEndCapField;
8313

8314
        private CT_NumDataSource plusField;
8315

8316
        private CT_NumDataSource minusField;
8317

8318
        private CT_Double valField;
8319

8320
        private CT_ShapeProperties spPrField;
8321

8322
        private List<CT_Extension> extLstField;
8323

8324
        public CT_ErrBars()
8325
        {
8326
        }
8327
        public static CT_ErrBars Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8328
        {
8329
            if (node == null)
8330
                return null;
8331
            CT_ErrBars ctObj = new CT_ErrBars();
8332
            ctObj.extLst = new List<CT_Extension>();
8333
            foreach (XmlNode childNode in node.ChildNodes)
8334
            {
8335
                if (childNode.LocalName == "errDir")
8336
                    ctObj.errDir = CT_ErrDir.Parse(childNode, namespaceManager);
8337
                else if (childNode.LocalName == "errBarType")
8338
                    ctObj.errBarType = CT_ErrBarType.Parse(childNode, namespaceManager);
8339
                else if (childNode.LocalName == "errValType")
8340
                    ctObj.errValType = CT_ErrValType.Parse(childNode, namespaceManager);
8341
                else if (childNode.LocalName == "noEndCap")
8342
                    ctObj.noEndCap = CT_Boolean.Parse(childNode, namespaceManager);
8343
                else if (childNode.LocalName == "plus")
8344
                    ctObj.plus = CT_NumDataSource.Parse(childNode, namespaceManager);
8345
                else if (childNode.LocalName == "minus")
8346
                    ctObj.minus = CT_NumDataSource.Parse(childNode, namespaceManager);
8347
                else if (childNode.LocalName == "val")
8348
                    ctObj.val = CT_Double.Parse(childNode, namespaceManager);
8349
                else if (childNode.LocalName == "spPr")
8350
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
8351
                else if (childNode.LocalName == "extLst")
8352
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
8353
            }
8354
            return ctObj;
8355
        }
8356

8357

8358

8359
        internal void Write(StreamWriter sw, string nodeName)
8360
        {
8361
            sw.Write(string.Format("<c:{0}", nodeName));
8362
            sw.Write(">");
8363
            if (this.errDir != null)
8364
                this.errDir.Write(sw, "errDir");
8365
            if (this.errBarType != null)
8366
                this.errBarType.Write(sw, "errBarType");
8367
            if (this.errValType != null)
8368
                this.errValType.Write(sw, "errValType");
8369
            if (this.noEndCap != null)
8370
                this.noEndCap.Write(sw, "noEndCap");
8371
            if (this.plus != null)
8372
                this.plus.Write(sw, "plus");
8373
            if (this.minus != null)
8374
                this.minus.Write(sw, "minus");
8375
            if (this.val != null)
8376
                this.val.Write(sw, "val");
8377
            if (this.spPr != null)
8378
                this.spPr.Write(sw, "spPr");
8379
            if (this.extLst != null)
8380
            {
8381
                foreach (CT_Extension x in this.extLst)
8382
                {
8383
                    x.Write(sw, "extLst");
8384
                }
8385
            }
8386
            sw.Write(string.Format("</c:{0}>", nodeName));
8387
        }
8388

8389

8390
        [XmlElement(Order = 0)]
8391
        public CT_ErrDir errDir
8392
        {
8393
            get
8394
            {
8395
                return this.errDirField;
8396
            }
8397
            set
8398
            {
8399
                this.errDirField = value;
8400
            }
8401
        }
8402

8403
        [XmlElement(Order = 1)]
8404
        public CT_ErrBarType errBarType
8405
        {
8406
            get
8407
            {
8408
                return this.errBarTypeField;
8409
            }
8410
            set
8411
            {
8412
                this.errBarTypeField = value;
8413
            }
8414
        }
8415

8416
        [XmlElement(Order = 2)]
8417
        public CT_ErrValType errValType
8418
        {
8419
            get
8420
            {
8421
                return this.errValTypeField;
8422
            }
8423
            set
8424
            {
8425
                this.errValTypeField = value;
8426
            }
8427
        }
8428

8429
        [XmlElement(Order = 3)]
8430
        public CT_Boolean noEndCap
8431
        {
8432
            get
8433
            {
8434
                return this.noEndCapField;
8435
            }
8436
            set
8437
            {
8438
                this.noEndCapField = value;
8439
            }
8440
        }
8441

8442
        [XmlElement(Order = 4)]
8443
        public CT_NumDataSource plus
8444
        {
8445
            get
8446
            {
8447
                return this.plusField;
8448
            }
8449
            set
8450
            {
8451
                this.plusField = value;
8452
            }
8453
        }
8454

8455
        [XmlElement(Order = 5)]
8456
        public CT_NumDataSource minus
8457
        {
8458
            get
8459
            {
8460
                return this.minusField;
8461
            }
8462
            set
8463
            {
8464
                this.minusField = value;
8465
            }
8466
        }
8467

8468
        [XmlElement(Order = 6)]
8469
        public CT_Double val
8470
        {
8471
            get
8472
            {
8473
                return this.valField;
8474
            }
8475
            set
8476
            {
8477
                this.valField = value;
8478
            }
8479
        }
8480

8481
        [XmlElement(Order = 7)]
8482
        public CT_ShapeProperties spPr
8483
        {
8484
            get
8485
            {
8486
                return this.spPrField;
8487
            }
8488
            set
8489
            {
8490
                this.spPrField = value;
8491
            }
8492
        }
8493

8494
        [XmlElement(Order = 8)]
8495
        public List<CT_Extension> extLst
8496
        {
8497
            get
8498
            {
8499
                return this.extLstField;
8500
            }
8501
            set
8502
            {
8503
                this.extLstField = value;
8504
            }
8505
        }
8506
    }
8507

8508

8509
    [Serializable]
8510

8511
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8512
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8513
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8514
    public class CT_ErrDir
8515
    {
8516
        public static CT_ErrDir Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8517
        {
8518
            if (node == null)
8519
                return null;
8520
            CT_ErrDir ctObj = new CT_ErrDir();
8521
            if (node.Attributes["val"] != null)
8522
                ctObj.val = (ST_ErrDir)Enum.Parse(typeof(ST_ErrDir), node.Attributes["val"].Value);
8523
            return ctObj;
8524
        }
8525

8526

8527

8528
        internal void Write(StreamWriter sw, string nodeName)
8529
        {
8530
            sw.Write(string.Format("<c:{0}", nodeName));
8531
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
8532
            sw.Write("/>");
8533
        }
8534

8535
        private ST_ErrDir valField;
8536

8537
        [XmlAttribute]
8538
        public ST_ErrDir val
8539
        {
8540
            get
8541
            {
8542
                return this.valField;
8543
            }
8544
            set
8545
            {
8546
                this.valField = value;
8547
            }
8548
        }
8549
    }
8550

8551

8552
    [Serializable]
8553
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8554
    public enum ST_ErrDir
8555
    {
8556

8557
        /// <remarks/>
8558
        x,
8559

8560
        /// <remarks/>
8561
        y,
8562
    }
8563

8564

8565
    [Serializable]
8566

8567
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8568
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8569
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8570
    public class CT_ErrBarType
8571
    {
8572
        public static CT_ErrBarType Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8573
        {
8574
            if (node == null)
8575
                return null;
8576
            CT_ErrBarType ctObj = new CT_ErrBarType();
8577
            if (node.Attributes["val"] != null)
8578
                ctObj.val = (ST_ErrBarType)Enum.Parse(typeof(ST_ErrBarType), node.Attributes["val"].Value);
8579
            return ctObj;
8580
        }
8581

8582

8583

8584
        internal void Write(StreamWriter sw, string nodeName)
8585
        {
8586
            sw.Write(string.Format("<c:{0}", nodeName));
8587
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
8588
            sw.Write("/>");
8589
        }
8590

8591
        private ST_ErrBarType valField;
8592

8593
        public CT_ErrBarType()
8594
        {
8595
            this.valField = ST_ErrBarType.both;
8596
        }
8597

8598
        [XmlAttribute]
8599
        [DefaultValue(ST_ErrBarType.both)]
8600
        public ST_ErrBarType val
8601
        {
8602
            get
8603
            {
8604
                return this.valField;
8605
            }
8606
            set
8607
            {
8608
                this.valField = value;
8609
            }
8610
        }
8611
    }
8612

8613

8614
    [Serializable]
8615
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8616
    public enum ST_ErrBarType
8617
    {
8618

8619
        /// <remarks/>
8620
        both,
8621

8622
        /// <remarks/>
8623
        minus,
8624

8625
        /// <remarks/>
8626
        plus,
8627
    }
8628

8629

8630
    [Serializable]
8631

8632
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8633
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8634
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8635
    public class CT_ErrValType
8636
    {
8637

8638
        private ST_ErrValType valField;
8639

8640
        public CT_ErrValType()
8641
        {
8642
            this.valField = ST_ErrValType.fixedVal;
8643
        }
8644
        public static CT_ErrValType Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8645
        {
8646
            if (node == null)
8647
                return null;
8648
            CT_ErrValType ctObj = new CT_ErrValType();
8649
            if (node.Attributes["val"] != null)
8650
                ctObj.val = (ST_ErrValType)Enum.Parse(typeof(ST_ErrValType), node.Attributes["val"].Value);
8651
            return ctObj;
8652
        }
8653

8654

8655

8656
        internal void Write(StreamWriter sw, string nodeName)
8657
        {
8658
            sw.Write(string.Format("<c:{0}", nodeName));
8659
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
8660
            sw.Write("/>");
8661
        }
8662

8663
        [XmlAttribute]
8664
        [DefaultValue(ST_ErrValType.fixedVal)]
8665
        public ST_ErrValType val
8666
        {
8667
            get
8668
            {
8669
                return this.valField;
8670
            }
8671
            set
8672
            {
8673
                this.valField = value;
8674
            }
8675
        }
8676
    }
8677

8678

8679
    [Serializable]
8680
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8681
    public enum ST_ErrValType
8682
    {
8683

8684
        /// <remarks/>
8685
        cust,
8686

8687
        /// <remarks/>
8688
        fixedVal,
8689

8690
        /// <remarks/>
8691
        percentage,
8692

8693
        /// <remarks/>
8694
        stdDev,
8695

8696
        /// <remarks/>
8697
        stdErr,
8698
    }
8699

8700

8701
    [Serializable]
8702

8703
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8704
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8705
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8706
    public class CT_NumDataSource
8707
    {
8708
        CT_NumData numLitField;
8709
        CT_NumRef numRefField;
8710
        public static CT_NumDataSource Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8711
        {
8712
            if (node == null)
8713
                return null;
8714
            CT_NumDataSource ctObj = new CT_NumDataSource();
8715
            foreach (XmlNode childNode in node.ChildNodes)
8716
            {
8717
                if (childNode.LocalName == "numLit")
8718
                    ctObj.numLit = CT_NumData.Parse(childNode, namespaceManager);
8719
                else if (childNode.LocalName == "numRef")
8720
                    ctObj.numRef = CT_NumRef.Parse(childNode, namespaceManager);
8721
            }
8722
            return ctObj;
8723
        }
8724

8725

8726

8727
        internal void Write(StreamWriter sw, string nodeName)
8728
        {
8729
            sw.Write(string.Format("<c:{0}", nodeName));
8730
            sw.Write(">");
8731
            if (this.numLit != null)
8732
                this.numLit.Write(sw, "numLit");
8733
            if (this.numRef != null)
8734
                this.numRef.Write(sw, "numRef");
8735
            sw.Write(string.Format("</c:{0}>", nodeName));
8736
        }
8737

8738
        public CT_NumRef AddNewNumRef()
8739
        {
8740
            this.numRefField = new CT_NumRef();
8741
            return this.numRefField;
8742
        }
8743
        public CT_NumData numLit
8744
        {
8745
            get
8746
            {
8747
                return this.numLitField;
8748
            }
8749
            set
8750
            {
8751
                this.numLitField = value;
8752
            }
8753
        }
8754
        public CT_NumRef numRef
8755
        {
8756
            get
8757
            {
8758
                return this.numRefField;
8759
            }
8760
            set
8761
            {
8762
                this.numRefField = value;
8763
            }
8764
        }
8765

8766
        public CT_NumData AddNewNumLit()
8767
        {
8768
            numLit = new CT_NumData();
8769
            return numLit;
8770
        }
8771
    }
8772

8773

8774
    [Serializable]
8775

8776
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8777
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8778
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8779
    public class CT_NumData
8780
    {
8781

8782
        private string formatCodeField;
8783

8784
        private CT_UnsignedInt ptCountField;
8785

8786
        private List<CT_NumVal> ptField;
8787

8788
        private List<CT_Extension> extLstField;
8789
        public static CT_NumData Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8790
        {
8791
            if (node == null)
8792
                return null;
8793
            CT_NumData ctObj = new CT_NumData();
8794
            ctObj.pt = new List<CT_NumVal>();
8795
            ctObj.extLst = new List<CT_Extension>();
8796
            foreach (XmlNode childNode in node.ChildNodes)
8797
            {
8798
                if (childNode.LocalName == "formatCode")
8799
                    ctObj.formatCode = childNode.InnerText;
8800
                else if (childNode.LocalName == "ptCount")
8801
                    ctObj.ptCount = CT_UnsignedInt.Parse(childNode, namespaceManager);
8802
                else if (childNode.LocalName == "pt")
8803
                    ctObj.pt.Add(CT_NumVal.Parse(childNode, namespaceManager));
8804
                else if (childNode.LocalName == "extLst")
8805
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
8806
            }
8807
            return ctObj;
8808
        }
8809

8810

8811

8812
        internal void Write(StreamWriter sw, string nodeName)
8813
        {
8814
            sw.Write(string.Format("<c:{0}", nodeName));
8815
            sw.Write(">");
8816
            if (this.formatCode != null)
8817
                sw.Write(string.Format("<c:formatCode>{0}</c:formatCode>", this.formatCode));
8818
            if (this.ptCount != null)
8819
                this.ptCount.Write(sw, "ptCount");
8820
            if (this.pt != null)
8821
            {
8822
                foreach (CT_NumVal x in this.pt)
8823
                {
8824
                    x.Write(sw, "pt");
8825
                }
8826
            }
8827
            if (this.extLst != null)
8828
            {
8829
                foreach (CT_Extension x in this.extLst)
8830
                {
8831
                    x.Write(sw, "extLst");
8832
                }
8833
            }
8834
            sw.Write(string.Format("</c:{0}>", nodeName));
8835
        }
8836

8837
        public CT_NumData()
8838
        {
8839
            //this.extLstField = new List<CT_Extension>();
8840
            //this.ptField = new List<CT_NumVal>();
8841
            //this.ptCountField = new CT_UnsignedInt();
8842
        }
8843
        public CT_NumVal AddNewPt()
8844
        {
8845
            if(this.ptField==null)
8846
                this.ptField = new List<CT_NumVal>();
8847
            CT_NumVal val = new CT_NumVal();
8848
            this.ptField.Add(val);
8849
            return val;
8850
        }
8851
        public CT_UnsignedInt AddNewPtCount()
8852
        {
8853
            this.ptCountField = new CT_UnsignedInt();
8854
            return ptCountField;
8855
        }
8856
        [XmlElement(Order = 0)]
8857
        public string formatCode
8858
        {
8859
            get
8860
            {
8861
                return this.formatCodeField;
8862
            }
8863
            set
8864
            {
8865
                this.formatCodeField = value;
8866
            }
8867
        }
8868

8869
        [XmlElement(Order = 1)]
8870
        public CT_UnsignedInt ptCount
8871
        {
8872
            get
8873
            {
8874
                return this.ptCountField;
8875
            }
8876
            set
8877
            {
8878
                this.ptCountField = value;
8879
            }
8880
        }
8881

8882
        [XmlElement("pt", Order = 2)]
8883
        public List<CT_NumVal> pt
8884
        {
8885
            get
8886
            {
8887
                return this.ptField;
8888
            }
8889
            set
8890
            {
8891
                this.ptField = value;
8892
            }
8893
        }
8894

8895
        [XmlElement(Order = 3)]
8896
        public List<CT_Extension> extLst
8897
        {
8898
            get
8899
            {
8900
                return this.extLstField;
8901
            }
8902
            set
8903
            {
8904
                this.extLstField = value;
8905
            }
8906
        }
8907
    }
8908

8909

8910
    [Serializable]
8911

8912
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8913
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8914
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8915
    public class CT_NumVal
8916
    {
8917

8918
        private string vField;
8919

8920
        private uint idxField;
8921

8922
        private string formatCodeField;
8923
        public static CT_NumVal Parse(XmlNode node, XmlNamespaceManager namespaceManager)
8924
        {
8925
            if (node == null)
8926
                return null;
8927
            CT_NumVal ctObj = new CT_NumVal();
8928
            if (node.Attributes["idx"] != null)
8929
                ctObj.idx = XmlHelper.ReadUInt(node.Attributes["idx"]);
8930
            ctObj.formatCode = XmlHelper.ReadString(node.Attributes["formatCode"]);
8931
            foreach (XmlNode childNode in node.ChildNodes)
8932
            {
8933
                if (childNode.LocalName == "v")
8934
                    ctObj.v = childNode.InnerText;
8935
            }
8936
            return ctObj;
8937
        }
8938

8939

8940

8941
        internal void Write(StreamWriter sw, string nodeName)
8942
        {
8943
            sw.Write(string.Format("<c:{0}", nodeName));
8944
            XmlHelper.WriteAttribute(sw, "idx", this.idx, true);
8945
            XmlHelper.WriteAttribute(sw, "formatCode", this.formatCode);
8946
            sw.Write(">");
8947
            if (this.v != null)
8948
                sw.Write(string.Format("<c:v>{0}</c:v>", this.v.ToString()));
8949
            sw.Write(string.Format("</c:{0}>", nodeName));
8950
        }
8951

8952
        [XmlElement(Order = 0)]
8953
        public string v
8954
        {
8955
            get
8956
            {
8957
                return this.vField;
8958
            }
8959
            set
8960
            {
8961
                this.vField = value;
8962
            }
8963
        }
8964

8965
        [XmlAttribute]
8966
        public uint idx
8967
        {
8968
            get
8969
            {
8970
                return this.idxField;
8971
            }
8972
            set
8973
            {
8974
                this.idxField = value;
8975
            }
8976
        }
8977

8978
        [XmlAttribute]
8979
        public string formatCode
8980
        {
8981
            get
8982
            {
8983
                return this.formatCodeField;
8984
            }
8985
            set
8986
            {
8987
                this.formatCodeField = value;
8988
            }
8989
        }
8990
    }
8991

8992

8993
    [Serializable]
8994

8995
    [System.ComponentModel.DesignerCategoryAttribute("code")]
8996
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
8997
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
8998
    public class CT_NumRef
8999
    {
9000

9001
        private string fField;
9002

9003
        private CT_NumData numCacheField;
9004

9005
        private List<CT_Extension> extLstField;
9006

9007
        public CT_NumRef()
9008
        {
9009
        }
9010
        public static CT_NumRef Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9011
        {
9012
            if (node == null)
9013
                return null;
9014
            CT_NumRef ctObj = new CT_NumRef();
9015
            ctObj.extLst = new List<CT_Extension>();
9016
            foreach (XmlNode childNode in node.ChildNodes)
9017
            {
9018
                if (childNode.LocalName == "f")
9019
                    ctObj.f = childNode.InnerText;
9020
                else if (childNode.LocalName == "numCache")
9021
                    ctObj.numCache = CT_NumData.Parse(childNode, namespaceManager);
9022
                else if (childNode.LocalName == "extLst")
9023
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
9024
            }
9025
            return ctObj;
9026
        }
9027

9028

9029

9030
        internal void Write(StreamWriter sw, string nodeName)
9031
        {
9032
            sw.Write(string.Format("<c:{0}", nodeName));
9033
            sw.Write(">");
9034
            if (this.f != null)
9035
                sw.Write(string.Format("<c:f>{0}</c:f>", this.f));
9036
            if (this.numCache != null)
9037
                this.numCache.Write(sw, "numCache");
9038
            if (this.extLst != null)
9039
            {
9040
                foreach (CT_Extension x in this.extLst)
9041
                {
9042
                    x.Write(sw, "extLst");
9043
                }
9044
            }
9045
            sw.Write(string.Format("</c:{0}>", nodeName));
9046
        }
9047

9048
        public CT_NumData AddNewNumCache()
9049
        {
9050
            this.numCacheField = new CT_NumData();
9051
            return this.numCacheField;
9052
        }
9053
        [XmlElement(Order = 0)]
9054
        public string f
9055
        {
9056
            get
9057
            {
9058
                return this.fField;
9059
            }
9060
            set
9061
            {
9062
                this.fField = value;
9063
            }
9064
        }
9065

9066
        [XmlElement(Order = 1)]
9067
        public CT_NumData numCache
9068
        {
9069
            get
9070
            {
9071
                return this.numCacheField;
9072
            }
9073
            set
9074
            {
9075
                this.numCacheField = value;
9076
            }
9077
        }
9078

9079
        [XmlElement(Order = 2)]
9080
        public List<CT_Extension> extLst
9081
        {
9082
            get
9083
            {
9084
                return this.extLstField;
9085
            }
9086
            set
9087
            {
9088
                this.extLstField = value;
9089
            }
9090
        }
9091
    }
9092

9093

9094
    [Serializable]
9095

9096
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9097
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9098
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9099
    public class CT_AxDataSource
9100
    {
9101
        CT_MultiLvlStrRef multiLvlStrRefField;
9102
        CT_NumData numLitField;
9103
        CT_NumRef numRefField;
9104
        CT_StrData strLitField;
9105
        CT_StrRef strRefField;
9106
        public static CT_AxDataSource Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9107
        {
9108
            if (node == null)
9109
                return null;
9110
            CT_AxDataSource ctObj = new CT_AxDataSource();
9111
            foreach (XmlNode childNode in node.ChildNodes)
9112
            {
9113
                if (childNode.LocalName == "numLit")
9114
                    ctObj.numLit = CT_NumData.Parse(childNode, namespaceManager);
9115
                else if (childNode.LocalName == "numRef")
9116
                    ctObj.numRef = CT_NumRef.Parse(childNode, namespaceManager);
9117
                else if (childNode.LocalName == "strLit")
9118
                    ctObj.strLit = CT_StrData.Parse(childNode, namespaceManager);
9119
                else if (childNode.LocalName == "strRef")
9120
                    ctObj.strRef = CT_StrRef.Parse(childNode, namespaceManager);
9121
                else if (childNode.LocalName == "multiLvlStrRef")
9122
                    ctObj.multiLvlStrRef = CT_MultiLvlStrRef.Parse(childNode, namespaceManager);
9123
            }
9124
            return ctObj;
9125
        }
9126

9127

9128

9129
        internal void Write(StreamWriter sw, string nodeName)
9130
        {
9131
            sw.Write(string.Format("<c:{0}", nodeName));
9132
            sw.Write(">");
9133
            if (this.numLit != null)
9134
                this.numLit.Write(sw, "numLit");
9135
            if (this.numRef != null)
9136
                this.numRef.Write(sw, "numRef");
9137
            if (this.strLit != null)
9138
                this.strLit.Write(sw, "strLit");
9139
            if (this.strRef != null)
9140
                this.strRef.Write(sw, "strRef");
9141
            if (this.multiLvlStrRef != null)
9142
                this.multiLvlStrRef.Write(sw, "multiLvlStrRef");
9143
            sw.Write(string.Format("</c:{0}>", nodeName));
9144
        }
9145

9146
        public CT_NumRef AddNewNumRef()
9147
        {
9148
            this.numRefField = new CT_NumRef();
9149
            return this.numRefField;
9150
        }
9151
        public CT_NumData AddNewNumLit()
9152
        {
9153
            numLit = new CT_NumData();
9154
            return numLit;
9155
        }
9156
        public CT_NumData numLit
9157
        {
9158
            get
9159
            {
9160
                return this.numLitField;
9161
            }
9162
            set
9163
            {
9164
                this.numLitField = value;
9165
            }
9166
        }
9167
        public CT_NumRef numRef
9168
        {
9169
            get
9170
            {
9171
                return this.numRefField;
9172
            }
9173
            set
9174
            {
9175
                this.numRefField = value;
9176
            }
9177
        }
9178
        public CT_StrData strLit
9179
        {
9180
            get
9181
            {
9182
                return this.strLitField;
9183
            }
9184
            set
9185
            {
9186
                this.strLitField = value;
9187
            }
9188
        }
9189
        public CT_StrRef strRef
9190
        {
9191
            get
9192
            {
9193
                return this.strRefField;
9194
            }
9195
            set
9196
            {
9197
                this.strRefField = value;
9198
            }
9199
        }
9200
        public CT_MultiLvlStrRef multiLvlStrRef
9201
        {
9202
            get
9203
            {
9204
                return this.multiLvlStrRefField;
9205
            }
9206
            set
9207
            {
9208
                this.multiLvlStrRefField = value;
9209
            }
9210
        }
9211
        //private object itemField;
9212

9213
        //[XmlElement("multiLvlStrRef", typeof(CT_MultiLvlStrRef), Order = 0)]
9214
        //[XmlElement("numLit", typeof(CT_NumData), Order = 0)]
9215
        //[XmlElement("numRef", typeof(CT_NumRef), Order = 0)]
9216
        //[XmlElement("strLit", typeof(CT_StrData), Order = 0)]
9217
        //[XmlElement("strRef", typeof(CT_StrRef), Order = 0)]
9218
        //public object Item
9219
        //{
9220
        //    get
9221
        //    {
9222
        //        return this.itemField;
9223
        //    }
9224
        //    set
9225
        //    {
9226
        //        this.itemField = value;
9227
        //    }
9228
        //}
9229

9230

9231

9232
        public CT_StrRef AddNewStrRef()
9233
        {
9234
            strRef = new CT_StrRef();
9235
            return strRef;
9236
        }
9237

9238
        public CT_StrData AddNewStrLit()
9239
        {
9240
            strLit = new CT_StrData();
9241
            return strLit;
9242
        }
9243
    }
9244

9245

9246
    [Serializable]
9247

9248
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9249
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9250
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9251
    public class CT_MultiLvlStrRef
9252
    {
9253
        public static CT_MultiLvlStrRef Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9254
        {
9255
            if (node == null)
9256
                return null;
9257
            CT_MultiLvlStrRef ctObj = new CT_MultiLvlStrRef();
9258
            ctObj.extLst = new List<CT_Extension>();
9259
            foreach (XmlNode childNode in node.ChildNodes)
9260
            {
9261
                if (childNode.LocalName == "f")
9262
                    ctObj.f = childNode.InnerText;
9263
                else if (childNode.LocalName == "multiLvlStrCache")
9264
                    ctObj.multiLvlStrCache = CT_MultiLvlStrData.Parse(childNode, namespaceManager);
9265
                else if (childNode.LocalName == "extLst")
9266
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
9267
            }
9268
            return ctObj;
9269
        }
9270

9271

9272

9273
        internal void Write(StreamWriter sw, string nodeName)
9274
        {
9275
            sw.Write(string.Format("<c:{0}", nodeName));
9276
            sw.Write(">");
9277
            if (this.f != null)
9278
                sw.Write(string.Format("<c:f>{0}</c:f>", this.f));
9279
            if (this.multiLvlStrCache != null)
9280
                this.multiLvlStrCache.Write(sw, "multiLvlStrCache");
9281
            if (this.extLst != null)
9282
            {
9283
                foreach (CT_Extension x in this.extLst)
9284
                {
9285
                    x.Write(sw, "extLst");
9286
                }
9287
            }
9288
            sw.Write(string.Format("</c:{0}>", nodeName));
9289
        }
9290

9291
        private string fField;
9292

9293
        private CT_MultiLvlStrData multiLvlStrCacheField;
9294

9295
        private List<CT_Extension> extLstField;
9296

9297
        public CT_MultiLvlStrRef()
9298
        {
9299
        }
9300

9301
        [XmlElement(Order = 0)]
9302
        public string f
9303
        {
9304
            get
9305
            {
9306
                return this.fField;
9307
            }
9308
            set
9309
            {
9310
                this.fField = value;
9311
            }
9312
        }
9313

9314
        [XmlElement(Order = 1)]
9315
        public CT_MultiLvlStrData multiLvlStrCache
9316
        {
9317
            get
9318
            {
9319
                return this.multiLvlStrCacheField;
9320
            }
9321
            set
9322
            {
9323
                this.multiLvlStrCacheField = value;
9324
            }
9325
        }
9326

9327
        [XmlElement(Order = 2)]
9328
        public List<CT_Extension> extLst
9329
        {
9330
            get
9331
            {
9332
                return this.extLstField;
9333
            }
9334
            set
9335
            {
9336
                this.extLstField = value;
9337
            }
9338
        }
9339
    }
9340

9341

9342
    [Serializable]
9343

9344
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9345
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9346
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9347
    public class CT_MultiLvlStrData
9348
    {
9349

9350
        private CT_UnsignedInt ptCountField;
9351

9352
        private List<CT_Lvl> lvlField;
9353

9354
        private List<CT_Extension> extLstField;
9355

9356
        public static CT_MultiLvlStrData Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9357
        {
9358
            if (node == null)
9359
                return null;
9360
            CT_MultiLvlStrData ctObj = new CT_MultiLvlStrData();
9361
            ctObj.lvl = new List<CT_Lvl>();
9362
            ctObj.extLst = new List<CT_Extension>();
9363
            foreach (XmlNode childNode in node.ChildNodes)
9364
            {
9365
                if (childNode.LocalName == "ptCount")
9366
                    ctObj.ptCount = CT_UnsignedInt.Parse(childNode, namespaceManager);
9367
                else if (childNode.LocalName == "lvl")
9368
                    ctObj.lvl.Add(CT_Lvl.Parse(childNode, namespaceManager));
9369
                else if (childNode.LocalName == "extLst")
9370
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
9371
            }
9372
            return ctObj;
9373
        }
9374

9375

9376

9377
        internal void Write(StreamWriter sw, string nodeName)
9378
        {
9379
            sw.Write(string.Format("<c:{0}", nodeName));
9380
            sw.Write(">");
9381
            if (this.ptCount != null)
9382
                this.ptCount.Write(sw, "ptCount");
9383
            if (this.lvl != null && this.lvl.Count > 0)
9384
            {
9385
                foreach (CT_Lvl x in this.lvl)
9386
                {
9387
                    x.Write(sw, "lvl");
9388
                }
9389
            }
9390
            if (this.extLst != null)
9391
            {
9392
                foreach (CT_Extension x in this.extLst)
9393
                {
9394
                    x.Write(sw, "extLst");
9395
                }
9396
            }
9397
            sw.Write(string.Format("</c:{0}>", nodeName));
9398
        }
9399

9400
        public CT_MultiLvlStrData()
9401
        {
9402
        }
9403

9404
        [XmlElement(Order = 0)]
9405
        public CT_UnsignedInt ptCount
9406
        {
9407
            get
9408
            {
9409
                return this.ptCountField;
9410
            }
9411
            set
9412
            {
9413
                this.ptCountField = value;
9414
            }
9415
        }
9416

9417
        [XmlElement(Order = 1)]
9418
        public List<CT_Lvl> lvl
9419
        {
9420
            get
9421
            {
9422
                return this.lvlField;
9423
            }
9424
            set
9425
            {
9426
                this.lvlField = value;
9427
            }
9428
        }
9429

9430
        [XmlElement(Order = 2)]
9431
        public List<CT_Extension> extLst
9432
        {
9433
            get
9434
            {
9435
                return this.extLstField;
9436
            }
9437
            set
9438
            {
9439
                this.extLstField = value;
9440
            }
9441
        }
9442
    }
9443

9444

9445
    [Serializable]
9446

9447
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9448
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9449
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9450
    public class CT_BandFmt
9451
    {
9452

9453
        private CT_UnsignedInt idxField;
9454

9455
        private CT_ShapeProperties spPrField;
9456

9457
        public CT_BandFmt()
9458
        {
9459

9460
        }
9461
        public static CT_BandFmt Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9462
        {
9463
            if (node == null)
9464
                return null;
9465
            CT_BandFmt ctObj = new CT_BandFmt();
9466
            foreach (XmlNode childNode in node.ChildNodes)
9467
            {
9468
                if (childNode.LocalName == "idx")
9469
                    ctObj.idx = CT_UnsignedInt.Parse(childNode, namespaceManager);
9470
                else if (childNode.LocalName == "spPr")
9471
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
9472
            }
9473
            return ctObj;
9474
        }
9475

9476

9477

9478
        internal void Write(StreamWriter sw, string nodeName)
9479
        {
9480
            sw.Write(string.Format("<c:{0}", nodeName));
9481
            sw.Write(">");
9482
            if (this.idx != null)
9483
                this.idx.Write(sw, "idx");
9484
            if (this.spPr != null)
9485
                this.spPr.Write(sw, "spPr");
9486
            sw.Write(string.Format("</c:{0}>", nodeName));
9487
        }
9488

9489

9490
        [XmlElement(Order = 0)]
9491
        public CT_UnsignedInt idx
9492
        {
9493
            get
9494
            {
9495
                return this.idxField;
9496
            }
9497
            set
9498
            {
9499
                this.idxField = value;
9500
            }
9501
        }
9502

9503
        [XmlElement(Order = 1)]
9504
        public CT_ShapeProperties spPr
9505
        {
9506
            get
9507
            {
9508
                return this.spPrField;
9509
            }
9510
            set
9511
            {
9512
                this.spPrField = value;
9513
            }
9514
        }
9515
    }
9516

9517

9518
    [Serializable]
9519

9520
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9521
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9522
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9523
    public class CT_SurfaceChart
9524
    {
9525

9526
        private CT_Boolean wireframeField;
9527

9528
        private List<CT_SurfaceSer> serField;
9529

9530
        private List<CT_BandFmt> bandFmtsField;
9531

9532
        private List<CT_UnsignedInt> axIdField;
9533

9534
        private List<CT_Extension> extLstField;
9535

9536
        public CT_SurfaceChart()
9537
        {
9538
        }
9539
        public static CT_SurfaceChart Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9540
        {
9541
            if (node == null)
9542
                return null;
9543
            CT_SurfaceChart ctObj = new CT_SurfaceChart();
9544
            ctObj.ser = new List<CT_SurfaceSer>();
9545
            ctObj.bandFmts = new List<CT_BandFmt>();
9546
            ctObj.axId = new List<CT_UnsignedInt>();
9547
            ctObj.extLst = new List<CT_Extension>();
9548
            foreach (XmlNode childNode in node.ChildNodes)
9549
            {
9550
                if (childNode.LocalName == "wireframe")
9551
                    ctObj.wireframe = CT_Boolean.Parse(childNode, namespaceManager);
9552
                else if (childNode.LocalName == "ser")
9553
                    ctObj.ser.Add(CT_SurfaceSer.Parse(childNode, namespaceManager));
9554
                else if (childNode.LocalName == "bandFmts")
9555
                    ctObj.bandFmts.Add(CT_BandFmt.Parse(childNode, namespaceManager));
9556
                else if (childNode.LocalName == "axId")
9557
                    ctObj.axId.Add(CT_UnsignedInt.Parse(childNode, namespaceManager));
9558
                else if (childNode.LocalName == "extLst")
9559
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
9560
            }
9561
            return ctObj;
9562
        }
9563

9564

9565

9566
        internal void Write(StreamWriter sw, string nodeName)
9567
        {
9568
            sw.Write(string.Format("<c:{0}", nodeName));
9569
            sw.Write(">");
9570
            if (this.wireframe != null)
9571
                this.wireframe.Write(sw, "wireframe");
9572
            if (this.ser != null)
9573
            {
9574
                foreach (CT_SurfaceSer x in this.ser)
9575
                {
9576
                    x.Write(sw, "ser");
9577
                }
9578
            }
9579
            if (this.bandFmts != null)
9580
            {
9581
                foreach (CT_BandFmt x in this.bandFmts)
9582
                {
9583
                    x.Write(sw, "bandFmts");
9584
                }
9585
            }
9586
            if (this.axId != null)
9587
            {
9588
                foreach (CT_UnsignedInt x in this.axId)
9589
                {
9590
                    x.Write(sw, "axId");
9591
                }
9592
            }
9593
            if (this.extLst != null)
9594
            {
9595
                foreach (CT_Extension x in this.extLst)
9596
                {
9597
                    x.Write(sw, "extLst");
9598
                }
9599
            }
9600
            sw.Write(string.Format("</c:{0}>", nodeName));
9601
        }
9602

9603
        [XmlElement(Order = 0)]
9604
        public CT_Boolean wireframe
9605
        {
9606
            get
9607
            {
9608
                return this.wireframeField;
9609
            }
9610
            set
9611
            {
9612
                this.wireframeField = value;
9613
            }
9614
        }
9615

9616
        public int GetSeriesCount()
9617
        {
9618
            return this.serField == null ? 0 : this.serField.Count;
9619
        }
9620

9621
        [XmlElement("ser", Order = 1)]
9622
        public List<CT_SurfaceSer> ser
9623
        {
9624
            get
9625
            {
9626
                return this.serField;
9627
            }
9628
            set
9629
            {
9630
                this.serField = value;
9631
            }
9632
        }
9633

9634
        [XmlElement(Order = 2)]
9635
        public List<CT_BandFmt> bandFmts
9636
        {
9637
            get
9638
            {
9639
                return this.bandFmtsField;
9640
            }
9641
            set
9642
            {
9643
                this.bandFmtsField = value;
9644
            }
9645
        }
9646

9647
        [XmlElement("axId", Order = 3)]
9648
        public List<CT_UnsignedInt> axId
9649
        {
9650
            get
9651
            {
9652
                return this.axIdField;
9653
            }
9654
            set
9655
            {
9656
                this.axIdField = value;
9657
            }
9658
        }
9659

9660
        [XmlElement(Order = 4)]
9661
        public List<CT_Extension> extLst
9662
        {
9663
            get
9664
            {
9665
                return this.extLstField;
9666
            }
9667
            set
9668
            {
9669
                this.extLstField = value;
9670
            }
9671
        }
9672
    }
9673

9674

9675
    [Serializable]
9676

9677
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9678
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9679
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9680
    public class CT_SecondPieSize
9681
    {
9682

9683
        private ushort valField;
9684

9685
        public CT_SecondPieSize()
9686
        {
9687
            this.valField = ((ushort)(75));
9688
        }
9689
        public static CT_SecondPieSize Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9690
        {
9691
            if (node == null)
9692
                return null;
9693
            CT_SecondPieSize ctObj = new CT_SecondPieSize();
9694
            if (node.Attributes["val"] != null)
9695
                ctObj.val = XmlHelper.ReadUShort(node.Attributes["val"]);
9696
            return ctObj;
9697
        }
9698

9699

9700

9701
        internal void Write(StreamWriter sw, string nodeName)
9702
        {
9703
            sw.Write(string.Format("<c:{0}", nodeName));
9704
            XmlHelper.WriteAttribute(sw, "val", this.val);
9705
            sw.Write("/>");
9706
        }
9707

9708
        [XmlAttribute]
9709
        [DefaultValue(typeof(ushort), "75")]
9710
        public ushort val
9711
        {
9712
            get
9713
            {
9714
                return this.valField;
9715
            }
9716
            set
9717
            {
9718
                this.valField = value;
9719
            }
9720
        }
9721
    }
9722

9723

9724
    [Serializable]
9725

9726
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9727
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9728
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9729
    public class CT_SplitType
9730
    {
9731

9732
        private ST_SplitType valField;
9733

9734
        public CT_SplitType()
9735
        {
9736
            this.valField = ST_SplitType.auto;
9737
        }
9738
        public static CT_SplitType Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9739
        {
9740
            if (node == null)
9741
                return null;
9742
            CT_SplitType ctObj = new CT_SplitType();
9743
            if (node.Attributes["val"] != null)
9744
                ctObj.val = (ST_SplitType)Enum.Parse(typeof(ST_SplitType), node.Attributes["val"].Value);
9745
            return ctObj;
9746
        }
9747

9748

9749

9750
        internal void Write(StreamWriter sw, string nodeName)
9751
        {
9752
            sw.Write(string.Format("<c:{0}", nodeName));
9753
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
9754
            sw.Write("/>");
9755
        }
9756

9757
        [XmlAttribute]
9758
        [DefaultValue(ST_SplitType.auto)]
9759
        public ST_SplitType val
9760
        {
9761
            get
9762
            {
9763
                return this.valField;
9764
            }
9765
            set
9766
            {
9767
                this.valField = value;
9768
            }
9769
        }
9770
    }
9771

9772

9773
    [Serializable]
9774
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9775
    public enum ST_SplitType
9776
    {
9777

9778
        /// <remarks/>
9779
        auto,
9780

9781
        /// <remarks/>
9782
        cust,
9783

9784
        /// <remarks/>
9785
        percent,
9786

9787
        /// <remarks/>
9788
        pos,
9789

9790
        /// <remarks/>
9791
        val,
9792
    }
9793

9794

9795
    [Serializable]
9796

9797
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9798
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9799
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9800
    public class CT_GapAmount
9801
    {
9802

9803
        private ushort valField;
9804

9805
        public CT_GapAmount()
9806
        {
9807
            this.valField = ((ushort)(150));
9808
        }
9809
        public static CT_GapAmount Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9810
        {
9811
            if (node == null)
9812
                return null;
9813
            CT_GapAmount ctObj = new CT_GapAmount();
9814
            if (node.Attributes["val"]!=null)
9815
                ctObj.val = XmlHelper.ReadUShort(node.Attributes["val"]);
9816
            return ctObj;
9817
        }
9818

9819

9820

9821
        internal void Write(StreamWriter sw, string nodeName)
9822
        {
9823
            sw.Write(string.Format("<c:{0}", nodeName));
9824
            XmlHelper.WriteAttribute(sw, "val", this.val);
9825
            sw.Write("/>");
9826
        }
9827

9828
        [XmlAttribute]
9829
        [DefaultValue(typeof(ushort), "150")]
9830
        public ushort val
9831
        {
9832
            get
9833
            {
9834
                return this.valField;
9835
            }
9836
            set
9837
            {
9838
                this.valField = value;
9839
            }
9840
        }
9841
    }
9842

9843

9844

9845
    [Serializable]
9846

9847
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9848
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9849
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9850
    public class CT_Shape
9851
    {
9852

9853
        private ST_Shape valField;
9854

9855
        public CT_Shape()
9856
        {
9857
            this.valField = ST_Shape.box;
9858
        }
9859
        public static CT_Shape Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9860
        {
9861
            if (node == null)
9862
                return null;
9863
            CT_Shape ctObj = new CT_Shape();
9864
            if (node.Attributes["val"] != null)
9865
                ctObj.val = (ST_Shape)Enum.Parse(typeof(ST_Shape), node.Attributes["val"].Value);
9866
            return ctObj;
9867
        }
9868

9869

9870

9871
        internal void Write(StreamWriter sw, string nodeName)
9872
        {
9873
            sw.Write(string.Format("<c:{0}", nodeName));
9874
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
9875
            sw.Write("/>");
9876
        }
9877

9878
        [XmlAttribute]
9879
        [DefaultValue(ST_Shape.box)]
9880
        public ST_Shape val
9881
        {
9882
            get
9883
            {
9884
                return this.valField;
9885
            }
9886
            set
9887
            {
9888
                this.valField = value;
9889
            }
9890
        }
9891
    }
9892

9893

9894
    [Serializable]
9895
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9896
    public enum ST_Shape
9897
    {
9898

9899
        /// <remarks/>
9900
        cone,
9901

9902
        /// <remarks/>
9903
        coneToMax,
9904

9905
        /// <remarks/>
9906
        box,
9907

9908
        /// <remarks/>
9909
        cylinder,
9910

9911
        /// <remarks/>
9912
        pyramid,
9913

9914
        /// <remarks/>
9915
        pyramidToMax,
9916
    }
9917

9918

9919
    [Serializable]
9920

9921
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9922
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9923
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9924
    public class CT_Overlap
9925
    {
9926
        public static CT_Overlap Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9927
        {
9928
            if (node == null)
9929
                return null;
9930
            CT_Overlap ctObj = new CT_Overlap();
9931
            if (node.Attributes["val"] != null)
9932
                ctObj.val = XmlHelper.ReadSByte(node.Attributes["val"]);
9933
            return ctObj;
9934
        }
9935

9936

9937

9938
        internal void Write(StreamWriter sw, string nodeName)
9939
        {
9940
            sw.Write(string.Format("<c:{0}", nodeName));
9941
            XmlHelper.WriteAttribute(sw, "val", this.val);
9942
            sw.Write("/>");
9943
        }
9944

9945
        private sbyte valField;
9946

9947
        public CT_Overlap()
9948
        {
9949
            this.valField = ((sbyte)(0));
9950
        }
9951

9952
        [XmlAttribute]
9953
        [DefaultValue(typeof(sbyte), "0")]
9954
        public sbyte val
9955
        {
9956
            get
9957
            {
9958
                return this.valField;
9959
            }
9960
            set
9961
            {
9962
                this.valField = value;
9963
            }
9964
        }
9965
    }
9966

9967

9968

9969
    [Serializable]
9970

9971
    [System.ComponentModel.DesignerCategoryAttribute("code")]
9972
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
9973
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
9974
    public class CT_Grouping
9975
    {
9976

9977
        private ST_Grouping valField;
9978

9979
        public CT_Grouping()
9980
        {
9981
            this.valField = ST_Grouping.standard;
9982
        }
9983
        public static CT_Grouping Parse(XmlNode node, XmlNamespaceManager namespaceManager)
9984
        {
9985
            if (node == null)
9986
                return null;
9987
            CT_Grouping ctObj = new CT_Grouping();
9988
            if (node.Attributes["val"] != null)
9989
                ctObj.val = (ST_Grouping)Enum.Parse(typeof(ST_Grouping), node.Attributes["val"].Value);
9990
            return ctObj;
9991
        }
9992

9993

9994

9995
        internal void Write(StreamWriter sw, string nodeName)
9996
        {
9997
            sw.Write(string.Format("<c:{0}", nodeName));
9998
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
9999
            sw.Write("/>");
10000
        }
10001

10002
        [XmlAttribute]
10003
        [DefaultValue(ST_Grouping.standard)]
10004
        public ST_Grouping val
10005
        {
10006
            get
10007
            {
10008
                return this.valField;
10009
            }
10010
            set
10011
            {
10012
                this.valField = value;
10013
            }
10014
        }
10015
    }
10016

10017

10018
    [Serializable]
10019
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
10020
    public enum ST_Grouping
10021
    {
10022

10023
        /// <remarks/>
10024
        percentStacked,
10025

10026
        /// <remarks/>
10027
        standard,
10028

10029
        /// <remarks/>
10030
        stacked,
10031
    }
10032

10033

10034

10035
    [Serializable]
10036

10037
    [System.ComponentModel.DesignerCategoryAttribute("code")]
10038
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
10039
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
10040
    public class CT_PlotArea
10041
    {
10042

10043
        private CT_Layout layoutField;
10044

10045
        private CT_DTable dTableField;
10046

10047
        private CT_ShapeProperties spPrField;
10048

10049
        private List<CT_Extension> extLstField;
10050

10051
        public CT_PlotArea()
10052
        {
10053
            //this.items1Field = new List<object>();
10054
        }
10055

10056
        public static CT_PlotArea Parse(XmlNode node, XmlNamespaceManager namespaceManager)
10057
        {
10058
            if (node == null)
10059
                return null;
10060
            CT_PlotArea ctObj = new CT_PlotArea();
10061
            ctObj.surfaceChart = new List<CT_SurfaceChart>();
10062
            ctObj.lineChart = new List<CT_LineChart>();
10063
            ctObj.bubbleChart = new List<CT_BubbleChart>();
10064
            ctObj.bar3DChart = new List<CT_Bar3DChart>();
10065
            ctObj.area3DChart = new List<CT_Area3DChart>();
10066
            ctObj.doughnutChart = new List<CT_DoughnutChart>();
10067
            ctObj.pie3DChart = new List<CT_Pie3DChart>();
10068
            ctObj.line3DChart = new List<CT_Line3DChart>();
10069
            ctObj.surface3DChart = new List<CT_Surface3DChart>();
10070
            ctObj.barChart = new List<CT_BarChart>();
10071
            ctObj.radarChart = new List<CT_RadarChart>();
10072
            ctObj.areaChart = new List<CT_AreaChart>();
10073
            ctObj.scatterChart = new List<CT_ScatterChart>();
10074
            ctObj.ofPieChart = new List<CT_OfPieChart>();
10075
            ctObj.pieChart = new List<CT_PieChart>();
10076
            ctObj.stockChart = new List<CT_StockChart>();
10077
            ctObj.valAx = new List<CT_ValAx>();
10078
            ctObj.serAx = new List<CT_SerAx>();
10079
            ctObj.dateAx = new List<CT_DateAx>();
10080
            ctObj.catAx = new List<CT_CatAx>();
10081
            ctObj.extLst = new List<CT_Extension>();
10082
            foreach (XmlNode childNode in node.ChildNodes)
10083
            {
10084
                if (childNode.LocalName == "layout")
10085
                    ctObj.layout = CT_Layout.Parse(childNode, namespaceManager);
10086
                else if (childNode.LocalName == "dTable")
10087
                    ctObj.dTable = CT_DTable.Parse(childNode, namespaceManager);
10088
                else if (childNode.LocalName == "spPr")
10089
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
10090
                else if (childNode.LocalName == "surfaceChart")
10091
                    ctObj.surfaceChart.Add(CT_SurfaceChart.Parse(childNode, namespaceManager));
10092
                else if (childNode.LocalName == "lineChart")
10093
                    ctObj.lineChart.Add(CT_LineChart.Parse(childNode, namespaceManager));
10094
                else if (childNode.LocalName == "bubbleChart")
10095
                    ctObj.bubbleChart.Add(CT_BubbleChart.Parse(childNode, namespaceManager));
10096
                else if (childNode.LocalName == "bar3DChart")
10097
                    ctObj.bar3DChart.Add(CT_Bar3DChart.Parse(childNode, namespaceManager));
10098
                else if (childNode.LocalName == "area3DChart")
10099
                    ctObj.area3DChart.Add(CT_Area3DChart.Parse(childNode, namespaceManager));
10100
                else if (childNode.LocalName == "doughnutChart")
10101
                    ctObj.doughnutChart.Add(CT_DoughnutChart.Parse(childNode, namespaceManager));
10102
                else if (childNode.LocalName == "pie3DChart")
10103
                    ctObj.pie3DChart.Add(CT_Pie3DChart.Parse(childNode, namespaceManager));
10104
                else if (childNode.LocalName == "line3DChart")
10105
                    ctObj.line3DChart.Add(CT_Line3DChart.Parse(childNode, namespaceManager));
10106
                else if (childNode.LocalName == "surface3DChart")
10107
                    ctObj.surface3DChart.Add(CT_Surface3DChart.Parse(childNode, namespaceManager));
10108
                else if (childNode.LocalName == "barChart")
10109
                    ctObj.barChart.Add(CT_BarChart.Parse(childNode, namespaceManager));
10110
                else if (childNode.LocalName == "radarChart")
10111
                    ctObj.radarChart.Add(CT_RadarChart.Parse(childNode, namespaceManager));
10112
                else if (childNode.LocalName == "areaChart")
10113
                    ctObj.areaChart.Add(CT_AreaChart.Parse(childNode, namespaceManager));
10114
                else if (childNode.LocalName == "scatterChart")
10115
                    ctObj.scatterChart.Add(CT_ScatterChart.Parse(childNode, namespaceManager));
10116
                else if (childNode.LocalName == "ofPieChart")
10117
                    ctObj.ofPieChart.Add(CT_OfPieChart.Parse(childNode, namespaceManager));
10118
                else if (childNode.LocalName == "pieChart")
10119
                    ctObj.pieChart.Add(CT_PieChart.Parse(childNode, namespaceManager));
10120
                else if (childNode.LocalName == "stockChart")
10121
                    ctObj.stockChart.Add(CT_StockChart.Parse(childNode, namespaceManager));
10122
                else if (childNode.LocalName == "valAx")
10123
                    ctObj.valAx.Add(CT_ValAx.Parse(childNode, namespaceManager));
10124
                else if (childNode.LocalName == "serAx")
10125
                    ctObj.serAx.Add(CT_SerAx.Parse(childNode, namespaceManager));
10126
                else if (childNode.LocalName == "dateAx")
10127
                    ctObj.dateAx.Add(CT_DateAx.Parse(childNode, namespaceManager));
10128
                else if (childNode.LocalName == "catAx")
10129
                    ctObj.catAx.Add(CT_CatAx.Parse(childNode, namespaceManager));
10130
                else if (childNode.LocalName == "extLst")
10131
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
10132
            }
10133
            return ctObj;
10134
        }
10135

10136

10137

10138
        internal void Write(StreamWriter sw, string nodeName)
10139
        {
10140
            sw.Write(string.Format("<c:{0}>", nodeName));
10141
            if (this.layout != null)
10142
                this.layout.Write(sw, "layout");
10143
            if (this.dTable != null)
10144
                this.dTable.Write(sw, "dTable");
10145
            if (this.surfaceChart != null)
10146
            {
10147
                foreach (CT_SurfaceChart x in this.surfaceChart)
10148
                {
10149
                    x.Write(sw, "surfaceChart");
10150
                }
10151
            }
10152
            if (this.bubbleChart != null)
10153
            {
10154
                foreach (CT_BubbleChart x in this.bubbleChart)
10155
                {
10156
                    x.Write(sw, "bubbleChart");
10157
                }
10158
            }
10159
            if (this.bar3DChart != null)
10160
            {
10161
                foreach (CT_Bar3DChart x in this.bar3DChart)
10162
                {
10163
                    x.Write(sw, "bar3DChart");
10164
                }
10165
            }
10166
            if (this.area3DChart != null)
10167
            {
10168
                foreach (CT_Area3DChart x in this.area3DChart)
10169
                {
10170
                    x.Write(sw, "area3DChart");
10171
                }
10172
            }
10173
            if (this.doughnutChart != null)
10174
            {
10175
                foreach (CT_DoughnutChart x in this.doughnutChart)
10176
                {
10177
                    x.Write(sw, "doughnutChart");
10178
                }
10179
            }
10180
            if (this.pie3DChart != null)
10181
            {
10182
                foreach (CT_Pie3DChart x in this.pie3DChart)
10183
                {
10184
                    x.Write(sw, "pie3DChart");
10185
                }
10186
            }
10187
            if (this.line3DChart != null)
10188
            {
10189
                foreach (CT_Line3DChart x in this.line3DChart)
10190
                {
10191
                    x.Write(sw, "line3DChart");
10192
                }
10193
            }
10194
            if (this.surface3DChart != null)
10195
            {
10196
                foreach (CT_Surface3DChart x in this.surface3DChart)
10197
                {
10198
                    x.Write(sw, "surface3DChart");
10199
                }
10200
            }
10201
            if (this.barChart != null)
10202
            {
10203
                foreach (CT_BarChart x in this.barChart)
10204
                {
10205
                    x.Write(sw, "barChart");
10206
                }
10207
            }
10208
            if (this.lineChart != null)
10209
            {
10210
                foreach (CT_LineChart x in this.lineChart)
10211
                {
10212
                    x.Write(sw, "lineChart");
10213
                }
10214
            }
10215
            if (this.radarChart != null)
10216
            {
10217
                foreach (CT_RadarChart x in this.radarChart)
10218
                {
10219
                    x.Write(sw, "radarChart");
10220
                }
10221
            }
10222
            if (this.areaChart != null)
10223
            {
10224
                foreach (CT_AreaChart x in this.areaChart)
10225
                {
10226
                    x.Write(sw, "areaChart");
10227
                }
10228
            }
10229
            if (this.scatterChart != null)
10230
            {
10231
                foreach (CT_ScatterChart x in this.scatterChart)
10232
                {
10233
                    x.Write(sw, "scatterChart");
10234
                }
10235
            }
10236
            if (this.ofPieChart != null)
10237
            {
10238
                foreach (CT_OfPieChart x in this.ofPieChart)
10239
                {
10240
                    x.Write(sw, "ofPieChart");
10241
                }
10242
            }
10243
            if (this.pieChart != null)
10244
            {
10245
                foreach (CT_PieChart x in this.pieChart)
10246
                {
10247
                    x.Write(sw, "pieChart");
10248
                }
10249
            }
10250
            if (this.stockChart != null)
10251
            {
10252
                foreach (CT_StockChart x in this.stockChart)
10253
                {
10254
                    x.Write(sw, "stockChart");
10255
                }
10256
            }
10257
            if (this.serAx != null)
10258
            {
10259
                foreach (CT_SerAx x in this.serAx)
10260
                {
10261
                    x.Write(sw, "serAx");
10262
                }
10263
            }
10264
            if (this.dateAx != null)
10265
            {
10266
                foreach (CT_DateAx x in this.dateAx)
10267
                {
10268
                    x.Write(sw, "dateAx");
10269
                }
10270
            }
10271
            if (this.valAx != null)
10272
            {
10273
                foreach (CT_ValAx x in this.valAx)
10274
                {
10275
                    x.Write(sw, "valAx");
10276
                }
10277
            }
10278
            if (this.catAx != null)
10279
            {
10280
                foreach (CT_CatAx x in this.catAx)
10281
                {
10282
                    x.Write(sw, "catAx");
10283
                }
10284
            }
10285
            if (this.spPr != null)
10286
                this.spPr.Write(sw, "spPr");
10287
            if (this.extLst != null)
10288
            {
10289
                foreach (CT_Extension x in this.extLst)
10290
                {
10291
                    x.Write(sw, "extLst");
10292
                }
10293
            }
10294
            sw.Write(string.Format("</c:{0}>", nodeName));
10295
        }
10296

10297
        List<CT_ValAx> valAxField;
10298
        List<CT_SerAx> serAxField;
10299
        List<CT_CatAx> catAxField;
10300
        List<CT_DateAx> dateAxField;
10301
        public CT_ValAx AddNewValAx()
10302
        {
10303
            if (valAxField == null)
10304
                valAxField = new List<CT_ValAx>();
10305
            CT_ValAx val = new CT_ValAx();
10306
            this.valAxField.Add(val);
10307
            return val;
10308
        }
10309

10310
        public CT_SerAx AddNewSerAx()
10311
        {
10312
            if (serAxField == null)
10313
                serAxField = new List<CT_SerAx>();
10314
            CT_SerAx val = new CT_SerAx();
10315
            this.serAxField.Add(val);
10316
            return val;
10317
        }
10318
        public bool IsSetLayout()
10319
        {
10320
            return this.layoutField != null;
10321
        }
10322
        [XmlElement(Order = 0)]
10323
        public CT_Layout layout
10324
        {
10325
            get
10326
            {
10327
                return this.layoutField;
10328
            }
10329
            set
10330
            {
10331
                this.layoutField = value;
10332
            }
10333
        }
10334
        public CT_Layout AddNewLayout()
10335
        {
10336
            this.layoutField = new CT_Layout();
10337
            return this.layoutField;
10338
        }
10339
        //[XmlElement("area3DChart", typeof(CT_Area3DChart), Order = 1)]
10340
        //[XmlElement("areaChart", typeof(CT_AreaChart), Order = 1)]
10341
        //[XmlElement("bar3DChart", typeof(CT_Bar3DChart), Order = 1)]
10342
        //[XmlElement("barChart", typeof(CT_BarChart), Order = 1)]
10343
        //[XmlElement("bubbleChart", typeof(CT_BubbleChart), Order = 1)]
10344
        //[XmlElement("doughnutChart", typeof(CT_DoughnutChart), Order = 1)]
10345
        //[XmlElement("line3DChart", typeof(CT_Line3DChart), Order = 1)]
10346
        //[XmlElement("lineChart", typeof(CT_LineChart), Order = 1)]
10347
        //[XmlElement("ofPieChart", typeof(CT_OfPieChart), Order = 1)]
10348
        //[XmlElement("pie3DChart", typeof(CT_Pie3DChart), Order = 1)]
10349
        //[XmlElement("pieChart", typeof(CT_PieChart), Order = 1)]
10350
        //[XmlElement("radarChart", typeof(CT_RadarChart), Order = 1)]
10351
        //[XmlElement("scatterChart", typeof(CT_ScatterChart), Order = 1)]
10352
        //[XmlElement("stockChart", typeof(CT_StockChart), Order = 1)]
10353
        //[XmlElement("surface3DChart", typeof(CT_Surface3DChart), Order = 1)]
10354
        //[XmlElement("surfaceChart", typeof(CT_SurfaceChart), Order = 1)]
10355
        //public List<object> Items
10356
        //{
10357
        //    get
10358
        //    {
10359
        //        return this.itemsField;
10360
        //    }
10361
        //    set
10362
        //    {
10363
        //        this.itemsField = value;
10364
        //    }
10365
        //}
10366
        public CT_Pie3DChart AddNewPie3DChart()
10367
        {
10368
            if (this.pie3DChartField == null)
10369
                this.pie3DChartField = new List<CT_Pie3DChart>();
10370
            CT_Pie3DChart newobj = new CT_Pie3DChart();
10371
            this.pie3DChartField.Add(newobj);
10372
            return newobj;
10373
        }
10374

10375
        public CT_PieChart AddNewPieChart()
10376
        {
10377
            if (this.pieChartField == null)
10378
                this.pieChartField = new List<CT_PieChart>();
10379
            CT_PieChart newobj = new CT_PieChart();
10380
            this.pieChartField.Add(newobj);
10381
            return newobj;
10382
        }
10383

10384
        public CT_ScatterChart AddNewScatterChart()
10385
        {
10386
            if (this.scatterChartField == null)
10387
                this.scatterChartField = new List<CT_ScatterChart>();
10388
            CT_ScatterChart newobj = new CT_ScatterChart();
10389
            this.scatterChartField.Add(newobj);
10390
            return newobj;
10391
        }
10392

10393
        public int GetAllSeriesCount()
10394
        {
10395
            return (surfaceChartField == null ? 0 : surfaceChartField.Select(x=>x.GetSeriesCount()).Sum())
10396
                + (lineChartField == null ? 0 : lineChartField.Select(x => x.GetSeriesCount()).Sum())
10397
                + (bubbleChartField == null ? 0 : bubbleChartField.Select(x => x.GetSeriesCount()).Sum())
10398
                + (bar3DChartField == null ? 0 : bar3DChartField.Select(x => x.GetSeriesCount()).Sum())
10399
                + (area3DChartField == null ? 0 : area3DChartField.Select(x => x.GetSeriesCount()).Sum())
10400
                + (doughnutChartField == null ? 0 : doughnutChartField.Select(x => x.GetSeriesCount()).Sum())
10401
                + (pie3DChartField == null ? 0 : pie3DChartField.Select(x => x.GetSeriesCount()).Sum())
10402
                + (line3DChartField == null ? 0 : line3DChartField.Select(x => x.GetSeriesCount()).Sum())
10403
                + (surface3DChartField == null ? 0 : surface3DChartField.Select(x => x.GetSeriesCount()).Sum())
10404
                + (barChartField == null ? 0 : barChartField.Select(x => x.GetSeriesCount()).Sum())
10405
                + (radarChartField == null ? 0 : radarChartField.Select(x => x.GetSeriesCount()).Sum())
10406
                + (areaChartField == null ? 0 : areaChartField.Select(x => x.GetSeriesCount()).Sum())
10407
                + (scatterChartField == null ? 0 : scatterChartField.Select(x => x.GetSeriesCount()).Sum())
10408
                + (ofPieChartField == null ? 0 : ofPieChartField.Select(x => x.GetSeriesCount()).Sum())
10409
                + (pieChartField == null ? 0 : pieChartField.Select(x => x.GetSeriesCount()).Sum())
10410
                + (stockChartField == null ? 0 : stockChartField.Select(x => x.GetSeriesCount()).Sum());
10411
        }
10412

10413
        List<CT_SurfaceChart> surfaceChartField;
10414
        public List<CT_SurfaceChart> surfaceChart
10415
        {
10416
            get { return this.surfaceChartField; }
10417
            set { this.surfaceChartField = value; }
10418
        }
10419

10420
        List<CT_LineChart> lineChartField;
10421
        public List<CT_LineChart> lineChart
10422
        {
10423
            get { return this.lineChartField; }
10424
            set { this.lineChartField = value; }
10425
        }
10426

10427
        List<CT_BubbleChart> bubbleChartField;
10428
        public List<CT_BubbleChart> bubbleChart
10429
        {
10430
            get { return this.bubbleChartField; }
10431
            set { this.bubbleChartField = value; }
10432
        }
10433

10434
        List<CT_Bar3DChart> bar3DChartField;
10435
        public List<CT_Bar3DChart> bar3DChart
10436
        {
10437
            get { return this.bar3DChartField; }
10438
            set { this.bar3DChartField = value; }
10439
        }
10440

10441
        List<CT_Area3DChart> area3DChartField;
10442
        public List<CT_Area3DChart> area3DChart
10443
        {
10444
            get { return this.area3DChartField; }
10445
            set { this.area3DChartField = value; }
10446
        }
10447

10448
        List<CT_DoughnutChart> doughnutChartField;
10449
        public List<CT_DoughnutChart> doughnutChart
10450
        {
10451
            get { return this.doughnutChartField; }
10452
            set { this.doughnutChartField = value; }
10453
        }
10454

10455
        List<CT_Pie3DChart> pie3DChartField;
10456
        public List<CT_Pie3DChart> pie3DChart
10457
        {
10458
            get { return this.pie3DChartField; }
10459
            set { this.pie3DChartField = value; }
10460
        }
10461

10462
        List<CT_Line3DChart> line3DChartField;
10463
        public List<CT_Line3DChart> line3DChart
10464
        {
10465
            get { return this.line3DChartField; }
10466
            set { this.line3DChartField = value; }
10467
        }
10468

10469
        List<CT_Surface3DChart> surface3DChartField;
10470
        public List<CT_Surface3DChart> surface3DChart
10471
        {
10472
            get { return this.surface3DChartField; }
10473
            set { this.surface3DChartField = value; }
10474
        }
10475

10476
        List<CT_BarChart> barChartField;
10477
        public List<CT_BarChart> barChart
10478
        {
10479
            get { return this.barChartField; }
10480
            set { this.barChartField = value; }
10481
        }
10482

10483
        List<CT_RadarChart> radarChartField;
10484
        public List<CT_RadarChart> radarChart
10485
        {
10486
            get { return this.radarChartField; }
10487
            set { this.radarChartField = value; }
10488
        }
10489

10490
        List<CT_AreaChart> areaChartField;
10491
        public List<CT_AreaChart> areaChart
10492
        {
10493
            get { return this.areaChartField; }
10494
            set { this.areaChartField = value; }
10495
        }
10496

10497
        List<CT_ScatterChart> scatterChartField;
10498
        public List<CT_ScatterChart> scatterChart
10499
        {
10500
            get { return this.scatterChartField; }
10501
            set { this.scatterChartField = value; }
10502
        }
10503

10504
        List<CT_OfPieChart> ofPieChartField;
10505
        public List<CT_OfPieChart> ofPieChart
10506
        {
10507
            get { return this.ofPieChartField; }
10508
            set { this.ofPieChartField = value; }
10509
        }
10510

10511
        List<CT_PieChart> pieChartField;
10512
        public List<CT_PieChart> pieChart
10513
        {
10514
            get { return this.pieChartField; }
10515
            set { this.pieChartField = value; }
10516
        }
10517

10518
        List<CT_StockChart> stockChartField;
10519
        public List<CT_StockChart> stockChart
10520
        {
10521
            get { return this.stockChartField; }
10522
            set { this.stockChartField = value; }
10523
        }
10524

10525

10526
        [XmlElement(Order = 21)]
10527
        public List<CT_ValAx> valAx
10528
        {
10529
            get
10530
            {
10531
                return this.valAxField;
10532
            }
10533
            set
10534
            {
10535
                this.valAxField = value;
10536
            }
10537
        }
10538

10539
        [XmlElement(Order = 22)]
10540
        public List<CT_SerAx> serAx
10541
        {
10542
            get
10543
            {
10544
                return this.serAxField;
10545
            }
10546
            set
10547
            {
10548
                this.serAxField = value;
10549
            }
10550
        }
10551
        [XmlElement(Order = 23)]
10552
        public List<CT_DateAx> dateAx
10553
        {
10554
            get
10555
            {
10556
                return this.dateAxField;
10557
            }
10558
            set
10559
            {
10560
                this.dateAxField = value;
10561
            }
10562
        }
10563
        [XmlElement(Order = 24)]
10564
        public List<CT_CatAx> catAx
10565
        {
10566
            get
10567
            {
10568
                return this.catAxField;
10569
            }
10570
            set
10571
            {
10572
                this.catAxField = value;
10573
            }
10574
        }
10575
        [XmlElement(Order = 25)]
10576
        public CT_DTable dTable
10577
        {
10578
            get
10579
            {
10580
                return this.dTableField;
10581
            }
10582
            set
10583
            {
10584
                this.dTableField = value;
10585
            }
10586
        }
10587

10588
        [XmlElement(Order = 26)]
10589
        public CT_ShapeProperties spPr
10590
        {
10591
            get
10592
            {
10593
                return this.spPrField;
10594
            }
10595
            set
10596
            {
10597
                this.spPrField = value;
10598
            }
10599
        }
10600

10601
        [XmlElement(Order = 27)]
10602
        public List<CT_Extension> extLst
10603
        {
10604
            get
10605
            {
10606
                return this.extLstField;
10607
            }
10608
            set
10609
            {
10610
                this.extLstField = value;
10611
            }
10612
        }
10613

10614
        public CT_BarChart AddNewBarChart()
10615
        {
10616
            CT_BarChart ctchart = new CT_BarChart();
10617
            if (this.barChartField == null)
10618
            {
10619
                this.barChartField = new List<CT_BarChart>();
10620
            }
10621
            this.barChartField.Add(ctchart);
10622
            return ctchart;
10623
        }
10624

10625
        public CT_AreaChart AddNewAreaChart()
10626
        {
10627
            CT_AreaChart ctchart = new CT_AreaChart();
10628
            if (this.areaChartField == null)
10629
            {
10630
                this.areaChartField = new List<CT_AreaChart>();
10631
            }
10632
            this.areaChartField.Add(ctchart);
10633
            return ctchart;
10634
        }
10635

10636
        public CT_LineChart AddNewLineChart()
10637
        {
10638
            CT_LineChart ctchart = new CT_LineChart();
10639
            if(this.lineChartField==null)
10640
                this.lineChartField = new List<CT_LineChart>();
10641
            lineChartField.Add(ctchart);
10642
            return ctchart;
10643
        }
10644

10645
        public CT_CatAx AddNewCatAx()
10646
        {
10647
            CT_CatAx newax = new CT_CatAx();
10648
            if(this.catAxField==null)
10649
                this.catAxField = new List<CT_CatAx>();
10650
            this.catAxField.Add(newax);
10651
            return newax;
10652
        }
10653

10654
        public CT_DateAx AddNewDateAx()
10655
        {
10656
            CT_DateAx newax = new CT_DateAx();
10657
            if (this.dateAxField == null)
10658
            {
10659
                this.dateAxField = new List<CT_DateAx>();
10660
            }
10661
            this.dateAxField.Add(newax);
10662
            return newax;
10663
        }
10664
    }
10665

10666

10667

10668
    [Serializable]
10669

10670
    [System.ComponentModel.DesignerCategoryAttribute("code")]
10671
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
10672
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
10673
    public class CT_Perspective
10674
    {
10675

10676
        private byte valField;
10677

10678
        public CT_Perspective()
10679
        {
10680
            this.valField = ((byte)(30));
10681
        }
10682
        public static CT_Perspective Parse(XmlNode node, XmlNamespaceManager namespaceManager)
10683
        {
10684
            if (node == null)
10685
                return null;
10686
            CT_Perspective ctObj = new CT_Perspective();
10687
            if (node.Attributes["val"]!=null)
10688
                ctObj.val = XmlHelper.ReadByte(node.Attributes["val"]);
10689
            return ctObj;
10690
        }
10691

10692

10693

10694
        internal void Write(StreamWriter sw, string nodeName)
10695
        {
10696
            sw.Write(string.Format("<c:{0}", nodeName));
10697
            if(this.val!=30)
10698
                XmlHelper.WriteAttribute(sw, "val", this.val);
10699
            sw.Write("/>");
10700
        }
10701

10702
        [XmlAttribute]
10703
        [DefaultValue(typeof(byte), "30")]
10704
        public byte val
10705
        {
10706
            get
10707
            {
10708
                return this.valField;
10709
            }
10710
            set
10711
            {
10712
                this.valField = value;
10713
            }
10714
        }
10715
    }
10716

10717

10718
    [Serializable]
10719

10720
    [System.ComponentModel.DesignerCategoryAttribute("code")]
10721
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
10722
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
10723
    public class CT_DepthPercent
10724
    {
10725

10726
        private ushort valField;
10727

10728
        public CT_DepthPercent()
10729
        {
10730
            this.valField = ((ushort)(100));
10731
        }
10732

10733
        [XmlAttribute]
10734
        [DefaultValue(typeof(ushort), "100")]
10735
        public ushort val
10736
        {
10737
            get
10738
            {
10739
                return this.valField;
10740
            }
10741
            set
10742
            {
10743
                this.valField = value;
10744
            }
10745
        }
10746
        public static CT_DepthPercent Parse(XmlNode node, XmlNamespaceManager namespaceManager)
10747
        {
10748
            if (node == null)
10749
                return null;
10750
            CT_DepthPercent ctObj = new CT_DepthPercent();
10751
            if (node.Attributes["val"]!=null)
10752
                ctObj.val = XmlHelper.ReadUShort(node.Attributes["val"]);
10753
            return ctObj;
10754
        }
10755

10756

10757

10758
        internal void Write(StreamWriter sw, string nodeName)
10759
        {
10760
            sw.Write(string.Format("<c:{0}", nodeName));
10761
            if(valField!=100)
10762
                XmlHelper.WriteAttribute(sw, "val", this.val);
10763
            sw.Write("/>");
10764
        }
10765

10766
    }
10767

10768

10769
    [Serializable]
10770

10771
    [System.ComponentModel.DesignerCategoryAttribute("code")]
10772
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
10773
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
10774
    public class CT_RotY
10775
    {
10776

10777
        private ushort valField;
10778

10779
        public CT_RotY()
10780
        {
10781
            this.valField = ((ushort)(0));
10782
        }
10783
        public static CT_RotY Parse(XmlNode node, XmlNamespaceManager namespaceManager)
10784
        {
10785
            if (node == null)
10786
                return null;
10787
            CT_RotY ctObj = new CT_RotY();
10788
            ctObj.val = XmlHelper.ReadUShort(node.Attributes["val"]);
10789
            return ctObj;
10790
        }
10791

10792

10793

10794
        internal void Write(StreamWriter sw, string nodeName)
10795
        {
10796
            sw.Write(string.Format("<c:{0}", nodeName));
10797
            XmlHelper.WriteAttribute(sw, "val", this.val);
10798
            sw.Write("/>");
10799
        }
10800

10801

10802
        [XmlAttribute]
10803
        [DefaultValue(typeof(ushort), "0")]
10804
        public ushort val
10805
        {
10806
            get
10807
            {
10808
                return this.valField;
10809
            }
10810
            set
10811
            {
10812
                this.valField = value;
10813
            }
10814
        }
10815
    }
10816

10817

10818
    [Serializable]
10819

10820
    [System.ComponentModel.DesignerCategoryAttribute("code")]
10821
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
10822
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
10823
    public class CT_HPercent
10824
    {
10825
        public static CT_HPercent Parse(XmlNode node, XmlNamespaceManager namespaceManager)
10826
        {
10827
            if (node == null)
10828
                return null;
10829
            CT_HPercent ctObj = new CT_HPercent();
10830
            ctObj.val = XmlHelper.ReadUShort(node.Attributes["val"]);
10831
            return ctObj;
10832
        }
10833

10834

10835

10836
        internal void Write(StreamWriter sw, string nodeName)
10837
        {
10838
            sw.Write(string.Format("<c:{0}", nodeName));
10839
            XmlHelper.WriteAttribute(sw, "val", this.val);
10840
            sw.Write("/>");
10841
        }
10842

10843

10844
        private ushort valField;
10845

10846
        public CT_HPercent()
10847
        {
10848
            this.valField = ((ushort)(100));
10849
        }
10850

10851
        [XmlAttribute]
10852
        [DefaultValue(typeof(ushort), "100")]
10853
        public ushort val
10854
        {
10855
            get
10856
            {
10857
                return this.valField;
10858
            }
10859
            set
10860
            {
10861
                this.valField = value;
10862
            }
10863
        }
10864
    }
10865

10866

10867
    [Serializable]
10868

10869
    [System.ComponentModel.DesignerCategoryAttribute("code")]
10870
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
10871
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
10872
    public class CT_RotX
10873
    {
10874

10875
        private sbyte valField;
10876

10877
        public CT_RotX()
10878
        {
10879
            this.valField = ((sbyte)(0));
10880
        }
10881
        public static CT_RotX Parse(XmlNode node, XmlNamespaceManager namespaceManager)
10882
        {
10883
            if (node == null)
10884
                return null;
10885
            CT_RotX ctObj = new CT_RotX();
10886
            ctObj.val = XmlHelper.ReadSByte(node.Attributes["val"]);
10887
            return ctObj;
10888
        }
10889

10890

10891

10892
        internal void Write(StreamWriter sw, string nodeName)
10893
        {
10894
            sw.Write(string.Format("<c:{0}", nodeName));
10895
            XmlHelper.WriteAttribute(sw, "val", this.val);
10896
            sw.Write("/>");
10897
        }
10898

10899

10900
        [XmlAttribute]
10901
        [DefaultValue(typeof(sbyte), "0")]
10902
        public sbyte val
10903
        {
10904
            get
10905
            {
10906
                return this.valField;
10907
            }
10908
            set
10909
            {
10910
                this.valField = value;
10911
            }
10912
        }
10913
    }
10914

10915

10916
    [Serializable]
10917

10918
    [System.ComponentModel.DesignerCategoryAttribute("code")]
10919
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
10920
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
10921
    public class CT_View3D
10922
    {
10923

10924
        private CT_RotX rotXField;
10925

10926
        private CT_HPercent hPercentField;
10927

10928
        private CT_RotY rotYField;
10929

10930
        private CT_DepthPercent depthPercentField;
10931

10932
        private CT_Boolean rAngAxField;
10933

10934
        private CT_Perspective perspectiveField;
10935

10936
        private List<CT_Extension> extLstField;
10937

10938
        public CT_View3D()
10939
        {
10940

10941
        }
10942
        public static CT_View3D Parse(XmlNode node, XmlNamespaceManager namespaceManager)
10943
        {
10944
            if (node == null)
10945
                return null;
10946
            CT_View3D ctObj = new CT_View3D();
10947
            ctObj.extLst = new List<CT_Extension>();
10948
            foreach (XmlNode childNode in node.ChildNodes)
10949
            {
10950
                if (childNode.LocalName == "rotX")
10951
                    ctObj.rotX = CT_RotX.Parse(childNode, namespaceManager);
10952
                else if (childNode.LocalName == "hPercent")
10953
                    ctObj.hPercent = CT_HPercent.Parse(childNode, namespaceManager);
10954
                else if (childNode.LocalName == "rotY")
10955
                    ctObj.rotY = CT_RotY.Parse(childNode, namespaceManager);
10956
                else if (childNode.LocalName == "depthPercent")
10957
                    ctObj.depthPercent = CT_DepthPercent.Parse(childNode, namespaceManager);
10958
                else if (childNode.LocalName == "rAngAx")
10959
                    ctObj.rAngAx = CT_Boolean.Parse(childNode, namespaceManager);
10960
                else if (childNode.LocalName == "perspective")
10961
                    ctObj.perspective = CT_Perspective.Parse(childNode, namespaceManager);
10962
                else if (childNode.LocalName == "extLst")
10963
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
10964
            }
10965
            return ctObj;
10966
        }
10967

10968

10969

10970
        internal void Write(StreamWriter sw, string nodeName)
10971
        {
10972
            sw.Write(string.Format("<c:{0}", nodeName));
10973
            sw.Write(">");
10974
            if (this.rotX != null)
10975
                this.rotX.Write(sw, "rotX");
10976
            if (this.hPercent != null)
10977
                this.hPercent.Write(sw, "hPercent");
10978
            if (this.rotY != null)
10979
                this.rotY.Write(sw, "rotY");
10980
            if (this.depthPercent != null)
10981
                this.depthPercent.Write(sw, "depthPercent");
10982
            if (this.rAngAx != null)
10983
                this.rAngAx.Write(sw, "rAngAx");
10984
            if (this.perspective != null)
10985
                this.perspective.Write(sw, "perspective");
10986
            if (this.extLst != null)
10987
            {
10988
                foreach (CT_Extension x in this.extLst)
10989
                {
10990
                    x.Write(sw, "extLst");
10991
                }
10992
            }
10993
            sw.Write(string.Format("</c:{0}>", nodeName));
10994
        }
10995

10996
        [XmlElement(Order = 0)]
10997
        public CT_RotX rotX
10998
        {
10999
            get
11000
            {
11001
                return this.rotXField;
11002
            }
11003
            set
11004
            {
11005
                this.rotXField = value;
11006
            }
11007
        }
11008

11009
        [XmlElement(Order = 1)]
11010
        public CT_HPercent hPercent
11011
        {
11012
            get
11013
            {
11014
                return this.hPercentField;
11015
            }
11016
            set
11017
            {
11018
                this.hPercentField = value;
11019
            }
11020
        }
11021

11022
        [XmlElement(Order = 2)]
11023
        public CT_RotY rotY
11024
        {
11025
            get
11026
            {
11027
                return this.rotYField;
11028
            }
11029
            set
11030
            {
11031
                this.rotYField = value;
11032
            }
11033
        }
11034

11035
        [XmlElement(Order = 3)]
11036
        public CT_DepthPercent depthPercent
11037
        {
11038
            get
11039
            {
11040
                return this.depthPercentField;
11041
            }
11042
            set
11043
            {
11044
                this.depthPercentField = value;
11045
            }
11046
        }
11047

11048
        [XmlElement(Order = 4)]
11049
        public CT_Boolean rAngAx
11050
        {
11051
            get
11052
            {
11053
                return this.rAngAxField;
11054
            }
11055
            set
11056
            {
11057
                this.rAngAxField = value;
11058
            }
11059
        }
11060

11061
        [XmlElement(Order = 5)]
11062
        public CT_Perspective perspective
11063
        {
11064
            get
11065
            {
11066
                return this.perspectiveField;
11067
            }
11068
            set
11069
            {
11070
                this.perspectiveField = value;
11071
            }
11072
        }
11073

11074
        [XmlElement(Order = 6)]
11075
        public List<CT_Extension> extLst
11076
        {
11077
            get
11078
            {
11079
                return this.extLstField;
11080
            }
11081
            set
11082
            {
11083
                this.extLstField = value;
11084
            }
11085
        }
11086
    }
11087

11088

11089
    [Serializable]
11090

11091
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11092
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11093
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
11094
    public class CT_PivotFmt
11095
    {
11096

11097
        private CT_UnsignedInt idxField;
11098

11099
        private CT_ShapeProperties spPrField;
11100

11101
        private CT_TextBody txPrField;
11102

11103
        private CT_Marker markerField;
11104

11105
        private CT_DLbl dLblField;
11106

11107
        private List<CT_Extension> extLstField;
11108

11109
        public CT_PivotFmt()
11110
        {
11111
            //this.extLstField = new List<CT_Extension>();
11112
            //this.dLblField = new CT_DLbl();
11113
            //this.markerField = new CT_Marker();
11114
            //this.idxField = new CT_UnsignedInt();
11115
        }
11116
        public static CT_PivotFmt Parse(XmlNode node, XmlNamespaceManager namespaceManager)
11117
        {
11118
            if (node == null)
11119
                return null;
11120
            CT_PivotFmt ctObj = new CT_PivotFmt();
11121
            ctObj.extLst = new List<CT_Extension>();
11122
            foreach (XmlNode childNode in node.ChildNodes)
11123
            {
11124
                if (childNode.LocalName == "idx")
11125
                    ctObj.idx = CT_UnsignedInt.Parse(childNode, namespaceManager);
11126
                else if (childNode.LocalName == "spPr")
11127
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
11128
                else if (childNode.LocalName == "txPr")
11129
                    ctObj.txPr = CT_TextBody.Parse(childNode, namespaceManager);
11130
                else if (childNode.LocalName == "marker")
11131
                    ctObj.marker = CT_Marker.Parse(childNode, namespaceManager);
11132
                else if (childNode.LocalName == "dLbl")
11133
                    ctObj.dLbl = CT_DLbl.Parse(childNode, namespaceManager);
11134
                else if (childNode.LocalName == "extLst")
11135
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
11136
            }
11137
            return ctObj;
11138
        }
11139

11140

11141

11142
        internal void Write(StreamWriter sw, string nodeName)
11143
        {
11144
            sw.Write(string.Format("<c:{0}", nodeName));
11145
            sw.Write(">");
11146
            if (this.idx != null)
11147
                this.idx.Write(sw, "idx");
11148
            if (this.spPr != null)
11149
                this.spPr.Write(sw, "spPr");
11150
            if (this.txPr != null)
11151
                this.txPr.Write(sw, "txPr");
11152
            if (this.marker != null)
11153
                this.marker.Write(sw, "marker");
11154
            if (this.dLbl != null)
11155
                this.dLbl.Write(sw, "dLbl");
11156
            if (this.extLst != null)
11157
            {
11158
                foreach (CT_Extension x in this.extLst)
11159
                {
11160
                    x.Write(sw, "extLst");
11161
                }
11162
            }
11163
            sw.Write(string.Format("</c:{0}>", nodeName));
11164
        }
11165

11166
        [XmlElement(Order = 0)]
11167
        public CT_UnsignedInt idx
11168
        {
11169
            get
11170
            {
11171
                return this.idxField;
11172
            }
11173
            set
11174
            {
11175
                this.idxField = value;
11176
            }
11177
        }
11178

11179
        [XmlElement(Order = 1)]
11180
        public CT_ShapeProperties spPr
11181
        {
11182
            get
11183
            {
11184
                return this.spPrField;
11185
            }
11186
            set
11187
            {
11188
                this.spPrField = value;
11189
            }
11190
        }
11191

11192
        [XmlElement(Order = 2)]
11193
        public CT_TextBody txPr
11194
        {
11195
            get
11196
            {
11197
                return this.txPrField;
11198
            }
11199
            set
11200
            {
11201
                this.txPrField = value;
11202
            }
11203
        }
11204

11205
        [XmlElement(Order = 3)]
11206
        public CT_Marker marker
11207
        {
11208
            get
11209
            {
11210
                return this.markerField;
11211
            }
11212
            set
11213
            {
11214
                this.markerField = value;
11215
            }
11216
        }
11217

11218
        [XmlElement(Order = 4)]
11219
        public CT_DLbl dLbl
11220
        {
11221
            get
11222
            {
11223
                return this.dLblField;
11224
            }
11225
            set
11226
            {
11227
                this.dLblField = value;
11228
            }
11229
        }
11230

11231
        [XmlElement(Order = 5)]
11232
        public List<CT_Extension> extLst
11233
        {
11234
            get
11235
            {
11236
                return this.extLstField;
11237
            }
11238
            set
11239
            {
11240
                this.extLstField = value;
11241
            }
11242
        }
11243
    }
11244

11245

11246
    [Serializable]
11247

11248
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11249
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11250
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart",ElementName = "chart", IsNullable = true)]
11251
    public class CT_Chart
11252
    {
11253
        private CT_Title titleField;
11254

11255
        private CT_Boolean autoTitleDeletedField;
11256

11257
        private CT_PivotFmts pivotFmtsField;
11258

11259
        private CT_View3D view3DField;
11260

11261
        private CT_Surface floorField;
11262

11263
        private CT_Surface sideWallField;
11264

11265
        private CT_Surface backWallField;
11266

11267
        private CT_PlotArea plotAreaField;
11268

11269
        private CT_Legend legendField;
11270

11271
        private CT_Boolean plotVisOnlyField;
11272

11273
        private CT_DispBlanksAs dispBlanksAsField;
11274

11275
        private CT_Boolean showDLblsOverMaxField;
11276

11277
        private List<CT_Extension> extLstField;
11278

11279
        public CT_Chart()
11280
        {
11281
        }
11282
        public static CT_Chart Parse(XmlNode node, XmlNamespaceManager namespaceManager)
11283
        {
11284
            if (node == null)
11285
                return null;
11286
            CT_Chart ctObj = new CT_Chart();
11287
            ctObj.extLst = new List<CT_Extension>();
11288
            foreach (XmlNode childNode in node.ChildNodes)
11289
            {
11290
                if (childNode.LocalName == "title")
11291
                    ctObj.title = CT_Title.Parse(childNode, namespaceManager);
11292
                else if (childNode.LocalName == "autoTitleDeleted")
11293
                    ctObj.autoTitleDeleted = CT_Boolean.Parse(childNode, namespaceManager);
11294
                else if (childNode.LocalName == "pivotFmts")
11295
                    ctObj.pivotFmts = CT_PivotFmts.Parse(childNode, namespaceManager);
11296
                else if (childNode.LocalName == "view3D")
11297
                    ctObj.view3D = CT_View3D.Parse(childNode, namespaceManager);
11298
                else if (childNode.LocalName == "floor")
11299
                    ctObj.floor = CT_Surface.Parse(childNode, namespaceManager);
11300
                else if (childNode.LocalName == "sideWall")
11301
                    ctObj.sideWall = CT_Surface.Parse(childNode, namespaceManager);
11302
                else if (childNode.LocalName == "backWall")
11303
                    ctObj.backWall = CT_Surface.Parse(childNode, namespaceManager);
11304
                else if (childNode.LocalName == "plotArea")
11305
                    ctObj.plotArea = CT_PlotArea.Parse(childNode, namespaceManager);
11306
                else if (childNode.LocalName == "legend")
11307
                    ctObj.legend = CT_Legend.Parse(childNode, namespaceManager);
11308
                else if (childNode.LocalName == "plotVisOnly")
11309
                    ctObj.plotVisOnly = CT_Boolean.Parse(childNode, namespaceManager);
11310
                else if (childNode.LocalName == "dispBlanksAs")
11311
                    ctObj.dispBlanksAs = CT_DispBlanksAs.Parse(childNode, namespaceManager);
11312
                else if (childNode.LocalName == "showDLblsOverMax")
11313
                    ctObj.showDLblsOverMax = CT_Boolean.Parse(childNode, namespaceManager);
11314
                else if (childNode.LocalName == "extLst")
11315
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
11316
            }
11317
            return ctObj;
11318
        }
11319

11320

11321

11322
        internal void Write(StreamWriter sw, string nodeName)
11323
        {
11324
            sw.Write(string.Format("<c:{0}", nodeName));
11325
            sw.Write(">");
11326
            if (this.title != null)
11327
                this.title.Write(sw, "title");
11328
            if (this.autoTitleDeleted != null)
11329
                this.autoTitleDeleted.Write(sw, "autoTitleDeleted");
11330
            if (this.pivotFmts != null)
11331
                this.pivotFmts.Write(sw, "pivotFmts");
11332
            if (this.view3D != null)
11333
                this.view3D.Write(sw, "view3D");
11334
            if (this.floor != null)
11335
                this.floor.Write(sw, "floor");
11336
            if (this.sideWall != null)
11337
                this.sideWall.Write(sw, "sideWall");
11338
            if (this.backWall != null)
11339
                this.backWall.Write(sw, "backWall");
11340
            if (this.plotArea != null)
11341
                this.plotArea.Write(sw, "plotArea");
11342
            if (this.legend != null)
11343
                this.legend.Write(sw, "legend");
11344
            if (this.plotVisOnly != null)
11345
                this.plotVisOnly.Write(sw, "plotVisOnly");
11346
            if (this.dispBlanksAs != null)
11347
                this.dispBlanksAs.Write(sw, "dispBlanksAs");
11348
            if (this.showDLblsOverMax != null)
11349
                this.showDLblsOverMax.Write(sw, "showDLblsOverMax");
11350

11351
            if (this.extLst != null)
11352
            {
11353
                foreach (CT_Extension x in this.extLst)
11354
                {
11355
                    x.Write(sw, "extLst");
11356
                }
11357
            }
11358
            sw.Write(string.Format("</c:{0}>", nodeName));
11359
        }
11360

11361
        public CT_Boolean AddNewPlotVisOnly()
11362
        {
11363
            this.plotVisOnlyField=new CT_Boolean();
11364
            return this.plotVisOnlyField;
11365
        }
11366
        public CT_PlotArea AddNewPlotArea()
11367
        {
11368
            this.plotAreaField = new CT_PlotArea();
11369
            return this.plotAreaField;
11370
        }
11371
        public bool IsSetTitle()
11372
        {
11373
            return titleField != null;
11374
        }
11375
        public bool IsSetLegend()
11376
        {
11377
            return legendField != null;
11378
        }
11379
        public void unsetLegend()
11380
        {
11381
            legendField = null;
11382
        }
11383
        public CT_Legend AddNewLegend()
11384
        {
11385
            if(this.legendField==null)
11386
                this.legendField = new CT_Legend();
11387
            return this.legendField;
11388
        }
11389

11390
        public CT_Title AddNewTitle()
11391
        {
11392
            this.titleField = new CT_Title();
11393
            return this.titleField;
11394
        }
11395

11396
        [XmlElement(Order = 0)]
11397
        public CT_Title title
11398
        {
11399
            get
11400
            {
11401
                return this.titleField;
11402
            }
11403
            set
11404
            {
11405
                this.titleField = value;
11406
            }
11407
        }
11408

11409
        [XmlElement(Order = 1)]
11410
        public CT_Boolean autoTitleDeleted
11411
        {
11412
            get
11413
            {
11414
                return this.autoTitleDeletedField;
11415
            }
11416
            set
11417
            {
11418
                this.autoTitleDeletedField = value;
11419
            }
11420
        }
11421

11422
        [XmlElement(Order = 2)]
11423
        public CT_PivotFmts pivotFmts
11424
        {
11425
            get
11426
            {
11427
                return this.pivotFmtsField;
11428
            }
11429
            set
11430
            {
11431
                this.pivotFmtsField = value;
11432
            }
11433
        }
11434

11435
        [XmlElement(Order = 3)]
11436
        public CT_View3D view3D
11437
        {
11438
            get
11439
            {
11440
                return this.view3DField;
11441
            }
11442
            set
11443
            {
11444
                this.view3DField = value;
11445
            }
11446
        }
11447

11448
        [XmlElement(Order = 4)]
11449
        public CT_Surface floor
11450
        {
11451
            get
11452
            {
11453
                return this.floorField;
11454
            }
11455
            set
11456
            {
11457
                this.floorField = value;
11458
            }
11459
        }
11460

11461
        [XmlElement(Order = 5)]
11462
        public CT_Surface sideWall
11463
        {
11464
            get
11465
            {
11466
                return this.sideWallField;
11467
            }
11468
            set
11469
            {
11470
                this.sideWallField = value;
11471
            }
11472
        }
11473

11474
        [XmlElement(Order = 6)]
11475
        public CT_Surface backWall
11476
        {
11477
            get
11478
            {
11479
                return this.backWallField;
11480
            }
11481
            set
11482
            {
11483
                this.backWallField = value;
11484
            }
11485
        }
11486

11487
        [XmlElement(Order = 7)]
11488
        public CT_PlotArea plotArea
11489
        {
11490
            get
11491
            {
11492
                return this.plotAreaField;
11493
            }
11494
            set
11495
            {
11496
                this.plotAreaField = value;
11497
            }
11498
        }
11499

11500
        [XmlElement(Order = 8)]
11501
        public CT_Legend legend
11502
        {
11503
            get
11504
            {
11505
                return this.legendField;
11506
            }
11507
            set
11508
            {
11509
                this.legendField = value;
11510
            }
11511
        }
11512

11513
        [XmlElement(Order = 9)]
11514
        public CT_Boolean plotVisOnly
11515
        {
11516
            get
11517
            {
11518
                return this.plotVisOnlyField;
11519
            }
11520
            set
11521
            {
11522
                this.plotVisOnlyField = value;
11523
            }
11524
        }
11525

11526
        [XmlElement(Order = 10)]
11527
        public CT_DispBlanksAs dispBlanksAs
11528
        {
11529
            get
11530
            {
11531
                return this.dispBlanksAsField;
11532
            }
11533
            set
11534
            {
11535
                this.dispBlanksAsField = value;
11536
            }
11537
        }
11538

11539
        [XmlElement(Order = 11)]
11540
        public CT_Boolean showDLblsOverMax
11541
        {
11542
            get
11543
            {
11544
                return this.showDLblsOverMaxField;
11545
            }
11546
            set
11547
            {
11548
                this.showDLblsOverMaxField = value;
11549
            }
11550
        }
11551

11552
        [XmlElement(Order = 12)]
11553
        public List<CT_Extension> extLst
11554
        {
11555
            get
11556
            {
11557
                return this.extLstField;
11558
            }
11559
            set
11560
            {
11561
                this.extLstField = value;
11562
            }
11563
        }
11564
    }
11565

11566

11567
    [Serializable]
11568

11569
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11570
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11571
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
11572
    public class CT_Protection
11573
    {
11574

11575
        private CT_Boolean chartObjectField;
11576

11577
        private CT_Boolean dataField;
11578

11579
        private CT_Boolean formattingField;
11580

11581
        private CT_Boolean selectionField;
11582

11583
        private CT_Boolean userInterfaceField;
11584

11585
        public CT_Protection()
11586
        {
11587
            //this.userInterfaceField = new CT_Boolean();
11588
            //this.selectionField = new CT_Boolean();
11589
            //this.formattingField = new CT_Boolean();
11590
            //this.dataField = new CT_Boolean();
11591
            //this.chartObjectField = new CT_Boolean();
11592
        }
11593
        public static CT_Protection Parse(XmlNode node, XmlNamespaceManager namespaceManager)
11594
        {
11595
            if (node == null)
11596
                return null;
11597
            CT_Protection ctObj = new CT_Protection();
11598
            foreach (XmlNode childNode in node.ChildNodes)
11599
            {
11600
                if (childNode.LocalName == "chartObject")
11601
                    ctObj.chartObject = CT_Boolean.Parse(childNode, namespaceManager);
11602
                else if (childNode.LocalName == "data")
11603
                    ctObj.data = CT_Boolean.Parse(childNode, namespaceManager);
11604
                else if (childNode.LocalName == "formatting")
11605
                    ctObj.formatting = CT_Boolean.Parse(childNode, namespaceManager);
11606
                else if (childNode.LocalName == "selection")
11607
                    ctObj.selection = CT_Boolean.Parse(childNode, namespaceManager);
11608
                else if (childNode.LocalName == "userInterface")
11609
                    ctObj.userInterface = CT_Boolean.Parse(childNode, namespaceManager);
11610
            }
11611
            return ctObj;
11612
        }
11613

11614

11615

11616
        internal void Write(StreamWriter sw, string nodeName)
11617
        {
11618
            sw.Write(string.Format("<c:{0}", nodeName));
11619
            sw.Write(">");
11620
            if (this.chartObject != null)
11621
                this.chartObject.Write(sw, "chartObject");
11622
            if (this.data != null)
11623
                this.data.Write(sw, "data");
11624
            if (this.formatting != null)
11625
                this.formatting.Write(sw, "formatting");
11626
            if (this.selection != null)
11627
                this.selection.Write(sw, "selection");
11628
            if (this.userInterface != null)
11629
                this.userInterface.Write(sw, "userInterface");
11630
            sw.Write(string.Format("</c:{0}>", nodeName));
11631
        }
11632

11633
        [XmlElement(Order = 0)]
11634
        public CT_Boolean chartObject
11635
        {
11636
            get
11637
            {
11638
                return this.chartObjectField;
11639
            }
11640
            set
11641
            {
11642
                this.chartObjectField = value;
11643
            }
11644
        }
11645

11646
        [XmlElement(Order = 1)]
11647
        public CT_Boolean data
11648
        {
11649
            get
11650
            {
11651
                return this.dataField;
11652
            }
11653
            set
11654
            {
11655
                this.dataField = value;
11656
            }
11657
        }
11658

11659
        [XmlElement(Order = 2)]
11660
        public CT_Boolean formatting
11661
        {
11662
            get
11663
            {
11664
                return this.formattingField;
11665
            }
11666
            set
11667
            {
11668
                this.formattingField = value;
11669
            }
11670
        }
11671

11672
        [XmlElement(Order = 3)]
11673
        public CT_Boolean selection
11674
        {
11675
            get
11676
            {
11677
                return this.selectionField;
11678
            }
11679
            set
11680
            {
11681
                this.selectionField = value;
11682
            }
11683
        }
11684

11685
        [XmlElement(Order = 4)]
11686
        public CT_Boolean userInterface
11687
        {
11688
            get
11689
            {
11690
                return this.userInterfaceField;
11691
            }
11692
            set
11693
            {
11694
                this.userInterfaceField = value;
11695
            }
11696
        }
11697
    }
11698

11699

11700
    [Serializable]
11701

11702
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11703
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11704
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
11705
    public class CT_PivotSource
11706
    {
11707

11708
        private string nameField;
11709

11710
        private CT_UnsignedInt fmtIdField;
11711

11712
        private List<CT_Extension> extLstField;
11713

11714
        public CT_PivotSource()
11715
        {
11716
        }
11717
        public static CT_PivotSource Parse(XmlNode node, XmlNamespaceManager namespaceManager)
11718
        {
11719
            if (node == null)
11720
                return null;
11721
            CT_PivotSource ctObj = new CT_PivotSource();
11722
            ctObj.extLst = new List<CT_Extension>();
11723
            foreach (XmlNode childNode in node.ChildNodes)
11724
            {
11725
                if (childNode.LocalName == "name")
11726
                    ctObj.name = childNode.InnerText;
11727
                else if (childNode.LocalName == "fmtId")
11728
                    ctObj.fmtId = CT_UnsignedInt.Parse(childNode, namespaceManager);
11729
                else if (childNode.LocalName == "extLst")
11730
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
11731
            }
11732
            return ctObj;
11733
        }
11734

11735

11736

11737
        internal void Write(StreamWriter sw, string nodeName)
11738
        {
11739
            sw.Write(string.Format("<c:{0}", nodeName));
11740
            sw.Write(">");
11741
            if (this.name != null)
11742
                sw.Write(string.Format("<c:name>{0}</c:name>", this.name));
11743
            if (this.fmtId != null)
11744
                this.fmtId.Write(sw, "fmtId");
11745
            if (this.extLst != null)
11746
            {
11747
                foreach (CT_Extension x in this.extLst)
11748
                {
11749
                    x.Write(sw, "extLst");
11750
                }
11751
            }
11752
            sw.Write(string.Format("</c:{0}>", nodeName));
11753
        }
11754

11755

11756
        [XmlElement(Order = 0)]
11757
        public string name
11758
        {
11759
            get
11760
            {
11761
                return this.nameField;
11762
            }
11763
            set
11764
            {
11765
                this.nameField = value;
11766
            }
11767
        }
11768

11769
        [XmlElement(Order = 1)]
11770
        public CT_UnsignedInt fmtId
11771
        {
11772
            get
11773
            {
11774
                return this.fmtIdField;
11775
            }
11776
            set
11777
            {
11778
                this.fmtIdField = value;
11779
            }
11780
        }
11781

11782
        [XmlElement(Order = 2)]
11783
        public List<CT_Extension> extLst
11784
        {
11785
            get
11786
            {
11787
                return this.extLstField;
11788
            }
11789
            set
11790
            {
11791
                this.extLstField = value;
11792
            }
11793
        }
11794
    }
11795

11796

11797
    [Serializable]
11798

11799
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11800
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11801
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
11802
    public class CT_Style
11803
    {
11804
        public static CT_Style Parse(XmlNode node, XmlNamespaceManager namespaceManager)
11805
        {
11806
            if (node == null)
11807
                return null;
11808
            CT_Style ctObj = new CT_Style();
11809
            ctObj.val = XmlHelper.ReadByte(node.Attributes["val"]);
11810
            return ctObj;
11811
        }
11812

11813

11814

11815
        internal void Write(StreamWriter sw, string nodeName)
11816
        {
11817
            sw.Write(string.Format("<c:{0}", nodeName));
11818
            XmlHelper.WriteAttribute(sw, "val", this.val);
11819
            sw.Write("/>");
11820
        }
11821

11822
        private byte valField;
11823

11824
        [XmlAttribute]
11825
        public byte val
11826
        {
11827
            get
11828
            {
11829
                return this.valField;
11830
            }
11831
            set
11832
            {
11833
                this.valField = value;
11834
            }
11835
        }
11836
    }
11837

11838

11839
    [Serializable]
11840

11841
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11842
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11843
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
11844
    public class CT_TextLanguageID
11845
    {
11846

11847
        private string valField;
11848

11849
        [XmlAttribute]
11850
        public string val
11851
        {
11852
            get
11853
            {
11854
                return this.valField;
11855
            }
11856
            set
11857
            {
11858
                this.valField = value;
11859
            }
11860
        }
11861
        public static CT_TextLanguageID Parse(XmlNode node, XmlNamespaceManager namespaceManager)
11862
        {
11863
            if (node == null)
11864
                return null;
11865
            CT_TextLanguageID ctObj = new CT_TextLanguageID();
11866
            ctObj.val = XmlHelper.ReadString(node.Attributes["val"]);
11867
            return ctObj;
11868
        }
11869

11870

11871

11872
        internal void Write(StreamWriter sw, string nodeName)
11873
        {
11874
            sw.Write(string.Format("<c:{0}", nodeName));
11875
            XmlHelper.WriteAttribute(sw, "val", this.val);
11876
            sw.Write("/>");
11877
        }
11878

11879
    }
11880

11881

11882
    [Serializable]
11883

11884
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11885
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11886
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
11887
    public class CT_ExtensionList
11888
    {
11889

11890
        private List<CT_Extension> extField;
11891

11892
        public CT_ExtensionList()
11893
        {
11894
            //this.extField = new List<CT_Extension>();
11895
        }
11896

11897
        [XmlElement("ext", Order = 0)]
11898
        public List<CT_Extension> ext
11899
        {
11900
            get
11901
            {
11902
                return this.extField;
11903
            }
11904
            set
11905
            {
11906
                this.extField = value;
11907
            }
11908
        }
11909
    }
11910

11911

11912
    [Serializable]
11913

11914
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11915
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11916
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
11917
    public class CT_Lvl
11918
    {
11919
        private List<CT_StrVal> ptField;
11920

11921
        public static CT_Lvl Parse(XmlNode node, XmlNamespaceManager namespaceManager)
11922
        {
11923
            if (node == null)
11924
                return null;
11925
            CT_Lvl ctObj = new CT_Lvl();
11926
            ctObj.pt = new List<CT_StrVal>();
11927
            foreach (XmlNode childNode in node.ChildNodes)
11928
            {
11929
                if (childNode.LocalName == "pt")
11930
                    ctObj.pt.Add(CT_StrVal.Parse(childNode, namespaceManager));
11931
            }
11932
            return ctObj;
11933
        }
11934

11935
        internal void Write(StreamWriter sw, string nodeName)
11936
        {
11937
            sw.Write(string.Format("<c:{0}>", nodeName));
11938
            foreach (CT_StrVal x in this.pt)
11939
            {
11940
                x.Write(sw, "pt");
11941
            }
11942
            sw.Write(string.Format("</c:{0}>", nodeName));
11943
        }
11944

11945
        public CT_Lvl()
11946
        {
11947
            //this.ptField = new List<CT_StrVal>();
11948
        }
11949

11950
        [XmlElement("pt", Order = 0)]
11951
        public List<CT_StrVal> pt
11952
        {
11953
            get
11954
            {
11955
                return this.ptField;
11956
            }
11957
            set
11958
            {
11959
                this.ptField = value;
11960
            }
11961
        }
11962
    }
11963

11964

11965
    [Serializable]
11966

11967
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11968
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11969
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
11970
    public class CT_CustSplit
11971
    {
11972

11973
        private List<CT_UnsignedInt> secondPiePtField;
11974

11975
        public CT_CustSplit()
11976
        {
11977
            //this.secondPiePtField = new List<CT_UnsignedInt>();
11978
        }
11979

11980
        [XmlElement("secondPiePt", Order = 0)]
11981
        public List<CT_UnsignedInt> secondPiePt
11982
        {
11983
            get
11984
            {
11985
                return this.secondPiePtField;
11986
            }
11987
            set
11988
            {
11989
                this.secondPiePtField = value;
11990
            }
11991
        }
11992
    }
11993

11994

11995
    [Serializable]
11996

11997
    [System.ComponentModel.DesignerCategoryAttribute("code")]
11998
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
11999
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
12000
    public class CT_BandFmts
12001
    {
12002

12003
        private List<CT_BandFmt> bandFmtField;
12004

12005
        public CT_BandFmts()
12006
        {
12007
            //this.bandFmtField = new List<CT_BandFmt>();
12008
        }
12009

12010
        [XmlElement("bandFmt", Order = 0)]
12011
        public List<CT_BandFmt> bandFmt
12012
        {
12013
            get
12014
            {
12015
                return this.bandFmtField;
12016
            }
12017
            set
12018
            {
12019
                this.bandFmtField = value;
12020
            }
12021
        }
12022
    }
12023

12024

12025
    [Serializable]
12026

12027
    [System.ComponentModel.DesignerCategoryAttribute("code")]
12028
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
12029
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
12030
    public class CT_PivotFmts
12031
    {
12032
        private List<CT_PivotFmt> pivotFmtField;
12033

12034
        public static CT_PivotFmts Parse(XmlNode node, XmlNamespaceManager namespaceManager)
12035
        {
12036
            if (node == null)
12037
                return null;
12038
            CT_PivotFmts ctObj = new CT_PivotFmts();
12039
            ctObj.pivotFmt = new List<CT_PivotFmt>();
12040
            foreach (XmlNode childNode in node.ChildNodes)
12041
            {
12042
                if (childNode.LocalName == "pivotFmt")
12043
                    ctObj.pivotFmt.Add(CT_PivotFmt.Parse(childNode, namespaceManager));
12044
            }
12045
            return ctObj;
12046
        }
12047

12048
        internal void Write(StreamWriter sw, string nodeName)
12049
        {
12050
            if (this.pivotFmt.Count == 0)
12051
            {
12052
                return;
12053
            }
12054

12055
            sw.Write(string.Format("<c:{0}>", nodeName));
12056
            foreach (CT_PivotFmt x in this.pivotFmt)
12057
            {
12058
                x.Write(sw, "pivotFmt");
12059
            }
12060
            sw.Write(string.Format("</c:{0}>", nodeName));
12061
        }
12062

12063
        public CT_PivotFmts()
12064
        {
12065
            //this.pivotFmtField = new List<CT_PivotFmt>();
12066
        }
12067

12068
        [XmlElement("pivotFmt", Order = 0)]
12069
        public List<CT_PivotFmt> pivotFmt
12070
        {
12071
            get
12072
            {
12073
                return this.pivotFmtField;
12074
            }
12075
            set
12076
            {
12077
                this.pivotFmtField = value;
12078
            }
12079
        }
12080
    }
12081

12082
    [Serializable]
12083

12084
    [System.ComponentModel.DesignerCategory("code")]
12085
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
12086
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
12087
    public class CT_TextBody
12088
    {
12089

12090
        private CT_TextBodyProperties bodyPrField;
12091

12092
        private CT_TextListStyle lstStyleField;
12093

12094
        private List<CT_TextParagraph> pField;
12095

12096
        public static CT_TextBody Parse(XmlNode node, XmlNamespaceManager namespaceManager)
12097
        {
12098
            if (node == null)
12099
                return null;
12100
            CT_TextBody ctObj = new CT_TextBody();
12101
            ctObj.p = new List<CT_TextParagraph>();
12102
            foreach (XmlNode childNode in node.ChildNodes)
12103
            {
12104
                if (childNode.LocalName == "bodyPr")
12105
                    ctObj.bodyPr = CT_TextBodyProperties.Parse(childNode, namespaceManager);
12106
                else if (childNode.LocalName == "lstStyle")
12107
                    ctObj.lstStyle = CT_TextListStyle.Parse(childNode, namespaceManager);
12108
                else if (childNode.LocalName == "p")
12109
                    ctObj.p.Add(CT_TextParagraph.Parse(childNode, namespaceManager));
12110
            }
12111
            return ctObj;
12112
        }
12113

12114

12115

12116
        internal void Write(StreamWriter sw, string nodeName)
12117
        {
12118
            sw.Write(string.Format("<c:{0}>", nodeName));
12119
            if (this.bodyPr != null)
12120
                this.bodyPr.Write(sw, "bodyPr");
12121
            if (this.lstStyle != null)
12122
                this.lstStyle.Write(sw, "lstStyle");
12123
            foreach (CT_TextParagraph x in this.p)
12124
            {
12125
                x.Write(sw, "p");
12126
            }
12127
            sw.Write(string.Format("</c:{0}>", nodeName));
12128
        }
12129

12130
        public void SetPArray(CT_TextParagraph[] array)
12131
        {
12132
            pField = new List<CT_TextParagraph>(array);
12133
        }
12134
        public CT_TextParagraph AddNewP()
12135
        {
12136
            if (this.pField == null)
12137
                pField = new List<CT_TextParagraph>();
12138
            CT_TextParagraph tp = new CT_TextParagraph();
12139
            pField.Add(tp);
12140
            return tp;
12141
        }
12142
        public CT_TextBodyProperties AddNewBodyPr()
12143
        {
12144
            this.bodyPrField = new CT_TextBodyProperties();
12145
            return this.bodyPrField;
12146
        }
12147
        public CT_TextListStyle AddNewLstStyle()
12148
        {
12149
            this.lstStyleField = new CT_TextListStyle();
12150
            return this.lstStyleField;
12151
        }
12152

12153
        public CT_TextBodyProperties bodyPr
12154
        {
12155
            get
12156
            {
12157
                return this.bodyPrField;
12158
            }
12159
            set
12160
            {
12161
                this.bodyPrField = value;
12162
            }
12163
        }
12164

12165

12166
        public CT_TextListStyle lstStyle
12167
        {
12168
            get
12169
            {
12170
                return this.lstStyleField;
12171
            }
12172
            set
12173
            {
12174
                this.lstStyleField = value;
12175
            }
12176
        }
12177
        public override string ToString()
12178
        {
12179
            if (p == null || p.Count == 0)
12180
                return string.Empty;
12181
            StringBuilder sb = new StringBuilder();
12182
            foreach (CT_TextParagraph tp in p)
12183
            {
12184
                foreach (CT_RegularTextRun tr in tp.r)
12185
                {
12186
                    sb.Append(tr.t);
12187
                }
12188
            }
12189
            return sb.ToString();
12190
        }
12191

12192
        public int SizeOfPArray()
12193
        {
12194
            if (this.pField == null)
12195
                pField = new List<CT_TextParagraph>();
12196
            return this.pField.Count;
12197
        }
12198

12199
        public CT_TextParagraph GetPArray(int v)
12200
        {
12201
            return this.pField[v];
12202
        }
12203

12204
        [XmlElement("p")]
12205
        public List<CT_TextParagraph> p
12206
        {
12207
            get
12208
            {
12209
                return this.pField;
12210
            }
12211
            set
12212
            {
12213
                this.pField = value;
12214
            }
12215
        }
12216
    }
12217
    [Serializable]
12218
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
12219
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
12220
    public class CT_ShapeProperties
12221
    {
12222

12223
        private CT_Transform2D xfrmField = null;
12224

12225
        private CT_CustomGeometry2D custGeomField = null;
12226

12227
        private CT_PresetGeometry2D prstGeomField = null;
12228

12229
        private CT_NoFillProperties noFillField = null;
12230

12231
        private CT_SolidColorFillProperties solidFillField = null;
12232

12233
        private CT_GradientFillProperties gradFillField = null;
12234

12235
        private CT_BlipFillProperties blipFillField = null;
12236

12237
        private CT_PatternFillProperties pattFillField = null;
12238

12239
        private CT_GroupFillProperties grpFillField = null;
12240

12241
        private CT_LineProperties lnField = null;
12242

12243
        private CT_EffectList effectLstField = null;
12244

12245
        private CT_EffectContainer effectDagField = null;
12246

12247
        private CT_Scene3D scene3dField = null;
12248

12249
        private CT_Shape3D sp3dField = null;
12250

12251
        private CT_OfficeArtExtensionList extLstField = null;
12252

12253
        private ST_BlackWhiteMode bwModeField = ST_BlackWhiteMode.none;
12254

12255

12256
        public CT_PresetGeometry2D AddNewPrstGeom()
12257
        {
12258
            this.prstGeomField = new CT_PresetGeometry2D();
12259
            return this.prstGeomField;
12260
        }
12261
        public CT_Transform2D AddNewXfrm()
12262
        {
12263
            this.xfrmField = new CT_Transform2D();
12264
            return this.xfrmField;
12265
        }
12266
        public CT_SolidColorFillProperties AddNewSolidFill()
12267
        {
12268
            this.solidFillField = new CT_SolidColorFillProperties();
12269
            return this.solidFillField;
12270
        }
12271
        public bool IsSetPattFill()
12272
        {
12273
            return this.pattFillField != null;
12274
        }
12275
        public bool IsSetSolidFill()
12276
        {
12277
            return this.solidFillField != null;
12278
        }
12279
        public bool IsSetLn()
12280
        {
12281
            return this.lnField != null;
12282
        }
12283
        public CT_LineProperties AddNewLn()
12284
        {
12285
            this.lnField = new CT_LineProperties();
12286
            return lnField;
12287
        }
12288
        public void unsetPattFill()
12289
        {
12290
            this.pattFill = null;
12291
        }
12292
        public void unsetSolidFill()
12293
        {
12294
            this.solidFill = null;
12295
        }
12296

12297
        [XmlElement(Order = 0)]
12298
        public CT_Transform2D xfrm
12299
        {
12300
            get
12301
            {
12302
                return this.xfrmField;
12303
            }
12304
            set
12305
            {
12306
                this.xfrmField = value;
12307
            }
12308
        }
12309

12310
        [XmlElement(Order = 1)]
12311
        public CT_CustomGeometry2D custGeom
12312
        {
12313
            get
12314
            {
12315
                return this.custGeomField;
12316
            }
12317
            set
12318
            {
12319
                this.custGeomField = value;
12320
            }
12321
        }
12322

12323
        [XmlElement(Order = 2)]
12324
        public CT_PresetGeometry2D prstGeom
12325
        {
12326
            get
12327
            {
12328
                return this.prstGeomField;
12329
            }
12330
            set
12331
            {
12332
                this.prstGeomField = value;
12333
            }
12334
        }
12335

12336
        [XmlElement(Order = 3)]
12337
        public CT_NoFillProperties noFill
12338
        {
12339
            get
12340
            {
12341
                return this.noFillField;
12342
            }
12343
            set
12344
            {
12345
                this.noFillField = value;
12346
            }
12347
        }
12348

12349
        [XmlElement(Order = 4)]
12350
        public CT_SolidColorFillProperties solidFill
12351
        {
12352
            get
12353
            {
12354
                return this.solidFillField;
12355
            }
12356
            set
12357
            {
12358
                this.solidFillField = value;
12359
            }
12360
        }
12361

12362
        [XmlElement(Order = 5)]
12363
        public CT_GradientFillProperties gradFill
12364
        {
12365
            get
12366
            {
12367
                return this.gradFillField;
12368
            }
12369
            set
12370
            {
12371
                this.gradFillField = value;
12372
            }
12373
        }
12374

12375
        [XmlElement(Order = 6)]
12376
        public CT_BlipFillProperties blipFill
12377
        {
12378
            get
12379
            {
12380
                return this.blipFillField;
12381
            }
12382
            set
12383
            {
12384
                this.blipFillField = value;
12385
            }
12386
        }
12387

12388
        [XmlElement(Order = 7)]
12389
        public CT_PatternFillProperties pattFill
12390
        {
12391
            get
12392
            {
12393
                return this.pattFillField;
12394
            }
12395
            set
12396
            {
12397
                this.pattFillField = value;
12398
            }
12399
        }
12400

12401
        [XmlElement(Order = 8)]
12402
        public CT_GroupFillProperties grpFill
12403
        {
12404
            get
12405
            {
12406
                return this.grpFillField;
12407
            }
12408
            set
12409
            {
12410
                this.grpFillField = value;
12411
            }
12412
        }
12413

12414
        [XmlElement(Order = 9)]
12415
        public CT_LineProperties ln
12416
        {
12417
            get
12418
            {
12419
                return this.lnField;
12420
            }
12421
            set
12422
            {
12423
                this.lnField = value;
12424
            }
12425
        }
12426

12427
        [XmlElement(Order = 10)]
12428
        public CT_EffectList effectLst
12429
        {
12430
            get
12431
            {
12432
                return this.effectLstField;
12433
            }
12434
            set
12435
            {
12436
                this.effectLstField = value;
12437
            }
12438
        }
12439

12440
        [XmlElement(Order = 11)]
12441
        public CT_EffectContainer effectDag
12442
        {
12443
            get
12444
            {
12445
                return this.effectDagField;
12446
            }
12447
            set
12448
            {
12449
                this.effectDagField = value;
12450
            }
12451
        }
12452

12453
        [XmlElement(Order = 12)]
12454
        public CT_Scene3D scene3d
12455
        {
12456
            get
12457
            {
12458
                return this.scene3dField;
12459
            }
12460
            set
12461
            {
12462
                this.scene3dField = value;
12463
            }
12464
        }
12465

12466
        [XmlElement(Order = 13)]
12467
        public CT_Shape3D sp3d
12468
        {
12469
            get
12470
            {
12471
                return this.sp3dField;
12472
            }
12473
            set
12474
            {
12475
                this.sp3dField = value;
12476
            }
12477
        }
12478

12479
        [XmlElement(Order = 14)]
12480
        public CT_OfficeArtExtensionList extLst
12481
        {
12482
            get
12483
            {
12484
                return this.extLstField;
12485
            }
12486
            set
12487
            {
12488
                this.extLstField = value;
12489
            }
12490
        }
12491

12492
        [XmlAttribute]
12493
        public ST_BlackWhiteMode bwMode
12494
        {
12495
            get
12496
            {
12497
                return this.bwModeField;
12498
            }
12499
            set
12500
            {
12501
                this.bwModeField = value;
12502
            }
12503
        }
12504
        [XmlIgnore]
12505
        public bool bwModeSpecified
12506
        {
12507
            get { return ST_BlackWhiteMode.none != this.bwModeField; }
12508
        }
12509

12510
        public static CT_ShapeProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
12511
        {
12512
            if (node == null)
12513
                return null;
12514
            CT_ShapeProperties ctObj = new CT_ShapeProperties();
12515
            if (node.Attributes["bwMode"] != null)
12516
                ctObj.bwMode = (ST_BlackWhiteMode)Enum.Parse(typeof(ST_BlackWhiteMode), node.Attributes["bwMode"].Value);
12517
            foreach (XmlNode childNode in node.ChildNodes)
12518
            {
12519
                if (childNode.LocalName == "xfrm")
12520
                    ctObj.xfrm = CT_Transform2D.Parse(childNode, namespaceManager);
12521
                else if (childNode.LocalName == "custGeom")
12522
                    ctObj.custGeom = CT_CustomGeometry2D.Parse(childNode, namespaceManager);
12523
                else if (childNode.LocalName == "prstGeom")
12524
                    ctObj.prstGeom = CT_PresetGeometry2D.Parse(childNode, namespaceManager);
12525
                else if (childNode.LocalName == "noFill")
12526
                    ctObj.noFill = new CT_NoFillProperties();
12527
                else if (childNode.LocalName == "solidFill")
12528
                    ctObj.solidFill = CT_SolidColorFillProperties.Parse(childNode, namespaceManager);
12529
                else if (childNode.LocalName == "gradFill")
12530
                    ctObj.gradFill = CT_GradientFillProperties.Parse(childNode, namespaceManager);
12531
                else if (childNode.LocalName == "blipFill")
12532
                    ctObj.blipFill = CT_BlipFillProperties.Parse(childNode, namespaceManager);
12533
                else if (childNode.LocalName == "pattFill")
12534
                    ctObj.pattFill = CT_PatternFillProperties.Parse(childNode, namespaceManager);
12535
                else if (childNode.LocalName == "grpFill")
12536
                    ctObj.grpFill = new CT_GroupFillProperties();
12537
                else if (childNode.LocalName == "ln")
12538
                    ctObj.ln = CT_LineProperties.Parse(childNode, namespaceManager);
12539
                else if (childNode.LocalName == "effectLst")
12540
                    ctObj.effectLst = CT_EffectList.Parse(childNode, namespaceManager);
12541
                else if (childNode.LocalName == "effectDag")
12542
                    ctObj.effectDag = CT_EffectContainer.Parse(childNode, namespaceManager);
12543
                else if (childNode.LocalName == "scene3d")
12544
                    ctObj.scene3d = CT_Scene3D.Parse(childNode, namespaceManager);
12545
                else if (childNode.LocalName == "sp3d")
12546
                    ctObj.sp3d = CT_Shape3D.Parse(childNode, namespaceManager);
12547
                else if (childNode.LocalName == "extLst")
12548
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
12549
            }
12550
            return ctObj;
12551
        }
12552

12553

12554

12555
        internal void Write(StreamWriter sw, string nodeName)
12556
        {
12557
            sw.Write(string.Format("<c:{0}", nodeName));
12558
            if(this.bwMode!= ST_BlackWhiteMode.none)
12559
                XmlHelper.WriteAttribute(sw, "bwMode", this.bwMode.ToString());
12560
            sw.Write(">");
12561
            if (this.xfrm != null)
12562
                this.xfrm.Write(sw, "a:xfrm");
12563
            if (this.custGeom != null)
12564
                this.custGeom.Write(sw, "custGeom");
12565
            if (this.prstGeom != null)
12566
                this.prstGeom.Write(sw, "prstGeom");
12567
            if (this.noFill != null)
12568
                sw.Write("<a:noFill/>");
12569
            if (this.solidFill != null)
12570
                this.solidFill.Write(sw, "solidFill");
12571
            if (this.gradFill != null)
12572
                this.gradFill.Write(sw, "gradFill");
12573
            if (this.blipFill != null)
12574
                this.blipFill.Write(sw, "a:blipFill");
12575
            if (this.pattFill != null)
12576
                this.pattFill.Write(sw, "pattFill");
12577
            if (this.grpFill != null)
12578
                sw.Write("<a:grpFill/>");
12579
            if (this.ln != null)
12580
                this.ln.Write(sw, "ln");
12581
            if (this.effectLst != null)
12582
                this.effectLst.Write(sw, "effectLst");
12583
            if (this.effectDag != null)
12584
                this.effectDag.Write(sw, "effectDag");
12585
            if (this.scene3d != null)
12586
                this.scene3d.Write(sw, "scene3d");
12587
            if (this.sp3d != null)
12588
                this.sp3d.Write(sw, "sp3d");
12589
            if (this.extLst != null)
12590
                this.extLst.Write(sw, "extLst");
12591
            sw.Write(string.Format("</c:{0}>", nodeName));
12592
        }
12593

12594
    }
12595
}
12596