npoi

1
using NPOI.OpenXml4Net.Util;
2
using NPOI.OpenXmlFormats.Dml.Spreadsheet;
3
using System;
4
using System.ComponentModel;
5
using System.Diagnostics;
6
using System.IO;
7
using System.Xml;
8
using System.Xml.Serialization;
9

10
namespace NPOI.OpenXmlFormats.Dml
11
{
12
    [Serializable]
13
    
14
    [System.ComponentModel.DesignerCategoryAttribute("code")]
15
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
16
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
17
    public class CT_ConnectorLocking
18
    {
19

20
        private CT_OfficeArtExtensionList extLstField;
21

22
        private bool noGrpField;
23

24
        private bool noSelectField;
25

26
        private bool noRotField;
27

28
        private bool noChangeAspectField;
29

30
        private bool noMoveField;
31

32
        private bool noResizeField;
33

34
        private bool noEditPointsField;
35

36
        private bool noAdjustHandlesField;
37

38
        private bool noChangeArrowheadsField;
39

40
        private bool noChangeShapeTypeField;
41
        public static CT_ConnectorLocking Parse(XmlNode node, XmlNamespaceManager namespaceManager)
42
        {
43
            if (node == null)
44
                return null;
45
            CT_ConnectorLocking ctObj = new CT_ConnectorLocking();
46
            ctObj.noGrp = XmlHelper.ReadBool(node.Attributes["noGrp"]);
47
            ctObj.noSelect = XmlHelper.ReadBool(node.Attributes["noSelect"]);
48
            ctObj.noRot = XmlHelper.ReadBool(node.Attributes["noRot"]);
49
            ctObj.noChangeAspect = XmlHelper.ReadBool(node.Attributes["noChangeAspect"]);
50
            ctObj.noMove = XmlHelper.ReadBool(node.Attributes["noMove"]);
51
            ctObj.noResize = XmlHelper.ReadBool(node.Attributes["noResize"]);
52
            ctObj.noEditPoints = XmlHelper.ReadBool(node.Attributes["noEditPoints"]);
53
            ctObj.noAdjustHandles = XmlHelper.ReadBool(node.Attributes["noAdjustHandles"]);
54
            ctObj.noChangeArrowheads = XmlHelper.ReadBool(node.Attributes["noChangeArrowheads"]);
55
            ctObj.noChangeShapeType = XmlHelper.ReadBool(node.Attributes["noChangeShapeType"]);
56
            foreach (XmlNode childNode in node.ChildNodes)
57
            {
58
                if (childNode.LocalName == "extLst")
59
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
60
            }
61
            return ctObj;
62
        }
63

64

65

66
        internal void Write(StreamWriter sw, string nodeName)
67
        {
68
            sw.Write(string.Format("<a:{0}", nodeName));
69
            XmlHelper.WriteAttribute(sw, "noGrp", this.noGrp);
70
            XmlHelper.WriteAttribute(sw, "noSelect", this.noSelect);
71
            XmlHelper.WriteAttribute(sw, "noRot", this.noRot);
72
            XmlHelper.WriteAttribute(sw, "noChangeAspect", this.noChangeAspect);
73
            XmlHelper.WriteAttribute(sw, "noMove", this.noMove);
74
            XmlHelper.WriteAttribute(sw, "noResize", this.noResize);
75
            XmlHelper.WriteAttribute(sw, "noEditPoints", this.noEditPoints);
76
            XmlHelper.WriteAttribute(sw, "noAdjustHandles", this.noAdjustHandles);
77
            XmlHelper.WriteAttribute(sw, "noChangeArrowheads", this.noChangeArrowheads);
78
            XmlHelper.WriteAttribute(sw, "noChangeShapeType", this.noChangeShapeType);
79
            sw.Write(">");
80
            if (this.extLst != null)
81
                this.extLst.Write(sw, "extLst");
82
            sw.Write(string.Format("</a:{0}>", nodeName));
83
        }
84

85
        public CT_ConnectorLocking()
86
        {
87
            //this.extLstField = new CT_OfficeArtExtensionList();
88
            this.noGrpField = false;
89
            this.noSelectField = false;
90
            this.noRotField = false;
91
            this.noChangeAspectField = false;
92
            this.noMoveField = false;
93
            this.noResizeField = false;
94
            this.noEditPointsField = false;
95
            this.noAdjustHandlesField = false;
96
            this.noChangeArrowheadsField = false;
97
            this.noChangeShapeTypeField = false;
98
        }
99

100
        [XmlElement(Order = 0)]
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]
114
        [DefaultValue(false)]
115
        public bool noGrp
116
        {
117
            get
118
            {
119
                return this.noGrpField;
120
            }
121
            set
122
            {
123
                this.noGrpField = value;
124
            }
125
        }
126

127
        [XmlAttribute]
128
        [DefaultValue(false)]
129
        public bool noSelect
130
        {
131
            get
132
            {
133
                return this.noSelectField;
134
            }
135
            set
136
            {
137
                this.noSelectField = value;
138
            }
139
        }
140

141
        [XmlAttribute]
142
        [DefaultValue(false)]
143
        public bool noRot
144
        {
145
            get
146
            {
147
                return this.noRotField;
148
            }
149
            set
150
            {
151
                this.noRotField = value;
152
            }
153
        }
154

155
        [XmlAttribute]
156
        [DefaultValue(false)]
157
        public bool noChangeAspect
158
        {
159
            get
160
            {
161
                return this.noChangeAspectField;
162
            }
163
            set
164
            {
165
                this.noChangeAspectField = value;
166
            }
167
        }
168

169
        [XmlAttribute]
170
        [DefaultValue(false)]
171
        public bool noMove
172
        {
173
            get
174
            {
175
                return this.noMoveField;
176
            }
177
            set
178
            {
179
                this.noMoveField = value;
180
            }
181
        }
182

183
        [XmlAttribute]
184
        [DefaultValue(false)]
185
        public bool noResize
186
        {
187
            get
188
            {
189
                return this.noResizeField;
190
            }
191
            set
192
            {
193
                this.noResizeField = value;
194
            }
195
        }
196

197
        [XmlAttribute]
198
        [DefaultValue(false)]
199
        public bool noEditPoints
200
        {
201
            get
202
            {
203
                return this.noEditPointsField;
204
            }
205
            set
206
            {
207
                this.noEditPointsField = value;
208
            }
209
        }
210

211
        [XmlAttribute]
212
        [DefaultValue(false)]
213
        public bool noAdjustHandles
214
        {
215
            get
216
            {
217
                return this.noAdjustHandlesField;
218
            }
219
            set
220
            {
221
                this.noAdjustHandlesField = value;
222
            }
223
        }
224

225
        [XmlAttribute]
226
        [DefaultValue(false)]
227
        public bool noChangeArrowheads
228
        {
229
            get
230
            {
231
                return this.noChangeArrowheadsField;
232
            }
233
            set
234
            {
235
                this.noChangeArrowheadsField = value;
236
            }
237
        }
238

239
        [XmlAttribute]
240
        [DefaultValue(false)]
241
        public bool noChangeShapeType
242
        {
243
            get
244
            {
245
                return this.noChangeShapeTypeField;
246
            }
247
            set
248
            {
249
                this.noChangeShapeTypeField = value;
250
            }
251
        }
252
    }
253

254

255

256
    [Serializable]
257
    
258
    [System.ComponentModel.DesignerCategoryAttribute("code")]
259
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
260
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
261
    public class CT_PictureLocking
