npoi

Styles.cs
3468 строк · 85.8 Кб
Перенос по словам
1
using NPOI.OpenXml4Net.Util;
2
using System;
3
using System.Collections.Generic;
4
using System.IO;
5
using System.Xml;
6
using System.Xml.Serialization;
7

8
namespace NPOI.OpenXmlFormats.Wordprocessing
9
{
10

11
    [Serializable]
12

13
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
14
    [XmlRoot("styles", Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = false)]
15
    public class CT_Styles
16
    {
17

18
        private CT_DocDefaults docDefaultsField;
19

20
        private CT_LatentStyles latentStylesField;
21

22
        private List<CT_Style> styleField;
23

24
        public CT_Styles()
25
        {
26
            //this.styleField = new List<CT_Style>();
27
            //this.latentStylesField = new CT_LatentStyles();
28
            //this.docDefaultsField = new CT_DocDefaults();
29
        }
30
        public static CT_Styles Parse(XmlNode node, XmlNamespaceManager namespaceManager)
31
        {
32
            if (node == null)
33
                return null;
34
            CT_Styles ctObj = new CT_Styles();
35
            ctObj.style = new List<CT_Style>();
36
            foreach (XmlNode childNode in node.ChildNodes)
37
            {
38
                if (childNode.LocalName == "docDefaults")
39
                    ctObj.docDefaults = CT_DocDefaults.Parse(childNode, namespaceManager);
40
                else if (childNode.LocalName == "latentStyles")
41
                    ctObj.latentStyles = CT_LatentStyles.Parse(childNode, namespaceManager);
42
                else if (childNode.LocalName == "style")
43
                    ctObj.style.Add(CT_Style.Parse(childNode, namespaceManager));
44
            }
45
            return ctObj;
46
        }
47

48

49

50
        internal void Write(StreamWriter sw)
51
        {
52
            sw.Write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
53
            sw.Write("<w:styles xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"");
54
            sw.Write(" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w16cex=\"http://schemas.microsoft.com/office/word/2018/wordml/cex\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:w16=\"http://schemas.microsoft.com/office/word/2018/wordml\" xmlns:w16sdtdh=\"http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" mc:Ignorable=\"w14 w15 w16se w16cid w16 w16cex w16sdtdh\"");
55
            sw.Write(">");
56
            if (this.docDefaults != null)
57
                this.docDefaults.Write(sw, "docDefaults");
58
            if (this.latentStyles != null)
59
                this.latentStyles.Write(sw, "latentStyles");
60
            if (this.style != null)
61
            {
62
                foreach (CT_Style x in this.style)
63
                {
64
                    x.Write(sw, "style");
65
                }
66
            }
67
            sw.Write("</w:styles>");
68
        }
69

70
        [XmlElement(Order = 0)]
71
        public CT_DocDefaults docDefaults
72
        {
73
            get
74
            {
75
                return this.docDefaultsField;
76
            }
77
            set
78
            {
79
                this.docDefaultsField = value;
80
            }
81
        }
82

83
        [XmlElement(Order = 1)]
84
        public CT_LatentStyles latentStyles
85
        {
86
            get
87
            {
88
                return this.latentStylesField;
89
            }
90
            set
91
            {
92
                this.latentStylesField = value;
93
            }
94
        }
95

96
        [XmlElement("style", Order = 2)]
97
        public List<CT_Style> style
98
        {
99
            get
100
            {
101
                return this.styleField;
102
            }
103
            set
104
            {
105
                this.styleField = value;
106
            }
107
        }
108

109
        public IList<CT_Style> GetStyleList()
110
        {
111
            if(this.styleField==null)
112
                this.styleField = new List<CT_Style>();
113
            return style;
114
        }
115

116
        public CT_Style AddNewStyle()
117
        {
118
            CT_Style s = new CT_Style();
119
            if (styleField == null)
120
                styleField = new List<CT_Style>();
121
            styleField.Add(s);
122
            return s;
123
        }
124

125
        public void SetStyleArray(int pos, CT_Style cT_Style)
126
        {
127
            lock (this)
128
            {
129
                this.styleField[pos] = cT_Style;
130
            }
131
        }
132

133
        public bool IsSetDocDefaults()
134
        {
135
            return this.docDefaultsField != null;
136
        }
137

138
        public CT_DocDefaults AddNewDocDefaults()
139
        {
140
            this.docDefaultsField = new CT_DocDefaults();
141
            return this.docDefaultsField;
142
        }
143
    }
144

145

146
    [Serializable]
147

148
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
149
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
150
    public class CT_DocDefaults
151
    {
152

153
        private CT_RPrDefault rPrDefaultField;
154

155
        private CT_PPrDefault pPrDefaultField;
156

157
        public CT_DocDefaults()
158
        {
159
            //this.pPrDefaultField = new CT_PPrDefault();
160
            //this.rPrDefaultField = new CT_RPrDefault();
161
        }
162
        public static CT_DocDefaults Parse(XmlNode node, XmlNamespaceManager namespaceManager)
163
        {
164
            if (node == null)
165
                return null;
166
            CT_DocDefaults ctObj = new CT_DocDefaults();
167
            foreach (XmlNode childNode in node.ChildNodes)
168
            {
169
                if (childNode.LocalName == "rPrDefault")
170
                    ctObj.rPrDefault = CT_RPrDefault.Parse(childNode, namespaceManager);
171
                else if (childNode.LocalName == "pPrDefault")
172
                    ctObj.pPrDefault = CT_PPrDefault.Parse(childNode, namespaceManager);
173
            }
174
            return ctObj;
175
        }
176

177

178

179
        internal void Write(StreamWriter sw, string nodeName)
180
        {
181
            sw.Write(string.Format("<w:{0}", nodeName));
182
            sw.Write(">");
183
            if (this.rPrDefault != null)
184
                this.rPrDefault.Write(sw, "rPrDefault");
185
            if (this.pPrDefault != null)
186
                this.pPrDefault.Write(sw, "pPrDefault");
187
            sw.WriteEndW(nodeName);
188
        }
189

190
        [XmlElement(Order = 0)]
191
        public CT_RPrDefault rPrDefault
192
        {
193
            get
194
            {
195
                return this.rPrDefaultField;
196
            }
197
            set
198
            {
199
                this.rPrDefaultField = value;
200
            }
201
        }
202

203
        [XmlElement(Order = 1)]
204
        public CT_PPrDefault pPrDefault
205
        {
206
            get
207
            {
208
                return this.pPrDefaultField;
209
            }
210
            set
211
            {
212
                this.pPrDefaultField = value;
213
            }
214
        }
215

216
        public bool IsSetRPrDefault()
217
        {
218
            return this.rPrDefaultField != null;
219
        }
220

221
        public CT_RPrDefault AddNewRPrDefault()
222
        {
223
            this.rPrDefaultField = new CT_RPrDefault();
224
            return this.rPrDefaultField;
225
        }
226

227
        public bool IsSetPPrDefault()
228
        {
229
            return this.pPrDefaultField != null;
230
        }
231

232
        public CT_PPrDefault AddNewPPrDefault()
233
        {
234
            this.pPrDefaultField = new CT_PPrDefault();
235
            return this.pPrDefaultField;
236
        }
237
    }
238

239

240
    [Serializable]
241

242
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
243
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
244
    public class CT_RPrDefault
245
    {
246

247
        private CT_RPr rPrField;
248

249
        public CT_RPrDefault()
250
        {
251
            
252
        }
253
        public static CT_RPrDefault Parse(XmlNode node, XmlNamespaceManager namespaceManager)
254
        {
255
            if (node == null)
256
                return null;
257
            CT_RPrDefault ctObj = new CT_RPrDefault();
258
            foreach (XmlNode childNode in node.ChildNodes)
259
            {
260
                if (childNode.LocalName == "rPr")
261
                    ctObj.rPr = CT_RPr.Parse(childNode, namespaceManager);
262
            }
263
            return ctObj;
264
        }
265

266

267

268
        internal void Write(StreamWriter sw, string nodeName)
269
        {
270
            sw.Write(string.Format("<w:{0}", nodeName));
271
            sw.Write(">");
272
            if (this.rPr != null)
273
                this.rPr.Write(sw, "rPr");
274
            sw.WriteEndW(nodeName);
275
        }
276

277
        [XmlElement(Order = 0)]
278
        public CT_RPr rPr
279
        {
280
            get
281
            {
282
                return this.rPrField;
283
            }
284
            set
285
            {
286
                this.rPrField = value;
287
            }
288
        }
289

290
        public bool IsSetRPr()
291
        {
292
            return this.rPrField != null;
293
        }
294

295
        public CT_RPr AddNewRPr()
296
        {
297
            this.rPrField = new CT_RPr();
298
            return this.rPrField;
299
        }
300
    }
301

302

303
    [Serializable]
304

305
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
306
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
307
    public class CT_PPrDefault
308
    {
309

310
        private CT_PPr pPrField;
311

312
        public CT_PPrDefault()
313
        {
314
        }
315
        public static CT_PPrDefault Parse(XmlNode node, XmlNamespaceManager namespaceManager)
316
        {
317
            if (node == null)
318
                return null;
319
            CT_PPrDefault ctObj = new CT_PPrDefault();
320
            foreach (XmlNode childNode in node.ChildNodes)
321
            {
322
                if (childNode.LocalName == "pPr")
323
                    ctObj.pPr = CT_PPr.Parse(childNode, namespaceManager);
324
            }
325
            return ctObj;
326
        }
327

328

329

330
        internal void Write(StreamWriter sw, string nodeName)
331
        {
332
            sw.Write(string.Format("<w:{0}", nodeName));
333
            sw.Write(">");
334
            if (this.pPr != null)
335
                this.pPr.Write(sw, "pPr");
336
            sw.WriteEndW(nodeName);
337
        }
338

339
        [XmlElement(Order = 0)]
340
        public CT_PPr pPr
341
        {
342
            get
343
            {
344
                return this.pPrField;
345
            }
346
            set
347
            {
348
                this.pPrField = value;
349
            }
350
        }
351

352
        public CT_PPr AddNewPPr()
353
        {
354
            this.pPrField = new CT_PPr();
355
            return this.pPrField;
356
        }
357

358
        public bool IsSetPPr()
359
        {
360
            return this.pPrField != null;
361
        }
362
    }
363

364

365
    [Serializable]
366

367
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
368
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
369
    public class CT_LatentStyles
370
    {
371

372
        private List<CT_LsdException> lsdExceptionField;
373

374
        private ST_OnOff defLockedStateField;
375

376
        private bool defLockedStateFieldSpecified;
377

378
        private string defUIPriorityField;
379

380
        private ST_OnOff defSemiHiddenField;
381

382
        private bool defSemiHiddenFieldSpecified;
383

384
        private ST_OnOff defUnhideWhenUsedField;
385

386
        private bool defUnhideWhenUsedFieldSpecified;
387

388
        private ST_OnOff defQFormatField;
389

390
        private bool defQFormatFieldSpecified;
391

392
        private string countField;
393
        public static CT_LatentStyles Parse(XmlNode node, XmlNamespaceManager namespaceManager)
394
        {
395
            if (node == null)
396
                return null;
397
            CT_LatentStyles ctObj = new CT_LatentStyles();
398
            if (node.Attributes["w:defLockedState"] != null)
399
                ctObj.defLockedState = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:defLockedState"].Value,true);
400
            ctObj.defUIPriority = XmlHelper.ReadString(node.Attributes["w:defUIPriority"]);
401
            if (node.Attributes["w:defSemiHidden"] != null)
402
                ctObj.defSemiHidden = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:defSemiHidden"].Value,true);
403
            if (node.Attributes["w:defUnhideWhenUsed"] != null)
404
                ctObj.defUnhideWhenUsed = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:defUnhideWhenUsed"].Value,true);
405
            if (node.Attributes["w:defQFormat"] != null)
406
                ctObj.defQFormat = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:defQFormat"].Value,true);
407
            ctObj.count = XmlHelper.ReadString(node.Attributes["w:count"]);
408
            ctObj.lsdException = new List<CT_LsdException>();
409
            foreach (XmlNode childNode in node.ChildNodes)
410
            {
411
                if (childNode.LocalName == "lsdException")
412
                    ctObj.lsdException.Add(CT_LsdException.Parse(childNode, namespaceManager));
413
            }
414
            return ctObj;
415
        }
416

417

418

419
        internal void Write(StreamWriter sw, string nodeName)
420
        {
421
            sw.Write(string.Format("<w:{0}", nodeName));
422
            XmlHelper.WriteAttribute(sw, "w:defLockedState", this.defLockedState== ST_OnOff.off?"0":"1");
423
            XmlHelper.WriteAttribute(sw, "w:defUIPriority", this.defUIPriority);
424
            XmlHelper.WriteAttribute(sw, "w:defSemiHidden", this.defSemiHidden == ST_OnOff.off ? "0" : "1");
425
            XmlHelper.WriteAttribute(sw, "w:defUnhideWhenUsed", this.defUnhideWhenUsed == ST_OnOff.off ? "0" : "1");
426
            XmlHelper.WriteAttribute(sw, "w:defQFormat", this.defQFormat == ST_OnOff.off ? "0" : "1");
427
            XmlHelper.WriteAttribute(sw, "w:count", this.count);
428
            sw.Write(">");
429
            if (this.lsdException != null)
430
            {
431
                foreach (CT_LsdException x in this.lsdException)
432
                {
433
                    x.Write(sw, "lsdException");
434
                }
435
            }
436
            sw.WriteEndW(nodeName);
437
        }
438

439
        public CT_LatentStyles()
440
        {
441
            //this.lsdExceptionField = new List<CT_LsdException>();
442
        }
443

444
        [XmlElement("lsdException", Order = 0)]
445
        public List<CT_LsdException> lsdException
446
        {
447
            get
448
            {
449
                return this.lsdExceptionField;
450
            }
451
            set
452
            {
453
                this.lsdExceptionField = value;
454
            }
455
        }
456

457
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
458
        public ST_OnOff defLockedState
459
        {
460
            get
461
            {
462
                return this.defLockedStateField;
463
            }
464
            set
465
            {
466
                this.defLockedStateField = value;
467
            }
468
        }
469

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

483
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
484
        public string defUIPriority
485
        {
486
            get
487
            {
488
                return this.defUIPriorityField;
489
            }
490
            set
491
            {
492
                this.defUIPriorityField = value;
493
            }
494
        }
495

496
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
497
        public ST_OnOff defSemiHidden
498
        {
499
            get
500
            {
501
                return this.defSemiHiddenField;
502
            }
503
            set
504
            {
505
                this.defSemiHiddenField = value;
506
            }
507
        }
508

509
        [XmlIgnore]
510
        public bool defSemiHiddenSpecified
511
        {
512
            get
513
            {
514
                return this.defSemiHiddenFieldSpecified;
515
            }
516
            set
517
            {
518
                this.defSemiHiddenFieldSpecified = value;
519
            }
520
        }
521

522
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
523
        public ST_OnOff defUnhideWhenUsed
524
        {
525
            get
526
            {
527
                return this.defUnhideWhenUsedField;
528
            }
529
            set
530
            {
531
                this.defUnhideWhenUsedField = value;
532
            }
533
        }
534

535
        [XmlIgnore]
536
        public bool defUnhideWhenUsedSpecified
537
        {
538
            get
539
            {
540
                return this.defUnhideWhenUsedFieldSpecified;
541
            }
542
            set
543
            {
544
                this.defUnhideWhenUsedFieldSpecified = value;
545
            }
546
        }
547

548
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
549
        public ST_OnOff defQFormat
550
        {
551
            get
552
            {
553
                return this.defQFormatField;
554
            }
555
            set
556
            {
557
                this.defQFormatField = value;
558
            }
559
        }
560

561
        [XmlIgnore]
562
        public bool defQFormatSpecified
563
        {
564
            get
565
            {
566
                return this.defQFormatFieldSpecified;
567
            }
568
            set
569
            {
570
                this.defQFormatFieldSpecified = value;
571
            }
572
        }
573

574
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
575
        public string count
576
        {
577
            get
578
            {
579
                return this.countField;
580
            }
581
            set
582
            {
583
                this.countField = value;
584
            }
585
        }
586

587
        public CT_LsdException AddNewLsdException()
588
        {
589
            CT_LsdException lsd = new CT_LsdException();
590
            if (this.lsdExceptionField == null)
591
                this.lsdExceptionField = new List<CT_LsdException>();
592
            this.lsdExceptionField.Add(lsd);
593
            return lsd;
594
        }
595

596
        public int SizeOfLsdExceptionArray()
597
        {
598
            return lsdExceptionField == null ? 0 : lsdExceptionField.Count;
599
        }
600
    }
601

602
    [Serializable]
603

604
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
605
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
606
    public class CT_Style
607
    {
608

609
        private CT_String nameField;
610

611
        private CT_String aliasesField;
612

613
        private CT_String basedOnField;
614

615
        private CT_String nextField;
616

617
        private CT_String linkField;
618

619
        private CT_OnOff autoRedefineField;
620

621
        private CT_OnOff hiddenField;
622

623
        private CT_DecimalNumber uiPriorityField;
624

625
        private CT_OnOff semiHiddenField;
626

627
        private CT_OnOff unhideWhenUsedField;
628

629
        private CT_OnOff qFormatField;
630

631
        private CT_OnOff lockedField;
632

633
        private CT_OnOff personalField;
634

635
        private CT_OnOff personalComposeField;
636

637
        private CT_OnOff personalReplyField;
638

639
        private CT_LongHexNumber rsidField;
640

641
        private CT_PPr pPrField;
642

643
        private CT_RPr rPrField;
644

645
        private CT_TblPrBase tblPrField;
646

647
        private CT_TrPr trPrField;
648

649
        private CT_TcPr tcPrField;
650

651
        private List<CT_TblStylePr> tblStylePrField;
652

653
        private ST_StyleType typeField;
654

655
        private bool typeFieldSpecified;
656

657
        private string styleIdField;
658

659
        private ST_OnOff defaultField;
660

661
        private bool defaultFieldSpecified;
662

663
        private ST_OnOff customStyleField;
664

665
        private bool customStyleFieldSpecified;
666

667
        public CT_Style()
668
        {
669
            //this.tblStylePrField = new List<CT_TblStylePr>();
670
            //this.tcPrField = new CT_TcPr();
671
            //this.trPrField = new CT_TrPr();
672
            //this.tblPrField = new CT_TblPrBase();
673
            //this.rPrField = new CT_RPr();
674
            //this.pPrField = new CT_PPr();
675
            //this.rsidField = new CT_LongHexNumber();
676
            //this.personalReplyField = new CT_OnOff();
677
            //this.personalComposeField = new CT_OnOff();
678
            //this.personalField = new CT_OnOff();
679
            //this.lockedField = new CT_OnOff();
680
            //this.qFormatField = new CT_OnOff();
681
            //this.unhideWhenUsedField = new CT_OnOff();
682
            //this.semiHiddenField = new CT_OnOff();
683
            //this.uiPriorityField = new CT_DecimalNumber();
684
            //this.hiddenField = new CT_OnOff();
685
            //this.autoRedefineField = new CT_OnOff();
686
            //this.linkField = new CT_String();
687
            //this.nextField = new CT_String();
688
            //this.basedOnField = new CT_String();
689
            //this.aliasesField = new CT_String();
690
            //this.nameField = new CT_String();
691
        }
692
        public static CT_Style Parse(XmlNode node, XmlNamespaceManager namespaceManager)
693
        {
694
            if (node == null)
695
                return null;
696
            CT_Style ctObj = new CT_Style();
697
            if (node.Attributes["w:type"] != null)
698
                ctObj.type = (ST_StyleType)Enum.Parse(typeof(ST_StyleType), node.Attributes["w:type"].Value);
699
            ctObj.styleId = XmlHelper.ReadString(node.Attributes["w:styleId"]);
700
            if (node.Attributes["w:default"] != null)
701
                ctObj.@default = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:default"].Value,true);
702
            if (node.Attributes["w:customStyle"] != null)
703
                ctObj.customStyle = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:customStyle"].Value,true);
704
            ctObj.tblStylePr = new List<CT_TblStylePr>();
705
            foreach (XmlNode childNode in node.ChildNodes)
706
            {
707
                if (childNode.LocalName == "name")
708
                    ctObj.name = CT_String.Parse(childNode, namespaceManager);
709
                else if (childNode.LocalName == "aliases")
710
                    ctObj.aliases = CT_String.Parse(childNode, namespaceManager);
711
                else if (childNode.LocalName == "basedOn")
712
                    ctObj.basedOn = CT_String.Parse(childNode, namespaceManager);
713
                else if (childNode.LocalName == "next")
714
                    ctObj.next = CT_String.Parse(childNode, namespaceManager);
715
                else if (childNode.LocalName == "link")
716
                    ctObj.link = CT_String.Parse(childNode, namespaceManager);
717
                else if (childNode.LocalName == "autoRedefine")
718
                    ctObj.autoRedefine = CT_OnOff.Parse(childNode, namespaceManager);
719
                else if (childNode.LocalName == "hidden")
720
                    ctObj.hidden = CT_OnOff.Parse(childNode, namespaceManager);
721
                else if (childNode.LocalName == "uiPriority")
722
                    ctObj.uiPriority = CT_DecimalNumber.Parse(childNode, namespaceManager);
723
                else if (childNode.LocalName == "semiHidden")
724
                    ctObj.semiHidden = CT_OnOff.Parse(childNode, namespaceManager);
725
                else if (childNode.LocalName == "unhideWhenUsed")
726
                    ctObj.unhideWhenUsed = CT_OnOff.Parse(childNode, namespaceManager);
727
                else if (childNode.LocalName == "qFormat")
728
                    ctObj.qFormat = CT_OnOff.Parse(childNode, namespaceManager);
729
                else if (childNode.LocalName == "locked")
730
                    ctObj.locked = CT_OnOff.Parse(childNode, namespaceManager);
731
                else if (childNode.LocalName == "personal")
732
                    ctObj.personal = CT_OnOff.Parse(childNode, namespaceManager);
733
                else if (childNode.LocalName == "personalCompose")
734
                    ctObj.personalCompose = CT_OnOff.Parse(childNode, namespaceManager);
735
                else if (childNode.LocalName == "personalReply")
736
                    ctObj.personalReply = CT_OnOff.Parse(childNode, namespaceManager);
737
                else if (childNode.LocalName == "rsid")
738
                    ctObj.rsid = CT_LongHexNumber.Parse(childNode, namespaceManager);
739
                else if (childNode.LocalName == "pPr")
740
                    ctObj.pPr = CT_PPr.Parse(childNode, namespaceManager);
741
                else if (childNode.LocalName == "rPr")
742
                    ctObj.rPr = CT_RPr.Parse(childNode, namespaceManager);
743
                else if (childNode.LocalName == "tblPr")
744
                    ctObj.tblPr = CT_TblPrBase.Parse(childNode, namespaceManager);
745
                else if (childNode.LocalName == "trPr")
746
                    ctObj.trPr = CT_TrPr.Parse(childNode, namespaceManager);
747
                else if (childNode.LocalName == "tcPr")
748
                    ctObj.tcPr = CT_TcPr.Parse(childNode, namespaceManager);
749
                else if (childNode.LocalName == "tblStylePr")
750
                    ctObj.tblStylePr.Add(CT_TblStylePr.Parse(childNode, namespaceManager));
751
            }
752
            return ctObj;
753
        }
754

755

756

757
        internal void Write(StreamWriter sw, string nodeName)
758
        {
759
            sw.Write(string.Format("<w:{0}", nodeName));
760
            XmlHelper.WriteAttribute(sw, "w:type", this.type.ToString());
761
            if(this.@default!= ST_OnOff.off)
762
                XmlHelper.WriteAttribute(sw, "w:default", "1");
763
            if (this.customStyle == ST_OnOff.on)
764
                XmlHelper.WriteAttribute(sw, "w:customStyle", "1");
765
            XmlHelper.WriteAttribute(sw, "w:styleId", this.styleId);
766
            sw.Write(">");
767
            if (this.name != null)
768
                this.name.Write(sw, "name");
769
            if (this.aliases != null)
770
                this.aliases.Write(sw, "aliases");
771
            if (this.basedOn != null)
772
                this.basedOn.Write(sw, "basedOn");
773
            if (this.next != null)
774
                this.next.Write(sw, "next");
775
            if (this.link != null)
776
                this.link.Write(sw, "link");
777
            if (this.autoRedefine != null)
778
                this.autoRedefine.Write(sw, "autoRedefine");
779
            if (this.hidden != null)
780
                this.hidden.Write(sw, "hidden");
781
            if (this.uiPriority != null)
782
                this.uiPriority.Write(sw, "uiPriority");
783
            if (this.semiHidden != null)
784
                this.semiHidden.Write(sw, "semiHidden");
785
            if (this.unhideWhenUsed != null)
786
                this.unhideWhenUsed.Write(sw, "unhideWhenUsed");
787
            if (this.qFormat != null)
788
                this.qFormat.Write(sw, "qFormat");
789
            if (this.locked != null)
790
                this.locked.Write(sw, "locked");
791
            if (this.personal != null)
792
                this.personal.Write(sw, "personal");
793
            if (this.personalCompose != null)
794
                this.personalCompose.Write(sw, "personalCompose");
795
            if (this.personalReply != null)
796
                this.personalReply.Write(sw, "personalReply");
797
            if (this.rsid != null)
798
                this.rsid.Write(sw, "rsid");
799
            if (this.pPr != null)
800
                this.pPr.Write(sw, "pPr");
801
            if (this.rPr != null)
802
                this.rPr.Write(sw, "rPr");
803
            if (this.tblPr != null)
804
                this.tblPr.Write(sw, "tblPr");
805
            if (this.trPr != null)
806
                this.trPr.Write(sw, "trPr");
807
            if (this.tcPr != null)
808
                this.tcPr.Write(sw, "tcPr");
809
            if (this.tblStylePr != null)
810
            {
811
                foreach (CT_TblStylePr x in this.tblStylePr)
812
                {
813
                    x.Write(sw, "tblStylePr");
814
                }
815
            }
816
            sw.WriteEndW(nodeName);
817
        }
818

819
        [XmlElement(Order = 0)]
820
        public CT_String name
821
        {
822
            get
823
            {
824
                return this.nameField;
825
            }
826
            set
827
            {
828
                this.nameField = value;
829
            }
830
        }
831

832
        [XmlElement(Order = 1)]
833
        public CT_String aliases
834
        {
835
            get
836
            {
837
                return this.aliasesField;
838
            }
839
            set
840
            {
841
                this.aliasesField = value;
842
            }
843
        }
844

845
        [XmlElement(Order = 2)]
846
        public CT_String basedOn
847
        {
848
            get
849
            {
850
                return this.basedOnField;
851
            }
852
            set
853
            {
854
                this.basedOnField = value;
855
            }
856
        }
857

858
        [XmlElement(Order = 3)]
859
        public CT_String next
860
        {
861
            get
862
            {
863
                return this.nextField;
864
            }
865
            set
866
            {
867
                this.nextField = value;
868
            }
869
        }
870

871
        [XmlElement(Order = 4)]
872
        public CT_String link
873
        {
874
            get
875
            {
876
                return this.linkField;
877
            }
878
            set
879
            {
880
                this.linkField = value;
881
            }
882
        }
883

884
        [XmlElement(Order = 5)]
885
        public CT_OnOff autoRedefine
886
        {
887
            get
888
            {
889
                return this.autoRedefineField;
890
            }
891
            set
892
            {
893
                this.autoRedefineField = value;
894
            }
895
        }
896

897
        [XmlElement(Order = 6)]
898
        public CT_OnOff hidden
899
        {
900
            get
901
            {
902
                return this.hiddenField;
903
            }
904
            set
905
            {
906
                this.hiddenField = value;
907
            }
908
        }
909

910
        [XmlElement(Order = 7)]
911
        public CT_DecimalNumber uiPriority
912
        {
913
            get
914
            {
915
                return this.uiPriorityField;
916
            }
917
            set
918
            {
919
                this.uiPriorityField = value;
920
            }
921
        }
922

923
        [XmlElement(Order = 8)]
924
        public CT_OnOff semiHidden
925
        {
926
            get
927
            {
928
                return this.semiHiddenField;
929
            }
930
            set
931
            {
932
                this.semiHiddenField = value;
933
            }
934
        }
935

936
        [XmlElement(Order = 9)]
937
        public CT_OnOff unhideWhenUsed
938
        {
939
            get
940
            {
941
                return this.unhideWhenUsedField;
942
            }
943
            set
944
            {
945
                this.unhideWhenUsedField = value;
946
            }
947
        }
948

949
        [XmlElement(Order = 10)]
950
        public CT_OnOff qFormat
951
        {
952
            get
953
            {
954
                return this.qFormatField;
955
            }
956
            set
957
            {
958
                this.qFormatField = value;
959
            }
960
        }
961

962
        [XmlElement(Order = 11)]
963
        public CT_OnOff locked
964
        {
965
            get
966
            {
967
                return this.lockedField;
968
            }
969
            set
970
            {
971
                this.lockedField = value;
972
            }
973
        }
974

975
        [XmlElement(Order = 12)]
976
        public CT_OnOff personal
977
        {
978
            get
979
            {
980
                return this.personalField;
981
            }
982
            set
983
            {
984
                this.personalField = value;
985
            }
986
        }
987

988
        [XmlElement(Order = 13)]
989
        public CT_OnOff personalCompose
990
        {
991
            get
992
            {
993
                return this.personalComposeField;
994
            }
995
            set
996
            {
997
                this.personalComposeField = value;
998
            }
999
        }
1000

1001
        [XmlElement(Order = 14)]
1002
        public CT_OnOff personalReply
1003
        {
1004
            get
1005
            {
1006
                return this.personalReplyField;
1007
            }
1008
            set
1009
            {
1010
                this.personalReplyField = value;
1011
            }
1012
        }
1013

1014
        [XmlElement(Order = 15)]
1015
        public CT_LongHexNumber rsid
1016
        {
1017
            get
1018
            {
1019
                return this.rsidField;
1020
            }
1021
            set
1022
            {
1023
                this.rsidField = value;
1024
            }
1025
        }
1026

1027
        [XmlElement(Order = 16)]
1028
        public CT_PPr pPr
1029
        {
1030
            get
1031
            {
1032
                return this.pPrField;
1033
            }
1034
            set
1035
            {
1036
                this.pPrField = value;
1037
            }
1038
        }
1039

1040
        [XmlElement(Order = 17)]
1041
        public CT_RPr rPr
1042
        {
1043
            get
1044
            {
1045
                return this.rPrField;
1046
            }
1047
            set
1048
            {
1049
                this.rPrField = value;
1050
            }
1051
        }
1052

1053
        [XmlElement(Order = 18)]
1054
        public CT_TblPrBase tblPr
1055
        {
1056
            get
1057
            {
1058
                return this.tblPrField;
1059
            }
1060
            set
1061
            {
1062
                this.tblPrField = value;
1063
            }
1064
        }
1065

1066
        [XmlElement(Order = 19)]
1067
        public CT_TrPr trPr
1068
        {
1069
            get
1070
            {
1071
                return this.trPrField;
1072
            }
1073
            set
1074
            {
1075
                this.trPrField = value;
1076
            }
1077
        }
1078

1079
        [XmlElement(Order = 20)]
1080
        public CT_TcPr tcPr
1081
        {
1082
            get
1083
            {
1084
                return this.tcPrField;
1085
            }
1086
            set
1087
            {
1088
                this.tcPrField = value;
1089
            }
1090
        }
1091

1092
        [XmlElement("tblStylePr", Order = 21)]
1093
        public List<CT_TblStylePr> tblStylePr
1094
        {
1095
            get
1096
            {
1097
                return this.tblStylePrField;
1098
            }
1099
            set
1100
            {
1101
                this.tblStylePrField = value;
1102
            }
1103
        }
1104

1105
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1106
        public ST_StyleType type
1107
        {
1108
            get
1109
            {
1110
                return this.typeField;
1111
            }
1112
            set
1113
            {
1114
                this.typeField = value;
1115
            }
1116
        }
1117

1118
        [XmlIgnore]
1119
        public bool typeSpecified
1120
        {
1121
            get
1122
            {
1123
                return this.typeFieldSpecified;
1124
            }
1125
            set
1126
            {
1127
                this.typeFieldSpecified = value;
1128
            }
1129
        }
1130

1131
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1132
        public string styleId
1133
        {
1134
            get
1135
            {
1136
                return this.styleIdField;
1137
            }
1138
            set
1139
            {
1140
                this.styleIdField = value;
1141
            }
1142
        }
1143

1144
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1145
        public ST_OnOff @default
1146
        {
1147
            get
1148
            {
1149
                return this.defaultField;
1150
            }
1151
            set
1152
            {
1153
                this.defaultField = value;
1154
            }
1155
        }
1156

1157
        [XmlIgnore]
1158
        public bool defaultSpecified
1159
        {
1160
            get
1161
            {
1162
                return this.defaultFieldSpecified;
1163
            }
1164
            set
1165
            {
1166
                this.defaultFieldSpecified = value;
1167
            }
1168
        }
1169

1170
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1171
        public ST_OnOff customStyle
1172
        {
1173
            get
1174
            {
1175
                return this.customStyleField;
1176
            }
1177
            set
1178
            {
1179
                this.customStyleField = value;
1180
            }
1181
        }
1182

1183
        [XmlIgnore]
1184
        public bool customStyleSpecified
1185
        {
1186
            get
1187
            {
1188
                return this.customStyleFieldSpecified;
1189
            }
1190
            set
1191
            {
1192
                this.customStyleFieldSpecified = value;
1193
            }
1194
        }
1195

1196
        public bool IsSetName()
1197
        {
1198
            return this.name != null;
1199
        }
1200
    }
1201
    [Serializable]
1202

1203
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1204
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1205
    public class CT_Em
1206
    {
1207
        public static CT_Em Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1208
        {
1209
            if (node == null)
1210
                return null;
1211
            CT_Em ctObj = new CT_Em();
1212
            if (node.Attributes["w:val"] != null)
1213
                ctObj.val = (ST_Em)Enum.Parse(typeof(ST_Em), node.Attributes["w:val"].Value);
1214
            return ctObj;
1215
        }
1216

1217

1218

1219
        internal void Write(StreamWriter sw, string nodeName)
1220
        {
1221
            sw.Write(string.Format("<w:{0}", nodeName));
1222
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1223
            sw.Write(">");
1224
            sw.WriteEndW(nodeName);
1225
        }
1226

1227

1228
        private ST_Em valField;
1229

1230
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1231
        public ST_Em val
1232
        {
1233
            get
1234
            {
1235
                return this.valField;
1236
            }
1237
            set
1238
            {
1239
                this.valField = value;
1240
            }
1241
        }
1242
    }
1243

1244

1245
    [Serializable]
1246

1247
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1248
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1249
    public class CT_VerticalJc
1250
    {
1251
        public static CT_VerticalJc Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1252
        {
1253
            if (node == null)
1254
                return null;
1255
            CT_VerticalJc ctObj = new CT_VerticalJc();
1256
            if (node.Attributes["w:val"] != null)
1257
                ctObj.val = (ST_VerticalJc)Enum.Parse(typeof(ST_VerticalJc), node.Attributes["w:val"].Value);
1258
            return ctObj;
1259
        }
1260

1261

1262

1263
        internal void Write(StreamWriter sw, string nodeName)
1264
        {
1265
            sw.Write(string.Format("<w:{0}", nodeName));
1266
            if(val.HasValue)
1267
                XmlHelper.WriteAttribute(sw, "w:val", this.val.Value.ToString());
1268
            sw.Write("/>");
1269
        }
1270

1271

1272
        private ST_VerticalJc? valField;
1273

1274
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1275
        public ST_VerticalJc? val
1276
        {
1277
            get
1278
            {
1279
                return this.valField;
1280
            }
1281
            set
1282
            {
1283
                this.valField = value;
1284
            }
1285
        }
1286
    }
1287

1288

1289
    [Serializable]
1290
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1291
    public enum ST_VerticalJc
1292
    {
1293

1294

1295
        top,
1296

1297

1298
        center,
1299

1300

1301
        both,
1302

1303

1304
        bottom,
1305
    }
1306
    [Serializable]
1307
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1308
    public enum ST_Em
1309
    {
1310

1311

1312
        none,
1313

1314

1315
        dot,
1316

1317

1318
        comma,
1319

1320

1321
        circle,
1322

1323

1324
        underDot,
1325
    }
1326

1327
    [Serializable]
1328

1329
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1330
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1331
    public class CT_Shd
1332
    {
1333

1334
        private ST_Shd valField;
1335

1336
        private string colorField;
1337

1338
        private ST_ThemeColor themeColorField;
1339

1340
        private bool themeColorFieldSpecified;
1341

1342
        private byte[] themeTintField;
1343

1344
        private byte[] themeShadeField;
1345

1346
        private string fillField;
1347

1348
        private ST_ThemeColor themeFillField;
1349

1350
        private bool themeFillFieldSpecified;
1351

1352
        private byte[] themeFillTintField;
1353

1354
        private byte[] themeFillShadeField;
1355
        public CT_Shd()
1356
        {
1357
            this.themeColorField = ST_ThemeColor.none;
1358
            this.themeFillField = ST_ThemeColor.none;
1359
        }
1360

1361
        public static CT_Shd Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1362
        {
1363
            if (node == null)
1364
                return null;
1365
            CT_Shd ctObj = new CT_Shd();
1366
            if (node.Attributes["w:val"] != null)
1367
                ctObj.val = (ST_Shd)Enum.Parse(typeof(ST_Shd), node.Attributes["w:val"].Value);
1368
            ctObj.color = XmlHelper.ReadString(node.Attributes["w:color"]);
1369
            if (node.Attributes["w:themeColor"] != null)
1370
                ctObj.themeColor = (ST_ThemeColor)Enum.Parse(typeof(ST_ThemeColor), node.Attributes["w:themeColor"].Value);
1371
            ctObj.themeTint = XmlHelper.ReadBytes(node.Attributes["w:themeTint"]);
1372
            ctObj.themeShade = XmlHelper.ReadBytes(node.Attributes["w:themeShade"]);
1373
            ctObj.fill = XmlHelper.ReadString(node.Attributes["w:fill"]);
1374
            if (node.Attributes["w:themeFill"] != null)
1375
                ctObj.themeFill = (ST_ThemeColor)Enum.Parse(typeof(ST_ThemeColor), node.Attributes["w:themeFill"].Value);
1376
            ctObj.themeFillTint = XmlHelper.ReadBytes(node.Attributes["w:themeFillTint"]);
1377
            ctObj.themeFillShade = XmlHelper.ReadBytes(node.Attributes["w:themeFillShade"]);
1378
            return ctObj;
1379
        }
1380

1381

1382

1383
        internal void Write(StreamWriter sw, string nodeName)
1384
        {
1385
            sw.Write(string.Format("<w:{0}", nodeName));
1386
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1387
            XmlHelper.WriteAttribute(sw, "w:color", this.color);
1388
            if(this.themeColor!= ST_ThemeColor.none)
1389
                XmlHelper.WriteAttribute(sw, "w:themeColor", this.themeColor.ToString());
1390
            XmlHelper.WriteAttribute(sw, "w:themeTint", this.themeTint);
1391
            XmlHelper.WriteAttribute(sw, "w:themeShade", this.themeShade);
1392
            XmlHelper.WriteAttribute(sw, "w:fill", this.fill);
1393
            if(this.themeFill!= ST_ThemeColor.none)
1394
                XmlHelper.WriteAttribute(sw, "w:themeFill", this.themeFill.ToString());
1395
            XmlHelper.WriteAttribute(sw, "w:themeFillTint", this.themeFillTint);
1396
            XmlHelper.WriteAttribute(sw, "w:themeFillShade", this.themeFillShade);
1397
            sw.Write("/>");
1398
        }
1399

1400

1401
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1402
        public ST_Shd val
1403
        {
1404
            get
1405
            {
1406
                return this.valField;
1407
            }
1408
            set
1409
            {
1410
                this.valField = value;
1411
            }
1412
        }
1413

1414
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1415
        public string color
1416
        {
1417
            get
1418
            {
1419
                return this.colorField;
1420
            }
1421
            set
1422
            {
1423
                this.colorField = value;
1424
            }
1425
        }
1426

1427
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1428
        public ST_ThemeColor themeColor
1429
        {
1430
            get
1431
            {
1432
                return this.themeColorField;
1433
            }
1434
            set
1435
            {
1436
                this.themeColorField = value;
1437
            }
1438
        }
1439

1440
        [XmlIgnore]
1441
        public bool themeColorSpecified
1442
        {
1443
            get
1444
            {
1445
                return this.themeColorFieldSpecified;
1446
            }
1447
            set
1448
            {
1449
                this.themeColorFieldSpecified = value;
1450
            }
1451
        }
1452

1453
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
1454
        public byte[] themeTint
1455
        {
1456
            get
1457
            {
1458
                return this.themeTintField;
1459
            }
1460
            set
1461
            {
1462
                this.themeTintField = value;
1463
            }
1464
        }
1465

1466
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
1467
        public byte[] themeShade
1468
        {
1469
            get
1470
            {
1471
                return this.themeShadeField;
1472
            }
1473
            set
1474
            {
1475
                this.themeShadeField = value;
1476
            }
1477
        }
1478

1479
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1480
        public string fill
1481
        {
1482
            get
1483
            {
1484
                return this.fillField;
1485
            }
1486
            set
1487
            {
1488
                this.fillField = value;
1489
            }
1490
        }
1491

1492
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1493
        public ST_ThemeColor themeFill
1494
        {
1495
            get
1496
            {
1497
                return this.themeFillField;
1498
            }
1499
            set
1500
            {
1501
                this.themeFillField = value;
1502
            }
1503
        }
1504

1505
        [XmlIgnore]
1506
        public bool themeFillSpecified
1507
        {
1508
            get
1509
            {
1510
                return this.themeFillFieldSpecified;
1511
            }
1512
            set
1513
            {
1514
                this.themeFillFieldSpecified = value;
1515
            }
1516
        }
1517

1518
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
1519
        public byte[] themeFillTint
1520
        {
1521
            get
1522
            {
1523
                return this.themeFillTintField;
1524
            }
1525
            set
1526
            {
1527
                this.themeFillTintField = value;
1528
            }
1529
        }
1530

1531
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
1532
        public byte[] themeFillShade
1533
        {
1534
            get
1535
            {
1536
                return this.themeFillShadeField;
1537
            }
1538
            set
1539
            {
1540
                this.themeFillShadeField = value;
1541
            }
1542
        }
1543
    }
1544

1545

1546
    [Serializable]
1547
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1548
    public enum ST_Shd
1549
    {
1550

1551
    
1552
        nil,
1553

1554
    
1555
        clear,
1556

1557
    
1558
        solid,
1559

1560
    
1561
        horzStripe,
1562

1563
    
1564
        vertStripe,
1565

1566
    
1567
        reverseDiagStripe,
1568

1569
    
1570
        diagStripe,
1571

1572
    
1573
        horzCross,
1574

1575
    
1576
        diagCross,
1577

1578
    
1579
        thinHorzStripe,
1580

1581
    
1582
        thinVertStripe,
1583

1584
    
1585
        thinReverseDiagStripe,
1586

1587
    
1588
        thinDiagStripe,
1589

1590
    
1591
        thinHorzCross,
1592

1593
    
1594
        thinDiagCross,
1595

1596
    
1597
        pct5,
1598

1599
    
1600
        pct10,
1601

1602
    
1603
        pct12,
1604

1605
    
1606
        pct15,
1607

1608
    
1609
        pct20,
1610

1611
    
1612
        pct25,
1613

1614
    
1615
        pct30,
1616

1617
    
1618
        pct35,
1619

1620
    
1621
        pct37,
1622

1623
    
1624
        pct40,
1625

1626
    
1627
        pct45,
1628

1629
    
1630
        pct50,
1631

1632
    
1633
        pct55,
1634

1635
    
1636
        pct60,
1637

1638
    
1639
        pct62,
1640

1641
    
1642
        pct65,
1643

1644
    
1645
        pct70,
1646

1647
    
1648
        pct75,
1649

1650
    
1651
        pct80,
1652

1653
    
1654
        pct85,
1655

1656
    
1657
        pct87,
1658

1659
    
1660
        pct90,
1661

1662
    
1663
        pct95,
1664
    }
1665

1666

1667

1668

1669

1670

1671

1672

1673

1674

1675
    //==============
1676

1677

1678
    /// <summary>
1679
    /// Text Expansion/Compression Percentage
1680
    /// </summary>
1681
    [Serializable]
1682
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1683
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1684
    public class CT_TextScale
1685
    {
1686
        public static CT_TextScale Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1687
        {
1688
            if (node == null)
1689
                return null;
1690
            CT_TextScale ctObj = new CT_TextScale();
1691
            ctObj.val = XmlHelper.ReadString(node.Attributes["w:val"]);
1692
            return ctObj;
1693
        }
1694

1695

1696

1697
        internal void Write(StreamWriter sw, string nodeName)
1698
        {
1699
            sw.Write(string.Format("<w:{0}", nodeName));
1700
            XmlHelper.WriteAttribute(sw, "w:val", this.val);
1701
            sw.Write(">");
1702
            sw.WriteEndW(nodeName);
1703
        }
1704

1705

1706
        private string valField;
1707
        /// <summary>
1708
        /// Text Expansion/Compression Value
1709
        /// </summary>
1710
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
1711
        public string val
1712
        {
1713
            get
1714
            {
1715
                return this.valField;
1716
            }
1717
            set
1718
            {
1719
                this.valField = value;
1720
            }
1721
        }
1722
    }
1723

1724
    /// <summary>
1725
    /// Text Highlight Colors
1726
    /// </summary>
1727
    [Serializable]
1728
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1729
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1730
    public class CT_Highlight
1731
    {
1732
        public static CT_Highlight Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1733
        {
1734
            if (node == null)
1735
                return null;
1736
            CT_Highlight ctObj = new CT_Highlight();
1737
            if (node.Attributes["w:val"] != null)
1738
                ctObj.val = (ST_HighlightColor)Enum.Parse(typeof(ST_HighlightColor), node.Attributes["w:val"].Value);
1739
            return ctObj;
1740
        }
1741

1742

1743

1744
        internal void Write(StreamWriter sw, string nodeName)
1745
        {
1746
            sw.Write(string.Format("<w:{0}", nodeName));
1747
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1748
            sw.Write(">");
1749
            sw.WriteEndW(nodeName);
1750
        }
1751

1752

1753
        private ST_HighlightColor valField;
1754
        /// <summary>
1755
        /// Highlighting Color
1756
        /// </summary>
1757
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1758
        public ST_HighlightColor val
1759
        {
1760
            get
1761
            {
1762
                return this.valField;
1763
            }
1764
            set
1765
            {
1766
                this.valField = value;
1767
            }
1768
        }
1769
    }
1770
    /// <summary>
1771
    /// Color Value
1772
    /// </summary>
1773
    [Serializable]
1774
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1775
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1776
    public class CT_Color
1777
    {
1778

1779
        private string valField;
1780

1781
        private ST_ThemeColor themeColorField;
1782

1783
        private bool themeColorFieldSpecified;
1784

1785
        private byte[] themeTintField;
1786

1787
        private byte[] themeShadeField;
1788

1789
        public CT_Color()
1790
        {
1791
            this.themeColorField = ST_ThemeColor.none;
1792
        }
1793

1794
        public static CT_Color Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1795
        {
1796
            if (node == null)
1797
                return null;
1798
            CT_Color ctObj = new CT_Color();
1799
            ctObj.val = XmlHelper.ReadString(node.Attributes["w:val"]);
1800
            if (node.Attributes["w:themeColor"] != null)
1801
                ctObj.themeColor = (ST_ThemeColor)Enum.Parse(typeof(ST_ThemeColor), node.Attributes["w:themeColor"].Value);
1802
            ctObj.themeTint = XmlHelper.ReadBytes(node.Attributes["w:themeTint"]);
1803
            ctObj.themeShade = XmlHelper.ReadBytes(node.Attributes["w:themeShade"]);
1804
            return ctObj;
1805
        }
1806

1807

1808

1809
        internal void Write(StreamWriter sw, string nodeName)
1810
        {
1811
            sw.Write(string.Format("<w:{0}", nodeName));
1812
            XmlHelper.WriteAttribute(sw, "w:val", this.val, true);
1813
            if(this.themeColorField!= ST_ThemeColor.none)
1814
                XmlHelper.WriteAttribute(sw, "w:themeColor", this.themeColor.ToString());
1815
            XmlHelper.WriteAttribute(sw, "w:themeTint", this.themeTint);
1816
            XmlHelper.WriteAttribute(sw, "w:themeShade", this.themeShade);
1817
            sw.Write("/>");
1818
        }
1819

1820
        /// <summary>
1821
        /// Run Content Color
1822
        /// </summary>
1823
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1824
        public string val
1825
        {
1826
            get
1827
            {
1828
                return this.valField;
1829
            }
1830
            set
1831
            {
1832
                this.valField = value;
1833
            }
1834
        }
1835
        /// <summary>
1836
        /// Run Content Theme Color
1837
        /// </summary>
1838
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1839
        public ST_ThemeColor themeColor
1840
        {
1841
            get
1842
            {
1843
                return this.themeColorField;
1844
            }
1845
            set
1846
            {
1847
                this.themeColorField = value;
1848
            }
1849
        }
1850

1851
        [XmlIgnore]
1852
        public bool themeColorSpecified
1853
        {
1854
            get
1855
            {
1856
                return this.themeColorFieldSpecified;
1857
            }
1858
            set
1859
            {
1860
                this.themeColorFieldSpecified = value;
1861
            }
1862
        }
1863
        /// <summary>
1864
        /// Run Content Theme Color Tint
1865
        /// </summary>
1866
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
1867
        public byte[] themeTint
1868
        {
1869
            get
1870
            {
1871
                return this.themeTintField;
1872
            }
1873
            set
1874
            {
1875
                this.themeTintField = value;
1876
            }
1877
        }
1878
        /// <summary>
1879
        /// Run Content Theme Color Shade
1880
        /// </summary>
1881
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
1882
        public byte[] themeShade
1883
        {
1884
            get
1885
            {
1886
                return this.themeShadeField;
1887
            }
1888
            set
1889
            {
1890
                this.themeShadeField = value;
1891
            }
1892
        }
1893
    }
1894

1895
    /// <summary>
1896
    /// Underline Style
1897
    /// </summary>
1898
    [Serializable]
1899
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1900
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1901
    public class CT_Underline
1902
    {
1903

1904
        private ST_Underline valField;
1905

1906
        private bool valFieldSpecified;
1907

1908
        private string colorField;
1909

1910
        private ST_ThemeColor themeColorField;
1911

1912
        private bool themeColorFieldSpecified;
1913

1914
        private byte[] themeTintField;
1915

1916
        private byte[] themeShadeField;
1917

1918
        public CT_Underline()
1919
        {
1920
            this.themeColorField = ST_ThemeColor.none;
1921
        }
1922

1923
        public static CT_Underline Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1924
        {
1925
            if (node == null)
1926
                return null;
1927
            CT_Underline ctObj = new CT_Underline();
1928
            if (node.Attributes["w:val"] != null)
1929
                ctObj.val = (ST_Underline)Enum.Parse(typeof(ST_Underline), node.Attributes["w:val"].Value);
1930
            ctObj.color = XmlHelper.ReadString(node.Attributes["w:color"]);
1931
            if (node.Attributes["w:themeColor"] != null)
1932
                ctObj.themeColor = (ST_ThemeColor)Enum.Parse(typeof(ST_ThemeColor), node.Attributes["w:themeColor"].Value);
1933
            ctObj.themeTint = XmlHelper.ReadBytes(node.Attributes["w:themeTint"]);
1934
            ctObj.themeShade = XmlHelper.ReadBytes(node.Attributes["w:themeShade"]);
1935
            return ctObj;
1936
        }
1937

1938

1939

1940
        internal void Write(StreamWriter sw, string nodeName)
1941
        {
1942
            sw.Write(string.Format("<w:{0}", nodeName));
1943
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1944
            XmlHelper.WriteAttribute(sw, "w:color", this.color);
1945
            if(this.themeColor!= ST_ThemeColor.none)
1946
                XmlHelper.WriteAttribute(sw, "w:themeColor", this.themeColor.ToString());
1947
            XmlHelper.WriteAttribute(sw, "w:themeTint", this.themeTint);
1948
            XmlHelper.WriteAttribute(sw, "w:themeShade", this.themeShade);
1949
            sw.Write("/>");
1950
        }
1951

1952

1953
        /// <summary>
1954
        /// Underline Style value
1955
        /// </summary>
1956
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1957
        public ST_Underline val
1958
        {
1959
            get
1960
            {
1961
                return this.valField;
1962
            }
1963
            set
1964
            {
1965
                this.valField = value;
1966
            }
1967
        }
1968

1969
        [XmlIgnore]
1970
        public bool valSpecified
1971
        {
1972
            get
1973
            {
1974
                return this.valFieldSpecified;
1975
            }
1976
            set
1977
            {
1978
                this.valFieldSpecified = value;
1979
            }
1980
        }
1981
        /// <summary>
1982
        /// Underline Color
1983
        /// </summary>
1984
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1985
        public string color
1986
        {
1987
            get
1988
            {
1989
                return this.colorField;
1990
            }
1991
            set
1992
            {
1993
                this.colorField = value;
1994
            }
1995
        }
1996
        /// <summary>
1997
        /// Underline Theme Color
1998
        /// </summary>
1999
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2000
        public ST_ThemeColor themeColor
2001
        {
2002
            get
2003
            {
2004
                return this.themeColorField;
2005
            }
2006
            set
2007
            {
2008
                this.themeColorField = value;
2009
            }
2010
        }
2011

2012
        [XmlIgnore]
2013
        public bool themeColorSpecified
2014
        {
2015
            get
2016
            {
2017
                return this.themeColorFieldSpecified;
2018
            }
2019
            set
2020
            {
2021
                this.themeColorFieldSpecified = value;
2022
            }
2023
        }
2024
        /// <summary>
2025
        /// Underline Theme Color Tint
2026
        /// </summary>
2027
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2028
        public byte[] themeTint
2029
        {
2030
            get
2031
            {
2032
                return this.themeTintField;
2033
            }
2034
            set
2035
            {
2036
                this.themeTintField = value;
2037
            }
2038
        }
2039
        /// <summary>
2040
        /// Underline Theme Color Shade
2041
        /// </summary>
2042
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2043
        public byte[] themeShade
2044
        {
2045
            get
2046
            {
2047
                return this.themeShadeField;
2048
            }
2049
            set
2050
            {
2051
                this.themeShadeField = value;
2052
            }
2053
        }
2054
    }
2055

2056
    /// <summary>
2057
    /// Underline Patterns
2058
    /// </summary>
2059
    [Serializable]
2060
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2061
    public enum ST_Underline
2062
    {
2063

2064
        /// <summary>
2065
        /// Single Underline
2066
        /// </summary>
2067
        single,
2068

2069
        /// <summary>
2070
        /// Underline Non-Space Characters Only
2071
        /// </summary>
2072
        words,
2073

2074
        /// <summary>
2075
        /// Double Underline
2076
        /// </summary>
2077
        @double,
2078

2079
        /// <summary>
2080
        /// Thick Underline
2081
        /// </summary>
2082
        thick,
2083

2084
        /// <summary>
2085
        /// Dotted Underline
2086
        /// </summary>
2087
        dotted,
2088

2089
        /// <summary>
2090
        /// Thick Dotted Underline
2091
        /// </summary>
2092
        dottedHeavy,
2093

2094
        /// <summary>
2095
        /// Dashed Underline
2096
        /// </summary>
2097
        dash,
2098

2099
        /// <summary>
2100
        /// Thick Dashed Underline
2101
        /// </summary>
2102
        dashedHeavy,
2103

2104
        /// <summary>
2105
        /// Long Dashed Underline
2106
        /// </summary>
2107
        dashLong,
2108

2109
        /// <summary>
2110
        /// Thick Long Dashed Underline
2111
        /// </summary>
2112
        dashLongHeavy,
2113

2114
        /// <summary>
2115
        /// Dash-Dot Underline
2116
        /// </summary>
2117
        dotDash,
2118

2119
        /// <summary>
2120
        /// Thick Dash-Dot Underline
2121
        /// </summary>
2122
        dashDotHeavy,
2123

2124
        /// <summary>
2125
        /// Dash-Dot-Dot Underline
2126
        /// </summary>
2127
        dotDotDash,
2128

2129
        /// <summary>
2130
        /// Thick Dash-Dot-Dot Underline
2131
        /// </summary>
2132
        dashDotDotHeavy,
2133

2134
        /// <summary>
2135
        /// Wave Underline
2136
        /// </summary>
2137
        wave,
2138

2139
        /// <summary>
2140
        /// Heavy Wave Underline
2141
        /// </summary>
2142
        wavyHeavy,
2143

2144
        /// <summary>
2145
        /// Double Wave Underline
2146
        /// </summary>
2147
        wavyDouble,
2148

2149
        /// <summary>
2150
        /// No Underline
2151
        /// </summary>
2152
        none,
2153
    }
2154

2155
    /// <summary>
2156
    /// Animated Text Effects
2157
    /// </summary>
2158
    [Serializable]
2159
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2160
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2161
    public class CT_TextEffect
2162
    {
2163
        public static CT_TextEffect Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2164
        {
2165
            if (node == null)
2166
                return null;
2167
            CT_TextEffect ctObj = new CT_TextEffect();
2168
            if (node.Attributes["w:val"] != null)
2169
                ctObj.val = (ST_TextEffect)Enum.Parse(typeof(ST_TextEffect), node.Attributes["w:val"].Value);
2170
            return ctObj;
2171
        }
2172

2173

2174

2175
        internal void Write(StreamWriter sw, string nodeName)
2176
        {
2177
            sw.Write(string.Format("<w:{0}", nodeName));
2178
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
2179
            sw.Write("/>");
2180
        }
2181

2182

2183
        private ST_TextEffect valField;
2184
        /// <summary>
2185
        /// Animated Text Effect Type
2186
        /// </summary>
2187
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2188
        public ST_TextEffect val
2189
        {
2190
            get
2191
            {
2192
                return this.valField;
2193
            }
2194
            set
2195
            {
2196
                this.valField = value;
2197
            }
2198
        }
2199
    }
2200

2201
    [Serializable]
2202
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2203
    public enum ST_TextEffect
2204
    {
2205

2206
        /// <summary>
2207
        /// Blinking Background Animation
2208
        /// </summary>
2209
        blinkBackground,
2210

2211
        /// <summary>
2212
        /// Colored Lights Animation
2213
        /// </summary>
2214
        lights,
2215

2216
        /// <summary>
2217
        /// Black Dashed Line Animation
2218
        /// </summary>
2219
        antsBlack,
2220

2221
        /// <summary>
2222
        /// Marching Red Ants
2223
        /// </summary>
2224
        antsRed,
2225

2226
        /// <summary>
2227
        /// Shimmer Animation
2228
        /// </summary>
2229
        shimmer,
2230

2231
        /// <summary>
2232
        /// Sparkling Lights Animation
2233
        /// </summary>
2234
        sparkle,
2235

2236
        /// <summary>
2237
        /// No Animation
2238
        /// </summary>
2239
        none,
2240
    }
2241

2242
    /// <summary>
2243
    /// Border Style
2244
    /// </summary>
2245
    [Serializable]
2246
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2247
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2248
    public class CT_Border
2249
    {
2250

2251
        private ST_Border valField;
2252

2253
        private string colorField;
2254

2255
        private ST_ThemeColor themeColorField;
2256

2257
        private bool themeColorFieldSpecified;
2258

2259
        private byte[] themeTintField;
2260

2261
        private byte[] themeShadeField;
2262

2263
        private ulong? szField;
2264

2265
        private ulong? spaceField;
2266

2267
        private ST_OnOff shadowField;
2268

2269
        private bool shadowFieldSpecified;
2270

2271
        private ST_OnOff frameField;
2272

2273
        private bool frameFieldSpecified;
2274

2275
        public CT_Border()
2276
        {
2277
            this.themeColor = ST_ThemeColor.none;
2278
        }
2279

2280
        public static CT_Border Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2281
        {
2282
            if (node == null)
2283
                return null;
2284
            CT_Border ctObj = new CT_Border();
2285
            if (node.Attributes["w:val"] != null)
2286
                ctObj.val = (ST_Border)Enum.Parse(typeof(ST_Border), node.Attributes["w:val"].Value);
2287
            ctObj.color = XmlHelper.ReadString(node.Attributes["w:color"]);
2288
            if (node.Attributes["w:themeColor"] != null)
2289
                ctObj.themeColor = (ST_ThemeColor)Enum.Parse(typeof(ST_ThemeColor), node.Attributes["w:themeColor"].Value);
2290
            ctObj.themeTint = XmlHelper.ReadBytes(node.Attributes["w:themeTint"]);
2291
            ctObj.themeShade = XmlHelper.ReadBytes(node.Attributes["w:themeShade"]);
2292
            if(node.Attributes["w:sz"]!=null)
2293
                ctObj.sz = XmlHelper.ReadULong(node.Attributes["w:sz"]);
2294
            if(node.Attributes["w:space"]!=null)
2295
                ctObj.space = XmlHelper.ReadULong(node.Attributes["w:space"]);
2296
            if (node.Attributes["w:shadow"] != null)
2297
                ctObj.shadow = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:shadow"].Value,true);
2298
            if (node.Attributes["w:frame"] != null)
2299
                ctObj.frame = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:frame"].Value,true);
2300
            return ctObj;
2301
        }
2302

2303

2304

2305
        internal void Write(StreamWriter sw, string nodeName)
2306
        {
2307
            sw.Write(string.Format("<w:{0}", nodeName));
2308
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
2309
            if (this.sz != null)
2310
                XmlHelper.WriteAttribute(sw, "w:sz", (ulong)this.sz, true);
2311
           if (this.space != null)
2312
               XmlHelper.WriteAttribute(sw, "w:space", (ulong)this.space, true);
2313
            XmlHelper.WriteAttribute(sw, "w:color", this.color);
2314
            if(this.themeColor!= ST_ThemeColor.none)
2315
                XmlHelper.WriteAttribute(sw, "w:themeColor", this.themeColor.ToString());
2316
            XmlHelper.WriteAttribute(sw, "w:themeTint", this.themeTint);
2317
            XmlHelper.WriteAttribute(sw, "w:themeShade", this.themeShade);
2318
            if(this.shadow!= ST_OnOff.off)
2319
                XmlHelper.WriteAttribute(sw, "w:shadow", this.shadow.ToString());
2320
            if (this.frame != ST_OnOff.off)
2321
                XmlHelper.WriteAttribute(sw, "w:frame", this.frame.ToString());
2322
            sw.Write("/>");
2323
        }
2324

2325

2326

2327
        /// <summary>
2328
        /// Border Style
2329
        /// </summary>
2330
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2331
        public ST_Border val
2332
        {
2333
            get
2334
            {
2335
                return this.valField;
2336
            }
2337
            set
2338
            {
2339
                this.valField = value;
2340
            }
2341
        }
2342
        /// <summary>
2343
        /// Border Color
2344
        /// </summary>
2345
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2346
        public string color
2347
        {
2348
            get
2349
            {
2350
                return this.colorField;
2351
            }
2352
            set
2353
            {
2354
                this.colorField = value;
2355
            }
2356
        }
2357
        /// <summary>
2358
        /// Border Theme Color
2359
        /// </summary>
2360
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2361
        public ST_ThemeColor themeColor
2362
        {
2363
            get
2364
            {
2365
                return this.themeColorField;
2366
            }
2367
            set
2368
            {
2369
                this.themeColorField = value;
2370
            }
2371
        }
2372

2373
        [XmlIgnore]
2374
        public bool themeColorSpecified
2375
        {
2376
            get
2377
            {
2378
                return this.themeColorFieldSpecified;
2379
            }
2380
            set
2381
            {
2382
                this.themeColorFieldSpecified = value;
2383
            }
2384
        }
2385
        /// <summary>
2386
        /// Border Theme Color Tint
2387
        /// </summary>
2388
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2389
        public byte[] themeTint
2390
        {
2391
            get
2392
            {
2393
                return this.themeTintField;
2394
            }
2395
            set
2396
            {
2397
                this.themeTintField = value;
2398
            }
2399
        }
2400
        /// <summary>
2401
        /// Border Theme Color Shade
2402
        /// </summary>
2403
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2404
        public byte[] themeShade
2405
        {
2406
            get
2407
            {
2408
                return this.themeShadeField;
2409
            }
2410
            set
2411
            {
2412
                this.themeShadeField = value;
2413
            }
2414
        }
2415
        /// <summary>
2416
        /// Border Width
2417
        /// </summary>
2418
        /// ST_EighthPointMeasure
2419
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2420
        public ulong? sz
2421
        {
2422
            get
2423
            {
2424
                return this.szField;
2425
            }
2426
            set
2427
            {
2428
                this.szField = value;
2429
            }
2430
        }
2431

2432
        /// <summary>
2433
        /// Border Spacing Measurement
2434
        /// </summary>
2435
        public ulong? space
2436
        {
2437
            get
2438
            {
2439
                return this.spaceField;
2440
            }
2441
            set
2442
            {
2443
                this.spaceField = value;
2444
            }
2445
        }
2446

2447
        /// <summary>
2448
        /// Border Shadow
2449
        /// </summary>
2450
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2451
        public ST_OnOff shadow
2452
        {
2453
            get
2454
            {
2455
                return this.shadowField;
2456
            }
2457
            set
2458
            {
2459
                this.shadowField = value;
2460
            }
2461
        }
2462

2463
        [XmlIgnore]
2464
        public bool shadowSpecified
2465
        {
2466
            get
2467
            {
2468
                return this.shadowFieldSpecified;
2469
            }
2470
            set
2471
            {
2472
                this.shadowFieldSpecified = value;
2473
            }
2474
        }
2475
        /// <summary>
2476
        /// Create Frame Effect
2477
        /// </summary>
2478
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2479
        public ST_OnOff frame
2480
        {
2481
            get
2482
            {
2483
                return this.frameField;
2484
            }
2485
            set
2486
            {
2487
                this.frameField = value;
2488
            }
2489
        }
2490

2491
        [XmlIgnore]
2492
        public bool frameSpecified
2493
        {
2494
            get
2495
            {
2496
                return this.frameFieldSpecified;
2497
            }
2498
            set
2499
            {
2500
                this.frameFieldSpecified = value;
2501
            }
2502
        }
2503
    }
2504

2505
    /// <summary>
2506
    /// Border Styles
2507
    /// </summary>
2508
    [Serializable]
2509
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2510
    public enum ST_Border
2511
    {
2512

2513
        /// <summary>
2514
        /// No Border
2515
        /// </summary>
2516
        nil,
2517

2518
        /// <summary>
2519
        /// No Border
2520
        /// </summary>
2521
        none,
2522

2523
        /// <summary>
2524
        /// Single Line Border
2525
        /// </summary>
2526
        single,
2527

2528
        /// <summary>
2529
        /// Single Line Border
2530
        /// </summary>
2531
        thick,
2532

2533
        /// <summary>
2534
        /// Double Line Border
2535
        /// </summary>
2536
        @double,
2537

2538
        /// <summary>
2539
        /// Dotted Line Border
2540
        /// </summary>
2541
        dotted,
2542

2543
        /// <summary>
2544
        /// Dashed Line Border
2545
        /// </summary>
2546
        dashed,
2547

2548
        /// <summary>
2549
        /// Dot Dash Line Border
2550
        /// </summary>
2551
        dotDash,
2552

2553
        /// <summary>
2554
        /// Dot Dot Dash Line Border
2555
        /// </summary>
2556
        dotDotDash,
2557

2558
        /// <summary>
2559
        /// Triple Line Border
2560
        /// </summary>
2561
        triple,
2562

2563
        /// <summary>
2564
        /// Thin, Thick Line Border<
2565
        /// </summary>
2566
        thinThickSmallGap,
2567

2568
        /// <summary>
2569
        /// Thick, Thin Line Border
2570
        /// </summary>
2571
        thickThinSmallGap,
2572

2573
        /// <summary>
2574
        /// Thin, Thick, Thin Line Border
2575
        /// </summary>
2576
        thinThickThinSmallGap,
2577

2578
        /// <summary>
2579
        /// Thin, Thick Line Border
2580
        /// </summary>
2581
        thinThickMediumGap,
2582

2583
        /// <summary>
2584
        /// Thick, Thin Line Border
2585
        /// </summary>
2586
        thickThinMediumGap,
2587

2588
        /// <summary>
2589
        /// Thin, Thick, Thin Line Border
2590
        /// </summary>
2591
        thinThickThinMediumGap,
2592

2593
        /// <summary>
2594
        /// Thin, Thick Line Border
2595
        /// </summary>
2596
        thinThickLargeGap,
2597

2598
        /// <summary>
2599
        /// Thick, Thin Line Border
2600
        /// </summary>
2601
        thickThinLargeGap,
2602

2603
        /// <summary>
2604
        /// Thin, Thick, Thin Line Border
2605
        /// </summary>
2606
        thinThickThinLargeGap,
2607

2608
        /// <summary>
2609
        /// Wavy Line Border
2610
        /// </summary>
2611
        wave,
2612

2613
        /// <summary>
2614
        /// Double Wave Line Border
2615
        /// </summary>
2616
        doubleWave,
2617

2618
        /// <summary>
2619
        /// Dashed Line Border
2620
        /// </summary>
2621
        dashSmallGap,
2622

2623
        /// <summary>
2624
        /// Dash Dot Strokes Line Border
2625
        /// </summary>
2626
        dashDotStroked,
2627

2628
        /// <summary>
2629
        /// 3D Embossed Line Border
2630
        /// </summary>
2631
        threeDEmboss,
2632

2633
        /// <summary>
2634
        /// 3D Engraved Line Border
2635
        /// </summary>
2636
        threeDEngrave,
2637

2638
        /// <summary>
2639
        /// Outset Line Border
2640
        /// </summary>
2641
        outset,
2642

2643
        /// <summary>
2644
        /// Inset Line Border
2645
        /// </summary>
2646
        inset,
2647

2648
        /// <summary>
2649
        /// Apples Art Border
2650
        /// </summary>
2651
        apples,
2652

2653
        /// <summary>
2654
        /// Arched Scallops Art Border
2655
        /// </summary>
2656
        archedScallops,
2657

2658
        /// <summary>
2659
        /// Baby Pacifier Art Border
2660
        /// </summary>
2661
        babyPacifier,
2662

2663
        /// <summary>
2664
        /// Baby Rattle Art Border
2665
        /// </summary>
2666
        babyRattle,
2667

2668
        /// <summary>
2669
        /// Three Color Balloons Art Border
2670
        /// </summary>
2671
        balloons3Colors,
2672

2673
        /// <summary>
2674
        /// Hot Air Balloons Art Border
2675
        /// </summary>
2676
        balloonsHotAir,
2677

2678
        /// <summary>
2679
        /// Black Dash Art Border
2680
        /// </summary>
2681
        basicBlackDashes,
2682

2683
        /// <summary>
2684
        /// Black Dot Art Border
2685
        /// </summary>
2686
        basicBlackDots,
2687

2688
        /// <summary>
2689
        /// Black Square Art Border
2690
        /// </summary>
2691
        basicBlackSquares,
2692

2693
        /// <summary>
2694
        /// Thin Line Art Border
2695
        /// </summary>
2696
        basicThinLines,
2697

2698
        /// <summary>
2699
        /// White Dash Art Border
2700
        /// </summary>
2701
        basicWhiteDashes,
2702

2703
        /// <summary>
2704
        /// White Dot Art Border
2705
        /// </summary>
2706
        basicWhiteDots,
2707

2708
        /// <summary>
2709
        /// White Square Art Border
2710
        /// </summary>
2711
        basicWhiteSquares,
2712

2713
        /// <summary>
2714
        /// Wide Inline Art Border
2715
        /// </summary>
2716
        basicWideInline,
2717

2718
        /// <summary>
2719
        /// Wide Midline Art Border
2720
        /// </summary>
2721
        basicWideMidline,
2722

2723
        /// <summary>
2724
        /// 
2725
        /// </summary>
2726
        basicWideOutline,
2727

2728
        /// <summary>
2729
        /// Wide Outline Art Border
2730
        /// </summary>
2731
        bats,
2732

2733
        /// <summary>
2734
        /// Bats Art Border
2735
        /// </summary>
2736
        birds,
2737

2738
        /// <summary>
2739
        /// Birds Art Border
2740
        /// </summary>
2741
        birdsFlight,
2742

2743
        /// <summary>
2744
        /// Cabin Art Border
2745
        /// </summary>
2746
        cabins,
2747

2748
        /// <summary>
2749
        /// Cake Art Border
2750
        /// </summary>
2751
        cakeSlice,
2752

2753
        /// <summary>
2754
        /// Candy Corn Art Border
2755
        /// </summary>
2756
        candyCorn,
2757

2758
        /// <summary>
2759
        /// Knot Work Art Border
2760
        /// </summary>
2761
        celticKnotwork,
2762

2763
        /// <summary>
2764
        /// Certificate Banner Art Border
2765
        /// </summary>
2766
        certificateBanner,
2767

2768
        /// <summary>
2769
        /// Chain Link Art Border
2770
        /// </summary>
2771
        chainLink,
2772

2773
        /// <summary>
2774
        /// Champagne Bottle Art Border
2775
        /// </summary>
2776
        champagneBottle,
2777

2778
        /// <summary>
2779
        /// Black and White Bar Art Border
2780
        /// </summary>
2781
        checkedBarBlack,
2782

2783
        /// <summary>
2784
        /// Color Checked Bar Art Border
2785
        /// </summary>
2786
        checkedBarColor,
2787

2788
        /// <summary>
2789
        /// Checkerboard Art Border
2790
        /// </summary>
2791
        checkered,
2792

2793
        /// <summary>
2794
        /// Christmas Tree Art Border
2795
        /// </summary>
2796
        christmasTree,
2797

2798
        /// <summary>
2799
        /// Circles And Lines Art Border
2800
        /// </summary>
2801
        circlesLines,
2802

2803
        /// <summary>
2804
        /// Circles and Rectangles Art Border
2805
        /// </summary>
2806
        circlesRectangles,
2807

2808
        /// <summary>
2809
        /// Wave Art Border
2810
        /// </summary>
2811
        classicalWave,
2812

2813
        /// <summary>
2814
        /// Clocks Art Border
2815
        /// </summary>
2816
        clocks,
2817

2818
        /// <summary>
2819
        /// Compass Art Border
2820
        /// </summary>
2821
        compass,
2822

2823
        /// <summary>
2824
        /// Confetti Art Border
2825
        /// </summary>
2826
        confetti,
2827

2828
        /// <summary>
2829
        /// Confetti Art Border
2830
        /// </summary>
2831
        confettiGrays,
2832

2833
        /// <summary>
2834
        /// Confetti Art Border
2835
        /// </summary>
2836
        confettiOutline,
2837

2838
        /// <summary>
2839
        /// Confetti Streamers Art Border
2840
        /// </summary>
2841
        confettiStreamers,
2842

2843
        /// <summary>
2844
        /// Confetti Art Border
2845
        /// </summary>
2846
        confettiWhite,
2847

2848
        /// <summary>
2849
        /// Corner Triangle Art Border
2850
        /// </summary>
2851
        cornerTriangles,
2852

2853
        /// <summary>
2854
        /// Dashed Line Art Border
2855
        /// </summary>
2856
        couponCutoutDashes,
2857

2858
        /// <summary>
2859
        /// Dotted Line Art Border
2860
        /// </summary>
2861
        couponCutoutDots,
2862

2863
        /// <summary>
2864
        /// Maze Art Border
2865
        /// </summary>
2866
        crazyMaze,
2867

2868
        /// <summary>
2869
        /// Butterfly Art Border
2870
        /// </summary>
2871
        creaturesButterfly,
2872

2873
        /// <summary>
2874
        /// Fish Art Border
2875
        /// </summary>
2876
        creaturesFish,
2877

2878
        /// <summary>
2879
        /// Insects Art Border
2880
        /// </summary>
2881
        creaturesInsects,
2882

2883
        /// <summary>
2884
        /// Ladybug Art Border
2885
        /// </summary>
2886
        creaturesLadyBug,
2887

2888
        /// <summary>
2889
        /// Cross-stitch Art Border
2890
        /// </summary>
2891
        crossStitch,
2892

2893
        /// <summary>
2894
        /// Cupid Art Border
2895
        /// </summary>
2896
        cup,
2897

2898
        /// <summary>
2899
        /// Archway Art Border
2900
        /// </summary>
2901
        decoArch,
2902

2903
        /// <summary>
2904
        /// Color Archway Art Border
2905
        /// </summary>
2906
        decoArchColor,
2907

2908
        /// <summary>
2909
        /// Blocks Art Border
2910
        /// </summary>
2911
        decoBlocks,
2912

2913
        /// <summary>
2914
        /// Gray Diamond Art Border
2915
        /// </summary>
2916
        diamondsGray,
2917

2918
        /// <summary>
2919
        /// Double D Art Border
2920
        /// </summary>
2921
        doubleD,
2922

2923
        /// <summary>
2924
        /// Diamond Art Border
2925
        /// </summary>
2926
        doubleDiamonds,
2927

2928
        /// <summary>
2929
        /// Earth Art Border
2930
        /// </summary>
2931
        earth1,
2932

2933
        /// <summary>
2934
        /// Earth Art Border
2935
        /// </summary>
2936
        earth2,
2937

2938
        /// <summary>
2939
        /// Shadowed Square Art Border
2940
        /// </summary>
2941
        eclipsingSquares1,
2942

2943
        /// <summary>
2944
        /// Shadowed Square Art Border
2945
        /// </summary>
2946
        eclipsingSquares2,
2947

2948
        /// <summary>
2949
        /// Painted Egg Art Border
2950
        /// </summary>
2951
        eggsBlack,
2952

2953
        /// <summary>
2954
        /// Fans Art Border
2955
        /// </summary>
2956
        fans,
2957

2958
        /// <summary>
2959
        /// Film Reel Art Border
2960
        /// </summary>
2961
        film,
2962

2963
        /// <summary>
2964
        /// Firecracker Art Border
2965
        /// </summary>
2966
        firecrackers,
2967

2968
        /// <summary>
2969
        /// Flowers Art Border
2970
        /// </summary>
2971
        flowersBlockPrint,
2972

2973
        /// <summary>
2974
        /// Daisy Art Border
2975
        /// </summary>
2976
        flowersDaisies,
2977

2978
        /// <summary>
2979
        /// Flowers Art Border
2980
        /// </summary>
2981
        flowersModern1,
2982

2983
        /// <summary>
2984
        /// Flowers Art Border
2985
        /// </summary>
2986
        flowersModern2,
2987

2988
        /// <summary>
2989
        /// Pansy Art Border
2990
        /// </summary>
2991
        flowersPansy,
2992

2993
        /// <summary>
2994
        /// Red Rose Art Border
2995
        /// </summary>
2996
        flowersRedRose,
2997

2998
        /// <summary>
2999
        /// Roses Art Border
3000
        /// </summary>
3001
        flowersRoses,
3002

3003
        /// <summary>
3004
        /// Flowers in a Teacup Art Border
3005
        /// </summary>
3006
        flowersTeacup,
3007

3008
        /// <summary>
3009
        /// Small Flower Art Border
3010
        /// </summary>
3011
        flowersTiny,
3012

3013
        /// <summary>
3014
        /// Gems Art Border
3015
        /// </summary>
3016
        gems,
3017

3018
        /// <summary>
3019
        /// Gingerbread Man Art Border
3020
        /// </summary>
3021
        gingerbreadMan,
3022

3023
        /// <summary>
3024
        /// Triangle Gradient Art Border
3025
        /// </summary>
3026
        gradient,
3027

3028
        /// <summary>
3029
        /// Handmade Art Border
3030
        /// </summary>
3031
        handmade1,
3032

3033
        /// <summary>
3034
        /// Handmade Art Border
3035
        /// </summary>
3036
        handmade2,
3037

3038
        /// <summary>
3039
        /// Heart-Shaped Balloon Art Border
3040
        /// </summary>
3041
        heartBalloon,
3042

3043
        /// <summary>
3044
        /// Gray Heart Art Border
3045
        /// </summary>
3046
        heartGray,
3047

3048
        /// <summary>
3049
        /// Hearts Art Border
3050
        /// </summary>
3051
        hearts,
3052

3053
        /// <summary>
3054
        /// Pattern Art Border
3055
        /// </summary>
3056
        heebieJeebies,
3057

3058
        /// <summary>
3059
        /// Holly Art Border
3060
        /// </summary>
3061
        holly,
3062

3063
        /// <summary>
3064
        /// House Art Border
3065
        /// </summary>
3066
        houseFunky,
3067

3068
        /// <summary>
3069
        /// Circular Art Border
3070
        /// </summary>
3071
        hypnotic,
3072

3073
        /// <summary>
3074
        /// Ice Cream Cone Art Border
3075
        /// </summary>
3076
        iceCreamCones,
3077

3078
        /// <summary>
3079
        /// Light Bulb Art Border
3080
        /// </summary>
3081
        lightBulb,
3082

3083
        /// <summary>
3084
        /// Light Bulb Art Border
3085
        /// </summary>
3086
        lightning1,
3087

3088
        /// <summary>
3089
        /// Light Bulb Art Border
3090
        /// </summary>
3091
        lightning2,
3092

3093
        /// <summary>
3094
        /// Map Pins Art Border
3095
        /// </summary>
3096
        mapPins,
3097

3098
        /// <summary>
3099
        /// Maple Leaf Art Border
3100
        /// </summary>
3101
        mapleLeaf,
3102
        
3103
        /// <summary>
3104
        /// Muffin Art Border
3105
        /// </summary>
3106
        mapleMuffins,
3107

3108
        /// <summary>
3109
        /// Marquee Art Border
3110
        /// </summary>
3111
        marquee,
3112

3113
        /// <summary>
3114
        /// Marquee Art Border
3115
        /// </summary>
3116
        marqueeToothed,
3117

3118
        /// <summary>
3119
        /// Moon Art Border
3120
        /// </summary>
3121
        moons,
3122

3123
        /// <summary>
3124
        /// Mosaic Art Border
3125
        /// </summary>
3126
        mosaic,
3127

3128
        /// <summary>
3129
        /// Musical Note Art Border
3130
        /// </summary>
3131
        musicNotes,
3132

3133
        /// <summary>
3134
        /// Patterned Art Border
3135
        /// </summary>
3136
        northwest,
3137

3138
        /// <summary>
3139
        /// Oval Art Border
3140
        /// </summary>
3141
        ovals,
3142

3143
        /// <summary>
3144
        /// Package Art Border
3145
        /// </summary>
3146
        packages,
3147

3148
        /// <summary>
3149
        /// Black Palm Tree Art Border
3150
        /// </summary>
3151
        palmsBlack,
3152

3153
        /// <summary>
3154
        /// Color Palm Tree Art Border
3155
        /// </summary>
3156
        palmsColor,
3157

3158
        /// <summary>
3159
        /// Paper Clip Art Border
3160
        /// </summary>
3161
        paperClips,
3162

3163
        /// <summary>
3164
        /// Papyrus Art Border
3165
        /// </summary>
3166
        papyrus,
3167

3168
        /// <summary>
3169
        /// Party Favor Art Border
3170
        /// </summary>
3171
        partyFavor,
3172

3173
        /// <summary>
3174
        /// Party Glass Art Border
3175
        /// </summary>
3176
        partyGlass,
3177

3178
        /// <summary>
3179
        /// Pencils Art Border
3180
        /// </summary>
3181
        pencils,
3182

3183
        /// <summary>
3184
        /// Character Art Border
3185
        /// </summary>
3186
        people,
3187

3188
        /// <summary>
3189
        /// Waving Character Border
3190
        /// </summary>
3191
        peopleWaving,
3192

3193
        /// <summary>
3194
        /// Character With Hat Art Border
3195
        /// </summary>
3196
        peopleHats,
3197

3198
        /// <summary>
3199
        /// Poinsettia Art Border
3200
        /// </summary>
3201
        poinsettias,
3202

3203
        /// <summary>
3204
        /// Postage Stamp Art Border
3205
        /// </summary>
3206
        postageStamp,
3207

3208
        /// <summary>
3209
        /// Pumpkin Art Border
3210
        /// </summary>
3211
        pumpkin1,
3212

3213
        /// <summary>
3214
        /// Push Pin Art Border
3215
        /// </summary>
3216
        pushPinNote2,
3217

3218
        /// <summary>
3219
        /// Push Pin Art Border
3220
        /// </summary>
3221
        pushPinNote1,
3222

3223
        /// <summary>
3224
        /// Pyramid Art Border
3225
        /// </summary>
3226
        pyramids,
3227

3228
        /// <summary>
3229
        /// Pyramid Art Border
3230
        /// </summary>
3231
        pyramidsAbove,
3232

3233
        /// <summary>
3234
        /// Quadrants Art Border
3235
        /// </summary>
3236
        quadrants,
3237

3238
        /// <summary>
3239
        /// Rings Art Border
3240
        /// </summary>
3241
        rings,
3242

3243
        /// <summary>
3244
        /// Safari Art Border
3245
        /// </summary>
3246
        safari,
3247

3248
        /// <summary>
3249
        /// Saw tooth Art Border
3250
        /// </summary>
3251
        sawtooth,
3252

3253
        /// <summary>
3254
        /// Gray Saw tooth Art Border
3255
        /// </summary>
3256
        sawtoothGray,
3257

3258
        /// <summary>
3259
        /// Scared Cat Art Border
3260
        /// </summary>
3261
        scaredCat,
3262

3263
        /// <summary>
3264
        /// Umbrella Art Border
3265
        /// </summary>
3266
        seattle,
3267

3268
        /// <summary>
3269
        /// Shadowed Squares Art Border
3270
        /// </summary>
3271
        shadowedSquares,
3272

3273
        /// <summary>
3274
        /// Shark Tooth Art Border
3275
        /// </summary>
3276
        sharksTeeth,
3277

3278
        /// <summary>
3279
        /// Bird Tracks Art Border
3280
        /// </summary>
3281
        shorebirdTracks,
3282

3283
        /// <summary>
3284
        /// Rocket Art Border
3285
        /// </summary>
3286
        skyrocket,
3287

3288
        /// <summary>
3289
        /// Snowflake Art Border
3290
        /// </summary>
3291
        snowflakeFancy,
3292

3293
        /// <summary>
3294
        /// Snowflake Art Border
3295
        /// </summary>
3296
        snowflakes,
3297

3298
        /// <summary>
3299
        /// Sombrero Art Border
3300
        /// </summary>
3301
        sombrero,
3302

3303
        /// <summary>
3304
        /// Southwest-themed Art Border
3305
        /// </summary>
3306
        southwest,
3307

3308
        /// <summary>
3309
        /// Stars Art Border
3310
        /// </summary>
3311
        stars,
3312

3313
        /// <summary>
3314
        /// Stars On Top Art Border
3315
        /// </summary>
3316
        starsTop,
3317

3318
        /// <summary>
3319
        /// 3-D Stars Art Border
3320
        /// </summary>
3321
        stars3d,
3322

3323
        /// <summary>
3324
        /// Stars Art Border
3325
        /// </summary>
3326
        starsBlack,
3327

3328
        /// <summary>
3329
        /// Stars With Shadows Art Border
3330
        /// </summary>
3331
        starsShadowed,
3332

3333
        /// <summary>
3334
        /// Sun Art Border
3335
        /// </summary>
3336
        sun,
3337

3338
        /// <summary>
3339
        /// Whirligig Art Border
3340
        /// </summary>
3341
        swirligig,
3342

3343
        /// <summary>
3344
        /// Torn Paper Art Border
3345
        /// </summary>
3346
        tornPaper,
3347

3348
        /// <summary>
3349
        /// Black Torn Paper Art Border
3350
        /// </summary>
3351
        tornPaperBlack,
3352

3353
        /// <summary>
3354
        /// Tree Art Border
3355
        /// </summary>
3356
        trees,
3357

3358
        /// <summary>
3359
        /// Triangle Art Border
3360
        /// </summary>
3361
        triangleParty,
3362

3363
        /// <summary>
3364
        /// Triangles Art Border
3365
        /// </summary>
3366
        triangles,
3367

3368
        /// <summary>
3369
        /// Tribal Art Border One
3370
        /// </summary>
3371
        tribal1,
3372

3373
        /// <summary>
3374
        /// Tribal Art Border Two
3375
        /// </summary>
3376
        tribal2,
3377

3378
        /// <summary>
3379
        /// Tribal Art Border Three
3380
        /// </summary>
3381
        tribal3,
3382

3383
        /// <summary>
3384
        /// Tribal Art Border Four
3385
        /// </summary>
3386
        tribal4,
3387

3388
        /// <summary>
3389
        /// Tribal Art Border Five
3390
        /// </summary>
3391
        tribal5,
3392

3393
        /// <summary>
3394
        /// Tribal Art Border Six
3395
        /// </summary>
3396
        tribal6,
3397

3398
        /// <summary>
3399
        /// Twisted Lines Art Border
3400
        /// </summary>
3401
        twistedLines1,
3402

3403
        /// <summary>
3404
        /// Twisted Lines Art Border
3405
        /// </summary>
3406
        twistedLines2,
3407

3408
        /// <summary>
3409
        /// Vine Art Border
3410
        /// </summary>
3411
        vine,
3412

3413
        /// <summary>
3414
        /// Wavy Line Art Border
3415
        /// </summary>
3416
        waveline,
3417

3418
        /// <summary>
3419
        /// Weaving Angles Art Border
3420
        /// </summary>
3421
        weavingAngles,
3422

3423
        /// <summary>
3424
        /// Weaving Braid Art Border
3425
        /// </summary>
3426
        weavingBraid,
3427

3428
        /// <summary>
3429
        /// Weaving Ribbon Art Border
3430
        /// </summary>
3431
        weavingRibbon,
3432

3433
        /// <summary>
3434
        /// Weaving Strips Art Border
3435
        /// </summary>
3436
        weavingStrips,
3437

3438
        /// <summary>
3439
        /// White Flowers Art Border
3440
        /// </summary>
3441
        whiteFlowers,
3442

3443
        /// <summary>
3444
        /// Woodwork Art Border
3445
        /// </summary>
3446
        woodwork,
3447

3448
        /// <summary>
3449
        /// Crisscross Art Border
3450
        /// </summary>
3451
        xIllusions,
3452

3453
        /// <summary>
3454
        /// Triangle Art Border
3455
        /// </summary>
3456
        zanyTriangles,
3457

3458
        /// <summary>
3459
        /// Zigzag Art Border
3460
        /// </summary>
3461
        zigZag,
3462

3463
        /// <summary>
3464
        /// Zigzag stitch
3465
        /// </summary>
3466
        zigZagStitch,
3467
    }
3468
}
npoi

Использование cookies
