npoi

1
// ------------------------------------------------------------------------------
2
//  <auto-generated>
3
//    Generated by Xsd2Code. Version 3.4.0.38967
4
//    <NameSpace>NPOI.OpenXmlFormats.Dml</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>False</DisableDebug><PropNameSpecified>Default</PropNameSpecified><Encoder>UTF8</Encoder><CustomUsings></CustomUsings><ExcludeIncludedTypes>True</ExcludeIncludedTypes><EnableInitializeFields>True</EnableInitializeFields>
5
//  </auto-generated>
6
// ------------------------------------------------------------------------------
7
namespace NPOI.OpenXmlFormats.Dml
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.Xml;
17
    using NPOI.OpenXml4Net.Util;
18
    using System.IO;
19
    using NPOI.OpenXmlFormats.Vml;
20

21
    [Serializable]
22
    [System.ComponentModel.DesignerCategoryAttribute("code")]
23
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
24
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
25
    public class CT_ColorScheme
26
    {
27

28
        private CT_Color dk1Field;
29

30
        private CT_Color lt1Field;
31

32
        private CT_Color dk2Field;
33

34
        private CT_Color lt2Field;
35

36
        private CT_Color accent1Field;
37

38
        private CT_Color accent2Field;
39

40
        private CT_Color accent3Field;
41

42
        private CT_Color accent4Field;
43

44
        private CT_Color accent5Field;
45

46
        private CT_Color accent6Field;
47

48
        private CT_Color hlinkField;
49

50
        private CT_Color folHlinkField;
51

52
        private CT_OfficeArtExtensionList extLstField;
53

54
        private string nameField;
55

56
        public CT_ColorScheme()
57
        {
58
        }
59
        public static CT_ColorScheme Parse(XmlNode node, XmlNamespaceManager namespaceManager)
60
        {
61
            if (node == null)
62
                return null;
63
            CT_ColorScheme ctObj = new CT_ColorScheme();
64
            ctObj.name = XmlHelper.ReadString(node.Attributes["name"]);
65
            foreach (XmlNode childNode in node.ChildNodes)
66
            {
67
                if (childNode.LocalName == "dk1")
68
                    ctObj.dk1 = CT_Color.Parse(childNode, namespaceManager);
69
                else if (childNode.LocalName == "lt1")
70
                    ctObj.lt1 = CT_Color.Parse(childNode, namespaceManager);
71
                else if (childNode.LocalName == "dk2")
72
                    ctObj.dk2 = CT_Color.Parse(childNode, namespaceManager);
73
                else if (childNode.LocalName == "lt2")
74
                    ctObj.lt2 = CT_Color.Parse(childNode, namespaceManager);
75
                else if (childNode.LocalName == "accent1")
76
                    ctObj.accent1 = CT_Color.Parse(childNode, namespaceManager);
77
                else if (childNode.LocalName == "accent2")
78
                    ctObj.accent2 = CT_Color.Parse(childNode, namespaceManager);
79
                else if (childNode.LocalName == "accent3")
80
                    ctObj.accent3 = CT_Color.Parse(childNode, namespaceManager);
81
                else if (childNode.LocalName == "accent4")
82
                    ctObj.accent4 = CT_Color.Parse(childNode, namespaceManager);
83
                else if (childNode.LocalName == "accent5")
84
                    ctObj.accent5 = CT_Color.Parse(childNode, namespaceManager);
85
                else if (childNode.LocalName == "accent6")
86
                    ctObj.accent6 = CT_Color.Parse(childNode, namespaceManager);
87
                else if (childNode.LocalName == "hlink")
88
                    ctObj.hlink = CT_Color.Parse(childNode, namespaceManager);
89
                else if (childNode.LocalName == "folHlink")
90
                    ctObj.folHlink = CT_Color.Parse(childNode, namespaceManager);
91
                else if (childNode.LocalName == "extLst")
92
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
93
            }
94
            return ctObj;
95
        }
96

97

98

99
        internal void Write(StreamWriter sw, string nodeName)
100
        {
101
            sw.Write(string.Format("<a:{0}", nodeName));
102
            XmlHelper.WriteAttribute(sw, "name", this.name);
103
            sw.Write(">");
104
            if (this.dk1 != null)
105
                this.dk1.Write(sw, "dk1");
106
            if (this.lt1 != null)
107
                this.lt1.Write(sw, "lt1");
108
            if (this.dk2 != null)
109
                this.dk2.Write(sw, "dk2");
110
            if (this.lt2 != null)
111
                this.lt2.Write(sw, "lt2");
112
            if (this.accent1 != null)
113
                this.accent1.Write(sw, "accent1");
114
            if (this.accent2 != null)
115
                this.accent2.Write(sw, "accent2");
116
            if (this.accent3 != null)
117
                this.accent3.Write(sw, "accent3");
118
            if (this.accent4 != null)
119
                this.accent4.Write(sw, "accent4");
120
            if (this.accent5 != null)
121
                this.accent5.Write(sw, "accent5");
122
            if (this.accent6 != null)
123
                this.accent6.Write(sw, "accent6");
124
            if (this.hlink != null)
125
                this.hlink.Write(sw, "hlink");
126
            if (this.folHlink != null)
127
                this.folHlink.Write(sw, "folHlink");
128
            if (this.extLst != null)
129
                this.extLst.Write(sw, "extLst");
130
            sw.Write(string.Format("</a:{0}>", nodeName));
131
        }
132

133
        [XmlElement(Order = 0)]
134
        public CT_Color dk1
135
        {
136
            get
137
            {
138
                return this.dk1Field;
139
            }
140
            set
141
            {
142
                this.dk1Field = value;
143
            }
144
        }
145

146
        [XmlElement(Order = 1)]
147
        public CT_Color lt1
148
        {
149
            get
150
            {
151
                return this.lt1Field;
152
            }
153
            set
154
            {
155
                this.lt1Field = value;
156
            }
157
        }
158

159
        [XmlElement(Order = 2)]
160
        public CT_Color dk2
161
        {
162
            get
163
            {
164
                return this.dk2Field;
165
            }
166
            set
167
            {
168
                this.dk2Field = value;
169
            }
170
        }
171

172
        [XmlElement(Order = 3)]
173
        public CT_Color lt2
174
        {
175
            get
176
            {
177
                return this.lt2Field;
178
            }
179
            set
180
            {
181
                this.lt2Field = value;
182
            }
183
        }
184

185
        [XmlElement(Order = 4)]
186
        public CT_Color accent1
187
        {
188
            get
189
            {
190
                return this.accent1Field;
191
            }
192
            set
193
            {
194
                this.accent1Field = value;
195
            }
196
        }
197

198
        [XmlElement(Order = 5)]
199
        public CT_Color accent2
200
        {
201
            get
202
            {
203
                return this.accent2Field;
204
            }
205
            set
206
            {
207
                this.accent2Field = value;
208
            }
209
        }
210

211
        [XmlElement(Order = 6)]
212
        public CT_Color accent3
213
        {
214
            get
215
            {
216
                return this.accent3Field;
217
            }
218
            set
219
            {
220
                this.accent3Field = value;
221
            }
222
        }
223

224
        [XmlElement(Order = 7)]
225
        public CT_Color accent4
226
        {
227
            get
228
            {
229
                return this.accent4Field;
230
            }
231
            set
232
            {
233
                this.accent4Field = value;
234
            }
235
        }
236

237
        [XmlElement(Order = 8)]
238
        public CT_Color accent5
239
        {
240
            get
241
            {
242
                return this.accent5Field;
243
            }
244
            set
245
            {
246
                this.accent5Field = value;
247
            }
248
        }
249

250
        [XmlElement(Order = 9)]
251
        public CT_Color accent6
252
        {
253
            get
254
            {
255
                return this.accent6Field;
256
            }
257
            set
258
            {
259
                this.accent6Field = value;
260
            }
261
        }
262

263
        [XmlElement(Order = 10)]
264
        public CT_Color hlink
265
        {
266
            get
267
            {
268
                return this.hlinkField;
269
            }
270
            set
271
            {
272
                this.hlinkField = value;
273
            }
274
        }
275

276
        [XmlElement(Order = 11)]
277
        public CT_Color folHlink
278
        {
279
            get
280
            {
281
                return this.folHlinkField;
282
            }
283
            set
284
            {
285
                this.folHlinkField = value;
286
            }
287
        }
288

289
        [XmlElement(Order = 12)]
290
        public CT_OfficeArtExtensionList extLst
291
        {
292
            get
293
            {
294
                return this.extLstField;
295
            }
296
            set
297
            {
298
                this.extLstField = value;
299
            }
300
        }
301

302
        [XmlAttribute]
303
        public string name
304
        {
305
            get
306
            {
307
                return this.nameField;
308
            }
309
            set
310
            {
311
                this.nameField = value;
312
            }
313
        }
314
    }