262
    {
263

264
        private CT_OfficeArtExtensionList extLstField;
265

266
        private bool noGrpField;
267

268
        private bool noSelectField;
269

270
        private bool noRotField;
271

272
        private bool noChangeAspectField;
273

274
        private bool noMoveField;
275

276
        private bool noResizeField;
277

278
        private bool noEditPointsField;
279

280
        private bool noAdjustHandlesField;
281

282
        private bool noChangeArrowheadsField;
283

284
        private bool noChangeShapeTypeField;
285

286
        private bool noCropField;
287

288
        public CT_PictureLocking()
289
        {
290
            //this.extLstField = new CT_OfficeArtExtensionList();
291
            this.noGrpField = false;
292
            this.noSelectField = false;
293
            this.noRotField = false;
294
            this.noChangeAspectField = false;
295
            this.noMoveField = false;
296
            this.noResizeField = false;
297
            this.noEditPointsField = false;
298
            this.noAdjustHandlesField = false;
299
            this.noChangeArrowheadsField = false;
300
            this.noChangeShapeTypeField = false;
301
            this.noCropField = false;
302
        }
303
        public static CT_PictureLocking Parse(XmlNode node, XmlNamespaceManager namespaceManager)
304
        {
305
            if (node == null)
306
                return null;
307
            CT_PictureLocking ctObj = new CT_PictureLocking();
308
            ctObj.noGrp = XmlHelper.ReadBool(node.Attributes["noGrp"]);
309
            ctObj.noSelect = XmlHelper.ReadBool(node.Attributes["noSelect"]);
310
            ctObj.noRot = XmlHelper.ReadBool(node.Attributes["noRot"]);
311
            ctObj.noChangeAspect = XmlHelper.ReadBool(node.Attributes["noChangeAspect"]);
312
            ctObj.noMove = XmlHelper.ReadBool(node.Attributes["noMove"]);
313
            ctObj.noResize = XmlHelper.ReadBool(node.Attributes["noResize"]);
314
            ctObj.noEditPoints = XmlHelper.ReadBool(node.Attributes["noEditPoints"]);
315
            ctObj.noAdjustHandles = XmlHelper.ReadBool(node.Attributes["noAdjustHandles"]);
316
            ctObj.noChangeArrowheads = XmlHelper.ReadBool(node.Attributes["noChangeArrowheads"]);
317
            ctObj.noChangeShapeType = XmlHelper.ReadBool(node.Attributes["noChangeShapeType"]);
318
            ctObj.noCrop = XmlHelper.ReadBool(node.Attributes["noCrop"]);
319
            foreach (XmlNode childNode in node.ChildNodes)
320
            {
321
                if (childNode.LocalName == "extLst")
322
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
323
            }
324
            return ctObj;
325
        }
326

327

328

329
        internal void Write(StreamWriter sw, string nodeName)
330
        {
331
            sw.Write(string.Format("<a:{0}", nodeName));
332
            if(noGrp)
333
                XmlHelper.WriteAttribute(sw, "noGrp", this.noGrp);
334
            if (noSelect)
335
                XmlHelper.WriteAttribute(sw, "noSelect", this.noSelect);
336
            if (noRot)
337
                XmlHelper.WriteAttribute(sw, "noRot", this.noRot);
338
            if (noChangeAspect)
339
                XmlHelper.WriteAttribute(sw, "noChangeAspect", this.noChangeAspect);
340
            if (noMove)
341
                XmlHelper.WriteAttribute(sw, "noMove", this.noMove);
342
            if (noResize)
343
                XmlHelper.WriteAttribute(sw, "noResize", this.noResize);
344
            if (noEditPoints)
345
                XmlHelper.WriteAttribute(sw, "noEditPoints", this.noEditPoints);
346
            if (noAdjustHandles)
347
                XmlHelper.WriteAttribute(sw, "noAdjustHandles", this.noAdjustHandles);
348
            if (noChangeArrowheads)
349
                XmlHelper.WriteAttribute(sw, "noChangeArrowheads", this.noChangeArrowheads);
350
            if (noChangeShapeType)
351
                XmlHelper.WriteAttribute(sw, "noChangeShapeType", this.noChangeShapeType);
352
            if (noCrop)
353
                XmlHelper.WriteAttribute(sw, "noCrop", this.noCrop);
354
            sw.Write(">");
355
            if (this.extLst != null)
356
                this.extLst.Write(sw, "extLst");
357
            sw.Write(string.Format("</a:{0}>", nodeName));
358
        }
359
        [XmlElement(Order = 0)]
360
        public CT_OfficeArtExtensionList extLst
361
        {
362
            get
363
            {
364
                return this.extLstField;
365
            }
366
            set
367
            {
368
                this.extLstField = value;
369
            }
370
        }
371

372
        [XmlAttribute]
373
        [DefaultValue(false)]
374
        public bool noGrp
375
        {
376
            get
377
            {
378
                return this.noGrpField;
379
            }
380
            set
381
            {
382
                this.noGrpField = value;
383
            }
384
        }
385

386
        [XmlAttribute]
387
        [DefaultValue(false)]
388
        public bool noSelect
389
        {
390
            get
391
            {
392
                return this.noSelectField;
393
            }
394
            set
395
            {
396
                this.noSelectField = value;
397
            }
398
        }
399

400
        [XmlAttribute]
401
        [DefaultValue(false)]
402
        public bool noRot
403
        {
404
            get
405
            {
406
                return this.noRotField;
407
            }
408
            set
409
            {
410
                this.noRotField = value;
411
            }
412
        }
413

414
        [XmlAttribute]
415
        [DefaultValue(false)]
416
        public bool noChangeAspect
417
        {
418
            get
419
            {
420
                return this.noChangeAspectField;
421
            }
422
            set
423
            {
424
                this.noChangeAspectField = value;
425
            }
426
        }
427

428
        [XmlAttribute]
429
        [DefaultValue(false)]
430
        public bool noMove
431
        {
432
            get
433
            {
434
                return this.noMoveField;
435
            }
436
            set
437
            {
438
                this.noMoveField = value;
439
            }
440
        }
441

442
        [XmlAttribute]
443
        [DefaultValue(false)]
444
        public bool noResize
445
        {
446
            get
447
            {
448
                return this.noResizeField;
449
            }
450
            set
451
            {
452
                this.noResizeField = value;
453
            }
454
        }
455

456
        [XmlAttribute]
457
        [DefaultValue(false)]
458
        public bool noEditPoints
459
        {
460
            get
461
            {
462
                return this.noEditPointsField;
463
            }
464
            set
465
            {
466
                this.noEditPointsField = value;
467
            }
468
        }
469

470
        [XmlAttribute]
471
        [DefaultValue(false)]
472
        public bool noAdjustHandles
473
        {
474
            get
475
            {
476
                return this.noAdjustHandlesField;
477
            }
478
            set
479
            {
480
                this.noAdjustHandlesField = value;
481
            }
482
        }
483

484
        [XmlAttribute]
485
        [DefaultValue(false)]
486
        public bool noChangeArrowheads
487
        {
488
            get
489
            {
490
                return this.noChangeArrowheadsField;
491
            }
492
            set
493
            {
494
                this.noChangeArrowheadsField = value;
495
            }
496
        }
497

498
        [XmlAttribute]
499
        [DefaultValue(false)]
500
        public bool noChangeShapeType
501
        {
502
            get
503
            {
504
                return this.noChangeShapeTypeField;
505
            }
506
            set
507
            {
508
                this.noChangeShapeTypeField = value;
509
            }
510
        }
511

512
        [XmlAttribute]
513
        [DefaultValue(false)]
514
        public bool noCrop
515
        {
516
            get
517
            {
518
                return this.noCropField;
519
            }
520
            set
521
            {
522
                this.noCropField = value;
523
            }
524
        }
525
    }
526

527

528

529

530

531
    [Serializable]
532
    
533
    [System.ComponentModel.DesignerCategoryAttribute("code")]
534
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
535
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
536
    public class CT_GraphicalObjectFrameLocking
537
    {
538

539
        private CT_OfficeArtExtensionList extLstField;
540

541
        private bool noGrpField;
542

543
        private bool noDrilldownField;
544

545
        private bool noSelectField;
546

547
        private bool noChangeAspectField;
548

549
        private bool noMoveField;
550

551
        private bool noResizeField;
552

553
        public CT_GraphicalObjectFrameLocking()
554
        {
555
            //this.extLstField = new CT_OfficeArtExtensionList();
556
            this.noGrpField = false;
557
            this.noDrilldownField = false;
558
            this.noSelectField = false;
559
            this.noChangeAspectField = false;
560
            this.noMoveField = false;
561
            this.noResizeField = false;
562
        }
563
        public static CT_GraphicalObjectFrameLocking Parse(XmlNode node, XmlNamespaceManager namespaceManager)
564
        {
565
            if (node == null)
566
                return null;
567
            CT_GraphicalObjectFrameLocking ctObj = new CT_GraphicalObjectFrameLocking();
568
            ctObj.noGrp = XmlHelper.ReadBool(node.Attributes["noGrp"]);
569
            ctObj.noDrilldown = XmlHelper.ReadBool(node.Attributes["noDrilldown"]);
570
            ctObj.noSelect = XmlHelper.ReadBool(node.Attributes["noSelect"]);
571
            ctObj.noChangeAspect = XmlHelper.ReadBool(node.Attributes["noChangeAspect"]);
572
            ctObj.noMove = XmlHelper.ReadBool(node.Attributes["noMove"]);
573
            ctObj.noResize = XmlHelper.ReadBool(node.Attributes["noResize"]);
574
            foreach (XmlNode childNode in node.ChildNodes)
575
            {
576
                if (childNode.LocalName == "extLst")
577
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
578
            }
579
            return ctObj;
580
        }
581

582

583

584
        internal void Write(StreamWriter sw, string nodeName)
585
        {
586
            sw.Write(string.Format("<a:{0} xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\"", nodeName));
587
            XmlHelper.WriteAttribute(sw, "noGrp", this.noGrp, false);
588
            XmlHelper.WriteAttribute(sw, "noDrilldown", this.noDrilldown, false);
589
            XmlHelper.WriteAttribute(sw, "noSelect", this.noSelect, false);
590
            XmlHelper.WriteAttribute(sw, "noChangeAspect", this.noChangeAspect, false);
591
            XmlHelper.WriteAttribute(sw, "noMove", this.noMove, false);
592
            XmlHelper.WriteAttribute(sw, "noResize", this.noResize, false);
593
            if (this.extLst != null && this.extLst.ext.Count != 0)
594
            {
595
                sw.Write(">");
596
                this.extLst.Write(sw, "extLst");
597
                sw.Write(string.Format("</a:{0}>", nodeName));
598
            }
599
            else
600
            {
601
                sw.Write("/>");
602
            }
603
        }
604

605
        [XmlElement(Order = 0)]
606
        public CT_OfficeArtExtensionList extLst
607
        {
608
            get
609
            {
610
                return this.extLstField;
611
            }
612
            set
613
            {
614
                this.extLstField = value;
615
            }
616
        }
617

618
        [XmlAttribute]
619
        [DefaultValue(false)]
620
        public bool noGrp
621
        {
622
            get
623
            {
624
                return this.noGrpField;
625
            }
626
            set
627
            {
628
                this.noGrpField = value;
629
            }
630
        }
631

632
        [XmlAttribute]
633
        [DefaultValue(false)]
634
        public bool noDrilldown
635
        {
636
            get
637
            {
638
                return this.noDrilldownField;
639
            }
640
            set
641
            {
642
                this.noDrilldownField = value;
643
            }
644
        }
645

646
        [XmlAttribute]
647
        [DefaultValue(false)]
648
        public bool noSelect
649
        {
650
            get
651
            {
652
                return this.noSelectField;
653
            }
654
            set
655
            {
656
                this.noSelectField = value;
657
            }
658
        }
659

660
        [XmlAttribute]
661
        [DefaultValue(false)]
662
        public bool noChangeAspect
663
        {
664
            get
665
            {
666
                return this.noChangeAspectField;
667
            }
668
            set
669
            {
670
                this.noChangeAspectField = value;
671
            }
672
        }
673

674
        [XmlAttribute]
675
        [DefaultValue(false)]
676
        public bool noMove
677
        {
678
            get
679
            {
680
                return this.noMoveField;
681
            }
682
            set
683
            {
684
                this.noMoveField = value;
685
            }
686
        }
687

688
        [XmlAttribute]
689
        [DefaultValue(false)]
690
        public bool noResize
691
        {
692
            get
693
            {
694
                return this.noResizeField;
695
            }
696
            set
697
            {
698
                this.noResizeField = value;
699
            }
700
        }
701
    }
