npoi

1
using System;
2
using System.Collections.Generic;
3
using System.Xml.Schema;
4
using System.Xml.Serialization;
5
using NPOI.OpenXmlFormats.Vml.Wordprocessing;
6
using NPOI.OpenXmlFormats.Vml.Office;
7
using NPOI.OpenXmlFormats.Vml.Spreadsheet;
8
using NPOI.OpenXmlFormats.Vml.Presentation;
9
using System.IO;
10
using System.Xml;
11
using System.Text;
12
using System.ComponentModel;
13
using NPOI.OpenXml4Net.Util;
14

15
namespace NPOI.OpenXmlFormats.Vml
16
{
17
    [Serializable]
18

19
    [System.ComponentModel.DesignerCategory("code")]
20
    [XmlType(Namespace = "urn:schemas-microsoft-com:vml")]
21
    public class CT_Fill
22
    {
23

24
        private string idField;
25

26
        private ST_FillType typeField;
27

28
        private bool typeFieldSpecified;
29

30
        private ST_TrueFalse onField;
31

32
        private bool onFieldSpecified;
33

34
        private string colorField;
35

36
        private string opacityField;
37

38
        private string color2Field;
39

40
        private string srcField;
41

42
        private string sizeField;
43

44
        private string originField;
45

46
        private string positionField;
47

48
        private ST_ImageAspect aspectField;
49

50
        private bool aspectFieldSpecified;
51

52
        private string colorsField;
53

54
        private decimal angleField;
55

56
        private bool angleFieldSpecified;
57

58
        private ST_TrueFalse alignshapeField;
59

60
        private bool alignshapeFieldSpecified;
61

62
        private string focusField;
63

64
        private string focussizeField;
65

66
        private string focuspositionField;
67

68
        private ST_FillMethod methodField;
69

70
        private bool methodFieldSpecified;
71

72
        private ST_TrueFalse recolorField;
73

74
        private bool recolorFieldSpecified;
75

76
        private ST_TrueFalse rotateField;
77

78
        private bool rotateFieldSpecified;
79

80
        //private string id1Field;
81

82
        public static CT_Fill Parse(XmlNode node, XmlNamespaceManager namespaceManager)
83
        {
84
            if (node == null)
85
                return null;
86
            CT_Fill ctObj = new CT_Fill();
87
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
88
            if (node.Attributes["type"] != null)
89
                ctObj.type = (ST_FillType)Enum.Parse(typeof(ST_FillType), node.Attributes["type"].Value);
90
            if (node.Attributes["on"] != null)
91
                ctObj.on = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["on"]);
92
            ctObj.color = XmlHelper.ReadString(node.Attributes["color"]);
93
            ctObj.opacity = XmlHelper.ReadString(node.Attributes["opacity"]);
94
            ctObj.color2 = XmlHelper.ReadString(node.Attributes["color2"]);
95
            ctObj.src = XmlHelper.ReadString(node.Attributes["src"]);
96
            ctObj.size = XmlHelper.ReadString(node.Attributes["size"]);
97
            ctObj.origin = XmlHelper.ReadString(node.Attributes["origin"]);
98
            ctObj.position = XmlHelper.ReadString(node.Attributes["position"]);
99
            if (node.Attributes["aspect"] != null)
100
                ctObj.aspect = (ST_ImageAspect)Enum.Parse(typeof(ST_ImageAspect), node.Attributes["aspect"].Value);
101
            ctObj.colors = XmlHelper.ReadString(node.Attributes["colors"]);
102
            if (node.Attributes["angle"] != null)
103
                ctObj.angle = XmlHelper.ReadDecimal(node.Attributes["angle"]);
104
            if (node.Attributes["alignshape"] != null)
105
                    ctObj.alignshape = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["alignshape"]);
106
            ctObj.focus = XmlHelper.ReadString(node.Attributes["focus"]);
107
            ctObj.focussize = XmlHelper.ReadString(node.Attributes["focussize"]);
108
            ctObj.focusposition = XmlHelper.ReadString(node.Attributes["focusposition"]);
109
            if (node.Attributes["method"] != null)
110
                ctObj.method = (ST_FillMethod)Enum.Parse(typeof(ST_FillMethod), node.Attributes["method"].Value);
111
            if (node.Attributes["recolor"] != null)
112
                ctObj.recolor = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["recolor"]);
113
            if (node.Attributes["rotate"] != null)
114
                ctObj.rotate = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["rotate"]);
115
            return ctObj;
116
        }
117

118

119

120
        internal void Write(StreamWriter sw, string nodeName)
121
        {
122
            sw.Write(string.Format("<v:{0}", nodeName));
123
            XmlHelper.WriteAttribute(sw, "id", this.id);
124
            XmlHelper.WriteAttribute(sw, "type", this.type.ToString());
125
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "on", this.on);
126
            XmlHelper.WriteAttribute(sw, "color", this.color);
127
            XmlHelper.WriteAttribute(sw, "opacity", this.opacity);
128
            XmlHelper.WriteAttribute(sw, "color2", this.color2);
129
            XmlHelper.WriteAttribute(sw, "src", this.src);
130
            XmlHelper.WriteAttribute(sw, "size", this.size);
131
            XmlHelper.WriteAttribute(sw, "origin", this.origin);
132
            XmlHelper.WriteAttribute(sw, "position", this.position);
133
            XmlHelper.WriteAttribute(sw, "aspect", this.aspect.ToString());
134
            XmlHelper.WriteAttribute(sw, "colors", this.colors);
135
            XmlHelper.WriteAttribute(sw, "angle", (double)this.angle);
136
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "alignshape", this.alignshape);
137
            XmlHelper.WriteAttribute(sw, "focus", this.focus);
138
            XmlHelper.WriteAttribute(sw, "focussize", this.focussize);
139
            XmlHelper.WriteAttribute(sw, "focusposition", this.focusposition);
140
            XmlHelper.WriteAttribute(sw, "method", this.method.ToString());
141
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "recolor", this.recolor);
142
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "rotate", this.rotate);
143
            sw.Write(">");
144
            sw.Write(string.Format("</v:{0}>", nodeName));
145
        }
146

147
        [XmlAttribute]
148
        public string id
149
        {
150
            get
151
            {
152
                return this.idField;
153
            }
154
            set
155
            {
156
                this.idField = value;
157
            }
158
        }
159

160

161
        [XmlAttribute]
162
        public ST_FillType type
163
        {
164
            get
165
            {
166
                return this.typeField;
167
            }
168
            set
169
            {
170
                this.typeField = value;
171
            }
172
        }
173

174

175
        [XmlIgnore]
176
        public bool typeSpecified
177
        {
178
            get
179
            {
180
                return this.typeFieldSpecified;
181
            }
182
            set
183
            {
184
                this.typeFieldSpecified = value;
185
            }
186
        }
187

188

189
        [XmlAttribute]
190
        public ST_TrueFalse on
191
        {
192
            get
193
            {
194
                return this.onField;
195
            }
196
            set
197
            {
198
                this.onField = value;
199
            }
200
        }
201

202

203
        [XmlIgnore]
204
        public bool onSpecified
205
        {
206
            get
207
            {
208
                return this.onFieldSpecified;
209
            }
210
            set
211
            {
212
                this.onFieldSpecified = value;
213
            }
214
        }
215

216

217
        [XmlAttribute]
218
        public string color
219
        {
220
            get
221
            {
222
                return this.colorField;
223
            }
224
            set
225
            {
226
                this.colorField = value;
227
            }
228
        }
229

230

231
        [XmlAttribute]
232
        public string opacity
233
        {
234
            get
235
            {
236
                return this.opacityField;
237
            }
238
            set
239
            {
240
                this.opacityField = value;
241
            }
242
        }
243

244

245
        [XmlAttribute]
246
        public string color2
247
        {
248
            get
249
            {
250
                return this.color2Field;
251
            }
252
            set
253
            {
254
                this.color2Field = value;
255
            }
256
        }
257

258

259
        [XmlAttribute]
260
        public string src
261
        {
262
            get
263
            {
264
                return this.srcField;
265
            }
266
            set
267
            {
268
                this.srcField = value;
269
            }
270
        }
271

272

273
        [XmlAttribute]
274
        public string size
275
        {
276
            get
277
            {
278
                return this.sizeField;
279
            }
280
            set
281
            {
282
                this.sizeField = value;
283
            }
284
        }
285

286

287
        [XmlAttribute]
288
        public string origin
289
        {
290
            get
291
            {
292
                return this.originField;
293
            }
294
            set
295
            {
296
                this.originField = value;
297
            }
298
        }
299

300

301
        [XmlAttribute]
302
        public string position
303
        {
304
            get
305
            {
306
                return this.positionField;
307
            }
308
            set
309
            {
310
                this.positionField = value;
311
            }
312
        }
313

314

315
        [XmlAttribute]
316
        public ST_ImageAspect aspect
317
        {
318
            get
319
            {
320
                return this.aspectField;
321
            }
322
            set
323
            {
324
                this.aspectField = value;
325
            }
326
        }
327

328

329
        [XmlIgnore]
330
        public bool aspectSpecified
331
        {
332
            get
333
            {
334
                return this.aspectFieldSpecified;
335
            }
336
            set
337
            {
338
                this.aspectFieldSpecified = value;
339
            }
340
        }
341

342

343
        [XmlAttribute]
344
        public string colors
345
        {
346
            get
347
            {
348
                return this.colorsField;
349
            }
350
            set
351
            {
352
                this.colorsField = value;
353
            }
354
        }
355

356

357
        [XmlAttribute]
358
        public decimal angle
359
        {
360
            get
361
            {
362
                return this.angleField;
363
            }
364
            set
365
            {
366
                this.angleField = value;
367
            }
368
        }
369

370

371
        [XmlIgnore]
372
        public bool angleSpecified
373
        {
374
            get
375
            {
376
                return this.angleFieldSpecified;
377
            }
378
            set
379
            {
380
                this.angleFieldSpecified = value;
381
            }
382
        }
383

384

385
        [XmlAttribute]
386
        public ST_TrueFalse alignshape
387
        {
388
            get
389
            {
390
                return this.alignshapeField;
391
            }
392
            set
393
            {
394
                this.alignshapeField = value;
395
            }
396
        }
397

398

399
        [XmlIgnore]
400
        public bool alignshapeSpecified
401
        {
402
            get
403
            {
404
                return this.alignshapeFieldSpecified;
405
            }
406
            set
407
            {
408
                this.alignshapeFieldSpecified = value;
409
            }
410
        }
411

412

413
        [XmlAttribute]
414
        public string focus
415
        {
416
            get
417
            {
418
                return this.focusField;
419
            }
420
            set
421
            {
422
                this.focusField = value;
423
            }
424
        }
425

426

427
        [XmlAttribute]
428
        public string focussize
429
        {
430
            get
431
            {
432
                return this.focussizeField;
433
            }
434
            set
435
            {
436
                this.focussizeField = value;
437
            }
438
        }
439

440

441
        [XmlAttribute]
442
        public string focusposition
443
        {
444
            get
445
            {
446
                return this.focuspositionField;
447
            }
448
            set
449
            {
450
                this.focuspositionField = value;
451
            }
452
        }
453

454

455
        [XmlAttribute]
456
        public ST_FillMethod method
457
        {
458
            get
459
            {
460
                return this.methodField;
461
            }
462
            set
463
            {
464
                this.methodField = value;
465
            }
466
        }
467

468

469
        [XmlIgnore]
470
        public bool methodSpecified
471
        {
472
            get
473
            {
474
                return this.methodFieldSpecified;
475
            }
476
            set
477
            {
478
                this.methodFieldSpecified = value;
479
            }
480
        }
481

482

483
        [XmlAttribute]
484
        public ST_TrueFalse recolor
485
        {
486
            get
487
            {
488
                return this.recolorField;
489
            }
490
            set
491
            {
492
                this.recolorField = value;
493
            }
494
        }
495

496

497
        [XmlIgnore]
498
        public bool recolorSpecified
499
        {
500
            get
501
            {
502
                return this.recolorFieldSpecified;
503
            }
504
            set
505
            {
506
                this.recolorFieldSpecified = value;
507
            }
508
        }
509

510

511
        [XmlAttribute]
512
        public ST_TrueFalse rotate
513
        {
514
            get
515
            {
516
                return this.rotateField;
517
            }
518
            set
519
            {
520
                this.rotateField = value;
521
            }
522
        }
523

524

525
        [XmlIgnore]
526
        public bool rotateSpecified
527
        {
528
            get
529
            {
530
                return this.rotateFieldSpecified;
531
            }
532
            set
533
            {
534
                this.rotateFieldSpecified = value;
535
            }
536
        }
537
    }
538

539

540
    [Serializable]
541
    [XmlType(Namespace = "urn:schemas-microsoft-com:vml")]
542
    public enum ST_FillType
543
    {
544

545

546
        solid,
547

548

549
        gradient,
550

551

552
        gradientRadial,
553

554

555
        tile,
556

557

558
        pattern,
559

560

561
        frame,
562
    }
563

564

565
    [Serializable]
566
    [XmlType(Namespace = "urn:schemas-microsoft-com:vml")]
567
    public enum ST_TrueFalse
568
    {
569

570
        f,
571
        t,
572
        @true,
573
        @false,
574
    }
575

576

577
    [Serializable]
578
    [XmlType(Namespace = "urn:schemas-microsoft-com:vml")]
579
    public enum ST_ImageAspect
580
    {
581

582

583
        ignore,
584

585

586
        atMost,
587

588

589
        atLeast,
590
    }
591

592

593
    [Serializable]
594
    [XmlType(Namespace = "urn:schemas-microsoft-com:vml")]
595
    public enum ST_FillMethod
596
    {
597

598

599
        none,
600

601

602
        linear,
603

604

605
        sigma,
606

607

608
        any,
609

610

611
        [XmlEnum("linear sigma")]
612
        linearsigma,
613
    }
614
    [Serializable]
615

616
    [System.ComponentModel.DesignerCategory("code")]
617
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
618
    [XmlRoot("shape",Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
619
    public class  CT_Shape {
620
        
621
        
622
        private string typeField;
623
        
624
        private string adjField;
625
        private string styleField;
626
        private CT_Path pathField;
627
        
628
        private string equationxmlField;
629

630
        private string idField;
631
        private string fillcolorField;
632
        private ST_InsetMode insetmodeField;
633

634
        private ST_TrueFalse strokedField;
635
        private string wrapcoordsField;
636

637
        public static CT_Shape Parse(XmlNode node, XmlNamespaceManager namespaceManager)
638
        {
639
            if (node == null)
640
                return null;
641
            CT_Shape ctObj = new CT_Shape();
642
            ctObj.wrapcoords = XmlHelper.ReadString(node.Attributes["wrapcoords"]);
643
            if (node.Attributes["stroked"] != null)
644
                ctObj.stroked = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["stroked"]);
645
            ctObj.spid = XmlHelper.ReadString(node.Attributes["o:spid"]);
646
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
647
            ctObj.fillcolor = XmlHelper.ReadString(node.Attributes["fillcolor"]);
648
            if (node.Attributes["o:insetmode"] != null)
649
                ctObj.insetmode = (ST_InsetMode)Enum.Parse(typeof(ST_InsetMode), node.Attributes["o:insetmode"].Value);
650
            ctObj.type = XmlHelper.ReadString(node.Attributes["type"]);
651
            ctObj.adj = XmlHelper.ReadString(node.Attributes["adj"]);
652
            ctObj.equationxml = XmlHelper.ReadString(node.Attributes["equationxml"]);
653
            ctObj.style = XmlHelper.ReadString(node.Attributes["style"]);
654
            ctObj.ClientData = new List<CT_ClientData>();
655
            foreach (XmlNode childNode in node.ChildNodes)
656
            {
657
                if (childNode.LocalName == "textdata")
658
                    ctObj.textdata = CT_Rel.Parse(childNode, namespaceManager);
659
                else if (childNode.LocalName == "anchorlock")
660
                    ctObj.anchorlock = new CT_AnchorLock();
661
                else if (childNode.LocalName == "borderright")
662
                    ctObj.borderright = CT_Border.Parse(childNode, namespaceManager);
663
                else if (childNode.LocalName == "borderleft")
664
                    ctObj.borderleft = CT_Border.Parse(childNode, namespaceManager);
665
                else if (childNode.LocalName == "borderbottom")
666
                    ctObj.borderbottom = CT_Border.Parse(childNode, namespaceManager);
667
                else if (childNode.LocalName == "bordertop")
668
                    ctObj.bordertop = CT_Border.Parse(childNode, namespaceManager);
669
                else if (childNode.LocalName == "iscomment")
670
                    ctObj.iscomment = new CT_Empty();
671
                else if (childNode.LocalName == "stroke")
672
                    ctObj.stroke = CT_Stroke.Parse(childNode, namespaceManager);
673
                else if (childNode.LocalName == "wrap")
674
                    ctObj.wrap = CT_Wrap.Parse(childNode, namespaceManager);
675
                else if (childNode.LocalName == "textbox")
676
                    ctObj.textbox = CT_Textbox.Parse(childNode, namespaceManager);
677
                else if (childNode.LocalName == "fill")
678
                    ctObj.fill = CT_Fill.Parse(childNode, namespaceManager);
679
                else if (childNode.LocalName == "formulas")
680
                    ctObj.formulas = CT_Formulas.Parse(childNode, namespaceManager);
681
                else if (childNode.LocalName == "handles")
682
                    ctObj.handles = CT_Handles.Parse(childNode, namespaceManager);
683
                else if (childNode.LocalName == "imagedata")
684
                    ctObj.imagedata = CT_ImageData.Parse(childNode, namespaceManager);
685
                else if (childNode.LocalName == "lock")
686
                    ctObj.@lock = CT_Lock.Parse(childNode, namespaceManager);
687
                else if (childNode.LocalName == "shadow")
688
                    ctObj.shadow = CT_Shadow.Parse(childNode, namespaceManager);
689
                else if (childNode.LocalName == "path")
690
                    ctObj.path = CT_Path.Parse(childNode, namespaceManager);
691
                else if (childNode.LocalName == "textpath")
692
                    ctObj.textpath = CT_TextPath.Parse(childNode, namespaceManager);
693
                else if (childNode.LocalName == "ClientData")
694
                    ctObj.ClientData.Add(CT_ClientData.Parse(childNode, namespaceManager));
695
            }
696
            return ctObj;
697
        }
698

699

700

701
        public void Write(StreamWriter sw, string nodeName)
702
        {
703
            sw.Write(string.Format("<v:{0}", nodeName));
704
            XmlHelper.WriteAttribute(sw, "id", this.id);
705
            XmlHelper.WriteAttribute(sw, "o:spid", this.spid);
706
            XmlHelper.WriteAttribute(sw, "type", this.type);
707
            XmlHelper.WriteAttribute(sw, "style", this.style);
708
            XmlHelper.WriteAttribute(sw, "fillcolor", this.fillcolor);
709
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "stroked", this.stroked);
710
            XmlHelper.WriteAttribute(sw, "wrapcoords", this.wrapcoords);
711
            XmlHelper.WriteAttribute(sw, "o:insetmode", this.insetmode.ToString());
712
            XmlHelper.WriteAttribute(sw, "adj", this.adj);
713
            XmlHelper.WriteAttribute(sw, "equationxml", this.equationxml);
714
            sw.Write(">");
715

716
            if (this.iscomment != null)
717
                sw.Write("<iscomment/>");
718
            if (this.stroke != null)
719
                this.stroke.Write(sw, "stroke");
720
            if (this.wrap != null)
721
                this.wrap.Write(sw, "wrap");
722
            if (this.fill != null)
723
                this.fill.Write(sw, "fill");
724
            if (this.formulas != null)
725
                this.formulas.Write(sw, "formulas");
726
            if (this.handles != null)
727
                this.handles.Write(sw, "handles");
728
            if (this.imagedata != null)
729
                this.imagedata.Write(sw, "imagedata");
730
            if (this.@lock != null)
731
                this.@lock.Write(sw, "lock");
732
            if (this.shadow != null)
733
                this.shadow.Write(sw, "shadow");
734
            if (this.path != null)
735
                this.path.Write(sw, "path");
736
            if (this.textpath != null)
737
                this.textpath.Write(sw, "textpath");
738
            if (this.textbox != null)
739
                this.textbox.Write(sw, "textbox");
740
            if (this.textdata != null)
741
                this.textdata.Write(sw, "textdata");
742
            if (this.anchorlock != null)
743
                sw.Write("<w:anchorlock/>");
744
            if (this.borderright != null)
745
                this.borderright.Write(sw, "borderright");
746
            if (this.borderleft != null)
747
                this.borderleft.Write(sw, "borderleft");
748
            if (this.borderbottom != null)
749
                this.borderbottom.Write(sw, "borderbottom");
750
            if (this.bordertop != null)
751
                this.bordertop.Write(sw, "bordertop");
752
            if (this.ClientData != null)
753
            {
754
                foreach (CT_ClientData x in this.ClientData)
755
                {
756
                    x.Write(sw, "ClientData");
757
                }
758
            }
759
            sw.Write(string.Format("</v:{0}>", nodeName));
760
        }
761

762
        [XmlAttribute]
763
        public string wrapcoords
764
        {
765
            get { return wrapcoordsField; }
766
            set { wrapcoordsField = value; }
767
        }
768
        [XmlAttribute]
769
        [DefaultValue(ST_TrueFalse.t)]
770
        public ST_TrueFalse stroked
771
        {
772
            get { return strokedField; }
773
            set { strokedField = value; }
774
        }
775

776

777
        //static XmlSerializer serializer = new XmlSerializer(typeof(CT_Shape), "urn:schemas-microsoft-com:vml");
778
        //public static CT_Shape Parse(string xmltext)
779
        //{
780
        //    TextReader tr = new StringReader(xmltext);
781
        //    CT_Shape obj = (CT_Shape)serializer.Deserialize(tr);
782
        //    return obj;
783
        //}
784
        private string spidField;
785

786
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
787
        public string spid
788
        {
789
            get { return this.spidField; }
790
            set { this.spidField = value; }
791
        }
792
        [XmlAttribute]
793
        public string id
794
        {
795
            get { return idField; }
796
            set { idField = value; }
797
        }
798

799
        [XmlAttribute]
800
        public string fillcolor
801
        {
802
            get { return fillcolorField; }
803
            set { fillcolorField = value; }
804
        }
805

806
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
807
        [DefaultValue(ST_InsetMode.auto)]
808
        public ST_InsetMode insetmode
809
        {
810
            get { return insetmodeField; }
811
            set { insetmodeField = value; }
812
        }
813

814
        public CT_Textbox AddNewTextbox()
815
        {
816
            textboxField = new CT_Textbox();
817
            return this.textboxField;
818
        }
819

820
        private CT_Wrap wrapField;
821
        private CT_Fill fillField;
822
        private CT_Formulas formulasField;
823
        private CT_Handles handlesField;
824
        private CT_ImageData imagedataField;
825
        private CT_Stroke strokeField;
826
        private CT_Shadow shadowField;
827
        private CT_Textbox textboxField;
828
        private CT_TextPath textpathField;
829
        private CT_Empty iscommentField;
830
        private CT_Lock lockField;
831
        private CT_Border bordertopField;
832
        private CT_Border borderrightField;
833
        private CT_Border borderleftField;
834
        private CT_Border borderbottomField;
835
        private CT_AnchorLock anchorlockField;
836
        private CT_Rel textdataField;
837

838
        [XmlElement(Namespace = "urn:schemas-microsoft-com:office:powerpoint")]
839
        public CT_Rel textdata
840
        {
841
            get { return this.textdataField; }
842
            set { this.textdataField = value; }
843
        }
844
        [XmlElement(Namespace = "urn:schemas-microsoft-com:office:word")]
845
        public CT_AnchorLock anchorlock
846
        {
847
            get { return this.anchorlockField; }
848
            set { this.anchorlockField = value; }
849
        }
850
        [XmlElement(Namespace = "urn:schemas-microsoft-com:office:word")]
851
        public CT_Border borderright
852
        {
853
            get { return this.borderrightField; }
854
            set { this.borderrightField = value; }
855
        }
856
        [XmlElement(Namespace = "urn:schemas-microsoft-com:office:word")]
857
        public CT_Border borderleft
858
        {
859
            get { return this.borderleftField; }
860
            set { this.borderleftField = value; }
861
        }
862
        [XmlElement(Namespace = "urn:schemas-microsoft-com:office:word")]
863
        public CT_Border borderbottom
864
        {
865
            get { return this.borderbottomField; }
866
            set { this.borderbottomField = value; }
867
        }
868
        [XmlElement(Namespace = "urn:schemas-microsoft-com:office:word")]
869
        public CT_Border bordertop
870
        {
871
            get { return this.bordertopField; }
872
            set { this.bordertopField = value; }
873
        }
874
        [XmlElement(Namespace = "urn:schemas-microsoft-com:office:powerpoint")]
875
        public CT_Empty iscomment
876
        {
877
            get { return this.iscommentField; }
878
            set { this.iscommentField = value; }
879
        }
880
        [XmlElement]
881
        public CT_Stroke stroke
882
        {
883
            get { return this.strokeField; }
884
            set { this.strokeField = value; }
885
        }
886

887

888
        [XmlElement(Namespace="urn:schemas-microsoft-com:office:word")]
889
        public CT_Wrap wrap
890
        {
891
            get { return this.wrapField; }
892
            set { this.wrapField = value; }
893
        }
894
        [XmlElement]
895
        public CT_Textbox textbox
896
        {
897
            get { return this.textboxField; }
898
            set { this.textboxField = value; }
899
        }
900
        [XmlElement]
901
        public CT_Fill fill
902
        {
903
            get { return this.fillField; }
904
            set { this.fillField = value; }
905
        }
906
        [XmlElement]
907
        public CT_Formulas formulas
908
        {
909
            get { return this.formulasField; }
910
            set { this.formulasField = value; }
911
        }
912
        [XmlElement]
913
        public CT_Handles handles
914
        {
915
            get { return this.handlesField; }
916
            set { this.handlesField = value; }
917
        }
918
        [XmlElement]
919
        public CT_ImageData imagedata
920
        {
921
            get { return this.imagedataField; }
922
            set { this.imagedataField = value; }
923
        }
924
        [XmlElement(ElementName = "lock", Namespace = "urn:schemas-microsoft-com:office:office")]
925
        public CT_Lock @lock
926
        {
927
            get
928
            {
929
                return this.lockField;
930
            }
931
            set
932
            {
933
                this.lockField = value;
934
            }
935
        }
936

937
        [XmlElement]
938
        public CT_Shadow shadow
939
        {
940
            get { return this.shadowField; }
941
            set { this.shadowField = value; }
942
        }
943

944
        public CT_Fill AddNewFill()
945
        {
946
            this.fillField=new CT_Fill();
947
            return this.fillField;
948
        }
949
        public CT_Shadow AddNewShadow()
950
        {
951
            this.shadowField = new CT_Shadow();
952
            return this.shadowField;
953
        }
954
        public CT_Path AddNewPath()
955
        {
956
            this.pathField = new CT_Path();
957
            return this.pathField;       
958
        }
959

960
        List<CT_ClientData> clientDataField = null;
961
        public List<CT_ClientData> ClientData
962
        {
963
            get
964
            {
965
                return clientDataField;
966
            }
967
            set
968
            {
969
                    this.clientDataField = value;
970
            }
971
        }
972
        public CT_ClientData GetClientDataArray(int index)
973
        {
974
            return clientDataField != null ? this.clientDataField[index] : null;
975
        }
976
        public int sizeOfClientDataArray()
977
        {
978
            if (clientDataField == null)
979
                return 0;
980
            return clientDataField.Count;
981
        }
982
        public CT_ClientData AddNewClientData()
983
        {
984
            CT_ClientData cd=new CT_ClientData();
985
            if (clientDataField == null)
986
                this.clientDataField = new List<CT_ClientData>();
987
            this.clientDataField.Add(cd);
988
            return cd;
989
        }
990
        
991
        
992
        [XmlAttribute]
993
        public string type {
994
            get {
995
                return this.typeField;
996
            }
997
            set {
998
                this.typeField = value;
999
            }
1000
        }
1001
        
1002
        
1003
        [XmlAttribute]
1004
        public string adj {
1005
            get {
1006
                return this.adjField;
1007
            }
1008
            set {
1009
                this.adjField = value;
1010
            }
1011
        }
1012
        
1013
        
1014
        [XmlElement]
1015
        public CT_Path path {
1016
            get {
1017
                return this.pathField;
1018
            }
1019
            set {
1020
                this.pathField = value;
1021
            }
1022
        }
1023
        
1024
        
1025
        [XmlAttribute]
1026
        public string equationxml {
1027
            get {
1028
                return this.equationxmlField;
1029
            }
1030
            set {
1031
                this.equationxmlField = value;
1032
            }
1033
        }
1034
        [XmlAttribute]
1035
        public string style
1036
        {
1037
            get 
1038
            {
1039
                return this.styleField;
1040
            }
1041
            set 
1042
            {
1043
                this.styleField = value;
1044
            }
1045
        }
1046
        //internal static XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(new XmlQualifiedName[] {
1047
        //    new XmlQualifiedName("o", "urn:schemas-microsoft-com:office:office"),
1048
        //    new XmlQualifiedName("x", "urn:schemas-microsoft-com:office:excel"),
1049
        //    new XmlQualifiedName("v", "urn:schemas-microsoft-com:vml")
1050
        //});
1051

1052
        //public override string ToString()
1053
        //{
1054
        //    using (StringWriter stringWriter = new StringWriter())
1055
        //    {
1056
        //        XmlWriterSettings settings = new XmlWriterSettings();
1057
                
1058
        //        settings.Encoding = Encoding.UTF8;
1059
        //        settings.OmitXmlDeclaration = true;
1060

1061
        //        using (XmlWriter writer = XmlWriter.Create(stringWriter, settings))
1062
        //        {
1063
        //            serializer.Serialize(writer, this, namespaces);
1064
        //        }
1065
        //        return stringWriter.ToString();
1066
        //    }
1067
        //}
1068
        [XmlElement]
1069
        public CT_TextPath textpath
1070
        {
1071
            get
1072
            {
1073
                return this.textpathField;
1074
            }
1075
            set
1076
            {
1077
                this.textpathField = value;
1078
            }
1079
        }
1080

1081
        public void Set(CT_Shape shape)
1082
        {
1083
            this.adj = shape.adj;
1084
            this.anchorlock = shape.anchorlock;
1085
            this.borderbottom = shape.borderbottom;
1086
            this.borderleft = shape.borderleft;
1087
            this.borderright = shape.borderright;
1088
            this.bordertop = shape.bordertop;
1089
            this.equationxml = shape.equationxml;
1090
            this.fill = shape.fill;
1091
            this.fillcolor = shape.fillcolor;
1092
            this.formulas = shape.formulas;
1093
            this.handles = shape.handles;
1094
            this.imagedata = shape.imagedata;
1095
            this.insetmode = shape.insetmode;
1096
            this.iscomment = shape.iscomment;
1097
            this.@lock = shape.@lock;
1098
            this.path = shape.path;
1099
            this.shadow = shape.shadow;
1100
            this.spid = shape.spid;
1101
            this.stroke = shape.stroke;
1102
            this.stroked = shape.stroked;
1103
            this.style = shape.style;
1104
            this.textbox = shape.textbox;
1105
            this.textdata = shape.textdata;
1106
            this.textpath = shape.textpath;
1107
            this.wrap = shape.wrap;
1108
            this.wrapcoords = shape.wrapcoords;
1109
        }
1110

1111
        public CT_TextPath AddNewTextpath()
1112
        {
1113
            this.textpathField = new CT_TextPath();
1114
            return this.textpathField;
1115
        }
1116

1117
        public int SizeOfClientDataArray()
1118
        {
1119
            return clientDataField == null ? 0 : clientDataField.Count;
1120
        }
1121
    }