315

316

317
    [Serializable]
318
    [System.ComponentModel.DesignerCategoryAttribute("code")]
319
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
320
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
321
    public class CT_CustomColor
322
    {
323

324
        private CT_ScRgbColor scrgbClrField;
325

326
        private CT_SRgbColor srgbClrField;
327

328
        private CT_HslColor hslClrField;
329

330
        private CT_SystemColor sysClrField;
331

332
        private CT_SchemeColor schemeClrField;
333

334
        private CT_PresetColor prstClrField;
335

336
        private string nameField;
337
        public static CT_CustomColor Parse(XmlNode node, XmlNamespaceManager namespaceManager)
338
        {
339
            if (node == null)
340
                return null;
341
            CT_CustomColor ctObj = new CT_CustomColor();
342
            ctObj.name = XmlHelper.ReadString(node.Attributes["name"]);
343
            foreach (XmlNode childNode in node.ChildNodes)
344
            {
345
                if (childNode.LocalName == "scrgbClr")
346
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
347
                else if (childNode.LocalName == "srgbClr")
348
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
349
                else if (childNode.LocalName == "hslClr")
350
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
351
                else if (childNode.LocalName == "sysClr")
352
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
353
                else if (childNode.LocalName == "schemeClr")
354
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
355
                else if (childNode.LocalName == "prstClr")
356
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
357
            }
358
            return ctObj;
359
        }
360

361

362

363
        internal void Write(StreamWriter sw, string nodeName)
364
        {
365
            sw.Write(string.Format("<a:{0}", nodeName));
366
            XmlHelper.WriteAttribute(sw, "name", this.name);
367
            sw.Write(">");
368
            if (this.scrgbClr != null)
369
                this.scrgbClr.Write(sw, "scrgbClr");
370
            if (this.srgbClr != null)
371
                this.srgbClr.Write(sw, "srgbClr");
372
            if (this.hslClr != null)
373
                this.hslClr.Write(sw, "hslClr");
374
            if (this.sysClr != null)
375
                this.sysClr.Write(sw, "sysClr");
376
            if (this.schemeClr != null)
377
                this.schemeClr.Write(sw, "schemeClr");
378
            if (this.prstClr != null)
379
                this.prstClr.Write(sw, "prstClr");
380
            sw.Write(string.Format("</a:{0}>", nodeName));
381
        }
382

383
        public CT_CustomColor()
384
        {
385
            //this.prstClrField = new CT_PresetColor();
386
            //this.schemeClrField = new CT_SchemeColor();
387
            //this.sysClrField = new CT_SystemColor();
388
            //this.hslClrField = new CT_HslColor();
389
            //this.srgbClrField = new CT_SRgbColor();
390
            //this.scrgbClrField = new CT_ScRgbColor();
391
            //this.nameField = "";
392
        }
393

394
        [XmlElement(Order = 0)]
395
        public CT_ScRgbColor scrgbClr
396
        {
397
            get
398
            {
399
                return this.scrgbClrField;
400
            }
401
            set
402
            {
403
                this.scrgbClrField = value;
404
            }
405
        }
406

407
        [XmlElement(Order = 1)]
408
        public CT_SRgbColor srgbClr
409
        {
410
            get
411
            {
412
                return this.srgbClrField;
413
            }
414
            set
415
            {
416
                this.srgbClrField = value;
417
            }
418
        }
419

420
        [XmlElement(Order = 2)]
421
        public CT_HslColor hslClr
422
        {
423
            get
424
            {
425
                return this.hslClrField;
426
            }
427
            set
428
            {
429
                this.hslClrField = value;
430
            }
431
        }
432

433
        [XmlElement(Order = 3)]
434
        public CT_SystemColor sysClr
435
        {
436
            get
437
            {
438
                return this.sysClrField;
439
            }
440
            set
441
            {
442
                this.sysClrField = value;
443
            }
444
        }
445

446
        [XmlElement(Order = 4)]
447
        public CT_SchemeColor schemeClr
448
        {
449
            get
450
            {
451
                return this.schemeClrField;
452
            }
453
            set
454
            {
455
                this.schemeClrField = value;
456
            }
457
        }
458

459
        [XmlElement(Order = 5)]
460
        public CT_PresetColor prstClr
461
        {
462
            get
463
            {
464
                return this.prstClrField;
465
            }
466
            set
467
            {
468
                this.prstClrField = value;
469
            }
470
        }
471

472
        [XmlAttribute]
473
        [DefaultValue("")]
474
        public string name
475
        {
476
            get
477
            {
478
                return this.nameField;
479
            }
480
            set
481
            {
482
                this.nameField = value;
483
            }
484
        }
485
    }
