npoi

1
// ------------------------------------------------------------------------------
2
//  <auto-generated>
3
//    Generated by Xsd2Code. Version 3.4.0.38967
4
//    <NameSpace>NPOI.OpenXmlFormats.Dml</NameSpace><Collection>List</Collection><codeType>CSharp</codeType><EnableDataBinding>False</EnableDataBinding><EnableLazyLoading>False</EnableLazyLoading><TrackingChangesEnable>False</TrackingChangesEnable><GenTrackingClasses>False</GenTrackingClasses><HidePrivateFieldInIDE>False</HidePrivateFieldInIDE><EnableSummaryComment>False</EnableSummaryComment><VirtualProp>False</VirtualProp><IncludeSerializeMethod>False</IncludeSerializeMethod><UseBaseClass>False</UseBaseClass><GenBaseClass>False</GenBaseClass><GenerateCloneMethod>False</GenerateCloneMethod><GenerateDataContracts>False</GenerateDataContracts><CodeBaseTag>Net20</CodeBaseTag><SerializeMethodName>Serialize</SerializeMethodName><DeserializeMethodName>Deserialize</DeserializeMethodName><SaveToFileMethodName>SaveToFile</SaveToFileMethodName><LoadFromFileMethodName>LoadFromFile</LoadFromFileMethodName><GenerateXMLAttributes>True</GenerateXMLAttributes><EnableEncoding>False</EnableEncoding><AutomaticProperties>False</AutomaticProperties><GenerateShouldSerialize>False</GenerateShouldSerialize><DisableDebug>True</DisableDebug><PropNameSpecified>Default</PropNameSpecified><Encoder>UTF8</Encoder><CustomUsings></CustomUsings><ExcludeIncludedTypes>True</ExcludeIncludedTypes><EnableInitializeFields>True</EnableInitializeFields>
5
//  </auto-generated>
6
// ------------------------------------------------------------------------------
7
namespace NPOI.OpenXmlFormats.Dml
8
{
9
    using System;
10
    using System.Diagnostics;
11
    using System.Xml.Serialization;
12
    using System.Collections;
13
    using System.Xml.Schema;
14
    using System.ComponentModel;
15
    using System.Collections.Generic;
16
    using System.IO;
17
    using System.Xml;
18
    using NPOI.OpenXml4Net.Util;
19

20

21
    [Serializable]
22
    [DebuggerStepThrough]
23
    [System.ComponentModel.DesignerCategoryAttribute("code")]
24
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
25
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
26
    public class CT_TextSpacingPercent
27
    {
28
        public static CT_TextSpacingPercent Parse(XmlNode node, XmlNamespaceManager namespaceManager)
29
        {
30
            if (node == null)
31
                return null;
32
            CT_TextSpacingPercent ctObj = new CT_TextSpacingPercent();
33
            ctObj.val = XmlHelper.ReadInt(node.Attributes["val"]);
34
            return ctObj;
35
        }
36

37

38

39
        internal void Write(StreamWriter sw, string nodeName)
40
        {
41
            sw.Write(string.Format("<a:{0}", nodeName));
42
            XmlHelper.WriteAttribute(sw, "val", this.val, true);
43
            sw.Write("/>");
44
        }
45

46
        private int valField;
47
        /*<xsd:restriction base="ST_Percentage">
48
              <xsd:minInclusive value="0" />
49
              <xsd:maxInclusive value="13200000" />
50
          </xsd:restriction>*/
51
        [XmlAttribute]
52
        public int val
53
        {
54
            get
55
            {
56
                return this.valField;
57
            }
58
            set
59
            {
60
                this.valField = value;
61
            }
62
        }
63
    }
64

65

66
    [Serializable]
67
    [DebuggerStepThrough]
68
    [System.ComponentModel.DesignerCategoryAttribute("code")]
69
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
70
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
71
    public class CT_TextSpacingPoint
72
    {
73
        public static CT_TextSpacingPoint Parse(XmlNode node, XmlNamespaceManager namespaceManager)
74
        {
75
            if (node == null)
76
                return null;
77
            CT_TextSpacingPoint ctObj = new CT_TextSpacingPoint();
78
            ctObj.val = XmlHelper.ReadInt(node.Attributes["val"]);
79
            return ctObj;
80
        }
81

82

83

84
        internal void Write(StreamWriter sw, string nodeName)
85
        {
86
            sw.Write(string.Format("<a:{0}", nodeName));
87
            XmlHelper.WriteAttribute(sw, "val", this.val, true);
88
            sw.Write("/>");
89
        }
90

91
        private int valField;
92
        /*<xsd:restriction base="xsd:int">
93
              <xsd:minInclusive value="0" />
94
              <xsd:maxInclusive value="158400" />
95
          </xsd:restriction>*/
96
        [XmlAttribute]
97
        public int val
98
        {
99
            get
100
            {
101
                return this.valField;
102
            }
103
            set
104
            {
105
                this.valField = value;
106
            }
107
        }
108
    }
109

110

111
    [Serializable]
112
    [DebuggerStepThrough]
113
    [System.ComponentModel.DesignerCategoryAttribute("code")]
114
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
115
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
116
    public class CT_TextTabStop
117
    {
118

119
        private int posField;
120

121
        private bool posFieldSpecified;
122

123
        private ST_TextTabAlignType algnField;
124

125
        private bool algnFieldSpecified;
126
        public static CT_TextTabStop Parse(XmlNode node, XmlNamespaceManager namespaceManager)
127
        {
128
            if (node == null)
129
                return null;
130
            CT_TextTabStop ctObj = new CT_TextTabStop();
131
            ctObj.pos = XmlHelper.ReadInt(node.Attributes["pos"]);
132
            if (node.Attributes["algn"] != null)
133
                ctObj.algn = (ST_TextTabAlignType)Enum.Parse(typeof(ST_TextTabAlignType), node.Attributes["algn"].Value);
134
            return ctObj;
135
        }
136

137

138

139
        internal void Write(StreamWriter sw, string nodeName)
140
        {
141
            sw.Write(string.Format("<a:{0}", nodeName));
142
            XmlHelper.WriteAttribute(sw, "pos", this.pos);
143
            XmlHelper.WriteAttribute(sw, "algn", this.algn.ToString());
144
            sw.Write("/>");
145
        }
146

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

160
        [XmlIgnore]
161
        public bool posSpecified
162
        {
163
            get
164
            {
165
                return this.posFieldSpecified;
166
            }
167
            set
168
            {
169
                this.posFieldSpecified = value;
170
            }
171
        }
172

173
        [XmlAttribute]
174
        public ST_TextTabAlignType algn
175
        {
176
            get
177
            {
178
                return this.algnField;
179
            }
180
            set
181
            {
182
                this.algnField = value;
183
            }
184
        }
185

186
        [XmlIgnore]
187
        public bool algnSpecified
188
        {
189
            get
190
            {
191
                return this.algnFieldSpecified;
192
            }
193
            set
194
            {
195
                this.algnFieldSpecified = value;
196
            }
197
        }
198
    }
199

200

201
    [Serializable]
202
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
203
    public enum ST_TextTabAlignType
204
    {
205

206
        /// <remarks/>
207
        l,
208

209
        /// <remarks/>
210
        ctr,
211

212
        /// <remarks/>
213
        r,
214

215
        /// <remarks/>
216
        dec,
217
    }
218

219

220
    [Serializable]
221
    [DebuggerStepThrough]
222
    [System.ComponentModel.DesignerCategoryAttribute("code")]
223
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
224
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
225
    public class CT_TextTabStopList
226
    {
227

228
        private List<CT_TextTabStop> tabField;
229

230
        public CT_TextTabStopList()
231
        {
232
            this.tabField = new List<CT_TextTabStop>();
233
        }
234

235
        [XmlElement("tab", Order = 0)]
236
        public List<CT_TextTabStop> tab
237
        {
238
            get
239
            {
240
                return this.tabField;
241
            }
242
            set
243
            {
244
                this.tabField = value;
245
            }
246
        }
247

248
        internal void Write(StreamWriter sw, string p)
249
        {
250
            sw.Write("<a:{0}>", p);
251
            if (this.tab != null)
252
            {
253
                foreach (CT_TextTabStop tts in tab)
254
                {
255
                    tts.Write(sw, "tab");
256
                }
257
            }
258
            sw.Write("</a:{0}>", p);
259
        }
260

261
        internal static CT_TextTabStopList Parse(XmlNode node, XmlNamespaceManager namespaceManager)
262
        {
263
            CT_TextTabStopList ttsl = new CT_TextTabStopList();
264
            ttsl.tab = new List<CT_TextTabStop>();
265
            foreach (XmlNode childNode in node)
266
            {
267
                if(childNode.LocalName=="tab")
268
                    ttsl.tab.Add(CT_TextTabStop.Parse(childNode, namespaceManager));
269
            }
270
            return ttsl;
271
        }
272

273
        public CT_TextTabStop AddNewTab()
274
        {
275
            this.tabField.Add(new CT_TextTabStop());
276
            return this.tabField[this.tabField.Count - 1];
277
        }
278

279
        public int SizeOfTabArray()
280
        {
281
            return tabField.Count;
282
        }
283

284
        public CT_TextTabStop GetTabArray(int idx)
285
        {
286
            return tabField[idx];
287
        }
288
    }
289

290

291
    [Serializable]
292
    [DebuggerStepThrough]
293
    [System.ComponentModel.DesignerCategoryAttribute("code")]
294
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
295
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
296
    public class CT_TextLineBreak
297
    {
298

299
        private CT_TextCharacterProperties rPrField;
300

301
        public CT_TextLineBreak()
302
        {
303
            //this.rPrField = new CT_TextCharacterProperties();
304
        }
305

306
        public static CT_TextLineBreak Parse(XmlNode node, XmlNamespaceManager namespaceManager)
307
        {
308
            if (node == null)
309
                return null;
310
            CT_TextLineBreak ctObj = new CT_TextLineBreak();
311
            foreach (XmlNode childNode in node.ChildNodes)
312
            {
313
                if (childNode.LocalName == "rPr")
314
                    ctObj.rPr = CT_TextCharacterProperties.Parse(childNode, namespaceManager);
315
            }
316
            return ctObj;
317
        }
318

319

320

321
        internal void Write(StreamWriter sw, string nodeName)
322
        {
323
            sw.Write(string.Format("<a:{0}>", nodeName));
324
            if (this.rPr != null)
325
                this.rPr.Write(sw, "rPr");
326
            sw.Write(string.Format("</a:{0}>", nodeName));
327
        }
328

329
        [XmlElement(Order = 0)]
330
        public CT_TextCharacterProperties rPr
331
        {
332
            get
333
            {
334
                return this.rPrField;
335
            }
336
            set
337
            {
338
                this.rPrField = value;
339
            }
340
        }
341

342
        public CT_TextCharacterProperties AddNewRPr()
343
        {
344
            this.rPr = new CT_TextCharacterProperties();
345
            return rPr;
346
        }
347
    }
348

349
    [Serializable]
350
    [DebuggerStepThrough]
351
    [System.ComponentModel.DesignerCategoryAttribute("code")]
352
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
353
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
354
    public class CT_TextSpacing
355
    {
356
        private CT_TextSpacingPercent spcPctField;
357
        private CT_TextSpacingPoint spcPtsField;
358
        public static CT_TextSpacing Parse(XmlNode node, XmlNamespaceManager namespaceManager)
359
        {
360
            if (node == null)
361
                return null;
362
            CT_TextSpacing ctObj = new CT_TextSpacing();
363
            foreach (XmlNode childNode in node.ChildNodes)
364
            {
365
                if (childNode.LocalName == "spcPct")
366
                    ctObj.spcPct = CT_TextSpacingPercent.Parse(childNode, namespaceManager);
367
                else if (childNode.LocalName == "spcPts")
368
                    ctObj.spcPts = CT_TextSpacingPoint.Parse(childNode, namespaceManager);
369
            }
370
            return ctObj;
371
        }
372

373

374

375
        internal void Write(StreamWriter sw, string nodeName)
376
        {
377
            sw.Write(string.Format("<a:{0}>", nodeName));
378
            if (this.spcPct != null)
379
                this.spcPct.Write(sw, "spcPct");
380
            if (this.spcPts != null)
381
                this.spcPts.Write(sw, "spcPts");
382
            sw.Write(string.Format("</a:{0}>", nodeName));
383
        }
384
        public CT_TextSpacingPercent spcPct
385
        {
386
            get { return this.spcPctField; }
387
            set { this.spcPctField = value; }
388
        }
389
        public CT_TextSpacingPoint spcPts
390
        {
391
            get { return this.spcPtsField; }
392
            set { this.spcPtsField = value; }
393
        }
394

395
        public CT_TextSpacingPercent AddNewSpcPct()
396
        {
397
            this.spcPctField = new CT_TextSpacingPercent();
398
            return this.spcPctField;
399
        }
400

401
        public CT_TextSpacingPoint AddNewSpcPts()
402
        {
403
            this.spcPtsField = new CT_TextSpacingPoint();
404
            return this.spcPtsField;
405
        }
406

407
        public bool IsSetSpcPct()
408
        {
409
            return this.spcPctField != null;
410
        }
411

412
        public bool IsSetSpcPts()
413
        {
414
            return this.spcPtsField != null;
415
        }
416
    }
417

418

419
    [Serializable]
420
    [System.Diagnostics.DebuggerStepThrough]
421
    [System.ComponentModel.DesignerCategory("code")]
422
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
423
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
424
    public class CT_TextParagraph
425
    {
426
        public static CT_TextParagraph Parse(XmlNode node, XmlNamespaceManager namespaceManager)
427
        {
428
            if (node == null)
429
                return null;
430
            CT_TextParagraph ctObj = new CT_TextParagraph();
431
            ctObj.r = new List<CT_RegularTextRun>();
432
            ctObj.br = new List<CT_TextLineBreak>();
433
            ctObj.fld = new List<CT_TextField>();
434
            ctObj.items = new List<object>();
435
            foreach (XmlNode childNode in node.ChildNodes)
436
            {
437
                if (childNode.LocalName == "pPr")
438
                {
439
                    ctObj.pPr = CT_TextParagraphProperties.Parse(childNode, namespaceManager);
440
                    ctObj.items.Add(ctObj.pPr);
441
                }
442
                else if (childNode.LocalName == "endParaRPr")
443
                {
444
                    ctObj.endParaRPr = CT_TextCharacterProperties.Parse(childNode, namespaceManager);
445
                    ctObj.items.Add(ctObj.endParaRPr);
446
                }
447
                else if (childNode.LocalName == "r")
448
                {
449
                    CT_RegularTextRun r = CT_RegularTextRun.Parse(childNode, namespaceManager);
450
                    ctObj.r.Add(r);
451
                    ctObj.items.Add(r);
452
                }
453
                else if (childNode.LocalName == "br")
454
                {
455
                    CT_TextLineBreak br = CT_TextLineBreak.Parse(childNode, namespaceManager);
456
                    ctObj.br.Add(br);
457
                    ctObj.items.Add(br);
458
                }
459
                else if (childNode.LocalName == "fld")
460
                {
461
                    CT_TextField fld = CT_TextField.Parse(childNode, namespaceManager);
462
                    ctObj.fld.Add(fld);
463
                    ctObj.items.Add(fld);
464
                }
465
            }
466
            return ctObj;
467
        }
468

469

470

471
        internal void Write(StreamWriter sw, string nodeName)
472
        {
473
            sw.Write(string.Format("<a:{0}", nodeName));
474
            sw.Write(">");
475
            if (this.pPr != null)
476
                this.pPr.Write(sw, "pPr");
477
            //if (this.r != null)
478
            //{
479
            //    foreach (CT_RegularTextRun x in this.r)
480
            //    {
481
            //        x.Write(sw, "r");
482
            //    }
483
            //}
484
            //if (this.br != null)
485
            //{
486
            //    foreach (CT_TextLineBreak x in this.br)
487
            //    {
488
            //        x.Write(sw, "br");
489
            //    }
490
            //}
491
            //if (this.fld != null)
492
            //{
493
            //    foreach (CT_TextField x in this.fld)
494
            //    {
495
            //        x.Write(sw, "fld");
496
            //    }
497
            //}
498
            foreach (object o in items)
499
            {
500
                if (o is CT_RegularTextRun)
501
                {
502
                    (o as CT_RegularTextRun).Write(sw, "r");
503
                }
504
                else if (o is CT_TextLineBreak)
505
                {
506
                    (o as CT_TextLineBreak).Write(sw, "br");
507
                }
508
                else if (o is CT_TextField)
509
                {
510
                    (o as CT_TextField).Write(sw, "fld");
511
                }
512
            }
513
            if (this.endParaRPr != null)
514
                this.endParaRPr.Write(sw, "endParaRPr");
515
            sw.Write(string.Format("</a:{0}>", nodeName));
516
        }
517

518
        private CT_TextParagraphProperties pPrField;
519

520
        private List<CT_RegularTextRun> rField = new List<CT_RegularTextRun>();
521

522
        private List<CT_TextLineBreak> brField = new List<CT_TextLineBreak>();
523

524
        private List<CT_TextField> fldField = new List<CT_TextField>();
525

526
        private List<object> itemsField = new List<object>();
527
        [XmlIgnore]
528
        public List<object> items
529
        {
530
            get { return itemsField; }
531
            set { itemsField = value; }
532
        }
533
        private CT_TextCharacterProperties endParaRPrField;
534

535
        public CT_RegularTextRun AddNewR()
536
        {
537
            if (this.rField == null)
538
                this.rField = new List<CT_RegularTextRun>();
539
            CT_RegularTextRun rtr = new CT_RegularTextRun();
540
            this.rField.Add(rtr);
541
            this.itemsField.Add(rtr);
542
            return rtr;
543
        }
544
        public CT_TextParagraphProperties AddNewPPr()
545
        {
546
            this.pPrField = new CT_TextParagraphProperties();
547
            return this.pPrField;
548
        }
549
        public CT_TextCharacterProperties AddNewEndParaRPr()
550
        {
551
            this.endParaRPrField = new CT_TextCharacterProperties();
552
            return this.endParaRPrField;
553
        }
554

555
        public CT_TextParagraphProperties pPr
556
        {
557
            get
558
            {
559
                return this.pPrField;
560
            }
561
            set
562
            {
563
                this.pPrField = value;
564
            }
565
        }
566

567

568
        [XmlElement("r")]
569
        public List<CT_RegularTextRun> r
570
        {
571
            get
572
            {
573
                return this.rField;
574
            }
575
            set
576
            {
577
                this.rField = value;
578
            }
579
        }
580

581

582
        [XmlElement("br")]
583
        public List<CT_TextLineBreak> br
584
        {
585
            get
586
            {
587
                return this.brField;
588
            }
589
            set
590
            {
591
                this.brField = value;
592
            }
593
        }
594

595

596
        [XmlElement("fld")]
597
        public List<CT_TextField> fld
598
        {
599
            get
600
            {
601
                return this.fldField;
602
            }
603
            set
604
            {
605
                this.fldField = value;
606
            }
607
        }
608

609

610
        public CT_TextCharacterProperties endParaRPr
611
        {
612
            get
613
            {
614
                return this.endParaRPrField;
615
            }
616
            set
617
            {
618
                this.endParaRPrField = value;
619
            }
620
        }
621

622
        public int SizeOfRArray()
623
        {
624
            return rField.Count;
625
        }
626

627
        public bool IsSetPPr()
628
        {
629
            return this.pPrField != null;
630
        }
631

632
        public CT_TextLineBreak AddNewBr()
633
        {
634
            CT_TextLineBreak br = new CT_TextLineBreak();
635
            this.brField.Add(br);
636
            this.itemsField.Add(br);
637
            return br;
638
        }
639

640
        public CT_RegularTextRun GetRArray(int v)
641
        {
642
            return rField[v];
643
        }
644

645
        public int SizeOfFldArray()
646
        {
647
            return this.fldField.Count;
648
        }
649

650
        public CT_TextField GetFldArray(int v)
651
        {
652
            return fldField[v];
653
        }
654
    }
655

656
    [Serializable]
657
    [DebuggerStepThrough]
658
    [System.ComponentModel.DesignerCategoryAttribute("code")]
659
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
660
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
661
    public class CT_TextParagraphProperties
662
    {
663

664
        private CT_TextSpacing lnSpcField;
665

666
        private CT_TextSpacing spcBefField;
667

668
        private CT_TextSpacing spcAftField;
669

670
        private CT_TextBulletColorFollowText buClrTxField;
671

672
        private CT_Color buClrField;
673

674
        private CT_TextBulletSizeFollowText buSzTxField;
675

676
        private CT_TextBulletSizePercent buSzPctField;
677

678
        private CT_TextBulletSizePoint buSzPtsField;
679

680
        private CT_TextBulletTypefaceFollowText buFontTxField;
681

682
        private CT_TextFont buFontField;
683

684
        private CT_TextNoBullet buNoneField;
685

686
        private CT_TextAutonumberBullet buAutoNumField;
687

688
        private CT_TextCharBullet buCharField;
689

690
        private CT_TextBlipBullet buBlipField;
691

692
        private CT_TextTabStopList tabLstField;
693

694
        private CT_TextCharacterProperties defRPrField;
695

696
        private CT_OfficeArtExtensionList extLstField;
697

698
        private int marLField;
699

700
        private bool marLFieldSpecified;
701

702
        private int marRField;
703

704
        private bool marRFieldSpecified;
705

706
        private int lvlField;
707

708
        private bool lvlFieldSpecified;
709

710
        private int indentField;
711

712
        private bool indentFieldSpecified;
713

714
        private ST_TextAlignType algnField;
715

716
        private bool algnFieldSpecified;
717

718
        private int defTabSzField;
719

720
        private bool defTabSzFieldSpecified;
721

722
        private bool rtlField;
723

724
        private bool rtlFieldSpecified;
725

726
        private bool eaLnBrkField;
727

728
        private bool eaLnBrkFieldSpecified;
729

730
        private ST_TextFontAlignType fontAlgnField;
731

732
        private bool fontAlgnFieldSpecified;
733

734
        private bool latinLnBrkField;
735

736
        private bool latinLnBrkFieldSpecified;
737

738
        private bool hangingPunctField;
739

740
        private bool hangingPunctFieldSpecified;
741

742
        public CT_TextParagraphProperties()
743
        { 
744
            this.algn = ST_TextAlignType.l;
745
        }
746

747
        public static CT_TextParagraphProperties Parse(XmlNode node, XmlNamespaceManager namespaceManager)
748
        {
749
            if (node == null)
750
                return null;
751
            CT_TextParagraphProperties ctObj = new CT_TextParagraphProperties();
752
            ctObj.marL = XmlHelper.ReadInt(node.Attributes["marL"]);
753
            ctObj.marR = XmlHelper.ReadInt(node.Attributes["marR"]);
754
            ctObj.lvlFieldSpecified = node.Attributes["lvl"] != null;
755
            ctObj.lvlField = XmlHelper.ReadInt(node.Attributes["lvl"]);
756
            ctObj.indent = XmlHelper.ReadInt(node.Attributes["indent"]);
757
            ctObj.algnFieldSpecified = node.Attributes["algn"] != null;
758
            if (node.Attributes["algn"] != null)
759
                ctObj.algnField = (ST_TextAlignType)Enum.Parse(typeof(ST_TextAlignType), node.Attributes["algn"].Value);
760
            else
761
                ctObj.algnField = ST_TextAlignType.l;
762
            ctObj.defTabSz = XmlHelper.ReadInt(node.Attributes["defTabSz"]);
763
            ctObj.rtlFieldSpecified = node.Attributes["rtl"] != null;
764
            ctObj.rtlField = XmlHelper.ReadBool(node.Attributes["rtl"]);
765
            ctObj.eaLnBrk = XmlHelper.ReadBool(node.Attributes["eaLnBrk"]);
766
            ctObj.fontAlgnFieldSpecified = node.Attributes["fontAlgn"] != null;
767
            if (node.Attributes["fontAlgn"] != null)
768
                ctObj.fontAlgnField = (ST_TextFontAlignType)Enum.Parse(typeof(ST_TextFontAlignType), node.Attributes["fontAlgn"].Value);
769
            ctObj.latinLnBrkFieldSpecified = node.Attributes["latinLnBrk"]!=null;
770
            ctObj.latinLnBrkField = XmlHelper.ReadBool(node.Attributes["latinLnBrk"]);
771
            ctObj.hangingPunct = XmlHelper.ReadBool(node.Attributes["hangingPunct"]);
772
  
773
            foreach (XmlNode childNode in node.ChildNodes)
774
            {
775
                if (childNode.LocalName == "lnSpc")
776
                    ctObj.lnSpc = CT_TextSpacing.Parse(childNode, namespaceManager);
777
                else if (childNode.LocalName == "spcBef")
778
                    ctObj.spcBef = CT_TextSpacing.Parse(childNode, namespaceManager);
779
                else if (childNode.LocalName == "spcAft")
780
                    ctObj.spcAft = CT_TextSpacing.Parse(childNode, namespaceManager);
781
                else if (childNode.LocalName == "buClrTx")
782
                    ctObj.buClrTx = new CT_TextBulletColorFollowText();
783
                else if (childNode.LocalName == "buClr")
784
                    ctObj.buClr = CT_Color.Parse(childNode, namespaceManager);
785
                else if (childNode.LocalName == "buSzTx")
786
                    ctObj.buSzTx = new CT_TextBulletSizeFollowText();
787
                else if (childNode.LocalName == "buSzPct")
788
                    ctObj.buSzPct = CT_TextBulletSizePercent.Parse(childNode, namespaceManager);
789
                else if (childNode.LocalName == "buSzPts")
790
                    ctObj.buSzPts = CT_TextBulletSizePoint.Parse(childNode, namespaceManager);
791
                else if (childNode.LocalName == "buFontTx")
792
                    ctObj.buFontTx = new CT_TextBulletTypefaceFollowText();
793
                else if (childNode.LocalName == "buFont")
794
                    ctObj.buFont = CT_TextFont.Parse(childNode, namespaceManager);
795
                else if (childNode.LocalName == "buNone")
796
                    ctObj.buNone = new CT_TextNoBullet();
797
                else if (childNode.LocalName == "buAutoNum")
798
                    ctObj.buAutoNum = CT_TextAutonumberBullet.Parse(childNode, namespaceManager);
799
                else if (childNode.LocalName == "buChar")
800
                    ctObj.buChar = CT_TextCharBullet.Parse(childNode, namespaceManager);
801
                else if (childNode.LocalName == "buBlip")
802
                    ctObj.buBlip = CT_TextBlipBullet.Parse(childNode, namespaceManager);
803
                else if (childNode.LocalName == "defRPr")
804
                    ctObj.defRPr = CT_TextCharacterProperties.Parse(childNode, namespaceManager);
805
                else if (childNode.LocalName == "extLst")
806
                    ctObj.extLst = CT_OfficeArtExtensionList.Parse(childNode, namespaceManager);
807
                else if (childNode.LocalName == "tabLst")
808
                    ctObj.tabLst = CT_TextTabStopList.Parse(childNode, namespaceManager);
809
            }
810
            return ctObj;
811
        }
812

813

814

815
        internal void Write(StreamWriter sw, string nodeName)
816
        {
817
            sw.Write(string.Format("<a:{0}", nodeName));
818
            XmlHelper.WriteAttribute(sw, "marL", this.marL);
819
            XmlHelper.WriteAttribute(sw, "marR", this.marR);
820
            if(this.lvlFieldSpecified)
821
                XmlHelper.WriteAttribute(sw, "lvl", this.lvlField, true);
822
            XmlHelper.WriteAttribute(sw, "indent", this.indent);
823
            if(this.algnFieldSpecified)
824
                XmlHelper.WriteAttribute(sw, "algn", this.algnField.ToString());
825
            XmlHelper.WriteAttribute(sw, "defTabSz", this.defTabSz);
826
            if(this.rtlFieldSpecified)
827
                XmlHelper.WriteAttribute(sw, "rtl", this.rtlField);
828
            XmlHelper.WriteAttribute(sw, "eaLnBrk", this.eaLnBrk, false);
829
            if(this.fontAlgnFieldSpecified&& this.fontAlgn!= ST_TextFontAlignType.auto)
830
                XmlHelper.WriteAttribute(sw, "fontAlgn", this.fontAlgnField.ToString());
831
            if(this.latinLnBrkFieldSpecified)
832
                XmlHelper.WriteAttribute(sw, "latinLnBrk", this.latinLnBrk, true);
833
            XmlHelper.WriteAttribute(sw, "hangingPunct", this.hangingPunct, false);
834
            sw.Write(">");
835
            if (this.lnSpc != null)
836
                this.lnSpc.Write(sw, "lnSpc");
837
            if (this.spcBef != null)
838
                this.spcBef.Write(sw, "spcBef");
839
            if (this.spcAft != null)
840
                this.spcAft.Write(sw, "spcAft");
841
            if (this.buClrTx != null)
842
                sw.Write("<a:buClrTx/>");
843
            if (this.buClr != null)
844
                this.buClr.Write(sw, "buClr");
845
            if (this.buSzTx != null)
846
                sw.Write("<a:buSzTx/>");
847
            if (this.buSzPct != null)
848
                this.buSzPct.Write(sw, "buSzPct");
849
            if (this.buSzPts != null)
850
                this.buSzPts.Write(sw, "buSzPts");
851
            if (this.buFontTx != null)
852
                sw.Write("<a:buFontTx/>");
853
            if (this.buFont != null)
854
                this.buFont.Write(sw, "buFont");
855
            if (this.buNone != null)
856
                sw.Write("<a:buNone/>");
857
            if (this.buAutoNum != null)
858
                this.buAutoNum.Write(sw, "buAutoNum");
859
            if (this.buChar != null)
860
                this.buChar.Write(sw, "buChar");
861
            if (this.buBlip != null)
862
                this.buBlip.Write(sw, "buBlip");
863
            if (this.tabLstField != null)
864
            {
865
                this.tabLstField.Write(sw, "tabLst");
866
            }
867
            if (this.defRPr != null)
868
                this.defRPr.Write(sw, "defRPr");
869
            if (this.extLst != null)
870
                this.extLst.Write(sw, "extLst");
871
            sw.Write(string.Format("</a:{0}>", nodeName));
872
        }
873
        
874
        [XmlElement(Order = 0)]
875
        public CT_TextSpacing lnSpc
876
        {
877
            get
878
            {
879
                return this.lnSpcField;
880
            }
881
            set
882
            {
883
                this.lnSpcField = value;
884
            }
885
        }
886

887
        [XmlElement(Order = 1)]
888
        public CT_TextSpacing spcBef
889
        {
890
            get
891
            {
892
                return this.spcBefField;
893
            }
894
            set
895
            {
896
                this.spcBefField = value;
897
            }
898
        }
899

900
        [XmlElement(Order = 2)]
901
        public CT_TextSpacing spcAft
902
        {
903
            get
904
            {
905
                return this.spcAftField;
906
            }
907
            set
908
            {
909
                this.spcAftField = value;
910
            }
911
        }
912

913
        [XmlElement(Order = 3)]
914
        public CT_TextBulletColorFollowText buClrTx
915
        {
916
            get
917
            {
918
                return this.buClrTxField;
919
            }
920
            set
921
            {
922
                this.buClrTxField = value;
923
            }
924
        }
925

926
        [XmlElement(Order = 4)]
927
        public CT_Color buClr
928
        {
929
            get
930
            {
931
                return this.buClrField;
932
            }
933
            set
934
            {
935
                this.buClrField = value;
936
            }
937
        }
938

939
        [XmlElement(Order = 5)]
940
        public CT_TextBulletSizeFollowText buSzTx
941
        {
942
            get
943
            {
944
                return this.buSzTxField;
945
            }
946
            set
947
            {
948
                this.buSzTxField = value;
949
            }
950
        }
951

952
        [XmlElement(Order = 6)]
953
        public CT_TextBulletSizePercent buSzPct
954
        {
955
            get
956
            {
957
                return this.buSzPctField;
958
            }
959
            set
960
            {
961
                this.buSzPctField = value;
962
            }
963
        }
964

965
        [XmlElement(Order = 7)]
966
        public CT_TextBulletSizePoint buSzPts
967
        {
968
            get
969
            {
970
                return this.buSzPtsField;
971
            }
972
            set
973
            {
974
                this.buSzPtsField = value;
975
            }
976
        }
977

978
        [XmlElement(Order = 8)]
979
        public CT_TextBulletTypefaceFollowText buFontTx
980
        {
981
            get
982
            {
983
                return this.buFontTxField;
984
            }
985
            set
986
            {
987
                this.buFontTxField = value;
988
            }
989
        }
990

991
        [XmlElement(Order = 9)]
992
        public CT_TextFont buFont
993
        {
994
            get
995
            {
996
                return this.buFontField;
997
            }
998
            set
999
            {
1000
                this.buFontField = value;
1001
            }
1002
        }
1003

1004
        [XmlElement(Order = 10)]
1005
        public CT_TextNoBullet buNone
1006
        {
1007
            get
1008
            {
1009
                return this.buNoneField;
1010
            }
1011
            set
1012
            {
1013
                this.buNoneField = value;
1014
            }
1015
        }
1016

1017
        [XmlElement(Order = 11)]
1018
        public CT_TextAutonumberBullet buAutoNum
1019
        {
1020
            get
1021
            {
1022
                return this.buAutoNumField;
1023
            }
1024
            set
1025
            {
1026
                this.buAutoNumField = value;
1027
            }
1028
        }
1029

1030
        [XmlElement(Order = 12)]
1031
        public CT_TextCharBullet buChar
1032
        {
1033
            get
1034
            {
1035
                return this.buCharField;
1036
            }
1037
            set
1038
            {
1039
                this.buCharField = value;
1040
            }
1041
        }
1042

1043
        [XmlElement(Order = 13)]
1044
        public CT_TextBlipBullet buBlip
1045
        {
1046
            get
1047
            {
1048
                return this.buBlipField;
1049
            }
1050
            set
1051
            {
1052
                this.buBlipField = value;
1053
            }
1054
        }
1055

1056
        [XmlElement(Order = 14)]
1057
        public CT_TextTabStopList tabLst
1058
        {
1059
            get
1060
            {
1061
                return this.tabLstField;
1062
            }
1063
            set
1064
            {
1065
                this.tabLstField = value;
1066
            }
1067
        }
1068

1069
        [XmlElement(Order = 15)]
1070
        public CT_TextCharacterProperties defRPr
1071
        {
1072
            get
1073
            {
1074
                return this.defRPrField;
1075
            }
1076
            set
1077
            {
1078
                this.defRPrField = value;
1079
            }
1080
        }
1081

1082
        [XmlElement(Order = 16)]
1083
        public CT_OfficeArtExtensionList extLst
1084
        {
1085
            get
1086
            {
1087
                return this.extLstField;
1088
            }
1089
            set
1090
            {
1091
                this.extLstField = value;
1092
            }
1093
        }
1094

1095
        [XmlAttribute]
1096
        public int marL
1097
        {
1098
            get
1099
            {
1100
                return this.marLField;
1101
            }
1102
            set
1103
            {
1104
                this.marLField = value;
1105
                this.marLFieldSpecified = true;
1106
            }
1107
        }
1108

1109
        [XmlIgnore]
1110
        public bool marLSpecified
1111
        {
1112
            get
1113
            {
1114
                return this.marLFieldSpecified;
1115
            }
1116
            set
1117
            {
1118
                this.marLFieldSpecified = value;
1119
            }
1120
        }
1121

1122
        [XmlAttribute]
1123
        public int marR
1124
        {
1125
            get
1126
            {
1127
                return this.marRField;
1128
            }
1129
            set
1130
            {
1131
                this.marRField = value;
1132
                this.marRFieldSpecified = true;
1133
            }
1134
        }
1135

1136
        [XmlIgnore]
1137
        public bool marRSpecified
1138
        {
1139
            get
1140
            {
1141
                return this.marRFieldSpecified;
1142
            }
1143
            set
1144
            {
1145
                this.marRFieldSpecified = value;
1146
            }
1147
        }
1148
        /*<xsd:restriction base="xsd:int">
1149
            <xsd:minInclusive value="0" />
1150
            <xsd:maxInclusive value="8" />
1151
          </xsd:restriction>*/
1152
        [XmlAttribute]
1153
        public int lvl
1154
        {
1155
            get
1156
            {
1157
                return this.lvlField;
1158
            }
1159
            set
1160
            {
1161
                this.lvlField = value;
1162
                this.lvlFieldSpecified = true;
1163
            }
1164
        }
1165

1166
        [XmlAttribute]
1167
        public int indent
1168
        {
1169
            get
1170
            {
1171
                return this.indentField;
1172
            }
1173
            set
1174
            {
1175
                this.indentField = value;
1176
                this.indentFieldSpecified = true;
1177
            }
1178
        }
1179

1180
        [XmlIgnore]
1181
        public bool indentSpecified
1182
        {
1183
            get
1184
            {
1185
                return this.indentFieldSpecified;
1186
            }
1187
            set
1188
            {
1189
                this.indentFieldSpecified = value;
1190
            }
1191
        }
1192

1193
        [XmlAttribute]
1194
        public ST_TextAlignType algn
1195
        {
1196
            get
1197
            {
1198
                return this.algnField;
1199
            }
1200
            set
1201
            {
1202
                this.algnField = value;
1203
                this.algnFieldSpecified = true;
1204
            }
1205
        }
1206

1207
        [XmlIgnore]
1208
        public bool algnSpecified
1209
        {
1210
            get
1211
            {
1212
                return this.algnFieldSpecified;
1213
            }
1214
            set
1215
            {
1216
                this.algnFieldSpecified = value;
1217
            }
1218
        }
1219

1220
        [XmlAttribute]
1221
        public int defTabSz
1222
        {
1223
            get
1224
            {
1225
                return this.defTabSzField;
1226
            }
1227
            set
1228
            {
1229
                this.defTabSzField = value;
1230
                this.defTabSzFieldSpecified = true;
1231
            }
1232
        }
1233

1234
        [XmlIgnore]
1235
        public bool defTabSzSpecified
1236
        {
1237
            get
1238
            {
1239
                return this.defTabSzFieldSpecified;
1240
            }
1241
            set
1242
            {
1243
                this.defTabSzFieldSpecified = value;
1244
            }
1245
        }
1246

1247
        [XmlAttribute]
1248
        public bool rtl
1249
        {
1250
            get
1251
            {
1252
                return this.rtlField;
1253
            }
1254
            set
1255
            {
1256
                this.rtlField = value;
1257
                this.rtlFieldSpecified = value;
1258
            }
1259
        }
1260

1261
        [XmlIgnore]
1262
        public bool rtlSpecified
1263
        {
1264
            get
1265
            {
1266
                return this.rtlFieldSpecified;
1267
            }
1268
            set
1269
            {
1270
                this.rtlFieldSpecified = value;
1271
            }
1272
        }
1273

1274
        [XmlAttribute]
1275
        public bool eaLnBrk
1276
        {
1277
            get
1278
            {
1279
                return this.eaLnBrkField;
1280
            }
1281
            set
1282
            {
1283
                this.eaLnBrkField = value;
1284
                this.eaLnBrkFieldSpecified = value;
1285
            }
1286
        }
1287

1288
        [XmlIgnore]
1289
        public bool eaLnBrkSpecified
1290
        {
1291
            get
1292
            {
1293
                return this.eaLnBrkFieldSpecified;
1294
            }
1295
            set
1296
            {
1297
                this.eaLnBrkFieldSpecified = value;
1298
            }
1299
        }
1300

1301
        [XmlAttribute]
1302
        public ST_TextFontAlignType fontAlgn
1303
        {
1304
            get
1305
            {
1306
                return this.fontAlgnField;
1307
            }
1308
            set
1309
            {
1310
                this.fontAlgnField = value;
1311
                this.fontAlgnFieldSpecified = true;
1312
            }
1313
        }
1314

1315
        [XmlIgnore]
1316
        public bool fontAlgnSpecified
1317
        {
1318
            get
1319
            {
1320
                return this.fontAlgnFieldSpecified;
1321
            }
1322
            set
1323
            {
1324
                this.fontAlgnFieldSpecified = value;
1325
            }
1326
        }
1327

1328
        [XmlAttribute]
1329
        public bool latinLnBrk
1330
        {
1331
            get
1332
            {
1333
                return this.latinLnBrkField;
1334
            }
1335
            set
1336
            {
1337
                this.latinLnBrkField = value;
1338
                this.latinLnBrkFieldSpecified = value;
1339
            }
1340
        }
1341

1342
        [XmlIgnore]
1343
        public bool latinLnBrkSpecified
1344
        {
1345
            get
1346
            {
1347
                return this.latinLnBrkFieldSpecified;
1348
            }
1349
            set
1350
            {
1351
                this.latinLnBrkFieldSpecified = value;
1352
            }
1353
        }
1354

1355
        [XmlAttribute]
1356
        public bool hangingPunct
1357
        {
1358
            get
1359
            {
1360
                return this.hangingPunctField;
1361
            }
1362
            set
1363
            {
1364
                this.hangingPunctField = value;
1365
                this.hangingPunctFieldSpecified = value;
1366
            }
1367
        }
1368

1369
        [XmlIgnore]
1370
        public bool hangingPunctSpecified
1371
        {
1372
            get
1373
            {
1374
                return this.hangingPunctFieldSpecified;
1375
            }
1376
            set
1377
            {
1378
                this.hangingPunctFieldSpecified = value;
1379
            }
1380
        }
1381

1382
        public bool IsSetAlgn()
1383
        {
1384
            return this.algnFieldSpecified;
1385
        }
1386

1387
        public bool IsSetBuNone()
1388
        {
1389
            return this.buNoneField != null;
1390
        }
1391

1392
        public bool IsSetBuFont()
1393
        {
1394
            return this.buFontField != null;
1395
        }
1396

1397
        public bool IsSetBuChar()
1398
        {
1399
            return this.buCharField != null;
1400
        }
1401

1402
        public bool IsSetBuAutoNum()
1403
        {
1404
            return this.buAutoNumField != null;
1405
        }
1406

1407
        public void AddNewBuNone()
1408
        {
1409
            this.buNoneField = new CT_TextNoBullet();
1410
        }
1411

1412
        public bool IsSetBuBlip()
1413
        {
1414
            return this.buBlipField != null;
1415
        }
1416

1417
        public bool IsSetBuClr()
1418
        {
1419
            return this.buClrField != null;
1420
        }
1421

1422
        public bool IsSetBuClrTx()
1423
        {
1424
            return this.buClrTxField != null;
1425
        }
1426

1427
        public bool IsSetBuFontTx()
1428
        {
1429
            return this.buFontTxField != null;
1430
        }
1431

1432
        public bool IsSetBuSzPct()
1433
        {
1434
            return this.buSzPctField != null;
1435
        }
1436

1437
        public bool IsSetBuSzPts()
1438
        {
1439
            return this.buSzPtsField != null;
1440
        }
1441

1442
        public bool IsSetBuSzTx()
1443
        {
1444
            return this.buSzTxField != null;
1445
        }
1446

1447
        public CT_TextCharBullet AddNewBuChar()
1448
        {
1449
            this.buCharField = new CT_TextCharBullet();
1450
            return this.buCharField;
1451
        }
1452

1453
        public CT_TextFont AddNewBuFont()
1454
        {
1455
            this.buFontField = new CT_TextFont();
1456
            return this.buFontField;
1457
        }
1458

1459
        public void UnsetBuNone()
1460
        {
1461
            this.buNoneField = null;
1462
        }
1463

1464
        public void UnsetBuSzTx()
1465
        {
1466
            this.buSzTxField = null;
1467
        }
1468

1469
        public void UnsetBuSzPts()
1470
        {
1471
            this.buSzPtsField = null;
1472
        }
1473

1474
        public void UnsetBuAutoNum()
1475
        {
1476
            this.buAutoNumField = null;
1477
        }
1478

1479
        public void UnsetBuBlip()
1480
        {
1481
            this.buBlipField = null;
1482
        }
1483

1484
        public void UnsetBuChar()
1485
        {
1486
            this.buCharField = null;
1487
        }
1488

1489
        public void UnsetBuClr()
1490
        {
1491
            this.buClrField = null;
1492
        }
1493

1494
        public void UnsetBuClrTx()
1495
        {
1496
            this.buClrTxField = null;
1497
        }
1498

1499
        public void UnsetBuFont()
1500
        {
1501
            this.buFontField = null;
1502
        }
1503

1504
        public void UnsetBuFontTx()
1505
        {
1506
            this.buFontTxField = null;
1507
        }
1508

1509
        public void UnsetBuSzPct()
1510
        {
1511
            this.buSzPctField = null;
1512
        }
1513

1514
        public void UnsetAlgn()
1515
        {
1516
            this.algnFieldSpecified = false;
1517
        }
1518

1519
        public bool IsSetFontAlgn()
1520
        {
1521
            return this.fontAlgnFieldSpecified;
1522
        }
1523

1524
        public void UnsetFontAlgn()
1525
        {
1526
            this.fontAlgnFieldSpecified = false;
1527
        }
1528

1529
        public CT_Color AddNewBuClr()
1530
        {
1531
            this.buClrField = new CT_Color();
1532
            return this.buClrField;
1533
        }
1534

1535
        public CT_TextBulletSizePercent AddNewBuSzPct()
1536
        {
1537
            this.buSzPctField = new CT_TextBulletSizePercent();
1538
            return this.buSzPctField;
1539
        }
1540

1541
        public CT_TextBulletSizePoint AddNewBuSzPts()
1542
        {
1543
            this.buSzPtsField = new CT_TextBulletSizePoint();
1544
            return this.buSzPtsField;
1545
        }
1546

1547
        public bool IsSetIndent()
1548
        {
1549
            return this.indentFieldSpecified;
1550
        }
1551

1552
        public void UnsetIndent()
1553
        {
1554
            this.indentFieldSpecified = false;
1555
        }
1556

1557
        public bool IsSetMarL()
1558
        {
1559
            return this.marLFieldSpecified;
1560
        }
1561

1562
        public void UnsetMarL()
1563
        {
1564
            this.marLFieldSpecified = false;
1565
        }
1566

1567
        public bool IsSetMarR()
1568
        {
1569
            return this.marRFieldSpecified;
1570
        }
1571

1572
        public void UnsetMarR()
1573
        {
1574
            this.marRFieldSpecified = false;
1575
        }
1576

1577
        public bool IsSetDefTabSz()
1578
        {
1579
            return this.defTabSzFieldSpecified;
1580
        }
1581

1582
        public bool IsSetTabLst()
1583
        {
1584
            return this.tabLstField != null;
1585
        }
1586

1587
        public CT_TextTabStopList AddNewTabLst()
1588
        {
1589
            this.tabLstField = new CT_TextTabStopList();
1590
            return this.tabLstField;
1591
        }
1592

1593
        public bool IsSetLnSpc()
1594
        {
1595
            return this.lnSpcField != null;
1596
        }
1597

1598
        public bool IsSetSpcBef()
1599
        {
1600
            return this.spcBefField != null;
1601
        }
1602

1603
        public bool IsSetSpcAft()
1604
        {
1605
            return this.spcAftField != null;
1606
        }
1607

1608
        public CT_TextAutonumberBullet AddNewBuAutoNum()
1609
        {
1610
            this.buAutoNumField = new CT_TextAutonumberBullet();
1611
            return this.buAutoNumField;
1612
        }
1613
    }
1614

1615

1616
    [Serializable]
1617
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1618
    public enum ST_TextAlignType
1619
    {
1620

1621
        /// <remarks/>
1622
        l,
1623

1624
        /// <remarks/>
1625
        ctr,
1626

1627
        /// <remarks/>
1628
        r,
1629

1630
        /// <remarks/>
1631
        just,
1632

1633
        /// <remarks/>
1634
        justLow,
1635

1636
        /// <remarks/>
1637
        dist,
1638

1639
        /// <remarks/>
1640
        thaiDist,
1641
    }
1642

1643

1644
    [Serializable]
1645
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1646
    public enum ST_TextFontAlignType
1647
    {
1648

1649
        /// <remarks/>
1650
        auto,
1651

1652
        /// <remarks/>
1653
        t,
1654

1655
        /// <remarks/>
1656
        ctr,
1657

1658
        /// <remarks/>
1659
        @base,
1660

1661
        /// <remarks/>
1662
        b,
1663
    }
1664

1665

1666
    [Serializable]
1667
    [DebuggerStepThrough]
1668
    [System.ComponentModel.DesignerCategoryAttribute("code")]
1669
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
1670
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
1671
    public class CT_TextField
1672
    {
1673

1674
        private CT_TextCharacterProperties rPrField;
1675

1676
        private CT_TextParagraphProperties pPrField;
1677

1678
        private string tField;
1679

1680
        private string idField;
1681

1682
        private string typeField;
1683
        public static CT_TextField Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1684
        {
1685
            if (node == null)
1686
                return null;
1687
            CT_TextField ctObj = new CT_TextField();
1688
            ctObj.t = XmlHelper.ReadString(node.Attributes["t"]);
1689
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
1690
            ctObj.type = XmlHelper.ReadString(node.Attributes["type"]);
1691
            foreach (XmlNode childNode in node.ChildNodes)
1692
            {
1693
                if (childNode.LocalName == "rPr")
1694
                    ctObj.rPr = CT_TextCharacterProperties.Parse(childNode, namespaceManager);
1695
                else if (childNode.LocalName == "pPr")
1696
                    ctObj.pPr = CT_TextParagraphProperties.Parse(childNode, namespaceManager);
1697
            }
1698
            return ctObj;
1699
        }
1700

1701

1702

1703
        internal void Write(StreamWriter sw, string nodeName)
1704
        {
1705
            sw.Write(string.Format("<a:{0}", nodeName));
1706
            XmlHelper.WriteAttribute(sw, "t", this.t);
1707
            XmlHelper.WriteAttribute(sw, "id", this.id);
1708
            XmlHelper.WriteAttribute(sw, "type", this.type);
1709
            sw.Write(">");
1710
            if (this.rPr != null)
1711
                this.rPr.Write(sw, "rPr");
1712
            if (this.pPr != null)
1713
                this.pPr.Write(sw, "pPr");
1714
            sw.Write(string.Format("</a:{0}>", nodeName));
1715
        }
1716

1717
        public CT_TextField()
1718
        {
1719
            //this.pPrField = new CT_TextParagraphProperties();
1720
            //this.rPrField = new CT_TextCharacterProperties();
1721
        }
1722

1723
        [XmlElement(Order = 0)]
1724
        public CT_TextCharacterProperties rPr
1725
        {
1726
            get
1727
            {
1728
                return this.rPrField;
1729
            }
1730
            set
1731
            {
1732
                this.rPrField = value;
1733
            }
1734
        }
1735

1736
        [XmlElement(Order = 1)]
1737
        public CT_TextParagraphProperties pPr
1738
        {
1739
            get
1740
            {
1741
                return this.pPrField;
1742
            }
1743
            set
1744
            {
1745
                this.pPrField = value;
1746
            }
1747
        }
1748

1749
        [XmlElement(Order = 2)]
1750
        public string t
1751
        {
1752
            get
1753
            {
1754
                return this.tField;
1755
            }
1756
            set
1757
            {
1758
                this.tField = value;
1759
            }
1760
        }
1761

1762
        [System.Xml.Serialization.XmlAttributeAttribute(DataType = "token")]
1763
        public string id
1764
        {
1765
            get
1766
            {
1767
                return this.idField;
1768
            }
1769
            set
1770
            {
1771
                this.idField = value;
1772
            }
1773
        }
1774

1775
        [XmlAttribute]
1776
        public string type
1777
        {
1778
            get
1779
            {
1780
                return this.typeField;
1781
            }
1782
            set
1783
            {
1784
                this.typeField = value;
1785
            }
1786
        }
1787
    }
1788
}
1789