702

703

704
    [Serializable]
705
    
706
    [System.ComponentModel.DesignerCategoryAttribute("code")]
707
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
708
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
709
    public class CT_NonVisualDrawingProps
710
    {
711
        public static CT_NonVisualDrawingProps Parse(XmlNode node, XmlNamespaceManager namespaceManager)
712
        {
713
            if (node == null)
714
                return null;
715
            CT_NonVisualDrawingProps ctObj = new CT_NonVisualDrawingProps();
716
            ctObj.id = XmlHelper.ReadUInt(node.Attributes["id"]);
717
            ctObj.name = XmlHelper.ReadString(node.Attributes["name"]);
718
            ctObj.descr = XmlHelper.ReadString(node.Attributes["descr"]);
719
            ctObj.hidden = XmlHelper.ReadBool(node.Attributes["hidden"]);
720
            foreach (XmlNode childNode in node.ChildNodes)
721
            {
722
                if (childNode.LocalName == "hlinkClick")
723
                    ctObj.hlinkClick = CT_Hyperlink.Parse(childNode, namespaceManager);
724
                else if (childNode.LocalName == "hlinkHover")
725
                    ctObj.hlinkHover = CT_Hyperlink.Parse(childNode, namespaceManager);
726
                else if (childNode.LocalName == "extLst")
727
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
728
            }
729
            return ctObj;
730
        }
731

732

733

734
        internal void Write(StreamWriter sw, string nodeName)
735
        {
736
            sw.Write(string.Format("<pic:{0}", nodeName));
737
            XmlHelper.WriteAttribute(sw, "id", this.id, true);
738
            XmlHelper.WriteAttribute(sw, "name", this.name);
739
            XmlHelper.WriteAttribute(sw, "descr", this.descr);
740
            if(this.hidden)
741
                XmlHelper.WriteAttribute(sw, "hidden", this.hidden);
742
            sw.Write(">");
743
            if (this.hlinkClick != null)
744
                this.hlinkClick.Write(sw, "hlinkClick");
745
            if (this.hlinkHover != null)
746
                this.hlinkHover.Write(sw, "hlinkHover");
747
            if (this.extLst != null)
748
                this.extLst.Write(sw, "extLst");
749
            sw.Write(string.Format("</pic:{0}>", nodeName));
750
        }
751

752
        private CT_Hyperlink hlinkClickField = null;
753

754
        private CT_Hyperlink hlinkHoverField = null;
755

756
        private CT_OfficeArtExtensionList extLstField = null;
757

758
        private uint idField;
759

760
        private string nameField = null;
761

762
        private string descrField;
763

764
        private bool? hiddenField = null;
765

766
        [XmlElement(Order = 0)]
767
        public CT_Hyperlink hlinkClick
768
        {
769
            get
770
            {
771
                return this.hlinkClickField;
772
            }
773
            set
774
            {
775
                this.hlinkClickField = value;
776
            }
777
        }
778

779
        [XmlElement(Order = 1)]
780
        public CT_Hyperlink hlinkHover
781
        {
782
            get
783
            {
784
                return this.hlinkHoverField;
785
            }
786
            set
787
            {
788
                this.hlinkHoverField = value;
789
            }
790
        }
791

792
        [XmlElement(Order = 2)]
793
        public CT_OfficeArtExtensionList extLst
794
        {
795
            get
796
            {
797
                return this.extLstField;
798
            }
799
            set
800
            {
801
                this.extLstField = value;
802
            }
803
        }
804

805
        [XmlAttribute]
806
        public uint id
807
        {
808
            get
809
            {
810
                return this.idField;
811
            }
812
            set
813
            {
814
                this.idField = value;
815
            }
816
        }
817

818
        [XmlAttribute]
819
        public string name
820
        {
821
            get
822
            {
823
                return this.nameField;
824
            }
825
            set
826
            {
827
                this.nameField = value;
828
            }
829
        }
830

831
        [XmlAttribute]
832
        [DefaultValue("")]
833
        public string descr
834
        {
835
            get
836
            {
837
                return null == this.descrField ? "" : descrField;
838
            }
839
            set
840
            {
841
                this.descrField = value;
842
            }
843
        }
844
        [XmlIgnore]
845
        public bool descrSpecified
846
        {
847
            get { return (null != descrField); }
848
        }
849
        [XmlAttribute]
850
        [DefaultValue(false)]
851
        public bool hidden
852
        {
853
            get
854
            {
855
                return null == this.hiddenField ? false : (bool)hiddenField;
856
            }
857
            set
858
            {
859
                this.hiddenField = value;
860
            }
861
        }
862

863
        [XmlIgnore]
864
        public bool hiddenSpecified
865
        {
866
            get { return (null != hiddenField); }
867
        }
868
    }
869

870

871
    [Serializable]
872
    
873
    [System.ComponentModel.DesignerCategoryAttribute("code")]
874
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
875
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
876
    public class CT_NonVisualDrawingShapeProps
877
    {
878

879
        private CT_ShapeLocking spLocksField;
880

881
        private CT_OfficeArtExtensionList extLstField;
882

883
        private bool txBoxField;
884
        public static CT_NonVisualDrawingShapeProps Parse(XmlNode node, XmlNamespaceManager namespaceManager)
885
        {
886
            if (node == null)
887
                return null;
888
            CT_NonVisualDrawingShapeProps ctObj = new CT_NonVisualDrawingShapeProps();
889
            ctObj.txBox = XmlHelper.ReadBool(node.Attributes["txBox"]);
890
            foreach (XmlNode childNode in node.ChildNodes)
891
            {
892
                if (childNode.LocalName == "spLocks")
893
                    ctObj.spLocks = CT_ShapeLocking.Parse(childNode, namespaceManager);
894
                else if (childNode.LocalName == "extLst")
895
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
896
            }
897
            return ctObj;
898
        }
899

900

901

902
        internal void Write(StreamWriter sw, string nodeName)
903
        {
904
            sw.Write(string.Format("<a:{0}", nodeName));
905
            XmlHelper.WriteAttribute(sw, "txBox", this.txBox, false);
906
            sw.Write(">");
907
            if (this.spLocks != null)
908
                this.spLocks.Write(sw, "spLocks");
909
            if (this.extLst != null)
910
                this.extLst.Write(sw, "extLst");
911
            sw.Write(string.Format("</a:{0}>", nodeName));
912
        }
913

914

915

916
        [XmlElement(Order = 0)]
917
        public CT_ShapeLocking spLocks
918
        {
919
            get
920
            {
921
                return this.spLocksField;
922
            }
923
            set
924
            {
925
                this.spLocksField = value;
926
            }
927
        }
928

929
        [XmlElement(Order = 1)]
930
        public CT_OfficeArtExtensionList extLst
931
        {
932
            get
933
            {
934
                return this.extLstField;
935
            }
936
            set
937
            {
938
                this.extLstField = value;
939
            }
940
        }
941

942
        [XmlAttribute]
943
        [DefaultValue(false)]
944
        public bool txBox
945
        {
946
            get
947
            {
948
                return this.txBoxField;
949
            }
950
            set
951
            {
952
                this.txBoxField = value;
953
            }
954
        }
955
    }
956

957

958
    [Serializable]
959
    
960
    [System.ComponentModel.DesignerCategoryAttribute("code")]
961
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
962
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
963
    public class CT_NonVisualConnectorProperties