486

487

488
    [Serializable]
489
    [System.ComponentModel.DesignerCategoryAttribute("code")]
490
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
491
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
492
    public class CT_SupplementalFont
493
    {
494

495
        private string scriptField;
496

497
        private string typefaceField;
498
        public static CT_SupplementalFont Parse(XmlNode node, XmlNamespaceManager namespaceManager)
499
        {
500
            if (node == null)
501
                return null;
502
            CT_SupplementalFont ctObj = new CT_SupplementalFont();
503
            ctObj.script = XmlHelper.ReadString(node.Attributes["script"]);
504
            ctObj.typeface = XmlHelper.ReadString(node.Attributes["typeface"]);
505
            return ctObj;
506
        }
507

508

509

510
        internal void Write(StreamWriter sw, string nodeName)
511
        {
512
            sw.Write(string.Format("<a:{0}", nodeName));
513
            XmlHelper.WriteAttribute(sw, "script", this.script);
514
            XmlHelper.WriteAttribute(sw, "typeface", this.typeface, true);
515
            sw.Write("/>");
516
        }
517

518
        [XmlAttribute]
519
        public string script
520
        {
521
            get
522
            {
523
                return this.scriptField;
524
            }
525
            set
526
            {
527
                this.scriptField = value;
528
            }
529
        }
530

531
        [XmlAttribute]
532
        public string typeface
533
        {
534
            get
535
            {
536
                return this.typefaceField;
537
            }
538
            set
539
            {
540
                this.typefaceField = value;
541
            }
542
        }
543
    }
544

545

546
    [Serializable]
547
    [System.ComponentModel.DesignerCategoryAttribute("code")]
548
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
549
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
550
    public class CT_CustomColorList
551
    {
552

553
        private List<CT_CustomColor> custClrField;
554

555
        public CT_CustomColorList()
556
        {
557
            this.custClrField = new List<CT_CustomColor>();
558
        }
559

560
        [XmlElement("custClr", Order = 0)]
561
        public List<CT_CustomColor> custClr
562
        {
563
            get
564
            {
565
                return this.custClrField;
566
            }
567
            set
568
            {
569
                this.custClrField = value;
570
            }
571
        }
572
    }
573

574

575
    [Serializable]
576
    [System.ComponentModel.DesignerCategoryAttribute("code")]
577
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
578
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
579
    public class CT_FontCollection
580
    {
581

582
        private CT_TextFont latinField;
583

584
        private CT_TextFont eaField;
585

586
        private CT_TextFont csField;
587

588
        private List<CT_SupplementalFont> fontField;
589

590
        private CT_OfficeArtExtensionList extLstField;
591
        public static CT_FontCollection Parse(XmlNode node, XmlNamespaceManager namespaceManager)
592
        {
593
            if (node == null)
594
                return null;
595
            CT_FontCollection ctObj = new CT_FontCollection();
596
            ctObj.font = new List<CT_SupplementalFont>();
597
            foreach (XmlNode childNode in node.ChildNodes)
598
            {
599
                if (childNode.LocalName == "latin")
600
                    ctObj.latin = CT_TextFont.Parse(childNode, namespaceManager);
601
                else if (childNode.LocalName == "ea")
602
                    ctObj.ea = CT_TextFont.Parse(childNode, namespaceManager);
603
                else if (childNode.LocalName == "cs")
604
                    ctObj.cs = CT_TextFont.Parse(childNode, namespaceManager);
605
                else if (childNode.LocalName == "extLst")
606
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
607
                else if (childNode.LocalName == "font")
608
                    ctObj.font.Add(CT_SupplementalFont.Parse(childNode, namespaceManager));
609
            }
610
            return ctObj;
611
        }
612

613

614

615
        internal void Write(StreamWriter sw, string nodeName)
616
        {
617
            sw.Write(string.Format("<a:{0}", nodeName));
618
            sw.Write(">");
619
            if (this.latin != null)
620
                this.latin.Write(sw, "latin");
621
            if (this.ea != null)
622
                this.ea.Write(sw, "ea");
623
            if (this.cs != null)
624
                this.cs.Write(sw, "cs");
625
            if (this.extLst != null)
626
                this.extLst.Write(sw, "extLst");
627
            if (this.font != null)
628
            {
629
                foreach (CT_SupplementalFont x in this.font)
630
                {
631
                    x.Write(sw, "font");
632
                }
633
            }
634
            sw.Write(string.Format("</a:{0}>", nodeName));
635
        }
636

637
        public CT_FontCollection()
638
        {
639
            //this.extLstField = new CT_OfficeArtExtensionList();
640
            //this.fontField = new List<CT_SupplementalFont>();
641
            //this.csField = new CT_TextFont();
642
            //this.eaField = new CT_TextFont();
643
            //this.latinField = new CT_TextFont();
644
        }
645

646
        [XmlElement(Order = 0)]
647
        public CT_TextFont latin
648
        {
649
            get
650
            {
651
                return this.latinField;
652
            }
653
            set
654
            {
655
                this.latinField = value;
656
            }
657
        }
658

659
        [XmlElement(Order = 1)]
660
        public CT_TextFont ea
661
        {
662
            get
663
            {
664
                return this.eaField;
665
            }
666
            set
667
            {
668
                this.eaField = value;
669
            }
670
        }
671

672
        [XmlElement(Order = 2)]
673
        public CT_TextFont cs
674
        {
675
            get
676
            {
677
                return this.csField;
678
            }
679
            set
680
            {
681
                this.csField = value;
682
            }
683
        }
684

685
        [XmlElement("font", Order = 3)]
686
        public List<CT_SupplementalFont> font
687
        {
688
            get
689
            {
690
                return this.fontField;
691
            }
692
            set
693
            {
694
                this.fontField = value;
695
            }
696
        }
697

698
        [XmlElement(Order = 4)]
699
        public CT_OfficeArtExtensionList extLst
700
        {
701
            get
702
            {
703
                return this.extLstField;
704
            }
705
            set
706
            {
707
                this.extLstField = value;
708
            }
709
        }
710
    }
