npoi

1
using System;
2
using System.ComponentModel;
3
using System.Xml.Serialization;
4
using System.Collections.Generic;
5
using System.Xml;
6
using System.IO;
7
using NPOI.OpenXml4Net.Util;
8

9
namespace NPOI.OpenXmlFormats.Dml
10
{
11

12
    [Serializable]
13
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
14
    [XmlRoot("blip", Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = false)]
15
    public class CT_Blip
16
    {
17

18
        private List<object> itemsField;
19

20
        private CT_OfficeArtExtensionList extLstField;
21

22
        private string embedField;
23

24
        private string linkField;
25

26
        private ST_BlipCompression cstateField;
27

28
        public CT_Blip()
29
        {
30
            //this.extLstField = new CT_OfficeArtExtensionList();
31
            //this.itemsField = new List<object>();
32
            this.embedField = "";
33
            this.linkField = "";
34
            this.cstateField = ST_BlipCompression.none;
35
        }
36
        public static CT_Blip Parse(XmlNode node, XmlNamespaceManager namespaceManager)
37
        {
38
            if (node == null)
39
                return null;
40
            CT_Blip ctObj = new CT_Blip();
41
            ctObj.embed = XmlHelper.ReadString(node.Attributes["r:embed"]);
42
            ctObj.link = XmlHelper.ReadString(node.Attributes["r:link"]);
43
            if (node.Attributes["cstate"] != null)
44
                ctObj.cstate = (ST_BlipCompression)Enum.Parse(typeof(ST_BlipCompression), node.Attributes["cstate"].Value);
45
            ctObj.Items = new List<Object>();
46
            foreach (XmlNode childNode in node.ChildNodes)
47
            {
48
                if (childNode.LocalName == "extLst")
49
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
50
                //TODO: implement http://www.schemacentral.com/sc/ooxml/t-a_CT_Blip.html
51
                //else if (childNode.LocalName == "Items")
52
                //    ctObj.Items.Add(Object.Parse(childNode, namespaceManager));
53
            }
54
            return ctObj;
55
        }
56

57

58
        internal void Write(StreamWriter sw, string nodeName)
59
        {
60
            sw.Write(string.Format("<a:{0} xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"", nodeName));
61
            XmlHelper.WriteAttribute(sw, "r:embed", this.embed);
62
            XmlHelper.WriteAttribute(sw, "r:link", this.link);
63
            if(cstate!= ST_BlipCompression.none)
64
                XmlHelper.WriteAttribute(sw, "cstate", this.cstate.ToString());
65
            sw.Write(">");
66
            if (this.extLst != null)
67
                this.extLst.Write(sw, "extLst");
68
            sw.Write(string.Format("</a:{0}>", nodeName));
69
        }
70

71
        [XmlElement("alphaBiLevel", typeof(CT_AlphaBiLevelEffect), Order = 0)]
72
        [XmlElement("alphaCeiling", typeof(CT_AlphaCeilingEffect), Order = 0)]
73
        [XmlElement("alphaFloor", typeof(CT_AlphaFloorEffect), Order = 0)]
74
        [XmlElement("alphaInv", typeof(CT_AlphaInverseEffect), Order = 0)]
75
        [XmlElement("alphaMod", typeof(CT_AlphaModulateEffect), Order = 0)]
76
        [XmlElement("alphaModFix", typeof(CT_AlphaModulateFixedEffect), Order = 0)]
77
        [XmlElement("alphaRepl", typeof(CT_AlphaReplaceEffect), Order = 0)]
78
        [XmlElement("biLevel", typeof(CT_BiLevelEffect), Order = 0)]
79
        [XmlElement("blur", typeof(CT_BlurEffect), Order = 0)]
80
        [XmlElement("clrChange", typeof(CT_ColorChangeEffect), Order = 0)]
81
        [XmlElement("clrRepl", typeof(CT_ColorReplaceEffect), Order = 0)]
82
        [XmlElement("duotone", typeof(CT_DuotoneEffect), Order = 0)]
83
        [XmlElement("fillOverlay", typeof(CT_FillOverlayEffect), Order = 0)]
84
        [XmlElement("grayscl", typeof(CT_GrayscaleEffect), Order = 0)]
85
        [XmlElement("hsl", typeof(CT_HSLEffect), Order = 0)]
86
        [XmlElement("lum", typeof(CT_LuminanceEffect), Order = 0)]
87
        [XmlElement("tint", typeof(CT_TintEffect), Order = 0)]
88
        public List<object> Items
89
        {
90
            get
91
            {
92
                return this.itemsField;
93
            }
94
            set
95
            {
96
                this.itemsField = value;
97
            }
98
        }
99

100
        [XmlElement(Order = 1)]
101
        public CT_OfficeArtExtensionList extLst
102
        {
103
            get
104
            {
105
                return this.extLstField;
106
            }
107
            set
108
            {
109
                this.extLstField = value;
110
            }
111
        }
112

113
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships")]
114
        [DefaultValue("")]
115
        public string embed
116
        {
117
            get
118
            {
119
                return this.embedField;
120
            }
121
            set
122
            {
123
                this.embedField = value;
124
            }
125
        }
126

127
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships")]
128
        [DefaultValue("")]
129
        public string link
130
        {
131
            get
132
            {
133
                return this.linkField;
134
            }
135
            set
136
            {
137
                this.linkField = value;
138
            }
139
        }
140

141
        [XmlAttribute]
142
        [DefaultValue(ST_BlipCompression.none)]
143
        public ST_BlipCompression cstate
144
        {
145
            get
146
            {
147
                return this.cstateField;
148
            }
149
            set
150
            {
151
                this.cstateField = value;
152
            }
153
        }
154
    }
155

156

157
    [Serializable]
158
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
159
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
160
    public class CT_AlphaBiLevelEffect
161
    {
162

163
        private int threshField;
164

165
        [XmlAttribute]
166
        public int thresh
167
        {
168
            get
169
            {
170
                return this.threshField;
171
            }
172
            set
173
            {
174
                this.threshField = value;
175
            }
176
        }
177
    }
178

179

180
    [Serializable]
181
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
182
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
183
    public class CT_TransformEffect
184
    {
185

186
        private int sxField;
187

188
        private int syField;
189

190
        private int kxField;
191

192
        private int kyField;
193

194
        private long txField;
195

196
        private long tyField;
197

198
        public CT_TransformEffect()
199
        {
200
            this.sxField = 100000;
201
            this.syField = 100000;
202
            this.kxField = 0;
203
            this.kyField = 0;
204
            this.txField = ((long)(0));
205
            this.tyField = ((long)(0));
206
        }
207

208
        [XmlAttribute]
209
        [DefaultValue(100000)]
210
        public int sx
211
        {
212
            get
213
            {
214
                return this.sxField;
215
            }
216
            set
217
            {
218
                this.sxField = value;
219
            }
220
        }
221

222
        [XmlAttribute]
223
        [DefaultValue(100000)]
224
        public int sy
225
        {
226
            get
227
            {
228
                return this.syField;
229
            }
230
            set
231
            {
232
                this.syField = value;
233
            }
234
        }
235

236
        [XmlAttribute]
237
        [DefaultValue(0)]
238
        public int kx
239
        {
240
            get
241
            {
242
                return this.kxField;
243
            }
244
            set
245
            {
246
                this.kxField = value;
247
            }
248
        }
249

250
        [XmlAttribute]
251
        [DefaultValue(0)]
252
        public int ky
253
        {
254
            get
255
            {
256
                return this.kyField;
257
            }
258
            set
259
            {
260
                this.kyField = value;
261
            }
262
        }
263

264
        [XmlAttribute]
265
        [DefaultValue(typeof(long), "0")]
266
        public long tx
267
        {
268
            get
269
            {
270
                return this.txField;
271
            }
272
            set
273
            {
274
                this.txField = value;
275
            }
276
        }
277

278
        [XmlAttribute]
279
        [DefaultValue(typeof(long), "0")]
280
        public long ty
281
        {
282
            get
283
            {
284
                return this.tyField;
285
            }
286
            set
287
            {
288
                this.tyField = value;
289
            }
290
        }
291
    }
292

293

294
    [Serializable]
295
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
296
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
297
    public class CT_TintEffect
298
    {
299

300
        private int hueField;
301

302
        private int amtField;
303

304
        public CT_TintEffect()
305
        {
306
            this.hueField = 0;
307
            this.amtField = 0;
308
        }
309

310
        [XmlAttribute]
311
        [DefaultValue(0)]
312
        public int hue
313
        {
314
            get
315
            {
316
                return this.hueField;
317
            }
318
            set
319
            {
320
                this.hueField = value;
321
            }
322
        }
323

324
        [XmlAttribute]
325
        [DefaultValue(0)]
326
        public int amt
327
        {
328
            get
329
            {
330
                return this.amtField;
331
            }
332
            set
333
            {
334
                this.amtField = value;
335
            }
336
        }
337
    }
338

339
    [Serializable]
340
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
341
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
342
    public class CT_SoftEdgesEffect
343
    {
344
        public static CT_SoftEdgesEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
345
        {
346
            if (node == null)
347
                return null;
348
            CT_SoftEdgesEffect ctObj = new CT_SoftEdgesEffect();
349
            ctObj.rad = XmlHelper.ReadLong(node.Attributes["rad"]);
350
            return ctObj;
351
        }
352

353

354

355
        internal void Write(StreamWriter sw, string nodeName)
356
        {
357
            sw.Write(string.Format("<a:{0}", nodeName));
358
            XmlHelper.WriteAttribute(sw, "rad", this.rad);
359
            sw.Write(">");
360
            sw.Write(string.Format("</a:{0}>", nodeName));
361
        }
362

363
        private long radField;
364

365
        [XmlAttribute]
366
        public long rad
367
        {
368
            get
369
            {
370
                return this.radField;
371
            }
372
            set
373
            {
374
                this.radField = value;
375
            }
376
        }
377
    }
378

379
    [Serializable]
380
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
381
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
382
    public class CT_RelativeOffsetEffect
383
    {
384

385
        private int txField;
386

387
        private int tyField;
388

389
        public CT_RelativeOffsetEffect()
390
        {
391
            this.txField = 0;
392
            this.tyField = 0;
393
        }
394

395
        [XmlAttribute]
396
        [DefaultValue(0)]
397
        public int tx
398
        {
399
            get
400
            {
401
                return this.txField;
402
            }
403
            set
404
            {
405
                this.txField = value;
406
            }
407
        }
408

409
        [XmlAttribute]
410
        [DefaultValue(0)]
411
        public int ty
412
        {
413
            get
414
            {
415
                return this.tyField;
416
            }
417
            set
418
            {
419
                this.tyField = value;
420
            }
421
        }
422
    }
423

424
    [Serializable]
425
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
426
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
427
    public class CT_ReflectionEffect
428
    {
429

430
        private long blurRadField;
431

432
        private int stAField;
433

434
        private int stPosField;
435

436
        private int endAField;
437

438
        private int endPosField;
439

440
        private long distField;
441

442
        private int dirField;
443

444
        private int fadeDirField;
445

446
        private int sxField;
447

448
        private int syField;
449

450
        private int kxField;
451

452
        private int kyField;
453

454
        private ST_RectAlignment algnField;
455

456
        private bool rotWithShapeField;
457
        public static CT_ReflectionEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
458
        {
459
            if (node == null)
460
                return null;
461
            CT_ReflectionEffect ctObj = new CT_ReflectionEffect();
462
            ctObj.blurRad = XmlHelper.ReadLong(node.Attributes["blurRad"]);
463
            ctObj.stA = XmlHelper.ReadInt(node.Attributes["stA"]);
464
            ctObj.stPos = XmlHelper.ReadInt(node.Attributes["stPos"]);
465
            ctObj.endA = XmlHelper.ReadInt(node.Attributes["endA"]);
466
            ctObj.endPos = XmlHelper.ReadInt(node.Attributes["endPos"]);
467
            ctObj.dist = XmlHelper.ReadLong(node.Attributes["dist"]);
468
            ctObj.dir = XmlHelper.ReadInt(node.Attributes["dir"]);
469
            ctObj.fadeDir = XmlHelper.ReadInt(node.Attributes["fadeDir"]);
470
            ctObj.sx = XmlHelper.ReadInt(node.Attributes["sx"]);
471
            ctObj.sy = XmlHelper.ReadInt(node.Attributes["sy"]);
472
            ctObj.kx = XmlHelper.ReadInt(node.Attributes["kx"]);
473
            ctObj.ky = XmlHelper.ReadInt(node.Attributes["ky"]);
474
            if (node.Attributes["algn"] != null)
475
                ctObj.algn = (ST_RectAlignment)Enum.Parse(typeof(ST_RectAlignment), node.Attributes["algn"].Value);
476
            ctObj.rotWithShape = XmlHelper.ReadBool(node.Attributes["rotWithShape"]);
477
            return ctObj;
478
        }
479

480

481

482
        internal void Write(StreamWriter sw, string nodeName)
483
        {
484
            sw.Write(string.Format("<a:{0}", nodeName));
485
            XmlHelper.WriteAttribute(sw, "blurRad", this.blurRad);
486
            XmlHelper.WriteAttribute(sw, "stA", this.stA);
487
            XmlHelper.WriteAttribute(sw, "stPos", this.stPos);
488
            XmlHelper.WriteAttribute(sw, "endA", this.endA);
489
            XmlHelper.WriteAttribute(sw, "endPos", this.endPos);
490
            XmlHelper.WriteAttribute(sw, "dist", this.dist);
491
            XmlHelper.WriteAttribute(sw, "dir", this.dir);
492
            XmlHelper.WriteAttribute(sw, "fadeDir", this.fadeDir);
493
            XmlHelper.WriteAttribute(sw, "sx", this.sx);
494
            XmlHelper.WriteAttribute(sw, "sy", this.sy);
495
            XmlHelper.WriteAttribute(sw, "kx", this.kx);
496
            XmlHelper.WriteAttribute(sw, "ky", this.ky);
497
            XmlHelper.WriteAttribute(sw, "algn", this.algn.ToString());
498
            XmlHelper.WriteAttribute(sw, "rotWithShape", this.rotWithShape);
499
            sw.Write(">");
500
            sw.Write(string.Format("</a:{0}>", nodeName));
501
        }
502

503
        public CT_ReflectionEffect()
504
        {
505
            this.blurRadField = ((long)(0));
506
            this.stAField = 100000;
507
            this.stPosField = 0;
508
            this.endAField = 0;
509
            this.endPosField = 100000;
510
            this.distField = ((long)(0));
511
            this.dirField = 0;
512
            this.fadeDirField = 5400000;
513
            this.sxField = 100000;
514
            this.syField = 100000;
515
            this.kxField = 0;
516
            this.kyField = 0;
517
            this.algnField = ST_RectAlignment.b;
518
            this.rotWithShapeField = true;
519
        }
520

521
        [XmlAttribute]
522
        [DefaultValue(typeof(long), "0")]
523
        public long blurRad
524
        {
525
            get
526
            {
527
                return this.blurRadField;
528
            }
529
            set
530
            {
531
                this.blurRadField = value;
532
            }
533
        }
534

535
        [XmlAttribute]
536
        [DefaultValue(100000)]
537
        public int stA
538
        {
539
            get
540
            {
541
                return this.stAField;
542
            }
543
            set
544
            {
545
                this.stAField = value;
546
            }
547
        }
548

549
        [XmlAttribute]
550
        [DefaultValue(0)]
551
        public int stPos
552
        {
553
            get
554
            {
555
                return this.stPosField;
556
            }
557
            set
558
            {
559
                this.stPosField = value;
560
            }
561
        }
562

563
        [XmlAttribute]
564
        [DefaultValue(0)]
565
        public int endA
566
        {
567
            get
568
            {
569
                return this.endAField;
570
            }
571
            set
572
            {
573
                this.endAField = value;
574
            }
575
        }
576

577
        [XmlAttribute]
578
        [DefaultValue(100000)]
579
        public int endPos
580
        {
581
            get
582
            {
583
                return this.endPosField;
584
            }
585
            set
586
            {
587
                this.endPosField = value;
588
            }
589
        }
590

591
        [XmlAttribute]
592
        [DefaultValue(typeof(long), "0")]
593
        public long dist
594
        {
595
            get
596
            {
597
                return this.distField;
598
            }
599
            set
600
            {
601
                this.distField = value;
602
            }
603
        }
604

605
        [XmlAttribute]
606
        [DefaultValue(0)]
607
        public int dir
608
        {
609
            get
610
            {
611
                return this.dirField;
612
            }
613
            set
614
            {
615
                this.dirField = value;
616
            }
617
        }
618

619
        [XmlAttribute]
620
        [DefaultValue(5400000)]
621
        public int fadeDir
622
        {
623
            get
624
            {
625
                return this.fadeDirField;
626
            }
627
            set
628
            {
629
                this.fadeDirField = value;
630
            }
631
        }
632

633
        [XmlAttribute]
634
        [DefaultValue(100000)]
635
        public int sx
636
        {
637
            get
638
            {
639
                return this.sxField;
640
            }
641
            set
642
            {
643
                this.sxField = value;
644
            }
645
        }
646

647
        [XmlAttribute]
648
        [DefaultValue(100000)]
649
        public int sy
650
        {
651
            get
652
            {
653
                return this.syField;
654
            }
655
            set
656
            {
657
                this.syField = value;
658
            }
659
        }
660

661
        [XmlAttribute]
662
        [DefaultValue(0)]
663
        public int kx
664
        {
665
            get
666
            {
667
                return this.kxField;
668
            }
669
            set
670
            {
671
                this.kxField = value;
672
            }
673
        }
674

675
        [XmlAttribute]
676
        [DefaultValue(0)]
677
        public int ky
678
        {
679
            get
680
            {
681
                return this.kyField;
682
            }
683
            set
684
            {
685
                this.kyField = value;
686
            }
687
        }
688

689
        [XmlAttribute]
690
        [DefaultValue(ST_RectAlignment.b)]
691
        public ST_RectAlignment algn
692
        {
693
            get
694
            {
695
                return this.algnField;
696
            }
697
            set
698
            {
699
                this.algnField = value;
700
            }
701
        }
702

703
        [XmlAttribute]
704
        [DefaultValue(true)]
705
        public bool rotWithShape
706
        {
707
            get
708
            {
709
                return this.rotWithShapeField;
710
            }
711
            set
712
            {
713
                this.rotWithShapeField = value;
714
            }
715
        }
716
    }
717

718
    [Serializable]
719
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
720
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
721
    public class CT_PresetShadowEffect
722
    {
723

724
        private CT_ScRgbColor scrgbClrField;
725

726
        private CT_SRgbColor srgbClrField;
727

728
        private CT_HslColor hslClrField;
729

730
        private CT_SystemColor sysClrField;
731

732
        private CT_SchemeColor schemeClrField;
733

734
        private CT_PresetColor prstClrField;
735

736
        private ST_PresetShadowVal prstField;
737

738
        private long distField;
739

740
        private int dirField;
741
        public static CT_PresetShadowEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
742
        {
743
            if (node == null)
744
                return null;
745
            CT_PresetShadowEffect ctObj = new CT_PresetShadowEffect();
746
            if (node.Attributes["prst"] != null)
747
                ctObj.prst = (ST_PresetShadowVal)Enum.Parse(typeof(ST_PresetShadowVal), node.Attributes["prst"].Value);
748
            ctObj.dist = XmlHelper.ReadLong(node.Attributes["dist"]);
749
            ctObj.dir = XmlHelper.ReadInt(node.Attributes["dir"]);
750
            foreach (XmlNode childNode in node.ChildNodes)
751
            {
752
                if (childNode.LocalName == "scrgbClr")
753
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
754
                else if (childNode.LocalName == "srgbClr")
755
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
756
                else if (childNode.LocalName == "hslClr")
757
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
758
                else if (childNode.LocalName == "sysClr")
759
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
760
                else if (childNode.LocalName == "schemeClr")
761
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
762
                else if (childNode.LocalName == "prstClr")
763
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
764
            }
765
            return ctObj;
766
        }
767

768

769

770
        internal void Write(StreamWriter sw, string nodeName)
771
        {
772
            sw.Write(string.Format("<a:{0}", nodeName));
773
            XmlHelper.WriteAttribute(sw, "prst", this.prst.ToString());
774
            XmlHelper.WriteAttribute(sw, "dist", this.dist);
775
            XmlHelper.WriteAttribute(sw, "dir", this.dir);
776
            sw.Write(">");
777
            if (this.scrgbClr != null)
778
                this.scrgbClr.Write(sw, "scrgbClr");
779
            if (this.srgbClr != null)
780
                this.srgbClr.Write(sw, "srgbClr");
781
            if (this.hslClr != null)
782
                this.hslClr.Write(sw, "hslClr");
783
            if (this.sysClr != null)
784
                this.sysClr.Write(sw, "sysClr");
785
            if (this.schemeClr != null)
786
                this.schemeClr.Write(sw, "schemeClr");
787
            if (this.prstClr != null)
788
                this.prstClr.Write(sw, "prstClr");
789
            sw.Write(string.Format("</a:{0}>", nodeName));
790
        }
791

792
        public CT_PresetShadowEffect()
793
        {
794
            //this.prstClrField = new CT_PresetColor();
795
            //this.schemeClrField = new CT_SchemeColor();
796
            //this.sysClrField = new CT_SystemColor();
797
            //this.hslClrField = new CT_HslColor();
798
            //this.srgbClrField = new CT_SRgbColor();
799
            //this.scrgbClrField = new CT_ScRgbColor();
800
            //this.distField = ((long)(0));
801
            //this.dirField = 0;
802
        }
803

804
        [XmlElement(Order = 0)]
805
        public CT_ScRgbColor scrgbClr
806
        {
807
            get
808
            {
809
                return this.scrgbClrField;
810
            }
811
            set
812
            {
813
                this.scrgbClrField = value;
814
            }
815
        }
816

817
        [XmlElement(Order = 1)]
818
        public CT_SRgbColor srgbClr
819
        {
820
            get
821
            {
822
                return this.srgbClrField;
823
            }
824
            set
825
            {
826
                this.srgbClrField = value;
827
            }
828
        }
829

830
        [XmlElement(Order = 2)]
831
        public CT_HslColor hslClr
832
        {
833
            get
834
            {
835
                return this.hslClrField;
836
            }
837
            set
838
            {
839
                this.hslClrField = value;
840
            }
841
        }
842

843
        [XmlElement(Order = 3)]
844
        public CT_SystemColor sysClr
845
        {
846
            get
847
            {
848
                return this.sysClrField;
849
            }
850
            set
851
            {
852
                this.sysClrField = value;
853
            }
854
        }
855

856
        [XmlElement(Order = 4)]
857
        public CT_SchemeColor schemeClr
858
        {
859
            get
860
            {
861
                return this.schemeClrField;
862
            }
863
            set
864
            {
865
                this.schemeClrField = value;
866
            }
867
        }
868

869
        [XmlElement(Order = 5)]
870
        public CT_PresetColor prstClr
871
        {
872
            get
873
            {
874
                return this.prstClrField;
875
            }
876
            set
877
            {
878
                this.prstClrField = value;
879
            }
880
        }
881

882
        [XmlAttribute]
883
        public ST_PresetShadowVal prst
884
        {
885
            get
886
            {
887
                return this.prstField;
888
            }
889
            set
890
            {
891
                this.prstField = value;
892
            }
893
        }
894

895
        [XmlAttribute]
896
        [DefaultValue(typeof(long), "0")]
897
        public long dist
898
        {
899
            get
900
            {
901
                return this.distField;
902
            }
903
            set
904
            {
905
                this.distField = value;
906
            }
907
        }
908

909
        [XmlAttribute]
910
        [DefaultValue(0)]
911
        public int dir
912
        {
913
            get
914
            {
915
                return this.dirField;
916
            }
917
            set
918
            {
919
                this.dirField = value;
920
            }
921
        }
922
    }
923

924
    [Serializable]
925
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
926
    public enum ST_PresetShadowVal
927
    {
928

929
        /// <remarks/>
930
        shdw1,
931

932
        /// <remarks/>
933
        shdw2,
934

935
        /// <remarks/>
936
        shdw3,
937

938
        /// <remarks/>
939
        shdw4,
940

941
        /// <remarks/>
942
        shdw5,
943

944
        /// <remarks/>
945
        shdw6,
946

947
        /// <remarks/>
948
        shdw7,
949

950
        /// <remarks/>
951
        shdw8,
952

953
        /// <remarks/>
954
        shdw9,
955

956
        /// <remarks/>
957
        shdw10,
958

959
        /// <remarks/>
960
        shdw11,
961

962
        /// <remarks/>
963
        shdw12,
964

965
        /// <remarks/>
966
        shdw13,
967

968
        /// <remarks/>
969
        shdw14,
970

971
        /// <remarks/>
972
        shdw15,
973

974
        /// <remarks/>
975
        shdw16,
976

977
        /// <remarks/>
978
        shdw17,
979

980
        /// <remarks/>
981
        shdw18,
982

983
        /// <remarks/>
984
        shdw19,
985

986
        /// <remarks/>
987
        shdw20,
988
    }
989

990
    [Serializable]
991
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
992
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
993
    public class CT_OuterShadowEffect
994
    {
995

996
        private CT_ScRgbColor scrgbClrField;
997

998
        private CT_SRgbColor srgbClrField;
999

1000
        private CT_HslColor hslClrField;
1001

1002
        private CT_SystemColor sysClrField;
1003

1004
        private CT_SchemeColor schemeClrField;
1005

1006
        private CT_PresetColor prstClrField;
1007

1008
        private long blurRadField;
1009

1010
        private long distField;
1011

1012
        private int dirField;
1013

1014
        private int sxField;
1015

1016
        private int syField;
1017

1018
        private int kxField;
1019

1020
        private int kyField;
1021

1022
        private ST_RectAlignment algnField;
1023

1024
        private bool rotWithShapeField;
1025
        public static CT_OuterShadowEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1026
        {
1027
            if (node == null)
1028
                return null;
1029
            CT_OuterShadowEffect ctObj = new CT_OuterShadowEffect();
1030
            ctObj.blurRad = XmlHelper.ReadLong(node.Attributes["blurRad"]);
1031
            ctObj.dist = XmlHelper.ReadLong(node.Attributes["dist"]);
1032
            ctObj.dir = XmlHelper.ReadInt(node.Attributes["dir"]);
1033
            ctObj.sx = XmlHelper.ReadInt(node.Attributes["sx"]);
1034
            ctObj.sy = XmlHelper.ReadInt(node.Attributes["sy"]);
1035
            ctObj.kx = XmlHelper.ReadInt(node.Attributes["kx"]);
1036
            ctObj.ky = XmlHelper.ReadInt(node.Attributes["ky"]);
1037
            if (node.Attributes["algn"] != null)
1038
                ctObj.algn = (ST_RectAlignment)Enum.Parse(typeof(ST_RectAlignment), node.Attributes["algn"].Value);
1039
            ctObj.rotWithShape = XmlHelper.ReadBool(node.Attributes["rotWithShape"]);
1040
            foreach (XmlNode childNode in node.ChildNodes)
1041
            {
1042
                if (childNode.LocalName == "scrgbClr")
1043
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
1044
                else if (childNode.LocalName == "srgbClr")
1045
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
1046
                else if (childNode.LocalName == "hslClr")
1047
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
1048
                else if (childNode.LocalName == "sysClr")
1049
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
1050
                else if (childNode.LocalName == "schemeClr")
1051
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
1052
                else if (childNode.LocalName == "prstClr")
1053
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
1054
            }
1055
            return ctObj;
1056
        }
1057

1058

1059

1060
        internal void Write(StreamWriter sw, string nodeName)
1061
        {
1062
            sw.Write(string.Format("<a:{0}", nodeName));
1063
            XmlHelper.WriteAttribute(sw, "blurRad", this.blurRad);
1064
            XmlHelper.WriteAttribute(sw, "dist", this.dist);
1065
            XmlHelper.WriteAttribute(sw, "dir", this.dir);
1066
            XmlHelper.WriteAttribute(sw, "sx", this.sx);
1067
            XmlHelper.WriteAttribute(sw, "sy", this.sy);
1068
            XmlHelper.WriteAttribute(sw, "kx", this.kx);
1069
            XmlHelper.WriteAttribute(sw, "ky", this.ky);
1070
            if(this.algn != ST_RectAlignment.tl)
1071
                XmlHelper.WriteAttribute(sw, "algn", this.algn.ToString());
1072
            XmlHelper.WriteAttribute(sw, "rotWithShape", this.rotWithShape);
1073
            sw.Write(">");
1074
            if (this.scrgbClr != null)
1075
                this.scrgbClr.Write(sw, "scrgbClr");
1076
            if (this.srgbClr != null)
1077
                this.srgbClr.Write(sw, "srgbClr");
1078
            if (this.hslClr != null)
1079
                this.hslClr.Write(sw, "hslClr");
1080
            if (this.sysClr != null)
1081
                this.sysClr.Write(sw, "sysClr");
1082
            if (this.schemeClr != null)
1083
                this.schemeClr.Write(sw, "schemeClr");
1084
            if (this.prstClr != null)
1085
                this.prstClr.Write(sw, "prstClr");
1086
            sw.Write(string.Format("</a:{0}>", nodeName));
1087
        }
1088

1089
        public CT_OuterShadowEffect()
1090
        {
1091
            //this.prstClrField = new CT_PresetColor();
1092
            //this.schemeClrField = new CT_SchemeColor();
1093
            //this.sysClrField = new CT_SystemColor();
1094
            //this.hslClrField = new CT_HslColor();
1095
            //this.srgbClrField = new CT_SRgbColor();
1096
            //this.scrgbClrField = new CT_ScRgbColor();
1097
            //this.blurRadField = ((long)(0));
1098
            //this.distField = ((long)(0));
1099
            //this.dirField = 0;
1100
            //this.sxField = 100000;
1101
            //this.syField = 100000;
1102
            //this.kxField = 0;
1103
            //this.kyField = 0;
1104
            //this.algnField = ST_RectAlignment.b;
1105
            //this.rotWithShapeField = true;
1106
        }
1107

1108
        [XmlElement(Order = 0)]
1109
        public CT_ScRgbColor scrgbClr
1110
        {
1111
            get
1112
            {
1113
                return this.scrgbClrField;
1114
            }
1115
            set
1116
            {
1117
                this.scrgbClrField = value;
1118
            }
1119
        }
1120

1121
        [XmlElement(Order = 1)]
1122
        public CT_SRgbColor srgbClr
1123
        {
1124
            get
1125
            {
1126
                return this.srgbClrField;
1127
            }
1128
            set
1129
            {
1130
                this.srgbClrField = value;
1131
            }
1132
        }
1133

1134
        [XmlElement(Order = 2)]
1135
        public CT_HslColor hslClr
1136
        {
1137
            get
1138
            {
1139
                return this.hslClrField;
1140
            }
1141
            set
1142
            {
1143
                this.hslClrField = value;
1144
            }
1145
        }
1146

1147
        [XmlElement(Order = 3)]
1148
        public CT_SystemColor sysClr
1149
        {
1150
            get
1151
            {
1152
                return this.sysClrField;
1153
            }
1154
            set
1155
            {
1156
                this.sysClrField = value;
1157
            }
1158
        }
1159

1160
        [XmlElement(Order = 4)]
1161
        public CT_SchemeColor schemeClr
1162
        {
1163
            get
1164
            {
1165
                return this.schemeClrField;
1166
            }
1167
            set
1168
            {
1169
                this.schemeClrField = value;
1170
            }
1171
        }
1172

1173
        [XmlElement(Order = 5)]
1174
        public CT_PresetColor prstClr
1175
        {
1176
            get
1177
            {
1178
                return this.prstClrField;
1179
            }
1180
            set
1181
            {
1182
                this.prstClrField = value;
1183
            }
1184
        }
1185

1186
        [XmlAttribute]
1187
        [DefaultValue(typeof(long), "0")]
1188
        public long blurRad
1189
        {
1190
            get
1191
            {
1192
                return this.blurRadField;
1193
            }
1194
            set
1195
            {
1196
                this.blurRadField = value;
1197
            }
1198
        }
1199

1200
        [XmlAttribute]
1201
        [DefaultValue(typeof(long), "0")]
1202
        public long dist
1203
        {
1204
            get
1205
            {
1206
                return this.distField;
1207
            }
1208
            set
1209
            {
1210
                this.distField = value;
1211
            }
1212
        }
1213

1214
        [XmlAttribute]
1215
        [DefaultValue(0)]
1216
        public int dir
1217
        {
1218
            get
1219
            {
1220
                return this.dirField;
1221
            }
1222
            set
1223
            {
1224
                this.dirField = value;
1225
            }
1226
        }
1227

1228
        [XmlAttribute]
1229
        [DefaultValue(100000)]
1230
        public int sx
1231
        {
1232
            get
1233
            {
1234
                return this.sxField;
1235
            }
1236
            set
1237
            {
1238
                this.sxField = value;
1239
            }
1240
        }
1241

1242
        [XmlAttribute]
1243
        [DefaultValue(100000)]
1244
        public int sy
1245
        {
1246
            get
1247
            {
1248
                return this.syField;
1249
            }
1250
            set
1251
            {
1252
                this.syField = value;
1253
            }
1254
        }
1255

1256
        [XmlAttribute]
1257
        [DefaultValue(0)]
1258
        public int kx
1259
        {
1260
            get
1261
            {
1262
                return this.kxField;
1263
            }
1264
            set
1265
            {
1266
                this.kxField = value;
1267
            }
1268
        }
1269

1270
        [XmlAttribute]
1271
        [DefaultValue(0)]
1272
        public int ky
1273
        {
1274
            get
1275
            {
1276
                return this.kyField;
1277
            }
1278
            set
1279
            {
1280
                this.kyField = value;
1281
            }
1282
        }
1283

1284
        [XmlAttribute]
1285
        [DefaultValue(ST_RectAlignment.b)]
1286
        public ST_RectAlignment algn
1287
        {
1288
            get
1289
            {
1290
                return this.algnField;
1291
            }
1292
            set
1293
            {
1294
                this.algnField = value;
1295
            }
1296
        }
1297

1298
        [XmlAttribute]
1299
        [DefaultValue(true)]
1300
        public bool rotWithShape
1301
        {
1302
            get
1303
            {
1304
                return this.rotWithShapeField;
1305
            }
1306
            set
1307
            {
1308
                this.rotWithShapeField = value;
1309
            }
1310
        }
1311
    }
1312

1313
    [Serializable]
1314
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1315
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1316
    public class CT_LuminanceEffect
1317
    {
1318

1319
        private int brightField;
1320

1321
        private int contrastField;
1322

1323
        public CT_LuminanceEffect()
1324
        {
1325
            this.brightField = 0;
1326
            this.contrastField = 0;
1327
        }
1328

1329
        [XmlAttribute]
1330
        [DefaultValue(0)]
1331
        public int bright
1332
        {
1333
            get
1334
            {
1335
                return this.brightField;
1336
            }
1337
            set
1338
            {
1339
                this.brightField = value;
1340
            }
1341
        }
1342

1343
        [XmlAttribute]
1344
        [DefaultValue(0)]
1345
        public int contrast
1346
        {
1347
            get
1348
            {
1349
                return this.contrastField;
1350
            }
1351
            set
1352
            {
1353
                this.contrastField = value;
1354
            }
1355
        }
1356
    }
1357

1358
    [Serializable]
1359
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1360
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1361
    public class CT_InnerShadowEffect
1362
    {
1363

1364
        private CT_ScRgbColor scrgbClrField;
1365

1366
        private CT_SRgbColor srgbClrField;
1367

1368
        private CT_HslColor hslClrField;
1369

1370
        private CT_SystemColor sysClrField;
1371

1372
        private CT_SchemeColor schemeClrField;
1373

1374
        private CT_PresetColor prstClrField;
1375

1376
        private long blurRadField;
1377

1378
        private long distField;
1379

1380
        private int dirField;
1381
        public static CT_InnerShadowEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1382
        {
1383
            if (node == null)
1384
                return null;
1385
            CT_InnerShadowEffect ctObj = new CT_InnerShadowEffect();
1386
            ctObj.blurRad = XmlHelper.ReadLong(node.Attributes["blurRad"]);
1387
            ctObj.dist = XmlHelper.ReadLong(node.Attributes["dist"]);
1388
            ctObj.dir = XmlHelper.ReadInt(node.Attributes["dir"]);
1389
            foreach (XmlNode childNode in node.ChildNodes)
1390
            {
1391
                if (childNode.LocalName == "scrgbClr")
1392
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
1393
                else if (childNode.LocalName == "srgbClr")
1394
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
1395
                else if (childNode.LocalName == "hslClr")
1396
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
1397
                else if (childNode.LocalName == "sysClr")
1398
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
1399
                else if (childNode.LocalName == "schemeClr")
1400
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
1401
                else if (childNode.LocalName == "prstClr")
1402
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
1403
            }
1404
            return ctObj;
1405
        }
1406

1407

1408

1409
        internal void Write(StreamWriter sw, string nodeName)
1410
        {
1411
            sw.Write(string.Format("<a:{0}", nodeName));
1412
            XmlHelper.WriteAttribute(sw, "blurRad", this.blurRad);
1413
            XmlHelper.WriteAttribute(sw, "dist", this.dist);
1414
            XmlHelper.WriteAttribute(sw, "dir", this.dir);
1415
            sw.Write(">");
1416
            if (this.scrgbClr != null)
1417
                this.scrgbClr.Write(sw, "scrgbClr");
1418
            if (this.srgbClr != null)
1419
                this.srgbClr.Write(sw, "srgbClr");
1420
            if (this.hslClr != null)
1421
                this.hslClr.Write(sw, "hslClr");
1422
            if (this.sysClr != null)
1423
                this.sysClr.Write(sw, "sysClr");
1424
            if (this.schemeClr != null)
1425
                this.schemeClr.Write(sw, "schemeClr");
1426
            if (this.prstClr != null)
1427
                this.prstClr.Write(sw, "prstClr");
1428
            sw.Write(string.Format("</a:{0}>", nodeName));
1429
        }
1430

1431
        public CT_InnerShadowEffect()
1432
        {
1433
            //this.prstClrField = new CT_PresetColor();
1434
            //this.schemeClrField = new CT_SchemeColor();
1435
            //this.sysClrField = new CT_SystemColor();
1436
            //this.hslClrField = new CT_HslColor();
1437
            //this.srgbClrField = new CT_SRgbColor();
1438
            //this.scrgbClrField = new CT_ScRgbColor();
1439
            //this.blurRadField = ((long)(0));
1440
            //this.distField = ((long)(0));
1441
            //this.dirField = 0;
1442
        }
1443

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

1457
        [XmlElement(Order = 1)]
1458
        public CT_SRgbColor srgbClr
1459
        {
1460
            get
1461
            {
1462
                return this.srgbClrField;
1463
            }
1464
            set
1465
            {
1466
                this.srgbClrField = value;
1467
            }
1468
        }
1469

1470
        [XmlElement(Order = 2)]
1471
        public CT_HslColor hslClr
1472
        {
1473
            get
1474
            {
1475
                return this.hslClrField;
1476
            }
1477
            set
1478
            {
1479
                this.hslClrField = value;
1480
            }
1481
        }
1482

1483
        [XmlElement(Order = 3)]
1484
        public CT_SystemColor sysClr
1485
        {
1486
            get
1487
            {
1488
                return this.sysClrField;
1489
            }
1490
            set
1491
            {
1492
                this.sysClrField = value;
1493
            }
1494
        }
1495

1496
        [XmlElement(Order = 4)]
1497
        public CT_SchemeColor schemeClr
1498
        {
1499
            get
1500
            {
1501
                return this.schemeClrField;
1502
            }
1503
            set
1504
            {
1505
                this.schemeClrField = value;
1506
            }
1507
        }
1508

1509
        [XmlElement(Order = 5)]
1510
        public CT_PresetColor prstClr
1511
        {
1512
            get
1513
            {
1514
                return this.prstClrField;
1515
            }
1516
            set
1517
            {
1518
                this.prstClrField = value;
1519
            }
1520
        }
1521

1522
        [XmlAttribute]
1523
        [DefaultValue(typeof(long), "0")]
1524
        public long blurRad
1525
        {
1526
            get
1527
            {
1528
                return this.blurRadField;
1529
            }
1530
            set
1531
            {
1532
                this.blurRadField = value;
1533
            }
1534
        }
1535

1536
        [XmlAttribute]
1537
        [DefaultValue(typeof(long), "0")]
1538
        public long dist
1539
        {
1540
            get
1541
            {
1542
                return this.distField;
1543
            }
1544
            set
1545
            {
1546
                this.distField = value;
1547
            }
1548
        }
1549

1550
        [XmlAttribute]
1551
        [DefaultValue(0)]
1552
        public int dir
1553
        {
1554
            get
1555
            {
1556
                return this.dirField;
1557
            }
1558
            set
1559
            {
1560
                this.dirField = value;
1561
            }
1562
        }
1563
    }
1564

1565
    [Serializable]
1566
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1567
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1568
    public class CT_HSLEffect
1569
    {
1570

1571
        private int hueField;
1572

1573
        private int satField;
1574

1575
        private int lumField;
1576

1577
        public CT_HSLEffect()
1578
        {
1579
            this.hueField = 0;
1580
            this.satField = 0;
1581
            this.lumField = 0;
1582
        }
1583

1584
        [XmlAttribute]
1585
        [DefaultValue(0)]
1586
        public int hue
1587
        {
1588
            get
1589
            {
1590
                return this.hueField;
1591
            }
1592
            set
1593
            {
1594
                this.hueField = value;
1595
            }
1596
        }
1597

1598
        [XmlAttribute]
1599
        [DefaultValue(0)]
1600
        public int sat
1601
        {
1602
            get
1603
            {
1604
                return this.satField;
1605
            }
1606
            set
1607
            {
1608
                this.satField = value;
1609
            }
1610
        }
1611

1612
        [XmlAttribute]
1613
        [DefaultValue(0)]
1614
        public int lum
1615
        {
1616
            get
1617
            {
1618
                return this.lumField;
1619
            }
1620
            set
1621
            {
1622
                this.lumField = value;
1623
            }
1624
        }
1625
    }
1626

1627
    [Serializable]
1628
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1629
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1630
    public class CT_GrayscaleEffect
1631
    {
1632
    }
1633

1634

1635
    [Serializable]
1636
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1637
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1638
    public class CT_GlowEffect
1639
    {
1640

1641
        private CT_ScRgbColor scrgbClrField;
1642

1643
        private CT_SRgbColor srgbClrField;
1644

1645
        private CT_HslColor hslClrField;
1646

1647
        private CT_SystemColor sysClrField;
1648

1649
        private CT_SchemeColor schemeClrField;
1650

1651
        private CT_PresetColor prstClrField;
1652

1653
        private long radField;
1654
        public static CT_GlowEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1655
        {
1656
            if (node == null)
1657
                return null;
1658
            CT_GlowEffect ctObj = new CT_GlowEffect();
1659
            ctObj.rad = XmlHelper.ReadLong(node.Attributes["rad"]);
1660
            foreach (XmlNode childNode in node.ChildNodes)
1661
            {
1662
                if (childNode.LocalName == "scrgbClr")
1663
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
1664
                else if (childNode.LocalName == "srgbClr")
1665
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
1666
                else if (childNode.LocalName == "hslClr")
1667
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
1668
                else if (childNode.LocalName == "sysClr")
1669
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
1670
                else if (childNode.LocalName == "schemeClr")
1671
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
1672
                else if (childNode.LocalName == "prstClr")
1673
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
1674
            }
1675
            return ctObj;
1676
        }
1677

1678

1679

1680
        internal void Write(StreamWriter sw, string nodeName)
1681
        {
1682
            sw.Write(string.Format("<a:{0}", nodeName));
1683
            XmlHelper.WriteAttribute(sw, "rad", this.rad);
1684
            sw.Write(">");
1685
            if (this.scrgbClr != null)
1686
                this.scrgbClr.Write(sw, "scrgbClr");
1687
            if (this.srgbClr != null)
1688
                this.srgbClr.Write(sw, "srgbClr");
1689
            if (this.hslClr != null)
1690
                this.hslClr.Write(sw, "hslClr");
1691
            if (this.sysClr != null)
1692
                this.sysClr.Write(sw, "sysClr");
1693
            if (this.schemeClr != null)
1694
                this.schemeClr.Write(sw, "schemeClr");
1695
            if (this.prstClr != null)
1696
                this.prstClr.Write(sw, "prstClr");
1697
            sw.Write(string.Format("</a:{0}>", nodeName));
1698
        }
1699

1700
        public CT_GlowEffect()
1701
        {
1702
            //this.prstClrField = new CT_PresetColor();
1703
            //this.schemeClrField = new CT_SchemeColor();
1704
            //this.sysClrField = new CT_SystemColor();
1705
            //this.hslClrField = new CT_HslColor();
1706
            //this.srgbClrField = new CT_SRgbColor();
1707
            //this.scrgbClrField = new CT_ScRgbColor();
1708
            //this.radField = ((long)(0));
1709
        }
1710

1711
        [XmlElement(Order = 0)]
1712
        public CT_ScRgbColor scrgbClr
1713
        {
1714
            get
1715
            {
1716
                return this.scrgbClrField;
1717
            }
1718
            set
1719
            {
1720
                this.scrgbClrField = value;
1721
            }
1722
        }
1723

1724
        [XmlElement(Order = 1)]
1725
        public CT_SRgbColor srgbClr
1726
        {
1727
            get
1728
            {
1729
                return this.srgbClrField;
1730
            }
1731
            set
1732
            {
1733
                this.srgbClrField = value;
1734
            }
1735
        }
1736

1737
        [XmlElement(Order = 2)]
1738
        public CT_HslColor hslClr
1739
        {
1740
            get
1741
            {
1742
                return this.hslClrField;
1743
            }
1744
            set
1745
            {
1746
                this.hslClrField = value;
1747
            }
1748
        }
1749

1750
        [XmlElement(Order = 3)]
1751
        public CT_SystemColor sysClr
1752
        {
1753
            get
1754
            {
1755
                return this.sysClrField;
1756
            }
1757
            set
1758
            {
1759
                this.sysClrField = value;
1760
            }
1761
        }
1762

1763
        [XmlElement(Order = 4)]
1764
        public CT_SchemeColor schemeClr
1765
        {
1766
            get
1767
            {
1768
                return this.schemeClrField;
1769
            }
1770
            set
1771
            {
1772
                this.schemeClrField = value;
1773
            }
1774
        }
1775

1776
        [XmlElement(Order = 5)]
1777
        public CT_PresetColor prstClr
1778
        {
1779
            get
1780
            {
1781
                return this.prstClrField;
1782
            }
1783
            set
1784
            {
1785
                this.prstClrField = value;
1786
            }
1787
        }
1788

1789
        [XmlAttribute]
1790
        [DefaultValue(typeof(long), "0")]
1791
        public long rad
1792
        {
1793
            get
1794
            {
1795
                return this.radField;
1796
            }
1797
            set
1798
            {
1799
                this.radField = value;
1800
            }
1801
        }
1802
    }
1803

1804

1805
    [Serializable]
1806
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1807
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1808
    public class CT_FillOverlayEffect
1809
    {
1810

1811
        private CT_NoFillProperties noFillField;
1812

1813
        private CT_SolidColorFillProperties solidFillField;
1814

1815
        private CT_GradientFillProperties gradFillField;
1816

1817
        private CT_BlipFillProperties blipFillField;
1818

1819
        private CT_PatternFillProperties pattFillField;
1820

1821
        private CT_GroupFillProperties grpFillField;
1822

1823
        private ST_BlendMode blendField;
1824
        public static CT_FillOverlayEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1825
        {
1826
            if (node == null)
1827
                return null;
1828
            CT_FillOverlayEffect ctObj = new CT_FillOverlayEffect();
1829
            if (node.Attributes["blend"] != null)
1830
                ctObj.blend = (ST_BlendMode)Enum.Parse(typeof(ST_BlendMode), node.Attributes["blend"].Value);
1831
            foreach (XmlNode childNode in node.ChildNodes)
1832
            {
1833
                if (childNode.LocalName == "noFill")
1834
                    ctObj.noFill = new CT_NoFillProperties();
1835
                else if (childNode.LocalName == "solidFill")
1836
                    ctObj.solidFill = CT_SolidColorFillProperties.Parse(childNode, namespaceManager);
1837
                else if (childNode.LocalName == "gradFill")
1838
                    ctObj.gradFill = CT_GradientFillProperties.Parse(childNode, namespaceManager);
1839
                else if (childNode.LocalName == "blipFill")
1840
                    ctObj.blipFill = CT_BlipFillProperties.Parse(childNode, namespaceManager);
1841
                else if (childNode.LocalName == "pattFill")
1842
                    ctObj.pattFill = CT_PatternFillProperties.Parse(childNode, namespaceManager);
1843
                else if (childNode.LocalName == "grpFill")
1844
                    ctObj.grpFill = new CT_GroupFillProperties();
1845
            }
1846
            return ctObj;
1847
        }
1848

1849

1850

1851
        internal void Write(StreamWriter sw, string nodeName)
1852
        {
1853
            sw.Write(string.Format("<a:{0}", nodeName));
1854
            XmlHelper.WriteAttribute(sw, "blend", this.blend.ToString());
1855
            sw.Write(">");
1856
            if (this.noFill != null)
1857
                sw.Write("<a:noFill/>");
1858
            if (this.gradFill != null)
1859
                this.gradFill.Write(sw, "gradFill");            
1860
            if (this.solidFill != null)
1861
                this.solidFill.Write(sw, "solidFill");
1862
            if (this.blipFill != null)
1863
                this.blipFill.Write(sw, "a:blipFill");
1864
            if (this.pattFill != null)
1865
                this.pattFill.Write(sw, "pattFill");
1866
            if (this.grpFill != null)
1867
                sw.Write("<a:grpFill/>");
1868
            sw.Write(string.Format("</a:{0}>", nodeName));
1869
        }
1870

1871
        public CT_FillOverlayEffect()
1872
        {
1873
            //this.grpFillField = new CT_GroupFillProperties();
1874
            //this.pattFillField = new CT_PatternFillProperties();
1875
            //this.blipFillField = new CT_BlipFillProperties();
1876
            //this.gradFillField = new CT_GradientFillProperties();
1877
            //this.solidFillField = new CT_SolidColorFillProperties();
1878
            //this.noFillField = new CT_NoFillProperties();
1879
        }
1880

1881
        [XmlElement(Order = 0)]
1882
        public CT_NoFillProperties noFill
1883
        {
1884
            get
1885
            {
1886
                return this.noFillField;
1887
            }
1888
            set
1889
            {
1890
                this.noFillField = value;
1891
            }
1892
        }
1893

1894
        [XmlElement(Order = 1)]
1895
        public CT_SolidColorFillProperties solidFill
1896
        {
1897
            get
1898
            {
1899
                return this.solidFillField;
1900
            }
1901
            set
1902
            {
1903
                this.solidFillField = value;
1904
            }
1905
        }
1906

1907
        [XmlElement(Order = 2)]
1908
        public CT_GradientFillProperties gradFill
1909
        {
1910
            get
1911
            {
1912
                return this.gradFillField;
1913
            }
1914
            set
1915
            {
1916
                this.gradFillField = value;
1917
            }
1918
        }
1919

1920
        [XmlElement(Order = 3)]
1921
        public CT_BlipFillProperties blipFill
1922
        {
1923
            get
1924
            {
1925
                return this.blipFillField;
1926
            }
1927
            set
1928
            {
1929
                this.blipFillField = value;
1930
            }
1931
        }
1932

1933
        [XmlElement(Order = 4)]
1934
        public CT_PatternFillProperties pattFill
1935
        {
1936
            get
1937
            {
1938
                return this.pattFillField;
1939
            }
1940
            set
1941
            {
1942
                this.pattFillField = value;
1943
            }
1944
        }
1945

1946
        [XmlElement(Order = 5)]
1947
        public CT_GroupFillProperties grpFill
1948
        {
1949
            get
1950
            {
1951
                return this.grpFillField;
1952
            }
1953
            set
1954
            {
1955
                this.grpFillField = value;
1956
            }
1957
        }
1958

1959
        [XmlAttribute]
1960
        public ST_BlendMode blend
1961
        {
1962
            get
1963
            {
1964
                return this.blendField;
1965
            }
1966
            set
1967
            {
1968
                this.blendField = value;
1969
            }
1970
        }
1971
    }
1972

1973

1974
    [Serializable]
1975
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1976
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1977
    public class CT_NoFillProperties
1978
    {
1979
    }
1980

1981

1982
    [Serializable]
1983
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1984
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1985
    public class CT_SolidColorFillProperties
1986
    {
1987

1988
        private CT_ScRgbColor scrgbClrField;
1989

1990
        private CT_SRgbColor srgbClrField;
1991

1992
        private CT_HslColor hslClrField;
1993

1994
        private CT_SystemColor sysClrField;
1995

1996
        private CT_SchemeColor schemeClrField;
1997

1998
        private CT_PresetColor prstClrField;
1999

2000
        public CT_SolidColorFillProperties()
2001
        {
2002
            //this.prstClrField = new CT_PresetColor();
2003
            //this.schemeClrField = new CT_SchemeColor();
2004
            //this.sysClrField = new CT_SystemColor();
2005
            //this.hslClrField = new CT_HslColor();
2006
            //this.srgbClrField = new CT_SRgbColor();
2007
            //this.scrgbClrField = new CT_ScRgbColor();
2008
        }
2009
        public static CT_SolidColorFillProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2010
        {
2011
            if (node == null)
2012
                return null;
2013
            CT_SolidColorFillProperties ctObj = new CT_SolidColorFillProperties();
2014
            foreach (XmlNode childNode in node.ChildNodes)
2015
            {
2016
                if (childNode.LocalName == "scrgbClr")
2017
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
2018
                else if (childNode.LocalName == "srgbClr")
2019
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
2020
                else if (childNode.LocalName == "hslClr")
2021
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
2022
                else if (childNode.LocalName == "sysClr")
2023
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
2024
                else if (childNode.LocalName == "schemeClr")
2025
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
2026
                else if (childNode.LocalName == "prstClr")
2027
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
2028
            }
2029
            return ctObj;
2030
        }
2031

2032
        internal void Write(StreamWriter sw, string nodeName)
2033
        {
2034
            sw.Write(string.Format("<a:{0}", nodeName));
2035
            sw.Write(">");
2036
            if (this.scrgbClr != null)
2037
                this.scrgbClr.Write(sw, "scrgbClr");
2038
            if (this.srgbClr != null)
2039
                this.srgbClr.Write(sw, "srgbClr");
2040
            if (this.hslClr != null)
2041
                this.hslClr.Write(sw, "hslClr");
2042
            if (this.sysClr != null)
2043
                this.sysClr.Write(sw, "sysClr");
2044
            if (this.schemeClr != null)
2045
                this.schemeClr.Write(sw, "schemeClr");
2046
            if (this.prstClr != null)
2047
                this.prstClr.Write(sw, "prstClr");
2048
            sw.Write(string.Format("</a:{0}>", nodeName));
2049
        }
2050

2051
        [XmlElement(Order = 0)]
2052
        public CT_ScRgbColor scrgbClr
2053
        {
2054
            get
2055
            {
2056
                return this.scrgbClrField;
2057
            }
2058
            set
2059
            {
2060
                this.scrgbClrField = value;
2061
            }
2062
        }
2063

2064
        [XmlElement(Order = 1)]
2065
        public CT_SRgbColor srgbClr
2066
        {
2067
            get
2068
            {
2069
                return this.srgbClrField;
2070
            }
2071
            set
2072
            {
2073
                this.srgbClrField = value;
2074
            }
2075
        }
2076

2077
        [XmlElement(Order = 2)]
2078
        public CT_HslColor hslClr
2079
        {
2080
            get
2081
            {
2082
                return this.hslClrField;
2083
            }
2084
            set
2085
            {
2086
                this.hslClrField = value;
2087
            }
2088
        }
2089

2090
        [XmlElement(Order = 3)]
2091
        public CT_SystemColor sysClr
2092
        {
2093
            get
2094
            {
2095
                return this.sysClrField;
2096
            }
2097
            set
2098
            {
2099
                this.sysClrField = value;
2100
            }
2101
        }
2102

2103
        [XmlElement(Order = 4)]
2104
        public CT_SchemeColor schemeClr
2105
        {
2106
            get
2107
            {
2108
                return this.schemeClrField;
2109
            }
2110
            set
2111
            {
2112
                this.schemeClrField = value;
2113
            }
2114
        }
2115

2116
        [XmlElement(Order = 5)]
2117
        public CT_PresetColor prstClr
2118
        {
2119
            get
2120
            {
2121
                return this.prstClrField;
2122
            }
2123
            set
2124
            {
2125
                this.prstClrField = value;
2126
            }
2127
        }
2128

2129
        public bool IsSetSrgbClr()
2130
        {
2131
            return srgbClrField != null;
2132
        }
2133

2134
        public CT_SRgbColor AddNewSrgbClr()
2135
        {
2136
            this.srgbClrField = new CT_SRgbColor();
2137
            return srgbClrField;
2138
        }
2139

2140
        public bool IsSetHslClr()
2141
        {
2142
            return this.hslClrField != null;
2143
        }
2144

2145
        public bool IsSetPrstClr()
2146
        {
2147
            return this.prstClrField != null;
2148
        }
2149

2150
        public bool IsSetSchemeClr()
2151
        {
2152
            return this.schemeClrField != null;
2153
        }
2154

2155
        public bool IsSetScrgbClr()
2156
        {
2157
            return this.scrgbClrField != null;
2158
        }
2159

2160
        public bool IsSetSysClr()
2161
        {
2162
            return this.sysClrField != null;
2163
        }
2164

2165
        public void UnsetHslClr()
2166
        {
2167
            this.hslClrField = null;
2168
        }
2169

2170
        public void UnsetPrstClr()
2171
        {
2172
            this.prstClrField = null;
2173
        }
2174

2175
        public void UnsetSchemeClr()
2176
        {
2177
            this.schemeClrField = null;
2178
        }
2179

2180
        public void UnsetScrgbClr()
2181
        {
2182
            this.scrgbClrField = null;
2183
        }
2184

2185
        public void UnsetSysClr()
2186
        {
2187
            this.sysClrField = null;
2188
        }
2189
    }
2190

2191
    [Serializable]
2192
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2193
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
2194
    public class CT_GradientFillProperties
2195
    {
2196

2197
        private CT_GradientStopList gsLstField;
2198

2199
        private CT_LinearShadeProperties linField;
2200

2201
        private CT_PathShadeProperties pathField;
2202

2203
        private CT_RelativeRect tileRectField;
2204

2205
        private ST_TileFlipMode flipField;
2206

2207
        private bool flipFieldSpecified;
2208

2209
        private bool rotWithShapeField;
2210

2211
        private bool rotWithShapeFieldSpecified;
2212

2213
        public CT_GradientFillProperties()
2214
        {
2215
            //this.tileRectField = new CT_RelativeRect();
2216
            //this.pathField = new CT_PathShadeProperties();
2217
            //this.linField = new CT_LinearShadeProperties();
2218
            //this.gsLstField = new List<CT_GradientStop>();
2219
        }
2220
        public static CT_GradientFillProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2221
        {
2222
            if (node == null)
2223
                return null;
2224
            CT_GradientFillProperties ctObj = new CT_GradientFillProperties();
2225
            if (node.Attributes["flip"] != null)
2226
                ctObj.flip = (ST_TileFlipMode)Enum.Parse(typeof(ST_TileFlipMode), node.Attributes["flip"].Value);
2227
            ctObj.rotWithShape = XmlHelper.ReadBool(node.Attributes["rotWithShape"]);
2228
            foreach (XmlNode childNode in node.ChildNodes)
2229
            {
2230
                if (childNode.LocalName == "gsLst")
2231
                    ctObj.gsLst = CT_GradientStopList.Parse(childNode, namespaceManager);
2232
                else if (childNode.LocalName == "lin")
2233
                    ctObj.lin = CT_LinearShadeProperties.Parse(childNode, namespaceManager);
2234
                else if (childNode.LocalName == "path")
2235
                    ctObj.path = CT_PathShadeProperties.Parse(childNode, namespaceManager);
2236
                else if (childNode.LocalName == "tileRect")
2237
                    ctObj.tileRect = CT_RelativeRect.Parse(childNode, namespaceManager);
2238
            }
2239
            return ctObj;
2240
        }
2241

2242

2243

2244
        internal void Write(StreamWriter sw, string nodeName)
2245
        {
2246
            sw.Write(string.Format("<a:{0}", nodeName));
2247
            if(this.flip!= ST_TileFlipMode.none)
2248
                XmlHelper.WriteAttribute(sw, "flip", this.flip.ToString());
2249
            XmlHelper.WriteAttribute(sw, "rotWithShape", this.rotWithShape);
2250
            sw.Write(">");
2251
            if (this.gsLst != null)
2252
                this.gsLst.Write(sw, "gsLst");
2253
            if (this.lin != null)
2254
                this.lin.Write(sw, "lin");
2255
            if (this.path != null)
2256
                this.path.Write(sw, "path");
2257
            if (this.tileRect != null)
2258
                this.tileRect.Write(sw, "tileRect");
2259
            sw.Write(string.Format("</a:{0}>", nodeName));
2260
        }
2261
        [XmlElement(Order = 0)]
2262
        public CT_GradientStopList gsLst
2263
        {
2264
            get
2265
            {
2266
                return this.gsLstField;
2267
            }
2268
            set
2269
            {
2270
                this.gsLstField = value;
2271
            }
2272
        }
2273

2274
        [XmlElement(Order = 1)]
2275
        public CT_LinearShadeProperties lin
2276
        {
2277
            get
2278
            {
2279
                return this.linField;
2280
            }
2281
            set
2282
            {
2283
                this.linField = value;
2284
            }
2285
        }
2286

2287
        [XmlElement(Order = 2)]
2288
        public CT_PathShadeProperties path
2289
        {
2290
            get
2291
            {
2292
                return this.pathField;
2293
            }
2294
            set
2295
            {
2296
                this.pathField = value;
2297
            }
2298
        }
2299

2300
        [XmlElement(Order = 3)]
2301
        public CT_RelativeRect tileRect
2302
        {
2303
            get
2304
            {
2305
                return this.tileRectField;
2306
            }
2307
            set
2308
            {
2309
                this.tileRectField = value;
2310
            }
2311
        }
2312

2313
        [XmlAttribute]
2314
        public ST_TileFlipMode flip
2315
        {
2316
            get
2317
            {
2318
                return this.flipField;
2319
            }
2320
            set
2321
            {
2322
                this.flipField = value;
2323
            }
2324
        }
2325

2326
        [XmlIgnore]
2327
        public bool flipSpecified
2328
        {
2329
            get
2330
            {
2331
                return this.flipFieldSpecified;
2332
            }
2333
            set
2334
            {
2335
                this.flipFieldSpecified = value;
2336
            }
2337
        }
2338

2339
        [XmlAttribute]
2340
        public bool rotWithShape
2341
        {
2342
            get
2343
            {
2344
                return this.rotWithShapeField;
2345
            }
2346
            set
2347
            {
2348
                this.rotWithShapeField = value;
2349
            }
2350
        }
2351

2352
        [XmlIgnore]
2353
        public bool rotWithShapeSpecified
2354
        {
2355
            get
2356
            {
2357
                return this.rotWithShapeFieldSpecified;
2358
            }
2359
            set
2360
            {
2361
                this.rotWithShapeFieldSpecified = value;
2362
            }
2363
        }
2364

2365
    }
2366

2367
    [Serializable]
2368
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2369
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
2370
    public class CT_GradientStop
2371
    {
2372

2373
        private CT_ScRgbColor scrgbClrField;
2374

2375
        private CT_SRgbColor srgbClrField;
2376

2377
        private CT_HslColor hslClrField;
2378

2379
        private CT_SystemColor sysClrField;
2380

2381
        private CT_SchemeColor schemeClrField;
2382

2383
        private CT_PresetColor prstClrField;
2384

2385
        private int posField;
2386

2387
        public CT_GradientStop()
2388
        {
2389
        }
2390
        public static CT_GradientStop Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2391
        {
2392
            if (node == null)
2393
                return null;
2394
            CT_GradientStop ctObj = new CT_GradientStop();
2395
            ctObj.pos = XmlHelper.ReadInt(node.Attributes["pos"]);
2396
            foreach (XmlNode childNode in node.ChildNodes)
2397
            {
2398
                if (childNode.LocalName == "scrgbClr")
2399
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
2400
                else if (childNode.LocalName == "srgbClr")
2401
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
2402
                else if (childNode.LocalName == "hslClr")
2403
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
2404
                else if (childNode.LocalName == "sysClr")
2405
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
2406
                else if (childNode.LocalName == "schemeClr")
2407
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
2408
                else if (childNode.LocalName == "prstClr")
2409
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
2410
            }
2411
            return ctObj;
2412
        }
2413

2414

2415

2416
        internal void Write(StreamWriter sw, string nodeName)
2417
        {
2418
            sw.Write(string.Format("<a:{0}", nodeName));
2419
            XmlHelper.WriteAttribute(sw, "pos", this.pos, true);
2420
            sw.Write(">");
2421
            if (this.scrgbClr != null)
2422
                this.scrgbClr.Write(sw, "scrgbClr");
2423
            if (this.srgbClr != null)
2424
                this.srgbClr.Write(sw, "srgbClr");
2425
            if (this.hslClr != null)
2426
                this.hslClr.Write(sw, "hslClr");
2427
            if (this.sysClr != null)
2428
                this.sysClr.Write(sw, "sysClr");
2429
            if (this.schemeClr != null)
2430
                this.schemeClr.Write(sw, "schemeClr");
2431
            if (this.prstClr != null)
2432
                this.prstClr.Write(sw, "prstClr");
2433
            sw.Write(string.Format("</a:{0}>", nodeName));
2434
        }
2435

2436
        [XmlElement(Order = 0)]
2437
        public CT_ScRgbColor scrgbClr
2438
        {
2439
            get
2440
            {
2441
                return this.scrgbClrField;
2442
            }
2443
            set
2444
            {
2445
                this.scrgbClrField = value;
2446
            }
2447
        }
2448

2449
        [XmlElement(Order = 1)]
2450
        public CT_SRgbColor srgbClr
2451
        {
2452
            get
2453
            {
2454
                return this.srgbClrField;
2455
            }
2456
            set
2457
            {
2458
                this.srgbClrField = value;
2459
            }
2460
        }
2461

2462
        [XmlElement(Order = 2)]
2463
        public CT_HslColor hslClr
2464
        {
2465
            get
2466
            {
2467
                return this.hslClrField;
2468
            }
2469
            set
2470
            {
2471
                this.hslClrField = value;
2472
            }
2473
        }
2474

2475
        [XmlElement(Order = 3)]
2476
        public CT_SystemColor sysClr
2477
        {
2478
            get
2479
            {
2480
                return this.sysClrField;
2481
            }
2482
            set
2483
            {
2484
                this.sysClrField = value;
2485
            }
2486
        }
2487

2488
        [XmlElement(Order = 4)]
2489
        public CT_SchemeColor schemeClr
2490
        {
2491
            get
2492
            {
2493
                return this.schemeClrField;
2494
            }
2495
            set
2496
            {
2497
                this.schemeClrField = value;
2498
            }
2499
        }
2500

2501
        [XmlElement(Order = 5)]
2502
        public CT_PresetColor prstClr
2503
        {
2504
            get
2505
            {
2506
                return this.prstClrField;
2507
            }
2508
            set
2509
            {
2510
                this.prstClrField = value;
2511
            }
2512
        }
2513

2514
        [XmlAttribute]
2515
        public int pos
2516
        {
2517
            get
2518
            {
2519
                return this.posField;
2520
            }
2521
            set
2522
            {
2523
                this.posField = value;
2524
            }
2525
        }
2526
    }
2527

2528
    [Serializable]
2529
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2530
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
2531
    public class CT_LinearShadeProperties
2532
    {
2533

2534
        private int angField;
2535

2536
        private bool angFieldSpecified;
2537

2538
        private bool scaledField;
2539

2540
        private bool scaledFieldSpecified;
2541
        public static CT_LinearShadeProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2542
        {
2543
            if (node == null)
2544
                return null;
2545
            CT_LinearShadeProperties ctObj = new CT_LinearShadeProperties();
2546
            ctObj.ang = XmlHelper.ReadInt(node.Attributes["ang"]);
2547
            ctObj.scaled = XmlHelper.ReadBool(node.Attributes["scaled"]);
2548
            return ctObj;
2549
        }
2550

2551

2552

2553
        internal void Write(StreamWriter sw, string nodeName)
2554
        {
2555
            sw.Write(string.Format("<a:{0}", nodeName));
2556
            XmlHelper.WriteAttribute(sw, "ang", this.ang);
2557
            XmlHelper.WriteAttribute(sw, "scaled", this.scaled);
2558
            sw.Write("/>");
2559
        }
2560

2561
        [XmlAttribute]
2562
        public int ang
2563
        {
2564
            get
2565
            {
2566
                return this.angField;
2567
            }
2568
            set
2569
            {
2570
                this.angField = value;
2571
            }
2572
        }
2573

2574
        [XmlIgnore]
2575
        public bool angSpecified
2576
        {
2577
            get
2578
            {
2579
                return this.angFieldSpecified;
2580
            }
2581
            set
2582
            {
2583
                this.angFieldSpecified = value;
2584
            }
2585
        }
2586

2587
        [XmlAttribute]
2588
        public bool scaled
2589
        {
2590
            get
2591
            {
2592
                return this.scaledField;
2593
            }
2594
            set
2595
            {
2596
                this.scaledField = value;
2597
            }
2598
        }
2599

2600
        [XmlIgnore]
2601
        public bool scaledSpecified
2602
        {
2603
            get
2604
            {
2605
                return this.scaledFieldSpecified;
2606
            }
2607
            set
2608
            {
2609
                this.scaledFieldSpecified = value;
2610
            }
2611
        }
2612
    }
2613

2614
    [Serializable]
2615
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2616
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
2617
    public class CT_PathShadeProperties
2618
    {
2619

2620
        private CT_RelativeRect fillToRectField;
2621

2622
        private ST_PathShadeType pathField;
2623

2624
        private bool pathFieldSpecified;
2625

2626
        public CT_PathShadeProperties()
2627
        {
2628
            //this.fillToRectField = new CT_RelativeRect();
2629
        }
2630
        public static CT_PathShadeProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2631
        {
2632
            if (node == null)
2633
                return null;
2634
            CT_PathShadeProperties ctObj = new CT_PathShadeProperties();
2635
            if (node.Attributes["path"] != null)
2636
                ctObj.path = (ST_PathShadeType)Enum.Parse(typeof(ST_PathShadeType), node.Attributes["path"].Value);
2637
            foreach (XmlNode childNode in node.ChildNodes)
2638
            {
2639
                if (childNode.LocalName == "fillToRect")
2640
                    ctObj.fillToRect = CT_RelativeRect.Parse(childNode, namespaceManager);
2641
            }
2642
            return ctObj;
2643
        }
2644

2645

2646

2647
        internal void Write(StreamWriter sw, string nodeName)
2648
        {
2649
            sw.Write(string.Format("<a:{0}", nodeName));
2650
            XmlHelper.WriteAttribute(sw, "path", this.path.ToString());
2651
            sw.Write(">");
2652
            if (this.fillToRect != null)
2653
                this.fillToRect.Write(sw, "fillToRect");
2654
            sw.Write(string.Format("</a:{0}>", nodeName));
2655
        }
2656

2657

2658
        [XmlElement(Order = 0)]
2659
        public CT_RelativeRect fillToRect
2660
        {
2661
            get
2662
            {
2663
                return this.fillToRectField;
2664
            }
2665
            set
2666
            {
2667
                this.fillToRectField = value;
2668
            }
2669
        }
2670

2671
        [XmlAttribute]
2672
        public ST_PathShadeType path
2673
        {
2674
            get
2675
            {
2676
                return this.pathField;
2677
            }
2678
            set
2679
            {
2680
                this.pathField = value;
2681
            }
2682
        }
2683

2684
        [XmlIgnore]
2685
        public bool pathSpecified
2686
        {
2687
            get
2688
            {
2689
                return this.pathFieldSpecified;
2690
            }
2691
            set
2692
            {
2693
                this.pathFieldSpecified = value;
2694
            }
2695
        }
2696
    }
2697

2698
    [Serializable]
2699
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2700
    public enum ST_PathShadeType
2701
    {
2702

2703
        /// <remarks/>
2704
        shape,
2705

2706
        /// <remarks/>
2707
        circle,
2708

2709
        /// <remarks/>
2710
        rect,
2711
    }
2712

2713

2714
    [Serializable]
2715
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2716
    public enum ST_TileFlipMode
2717
    {
2718

2719
        /// <remarks/>
2720
        none,
2721

2722
        /// <remarks/>
2723
        x,
2724

2725
        /// <remarks/>
2726
        y,
2727

2728
        /// <remarks/>
2729
        xy,
2730
    }
2731

2732
    [Serializable]
2733
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2734
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
2735
    public class CT_BlipFillProperties
2736
    {
2737

2738
        private CT_Blip blipField = null;
2739

2740
        private CT_RelativeRect srcRectField = null;
2741

2742
        private CT_TileInfoProperties tileField = null;
2743

2744
        private CT_StretchInfoProperties stretchField = null;
2745

2746
        private uint dpiField;
2747
        private bool dpiFieldSpecified;
2748

2749
        private bool rotWithShapeField;
2750

2751
        private bool rotWithShapeFieldSpecified;
2752

2753
        public CT_Blip AddNewBlip()
2754
        {
2755
            this.blipField = new CT_Blip();
2756
            return blipField;
2757
        }
2758

2759
        public CT_StretchInfoProperties AddNewStretch()
2760
        {
2761
            this.stretchField = new CT_StretchInfoProperties();
2762
            return stretchField;
2763
        }
2764

2765
        public static CT_BlipFillProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2766
        {
2767
            if (node == null)
2768
                return null;
2769
            CT_BlipFillProperties ctObj = new CT_BlipFillProperties();
2770
            ctObj.dpi = XmlHelper.ReadUInt(node.Attributes["dpi"]);
2771
            ctObj.rotWithShape = XmlHelper.ReadBool(node.Attributes["rotWithShape"]);
2772
            foreach (XmlNode childNode in node.ChildNodes)
2773
            {
2774
                if (childNode.LocalName == "blip")
2775
                    ctObj.blip = CT_Blip.Parse(childNode, namespaceManager);
2776
                else if (childNode.LocalName == "srcRect")
2777
                    ctObj.srcRect = CT_RelativeRect.Parse(childNode, namespaceManager);
2778
                else if (childNode.LocalName == "tile")
2779
                    ctObj.tile = CT_TileInfoProperties.Parse(childNode, namespaceManager);
2780
                else if (childNode.LocalName == "stretch")
2781
                    ctObj.stretch = CT_StretchInfoProperties.Parse(childNode, namespaceManager);
2782
            }
2783
            return ctObj;
2784
        }
2785

2786

2787

2788
        internal void Write(StreamWriter sw, string nodeName)
2789
        {
2790
            sw.Write(string.Format("<{0}", nodeName));
2791
            XmlHelper.WriteAttribute(sw, "dpi", this.dpi);
2792
            XmlHelper.WriteAttribute(sw, "rotWithShape", this.rotWithShape);
2793
            sw.Write(">");
2794
            if (this.blip != null)
2795
                this.blip.Write(sw, "blip");
2796
            if (this.srcRect != null)
2797
                this.srcRect.Write(sw, "srcRect");
2798
            if (this.tile != null)
2799
                this.tile.Write(sw, "tile");
2800
            if (this.stretch != null)
2801
                this.stretch.Write(sw, "stretch");
2802
            sw.Write(string.Format("</{0}>", nodeName));
2803
        }
2804

2805
        [XmlElement(Order = 0)]
2806
        public CT_Blip blip
2807
        {
2808
            get
2809
            {
2810
                return this.blipField;
2811
            }
2812
            set
2813
            {
2814
                this.blipField = value;
2815
            }
2816
        }
2817

2818
        [XmlElement(Order = 1)]
2819
        public CT_RelativeRect srcRect
2820
        {
2821
            get
2822
            {
2823
                return this.srcRectField;
2824
            }
2825
            set
2826
            {
2827
                this.srcRectField = value;
2828
            }
2829
        }
2830

2831
        [XmlElement(Order = 2)]
2832
        public CT_TileInfoProperties tile
2833
        {
2834
            get
2835
            {
2836
                return this.tileField;
2837
            }
2838
            set
2839
            {
2840
                this.tileField = value;
2841
            }
2842
        }
2843

2844
        [XmlElement(Order = 3)]
2845
        public CT_StretchInfoProperties stretch
2846
        {
2847
            get
2848
            {
2849
                return this.stretchField;
2850
            }
2851
            set
2852
            {
2853
                this.stretchField = value;
2854
            }
2855
        }
2856

2857
        [XmlAttribute]
2858
        public uint dpi
2859
        {
2860
            get 
2861
            { 
2862
                return (uint)this.dpiField; 
2863
            }
2864
            set 
2865
            { 
2866
                this.dpiField = value; 
2867
            }
2868
        }
2869
        [XmlIgnore]
2870
        public bool dpiSpecified
2871
        {
2872
            get
2873
            {
2874
                return dpiFieldSpecified;
2875
            }
2876
            set
2877
            {
2878
                this.dpiFieldSpecified = value;
2879
            }
2880
        }
2881

2882

2883
        [XmlAttribute]
2884
        public bool rotWithShape
2885
        {
2886
            get
2887
            {
2888
                return (bool)this.rotWithShapeField;
2889
            }
2890
            set
2891
            {
2892
                this.rotWithShapeField = value;
2893
            }
2894
        }
2895
        [XmlIgnore]
2896
        public bool rotWithShapeSpecified
2897
        {
2898
            get
2899
            {
2900
                return rotWithShapeFieldSpecified;
2901
            }
2902
            set
2903
            {
2904
                this.rotWithShapeFieldSpecified = value;
2905
            }
2906
        }
2907

2908
        public bool IsSetBlip()
2909
        {
2910
            return this.blipField != null;
2911
        }
2912

2913
    }
2914

2915

2916

2917
    [Serializable]
2918
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2919
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
2920
    public class CT_TileInfoProperties
2921
    {
2922

2923
        private long txField;
2924

2925
        private bool txFieldSpecified;
2926

2927
        private long tyField;
2928

2929
        private bool tyFieldSpecified;
2930

2931
        private int sxField;
2932

2933
        private bool sxFieldSpecified;
2934

2935
        private int syField;
2936

2937
        private bool syFieldSpecified;
2938

2939
        private ST_TileFlipMode flipField;
2940

2941
        private bool flipFieldSpecified;
2942

2943
        private ST_RectAlignment algnField;
2944

2945
        private bool algnFieldSpecified;
2946

2947
        public static CT_TileInfoProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2948
        {
2949
            if (node == null)
2950
                return null;
2951
            CT_TileInfoProperties ctObj = new CT_TileInfoProperties();
2952
            ctObj.tx = XmlHelper.ReadLong(node.Attributes["tx"]);
2953
            ctObj.ty = XmlHelper.ReadLong(node.Attributes["ty"]);
2954
            ctObj.sx = XmlHelper.ReadInt(node.Attributes["sx"]);
2955
            ctObj.sy = XmlHelper.ReadInt(node.Attributes["sy"]);
2956
            if (node.Attributes["flip"] != null)
2957
                ctObj.flip = (ST_TileFlipMode)Enum.Parse(typeof(ST_TileFlipMode), node.Attributes["flip"].Value);
2958
            if (node.Attributes["algn"] != null)
2959
                ctObj.algn = (ST_RectAlignment)Enum.Parse(typeof(ST_RectAlignment), node.Attributes["algn"].Value);
2960
            return ctObj;
2961
        }
2962

2963

2964

2965
        internal void Write(StreamWriter sw, string nodeName)
2966
        {
2967
            sw.Write(string.Format("<a:{0}", nodeName));
2968
            XmlHelper.WriteAttribute(sw, "tx", this.tx);
2969
            XmlHelper.WriteAttribute(sw, "ty", this.ty);
2970
            XmlHelper.WriteAttribute(sw, "sx", this.sx);
2971
            XmlHelper.WriteAttribute(sw, "sy", this.sy);
2972
            XmlHelper.WriteAttribute(sw, "flip", this.flip.ToString());
2973
            XmlHelper.WriteAttribute(sw, "algn", this.algn.ToString());
2974
            sw.Write(">");
2975
            sw.Write(string.Format("</a:{0}>", nodeName));
2976
        }
2977

2978
        [XmlAttribute]
2979
        public long tx
2980
        {
2981
            get
2982
            {
2983
                return this.txField;
2984
            }
2985
            set
2986
            {
2987
                this.txField = value;
2988
            }
2989
        }
2990

2991
        [XmlIgnore]
2992
        public bool txSpecified
2993
        {
2994
            get
2995
            {
2996
                return this.txFieldSpecified;
2997
            }
2998
            set
2999
            {
3000
                this.txFieldSpecified = value;
3001
            }
3002
        }
3003

3004
        [XmlAttribute]
3005
        public long ty
3006
        {
3007
            get
3008
            {
3009
                return this.tyField;
3010
            }
3011
            set
3012
            {
3013
                this.tyField = value;
3014
            }
3015
        }
3016

3017
        [XmlIgnore]
3018
        public bool tySpecified
3019
        {
3020
            get
3021
            {
3022
                return this.tyFieldSpecified;
3023
            }
3024
            set
3025
            {
3026
                this.tyFieldSpecified = value;
3027
            }
3028
        }
3029

3030
        [XmlAttribute]
3031
        public int sx
3032
        {
3033
            get
3034
            {
3035
                return this.sxField;
3036
            }
3037
            set
3038
            {
3039
                this.sxField = value;
3040
            }
3041
        }
3042

3043
        [XmlIgnore]
3044
        public bool sxSpecified
3045
        {
3046
            get
3047
            {
3048
                return this.sxFieldSpecified;
3049
            }
3050
            set
3051
            {
3052
                this.sxFieldSpecified = value;
3053
            }
3054
        }
3055

3056
        [XmlAttribute]
3057
        public int sy
3058
        {
3059
            get
3060
            {
3061
                return this.syField;
3062
            }
3063
            set
3064
            {
3065
                this.syField = value;
3066
            }
3067
        }
3068

3069
        [XmlIgnore]
3070
        public bool sySpecified
3071
        {
3072
            get
3073
            {
3074
                return this.syFieldSpecified;
3075
            }
3076
            set
3077
            {
3078
                this.syFieldSpecified = value;
3079
            }
3080
        }
3081

3082
        [XmlAttribute]
3083
        public ST_TileFlipMode flip
3084
        {
3085
            get
3086
            {
3087
                return this.flipField;
3088
            }
3089
            set
3090
            {
3091
                this.flipField = value;
3092
            }
3093
        }
3094

3095
        [XmlIgnore]
3096
        public bool flipSpecified
3097
        {
3098
            get
3099
            {
3100
                return this.flipFieldSpecified;
3101
            }
3102
            set
3103
            {
3104
                this.flipFieldSpecified = value;
3105
            }
3106
        }
3107

3108
        [XmlAttribute]
3109
        public ST_RectAlignment algn
3110
        {
3111
            get
3112
            {
3113
                return this.algnField;
3114
            }
3115
            set
3116
            {
3117
                this.algnField = value;
3118
            }
3119
        }
3120

3121
        [XmlIgnore]
3122
        public bool algnSpecified
3123
        {
3124
            get
3125
            {
3126
                return this.algnFieldSpecified;
3127
            }
3128
            set
3129
            {
3130
                this.algnFieldSpecified = value;
3131
            }
3132
        }
3133
    }
3134

3135

3136
    [Serializable]
3137
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3138
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3139
    public class CT_StretchInfoProperties
3140
    {
3141
        public static CT_StretchInfoProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3142
        {
3143
            if (node == null)
3144
                return null;
3145
            CT_StretchInfoProperties ctObj = new CT_StretchInfoProperties();
3146
            foreach (XmlNode childNode in node.ChildNodes)
3147
            {
3148
                if (childNode.LocalName == "fillRect")
3149
                    ctObj.fillRect = CT_RelativeRect.Parse(childNode, namespaceManager);
3150
            }
3151
            return ctObj;
3152
        }
3153

3154

3155

3156
        internal void Write(StreamWriter sw, string nodeName)
3157
        {
3158
            sw.Write(string.Format("<a:{0}", nodeName));
3159
            sw.Write(">");
3160
            if (this.fillRect != null)
3161
                this.fillRect.Write(sw, "fillRect");
3162
            sw.Write(string.Format("</a:{0}>", nodeName));
3163
        }
3164

3165
        private CT_RelativeRect fillRectField = null;
3166

3167
        public CT_RelativeRect AddNewFillRect()
3168
        {
3169
            this.fillRectField = new CT_RelativeRect();
3170
            return this.fillRectField;
3171
        }
3172

3173
        [XmlElement(Order = 0)]
3174
        public CT_RelativeRect fillRect
3175
        {
3176
            get
3177
            {
3178
                return this.fillRectField;
3179
            }
3180
            set
3181
            {
3182
                this.fillRectField = value;
3183
            }
3184
        }
3185
    }
3186

3187
    [Serializable]
3188
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3189
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3190
    public class CT_PatternFillProperties
3191
    {
3192

3193
        private CT_Color fgClrField;
3194

3195
        private CT_Color bgClrField;
3196

3197
        private ST_PresetPatternVal prstField;
3198

3199
        private bool prstFieldSpecified;
3200
        public static CT_PatternFillProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3201
        {
3202
            if (node == null)
3203
                return null;
3204
            CT_PatternFillProperties ctObj = new CT_PatternFillProperties();
3205
            if (node.Attributes["prst"] != null)
3206
                ctObj.prst = (ST_PresetPatternVal)Enum.Parse(typeof(ST_PresetPatternVal), node.Attributes["prst"].Value);
3207
            foreach (XmlNode childNode in node.ChildNodes)
3208
            {
3209
                if (childNode.LocalName == "fgClr")
3210
                    ctObj.fgClr = CT_Color.Parse(childNode, namespaceManager);
3211
                else if (childNode.LocalName == "bgClr")
3212
                    ctObj.bgClr = CT_Color.Parse(childNode, namespaceManager);
3213
            }
3214
            return ctObj;
3215
        }
3216

3217

3218

3219
        internal void Write(StreamWriter sw, string nodeName)
3220
        {
3221
            sw.Write(string.Format("<a:{0}", nodeName));
3222
            XmlHelper.WriteAttribute(sw, "prst", this.prst.ToString());
3223
            sw.Write(">");
3224
            if (this.fgClr != null)
3225
                this.fgClr.Write(sw, "fgClr");
3226
            if (this.bgClr != null)
3227
                this.bgClr.Write(sw, "bgClr");
3228
            sw.Write(string.Format("</a:{0}>", nodeName));
3229
        }
3230

3231

3232
        public CT_PatternFillProperties()
3233
        {
3234
            //this.bgClrField = new CT_Color();
3235
            //this.fgClrField = new CT_Color();
3236
        }
3237

3238
        [XmlElement(Order = 0)]
3239
        public CT_Color fgClr
3240
        {
3241
            get
3242
            {
3243
                return this.fgClrField;
3244
            }
3245
            set
3246
            {
3247
                this.fgClrField = value;
3248
            }
3249
        }
3250

3251
        [XmlElement(Order = 1)]
3252
        public CT_Color bgClr
3253
        {
3254
            get
3255
            {
3256
                return this.bgClrField;
3257
            }
3258
            set
3259
            {
3260
                this.bgClrField = value;
3261
            }
3262
        }
3263

3264
        [XmlAttribute]
3265
        public ST_PresetPatternVal prst
3266
        {
3267
            get
3268
            {
3269
                return this.prstField;
3270
            }
3271
            set
3272
            {
3273
                this.prstField = value;
3274
            }
3275
        }
3276

3277
        [XmlIgnore]
3278
        public bool prstSpecified
3279
        {
3280
            get
3281
            {
3282
                return this.prstFieldSpecified;
3283
            }
3284
            set
3285
            {
3286
                this.prstFieldSpecified = value;
3287
            }
3288
        }
3289
    }
3290

3291
    [Serializable]
3292
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3293
    public enum ST_PresetPatternVal
3294
    {
3295

3296
        /// <remarks/>
3297
        pct5,
3298

3299
        /// <remarks/>
3300
        pct10,
3301

3302
        /// <remarks/>
3303
        pct20,
3304

3305
        /// <remarks/>
3306
        pct25,
3307

3308
        /// <remarks/>
3309
        pct30,
3310

3311
        /// <remarks/>
3312
        pct40,
3313

3314
        /// <remarks/>
3315
        pct50,
3316

3317
        /// <remarks/>
3318
        pct60,
3319

3320
        /// <remarks/>
3321
        pct70,
3322

3323
        /// <remarks/>
3324
        pct75,
3325

3326
        /// <remarks/>
3327
        pct80,
3328

3329
        /// <remarks/>
3330
        pct90,
3331

3332
        /// <remarks/>
3333
        horz,
3334

3335
        /// <remarks/>
3336
        vert,
3337

3338
        /// <remarks/>
3339
        ltHorz,
3340

3341
        /// <remarks/>
3342
        ltVert,
3343

3344
        /// <remarks/>
3345
        dkHorz,
3346

3347
        /// <remarks/>
3348
        dkVert,
3349

3350
        /// <remarks/>
3351
        narHorz,
3352

3353
        /// <remarks/>
3354
        narVert,
3355

3356
        /// <remarks/>
3357
        dashHorz,
3358

3359
        /// <remarks/>
3360
        dashVert,
3361

3362
        /// <remarks/>
3363
        cross,
3364

3365
        /// <remarks/>
3366
        dnDiag,
3367

3368
        /// <remarks/>
3369
        upDiag,
3370

3371
        /// <remarks/>
3372
        ltDnDiag,
3373

3374
        /// <remarks/>
3375
        ltUpDiag,
3376

3377
        /// <remarks/>
3378
        dkDnDiag,
3379

3380
        /// <remarks/>
3381
        dkUpDiag,
3382

3383
        /// <remarks/>
3384
        wdDnDiag,
3385

3386
        /// <remarks/>
3387
        wdUpDiag,
3388

3389
        /// <remarks/>
3390
        dashDnDiag,
3391

3392
        /// <remarks/>
3393
        dashUpDiag,
3394

3395
        /// <remarks/>
3396
        diagCross,
3397

3398
        /// <remarks/>
3399
        smCheck,
3400

3401
        /// <remarks/>
3402
        lgCheck,
3403

3404
        /// <remarks/>
3405
        smGrid,
3406

3407
        /// <remarks/>
3408
        lgGrid,
3409

3410
        /// <remarks/>
3411
        dotGrid,
3412

3413
        /// <remarks/>
3414
        smConfetti,
3415

3416
        /// <remarks/>
3417
        lgConfetti,
3418

3419
        /// <remarks/>
3420
        horzBrick,
3421

3422
        /// <remarks/>
3423
        diagBrick,
3424

3425
        /// <remarks/>
3426
        solidDmnd,
3427

3428
        /// <remarks/>
3429
        openDmnd,
3430

3431
        /// <remarks/>
3432
        dotDmnd,
3433

3434
        /// <remarks/>
3435
        plaid,
3436

3437
        /// <remarks/>
3438
        sphere,
3439

3440
        /// <remarks/>
3441
        weave,
3442

3443
        /// <remarks/>
3444
        divot,
3445

3446
        /// <remarks/>
3447
        shingle,
3448

3449
        /// <remarks/>
3450
        wave,
3451

3452
        /// <remarks/>
3453
        trellis,
3454

3455
        /// <remarks/>
3456
        zigZag,
3457
    }
3458

3459

3460
    [Serializable]
3461
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3462
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3463
    public class CT_GroupFillProperties
3464
    {
3465
    }
3466

3467
    [Serializable]
3468
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3469
    public enum ST_BlendMode
3470
    {
3471

3472
        /// <remarks/>
3473
        over,
3474

3475
        /// <remarks/>
3476
        mult,
3477

3478
        /// <remarks/>
3479
        screen,
3480

3481
        /// <remarks/>
3482
        darken,
3483

3484
        /// <remarks/>
3485
        lighten,
3486
    }
3487

3488
    [Serializable]
3489
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3490
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3491
    public class CT_FillEffect
3492
    {
3493

3494
        private CT_NoFillProperties noFillField;
3495

3496
        private CT_SolidColorFillProperties solidFillField;
3497

3498
        private CT_GradientFillProperties gradFillField;
3499

3500
        private CT_BlipFillProperties blipFillField;
3501

3502
        private CT_PatternFillProperties pattFillField;
3503

3504
        private CT_GroupFillProperties grpFillField;
3505

3506
        public CT_FillEffect()
3507
        {
3508
            //this.grpFillField = new CT_GroupFillProperties();
3509
            //this.pattFillField = new CT_PatternFillProperties();
3510
            //this.blipFillField = new CT_BlipFillProperties();
3511
            //this.gradFillField = new CT_GradientFillProperties();
3512
            //this.solidFillField = new CT_SolidColorFillProperties();
3513
            //this.noFillField = new CT_NoFillProperties();
3514
        }
3515

3516
        [XmlElement(Order = 0)]
3517
        public CT_NoFillProperties noFill
3518
        {
3519
            get
3520
            {
3521
                return this.noFillField;
3522
            }
3523
            set
3524
            {
3525
                this.noFillField = value;
3526
            }
3527
        }
3528

3529
        [XmlElement(Order = 1)]
3530
        public CT_SolidColorFillProperties solidFill
3531
        {
3532
            get
3533
            {
3534
                return this.solidFillField;
3535
            }
3536
            set
3537
            {
3538
                this.solidFillField = value;
3539
            }
3540
        }
3541

3542
        [XmlElement(Order = 2)]
3543
        public CT_GradientFillProperties gradFill
3544
        {
3545
            get
3546
            {
3547
                return this.gradFillField;
3548
            }
3549
            set
3550
            {
3551
                this.gradFillField = value;
3552
            }
3553
        }
3554

3555
        [XmlElement(Order = 3)]
3556
        public CT_BlipFillProperties blipFill
3557
        {
3558
            get
3559
            {
3560
                return this.blipFillField;
3561
            }
3562
            set
3563
            {
3564
                this.blipFillField = value;
3565
            }
3566
        }
3567

3568
        [XmlElement(Order = 4)]
3569
        public CT_PatternFillProperties pattFill
3570
        {
3571
            get
3572
            {
3573
                return this.pattFillField;
3574
            }
3575
            set
3576
            {
3577
                this.pattFillField = value;
3578
            }
3579
        }
3580

3581
        [XmlElement(Order = 5)]
3582
        public CT_GroupFillProperties grpFill
3583
        {
3584
            get
3585
            {
3586
                return this.grpFillField;
3587
            }
3588
            set
3589
            {
3590
                this.grpFillField = value;
3591
            }
3592
        }
3593
    }
3594

3595
    [Serializable]
3596
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3597
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3598
    public class CT_DuotoneEffect
3599
    {
3600
        private List<object> itemsField;
3601

3602
        public CT_DuotoneEffect()
3603
        {
3604
            this.itemsField = new List<object>();
3605
        }
3606

3607
        [XmlElement("hslClr", typeof(CT_HslColor), Order = 0)]
3608
        [XmlElement("prstClr", typeof(CT_PresetColor), Order = 0)]
3609
        [XmlElement("schemeClr", typeof(CT_SchemeColor), Order = 0)]
3610
        [XmlElement("scrgbClr", typeof(CT_ScRgbColor), Order = 0)]
3611
        [XmlElement("srgbClr", typeof(CT_SRgbColor), Order = 0)]
3612
        [XmlElement("sysClr", typeof(CT_SystemColor), Order = 0)]
3613
        public List<object> Items
3614
        {
3615
            get
3616
            {
3617
                return this.itemsField;
3618
            }
3619
            set
3620
            {
3621
                this.itemsField = value;
3622
            }
3623
        }
3624

3625
        #region another way
3626
        //private CT_ScRgbColor[] scrgbClrField;
3627

3628
        //private CT_SRgbColor[] srgbClrField;
3629

3630
        //private CT_HslColor[] hslClrField;
3631

3632
        //private CT_SystemColor[] sysClrField;
3633

3634
        //private CT_SchemeColor[] schemeClrField;
3635

3636
        //private CT_PresetColor[] prstClrField;
3637

3638

3639
        //[XmlElement("scrgbClr")]
3640
        //public CT_ScRgbColor[] scrgbClr
3641
        //{
3642
        //    get
3643
        //    {
3644
        //        return this.scrgbClrField;
3645
        //    }
3646
        //    set
3647
        //    {
3648
        //        this.scrgbClrField = value;
3649
        //    }
3650
        //}
3651

3652

3653
        //[XmlElement("srgbClr")]
3654
        //public CT_SRgbColor[] srgbClr
3655
        //{
3656
        //    get
3657
        //    {
3658
        //        return this.srgbClrField;
3659
        //    }
3660
        //    set
3661
        //    {
3662
        //        this.srgbClrField = value;
3663
        //    }
3664
        //}
3665

3666

3667
        //[XmlElement("hslClr")]
3668
        //public CT_HslColor[] hslClr
3669
        //{
3670
        //    get
3671
        //    {
3672
        //        return this.hslClrField;
3673
        //    }
3674
        //    set
3675
        //    {
3676
        //        this.hslClrField = value;
3677
        //    }
3678
        //}
3679

3680

3681
        //[XmlElement("sysClr")]
3682
        //public CT_SystemColor[] sysClr
3683
        //{
3684
        //    get
3685
        //    {
3686
        //        return this.sysClrField;
3687
        //    }
3688
        //    set
3689
        //    {
3690
        //        this.sysClrField = value;
3691
        //    }
3692
        //}
3693

3694

3695
        //[XmlElement("schemeClr")]
3696
        //public CT_SchemeColor[] schemeClr
3697
        //{
3698
        //    get
3699
        //    {
3700
        //        return this.schemeClrField;
3701
        //    }
3702
        //    set
3703
        //    {
3704
        //        this.schemeClrField = value;
3705
        //    }
3706
        //}
3707

3708

3709
        //[XmlElement("prstClr")]
3710
        //public CT_PresetColor[] prstClr
3711
        //{
3712
        //    get
3713
        //    {
3714
        //        return this.prstClrField;
3715
        //    }
3716
        //    set
3717
        //    {
3718
        //        this.prstClrField = value;
3719
        //    }
3720
        //}
3721

3722
        #endregion
3723
    }
3724

3725
    [Serializable]
3726
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3727
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3728
    public class CT_ColorReplaceEffect
3729
    {
3730

3731
        private CT_ScRgbColor scrgbClrField;
3732

3733
        private CT_SRgbColor srgbClrField;
3734

3735
        private CT_HslColor hslClrField;
3736

3737
        private CT_SystemColor sysClrField;
3738

3739
        private CT_SchemeColor schemeClrField;
3740

3741
        private CT_PresetColor prstClrField;
3742

3743
        public CT_ColorReplaceEffect()
3744
        {
3745
            //this.prstClrField = new CT_PresetColor();
3746
            //this.schemeClrField = new CT_SchemeColor();
3747
            //this.sysClrField = new CT_SystemColor();
3748
            //this.hslClrField = new CT_HslColor();
3749
            //this.srgbClrField = new CT_SRgbColor();
3750
            //this.scrgbClrField = new CT_ScRgbColor();
3751
        }
3752

3753
        [XmlElement(Order = 0)]
3754
        public CT_ScRgbColor scrgbClr
3755
        {
3756
            get
3757
            {
3758
                return this.scrgbClrField;
3759
            }
3760
            set
3761
            {
3762
                this.scrgbClrField = value;
3763
            }
3764
        }
3765

3766
        [XmlElement(Order = 1)]
3767
        public CT_SRgbColor srgbClr
3768
        {
3769
            get
3770
            {
3771
                return this.srgbClrField;
3772
            }
3773
            set
3774
            {
3775
                this.srgbClrField = value;
3776
            }
3777
        }
3778

3779
        [XmlElement(Order = 2)]
3780
        public CT_HslColor hslClr
3781
        {
3782
            get
3783
            {
3784
                return this.hslClrField;
3785
            }
3786
            set
3787
            {
3788
                this.hslClrField = value;
3789
            }
3790
        }
3791

3792
        [XmlElement(Order = 3)]
3793
        public CT_SystemColor sysClr
3794
        {
3795
            get
3796
            {
3797
                return this.sysClrField;
3798
            }
3799
            set
3800
            {
3801
                this.sysClrField = value;
3802
            }
3803
        }
3804

3805
        [XmlElement(Order = 4)]
3806
        public CT_SchemeColor schemeClr
3807
        {
3808
            get
3809
            {
3810
                return this.schemeClrField;
3811
            }
3812
            set
3813
            {
3814
                this.schemeClrField = value;
3815
            }
3816
        }
3817

3818
        [XmlElement(Order = 5)]
3819
        public CT_PresetColor prstClr
3820
        {
3821
            get
3822
            {
3823
                return this.prstClrField;
3824
            }
3825
            set
3826
            {
3827
                this.prstClrField = value;
3828
            }
3829
        }
3830
    }
3831

3832

3833
    [Serializable]
3834
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3835
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3836
    public class CT_ColorChangeEffect
3837
    {
3838

3839
        private CT_Color clrFromField;
3840

3841
        private CT_Color clrToField;
3842

3843
        private bool useAField;
3844

3845
        public CT_ColorChangeEffect()
3846
        {
3847
            this.clrToField = new CT_Color();
3848
            this.clrFromField = new CT_Color();
3849
            this.useAField = true;
3850
        }
3851

3852
        [XmlElement(Order = 0)]
3853
        public CT_Color clrFrom
3854
        {
3855
            get
3856
            {
3857
                return this.clrFromField;
3858
            }
3859
            set
3860
            {
3861
                this.clrFromField = value;
3862
            }
3863
        }
3864

3865
        [XmlElement(Order = 1)]
3866
        public CT_Color clrTo
3867
        {
3868
            get
3869
            {
3870
                return this.clrToField;
3871
            }
3872
            set
3873
            {
3874
                this.clrToField = value;
3875
            }
3876
        }
3877

3878
        [XmlAttribute]
3879
        [DefaultValue(true)]
3880
        public bool useA
3881
        {
3882
            get
3883
            {
3884
                return this.useAField;
3885
            }
3886
            set
3887
            {
3888
                this.useAField = value;
3889
            }
3890
        }
3891
    }
3892

3893

3894
    [Serializable]
3895
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3896
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3897
    public class CT_BlurEffect
3898
    {
3899
        public static CT_BlurEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3900
        {
3901
            if (node == null)
3902
                return null;
3903
            CT_BlurEffect ctObj = new CT_BlurEffect();
3904
            ctObj.rad = XmlHelper.ReadLong(node.Attributes["rad"]);
3905
            ctObj.grow = XmlHelper.ReadBool(node.Attributes["grow"]);
3906
            return ctObj;
3907
        }
3908

3909

3910

3911
        internal void Write(StreamWriter sw, string nodeName)
3912
        {
3913
            sw.Write(string.Format("<a:{0}", nodeName));
3914
            XmlHelper.WriteAttribute(sw, "rad", this.rad);
3915
            XmlHelper.WriteAttribute(sw, "grow", this.grow);
3916
            sw.Write(">");
3917
            sw.Write(string.Format("</a:{0}>", nodeName));
3918
        }
3919
        private long radField;
3920

3921
        private bool growField;
3922

3923
        public CT_BlurEffect()
3924
        {
3925
            this.radField = ((long)(0));
3926
            this.growField = true;
3927
        }
3928

3929
        [XmlAttribute]
3930
        [DefaultValue(typeof(long), "0")]
3931
        public long rad
3932
        {
3933
            get
3934
            {
3935
                return this.radField;
3936
            }
3937
            set
3938
            {
3939
                this.radField = value;
3940
            }
3941
        }
3942

3943
        [XmlAttribute]
3944
        [DefaultValue(true)]
3945
        public bool grow
3946
        {
3947
            get
3948
            {
3949
                return this.growField;
3950
            }
3951
            set
3952
            {
3953
                this.growField = value;
3954
            }
3955
        }
3956
    }
3957

3958

3959
    [Serializable]
3960
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
3961
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
3962
    public class CT_BlendEffect
3963
    {
3964

3965
        private CT_EffectContainer contField;
3966

3967
        private ST_BlendMode blendField;
3968

3969
        public CT_BlendEffect()
3970
        {
3971
            this.contField = new CT_EffectContainer();
3972
        }
3973

3974
        [XmlElement(Order = 0)]
3975
        public CT_EffectContainer cont
3976
        {
3977
            get
3978
            {
3979
                return this.contField;
3980
            }
3981
            set
3982
            {
3983
                this.contField = value;
3984
            }
3985
        }
3986

3987
        [XmlAttribute]
3988
        public ST_BlendMode blend
3989
        {
3990
            get
3991
            {
3992
                return this.blendField;
3993
            }
3994
            set
3995
            {
3996
                this.blendField = value;
3997
            }
3998
        }
3999
    }
4000

4001

4002
    [Serializable]
4003
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4004
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4005
    public class CT_EffectContainer
4006
    {
4007

4008
        private List<object> itemsField;
4009

4010
        private ST_EffectContainerType typeField;
4011

4012
        private string nameField;
4013

4014
        public CT_EffectContainer()
4015
        {
4016
            this.itemsField = new List<object>();
4017
            this.typeField = ST_EffectContainerType.sib;
4018
        }
4019
        public static CT_EffectContainer Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4020
        {
4021
            if (node == null)
4022
                return null;
4023
            CT_EffectContainer ctObj = new CT_EffectContainer();
4024
            if (node.Attributes["type"] != null)
4025
                ctObj.type = (ST_EffectContainerType)Enum.Parse(typeof(ST_EffectContainerType), node.Attributes["type"].Value);
4026
            ctObj.name = XmlHelper.ReadString(node.Attributes["name"]);
4027
            return ctObj;
4028
        }
4029

4030

4031

4032
        internal void Write(StreamWriter sw, string nodeName)
4033
        {
4034
            sw.Write(string.Format("<a:{0}", nodeName));
4035
            XmlHelper.WriteAttribute(sw, "type", this.type.ToString());
4036
            XmlHelper.WriteAttribute(sw, "name", this.name);
4037
            sw.Write(">");
4038
            sw.Write(string.Format("</a:{0}>", nodeName));
4039
        }
4040

4041
        [XmlElement("alphaBiLevel", typeof(CT_AlphaBiLevelEffect), Order = 0)]
4042
        [XmlElement("alphaCeiling", typeof(CT_AlphaCeilingEffect), Order = 0)]
4043
        [XmlElement("alphaFloor", typeof(CT_AlphaFloorEffect), Order = 0)]
4044
        [XmlElement("alphaInv", typeof(CT_AlphaInverseEffect), Order = 0)]
4045
        [XmlElement("alphaMod", typeof(CT_AlphaModulateEffect), Order = 0)]
4046
        [XmlElement("alphaModFix", typeof(CT_AlphaModulateFixedEffect), Order = 0)]
4047
        [XmlElement("alphaOutset", typeof(CT_AlphaOutsetEffect), Order = 0)]
4048
        [XmlElement("alphaRepl", typeof(CT_AlphaReplaceEffect), Order = 0)]
4049
        [XmlElement("biLevel", typeof(CT_BiLevelEffect), Order = 0)]
4050
        [XmlElement("blend", typeof(CT_BlendEffect), Order = 0)]
4051
        [XmlElement("blur", typeof(CT_BlurEffect), Order = 0)]
4052
        [XmlElement("clrChange", typeof(CT_ColorChangeEffect), Order = 0)]
4053
        [XmlElement("clrRepl", typeof(CT_ColorReplaceEffect), Order = 0)]
4054
        [XmlElement("cont", typeof(CT_EffectContainer), Order = 0)]
4055
        [XmlElement("duotone", typeof(CT_DuotoneEffect), Order = 0)]
4056
        [XmlElement("effect", typeof(CT_EffectReference), Order = 0)]
4057
        [XmlElement("fill", typeof(CT_FillEffect), Order = 0)]
4058
        [XmlElement("fillOverlay", typeof(CT_FillOverlayEffect), Order = 0)]
4059
        [XmlElement("glow", typeof(CT_GlowEffect), Order = 0)]
4060
        [XmlElement("grayscl", typeof(CT_GrayscaleEffect), Order = 0)]
4061
        [XmlElement("hsl", typeof(CT_HSLEffect), Order = 0)]
4062
        [XmlElement("innerShdw", typeof(CT_InnerShadowEffect), Order = 0)]
4063
        [XmlElement("lum", typeof(CT_LuminanceEffect), Order = 0)]
4064
        [XmlElement("outerShdw", typeof(CT_OuterShadowEffect), Order = 0)]
4065
        [XmlElement("prstShdw", typeof(CT_PresetShadowEffect), Order = 0)]
4066
        [XmlElement("reflection", typeof(CT_ReflectionEffect), Order = 0)]
4067
        [XmlElement("relOff", typeof(CT_RelativeOffsetEffect), Order = 0)]
4068
        [XmlElement("softEdge", typeof(CT_SoftEdgesEffect), Order = 0)]
4069
        [XmlElement("tint", typeof(CT_TintEffect), Order = 0)]
4070
        [XmlElement("xfrm", typeof(CT_TransformEffect), Order = 0)]
4071
        public List<object> Items
4072
        {
4073
            get
4074
            {
4075
                return this.itemsField;
4076
            }
4077
            set
4078
            {
4079
                this.itemsField = value;
4080
            }
4081
        }
4082

4083
        [XmlAttribute]
4084
        [DefaultValue(ST_EffectContainerType.sib)]
4085
        public ST_EffectContainerType type
4086
        {
4087
            get
4088
            {
4089
                return this.typeField;
4090
            }
4091
            set
4092
            {
4093
                this.typeField = value;
4094
            }
4095
        }
4096

4097
        [XmlAttribute(DataType = "token")]
4098
        public string name
4099
        {
4100
            get
4101
            {
4102
                return this.nameField;
4103
            }
4104
            set
4105
            {
4106
                this.nameField = value;
4107
            }
4108
        }
4109
    }
4110

4111

4112
    [Serializable]
4113
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4114
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4115
    public class CT_AlphaCeilingEffect
4116
    {
4117
    }
4118

4119

4120
    [Serializable]
4121
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4122
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4123
    public class CT_AlphaFloorEffect
4124
    {
4125
    }
4126

4127

4128
    [Serializable]
4129
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4130
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4131
    public class CT_AlphaInverseEffect
4132
    {
4133

4134
        private CT_ScRgbColor scrgbClrField;
4135

4136
        private CT_SRgbColor srgbClrField;
4137

4138
        private CT_HslColor hslClrField;
4139

4140
        private CT_SystemColor sysClrField;
4141

4142
        private CT_SchemeColor schemeClrField;
4143

4144
        private CT_PresetColor prstClrField;
4145

4146
        public CT_AlphaInverseEffect()
4147
        {
4148
            //this.prstClrField = new CT_PresetColor();
4149
            //this.schemeClrField = new CT_SchemeColor();
4150
            //this.sysClrField = new CT_SystemColor();
4151
            //this.hslClrField = new CT_HslColor();
4152
            //this.srgbClrField = new CT_SRgbColor();
4153
            //this.scrgbClrField = new CT_ScRgbColor();
4154
        }
4155

4156
        [XmlElement(Order = 0)]
4157
        public CT_ScRgbColor scrgbClr
4158
        {
4159
            get
4160
            {
4161
                return this.scrgbClrField;
4162
            }
4163
            set
4164
            {
4165
                this.scrgbClrField = value;
4166
            }
4167
        }
4168

4169
        [XmlElement(Order = 1)]
4170
        public CT_SRgbColor srgbClr
4171
        {
4172
            get
4173
            {
4174
                return this.srgbClrField;
4175
            }
4176
            set
4177
            {
4178
                this.srgbClrField = value;
4179
            }
4180
        }
4181

4182
        [XmlElement(Order = 2)]
4183
        public CT_HslColor hslClr
4184
        {
4185
            get
4186
            {
4187
                return this.hslClrField;
4188
            }
4189
            set
4190
            {
4191
                this.hslClrField = value;
4192
            }
4193
        }
4194

4195
        [XmlElement(Order = 3)]
4196
        public CT_SystemColor sysClr
4197
        {
4198
            get
4199
            {
4200
                return this.sysClrField;
4201
            }
4202
            set
4203
            {
4204
                this.sysClrField = value;
4205
            }
4206
        }
4207

4208
        [XmlElement(Order = 4)]
4209
        public CT_SchemeColor schemeClr
4210
        {
4211
            get
4212
            {
4213
                return this.schemeClrField;
4214
            }
4215
            set
4216
            {
4217
                this.schemeClrField = value;
4218
            }
4219
        }
4220

4221
        [XmlElement(Order = 5)]
4222
        public CT_PresetColor prstClr
4223
        {
4224
            get
4225
            {
4226
                return this.prstClrField;
4227
            }
4228
            set
4229
            {
4230
                this.prstClrField = value;
4231
            }
4232
        }
4233
    }
4234

4235
    [Serializable]
4236
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4237
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4238
    public class CT_AlphaModulateEffect
4239
    {
4240

4241
        private CT_EffectContainer contField;
4242

4243
        public CT_AlphaModulateEffect()
4244
        {
4245
            this.contField = new CT_EffectContainer();
4246
        }
4247

4248
        [XmlElement(Order = 0)]
4249
        public CT_EffectContainer cont
4250
        {
4251
            get
4252
            {
4253
                return this.contField;
4254
            }
4255
            set
4256
            {
4257
                this.contField = value;
4258
            }
4259
        }
4260
    }
4261

4262
    [Serializable]
4263
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4264
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4265
    public class CT_AlphaModulateFixedEffect
4266
    {
4267

4268
        private int amtField;
4269

4270
        public CT_AlphaModulateFixedEffect()
4271
        {
4272
            this.amtField = 100000;
4273
        }
4274

4275
        [XmlAttribute]
4276
        [DefaultValue(100000)]
4277
        public int amt
4278
        {
4279
            get
4280
            {
4281
                return this.amtField;
4282
            }
4283
            set
4284
            {
4285
                this.amtField = value;
4286
            }
4287
        }
4288
    }
4289

4290

4291
    [Serializable]
4292
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4293
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4294
    public class CT_AlphaOutsetEffect
4295
    {
4296

4297
        private long radField;
4298

4299
        public CT_AlphaOutsetEffect()
4300
        {
4301
            this.radField = ((long)(0));
4302
        }
4303

4304
        [XmlAttribute]
4305
        [DefaultValue(typeof(long), "0")]
4306
        public long rad
4307
        {
4308
            get
4309
            {
4310
                return this.radField;
4311
            }
4312
            set
4313
            {
4314
                this.radField = value;
4315
            }
4316
        }
4317
    }
4318

4319

4320
    [Serializable]
4321
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4322
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4323
    public class CT_AlphaReplaceEffect
4324
    {
4325

4326
        private int aField;
4327

4328
        [XmlAttribute]
4329
        public int a
4330
        {
4331
            get
4332
            {
4333
                return this.aField;
4334
            }
4335
            set
4336
            {
4337
                this.aField = value;
4338
            }
4339
        }
4340
    }
4341

4342

4343
    [Serializable]
4344
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4345
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4346
    public class CT_BiLevelEffect
4347
    {
4348

4349
        private int threshField;
4350

4351
        [XmlAttribute]
4352
        public int thresh
4353
        {
4354
            get
4355
            {
4356
                return this.threshField;
4357
            }
4358
            set
4359
            {
4360
                this.threshField = value;
4361
            }
4362
        }
4363
    }
4364

4365
    [Serializable]
4366
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4367
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4368
    public class CT_EffectReference
4369
    {
4370

4371
        private string refField;
4372

4373
        [XmlAttribute(DataType = "token")]
4374
        public string @ref
4375
        {
4376
            get
4377
            {
4378
                return this.refField;
4379
            }
4380
            set
4381
            {
4382
                this.refField = value;
4383
            }
4384
        }
4385
    }
4386

4387

4388
    [Serializable]
4389
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4390
    public enum ST_EffectContainerType
4391
    {
4392

4393
        /// <remarks/>
4394
        sib,
4395

4396
        /// <remarks/>
4397
        tree,
4398
    }
4399

4400

4401
    [Serializable]
4402
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4403
    public enum ST_BlipCompression
4404
    {
4405

4406
        /// <remarks/>
4407
        email,
4408

4409
        /// <remarks/>
4410
        screen,
4411

4412
        /// <remarks/>
4413
        print,
4414

4415
        /// <remarks/>
4416
        hqprint,
4417

4418
        /// <remarks/>
4419
        none,
4420
    }
4421

4422

4423
    [Serializable]
4424
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4425
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4426
    public class CT_GradientStopList
4427
    {
4428
        public static CT_GradientStopList Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4429
        {
4430
            if (node == null)
4431
                return null;
4432
            CT_GradientStopList ctObj = new CT_GradientStopList();
4433
            ctObj.gs = new List<CT_GradientStop>();
4434
            foreach (XmlNode childNode in node.ChildNodes)
4435
            {
4436
                if (childNode.LocalName == "gs")
4437
                    ctObj.gs.Add(CT_GradientStop.Parse(childNode, namespaceManager));
4438
            }
4439
            return ctObj;
4440
        }
4441

4442

4443

4444
        internal void Write(StreamWriter sw, string nodeName)
4445
        {
4446
            sw.Write(string.Format("<a:{0}", nodeName));
4447
            sw.Write(">");
4448
            if (this.gs != null)
4449
            {
4450
                foreach (CT_GradientStop x in this.gs)
4451
                {
4452
                    x.Write(sw, "gs");
4453
                }
4454
            }
4455
            sw.Write(string.Format("</a:{0}>", nodeName));
4456
        }
4457

4458
        private List<CT_GradientStop> gsField;
4459

4460
        public CT_GradientStopList()
4461
        {
4462
            this.gsField = new List<CT_GradientStop>();
4463
        }
4464

4465
        [XmlElement("gs", Order = 0)]
4466
        public List<CT_GradientStop> gs
4467
        {
4468
            get
4469
            {
4470
                return this.gsField;
4471
            }
4472
            set
4473
            {
4474
                this.gsField = value;
4475
            }
4476
        }
4477
    }
4478

4479
    [Serializable]
4480
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4481
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4482
    public class CT_FillProperties
4483
    {
4484

4485
        private CT_NoFillProperties noFillField;
4486

4487
        private CT_SolidColorFillProperties solidFillField;
4488

4489
        private CT_GradientFillProperties gradFillField;
4490

4491
        private CT_BlipFillProperties blipFillField;
4492

4493
        private CT_PatternFillProperties pattFillField;
4494

4495
        private CT_GroupFillProperties grpFillField;
4496

4497
        public CT_FillProperties()
4498
        {
4499
            //this.grpFillField = new CT_GroupFillProperties();
4500
            //this.pattFillField = new CT_PatternFillProperties();
4501
            //this.blipFillField = new CT_BlipFillProperties();
4502
            //this.gradFillField = new CT_GradientFillProperties();
4503
            //this.solidFillField = new CT_SolidColorFillProperties();
4504
            //this.noFillField = new CT_NoFillProperties();
4505
        }
4506

4507
        [XmlElement(Order = 0)]
4508
        public CT_NoFillProperties noFill
4509
        {
4510
            get
4511
            {
4512
                return this.noFillField;
4513
            }
4514
            set
4515
            {
4516
                this.noFillField = value;
4517
            }
4518
        }
4519

4520
        [XmlElement(Order = 1)]
4521
        public CT_SolidColorFillProperties solidFill
4522
        {
4523
            get
4524
            {
4525
                return this.solidFillField;
4526
            }
4527
            set
4528
            {
4529
                this.solidFillField = value;
4530
            }
4531
        }
4532

4533
        [XmlElement(Order = 2)]
4534
        public CT_GradientFillProperties gradFill
4535
        {
4536
            get
4537
            {
4538
                return this.gradFillField;
4539
            }
4540
            set
4541
            {
4542
                this.gradFillField = value;
4543
            }
4544
        }
4545

4546
        [XmlElement(Order = 3)]
4547
        public CT_BlipFillProperties blipFill
4548
        {
4549
            get
4550
            {
4551
                return this.blipFillField;
4552
            }
4553
            set
4554
            {
4555
                this.blipFillField = value;
4556
            }
4557
        }
4558

4559
        [XmlElement(Order = 4)]
4560
        public CT_PatternFillProperties pattFill
4561
        {
4562
            get
4563
            {
4564
                return this.pattFillField;
4565
            }
4566
            set
4567
            {
4568
                this.pattFillField = value;
4569
            }
4570
        }
4571

4572
        [XmlElement(Order = 5)]
4573
        public CT_GroupFillProperties grpFill
4574
        {
4575
            get
4576
            {
4577
                return this.grpFillField;
4578
            }
4579
            set
4580
            {
4581
                this.grpFillField = value;
4582
            }
4583
        }
4584
    }
4585

4586
    [Serializable]
4587
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4588
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4589
    public class CT_EffectList
4590
    {
4591

4592
        private CT_BlurEffect blurField;
4593

4594
        private CT_FillOverlayEffect fillOverlayField;
4595

4596
        private CT_GlowEffect glowField;
4597

4598
        private CT_InnerShadowEffect innerShdwField;
4599

4600
        private CT_OuterShadowEffect outerShdwField;
4601

4602
        private CT_PresetShadowEffect prstShdwField;
4603

4604
        private CT_ReflectionEffect reflectionField;
4605

4606
        private CT_SoftEdgesEffect softEdgeField;
4607
        public static CT_EffectList Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4608
        {
4609
            if (node == null)
4610
                return null;
4611
            CT_EffectList ctObj = new CT_EffectList();
4612
            foreach (XmlNode childNode in node.ChildNodes)
4613
            {
4614
                if (childNode.LocalName == "blur")
4615
                    ctObj.blur = CT_BlurEffect.Parse(childNode, namespaceManager);
4616
                else if (childNode.LocalName == "fillOverlay")
4617
                    ctObj.fillOverlay = CT_FillOverlayEffect.Parse(childNode, namespaceManager);
4618
                else if (childNode.LocalName == "glow")
4619
                    ctObj.glow = CT_GlowEffect.Parse(childNode, namespaceManager);
4620
                else if (childNode.LocalName == "innerShdw")
4621
                    ctObj.innerShdw = CT_InnerShadowEffect.Parse(childNode, namespaceManager);
4622
                else if (childNode.LocalName == "outerShdw")
4623
                    ctObj.outerShdw = CT_OuterShadowEffect.Parse(childNode, namespaceManager);
4624
                else if (childNode.LocalName == "prstShdw")
4625
                    ctObj.prstShdw = CT_PresetShadowEffect.Parse(childNode, namespaceManager);
4626
                else if (childNode.LocalName == "reflection")
4627
                    ctObj.reflection = CT_ReflectionEffect.Parse(childNode, namespaceManager);
4628
                else if (childNode.LocalName == "softEdge")
4629
                    ctObj.softEdge = CT_SoftEdgesEffect.Parse(childNode, namespaceManager);
4630
            }
4631
            return ctObj;
4632
        }
4633

4634

4635

4636
        internal void Write(StreamWriter sw, string nodeName)
4637
        {
4638
            sw.Write(string.Format("<a:{0}", nodeName));
4639
            sw.Write(">");
4640
            if (this.blur != null)
4641
                this.blur.Write(sw, "blur");
4642
            if (this.fillOverlay != null)
4643
                this.fillOverlay.Write(sw, "fillOverlay");
4644
            if (this.glow != null)
4645
                this.glow.Write(sw, "glow");
4646
            if (this.innerShdw != null)
4647
                this.innerShdw.Write(sw, "innerShdw");
4648
            if (this.outerShdw != null)
4649
                this.outerShdw.Write(sw, "outerShdw");
4650
            if (this.prstShdw != null)
4651
                this.prstShdw.Write(sw, "prstShdw");
4652
            if (this.reflection != null)
4653
                this.reflection.Write(sw, "reflection");
4654
            if (this.softEdge != null)
4655
                this.softEdge.Write(sw, "softEdge");
4656
            sw.Write(string.Format("</a:{0}>", nodeName));
4657
        }
4658

4659
        public CT_EffectList()
4660
        {
4661
            //this.softEdgeField = new CT_SoftEdgesEffect();
4662
            //this.reflectionField = new CT_ReflectionEffect();
4663
            //this.prstShdwField = new CT_PresetShadowEffect();
4664
            //this.outerShdwField = new CT_OuterShadowEffect();
4665
            //this.innerShdwField = new CT_InnerShadowEffect();
4666
            //this.glowField = new CT_GlowEffect();
4667
            //this.fillOverlayField = new CT_FillOverlayEffect();
4668
            //this.blurField = new CT_BlurEffect();
4669
        }
4670

4671
        [XmlElement(Order = 0)]
4672
        public CT_BlurEffect blur
4673
        {
4674
            get
4675
            {
4676
                return this.blurField;
4677
            }
4678
            set
4679
            {
4680
                this.blurField = value;
4681
            }
4682
        }
4683

4684
        [XmlElement(Order = 1)]
4685
        public CT_FillOverlayEffect fillOverlay
4686
        {
4687
            get
4688
            {
4689
                return this.fillOverlayField;
4690
            }
4691
            set
4692
            {
4693
                this.fillOverlayField = value;
4694
            }
4695
        }
4696

4697
        [XmlElement(Order = 2)]
4698
        public CT_GlowEffect glow
4699
        {
4700
            get
4701
            {
4702
                return this.glowField;
4703
            }
4704
            set
4705
            {
4706
                this.glowField = value;
4707
            }
4708
        }
4709

4710
        [XmlElement(Order = 3)]
4711
        public CT_InnerShadowEffect innerShdw
4712
        {
4713
            get
4714
            {
4715
                return this.innerShdwField;
4716
            }
4717
            set
4718
            {
4719
                this.innerShdwField = value;
4720
            }
4721
        }
4722

4723
        [XmlElement(Order = 4)]
4724
        public CT_OuterShadowEffect outerShdw
4725
        {
4726
            get
4727
            {
4728
                return this.outerShdwField;
4729
            }
4730
            set
4731
            {
4732
                this.outerShdwField = value;
4733
            }
4734
        }
4735

4736
        [XmlElement(Order = 5)]
4737
        public CT_PresetShadowEffect prstShdw
4738
        {
4739
            get
4740
            {
4741
                return this.prstShdwField;
4742
            }
4743
            set
4744
            {
4745
                this.prstShdwField = value;
4746
            }
4747
        }
4748

4749
        [XmlElement(Order = 6)]
4750
        public CT_ReflectionEffect reflection
4751
        {
4752
            get
4753
            {
4754
                return this.reflectionField;
4755
            }
4756
            set
4757
            {
4758
                this.reflectionField = value;
4759
            }
4760
        }
4761

4762
        [XmlElement(Order = 7)]
4763
        public CT_SoftEdgesEffect softEdge
4764
        {
4765
            get
4766
            {
4767
                return this.softEdgeField;
4768
            }
4769
            set
4770
            {
4771
                this.softEdgeField = value;
4772
            }
4773
        }
4774
    }
4775

4776

4777
    [Serializable]
4778
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
4779
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
4780
    public class CT_EffectProperties
4781
    {
4782

4783
        private CT_EffectList effectLstField;
4784

4785
        private CT_EffectContainer effectDagField;
4786

4787
        public CT_EffectProperties()
4788
        {
4789
            //this.effectDagField = new CT_EffectContainer();
4790
            //this.effectLstField = new CT_EffectList();
4791
        }
4792

4793
        [XmlElement(Order = 0)]
4794
        public CT_EffectList effectLst
4795
        {
4796
            get
4797
            {
4798
                return this.effectLstField;
4799
            }
4800
            set
4801
            {
4802
                this.effectLstField = value;
4803
            }
4804
        }
4805

4806
        [XmlElement(Order = 1)]
4807
        public CT_EffectContainer effectDag
4808
        {
4809
            get
4810
            {
4811
                return this.effectDagField;
4812
            }
4813
            set
4814
            {
4815
                this.effectDagField = value;
4816
            }
4817
        }
4818
    }
4819
}
4820