964
    {
965
        public static CT_NonVisualConnectorProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
966
        {
967
            if (node == null)
968
                return null;
969
            CT_NonVisualConnectorProperties ctObj = new CT_NonVisualConnectorProperties();
970
            foreach (XmlNode childNode in node.ChildNodes)
971
            {
972
                if (childNode.LocalName == "cxnSpLocks")
973
                    ctObj.cxnSpLocks = CT_ConnectorLocking.Parse(childNode, namespaceManager);
974
                else if (childNode.LocalName == "stCxn")
975
                    ctObj.stCxn = CT_Connection.Parse(childNode, namespaceManager);
976
                else if (childNode.LocalName == "endCxn")
977
                    ctObj.endCxn = CT_Connection.Parse(childNode, namespaceManager);
978
                else if (childNode.LocalName == "extLst")
979
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
980
            }
981
            return ctObj;
982
        }
983

984

985

986
        internal void Write(StreamWriter sw, string nodeName)
987
        {
988
            sw.Write(string.Format("<xdr:{0}", nodeName));
989
            sw.Write(">");
990
            if (this.cxnSpLocks != null)
991
                this.cxnSpLocks.Write(sw, "cxnSpLocks");
992
            if (this.stCxn != null)
993
                this.stCxn.Write(sw, "stCxn");
994
            if (this.endCxn != null)
995
                this.endCxn.Write(sw, "endCxn");
996
            if (this.extLst != null)
997
                this.extLst.Write(sw, "extLst");
998
            sw.Write(string.Format("</xdr:{0}>", nodeName));
999
        }
1000

1001

1002
        private CT_ConnectorLocking cxnSpLocksField;
1003

1004
        private CT_Connection stCxnField;
1005

1006
        private CT_Connection endCxnField;
1007

1008
        private CT_OfficeArtExtensionList extLstField;
1009

1010
        public CT_NonVisualConnectorProperties()
1011
        {
1012
        }
1013

1014
        [XmlElement(Order = 0)]
1015
        public CT_ConnectorLocking cxnSpLocks
1016
        {
1017
            get
1018
            {
1019
                return this.cxnSpLocksField;
1020
            }
1021
            set
1022
            {
1023
                this.cxnSpLocksField = value;
1024
            }
1025
        }
1026

1027
        [XmlElement(Order = 1)]
1028
        public CT_Connection stCxn
1029
        {
1030
            get
1031
            {
1032
                return this.stCxnField;
1033
            }
1034
            set
1035
            {
1036
                this.stCxnField = value;
1037
            }
1038
        }
1039

1040
        [XmlElement(Order = 2)]
1041
        public CT_Connection endCxn
1042
        {
1043
            get
1044
            {
1045
                return this.endCxnField;
1046
            }
1047
            set
1048
            {
1049
                this.endCxnField = value;
1050
            }
1051
        }
1052

1053
        [XmlElement(Order = 3)]
1054
        public CT_OfficeArtExtensionList extLst
1055
        {
1056
            get
1057
            {
1058
                return this.extLstField;
1059
            }
1060
            set
1061
            {
1062
                this.extLstField = value;
1063
            }
1064
        }
1065
    }
1066

1067

1068

1069
    [Serializable]
1070
    
1071
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1072
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1073
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1074
    public class CT_NonVisualPictureProperties
1075
    {
1076
        public static CT_NonVisualPictureProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1077
        {
1078
            if (node == null)
1079
                return null;
1080
            CT_NonVisualPictureProperties ctObj = new CT_NonVisualPictureProperties();
1081
            ctObj.preferRelativeResize = XmlHelper.ReadBool(node.Attributes["preferRelativeResize"], true);
1082
            foreach (XmlNode childNode in node.ChildNodes)
1083
            {
1084
                if (childNode.LocalName == "picLocks")
1085
                    ctObj.picLocks = CT_PictureLocking.Parse(childNode, namespaceManager);
1086
                else if (childNode.LocalName == "extLst")
1087
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
1088
            }
1089
            return ctObj;
1090
        }
1091

1092

1093

1094
        internal void Write(StreamWriter sw, string nodeName)
1095
        {
1096
            sw.Write(string.Format("<pic:{0}", nodeName));
1097
            if (!preferRelativeResize)
1098
                XmlHelper.WriteAttribute(sw, "preferRelativeResize", this.preferRelativeResize);
1099
            sw.Write(">");
1100
            if (this.picLocks != null)  
1101
                this.picLocks.Write(sw, "picLocks");
1102
            if (this.extLst != null)
1103
                this.extLst.Write(sw, "extLst");
1104
            sw.Write(string.Format("</pic:{0}>", nodeName));
1105
        }
1106

1107
        private CT_PictureLocking picLocksField = null;
1108

1109
        private CT_OfficeArtExtensionList extLstField = null;
1110

1111
        private bool preferRelativeResizeField = true;
1112

1113
        public CT_NonVisualPictureProperties()
1114
        {
1115
        }
1116

1117
        public CT_PictureLocking AddNewPicLocks()
1118
        {
1119
            this.picLocksField = new CT_PictureLocking();
1120
            return picLocksField;
1121
        }
1122

1123
        [XmlElement(Order = 0)]
1124
        public CT_PictureLocking picLocks
1125
        {
1126
            get
1127
            {
1128
                return this.picLocksField;
1129
            }
1130
            set
1131
            {
1132
                this.picLocksField = value;
1133
            }
1134
        }
1135

1136
        [XmlElement(Order = 1)]
1137
        public CT_OfficeArtExtensionList extLst
1138
        {
1139
            get
1140
            {
1141
                return this.extLstField;
1142
            }
1143
            set
1144
            {
1145
                this.extLstField = value;
1146
            }
1147
        }
1148

1149
        [XmlAttribute]
1150
        public bool preferRelativeResize
1151
        {
1152
            get
1153
            {
1154
                return preferRelativeResizeField;
1155
            }
1156
            set
1157
            {
1158
                this.preferRelativeResizeField = value;
1159
            }
1160
        }
1161
    }
1162

1163

1164
    [Serializable]
1165
    
1166
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1167
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1168
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1169
    public class CT_NonVisualGroupDrawingShapeProps
1170
    {
1171

1172
        private CT_GroupLocking grpSpLocksField;
1173

1174
        private CT_OfficeArtExtensionList extLstField;
1175

1176
        public static CT_NonVisualGroupDrawingShapeProps Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1177
        {
1178
            if (node == null)
1179
                return null;
1180
            CT_NonVisualGroupDrawingShapeProps ctObj = new CT_NonVisualGroupDrawingShapeProps();
1181
            foreach (XmlNode childNode in node.ChildNodes)
1182
            {
1183
                if (childNode.LocalName == "grpSpLocks")
1184
                    ctObj.grpSpLocks = CT_GroupLocking.Parse(childNode, namespaceManager);
1185
                else if (childNode.LocalName == "extLst")
1186
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
1187
            }
1188
            return ctObj;
1189
        }
1190

1191

1192

1193
        internal void Write(StreamWriter sw, string nodeName)
1194
        {
1195
            sw.Write(string.Format("<{0}", nodeName));
1196
            sw.Write(">");
1197
            if (this.grpSpLocks != null)
1198
                this.grpSpLocks.Write(sw, "grpSpLocks");
1199
            if (this.extLst != null)
1200
                this.extLst.Write(sw, "extLst");
1201
            sw.Write(string.Format("</{0}>", nodeName));
1202
        }
1203

1204
        public CT_NonVisualGroupDrawingShapeProps()
1205
        {
1206
            //this.extLstField = new CT_OfficeArtExtensionList();
1207
           //this.grpSpLocksField = new CT_GroupLocking();
1208
        }
1209

1210
        [XmlElement(Order = 0)]
1211
        public CT_GroupLocking grpSpLocks
1212
        {
1213
            get
1214
            {
1215
                return this.grpSpLocksField;
1216
            }
1217
            set
1218
            {
1219
                this.grpSpLocksField = value;
1220
            }
1221
        }
1222

1223
        [XmlElement(Order = 1)]
1224
        public CT_OfficeArtExtensionList extLst
1225
        {
1226
            get
1227
            {
1228
                return this.extLstField;
1229
            }
1230
            set
1231
            {
1232
                this.extLstField = value;
1233
            }
1234
        }
1235
    }
1236

1237

1238
    [Serializable]
1239
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1240
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1241
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1242
    public class CT_NonVisualGraphicFrameProperties