711

712

713

714
    [Serializable]
715
    [System.ComponentModel.DesignerCategoryAttribute("code")]
716
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
717
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
718
    public class CT_EffectStyleItem
719
    {
720

721
        private CT_EffectList effectLstField;
722

723
        private CT_EffectContainer effectDagField;
724

725
        private CT_Scene3D scene3dField;
726

727
        private CT_Shape3D sp3dField;
728
        public static CT_EffectStyleItem Parse(XmlNode node, XmlNamespaceManager namespaceManager)
729
        {
730
            if (node == null)
731
                return null;
732
            CT_EffectStyleItem ctObj = new CT_EffectStyleItem();
733
            foreach (XmlNode childNode in node.ChildNodes)
734
            {
735
                if (childNode.LocalName == "effectLst")
736
                    ctObj.effectLst = CT_EffectList.Parse(childNode, namespaceManager);
737
                else if (childNode.LocalName == "effectDag")
738
                    ctObj.effectDag = CT_EffectContainer.Parse(childNode, namespaceManager);
739
                else if (childNode.LocalName == "scene3d")
740
                    ctObj.scene3d = CT_Scene3D.Parse(childNode, namespaceManager);
741
                else if (childNode.LocalName == "sp3d")
742
                    ctObj.sp3d = CT_Shape3D.Parse(childNode, namespaceManager);
743
            }
744
            return ctObj;
745
        }
746

747

748

749
        internal void Write(StreamWriter sw, string nodeName)
750
        {
751
            sw.Write(string.Format("<a:{0}", nodeName));
752
            sw.Write(">");
753
            if (this.effectLst != null)
754
                this.effectLst.Write(sw, "effectLst");
755
            if (this.effectDag != null)
756
                this.effectDag.Write(sw, "effectDag");
757
            if (this.scene3d != null)
758
                this.scene3d.Write(sw, "scene3d");
759
            if (this.sp3d != null)
760
                this.sp3d.Write(sw, "sp3d");
761
            sw.Write(string.Format("</a:{0}>", nodeName));
762
        }
763

764
        public CT_EffectStyleItem()
765
        {
766
            //this.sp3dField = new CT_Shape3D();
767
            //this.scene3dField = new CT_Scene3D();
768
            //this.effectDagField = new CT_EffectContainer();
769
            //this.effectLstField = new CT_EffectList();
770
        }
771

772
        [XmlElement(Order = 0)]
773
        public CT_EffectList effectLst
774
        {
775
            get
776
            {
777
                return this.effectLstField;
778
            }
779
            set
780
            {
781
                this.effectLstField = value;
782
            }
783
        }
784

785
        [XmlElement(Order = 1)]
786
        public CT_EffectContainer effectDag
787
        {
788
            get
789
            {
790
                return this.effectDagField;
791
            }
792
            set
793
            {
794
                this.effectDagField = value;
795
            }
796
        }
797

798
        [XmlElement(Order = 2)]
799
        public CT_Scene3D scene3d
800
        {
801
            get
802
            {
803
                return this.scene3dField;
804
            }
805
            set
806
            {
807
                this.scene3dField = value;
808
            }
809
        }
810

811
        [XmlElement(Order = 3)]
812
        public CT_Shape3D sp3d
813
        {
814
            get
815
            {
816
                return this.sp3dField;
817
            }
818
            set
819
            {
820
                this.sp3dField = value;
821
            }
822
        }
823
    }
824

825

826
    [Serializable]
827
    [System.ComponentModel.DesignerCategoryAttribute("code")]
828
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
829
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
830
    public class CT_FontScheme