1122
    
1123
    
1124
    [Serializable]
1125

1126
    [System.ComponentModel.DesignerCategory("code")]
1127
    [XmlType(Namespace = "urn:schemas-microsoft-com:vml")]
1128
    public class CT_Formulas
1129
    {
1130
        private List<CT_F> fField = null; // 0..* 
1131

1132
       
1133
        [XmlElement("f", Form = XmlSchemaForm.Qualified, Namespace = "urn:schemas-microsoft-com:vml")]
1134
        public List<CT_F> f
1135
        {
1136
            get { return this.fField; }
1137
            set { this.fField = value; }
1138
        }
1139
        [XmlIgnore]
1140
        public bool fSpecified
1141
        {
1142
            get { return (null != fField); }
1143
        }
1144

1145
        public CT_F AddNewF()
1146
        {
1147
            if (this.fField == null)
1148
                this.fField = new List<CT_F>();
1149
            this.fField.Add(new CT_F());
1150
            return this.fField[this.fField.Count - 1];
1151
        }
1152

1153
        public static CT_Formulas Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1154
        {
1155
            if (node == null)
1156
                return null;
1157
            CT_Formulas ctObj = new CT_Formulas();
1158
            ctObj.f = new List<CT_F>();
1159
            foreach (XmlNode childNode in node.ChildNodes)
1160
            {
1161
                if (childNode.LocalName == "f")
1162
                    ctObj.f.Add(CT_F.Parse(childNode, namespaceManager));
1163
            }
1164
            return ctObj;
1165
        }
1166

1167

1168

1169
        internal void Write(StreamWriter sw, string nodeName)
1170
        {
1171
            sw.Write(string.Format("<v:{0}", nodeName));
1172
            sw.Write(">");
1173
            if (this.f != null)
1174
            {
1175
                foreach (CT_F x in this.f)
1176
                {
1177
                    x.Write(sw, "f");
1178
                }
1179
            }
1180
            sw.Write(string.Format("</v:{0}>", nodeName));
1181
        }
1182

1183
    }
1184

1185

1186
    [Serializable]
1187

1188
    [System.ComponentModel.DesignerCategory("code")]
1189
    [XmlType(Namespace = "urn:schemas-microsoft-com:vml")]
1190
    public class CT_F
1191
    {
1192
        private string eqnField = null;
1193

1194
        [XmlAttribute]
1195
        public string eqn
1196
        {
1197
            get { return this.eqnField; }
1198
            set { this.eqnField = value; }
1199
        }
1200
        [XmlIgnore]
1201
        public bool eqnSpecified
1202
        {
1203
            get { return (null != eqnField); }
1204
        }
1205
        public static CT_F Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1206
        {
1207
            if (node == null)
1208
                return null;
1209
            CT_F ctObj = new CT_F();
1210
            ctObj.eqn = XmlHelper.ReadString(node.Attributes["eqn"]);
1211
            return ctObj;
1212
        }
1213

1214

1215

1216
        internal void Write(StreamWriter sw, string nodeName)
1217
        {
1218
            sw.Write(string.Format("<v:{0}", nodeName));
1219
            XmlHelper.WriteAttribute(sw, "eqn", this.eqn);
1220
            sw.Write("/>");
1221
        }
1222

1223
    }
1224

1225

1226
    [Serializable]
1227

1228
    [System.ComponentModel.DesignerCategory("code")]
1229
    [XmlType(Namespace = "urn:schemas-microsoft-com:vml")]
1230
    public class CT_Handles
1231
    {
1232

1233
        private List<CT_H> hField = null;
1234

1235
        [XmlElement("h")]
1236
        public List<CT_H> h
1237
        {
1238
            get { return this.hField; }
1239
            set { this.hField = value; }
1240
        }
1241
        [XmlIgnore]
1242
        public bool hSpecified
1243
        {
1244
            get { return (null != hField); }
1245
        }
1246

1247
        public CT_H AddNewH()
1248
        {
1249
            if (hField == null)
1250
                hField = new List<CT_H>();
1251
            CT_H h = new CT_H();
1252
            hField.Add(h);
1253
            return h;
1254
        }
1255

1256
        public static CT_Handles Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1257
        {
1258
            if (node == null)
1259
                return null;
1260
            CT_Handles ctObj = new CT_Handles();
1261
            ctObj.h = new List<CT_H>();
1262
            foreach (XmlNode childNode in node.ChildNodes)
1263
            {
1264
                if (childNode.LocalName == "h")
1265
                    ctObj.h.Add(CT_H.Parse(childNode, namespaceManager));
1266
            }
1267
            return ctObj;
1268
        }
1269

1270

1271

1272
        internal void Write(StreamWriter sw, string nodeName)
1273
        {
1274
            sw.Write(string.Format("<v:{0}", nodeName));
1275
            sw.Write(">");
1276
            if (this.h != null)
1277
            {
1278
                foreach (CT_H x in this.h)
1279
                {
1280
                    x.Write(sw, "h");
1281
                }
1282
            }
1283
            sw.Write(string.Format("</v:{0}>", nodeName));
1284
        }
1285

1286
    }
1287
    
1288
    
1289
    [Serializable]
1290

1291
    [System.ComponentModel.DesignerCategory("code")]
1292
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
1293
    public class CT_H {
1294
        
1295
        private string positionField;
1296
        
1297
        private string polarField;
1298
        
1299
        private string mapField;
1300
        
1301
        private ST_TrueFalse invxField;
1302
        
1303
        private bool invxFieldSpecified;
1304
        
1305
        private ST_TrueFalse invyField;
1306
        
1307
        private bool invyFieldSpecified; // TODO remove
1308
        
1309
        private ST_TrueFalseBlank switchField;
1310
        
1311
        private bool switchFieldSpecified;
1312
        
1313
        private string xrangeField;
1314
        
1315
        private string yrangeField;
1316
        
1317
        private string radiusrangeField;
1318
        
1319
        
1320
        [XmlAttribute]
1321
        public string position {
1322
            get {
1323
                return this.positionField;
1324
            }
1325
            set {
1326
                this.positionField = value;
1327
            }
1328
        }
1329
        
1330
        
1331
        [XmlAttribute]
1332
        public string polar {
1333
            get {
1334
                return this.polarField;
1335
            }
1336
            set {
1337
                this.polarField = value;
1338
            }
1339
        }
1340
        
1341
        
1342
        [XmlAttribute]
1343
        public string map {
1344
            get {
1345
                return this.mapField;
1346
            }
1347
            set {
1348
                this.mapField = value;
1349
            }
1350
        }
1351
        
1352
        
1353
        [XmlAttribute]
1354
        public ST_TrueFalse invx {
1355
            get {
1356
                return this.invxField;
1357
            }
1358
            set {
1359
                this.invxField = value;
1360
            }
1361
        }
1362
        
1363
        
1364
        [XmlIgnore]
1365
        public bool invxSpecified {
1366
            get {
1367
                return this.invxFieldSpecified;
1368
            }
1369
            set {
1370
                this.invxFieldSpecified = value;
1371
            }
1372
        }
1373
        
1374
        
1375
        [XmlAttribute]
1376
        public ST_TrueFalse invy {
1377
            get {
1378
                return this.invyField;
1379
            }
1380
            set {
1381
                this.invyField = value;
1382
            }
1383
        }
1384
        
1385
        
1386
        [XmlIgnore]
1387
        public bool invySpecified {
1388
            get {
1389
                return this.invyFieldSpecified;
1390
            }
1391
            set {
1392
                this.invyFieldSpecified = value;
1393
            }
1394
        }
1395
        
1396
        
1397
        [XmlAttribute]
1398
        public ST_TrueFalseBlank @switch {
1399
            get {
1400
                return this.switchField;
1401
            }
1402
            set {
1403
                this.switchField = value;
1404
            }
1405
        }
1406
        
1407
        
1408
        [XmlIgnore]
1409
        public bool switchSpecified {
1410
            get {
1411
                return this.switchFieldSpecified;
1412
            }
1413
            set {
1414
                this.switchFieldSpecified = value;
1415
            }
1416
        }
1417
        
1418
        
1419
        [XmlAttribute]
1420
        public string xrange {
1421
            get {
1422
                return this.xrangeField;
1423
            }
1424
            set {
1425
                this.xrangeField = value;
1426
            }
1427
        }
1428
        
1429
        
1430
        [XmlAttribute]
1431
        public string yrange {
1432
            get {
1433
                return this.yrangeField;
1434
            }
1435
            set {
1436
                this.yrangeField = value;
1437
            }
1438
        }
1439
        
1440
        
1441
        [XmlAttribute]
1442
        public string radiusrange {
1443
            get {
1444
                return this.radiusrangeField;
1445
            }
1446
            set {
1447
                this.radiusrangeField = value;
1448
            }
1449
        }
1450
        public static CT_H Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1451
        {
1452
            if (node == null)
1453
                return null;
1454
            CT_H ctObj = new CT_H();
1455
            ctObj.position = XmlHelper.ReadString(node.Attributes["position"]);
1456
            ctObj.polar = XmlHelper.ReadString(node.Attributes["polar"]);
1457
            ctObj.map = XmlHelper.ReadString(node.Attributes["map"]);
1458
            if (node.Attributes["invx"] != null)
1459
                ctObj.invx = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["invx"]);
1460
            if (node.Attributes["invy"] != null)
1461
                ctObj.invy = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["invy"]);
1462
            if (node.Attributes["switch"] != null)
1463
                ctObj.@switch = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalseBlank(node.Attributes["switch"]);
1464
            ctObj.xrange = XmlHelper.ReadString(node.Attributes["xrange"]);
1465
            ctObj.yrange = XmlHelper.ReadString(node.Attributes["yrange"]);
1466
            ctObj.radiusrange = XmlHelper.ReadString(node.Attributes["radiusrange"]);
1467
            return ctObj;
1468
        }
1469

1470

1471

1472
        internal void Write(StreamWriter sw, string nodeName)
1473
        {
1474
            sw.Write(string.Format("<v:{0}", nodeName));
1475
            XmlHelper.WriteAttribute(sw, "position", this.position);
1476
            XmlHelper.WriteAttribute(sw, "polar", this.polar);
1477
            XmlHelper.WriteAttribute(sw, "map", this.map);
1478
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "invx", this.invx);
1479
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "invy", this.invy);
1480
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "switch", this.@switch);
1481
            XmlHelper.WriteAttribute(sw, "xrange", this.xrange);
1482
            XmlHelper.WriteAttribute(sw, "yrange", this.yrange);
1483
            XmlHelper.WriteAttribute(sw, "radiusrange", this.radiusrange);
1484
            sw.Write(">");
1485
            sw.Write(string.Format("</v:{0}>", nodeName));
1486
        }
1487
    }
1488
    
1489
    
1490
    [Serializable]
1491

1492
    [System.ComponentModel.DesignerCategory("code")]
1493
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
1494
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
1495
    public class CT_ImageData {
1496

1497

1498
        private string relidField;
1499
        private string titleField;
1500
        private string oleidField;
1501
        private string movieField;
1502
        private string idField;
1503
        
1504
        private string srcField;
1505
        
1506
        private string cropleftField;
1507
        
1508
        private string croptopField;
1509
        
1510
        private string croprightField;
1511
        
1512
        private string cropbottomField;
1513
        
1514
        private string gainField;
1515
        
1516
        private string blacklevelField;
1517
        
1518
        private string gammaField;
1519
        
1520
        private ST_TrueFalse grayscaleField;
1521
        
1522
        private bool grayscaleFieldSpecified;
1523
        
1524
        private ST_TrueFalse bilevelField;
1525
        
1526
        private bool bilevelFieldSpecified;
1527
        
1528
        private string chromakeyField;
1529
        
1530
        private string embosscolorField;
1531
        
1532
        private string recolortargetField;
1533
        
1534
        //private string id1Field;
1535
        
1536
        private string pictField;
1537
        
1538
        private string hrefField;
1539

1540
        public static CT_ImageData Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1541
        {
1542
            if (node == null)
1543
                return null;
1544
            CT_ImageData ctObj = new CT_ImageData();
1545
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
1546
            ctObj.src = XmlHelper.ReadString(node.Attributes["src"]);
1547
            ctObj.cropleft = XmlHelper.ReadString(node.Attributes["cropleft"]);
1548
            ctObj.croptop = XmlHelper.ReadString(node.Attributes["croptop"]);
1549
            ctObj.cropright = XmlHelper.ReadString(node.Attributes["cropright"]);
1550
            ctObj.cropbottom = XmlHelper.ReadString(node.Attributes["cropbottom"]);
1551
            ctObj.gain = XmlHelper.ReadString(node.Attributes["gain"]);
1552
            ctObj.blacklevel = XmlHelper.ReadString(node.Attributes["blacklevel"]);
1553
            ctObj.gamma = XmlHelper.ReadString(node.Attributes["gamma"]);
1554
            if (node.Attributes["grayscale"] != null)
1555
                ctObj.grayscale = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["grayscale"]);
1556
            if (node.Attributes["bilevel"] != null)
1557
                ctObj.bilevel = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["bilevel"]);
1558
            ctObj.chromakey = XmlHelper.ReadString(node.Attributes["chromakey"]);
1559
            ctObj.embosscolor = XmlHelper.ReadString(node.Attributes["embosscolor"]);
1560
            ctObj.recolortarget = XmlHelper.ReadString(node.Attributes["recolortarget"]);
1561
            ctObj.pict = XmlHelper.ReadString(node.Attributes["pict"]);
1562
            ctObj.href = XmlHelper.ReadString(node.Attributes["r:href"]);
1563
            ctObj.relid = XmlHelper.ReadString(node.Attributes["o:relid"]);
1564
            ctObj.title = XmlHelper.ReadString(node.Attributes["o:title"]);
1565
            ctObj.movie = XmlHelper.ReadString(node.Attributes["o:movie"]);
1566
            ctObj.oleid = XmlHelper.ReadString(node.Attributes["o:oleid"]);
1567
            return ctObj;
1568
        }
1569

1570

1571

1572
        internal void Write(StreamWriter sw, string nodeName)
1573
        {
1574
            sw.Write(string.Format("<v:{0}", nodeName));
1575
            XmlHelper.WriteAttribute(sw, "id", this.id);
1576
            XmlHelper.WriteAttribute(sw, "src", this.src);
1577
            XmlHelper.WriteAttribute(sw, "cropleft", this.cropleft);
1578
            XmlHelper.WriteAttribute(sw, "croptop", this.croptop);
1579
            XmlHelper.WriteAttribute(sw, "cropright", this.cropright);
1580
            XmlHelper.WriteAttribute(sw, "cropbottom", this.cropbottom);
1581
            XmlHelper.WriteAttribute(sw, "gain", this.gain);
1582
            XmlHelper.WriteAttribute(sw, "blacklevel", this.blacklevel);
1583
            XmlHelper.WriteAttribute(sw, "gamma", this.gamma);
1584
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "grayscale", this.grayscale);
1585
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "bilevel", this.bilevel);
1586
            XmlHelper.WriteAttribute(sw, "chromakey", this.chromakey);
1587
            XmlHelper.WriteAttribute(sw, "embosscolor", this.embosscolor);