1243
    {
1244

1245
        private CT_GraphicalObjectFrameLocking graphicFrameLocksField;
1246

1247
        private CT_OfficeArtExtensionList extLstField;
1248

1249
        public CT_NonVisualGraphicFrameProperties()
1250
        {
1251
            //this.extLstField = new CT_OfficeArtExtensionList();
1252
            //this.graphicFrameLocksField = new CT_GraphicalObjectFrameLocking();
1253
        }
1254
        public static CT_NonVisualGraphicFrameProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1255
        {
1256
            if (node == null)
1257
                return null;
1258
            CT_NonVisualGraphicFrameProperties ctObj = new CT_NonVisualGraphicFrameProperties();
1259
            foreach (XmlNode childNode in node.ChildNodes)
1260
            {
1261
                if (childNode.LocalName == "graphicFrameLocks")
1262
                    ctObj.graphicFrameLocks = CT_GraphicalObjectFrameLocking.Parse(childNode, namespaceManager);
1263
                else if (childNode.LocalName == "extLst")
1264
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
1265
            }
1266
            return ctObj;
1267
        }
1268

1269

1270

1271
        internal void Write(StreamWriter sw, string nodeName)
1272
        {
1273
            sw.Write(string.Format("<a:{0}", nodeName));
1274
            sw.Write(">");
1275
            if (this.graphicFrameLocks != null)
1276
                this.graphicFrameLocks.Write(sw, "graphicFrameLocks");
1277
            if (this.extLst != null)
1278
                this.extLst.Write(sw, "extLst");
1279
            sw.Write(string.Format("</a:{0}>", nodeName));
1280
        }
1281

1282
        [XmlElement(Order = 0)]
1283
        public CT_GraphicalObjectFrameLocking graphicFrameLocks
1284
        {
1285
            get
1286
            {
1287
                return this.graphicFrameLocksField;
1288
            }
1289
            set
1290
            {
1291
                this.graphicFrameLocksField = value;
1292
            }
1293
        }
1294

1295
        [XmlElement(Order = 1)]
1296
        public CT_OfficeArtExtensionList extLst
1297
        {
1298
            get
1299
            {
1300
                return this.extLstField;
1301
            }
1302
            set
1303
            {
1304
                this.extLstField = value;
1305
            }
1306
        }
1307
    }
1308

1309
    [Serializable]
1310
    
1311
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1312
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1313
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1314
    public class CT_ShapeLocking
1315
    {
1316

1317
        private CT_OfficeArtExtensionList extLstField;
1318

1319
        private bool noGrpField;
1320

1321
        private bool noSelectField;
1322

1323
        private bool noRotField;
1324

1325
        private bool noChangeAspectField;
1326

1327
        private bool noMoveField;
1328

1329
        private bool noResizeField;
1330

1331
        private bool noEditPointsField;
1332

1333
        private bool noAdjustHandlesField;
1334

1335
        private bool noChangeArrowheadsField;
1336

1337
        private bool noChangeShapeTypeField;
1338

1339
        private bool noTextEditField;
1340
        public static CT_ShapeLocking Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1341
        {
1342
            if (node == null)
1343
                return null;
1344
            CT_ShapeLocking ctObj = new CT_ShapeLocking();
1345
            ctObj.noGrp = XmlHelper.ReadBool(node.Attributes["noGrp"]);
1346
            ctObj.noSelect = XmlHelper.ReadBool(node.Attributes["noSelect"]);
1347
            ctObj.noRot = XmlHelper.ReadBool(node.Attributes["noRot"]);
1348
            ctObj.noChangeAspect = XmlHelper.ReadBool(node.Attributes["noChangeAspect"]);
1349
            ctObj.noMove = XmlHelper.ReadBool(node.Attributes["noMove"]);
1350
            ctObj.noResize = XmlHelper.ReadBool(node.Attributes["noResize"]);
1351
            ctObj.noEditPoints = XmlHelper.ReadBool(node.Attributes["noEditPoints"]);
1352
            ctObj.noAdjustHandles = XmlHelper.ReadBool(node.Attributes["noAdjustHandles"]);
1353
            ctObj.noChangeArrowheads = XmlHelper.ReadBool(node.Attributes["noChangeArrowheads"]);
1354
            ctObj.noChangeShapeType = XmlHelper.ReadBool(node.Attributes["noChangeShapeType"]);
1355
            ctObj.noTextEdit = XmlHelper.ReadBool(node.Attributes["noTextEdit"]);
1356
            foreach (XmlNode childNode in node.ChildNodes)
1357
            {
1358
                if (childNode.LocalName == "extLst")
1359
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
1360
            }
1361
            return ctObj;
1362
        }
1363

1364

1365

1366
        internal void Write(StreamWriter sw, string nodeName)
1367
        {
1368
            sw.Write(string.Format("<a:{0}", nodeName));
1369
            XmlHelper.WriteAttribute(sw, "noGrp", this.noGrp, false);
1370
            XmlHelper.WriteAttribute(sw, "noSelect", this.noSelect, false);
1371
            XmlHelper.WriteAttribute(sw, "noRot", this.noRot, false);
1372
            XmlHelper.WriteAttribute(sw, "noChangeAspect", this.noChangeAspect, false);
1373
            XmlHelper.WriteAttribute(sw, "noMove", this.noMove, false);
1374
            XmlHelper.WriteAttribute(sw, "noResize", this.noResize, false);
1375
            XmlHelper.WriteAttribute(sw, "noEditPoints", this.noEditPoints, false);
1376
            XmlHelper.WriteAttribute(sw, "noAdjustHandles", this.noAdjustHandles, false);
1377
            XmlHelper.WriteAttribute(sw, "noChangeArrowheads", this.noChangeArrowheads, false);
1378
            XmlHelper.WriteAttribute(sw, "noChangeShapeType", this.noChangeShapeType, false);
1379
            XmlHelper.WriteAttribute(sw, "noTextEdit", this.noTextEdit, false);
1380

1381
            if (this.extLst == null)
1382
            {
1383
                sw.Write("/>");
1384
            }
1385
            else
1386
            {
1387
                sw.Write(">");
1388
                this.extLst.Write(sw, "extLst");
1389
                sw.Write(string.Format("</a:{0}>", nodeName));
1390
            }
1391
        }
1392
        public CT_ShapeLocking()
1393
        {
1394
            //this.extLstField = new CT_OfficeArtExtensionList();
1395
            this.noGrpField = false;
1396
            this.noSelectField = false;
1397
            this.noRotField = false;
1398
            this.noChangeAspectField = false;
1399
            this.noMoveField = false;
1400
            this.noResizeField = false;
1401
            this.noEditPointsField = false;
1402
            this.noAdjustHandlesField = false;
1403
            this.noChangeArrowheadsField = false;
1404
            this.noChangeShapeTypeField = false;
1405
            this.noTextEditField = false;
1406
        }
1407

1408
        [XmlElement(Order = 0)]
1409
        public CT_OfficeArtExtensionList extLst
1410
        {
1411
            get
1412
            {
1413
                return this.extLstField;
1414
            }
1415
            set
1416
            {
1417
                this.extLstField = value;
1418
            }
1419
        }
1420

1421
        [XmlAttribute]
1422
        [DefaultValue(false)]
1423
        public bool noGrp
1424
        {
1425
            get
1426
            {
1427
                return this.noGrpField;
1428
            }
1429
            set
1430
            {
1431
                this.noGrpField = value;
1432
            }
1433
        }
1434

1435
        [XmlAttribute]
1436
        [DefaultValue(false)]
1437
        public bool noSelect
1438
        {
1439
            get
1440
            {
1441
                return this.noSelectField;
1442
            }
1443
            set
1444
            {
1445
                this.noSelectField = value;
1446
            }
1447
        }
1448

1449
        [XmlAttribute]
1450
        [DefaultValue(false)]
1451
        public bool noRot
1452
        {
1453
            get
1454
            {
1455
                return this.noRotField;
1456
            }
1457
            set
1458
            {
1459
                this.noRotField = value;
1460
            }
1461
        }
1462

1463
        [XmlAttribute]
1464
        [DefaultValue(false)]
1465
        public bool noChangeAspect
1466
        {
1467
            get
1468
            {
1469
                return this.noChangeAspectField;
1470
            }
1471
            set
1472
            {
1473
                this.noChangeAspectField = value;
1474
            }
1475
        }
1476

1477
        [XmlAttribute]
1478
        [DefaultValue(false)]
1479
        public bool noMove
1480
        {
1481
            get
1482
            {
1483
                return this.noMoveField;
1484
            }
1485
            set
1486
            {
1487
                this.noMoveField = value;
1488
            }
1489
        }
1490

1491
        [XmlAttribute]
1492
        [DefaultValue(false)]
1493
        public bool noResize
1494
        {
1495
            get
1496
            {
1497
                return this.noResizeField;
1498
            }
1499
            set
1500
            {
1501
                this.noResizeField = value;
1502
            }
1503
        }
1504

1505
        [XmlAttribute]
1506
        [DefaultValue(false)]
1507
        public bool noEditPoints
1508
        {
1509
            get
1510
            {
1511
                return this.noEditPointsField;
1512
            }
1513
            set
1514
            {
1515
                this.noEditPointsField = value;
1516
            }
1517
        }
1518

1519
        [XmlAttribute]
1520
        [DefaultValue(false)]
1521
        public bool noAdjustHandles
1522
        {
1523
            get
1524
            {
1525
                return this.noAdjustHandlesField;
1526
            }
1527
            set
1528
            {
1529
                this.noAdjustHandlesField = value;
1530
            }
1531
        }
1532

1533
        [XmlAttribute]
1534
        [DefaultValue(false)]
1535
        public bool noChangeArrowheads
1536
        {
1537
            get
1538
            {
1539
                return this.noChangeArrowheadsField;
1540
            }
1541
            set
1542
            {
1543
                this.noChangeArrowheadsField = value;
1544
            }
1545
        }
1546

1547
        [XmlAttribute]
1548
        [DefaultValue(false)]
1549
        public bool noChangeShapeType
1550
        {
1551
            get
1552
            {
1553
                return this.noChangeShapeTypeField;
1554
            }
1555
            set
1556
            {
1557
                this.noChangeShapeTypeField = value;
1558
            }
1559
        }
1560

1561
        [XmlAttribute]
1562
        [DefaultValue(false)]
1563
        public bool noTextEdit
1564
        {
1565
            get
1566
            {
1567
                return this.noTextEditField;
1568
            }
1569
            set
1570
            {
1571
                this.noTextEditField = value;
1572
            }
1573
        }
1574
    }