831
    {
832

833
        private CT_FontCollection majorFontField;
834

835
        private CT_FontCollection minorFontField;
836

837
        private CT_OfficeArtExtensionList extLstField;
838

839
        private string nameField;
840
        public static CT_FontScheme Parse(XmlNode node, XmlNamespaceManager namespaceManager)
841
        {
842
            if (node == null)
843
                return null;
844
            CT_FontScheme ctObj = new CT_FontScheme();
845
            ctObj.name = XmlHelper.ReadString(node.Attributes["name"]);
846
            foreach (XmlNode childNode in node.ChildNodes)
847
            {
848
                if (childNode.LocalName == "majorFont")
849
                    ctObj.majorFont = CT_FontCollection.Parse(childNode, namespaceManager);
850
                else if (childNode.LocalName == "minorFont")
851
                    ctObj.minorFont = CT_FontCollection.Parse(childNode, namespaceManager);
852
                else if (childNode.LocalName == "extLst")
853
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
854
            }
855
            return ctObj;
856
        }
857

858

859

860
        internal void Write(StreamWriter sw, string nodeName)
861
        {
862
            sw.Write(string.Format("<a:{0}", nodeName));
863
            XmlHelper.WriteAttribute(sw, "name", this.name);
864
            sw.Write(">");
865
            if (this.majorFont != null)
866
                this.majorFont.Write(sw, "majorFont");
867
            if (this.minorFont != null)
868
                this.minorFont.Write(sw, "minorFont");
869
            if (this.extLst != null)
870
                this.extLst.Write(sw, "extLst");
871
            sw.Write(string.Format("</a:{0}>", nodeName));
872
        }
873

874
        public CT_FontScheme()
875
        {
876
            //this.extLstField = new CT_OfficeArtExtensionList();
877
            //this.minorFontField = new CT_FontCollection();
878
            //this.majorFontField = new CT_FontCollection();
879
        }
880

881
        [XmlElement(Order = 0)]
882
        public CT_FontCollection majorFont
883
        {
884
            get
885
            {
886
                return this.majorFontField;
887
            }
888
            set
889
            {
890
                this.majorFontField = value;
891
            }
892
        }
893

894
        [XmlElement(Order = 1)]
895
        public CT_FontCollection minorFont
896
        {
897
            get
898
            {
899
                return this.minorFontField;
900
            }
901
            set
902
            {
903
                this.minorFontField = value;
904
            }
905
        }
906

907
        [XmlElement(Order = 2)]
908
        public CT_OfficeArtExtensionList extLst
909
        {
910
            get
911
            {
912
                return this.extLstField;
913
            }
914
            set
915
            {
916
                this.extLstField = value;
917
            }
918
        }
919

920
        [XmlAttribute]
921
        public string name
922
        {
923
            get
924
            {
925
                return this.nameField;
926
            }
927
            set
928
            {
929
                this.nameField = value;
930
            }
931
        }
932
    }
933

934

935
    [Serializable]
936
    [System.ComponentModel.DesignerCategoryAttribute("code")]
937
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
938
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
939
    public class CT_FillStyleList
940
    {
941
        
942
        public CT_FillStyleList()
943
        {
944
        }
945
        public static CT_FillStyleList Parse(XmlNode node, XmlNamespaceManager namespaceManager)
946
        {
947
            if (node == null)
948
                return null;
949
            CT_FillStyleList ctObj = new CT_FillStyleList();
950
            ctObj.blipFill = new List<CT_BlipFillProperties>();
951
            ctObj.gradFill = new List<CT_GradientFillProperties>();
952
            ctObj.grpFill = new List<CT_GroupFillProperties>();
953
            ctObj.noFill = new List<CT_NoFillProperties>();
954
            ctObj.pattFill = new List<CT_PatternFillProperties>();
955
            ctObj.solidFill = new List<CT_SolidColorFillProperties>();
956
            foreach (XmlNode childNode in node.ChildNodes)
957
            {
958
                if (childNode.LocalName == "solidFill")
959
                    ctObj.solidFill.Add(CT_SolidColorFillProperties.Parse(childNode, namespaceManager));
960
                else if (childNode.LocalName == "blipFill")
961
                    ctObj.blipFill.Add(CT_BlipFillProperties.Parse(childNode, namespaceManager));
962
                else if (childNode.LocalName == "gradFill")
963
                    ctObj.gradFill.Add(CT_GradientFillProperties.Parse(childNode, namespaceManager));
964
                else if (childNode.LocalName == "grpFill")
965
                    ctObj.grpFill.Add(new CT_GroupFillProperties());
966
                else if (childNode.LocalName == "noFill")
967
                    ctObj.noFill.Add(new CT_NoFillProperties());
968
                else if (childNode.LocalName == "pattFill")
969
                    ctObj.pattFill.Add(CT_PatternFillProperties.Parse(childNode, namespaceManager));
970
            }
971
            return ctObj;
972
        }
973

974

975

976
        internal void Write(StreamWriter sw, string nodeName)
977
        {
978
            sw.Write(string.Format("<a:{0}", nodeName));
979
            sw.Write(">");
980
            if (this.blipFill != null)
981
            {
982
                foreach (CT_BlipFillProperties x in this.blipFill)
983
                {
984
                    x.Write(sw, "a:blipFill");
985
                }
986
            }
987
            if (this.solidFill != null)
988
            {
989
                foreach (CT_SolidColorFillProperties x in this.solidFill)
990
                {
991
                    x.Write(sw, "solidFill");
992
                }
993
            }
994
            if (this.gradFill != null)
995
            {
996
                foreach (CT_GradientFillProperties x in this.gradFill)
997
                {
998
                    x.Write(sw, "gradFill");
999
                }
1000
            }
1001
            if (this.grpFill != null)
1002
            {
1003
                foreach (CT_GroupFillProperties x in this.grpFill)
1004
                {
1005
                    sw.Write("<a:grpFill/>");
1006
                }
1007
            }
1008
            if (this.noFill != null)
1009
            {
1010
                foreach (CT_NoFillProperties x in this.noFill)
1011
                {
1012
                    sw.Write("<a:noFill/>");
1013
                }
1014
            }
1015
            if (this.pattFill != null)
1016
            {
1017
                foreach (CT_PatternFillProperties x in this.pattFill)
1018
                {
1019
                    x.Write(sw, "pattFill");
1020
                }
1021
            }
1022
            sw.Write(string.Format("</a:{0}>", nodeName));
1023
        }
1024

1025

1026

1027

1028
        List<CT_BlipFillProperties> blipFillField;
1029
        public List<CT_BlipFillProperties> blipFill
1030
        {
1031
            get
1032
            {
1033
                return blipFillField;
1034
            }
1035
            set
1036
            {
1037
                blipFillField = value;
1038
            }
1039
        }
1040
        List<CT_GradientFillProperties> gradFillField;
1041
        public List<CT_GradientFillProperties> gradFill
1042
        {
1043
            get
1044
            {
1045
                return gradFillField;
1046
            }
1047
            set
1048
            {
1049
                gradFillField = value;
1050
            }
1051
        }
1052
        List<CT_GroupFillProperties> grpFillField;
1053
        public List<CT_GroupFillProperties> grpFill
1054
        {
1055
            get
1056
            {
1057
                return grpFillField;
1058
            }
1059
            set
1060
            {
1061
                grpFillField = value;
1062
            }
1063
        }
1064
        List<CT_NoFillProperties> noFillField;
1065
        public List<CT_NoFillProperties> noFill
1066
        {
1067
            get
1068
            {
1069
                return noFillField;
1070
            }
1071
            set
1072
            {
1073
                noFillField = value;
1074
            }
1075
        }
1076
        List<CT_PatternFillProperties> pattFillField;
1077
        public List<CT_PatternFillProperties> pattFill
1078
        {
1079
            get
1080
            {
1081
                return pattFillField;
1082
            }
1083
            set
1084
            {
1085
                pattFillField = value;
1086
            }
1087
        }
1088
        List<CT_SolidColorFillProperties> solidFillField;
1089
        public List<CT_SolidColorFillProperties> solidFill
1090
        {
1091
            get
1092
            {
1093
                return solidFillField;
1094
            }
1095
            set
1096
            {
1097
                solidFillField = value;
1098
            }
1099
        }
1100
    }