1588
            XmlHelper.WriteAttribute(sw, "recolortarget", this.recolortarget);
1589
            XmlHelper.WriteAttribute(sw, "pict", this.pict);
1590
            XmlHelper.WriteAttribute(sw, "r:href", this.href);
1591
            XmlHelper.WriteAttribute(sw, "o:relid", this.relid);
1592
            XmlHelper.WriteAttribute(sw, "o:title", this.title);
1593
            XmlHelper.WriteAttribute(sw, "o:movie", this.movie);
1594
            XmlHelper.WriteAttribute(sw, "o:oleid", this.oleid);
1595
            sw.Write("/>");
1596
        }
1597

1598
        [XmlAttribute]
1599
        public string id
1600
        {
1601
            get {
1602
                return this.idField;
1603
            }
1604
            set {
1605
                this.idField = value;
1606
            }
1607
        }
1608
        
1609
        
1610
        [XmlAttribute]
1611
        public string src {
1612
            get {
1613
                return this.srcField;
1614
            }
1615
            set {
1616
                this.srcField = value;
1617
            }
1618
        }
1619
        
1620
        
1621
        [XmlAttribute]
1622
        public string cropleft {
1623
            get {
1624
                return this.cropleftField;
1625
            }
1626
            set {
1627
                this.cropleftField = value;
1628
            }
1629
        }
1630
        
1631
        
1632
        [XmlAttribute]
1633
        public string croptop {
1634
            get {
1635
                return this.croptopField;
1636
            }
1637
            set {
1638
                this.croptopField = value;
1639
            }
1640
        }
1641
        
1642
        
1643
        [XmlAttribute]
1644
        public string cropright {
1645
            get {
1646
                return this.croprightField;
1647
            }
1648
            set {
1649
                this.croprightField = value;
1650
            }
1651
        }
1652
        
1653
        
1654
        [XmlAttribute]
1655
        public string cropbottom {
1656
            get {
1657
                return this.cropbottomField;
1658
            }
1659
            set {
1660
                this.cropbottomField = value;
1661
            }
1662
        }
1663
        
1664
        
1665
        [XmlAttribute]
1666
        public string gain {
1667
            get {
1668
                return this.gainField;
1669
            }
1670
            set {
1671
                this.gainField = value;
1672
            }
1673
        }
1674
        
1675
        
1676
        [XmlAttribute]
1677
        public string blacklevel {
1678
            get {
1679
                return this.blacklevelField;
1680
            }
1681
            set {
1682
                this.blacklevelField = value;
1683
            }
1684
        }
1685
        
1686
        
1687
        [XmlAttribute]
1688
        public string gamma {
1689
            get {
1690
                return this.gammaField;
1691
            }
1692
            set {
1693
                this.gammaField = value;
1694
            }
1695
        }
1696
        
1697
        
1698
        [XmlAttribute]
1699
        public ST_TrueFalse grayscale {
1700
            get {
1701
                return this.grayscaleField;
1702
            }
1703
            set {
1704
                this.grayscaleField = value;
1705
            }
1706
        }
1707
        
1708
        
1709
        [XmlIgnore]
1710
        public bool grayscaleSpecified {
1711
            get {
1712
                return this.grayscaleFieldSpecified;
1713
            }
1714
            set {
1715
                this.grayscaleFieldSpecified = value;
1716
            }
1717
        }
1718
        
1719
        
1720
        [XmlAttribute]
1721
        public ST_TrueFalse bilevel {
1722
            get {
1723
                return this.bilevelField;
1724
            }
1725
            set {
1726
                this.bilevelField = value;
1727
            }
1728
        }
1729
        
1730
        
1731
        [XmlIgnore]
1732
        public bool bilevelSpecified {
1733
            get {
1734
                return this.bilevelFieldSpecified;
1735
            }
1736
            set {
1737
                this.bilevelFieldSpecified = value;
1738
            }
1739
        }
1740
        
1741
        
1742
        [XmlAttribute]
1743
        public string chromakey {
1744
            get {
1745
                return this.chromakeyField;
1746
            }
1747
            set {
1748
                this.chromakeyField = value;
1749
            }
1750
        }
1751
        
1752
        
1753
        [XmlAttribute]
1754
        public string embosscolor {
1755
            get {
1756
                return this.embosscolorField;
1757
            }
1758
            set {
1759
                this.embosscolorField = value;
1760
            }
1761
        }
1762
        
1763
        
1764
        [XmlAttribute]
1765
        public string recolortarget {
1766
            get {
1767
                return this.recolortargetField;
1768
            }
1769
            set {
1770
                this.recolortargetField = value;
1771
            }
1772
        }
1773
        
1774
        
1775
        [XmlAttribute]//(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships")]
1776
        public string pict {
1777
            get {
1778
                return this.pictField;
1779
            }
1780
            set {
1781
                this.pictField = value;
1782
            }
1783
        }
1784
        
1785
        
1786
        [XmlAttribute(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships")]
1787
        public string href {
1788
            get {
1789
                return this.hrefField;
1790
            }
1791
            set {
1792
                this.hrefField = value;
1793
            }
1794
        }
1795

1796
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
1797
        public string relid
1798
        {
1799
            get
1800
            {
1801
                return this.relidField;
1802
            }
1803
            set
1804
            {
1805
                this.relidField = value;
1806
            }
1807
        }
1808
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
1809
        public string title
1810
        {
1811
            get
1812
            {
1813
                return this.titleField;
1814
            }
1815
            set
1816
            {
1817
                this.titleField = value;
1818
            }
1819
        }
1820
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
1821
        public string movie
1822
        {
1823
            get
1824
            {
1825
                return this.movieField;
1826
            }
1827
            set
1828
            {
1829
                this.movieField = value;
1830
            }
1831
        }
1832
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
1833
        public string oleid
1834
        {
1835
            get {
1836
                return this.oleidField;
1837
            }
1838
            set 
1839
            {
1840
                this.oleidField = value;
1841
            }
1842
        }
1843
    }
1844
    
1845
    
1846
    [Serializable]
1847

1848
    [System.ComponentModel.DesignerCategory("code")]
1849
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
1850
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
1851
    public class CT_Path {
1852
        
1853
        private string idField;
1854
        
1855
        private string vField;
1856
        
1857
        private string limoField;
1858
        
1859
        private string textboxrectField;
1860
        
1861
        private ST_TrueFalse fillokField;
1862
        
1863
        private bool fillokFieldSpecified;
1864
        
1865
        private ST_TrueFalse strokeokField;
1866
        
1867
        private bool strokeokFieldSpecified;
1868
        
1869
        private ST_TrueFalse shadowokField;
1870
        
1871
        private bool shadowokFieldSpecified;
1872
        
1873
        private ST_TrueFalse arrowokField;
1874
        
1875
        private bool arrowokFieldSpecified;
1876
        
1877
        private ST_TrueFalse gradientshapeokField;
1878
        
1879
        private bool gradientshapeokFieldSpecified;
1880
        
1881
        private ST_TrueFalse textpathokField;
1882
        
1883
        private bool textpathokFieldSpecified;
1884
        
1885
        private ST_TrueFalse insetpenokField;
1886
        
1887
        private bool insetpenokFieldSpecified;
1888

1889
        private ST_ConnectType connecttypeField;
1890

1891
        private string connectlocsField;
1892

1893
        private bool connectlocsFieldSpecified;
1894

1895
        private string connectanglesField;
1896

1897
        private bool connectanglesFieldSpecified;
1898

1899
        private ST_TrueFalse extrusionokField;
1900

1901
        private bool extrusionokFieldSpecified;
1902

1903
        [XmlAttribute]
1904
        public string id
1905
        {
1906
            get {
1907
                return this.idField;
1908
            }
1909
            set {
1910
                this.idField = value;
1911
            }
1912
        }
1913
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
1914
        public ST_ConnectType connecttype
1915
        {
1916
            get
1917
            {
1918
                return this.connecttypeField;
1919
            }
1920
            set
1921
            {
1922
                this.connecttypeField = value;
1923
            }
1924
        }
1925
        
1926
        [XmlAttribute]
1927
        public string v {
1928
            get {
1929
                return this.vField;
1930
            }
1931
            set {
1932
                this.vField = value;
1933
            }
1934
        }
1935
        
1936
        
1937
        [XmlAttribute]
1938
        public string limo {
1939
            get {
1940
                return this.limoField;
1941
            }
1942
            set {
1943
                this.limoField = value;
1944
            }
1945
        }
1946
        
1947
        
1948
        [XmlAttribute]
1949
        public string textboxrect {
1950
            get {
1951
                return this.textboxrectField;
1952
            }
1953
            set {
1954
                this.textboxrectField = value;
1955
            }
1956
        }
1957
        
1958
        
1959
        [XmlAttribute]
1960
        public ST_TrueFalse fillok {
1961
            get {
1962
                return this.fillokField;
1963
            }
1964
            set {
1965
                this.fillokField = value;
1966
            }
1967
        }
1968
        
1969
        
1970
        [XmlIgnore]
1971
        public bool fillokSpecified {
1972
            get {
1973
                return this.fillokFieldSpecified;
1974
            }
1975
            set {
1976
                this.fillokFieldSpecified = value;
1977
            }
1978
        }
1979
        
1980
        
1981
        [XmlAttribute]
1982
        public ST_TrueFalse strokeok {
1983
            get {
1984
                return this.strokeokField;
1985
            }
1986
            set {
1987
                this.strokeokField = value;
1988
            }
1989
        }
1990
        
1991
        
1992
        [XmlIgnore]
1993
        public bool strokeokSpecified {
1994
            get {
1995
                return this.strokeokFieldSpecified;
1996
            }
1997
            set {
1998
                this.strokeokFieldSpecified = value;
1999
            }
2000
        }
2001
        
2002
        
2003
        [XmlAttribute]
2004
        public ST_TrueFalse shadowok {
2005
            get {
2006
                return this.shadowokField;
2007
            }
2008
            set {
2009
                this.shadowokField = value;
2010
            }
2011
        }
2012
        
2013
        
2014
        [XmlIgnore]
2015
        public bool shadowokSpecified {
2016
            get {
2017
                return this.shadowokFieldSpecified;
2018
            }
2019
            set {
2020
                this.shadowokFieldSpecified = value;
2021
            }
2022
        }
2023
        
2024
        
2025
        [XmlAttribute]
2026
        public ST_TrueFalse arrowok {
2027
            get {
2028
                return this.arrowokField;
2029
            }
2030
            set {
2031
                this.arrowokField = value;
2032
            }
2033
        }
2034
        
2035
        
2036
        [XmlIgnore]
2037
        public bool arrowokSpecified {
2038
            get {
2039
                return this.arrowokFieldSpecified;
2040
            }
2041
            set {
2042
                this.arrowokFieldSpecified = value;
2043
            }
2044
        }
2045
        
2046
        
2047
        [XmlAttribute]
2048
        public ST_TrueFalse gradientshapeok {
2049
            get {
2050
                return this.gradientshapeokField;
2051
            }
2052
            set {
2053
                this.gradientshapeokField = value;
2054
            }
2055
        }
2056
        
2057
        
2058
        [XmlIgnore]
2059
        public bool gradientshapeokSpecified {
2060
            get {
2061
                return this.gradientshapeokFieldSpecified;
2062
            }
2063
            set {
2064
                this.gradientshapeokFieldSpecified = value;
2065
            }
2066
        }
2067
        
2068
        
2069
        [XmlAttribute]
2070
        public ST_TrueFalse textpathok {
2071
            get {
2072
                return this.textpathokField;
2073
            }
2074
            set {
2075
                this.textpathokField = value;
2076
            }
2077
        }
2078
        
2079
        
2080
        [XmlIgnore]
2081
        public bool textpathokSpecified {
2082
            get {
2083
                return this.textpathokFieldSpecified;
2084
            }
2085
            set {
2086
                this.textpathokFieldSpecified = value;
2087
            }
2088
        }
2089
        
2090
        
2091
        [XmlAttribute]
2092
        public ST_TrueFalse insetpenok {
2093
            get {
2094
                return this.insetpenokField;
2095
            }
2096
            set {
2097
                this.insetpenokField = value;
2098
            }
2099
        }
2100
        
2101
        
2102
        [XmlIgnore]
2103
        public bool insetpenokSpecified {
2104
            get {
2105
                return this.insetpenokFieldSpecified;
2106
            }
2107
            set {
2108
                this.insetpenokFieldSpecified = value;
2109
            }
2110
        }
2111
        [XmlAttribute]
2112
        public string connectlocs
2113
        {
2114
            get
2115
            {
2116
                return this.connectlocsField;
2117
            }
2118
            set
2119
            {
2120
                this.connectlocsField = value;
2121
            }
2122
        }
2123
        [XmlIgnore]
2124
        public bool connectlocsSpecified
2125
        {
2126
            get
2127
            {
2128
                return this.connectlocsFieldSpecified;
2129
            }
2130
            set
2131
            {
2132
                this.connectlocsFieldSpecified = value;
2133
            }
2134
        }
2135
        [XmlAttribute]
2136
        public string connectangles
2137
        {
2138
            get
2139
            {
2140
                return this.connectanglesField;
2141
            }
2142
            set
2143
            {
2144
                this.connectanglesField = value;
2145
            }
2146
        }
2147
        [XmlIgnore]
2148
        public bool connectanglesSpecified
2149
        {
2150
            get
2151
            {
2152
                return this.connectanglesFieldSpecified;
2153
            }
2154
            set
2155
            {
2156
                this.connectanglesFieldSpecified = value;
2157
            }
2158
        }
2159
        [XmlAttribute(Namespace="urn:schemas-microsoft-com:office:office")]
2160
        public ST_TrueFalse extrusionok
2161
        {
2162
            get
2163
            {
2164
                return this.extrusionokField;
2165
            }
2166
            set
2167
            {
2168
                this.extrusionokField = value;
2169
            }
2170
        }
2171
        [XmlIgnore]
2172
        public bool extrusionokSpecified
2173
        {
2174
            get
2175
            {
2176
                return this.extrusionokFieldSpecified;
2177
            }
2178
            set
2179
            {
2180
                this.extrusionokFieldSpecified = value;
2181
            }
2182
        }
2183
        public static CT_Path Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2184
        {
2185
            if (node == null)
2186
                return null;
2187
            CT_Path ctObj = new CT_Path();
2188
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
2189
            if (node.Attributes["o:connecttype"] != null)
2190
                ctObj.connecttype = (ST_ConnectType)Enum.Parse(typeof(ST_ConnectType), node.Attributes["o:connecttype"].Value);
2191
            ctObj.v = XmlHelper.ReadString(node.Attributes["v"]);
2192
            ctObj.limo = XmlHelper.ReadString(node.Attributes["limo"]);
2193
            ctObj.textboxrect = XmlHelper.ReadString(node.Attributes["textboxrect"]);
2194
            if (node.Attributes["fillok"] != null)
2195
                ctObj.fillok = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["fillok"]);
2196
            if (node.Attributes["strokeok"] != null)
2197
                ctObj.strokeok = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["strokeok"]);
2198
            if (node.Attributes["shadowok"] != null)
2199
                ctObj.shadowok = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["shadowok"]);
2200
            if (node.Attributes["arrowok"] != null)
2201
                ctObj.arrowok = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["arrowok"]);
2202
            if (node.Attributes["gradientshapeok"] != null)
2203
                ctObj.gradientshapeok = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["gradientshapeok"]);
2204
            if (node.Attributes["textpathok"] != null)
2205
                ctObj.textpathok = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["textpathok"]);
2206
            if (node.Attributes["insetpenok"] != null)
2207
                ctObj.insetpenok = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["insetpenok"]);
2208
            ctObj.connectlocs = XmlHelper.ReadString(node.Attributes["connectlocs"]);
2209
            ctObj.connectangles = XmlHelper.ReadString(node.Attributes["connectangles"]);
2210
            if (node.Attributes["o:extrusionok"] != null)
2211
                ctObj.extrusionok = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["o:extrusionok"]);
2212
            return ctObj;
2213
        }
2214

2215

2216

2217
        internal void Write(StreamWriter sw, string nodeName)
2218
        {
2219
            sw.Write(string.Format("<v:{0}", nodeName));
2220
            XmlHelper.WriteAttribute(sw, "id", this.id);
2221
            XmlHelper.WriteAttribute(sw, "o:connecttype", this.connecttype.ToString());
2222
            XmlHelper.WriteAttribute(sw, "v", this.v);
2223
            XmlHelper.WriteAttribute(sw, "limo", this.limo);
2224
            XmlHelper.WriteAttribute(sw, "textboxrect", this.textboxrect);
2225
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "fillok", this.fillok);
2226
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "strokeok", this.strokeok);
2227
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "shadowok", this.shadowok);
2228
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "arrowok", this.arrowok);
2229
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "gradientshapeok", this.gradientshapeok);
2230
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "textpathok", this.textpathok);
2231
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "insetpenok", this.insetpenok);
2232
            XmlHelper.WriteAttribute(sw, "connectlocs", this.connectlocs);
2233
            XmlHelper.WriteAttribute(sw, "connectangles", this.connectangles);
2234
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "o:extrusionok", this.extrusionok, false);
2235
            sw.Write(">");
2236
            sw.Write(string.Format("</v:{0}>", nodeName));
2237
        }
2238

2239
    }
2240
    
2241
    
2242
    [Serializable]
2243

2244
    [System.ComponentModel.DesignerCategory("code")]
2245
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
2246
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
2247
    public class CT_Shadow {
2248
        
2249
        private string idField;
2250
        
2251
        private ST_TrueFalse onField;
2252
        
2253
        private bool onFieldSpecified;
2254
        
2255
        private ST_ShadowType typeField;
2256
        
2257
        private bool typeFieldSpecified;
2258
        
2259
        private ST_TrueFalse obscuredField;
2260
        
2261
        private bool obscuredFieldSpecified;
2262
        
2263
        private string colorField;
2264
        
2265
        private string opacityField;
2266
        
2267
        private string offsetField;
2268
        
2269
        private string color2Field;
2270
        
2271
        private string offset2Field;
2272
        
2273
        private string originField;
2274
        
2275
        private string matrixField;
2276
        public static CT_Shadow Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2277
        {
2278
            if (node == null)
2279
                return null;
2280
            CT_Shadow ctObj = new CT_Shadow();
2281
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
2282
            if (node.Attributes["on"] != null)
2283
                ctObj.on = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["on"]);
2284
            if (node.Attributes["type"] != null)
2285
                ctObj.type = (ST_ShadowType)Enum.Parse(typeof(ST_ShadowType), node.Attributes["type"].Value);
2286
            if (node.Attributes["obscured"] != null)
2287
                ctObj.obscured = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["obscured"]);
2288
            ctObj.color = XmlHelper.ReadString(node.Attributes["color"]);
2289
            ctObj.opacity = XmlHelper.ReadString(node.Attributes["opacity"]);
2290
            ctObj.offset = XmlHelper.ReadString(node.Attributes["offset"]);
2291
            ctObj.color2 = XmlHelper.ReadString(node.Attributes["color2"]);
2292
            ctObj.offset2 = XmlHelper.ReadString(node.Attributes["offset2"]);
2293
            ctObj.origin = XmlHelper.ReadString(node.Attributes["origin"]);
2294
            ctObj.matrix = XmlHelper.ReadString(node.Attributes["matrix"]);
2295
            return ctObj;
2296
        }
2297

2298

2299

2300
        internal void Write(StreamWriter sw, string nodeName)
2301
        {
2302
            sw.Write(string.Format("<v:{0}", nodeName));
2303
            XmlHelper.WriteAttribute(sw, "id", this.id);
2304
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "on", this.on);
2305
            XmlHelper.WriteAttribute(sw, "type", this.type.ToString());
2306
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "obscured", this.obscured);
2307
            XmlHelper.WriteAttribute(sw, "color", this.color);
2308
            XmlHelper.WriteAttribute(sw, "opacity", this.opacity);
2309
            XmlHelper.WriteAttribute(sw, "offset", this.offset);
2310
            XmlHelper.WriteAttribute(sw, "color2", this.color2);
2311
            XmlHelper.WriteAttribute(sw, "offset2", this.offset2);
2312
            XmlHelper.WriteAttribute(sw, "origin", this.origin);
2313
            XmlHelper.WriteAttribute(sw, "matrix", this.matrix);
2314
            sw.Write(">");
2315
            sw.Write(string.Format("</v:{0}>", nodeName));
2316
        }
2317

2318

2319
        [XmlAttribute]
2320
        public string id
2321
        {
2322
            get {
2323
                return this.idField;
2324
            }
2325
            set {
2326
                this.idField = value;
2327
            }
2328
        }
2329
        
2330
        
2331
        [XmlAttribute]
2332
        public ST_TrueFalse on {
2333
            get {
2334
                return this.onField;
2335
            }
2336
            set {
2337
                this.onField = value;
2338
            }
2339
        }
2340
        
2341
        
2342
        [XmlIgnore]
2343
        public bool onSpecified {
2344
            get {
2345
                return this.onFieldSpecified;
2346
            }
2347
            set {
2348
                this.onFieldSpecified = value;
2349
            }
2350
        }
2351
        
2352
        
2353
        [XmlAttribute]
2354
        public ST_ShadowType type {
2355
            get {
2356
                return this.typeField;
2357
            }
2358
            set {
2359
                this.typeField = value;
2360
            }
2361
        }
2362
        
2363
        
2364
        [XmlIgnore]
2365
        public bool typeSpecified {
2366
            get {
2367
                return this.typeFieldSpecified;
2368
            }
2369
            set {
2370
                this.typeFieldSpecified = value;
2371
            }
2372
        }
2373
        
2374
        
2375
        [XmlAttribute]
2376
        public ST_TrueFalse obscured {
2377
            get {
2378
                return this.obscuredField;
2379
            }
2380
            set {
2381
                this.obscuredField = value;
2382
            }
2383
        }
2384
        
2385
        
2386
        [XmlIgnore]
2387
        public bool obscuredSpecified {
2388
            get {
2389
                return this.obscuredFieldSpecified;
2390
            }
2391
            set {
2392
                this.obscuredFieldSpecified = value;
2393
            }
2394
        }
2395
        
2396
        
2397
        [XmlAttribute]
2398
        public string color {
2399
            get {
2400
                return this.colorField;
2401
            }
2402
            set {
2403
                this.colorField = value;
2404
            }
2405
        }
2406
        
2407
        
2408
        [XmlAttribute]
2409
        public string opacity {
2410
            get {
2411
                return this.opacityField;
2412
            }
2413
            set {
2414
                this.opacityField = value;
2415
            }
2416
        }
2417
        
2418
        
2419
        [XmlAttribute]
2420
        public string offset {
2421
            get {
2422
                return this.offsetField;
2423
            }
2424
            set {
2425
                this.offsetField = value;
2426
            }
2427
        }
2428
        
2429
        
2430
        [XmlAttribute]
2431
        public string color2 {
2432
            get {
2433
                return this.color2Field;
2434
            }
2435
            set {
2436
                this.color2Field = value;
2437
            }
2438
        }
2439
        
2440
        
2441
        [XmlAttribute]
2442
        public string offset2 {
2443
            get {
2444
                return this.offset2Field;
2445
            }
2446
            set {
2447
                this.offset2Field = value;
2448
            }
2449
        }
2450
        
2451
        
2452
        [XmlAttribute]
2453
        public string origin {
2454
            get {
2455
                return this.originField;
2456
            }
2457
            set {
2458
                this.originField = value;
2459
            }
2460
        }
2461
        
