npoi

1
using System;
2
using System.Collections.Generic;
3
using System.IO;
4
using System.Text;
5
using System.Xml;
6
using System.Xml.Serialization;
7

8

9
namespace NPOI.OpenXmlFormats.Dml.Chart
10
{
11

12
    [Serializable]
13

14
    [System.ComponentModel.DesignerCategoryAttribute("code")]
15
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
16
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
17
    public class CT_LineSer
18
    {
19

20
        private CT_UnsignedInt idxField;
21

22
        private CT_UnsignedInt orderField;
23

24
        private CT_SerTx txField;
25

26
        private CT_ShapeProperties spPrField;
27

28
        private CT_Marker markerField;
29

30
        private List<CT_DPt> dPtField;
31

32
        private CT_DLbls dLblsField;
33

34
        private List<CT_Trendline> trendlineField;
35

36
        private CT_ErrBars errBarsField;
37

38
        private CT_AxDataSource catField;
39

40
        private CT_NumDataSource valField;
41

42
        private CT_Boolean smoothField;
43

44
        private List<CT_Extension> extLstField;
45

46
        public CT_LineSer()
47
        {
48
        }
49

50
        public static CT_LineSer Parse(XmlNode node, XmlNamespaceManager namespaceManager)
51
        {
52
            if (node == null)
53
                return null;
54
            CT_LineSer ctObj = new CT_LineSer();
55
            ctObj.dPt = new List<CT_DPt>();
56
            ctObj.trendline = new List<CT_Trendline>();
57
            ctObj.extLst = new List<CT_Extension>();
58
            foreach (XmlNode childNode in node.ChildNodes)
59
            {
60
                if (childNode.LocalName == "idx")
61
                    ctObj.idx = CT_UnsignedInt.Parse(childNode, namespaceManager);
62
                else if (childNode.LocalName == "order")
63
                    ctObj.order = CT_UnsignedInt.Parse(childNode, namespaceManager);
64
                else if (childNode.LocalName == "tx")
65
                    ctObj.tx = CT_SerTx.Parse(childNode, namespaceManager);
66
                else if (childNode.LocalName == "spPr")
67
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
68
                else if (childNode.LocalName == "marker")
69
                    ctObj.marker = CT_Marker.Parse(childNode, namespaceManager);
70
                else if (childNode.LocalName == "dLbls")
71
                    ctObj.dLbls = CT_DLbls.Parse(childNode, namespaceManager);
72
                else if (childNode.LocalName == "errBars")
73
                    ctObj.errBars = CT_ErrBars.Parse(childNode, namespaceManager);
74
                else if (childNode.LocalName == "cat")
75
                    ctObj.cat = CT_AxDataSource.Parse(childNode, namespaceManager);
76
                else if (childNode.LocalName == "val")
77
                    ctObj.val = CT_NumDataSource.Parse(childNode, namespaceManager);
78
                else if (childNode.LocalName == "smooth")
79
                    ctObj.smooth = CT_Boolean.Parse(childNode, namespaceManager);
80
                else if (childNode.LocalName == "dPt")
81
                    ctObj.dPt.Add(CT_DPt.Parse(childNode, namespaceManager));
82
                else if (childNode.LocalName == "trendline")
83
                    ctObj.trendline.Add(CT_Trendline.Parse(childNode, namespaceManager));
84
                else if (childNode.LocalName == "extLst")
85
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
86
            }
87
            return ctObj;
88
        }
89

90

91

92
        internal void Write(StreamWriter sw, string nodeName)
93
        {
94
            sw.Write(string.Format("<c:{0}", nodeName));
95
            sw.Write(">");
96
            if (this.idx != null)
97
                this.idx.Write(sw, "idx");
98
            if (this.order != null)
99
                this.order.Write(sw, "order");
100
            if (this.tx != null)
101
                this.tx.Write(sw, "tx");
102
            if (this.spPr != null)
103
                this.spPr.Write(sw, "spPr");
104
            if (this.marker != null)
105
                this.marker.Write(sw, "marker");
106
            if (this.dLbls != null)
107
                this.dLbls.Write(sw, "dLbls");
108
            if (this.errBars != null)
109
                this.errBars.Write(sw, "errBars");
110
            if (this.cat != null)
111
                this.cat.Write(sw, "cat");
112
            if (this.val != null)
113
                this.val.Write(sw, "val");
114
            if (this.smooth != null)
115
                this.smooth.Write(sw, "smooth");
116
            if (this.dPt != null)
117
            {
118
                foreach (CT_DPt x in this.dPt)
119
                {
120
                    x.Write(sw, "dPt");
121
                }
122
            }
123
            if (this.trendline != null)
124
            {
125
                foreach (CT_Trendline x in this.trendline)
126
                {
127
                    x.Write(sw, "trendline");
128
                }
129
            }
130
            if (this.extLst != null)
131
            {
132
                foreach (CT_Extension x in this.extLst)
133
                {
134
                    x.Write(sw, "extLst");
135
                }
136
            }
137
            sw.Write(string.Format("</c:{0}>", nodeName));
138
        }
139

140
        [XmlElement(Order = 0)]
141
        public CT_UnsignedInt idx
142
        {
143
            get
144
            {
145
                return this.idxField;
146
            }
147
            set
148
            {
149
                this.idxField = value;
150
            }
151
        }
152

153
        [XmlElement(Order = 1)]
154
        public CT_UnsignedInt order
155
        {
156
            get
157
            {
158
                return this.orderField;
159
            }
160
            set
161
            {
162
                this.orderField = value;
163
            }
164
        }
165

166
        [XmlElement(Order = 2)]
167
        public CT_SerTx tx
168
        {
169
            get
170
            {
171
                return this.txField;
172
            }
173
            set
174
            {
175
                this.txField = value;
176
            }
177
        }
178

179
        [XmlElement(Order = 3)]
180
        public CT_ShapeProperties spPr
181
        {
182
            get
183
            {
184
                return this.spPrField;
185
            }
186
            set
187
            {
188
                this.spPrField = value;
189
            }
190
        }
191

192
        [XmlElement(Order = 4)]
193
        public CT_Marker marker
194
        {
195
            get
196
            {
197
                return this.markerField;
198
            }
199
            set
200
            {
201
                this.markerField = value;
202
            }
203
        }
204

205
        [XmlElement("dPt", Order = 5)]
206
        public List<CT_DPt> dPt
207
        {
208
            get
209
            {
210
                return this.dPtField;
211
            }
212
            set
213
            {
214
                this.dPtField = value;
215
            }
216
        }
217

218
        [XmlElement(Order = 6)]
219
        public CT_DLbls dLbls
220
        {
221
            get
222
            {
223
                return this.dLblsField;
224
            }
225
            set
226
            {
227
                this.dLblsField = value;
228
            }
229
        }
230

231
        [XmlElement("trendline", Order = 7)]
232
        public List<CT_Trendline> trendline
233
        {
234
            get
235
            {
236
                return this.trendlineField;
237
            }
238
            set
239
            {
240
                this.trendlineField = value;
241
            }
242
        }
243

244
        [XmlElement(Order = 8)]
245
        public CT_ErrBars errBars
246
        {
247
            get
248
            {
249
                return this.errBarsField;
250
            }
251
            set
252
            {
253
                this.errBarsField = value;
254
            }
255
        }
256

257
        [XmlElement(Order = 9)]
258
        public CT_AxDataSource cat
259
        {
260
            get
261
            {
262
                return this.catField;
263
            }
264
            set
265
            {
266
                this.catField = value;
267
            }
268
        }
269

270
        [XmlElement(Order = 10)]
271
        public CT_NumDataSource val
272
        {
273
            get
274
            {
275
                return this.valField;
276
            }
277
            set
278
            {
279
                this.valField = value;
280
            }
281
        }
282

283
        [XmlElement(Order = 11)]
284
        public CT_Boolean smooth
285
        {
286
            get
287
            {
288
                return this.smoothField;
289
            }
290
            set
291
            {
292
                this.smoothField = value;
293
            }
294
        }
295

296
        [XmlElement(Order = 12)]
297
        public List<CT_Extension> extLst
298
        {
299
            get
300
            {
301
                return this.extLstField;
302
            }
303
            set
304
            {
305
                this.extLstField = value;
306
            }
307
        }
308

309
        public CT_UnsignedInt AddNewIdx()
310
        {
311
            this.idxField = new CT_UnsignedInt();
312
            return this.idxField;
313
        }
314

315
        public CT_UnsignedInt AddNewOrder()
316
        {
317
            this.orderField = new CT_UnsignedInt();
318
            return this.orderField;
319
        }
320

321
        public CT_Marker AddNewMarker()
322
        {
323
            this.markerField = new CT_Marker();
324
            return this.markerField;
325
        }
326

327
        public CT_AxDataSource AddNewCat()
328
        {
329
            this.catField = new CT_AxDataSource();
330
            return this.catField;
331
        }
332

333
        public CT_NumDataSource AddNewVal()
334
        {
335
            this.valField = new CT_NumDataSource();
336
            return this.valField;
337
        }
338
    }
339

340

341
    [Serializable]
342

343
    [System.ComponentModel.DesignerCategoryAttribute("code")]
344
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
345
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
346
    public class CT_Line3DChart
347
    {
348

349
        private CT_Grouping groupingField;
350

351
        private CT_Boolean varyColorsField;
352

353
        private List<CT_LineSer> serField;
354

355
        private CT_DLbls dLblsField;
356

357
        private CT_ChartLines dropLinesField;
358

359
        private CT_GapAmount gapDepthField;
360

361
        private List<CT_UnsignedInt> axIdField;
362

363
        private List<CT_Extension> extLstField;
364

365
        public CT_Line3DChart()
366
        {
367
            //this.extLstField = new List<CT_Extension>();
368
            //this.axIdField = new List<CT_UnsignedInt>();
369
            //this.gapDepthField = new CT_GapAmount();
370
            //this.dropLinesField = new CT_ChartLines();
371
            //this.dLblsField = new CT_DLbls();
372
            //this.serField = new List<CT_LineSer>();
373
            //this.varyColorsField = new CT_Boolean();
374
            //this.groupingField = new CT_Grouping();
375
        }
376

377
        public int GetSeriesCount()
378
        {
379
            return this.serField == null ? 0 : this.serField.Count;
380
        }
381

382
        [XmlElement(Order = 0)]
383
        public CT_Grouping grouping
384
        {
385
            get
386
            {
387
                return this.groupingField;
388
            }
389
            set
390
            {
391
                this.groupingField = value;
392
            }
393
        }
394

395
        [XmlElement(Order = 1)]
396
        public CT_Boolean varyColors
397
        {
398
            get
399
            {
400
                return this.varyColorsField;
401
            }
402
            set
403
            {
404
                this.varyColorsField = value;
405
            }
406
        }
407

408
        [XmlElement("ser", Order = 2)]
409
        public List<CT_LineSer> ser
410
        {
411
            get
412
            {
413
                return this.serField;
414
            }
415
            set
416
            {
417
                this.serField = value;
418
            }
419
        }
420

421
        [XmlElement(Order = 3)]
422
        public CT_DLbls dLbls
423
        {
424
            get
425
            {
426
                return this.dLblsField;
427
            }
428
            set
429
            {
430
                this.dLblsField = value;
431
            }
432
        }
433

434
        [XmlElement(Order = 4)]
435
        public CT_ChartLines dropLines
436
        {
437
            get
438
            {
439
                return this.dropLinesField;
440
            }
441
            set
442
            {
443
                this.dropLinesField = value;
444
            }
445
        }
446

447
        [XmlElement(Order = 5)]
448
        public CT_GapAmount gapDepth
449
        {
450
            get
451
            {
452
                return this.gapDepthField;
453
            }
454
            set
455
            {
456
                this.gapDepthField = value;
457
            }
458
        }
459

460
        [XmlElement("axId", Order = 6)]
461
        public List<CT_UnsignedInt> axId
462
        {
463
            get
464
            {
465
                return this.axIdField;
466
            }
467
            set
468
            {
469
                this.axIdField = value;
470
            }
471
        }
472

473
        [XmlElement(Order = 7)]
474
        public List<CT_Extension> extLst
475
        {
476
            get
477
            {
478
                return this.extLstField;
479
            }
480
            set
481
            {
482
                this.extLstField = value;
483
            }
484
        }
485
        public static CT_Line3DChart Parse(XmlNode node, XmlNamespaceManager namespaceManager)
486
        {
487
            if (node == null)
488
                return null;
489
            CT_Line3DChart ctObj = new CT_Line3DChart();
490
            ctObj.ser = new List<CT_LineSer>();
491
            ctObj.axId = new List<CT_UnsignedInt>();
492
            ctObj.extLst = new List<CT_Extension>();
493
            foreach (XmlNode childNode in node.ChildNodes)
494
            {
495
                if (childNode.LocalName == "grouping")
496
                    ctObj.grouping = CT_Grouping.Parse(childNode, namespaceManager);
497
                else if (childNode.LocalName == "varyColors")
498
                    ctObj.varyColors = CT_Boolean.Parse(childNode, namespaceManager);
499
                else if (childNode.LocalName == "dLbls")
500
                    ctObj.dLbls = CT_DLbls.Parse(childNode, namespaceManager);
501
                else if (childNode.LocalName == "dropLines")
502
                    ctObj.dropLines = CT_ChartLines.Parse(childNode, namespaceManager);
503
                else if (childNode.LocalName == "gapDepth")
504
                    ctObj.gapDepth = CT_GapAmount.Parse(childNode, namespaceManager);
505
                else if (childNode.LocalName == "ser")
506
                    ctObj.ser.Add(CT_LineSer.Parse(childNode, namespaceManager));
507
                else if (childNode.LocalName == "axId")
508
                    ctObj.axId.Add(CT_UnsignedInt.Parse(childNode, namespaceManager));
509
                else if (childNode.LocalName == "extLst")
510
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
511
            }
512
            return ctObj;
513
        }
514

515

516

517
        internal void Write(StreamWriter sw, string nodeName)
518
        {
519
            sw.Write(string.Format("<c:{0}", nodeName));
520
            sw.Write(">");
521
            if (this.grouping != null)
522
                this.grouping.Write(sw, "grouping");
523
            if (this.varyColors != null)
524
                this.varyColors.Write(sw, "varyColors");
525
            if (this.dLbls != null)
526
                this.dLbls.Write(sw, "dLbls");
527
            if (this.dropLines != null)
528
                this.dropLines.Write(sw, "dropLines");
529
            if (this.gapDepth != null)
530
                this.gapDepth.Write(sw, "gapDepth");
531
            if (this.ser != null)
532
            {
533
                foreach (CT_LineSer x in this.ser)
534
                {
535
                    x.Write(sw, "ser");
536
                }
537
            }
538
            if (this.axId != null)
539
            {
540
                foreach (CT_UnsignedInt x in this.axId)
541
                {
542
                    x.Write(sw, "axId");
543
                }
544
            }
545
            if (this.extLst != null)
546
            {
547
                foreach (CT_Extension x in this.extLst)
548
                {
549
                    x.Write(sw, "extLst");
550
                }
551
            }
552
            sw.Write(string.Format("</c:{0}>", nodeName));
553
        }
554

555
    }
556

557

558

559

560
    [Serializable]
561

562
    [System.ComponentModel.DesignerCategoryAttribute("code")]
563
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
564
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
565
    public class CT_UpDownBars
566
    {
567

568
        private CT_GapAmount gapWidthField;
569

570
        private CT_UpDownBar upBarsField;
571

572
        private CT_UpDownBar downBarsField;
573

574
        private List<CT_Extension> extLstField;
575

576
        public CT_UpDownBars()
577
        {
578
        }
579
        public static CT_UpDownBars Parse(XmlNode node, XmlNamespaceManager namespaceManager)
580
        {
581
            if (node == null)
582
                return null;
583
            CT_UpDownBars ctObj = new CT_UpDownBars();
584
            ctObj.extLst = new List<CT_Extension>();
585
            foreach (XmlNode childNode in node.ChildNodes)
586
            {
587
                if (childNode.LocalName == "gapWidth")
588
                    ctObj.gapWidth = CT_GapAmount.Parse(childNode, namespaceManager);
589
                else if (childNode.LocalName == "upBars")
590
                    ctObj.upBars = CT_UpDownBar.Parse(childNode, namespaceManager);
591
                else if (childNode.LocalName == "downBars")
592
                    ctObj.downBars = CT_UpDownBar.Parse(childNode, namespaceManager);
593
                else if (childNode.LocalName == "extLst")
594
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
595
            }
596
            return ctObj;
597
        }
598

599

600

601
        internal void Write(StreamWriter sw, string nodeName)
602
        {
603
            sw.Write(string.Format("<c:{0}", nodeName));
604
            sw.Write(">");
605
            if (this.gapWidth != null)
606
                this.gapWidth.Write(sw, "gapWidth");
607
            if (this.upBars != null)
608
                this.upBars.Write(sw, "upBars");
609
            if (this.downBars != null)
610
                this.downBars.Write(sw, "downBars");
611
            if (this.extLst != null)
612
            {
613
                foreach (CT_Extension x in this.extLst)
614
                {
615
                    x.Write(sw, "extLst");
616
                }
617
            }
618
            sw.Write(string.Format("</c:{0}>", nodeName));
619
        }
620

621

622
        [XmlElement(Order = 0)]
623
        public CT_GapAmount gapWidth
624
        {
625
            get
626
            {
627
                return this.gapWidthField;
628
            }
629
            set
630
            {
631
                this.gapWidthField = value;
632
            }
633
        }
634

635
        [XmlElement(Order = 1)]
636
        public CT_UpDownBar upBars
637
        {
638
            get
639
            {
640
                return this.upBarsField;
641
            }
642
            set
643
            {
644
                this.upBarsField = value;
645
            }
646
        }
647

648
        [XmlElement(Order = 2)]
649
        public CT_UpDownBar downBars
650
        {
651
            get
652
            {
653
                return this.downBarsField;
654
            }
655
            set
656
            {
657
                this.downBarsField = value;
658
            }
659
        }
660

661
        [XmlElement(Order = 3)]
662
        public List<CT_Extension> extLst
663
        {
664
            get
665
            {
666
                return this.extLstField;
667
            }
668
            set
669
            {
670
                this.extLstField = value;
671
            }
672
        }
673
    }
674

675

676
    [Serializable]
677

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

684
        private CT_ShapeProperties spPrField;
685
        public static CT_UpDownBar Parse(XmlNode node, XmlNamespaceManager namespaceManager)
686
        {
687
            if (node == null)
688
                return null;
689
            CT_UpDownBar ctObj = new CT_UpDownBar();
690
            foreach (XmlNode childNode in node.ChildNodes)
691
            {
692
                if (childNode.LocalName == "spPr")
693
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
694
            }
695
            return ctObj;
696
        }
697

698

699

700
        internal void Write(StreamWriter sw, string nodeName)
701
        {
702
            sw.Write(string.Format("<c:{0}", nodeName));
703
            sw.Write(">");
704
            if (this.spPr != null)
705
                this.spPr.Write(sw, "spPr");
706
            sw.Write(string.Format("</c:{0}>", nodeName));
707
        }
708

709
        [XmlElement(Order = 0)]
710
        public CT_ShapeProperties spPr
711
        {
712
            get
713
            {
714
                return this.spPrField;
715
            }
716
            set
717
            {
718
                this.spPrField = value;
719
            }
720
        }
721
    }