1575

1576
    [Serializable]
1577
    
1578
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1579
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1580
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1581
    public class CT_GroupLocking
1582
    {
1583

1584
        private CT_OfficeArtExtensionList extLstField;
1585

1586
        private bool noGrpField;
1587

1588
        private bool noUngrpField;
1589

1590
        private bool noSelectField;
1591

1592
        private bool noRotField;
1593

1594
        private bool noChangeAspectField;
1595

1596
        private bool noMoveField;
1597

1598
        private bool noResizeField;
1599

1600
        public CT_GroupLocking()
1601
        {
1602
            //this.extLstField = new CT_OfficeArtExtensionList();
1603
            this.noGrpField = false;
1604
            this.noUngrpField = false;
1605
            this.noSelectField = false;
1606
            this.noRotField = false;
1607
            this.noChangeAspectField = false;
1608
            this.noMoveField = false;
1609
            this.noResizeField = false;
1610
        }
1611
        public static CT_GroupLocking Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1612
        {
1613
            if (node == null)
1614
                return null;
1615
            CT_GroupLocking ctObj = new CT_GroupLocking();
1616
            ctObj.noGrp = XmlHelper.ReadBool(node.Attributes["noGrp"]);
1617
            ctObj.noUngrp = XmlHelper.ReadBool(node.Attributes["noUngrp"]);
1618
            ctObj.noSelect = XmlHelper.ReadBool(node.Attributes["noSelect"]);
1619
            ctObj.noRot = XmlHelper.ReadBool(node.Attributes["noRot"]);
1620
            ctObj.noChangeAspect = XmlHelper.ReadBool(node.Attributes["noChangeAspect"]);
1621
            ctObj.noMove = XmlHelper.ReadBool(node.Attributes["noMove"]);
1622
            ctObj.noResize = XmlHelper.ReadBool(node.Attributes["noResize"]);
1623
            foreach (XmlNode childNode in node.ChildNodes)
1624
            {
1625
                if (childNode.LocalName == "extLst")
1626
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
1627
            }
1628
            return ctObj;
1629
        }
1630

1631

1632

1633
        internal void Write(StreamWriter sw, string nodeName)
1634
        {
1635
            sw.Write(string.Format("<a:{0}", nodeName));
1636
            if(this.noGrp)
1637
                XmlHelper.WriteAttribute(sw, "noGrp", this.noGrp);
1638
            if(this.noUngrp)
1639
                XmlHelper.WriteAttribute(sw, "noUngrp", this.noUngrp);
1640
            if(this.noSelect)
1641
                XmlHelper.WriteAttribute(sw, "noSelect", this.noSelect);
1642
            if(this.noRot)
1643
                XmlHelper.WriteAttribute(sw, "noRot", this.noRot);
1644
            if(this.noChangeAspect)
1645
                XmlHelper.WriteAttribute(sw, "noChangeAspect", this.noChangeAspect);
1646
            if(this.noMove)
1647
                XmlHelper.WriteAttribute(sw, "noMove", this.noMove);
1648
            if(this.noResize)
1649
                XmlHelper.WriteAttribute(sw, "noResize", this.noResize);
1650
            sw.Write("/>");
1651
            /*if (this.extLst != null)
1652
                this.extLst.Write(sw, "extLst");*/
1653
        }
1654

1655
        [XmlElement(Order = 0)]
1656
        public CT_OfficeArtExtensionList extLst
1657
        {
1658
            get
1659
            {
1660
                return this.extLstField;
1661
            }
1662
            set
1663
            {
1664
                this.extLstField = value;
1665
            }
1666
        }
1667

1668
        [XmlAttribute]
1669
        [DefaultValue(false)]
1670
        public bool noGrp
1671
        {
1672
            get
1673
            {
1674
                return this.noGrpField;
1675
            }
1676
            set
1677
            {
1678
                this.noGrpField = value;
1679
            }
1680
        }
1681

1682
        [XmlAttribute]
1683
        [DefaultValue(false)]
1684
        public bool noUngrp
1685
        {
1686
            get
1687
            {
1688
                return this.noUngrpField;
1689
            }
1690
            set
1691
            {
1692
                this.noUngrpField = value;
1693
            }
1694
        }
1695

1696
        [XmlAttribute]
1697
        [DefaultValue(false)]
1698
        public bool noSelect
1699
        {
1700
            get
1701
            {
1702
                return this.noSelectField;
1703
            }
1704
            set
1705
            {
1706
                this.noSelectField = value;
1707
            }
1708
        }
1709

1710
        [XmlAttribute]
1711
        [DefaultValue(false)]
1712
        public bool noRot
1713
        {
1714
            get
1715
            {
1716
                return this.noRotField;
1717
            }
1718
            set
1719
            {
1720
                this.noRotField = value;
1721
            }
1722
        }
1723

1724
        [XmlAttribute]
1725
        [DefaultValue(false)]
1726
        public bool noChangeAspect
1727
        {
1728
            get
1729
            {
1730
                return this.noChangeAspectField;
1731
            }
1732
            set
1733
            {
1734
                this.noChangeAspectField = value;
1735
            }
1736
        }
1737

1738
        [XmlAttribute]
1739
        [DefaultValue(false)]
1740
        public bool noMove
1741
        {
1742
            get
1743
            {
1744
                return this.noMoveField;
1745
            }
1746
            set
1747
            {
1748
                this.noMoveField = value;
1749
            }
1750
        }
1751

1752
        [XmlAttribute]
1753
        [DefaultValue(false)]
1754
        public bool noResize
1755
        {
1756
            get
1757
            {
1758
                return this.noResizeField;
1759
            }
1760
            set
1761
            {
1762
                this.noResizeField = value;
1763
            }
1764
        }
1765
    }
1766
    [Serializable]
1767
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1768
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1769
    public class CT_ShapeProperties