2462
        
2463
        [XmlAttribute]
2464
        public string matrix {
2465
            get {
2466
                return this.matrixField;
2467
            }
2468
            set {
2469
                this.matrixField = value;
2470
            }
2471
        }
2472
    }
2473
    
2474
    
2475
    [Serializable]
2476
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
2477
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
2478
    public enum ST_ShadowType {
2479
        
2480
        
2481
        single,
2482
        
2483
        
2484
        @double,
2485
        
2486
        
2487
        emboss,
2488
        
2489
        
2490
        perspective,
2491
    }
2492
    
2493
    
2494
    [Serializable]
2495

2496
    [System.ComponentModel.DesignerCategory("code")]
2497
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
2498
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
2499
    public class CT_Stroke {
2500
        
2501
        private string idField;
2502
        
2503
        private ST_TrueFalse onField;
2504
        
2505
        private bool onFieldSpecified;
2506
        
2507
        private string weightField;
2508
        
2509
        private string colorField;
2510
        
2511
        private string opacityField;
2512
        
2513
        private ST_StrokeLineStyle linestyleField;
2514
        
2515
        private bool linestyleFieldSpecified;
2516
        
2517
        private decimal miterlimitField;
2518
        
2519
        private bool miterlimitFieldSpecified;
2520
        
2521
        private ST_StrokeJoinStyle joinstyleField;
2522
        
2523
        private bool joinstyleFieldSpecified;
2524
        
2525
        private ST_StrokeEndCap endcapField;
2526
        
2527
        private bool endcapFieldSpecified;
2528
        
2529
        private string dashstyleField;
2530
        
2531
        private ST_FillType filltypeField;
2532
        
2533
        private bool filltypeFieldSpecified;
2534
        
2535
        private string srcField;
2536
        
2537
        private ST_ImageAspect imageaspectField;
2538
        
2539
        private bool imageaspectFieldSpecified;
2540
        
2541
        private string imagesizeField;
2542
        
2543
        private ST_TrueFalse imagealignshapeField;
2544
        
2545
        private bool imagealignshapeFieldSpecified;
2546
        
2547
        private string color2Field;
2548
        
2549
        private ST_StrokeArrowType startarrowField;
2550
        
2551
        private bool startarrowFieldSpecified;
2552
        
2553
        private ST_StrokeArrowWidth startarrowwidthField;
2554
        
2555
        private bool startarrowwidthFieldSpecified;
2556
        
2557
        private ST_StrokeArrowLength startarrowlengthField;
2558
        
2559
        private bool startarrowlengthFieldSpecified;
2560
        
2561
        private ST_StrokeArrowType endarrowField;
2562
        
2563
        private bool endarrowFieldSpecified;
2564
        
2565
        private ST_StrokeArrowWidth endarrowwidthField;
2566
        
2567
        private bool endarrowwidthFieldSpecified;
2568
        
2569
        private ST_StrokeArrowLength endarrowlengthField;
2570
        
2571
        private bool endarrowlengthFieldSpecified;
2572
        
2573
        //private string id1Field;
2574
        
2575
        private ST_TrueFalse insetpenField;
2576
        
2577
        private bool insetpenFieldSpecified;
2578

2579
        public static CT_Stroke Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2580
        {
2581
            if (node == null)
2582
                return null;
2583
            CT_Stroke ctObj = new CT_Stroke();
2584
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
2585
            if (node.Attributes["on"] != null)
2586
                ctObj.on = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["on"]);
2587
            ctObj.weight = XmlHelper.ReadString(node.Attributes["weight"]);
2588
            ctObj.color = XmlHelper.ReadString(node.Attributes["color"]);
2589
            ctObj.opacity = XmlHelper.ReadString(node.Attributes["opacity"]);
2590
            if (node.Attributes["linestyle"] != null)
2591
            {
2592
                ctObj.linestyle = (ST_StrokeLineStyle)Enum.Parse(typeof(ST_StrokeLineStyle), node.Attributes["linestyle"].Value);
2593
                ctObj.linestyleFieldSpecified = true;
2594
            }
2595
            else
2596
            {
2597
                ctObj.linestyleFieldSpecified = false;
2598
            }
2599
            if (node.Attributes["miterlimit"] != null)
2600
            {
2601
                ctObj.miterlimit = XmlHelper.ReadDecimal(node.Attributes["miterlimit"]);
2602
                ctObj.miterlimitFieldSpecified = true;
2603
            }
2604
            else
2605
            {
2606
                ctObj.miterlimitFieldSpecified = false;
2607
            }
2608
            if (node.Attributes["joinstyle"] != null)
2609
            {
2610
                ctObj.joinstyleFieldSpecified = true;
2611
                ctObj.joinstyle = (ST_StrokeJoinStyle)Enum.Parse(typeof(ST_StrokeJoinStyle), node.Attributes["joinstyle"].Value);
2612
            }
2613
            else
2614
            {
2615
                ctObj.joinstyleFieldSpecified = false;
2616
            }
2617
            if (node.Attributes["endcap"] != null)
2618
            {
2619
                ctObj.endcap = (ST_StrokeEndCap)Enum.Parse(typeof(ST_StrokeEndCap), node.Attributes["endcap"].Value);
2620
                ctObj.endcapFieldSpecified = true;
2621
            }
2622
            else
2623
            {
2624
                ctObj.endcapFieldSpecified = false;
2625
            }
2626
            ctObj.dashstyle = XmlHelper.ReadString(node.Attributes["dashstyle"]);
2627

2628
            if (node.Attributes["filltype"] != null)
2629
            {
2630
                ctObj.filltype = (ST_FillType)Enum.Parse(typeof(ST_FillType), node.Attributes["filltype"].Value);
2631
                ctObj.filltypeFieldSpecified = true;
2632
            }
2633
            else
2634
            {
2635
                ctObj.filltypeFieldSpecified = false;
2636
            }
2637
            ctObj.src = XmlHelper.ReadString(node.Attributes["src"]);
2638
            if (node.Attributes["imageaspect"] != null)
2639
            {
2640
                ctObj.imageaspect = (ST_ImageAspect)Enum.Parse(typeof(ST_ImageAspect), node.Attributes["imageaspect"].Value);
2641
                ctObj.imageaspectFieldSpecified = true;
2642
            }
2643
            else
2644
            {
2645
                ctObj.imageaspectFieldSpecified = false;
2646
            }
2647
            ctObj.imagesize = XmlHelper.ReadString(node.Attributes["imagesize"]);
2648
            if (node.Attributes["imagealignshape"] != null)
2649
            {
2650
                ctObj.imagealignshape = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["imagealignshape"]);
2651
                ctObj.imagealignshapeSpecified = true;
2652
            }
2653
            else
2654
            {
2655
                ctObj.imagealignshapeSpecified = false;
2656
            }
2657
            ctObj.color2 = XmlHelper.ReadString(node.Attributes["color2"]);
2658
            if (node.Attributes["startarrow"] != null)
2659
            {
2660
                ctObj.startarrow = (ST_StrokeArrowType)Enum.Parse(typeof(ST_StrokeArrowType), node.Attributes["startarrow"].Value);
2661
                ctObj.startarrowFieldSpecified = true;
2662
            }
2663
            else
2664
            {
2665
                ctObj.startarrowFieldSpecified = false;
2666
            }
2667
            if (node.Attributes["startarrowwidth"] != null)
2668
            {
2669
                ctObj.startarrowwidth = (ST_StrokeArrowWidth)Enum.Parse(typeof(ST_StrokeArrowWidth), node.Attributes["startarrowwidth"].Value);
2670
                ctObj.startarrowwidthFieldSpecified = true;
2671
            }
2672
            else
2673
            {
2674
                ctObj.startarrowwidthFieldSpecified = false;
2675
            }
2676
            if (node.Attributes["startarrowlength"] != null)
2677
            {
2678
                ctObj.startarrowlength = (ST_StrokeArrowLength)Enum.Parse(typeof(ST_StrokeArrowLength), node.Attributes["startarrowlength"].Value);
2679
                ctObj.startarrowlengthFieldSpecified = true;
2680
            }
2681
            else
2682
            {
2683
                ctObj.startarrowlengthFieldSpecified = false;
2684
            }
2685
            if (node.Attributes["endarrow"] != null)
2686
            {
2687
                ctObj.endarrow = (ST_StrokeArrowType)Enum.Parse(typeof(ST_StrokeArrowType), node.Attributes["endarrow"].Value);
2688
                ctObj.endarrowFieldSpecified = true;
2689
            }
2690
            else
2691
            {
2692
                ctObj.endarrowFieldSpecified = false;
2693
            }
2694
            if (node.Attributes["endarrowwidth"] != null)
2695
            {
2696
                ctObj.endarrowwidth = (ST_StrokeArrowWidth)Enum.Parse(typeof(ST_StrokeArrowWidth), node.Attributes["endarrowwidth"].Value);
2697
                ctObj.endarrowwidthFieldSpecified = true;
2698
            }
2699
            else
2700
            {
2701
                ctObj.endarrowwidthFieldSpecified = false;
2702
            }
2703
            if (node.Attributes["endarrowlength"] != null)
2704
            {
2705
                ctObj.endarrowlength = (ST_StrokeArrowLength)Enum.Parse(typeof(ST_StrokeArrowLength), node.Attributes["endarrowlength"].Value);
2706
                ctObj.endarrowlengthFieldSpecified = true;
2707
            }
2708
            else
2709
            {
2710
                ctObj.endarrowlengthFieldSpecified = false;
2711
            }
2712
            if (node.Attributes["insetpen"] != null)
2713
                ctObj.insetpen = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["insetpen"]);
2714
            return ctObj;
2715
        }
2716

2717

2718

2719
        internal void Write(StreamWriter sw, string nodeName)
2720
        {
2721
            sw.Write(string.Format("<v:{0}", nodeName));
2722
            XmlHelper.WriteAttribute(sw, "id", this.id);
2723
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "on", this.on);
2724
            XmlHelper.WriteAttribute(sw, "weight", this.weight);
2725
            XmlHelper.WriteAttribute(sw, "color", this.color);
2726
            XmlHelper.WriteAttribute(sw, "opacity", this.opacity);
2727
            if(linestyleFieldSpecified)
2728
                XmlHelper.WriteAttribute(sw, "linestyle", this.linestyle.ToString());
2729
            if(miterlimitFieldSpecified)
2730
                XmlHelper.WriteAttribute(sw, "miterlimit", (float)this.miterlimit);
2731
            if(joinstyleFieldSpecified)
2732
                XmlHelper.WriteAttribute(sw, "joinstyle", this.joinstyle.ToString());
2733
            if(endcapFieldSpecified)
2734
                XmlHelper.WriteAttribute(sw, "endcap", this.endcap.ToString());
2735
            XmlHelper.WriteAttribute(sw, "dashstyle", this.dashstyle);
2736
            if(filltypeFieldSpecified)
2737
                XmlHelper.WriteAttribute(sw, "filltype", this.filltype.ToString());
2738
            XmlHelper.WriteAttribute(sw, "src", this.src);
2739
            if(imageaspectFieldSpecified)
2740
                XmlHelper.WriteAttribute(sw, "imageaspect", this.imageaspect.ToString());
2741
            XmlHelper.WriteAttribute(sw, "imagesize", this.imagesize);
2742
            if(imagealignshapeFieldSpecified)
2743
                NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "imagealignshape", this.imagealignshape);
2744
            XmlHelper.WriteAttribute(sw, "color2", this.color2);
2745
            if(startarrowSpecified)
2746
                XmlHelper.WriteAttribute(sw, "startarrow", this.startarrow.ToString());
2747
            if(startarrowwidthFieldSpecified)
2748
                XmlHelper.WriteAttribute(sw, "startarrowwidth", this.startarrowwidth.ToString());
2749
            if(startarrowlengthFieldSpecified)
2750
                XmlHelper.WriteAttribute(sw, "startarrowlength", this.startarrowlength.ToString());
2751
            if(endarrowFieldSpecified)
2752
                XmlHelper.WriteAttribute(sw, "endarrow", this.endarrow.ToString());
2753
            if(endarrowwidthFieldSpecified)
2754
                XmlHelper.WriteAttribute(sw, "endarrowwidth", this.endarrowwidth.ToString());
2755
            if(endarrowlengthFieldSpecified)
2756
                XmlHelper.WriteAttribute(sw, "endarrowlength", this.endarrowlength.ToString());
2757
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "insetpen", this.insetpen);
2758
            sw.Write("/>");
2759
        }
2760

2761
        [XmlAttribute]
2762
        public string id
2763
        {
2764
            get {
2765
                return this.idField;
2766
            }
2767
            set {
2768
                this.idField = value;
2769
            }
2770
        }
2771
        
2772
        
2773
        [XmlAttribute]
2774
        public ST_TrueFalse on {
2775
            get {
2776
                return this.onField;
2777
            }
2778
            set {
2779
                this.onField = value;
2780
            }
2781
        }
2782
        
2783
        
2784
        [XmlIgnore]
2785
        public bool onSpecified {
2786
            get {
2787
                return this.onFieldSpecified;
2788
            }
2789
            set {
2790
                this.onFieldSpecified = value;
2791
            }
2792
        }
2793
        
2794
        
2795
        [XmlAttribute]
2796
        public string weight {
2797
            get {
2798
                return this.weightField;
2799
            }
2800
            set {
2801
                this.weightField = value;
2802
            }
2803
        }
2804
        
2805
        
2806
        [XmlAttribute]
2807
        public string color {
2808
            get {
2809
                return this.colorField;
2810
            }
2811
            set {
2812
                this.colorField = value;
2813
            }
2814
        }
2815
        
2816
        
2817
        [XmlAttribute]
2818
        public string opacity {
2819
            get {
2820
                return this.opacityField;
2821
            }
2822
            set {
2823
                this.opacityField = value;
2824
            }
2825
        }
2826
        
2827
        
2828
        [XmlAttribute]
2829
        public ST_StrokeLineStyle linestyle {
2830
            get {
2831
                return this.linestyleField;
2832
            }
2833
            set {
2834
                this.linestyleField = value;
2835
                this.linestyleFieldSpecified = true;
2836
            }
2837
        }
2838
        
2839
        
2840
        [XmlIgnore]
2841
        public bool linestyleSpecified {
2842
            get {
2843
                return this.linestyleFieldSpecified;
2844
            }
2845
            set {
2846
                this.linestyleFieldSpecified = value;
2847
            }
2848
        }
2849
        
2850
        
2851
        [XmlAttribute]
2852
        public decimal miterlimit {
2853
            get {
2854
                return this.miterlimitField;
2855
            }
2856
            set {
2857
                this.miterlimitField = value;
2858
                this.miterlimitFieldSpecified = true;
2859
            }
2860
        }
2861
        
2862
        
2863
        [XmlIgnore]
2864
        public bool miterlimitSpecified {
2865
            get {
2866
                return this.miterlimitFieldSpecified;
2867
            }
2868
            set {
2869
                this.miterlimitFieldSpecified = value;
2870
            }
2871
        }
2872
        
2873
        
2874
        [XmlAttribute]
2875
        public ST_StrokeJoinStyle joinstyle {
2876
            get {
2877
                return this.joinstyleField;
2878
            }
2879
            set {
2880
                this.joinstyleField = value;
2881
                this.joinstyleFieldSpecified = true;
2882
            }
2883
        }
2884
        
2885
        
2886
        [XmlIgnore]
2887
        public bool joinstyleSpecified {
2888
            get {
2889
                return this.joinstyleFieldSpecified;
2890
            }
2891
            set {
2892
                this.joinstyleFieldSpecified = value;
2893
            }
2894
        }
2895
        
2896
        
2897
        [XmlAttribute]
2898
        public ST_StrokeEndCap endcap {
2899
            get {
2900
                return this.endcapField;
2901
            }
2902
            set {
2903
                this.endcapField = value;
2904
                this.endcapFieldSpecified = true;
2905
            }
2906
        }
2907
        
2908
        
2909
        [XmlIgnore]
2910
        public bool endcapSpecified {
2911
            get {
2912
                return this.endcapFieldSpecified;
2913
            }
2914
            set {
2915
                this.endcapFieldSpecified = value;
2916
            }
2917
        }
2918
        
2919
        
2920
        [XmlAttribute]
2921
        public string dashstyle {
2922
            get {
2923
                return this.dashstyleField;
2924
            }
2925
            set {
2926
                this.dashstyleField = value;
2927
            }
2928
        }
2929
        
2930
        
2931
        [XmlAttribute]
2932
        public ST_FillType filltype {
2933
            get {
2934
                return this.filltypeField;
2935
            }
2936
            set {
2937
                this.filltypeField = value;
2938
                this.filltypeFieldSpecified = true;
2939
            }
2940
        }
2941
        
2942
        
2943
        [XmlIgnore]
2944
        public bool filltypeSpecified {
2945
            get {
2946
                return this.filltypeFieldSpecified;
2947
            }
2948
            set {
2949
                this.filltypeFieldSpecified = value;
2950
            }
2951
        }
2952
        
2953
        
2954
        [XmlAttribute]
2955
        public string src {
2956
            get {
2957
                return this.srcField;
2958
            }
2959
            set {
2960
                this.srcField = value;
2961
            }
2962
        }
2963
        
2964
        
2965
        [XmlAttribute]
2966
        public ST_ImageAspect imageaspect {
2967
            get {
2968
                return this.imageaspectField;
2969
            }
2970
            set {
2971
                this.imageaspectField = value;
2972
                this.imageaspectFieldSpecified = true;
2973
            }
2974
        }
2975
        
2976
        
2977
        [XmlIgnore]
2978
        public bool imageaspectSpecified {
2979
            get {
2980
                return this.imageaspectFieldSpecified;
2981
            }
2982
            set {
2983
                this.imageaspectFieldSpecified = value;
2984
            }
2985
        }
2986
        
2987
        
2988
        [XmlAttribute]
2989
        public string imagesize {
2990
            get {
2991
                return this.imagesizeField;
2992
            }
2993
            set {
2994
                this.imagesizeField = value;
2995
            }
2996
        }
2997
        
2998
        
2999
        [XmlAttribute]
3000
        public ST_TrueFalse imagealignshape {
3001
            get {
3002
                return this.imagealignshapeField;
3003
            }
3004
            set {
3005
                this.imagealignshapeField = value;
3006
                this.imagealignshapeFieldSpecified = true;
3007
            }
3008
        }
3009
        
3010
        
3011
        [XmlIgnore]
3012
        public bool imagealignshapeSpecified {
3013
            get {
3014
                return this.imagealignshapeFieldSpecified;
3015
            }
3016
            set {
3017
                this.imagealignshapeFieldSpecified = value;
3018
            }
3019
        }
3020
        
3021
        
3022
        [XmlAttribute]
3023
        public string color2 {
3024
            get {
3025
                return this.color2Field;
3026
            }
3027
            set {
3028
                this.color2Field = value;
3029
            }
3030
        }
3031
        
3032
        
3033
        [XmlAttribute]
3034
        public ST_StrokeArrowType startarrow {
3035
            get {
3036
                return this.startarrowField;
3037
            }
3038
            set {
3039
                this.startarrowField = value;
3040
                this.startarrowFieldSpecified = true;
3041
            }
3042
        }
3043
        
3044
        
3045
        [XmlIgnore]
3046
        public bool startarrowSpecified {
3047
            get {
3048
                return this.startarrowFieldSpecified;
3049
            }
3050
            set {
3051
                this.startarrowFieldSpecified = value;
3052
            }
3053
        }
3054
        
3055
        
3056
        [XmlAttribute]
3057
        public ST_StrokeArrowWidth startarrowwidth {
3058
            get {
3059
                return this.startarrowwidthField;
3060
            }
3061
            set {
3062
                this.startarrowwidthField = value;
3063
                this.startarrowwidthFieldSpecified = true;
3064
            }
3065
        }
3066
        
3067
        
3068
        [XmlIgnore]
3069
        public bool startarrowwidthSpecified {
3070
            get {
3071
                return this.startarrowwidthFieldSpecified;
3072
            }
3073
            set {
3074
                this.startarrowwidthFieldSpecified = value;
3075
            }
3076
        }
3077
        
3078
        
3079
        [XmlAttribute]
3080
        public ST_StrokeArrowLength startarrowlength {
3081
            get {
3082
                return this.startarrowlengthField;
3083
            }
3084
            set {
3085
                this.startarrowlengthField = value;
3086
                this.startarrowlengthFieldSpecified = true;
3087
            }
3088
        }
3089
        
3090
        
3091
        [XmlIgnore]
3092
        public bool startarrowlengthSpecified {
3093
            get {
3094
                return this.startarrowlengthFieldSpecified;
3095
            }
3096
            set {
3097
                this.startarrowlengthFieldSpecified = value;
3098
            }
3099
        }
3100
        
3101
        
3102
        [XmlAttribute]
3103
        public ST_StrokeArrowType endarrow {
3104
            get {
3105
                return this.endarrowField;
3106
            }
3107
            set {
3108
                this.endarrowField = value;
3109
                this.endarrowFieldSpecified = true;
3110
            }
3111
        }
3112
        
3113
        
3114
        [XmlIgnore]
3115
        public bool endarrowSpecified {
3116
            get {
3117
                return this.endarrowFieldSpecified;
3118
            }
3119
            set {
3120
                this.endarrowFieldSpecified = value;
3121
            }
3122
        }
3123
        
3124
        
3125
        [XmlAttribute]
3126
        public ST_StrokeArrowWidth endarrowwidth {
3127
            get {
3128
                return this.endarrowwidthField;
3129
            }
3130
            set {
3131
                this.endarrowwidthField = value;
3132
                this.endarrowwidthFieldSpecified = true;
3133
            }
3134
        }
3135
        
3136
        
3137
        [XmlIgnore]
3138
        public bool endarrowwidthSpecified {
3139
            get {
3140
                return this.endarrowwidthFieldSpecified;
3141
            }
3142
            set {
3143
                this.endarrowwidthFieldSpecified = value;
3144
            }
3145
        }
3146
        
3147
        
3148
        [XmlAttribute]
3149
        public ST_StrokeArrowLength endarrowlength {
3150
            get {
3151
                return this.endarrowlengthField;
3152
            }
3153
            set {
3154
                this.endarrowlengthField = value;
3155
                this.endarrowlengthFieldSpecified = true;
3156
            }
3157
        }
3158
        
3159
        
3160
        [XmlIgnore]
3161
        public bool endarrowlengthSpecified {
3162
            get {
3163
                return this.endarrowlengthFieldSpecified;
3164
            }
3165
            set {
3166
                this.endarrowlengthFieldSpecified = value;
3167
            }
3168
        }
3169
                
3170
        
3171
        [XmlAttribute]
3172
        public ST_TrueFalse insetpen {
3173
            get {
3174
                return this.insetpenField;
3175
            }
3176
            set {
3177
                this.insetpenField = value;
3178
                this.insetpenFieldSpecified = true;
3179
            }
3180
        }
3181
        
3182
        
3183
        [XmlIgnore]
3184
        public bool insetpenSpecified {
3185
            get {
3186
                return this.insetpenFieldSpecified;
3187
            }
3188
            set {
3189
                this.insetpenFieldSpecified = value;
3190
            }
3191
        }
3192
    }
3193
    
3194
    
3195
    [Serializable]
3196
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3197
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
3198
    public enum ST_StrokeLineStyle {
3199
        
3200
        
3201
        single,
3202
        
3203
        
3204
        thinThin,
3205
        
3206
        
3207
        thinThick,
3208
        
3209
        
3210
        thickThin,
3211
        
3212
        
3213
        thickBetweenThin,
3214
    }