1101

1102

1103
    [Serializable]
1104
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1105
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1106
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1107
    public class CT_LineStyleList
1108
    {
1109

1110
        private List<CT_LineProperties> lnField;
1111

1112
        public CT_LineStyleList()
1113
        {
1114
            this.lnField = new List<CT_LineProperties>();
1115
        }
1116
        public static CT_LineStyleList Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1117
        {
1118
            if (node == null)
1119
                return null;
1120
            CT_LineStyleList ctObj = new CT_LineStyleList();
1121
            ctObj.ln = new List<CT_LineProperties>();
1122
            foreach (XmlNode childNode in node.ChildNodes)
1123
            {
1124
                ctObj.ln.Add(CT_LineProperties.Parse(childNode, namespaceManager));
1125
            }
1126
            return ctObj;
1127
        }
1128

1129
        [XmlElement("ln", Order = 0)]
1130
        public List<CT_LineProperties> ln
1131
        {
1132
            get
1133
            {
1134
                return this.lnField;
1135
            }
1136
            set
1137
            {
1138
                this.lnField = value;
1139
            }
1140
        }
1141
        internal void Write(StreamWriter sw, string nodeName)
1142
        {
1143
            sw.Write(string.Format("<a:{0}>", nodeName));
1144
            if (this.ln.Count>0)
1145
            {
1146
                foreach (CT_LineProperties x in this.ln)
1147
                {
1148
                    x.Write(sw, "ln");
1149
                }
1150
            }
1151
            sw.Write(string.Format("</a:{0}>", nodeName));
1152
        }
1153
    }
1154

1155

1156
    [Serializable]
1157
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1158
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1159
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1160
    public class CT_EffectStyleList
1161
    {
1162

1163
        private List<CT_EffectStyleItem> effectStyleField;
1164

1165
        public CT_EffectStyleList()
1166
        {
1167
            this.effectStyleField = new List<CT_EffectStyleItem>();
1168
        }
1169

1170
        [XmlElement("effectStyle", Order = 0)]
1171
        public List<CT_EffectStyleItem> effectStyle
1172
        {
1173
            get
1174
            {
1175
                return this.effectStyleField;
1176
            }
1177
            set
1178
            {
1179
                this.effectStyleField = value;
1180
            }
1181
        }
1182

1183
        public static CT_EffectStyleList Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1184
        {
1185
            if (node == null)
1186
                return null;
1187
            CT_EffectStyleList ctObj = new CT_EffectStyleList();
1188
            ctObj.effectStyle = new List<CT_EffectStyleItem>();
1189
            foreach (XmlNode childNode in node.ChildNodes)
1190
            {
1191
                ctObj.effectStyle.Add(CT_EffectStyleItem.Parse(childNode, namespaceManager));
1192
            }
1193
            return ctObj;
1194
        }
1195
        internal void Write(StreamWriter sw, string nodeName)
1196
        {
1197
            sw.Write(string.Format("<a:{0}>", nodeName));
1198
            if (this.effectStyle.Count > 0)
1199
            {
1200
                foreach (CT_EffectStyleItem x in this.effectStyle)
1201
                {
1202
                    x.Write(sw, "effectStyle");
1203
                }
1204
            }
1205
            sw.Write(string.Format("</a:{0}>", nodeName));
1206
        }
1207
    }
1208

1209

1210
    [Serializable]
1211
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1212
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1213
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1214
    public class CT_BackgroundFillStyleList