1770
    {
1771

1772
        private CT_Transform2D xfrmField = null;
1773

1774
        private CT_CustomGeometry2D custGeomField = null;
1775

1776
        private CT_PresetGeometry2D prstGeomField = null;
1777

1778
        private CT_NoFillProperties noFillField = null;
1779

1780
        private CT_SolidColorFillProperties solidFillField = null;
1781

1782
        private CT_GradientFillProperties gradFillField = null;
1783

1784
        private CT_BlipFillProperties blipFillField = null;
1785

1786
        private CT_PatternFillProperties pattFillField = null;
1787

1788
        private CT_GroupFillProperties grpFillField = null;
1789

1790
        private CT_LineProperties lnField = null;
1791

1792
        private CT_EffectList effectLstField = null;
1793

1794
        private CT_EffectContainer effectDagField = null;
1795

1796
        private CT_Scene3D scene3dField = null;
1797

1798
        private CT_Shape3D sp3dField = null;
1799

1800
        private CT_OfficeArtExtensionList extLstField = null;
1801

1802
        private ST_BlackWhiteMode bwModeField = ST_BlackWhiteMode.none;
1803

1804

1805
        public CT_PresetGeometry2D AddNewPrstGeom()
1806
        {
1807
            this.prstGeomField = new CT_PresetGeometry2D();
1808
            return this.prstGeomField;
1809
        }
1810
        public CT_Transform2D AddNewXfrm()
1811
        {
1812
            this.xfrmField = new CT_Transform2D();
1813
            return this.xfrmField;
1814
        }
1815
        public CT_SolidColorFillProperties AddNewSolidFill()
1816
        {
1817
            this.solidFillField = new CT_SolidColorFillProperties();
1818
            return this.solidFillField;
1819
        }
1820
        public bool IsSetPattFill()
1821
        {
1822
            return this.pattFillField != null;
1823
        }
1824
        public bool IsSetSolidFill()
1825
        {
1826
            return this.solidFillField != null;
1827
        }
1828
        public bool IsSetLn()
1829
        {
1830
            return this.lnField != null;
1831
        }
1832
        public CT_LineProperties AddNewLn()
1833
        {
1834
            this.lnField = new CT_LineProperties();
1835
            return lnField;
1836
        }
1837
        public void unsetPattFill()
1838
        {
1839
            this.pattFill = null;
1840
        }
1841
        public void unsetSolidFill()
1842
        {
1843
            this.solidFill = null;
1844
        }
1845

1846
        [XmlElement(Order = 0)]
1847
        public CT_Transform2D xfrm
1848
        {
1849
            get
1850
            {
1851
                return this.xfrmField;
1852
            }
1853
            set
1854
            {
1855
                this.xfrmField = value;
1856
            }
1857
        }
1858

1859
        [XmlElement(Order = 1)]
1860
        public CT_CustomGeometry2D custGeom
1861
        {
1862
            get
1863
            {
1864
                return this.custGeomField;
1865
            }
1866
            set
1867
            {
1868
                this.custGeomField = value;
1869
            }
1870
        }
1871

1872
        [XmlElement(Order = 2)]
1873
        public CT_PresetGeometry2D prstGeom
1874
        {
1875
            get
1876
            {
1877
                return this.prstGeomField;
1878
            }
1879
            set
1880
            {
1881
                this.prstGeomField = value;
1882
            }
1883
        }
1884

1885
        [XmlElement(Order = 3)]
1886
        public CT_NoFillProperties noFill
1887
        {
1888
            get
1889
            {
1890
                return this.noFillField;
1891
            }
1892
            set
1893
            {
1894
                this.noFillField = value;
1895
            }
1896
        }
1897

1898
        [XmlElement(Order = 4)]
1899
        public CT_SolidColorFillProperties solidFill
1900
        {
1901
            get
1902
            {
1903
                return this.solidFillField;
1904
            }
1905
            set
1906
            {
1907
                this.solidFillField = value;
1908
            }
1909
        }
1910

1911
        [XmlElement(Order = 5)]
1912
        public CT_GradientFillProperties gradFill
1913
        {
1914
            get
1915
            {
1916
                return this.gradFillField;
1917
            }
1918
            set
1919
            {
1920
                this.gradFillField = value;
1921
            }
1922
        }
1923

1924
        [XmlElement(Order = 6)]
1925
        public CT_BlipFillProperties blipFill
1926
        {
1927
            get
1928
            {
1929
                return this.blipFillField;
1930
            }
1931
            set
1932
            {
1933
                this.blipFillField = value;
1934
            }
1935
        }
1936

1937
        [XmlElement(Order = 7)]
1938
        public CT_PatternFillProperties pattFill
1939
        {
1940
            get
1941
            {
1942
                return this.pattFillField;
1943
            }
1944
            set
1945
            {
1946
                this.pattFillField = value;
1947
            }
1948
        }
1949

1950
        [XmlElement(Order = 8)]
1951
        public CT_GroupFillProperties grpFill
1952
        {
1953
            get
1954
            {
1955
                return this.grpFillField;
1956
            }
1957
            set
1958
            {
1959
                this.grpFillField = value;
1960
            }
1961
        }
1962

1963
        [XmlElement(Order = 9)]
1964
        public CT_LineProperties ln
1965
        {
1966
            get
1967
            {
1968
                return this.lnField;
1969
            }
1970
            set
1971
            {
1972
                this.lnField = value;
1973
            }
1974
        }
1975

1976
        [XmlElement(Order = 10)]
1977
        public CT_EffectList effectLst
1978
        {
1979
            get
1980
            {
1981
                return this.effectLstField;
1982
            }
1983
            set
1984
            {
1985
                this.effectLstField = value;
1986
            }
1987
        }
1988

1989
        [XmlElement(Order = 11)]
1990
        public CT_EffectContainer effectDag
1991
        {
1992
            get
1993
            {
1994
                return this.effectDagField;
1995
            }
1996
            set
1997
            {
1998
                this.effectDagField = value;
1999
            }
2000
        }
2001

2002
        [XmlElement(Order = 12)]
2003
        public CT_Scene3D scene3d
2004
        {
2005
            get
2006
            {
2007
                return this.scene3dField;
2008
            }
2009
            set
2010
            {
2011
                this.scene3dField = value;
2012
            }
2013
        }
2014

2015
        [XmlElement(Order = 13)]
2016
        public CT_Shape3D sp3d
2017
        {
2018
            get
2019
            {
2020
                return this.sp3dField;
2021
            }
2022
            set
2023
            {
2024
                this.sp3dField = value;
2025
            }
2026
        }
2027

2028
        [XmlElement(Order = 14)]
2029
        public CT_OfficeArtExtensionList extLst
2030
        {
2031
            get
2032
            {
2033
                return this.extLstField;
2034
            }
2035
            set
2036
            {
2037
                this.extLstField = value;
2038
            }
2039
        }
2040

2041
        [XmlAttribute]
2042
        public ST_BlackWhiteMode bwMode
2043
        {
2044
            get
2045
            {
2046
                return this.bwModeField;
2047
            }
2048
            set
2049
            {
2050
                this.bwModeField = value;
2051
            }
2052
        }
2053
        [XmlIgnore]
2054
        public bool bwModeSpecified
2055
        {
2056
            get { return ST_BlackWhiteMode.none != this.bwModeField; }
2057
        }
2058

2059
        public static CT_ShapeProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2060
        {
2061
            if (node == null)
2062
                return null;
2063
            CT_ShapeProperties ctObj = new CT_ShapeProperties();
2064
            if (node.Attributes["bwMode"] != null)
2065
                ctObj.bwMode = (ST_BlackWhiteMode)Enum.Parse(typeof(ST_BlackWhiteMode), node.Attributes["bwMode"].Value);
2066
            foreach (XmlNode childNode in node.ChildNodes)
2067
            {
2068
                if (childNode.LocalName == "xfrm")
2069
                    ctObj.xfrm = CT_Transform2D.Parse(childNode, namespaceManager);
2070
                else if (childNode.LocalName == "custGeom")
2071
                    ctObj.custGeom = CT_CustomGeometry2D.Parse(childNode, namespaceManager);
2072
                else if (childNode.LocalName == "prstGeom")
2073
                    ctObj.prstGeom = CT_PresetGeometry2D.Parse(childNode, namespaceManager);
2074
                else if (childNode.LocalName == "noFill")
2075
                    ctObj.noFill = new CT_NoFillProperties();
2076
                else if (childNode.LocalName == "solidFill")
2077
                    ctObj.solidFill = CT_SolidColorFillProperties.Parse(childNode, namespaceManager);
2078
                else if (childNode.LocalName == "gradFill")
2079
                    ctObj.gradFill = CT_GradientFillProperties.Parse(childNode, namespaceManager);
2080
                else if (childNode.LocalName == "blipFill")
2081
                    ctObj.blipFill = CT_BlipFillProperties.Parse(childNode, namespaceManager);
2082
                else if (childNode.LocalName == "pattFill")
2083
                    ctObj.pattFill = CT_PatternFillProperties.Parse(childNode, namespaceManager);
2084
                else if (childNode.LocalName == "grpFill")
2085
                    ctObj.grpFill = new CT_GroupFillProperties();
2086
                else if (childNode.LocalName == "ln")
2087
                    ctObj.ln = CT_LineProperties.Parse(childNode, namespaceManager);
2088
                else if (childNode.LocalName == "effectLst")
2089
                    ctObj.effectLst = CT_EffectList.Parse(childNode, namespaceManager);
2090
                else if (childNode.LocalName == "effectDag")
2091
                    ctObj.effectDag = CT_EffectContainer.Parse(childNode, namespaceManager);
2092
                else if (childNode.LocalName == "scene3d")
2093
                    ctObj.scene3d = CT_Scene3D.Parse(childNode, namespaceManager);
2094
                else if (childNode.LocalName == "sp3d")
2095
                    ctObj.sp3d = CT_Shape3D.Parse(childNode, namespaceManager);
2096
                else if (childNode.LocalName == "extLst")
2097
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
2098
            }
2099
            return ctObj;
2100
        }
2101

2102

2103

2104
        internal void Write(StreamWriter sw, string nodeName)
2105
        {
2106
            sw.Write(string.Format("<{0}", nodeName));
2107
            if(this.bwMode!= ST_BlackWhiteMode.none)
2108
                XmlHelper.WriteAttribute(sw, "bwMode", this.bwMode.ToString());
2109
            sw.Write(">");
2110
            if (this.xfrm != null)
2111
                this.xfrm.Write(sw, "a:xfrm");
2112
            if (this.custGeom != null)
2113
                this.custGeom.Write(sw, "custGeom");
2114
            if (this.prstGeom != null)
2115
                this.prstGeom.Write(sw, "prstGeom");
2116
            if (this.noFill != null)
2117
                sw.Write("<a:noFill/>");
2118
            if (this.solidFill != null)
2119
                this.solidFill.Write(sw, "solidFill");
2120
            if (this.gradFill != null)
2121
                this.gradFill.Write(sw, "gradFill");
2122
            if (this.blipFill != null)
2123
                this.blipFill.Write(sw, "a:blipFill");
2124
            if (this.pattFill != null)
2125
                this.pattFill.Write(sw, "pattFill");
2126
            if (this.grpFill != null)
2127
                sw.Write("<a:grpFill/>");
2128
            if (this.ln != null)
2129
                this.ln.Write(sw, "ln");
2130
            if (this.effectLst != null)
2131
                this.effectLst.Write(sw, "effectLst");
2132
            if (this.effectDag != null)
2133
                this.effectDag.Write(sw, "effectDag");
2134
            if (this.scene3d != null)
2135
                this.scene3d.Write(sw, "scene3d");
2136
            if (this.sp3d != null)
2137
                this.sp3d.Write(sw, "sp3d");
2138
            if (this.extLst != null)
2139
                this.extLst.Write(sw, "extLst");
2140
            sw.Write(string.Format("</{0}>", nodeName));
2141
        }
2142

2143
    }
2144

2145
    [Serializable]
2146
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
2147
    public partial class CT_GroupShapeProperties