3215
    
3216
    
3217
    [Serializable]
3218
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3219
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
3220
    public enum ST_StrokeJoinStyle {
3221
        
3222
        
3223
        round,
3224
        
3225
        
3226
        bevel,
3227
        
3228
        
3229
        miter,
3230
    }
3231
    
3232
    
3233
    [Serializable]
3234
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3235
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
3236
    public enum ST_StrokeEndCap {
3237
        
3238
        
3239
        flat,
3240
        
3241
        
3242
        square,
3243
        
3244
        
3245
        round,
3246
    }
3247
    
3248
    
3249
    [Serializable]
3250
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3251
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
3252
    public enum ST_StrokeArrowType {
3253
        
3254
        
3255
        none,
3256
        
3257
        
3258
        block,
3259
        
3260
        
3261
        classic,
3262
        
3263
        
3264
        oval,
3265
        
3266
        
3267
        diamond,
3268
        
3269
        
3270
        open,
3271
    }
3272
    
3273
    
3274
    [Serializable]
3275
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3276
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
3277
    public enum ST_StrokeArrowWidth {
3278
        
3279
        
3280
        narrow,
3281
        
3282
        
3283
        medium,
3284
        
3285
        
3286
        wide,
3287
    }
3288
    
3289
    
3290
    [Serializable]
3291
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3292
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
3293
    public enum ST_StrokeArrowLength {
3294
        
3295
        
3296
        @short,
3297
        
3298
        
3299
        medium,
3300
        
3301
        
3302
        @long,
3303
    }
3304
    
3305
    
3306
    [Serializable]
3307

3308
    [System.ComponentModel.DesignerCategory("code")]
3309
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3310
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
3311
    public class CT_Textbox {
3312
        
3313
        private string itemField;
3314
        
3315
        private string idField;
3316
        
3317
        private string styleField;
3318
        
3319
        private string insetField;
3320
        
3321
        
3322
        //[XmlAnyElement()]
3323
        public string ItemXml {
3324
            get {
3325
                return this.itemField;
3326
            }
3327
            set {
3328
                this.itemField = value;
3329
            }
3330
        }
3331

3332

3333
        [XmlAttribute]
3334
        public string id
3335
        {
3336
            get {
3337
                return this.idField;
3338
            }
3339
            set {
3340
                this.idField = value;
3341
            }
3342
        }
3343
        
3344
        
3345
        [XmlAttribute]
3346
        public string style {
3347
            get {
3348
                return this.styleField;
3349
            }
3350
            set {
3351
                this.styleField = value;
3352
            }
3353
        }
3354
        
3355
        
3356
        [XmlAttribute]
3357
        public string inset {
3358
            get {
3359
                return this.insetField;
3360
            }
3361
            set {
3362
                this.insetField = value;
3363
            }
3364
        }
3365
        public static CT_Textbox Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3366
        {
3367
            if (node == null)
3368
                return null;
3369
            CT_Textbox ctObj = new CT_Textbox();
3370
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
3371
            ctObj.style = XmlHelper.ReadString(node.Attributes["style"]);
3372
            ctObj.inset = XmlHelper.ReadString(node.Attributes["inset"]);
3373
            ctObj.ItemXml = node.InnerXml;
3374
            return ctObj;
3375
        }
3376

3377

3378

3379
        internal void Write(StreamWriter sw, string nodeName)
3380
        {
3381
            sw.Write(string.Format("<v:{0}", nodeName));
3382
            XmlHelper.WriteAttribute(sw, "id", this.id);
3383
            XmlHelper.WriteAttribute(sw, "style", this.style);
3384
            XmlHelper.WriteAttribute(sw, "inset", this.inset);
3385
            sw.Write(">");
3386
            if (this.ItemXml != null)
3387
                sw.Write(this.ItemXml);
3388
            sw.Write(string.Format("</v:{0}>", nodeName));
3389
        }
3390

3391
    }
3392
    
3393
    
3394
    [Serializable]
3395

3396
    [System.ComponentModel.DesignerCategory("code")]
3397
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3398
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
3399
    public class CT_TextPath {
3400
        
3401
        private string idField;
3402
        
3403
        private string styleField;
3404
        
3405
        private ST_TrueFalse onField;
3406
        
3407
        private bool onFieldSpecified;
3408
        
3409
        private ST_TrueFalse fitshapeField;
3410
        
3411
        private bool fitshapeFieldSpecified;
3412
        
3413
        private ST_TrueFalse fitpathField;
3414
        
3415
        private bool fitpathFieldSpecified;
3416
        
3417
        private ST_TrueFalse trimField;
3418
        
3419
        private bool trimFieldSpecified;
3420
        
3421
        private ST_TrueFalse xscaleField;
3422
        
3423
        private bool xscaleFieldSpecified;
3424
        
3425
        private string stringField;
3426

3427
        public static CT_TextPath Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3428
        {
3429
            if (node == null)
3430
                return null;
3431
            CT_TextPath ctObj = new CT_TextPath();
3432
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
3433
            ctObj.style = XmlHelper.ReadString(node.Attributes["style"]);
3434
            if (node.Attributes["on"] != null)
3435
                ctObj.on = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["on"]);
3436
            if (node.Attributes["fitshape"] != null)
3437
                ctObj.fitshape = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["fitshape"]);
3438
            if (node.Attributes["fitpath"] != null)
3439
                ctObj.fitpath = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["fitpath"]);
3440
            if (node.Attributes["trim"] != null)
3441
                ctObj.trim = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["trim"]);
3442
            if (node.Attributes["xscale"] != null)
3443
                ctObj.xscale = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["xscale"]);
3444
            ctObj.@string = XmlHelper.ReadString(node.Attributes["string"]);
3445
            return ctObj;
3446
        }
3447

3448

3449

3450
        internal void Write(StreamWriter sw, string nodeName)
3451
        {
3452
            sw.Write(string.Format("<v:{0}", nodeName));
3453
            XmlHelper.WriteAttribute(sw, "id", this.id);
3454
            XmlHelper.WriteAttribute(sw, "style", this.style);
3455
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "on", this.on);
3456
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "fitshape", this.fitshape);
3457
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "fitpath", this.fitpath);
3458
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "trim", this.trim);
3459
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "xscale", this.xscale);
3460
            XmlHelper.WriteAttribute(sw, "string", this.@string);
3461
            sw.Write(">");
3462
            sw.Write(string.Format("</v:{0}>", nodeName));
3463
        }
3464

3465
        [XmlAttribute]
3466
        public string id
3467
        {
3468
            get {
3469
                return this.idField;
3470
            }
3471
            set {
3472
                this.idField = value;
3473
            }
3474
        }
3475
        
3476
        
3477
        [XmlAttribute]
3478
        public string style {
3479
            get {
3480
                return this.styleField;
3481
            }
3482
            set {
3483
                this.styleField = value;
3484
            }
3485
        }
3486
        
3487
        
3488
        [XmlAttribute]
3489
        public ST_TrueFalse on {
3490
            get {
3491
                return this.onField;
3492
            }
3493
            set {
3494
                this.onField = value;
3495
            }
3496
        }
3497
        
3498
        
3499
        [XmlIgnore]
3500
        public bool onSpecified {
3501
            get {
3502
                return this.onFieldSpecified;
3503
            }
3504
            set {
3505
                this.onFieldSpecified = value;
3506
            }
3507
        }
3508
        
3509
        
3510
        [XmlAttribute]
3511
        public ST_TrueFalse fitshape {
3512
            get {
3513
                return this.fitshapeField;
3514
            }
3515
            set {
3516
                this.fitshapeField = value;
3517
            }
3518
        }
3519
        
3520
        
3521
        [XmlIgnore]
3522
        public bool fitshapeSpecified {
3523
            get {
3524
                return this.fitshapeFieldSpecified;
3525
            }
3526
            set {
3527
                this.fitshapeFieldSpecified = value;
3528
            }
3529
        }
3530
        
3531
        
3532
        [XmlAttribute]
3533
        public ST_TrueFalse fitpath {
3534
            get {
3535
                return this.fitpathField;
3536
            }
3537
            set {
3538
                this.fitpathField = value;
3539
            }
3540
        }
3541
        
3542
        
3543
        [XmlIgnore]
3544
        public bool fitpathSpecified {
3545
            get {
3546
                return this.fitpathFieldSpecified;
3547
            }
3548
            set {
3549
                this.fitpathFieldSpecified = value;
3550
            }
3551
        }
3552
        
3553
        
3554
        [XmlAttribute]
3555
        public ST_TrueFalse trim {
3556
            get {
3557
                return this.trimField;
3558
            }
3559
            set {
3560
                this.trimField = value;
3561
            }
3562
        }
3563
        
3564
        
3565
        [XmlIgnore]
3566
        public bool trimSpecified {
3567
            get {
3568
                return this.trimFieldSpecified;
3569
            }
3570
            set {
3571
                this.trimFieldSpecified = value;
3572
            }
3573
        }
3574
        
3575
        
3576
        [XmlAttribute]
3577
        public ST_TrueFalse xscale {
3578
            get {
3579
                return this.xscaleField;
3580
            }
3581
            set {
3582
                this.xscaleField = value;
3583
            }
3584
        }
3585
        
3586
        
3587
        [XmlIgnore]
3588
        public bool xscaleSpecified {
3589
            get {
3590
                return this.xscaleFieldSpecified;
3591
            }
3592
            set {
3593
                this.xscaleFieldSpecified = value;
3594
            }
3595
        }
3596
        
3597
        
3598
        [XmlAttribute]
3599
        public string @string {
3600
            get {
3601
                return this.stringField;
3602
            }
3603
            set {
3604
                this.stringField = value;
3605
            }
3606
        }
3607
    }
3608
    
3609
    
3610
    [Serializable]
3611
    [XmlType(Namespace="urn:schemas-microsoft-com:vml", IncludeInSchema=false)]
3612
    public enum ItemsChoiceType1 {
3613
        
3614
        
3615
        [XmlEnum("urn:schemas-microsoft-com:office:excel:ClientData")]
3616
        ClientData,
3617
        
3618
        
3619
        [XmlEnum("urn:schemas-microsoft-com:office:powerpoint:iscomment")]
3620
        iscomment,
3621
        
3622
        
3623
        [XmlEnum("urn:schemas-microsoft-com:office:powerpoint:textdata")]
3624
        textdata,
3625
        
3626
        
3627
        [XmlEnum("urn:schemas-microsoft-com:office:word:anchorlock")]
3628
        anchorlock,
3629
        
3630
        
3631
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderbottom")]
3632
        borderbottom,
3633
        
3634
        
3635
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderleft")]
3636
        borderleft,
3637
        
3638
        
3639
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderright")]
3640
        borderright,
3641
        
3642
        
3643
        [XmlEnum("urn:schemas-microsoft-com:office:word:bordertop")]
3644
        bordertop,
3645
        
3646
        
3647
        [XmlEnum("urn:schemas-microsoft-com:office:word:wrap")]
3648
        wrap,
3649
        
3650
        
3651
        fill,
3652
        
3653
        
3654
        formulas,
3655
        
3656
        
3657
        handles,
3658
        
3659
        
3660
        imagedata,
3661
        
3662
        
3663
        path,
3664
        
3665
        
3666
        shadow,
3667
        
3668
        
3669
        stroke,
3670
        
3671
        
3672
        textbox,
3673
        
3674
        
3675
        textpath,
3676
    }
3677
    
3678
    
3679
    [Serializable]
3680

3681
    [System.ComponentModel.DesignerCategory("code")]
3682
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
3683
    [XmlRoot("shapetype",Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
3684
    public class CT_Shapetype {
3685
            
3686
        private CT_Path pathField;
3687
        
3688
        private List<CT_Formulas> formulasField = new List<CT_Formulas>();
3689
        
3690
        private List<CT_Handles> handlesField = new List<CT_Handles>();
3691
        
3692
        private List<CT_Fill> fillField = new List<CT_Fill>();
3693
        
3694
        private CT_Stroke strokeField;
3695
        
3696
        private List<CT_Shadow> shadowField;
3697
        
3698
        private List<CT_Textbox> textboxField;
3699
        
3700
        private List<CT_TextPath> textpathField = new List<CT_TextPath>();
3701
        
3702
        private List<CT_ImageData> imagedataField;
3703
        
3704
        private List<CT_Wrap> wrapField;
3705
        
3706
        private List<CT_AnchorLock> anchorlockField;
3707

3708
        private CT_Lock lockField;
3709
        
3710
        private List<CT_Border> bordertopField;
3711
        
3712
        private List<CT_Border> borderbottomField;
3713
        
3714
        private List<CT_Border> borderleftField;
3715
        
3716
        private List<CT_Border> borderrightField;
3717
        
3718
        private List<CT_ClientData> clientDataField;
3719
        
3720
        private List<CT_Rel> textdataField;
3721
        
3722
        private string adjField;
3723
        private string idField;
3724
        private ST_TrueFalse filledField = ST_TrueFalse.t;
3725
        private ST_TrueFalse strokedField = ST_TrueFalse.t;
3726
        private ST_TrueFalse preferrelativeField;
3727
        //private string styleField;
3728
        private float sptField;
3729
        private string coordsizeField;
3730

3731
        //static XmlSerializer serializer = new XmlSerializer(typeof(CT_Shapetype), "urn:schemas-microsoft-com:vml");
3732

3733
        //public static CT_Shapetype Parse(string xmltext)
3734
        //{
3735
        //    TextReader tr = new StringReader(xmltext);
3736
        //    CT_Shapetype obj = (CT_Shapetype)serializer.Deserialize(tr);
3737
        //    return obj;
3738
        //}
3739

3740
        public static CT_Shapetype Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3741
        {
3742
            if (node == null)
3743
                return null;
3744
            CT_Shapetype ctObj = new CT_Shapetype();
3745
            if (node.Attributes["stroked"] != null)
3746
                ctObj.stroked = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["stroked"]);
3747
            if (node.Attributes["filled"] != null)
3748
                ctObj.filled = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["filled"]);
3749
            if (node.Attributes["o:preferrelative"] != null)
3750
                ctObj.preferrelative = NPOI.OpenXmlFormats.Util.XmlHelper.ReadTrueFalse2(node.Attributes["o:preferrelative"]);
3751
            ctObj.coordsize = XmlHelper.ReadString(node.Attributes["coordsize"]);
3752
            if (node.Attributes["o:spt"] != null)
3753
                ctObj.id = XmlHelper.ReadString(node.Attributes["o:spt"]);
3754
            ctObj.adj = XmlHelper.ReadString(node.Attributes["adj"]);
3755
            ctObj.path2 = XmlHelper.ReadString(node.Attributes["path"]);
3756
            ctObj.formulas = new List<CT_Formulas>();
3757
            ctObj.handles = new List<CT_Handles>();
3758
            ctObj.fill = new List<CT_Fill>();
3759
            ctObj.shadow = new List<CT_Shadow>();
3760
            ctObj.textbox = new List<CT_Textbox>();
3761
            ctObj.textpath = new List<CT_TextPath>();
3762
            ctObj.imagedata = new List<CT_ImageData>();
3763
            ctObj.wrap = new List<CT_Wrap>();
3764
            ctObj.anchorlock = new List<CT_AnchorLock>();
3765
            ctObj.bordertop = new List<CT_Border>();
3766
            ctObj.borderbottom = new List<CT_Border>();
3767
            ctObj.borderleft = new List<CT_Border>();
3768
            ctObj.borderright = new List<CT_Border>();
3769
            ctObj.Clientdata = new List<CT_ClientData>();
3770
            ctObj.textdata = new List<CT_Rel>();
3771
            foreach (XmlNode childNode in node.ChildNodes)
3772
            {
3773
                if (childNode.LocalName == "stroke")
3774
                    ctObj.stroke = CT_Stroke.Parse(childNode, namespaceManager);
3775
                else if (childNode.LocalName == "path")
3776
                    ctObj.path = CT_Path.Parse(childNode, namespaceManager);
3777
                else if (childNode.LocalName == "lock")
3778
                    ctObj.@lock = CT_Lock.Parse(childNode, namespaceManager);
3779
                else if (childNode.LocalName == "formulas")
3780
                    ctObj.formulas.Add(CT_Formulas.Parse(childNode, namespaceManager));
3781
                else if (childNode.LocalName == "handles")
3782
                    ctObj.handles.Add(CT_Handles.Parse(childNode, namespaceManager));
3783
                else if (childNode.LocalName == "fill")
3784
                    ctObj.fill.Add(CT_Fill.Parse(childNode, namespaceManager));
3785
                else if (childNode.LocalName == "shadow")
3786
                    ctObj.shadow.Add(CT_Shadow.Parse(childNode, namespaceManager));
3787
                else if (childNode.LocalName == "textbox")
3788
                    ctObj.textbox.Add(CT_Textbox.Parse(childNode, namespaceManager));
3789
                else if (childNode.LocalName == "textpath")
3790
                    ctObj.textpath.Add(CT_TextPath.Parse(childNode, namespaceManager));
3791
                else if (childNode.LocalName == "imagedata")
3792
                    ctObj.imagedata.Add(CT_ImageData.Parse(childNode, namespaceManager));
3793
                else if (childNode.LocalName == "wrap")
3794
                    ctObj.wrap.Add(CT_Wrap.Parse(childNode, namespaceManager));
3795
                else if (childNode.LocalName == "anchorlock")
3796
                    ctObj.anchorlock.Add(new CT_AnchorLock());
3797
                else if (childNode.LocalName == "bordertop")
3798
                    ctObj.bordertop.Add(CT_Border.Parse(childNode, namespaceManager));
3799
                else if (childNode.LocalName == "borderbottom")
3800
                    ctObj.borderbottom.Add(CT_Border.Parse(childNode, namespaceManager));
3801
                else if (childNode.LocalName == "borderleft")
3802
                    ctObj.borderleft.Add(CT_Border.Parse(childNode, namespaceManager));
3803
                else if (childNode.LocalName == "borderright")
3804
                    ctObj.borderright.Add(CT_Border.Parse(childNode, namespaceManager));
3805
                else if (childNode.LocalName == "ClientData")
3806
                    ctObj.Clientdata.Add(CT_ClientData.Parse(childNode, namespaceManager));
3807
                else if (childNode.LocalName == "textdata")
3808
                    ctObj.textdata.Add(CT_Rel.Parse(childNode, namespaceManager));
3809
            }
3810
            return ctObj;
3811
        }
3812

3813

3814

3815
        public void Write(StreamWriter sw, string nodeName)
3816
        {
3817
            sw.Write(string.Format("<v:{0}", nodeName));
3818
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "stroked", this.stroked, true);
3819
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "filled", this.filled, true);
3820
            NPOI.OpenXmlFormats.Util.XmlHelper.WriteAttribute(sw, "o:preferrelative", this.preferrelative);
3821
            XmlHelper.WriteAttribute(sw, "coordsize", this.coordsize);
3822
            XmlHelper.WriteAttribute(sw, "o:spt", this.spt);
3823
            XmlHelper.WriteAttribute(sw, "id", this.id);
3824
            XmlHelper.WriteAttribute(sw, "adj", this.adj);
3825
            XmlHelper.WriteAttribute(sw, "path", this.path2);
3826
            sw.Write(">");
3827
            if (this.stroke != null)
3828
                this.stroke.Write(sw, "stroke");
3829
            if (this.path != null)
3830
                this.path.Write(sw, "path");
3831
            if (this.textpath != null)
3832
            {
3833
                foreach (CT_TextPath x in this.textpath)
3834
                {
3835
                    x.Write(sw, "textpath");
3836
                }
3837
            }
3838
            if (this.formulas != null)
3839
            {
3840
                foreach (CT_Formulas x in this.formulas)
3841
                {
3842
                    x.Write(sw, "formulas");
3843
                }
3844
            }
3845
            if (this.handles != null)
3846
            {
3847
                foreach (CT_Handles x in this.handles)
3848
                {
3849
                    x.Write(sw, "handles");
3850
                }
3851
            }
3852
            if (this.fill != null)
3853
            {
3854
                foreach (CT_Fill x in this.fill)
3855
                {
3856
                    x.Write(sw, "fill");
3857
                }
3858
            }
3859
            if (this.shadow != null)
3860
            {
3861
                foreach (CT_Shadow x in this.shadow)
3862
                {
3863
                    x.Write(sw, "shadow");
3864
                }
3865
            }
3866
            if (this.@lock != null)
3867
                this.@lock.Write(sw, "lock");
3868
            if (this.textbox != null)
3869
            {
3870
                foreach (CT_Textbox x in this.textbox)
3871
                {
3872
                    x.Write(sw, "textbox");
3873
                }
3874
            }
3875
            if (this.imagedata != null)
3876
            {
3877
                foreach (CT_ImageData x in this.imagedata)
3878
                {
3879
                    x.Write(sw, "imagedata");
3880
                }
3881
            }
3882
            if (this.wrap != null)
3883
            {
3884
                foreach (CT_Wrap x in this.wrap)
3885
                {
3886
                    x.Write(sw, "wrap");
3887
                }
3888
            }
3889
            if (this.anchorlock != null)
3890
            {
3891
                foreach (CT_AnchorLock x in this.anchorlock)
3892
                {
3893
                    sw.Write("<anchorlock/>");
3894
                }
3895
            }
3896
            if (this.bordertop != null)
3897
            {
3898
                foreach (CT_Border x in this.bordertop)
3899
                {
3900
                    x.Write(sw, "bordertop");
3901
                }
3902
            }
3903
            if (this.borderbottom != null)
3904
            {
3905
                foreach (CT_Border x in this.borderbottom)
3906
                {
3907
                    x.Write(sw, "borderbottom");
3908
                }
3909
            }
3910
            if (this.borderleft != null)
3911
            {
3912
                foreach (CT_Border x in this.borderleft)
3913
                {
3914
                    x.Write(sw, "borderleft");
3915
                }
3916
            }
3917
            if (this.borderright != null)
3918
            {
3919
                foreach (CT_Border x in this.borderright)
3920
                {
3921
                    x.Write(sw, "borderright");
3922
                }
3923
            }
3924
            if (this.Clientdata != null)
3925
            {
3926
                foreach (CT_ClientData x in this.Clientdata)
3927
                {
3928
                    x.Write(sw, "ClientData");
3929
                }
3930
            }
3931
            if (this.textdata != null)
3932
            {
3933
                foreach (CT_Rel x in this.textdata)
3934
                {
3935
                    x.Write(sw, "textdata");
3936
                }
3937
            }
3938
            sw.Write(string.Format("</v:{0}>", nodeName));
3939
        }
3940

3941
        [XmlAttribute]
3942
        public ST_TrueFalse stroked
3943
        {
3944
            get
3945
            {
3946
                return this.strokedField;
3947
            }
3948
            set
3949
            {
3950
                this.strokedField = value;
3951
            }
3952
        }
3953
        [XmlAttribute]
3954
        public ST_TrueFalse filled
3955
        {
3956
            get
3957
            {
3958
                return this.filledField;
3959
            }
3960
            set
3961
            {
3962
                this.filledField = value;
3963
            }
3964
        }
3965
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
3966
        public ST_TrueFalse preferrelative
3967
        {
3968
            get
3969
            {
3970
                return this.preferrelativeField;
3971
            }
3972
            set
3973
            {
3974
                this.preferrelativeField = value;
3975
            }
3976
        }
3977
        [XmlAttribute]
3978
        public string coordsize