722

723

724
    [Serializable]
725

726
    [System.ComponentModel.DesignerCategoryAttribute("code")]
727
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
728
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
729
    public class CT_StockChart
730
    {
731

732
        private List<CT_LineSer> serField;
733

734
        private CT_DLbls dLblsField;
735

736
        private CT_ChartLines dropLinesField;
737

738
        private CT_ChartLines hiLowLinesField;
739

740
        private CT_UpDownBars upDownBarsField;
741

742
        private List<CT_UnsignedInt> axIdField;
743

744
        private List<CT_Extension> extLstField;
745

746
        public CT_StockChart()
747
        {
748
        }
749
        public static CT_StockChart Parse(XmlNode node, XmlNamespaceManager namespaceManager)
750
        {
751
            if (node == null)
752
                return null;
753
            CT_StockChart ctObj = new CT_StockChart();
754
            ctObj.ser = new List<CT_LineSer>();
755
            ctObj.axId = new List<CT_UnsignedInt>();
756
            ctObj.extLst = new List<CT_Extension>();
757
            foreach (XmlNode childNode in node.ChildNodes)
758
            {
759
                if (childNode.LocalName == "dLbls")
760
                    ctObj.dLbls = CT_DLbls.Parse(childNode, namespaceManager);
761
                else if (childNode.LocalName == "dropLines")
762
                    ctObj.dropLines = CT_ChartLines.Parse(childNode, namespaceManager);
763
                else if (childNode.LocalName == "hiLowLines")
764
                    ctObj.hiLowLines = CT_ChartLines.Parse(childNode, namespaceManager);
765
                else if (childNode.LocalName == "upDownBars")
766
                    ctObj.upDownBars = CT_UpDownBars.Parse(childNode, namespaceManager);
767
                else if (childNode.LocalName == "ser")
768
                    ctObj.ser.Add(CT_LineSer.Parse(childNode, namespaceManager));
769
                else if (childNode.LocalName == "axId")
770
                    ctObj.axId.Add(CT_UnsignedInt.Parse(childNode, namespaceManager));
771
                else if (childNode.LocalName == "extLst")
772
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
773
            }
774
            return ctObj;
775
        }
776

777

778

779
        internal void Write(StreamWriter sw, string nodeName)
780
        {
781
            sw.Write(string.Format("<c:{0}", nodeName));
782
            sw.Write(">");
783
            if (this.dLbls != null)
784
                this.dLbls.Write(sw, "dLbls");
785
            if (this.dropLines != null)
786
                this.dropLines.Write(sw, "dropLines");
787
            if (this.hiLowLines != null)
788
                this.hiLowLines.Write(sw, "hiLowLines");
789
            if (this.upDownBars != null)
790
                this.upDownBars.Write(sw, "upDownBars");
791
            if (this.ser != null)
792
            {
793
                foreach (CT_LineSer x in this.ser)
794
                {
795
                    x.Write(sw, "ser");
796
                }
797
            }
798
            if (this.axId != null)
799
            {
800
                foreach (CT_UnsignedInt x in this.axId)
801
                {
802
                    x.Write(sw, "axId");
803
                }
804
            }
805
            if (this.extLst != null)
806
            {
807
                foreach (CT_Extension x in this.extLst)
808
                {
809
                    x.Write(sw, "extLst");
810
                }
811
            }
812
            sw.Write(string.Format("</c:{0}>", nodeName));
813
        }
814

815
        public int GetSeriesCount()
816
        {
817
            return this.serField == null ? 0 : this.serField.Count;
818
        }
819

820
        [XmlElement("ser", Order = 0)]
821
        public List<CT_LineSer> ser
822
        {
823
            get
824
            {
825
                return this.serField;
826
            }
827
            set
828
            {
829
                this.serField = value;
830
            }
831
        }
832

833
        [XmlElement(Order = 1)]
834
        public CT_DLbls dLbls
835
        {
836
            get
837
            {
838
                return this.dLblsField;
839
            }
840
            set
841
            {
842
                this.dLblsField = value;
843
            }
844
        }
845

846
        [XmlElement(Order = 2)]
847
        public CT_ChartLines dropLines
848
        {
849
            get
850
            {
851
                return this.dropLinesField;
852
            }
853
            set
854
            {
855
                this.dropLinesField = value;
856
            }
857
        }
858

859
        [XmlElement(Order = 3)]
860
        public CT_ChartLines hiLowLines
861
        {
862
            get
863
            {
864
                return this.hiLowLinesField;
865
            }
866
            set
867
            {
868
                this.hiLowLinesField = value;
869
            }
870
        }
871

872
        [XmlElement(Order = 4)]
873
        public CT_UpDownBars upDownBars
874
        {
875
            get
876
            {
877
                return this.upDownBarsField;
878
            }
879
            set
880
            {
881
                this.upDownBarsField = value;
882
            }
883
        }
884

885
        [XmlElement("axId", Order = 5)]
886
        public List<CT_UnsignedInt> axId
887
        {
888
            get
889
            {
890
                return this.axIdField;
891
            }
892
            set
893
            {
894
                this.axIdField = value;
895
            }
896
        }
897

898
        [XmlElement(Order = 6)]
899
        public List<CT_Extension> extLst
900
        {
901
            get
902
            {
903
                return this.extLstField;
904
            }
905
            set
906
            {
907
                this.extLstField = value;
908
            }
909
        }
910
    }