2148
    {
2149

2150
        private CT_GroupTransform2D xfrmField;
2151

2152
        private CT_NoFillProperties noFillField;
2153

2154
        private CT_SolidColorFillProperties solidFillField;
2155

2156
        private CT_GradientFillProperties gradFillField;
2157

2158
        private CT_BlipFillProperties blipFillField;
2159

2160
        private CT_PatternFillProperties pattFillField;
2161

2162
        private CT_GroupFillProperties grpFillField;
2163

2164
        private CT_EffectList effectLstField;
2165

2166
        private CT_EffectContainer effectDagField;
2167

2168
        private CT_Scene3D scene3dField;
2169

2170
        private CT_OfficeArtExtensionList extLstField;
2171

2172
        private ST_BlackWhiteMode bwModeField;
2173

2174
        private bool bwModeFieldSpecified;
2175
        public static CT_GroupShapeProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2176
        {
2177
            if (node == null)
2178
                return null;
2179
            CT_GroupShapeProperties ctObj = new CT_GroupShapeProperties();
2180
            if (node.Attributes["bwMode"] != null)
2181
                ctObj.bwMode = (ST_BlackWhiteMode)Enum.Parse(typeof(ST_BlackWhiteMode), node.Attributes["bwMode"].Value);
2182
            foreach (XmlNode childNode in node.ChildNodes)
2183
            {
2184
                if (childNode.LocalName == "xfrm")
2185
                    ctObj.xfrm = CT_GroupTransform2D.Parse(childNode, namespaceManager);
2186
                else if (childNode.LocalName == "noFill")
2187
                    ctObj.noFill = new CT_NoFillProperties();
2188
                else if (childNode.LocalName == "solidFill")
2189
                    ctObj.solidFill = CT_SolidColorFillProperties.Parse(childNode, namespaceManager);
2190
                else if (childNode.LocalName == "gradFill")
2191
                    ctObj.gradFill = CT_GradientFillProperties.Parse(childNode, namespaceManager);
2192
                else if (childNode.LocalName == "blipFill")
2193
                    ctObj.blipFill = CT_BlipFillProperties.Parse(childNode, namespaceManager);
2194
                else if (childNode.LocalName == "pattFill")
2195
                    ctObj.pattFill = CT_PatternFillProperties.Parse(childNode, namespaceManager);
2196
                else if (childNode.LocalName == "grpFill")
2197
                    ctObj.grpFill = new CT_GroupFillProperties();
2198
                else if (childNode.LocalName == "effectLst")
2199
                    ctObj.effectLst = CT_EffectList.Parse(childNode, namespaceManager);
2200
                else if (childNode.LocalName == "effectDag")
2201
                    ctObj.effectDag = CT_EffectContainer.Parse(childNode, namespaceManager);
2202
                else if (childNode.LocalName == "scene3d")
2203
                    ctObj.scene3d = CT_Scene3D.Parse(childNode, namespaceManager);
2204
                else if (childNode.LocalName == "extLst")
2205
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
2206
            }
2207
            return ctObj;
2208
        }
2209

2210

2211

2212
        internal void Write(StreamWriter sw, string nodeName)
2213
        {
2214
            sw.Write(string.Format("<{0}", nodeName));
2215
            if(this.bwMode!= ST_BlackWhiteMode.none)
2216
                XmlHelper.WriteAttribute(sw, "bwMode", this.bwMode.ToString());
2217
            sw.Write(">");
2218
            if (this.xfrm != null)
2219
                this.xfrm.Write(sw, "xfrm");
2220
            if (this.noFill != null)
2221
                sw.Write("<a:noFill/>");
2222
            if (this.solidFill != null)
2223
                this.solidFill.Write(sw, "solidFill");
2224
            if (this.gradFill != null)
2225
                this.gradFill.Write(sw, "gradFill");
2226
            if (this.blipFill != null)
2227
                this.blipFill.Write(sw, "a:blipFill");
2228
            if (this.pattFill != null)
2229
                this.pattFill.Write(sw, "pattFill");
2230
            if (this.grpFill != null)
2231
                sw.Write("<a:grpFill/>");
2232
            if (this.effectLst != null)
2233
                this.effectLst.Write(sw, "effectLst");
2234
            if (this.effectDag != null)
2235
                this.effectDag.Write(sw, "effectDag");
2236
            if (this.scene3d != null)
2237
                this.scene3d.Write(sw, "scene3d");
2238
            if (this.extLst != null)
2239
                this.extLst.Write(sw, "extLst");
2240
            sw.Write(string.Format("</{0}>", nodeName));
2241
        }
2242

2243
        public CT_GroupShapeProperties()
2244
        {
2245
            //this.extlstfield = new ct_officeartextensionlist();
2246
            //this.scene3dfield = new ct_scene3d();
2247
            //this.effectdagfield = new ct_effectcontainer();
2248
            //this.effectlstfield = new ct_effectlist();
2249
            //this.grpfillfield = new ct_groupfillproperties();
2250
            //this.pattfillfield = new ct_patternfillproperties();
2251
            //this.blipfillfield = new ct_blipfillproperties();
2252
            //this.gradfillfield = new ct_gradientfillproperties();
2253
            //this.solidfillfield = new ct_solidcolorfillproperties();
2254
            //this.nofillfield = new ct_nofillproperties();
2255
            //this.xfrmField = new CT_GroupTransform2D();
2256
        }
2257

2258
        public CT_GroupTransform2D AddNewXfrm()
2259
        {
2260
            this.xfrmField = new CT_GroupTransform2D();
2261
            return this.xfrmField;
2262
        }
2263
        [XmlElement(Order = 0)]
2264
        public CT_GroupTransform2D xfrm
2265
        {
2266
            get
2267
            {
2268
                return this.xfrmField;
2269
            }
2270
            set
2271
            {
2272
                this.xfrmField = value;
2273
            }
2274
        }
2275

2276
        [XmlElement(Order = 1)]
2277
        public CT_NoFillProperties noFill
2278
        {
2279
            get
2280
            {
2281
                return this.noFillField;
2282
            }
2283
            set
2284
            {
2285
                this.noFillField = value;
2286
            }
2287
        }
2288

2289
        [XmlElement(Order = 2)]
2290
        public CT_SolidColorFillProperties solidFill
2291
        {
2292
            get
2293
            {
2294
                return this.solidFillField;
2295
            }
2296
            set
2297
            {
2298
                this.solidFillField = value;
2299
            }
2300
        }
2301

2302
        [XmlElement(Order = 3)]
2303
        public CT_GradientFillProperties gradFill
2304
        {
2305
            get
2306
            {
2307
                return this.gradFillField;
2308
            }
2309
            set
2310
            {
2311
                this.gradFillField = value;
2312
            }
2313
        }
2314

2315
        [XmlElement(Order = 4)]
2316
        public CT_BlipFillProperties blipFill
2317
        {
2318
            get
2319
            {
2320
                return this.blipFillField;
2321
            }
2322
            set
2323
            {
2324
                this.blipFillField = value;
2325
            }
2326
        }
2327

2328
        [XmlElement(Order = 5)]
2329
        public CT_PatternFillProperties pattFill
2330
        {
2331
            get
2332
            {
2333
                return this.pattFillField;
2334
            }
2335
            set
2336
            {
2337
                this.pattFillField = value;
2338
            }
2339
        }
2340

2341
        [XmlElement(Order = 6)]
2342
        public CT_GroupFillProperties grpFill
2343
        {
2344
            get
2345
            {
2346
                return this.grpFillField;
2347
            }
2348
            set
2349
            {
2350
                this.grpFillField = value;
2351
            }
2352
        }
2353

2354
        [XmlElement(Order = 7)]
2355
        public CT_EffectList effectLst
2356
        {
2357
            get
2358
            {
2359
                return this.effectLstField;
2360
            }
2361
            set
2362
            {
2363
                this.effectLstField = value;
2364
            }
2365
        }
2366

2367
        [XmlElement(Order = 8)]
2368
        public CT_EffectContainer effectDag
2369
        {
2370
            get
2371
            {
2372
                return this.effectDagField;
2373
            }
2374
            set
2375
            {
2376
                this.effectDagField = value;
2377
            }
2378
        }
2379

2380
        [XmlElement(Order = 9)]
2381
        public CT_Scene3D scene3d
2382
        {
2383
            get
2384
            {
2385
                return this.scene3dField;
2386
            }
2387
            set
2388
            {
2389
                this.scene3dField = value;
2390
            }
2391
        }
2392

2393
        [XmlElement(Order = 10)]
2394
        public CT_OfficeArtExtensionList extLst
2395
        {
2396
            get
2397
            {
2398
                return this.extLstField;
2399
            }
2400
            set
2401
            {
2402
                this.extLstField = value;
2403
            }
2404
        }
2405

2406
        [XmlAttribute]
2407
        public ST_BlackWhiteMode bwMode
2408
        {
2409
            get
2410
            {
2411
                return this.bwModeField;
2412
            }
2413
            set
2414
            {
2415
                this.bwModeField = value;
2416
            }
2417
        }
2418

2419
        [XmlIgnore]
2420
        public bool bwModeSpecified
2421
        {
2422
            get
2423
            {
2424
                return this.bwModeFieldSpecified;
2425
            }
2426
            set
2427
            {
2428
                this.bwModeFieldSpecified = value;
2429
            }
2430
        }
2431
    }
2432
}
2433