1215
    {
1216
        public static CT_BackgroundFillStyleList Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1217
        {
1218
            if (node == null)
1219
                return null;
1220
            CT_BackgroundFillStyleList ctObj = new CT_BackgroundFillStyleList();
1221
            ctObj.blipFill = new List<CT_BlipFillProperties>();
1222
            ctObj.gradFill = new List<CT_GradientFillProperties>();
1223
            ctObj.grpFill = new List<CT_GroupFillProperties>();
1224
            ctObj.noFill = new List<CT_NoFillProperties>();
1225
            ctObj.pattFill = new List<CT_PatternFillProperties>();
1226
            ctObj.solidFill = new List<CT_SolidColorFillProperties>();
1227
            foreach (XmlNode childNode in node.ChildNodes)
1228
            {
1229
                if (childNode.LocalName == "blipFill")
1230
                    ctObj.blipFill.Add(CT_BlipFillProperties.Parse(childNode, namespaceManager));
1231
                else if (childNode.LocalName == "gradFill")
1232
                    ctObj.gradFill.Add(CT_GradientFillProperties.Parse(childNode, namespaceManager));
1233
                else if (childNode.LocalName == "grpFill")
1234
                    ctObj.grpFill.Add(new CT_GroupFillProperties());
1235
                else if (childNode.LocalName == "noFill")
1236
                    ctObj.noFill.Add(new CT_NoFillProperties());
1237
                else if (childNode.LocalName == "pattFill")
1238
                    ctObj.pattFill.Add(CT_PatternFillProperties.Parse(childNode, namespaceManager));
1239
                else if (childNode.LocalName == "solidFill")
1240
                    ctObj.solidFill.Add(CT_SolidColorFillProperties.Parse(childNode, namespaceManager));
1241
            }
1242
            return ctObj;
1243
        }
1244

1245

1246

1247
        internal void Write(StreamWriter sw, string nodeName)
1248
        {
1249
            sw.Write(string.Format("<a:{0}", nodeName));
1250
            sw.Write(">");
1251
            if (this.solidFill != null)
1252
            {
1253
                foreach (CT_SolidColorFillProperties x in this.solidFill)
1254
                {
1255
                    x.Write(sw, "solidFill");
1256
                }
1257
            }
1258
            if (this.gradFill != null)
1259
            {
1260
                foreach (CT_GradientFillProperties x in this.gradFill)
1261
                {
1262
                    x.Write(sw, "gradFill");
1263
                }
1264
            }
1265
            if (this.blipFill != null)
1266
            {
1267
                foreach (CT_BlipFillProperties x in this.blipFill)
1268
                {
1269
                    x.Write(sw, "a:blipFill");
1270
                }
1271
            }
1272
            if (this.grpFill != null)
1273
            {
1274
                foreach (CT_GroupFillProperties x in this.grpFill)
1275
                {
1276
                    sw.Write("<a:grpFill/>");
1277
                }
1278
            }
1279
            if (this.noFill != null)
1280
            {
1281
                foreach (CT_NoFillProperties x in this.noFill)
1282
                {
1283
                    sw.Write("<noFill/>");
1284
                }
1285
            }
1286
            if (this.pattFill != null)
1287
            {
1288
                foreach (CT_PatternFillProperties x in this.pattFill)
1289
                {
1290
                    x.Write(sw, "pattFill");
1291
                }
1292
            }
1293
            sw.Write(string.Format("</a:{0}>", nodeName));
1294
        }
1295

1296

1297

1298
        public CT_BackgroundFillStyleList()
1299
        {
1300
            //this.itemsField = new List<object>();
1301
        }
1302
        List<CT_BlipFillProperties> blipFillField;
1303
        public List<CT_BlipFillProperties> blipFill
1304
        {
1305
            get 
1306
            {
1307
                return blipFillField;
1308
            }
1309
            set {
1310
                blipFillField = value;
1311
            }
1312
        }
1313
        List<CT_GradientFillProperties> gradFillField;
1314
        public List<CT_GradientFillProperties> gradFill
1315
        {
1316
            get
1317
            {
1318
                return gradFillField;
1319
            }
1320
            set
1321
            {
1322
                gradFillField = value;
1323
            }
1324
        }
1325
        List<CT_GroupFillProperties> grpFillField;
1326
        public List<CT_GroupFillProperties> grpFill
1327
        {
1328
            get
1329
            {
1330
                return grpFillField;
1331
            }
1332
            set
1333
            {
1334
                grpFillField = value;
1335
            }
1336
        }
1337
        List<CT_NoFillProperties> noFillField;
1338
        public List<CT_NoFillProperties> noFill
1339
        {
1340
            get
1341
            {
1342
                return noFillField;
1343
            }
1344
            set
1345
            {
1346
                noFillField = value;
1347
            }
1348
        }
1349
        List<CT_PatternFillProperties> pattFillField;
1350
        public List<CT_PatternFillProperties> pattFill
1351
        {
1352
            get
1353
            {
1354
                return pattFillField;
1355
            }
1356
            set
1357
            {
1358
                pattFillField = value;
1359
            }
1360
        }
1361
        List<CT_SolidColorFillProperties> solidFillField;
1362
        public List<CT_SolidColorFillProperties> solidFill
1363
        {
1364
            get
1365
            {
1366
                return solidFillField;
1367
            }
1368
            set
1369
            {
1370
                solidFillField = value;
1371
            }
1372
        }
1373
    }
1374

1375

1376
    [Serializable]
1377
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1378
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1379
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1380
    public class CT_StyleMatrix
1381
    {
1382

1383
        private CT_FillStyleList fillStyleLstField;
1384

1385
        private CT_LineStyleList lnStyleLstField;
1386

1387
        private CT_EffectStyleList effectStyleLstField;
1388

1389
        private CT_BackgroundFillStyleList bgFillStyleLstField;
1390

1391
        private string nameField;
1392
        public static CT_StyleMatrix Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1393
        {
1394
            if (node == null)
1395
                return null;
1396
            CT_StyleMatrix ctObj = new CT_StyleMatrix();
1397
            ctObj.name = XmlHelper.ReadString(node.Attributes["name"]);
1398
            
1399
            foreach (XmlNode childNode in node.ChildNodes)
1400
            {
1401
                if (childNode.LocalName == "fillStyleLst")
1402
                    ctObj.fillStyleLst = CT_FillStyleList.Parse(childNode, namespaceManager);
1403
                else if (childNode.LocalName == "bgFillStyleLst")
1404
                    ctObj.bgFillStyleLst = CT_BackgroundFillStyleList.Parse(childNode, namespaceManager);
1405
                else if (childNode.LocalName == "lnStyleLst")
1406
                {
1407
                    ctObj.lnStyleLst = CT_LineStyleList.Parse(childNode, namespaceManager);
1408
                }
1409
                else if (childNode.LocalName == "effectStyleLst")
1410
                {
1411
                    ctObj.effectStyleLst= CT_EffectStyleList.Parse(childNode, namespaceManager);
1412
                }
1413
            }
1414
            return ctObj;
1415
        }
1416

1417

1418

1419
        internal void Write(StreamWriter sw, string nodeName)
1420
        {
1421
            sw.Write(string.Format("<a:{0}", nodeName));
1422
            XmlHelper.WriteAttribute(sw, "name", this.name);
1423
            sw.Write(">");
1424
            if (this.fillStyleLst != null)
1425
                this.fillStyleLst.Write(sw, "fillStyleLst");
1426
            if (this.lnStyleLst != null)
1427
            {
1428
                this.lnStyleLst.Write(sw, "lnStyleLst");
1429
            }
1430
            if (this.effectStyleLst != null)
1431
            {
1432
                this.effectStyleLst.Write(sw, "effectStyleLst");
1433
            }
1434
            if (this.bgFillStyleLst != null)
1435
                this.bgFillStyleLst.Write(sw, "bgFillStyleLst");
1436
            sw.Write(string.Format("</a:{0}>", nodeName));
1437
        }
1438

1439
        public CT_StyleMatrix()
1440
        {
1441
            this.nameField = "";
1442
        }
1443

1444
        [XmlElement(Order = 0)]
1445
        public CT_FillStyleList fillStyleLst
1446
        {
1447
            get
1448
            {
1449
                return this.fillStyleLstField;
1450
            }
1451
            set
1452
            {
1453
                this.fillStyleLstField = value;
1454
            }
1455
        }
1456

1457
        [XmlArray(Order = 1)]
1458
        [XmlArrayItem("ln", IsNullable = false)]
1459
        public CT_LineStyleList lnStyleLst
1460
        {
1461
            get
1462
            {
1463
                return this.lnStyleLstField;
1464
            }
1465
            set
1466
            {
1467
                this.lnStyleLstField = value;
1468
            }
1469
        }
1470

1471
        [XmlArray(Order = 2)]
1472
        [XmlArrayItem("effectStyle", IsNullable = false)]
1473
        public CT_EffectStyleList effectStyleLst
1474
        {
1475
            get
1476
            {
1477
                return this.effectStyleLstField;
1478
            }
1479
            set
1480
            {
1481
                this.effectStyleLstField = value;
1482
            }
1483
        }
1484

1485
        [XmlElement(Order = 3)]
1486
        public CT_BackgroundFillStyleList bgFillStyleLst
1487
        {
1488
            get
1489
            {
1490
                return this.bgFillStyleLstField;
1491
            }
1492
            set
1493
            {
1494
                this.bgFillStyleLstField = value;
1495
            }
1496
        }
1497

1498
        [XmlAttribute]
1499
        [DefaultValue("")]
1500
        public string name
1501
        {
1502
            get
1503
            {
1504
                return this.nameField;
1505
            }
1506
            set
1507
            {
1508
                this.nameField = value;
1509
            }
1510
        }
1511
    }