3979
        {
3980
            get
3981
            {
3982
                return this.coordsizeField;
3983
            }
3984
            set
3985
            {
3986
                this.coordsizeField = value;
3987
            }
3988
        }
3989

3990
        [XmlAttribute(Namespace = "urn:schemas-microsoft-com:office:office")]
3991
        public float spt
3992
        {
3993
            get
3994
            {
3995
                return this.sptField;
3996
            }
3997
            set
3998
            {
3999
                this.sptField = value;
4000
            }
4001
        }
4002
        private string path1Field;
4003

4004
        [XmlAttribute]
4005
        public string id
4006
        {
4007
            get {
4008
                return this.idField;
4009
            }
4010
            set 
4011
            {
4012
                this.idField = value;
4013
            }
4014
        }
4015

4016

4017
        [XmlElement("stroke")]
4018
        public CT_Stroke stroke
4019
        {
4020
            get
4021
            {
4022
                return this.strokeField;
4023
            }
4024
            set
4025
            {
4026
                this.strokeField = value;
4027
            }
4028
        }
4029

4030

4031
        [XmlElement("formulas")]
4032
        public List<CT_Formulas> formulas
4033
        {
4034
            get
4035
            {
4036
                return this.formulasField;
4037
            }
4038
            set
4039
            {
4040

4041
                    this.formulasField = value;
4042
            }
4043
        }
4044

4045

4046
        [XmlElement("handles")]
4047
        public List<CT_Handles> handles
4048
        {
4049
            get
4050
            {
4051
                return this.handlesField;
4052
            }
4053
            set
4054
            {
4055
                    this.handlesField = value;
4056
            }
4057
        }
4058

4059

4060
        [XmlElement("fill")]
4061
        public List<CT_Fill> fill
4062
        {
4063
            get
4064
            {
4065
                return this.fillField;
4066
            }
4067
            set
4068
            {
4069
                this.fillField = value;
4070
            }
4071
        }
4072

4073

4074

4075

4076
        [XmlElement("shadow")]
4077
        public List<CT_Shadow> shadow
4078
        {
4079
            get
4080
            {
4081
                return this.shadowField;
4082
            }
4083
            set
4084
            {
4085
                this.shadowField = value;
4086
            }
4087
        }
4088

4089

4090
        [XmlElement("textbox")]
4091
        public List<CT_Textbox> textbox
4092
        {
4093
            get
4094
            {
4095
                return this.textboxField;
4096
            }
4097
            set
4098
            {
4099
                this.textboxField = value;
4100
            }
4101
        }
4102

4103

4104
        [XmlElement("textpath")]
4105
        public List<CT_TextPath> textpath
4106
        {
4107
            get
4108
            {
4109
                return this.textpathField;
4110
            }
4111
            set
4112
            {
4113
                this.textpathField = value;
4114
            }
4115
        }
4116

4117

4118
        [XmlElement("imagedata")]
4119
        public List<CT_ImageData> imagedata
4120
        {
4121
            get
4122
            {
4123
                return this.imagedataField;
4124
            }
4125
            set
4126
            {
4127
                this.imagedataField = value;
4128
            }
4129
        }
4130

4131

4132
        [XmlElement("wrap", Namespace = "urn:schemas-microsoft-com:office:word")]
4133
        public List<CT_Wrap> wrap
4134
        {
4135
            get
4136
            {
4137
                return this.wrapField;
4138
            }
4139
            set
4140
            {
4141
                this.wrapField = value;
4142
            }
4143
        }
4144

4145

4146
        [XmlElement("anchorlock", Namespace = "urn:schemas-microsoft-com:office:word")]
4147
        public List<CT_AnchorLock> anchorlock
4148
        {
4149
            get
4150
            {
4151
                return this.anchorlockField;
4152
            }
4153
            set
4154
            {
4155
                this.anchorlockField = value;
4156
            }
4157
        }
4158

4159
        [XmlElement("path")]
4160
        public CT_Path path
4161
        {
4162
            get
4163
            {
4164
                return this.pathField;
4165
            }
4166
            set
4167
            {
4168

4169
                this.pathField = value;
4170
            }
4171
        }
4172

4173
        [XmlElement("lock", Namespace = "urn:schemas-microsoft-com:office:office")]
4174
        public CT_Lock @lock
4175
        {
4176
            get
4177
            {
4178
                return this.lockField;
4179
            }
4180
            set
4181
            {
4182
                    this.lockField = value;
4183
            }
4184
        }
4185

4186
        [XmlElement("bordertop", Namespace = "urn:schemas-microsoft-com:office:word")]
4187
        public List<CT_Border> bordertop
4188
        {
4189
            get
4190
            {
4191
                return this.bordertopField;
4192
            }
4193
            set
4194
            {
4195
                this.bordertopField = value;
4196
            }
4197
        }
4198

4199

4200
        [XmlElement("borderbottom", Namespace = "urn:schemas-microsoft-com:office:word")]
4201
        public List<CT_Border> borderbottom
4202
        {
4203
            get
4204
            {
4205
                return this.borderbottomField;
4206
            }
4207
            set
4208
            {
4209
                this.borderbottomField = value;
4210
            }
4211
        }
4212

4213

4214
        [XmlElement("borderleft", Namespace = "urn:schemas-microsoft-com:office:word")]
4215
        public List<CT_Border> borderleft
4216
        {
4217
            get
4218
            {
4219
                return this.borderleftField;
4220
            }
4221
            set
4222
            {
4223
                this.borderleftField = value;
4224
            }
4225
        }
4226

4227

4228
        [XmlElement("borderright", Namespace = "urn:schemas-microsoft-com:office:word")]
4229
        public List<CT_Border> borderright
4230
        {
4231
            get
4232
            {
4233
                return this.borderrightField;
4234
            }
4235
            set
4236
            {
4237
                this.borderrightField = value;
4238
            }
4239
        }
4240
        
4241
        
4242
        [XmlElement("clientdata", Namespace="urn:schemas-microsoft-com:office:excel")]
4243
        public List<CT_ClientData> Clientdata {
4244
            get {
4245
                return this.clientDataField;
4246
            }
4247
            set {
4248
                this.clientDataField = value;
4249
            }
4250
        }
4251

4252

4253
        [XmlElement("textdata", Namespace = "urn:schemas-microsoft-com:office:powerpoint")]
4254
        public List<CT_Rel> textdata
4255
        {
4256
            get
4257
            {
4258
                return this.textdataField;
4259
            }
4260
            set
4261
            {
4262
                this.textdataField = value;
4263
            }
4264
        }
4265
        
4266
        
4267
        [XmlAttribute]
4268
        public string adj {
4269
            get {
4270
                return this.adjField;
4271
            }
4272
            set {
4273
                this.adjField = value;
4274
            }
4275
        }
4276
        
4277
        
4278
        [XmlAttribute("path")]
4279
        public string path2 {
4280
            get {
4281
                return this.path1Field;
4282
            }
4283
            set {
4284
                this.path1Field = value;
4285
            }
4286
        }
4287

4288
        public CT_Stroke AddNewStroke()
4289
        {
4290
            this.strokeField = new CT_Stroke();
4291
            return strokeField;
4292
        }
4293
        public CT_Path AddNewPath()
4294
        {
4295
                this.pathField = new CT_Path();
4296
            return this.pathField;
4297
        }
4298
        //internal static XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(new XmlQualifiedName[] {
4299
        //    new XmlQualifiedName("o", "urn:schemas-microsoft-com:office:office"),
4300
        //    new XmlQualifiedName("x", "urn:schemas-microsoft-com:office:excel"),
4301
        //    new XmlQualifiedName("v", "urn:schemas-microsoft-com:vml")
4302
        //});
4303

4304
        //public override string ToString()
4305
        //{
4306
        //    using (StringWriter stringWriter = new StringWriter())
4307
        //    {
4308
        //        XmlWriterSettings settings = new XmlWriterSettings();
4309
        //        settings.Encoding = Encoding.UTF8;
4310
        //        settings.OmitXmlDeclaration = true;
4311

4312
        //        using (XmlWriter writer = XmlWriter.Create(stringWriter, settings))
4313
        //        {
4314
        //            serializer.Serialize(writer, this, namespaces);
4315
        //        }
4316
        //        return stringWriter.ToString();
4317
        //    }
4318
        //}
4319

4320
        public CT_Formulas AddNewFormulas()
4321
        {
4322
            if (this.formulasField == null)
4323
                this.formulasField = new List<CT_Formulas>();
4324
            CT_Formulas obj = new CT_Formulas();
4325
            this.formulasField.Add(obj);
4326
            return obj;
4327
        }
4328

4329
        public CT_TextPath AddNewTextpath()
4330
        {
4331
            if (this.textpathField == null)
4332
                this.textpathField = new List<CT_TextPath>();
4333
            CT_TextPath obj = new CT_TextPath();
4334
            this.textpathField.Add(obj);
4335
            return obj;
4336
        }
4337

4338
        public CT_Handles AddNewHandles()
4339
        {
4340
            if (this.handlesField == null)
4341
                this.handlesField = new List<CT_Handles>();
4342
            CT_Handles obj = new CT_Handles();
4343
            this.handlesField.Add(obj);
4344
            return obj;
4345
        }
4346

4347
        public CT_Lock AddNewLock()
4348
        {
4349
            CT_Lock lockField = new CT_Lock();
4350
            return lockField;
4351
        }
4352
    }
4353
    
4354
    
4355
    [Serializable]
4356

4357
    [System.ComponentModel.DesignerCategory("code")]