911

912
    [Serializable]
913

914
    [System.ComponentModel.DesignerCategoryAttribute("code")]
915
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
916
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
917
    public class CT_LineChart
918
    {
919

920
        private CT_Grouping groupingField;
921

922
        private CT_Boolean varyColorsField;
923

924
        private List<CT_LineSer> serField;
925

926
        private CT_DLbls dLblsField;
927

928
        private CT_ChartLines dropLinesField;
929

930
        private CT_ChartLines hiLowLinesField;
931

932
        private CT_UpDownBars upDownBarsField;
933

934
        private CT_Boolean markerField;
935

936
        private CT_Boolean smoothField;
937

938
        private List<CT_UnsignedInt> axIdField;
939

940
        private List<CT_Extension> extLstField;
941

942
        public CT_LineChart()
943
        {
944
        }
945
        public static CT_LineChart Parse(XmlNode node, XmlNamespaceManager namespaceManager)
946
        {
947
            if (node == null)
948
                return null;
949
            CT_LineChart ctObj = new CT_LineChart();
950
            ctObj.ser = new List<CT_LineSer>();
951
            ctObj.axId = new List<CT_UnsignedInt>();
952
            ctObj.extLst = new List<CT_Extension>();
953
            foreach (XmlNode childNode in node.ChildNodes)
954
            {
955
                if (childNode.LocalName == "grouping")
956
                    ctObj.grouping = CT_Grouping.Parse(childNode, namespaceManager);
957
                else if (childNode.LocalName == "varyColors")
958
                    ctObj.varyColors = CT_Boolean.Parse(childNode, namespaceManager);
959
                else if (childNode.LocalName == "dLbls")
960
                    ctObj.dLbls = CT_DLbls.Parse(childNode, namespaceManager);
961
                else if (childNode.LocalName == "dropLines")
962
                    ctObj.dropLines = CT_ChartLines.Parse(childNode, namespaceManager);
963
                else if (childNode.LocalName == "hiLowLines")
964
                    ctObj.hiLowLines = CT_ChartLines.Parse(childNode, namespaceManager);
965
                else if (childNode.LocalName == "upDownBars")
966
                    ctObj.upDownBars = CT_UpDownBars.Parse(childNode, namespaceManager);
967
                else if (childNode.LocalName == "marker")
968
                    ctObj.marker = CT_Boolean.Parse(childNode, namespaceManager);
969
                else if (childNode.LocalName == "smooth")
970
                    ctObj.smooth = CT_Boolean.Parse(childNode, namespaceManager);
971
                else if (childNode.LocalName == "ser")
972
                    ctObj.ser.Add(CT_LineSer.Parse(childNode, namespaceManager));
973
                else if (childNode.LocalName == "axId")
974
                    ctObj.axId.Add(CT_UnsignedInt.Parse(childNode, namespaceManager));
975
                else if (childNode.LocalName == "extLst")
976
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
977
            }
978
            return ctObj;
979
        }
980

981

982

983
        internal void Write(StreamWriter sw, string nodeName)
984
        {
985
            sw.Write(string.Format("<c:{0}", nodeName));
986
            sw.Write(">");
987
            if (this.grouping != null)
988
                this.grouping.Write(sw, "grouping");
989
            if (this.varyColors != null)
990
                this.varyColors.Write(sw, "varyColors");
991
            if (this.ser != null)
992
            {
993
                foreach (CT_LineSer x in this.ser)
994
                {
995
                    x.Write(sw, "ser");
996
                }
997
            }
998
            if (this.dLbls != null)
999
                this.dLbls.Write(sw, "dLbls");
1000
            if (this.dropLines != null)
1001
                this.dropLines.Write(sw, "dropLines");
1002
            if (this.hiLowLines != null)
1003
                this.hiLowLines.Write(sw, "hiLowLines");
1004
            if (this.upDownBars != null)
1005
                this.upDownBars.Write(sw, "upDownBars");
1006
            if (this.marker != null)
1007
                this.marker.Write(sw, "marker");
1008
            if (this.smooth != null)
1009
                this.smooth.Write(sw, "smooth");
1010

1011
            if (this.axId != null)
1012
            {
1013
                foreach (CT_UnsignedInt x in this.axId)
1014
                {
1015
                    x.Write(sw, "axId");
1016
                }
1017
            }
1018
            if (this.extLst != null)
1019
            {
1020
                foreach (CT_Extension x in this.extLst)
1021
                {
1022
                    x.Write(sw, "extLst");
1023
                }
1024
            }
1025
            sw.Write(string.Format("</c:{0}>", nodeName));
1026
        }
1027

1028
        public int GetSeriesCount()
1029
        {
1030
            return this.serField == null ? 0 : this.serField.Count;
1031
        }
1032

1033
        [XmlElement(Order = 0)]
1034
        public CT_Grouping grouping
1035
        {
1036
            get
1037
            {
1038
                return this.groupingField;
1039
            }
1040
            set
1041
            {
1042
                this.groupingField = value;
1043
            }
1044
        }
1045

1046
        [XmlElement(Order = 1)]
1047
        public CT_Boolean varyColors
1048
        {
1049
            get
1050
            {
1051
                return this.varyColorsField;
1052
            }
1053
            set
1054
            {
1055
                this.varyColorsField = value;
1056
            }
1057
        }
1058

1059
        [XmlElement("ser", Order = 2)]
1060
        public List<CT_LineSer> ser
1061
        {
1062
            get
1063
            {
1064
                return this.serField;
1065
            }
1066
            set
1067
            {
1068
                this.serField = value;
1069
            }
1070
        }
1071

1072
        [XmlElement(Order = 3)]
1073
        public CT_DLbls dLbls
1074
        {
1075
            get
1076
            {
1077
                return this.dLblsField;
1078
            }
1079
            set
1080
            {
1081
                this.dLblsField = value;
1082
            }
1083
        }
1084

1085
        [XmlElement(Order = 4)]
1086
        public CT_ChartLines dropLines
1087
        {
1088
            get
1089
            {
1090
                return this.dropLinesField;
1091
            }
1092
            set
1093
            {
1094
                this.dropLinesField = value;
1095
            }
1096
        }
1097

1098
        [XmlElement(Order = 5)]
1099
        public CT_ChartLines hiLowLines
1100
        {
1101
            get
1102
            {
1103
                return this.hiLowLinesField;
1104
            }
1105
            set
1106
            {
1107
                this.hiLowLinesField = value;
1108
            }
1109
        }
1110

1111
        [XmlElement(Order = 6)]
1112
        public CT_UpDownBars upDownBars
1113
        {
1114
            get
1115
            {
1116
                return this.upDownBarsField;
1117
            }
1118
            set
1119
            {
1120
                this.upDownBarsField = value;
1121
            }
1122
        }
1123

1124
        [XmlElement(Order = 7)]
1125
        public CT_Boolean marker
1126
        {
1127
            get
1128
            {
1129
                return this.markerField;
1130
            }
1131
            set
1132
            {
1133
                this.markerField = value;
1134
            }
1135
        }
1136

1137
        [XmlElement(Order = 8)]
1138
        public CT_Boolean smooth
1139
        {
1140
            get
1141
            {
1142
                return this.smoothField;
1143
            }
1144
            set
1145
            {
1146
                this.smoothField = value;
1147
            }
1148
        }
1149

1150
        [XmlElement("axId", Order = 9)]
1151
        public List<CT_UnsignedInt> axId
1152
        {
1153
            get
1154
            {
1155
                return this.axIdField;
1156
            }
1157
            set
1158
            {
1159
                this.axIdField = value;
1160
            }
1161
        }
1162

1163
        [XmlElement(Order = 10)]
1164
        public List<CT_Extension> extLst
1165
        {
1166
            get
1167
            {
1168
                return this.extLstField;
1169
            }
1170
            set
1171
            {
1172
                this.extLstField = value;
1173
            }
1174
        }
1175
        public CT_Grouping AddNewGrouping()
1176
        {
1177
            this.groupingField = new CT_Grouping();
1178
            return this.groupingField;
1179
        }
1180
        public CT_LineSer AddNewSer()
1181
        {
1182
            CT_LineSer newSer = new  CT_LineSer();
1183
            if (this.serField == null)
1184
            {
1185
                this.serField = new List<CT_LineSer>();
1186
            }
1187
            this.serField.Add(newSer);
1188
            return newSer;
1189
        }
1190

1191
        public CT_Boolean AddNewVaryColors()
1192
        {
1193
            this.varyColorsField = new CT_Boolean();
1194
            return this.varyColorsField;
1195
        }
1196

1197
        public CT_UnsignedInt AddNewAxId()
1198
        {
1199
            CT_UnsignedInt si = new CT_UnsignedInt();
1200
            if (this.axIdField == null)
1201
                this.axIdField = new List<CT_UnsignedInt>();
1202
            axIdField.Add(si);
1203
            return si;
1204
        }
1205
    }
1206

1207

1208
}
1209