1512

1513

1514
    [Serializable]
1515
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1516
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1517
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1518
    public class CT_BaseStyles
1519
    {
1520

1521
        private CT_ColorScheme clrSchemeField;
1522

1523
        private CT_FontScheme fontSchemeField;
1524

1525
        private CT_StyleMatrix fmtSchemeField;
1526

1527
        private CT_OfficeArtExtensionList extLstField;
1528
        public static CT_BaseStyles Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1529
        {
1530
            if (node == null)
1531
                return null;
1532
            CT_BaseStyles ctObj = new CT_BaseStyles();
1533
            foreach (XmlNode childNode in node.ChildNodes)
1534
            {
1535
                if (childNode.LocalName == "clrScheme")
1536
                    ctObj.clrScheme = CT_ColorScheme.Parse(childNode, namespaceManager);
1537
                else if (childNode.LocalName == "fontScheme")
1538
                    ctObj.fontScheme = CT_FontScheme.Parse(childNode, namespaceManager);
1539
                else if (childNode.LocalName == "fmtScheme")
1540
                    ctObj.fmtScheme = CT_StyleMatrix.Parse(childNode, namespaceManager);
1541
                else if (childNode.LocalName == "extLst")
1542
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
1543
            }
1544
            return ctObj;
1545
        }
1546

1547

1548

1549
        internal void Write(StreamWriter sw, string nodeName)
1550
        {
1551
            sw.Write(string.Format("<a:{0}", nodeName));
1552
            sw.Write(">");
1553
            if (this.clrScheme != null)
1554
                this.clrScheme.Write(sw, "clrScheme");
1555
            if (this.fontScheme != null)
1556
                this.fontScheme.Write(sw, "fontScheme");
1557
            if (this.fmtScheme != null)
1558
                this.fmtScheme.Write(sw, "fmtScheme");
1559
            if (this.extLst != null)
1560
                this.extLst.Write(sw, "extLst");
1561
            sw.Write(string.Format("</a:{0}>", nodeName));
1562
        }
1563

1564
        public CT_BaseStyles()
1565
        {
1566
            //this.extLstField = new CT_OfficeArtExtensionList();
1567
            //this.fmtSchemeField = new CT_StyleMatrix();
1568
            //this.fontSchemeField = new CT_FontScheme();
1569
            //this.clrSchemeField = new CT_ColorScheme();
1570
        }
1571

1572
        [XmlElement(Order = 0)]
1573
        public CT_ColorScheme clrScheme
1574
        {
1575
            get
1576
            {
1577
                return this.clrSchemeField;
1578
            }
1579
            set
1580
            {
1581
                this.clrSchemeField = value;
1582
            }
1583
        }
1584

1585
        [XmlElement(Order = 1)]
1586
        public CT_FontScheme fontScheme
1587
        {
1588
            get
1589
            {
1590
                return this.fontSchemeField;
1591
            }
1592
            set
1593
            {
1594
                this.fontSchemeField = value;
1595
            }
1596
        }
1597

1598
        [XmlElement(Order = 2)]
1599
        public CT_StyleMatrix fmtScheme
1600
        {
1601
            get
1602
            {
1603
                return this.fmtSchemeField;
1604
            }
1605
            set
1606
            {
1607
                this.fmtSchemeField = value;
1608
            }
1609
        }
1610

1611
        [XmlElement(Order = 3)]
1612
        public CT_OfficeArtExtensionList extLst
1613
        {
1614
            get
1615
            {
1616
                return this.extLstField;
1617
            }
1618
            set
1619
            {
1620
                this.extLstField = value;
1621
            }
1622
        }
1623
    }
1624

1625

1626
    [Serializable]
1627
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1628
    public enum ST_FontCollectionIndex
1629
    {
1630

1631

1632
        major,
1633

1634

1635
        minor,
1636

1637

1638
        none,
1639
    }
1640
    [Serializable]
1641
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1642
    public enum ST_ColorSchemeIndex
1643
    {
1644

1645

1646
        dk1,
1647

1648

1649
        lt1,
1650

1651

1652
        dk2,
1653

1654

1655
        lt2,
1656

1657

1658
        accent1,
1659

1660

1661
        accent2,
1662

1663

1664
        accent3,
1665

1666

1667
        accent4,
1668

1669

1670
        accent5,
1671

1672

1673
        accent6,
1674

1675

1676
        hlink,
1677

1678

1679
        folHlink,
1680
    }
1681
}
1682