4358
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
4359
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
4360
    public class CT_Group {
4361
        
4362
        private List<object> itemsField = new List<object>();
4363
        
4364
        private List<ItemsChoiceType6> itemsElementNameField = new List<ItemsChoiceType6>();
4365
        
4366
        private ST_TrueFalse filledField;
4367
        
4368
        private bool filledFieldSpecified;
4369
        
4370
        private string fillcolorField;
4371
        
4372
        private ST_EditAs editasField;
4373
        
4374
        private bool editasFieldSpecified;
4375
        
4376
        
4377
        [XmlElement("ClientData", typeof(CT_ClientData), Namespace="urn:schemas-microsoft-com:office:excel")]
4378
        [XmlElement("textdata", typeof(CT_Rel), Namespace="urn:schemas-microsoft-com:office:powerpoint")]
4379
        [XmlElement("anchorlock", typeof(CT_AnchorLock), Namespace="urn:schemas-microsoft-com:office:word")]
4380
        [XmlElement("borderbottom", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
4381
        [XmlElement("borderleft", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
4382
        [XmlElement("borderright", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
4383
        [XmlElement("bordertop", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
4384
        [XmlElement("wrap", typeof(CT_Wrap), Namespace="urn:schemas-microsoft-com:office:word")]
4385
        [XmlElement("arc", typeof(CT_Arc))]
4386
        [XmlElement("curve", typeof(CT_Curve))]
4387
        [XmlElement("fill", typeof(CT_Fill))]
4388
        [XmlElement("formulas", typeof(CT_Formulas))]
4389
        [XmlElement("group", typeof(CT_Group))]
4390
        [XmlElement("handles", typeof(CT_Handles))]
4391
        [XmlElement("image", typeof(CT_Image))]
4392
        [XmlElement("imagedata", typeof(CT_ImageData))]
4393
        [XmlElement("line", typeof(CT_Line))]
4394
        [XmlElement("oval", typeof(CT_Oval))]
4395
        [XmlElement("path", typeof(CT_Path))]
4396
        [XmlElement("polyline", typeof(CT_PolyLine))]
4397
        [XmlElement("rect", typeof(CT_Rect))]
4398
        [XmlElement("roundrect", typeof(CT_RoundRect))]
4399
        [XmlElement("shadow", typeof(CT_Shadow))]
4400
        [XmlElement("shape", typeof(CT_Shape))]
4401
        [XmlElement("shapetype", typeof(CT_Shapetype))]
4402
        [XmlElement("stroke", typeof(CT_Stroke))]
4403
        [XmlElement("textbox", typeof(CT_Textbox))]
4404
        [XmlElement("textpath", typeof(CT_TextPath))]
4405
        [XmlChoiceIdentifier("ItemsElementName")]
4406
        public object[] Items {
4407
            get {
4408
                if (this.itemsField == null)
4409
                    return null;
4410
                return this.itemsField.ToArray();
4411
            }
4412
            set {
4413
                if (value == null)
4414
                    this.itemsField = new List<object>();
4415
                else
4416
                    this.itemsField = new List<object>(value);
4417
            }
4418
        }
4419
        
4420
        
4421
        [XmlElement("ItemsElementName")]
4422
        [XmlIgnore]
4423
        public ItemsChoiceType6[] ItemsElementName {
4424
            get {
4425
                return this.itemsElementNameField.ToArray();
4426
            }
4427
            set {
4428
                if (value == null)
4429
                    this.itemsElementNameField = new List<ItemsChoiceType6>();
4430
                else
4431
                    this.itemsElementNameField = new List<ItemsChoiceType6>(value);
4432
            }
4433
        }
4434
        
4435
        
4436
        [XmlAttribute]
4437
        public ST_TrueFalse filled {
4438
            get {
4439
                return this.filledField;
4440
            }
4441
            set {
4442
                this.filledField = value;
4443
            }
4444
        }
4445
        
4446
        
4447
        [XmlIgnore]
4448
        public bool filledSpecified {
4449
            get {
4450
                return this.filledFieldSpecified;
4451
            }
4452
            set {
4453
                this.filledFieldSpecified = value;
4454
            }
4455
        }
4456
        
4457
        
4458
        [XmlAttribute]
4459
        public string fillcolor {
4460
            get {
4461
                return this.fillcolorField;
4462
            }
4463
            set {
4464
                this.fillcolorField = value;
4465
            }
4466
        }
4467
        
4468
        
4469
        [XmlAttribute]
4470
        public ST_EditAs editas {
4471
            get {
4472
                return this.editasField;
4473
            }
4474
            set {
4475
                this.editasField = value;
4476
            }
4477
        }
4478
        
4479
        
4480
        [XmlIgnore]
4481
        public bool editasSpecified {
4482
            get {
4483
                return this.editasFieldSpecified;
4484
            }
4485
            set {
4486
                this.editasFieldSpecified = value;
4487
            }
4488
        }
4489

4490
        public CT_Shapetype AddNewShapetype()
4491
        {
4492
            return AddNewObject<CT_Shapetype>(ItemsChoiceType6.shapetype);
4493
        }
4494
        #region Generic methods for object operation
4495

4496
        private List<T> GetObjectList<T>(ItemsChoiceType6 type) where T : class
4497
        {
4498
            lock (this)
4499
            {
4500
                List<T> list = new List<T>();
4501
                for (int i = 0; i < itemsElementNameField.Count; i++)
4502
                {
4503
                    if (itemsElementNameField[i] == type)
4504
                        list.Add(itemsField[i] as T);
4505
                }
4506
                return list;
4507
            }
4508
        }
4509
        private int SizeOfObjectArray(ItemsChoiceType6 type)
4510
        {
4511
            lock (this)
4512
            {
4513
                int size = 0;
4514
                for (int i = 0; i < itemsElementNameField.Count; i++)
4515
                {
4516
                    if (itemsElementNameField[i] == type)
4517
                        size++;
4518
                }
4519
                return size;
4520
            }
4521
        }
4522
        private T GetObjectArray<T>(int p, ItemsChoiceType6 type) where T : class
4523
        {
4524
            lock (this)
4525
            {
4526
                int pos = GetObjectIndex(type, p);
4527
                if (pos < 0 || pos >= this.itemsField.Count)
4528
                    return null;
4529
                return itemsField[pos] as T;
4530
            }
4531
        }
4532
        private T InsertNewObject<T>(ItemsChoiceType6 type, int p) where T : class, new()
4533
        {
4534
            T t = new T();
4535
            lock (this)
4536
            {
4537
                int pos = GetObjectIndex(type, p);
4538
                this.itemsElementNameField.Insert(pos, type);
4539
                this.itemsField.Insert(pos, t);
4540
            }
4541
            return t;
4542
        }
4543
        private T AddNewObject<T>(ItemsChoiceType6 type) where T : class, new()
4544
        {
4545
            T t = new T();
4546
            lock (this)
4547
            {
4548
                this.itemsElementNameField.Add(type);
4549
                this.itemsField.Add(t);
4550
            }
4551
            return t;
4552
        }
4553
        private void SetObjectArray<T>(ItemsChoiceType6 type, int p, T obj) where T : class
4554
        {
4555
            lock (this)
4556
            {
4557
                int pos = GetObjectIndex(type, p);
4558
                if (pos < 0 || pos >= this.itemsField.Count)
4559
                    return;
4560
                if (this.itemsField[pos] is T)
4561
                    this.itemsField[pos] = obj;
4562
                else
4563
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
4564
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
4565
            }
4566
        }
4567
        private int GetObjectIndex(ItemsChoiceType6 type, int p)
4568
        {
4569
            int index = -1;
4570
            int pos = 0;
4571
            for (int i = 0; i < itemsElementNameField.Count; i++)
4572
            {
4573
                if (itemsElementNameField[i] == type)
4574
                {
4575
                    if (pos == p)
4576
                    {
4577
                        //return itemsField[p] as T;
4578
                        index = i;
4579
                        break;
4580
                    }
4581
                    else
4582
                        pos++;
4583
                }
4584
            }
4585
            return index;
4586
        }
4587
        private void RemoveObject(ItemsChoiceType6 type, int p)
4588
        {
4589
            lock (this)
4590
            {
4591
                int pos = GetObjectIndex(type, p);
4592
                if (pos < 0 || pos >= this.itemsField.Count)
4593
                    return;
4594
                itemsElementNameField.RemoveAt(pos);
4595
                itemsField.RemoveAt(pos);
4596
            }
4597
        }
4598
        #endregion
4599

4600
        public CT_Shape AddNewShape()
4601
        {
4602
            return AddNewObject<CT_Shape>(ItemsChoiceType6.shape);
4603
        }
4604
    }
4605
    
4606
    
4607
    [Serializable]
4608

4609
    [System.ComponentModel.DesignerCategory("code")]
4610
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
4611
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
4612
    public class CT_Arc {
4613
        
4614
        private List<CT_Path> pathField;
4615
        
4616
        private List<CT_Formulas> formulasField;
4617
        
4618
        private List<CT_Handles> handlesField;
4619
        
4620
        private List<CT_Fill> fillField;
4621
        
4622
        private List<CT_Stroke> strokeField;
4623
        
4624
        private List<CT_Shadow> shadowField;
4625
        
4626
        private List<CT_Textbox> textboxField;
4627
        
4628
        private List<CT_TextPath> textpathField;
4629
        
4630
        private List<CT_ImageData> imagedataField;
4631
        
4632
        private List<CT_Wrap> wrapField;
4633
        
4634
        private List<CT_AnchorLock> anchorlockField;
4635
        
4636
        private List<CT_Border> bordertopField;
4637
        
4638
        private List<CT_Border> borderbottomField;
4639
        
4640
        private List<CT_Border> borderleftField;
4641
        
4642
        private List<CT_Border> borderrightField;
4643
        
4644
        private List<CT_ClientData> clientDataField;
4645
        
4646
        private List<CT_Rel> textdataField;
4647
        
4648
        private decimal startAngleField;
4649
        
4650
        private bool startAngleFieldSpecified;
4651
        
4652
        private decimal endAngleField;
4653
        
4654
        private bool endAngleFieldSpecified;
4655
        
4656
        
4657
        [XmlElement("path")]
4658
        public List<CT_Path> path {
4659
            get {
4660
                return this.pathField;
4661
            }
4662
            set {
4663
                this.pathField = value;
4664
            }
4665
        }
4666
        
4667
        
4668
        [XmlElement("formulas")]
4669
        public List<CT_Formulas> formulas {
4670
            get {
4671
                return this.formulasField;
4672
            }
4673
            set {
4674
                this.formulasField = value;
4675
            }
4676
        }
4677
        
4678
        
4679
        [XmlElement("handles")]
4680
        public List<CT_Handles> handles {
4681
            get {
4682
                return this.handlesField;
4683
            }
4684
            set {
4685
                this.handlesField = value;
4686
            }
4687
        }
4688
        
4689
        
4690
        [XmlElement("fill")]
4691
        public List<CT_Fill> fill {
4692
            get {
4693
                return this.fillField;
4694
            }
4695
            set {
4696
                this.fillField = value;
4697
            }
4698
        }
4699
        
4700
        
4701
        [XmlElement("stroke")]
4702
        public List<CT_Stroke> stroke {
4703
            get {
4704
                return this.strokeField;
4705
            }
4706
            set {
4707
                this.strokeField = value;
4708
            }
4709
        }
4710
        
4711
        
4712
        [XmlElement("shadow")]
4713
        public List<CT_Shadow> shadow {
4714
            get {
4715
                return this.shadowField;
4716
            }
4717
            set {
4718
                this.shadowField = value;
4719
            }
4720
        }
4721
        
4722
        
4723
        [XmlElement("textbox")]
4724
        public List<CT_Textbox> textbox {
4725
            get {
4726
                return this.textboxField;
4727
            }
4728
            set {
4729
                this.textboxField = value;
4730
            }
4731
        }
4732
        
4733
        
4734
        [XmlElement("textpath")]
4735
        public List<CT_TextPath> textpath {
4736
            get {
4737
                return this.textpathField;
4738
            }
4739
            set {
4740
                this.textpathField = value;
4741
            }
4742
        }
4743
        
4744
        
4745
        [XmlElement("imagedata")]
4746
        public List<CT_ImageData> imagedata {
4747
            get {
4748
                return this.imagedataField;
4749
            }
4750
            set {
4751
                this.imagedataField = value;
4752
            }
4753
        }
4754
        
4755
        
4756
        [XmlElement("wrap", Namespace="urn:schemas-microsoft-com:office:word")]
4757
        public List<CT_Wrap> wrap {
4758
            get {
4759
                return this.wrapField;
4760
            }
4761
            set {
4762
                this.wrapField = value;
4763
            }
4764
        }
4765
        
4766
        
4767
        [XmlElement("anchorlock", Namespace="urn:schemas-microsoft-com:office:word")]
4768
        public List<CT_AnchorLock> anchorlock {
4769
            get {
4770
                return this.anchorlockField;
4771
            }
4772
            set {
4773
                this.anchorlockField = value;
4774
            }
4775
        }
4776
        
4777
        
4778
        [XmlElement("bordertop", Namespace="urn:schemas-microsoft-com:office:word")]
4779
        public List<CT_Border> bordertop {
4780
            get {
4781
                return this.bordertopField;
4782
            }
4783
            set {
4784
                this.bordertopField = value;
4785
            }
4786
        }
4787
        
4788
        
4789
        [XmlElement("borderbottom", Namespace="urn:schemas-microsoft-com:office:word")]
4790
        public List<CT_Border> borderbottom {
4791
            get {
4792
                return this.borderbottomField;
4793
            }
4794
            set {
4795
                this.borderbottomField = value;
4796
            }
4797
        }
4798
        
4799
        
4800
        [XmlElement("borderleft", Namespace="urn:schemas-microsoft-com:office:word")]
4801
        public List<CT_Border> borderleft {
4802
            get {
4803
                return this.borderleftField;
4804
            }
4805
            set {
4806
                this.borderleftField = value;
4807
            }
4808
        }
4809
        
4810
        
4811
        [XmlElement("borderright", Namespace="urn:schemas-microsoft-com:office:word")]
4812
        public List<CT_Border> borderright {
4813
            get {
4814
                return this.borderrightField;
4815
            }
4816
            set {
4817
                this.borderrightField = value;
4818
            }
4819
        }
4820
        
4821
        
4822
        [XmlElement("ClientData", Namespace="urn:schemas-microsoft-com:office:excel")]
4823
        public List<CT_ClientData> ClientData {
4824
            get {
4825
                return this.clientDataField;
4826
            }
4827
            set {
4828
                this.clientDataField = value;
4829
            }
4830
        }
4831
        
4832
        
4833
        [XmlElement("textdata", Namespace="urn:schemas-microsoft-com:office:powerpoint")]
4834
        public List<CT_Rel> textdata {
4835
            get {
4836
                return this.textdataField;
4837
            }
4838
            set {
4839
                this.textdataField = value;
4840
            }
4841
        }
4842
        
4843
        
4844
        [XmlAttribute]
4845
        public decimal startAngle {
4846
            get {
4847
                return this.startAngleField;
4848
            }
4849
            set {
4850
                this.startAngleField = value;
4851
            }
4852
        }
4853
        
4854
        
4855
        [XmlIgnore]
4856
        public bool startAngleSpecified {
4857
            get {
4858
                return this.startAngleFieldSpecified;
4859
            }
4860
            set {
4861
                this.startAngleFieldSpecified = value;
4862
            }
4863
        }
4864
        
4865
        
4866
        [XmlAttribute]
4867
        public decimal endAngle {
4868
            get {
4869
                return this.endAngleField;
4870
            }
4871
            set {
4872
                this.endAngleField = value;
4873
            }
4874
        }
4875
        
4876
        
4877
        [XmlIgnore]
4878
        public bool endAngleSpecified {
4879
            get {
4880
                return this.endAngleFieldSpecified;
4881
            }
4882
            set {
4883
                this.endAngleFieldSpecified = value;
4884
            }
4885
        }
4886
    }
4887
    
4888
    
4889
    [Serializable]
4890

4891
    [System.ComponentModel.DesignerCategory("code")]
4892
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
4893
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
4894
    public class CT_Curve {
4895
        
4896
        private List<CT_Path> pathField;
4897
        
4898
        private List<CT_Formulas> formulasField;
4899
        
4900
        private List<CT_Handles> handlesField;
4901
        
4902
        private List<CT_Fill> fillField;
4903
        
4904
        private List<CT_Stroke> strokeField;
4905
        
4906
        private List<CT_Shadow> shadowField;
4907
        
4908
        private List<CT_Textbox> textboxField;
4909
        
4910
        private List<CT_TextPath> textpathField;
4911
        
4912
        private List<CT_ImageData> imagedataField;
4913
        
4914
        private List<CT_Wrap> wrapField;
4915
        
4916
        private List<CT_AnchorLock> anchorlockField;
4917
        
4918
        private List<CT_Border> bordertopField;
4919
        
4920
        private List<CT_Border> borderbottomField;
4921
        
4922
        private List<CT_Border> borderleftField;
4923
        
4924
        private List<CT_Border> borderrightField;
4925
        
4926
        private List<CT_ClientData> clientDataField;
4927
        
4928
        private List<CT_Rel> textdataField;
4929
        
4930
        private string fromField;
4931
        
4932
        private string control1Field;
4933
        
4934
        private string control2Field;
4935
        
4936
        private string toField;
4937
        
4938
        
4939
        [XmlElement("path")]
4940
        public List<CT_Path> path {
4941
            get {
4942
                return this.pathField;
4943
            }
4944
            set {
4945
                this.pathField = value;
4946
            }
4947
        }
4948
        
4949
        
4950
        [XmlElement("formulas")]
4951
        public List<CT_Formulas> formulas {
4952
            get {
4953
                return this.formulasField;
4954
            }
4955
            set {
4956
                this.formulasField = value;
4957
            }
4958
        }
4959
        
4960
        
4961
        [XmlElement("handles")]
4962
        public List<CT_Handles> handles {
4963
            get {
4964
                return this.handlesField;
4965
            }
4966
            set {
4967
                this.handlesField = value;
4968
            }
4969
        }
4970
        
4971
        
4972
        [XmlElement("fill")]
4973
        public List<CT_Fill> fill {
4974
            get {
4975
                return this.fillField;
4976
            }
4977
            set {
4978
                this.fillField = value;
4979
            }
4980
        }
4981
        
4982
        
4983
        [XmlElement("stroke")]
4984
        public List<CT_Stroke> stroke {
4985
            get {
4986
                return this.strokeField;
4987
            }
4988
            set {
4989
                this.strokeField = value;
4990
            }
4991
        }
4992
        
4993
        
4994
        [XmlElement("shadow")]
4995
        public List<CT_Shadow> shadow {
4996
            get {
4997
                return this.shadowField;
4998
            }
4999
            set {
5000
                this.shadowField = value;
5001
            }
5002
        }
5003
        
5004
        
5005
        [XmlElement("textbox")]
5006
        public List<CT_Textbox> textbox {
5007
            get {
5008
                return this.textboxField;
5009
            }
5010
            set {
5011
                this.textboxField = value;
5012
            }
5013
        }
5014
        
5015
        
5016
        [XmlElement("textpath")]
5017
        public List<CT_TextPath> textpath {
5018
            get {
5019
                return this.textpathField;
5020
            }
5021
            set {
5022
                this.textpathField = value;
5023
            }
5024
        }
5025
        
5026
        
5027
        [XmlElement("imagedata")]
5028
        public List<CT_ImageData> imagedata {
5029
            get {
5030
                return this.imagedataField;
5031
            }
5032
            set {
5033
                this.imagedataField = value;
5034
            }
5035
        }
5036
        
5037
        
5038
        [XmlElement("wrap", Namespace="urn:schemas-microsoft-com:office:word")]
5039
        public List<CT_Wrap> wrap {
5040
            get {
5041
                return this.wrapField;
5042
            }
5043
            set {
5044
                this.wrapField = value;
5045
            }
5046
        }
5047
        
5048
        
5049
        [XmlElement("anchorlock", Namespace="urn:schemas-microsoft-com:office:word")]
5050
        public List<CT_AnchorLock> anchorlock {
5051
            get {
5052
                return this.anchorlockField;
5053
            }
5054
            set {
5055
                this.anchorlockField = value;
5056
            }
5057
        }
5058
        
5059
        
5060
        [XmlElement("bordertop", Namespace="urn:schemas-microsoft-com:office:word")]
5061
        public List<CT_Border> bordertop {
5062
            get {
5063
                return this.bordertopField;
5064
            }
5065
            set {
5066
                this.bordertopField = value;
5067
            }
5068
        }
5069
        
5070
        
5071
        [XmlElement("borderbottom", Namespace="urn:schemas-microsoft-com:office:word")]
5072
        public List<CT_Border> borderbottom {
5073
            get {
5074
                return this.borderbottomField;
5075
            }
5076
            set {
5077
                this.borderbottomField = value;
5078
            }
5079
        }
5080
        
5081
        
5082
        [XmlElement("borderleft", Namespace="urn:schemas-microsoft-com:office:word")]
5083
        public List<CT_Border> borderleft {
5084
            get {
5085
                return this.borderleftField;
5086
            }
5087
            set {
5088
                this.borderleftField = value;
5089
            }
5090
        }
5091
        
5092
        
5093
        [XmlElement("borderright", Namespace="urn:schemas-microsoft-com:office:word")]
5094
        public List<CT_Border> borderright {
5095
            get {
5096
                return this.borderrightField;
5097
            }
5098
            set {
5099
                this.borderrightField = value;
5100
            }
5101
        }
5102
        
5103
        
5104
        [XmlElement("ClientData", Namespace="urn:schemas-microsoft-com:office:excel")]
5105
        public List<CT_ClientData> ClientData {
5106
            get {
5107
                return this.clientDataField;
5108
            }
5109
            set {
5110
                this.clientDataField = value;
5111
            }
5112
        }
5113
        
5114
        
5115
        [XmlElement("textdata", Namespace="urn:schemas-microsoft-com:office:powerpoint")]
5116
        public List<CT_Rel> textdata {
5117
            get {
5118
                return this.textdataField;
5119
            }
5120
            set {
5121
                this.textdataField = value;
5122
            }
5123
        }
5124
        
5125
        
5126
        [XmlAttribute]
5127
        public string from {
5128
            get {
5129
                return this.fromField;
5130
            }
5131
            set {
5132
                this.fromField = value;
5133
            }
5134
        }
5135
        
5136
        
5137
        [XmlAttribute]
5138
        public string control1 {
5139
            get {
5140
                return this.control1Field;
5141
            }
5142
            set {
5143
                this.control1Field = value;
5144
            }
5145
        }
5146
        
5147
        
5148
        [XmlAttribute]
5149
        public string control2 {
5150
            get {
5151
                return this.control2Field;
5152
            }
5153
            set {
5154
                this.control2Field = value;
5155
            }
5156
        }
5157
        
5158
        
5159
        [XmlAttribute]
5160
        public string to {
5161
            get {
5162
                return this.toField;
5163
            }
5164
            set {
5165
                this.toField = value;
5166
            }
5167
        }
5168
    }
5169
    
5170
    
5171
    [Serializable]
5172

5173
    [System.ComponentModel.DesignerCategory("code")]
5174
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
5175
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
5176
    public class CT_Image {
5177
        
5178
        private List<CT_Path> pathField;
5179
        
5180
        private List<CT_Formulas> formulasField;
5181
        
5182
        private List<CT_Handles> handlesField;
5183
        
5184
        private List<CT_Fill> fillField;
5185
        
5186
        private List<CT_Stroke> strokeField;
5187
        
5188
        private List<CT_Shadow> shadowField;
5189
        
5190
        private List<CT_Textbox> textboxField;
5191
        
5192
        private List<CT_TextPath> textpathField;
5193
        
5194
        private List<CT_ImageData> imagedataField;
5195
        
5196
        private List<CT_Wrap> wrapField;
5197
        
5198
        private List<CT_AnchorLock> anchorlockField;
5199
        
5200
        private List<CT_Border> bordertopField;
5201
        
5202
        private List<CT_Border> borderbottomField;
5203
        
5204
        private List<CT_Border> borderleftField;
5205
        
5206
        private List<CT_Border> borderrightField;
5207
        
5208
        private List<CT_ClientData> clientDataField;
5209
        
5210
        private List<CT_Rel> textdataField;
5211
        
5212
        private string srcField;
5213
        
5214
        private string cropleftField;
5215
        
5216
        private string croptopField;
5217
        
5218
        private string croprightField;
5219
        
5220
        private string cropbottomField;
5221
        
5222
        private string gainField;
5223
        
5224
        private string blacklevelField;
5225
        
5226
        private string gammaField;
5227
        
5228
        private ST_TrueFalse grayscaleField;
5229
        
5230
        private bool grayscaleFieldSpecified;
5231
        
5232
        private ST_TrueFalse bilevelField;
5233
        
5234
        private bool bilevelFieldSpecified;
5235
        
5236
        
5237
        [XmlElement("path")]
5238
        public List<CT_Path> path {
5239
            get {
5240
                return this.pathField;
5241
            }
5242
            set {
5243
                this.pathField = value;
5244
            }
5245
        }
5246
        
5247
        
5248
        [XmlElement("formulas")]
5249
        public List<CT_Formulas> formulas {
5250
            get {
5251
                return this.formulasField;
5252
            }
5253
            set {
5254
                this.formulasField = value;
5255
            }
5256
        }
5257
        
5258
        
5259
        [XmlElement("handles")]
5260
        public List<CT_Handles> handles {
5261
            get {
5262
                return this.handlesField;
5263
            }
5264
            set {
5265
                this.handlesField = value;
5266
            }
5267
        }
5268
        
5269
        
5270
        [XmlElement("fill")]
5271
        public List<CT_Fill> fill {
5272
            get {
5273
                return this.fillField;
5274
            }
5275
            set {
5276
                this.fillField = value;
5277
            }
5278
        }
5279
        
5280
        
5281
        [XmlElement("stroke")]
5282
        public List<CT_Stroke> stroke {
5283
            get {
5284
                return this.strokeField;
5285
            }
5286
            set {
5287
                this.strokeField = value;
5288
            }
5289
        }
5290
        
5291
        
5292
        [XmlElement("shadow")]
5293
        public List<CT_Shadow> shadow {
5294
            get {
5295
                return this.shadowField;
5296
            }
5297
            set {
5298
                this.shadowField = value;
5299
            }
5300
        }
5301
        
5302
        
5303
        [XmlElement("textbox")]
5304
        public List<CT_Textbox> textbox {
5305
            get {
5306
                return this.textboxField;
5307
            }
5308
            set {
5309
                this.textboxField = value;
5310
            }
5311
        }
5312
        
5313
        
5314
        [XmlElement("textpath")]
5315
        public List<CT_TextPath> textpath {
5316
            get {
5317
                return this.textpathField;
5318
            }
5319
            set {
5320
                this.textpathField = value;
5321
            }
5322
        }
5323
        
5324
        
5325
        [XmlElement("imagedata")]
5326
        public List<CT_ImageData> imagedata {
5327
            get {
5328
                return this.imagedataField;
5329
            }
5330
            set {
5331
                this.imagedataField = value;
5332
            }
5333
        }
5334
        
5335
        
5336
        [XmlElement("wrap", Namespace="urn:schemas-microsoft-com:office:word")]
5337
        public List<CT_Wrap> wrap {
5338
            get {
5339
                return this.wrapField;
5340
            }
5341
            set {
5342
                this.wrapField = value;
5343
            }
5344
        }
5345
        
5346
        
5347
        [XmlElement("anchorlock", Namespace="urn:schemas-microsoft-com:office:word")]
5348
        public List<CT_AnchorLock> anchorlock {
5349
            get {
5350
                return this.anchorlockField;
5351
            }
5352
            set {
5353
                this.anchorlockField = value;
5354
            }
5355
        }
5356
        
5357
        
5358
        [XmlElement("bordertop", Namespace="urn:schemas-microsoft-com:office:word")]
5359
        public List<CT_Border> bordertop {
5360
            get {
5361
                return this.bordertopField;
5362
            }
5363
            set {
5364
                this.bordertopField = value;
5365
            }
5366
        }
5367
        
5368
        
5369
        [XmlElement("borderbottom", Namespace="urn:schemas-microsoft-com:office:word")]
5370
        public List<CT_Border> borderbottom {
5371
            get {
5372
                return this.borderbottomField;
5373
            }
5374
            set {
5375
                this.borderbottomField = value;
5376
            }
5377
        }
5378
        
5379
        
5380
        [XmlElement("borderleft", Namespace="urn:schemas-microsoft-com:office:word")]
5381
        public List<CT_Border> borderleft {
5382
            get {
5383
                return this.borderleftField;
5384
            }
5385
            set {
5386
                this.borderleftField = value;
5387
            }
5388
        }
5389
        
5390
        
5391
        [XmlElement("borderright", Namespace="urn:schemas-microsoft-com:office:word")]
5392
        public List<CT_Border> borderright {
5393
            get {
5394
                return this.borderrightField;
5395
            }
5396
            set {
5397
                this.borderrightField = value;
5398
            }
5399
        }
5400
        
5401
        
5402
        [XmlElement("ClientData", Namespace="urn:schemas-microsoft-com:office:excel")]
5403
        public List<CT_ClientData> ClientData {
5404
            get {
5405
                return this.clientDataField;
5406
            }
5407
            set {
5408
                this.clientDataField = value;
5409
            }
5410
        }
5411
        
5412
        
5413
        [XmlElement("textdata", Namespace="urn:schemas-microsoft-com:office:powerpoint")]
5414
        public List<CT_Rel> textdata {
5415
            get {
5416
                return this.textdataField;
5417
            }
5418
            set {
5419
                this.textdataField = value;
5420
            }
5421
        }
5422
        
5423
        
5424
        [XmlAttribute]
5425
        public string src {
5426
            get {
5427
                return this.srcField;
5428
            }
5429
            set {
5430
                this.srcField = value;
5431
            }
5432
        }
5433
        
5434
        
5435
        [XmlAttribute]
5436
        public string cropleft {
5437
            get {
5438
                return this.cropleftField;
5439
            }
5440
            set {
5441
                this.cropleftField = value;
5442
            }
5443
        }
5444
        
5445
        
5446
        [XmlAttribute]
5447
        public string croptop {
5448
            get {
5449
                return this.croptopField;
5450
            }
5451
            set {
5452
                this.croptopField = value;
5453
            }
5454
        }
5455
        
5456
        
5457
        [XmlAttribute]
5458
        public string cropright {
5459
            get {
5460
                return this.croprightField;
5461
            }
5462
            set {
5463
                this.croprightField = value;
5464
            }
5465
        }
5466
        
5467
        
5468
        [XmlAttribute]
5469
        public string cropbottom {
5470
            get {
5471
                return this.cropbottomField;
5472
            }
5473
            set {
5474
                this.cropbottomField = value;
5475
            }
5476
        }
5477
        
5478
        
5479
        [XmlAttribute]
5480
        public string gain {
5481
            get {
5482
                return this.gainField;
5483
            }
5484
            set {
5485
                this.gainField = value;
5486
            }
5487
        }
5488
        
5489
        
5490
        [XmlAttribute]
5491
        public string blacklevel {
5492
            get {
5493
                return this.blacklevelField;
5494
            }
5495
            set {
5496
                this.blacklevelField = value;
5497
            }
5498
        }
5499
        
5500
        
5501
        [XmlAttribute]
5502
        public string gamma {
5503
            get {
5504
                return this.gammaField;
5505
            }
5506
            set {
5507
                this.gammaField = value;
5508
            }
5509
        }
5510
        
5511
        
5512
        [XmlAttribute]
5513
        public ST_TrueFalse grayscale {
5514
            get {
5515
                return this.grayscaleField;
5516
            }
5517
            set {
5518
                this.grayscaleField = value;
5519
            }
5520
        }
5521
        
5522
        
5523
        [XmlIgnore]
5524
        public bool grayscaleSpecified {
5525
            get {
5526
                return this.grayscaleFieldSpecified;
5527
            }
5528
            set {
5529
                this.grayscaleFieldSpecified = value;
5530
            }
5531
        }
5532
        
5533
        
5534
        [XmlAttribute]
5535
        public ST_TrueFalse bilevel {
5536
            get {
5537
                return this.bilevelField;
5538
            }
5539
            set {
5540
                this.bilevelField = value;
5541
            }
5542
        }
5543
        
5544
        
5545
        [XmlIgnore]
5546
        public bool bilevelSpecified {
5547
            get {
5548
                return this.bilevelFieldSpecified;
5549
            }
5550
            set {
5551
                this.bilevelFieldSpecified = value;
5552
            }
5553
        }
5554
    }
5555
    
5556
    
5557
    [Serializable]
5558

5559
    [System.ComponentModel.DesignerCategory("code")]
5560
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
5561
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
5562
    public class CT_Line {
5563
        
5564
        private List<CT_Path> pathField;
5565
        
5566
        private List<CT_Formulas> formulasField;
5567
        
5568
        private List<CT_Handles> handlesField;
5569
        
5570
        private List<CT_Fill> fillField;
5571
        
5572
        private List<CT_Stroke> strokeField;
5573
        
5574
        private List<CT_Shadow> shadowField;
5575
        
5576
        private List<CT_Textbox> textboxField;
5577
        
5578
        private List<CT_TextPath> textpathField;
5579
        
5580
        private List<CT_ImageData> imagedataField;
5581
        
5582
        private List<CT_Wrap> wrapField;
5583
        
5584
        private List<CT_AnchorLock> anchorlockField;
5585
        
5586
        private List<CT_Border> bordertopField;
5587
        
5588
        private List<CT_Border> borderbottomField;
5589
        
5590
        private List<CT_Border> borderleftField;
5591
        
5592
        private List<CT_Border> borderrightField;
5593
        
5594
        private List<CT_ClientData> clientDataField;
5595
        
5596
        private List<CT_Rel> textdataField;
5597
        
5598
        private string fromField;
5599
        
5600
        private string toField;
5601
        
5602
        
5603
        [XmlElement("path")]
5604
        public List<CT_Path> path {
5605
            get {
5606
                return this.pathField;
5607
            }
5608
            set {
5609
                this.pathField = value;
5610
            }
5611
        }
5612
        
5613
        
5614
        [XmlElement("formulas")]
5615
        public List<CT_Formulas> formulas {
5616
            get {
5617
                return this.formulasField;
5618
            }
5619
            set {
5620
                this.formulasField = value;
5621
            }
5622
        }
5623
        
5624
        
5625
        [XmlElement("handles")]
5626
        public List<CT_Handles> handles {
5627
            get {
5628
                return this.handlesField;
5629
            }
5630
            set {
5631
                this.handlesField = value;
5632
            }
5633
        }
5634
        
5635
        
5636
        [XmlElement("fill")]
5637
        public List<CT_Fill> fill {
5638
            get {
5639
                return this.fillField;
5640
            }
5641
            set {
5642
                this.fillField = value;
5643
            }
5644
        }
5645
        
5646
        
5647
        [XmlElement("stroke")]
5648
        public List<CT_Stroke> stroke {
5649
            get {
5650
                return this.strokeField;
5651
            }
5652
            set {
5653
                this.strokeField = value;
5654
            }
5655
        }
5656
        
5657
        
5658
        [XmlElement("shadow")]
5659
        public List<CT_Shadow> shadow {
5660
            get {
5661
                return this.shadowField;
5662
            }
5663
            set {
5664
                this.shadowField = value;
5665
            }
5666
        }
5667
        
5668
        
5669
        [XmlElement("textbox")]
5670
        public List<CT_Textbox> textbox {
5671
            get {
5672
                return this.textboxField;
5673
            }
5674
            set {
5675
                this.textboxField = value;
5676
            }
5677
        }
5678
        
5679
        
5680
        [XmlElement("textpath")]
5681
        public List<CT_TextPath> textpath {
5682
            get {
5683
                return this.textpathField;
5684
            }
5685
            set {
5686
                this.textpathField = value;
5687
            }
5688
        }
5689
        
5690
        
5691
        [XmlElement("imagedata")]
5692
        public List<CT_ImageData> imagedata {
5693
            get {
5694
                return this.imagedataField;
5695
            }
5696
            set {
5697
                this.imagedataField = value;
5698
            }
5699
        }
5700
        
5701
        
5702
        [XmlElement("wrap", Namespace="urn:schemas-microsoft-com:office:word")]
5703
        public List<CT_Wrap> wrap {
5704
            get {
5705
                return this.wrapField;
5706
            }
5707
            set {
5708
                this.wrapField = value;
5709
            }
5710
        }
5711
        
5712
        
5713
        [XmlElement("anchorlock", Namespace="urn:schemas-microsoft-com:office:word")]
5714
        public List<CT_AnchorLock> anchorlock {
5715
            get {
5716
                return this.anchorlockField;
5717
            }
5718
            set {
5719
                this.anchorlockField = value;
5720
            }
5721
        }
5722
        
5723
        
5724
        [XmlElement("bordertop", Namespace="urn:schemas-microsoft-com:office:word")]
5725
        public List<CT_Border> bordertop {
5726
            get {
5727
                return this.bordertopField;
5728
            }
5729
            set {
5730
                this.bordertopField = value;
5731
            }
5732
        }
5733
        
5734
        
5735
        [XmlElement("borderbottom", Namespace="urn:schemas-microsoft-com:office:word")]
5736
        public List<CT_Border> borderbottom {
5737
            get {
5738
                return this.borderbottomField;
5739
            }
5740
            set {
5741
                this.borderbottomField = value;
5742
            }
5743
        }
5744
        
5745
        
5746
        [XmlElement("borderleft", Namespace="urn:schemas-microsoft-com:office:word")]
5747
        public List<CT_Border> borderleft {
5748
            get {
5749
                return this.borderleftField;
5750
            }
5751
            set {
5752
                this.borderleftField = value;
5753
            }
5754
        }
5755
        
5756
        
5757
        [XmlElement("borderright", Namespace="urn:schemas-microsoft-com:office:word")]
5758
        public List<CT_Border> borderright {
5759
            get {
5760
                return this.borderrightField;
5761
            }
5762
            set {
5763
                this.borderrightField = value;
5764
            }
5765
        }
5766
        
5767
        
5768
        [XmlElement("ClientData", Namespace="urn:schemas-microsoft-com:office:excel")]
5769
        public List<CT_ClientData> ClientData {
5770
            get {
5771
                return this.clientDataField;
5772
            }
5773
            set {
5774
                this.clientDataField = value;
5775
            }
5776
        }
5777
        
5778
        
5779
        [XmlElement("textdata", Namespace="urn:schemas-microsoft-com:office:powerpoint")]
5780
        public List<CT_Rel> textdata {
5781
            get {
5782
                return this.textdataField;
5783
            }
5784
            set {
5785
                this.textdataField = value;
5786
            }
5787
        }
5788
        
5789
        
5790
        [XmlAttribute]
5791
        public string from {
5792
            get {
5793
                return this.fromField;
5794
            }
5795
            set {
5796
                this.fromField = value;
5797
            }
5798
        }
5799
        
5800
        
5801
        [XmlAttribute]
5802
        public string to {
5803
            get {
5804
                return this.toField;
5805
            }
5806
            set {
5807
                this.toField = value;
5808
            }
5809
        }
5810
    }
5811
    
5812
    
5813
    [Serializable]
5814

5815
    [System.ComponentModel.DesignerCategory("code")]
5816
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
5817
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
5818
    public class CT_Oval {
5819
        
5820
        private List<object> itemsField = new List<object>();
5821
        
5822
        private List<ItemsChoiceType2> itemsElementNameField = new List<ItemsChoiceType2>();
5823

5824

5825
        [XmlElement("ClientData", typeof(CT_ClientData), Namespace = "urn:schemas-microsoft-com:office:excel")]
5826
        [XmlElement("textdata", typeof(CT_Rel), Namespace = "urn:schemas-microsoft-com:office:powerpoint")]
5827
        [XmlElement("anchorlock", typeof(CT_AnchorLock), Namespace = "urn:schemas-microsoft-com:office:word")]
5828
        [XmlElement("borderbottom", typeof(CT_Border), Namespace = "urn:schemas-microsoft-com:office:word")]
5829
        [XmlElement("borderleft", typeof(CT_Border), Namespace = "urn:schemas-microsoft-com:office:word")]
5830
        [XmlElement("borderright", typeof(CT_Border), Namespace = "urn:schemas-microsoft-com:office:word")]
5831
        [XmlElement("bordertop", typeof(CT_Border), Namespace = "urn:schemas-microsoft-com:office:word")]
5832
        [XmlElement("wrap", typeof(CT_Wrap), Namespace = "urn:schemas-microsoft-com:office:word")]
5833
        [XmlElement("fill", typeof(CT_Fill))]
5834
        [XmlElement("formulas", typeof(CT_Formulas))]
5835
        [XmlElement("handles", typeof(CT_Handles))]
5836
        [XmlElement("imagedata", typeof(CT_ImageData))]
5837
        [XmlElement("path", typeof(CT_Path))]
5838
        [XmlElement("shadow", typeof(CT_Shadow))]
5839
        [XmlElement("stroke", typeof(CT_Stroke))]
5840
        [XmlElement("textbox", typeof(CT_Textbox))]
5841
        [XmlElement("textpath", typeof(CT_TextPath))]
5842
        [XmlChoiceIdentifier("ItemsElementName")]
5843
        public object[] Items
5844
        {
5845
            get
5846
            {
5847
                return this.itemsField.ToArray();
5848
            }
5849
            set
5850
            {
5851
                if (value == null)
5852
                    this.itemsField = new List<object>();
5853
                else
5854
                    this.itemsField = new List<object>(value);
5855
            }
5856
        }
5857
        
5858
        
5859
        [XmlElement("ItemsElementName")]
5860
        [XmlIgnore]
5861
        public ItemsChoiceType2[] ItemsElementName {
5862
            get {
5863
                return this.itemsElementNameField.ToArray();
5864
            }
5865
            set {
5866
                if (value == null)
5867
                    this.itemsElementNameField = new List<ItemsChoiceType2>();
5868
                else
5869
                    this.itemsElementNameField = new List<ItemsChoiceType2>(value);
5870
            }
5871
        }
5872
    }
5873
    
5874
    
5875
    [Serializable]
5876
    [XmlType(Namespace="urn:schemas-microsoft-com:vml", IncludeInSchema=false)]
5877
    public enum ItemsChoiceType2 {
5878
        
5879
        
5880
        [XmlEnum("urn:schemas-microsoft-com:office:excel:ClientData")]
5881
        ClientData,
5882
        
5883
        
5884
        [XmlEnum("urn:schemas-microsoft-com:office:powerpoint:textdata")]
5885
        textdata,
5886
        
5887
        
5888
        [XmlEnum("urn:schemas-microsoft-com:office:word:anchorlock")]
5889
        anchorlock,
5890
        
5891
        
5892
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderbottom")]
5893
        borderbottom,
5894
        
5895
        
5896
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderleft")]
5897
        borderleft,
5898
        
5899
        
5900
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderright")]
5901
        borderright,
5902
        
5903
        
5904
        [XmlEnum("urn:schemas-microsoft-com:office:word:bordertop")]
5905
        bordertop,
5906
        
5907
        
5908
        [XmlEnum("urn:schemas-microsoft-com:office:word:wrap")]
5909
        wrap,
5910
        
5911
        
5912
        fill,
5913
        
5914
        
5915
        formulas,
5916
        
5917
        
5918
        handles,
5919
        
5920
        
5921
        imagedata,
5922
        
5923
        
5924
        path,
5925
        
5926
        
5927
        shadow,
5928
        
5929
        
5930
        stroke,
5931
        
5932
        
5933
        textbox,
5934
        
5935
        
5936
        textpath,
5937
    }
5938
    
5939
    
5940
    [Serializable]
5941

5942
    [System.ComponentModel.DesignerCategory("code")]
5943
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
5944
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
5945
    public class CT_PolyLine {
5946
        
5947
        private List<object> itemsField = new List<object>();
5948

5949
        private List<ItemsChoiceType3> itemsElementNameField = new List<ItemsChoiceType3>();
5950
        
5951
        private string pointsField;
5952
        
5953
        
5954
        [XmlElement("ClientData", typeof(CT_ClientData), Namespace="urn:schemas-microsoft-com:office:excel")]
5955
        [XmlElement("textdata", typeof(CT_Rel), Namespace="urn:schemas-microsoft-com:office:powerpoint")]
5956
        [XmlElement("anchorlock", typeof(CT_AnchorLock), Namespace="urn:schemas-microsoft-com:office:word")]
5957
        [XmlElement("borderbottom", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
5958
        [XmlElement("borderleft", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
5959
        [XmlElement("borderright", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
5960
        [XmlElement("bordertop", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
5961
        [XmlElement("wrap", typeof(CT_Wrap), Namespace="urn:schemas-microsoft-com:office:word")]
5962
        [XmlElement("fill", typeof(CT_Fill))]
5963
        [XmlElement("formulas", typeof(CT_Formulas))]
5964
        [XmlElement("handles", typeof(CT_Handles))]
5965
        [XmlElement("imagedata", typeof(CT_ImageData))]
5966
        [XmlElement("path", typeof(CT_Path))]
5967
        [XmlElement("shadow", typeof(CT_Shadow))]
5968
        [XmlElement("stroke", typeof(CT_Stroke))]
5969
        [XmlElement("textbox", typeof(CT_Textbox))]
5970
        [XmlElement("textpath", typeof(CT_TextPath))]
5971
        [XmlChoiceIdentifier("ItemsElementName")]
5972
        public object[] Items {
5973
            get {
5974
                return this.itemsField.ToArray();
5975
            }
5976
            set {
5977
                if (value == null)
5978
                    this.itemsField = new List<object>();
5979
                else
5980
                    this.itemsField = new List<object>(value);
5981
            }
5982
        }
5983
        
5984
        
5985
        [XmlElement("ItemsElementName")]
5986
        [XmlIgnore]
5987
        public ItemsChoiceType3[] ItemsElementName {
5988
            get {
5989
                return this.itemsElementNameField.ToArray();
5990
            }
5991
            set {
5992
                if (value == null)
5993
                    this.itemsElementNameField = new List<ItemsChoiceType3>();
5994
                else
5995
                    this.itemsElementNameField = new List<ItemsChoiceType3>(value);
5996
            }
5997
        }
5998
        
5999
        
6000
        [XmlAttribute]
6001
        public string points {
6002
            get {
6003
                return this.pointsField;
6004
            }
6005
            set {
6006
                this.pointsField = value;
6007
            }
6008
        }
6009
    }
6010
    
6011
    
6012
    [Serializable]
6013
    [XmlType(Namespace="urn:schemas-microsoft-com:vml", IncludeInSchema=false)]
6014
    public enum ItemsChoiceType3 {
6015
        
6016
        
6017
        [XmlEnum("urn:schemas-microsoft-com:office:excel:ClientData")]
6018
        ClientData,
6019
        
6020
        
6021
        [XmlEnum("urn:schemas-microsoft-com:office:powerpoint:textdata")]
6022
        textdata,
6023
        
6024
        
6025
        [XmlEnum("urn:schemas-microsoft-com:office:word:anchorlock")]
6026
        anchorlock,
6027
        
6028
        
6029
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderbottom")]
6030
        borderbottom,
6031
        
6032
        
6033
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderleft")]
6034
        borderleft,
6035
        
6036
        
6037
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderright")]
6038
        borderright,
6039
        
6040
        
6041
        [XmlEnum("urn:schemas-microsoft-com:office:word:bordertop")]
6042
        bordertop,
6043
        
6044
        
6045
        [XmlEnum("urn:schemas-microsoft-com:office:word:wrap")]
6046
        wrap,
6047
        
6048
        
6049
        fill,
6050
        
6051
        
6052
        formulas,
6053
        
6054
        
6055
        handles,
6056
        
6057
        
6058
        imagedata,
6059
        
6060
        
6061
        path,
6062
        
6063
        
6064
        shadow,
6065
        
6066
        
6067
        stroke,
6068
        
6069
        
6070
        textbox,
6071
        
6072
        
6073
        textpath,
6074
    }
6075
    
6076
    
6077
    [Serializable]
6078

6079
    [System.ComponentModel.DesignerCategory("code")]
6080
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
6081
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
6082
    public class CT_Rect {
6083
        
6084
        //private List<object> itemsField;
6085
        
6086
        //private ItemsChoiceType4[] itemsElementNameField;
6087
        
6088
        
6089
        //[XmlElement("ClientData", typeof(CT_ClientData), Namespace="urn:schemas-microsoft-com:office:excel")]
6090
        //[XmlElement("textdata", typeof(CT_Rel), Namespace="urn:schemas-microsoft-com:office:powerpoint")]
6091
        //[XmlElement("anchorlock", typeof(CT_AnchorLock), Namespace="urn:schemas-microsoft-com:office:word")]
6092
        //[XmlElement("borderbottom", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
6093
        //[XmlElement("borderleft", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
6094
        //[XmlElement("borderright", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
6095
        //[XmlElement("bordertop", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
6096
        //[XmlElement("wrap", typeof(CT_Wrap), Namespace="urn:schemas-microsoft-com:office:word")]
6097
        //[XmlElement("fill", typeof(CT_Fill))]
6098
        //[XmlElement("formulas", typeof(CT_Formulas))]
6099
        //[XmlElement("handles", typeof(CT_Handles))]
6100
        //[XmlElement("imagedata", typeof(CT_ImageData))]
6101
        //[XmlElement("path", typeof(CT_Path))]
6102
        //[XmlElement("shadow", typeof(CT_Shadow))]
6103
        //[XmlElement("stroke", typeof(CT_Stroke))]
6104
        //[XmlElement("textbox", typeof(CT_Textbox))]
6105
        //[XmlElement("textpath", typeof(CT_TextPath))]
6106
        //[XmlChoiceIdentifier("ItemsElementName")]
6107
        //public List<object> Items {
6108
        //    get {
6109
        //        return this.itemsField;
6110
        //    }
6111
        //    set {
6112
        //        this.itemsField = value;
6113
        //    }
6114
        //}
6115
        
6116
        
6117
        //[XmlElement("ItemsElementName")]
6118
        //[XmlIgnore]
6119
        //public ItemsChoiceType4[] ItemsElementName {
6120
        //    get {
6121
        //        return this.itemsElementNameField;
6122
        //    }
6123
        //    set {
6124
        //        this.itemsElementNameField = value;
6125
        //    }
6126
        //}
6127
    }
6128
    
6129
    
6130
    [Serializable]
6131
    [XmlType(Namespace="urn:schemas-microsoft-com:vml", IncludeInSchema=false)]
6132
    public enum ItemsChoiceType4 {
6133
        
6134
        
6135
        [XmlEnum("urn:schemas-microsoft-com:office:excel:ClientData")]
6136
        ClientData,
6137
        
6138
        
6139
        [XmlEnum("urn:schemas-microsoft-com:office:powerpoint:textdata")]
6140
        textdata,
6141
        
6142
        
6143
        [XmlEnum("urn:schemas-microsoft-com:office:word:anchorlock")]
6144
        anchorlock,
6145
        
6146
        
6147
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderbottom")]
6148
        borderbottom,
6149
        
6150
        
6151
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderleft")]
6152
        borderleft,
6153
        
6154
        
6155
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderright")]
6156
        borderright,
6157
        
6158
        
6159
        [XmlEnum("urn:schemas-microsoft-com:office:word:bordertop")]
6160
        bordertop,
6161
        
6162
        
6163
        [XmlEnum("urn:schemas-microsoft-com:office:word:wrap")]
6164
        wrap,
6165
        
6166
        
6167
        fill,
6168
        
6169
        
6170
        formulas,
6171
        
6172
        
6173
        handles,
6174
        
6175
        
6176
        imagedata,
6177
        
6178
        
6179
        path,
6180
        
6181
        
6182
        shadow,
6183
        
6184
        
6185
        stroke,
6186
        
6187
        
6188
        textbox,
6189
        
6190
        
6191
        textpath,
6192
    }
6193
    
6194
    
6195
    [Serializable]
6196

6197
    [System.ComponentModel.DesignerCategory("code")]
6198
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
6199
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
6200
    public class CT_RoundRect {
6201
        
6202
        //private List<object> itemsField;
6203
        
6204
        //private ItemsChoiceType5[] itemsElementNameField;
6205
        
6206
        private string arcsizeField;
6207
        
6208
        
6209
        //[XmlElement("ClientData", typeof(CT_ClientData), Namespace="urn:schemas-microsoft-com:office:excel")]
6210
        //[XmlElement("textdata", typeof(CT_Rel), Namespace="urn:schemas-microsoft-com:office:powerpoint")]
6211
        //[XmlElement("anchorlock", typeof(CT_AnchorLock), Namespace="urn:schemas-microsoft-com:office:word")]
6212
        //[XmlElement("borderbottom", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
6213
        //[XmlElement("borderleft", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
6214
        //[XmlElement("borderright", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
6215
        //[XmlElement("bordertop", typeof(CT_Border), Namespace="urn:schemas-microsoft-com:office:word")]
6216
        //[XmlElement("wrap", typeof(CT_Wrap), Namespace="urn:schemas-microsoft-com:office:word")]
6217
        //[XmlElement("fill", typeof(CT_Fill))]
6218
        //[XmlElement("formulas", typeof(CT_Formulas))]
6219
        //[XmlElement("handles", typeof(CT_Handles))]
6220
        //[XmlElement("imagedata", typeof(CT_ImageData))]
6221
        //[XmlElement("path", typeof(CT_Path))]
6222
        //[XmlElement("shadow", typeof(CT_Shadow))]
6223
        //[XmlElement("stroke", typeof(CT_Stroke))]
6224
        //[XmlElement("textbox", typeof(CT_Textbox))]
6225
        //[XmlElement("textpath", typeof(CT_TextPath))]
6226
        //[XmlChoiceIdentifier("ItemsElementName")]
6227
        //public List<object> Items {
6228
        //    get {
6229
        //        return this.itemsField;
6230
        //    }
6231
        //    set {
6232
        //        this.itemsField = value;
6233
        //    }
6234
        //}
6235
        
6236
        
6237
        //[XmlElement("ItemsElementName")]
6238
        //[XmlIgnore]
6239
        //public ItemsChoiceType5[] ItemsElementName {
6240
        //    get {
6241
        //        return this.itemsElementNameField;
6242
        //    }
6243
        //    set {
6244
        //        this.itemsElementNameField = value;
6245
        //    }
6246
        //}
6247
        
6248
        
6249
        [XmlAttribute]
6250
        public string arcsize {
6251
            get {
6252
                return this.arcsizeField;
6253
            }
6254
            set {
6255
                this.arcsizeField = value;
6256
            }
6257
        }
6258
    }
6259
    
6260
    
6261
    [Serializable]
6262
    [XmlType(Namespace="urn:schemas-microsoft-com:vml", IncludeInSchema=false)]
6263
    public enum ItemsChoiceType5 {
6264
        
6265
        
6266
        [XmlEnum("urn:schemas-microsoft-com:office:excel:ClientData")]
6267
        ClientData,
6268
        
6269
        
6270
        [XmlEnum("urn:schemas-microsoft-com:office:powerpoint:textdata")]
6271
        textdata,
6272
        
6273
        
6274
        [XmlEnum("urn:schemas-microsoft-com:office:word:anchorlock")]
6275
        anchorlock,
6276
        
6277
        
6278
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderbottom")]
6279
        borderbottom,
6280
        
6281
        
6282
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderleft")]
6283
        borderleft,
6284
        
6285
        
6286
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderright")]
6287
        borderright,
6288
        
6289
        
6290
        [XmlEnum("urn:schemas-microsoft-com:office:word:bordertop")]
6291
        bordertop,
6292
        
6293
        
6294
        [XmlEnum("urn:schemas-microsoft-com:office:word:wrap")]
6295
        wrap,
6296
        
6297
        
6298
        fill,
6299
        
6300
        
6301
        formulas,
6302
        
6303
        
6304
        handles,
6305
        
6306
        
6307
        imagedata,
6308
        
6309
        
6310
        path,
6311
        
6312
        
6313
        shadow,
6314
        
6315
        
6316
        stroke,
6317
        
6318
        
6319
        textbox,
6320
        
6321
        
6322
        textpath,
6323
    }
6324
    
6325
    
6326
    [Serializable]
6327
    [XmlType(Namespace="urn:schemas-microsoft-com:vml", IncludeInSchema=false)]
6328
    public enum ItemsChoiceType6 {
6329
        
6330
        
6331
        [XmlEnum("urn:schemas-microsoft-com:office:excel:ClientData")]
6332
        ClientData,
6333
        
6334
        
6335
        [XmlEnum("urn:schemas-microsoft-com:office:powerpoint:textdata")]
6336
        textdata,
6337
        
6338
        
6339
        [XmlEnum("urn:schemas-microsoft-com:office:word:anchorlock")]
6340
        anchorlock,
6341
        
6342
        
6343
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderbottom")]
6344
        borderbottom,
6345
        
6346
        
6347
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderleft")]
6348
        borderleft,
6349
        
6350
        
6351
        [XmlEnum("urn:schemas-microsoft-com:office:word:borderright")]
6352
        borderright,
6353
        
6354
        
6355
        [XmlEnum("urn:schemas-microsoft-com:office:word:bordertop")]
6356
        bordertop,
6357
        
6358
        
6359
        [XmlEnum("urn:schemas-microsoft-com:office:word:wrap")]
6360
        wrap,
6361
        
6362
        
6363
        arc,
6364
        
6365
        
6366
        curve,
6367
        
6368
        
6369
        fill,
6370
        
6371
        
6372
        formulas,
6373
        
6374
        
6375
        group,
6376
        
6377
        
6378
        handles,
6379
        
6380
        
6381
        image,
6382
        
6383
        
6384
        imagedata,
6385
        
6386
        
6387
        line,
6388
        
6389
        
6390
        oval,
6391
        
6392
        
6393
        path,
6394
        
6395
        
6396
        polyline,
6397
        
6398
        
6399
        rect,
6400
        
6401
        
6402
        roundrect,
6403
        
6404
        
6405
        shadow,
6406
        
6407
        
6408
        shape,
6409
        
6410
        
6411
        shapetype,
6412
        
6413
        
6414
        stroke,
6415
        
6416
        
6417
        textbox,
6418
        
6419
        
6420
        textpath,
6421
    }
6422
    
6423
    
6424
    [Serializable]
6425
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
6426
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
6427
    public enum ST_EditAs {
6428
        
6429
        
6430
        canvas,
6431
        
6432
        
6433
        orgchart,
6434
        
6435
        
6436
        radial,
6437
        
6438
        
6439
        cycle,
6440
        
6441
        
6442
        stacked,
6443
        
6444
        
6445
        venn,
6446
        
6447
        
6448
        bullseye,
6449
    }
6450
    
6451
    
6452
    [Serializable]
6453

6454
    [System.ComponentModel.DesignerCategory("code")]
6455
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
6456
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=true)]
6457
    public class CT_Background {
6458
        
6459
        private CT_Fill fillField;
6460
        
6461
        private string idField;
6462
        
6463
        private ST_TrueFalse filledField;
6464
        
6465
        private bool filledFieldSpecified;
6466
        
6467
        private string fillcolorField;
6468
        
6469
        
6470
        public CT_Fill fill {
6471
            get {
6472
                return this.fillField;
6473
            }
6474
            set {
6475
                this.fillField = value;
6476
            }
6477
        }
6478

6479

6480
        [XmlAttribute]
6481
        public string id
6482
        {
6483
            get {
6484
                return this.idField;
6485
            }
6486
            set {
6487
                this.idField = value;
6488
            }
6489
        }
6490
        
6491
        
6492
        [XmlAttribute]
6493
        public ST_TrueFalse filled {
6494
            get {
6495
                return this.filledField;
6496
            }
6497
            set {
6498
                this.filledField = value;
6499
            }
6500
        }
6501
        
6502
        
6503
        [XmlIgnore]
6504
        public bool filledSpecified {
6505
            get {
6506
                return this.filledFieldSpecified;
6507
            }
6508
            set {
6509
                this.filledFieldSpecified = value;
6510
            }
6511
        }
6512
        
6513
        
6514
        [XmlAttribute]
6515
        public string fillcolor {
6516
            get {
6517
                return this.fillcolorField;
6518
            }
6519
            set {
6520
                this.fillcolorField = value;
6521
            }
6522
        }
6523
    }
6524
    
6525
    
6526
    [Serializable]
6527
    [XmlType(Namespace="urn:schemas-microsoft-com:vml")]
6528
    [XmlRoot(Namespace="urn:schemas-microsoft-com:vml", IsNullable=false)]
6529
    public enum ST_Ext 
6530
    {       
6531
        NONE,
6532
        view,
6533
        edit,
6534
        backwardCompatible,
6535
    }
6536
}
6537