npoi

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

10
namespace NPOI.OpenXmlFormats.Wordprocessing
11
{
12
    [Serializable]
13
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
14
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
15
    public class CT_P
16
    {
17

18
        private CT_PPr pPrField;
19

20
        private ArrayList itemsField;
21

22
        private List<ParagraphItemsChoiceType> itemsElementNameField;
23

24
        private byte[] rsidRPrField;
25

26
        private byte[] rsidRField;
27

28
        private byte[] rsidDelField;
29

30
        private byte[] rsidPField;
31

32
        private byte[] rsidRDefaultField;
33
        private byte[] paraIdField;
34
        private byte[] textIdField;
35

36
        public CT_P()
37
        {
38
            this.itemsElementNameField = new List<ParagraphItemsChoiceType>();
39
            this.itemsField = new ArrayList();
40
            this.pPrField = new CT_PPr();
41
        }
42

43
        [XmlElement(Order = 0)]
44
        public CT_PPr pPr
45
        {
46
            get
47
            {
48
                return this.pPrField;
49
            }
50
            set
51
            {
52
                this.pPrField = value;
53
            }
54
        }
55

56
        public bool IsSetPPr()
57
        {
58
            return this.pPrField != null;
59
        }
60

61
        public static CT_P Parse(XmlNode node, XmlNamespaceManager namespaceManager)
62
        {
63
            if (node == null)
64
                return null;
65
            CT_P ctObj = new CT_P();
66
            if(node.Attributes["w14:paraId"] !=null)
67
                ctObj.paraIdField = XmlHelper.ReadBytes(node.Attributes["w14:paraId"]);
68
            if (node.Attributes["w14:textId"] != null)
69
                ctObj.textIdField = XmlHelper.ReadBytes(node.Attributes["w14:textId"]);
70
            ctObj.rsidRPr = XmlHelper.ReadBytes(node.Attributes["w:rsidRPr"]);
71
            ctObj.rsidR = XmlHelper.ReadBytes(node.Attributes["w:rsidR"]);
72
            ctObj.rsidDel = XmlHelper.ReadBytes(node.Attributes["w:rsidDel"]);
73
            ctObj.rsidP = XmlHelper.ReadBytes(node.Attributes["w:rsidP"]);
74
            ctObj.rsidRDefault = XmlHelper.ReadBytes(node.Attributes["w:rsidRDefault"]);
75

76
            foreach (XmlNode childNode in node.ChildNodes)
77
            {
78
                if (childNode.LocalName == "pPr")
79
                {
80
                    ctObj.pPr = CT_PPr.Parse(childNode, namespaceManager);
81
                }
82
                else if (childNode.LocalName == "bookmarkEnd")
83
                {
84
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
85
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.bookmarkEnd);
86
                }
87
                else if (childNode.LocalName == "moveFromRangeStart")
88
                {
89
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
90
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.moveFromRangeStart);
91
                }
92
                else if (childNode.LocalName == "moveTo")
93
                {
94
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
95
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.moveTo);
96
                }
97
                else if (childNode.LocalName == "oMathPara")
98
                {
99
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
100
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.oMathPara);
101
                }
102
                else if (childNode.LocalName == "oMath")
103
                {
104
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
105
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.oMath);
106
                }
107
                else if (childNode.LocalName == "bookmarkStart")
108
                {
109
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
110
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.bookmarkStart);
111
                }
112
                else if (childNode.LocalName == "commentRangeEnd")
113
                {
114
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
115
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.commentRangeEnd);
116
                }
117
                else if (childNode.LocalName == "commentRangeStart")
118
                {
119
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
120
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.commentRangeStart);
121
                }
122
                else if (childNode.LocalName == "customXml")
123
                {
124
                    ctObj.Items.Add(CT_CustomXmlRun.Parse(childNode, namespaceManager));
125
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXml);
126
                }
127
                else if (childNode.LocalName == "customXmlDelRangeEnd")
128
                {
129
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
130
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXmlDelRangeEnd);
131
                }
132
                else if (childNode.LocalName == "customXmlDelRangeStart")
133
                {
134
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
135
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXmlDelRangeStart);
136
                }
137
                else if (childNode.LocalName == "customXmlInsRangeEnd")
138
                {
139
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
140
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXmlInsRangeEnd);
141
                }
142
                else if (childNode.LocalName == "customXmlInsRangeStart")
143
                {
144
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
145
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXmlInsRangeStart);
146
                }
147
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
148
                {
149
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
150
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXmlMoveFromRangeEnd);
151
                }
152
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
153
                {
154
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
155
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXmlMoveFromRangeStart);
156
                }
157
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
158
                {
159
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
160
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXmlMoveToRangeEnd);
161
                }
162
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
163
                {
164
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
165
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.customXmlMoveToRangeStart);
166
                }
167
                else if (childNode.LocalName == "del")
168
                {
169
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
170
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.del);
171
                }
172
                else if (childNode.LocalName == "fldSimple")
173
                {
174
                    ctObj.Items.Add(CT_SimpleField.Parse(childNode, namespaceManager));
175
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.fldSimple);
176
                }
177
                else if (childNode.LocalName == "hyperlink")
178
                {
179
                    ctObj.Items.Add(CT_Hyperlink1.Parse(childNode, namespaceManager));
180
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.hyperlink);
181
                }
182
                else if (childNode.LocalName == "ins")
183
                {
184
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
185
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.ins);
186
                }
187
                else if (childNode.LocalName == "moveFrom")
188
                {
189
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
190
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.moveFrom);
191
                }
192
                else if (childNode.LocalName == "moveFromRangeEnd")
193
                {
194
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
195
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.moveFromRangeEnd);
196
                }
197
                else if (childNode.LocalName == "moveToRangeEnd")
198
                {
199
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
200
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.moveToRangeEnd);
201
                }
202
                else if (childNode.LocalName == "moveToRangeStart")
203
                {
204
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
205
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.moveToRangeStart);
206
                }
207
                else if (childNode.LocalName == "permEnd")
208
                {
209
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
210
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.permEnd);
211
                }
212
                else if (childNode.LocalName == "permStart")
213
                {
214
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
215
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.permStart);
216
                }
217
                else if (childNode.LocalName == "proofErr")
218
                {
219
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
220
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.proofErr);
221
                }
222
                else if (childNode.LocalName == "r")
223
                {
224
                    ctObj.Items.Add(CT_R.Parse(childNode, namespaceManager));
225
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.r);
226
                }
227
                else if (childNode.LocalName == "sdt")
228
                {
229
                    ctObj.Items.Add(CT_SdtRun.Parse(childNode, namespaceManager));
230
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.sdt);
231
                }
232
                else if (childNode.LocalName == "smartTag")
233
                {
234
                    ctObj.Items.Add(CT_SmartTagRun.Parse(childNode, namespaceManager));
235
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.smartTag);
236
                }
237
                else if (childNode.LocalName == "subDoc")
238
                {
239
                    ctObj.Items.Add(CT_Rel.Parse(childNode, namespaceManager));
240
                    ctObj.ItemsElementName.Add(ParagraphItemsChoiceType.subDoc);
241
                }
242
            }
243
            return ctObj;
244
        }
245

246
        public bool IsSetRsidR()
247
        {
248
            return this.rsidRField != null && rsidRField.Length > 0;
249
        }
250

251
        internal void Write(StreamWriter sw, string nodeName)
252
        {
253
            sw.Write(string.Format("<w:{0}", nodeName));
254
            XmlHelper.WriteAttribute(sw, "w14:paraId", this.paraIdField);
255
            XmlHelper.WriteAttribute(sw, "w14:textId", this.textIdField);
256
            XmlHelper.WriteAttribute(sw, "w:rsidR", this.rsidR);
257
            XmlHelper.WriteAttribute(sw, "w:rsidRPr", this.rsidRPr);
258
            XmlHelper.WriteAttribute(sw, "w:rsidRDefault", this.rsidRDefault);
259
            XmlHelper.WriteAttribute(sw, "w:rsidP", this.rsidP);
260
            XmlHelper.WriteAttribute(sw, "w:rsidDel", this.rsidDel);
261
            sw.Write(">");
262
            if (this.pPr != null&&!this.pPr.IsEmpty)
263
                this.pPr.Write(sw, "pPr");
264

265
            int i = 0;
266
            foreach (object o in this.Items)
267
            {
268
                if (o is CT_MarkupRange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.bookmarkEnd)
269
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
270
                else if (o is CT_MoveBookmark && this.itemsElementNameField[i] == ParagraphItemsChoiceType.moveFromRangeStart)
271
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
272
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.moveTo)
273
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
274
                else if (o is CT_OMathPara)
275
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
276
                else if (o is CT_OMath)
277
                    ((CT_OMath)o).Write(sw, "oMath");
278
                else if (o is CT_Bookmark && this.itemsElementNameField[i] == ParagraphItemsChoiceType.bookmarkStart)
279
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
280
                else if (o is CT_MarkupRange&& this.itemsElementNameField[i] == ParagraphItemsChoiceType.commentRangeEnd)
281
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
282
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.commentRangeStart)
283
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
284
                else if (o is CT_CustomXmlRun)
285
                    ((CT_CustomXmlRun)o).Write(sw, "customXml");
286
                else if (o is CT_Markup && this.itemsElementNameField[i] == ParagraphItemsChoiceType.customXmlDelRangeEnd)
287
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
288
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.customXmlDelRangeStart)
289
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
290
                else if (o is CT_Markup && this.itemsElementNameField[i] == ParagraphItemsChoiceType.customXmlInsRangeEnd)
291
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
292
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.customXmlInsRangeStart)
293
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
294
                else if (o is CT_Markup && this.itemsElementNameField[i] == ParagraphItemsChoiceType.customXmlMoveFromRangeEnd)
295
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
296
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.customXmlMoveFromRangeStart)
297
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
298
                else if (o is CT_Markup && this.itemsElementNameField[i] == ParagraphItemsChoiceType.customXmlMoveToRangeEnd)
299
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
300
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.customXmlMoveToRangeStart)
301
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
302
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.del)
303
                    ((CT_RunTrackChange)o).Write(sw, "del");
304
                else if (o is CT_SimpleField)
305
                    ((CT_SimpleField)o).Write(sw, "fldSimple");
306
                else if (o is CT_Hyperlink1)
307
                    ((CT_Hyperlink1)o).Write(sw, "hyperlink");
308
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.ins)
309
                    ((CT_RunTrackChange)o).Write(sw, "ins");
310
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.moveFrom)
311
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
312
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.moveFromRangeEnd)
313
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
314
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ParagraphItemsChoiceType.moveToRangeEnd)
315
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
316
                else if (o is CT_MoveBookmark && this.itemsElementNameField[i] == ParagraphItemsChoiceType.moveToRangeStart)
317
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
318
                else if (o is CT_Perm)
319
                    ((CT_Perm)o).Write(sw, "permEnd");
320
                else if (o is CT_PermStart)
321
                    ((CT_PermStart)o).Write(sw, "permStart");
322
                else if (o is CT_ProofErr)
323
                    ((CT_ProofErr)o).Write(sw, "proofErr");
324
                else if (o is CT_R)
325
                    ((CT_R)o).Write(sw, "r");
326
                else if (o is CT_SdtRun)
327
                    ((CT_SdtRun)o).Write(sw, "sdt");
328
                else if (o is CT_SmartTagRun)
329
                    ((CT_SmartTagRun)o).Write(sw, "smartTag");
330
                else if (o is CT_Rel)
331
                    ((CT_Rel)o).Write(sw, "subDoc");
332
                i++;
333
            }
334
            sw.WriteEndW(nodeName);
335
        }
336

337
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
338
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
339
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 1)]
340
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 1)]
341
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 1)]
342
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 1)]
343
        [XmlElement("customXml", typeof(CT_CustomXmlRun), Order = 1)]
344
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 1)]
345
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 1)]
346
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 1)]
347
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 1)]
348
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 1)]
349
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 1)]
350
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 1)]
351
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 1)]
352
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 1)]
353
        [XmlElement("fldSimple", typeof(CT_SimpleField), Order = 1)]
354
        [XmlElement("hyperlink", typeof(CT_Hyperlink1), Order = 1)]
355
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 1)]
356
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 1)]
357
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 1)]
358
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 1)]
359
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 1)]
360
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 1)]
361
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 1)]
362
        [XmlElement("permEnd", typeof(CT_Perm), Order = 1)]
363
        [XmlElement("permStart", typeof(CT_PermStart), Order = 1)]
364
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 1)]
365
        [XmlElement("r", typeof(CT_R), Order = 1)]
366
        [XmlElement("sdt", typeof(CT_SdtRun), Order = 1)]
367
        [XmlElement("smartTag", typeof(CT_SmartTagRun), Order = 1)]
368
        [XmlElement("subDoc", typeof(CT_Rel), Order = 1)]
369
        [XmlChoiceIdentifier("ItemsElementName")]
370
        public ArrayList Items
371
        {
372
            get
373
            {
374
                return this.itemsField;
375
            }
376
            set
377
            {
378
                this.itemsField = value;
379
            }
380
        }
381

382
        [XmlElement("ItemsElementName", Order = 2)]
383
        [XmlIgnore]
384
        public List<ParagraphItemsChoiceType> ItemsElementName
385
        {
386
            get
387
            {
388
                return this.itemsElementNameField;
389
            }
390
            set
391
            {
392
                this.itemsElementNameField = value;
393
            }
394
        }
395

396
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
397
        public byte[] rsidRPr
398
        {
399
            get
400
            {
401
                return this.rsidRPrField;
402
            }
403
            set
404
            {
405
                this.rsidRPrField = value;
406
            }
407
        }
408

409
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
410
        public byte[] rsidR
411
        {
412
            get
413
            {
414
                return this.rsidRField;
415
            }
416
            set
417
            {
418
                this.rsidRField = value;
419
            }
420
        }
421

422
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
423
        public byte[] rsidDel
424
        {
425
            get
426
            {
427
                return this.rsidDelField;
428
            }
429
            set
430
            {
431
                this.rsidDelField = value;
432
            }
433
        }
434

435
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
436
        public byte[] rsidP
437
        {
438
            get
439
            {
440
                return this.rsidPField;
441
            }
442
            set
443
            {
444
                this.rsidPField = value;
445
            }
446
        }
447

448
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
449
        public byte[] rsidRDefault
450
        {
451
            get
452
            {
453
                return this.rsidRDefaultField;
454
            }
455
            set
456
            {
457
                this.rsidRDefaultField = value;
458
            }
459
        }
460

461
        public CT_PPr AddNewPPr()
462
        {
463
            if (this.pPrField == null)
464
                this.pPrField = new CT_PPr();
465
            return this.pPrField;
466
        }
467

468
        #region Generic methods for object operation
469

470
        private List<T> GetObjectList<T>(ParagraphItemsChoiceType type) where T : class
471
        {
472
            lock (this)
473
            {
474
                List<T> list = new List<T>();
475
                for (int i = 0; i < itemsElementNameField.Count; i++)
476
                {
477
                    if (itemsElementNameField[i] == type)
478
                        list.Add(itemsField[i] as T);
479
                }
480
                return list;
481
            }
482
        }
483
        private int SizeOfArray(ParagraphItemsChoiceType type)
484
        {
485
            lock (this)
486
            {
487
                int size = 0;
488
                for (int i = 0; i < itemsElementNameField.Count; i++)
489
                {
490
                    if (itemsElementNameField[i] == type)
491
                        size++;
492
                }
493
                return size;
494
            }
495
        }
496
        private T GetObjectArray<T>(int p, ParagraphItemsChoiceType type) where T : class
497
        {
498
            lock (this)
499
            {
500
                int pos = GetObjectIndex(type, p);
501
                if (pos < 0 || pos >= this.itemsField.Count)
502
                    return null;
503
                return itemsField[pos] as T;
504
            }
505
        }
506
        private T InsertNewObject<T>(ParagraphItemsChoiceType type, int p) where T : class, new()
507
        {
508
            T t = new T();
509
            lock (this)
510
            {
511
                int pos = GetObjectIndex(type, p);
512
                if (pos == -1)
513
                    pos = 0;
514
                this.itemsElementNameField.Insert(pos, type);
515
                this.itemsField.Insert(pos, t);
516
            }
517
            return t;
518
        }
519
        private T AddNewObject<T>(ParagraphItemsChoiceType type) where T : class, new()
520
        {
521
            T t = new T();
522
            lock (this)
523
            {
524
                this.itemsElementNameField.Add(type);
525
                this.itemsField.Add(t);
526
            }
527
            return t;
528
        }
529
        private void SetObject<T>(ParagraphItemsChoiceType type, int p, T obj) where T : class
530
        {
531
            lock (this)
532
            {
533
                int pos = GetObjectIndex(type, p);
534
                if (pos < 0 || pos >= this.itemsField.Count)
535
                    return;
536
                if (this.itemsField[pos] is T)
537
                    this.itemsField[pos] = obj;
538
                else
539
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
540
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
541
            }
542
        }
543
        private int GetObjectIndex(ParagraphItemsChoiceType type, int p)
544
        {
545
            int index = -1;
546
            int pos = 0;
547
            for (int i = 0; i < itemsElementNameField.Count; i++)
548
            {
549
                if (itemsElementNameField[i] == type)
550
                {
551
                    if (pos == p)
552
                    {
553
                        //return itemsField[p] as T;
554
                        index = i;
555
                        break;
556
                    }
557
                    else
558
                        pos++;
559
                }
560
            }
561
            return index;
562
        }
563
        private void RemoveObject(ParagraphItemsChoiceType type, int p)
564
        {
565
            lock (this)
566
            {
567
                int pos = GetObjectIndex(type, p);
568
                if (pos < 0 || pos >= this.itemsField.Count)
569
                    return;
570
                itemsElementNameField.RemoveAt(pos);
571
                itemsField.RemoveAt(pos);
572
            }
573
        }
574
        #endregion
575

576
        #pragma warning disable format
577
        public CT_MarkupRange      AddNewBookmarkEnd()                     { return AddNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.bookmarkEnd); }
578
        public CT_Bookmark         AddNewBookmarkStart()                   { return AddNewObject<CT_Bookmark>      (ParagraphItemsChoiceType.bookmarkStart); }
579
        public CT_MarkupRange      AddNewCommentRangeEnd()                 { return AddNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.commentRangeEnd); }
580
        public CT_MarkupRange      AddNewCommentRangeStart()               { return AddNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.commentRangeStart); }
581
        public CT_CustomXmlRun     AddNewCustomXml()                       { return AddNewObject<CT_CustomXmlRun>  (ParagraphItemsChoiceType.customXml); }
582
        public CT_Markup           AddNewCustomXmlDelRangeEnd()            { return AddNewObject<CT_Markup>        (ParagraphItemsChoiceType.customXmlDelRangeEnd); }
583
        public CT_TrackChange      AddNewCustomXmlDelRangeStart()          { return AddNewObject<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlDelRangeStart); }
584
        public CT_Markup           AddNewCustomXmlInsRangeEnd()            { return AddNewObject<CT_Markup>        (ParagraphItemsChoiceType.customXmlInsRangeEnd); }
585
        public CT_TrackChange      AddNewCustomXmlInsRangeStart()          { return AddNewObject<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlInsRangeStart); }
586
        public CT_Markup           AddNewCustomXmlMoveFromRangeEnd()       { return AddNewObject<CT_Markup>        (ParagraphItemsChoiceType.customXmlMoveFromRangeEnd); }
587
        public CT_TrackChange      AddNewCustomXmlMoveFromRangeStart()     { return AddNewObject<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlMoveFromRangeStart); }
588
        public CT_Markup           AddNewCustomXmlMoveToRangeEnd()         { return AddNewObject<CT_Markup>        (ParagraphItemsChoiceType.customXmlMoveToRangeEnd); }
589
        public CT_TrackChange      AddNewCustomXmlMoveToRangeStart()       { return AddNewObject<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlMoveToRangeStart); }
590
        public CT_RunTrackChange   AddNewDel()                             { return AddNewObject<CT_RunTrackChange>(ParagraphItemsChoiceType.del); }
591
        public CT_SimpleField      AddNewFldSimple()                       { return AddNewObject<CT_SimpleField>   (ParagraphItemsChoiceType.fldSimple); }
592
        public CT_Hyperlink1       AddNewHyperlink()                       { return AddNewObject<CT_Hyperlink1>    (ParagraphItemsChoiceType.hyperlink); }
593
        public CT_RunTrackChange   AddNewIns()                             { return AddNewObject<CT_RunTrackChange>(ParagraphItemsChoiceType.ins); }
594
        public CT_RunTrackChange   AddNewMoveFrom()                        { return AddNewObject<CT_RunTrackChange>(ParagraphItemsChoiceType.moveFrom); }
595
        public CT_MarkupRange      AddNewMoveFromRangeEnd()                { return AddNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.moveFromRangeEnd); }
596
        public CT_MoveBookmark     AddNewMoveFromRangeStart()              { return AddNewObject<CT_MoveBookmark>  (ParagraphItemsChoiceType.moveFromRangeStart); }
597
        public CT_RunTrackChange   AddNewMoveTo()                          { return AddNewObject<CT_RunTrackChange>(ParagraphItemsChoiceType.moveTo); }
598
        public CT_MarkupRange      AddNewMoveToRangeEnd()                  { return AddNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.moveToRangeEnd); }
599
        public CT_MoveBookmark     AddNewMoveToRangeStart()                { return AddNewObject<CT_MoveBookmark>  (ParagraphItemsChoiceType.moveToRangeStart); }
600
        public CT_OMath            AddNewOMath()                           { return AddNewObject<CT_OMath>         (ParagraphItemsChoiceType.oMath); }
601
        public CT_OMathPara        AddNewOMathPara()                       { return AddNewObject<CT_OMathPara>     (ParagraphItemsChoiceType.oMathPara); }
602
        public CT_Perm             AddNewPermEnd()                         { return AddNewObject<CT_Perm>          (ParagraphItemsChoiceType.permEnd); }
603
        public CT_PermStart        AddNewPermStart()                       { return AddNewObject<CT_PermStart>     (ParagraphItemsChoiceType.permStart); }
604
        public CT_ProofErr         AddNewProofErr()                        { return AddNewObject<CT_ProofErr>      (ParagraphItemsChoiceType.proofErr); }
605
        public CT_R                AddNewR()                               { return AddNewObject<CT_R>             (ParagraphItemsChoiceType.r); }
606
        public CT_SdtRun           AddNewSdt()                             { return AddNewObject<CT_SdtRun>        (ParagraphItemsChoiceType.sdt); }
607
        public CT_SmartTagRun      AddNewSmartTag()                        { return AddNewObject<CT_SmartTagRun>   (ParagraphItemsChoiceType.smartTag); }
608
        public CT_Rel              AddNewSubDoc()                          { return AddNewObject<CT_Rel>           (ParagraphItemsChoiceType.subDoc); }
609

610
        public CT_MarkupRange      GetBookmarkEndArray(int p)                     { return GetObjectArray<CT_MarkupRange>   (p, ParagraphItemsChoiceType.bookmarkEnd); }
611
        public CT_Bookmark         GetBookmarkStartArray(int p)                   { return GetObjectArray<CT_Bookmark>      (p, ParagraphItemsChoiceType.bookmarkStart); }
612
        public CT_MarkupRange      GetCommentRangeEndArray(int p)                 { return GetObjectArray<CT_MarkupRange>   (p, ParagraphItemsChoiceType.commentRangeEnd); }
613
        public CT_MarkupRange      GetCommentRangeStartArray(int p)               { return GetObjectArray<CT_MarkupRange>   (p, ParagraphItemsChoiceType.commentRangeStart); }
614
        public CT_CustomXmlRun     GetCustomXmlArray(int p)                       { return GetObjectArray<CT_CustomXmlRun>  (p, ParagraphItemsChoiceType.customXml); }
615
        public CT_Markup           GetCustomXmlDelRangeEndArray(int p)            { return GetObjectArray<CT_Markup>        (p, ParagraphItemsChoiceType.customXmlDelRangeEnd); }
616
        public CT_TrackChange      GetCustomXmlDelRangeStartArray(int p)          { return GetObjectArray<CT_TrackChange>   (p, ParagraphItemsChoiceType.customXmlDelRangeStart); }
617
        public CT_Markup           GetCustomXmlInsRangeEndArray(int p)            { return GetObjectArray<CT_Markup>        (p, ParagraphItemsChoiceType.customXmlInsRangeEnd); }
618
        public CT_TrackChange      GetCustomXmlInsRangeStartArray(int p)          { return GetObjectArray<CT_TrackChange>   (p, ParagraphItemsChoiceType.customXmlInsRangeStart); }
619
        public CT_Markup           GetCustomXmlMoveFromRangeEndArray(int p)       { return GetObjectArray<CT_Markup>        (p, ParagraphItemsChoiceType.customXmlMoveFromRangeEnd); }
620
        public CT_TrackChange      GetCustomXmlMoveFromRangeStartArray(int p)     { return GetObjectArray<CT_TrackChange>   (p, ParagraphItemsChoiceType.customXmlMoveFromRangeStart); }
621
        public CT_Markup           GetCustomXmlMoveToRangeEndArray(int p)         { return GetObjectArray<CT_Markup>        (p, ParagraphItemsChoiceType.customXmlMoveToRangeEnd); }
622
        public CT_TrackChange      GetCustomXmlMoveToRangeStartArray(int p)       { return GetObjectArray<CT_TrackChange>   (p, ParagraphItemsChoiceType.customXmlMoveToRangeStart); }
623
        public CT_RunTrackChange   GetDelArray(int p)                             { return GetObjectArray<CT_RunTrackChange>(p, ParagraphItemsChoiceType.del); }
624
        public CT_SimpleField      GetFldSimpleArray(int p)                       { return GetObjectArray<CT_SimpleField>   (p, ParagraphItemsChoiceType.fldSimple); }
625
        public CT_Hyperlink1       GetHyperlinkArray(int p)                       { return GetObjectArray<CT_Hyperlink1>    (p, ParagraphItemsChoiceType.hyperlink); }
626
        public CT_RunTrackChange   GetInsArray(int p)                             { return GetObjectArray<CT_RunTrackChange>(p, ParagraphItemsChoiceType.ins); }
627
        public CT_RunTrackChange   GetMoveFromArray(int p)                        { return GetObjectArray<CT_RunTrackChange>(p, ParagraphItemsChoiceType.moveFrom); }
628
        public CT_MarkupRange      GetMoveFromRangeEndArray(int p)                { return GetObjectArray<CT_MarkupRange>   (p, ParagraphItemsChoiceType.moveFromRangeEnd); }
629
        public CT_MoveBookmark     GetMoveFromRangeStartArray(int p)              { return GetObjectArray<CT_MoveBookmark>  (p, ParagraphItemsChoiceType.moveFromRangeStart); }
630
        public CT_RunTrackChange   GetMoveToArray(int p)                          { return GetObjectArray<CT_RunTrackChange>(p, ParagraphItemsChoiceType.moveTo); }
631
        public CT_MarkupRange      GetMoveToRangeEndArray(int p)                  { return GetObjectArray<CT_MarkupRange>   (p, ParagraphItemsChoiceType.moveToRangeEnd); }
632
        public CT_MoveBookmark     GetMoveToRangeStartArray(int p)                { return GetObjectArray<CT_MoveBookmark>  (p, ParagraphItemsChoiceType.moveToRangeStart); }
633
        public CT_OMath            GetOMathArray(int p)                           { return GetObjectArray<CT_OMath>         (p, ParagraphItemsChoiceType.oMath); }
634
        public CT_OMathPara        GetOMathParaArray(int p)                       { return GetObjectArray<CT_OMathPara>     (p, ParagraphItemsChoiceType.oMathPara); }
635
        public CT_Perm             GetPermEndArray(int p)                         { return GetObjectArray<CT_Perm>          (p, ParagraphItemsChoiceType.permEnd); }
636
        public CT_PermStart        GetPermStartArray(int p)                       { return GetObjectArray<CT_PermStart>     (p, ParagraphItemsChoiceType.permStart); }
637
        public CT_ProofErr         GetProofErrArray(int p)                        { return GetObjectArray<CT_ProofErr>      (p, ParagraphItemsChoiceType.proofErr); }
638
        public CT_R                GetRArray(int p)                               { return GetObjectArray<CT_R>             (p, ParagraphItemsChoiceType.r); }
639
        public CT_SdtRun           GetSdtArray(int p)                             { return GetObjectArray<CT_SdtRun>        (p, ParagraphItemsChoiceType.sdt); }
640
        public CT_SmartTagRun      GetSmartTagArray(int p)                        { return GetObjectArray<CT_SmartTagRun>   (p, ParagraphItemsChoiceType.smartTag); }
641
        public CT_Rel              GetSubDocArray(int p)                          { return GetObjectArray<CT_Rel>           (p, ParagraphItemsChoiceType.subDoc); }
642

643
        public IList<CT_MarkupRange>      GetBookmarkEndList()                     { return GetObjectList<CT_MarkupRange>   (ParagraphItemsChoiceType.bookmarkEnd); }
644
        public IList<CT_Bookmark>         GetBookmarkStartList()                   { return GetObjectList<CT_Bookmark>      (ParagraphItemsChoiceType.bookmarkStart); }
645
        public IList<CT_MarkupRange>      GetCommentRangeEndList()                 { return GetObjectList<CT_MarkupRange>   (ParagraphItemsChoiceType.commentRangeEnd); }
646
        public IList<CT_MarkupRange>      GetCommentRangeStartList()               { return GetObjectList<CT_MarkupRange>   (ParagraphItemsChoiceType.commentRangeStart); }
647
        public IList<CT_CustomXmlRun>     GetCustomXmlList()                       { return GetObjectList<CT_CustomXmlRun>  (ParagraphItemsChoiceType.customXml); }
648
        public IList<CT_Markup>           GetCustomXmlDelRangeEndList()            { return GetObjectList<CT_Markup>        (ParagraphItemsChoiceType.customXmlDelRangeEnd); }
649
        public IList<CT_TrackChange>      GetCustomXmlDelRangeStartList()          { return GetObjectList<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlDelRangeStart); }
650
        public IList<CT_Markup>           GetCustomXmlInsRangeEndList()            { return GetObjectList<CT_Markup>        (ParagraphItemsChoiceType.customXmlInsRangeEnd); }
651
        public IList<CT_TrackChange>      GetCustomXmlInsRangeStartList()          { return GetObjectList<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlInsRangeStart); }
652
        public IList<CT_Markup>           GetCustomXmlMoveFromRangeEndList()       { return GetObjectList<CT_Markup>        (ParagraphItemsChoiceType.customXmlMoveFromRangeEnd); }
653
        public IList<CT_TrackChange>      GetCustomXmlMoveFromRangeStartList()     { return GetObjectList<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlMoveFromRangeStart); }
654
        public IList<CT_Markup>           GetCustomXmlMoveToRangeEndList()         { return GetObjectList<CT_Markup>        (ParagraphItemsChoiceType.customXmlMoveToRangeEnd); }
655
        public IList<CT_TrackChange>      GetCustomXmlMoveToRangeStartList()       { return GetObjectList<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlMoveToRangeStart); }
656
        public IList<CT_RunTrackChange>   GetDelList()                             { return GetObjectList<CT_RunTrackChange>(ParagraphItemsChoiceType.del); }
657
        public IList<CT_SimpleField>      GetFldSimpleList()                       { return GetObjectList<CT_SimpleField>   (ParagraphItemsChoiceType.fldSimple); }
658
        public IList<CT_Hyperlink1>       GetHyperlinkList()                       { return GetObjectList<CT_Hyperlink1>    (ParagraphItemsChoiceType.hyperlink); }
659
        public IList<CT_RunTrackChange>   GetInsList()                             { return GetObjectList<CT_RunTrackChange>(ParagraphItemsChoiceType.ins); }
660
        public IList<CT_RunTrackChange>   GetMoveFromList()                        { return GetObjectList<CT_RunTrackChange>(ParagraphItemsChoiceType.moveFrom); }
661
        public IList<CT_MarkupRange>      GetMoveFromRangeEndList()                { return GetObjectList<CT_MarkupRange>   (ParagraphItemsChoiceType.moveFromRangeEnd); }
662
        public IList<CT_MoveBookmark>     GetMoveFromRangeStartList()              { return GetObjectList<CT_MoveBookmark>  (ParagraphItemsChoiceType.moveFromRangeStart); }
663
        public IList<CT_RunTrackChange>   GetMoveToList()                          { return GetObjectList<CT_RunTrackChange>(ParagraphItemsChoiceType.moveTo); }
664
        public IList<CT_MarkupRange>      GetMoveToRangeEndList()                  { return GetObjectList<CT_MarkupRange>   (ParagraphItemsChoiceType.moveToRangeEnd); }
665
        public IList<CT_MoveBookmark>     GetMoveToRangeStartList()                { return GetObjectList<CT_MoveBookmark>  (ParagraphItemsChoiceType.moveToRangeStart); }
666
        public IList<CT_OMath>            GetOMathList()                           { return GetObjectList<CT_OMath>         (ParagraphItemsChoiceType.oMath); }
667
        public IList<CT_OMathPara>        GetOMathParaList()                       { return GetObjectList<CT_OMathPara>     (ParagraphItemsChoiceType.oMathPara); }
668
        public IList<CT_Perm>             GetPermEndList()                         { return GetObjectList<CT_Perm>          (ParagraphItemsChoiceType.permEnd); }
669
        public IList<CT_PermStart>        GetPermStartList()                       { return GetObjectList<CT_PermStart>     (ParagraphItemsChoiceType.permStart); }
670
        public IList<CT_ProofErr>         GetProofErrList()                        { return GetObjectList<CT_ProofErr>      (ParagraphItemsChoiceType.proofErr); }
671
        public IList<CT_R>                GetRList()                               { return GetObjectList<CT_R>             (ParagraphItemsChoiceType.r); }
672
        public IList<CT_SdtRun>           GetSdtList()                             { return GetObjectList<CT_SdtRun>        (ParagraphItemsChoiceType.sdt); }
673
        public IList<CT_SmartTagRun>      GetSmartTagList()                        { return GetObjectList<CT_SmartTagRun>   (ParagraphItemsChoiceType.smartTag); }
674
        public IList<CT_Rel>              GetSubDocList()                          { return GetObjectList<CT_Rel>           (ParagraphItemsChoiceType.subDoc); }
675

676
        public CT_MarkupRange      InsertNewBookmarkEnd(int p)                     { return InsertNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.bookmarkEnd, p); }
677
        public CT_Bookmark         InsertNewBookmarkStart(int p)                   { return InsertNewObject<CT_Bookmark>      (ParagraphItemsChoiceType.bookmarkStart, p); }
678
        public CT_MarkupRange      InsertNewCommentRangeEnd(int p)                 { return InsertNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.commentRangeEnd, p); }
679
        public CT_MarkupRange      InsertNewCommentRangeStart(int p)               { return InsertNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.commentRangeStart, p); }
680
        public CT_CustomXmlRun     InsertNewCustomXml(int p)                       { return InsertNewObject<CT_CustomXmlRun>  (ParagraphItemsChoiceType.customXml, p); }
681
        public CT_Markup           InsertNewCustomXmlDelRangeEnd(int p)            { return InsertNewObject<CT_Markup>        (ParagraphItemsChoiceType.customXmlDelRangeEnd, p); }
682
        public CT_TrackChange      InsertNewCustomXmlDelRangeStart(int p)          { return InsertNewObject<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlDelRangeStart, p); }
683
        public CT_Markup           InsertNewCustomXmlInsRangeEnd(int p)            { return InsertNewObject<CT_Markup>        (ParagraphItemsChoiceType.customXmlInsRangeEnd, p); }
684
        public CT_TrackChange      InsertNewCustomXmlInsRangeStart(int p)          { return InsertNewObject<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlInsRangeStart, p); }
685
        public CT_Markup           InsertNewCustomXmlMoveFromRangeEnd(int p)       { return InsertNewObject<CT_Markup>        (ParagraphItemsChoiceType.customXmlMoveFromRangeEnd, p); }
686
        public CT_TrackChange      InsertNewCustomXmlMoveFromRangeStart(int p)     { return InsertNewObject<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlMoveFromRangeStart, p); }
687
        public CT_Markup           InsertNewCustomXmlMoveToRangeEnd(int p)         { return InsertNewObject<CT_Markup>        (ParagraphItemsChoiceType.customXmlMoveToRangeEnd, p); }
688
        public CT_TrackChange      InsertNewCustomXmlMoveToRangeStart(int p)       { return InsertNewObject<CT_TrackChange>   (ParagraphItemsChoiceType.customXmlMoveToRangeStart, p); }
689
        public CT_RunTrackChange   InsertNewDel(int p)                             { return InsertNewObject<CT_RunTrackChange>(ParagraphItemsChoiceType.del, p); }
690
        public CT_SimpleField      InsertNewFldSimple(int p)                       { return InsertNewObject<CT_SimpleField>   (ParagraphItemsChoiceType.fldSimple, p); }
691
        public CT_Hyperlink1       InsertNewHyperlink(int p)                       { return InsertNewObject<CT_Hyperlink1>    (ParagraphItemsChoiceType.hyperlink, p); }
692
        public CT_RunTrackChange   InsertNewIns(int p)                             { return InsertNewObject<CT_RunTrackChange>(ParagraphItemsChoiceType.ins, p); }
693
        public CT_RunTrackChange   InsertNewMoveFrom(int p)                        { return InsertNewObject<CT_RunTrackChange>(ParagraphItemsChoiceType.moveFrom, p); }
694
        public CT_MarkupRange      InsertNewMoveFromRangeEnd(int p)                { return InsertNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.moveFromRangeEnd, p); }
695
        public CT_MoveBookmark     InsertNewMoveFromRangeStart(int p)              { return InsertNewObject<CT_MoveBookmark>  (ParagraphItemsChoiceType.moveFromRangeStart, p); }
696
        public CT_RunTrackChange   InsertNewMoveTo(int p)                          { return InsertNewObject<CT_RunTrackChange>(ParagraphItemsChoiceType.moveTo, p); }
697
        public CT_MarkupRange      InsertNewMoveToRangeEnd(int p)                  { return InsertNewObject<CT_MarkupRange>   (ParagraphItemsChoiceType.moveToRangeEnd, p); }
698
        public CT_MoveBookmark     InsertNewMoveToRangeStart(int p)                { return InsertNewObject<CT_MoveBookmark>  (ParagraphItemsChoiceType.moveToRangeStart, p); }
699
        public CT_OMath            InsertNewOMath(int p)                           { return InsertNewObject<CT_OMath>         (ParagraphItemsChoiceType.oMath, p); }
700
        public CT_OMathPara        InsertNewOMathPara(int p)                       { return InsertNewObject<CT_OMathPara>     (ParagraphItemsChoiceType.oMathPara, p); }
701
        public CT_Perm             InsertNewPermEnd(int p)                         { return InsertNewObject<CT_Perm>          (ParagraphItemsChoiceType.permEnd, p); }
702
        public CT_PermStart        InsertNewPermStart(int p)                       { return InsertNewObject<CT_PermStart>     (ParagraphItemsChoiceType.permStart, p); }
703
        public CT_ProofErr         InsertNewProofErr(int p)                        { return InsertNewObject<CT_ProofErr>      (ParagraphItemsChoiceType.proofErr, p); }
704
        public CT_R                InsertNewR(int p)                               { return InsertNewObject<CT_R>             (ParagraphItemsChoiceType.r, p); }
705
        public CT_SdtRun           InsertNewSdt(int p)                             { return InsertNewObject<CT_SdtRun>        (ParagraphItemsChoiceType.sdt, p); }
706
        public CT_SmartTagRun      InsertNewSmartTag(int p)                        { return InsertNewObject<CT_SmartTagRun>   (ParagraphItemsChoiceType.smartTag, p); }
707
        public CT_Rel              InsertNewSubDoc(int p)                          { return InsertNewObject<CT_Rel>           (ParagraphItemsChoiceType.subDoc, p); }
708

709
        public void RemoveBookmarkEnd(int p)                     { RemoveObject(ParagraphItemsChoiceType.bookmarkEnd, p); }
710
        public void RemoveBookmarkStart(int p)                   { RemoveObject(ParagraphItemsChoiceType.bookmarkStart, p); }
711
        public void RemoveCommentRangeEnd(int p)                 { RemoveObject(ParagraphItemsChoiceType.commentRangeEnd, p); }
712
        public void RemoveCommentRangeStart(int p)               { RemoveObject(ParagraphItemsChoiceType.commentRangeStart, p); }
713
        public void RemoveCustomXml(int p)                       { RemoveObject(ParagraphItemsChoiceType.customXml, p); }
714
        public void RemoveCustomXmlDelRangeEnd(int p)            { RemoveObject(ParagraphItemsChoiceType.customXmlDelRangeEnd, p); }
715
        public void RemoveCustomXmlDelRangeStart(int p)          { RemoveObject(ParagraphItemsChoiceType.customXmlDelRangeStart, p); }
716
        public void RemoveCustomXmlInsRangeEnd(int p)            { RemoveObject(ParagraphItemsChoiceType.customXmlInsRangeEnd, p); }
717
        public void RemoveCustomXmlInsRangeStart(int p)          { RemoveObject(ParagraphItemsChoiceType.customXmlInsRangeStart, p); }
718
        public void RemoveCustomXmlMoveFromRangeEnd(int p)       { RemoveObject(ParagraphItemsChoiceType.customXmlMoveFromRangeEnd, p); }
719
        public void RemoveCustomXmlMoveFromRangeStart(int p)     { RemoveObject(ParagraphItemsChoiceType.customXmlMoveFromRangeStart, p); }
720
        public void RemoveCustomXmlMoveToRangeEnd(int p)         { RemoveObject(ParagraphItemsChoiceType.customXmlMoveToRangeEnd, p); }
721
        public void RemoveCustomXmlMoveToRangeStart(int p)       { RemoveObject(ParagraphItemsChoiceType.customXmlMoveToRangeStart, p); }
722
        public void RemoveDel(int p)                             { RemoveObject(ParagraphItemsChoiceType.del, p); }
723
        public void RemoveFldSimple(int p)                       { RemoveObject(ParagraphItemsChoiceType.fldSimple, p); }
724
        public void RemoveHyperlink(int p)                       { RemoveObject(ParagraphItemsChoiceType.hyperlink, p); }
725
        public void RemoveIns(int p)                             { RemoveObject(ParagraphItemsChoiceType.ins, p); }
726
        public void RemoveMoveFrom(int p)                        { RemoveObject(ParagraphItemsChoiceType.moveFrom, p); }
727
        public void RemoveMoveFromRangeEnd(int p)                { RemoveObject(ParagraphItemsChoiceType.moveFromRangeEnd, p); }
728
        public void RemoveMoveFromRangeStart(int p)              { RemoveObject(ParagraphItemsChoiceType.moveFromRangeStart, p); }
729
        public void RemoveMoveTo(int p)                          { RemoveObject(ParagraphItemsChoiceType.moveTo, p); }
730
        public void RemoveMoveToRangeEnd(int p)                  { RemoveObject(ParagraphItemsChoiceType.moveToRangeEnd, p); }
731
        public void RemoveMoveToRangeStart(int p)                { RemoveObject(ParagraphItemsChoiceType.moveToRangeStart, p); }
732
        public void RemoveOMath(int p)                           { RemoveObject(ParagraphItemsChoiceType.oMath, p); }
733
        public void RemoveOMathPara(int p)                       { RemoveObject(ParagraphItemsChoiceType.oMathPara, p); }
734
        public void RemovePermEnd(int p)                         { RemoveObject(ParagraphItemsChoiceType.permEnd, p); }
735
        public void RemovePermStart(int p)                       { RemoveObject(ParagraphItemsChoiceType.permStart, p); }
736
        public void RemoveProofErr(int p)                        { RemoveObject(ParagraphItemsChoiceType.proofErr, p); }
737
        public void RemoveR(int p)                               { RemoveObject(ParagraphItemsChoiceType.r, p); }
738
        public void RemoveSdt(int p)                             { RemoveObject(ParagraphItemsChoiceType.sdt, p); }
739
        public void RemoveSmartTag(int p)                        { RemoveObject(ParagraphItemsChoiceType.smartTag, p); }
740
        public void RemoveSubDoc(int p)                          { RemoveObject(ParagraphItemsChoiceType.subDoc, p); }
741

742
        public void SetBookmarkEndArray(int p, CT_MarkupRange obj)                 { SetObject(ParagraphItemsChoiceType.bookmarkEnd, p, obj); }
743
        public void SetBookmarkStartArray(int p, CT_Bookmark obj)                  { SetObject(ParagraphItemsChoiceType.bookmarkStart, p, obj); }
744
        public void SetCommentRangeEndArray(int p, CT_MarkupRange obj)             { SetObject(ParagraphItemsChoiceType.commentRangeEnd, p, obj); }
745
        public void SetCommentRangeStartArray(int p, CT_MarkupRange obj)           { SetObject(ParagraphItemsChoiceType.commentRangeStart, p, obj); }
746
        public void SetCustomXmlArray(int p, CT_CustomXmlRun obj)                  { SetObject(ParagraphItemsChoiceType.customXml, p, obj); }
747
        public void SetCustomXmlDelRangeEndArray(int p, CT_Markup obj)             { SetObject(ParagraphItemsChoiceType.customXmlDelRangeEnd, p, obj); }
748
        public void SetCustomXmlDelRangeStartArray(int p, CT_TrackChange obj)      { SetObject(ParagraphItemsChoiceType.customXmlDelRangeStart, p, obj); }
749
        public void SetCustomXmlInsRangeEndArray(int p, CT_Markup obj)             { SetObject(ParagraphItemsChoiceType.customXmlInsRangeEnd, p, obj); }
750
        public void SetCustomXmlInsRangeStartArray(int p, CT_TrackChange obj)      { SetObject(ParagraphItemsChoiceType.customXmlInsRangeStart, p, obj); }
751
        public void SetCustomXmlMoveFromRangeEndArray(int p, CT_Markup obj)        { SetObject(ParagraphItemsChoiceType.customXmlMoveFromRangeEnd, p, obj); }
752
        public void SetCustomXmlMoveFromRangeStartArray(int p, CT_TrackChange obj) { SetObject(ParagraphItemsChoiceType.customXmlMoveFromRangeStart, p, obj); }
753
        public void SetCustomXmlMoveToRangeEndArray(int p, CT_Markup obj)          { SetObject(ParagraphItemsChoiceType.customXmlMoveToRangeEnd, p, obj); }
754
        public void SetCustomXmlMoveToRangeStartArray(int p, CT_TrackChange obj)   { SetObject(ParagraphItemsChoiceType.customXmlMoveToRangeStart, p, obj); }
755
        public void SetDelArray(int p, CT_RunTrackChange obj)                      { SetObject(ParagraphItemsChoiceType.del, p, obj); }
756
        public void SetFldSimpleArray(int p, CT_SimpleField obj)                   { SetObject(ParagraphItemsChoiceType.fldSimple, p, obj); }
757
        public void SetHyperlinkArray(int p, CT_Hyperlink1 obj)                    { SetObject(ParagraphItemsChoiceType.hyperlink, p, obj); }
758
        public void SetInsArray(int p, CT_RunTrackChange obj)                      { SetObject(ParagraphItemsChoiceType.ins, p, obj); }
759
        public void SetMoveFromArray(int p, CT_RunTrackChange obj)                 { SetObject(ParagraphItemsChoiceType.moveFrom, p, obj); }
760
        public void SetMoveFromRangeEndArray(int p, CT_MarkupRange obj)            { SetObject(ParagraphItemsChoiceType.moveFromRangeEnd, p, obj); }
761
        public void SetMoveFromRangeStartArray(int p, CT_MoveBookmark obj)         { SetObject(ParagraphItemsChoiceType.moveFromRangeStart, p, obj); }
762
        public void SetMoveToArray(int p, CT_RunTrackChange obj)                   { SetObject(ParagraphItemsChoiceType.moveTo, p, obj); }
763
        public void SetMoveToRangeEndArray(int p, CT_MarkupRange obj)              { SetObject(ParagraphItemsChoiceType.moveToRangeEnd, p, obj); }
764
        public void SetMoveToRangeStartArray(int p, CT_MoveBookmark obj)           { SetObject(ParagraphItemsChoiceType.moveToRangeStart, p, obj); }
765
        public void SetOMathArray(int p, CT_OMath obj)                             { SetObject(ParagraphItemsChoiceType.oMath, p, obj); }
766
        public void SetOMathParaArray(int p, CT_OMathPara obj)                     { SetObject(ParagraphItemsChoiceType.oMathPara, p, obj); }
767
        public void SetPermEndArray(int p, CT_Perm obj)                            { SetObject(ParagraphItemsChoiceType.permEnd, p, obj); }
768
        public void SetPermStartArray(int p, CT_PermStart obj)                     { SetObject(ParagraphItemsChoiceType.permStart, p, obj); }
769
        public void SetProofErrArray(int p, CT_ProofErr obj)                       { SetObject(ParagraphItemsChoiceType.proofErr, p, obj); }
770
        public void SetRArray(int p, CT_R obj)                                     { SetObject(ParagraphItemsChoiceType.r, p, obj); }
771
        public void SetSdtArray(int p, CT_SdtRun obj)                              { SetObject(ParagraphItemsChoiceType.sdt, p, obj); }
772
        public void SetSmartTagArray(int p, CT_SmartTagRun obj)                    { SetObject(ParagraphItemsChoiceType.smartTag, p, obj); }
773
        public void SetSubDocArray(int p, CT_Rel obj)                              { SetObject(ParagraphItemsChoiceType.subDoc, p, obj); }
774

775
        public int SizeOfBookmarkEndArray()                     { return SizeOfArray(ParagraphItemsChoiceType.bookmarkEnd); }
776
        public int SizeOfBookmarkStartArray()                   { return SizeOfArray(ParagraphItemsChoiceType.bookmarkStart); }
777
        public int SizeOfCommentRangeEndArray()                 { return SizeOfArray(ParagraphItemsChoiceType.commentRangeEnd); }
778
        public int SizeOfCommentRangeStartArray()               { return SizeOfArray(ParagraphItemsChoiceType.commentRangeStart); }
779
        public int SizeOfCustomXmlArray()                       { return SizeOfArray(ParagraphItemsChoiceType.customXml); }
780
        public int SizeOfCustomXmlDelRangeEndArray()            { return SizeOfArray(ParagraphItemsChoiceType.customXmlDelRangeEnd); }
781
        public int SizeOfCustomXmlDelRangeStartArray()          { return SizeOfArray(ParagraphItemsChoiceType.customXmlDelRangeStart); }
782
        public int SizeOfCustomXmlInsRangeEndArray()            { return SizeOfArray(ParagraphItemsChoiceType.customXmlInsRangeEnd); }
783
        public int SizeOfCustomXmlInsRangeStartArray()          { return SizeOfArray(ParagraphItemsChoiceType.customXmlInsRangeStart); }
784
        public int SizeOfCustomXmlMoveFromRangeEndArray()       { return SizeOfArray(ParagraphItemsChoiceType.customXmlMoveFromRangeEnd); }
785
        public int SizeOfCustomXmlMoveFromRangeStartArray()     { return SizeOfArray(ParagraphItemsChoiceType.customXmlMoveFromRangeStart); }
786
        public int SizeOfCustomXmlMoveToRangeEndArray()         { return SizeOfArray(ParagraphItemsChoiceType.customXmlMoveToRangeEnd); }
787
        public int SizeOfCustomXmlMoveToRangeStartArray()       { return SizeOfArray(ParagraphItemsChoiceType.customXmlMoveToRangeStart); }
788
        public int SizeOfDelArray()                             { return SizeOfArray(ParagraphItemsChoiceType.del); }
789
        public int SizeOfFldSimpleArray()                       { return SizeOfArray(ParagraphItemsChoiceType.fldSimple); }
790
        public int SizeOfHyperlinkArray()                       { return SizeOfArray(ParagraphItemsChoiceType.hyperlink); }
791
        public int SizeOfInsArray()                             { return SizeOfArray(ParagraphItemsChoiceType.ins); }
792
        public int SizeOfMoveFromArray()                        { return SizeOfArray(ParagraphItemsChoiceType.moveFrom); }
793
        public int SizeOfMoveFromRangeEndArray()                { return SizeOfArray(ParagraphItemsChoiceType.moveFromRangeEnd); }
794
        public int SizeOfMoveFromRangeStartArray()              { return SizeOfArray(ParagraphItemsChoiceType.moveFromRangeStart); }
795
        public int SizeOfMoveToArray()                          { return SizeOfArray(ParagraphItemsChoiceType.moveTo); }
796
        public int SizeOfMoveToRangeEndArray()                  { return SizeOfArray(ParagraphItemsChoiceType.moveToRangeEnd); }
797
        public int SizeOfMoveToRangeStartArray()                { return SizeOfArray(ParagraphItemsChoiceType.moveToRangeStart); }
798
        public int SizeOfOMathArray()                           { return SizeOfArray(ParagraphItemsChoiceType.oMath); }
799
        public int SizeOfOMathParaArray()                       { return SizeOfArray(ParagraphItemsChoiceType.oMathPara); }
800
        public int SizeOfPermEndArray()                         { return SizeOfArray(ParagraphItemsChoiceType.permEnd); }
801
        public int SizeOfPermStartArray()                       { return SizeOfArray(ParagraphItemsChoiceType.permStart); }
802
        public int SizeOfProofErrArray()                        { return SizeOfArray(ParagraphItemsChoiceType.proofErr); }
803
        public int SizeOfRArray()                               { return SizeOfArray(ParagraphItemsChoiceType.r); }
804
        public int SizeOfSdtArray()                             { return SizeOfArray(ParagraphItemsChoiceType.sdt); }
805
        public int SizeOfSmartTagArray()                        { return SizeOfArray(ParagraphItemsChoiceType.smartTag); }
806
        public int SizeOfSubDocArray()                          { return SizeOfArray(ParagraphItemsChoiceType.subDoc); }
807
        #pragma warning restore format
808
    }
809
    [Serializable]
810
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
811
    public enum ParagraphItemsChoiceType
812
    {
813

814
    
815
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
816
        oMath,
817

818
    
819
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
820
        oMathPara,
821

822
    
823
        bookmarkEnd,
824

825
    
826
        bookmarkStart,
827

828
    
829
        commentRangeEnd,
830

831
    
832
        commentRangeStart,
833

834
    
835
        customXml,
836

837
    
838
        customXmlDelRangeEnd,
839

840
    
841
        customXmlDelRangeStart,
842

843
    
844
        customXmlInsRangeEnd,
845

846
    
847
        customXmlInsRangeStart,
848

849
    
850
        customXmlMoveFromRangeEnd,
851

852
    
853
        customXmlMoveFromRangeStart,
854

855
    
856
        customXmlMoveToRangeEnd,
857

858
    
859
        customXmlMoveToRangeStart,
860

861
    
862
        del,
863

864
    
865
        fldSimple,
866

867
    
868
        hyperlink,
869

870
    
871
        ins,
872

873
    
874
        moveFrom,
875

876
    
877
        moveFromRangeEnd,
878

879
    
880
        moveFromRangeStart,
881

882
    
883
        moveTo,
884

885
    
886
        moveToRangeEnd,
887

888
    
889
        moveToRangeStart,
890

891
    
892
        permEnd,
893

894
    
895
        permStart,
896

897
    
898
        proofErr,
899

900
    
901
        r,
902

903
    
904
        sdt,
905

906
    
907
        smartTag,
908

909
    
910
        subDoc,
911
    }
912

913
    [Serializable]
914

915
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
916
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
917
    public class CT_PPr : CT_PPrBase
918
    {
919

920
        private CT_ParaRPr rPrField;
921

922
        private CT_SectPr sectPrField;
923

924
        private CT_PPrChange pPrChangeField;
925

926
        public CT_PPr()
927
        {
928

929
        }
930
        public CT_SectPr createSectPr()
931
        {
932
            this.sectPrField = new CT_SectPr();
933
            return this.sectPrField;
934
        }
935
        public override bool IsEmpty
936
        {
937
            get
938
            {
939
                return base.IsEmpty && 
940
                    rPrField == null && sectPrField == null && pPrChangeField == null;
941
            }
942
        }
943
        public static new CT_PPr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
944
        {
945
            if (node == null)
946
                return null;
947
            CT_PPr ctObj = new CT_PPr();
948
            ctObj.tabs = new List<CT_TabStop>();
949
            foreach (XmlNode childNode in node.ChildNodes)
950
            {
951
                if (childNode.LocalName == "rPr")
952
                    ctObj.rPr = CT_ParaRPr.Parse(childNode, namespaceManager);
953
                else if (childNode.LocalName == "sectPr")
954
                    ctObj.sectPr = CT_SectPr.Parse(childNode, namespaceManager);
955
                else if (childNode.LocalName == "pPrChange")
956
                    ctObj.pPrChange = CT_PPrChange.Parse(childNode, namespaceManager);
957
                else if (childNode.LocalName == "pStyle")
958
                    ctObj.pStyle = CT_String.Parse(childNode, namespaceManager);
959
                else if (childNode.LocalName == "keepNext")
960
                    ctObj.keepNext = CT_OnOff.Parse(childNode, namespaceManager);
961
                else if (childNode.LocalName == "keepLines")
962
                    ctObj.keepLines = CT_OnOff.Parse(childNode, namespaceManager);
963
                else if (childNode.LocalName == "pageBreakBefore")
964
                    ctObj.pageBreakBefore = CT_OnOff.Parse(childNode, namespaceManager);
965
                else if (childNode.LocalName == "framePr")
966
                    ctObj.framePr = CT_FramePr.Parse(childNode, namespaceManager);
967
                else if (childNode.LocalName == "widowControl")
968
                    ctObj.widowControl = CT_OnOff.Parse(childNode, namespaceManager);
969
                else if (childNode.LocalName == "numPr")
970
                    ctObj.numPr = CT_NumPr.Parse(childNode, namespaceManager);
971
                else if (childNode.LocalName == "suppressLineNumbers")
972
                    ctObj.suppressLineNumbers = CT_OnOff.Parse(childNode, namespaceManager);
973
                else if (childNode.LocalName == "pBdr")
974
                    ctObj.pBdr = CT_PBdr.Parse(childNode, namespaceManager);
975
                else if (childNode.LocalName == "shd")
976
                    ctObj.shd = CT_Shd.Parse(childNode, namespaceManager);
977
                else if (childNode.LocalName == "suppressAutoHyphens")
978
                    ctObj.suppressAutoHyphens = CT_OnOff.Parse(childNode, namespaceManager);
979
                else if (childNode.LocalName == "kinsoku")
980
                    ctObj.kinsoku = CT_OnOff.Parse(childNode, namespaceManager);
981
                else if (childNode.LocalName == "wordWrap")
982
                    ctObj.wordWrap = CT_OnOff.Parse(childNode, namespaceManager);
983
                else if (childNode.LocalName == "overflowPunct")
984
                    ctObj.overflowPunct = CT_OnOff.Parse(childNode, namespaceManager);
985
                else if (childNode.LocalName == "topLinePunct")
986
                    ctObj.topLinePunct = CT_OnOff.Parse(childNode, namespaceManager);
987
                else if (childNode.LocalName == "autoSpaceDE")
988
                    ctObj.autoSpaceDE = CT_OnOff.Parse(childNode, namespaceManager);
989
                else if (childNode.LocalName == "autoSpaceDN")
990
                    ctObj.autoSpaceDN = CT_OnOff.Parse(childNode, namespaceManager);
991
                else if (childNode.LocalName == "bidi")
992
                    ctObj.bidi = CT_OnOff.Parse(childNode, namespaceManager);
993
                else if (childNode.LocalName == "adjustRightInd")
994
                    ctObj.adjustRightInd = CT_OnOff.Parse(childNode, namespaceManager);
995
                else if (childNode.LocalName == "snapToGrid")
996
                    ctObj.snapToGrid = CT_OnOff.Parse(childNode, namespaceManager);
997
                else if (childNode.LocalName == "spacing")
998
                    ctObj.spacing = CT_Spacing.Parse(childNode, namespaceManager);
999
                else if (childNode.LocalName == "ind")
1000
                    ctObj.ind = CT_Ind.Parse(childNode, namespaceManager);
1001
                else if (childNode.LocalName == "contextualSpacing")
1002
                    ctObj.contextualSpacing = CT_OnOff.Parse(childNode, namespaceManager);
1003
                else if (childNode.LocalName == "mirrorIndents")
1004
                    ctObj.mirrorIndents = CT_OnOff.Parse(childNode, namespaceManager);
1005
                else if (childNode.LocalName == "suppressOverlap")
1006
                    ctObj.suppressOverlap = CT_OnOff.Parse(childNode, namespaceManager);
1007
                else if (childNode.LocalName == "jc")
1008
                    ctObj.jc = CT_Jc.Parse(childNode, namespaceManager);
1009
                else if (childNode.LocalName == "textDirection")
1010
                    ctObj.textDirection = CT_TextDirection.Parse(childNode, namespaceManager);
1011
                else if (childNode.LocalName == "textAlignment")
1012
                    ctObj.textAlignment = CT_TextAlignment.Parse(childNode, namespaceManager);
1013
                else if (childNode.LocalName == "textboxTightWrap")
1014
                    ctObj.textboxTightWrap = CT_TextboxTightWrap.Parse(childNode, namespaceManager);
1015
                else if (childNode.LocalName == "outlineLvl")
1016
                    ctObj.outlineLvl = CT_DecimalNumber.Parse(childNode, namespaceManager);
1017
                else if (childNode.LocalName == "divId")
1018
                    ctObj.divId = CT_DecimalNumber.Parse(childNode, namespaceManager);
1019
                else if (childNode.LocalName == "cnfStyle")
1020
                    ctObj.cnfStyle = CT_Cnf.Parse(childNode, namespaceManager);
1021
                else if (childNode.LocalName == "tabs")
1022
                {
1023
                    foreach (XmlNode snode in childNode.ChildNodes)
1024
                    {
1025
                        ctObj.tabs.Add(CT_TabStop.Parse(snode, namespaceManager));
1026
                    }
1027
                }
1028
            }
1029
            return ctObj;
1030
        }
1031

1032

1033

1034
        internal new void Write(StreamWriter sw, string nodeName)
1035
        {
1036
            sw.Write(string.Format("<w:{0}", nodeName));
1037
            sw.Write(">");
1038
            if (this.pPrChange != null)
1039
                this.pPrChange.Write(sw, "pPrChange");
1040
            if (this.pStyle != null)
1041
                this.pStyle.Write(sw, "pStyle");
1042
            if (this.keepNext != null)
1043
                this.keepNext.Write(sw, "keepNext");
1044
            if (this.keepLines != null)
1045
                this.keepLines.Write(sw, "keepLines");
1046
            if (this.pageBreakBefore != null)
1047
                this.pageBreakBefore.Write(sw, "pageBreakBefore");
1048
            if (this.framePr != null)
1049
                this.framePr.Write(sw, "framePr");
1050
            if (this.widowControl != null)
1051
                this.widowControl.Write(sw, "widowControl");
1052
            if (this.numPr != null)
1053
                this.numPr.Write(sw, "numPr");
1054
            if (this.pBdr != null)
1055
                this.pBdr.Write(sw, "pBdr");
1056
            if (this.tabs != null && this.tabs.Count > 0)
1057
            {
1058
                sw.Write("<w:tabs>");
1059
                foreach (CT_TabStop x in this.tabs)
1060
                {
1061
                    x.Write(sw, "tab");
1062
                }
1063
                sw.Write("</w:tabs>");
1064
            }
1065
            if (this.suppressLineNumbers != null)
1066
                this.suppressLineNumbers.Write(sw, "suppressLineNumbers");
1067
            if (this.shd != null)
1068
                this.shd.Write(sw, "shd");
1069
            if (this.suppressAutoHyphens != null)
1070
                this.suppressAutoHyphens.Write(sw, "suppressAutoHyphens");
1071
            if (this.kinsoku != null)
1072
                this.kinsoku.Write(sw, "kinsoku");
1073
            if (this.wordWrap != null)
1074
                this.wordWrap.Write(sw, "wordWrap");
1075
            if (this.overflowPunct != null)
1076
                this.overflowPunct.Write(sw, "overflowPunct");
1077
            if (this.topLinePunct != null)
1078
                this.topLinePunct.Write(sw, "topLinePunct");
1079
            if (this.autoSpaceDE != null)
1080
                this.autoSpaceDE.Write(sw, "autoSpaceDE");
1081
            if (this.autoSpaceDN != null)
1082
                this.autoSpaceDN.Write(sw, "autoSpaceDN");
1083
            if (this.bidi != null)
1084
                this.bidi.Write(sw, "bidi");
1085
            if (this.adjustRightInd != null)
1086
                this.adjustRightInd.Write(sw, "adjustRightInd");
1087
            if (this.snapToGrid != null)
1088
                this.snapToGrid.Write(sw, "snapToGrid");
1089
            if (this.spacing != null)
1090
                this.spacing.Write(sw, "spacing");
1091
            if (this.ind != null)
1092
                this.ind.Write(sw, "ind");
1093

1094
            if (this.contextualSpacing != null)
1095
                this.contextualSpacing.Write(sw, "contextualSpacing");
1096
            if (this.mirrorIndents != null)
1097
                this.mirrorIndents.Write(sw, "mirrorIndents");
1098
            if (this.suppressOverlap != null)
1099
                this.suppressOverlap.Write(sw, "suppressOverlap");
1100
            if (this.jc != null)
1101
                this.jc.Write(sw, "jc");
1102
            if (this.outlineLvl != null)
1103
                this.outlineLvl.Write(sw, "outlineLvl");
1104
            if (this.rPr != null)
1105
                this.rPr.Write(sw, "rPr");
1106
            if(this.sectPr != null)
1107
                this.sectPr.Write(sw, "sectPr");
1108
            if (this.textDirection != null)
1109
                this.textDirection.Write(sw, "textDirection");
1110
            if (this.textAlignment != null)
1111
                this.textAlignment.Write(sw, "textAlignment");
1112
            if (this.textboxTightWrap != null)
1113
                this.textboxTightWrap.Write(sw, "textboxTightWrap");
1114
            if (this.divId != null)
1115
                this.divId.Write(sw, "divId");
1116
            if (this.cnfStyle != null)
1117
                this.cnfStyle.Write(sw, "cnfStyle");
1118

1119
            sw.WriteEndW(nodeName);
1120
        }
1121

1122

1123

1124
        [XmlElement(Order = 0)]
1125
        public CT_ParaRPr rPr
1126
        {
1127
            get
1128
            {
1129
                return this.rPrField;
1130
            }
1131
            set
1132
            {
1133
                this.rPrField = value;
1134
            }
1135
        }
1136

1137
        [XmlElement(Order = 1)]
1138
        public CT_SectPr sectPr
1139
        {
1140
            get
1141
            {
1142
                return this.sectPrField;
1143
            }
1144
            set
1145
            {
1146
                this.sectPrField = value;
1147
            }
1148
        }
1149

1150
        [XmlElement(Order = 2)]
1151
        public CT_PPrChange pPrChange
1152
        {
1153
            get
1154
            {
1155
                return this.pPrChangeField;
1156
            }
1157
            set
1158
            {
1159
                this.pPrChangeField = value;
1160
            }
1161
        }
1162

1163
        public CT_ParaRPr AddNewRPr()
1164
        {
1165
            if (this.rPrField == null)
1166
                this.rPrField = new CT_ParaRPr();
1167
            return this.rPrField;
1168
        }
1169

1170
        public CT_NumPr AddNewNumPr()
1171
        {
1172
            if (this.numPr == null)
1173
                this.numPr = new CT_NumPr();
1174
            return this.numPr;
1175
        }
1176

1177
        public bool IsSetSpacing()
1178
        {
1179
            return this.spacing != null;
1180
        }
1181
    }
1182

1183

1184
    [Serializable]
1185

1186
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1187
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1188
    public class CT_ParaRPr
1189
    {
1190

1191
        private CT_TrackChange insField;
1192

1193
        private CT_TrackChange delField;
1194

1195
        private CT_TrackChange moveFromField;
1196

1197
        private CT_TrackChange moveToField;
1198

1199
        private CT_String rStyleField;
1200

1201
        private CT_Fonts rFontsField;
1202

1203
        private CT_OnOff bField;
1204

1205
        private CT_OnOff bCsField;
1206

1207
        private CT_OnOff iField;
1208

1209
        private CT_OnOff iCsField;
1210

1211
        private CT_OnOff capsField;
1212

1213
        private CT_OnOff smallCapsField;
1214

1215
        private CT_OnOff strikeField;
1216

1217
        private CT_OnOff dstrikeField;
1218

1219
        private CT_OnOff outlineField;
1220

1221
        private CT_OnOff shadowField;
1222

1223
        private CT_OnOff embossField;
1224

1225
        private CT_OnOff imprintField;
1226

1227
        private CT_OnOff noProofField;
1228

1229
        private CT_OnOff snapToGridField;
1230

1231
        private CT_OnOff vanishField;
1232

1233
        private CT_OnOff webHiddenField;
1234

1235
        private CT_Color colorField;
1236

1237
        private CT_SignedTwipsMeasure spacingField;
1238

1239
        private CT_TextScale wField;
1240

1241
        private CT_HpsMeasure kernField;
1242

1243
        private CT_SignedHpsMeasure positionField;
1244

1245
        private CT_HpsMeasure szField;
1246

1247
        private CT_HpsMeasure szCsField;
1248

1249
        private CT_Highlight highlightField;
1250

1251
        private CT_Underline uField;
1252

1253
        private CT_TextEffect effectField;
1254

1255
        private CT_Border bdrField;
1256

1257
        private CT_Shd shdField;
1258

1259
        private CT_FitText fitTextField;
1260

1261
        private CT_VerticalAlignRun vertAlignField;
1262

1263
        private CT_OnOff rtlField;
1264

1265
        private CT_OnOff csField;
1266

1267
        private CT_Em emField;
1268

1269
        private CT_Language langField;
1270

1271
        private CT_EastAsianLayout eastAsianLayoutField;
1272

1273
        private CT_OnOff specVanishField;
1274

1275
        private CT_OnOff oMathField;
1276

1277
        private CT_ParaRPrChange rPrChangeField;
1278

1279
        public CT_ParaRPr()
1280
        {
1281

1282
        }
1283

1284
        [XmlElement(Order = 0)]
1285
        public CT_TrackChange ins
1286
        {
1287
            get
1288
            {
1289
                return this.insField;
1290
            }
1291
            set
1292
            {
1293
                this.insField = value;
1294
            }
1295
        }
1296

1297
        [XmlElement(Order = 1)]
1298
        public CT_TrackChange del
1299
        {
1300
            get
1301
            {
1302
                return this.delField;
1303
            }
1304
            set
1305
            {
1306
                this.delField = value;
1307
            }
1308
        }
1309

1310
        [XmlElement(Order = 2)]
1311
        public CT_TrackChange moveFrom
1312
        {
1313
            get
1314
            {
1315
                return this.moveFromField;
1316
            }
1317
            set
1318
            {
1319
                this.moveFromField = value;
1320
            }
1321
        }
1322

1323
        [XmlElement(Order = 3)]
1324
        public CT_TrackChange moveTo
1325
        {
1326
            get
1327
            {
1328
                return this.moveToField;
1329
            }
1330
            set
1331
            {
1332
                this.moveToField = value;
1333
            }
1334
        }
1335

1336
        [XmlElement(Order = 4)]
1337
        public CT_String rStyle
1338
        {
1339
            get
1340
            {
1341
                return this.rStyleField;
1342
            }
1343
            set
1344
            {
1345
                this.rStyleField = value;
1346
            }
1347
        }
1348

1349
        [XmlElement(Order = 5)]
1350
        public CT_Fonts rFonts
1351
        {
1352
            get
1353
            {
1354
                return this.rFontsField;
1355
            }
1356
            set
1357
            {
1358
                this.rFontsField = value;
1359
            }
1360
        }
1361

1362
        [XmlElement(Order = 6)]
1363
        public CT_OnOff b
1364
        {
1365
            get
1366
            {
1367
                return this.bField;
1368
            }
1369
            set
1370
            {
1371
                this.bField = value;
1372
            }
1373
        }
1374

1375
        [XmlElement(Order = 7)]
1376
        public CT_OnOff bCs
1377
        {
1378
            get
1379
            {
1380
                return this.bCsField;
1381
            }
1382
            set
1383
            {
1384
                this.bCsField = value;
1385
            }
1386
        }
1387

1388
        [XmlElement(Order = 8)]
1389
        public CT_OnOff i
1390
        {
1391
            get
1392
            {
1393
                return this.iField;
1394
            }
1395
            set
1396
            {
1397
                this.iField = value;
1398
            }
1399
        }
1400

1401
        [XmlElement(Order = 9)]
1402
        public CT_OnOff iCs
1403
        {
1404
            get
1405
            {
1406
                return this.iCsField;
1407
            }
1408
            set
1409
            {
1410
                this.iCsField = value;
1411
            }
1412
        }
1413

1414
        [XmlElement(Order = 10)]
1415
        public CT_OnOff caps
1416
        {
1417
            get
1418
            {
1419
                return this.capsField;
1420
            }
1421
            set
1422
            {
1423
                this.capsField = value;
1424
            }
1425
        }
1426

1427
        [XmlElement(Order = 11)]
1428
        public CT_OnOff smallCaps
1429
        {
1430
            get
1431
            {
1432
                return this.smallCapsField;
1433
            }
1434
            set
1435
            {
1436
                this.smallCapsField = value;
1437
            }
1438
        }
1439

1440
        [XmlElement(Order = 12)]
1441
        public CT_OnOff strike
1442
        {
1443
            get
1444
            {
1445
                return this.strikeField;
1446
            }
1447
            set
1448
            {
1449
                this.strikeField = value;
1450
            }
1451
        }
1452

1453
        [XmlElement(Order = 13)]
1454
        public CT_OnOff dstrike
1455
        {
1456
            get
1457
            {
1458
                return this.dstrikeField;
1459
            }
1460
            set
1461
            {
1462
                this.dstrikeField = value;
1463
            }
1464
        }
1465

1466
        [XmlElement(Order = 14)]
1467
        public CT_OnOff outline
1468
        {
1469
            get
1470
            {
1471
                return this.outlineField;
1472
            }
1473
            set
1474
            {
1475
                this.outlineField = value;
1476
            }
1477
        }
1478

1479
        [XmlElement(Order = 15)]
1480
        public CT_OnOff shadow
1481
        {
1482
            get
1483
            {
1484
                return this.shadowField;
1485
            }
1486
            set
1487
            {
1488
                this.shadowField = value;
1489
            }
1490
        }
1491

1492
        [XmlElement(Order = 16)]
1493
        public CT_OnOff emboss
1494
        {
1495
            get
1496
            {
1497
                return this.embossField;
1498
            }
1499
            set
1500
            {
1501
                this.embossField = value;
1502
            }
1503
        }
1504

1505
        [XmlElement(Order = 17)]
1506
        public CT_OnOff imprint
1507
        {
1508
            get
1509
            {
1510
                return this.imprintField;
1511
            }
1512
            set
1513
            {
1514
                this.imprintField = value;
1515
            }
1516
        }
1517

1518
        [XmlElement(Order = 18)]
1519
        public CT_OnOff noProof
1520
        {
1521
            get
1522
            {
1523
                return this.noProofField;
1524
            }
1525
            set
1526
            {
1527
                this.noProofField = value;
1528
            }
1529
        }
1530

1531
        [XmlElement(Order = 19)]
1532
        public CT_OnOff snapToGrid
1533
        {
1534
            get
1535
            {
1536
                return this.snapToGridField;
1537
            }
1538
            set
1539
            {
1540
                this.snapToGridField = value;
1541
            }
1542
        }
1543

1544
        [XmlElement(Order = 20)]
1545
        public CT_OnOff vanish
1546
        {
1547
            get
1548
            {
1549
                return this.vanishField;
1550
            }
1551
            set
1552
            {
1553
                this.vanishField = value;
1554
            }
1555
        }
1556

1557
        [XmlElement(Order = 21)]
1558
        public CT_OnOff webHidden
1559
        {
1560
            get
1561
            {
1562
                return this.webHiddenField;
1563
            }
1564
            set
1565
            {
1566
                this.webHiddenField = value;
1567
            }
1568
        }
1569

1570
        [XmlElement(Order = 22)]
1571
        public CT_Color color
1572
        {
1573
            get
1574
            {
1575
                return this.colorField;
1576
            }
1577
            set
1578
            {
1579
                this.colorField = value;
1580
            }
1581
        }
1582

1583
        [XmlElement(Order = 23)]
1584
        public CT_SignedTwipsMeasure spacing
1585
        {
1586
            get
1587
            {
1588
                return this.spacingField;
1589
            }
1590
            set
1591
            {
1592
                this.spacingField = value;
1593
            }
1594
        }
1595

1596
        [XmlElement(Order = 24)]
1597
        public CT_TextScale w
1598
        {
1599
            get
1600
            {
1601
                return this.wField;
1602
            }
1603
            set
1604
            {
1605
                this.wField = value;
1606
            }
1607
        }
1608

1609
        [XmlElement(Order = 25)]
1610
        public CT_HpsMeasure kern
1611
        {
1612
            get
1613
            {
1614
                return this.kernField;
1615
            }
1616
            set
1617
            {
1618
                this.kernField = value;
1619
            }
1620
        }
1621

1622
        [XmlElement(Order = 26)]
1623
        public CT_SignedHpsMeasure position
1624
        {
1625
            get
1626
            {
1627
                return this.positionField;
1628
            }
1629
            set
1630
            {
1631
                this.positionField = value;
1632
            }
1633
        }
1634

1635
        [XmlElement(Order = 27)]
1636
        public CT_HpsMeasure sz
1637
        {
1638
            get
1639
            {
1640
                return this.szField;
1641
            }
1642
            set
1643
            {
1644
                this.szField = value;
1645
            }
1646
        }
1647

1648
        [XmlElement(Order = 28)]
1649
        public CT_HpsMeasure szCs
1650
        {
1651
            get
1652
            {
1653
                return this.szCsField;
1654
            }
1655
            set
1656
            {
1657
                this.szCsField = value;
1658
            }
1659
        }
1660

1661
        [XmlElement(Order = 29)]
1662
        public CT_Highlight highlight
1663
        {
1664
            get
1665
            {
1666
                return this.highlightField;
1667
            }
1668
            set
1669
            {
1670
                this.highlightField = value;
1671
            }
1672
        }
1673

1674
        [XmlElement(Order = 30)]
1675
        public CT_Underline u
1676
        {
1677
            get
1678
            {
1679
                return this.uField;
1680
            }
1681
            set
1682
            {
1683
                this.uField = value;
1684
            }
1685
        }
1686

1687
        [XmlElement(Order = 31)]
1688
        public CT_TextEffect effect
1689
        {
1690
            get
1691
            {
1692
                return this.effectField;
1693
            }
1694
            set
1695
            {
1696
                this.effectField = value;
1697
            }
1698
        }
1699

1700
        [XmlElement(Order = 32)]
1701
        public CT_Border bdr
1702
        {
1703
            get
1704
            {
1705
                return this.bdrField;
1706
            }
1707
            set
1708
            {
1709
                this.bdrField = value;
1710
            }
1711
        }
1712

1713
        [XmlElement(Order = 33)]
1714
        public CT_Shd shd
1715
        {
1716
            get
1717
            {
1718
                return this.shdField;
1719
            }
1720
            set
1721
            {
1722
                this.shdField = value;
1723
            }
1724
        }
1725

1726
        [XmlElement(Order = 34)]
1727
        public CT_FitText fitText
1728
        {
1729
            get
1730
            {
1731
                return this.fitTextField;
1732
            }
1733
            set
1734
            {
1735
                this.fitTextField = value;
1736
            }
1737
        }
1738

1739
        [XmlElement(Order = 35)]
1740
        public CT_VerticalAlignRun vertAlign
1741
        {
1742
            get
1743
            {
1744
                return this.vertAlignField;
1745
            }
1746
            set
1747
            {
1748
                this.vertAlignField = value;
1749
            }
1750
        }
1751

1752
        [XmlElement(Order = 36)]
1753
        public CT_OnOff rtl
1754
        {
1755
            get
1756
            {
1757
                return this.rtlField;
1758
            }
1759
            set
1760
            {
1761
                this.rtlField = value;
1762
            }
1763
        }
1764

1765
        [XmlElement(Order = 37)]
1766
        public CT_OnOff cs
1767
        {
1768
            get
1769
            {
1770
                return this.csField;
1771
            }
1772
            set
1773
            {
1774
                this.csField = value;
1775
            }
1776
        }
1777

1778
        [XmlElement(Order = 38)]
1779
        public CT_Em em
1780
        {
1781
            get
1782
            {
1783
                return this.emField;
1784
            }
1785
            set
1786
            {
1787
                this.emField = value;
1788
            }
1789
        }
1790

1791
        [XmlElement(Order = 39)]
1792
        public CT_Language lang
1793
        {
1794
            get
1795
            {
1796
                return this.langField;
1797
            }
1798
            set
1799
            {
1800
                this.langField = value;
1801
            }
1802
        }
1803

1804
        [XmlElement(Order = 40)]
1805
        public CT_EastAsianLayout eastAsianLayout
1806
        {
1807
            get
1808
            {
1809
                return this.eastAsianLayoutField;
1810
            }
1811
            set
1812
            {
1813
                this.eastAsianLayoutField = value;
1814
            }
1815
        }
1816

1817
        [XmlElement(Order = 41)]
1818
        public CT_OnOff specVanish
1819
        {
1820
            get
1821
            {
1822
                return this.specVanishField;
1823
            }
1824
            set
1825
            {
1826
                this.specVanishField = value;
1827
            }
1828
        }
1829

1830
        [XmlElement(Order = 42)]
1831
        public CT_OnOff oMath
1832
        {
1833
            get
1834
            {
1835
                return this.oMathField;
1836
            }
1837
            set
1838
            {
1839
                this.oMathField = value;
1840
            }
1841
        }
1842

1843
        [XmlElement(Order = 43)]
1844
        public CT_ParaRPrChange rPrChange
1845
        {
1846
            get
1847
            {
1848
                return this.rPrChangeField;
1849
            }
1850
            set
1851
            {
1852
                this.rPrChangeField = value;
1853
            }
1854
        }
1855

1856
        public CT_OnOff AddNewNoProof()
1857
        {
1858
            if (this.noProofField == null)
1859
                this.noProofField = new CT_OnOff();
1860
            return this.noProofField;
1861
        }
1862

1863
        public static CT_ParaRPr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1864
        {
1865
            if (node == null)
1866
                return null;
1867
            CT_ParaRPr ctObj = new CT_ParaRPr();
1868
            foreach (XmlNode childNode in node.ChildNodes)
1869
            {
1870
                if (childNode.LocalName == "ins")
1871
                    ctObj.ins = CT_TrackChange.Parse(childNode, namespaceManager);
1872
                else if (childNode.LocalName == "del")
1873
                    ctObj.del = CT_TrackChange.Parse(childNode, namespaceManager);
1874
                else if (childNode.LocalName == "moveFrom")
1875
                    ctObj.moveFrom = CT_TrackChange.Parse(childNode, namespaceManager);
1876
                else if (childNode.LocalName == "moveTo")
1877
                    ctObj.moveTo = CT_TrackChange.Parse(childNode, namespaceManager);
1878
                else if (childNode.LocalName == "rStyle")
1879
                    ctObj.rStyle = CT_String.Parse(childNode, namespaceManager);
1880
                else if (childNode.LocalName == "rFonts")
1881
                    ctObj.rFonts = CT_Fonts.Parse(childNode, namespaceManager);
1882
                else if (childNode.LocalName == "b")
1883
                    ctObj.b = CT_OnOff.Parse(childNode, namespaceManager);
1884
                else if (childNode.LocalName == "bCs")
1885
                    ctObj.bCs = CT_OnOff.Parse(childNode, namespaceManager);
1886
                else if (childNode.LocalName == "i")
1887
                    ctObj.i = CT_OnOff.Parse(childNode, namespaceManager);
1888
                else if (childNode.LocalName == "iCs")
1889
                    ctObj.iCs = CT_OnOff.Parse(childNode, namespaceManager);
1890
                else if (childNode.LocalName == "caps")
1891
                    ctObj.caps = CT_OnOff.Parse(childNode, namespaceManager);
1892
                else if (childNode.LocalName == "smallCaps")
1893
                    ctObj.smallCaps = CT_OnOff.Parse(childNode, namespaceManager);
1894
                else if (childNode.LocalName == "strike")
1895
                    ctObj.strike = CT_OnOff.Parse(childNode, namespaceManager);
1896
                else if (childNode.LocalName == "dstrike")
1897
                    ctObj.dstrike = CT_OnOff.Parse(childNode, namespaceManager);
1898
                else if (childNode.LocalName == "outline")
1899
                    ctObj.outline = CT_OnOff.Parse(childNode, namespaceManager);
1900
                else if (childNode.LocalName == "shadow")
1901
                    ctObj.shadow = CT_OnOff.Parse(childNode, namespaceManager);
1902
                else if (childNode.LocalName == "emboss")
1903
                    ctObj.emboss = CT_OnOff.Parse(childNode, namespaceManager);
1904
                else if (childNode.LocalName == "imprint")
1905
                    ctObj.imprint = CT_OnOff.Parse(childNode, namespaceManager);
1906
                else if (childNode.LocalName == "noProof")
1907
                    ctObj.noProof = CT_OnOff.Parse(childNode, namespaceManager);
1908
                else if (childNode.LocalName == "snapToGrid")
1909
                    ctObj.snapToGrid = CT_OnOff.Parse(childNode, namespaceManager);
1910
                else if (childNode.LocalName == "vanish")
1911
                    ctObj.vanish = CT_OnOff.Parse(childNode, namespaceManager);
1912
                else if (childNode.LocalName == "webHidden")
1913
                    ctObj.webHidden = CT_OnOff.Parse(childNode, namespaceManager);
1914
                else if (childNode.LocalName == "color")
1915
                    ctObj.color = CT_Color.Parse(childNode, namespaceManager);
1916
                else if (childNode.LocalName == "spacing")
1917
                    ctObj.spacing = CT_SignedTwipsMeasure.Parse(childNode, namespaceManager);
1918
                else if (childNode.LocalName == "w")
1919
                    ctObj.w = CT_TextScale.Parse(childNode, namespaceManager);
1920
                else if (childNode.LocalName == "kern")
1921
                    ctObj.kern = CT_HpsMeasure.Parse(childNode, namespaceManager);
1922
                else if (childNode.LocalName == "position")
1923
                    ctObj.position = CT_SignedHpsMeasure.Parse(childNode, namespaceManager);
1924
                else if (childNode.LocalName == "sz")
1925
                    ctObj.sz = CT_HpsMeasure.Parse(childNode, namespaceManager);
1926
                else if (childNode.LocalName == "szCs")
1927
                    ctObj.szCs = CT_HpsMeasure.Parse(childNode, namespaceManager);
1928
                else if (childNode.LocalName == "highlight")
1929
                    ctObj.highlight = CT_Highlight.Parse(childNode, namespaceManager);
1930
                else if (childNode.LocalName == "u")
1931
                    ctObj.u = CT_Underline.Parse(childNode, namespaceManager);
1932
                else if (childNode.LocalName == "effect")
1933
                    ctObj.effect = CT_TextEffect.Parse(childNode, namespaceManager);
1934
                else if (childNode.LocalName == "bdr")
1935
                    ctObj.bdr = CT_Border.Parse(childNode, namespaceManager);
1936
                else if (childNode.LocalName == "shd")
1937
                    ctObj.shd = CT_Shd.Parse(childNode, namespaceManager);
1938
                else if (childNode.LocalName == "fitText")
1939
                    ctObj.fitText = CT_FitText.Parse(childNode, namespaceManager);
1940
                else if (childNode.LocalName == "vertAlign")
1941
                    ctObj.vertAlign = CT_VerticalAlignRun.Parse(childNode, namespaceManager);
1942
                else if (childNode.LocalName == "rtl")
1943
                    ctObj.rtl = CT_OnOff.Parse(childNode, namespaceManager);
1944
                else if (childNode.LocalName == "cs")
1945
                    ctObj.cs = CT_OnOff.Parse(childNode, namespaceManager);
1946
                else if (childNode.LocalName == "em")
1947
                    ctObj.em = CT_Em.Parse(childNode, namespaceManager);
1948
                else if (childNode.LocalName == "lang")
1949
                    ctObj.lang = CT_Language.Parse(childNode, namespaceManager);
1950
                else if (childNode.LocalName == "eastAsianLayout")
1951
                    ctObj.eastAsianLayout = CT_EastAsianLayout.Parse(childNode, namespaceManager);
1952
                else if (childNode.LocalName == "specVanish")
1953
                    ctObj.specVanish = CT_OnOff.Parse(childNode, namespaceManager);
1954
                else if (childNode.LocalName == "oMath")
1955
                    ctObj.oMath = CT_OnOff.Parse(childNode, namespaceManager);
1956
                else if (childNode.LocalName == "rPrChange")
1957
                    ctObj.rPrChange = CT_ParaRPrChange.Parse(childNode, namespaceManager);
1958
            }
1959
            return ctObj;
1960
        }
1961

1962

1963

1964
        internal void Write(StreamWriter sw, string nodeName)
1965
        {
1966
            sw.Write(string.Format("<w:{0}", nodeName));
1967
            sw.Write(">");
1968
            if (this.ins != null)
1969
                this.ins.Write(sw, "ins");
1970
            if (this.del != null)
1971
                this.del.Write(sw, "del");
1972
            if (this.moveFrom != null)
1973
                this.moveFrom.Write(sw, "moveFrom");
1974
            if (this.moveTo != null)
1975
                this.moveTo.Write(sw, "moveTo");
1976
            if (this.rStyle != null)
1977
                this.rStyle.Write(sw, "rStyle");
1978
            if (this.rFonts != null)
1979
                this.rFonts.Write(sw, "rFonts");
1980
            if (this.b != null)
1981
                this.b.Write(sw, "b");
1982
            if (this.bCs != null)
1983
                this.bCs.Write(sw, "bCs");
1984
            if (this.i != null)
1985
                this.i.Write(sw, "i");
1986
            if (this.iCs != null)
1987
                this.iCs.Write(sw, "iCs");
1988
            if (this.caps != null)
1989
                this.caps.Write(sw, "caps");
1990
            if (this.smallCaps != null)
1991
                this.smallCaps.Write(sw, "smallCaps");
1992
            if (this.strike != null)
1993
                this.strike.Write(sw, "strike");
1994
            if (this.dstrike != null)
1995
                this.dstrike.Write(sw, "dstrike");
1996
            if (this.outline != null)
1997
                this.outline.Write(sw, "outline");
1998
            if (this.shadow != null)
1999
                this.shadow.Write(sw, "shadow");
2000
            if (this.emboss != null)
2001
                this.emboss.Write(sw, "emboss");
2002
            if (this.imprint != null)
2003
                this.imprint.Write(sw, "imprint");
2004
            if (this.noProof != null)
2005
                this.noProof.Write(sw, "noProof");
2006
            if (this.snapToGrid != null)
2007
                this.snapToGrid.Write(sw, "snapToGrid");
2008
            if (this.vanish != null)
2009
                this.vanish.Write(sw, "vanish");
2010
            if (this.webHidden != null)
2011
                this.webHidden.Write(sw, "webHidden");
2012
            if (this.color != null)
2013
                this.color.Write(sw, "color");
2014
            if (this.spacing != null)
2015
                this.spacing.Write(sw, "spacing");
2016
            if (this.w != null)
2017
                this.w.Write(sw, "w");
2018
            if (this.kern != null)
2019
                this.kern.Write(sw, "kern");
2020
            if (this.position != null)
2021
                this.position.Write(sw, "position");
2022
            if (this.sz != null)
2023
                this.sz.Write(sw, "sz");
2024
            if (this.szCs != null)
2025
                this.szCs.Write(sw, "szCs");
2026
            if (this.highlight != null)
2027
                this.highlight.Write(sw, "highlight");
2028
            if (this.u != null)
2029
                this.u.Write(sw, "u");
2030
            if (this.effect != null)
2031
                this.effect.Write(sw, "effect");
2032
            if (this.bdr != null)
2033
                this.bdr.Write(sw, "bdr");
2034
            if (this.shd != null)
2035
                this.shd.Write(sw, "shd");
2036
            if (this.fitText != null)
2037
                this.fitText.Write(sw, "fitText");
2038
            if (this.vertAlign != null)
2039
                this.vertAlign.Write(sw, "vertAlign");
2040
            if (this.rtl != null)
2041
                this.rtl.Write(sw, "rtl");
2042
            if (this.cs != null)
2043
                this.cs.Write(sw, "cs");
2044
            if (this.em != null)
2045
                this.em.Write(sw, "em");
2046
            if (this.lang != null)
2047
                this.lang.Write(sw, "lang");
2048
            if (this.eastAsianLayout != null)
2049
                this.eastAsianLayout.Write(sw, "eastAsianLayout");
2050
            if (this.specVanish != null)
2051
                this.specVanish.Write(sw, "specVanish");
2052
            if (this.oMath != null)
2053
                this.oMath.Write(sw, "oMath");
2054
            if (this.rPrChange != null)
2055
                this.rPrChange.Write(sw, "rPrChange");
2056
            sw.WriteEndW(nodeName);
2057
        }
2058

2059

2060
    }
2061

2062

2063

2064

2065
    [Serializable]
2066

2067
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2068
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2069
    public class CT_SectPrChange : CT_TrackChange
2070
    {
2071

2072
        private CT_SectPrBase sectPrField;
2073

2074
        public CT_SectPrChange()
2075
        {
2076
            this.sectPrField = new CT_SectPrBase();
2077
        }
2078
        public static new CT_SectPrChange Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2079
        {
2080
            if (node == null)
2081
                return null;
2082
            CT_SectPrChange ctObj = new CT_SectPrChange();
2083
            ctObj.author = XmlHelper.ReadString(node.Attributes["w:author"]);
2084
            ctObj.date = XmlHelper.ReadString(node.Attributes["w:date"]);
2085
            ctObj.id = XmlHelper.ReadString(node.Attributes["r:id"]);
2086
            foreach (XmlNode childNode in node.ChildNodes)
2087
            {
2088
                if (childNode.LocalName == "sectPr")
2089
                    ctObj.sectPr = CT_SectPrBase.Parse(childNode, namespaceManager);
2090
            }
2091
            return ctObj;
2092
        }
2093

2094

2095

2096
        internal new void Write(StreamWriter sw, string nodeName)
2097
        {
2098
            sw.Write(string.Format("<w:{0}", nodeName));
2099
            XmlHelper.WriteAttribute(sw, "w:author", this.author);
2100
            XmlHelper.WriteAttribute(sw, "w:date", this.date);
2101
            XmlHelper.WriteAttribute(sw, "r:id", this.id);
2102
            sw.Write(">");
2103
            if (this.sectPr != null)
2104
                this.sectPr.Write(sw, "sectPr");
2105
            sw.WriteEndW(nodeName);
2106
        }
2107

2108
        [XmlElement(Order = 0)]
2109
        public CT_SectPrBase sectPr
2110
        {
2111
            get
2112
            {
2113
                return this.sectPrField;
2114
            }
2115
            set
2116
            {
2117
                this.sectPrField = value;
2118
            }
2119
        }
2120
    }
2121

2122

2123
    [Serializable]
2124

2125
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2126
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2127
    public class CT_SectPrBase
2128
    {
2129

2130
        private CT_FtnProps footnotePrField;
2131

2132
        private CT_EdnProps endnotePrField;
2133

2134
        private CT_SectType typeField;
2135

2136
        private CT_PageSz pgSzField;
2137

2138
        private CT_PageMar pgMarField;
2139

2140
        private CT_PaperSource paperSrcField;
2141

2142
        private CT_PageBorders pgBordersField;
2143

2144
        private CT_LineNumber lnNumTypeField;
2145

2146
        private CT_PageNumber pgNumTypeField;
2147

2148
        private CT_Columns colsField;
2149

2150
        private CT_OnOff formProtField;
2151

2152
        private CT_VerticalJc vAlignField;
2153

2154
        private CT_OnOff noEndnoteField;
2155

2156
        private CT_OnOff titlePgField;
2157

2158
        private CT_TextDirection textDirectionField;
2159

2160
        private CT_OnOff bidiField;
2161

2162
        private CT_OnOff rtlGutterField;
2163

2164
        private CT_DocGrid docGridField;
2165

2166
        private CT_Rel printerSettingsField;
2167

2168
        private byte[] rsidRPrField;
2169

2170
        private byte[] rsidDelField;
2171

2172
        private byte[] rsidRField;
2173

2174
        private byte[] rsidSectField;
2175

2176
        public CT_SectPrBase()
2177
        {
2178
        }
2179
        public static CT_SectPrBase Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2180
        {
2181
            if (node == null)
2182
                return null;
2183
            CT_SectPrBase ctObj = new CT_SectPrBase();
2184
            ctObj.rsidRPr = XmlHelper.ReadBytes(node.Attributes["w:rsidRPr"]);
2185
            ctObj.rsidDel = XmlHelper.ReadBytes(node.Attributes["w:rsidDel"]);
2186
            ctObj.rsidR = XmlHelper.ReadBytes(node.Attributes["w:rsidR"]);
2187
            ctObj.rsidSect = XmlHelper.ReadBytes(node.Attributes["w:rsidSect"]);
2188
            foreach (XmlNode childNode in node.ChildNodes)
2189
            {
2190
                if (childNode.LocalName == "footnotePr")
2191
                    ctObj.footnotePr = CT_FtnProps.Parse(childNode, namespaceManager);
2192
                else if (childNode.LocalName == "endnotePr")
2193
                    ctObj.endnotePr = CT_EdnProps.Parse(childNode, namespaceManager);
2194
                else if (childNode.LocalName == "type")
2195
                    ctObj.type = CT_SectType.Parse(childNode, namespaceManager);
2196
                else if (childNode.LocalName == "pgSz")
2197
                    ctObj.pgSz = CT_PageSz.Parse(childNode, namespaceManager);
2198
                else if (childNode.LocalName == "pgMar")
2199
                    ctObj.pgMar = CT_PageMar.Parse(childNode, namespaceManager);
2200
                else if (childNode.LocalName == "paperSrc")
2201
                    ctObj.paperSrc = CT_PaperSource.Parse(childNode, namespaceManager);
2202
                else if (childNode.LocalName == "pgBorders")
2203
                    ctObj.pgBorders = CT_PageBorders.Parse(childNode, namespaceManager);
2204
                else if (childNode.LocalName == "lnNumType")
2205
                    ctObj.lnNumType = CT_LineNumber.Parse(childNode, namespaceManager);
2206
                else if (childNode.LocalName == "pgNumType")
2207
                    ctObj.pgNumType = CT_PageNumber.Parse(childNode, namespaceManager);
2208
                else if (childNode.LocalName == "cols")
2209
                    ctObj.cols = CT_Columns.Parse(childNode, namespaceManager);
2210
                else if (childNode.LocalName == "formProt")
2211
                    ctObj.formProt = CT_OnOff.Parse(childNode, namespaceManager);
2212
                else if (childNode.LocalName == "vAlign")
2213
                    ctObj.vAlign = CT_VerticalJc.Parse(childNode, namespaceManager);
2214
                else if (childNode.LocalName == "noEndnote")
2215
                    ctObj.noEndnote = CT_OnOff.Parse(childNode, namespaceManager);
2216
                else if (childNode.LocalName == "titlePg")
2217
                    ctObj.titlePg = CT_OnOff.Parse(childNode, namespaceManager);
2218
                else if (childNode.LocalName == "textDirection")
2219
                    ctObj.textDirection = CT_TextDirection.Parse(childNode, namespaceManager);
2220
                else if (childNode.LocalName == "bidi")
2221
                    ctObj.bidi = CT_OnOff.Parse(childNode, namespaceManager);
2222
                else if (childNode.LocalName == "rtlGutter")
2223
                    ctObj.rtlGutter = CT_OnOff.Parse(childNode, namespaceManager);
2224
                else if (childNode.LocalName == "docGrid")
2225
                    ctObj.docGrid = CT_DocGrid.Parse(childNode, namespaceManager);
2226
                else if (childNode.LocalName == "printerSettings")
2227
                    ctObj.printerSettings = CT_Rel.Parse(childNode, namespaceManager);
2228
            }
2229
            return ctObj;
2230
        }
2231

2232

2233

2234
        internal void Write(StreamWriter sw, string nodeName)
2235
        {
2236
            sw.Write(string.Format("<w:{0}", nodeName));
2237
            XmlHelper.WriteAttribute(sw, "w:rsidRPr", this.rsidRPr);
2238
            XmlHelper.WriteAttribute(sw, "w:rsidDel", this.rsidDel);
2239
            XmlHelper.WriteAttribute(sw, "w:rsidR", this.rsidR);
2240
            XmlHelper.WriteAttribute(sw, "w:rsidSect", this.rsidSect);
2241
            sw.Write(">");
2242
            if (this.footnotePr != null)
2243
                this.footnotePr.Write(sw, "footnotePr");
2244
            if (this.endnotePr != null)
2245
                this.endnotePr.Write(sw, "endnotePr");
2246
            if (this.type != null)
2247
                this.type.Write(sw, "type");
2248
            if (this.pgSz != null)
2249
                this.pgSz.Write(sw, "pgSz");
2250
            if (this.pgMar != null)
2251
                this.pgMar.Write(sw, "pgMar");
2252
            if (this.paperSrc != null)
2253
                this.paperSrc.Write(sw, "paperSrc");
2254
            if (this.pgBorders != null)
2255
                this.pgBorders.Write(sw, "pgBorders");
2256
            if (this.lnNumType != null)
2257
                this.lnNumType.Write(sw, "lnNumType");
2258
            if (this.pgNumType != null)
2259
                this.pgNumType.Write(sw, "pgNumType");
2260
            if (this.cols != null)
2261
                this.cols.Write(sw, "cols");
2262
            if (this.formProt != null)
2263
                this.formProt.Write(sw, "formProt");
2264
            if (this.vAlign != null)
2265
                this.vAlign.Write(sw, "vAlign");
2266
            if (this.noEndnote != null)
2267
                this.noEndnote.Write(sw, "noEndnote");
2268
            if (this.titlePg != null)
2269
                this.titlePg.Write(sw, "titlePg");
2270
            if (this.textDirection != null)
2271
                this.textDirection.Write(sw, "textDirection");
2272
            if (this.bidi != null)
2273
                this.bidi.Write(sw, "bidi");
2274
            if (this.rtlGutter != null)
2275
                this.rtlGutter.Write(sw, "rtlGutter");
2276
            if (this.docGrid != null)
2277
                this.docGrid.Write(sw, "docGrid");
2278
            if (this.printerSettings != null)
2279
                this.printerSettings.Write(sw, "printerSettings");
2280
            sw.WriteEndW(nodeName);
2281
        }
2282

2283
        [XmlElement(Order = 0)]
2284
        public CT_FtnProps footnotePr
2285
        {
2286
            get
2287
            {
2288
                return this.footnotePrField;
2289
            }
2290
            set
2291
            {
2292
                this.footnotePrField = value;
2293
            }
2294
        }
2295

2296
        [XmlElement(Order = 1)]
2297
        public CT_EdnProps endnotePr
2298
        {
2299
            get
2300
            {
2301
                return this.endnotePrField;
2302
            }
2303
            set
2304
            {
2305
                this.endnotePrField = value;
2306
            }
2307
        }
2308

2309
        [XmlElement(Order = 2)]
2310
        public CT_SectType type
2311
        {
2312
            get
2313
            {
2314
                return this.typeField;
2315
            }
2316
            set
2317
            {
2318
                this.typeField = value;
2319
            }
2320
        }
2321

2322
        [XmlElement(Order = 3)]
2323
        public CT_PageSz pgSz
2324
        {
2325
            get
2326
            {
2327
                return this.pgSzField;
2328
            }
2329
            set
2330
            {
2331
                this.pgSzField = value;
2332
            }
2333
        }
2334

2335
        [XmlElement(Order = 4)]
2336
        public CT_PageMar pgMar
2337
        {
2338
            get
2339
            {
2340
                return this.pgMarField;
2341
            }
2342
            set
2343
            {
2344
                this.pgMarField = value;
2345
            }
2346
        }
2347

2348
        [XmlElement(Order = 5)]
2349
        public CT_PaperSource paperSrc
2350
        {
2351
            get
2352
            {
2353
                return this.paperSrcField;
2354
            }
2355
            set
2356
            {
2357
                this.paperSrcField = value;
2358
            }
2359
        }
2360

2361
        [XmlElement(Order = 6)]
2362
        public CT_PageBorders pgBorders
2363
        {
2364
            get
2365
            {
2366
                return this.pgBordersField;
2367
            }
2368
            set
2369
            {
2370
                this.pgBordersField = value;
2371
            }
2372
        }
2373

2374
        [XmlElement(Order = 7)]
2375
        public CT_LineNumber lnNumType
2376
        {
2377
            get
2378
            {
2379
                return this.lnNumTypeField;
2380
            }
2381
            set
2382
            {
2383
                this.lnNumTypeField = value;
2384
            }
2385
        }
2386

2387
        [XmlElement(Order = 8)]
2388
        public CT_PageNumber pgNumType
2389
        {
2390
            get
2391
            {
2392
                return this.pgNumTypeField;
2393
            }
2394
            set
2395
            {
2396
                this.pgNumTypeField = value;
2397
            }
2398
        }
2399

2400
        [XmlElement(Order = 9)]
2401
        public CT_Columns cols
2402
        {
2403
            get
2404
            {
2405
                return this.colsField;
2406
            }
2407
            set
2408
            {
2409
                this.colsField = value;
2410
            }
2411
        }
2412

2413
        [XmlElement(Order = 10)]
2414
        public CT_OnOff formProt
2415
        {
2416
            get
2417
            {
2418
                return this.formProtField;
2419
            }
2420
            set
2421
            {
2422
                this.formProtField = value;
2423
            }
2424
        }
2425

2426
        [XmlElement(Order = 11)]
2427
        public CT_VerticalJc vAlign
2428
        {
2429
            get
2430
            {
2431
                return this.vAlignField;
2432
            }
2433
            set
2434
            {
2435
                this.vAlignField = value;
2436
            }
2437
        }
2438

2439
        [XmlElement(Order = 12)]
2440
        public CT_OnOff noEndnote
2441
        {
2442
            get
2443
            {
2444
                return this.noEndnoteField;
2445
            }
2446
            set
2447
            {
2448
                this.noEndnoteField = value;
2449
            }
2450
        }
2451

2452
        [XmlElement(Order = 13)]
2453
        public CT_OnOff titlePg
2454
        {
2455
            get
2456
            {
2457
                return this.titlePgField;
2458
            }
2459
            set
2460
            {
2461
                this.titlePgField = value;
2462
            }
2463
        }
2464

2465
        [XmlElement(Order = 14)]
2466
        public CT_TextDirection textDirection
2467
        {
2468
            get
2469
            {
2470
                return this.textDirectionField;
2471
            }
2472
            set
2473
            {
2474
                this.textDirectionField = value;
2475
            }
2476
        }
2477

2478
        [XmlElement(Order = 15)]
2479
        public CT_OnOff bidi
2480
        {
2481
            get
2482
            {
2483
                return this.bidiField;
2484
            }
2485
            set
2486
            {
2487
                this.bidiField = value;
2488
            }
2489
        }
2490

2491
        [XmlElement(Order = 16)]
2492
        public CT_OnOff rtlGutter
2493
        {
2494
            get
2495
            {
2496
                return this.rtlGutterField;
2497
            }
2498
            set
2499
            {
2500
                this.rtlGutterField = value;
2501
            }
2502
        }
2503

2504
        [XmlElement(Order = 17)]
2505
        public CT_DocGrid docGrid
2506
        {
2507
            get
2508
            {
2509
                return this.docGridField;
2510
            }
2511
            set
2512
            {
2513
                this.docGridField = value;
2514
            }
2515
        }
2516

2517
        [XmlElement(Order = 18)]
2518
        public CT_Rel printerSettings
2519
        {
2520
            get
2521
            {
2522
                return this.printerSettingsField;
2523
            }
2524
            set
2525
            {
2526
                this.printerSettingsField = value;
2527
            }
2528
        }
2529

2530
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2531
        public byte[] rsidRPr
2532
        {
2533
            get
2534
            {
2535
                return this.rsidRPrField;
2536
            }
2537
            set
2538
            {
2539
                this.rsidRPrField = value;
2540
            }
2541
        }
2542

2543
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2544
        public byte[] rsidDel
2545
        {
2546
            get
2547
            {
2548
                return this.rsidDelField;
2549
            }
2550
            set
2551
            {
2552
                this.rsidDelField = value;
2553
            }
2554
        }
2555

2556
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2557
        public byte[] rsidR
2558
        {
2559
            get
2560
            {
2561
                return this.rsidRField;
2562
            }
2563
            set
2564
            {
2565
                this.rsidRField = value;
2566
            }
2567
        }
2568

2569
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2570
        public byte[] rsidSect
2571
        {
2572
            get
2573
            {
2574
                return this.rsidSectField;
2575
            }
2576
            set
2577
            {
2578
                this.rsidSectField = value;
2579
            }
2580
        }
2581
    }
2582

2583
    
2584
    [Serializable]
2585

2586
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2587
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2588
    public class CT_SectPr
2589
    {
2590
        private CT_FtnProps footnotePrField;
2591

2592
        private CT_EdnProps endnotePrField;
2593

2594
        private CT_SectType typeField;
2595

2596
        private CT_PageSz pgSzField;
2597

2598
        private CT_PageMar pgMarField;
2599

2600
        private CT_PaperSource paperSrcField;
2601

2602
        private CT_PageBorders pgBordersField;
2603

2604
        private CT_LineNumber lnNumTypeField;
2605

2606
        private CT_PageNumber pgNumTypeField;
2607

2608
        private CT_Columns colsField;
2609

2610
        private CT_OnOff formProtField;
2611

2612
        private CT_VerticalJc vAlignField;
2613

2614
        private CT_OnOff noEndnoteField;
2615

2616
        private CT_OnOff titlePgField;
2617

2618
        private CT_TextDirection textDirectionField;
2619

2620
        private CT_OnOff bidiField;
2621

2622
        private CT_OnOff rtlGutterField;
2623

2624
        private CT_DocGrid docGridField;
2625

2626
        private CT_Rel printerSettingsField;
2627

2628
        private CT_SectPrChange sectPrChangeField;
2629

2630
        private byte[] rsidRPrField;
2631

2632
        private byte[] rsidDelField;
2633

2634
        private byte[] rsidRField;
2635

2636
        private byte[] rsidSectField;
2637

2638
        public CT_SectPr()
2639
        {
2640
            this.colsField = new CT_Columns();
2641
            this.cols.space = 425;
2642
            this.cols.spaceSpecified = true;
2643
            this.pgMarField = new CT_PageMar();
2644
            this.pgMar.top = 1440;
2645
            this.pgMar.right = 1800;
2646
            this.pgMar.bottom = 1440;
2647
            this.pgMar.left = 1800;
2648
            this.pgMar.header = 851;
2649
            this.pgMar.footer = 992;
2650
            this.pgMar.gutter = 0;
2651

2652
            this.pgSzField = new CT_PageSz();
2653
            this.pgSz.w = 11906;
2654
            this.pgSz.wSpecified = true;
2655
            this.pgSz.h = 16838;
2656
            this.pgSz.hSpecified = true;
2657

2658
            //this.typeField = new CT_SectType();
2659
            //this.endnotePrField = new CT_EdnProps();
2660
            //this.footnotePrField = new CT_FtnProps();
2661
            //this.itemsElementNameField = new List<ItemsChoiceHdrFtrRefType>();
2662
            //this.itemsField = new List<CT_HdrFtrRef>();
2663
        }
2664
        List<CT_HdrFtrRef> footerReferenceField;
2665
        public List<CT_HdrFtrRef> footerReference
2666
        {
2667
            get { return this.footerReferenceField; }
2668
            set { this.footerReferenceField = value; }
2669
        }
2670

2671
        List<CT_HdrFtrRef> headerReferenceField;
2672
        public List<CT_HdrFtrRef> headerReference
2673
        {
2674
            get { return this.headerReferenceField; }
2675
            set { this.headerReferenceField = value; }
2676
        }
2677

2678
        [XmlElement(Order = 2)]
2679
        public CT_FtnProps footnotePr
2680
        {
2681
            get
2682
            {
2683
                return this.footnotePrField;
2684
            }
2685
            set
2686
            {
2687
                this.footnotePrField = value;
2688
            }
2689
        }
2690

2691
        [XmlElement(Order = 3)]
2692
        public CT_EdnProps endnotePr
2693
        {
2694
            get
2695
            {
2696
                return this.endnotePrField;
2697
            }
2698
            set
2699
            {
2700
                this.endnotePrField = value;
2701
            }
2702
        }
2703

2704
        [XmlElement(Order = 4)]
2705
        public CT_SectType type
2706
        {
2707
            get
2708
            {
2709
                return this.typeField;
2710
            }
2711
            set
2712
            {
2713
                this.typeField = value;
2714
            }
2715
        }
2716

2717
        [XmlElement(Order = 5)]
2718
        public CT_PageSz pgSz
2719
        {
2720
            get
2721
            {
2722
                return this.pgSzField;
2723
            }
2724
            set
2725
            {
2726
                this.pgSzField = value;
2727
            }
2728
        }
2729

2730
        [XmlElement(Order = 6)]
2731
        public CT_PageMar pgMar
2732
        {
2733
            get
2734
            {
2735
                return this.pgMarField;
2736
            }
2737
            set
2738
            {
2739
                this.pgMarField = value;
2740
            }
2741
        }
2742

2743
        [XmlElement(Order = 7)]
2744
        public CT_PaperSource paperSrc
2745
        {
2746
            get
2747
            {
2748
                return this.paperSrcField;
2749
            }
2750
            set
2751
            {
2752
                this.paperSrcField = value;
2753
            }
2754
        }
2755

2756
        [XmlElement(Order = 8)]
2757
        public CT_PageBorders pgBorders
2758
        {
2759
            get
2760
            {
2761
                return this.pgBordersField;
2762
            }
2763
            set
2764
            {
2765
                this.pgBordersField = value;
2766
            }
2767
        }
2768

2769
        [XmlElement(Order = 9)]
2770
        public CT_LineNumber lnNumType
2771
        {
2772
            get
2773
            {
2774
                return this.lnNumTypeField;
2775
            }
2776
            set
2777
            {
2778
                this.lnNumTypeField = value;
2779
            }
2780
        }
2781

2782
        [XmlElement(Order = 10)]
2783
        public CT_PageNumber pgNumType
2784
        {
2785
            get
2786
            {
2787
                return this.pgNumTypeField;
2788
            }
2789
            set
2790
            {
2791
                this.pgNumTypeField = value;
2792
            }
2793
        }
2794

2795
        [XmlElement(Order = 11)]
2796
        public CT_Columns cols
2797
        {
2798
            get
2799
            {
2800
                return this.colsField;
2801
            }
2802
            set
2803
            {
2804
                this.colsField = value;
2805
            }
2806
        }
2807

2808
        [XmlElement(Order = 12)]
2809
        public CT_OnOff formProt
2810
        {
2811
            get
2812
            {
2813
                return this.formProtField;
2814
            }
2815
            set
2816
            {
2817
                this.formProtField = value;
2818
            }
2819
        }
2820

2821
        [XmlElement(Order = 13)]
2822
        public CT_VerticalJc vAlign
2823
        {
2824
            get
2825
            {
2826
                return this.vAlignField;
2827
            }
2828
            set
2829
            {
2830
                this.vAlignField = value;
2831
            }
2832
        }
2833

2834
        [XmlElement(Order = 14)]
2835
        public CT_OnOff noEndnote
2836
        {
2837
            get
2838
            {
2839
                return this.noEndnoteField;
2840
            }
2841
            set
2842
            {
2843
                this.noEndnoteField = value;
2844
            }
2845
        }
2846

2847
        [XmlElement(Order = 15)]
2848
        public CT_OnOff titlePg
2849
        {
2850
            get
2851
            {
2852
                return this.titlePgField;
2853
            }
2854
            set
2855
            {
2856
                this.titlePgField = value;
2857
            }
2858
        }
2859

2860
        [XmlElement(Order = 16)]
2861
        public CT_TextDirection textDirection
2862
        {
2863
            get
2864
            {
2865
                return this.textDirectionField;
2866
            }
2867
            set
2868
            {
2869
                this.textDirectionField = value;
2870
            }
2871
        }
2872

2873
        [XmlElement(Order = 17)]
2874
        public CT_OnOff bidi
2875
        {
2876
            get
2877
            {
2878
                return this.bidiField;
2879
            }
2880
            set
2881
            {
2882
                this.bidiField = value;
2883
            }
2884
        }
2885

2886
        [XmlElement(Order = 18)]
2887
        public CT_OnOff rtlGutter
2888
        {
2889
            get
2890
            {
2891
                return this.rtlGutterField;
2892
            }
2893
            set
2894
            {
2895
                this.rtlGutterField = value;
2896
            }
2897
        }
2898

2899
        [XmlElement(Order = 19)]
2900
        public CT_DocGrid docGrid
2901
        {
2902
            get
2903
            {
2904
                return this.docGridField;
2905
            }
2906
            set
2907
            {
2908
                this.docGridField = value;
2909
            }
2910
        }
2911

2912
        [XmlElement(Order = 20)]
2913
        public CT_Rel printerSettings
2914
        {
2915
            get
2916
            {
2917
                return this.printerSettingsField;
2918
            }
2919
            set
2920
            {
2921
                this.printerSettingsField = value;
2922
            }
2923
        }
2924

2925
        [XmlElement(Order = 21)]
2926
        public CT_SectPrChange sectPrChange
2927
        {
2928
            get
2929
            {
2930
                return this.sectPrChangeField;
2931
            }
2932
            set
2933
            {
2934
                this.sectPrChangeField = value;
2935
            }
2936
        }
2937

2938
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2939
        public byte[] rsidRPr
2940
        {
2941
            get
2942
            {
2943
                return this.rsidRPrField;
2944
            }
2945
            set
2946
            {
2947
                this.rsidRPrField = value;
2948
            }
2949
        }
2950

2951
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2952
        public byte[] rsidDel
2953
        {
2954
            get
2955
            {
2956
                return this.rsidDelField;
2957
            }
2958
            set
2959
            {
2960
                this.rsidDelField = value;
2961
            }
2962
        }
2963

2964
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2965
        public byte[] rsidR
2966
        {
2967
            get
2968
            {
2969
                return this.rsidRField;
2970
            }
2971
            set
2972
            {
2973
                this.rsidRField = value;
2974
            }
2975
        }
2976

2977
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
2978
        public byte[] rsidSect
2979
        {
2980
            get
2981
            {
2982
                return this.rsidSectField;
2983
            }
2984
            set
2985
            {
2986
                this.rsidSectField = value;
2987
            }
2988
        }
2989

2990
        public bool IsSetTitlePg()
2991
        {
2992
            return this.titlePgField != null;
2993
        }
2994

2995
        public CT_OnOff AddNewTitlePg()
2996
        {
2997
            if (this.titlePgField == null)
2998
                this.titlePgField = new CT_OnOff();
2999
            return this.titlePgField;
3000
        }
3001

3002
        public CT_PageMar AddPageMar()
3003
        {
3004
            this.pgMar = new CT_PageMar();
3005
            return this.pgMar;
3006
        }
3007
        public CT_HdrFtrRef AddNewHeaderReference()
3008
        {
3009
            CT_HdrFtrRef ref1 = new CT_HdrFtrRef();
3010
            if (this.headerReferenceField == null)
3011
                this.headerReferenceField = new List<CT_HdrFtrRef>();
3012

3013
            this.headerReferenceField.Add(ref1);
3014
            return ref1;
3015
        }
3016

3017
        public CT_HdrFtrRef AddNewFooterReference()
3018
        {
3019
            CT_HdrFtrRef ref1 = new CT_HdrFtrRef();
3020
            if (this.footerReferenceField == null)
3021
                this.footerReferenceField = new List<CT_HdrFtrRef>();
3022
            this.footerReferenceField.Add(ref1);
3023
            return ref1;
3024
        }
3025
        public int SizeOfHeaderReferenceArray()
3026
        {
3027
            if (headerReferenceField == null)
3028
                return 0;
3029
            return headerReferenceField.Count;
3030
        }
3031
        public CT_HdrFtrRef GetHeaderReferenceArray(int i)
3032
        {
3033
            if (headerReferenceField == null)
3034
                return null;
3035
            return headerReferenceField[i];
3036
        }
3037

3038
        public int SizeOfFooterReferenceArray()
3039
        {
3040
            if (footerReferenceField == null)
3041
                return 0;
3042
            return footerReferenceField.Count;
3043
        }
3044

3045
        public CT_HdrFtrRef GetFooterReferenceArray(int i)
3046
        {
3047
            if (footerReferenceField == null)
3048
                return null;
3049
            return footerReferenceField[i];
3050
        }
3051

3052
        public static CT_SectPr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3053
        {
3054
            if (node == null)
3055
                return null;
3056
            CT_SectPr ctObj = new CT_SectPr();
3057
            ctObj.rsidRPr = XmlHelper.ReadBytes(node.Attributes["w:rsidRPr"]);
3058
            ctObj.rsidDel = XmlHelper.ReadBytes(node.Attributes["w:rsidDel"]);
3059
            ctObj.rsidR = XmlHelper.ReadBytes(node.Attributes["w:rsidR"]);
3060
            ctObj.rsidSect = XmlHelper.ReadBytes(node.Attributes["w:rsidSect"]);
3061
            ctObj.footerReference = new List<CT_HdrFtrRef>();
3062
            ctObj.headerReference = new List<CT_HdrFtrRef>();
3063
            foreach (XmlNode childNode in node.ChildNodes)
3064
            {
3065
                if (childNode.LocalName == "footnotePr")
3066
                    ctObj.footnotePr = CT_FtnProps.Parse(childNode, namespaceManager);
3067
                else if (childNode.LocalName == "endnotePr")
3068
                    ctObj.endnotePr = CT_EdnProps.Parse(childNode, namespaceManager);
3069
                else if (childNode.LocalName == "type")
3070
                    ctObj.type = CT_SectType.Parse(childNode, namespaceManager);
3071
                else if (childNode.LocalName == "pgSz")
3072
                    ctObj.pgSz = CT_PageSz.Parse(childNode, namespaceManager);
3073
                else if (childNode.LocalName == "pgMar")
3074
                    ctObj.pgMar = CT_PageMar.Parse(childNode, namespaceManager);
3075
                else if (childNode.LocalName == "paperSrc")
3076
                    ctObj.paperSrc = CT_PaperSource.Parse(childNode, namespaceManager);
3077
                else if (childNode.LocalName == "pgBorders")
3078
                    ctObj.pgBorders = CT_PageBorders.Parse(childNode, namespaceManager);
3079
                else if (childNode.LocalName == "lnNumType")
3080
                    ctObj.lnNumType = CT_LineNumber.Parse(childNode, namespaceManager);
3081
                else if (childNode.LocalName == "pgNumType")
3082
                    ctObj.pgNumType = CT_PageNumber.Parse(childNode, namespaceManager);
3083
                else if (childNode.LocalName == "cols")
3084
                    ctObj.cols = CT_Columns.Parse(childNode, namespaceManager);
3085
                else if (childNode.LocalName == "formProt")
3086
                    ctObj.formProt = CT_OnOff.Parse(childNode, namespaceManager);
3087
                else if (childNode.LocalName == "vAlign")
3088
                    ctObj.vAlign = CT_VerticalJc.Parse(childNode, namespaceManager);
3089
                else if (childNode.LocalName == "noEndnote")
3090
                    ctObj.noEndnote = CT_OnOff.Parse(childNode, namespaceManager);
3091
                else if (childNode.LocalName == "titlePg")
3092
                    ctObj.titlePg = CT_OnOff.Parse(childNode, namespaceManager);
3093
                else if (childNode.LocalName == "textDirection")
3094
                    ctObj.textDirection = CT_TextDirection.Parse(childNode, namespaceManager);
3095
                else if (childNode.LocalName == "bidi")
3096
                    ctObj.bidi = CT_OnOff.Parse(childNode, namespaceManager);
3097
                else if (childNode.LocalName == "rtlGutter")
3098
                    ctObj.rtlGutter = CT_OnOff.Parse(childNode, namespaceManager);
3099
                else if (childNode.LocalName == "docGrid")
3100
                    ctObj.docGrid = CT_DocGrid.Parse(childNode, namespaceManager);
3101
                else if (childNode.LocalName == "printerSettings")
3102
                    ctObj.printerSettings = CT_Rel.Parse(childNode, namespaceManager);
3103
                else if (childNode.LocalName == "sectPrChange")
3104
                    ctObj.sectPrChange = CT_SectPrChange.Parse(childNode, namespaceManager);
3105
                else if (childNode.LocalName == "footerReference")
3106
                    ctObj.footerReference.Add(CT_HdrFtrRef.Parse(childNode, namespaceManager));
3107
                else if (childNode.LocalName == "headerReference")
3108
                    ctObj.headerReference.Add(CT_HdrFtrRef.Parse(childNode, namespaceManager));
3109
            }
3110
            return ctObj;
3111
        }
3112

3113

3114

3115
        internal void Write(StreamWriter sw, string nodeName)
3116
        {
3117
            sw.Write(string.Format("<w:{0}", nodeName));
3118
            XmlHelper.WriteAttribute(sw, "w:rsidR", this.rsidR);
3119
            XmlHelper.WriteAttribute(sw, "w:rsidRPr", this.rsidRPr);
3120
            XmlHelper.WriteAttribute(sw, "w:rsidSect", this.rsidSect);
3121
            XmlHelper.WriteAttribute(sw, "w:rsidDel", this.rsidDel);
3122
            sw.Write(">");
3123
            if (this.headerReference != null)
3124
            {
3125
                foreach (CT_HdrFtrRef x in this.headerReference)
3126
                {
3127
                    x.Write(sw, "headerReference");
3128
                }
3129
            }
3130
            if (this.footerReference != null)
3131
            {
3132
                foreach (CT_HdrFtrRef x in this.footerReference)
3133
                {
3134
                    x.Write(sw, "footerReference");
3135
                }
3136
            }
3137
            if (this.footnotePr != null)
3138
                this.footnotePr.Write(sw, "footnotePr");
3139
            if (this.endnotePr != null)
3140
                this.endnotePr.Write(sw, "endnotePr");
3141
            if (this.type != null)
3142
                this.type.Write(sw, "type");
3143
            if (this.pgSz != null)
3144
                this.pgSz.Write(sw, "pgSz");
3145
            if (this.pgMar != null)
3146
                this.pgMar.Write(sw, "pgMar");
3147
            if (this.paperSrc != null)
3148
                this.paperSrc.Write(sw, "paperSrc");
3149
            if (this.pgBorders != null)
3150
                this.pgBorders.Write(sw, "pgBorders");
3151
            if (this.lnNumType != null)
3152
                this.lnNumType.Write(sw, "lnNumType");
3153
            if (this.pgNumType != null)
3154
                this.pgNumType.Write(sw, "pgNumType");
3155
            if (this.cols != null)
3156
                this.cols.Write(sw, "cols");
3157
            if (this.formProt != null)
3158
                this.formProt.Write(sw, "formProt");
3159
            if (this.vAlign != null)
3160
                this.vAlign.Write(sw, "vAlign");
3161
            if (this.noEndnote != null)
3162
                this.noEndnote.Write(sw, "noEndnote");
3163
            if (this.titlePg != null)
3164
                this.titlePg.Write(sw, "titlePg");
3165
            if (this.textDirection != null)
3166
                this.textDirection.Write(sw, "textDirection");
3167
            if (this.bidi != null)
3168
                this.bidi.Write(sw, "bidi");
3169
            if (this.rtlGutter != null)
3170
                this.rtlGutter.Write(sw, "rtlGutter");
3171
            if (this.docGrid != null)
3172
                this.docGrid.Write(sw, "docGrid");
3173
            if (this.printerSettings != null)
3174
                this.printerSettings.Write(sw, "printerSettings");
3175
            if (this.sectPrChange != null)
3176
                this.sectPrChange.Write(sw, "sectPrChange");
3177
            sw.WriteEndW(nodeName);
3178
        }
3179

3180

3181
    }
3182
    [Serializable]
3183

3184
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3185
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
3186
    public class CT_PBdr
3187
    {
3188

3189
        private CT_Border topField;
3190

3191
        private CT_Border leftField;
3192

3193
        private CT_Border bottomField;
3194

3195
        private CT_Border rightField;
3196

3197
        private CT_Border betweenField;
3198

3199
        private CT_Border barField;
3200

3201
        public CT_PBdr()
3202
        {
3203

3204
        }
3205
        public static CT_PBdr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3206
        {
3207
            if (node == null)
3208
                return null;
3209
            CT_PBdr ctObj = new CT_PBdr();
3210
            foreach (XmlNode childNode in node.ChildNodes)
3211
            {
3212
                if (childNode.LocalName == "top")
3213
                    ctObj.top = CT_Border.Parse(childNode, namespaceManager);
3214
                else if (childNode.LocalName == "left")
3215
                    ctObj.left = CT_Border.Parse(childNode, namespaceManager);
3216
                else if (childNode.LocalName == "bottom")
3217
                    ctObj.bottom = CT_Border.Parse(childNode, namespaceManager);
3218
                else if (childNode.LocalName == "right")
3219
                    ctObj.right = CT_Border.Parse(childNode, namespaceManager);
3220
                else if (childNode.LocalName == "between")
3221
                    ctObj.between = CT_Border.Parse(childNode, namespaceManager);
3222
                else if (childNode.LocalName == "bar")
3223
                    ctObj.bar = CT_Border.Parse(childNode, namespaceManager);
3224
            }
3225
            return ctObj;
3226
        }
3227

3228

3229

3230
        internal void Write(StreamWriter sw, string nodeName)
3231
        {
3232
            sw.Write(string.Format("<w:{0}", nodeName));
3233
            sw.Write(">");
3234
            if (this.top != null)
3235
                this.top.Write(sw, "top");
3236
            if (this.left != null)
3237
                this.left.Write(sw, "left");
3238
            if (this.bottom != null)
3239
                this.bottom.Write(sw, "bottom");
3240
            if (this.right != null)
3241
                this.right.Write(sw, "right");
3242
            if (this.between != null)
3243
                this.between.Write(sw, "between");
3244
            if (this.bar != null)
3245
                this.bar.Write(sw, "bar");
3246
            sw.WriteEndW(nodeName);
3247
        }
3248

3249

3250

3251
        [XmlElement(Order = 0)]
3252
        public CT_Border top
3253
        {
3254
            get
3255
            {
3256
                return this.topField;
3257
            }
3258
            set
3259
            {
3260
                this.topField = value;
3261
            }
3262
        }
3263

3264
        [XmlElement(Order = 1)]
3265
        public CT_Border left
3266
        {
3267
            get
3268
            {
3269
                return this.leftField;
3270
            }
3271
            set
3272
            {
3273
                this.leftField = value;
3274
            }
3275
        }
3276

3277
        [XmlElement(Order = 2)]
3278
        public CT_Border bottom
3279
        {
3280
            get
3281
            {
3282
                return this.bottomField;
3283
            }
3284
            set
3285
            {
3286
                this.bottomField = value;
3287
            }
3288
        }
3289

3290
        [XmlElement(Order = 3)]
3291
        public CT_Border right
3292
        {
3293
            get
3294
            {
3295
                return this.rightField;
3296
            }
3297
            set
3298
            {
3299
                this.rightField = value;
3300
            }
3301
        }
3302

3303
        [XmlElement(Order = 4)]
3304
        public CT_Border between
3305
        {
3306
            get
3307
            {
3308
                return this.betweenField;
3309
            }
3310
            set
3311
            {
3312
                this.betweenField = value;
3313
            }
3314
        }
3315

3316
        [XmlElement(Order = 5)]
3317
        public CT_Border bar
3318
        {
3319
            get
3320
            {
3321
                return this.barField;
3322
            }
3323
            set
3324
            {
3325
                this.barField = value;
3326
            }
3327
        }
3328

3329
        public bool IsSetTop()
3330
        {
3331
            return this.topField != null && this.topField.val != ST_Border.none && this.topField.val != ST_Border.nil;
3332
        }
3333

3334
        public CT_Border AddNewTop()
3335
        {
3336
            if (this.topField == null)
3337
                this.topField = new CT_Border();
3338
            return this.topField;
3339
        }
3340

3341
        public void UnsetTop()
3342
        {
3343
            this.topField = new CT_Border();//?? set a new border or set null;
3344
        }
3345

3346
        public bool IsSetBottom()
3347
        {
3348
            return this.bottomField != null && this.bottomField.val != ST_Border.none && this.bottomField.val != ST_Border.nil;
3349
        }
3350

3351
        public CT_Border AddNewBottom()
3352
        {
3353
            if (this.bottomField == null)
3354
                this.bottomField = new CT_Border();
3355
            return this.bottomField;
3356
        }
3357

3358
        public void UnsetBottom()
3359
        {
3360
            this.bottomField = null;// new CT_Border();
3361
        }
3362

3363
        public bool IsSetRight()
3364
        {
3365
            return this.rightField != null && this.rightField.val != ST_Border.none && this.rightField.val != ST_Border.nil;
3366
        }
3367

3368
        public void UnsetRight()
3369
        {
3370
            this.rightField = null;// new CT_Border();
3371
        }
3372

3373
        public CT_Border AddNewRight()
3374
        {
3375
            if (this.rightField == null)
3376
                this.rightField = new CT_Border();
3377
            return this.rightField;
3378
        }
3379

3380
        public bool IsSetBetween()
3381
        {
3382
            return this.betweenField != null && this.betweenField.val != ST_Border.none && this.betweenField.val != ST_Border.nil;
3383
        }
3384

3385
        public CT_Border AddNewBetween()
3386
        {
3387
            if (this.betweenField == null)
3388
                this.betweenField = new CT_Border();
3389
            return this.betweenField;
3390
        }
3391

3392
        public void UnsetBetween()
3393
        {
3394
            this.betweenField = null;// new CT_Border();
3395
        }
3396

3397
        public bool IsSetLeft()
3398
        {
3399
            return this.leftField != null && this.leftField.val != ST_Border.none && this.leftField.val != ST_Border.nil;
3400
        }
3401

3402
        public CT_Border AddNewLeft()
3403
        {
3404
            if (this.leftField == null)
3405
                this.leftField = new CT_Border();
3406
            return this.leftField;
3407
        }
3408

3409
        public void UnsetLeft()
3410
        {
3411
            this.leftField = null;// new CT_Border();
3412
        }
3413
    }
3414

3415
    [Serializable]
3416

3417
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3418
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
3419
    public class CT_Spacing
3420
    {
3421

3422
        private ulong? beforeField;
3423

3424
        private string beforeLinesField;
3425

3426
        private ST_OnOff beforeAutospacingField;
3427

3428
        private bool beforeAutospacingFieldSpecified;
3429

3430
        private ulong? afterField;
3431

3432
        private string afterLinesField;
3433

3434
        private ST_OnOff afterAutospacingField;
3435

3436
        private bool afterAutospacingFieldSpecified;
3437

3438
        private string lineField;
3439

3440
        private ST_LineSpacingRule lineRuleField;
3441

3442
        private bool lineRuleFieldSpecified;
3443
        public static CT_Spacing Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3444
        {
3445
            if (node == null)
3446
                return null;
3447
            CT_Spacing ctObj = new CT_Spacing();
3448
            if(node.Attributes["w:before"]!=null)
3449
                ctObj.before = XmlHelper.ReadULong(node.Attributes["w:before"]);
3450
            ctObj.beforeLines = XmlHelper.ReadString(node.Attributes["w:beforeLines"]);
3451
            if (node.Attributes["w:beforeAutospacing"] != null)
3452
                ctObj.beforeAutospacing = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:beforeAutospacing"].Value,true);
3453
            if (node.Attributes["w:after"] != null)
3454
                ctObj.after = XmlHelper.ReadULong(node.Attributes["w:after"]);
3455
            ctObj.afterLines = XmlHelper.ReadString(node.Attributes["w:afterLines"]);
3456
            if (node.Attributes["w:afterAutospacing"] != null)
3457
                ctObj.afterAutospacing = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:afterAutospacing"].Value,true);
3458
            ctObj.line = XmlHelper.ReadString(node.Attributes["w:line"]);
3459
            if (node.Attributes["w:lineRule"] != null)
3460
                ctObj.lineRule = (ST_LineSpacingRule)Enum.Parse(typeof(ST_LineSpacingRule), node.Attributes["w:lineRule"].Value);
3461
            return ctObj;
3462
        }
3463

3464

3465

3466
        internal void Write(StreamWriter sw, string nodeName)
3467
        {
3468
            sw.Write(string.Format("<w:{0}", nodeName));
3469
            if(this.beforeField != null)
3470
                XmlHelper.WriteAttribute(sw, "w:before", (ulong)this.before, true);
3471
            XmlHelper.WriteAttribute(sw, "w:beforeLines", this.beforeLines);
3472
            if(this.beforeAutospacing!= ST_OnOff.off)
3473
                XmlHelper.WriteAttribute(sw, "w:beforeAutospacing", this.beforeAutospacing.ToString());
3474
            if (this.afterField != null)
3475
                XmlHelper.WriteAttribute(sw, "w:after", (ulong)this.after, true);
3476
            XmlHelper.WriteAttribute(sw, "w:afterLines", this.afterLines);
3477
            if (this.afterAutospacing != ST_OnOff.off)
3478
                XmlHelper.WriteAttribute(sw, "w:afterAutospacing", this.afterAutospacing.ToString());
3479
            XmlHelper.WriteAttribute(sw, "w:line", this.line);
3480
            if(this.lineRule!= ST_LineSpacingRule.nil)
3481
                XmlHelper.WriteAttribute(sw, "w:lineRule", this.lineRule.ToString());
3482
            sw.Write("/>");
3483
        }
3484

3485

3486
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3487
        public ulong? before
3488
        {
3489
            get
3490
            {
3491
                return this.beforeField;
3492
            }
3493
            set
3494
            {
3495
                this.beforeField = value;
3496
            }
3497
        }
3498

3499
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3500
        public string beforeLines
3501
        {
3502
            get
3503
            {
3504
                return this.beforeLinesField;
3505
            }
3506
            set
3507
            {
3508
                this.beforeLinesField = value;
3509
            }
3510
        }
3511

3512
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3513
        public ST_OnOff beforeAutospacing
3514
        {
3515
            get
3516
            {
3517
                return this.beforeAutospacingField;
3518
            }
3519
            set
3520
            {
3521
                this.beforeAutospacingField = value;
3522
            }
3523
        }
3524

3525
        [XmlIgnore]
3526
        public bool beforeAutospacingSpecified
3527
        {
3528
            get
3529
            {
3530
                return this.beforeAutospacingFieldSpecified;
3531
            }
3532
            set
3533
            {
3534
                this.beforeAutospacingFieldSpecified = value;
3535
            }
3536
        }
3537

3538
        public ulong? after
3539
        {
3540
            get
3541
            {
3542
                return this.afterField;
3543
            }
3544
            set
3545
            {
3546
                this.afterField = value;
3547
            }
3548
        }
3549

3550
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3551
        public string afterLines
3552
        {
3553
            get
3554
            {
3555
                return this.afterLinesField;
3556
            }
3557
            set
3558
            {
3559
                this.afterLinesField = value;
3560
            }
3561
        }
3562

3563
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3564
        public ST_OnOff afterAutospacing
3565
        {
3566
            get
3567
            {
3568
                return this.afterAutospacingField;
3569
            }
3570
            set
3571
            {
3572
                this.afterAutospacingField = value;
3573
            }
3574
        }
3575

3576
        [XmlIgnore]
3577
        public bool afterAutospacingSpecified
3578
        {
3579
            get
3580
            {
3581
                return this.afterAutospacingFieldSpecified;
3582
            }
3583
            set
3584
            {
3585
                this.afterAutospacingFieldSpecified = value;
3586
            }
3587
        }
3588

3589
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3590
        public string line
3591
        {
3592
            get
3593
            {
3594
                return this.lineField;
3595
            }
3596
            set
3597
            {
3598
                this.lineField = value;
3599
            }
3600
        }
3601

3602
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3603
        public ST_LineSpacingRule lineRule
3604
        {
3605
            get
3606
            {
3607
                return this.lineRuleField;
3608
            }
3609
            set
3610
            {
3611
                this.lineRuleField = value;
3612
            }
3613
        }
3614

3615
        [XmlIgnore]
3616
        public bool lineRuleSpecified
3617
        {
3618
            get
3619
            {
3620
                return this.lineRuleFieldSpecified;
3621
            }
3622
            set
3623
            {
3624
                this.lineRuleFieldSpecified = value;
3625
            }
3626
        }
3627

3628
        public bool IsSetBefore()
3629
        {
3630
            return this.beforeField != null;
3631
        }
3632

3633
        public bool IsSetBeforeLines()
3634
        {
3635
            return !string.IsNullOrEmpty(this.beforeLinesField);
3636
        }
3637

3638
        public bool IsSetLineRule()
3639
        {
3640
            return !(this.lineRuleField == ST_LineSpacingRule.nil);
3641
        }
3642

3643
        public bool IsSetLine() => !string.IsNullOrEmpty(this.lineField);
3644
        public bool IsSetBetweenLines() => IsSetLine();
3645

3646
        public bool IsSetAfter()
3647
        {
3648
            return !(this.afterField == 0);
3649
        }
3650

3651
        public bool IsSetAfterLines()
3652
        {
3653
            return !string.IsNullOrEmpty(this.afterLinesField);
3654
        }
3655
    }
3656

3657

3658
    [Serializable]
3659
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3660
    public enum ST_LineSpacingRule
3661
    {
3662
        nil,
3663
    
3664
        auto,
3665

3666
    
3667
        exact,
3668

3669
    
3670
        atLeast,
3671
    }
3672

3673

3674
    [Serializable]
3675

3676
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3677
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
3678
    public class CT_Ind
3679
    {
3680

3681
        private string leftField;
3682

3683
        private string leftCharsField;
3684

3685
        private string rightField;
3686

3687
        private string rightCharsField;
3688

3689
        private ulong hangingField;
3690

3691
        private bool hangingFieldSpecified;
3692

3693
        private string hangingCharsField;
3694

3695
        private long firstLineField;
3696

3697
        private bool firstLineFieldSpecified;
3698

3699
        private string firstLineCharsField;
3700
        public CT_Ind()
3701
        {
3702
            firstLineField = -1;
3703
        }
3704

3705
        public static CT_Ind Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3706
        {
3707
            if (node == null)
3708
                return null;
3709
            CT_Ind ctObj = new CT_Ind();
3710
            ctObj.left = XmlHelper.ReadString(node.Attributes["w:left"]);
3711
            ctObj.leftChars = XmlHelper.ReadString(node.Attributes["w:leftChars"]);
3712
            ctObj.right = XmlHelper.ReadString(node.Attributes["w:right"]);
3713
            ctObj.rightChars = XmlHelper.ReadString(node.Attributes["w:rightChars"]);
3714
            ctObj.hanging = XmlHelper.ReadULong(node.Attributes["w:hanging"]);
3715
            ctObj.hangingChars = XmlHelper.ReadString(node.Attributes["w:hangingChars"]);
3716
            if (node.Attributes["w:firstLine"]!=null)
3717
                ctObj.firstLine = XmlHelper.ReadLong(node.Attributes["w:firstLine"]);
3718
            ctObj.firstLineChars = XmlHelper.ReadString(node.Attributes["w:firstLineChars"]);
3719
            return ctObj;
3720
        }
3721

3722

3723

3724
        internal void Write(StreamWriter sw, string nodeName)
3725
        {
3726
            sw.Write(string.Format("<w:{0}", nodeName));
3727
            XmlHelper.WriteAttribute(sw, "w:leftChars", this.leftChars);
3728
            XmlHelper.WriteAttribute(sw, "w:left", this.left);
3729
            XmlHelper.WriteAttribute(sw, "w:rightChars", this.rightChars);
3730
            XmlHelper.WriteAttribute(sw, "w:right", this.right);
3731
            XmlHelper.WriteAttribute(sw, "w:hangingChars", this.hangingChars);
3732
            XmlHelper.WriteAttribute(sw, "w:hanging", this.hanging);
3733
            if(firstLineField>=0)
3734
                XmlHelper.WriteAttribute(sw, "w:firstLine", this.firstLine, true);
3735
            XmlHelper.WriteAttribute(sw, "w:firstLineChars", this.firstLineChars);
3736
            sw.Write("/>");
3737
        }
3738

3739

3740
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3741
        public string left
3742
        {
3743
            get
3744
            {
3745
                return this.leftField;
3746
            }
3747
            set
3748
            {
3749
                this.leftField = value;
3750
            }
3751
        }
3752

3753
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3754
        public string leftChars
3755
        {
3756
            get
3757
            {
3758
                return this.leftCharsField;
3759
            }
3760
            set
3761
            {
3762
                this.leftCharsField = value;
3763
            }
3764
        }
3765

3766
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3767
        public string right
3768
        {
3769
            get
3770
            {
3771
                return this.rightField;
3772
            }
3773
            set
3774
            {
3775
                this.rightField = value;
3776
            }
3777
        }
3778

3779
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3780
        public string rightChars
3781
        {
3782
            get
3783
            {
3784
                return this.rightCharsField;
3785
            }
3786
            set
3787
            {
3788
                this.rightCharsField = value;
3789
            }
3790
        }
3791

3792
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3793
        public ulong hanging
3794
        {
3795
            get
3796
            {
3797
                return this.hangingField;
3798
            }
3799
            set
3800
            {
3801
                this.hangingField = value;
3802
                this.hangingFieldSpecified = true;
3803
            }
3804
        }
3805

3806
        [XmlIgnore]
3807
        public bool hangingSpecified
3808
        {
3809
            get
3810
            {
3811
                return this.hangingFieldSpecified;
3812
            }
3813
            set
3814
            {
3815
                this.hangingFieldSpecified = value;
3816
            }
3817
        }
3818

3819
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3820
        public string hangingChars
3821
        {
3822
            get
3823
            {
3824
                return this.hangingCharsField;
3825
            }
3826
            set
3827
            {
3828
                this.hangingCharsField = value;
3829
            }
3830
        }
3831

3832
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3833
        public long firstLine
3834
        {
3835
            get
3836
            {
3837
                return this.firstLineField;
3838
            }
3839
            set
3840
            {
3841
                this.firstLineField = value;
3842
            }
3843
        }
3844

3845
        [XmlIgnore]
3846
        public bool firstLineSpecified
3847
        {
3848
            get
3849
            {
3850
                return this.firstLineFieldSpecified;
3851
            }
3852
            set
3853
            {
3854
                this.firstLineFieldSpecified = value;
3855
            }
3856
        }
3857

3858
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
3859
        public string firstLineChars
3860
        {
3861
            get
3862
            {
3863
                return this.firstLineCharsField;
3864
            }
3865
            set
3866
            {
3867
                this.firstLineCharsField = value;
3868
            }
3869
        }
3870

3871
        public bool IsSetLeft()
3872
        {
3873
            return !string.IsNullOrEmpty(this.leftField);
3874
        }
3875

3876
        public bool IsSetRight()
3877
        {
3878
            return !string.IsNullOrEmpty(this.rightField);
3879
        }
3880

3881
        public bool IsSetHanging()
3882
        {
3883
            return !(this.hangingField == 0);
3884
        }
3885

3886
        public bool IsSetFirstLine()
3887
        {
3888
            return !(this.firstLineField==0);
3889
        }
3890
    }
3891

3892
    [Serializable]
3893

3894
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3895
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
3896
    public class CT_RPr
3897
    {
3898

3899
        private CT_String rStyleField;
3900

3901
        private CT_Fonts rFontsField;
3902

3903
        private CT_OnOff bField;
3904

3905
        private CT_OnOff bCsField;
3906

3907
        private CT_OnOff iField;
3908

3909
        private CT_OnOff iCsField;
3910

3911
        private CT_OnOff capsField;
3912

3913
        private CT_OnOff smallCapsField;
3914

3915
        private CT_OnOff strikeField;
3916

3917
        private CT_OnOff dstrikeField;
3918

3919
        private CT_OnOff outlineField;
3920

3921
        private CT_OnOff shadowField;
3922

3923
        private CT_OnOff embossField;
3924

3925
        private CT_OnOff imprintField;
3926

3927
        private CT_OnOff noProofField;
3928

3929
        private CT_OnOff snapToGridField;
3930

3931
        private CT_OnOff vanishField;
3932

3933
        private CT_OnOff webHiddenField;
3934

3935
        private CT_Color colorField;
3936

3937
        private CT_SignedTwipsMeasure spacingField;
3938

3939
        private CT_TextScale wField;
3940

3941
        private CT_HpsMeasure kernField;
3942

3943
        private CT_SignedHpsMeasure positionField;
3944

3945
        private CT_HpsMeasure szField;
3946

3947
        private CT_HpsMeasure szCsField;
3948

3949
        private CT_Highlight highlightField;
3950

3951
        private CT_Underline uField;
3952

3953
        private CT_TextEffect effectField;
3954

3955
        private CT_Border bdrField;
3956

3957
        private CT_Shd shdField;
3958

3959
        private CT_FitText fitTextField;
3960

3961
        private CT_VerticalAlignRun vertAlignField;
3962

3963
        private CT_OnOff rtlField;
3964

3965
        private CT_OnOff csField;
3966

3967
        private CT_Em emField;
3968

3969
        private CT_Language langField;
3970

3971
        private CT_EastAsianLayout eastAsianLayoutField;
3972

3973
        private CT_OnOff specVanishField;
3974

3975
        private CT_OnOff oMathField;
3976

3977
        private CT_RPrChange rPrChangeField;
3978

3979
        public CT_RPr()
3980
        {
3981
        }
3982
        public static CT_RPr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3983
        {
3984
            if (node == null)
3985
                return null;
3986
            CT_RPr ctObj = new CT_RPr();
3987
            foreach (XmlNode childNode in node.ChildNodes)
3988
            {
3989
                if (childNode.LocalName == "rStyle")
3990
                    ctObj.rStyle = CT_String.Parse(childNode, namespaceManager);
3991
                else if (childNode.LocalName == "rFonts")
3992
                    ctObj.rFonts = CT_Fonts.Parse(childNode, namespaceManager);
3993
                else if (childNode.LocalName == "b")
3994
                    ctObj.b = CT_OnOff.Parse(childNode, namespaceManager);
3995
                else if (childNode.LocalName == "bCs")
3996
                    ctObj.bCs = CT_OnOff.Parse(childNode, namespaceManager);
3997
                else if (childNode.LocalName == "i")
3998
                    ctObj.i = CT_OnOff.Parse(childNode, namespaceManager);
3999
                else if (childNode.LocalName == "iCs")
4000
                    ctObj.iCs = CT_OnOff.Parse(childNode, namespaceManager);
4001
                else if (childNode.LocalName == "caps")
4002
                    ctObj.caps = CT_OnOff.Parse(childNode, namespaceManager);
4003
                else if (childNode.LocalName == "smallCaps")
4004
                    ctObj.smallCaps = CT_OnOff.Parse(childNode, namespaceManager);
4005
                else if (childNode.LocalName == "strike")
4006
                    ctObj.strike = CT_OnOff.Parse(childNode, namespaceManager);
4007
                else if (childNode.LocalName == "dstrike")
4008
                    ctObj.dstrike = CT_OnOff.Parse(childNode, namespaceManager);
4009
                else if (childNode.LocalName == "outline")
4010
                    ctObj.outline = CT_OnOff.Parse(childNode, namespaceManager);
4011
                else if (childNode.LocalName == "shadow")
4012
                    ctObj.shadow = CT_OnOff.Parse(childNode, namespaceManager);
4013
                else if (childNode.LocalName == "emboss")
4014
                    ctObj.emboss = CT_OnOff.Parse(childNode, namespaceManager);
4015
                else if (childNode.LocalName == "imprint")
4016
                    ctObj.imprint = CT_OnOff.Parse(childNode, namespaceManager);
4017
                else if (childNode.LocalName == "noProof")
4018
                    ctObj.noProof = CT_OnOff.Parse(childNode, namespaceManager);
4019
                else if (childNode.LocalName == "snapToGrid")
4020
                    ctObj.snapToGrid = CT_OnOff.Parse(childNode, namespaceManager);
4021
                else if (childNode.LocalName == "vanish")
4022
                    ctObj.vanish = CT_OnOff.Parse(childNode, namespaceManager);
4023
                else if (childNode.LocalName == "webHidden")
4024
                    ctObj.webHidden = CT_OnOff.Parse(childNode, namespaceManager);
4025
                else if (childNode.LocalName == "color")
4026
                    ctObj.color = CT_Color.Parse(childNode, namespaceManager);
4027
                else if (childNode.LocalName == "spacing")
4028
                    ctObj.spacing = CT_SignedTwipsMeasure.Parse(childNode, namespaceManager);
4029
                else if (childNode.LocalName == "w")
4030
                    ctObj.w = CT_TextScale.Parse(childNode, namespaceManager);
4031
                else if (childNode.LocalName == "kern")
4032
                    ctObj.kern = CT_HpsMeasure.Parse(childNode, namespaceManager);
4033
                else if (childNode.LocalName == "position")
4034
                    ctObj.position = CT_SignedHpsMeasure.Parse(childNode, namespaceManager);
4035
                else if (childNode.LocalName == "sz")
4036
                    ctObj.sz = CT_HpsMeasure.Parse(childNode, namespaceManager);
4037
                else if (childNode.LocalName == "szCs")
4038
                    ctObj.szCs = CT_HpsMeasure.Parse(childNode, namespaceManager);
4039
                else if (childNode.LocalName == "highlight")
4040
                    ctObj.highlight = CT_Highlight.Parse(childNode, namespaceManager);
4041
                else if (childNode.LocalName == "u")
4042
                    ctObj.u = CT_Underline.Parse(childNode, namespaceManager);
4043
                else if (childNode.LocalName == "effect")
4044
                    ctObj.effect = CT_TextEffect.Parse(childNode, namespaceManager);
4045
                else if (childNode.LocalName == "bdr")
4046
                    ctObj.bdr = CT_Border.Parse(childNode, namespaceManager);
4047
                else if (childNode.LocalName == "shd")
4048
                    ctObj.shd = CT_Shd.Parse(childNode, namespaceManager);
4049
                else if (childNode.LocalName == "fitText")
4050
                    ctObj.fitText = CT_FitText.Parse(childNode, namespaceManager);
4051
                else if (childNode.LocalName == "vertAlign")
4052
                    ctObj.vertAlign = CT_VerticalAlignRun.Parse(childNode, namespaceManager);
4053
                else if (childNode.LocalName == "rtl")
4054
                    ctObj.rtl = CT_OnOff.Parse(childNode, namespaceManager);
4055
                else if (childNode.LocalName == "cs")
4056
                    ctObj.cs = CT_OnOff.Parse(childNode, namespaceManager);
4057
                else if (childNode.LocalName == "em")
4058
                    ctObj.em = CT_Em.Parse(childNode, namespaceManager);
4059
                else if (childNode.LocalName == "lang")
4060
                    ctObj.lang = CT_Language.Parse(childNode, namespaceManager);
4061
                else if (childNode.LocalName == "eastAsianLayout")
4062
                    ctObj.eastAsianLayout = CT_EastAsianLayout.Parse(childNode, namespaceManager);
4063
                else if (childNode.LocalName == "specVanish")
4064
                    ctObj.specVanish = CT_OnOff.Parse(childNode, namespaceManager);
4065
                else if (childNode.LocalName == "oMath")
4066
                    ctObj.oMath = CT_OnOff.Parse(childNode, namespaceManager);
4067
                else if (childNode.LocalName == "rPrChange")
4068
                    ctObj.rPrChange = CT_RPrChange.Parse(childNode, namespaceManager);
4069
            }
4070
            return ctObj;
4071
        }
4072

4073

4074

4075
        internal void Write(StreamWriter sw, string nodeName)
4076
        {
4077
            sw.Write(string.Format("<w:{0}", nodeName));
4078
            sw.Write(">");
4079
            if (this.rStyle != null)
4080
                this.rStyle.Write(sw, "rStyle");
4081
            if (this.rFonts != null)
4082
                this.rFonts.Write(sw, "rFonts");
4083
            if (this.b != null)
4084
                this.b.Write(sw, "b");
4085
            if (this.bCs != null)
4086
                this.bCs.Write(sw, "bCs");
4087
            if (this.i != null)
4088
                this.i.Write(sw, "i");
4089
            if (this.iCs != null)
4090
                this.iCs.Write(sw, "iCs");
4091
            if (this.caps != null)
4092
                this.caps.Write(sw, "caps");
4093
            if (this.smallCaps != null)
4094
                this.smallCaps.Write(sw, "smallCaps");
4095
            if (this.strike != null)
4096
                this.strike.Write(sw, "strike");
4097
            if (this.dstrike != null)
4098
                this.dstrike.Write(sw, "dstrike");
4099
            if (this.outline != null)
4100
                this.outline.Write(sw, "outline");
4101
            if (this.shadow != null)
4102
                this.shadow.Write(sw, "shadow");
4103
            if (this.emboss != null)
4104
                this.emboss.Write(sw, "emboss");
4105
            if (this.imprint != null)
4106
                this.imprint.Write(sw, "imprint");
4107
            if (this.noProof != null)
4108
                this.noProof.Write(sw, "noProof");
4109
            if (this.snapToGrid != null)
4110
                this.snapToGrid.Write(sw, "snapToGrid");
4111
            if (this.vanish != null)
4112
                this.vanish.Write(sw, "vanish");
4113
            if (this.webHidden != null)
4114
                this.webHidden.Write(sw, "webHidden");
4115
            if (this.color != null)
4116
                this.color.Write(sw, "color");
4117
            if (this.spacing != null)
4118
                this.spacing.Write(sw, "spacing");
4119
            if (this.w != null)
4120
                this.w.Write(sw, "w");
4121
            if (this.kern != null)
4122
                this.kern.Write(sw, "kern");
4123
            if (this.position != null)
4124
                this.position.Write(sw, "position");
4125
            if (this.sz != null)
4126
                this.sz.Write(sw, "sz");
4127
            if (this.szCs != null)
4128
                this.szCs.Write(sw, "szCs");
4129
            if (this.highlight != null)
4130
                this.highlight.Write(sw, "highlight");
4131
            if (this.u != null)
4132
                this.u.Write(sw, "u");
4133
            if (this.effect != null)
4134
                this.effect.Write(sw, "effect");
4135
            if (this.bdr != null)
4136
                this.bdr.Write(sw, "bdr");
4137
            if (this.shd != null)
4138
                this.shd.Write(sw, "shd");
4139
            if (this.fitText != null)
4140
                this.fitText.Write(sw, "fitText");
4141
            if (this.vertAlign != null)
4142
                this.vertAlign.Write(sw, "vertAlign");
4143
            if (this.rtl != null)
4144
                this.rtl.Write(sw, "rtl");
4145
            if (this.cs != null)
4146
                this.cs.Write(sw, "cs");
4147
            if (this.em != null)
4148
                this.em.Write(sw, "em");
4149
            if (this.lang != null)
4150
                this.lang.Write(sw, "lang");
4151
            if (this.eastAsianLayout != null)
4152
                this.eastAsianLayout.Write(sw, "eastAsianLayout");
4153
            if (this.specVanish != null)
4154
                this.specVanish.Write(sw, "specVanish");
4155
            if (this.oMath != null)
4156
                this.oMath.Write(sw, "oMath");
4157
            if (this.rPrChange != null)
4158
                this.rPrChange.Write(sw, "rPrChange");
4159
            sw.WriteEndW(nodeName);
4160
        }
4161
        public CT_String AddNewRStyle()
4162
        {
4163
            this.rStyleField = new CT_String();
4164
            return this.rStyleField;
4165
        }
4166
        [XmlElement(Order = 0)]
4167
        public CT_String rStyle
4168
        {
4169
            get
4170
            {
4171
                return this.rStyleField;
4172
            }
4173
            set
4174
            {
4175
                this.rStyleField = value;
4176
            }
4177
        }
4178

4179
        [XmlElement(Order = 1)]
4180
        public CT_Fonts rFonts
4181
        {
4182
            get
4183
            {
4184
                return this.rFontsField;
4185
            }
4186
            set
4187
            {
4188
                this.rFontsField = value;
4189
            }
4190
        }
4191

4192
        [XmlElement(Order = 2)]
4193
        public CT_OnOff b
4194
        {
4195
            get
4196
            {
4197
                return this.bField;
4198
            }
4199
            set
4200
            {
4201
                this.bField = value;
4202
            }
4203
        }
4204

4205
        [XmlElement(Order = 3)]
4206
        public CT_OnOff bCs
4207
        {
4208
            get
4209
            {
4210
                return this.bCsField;
4211
            }
4212
            set
4213
            {
4214
                this.bCsField = value;
4215
            }
4216
        }
4217

4218
        [XmlElement(Order = 4)]
4219
        public CT_OnOff i
4220
        {
4221
            get
4222
            {
4223
                return this.iField;
4224
            }
4225
            set
4226
            {
4227
                this.iField = value;
4228
            }
4229
        }
4230

4231
        [XmlElement(Order = 5)]
4232
        public CT_OnOff iCs
4233
        {
4234
            get
4235
            {
4236
                return this.iCsField;
4237
            }
4238
            set
4239
            {
4240
                this.iCsField = value;
4241
            }
4242
        }
4243

4244
        [XmlElement(Order = 6)]
4245
        public CT_OnOff caps
4246
        {
4247
            get
4248
            {
4249
                return this.capsField;
4250
            }
4251
            set
4252
            {
4253
                this.capsField = value;
4254
            }
4255
        }
4256

4257
        [XmlElement(Order = 7)]
4258
        public CT_OnOff smallCaps
4259
        {
4260
            get
4261
            {
4262
                return this.smallCapsField;
4263
            }
4264
            set
4265
            {
4266
                this.smallCapsField = value;
4267
            }
4268
        }
4269

4270
        [XmlElement(Order = 8)]
4271
        public CT_OnOff strike
4272
        {
4273
            get
4274
            {
4275
                return this.strikeField;
4276
            }
4277
            set
4278
            {
4279
                this.strikeField = value;
4280
            }
4281
        }
4282

4283
        [XmlElement(Order = 9)]
4284
        public CT_OnOff dstrike
4285
        {
4286
            get
4287
            {
4288
                return this.dstrikeField;
4289
            }
4290
            set
4291
            {
4292
                this.dstrikeField = value;
4293
            }
4294
        }
4295

4296
        [XmlElement(Order = 10)]
4297
        public CT_OnOff outline
4298
        {
4299
            get
4300
            {
4301
                return this.outlineField;
4302
            }
4303
            set
4304
            {
4305
                this.outlineField = value;
4306
            }
4307
        }
4308

4309
        [XmlElement(Order = 11)]
4310
        public CT_OnOff shadow
4311
        {
4312
            get
4313
            {
4314
                return this.shadowField;
4315
            }
4316
            set
4317
            {
4318
                this.shadowField = value;
4319
            }
4320
        }
4321

4322
        [XmlElement(Order = 12)]
4323
        public CT_OnOff emboss
4324
        {
4325
            get
4326
            {
4327
                return this.embossField;
4328
            }
4329
            set
4330
            {
4331
                this.embossField = value;
4332
            }
4333
        }
4334

4335
        [XmlElement(Order = 13)]
4336
        public CT_OnOff imprint
4337
        {
4338
            get
4339
            {
4340
                return this.imprintField;
4341
            }
4342
            set
4343
            {
4344
                this.imprintField = value;
4345
            }
4346
        }
4347

4348
        [XmlElement(Order = 14)]
4349
        public CT_OnOff noProof
4350
        {
4351
            get
4352
            {
4353
                return this.noProofField;
4354
            }
4355
            set
4356
            {
4357
                this.noProofField = value;
4358
            }
4359
        }
4360

4361
        [XmlElement(Order = 15)]
4362
        public CT_OnOff snapToGrid
4363
        {
4364
            get
4365
            {
4366
                return this.snapToGridField;
4367
            }
4368
            set
4369
            {
4370
                this.snapToGridField = value;
4371
            }
4372
        }
4373

4374
        [XmlElement(Order = 16)]
4375
        public CT_OnOff vanish
4376
        {
4377
            get
4378
            {
4379
                return this.vanishField;
4380
            }
4381
            set
4382
            {
4383
                this.vanishField = value;
4384
            }
4385
        }
4386

4387
        [XmlElement(Order = 17)]
4388
        public CT_OnOff webHidden
4389
        {
4390
            get
4391
            {
4392
                return this.webHiddenField;
4393
            }
4394
            set
4395
            {
4396
                this.webHiddenField = value;
4397
            }
4398
        }
4399

4400
        [XmlElement(Order = 18)]
4401
        public CT_Color color
4402
        {
4403
            get
4404
            {
4405
                return this.colorField;
4406
            }
4407
            set
4408
            {
4409
                this.colorField = value;
4410
            }
4411
        }
4412

4413
        [XmlElement(Order = 19)]
4414
        public CT_SignedTwipsMeasure spacing
4415
        {
4416
            get
4417
            {
4418
                return this.spacingField;
4419
            }
4420
            set
4421
            {
4422
                this.spacingField = value;
4423
            }
4424
        }
4425

4426
        [XmlElement(Order = 20)]
4427
        public CT_TextScale w
4428
        {
4429
            get
4430
            {
4431
                return this.wField;
4432
            }
4433
            set
4434
            {
4435
                this.wField = value;
4436
            }
4437
        }
4438

4439
        [XmlElement(Order = 21)]
4440
        public CT_HpsMeasure kern
4441
        {
4442
            get
4443
            {
4444
                return this.kernField;
4445
            }
4446
            set
4447
            {
4448
                this.kernField = value;
4449
            }
4450
        }
4451

4452
        [XmlElement(Order = 22)]
4453
        public CT_SignedHpsMeasure position
4454
        {
4455
            get
4456
            {
4457
                return this.positionField;
4458
            }
4459
            set
4460
            {
4461
                this.positionField = value;
4462
            }
4463
        }
4464

4465
        [XmlElement(Order = 23)]
4466
        public CT_HpsMeasure sz
4467
        {
4468
            get
4469
            {
4470
                return this.szField;
4471
            }
4472
            set
4473
            {
4474
                this.szField = value;
4475
            }
4476
        }
4477

4478
        [XmlElement(Order = 24)]
4479
        public CT_HpsMeasure szCs
4480
        {
4481
            get
4482
            {
4483
                return this.szCsField;
4484
            }
4485
            set
4486
            {
4487
                this.szCsField = value;
4488
            }
4489
        }
4490

4491
        [XmlElement(Order = 25)]
4492
        public CT_Highlight highlight
4493
        {
4494
            get
4495
            {
4496
                return this.highlightField;
4497
            }
4498
            set
4499
            {
4500
                this.highlightField = value;
4501
            }
4502
        }
4503

4504
        [XmlElement(Order = 26)]
4505
        public CT_Underline u
4506
        {
4507
            get
4508
            {
4509
                return this.uField;
4510
            }
4511
            set
4512
            {
4513
                this.uField = value;
4514
            }
4515
        }
4516

4517
        [XmlElement(Order = 27)]
4518
        public CT_TextEffect effect
4519
        {
4520
            get
4521
            {
4522
                return this.effectField;
4523
            }
4524
            set
4525
            {
4526
                this.effectField = value;
4527
            }
4528
        }
4529

4530
        [XmlElement(Order = 28)]
4531
        public CT_Border bdr
4532
        {
4533
            get
4534
            {
4535
                return this.bdrField;
4536
            }
4537
            set
4538
            {
4539
                this.bdrField = value;
4540
            }
4541
        }
4542

4543
        [XmlElement(Order = 29)]
4544
        public CT_Shd shd
4545
        {
4546
            get
4547
            {
4548
                return this.shdField;
4549
            }
4550
            set
4551
            {
4552
                this.shdField = value;
4553
            }
4554
        }
4555

4556
        [XmlElement(Order = 30)]
4557
        public CT_FitText fitText
4558
        {
4559
            get
4560
            {
4561
                return this.fitTextField;
4562
            }
4563
            set
4564
            {
4565
                this.fitTextField = value;
4566
            }
4567
        }
4568

4569
        [XmlElement(Order = 31)]
4570
        public CT_VerticalAlignRun vertAlign
4571
        {
4572
            get
4573
            {
4574
                return this.vertAlignField;
4575
            }
4576
            set
4577
            {
4578
                this.vertAlignField = value;
4579
            }
4580
        }
4581

4582
        [XmlElement(Order = 32)]
4583
        public CT_OnOff rtl
4584
        {
4585
            get
4586
            {
4587
                return this.rtlField;
4588
            }
4589
            set
4590
            {
4591
                this.rtlField = value;
4592
            }
4593
        }
4594

4595
        [XmlElement(Order = 33)]
4596
        public CT_OnOff cs
4597
        {
4598
            get
4599
            {
4600
                return this.csField;
4601
            }
4602
            set
4603
            {
4604
                this.csField = value;
4605
            }
4606
        }
4607

4608
        [XmlElement(Order = 34)]
4609
        public CT_Em em
4610
        {
4611
            get
4612
            {
4613
                return this.emField;
4614
            }
4615
            set
4616
            {
4617
                this.emField = value;
4618
            }
4619
        }
4620

4621
        [XmlElement(Order = 35)]
4622
        public CT_Language lang
4623
        {
4624
            get
4625
            {
4626
                return this.langField;
4627
            }
4628
            set
4629
            {
4630
                this.langField = value;
4631
            }
4632
        }
4633

4634
        [XmlElement(Order = 36)]
4635
        public CT_EastAsianLayout eastAsianLayout
4636
        {
4637
            get
4638
            {
4639
                return this.eastAsianLayoutField;
4640
            }
4641
            set
4642
            {
4643
                this.eastAsianLayoutField = value;
4644
            }
4645
        }
4646

4647
        [XmlElement(Order = 37)]
4648
        public CT_OnOff specVanish
4649
        {
4650
            get
4651
            {
4652
                return this.specVanishField;
4653
            }
4654
            set
4655
            {
4656
                this.specVanishField = value;
4657
            }
4658
        }
4659

4660
        [XmlElement(Order = 38)]
4661
        public CT_OnOff oMath
4662
        {
4663
            get
4664
            {
4665
                return this.oMathField;
4666
            }
4667
            set
4668
            {
4669
                this.oMathField = value;
4670
            }
4671
        }
4672

4673
        [XmlElement(Order = 39)]
4674
        public CT_RPrChange rPrChange
4675
        {
4676
            get
4677
            {
4678
                return this.rPrChangeField;
4679
            }
4680
            set
4681
            {
4682
                this.rPrChangeField = value;
4683
            }
4684
        }
4685

4686
        public bool IsSetLang()
4687
        {
4688
            return this.langField != null;// !string.IsNullOrEmpty(this.langField.val);
4689
        }
4690

4691
        public CT_Language AddNewLang()
4692
        {
4693
            if (this.langField == null)
4694
                this.langField = new CT_Language();
4695
            return this.langField;
4696
        }
4697

4698
        public CT_Fonts AddNewRFonts()
4699
        {
4700
            if (this.rFontsField == null)
4701
                this.rFontsField = new CT_Fonts();
4702
            return this.rFontsField;
4703
        }
4704

4705
        public CT_OnOff AddNewB()
4706
        {
4707
            if (this.bField == null)
4708
                this.bField = new CT_OnOff();
4709
            return this.bField;
4710
        }
4711

4712
        public CT_Shd AddNewShd()
4713
        {
4714
            if (this.shdField == null)
4715
                this.shdField = new CT_Shd();
4716
            return this.shdField;
4717
        }
4718

4719
        public CT_OnOff AddNewBCs()
4720
        {
4721
            if (this.bCsField == null)
4722
                this.bCsField = new CT_OnOff();
4723
            return this.bCsField;
4724
        }
4725

4726
        public CT_Color AddNewColor()
4727
        {
4728
            if (this.colorField == null)
4729
                this.colorField = new CT_Color();
4730
            return this.colorField;
4731
        }
4732

4733
        public CT_HpsMeasure AddNewSz()
4734
        {
4735
            if (this.szField == null)
4736
                this.szField = new CT_HpsMeasure();
4737
            return this.szField;
4738
        }
4739

4740
        public CT_HpsMeasure AddNewSzCs()
4741
        {
4742
            if (this.szCsField == null)
4743
                this.szCsField = new CT_HpsMeasure();
4744
            return this.szCsField;
4745
        }
4746

4747
        public bool IsSetPosition()
4748
        {
4749
            return this.positionField!=null && !string.IsNullOrEmpty(this.positionField.val);
4750
        }
4751

4752
        public CT_SignedHpsMeasure AddNewPosition()
4753
        {
4754
            if (this.positionField == null)
4755
                this.positionField = new CT_SignedHpsMeasure();
4756
            return this.positionField;
4757
        }
4758

4759
        public bool IsSetB()
4760
        {
4761
            return this.bField != null;
4762
        }
4763

4764
        public bool IsSetI()
4765
        {
4766
            return this.iField != null;
4767
        }
4768

4769
        public CT_OnOff AddNewI()
4770
        {
4771
            if (this.iField == null)
4772
                this.iField = new CT_OnOff();
4773
            return this.iField;
4774
        }
4775

4776
        public void AddNewNoProof()
4777
        {
4778
            if (this.noProofField == null)
4779
                this.noProofField = new CT_OnOff();
4780
        }
4781

4782
        public bool IsSetU()
4783
        {
4784
            return this.uField != null 
4785
                && this.uField.val != ST_Underline.none;
4786
        }
4787

4788
        public CT_Underline AddNewU()
4789
        {
4790
            if (this.uField == null)
4791
                this.uField = new CT_Underline();
4792
            return this.uField;
4793
        }
4794

4795
        public bool IsSetStrike()
4796
        {
4797
            return this.strike != null;
4798
        }
4799

4800
        public CT_OnOff AddNewStrike()
4801
        {
4802
            if (this.strikeField == null)
4803
                this.strikeField = new CT_OnOff();
4804
            return this.strikeField;
4805
        }
4806

4807
        public bool IsSetVertAlign()
4808
        {
4809
            return !(this.vertAlignField == null);
4810
        }
4811

4812
        public CT_VerticalAlignRun AddNewVertAlign()
4813
        {
4814
            if (this.vertAlignField == null)
4815
                this.vertAlignField = new CT_VerticalAlignRun();
4816
            return this.vertAlignField;
4817
        }
4818

4819
        public bool IsSetRFonts()
4820
        {
4821
            return this.rFontsField != null;
4822
        }
4823

4824
        public bool IsSetSz()
4825
        {
4826
            return (this.szField!=null && this.szField.val != 0);
4827
        }
4828

4829
        public bool IsSetColor()
4830
        {
4831
            return colorField != null && !string.IsNullOrEmpty(colorField.val);
4832
        }
4833

4834
        public bool IsSetDstrike()
4835
        {
4836
            return this.dstrikeField != null;
4837
        }
4838

4839
        public CT_OnOff AddNewDstrike()
4840
        {
4841
            if (this.dstrikeField == null)
4842
                this.dstrikeField = new CT_OnOff();
4843
            return this.dstrikeField;
4844
        }
4845

4846
        public bool IsSetEmboss()
4847
        {
4848
            return this.embossField != null;
4849
        }
4850

4851
        public CT_OnOff AddNewEmboss()
4852
        {
4853
            if (this.embossField == null)
4854
                this.embossField = new CT_OnOff();
4855
            return this.embossField;
4856
        }
4857

4858
        public bool IsSetImprint()
4859
        {
4860
            return this.imprintField != null;
4861
        }
4862

4863
        public CT_OnOff AddNewImprint()
4864
        {
4865
            if (this.imprintField == null)
4866
                this.imprintField = new CT_OnOff();
4867
            return this.imprintField;
4868
        }
4869

4870
        public bool IsSetShadow()
4871
        {
4872
            return this.shadowField != null;
4873
        }
4874

4875
        public CT_OnOff AddNewShadow()
4876
        {
4877
            if (this.shadowField == null)
4878
                this.shadowField = new CT_OnOff();
4879
            return this.shadowField;
4880
        }
4881

4882
        public bool IsSetCaps()
4883
        {
4884
            return this.capsField != null;
4885
        }
4886

4887
        public CT_OnOff AddNewCaps()
4888
        {
4889
            if (this.capsField == null)
4890
                this.capsField = new CT_OnOff();
4891
            return this.capsField;
4892
        }
4893

4894
        public bool IsSetSmallCaps()
4895
        {
4896
            return this.smallCapsField != null;
4897
        }
4898

4899
        public CT_OnOff AddNewSmallCaps()
4900
        {
4901
            if (this.smallCapsField == null)
4902
                this.smallCapsField = new CT_OnOff();
4903
            return this.smallCapsField;
4904
        }
4905

4906
        public bool IsSetKern()
4907
        {
4908
            return this.kernField != null;
4909
        }
4910

4911
        public CT_HpsMeasure AddNewKern()
4912
        {
4913
            if (this.kernField == null)
4914
                this.kernField = new CT_HpsMeasure();
4915
            return this.kernField;
4916
        }
4917

4918
        public bool IsSetSpacing()
4919
        {
4920
            return this.spacingField != null;
4921
        }
4922

4923
        public CT_Highlight AddNewHighlight()
4924
        {
4925
            if (this.highlightField == null)
4926
                this.highlightField = new CT_Highlight();
4927
            return this.highlightField;
4928
        }
4929

4930
        public CT_SignedTwipsMeasure AddNewSpacing()
4931
        {
4932
            if (this.spacingField == null)
4933
                this.spacingField = new CT_SignedTwipsMeasure();
4934
            return this.spacingField;
4935
        }
4936

4937
        public bool IsSetHighlight()
4938
        {
4939
            return this.highlightField != null;
4940
        }
4941
    }
4942

4943

4944
    [Serializable]
4945

4946
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
4947
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
4948
    public class CT_ParaRPrChange : CT_TrackChange
4949
    {
4950
        public static new CT_ParaRPrChange Parse(XmlNode node, XmlNamespaceManager namespaceManager)
4951
        {
4952
            if (node == null)
4953
                return null;
4954
            CT_ParaRPrChange ctObj = new CT_ParaRPrChange();
4955
            ctObj.author = XmlHelper.ReadString(node.Attributes["author"]);
4956
            ctObj.date = XmlHelper.ReadString(node.Attributes["date"]);
4957
            ctObj.id = XmlHelper.ReadString(node.Attributes["id"]);
4958
            foreach (XmlNode childNode in node.ChildNodes)
4959
            {
4960
                if (childNode.LocalName == "rPr")
4961
                    ctObj.rPr = CT_ParaRPrOriginal.Parse(childNode, namespaceManager);
4962
            }
4963
            return ctObj;
4964
        }
4965

4966

4967

4968
        internal new void Write(StreamWriter sw, string nodeName)
4969
        {
4970
            sw.Write(string.Format("<{0}", nodeName));
4971
            XmlHelper.WriteAttribute(sw, "author", this.author);
4972
            XmlHelper.WriteAttribute(sw, "date", this.date);
4973
            XmlHelper.WriteAttribute(sw, "id", this.id);
4974
            sw.Write(">");
4975
            if (this.rPr != null)
4976
                this.rPr.Write(sw, "rPr");
4977
            sw.Write(string.Format("</{0}>", nodeName));
4978
        }
4979

4980

4981
        private CT_ParaRPrOriginal rPrField;
4982

4983
        public CT_ParaRPrChange()
4984
        {
4985
            //this.rPrField = new CT_ParaRPrOriginal();
4986
        }
4987

4988
        [XmlElement(Order = 0)]
4989
        public CT_ParaRPrOriginal rPr
4990
        {
4991
            get
4992
            {
4993
                return this.rPrField;
4994
            }
4995
            set
4996
            {
4997
                this.rPrField = value;
4998
            }
4999
        }
5000
    }
5001

5002

5003
    [Serializable]
5004

5005
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
5006
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
5007
    public class CT_ParaRPrOriginal
5008
    {
5009

5010
        private CT_TrackChange insField;
5011

5012
        private CT_TrackChange delField;
5013

5014
        private CT_TrackChange moveFromField;
5015

5016
        private CT_TrackChange moveToField;
5017

5018

5019
        public CT_ParaRPrOriginal()
5020
        {
5021

5022
        }
5023

5024
        [XmlElement(Order = 0)]
5025
        public CT_TrackChange ins
5026
        {
5027
            get
5028
            {
5029
                return this.insField;
5030
            }
5031
            set
5032
            {
5033
                this.insField = value;
5034
            }
5035
        }
5036

5037
        [XmlElement(Order = 1)]
5038
        public CT_TrackChange del
5039
        {
5040
            get
5041
            {
5042
                return this.delField;
5043
            }
5044
            set
5045
            {
5046
                this.delField = value;
5047
            }
5048
        }
5049

5050
        [XmlElement(Order = 2)]
5051
        public CT_TrackChange moveFrom
5052
        {
5053
            get
5054
            {
5055
                return this.moveFromField;
5056
            }
5057
            set
5058
            {
5059
                this.moveFromField = value;
5060
            }
5061
        }
5062

5063
        [XmlElement(Order = 3)]
5064
        public CT_TrackChange moveTo
5065
        {
5066
            get
5067
            {
5068
                return this.moveToField;
5069
            }
5070
            set
5071
            {
5072
                this.moveToField = value;
5073
            }
5074
        }
5075

5076
        List<CT_OnOff> webHiddenField;
5077
        [XmlElement(Order = 4)]
5078
        public List<CT_OnOff> webHidden
5079
        {
5080
            get { return this.webHiddenField; }
5081
            set { this.webHiddenField = value; }
5082
        }
5083

5084
        List<CT_OnOff> bField;
5085
        [XmlElement(Order = 4)]
5086
        public List<CT_OnOff> b
5087
        {
5088
            get { return this.bField; }
5089
            set { this.bField = value; }
5090
        }
5091

5092
        List<CT_OnOff> bCsField;
5093
        [XmlElement(Order = 4)]
5094
        public List<CT_OnOff> bCs
5095
        {
5096
            get { return this.bCsField; }
5097
            set { this.bCsField = value; }
5098
        }
5099

5100
        List<CT_Border> bdrField;
5101
        [XmlElement(Order = 4)]
5102
        public List<CT_Border> bdr
5103
        {
5104
            get { return this.bdrField; }
5105
            set { this.bdrField = value; }
5106
        }
5107

5108
        List<CT_OnOff> capsField;
5109
        [XmlElement(Order = 4)]
5110
        public List<CT_OnOff> caps
5111
        {
5112
            get { return this.capsField; }
5113
            set { this.capsField = value; }
5114
        }
5115

5116
        List<CT_Color> colorField;
5117
        [XmlElement(Order = 4)]
5118
        public List<CT_Color> color
5119
        {
5120
            get { return this.colorField; }
5121
            set { this.colorField = value; }
5122
        }
5123

5124
        List<CT_OnOff> csField;
5125
        [XmlElement(Order = 4)]
5126
        public List<CT_OnOff> cs
5127
        {
5128
            get { return this.csField; }
5129
            set { this.csField = value; }
5130
        }
5131

5132
        List<CT_OnOff> dstrikeField;
5133
        [XmlElement(Order = 4)]
5134
        public List<CT_OnOff> dstrike
5135
        {
5136
            get { return this.dstrikeField; }
5137
            set { this.dstrikeField = value; }
5138
        }
5139

5140
        List<CT_EastAsianLayout> eastAsianLayoutField;
5141
        [XmlElement(Order = 4)]
5142
        public List<CT_EastAsianLayout> eastAsianLayout
5143
        {
5144
            get { return this.eastAsianLayoutField; }
5145
            set { this.eastAsianLayoutField = value; }
5146
        }
5147

5148
        List<CT_TextEffect> effectField;
5149
        [XmlElement(Order = 4)]
5150
        public List<CT_TextEffect> effect
5151
        {
5152
            get { return this.effectField; }
5153
            set { this.effectField = value; }
5154
        }
5155

5156
        List<CT_Em> emField;
5157
        [XmlElement(Order = 4)]
5158
        public List<CT_Em> em
5159
        {
5160
            get { return this.emField; }
5161
            set { this.emField = value; }
5162
        }
5163

5164
        List<CT_OnOff> embossField;
5165
        [XmlElement(Order = 4)]
5166
        public List<CT_OnOff> emboss
5167
        {
5168
            get { return this.embossField; }
5169
            set { this.embossField = value; }
5170
        }
5171

5172
        List<CT_FitText> fitTextField;
5173
        [XmlElement(Order = 4)]
5174
        public List<CT_FitText> fitText
5175
        {
5176
            get { return this.fitTextField; }
5177
            set { this.fitTextField = value; }
5178
        }
5179

5180
        List<CT_Highlight> highlightField;
5181
        [XmlElement(Order = 4)]
5182
        public List<CT_Highlight> highlight
5183
        {
5184
            get { return this.highlightField; }
5185
            set { this.highlightField = value; }
5186
        }
5187

5188
        List<CT_OnOff> iField;
5189
        [XmlElement(Order = 4)]
5190
        public List<CT_OnOff> i
5191
        {
5192
            get { return this.iField; }
5193
            set { this.iField = value; }
5194
        }
5195

5196
        List<CT_OnOff> iCsField;
5197
        [XmlElement(Order = 4)]
5198
        public List<CT_OnOff> iCs
5199
        {
5200
            get { return this.iCsField; }
5201
            set { this.iCsField = value; }
5202
        }
5203

5204
        List<CT_OnOff> imprintField;
5205
        [XmlElement(Order = 4)]
5206
        public List<CT_OnOff> imprint
5207
        {
5208
            get { return this.imprintField; }
5209
            set { this.imprintField = value; }
5210
        }
5211

5212
        List<CT_HpsMeasure> kernField;
5213
        [XmlElement(Order = 4)]
5214
        public List<CT_HpsMeasure> kern
5215
        {
5216
            get { return this.kernField; }
5217
            set { this.kernField = value; }
5218
        }
5219

5220
        List<CT_Language> langField;
5221
        [XmlElement(Order = 4)]
5222
        public List<CT_Language> lang
5223
        {
5224
            get { return this.langField; }
5225
            set { this.langField = value; }
5226
        }
5227

5228
        List<CT_OnOff> noProofField;
5229
        [XmlElement(Order = 4)]
5230
        public List<CT_OnOff> noProof
5231
        {
5232
            get { return this.noProofField; }
5233
            set { this.noProofField = value; }
5234
        }
5235

5236
        List<CT_OnOff> oMathField;
5237
        [XmlElement(Order = 4)]
5238
        public List<CT_OnOff> oMath
5239
        {
5240
            get { return this.oMathField; }
5241
            set { this.oMathField = value; }
5242
        }
5243

5244
        List<CT_OnOff> outlineField;
5245
        [XmlElement(Order = 4)]
5246
        public List<CT_OnOff> outline
5247
        {
5248
            get { return this.outlineField; }
5249
            set { this.outlineField = value; }
5250
        }
5251

5252
        List<CT_SignedHpsMeasure> positionField;
5253
        [XmlElement(Order = 4)]
5254
        public List<CT_SignedHpsMeasure> position
5255
        {
5256
            get { return this.positionField; }
5257
            set { this.positionField = value; }
5258
        }
5259

5260
        List<CT_Fonts> rFontsField;
5261
        [XmlElement(Order = 4)]
5262
        public List<CT_Fonts> rFonts
5263
        {
5264
            get { return this.rFontsField; }
5265
            set { this.rFontsField = value; }
5266
        }
5267

5268
        List<CT_String> rStyleField;
5269
        [XmlElement(Order = 4)]
5270
        public List<CT_String> rStyle
5271
        {
5272
            get { return this.rStyleField; }
5273
            set { this.rStyleField = value; }
5274
        }
5275

5276
        List<CT_OnOff> rtlField;
5277
        [XmlElement(Order = 4)]
5278
        public List<CT_OnOff> rtl
5279
        {
5280
            get { return this.rtlField; }
5281
            set { this.rtlField = value; }
5282
        }
5283

5284
        List<CT_OnOff> shadowField;
5285
        [XmlElement(Order = 4)]
5286
        public List<CT_OnOff> shadow
5287
        {
5288
            get { return this.shadowField; }
5289
            set { this.shadowField = value; }
5290
        }
5291

5292
        List<CT_Shd> shdField;
5293
        [XmlElement(Order = 4)]
5294
        public List<CT_Shd> shd
5295
        {
5296
            get { return this.shdField; }
5297
            set { this.shdField = value; }
5298
        }
5299

5300
        List<CT_OnOff> smallCapsField;
5301
        [XmlElement(Order = 4)]
5302
        public List<CT_OnOff> smallCaps
5303
        {
5304
            get { return this.smallCapsField; }
5305
            set { this.smallCapsField = value; }
5306
        }
5307

5308
        List<CT_OnOff> snapToGridField;
5309
        [XmlElement(Order = 4)]
5310
        public List<CT_OnOff> snapToGrid
5311
        {
5312
            get { return this.snapToGridField; }
5313
            set { this.snapToGridField = value; }
5314
        }
5315

5316
        List<CT_SignedTwipsMeasure> spacingField;
5317
        [XmlElement(Order = 4)]
5318
        public List<CT_SignedTwipsMeasure> spacing
5319
        {
5320
            get { return this.spacingField; }
5321
            set { this.spacingField = value; }
5322
        }
5323

5324
        List<CT_OnOff> specVanishField;
5325
        [XmlElement(Order = 4)]
5326
        public List<CT_OnOff> specVanish
5327
        {
5328
            get { return this.specVanishField; }
5329
            set { this.specVanishField = value; }
5330
        }
5331

5332
        List<CT_OnOff> strikeField;
5333
        [XmlElement(Order = 4)]
5334
        public List<CT_OnOff> strike
5335
        {
5336
            get { return this.strikeField; }
5337
            set { this.strikeField = value; }
5338
        }
5339

5340
        List<CT_HpsMeasure> szField;
5341
        [XmlElement(Order = 4)]
5342
        public List<CT_HpsMeasure> sz
5343
        {
5344
            get { return this.szField; }
5345
            set { this.szField = value; }
5346
        }
5347

5348
        List<CT_HpsMeasure> szCsField;
5349
        [XmlElement(Order = 4)]
5350
        public List<CT_HpsMeasure> szCs
5351
        {
5352
            get { return this.szCsField; }
5353
            set { this.szCsField = value; }
5354
        }
5355

5356
        List<CT_Underline> uField;
5357
        [XmlElement(Order = 4)]
5358
        public List<CT_Underline> u
5359
        {
5360
            get { return this.uField; }
5361
            set { this.uField = value; }
5362
        }
5363

5364
        List<CT_OnOff> vanishField;
5365
        [XmlElement(Order = 4)]
5366
        public List<CT_OnOff> vanish
5367
        {
5368
            get { return this.vanishField; }
5369
            set { this.vanishField = value; }
5370
        }
5371

5372
        List<CT_VerticalAlignRun> vertAlignField;
5373
        [XmlElement(Order = 4)]
5374
        public List<CT_VerticalAlignRun> vertAlign
5375
        {
5376
            get { return this.vertAlignField; }
5377
            set { this.vertAlignField = value; }
5378
        }
5379

5380
        List<CT_TextScale> wField;
5381
        [XmlElement(Order = 4)]
5382
        public List<CT_TextScale> w
5383
        {
5384
            get { return this.wField; }
5385
            set { this.wField = value; }
5386
        }
5387

5388

5389
        public static CT_ParaRPrOriginal Parse(XmlNode node, XmlNamespaceManager namespaceManager)
5390
        {
5391
            if (node == null)
5392
                return null;
5393
            CT_ParaRPrOriginal ctObj = new CT_ParaRPrOriginal();
5394
            ctObj.webHidden = new List<CT_OnOff>();
5395
            ctObj.b = new List<CT_OnOff>();
5396
            ctObj.bCs = new List<CT_OnOff>();
5397
            ctObj.bdr = new List<CT_Border>();
5398
            ctObj.caps = new List<CT_OnOff>();
5399
            ctObj.color = new List<CT_Color>();
5400
            ctObj.cs = new List<CT_OnOff>();
5401
            ctObj.dstrike = new List<CT_OnOff>();
5402
            ctObj.eastAsianLayout = new List<CT_EastAsianLayout>();
5403
            ctObj.effect = new List<CT_TextEffect>();
5404
            ctObj.em = new List<CT_Em>();
5405
            ctObj.emboss = new List<CT_OnOff>();
5406
            ctObj.fitText = new List<CT_FitText>();
5407
            ctObj.highlight = new List<CT_Highlight>();
5408
            ctObj.i = new List<CT_OnOff>();
5409
            ctObj.iCs = new List<CT_OnOff>();
5410
            ctObj.imprint = new List<CT_OnOff>();
5411
            ctObj.kern = new List<CT_HpsMeasure>();
5412
            ctObj.lang = new List<CT_Language>();
5413
            ctObj.noProof = new List<CT_OnOff>();
5414
            ctObj.oMath = new List<CT_OnOff>();
5415
            ctObj.outline = new List<CT_OnOff>();
5416
            ctObj.position = new List<CT_SignedHpsMeasure>();
5417
            ctObj.rFonts = new List<CT_Fonts>();
5418
            ctObj.rStyle = new List<CT_String>();
5419
            ctObj.rtl = new List<CT_OnOff>();
5420
            ctObj.shadow = new List<CT_OnOff>();
5421
            ctObj.shd = new List<CT_Shd>();
5422
            ctObj.smallCaps = new List<CT_OnOff>();
5423
            ctObj.snapToGrid = new List<CT_OnOff>();
5424
            ctObj.spacing = new List<CT_SignedTwipsMeasure>();
5425
            ctObj.specVanish = new List<CT_OnOff>();
5426
            ctObj.strike = new List<CT_OnOff>();
5427
            ctObj.sz = new List<CT_HpsMeasure>();
5428
            ctObj.szCs = new List<CT_HpsMeasure>();
5429
            ctObj.u = new List<CT_Underline>();
5430
            ctObj.vanish = new List<CT_OnOff>();
5431
            ctObj.vertAlign = new List<CT_VerticalAlignRun>();
5432
            ctObj.w = new List<CT_TextScale>();
5433
            foreach (XmlNode childNode in node.ChildNodes)
5434
            {
5435
                if (childNode.LocalName == "ins")
5436
                    ctObj.ins = CT_TrackChange.Parse(childNode, namespaceManager);
5437
                else if (childNode.LocalName == "del")
5438
                    ctObj.del = CT_TrackChange.Parse(childNode, namespaceManager);
5439
                else if (childNode.LocalName == "moveFrom")
5440
                    ctObj.moveFrom = CT_TrackChange.Parse(childNode, namespaceManager);
5441
                else if (childNode.LocalName == "moveTo")
5442
                    ctObj.moveTo = CT_TrackChange.Parse(childNode, namespaceManager);
5443
                else if (childNode.LocalName == "webHidden")
5444
                    ctObj.webHidden.Add(CT_OnOff.Parse(childNode, namespaceManager));
5445
                else if (childNode.LocalName == "b")
5446
                    ctObj.b.Add(CT_OnOff.Parse(childNode, namespaceManager));
5447
                else if (childNode.LocalName == "bCs")
5448
                    ctObj.bCs.Add(CT_OnOff.Parse(childNode, namespaceManager));
5449
                else if (childNode.LocalName == "bdr")
5450
                    ctObj.bdr.Add(CT_Border.Parse(childNode, namespaceManager));
5451
                else if (childNode.LocalName == "caps")
5452
                    ctObj.caps.Add(CT_OnOff.Parse(childNode, namespaceManager));
5453
                else if (childNode.LocalName == "color")
5454
                    ctObj.color.Add(CT_Color.Parse(childNode, namespaceManager));
5455
                else if (childNode.LocalName == "cs")
5456
                    ctObj.cs.Add(CT_OnOff.Parse(childNode, namespaceManager));
5457
                else if (childNode.LocalName == "dstrike")
5458
                    ctObj.dstrike.Add(CT_OnOff.Parse(childNode, namespaceManager));
5459
                else if (childNode.LocalName == "eastAsianLayout")
5460
                    ctObj.eastAsianLayout.Add(CT_EastAsianLayout.Parse(childNode, namespaceManager));
5461
                else if (childNode.LocalName == "effect")
5462
                    ctObj.effect.Add(CT_TextEffect.Parse(childNode, namespaceManager));
5463
                else if (childNode.LocalName == "em")
5464
                    ctObj.em.Add(CT_Em.Parse(childNode, namespaceManager));
5465
                else if (childNode.LocalName == "emboss")
5466
                    ctObj.emboss.Add(CT_OnOff.Parse(childNode, namespaceManager));
5467
                else if (childNode.LocalName == "fitText")
5468
                    ctObj.fitText.Add(CT_FitText.Parse(childNode, namespaceManager));
5469
                else if (childNode.LocalName == "highlight")
5470
                    ctObj.highlight.Add(CT_Highlight.Parse(childNode, namespaceManager));
5471
                else if (childNode.LocalName == "i")
5472
                    ctObj.i.Add(CT_OnOff.Parse(childNode, namespaceManager));
5473
                else if (childNode.LocalName == "iCs")
5474
                    ctObj.iCs.Add(CT_OnOff.Parse(childNode, namespaceManager));
5475
                else if (childNode.LocalName == "imprint")
5476
                    ctObj.imprint.Add(CT_OnOff.Parse(childNode, namespaceManager));
5477
                else if (childNode.LocalName == "kern")
5478
                    ctObj.kern.Add(CT_HpsMeasure.Parse(childNode, namespaceManager));
5479
                else if (childNode.LocalName == "lang")
5480
                    ctObj.lang.Add(CT_Language.Parse(childNode, namespaceManager));
5481
                else if (childNode.LocalName == "noProof")
5482
                    ctObj.noProof.Add(CT_OnOff.Parse(childNode, namespaceManager));
5483
                else if (childNode.LocalName == "oMath")
5484
                    ctObj.oMath.Add(CT_OnOff.Parse(childNode, namespaceManager));
5485
                else if (childNode.LocalName == "outline")
5486
                    ctObj.outline.Add(CT_OnOff.Parse(childNode, namespaceManager));
5487
                else if (childNode.LocalName == "position")
5488
                    ctObj.position.Add(CT_SignedHpsMeasure.Parse(childNode, namespaceManager));
5489
                else if (childNode.LocalName == "rFonts")
5490
                    ctObj.rFonts.Add(CT_Fonts.Parse(childNode, namespaceManager));
5491
                else if (childNode.LocalName == "rStyle")
5492
                    ctObj.rStyle.Add(CT_String.Parse(childNode, namespaceManager));
5493
                else if (childNode.LocalName == "rtl")
5494
                    ctObj.rtl.Add(CT_OnOff.Parse(childNode, namespaceManager));
5495
                else if (childNode.LocalName == "shadow")
5496
                    ctObj.shadow.Add(CT_OnOff.Parse(childNode, namespaceManager));
5497
                else if (childNode.LocalName == "shd")
5498
                    ctObj.shd.Add(CT_Shd.Parse(childNode, namespaceManager));
5499
                else if (childNode.LocalName == "smallCaps")
5500
                    ctObj.smallCaps.Add(CT_OnOff.Parse(childNode, namespaceManager));
5501
                else if (childNode.LocalName == "snapToGrid")
5502
                    ctObj.snapToGrid.Add(CT_OnOff.Parse(childNode, namespaceManager));
5503
                else if (childNode.LocalName == "spacing")
5504
                    ctObj.spacing.Add(CT_SignedTwipsMeasure.Parse(childNode, namespaceManager));
5505
                else if (childNode.LocalName == "specVanish")
5506
                    ctObj.specVanish.Add(CT_OnOff.Parse(childNode, namespaceManager));
5507
                else if (childNode.LocalName == "strike")
5508
                    ctObj.strike.Add(CT_OnOff.Parse(childNode, namespaceManager));
5509
                else if (childNode.LocalName == "sz")
5510
                    ctObj.sz.Add(CT_HpsMeasure.Parse(childNode, namespaceManager));
5511
                else if (childNode.LocalName == "szCs")
5512
                    ctObj.szCs.Add(CT_HpsMeasure.Parse(childNode, namespaceManager));
5513
                else if (childNode.LocalName == "u")
5514
                    ctObj.u.Add(CT_Underline.Parse(childNode, namespaceManager));
5515
                else if (childNode.LocalName == "vanish")
5516
                    ctObj.vanish.Add(CT_OnOff.Parse(childNode, namespaceManager));
5517
                else if (childNode.LocalName == "vertAlign")
5518
                    ctObj.vertAlign.Add(CT_VerticalAlignRun.Parse(childNode, namespaceManager));
5519
                else if (childNode.LocalName == "w")
5520
                    ctObj.w.Add(CT_TextScale.Parse(childNode, namespaceManager));
5521
            }
5522
            return ctObj;
5523
        }
5524

5525

5526

5527
        internal void Write(StreamWriter sw, string nodeName)
5528
        {
5529
            sw.Write(string.Format("<w:{0}>", nodeName));
5530
            if (this.ins != null)
5531
                this.ins.Write(sw, "ins");
5532
            if (this.del != null)
5533
                this.del.Write(sw, "del");
5534
            if (this.moveFrom != null)
5535
                this.moveFrom.Write(sw, "moveFrom");
5536
            if (this.moveTo != null)
5537
                this.moveTo.Write(sw, "moveTo");
5538
            if (this.webHidden != null)
5539
            {
5540
                foreach (CT_OnOff x in this.webHidden)
5541
                {
5542
                    x.Write(sw, "webHidden");
5543
                }
5544
            }
5545
            if (this.b != null)
5546
            {
5547
                foreach (CT_OnOff x in this.b)
5548
                {
5549
                    x.Write(sw, "b");
5550
                }
5551
            }
5552
            if (this.bCs != null)
5553
            {
5554
                foreach (CT_OnOff x in this.bCs)
5555
                {
5556
                    x.Write(sw, "bCs");
5557
                }
5558
            }
5559
            if (this.bdr != null)
5560
            {
5561
                foreach (CT_Border x in this.bdr)
5562
                {
5563
                    x.Write(sw, "bdr");
5564
                }
5565
            }
5566
            if (this.caps != null)
5567
            {
5568
                foreach (CT_OnOff x in this.caps)
5569
                {
5570
                    x.Write(sw, "caps");
5571
                }
5572
            }
5573
            if (this.color != null)
5574
            {
5575
                foreach (CT_Color x in this.color)
5576
                {
5577
                    x.Write(sw, "color");
5578
                }
5579
            }
5580
            if (this.cs != null)
5581
            {
5582
                foreach (CT_OnOff x in this.cs)
5583
                {
5584
                    x.Write(sw, "cs");
5585
                }
5586
            }
5587
            if (this.dstrike != null)
5588
            {
5589
                foreach (CT_OnOff x in this.dstrike)
5590
                {
5591
                    x.Write(sw, "dstrike");
5592
                }
5593
            }
5594
            if (this.eastAsianLayout != null)
5595
            {
5596
                foreach (CT_EastAsianLayout x in this.eastAsianLayout)
5597
                {
5598
                    x.Write(sw, "eastAsianLayout");
5599
                }
5600
            }
5601
            if (this.effect != null)
5602
            {
5603
                foreach (CT_TextEffect x in this.effect)
5604
                {
5605
                    x.Write(sw, "effect");
5606
                }
5607
            }
5608
            if (this.em != null)
5609
            {
5610
                foreach (CT_Em x in this.em)
5611
                {
5612
                    x.Write(sw, "em");
5613
                }
5614
            }
5615
            if (this.emboss != null)
5616
            {
5617
                foreach (CT_OnOff x in this.emboss)
5618
                {
5619
                    x.Write(sw, "emboss");
5620
                }
5621
            }
5622
            if (this.fitText != null)
5623
            {
5624
                foreach (CT_FitText x in this.fitText)
5625
                {
5626
                    x.Write(sw, "fitText");
5627
                }
5628
            }
5629
            if (this.highlight != null)
5630
            {
5631
                foreach (CT_Highlight x in this.highlight)
5632
                {
5633
                    x.Write(sw, "highlight");
5634
                }
5635
            }
5636
            if (this.i != null)
5637
            {
5638
                foreach (CT_OnOff x in this.i)
5639
                {
5640
                    x.Write(sw, "i");
5641
                }
5642
            }
5643
            if (this.iCs != null)
5644
            {
5645
                foreach (CT_OnOff x in this.iCs)
5646
                {
5647
                    x.Write(sw, "iCs");
5648
                }
5649
            }
5650
            if (this.imprint != null)
5651
            {
5652
                foreach (CT_OnOff x in this.imprint)
5653
                {
5654
                    x.Write(sw, "imprint");
5655
                }
5656
            }
5657
            if (this.kern != null)
5658
            {
5659
                foreach (CT_HpsMeasure x in this.kern)
5660
                {
5661
                    x.Write(sw, "kern");
5662
                }
5663
            }
5664
            if (this.lang != null)
5665
            {
5666
                foreach (CT_Language x in this.lang)
5667
                {
5668
                    x.Write(sw, "lang");
5669
                }
5670
            }
5671
            if (this.noProof != null)
5672
            {
5673
                foreach (CT_OnOff x in this.noProof)
5674
                {
5675
                    x.Write(sw, "noProof");
5676
                }
5677
            }
5678
            if (this.oMath != null)
5679
            {
5680
                foreach (CT_OnOff x in this.oMath)
5681
                {
5682
                    x.Write(sw, "oMath");
5683
                }
5684
            }
5685
            if (this.outline != null)
5686
            {
5687
                foreach (CT_OnOff x in this.outline)
5688
                {
5689
                    x.Write(sw, "outline");
5690
                }
5691
            }
5692
            if (this.position != null)
5693
            {
5694
                foreach (CT_SignedHpsMeasure x in this.position)
5695
                {
5696
                    x.Write(sw, "position");
5697
                }
5698
            }
5699
            if (this.rFonts != null)
5700
            {
5701
                foreach (CT_Fonts x in this.rFonts)
5702
                {
5703
                    x.Write(sw, "rFonts");
5704
                }
5705
            }
5706
            if (this.rStyle != null)
5707
            {
5708
                foreach (CT_String x in this.rStyle)
5709
                {
5710
                    x.Write(sw, "rStyle");
5711
                }
5712
            }
5713
            if (this.rtl != null)
5714
            {
5715
                foreach (CT_OnOff x in this.rtl)
5716
                {
5717
                    x.Write(sw, "rtl");
5718
                }
5719
            }
5720
            if (this.shadow != null)
5721
            {
5722
                foreach (CT_OnOff x in this.shadow)
5723
                {
5724
                    x.Write(sw, "shadow");
5725
                }
5726
            }
5727
            if (this.shd != null)
5728
            {
5729
                foreach (CT_Shd x in this.shd)
5730
                {
5731
                    x.Write(sw, "shd");
5732
                }
5733
            }
5734
            if (this.smallCaps != null)
5735
            {
5736
                foreach (CT_OnOff x in this.smallCaps)
5737
                {
5738
                    x.Write(sw, "smallCaps");
5739
                }
5740
            }
5741
            if (this.snapToGrid != null)
5742
            {
5743
                foreach (CT_OnOff x in this.snapToGrid)
5744
                {
5745
                    x.Write(sw, "snapToGrid");
5746
                }
5747
            }
5748
            if (this.spacing != null)
5749
            {
5750
                foreach (CT_SignedTwipsMeasure x in this.spacing)
5751
                {
5752
                    x.Write(sw, "spacing");
5753
                }
5754
            }
5755
            if (this.specVanish != null)
5756
            {
5757
                foreach (CT_OnOff x in this.specVanish)
5758
                {
5759
                    x.Write(sw, "specVanish");
5760
                }
5761
            }
5762
            if (this.strike != null)
5763
            {
5764
                foreach (CT_OnOff x in this.strike)
5765
                {
5766
                    x.Write(sw, "strike");
5767
                }
5768
            }
5769
            if (this.sz != null)
5770
            {
5771
                foreach (CT_HpsMeasure x in this.sz)
5772
                {
5773
                    x.Write(sw, "sz");
5774
                }
5775
            }
5776
            if (this.szCs != null)
5777
            {
5778
                foreach (CT_HpsMeasure x in this.szCs)
5779
                {
5780
                    x.Write(sw, "szCs");
5781
                }
5782
            }
5783
            if (this.u != null)
5784
            {
5785
                foreach (CT_Underline x in this.u)
5786
                {
5787
                    x.Write(sw, "u");
5788
                }
5789
            }
5790
            if (this.vanish != null)
5791
            {
5792
                foreach (CT_OnOff x in this.vanish)
5793
                {
5794
                    x.Write(sw, "vanish");
5795
                }
5796
            }
5797
            if (this.vertAlign != null)
5798
            {
5799
                foreach (CT_VerticalAlignRun x in this.vertAlign)
5800
                {
5801
                    x.Write(sw, "vertAlign");
5802
                }
5803
            }
5804
            if (this.w != null)
5805
            {
5806
                foreach (CT_TextScale x in this.w)
5807
                {
5808
                    x.Write(sw, "w");
5809
                }
5810
            }
5811
            sw.WriteEndW(nodeName);
5812
        }
5813

5814
    }
5815

5816

5817
    [Serializable]
5818
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
5819
    public enum ItemsChoiceType3
5820
    {
5821

5822
    
5823
        b,
5824

5825
    
5826
        bCs,
5827

5828
    
5829
        bdr,
5830

5831
    
5832
        caps,
5833

5834
    
5835
        color,
5836

5837
    
5838
        cs,
5839

5840
    
5841
        dstrike,
5842

5843
    
5844
        eastAsianLayout,
5845

5846
    
5847
        effect,
5848

5849
    
5850
        em,
5851

5852
    
5853
        emboss,
5854

5855
    
5856
        fitText,
5857

5858
    
5859
        highlight,
5860

5861
    
5862
        i,
5863

5864
    
5865
        iCs,
5866

5867
    
5868
        imprint,
5869

5870
    
5871
        kern,
5872

5873
    
5874
        lang,
5875

5876
    
5877
        noProof,
5878

5879
    
5880
        oMath,
5881

5882
    
5883
        outline,
5884

5885
    
5886
        position,
5887

5888
    
5889
        rFonts,
5890

5891
    
5892
        rStyle,
5893

5894
    
5895
        rtl,
5896

5897
    
5898
        shadow,
5899

5900
    
5901
        shd,
5902

5903
    
5904
        smallCaps,
5905

5906
    
5907
        snapToGrid,
5908

5909
    
5910
        spacing,
5911

5912
    
5913
        specVanish,
5914

5915
    
5916
        strike,
5917

5918
    
5919
        sz,
5920

5921
    
5922
        szCs,
5923

5924
    
5925
        u,
5926

5927
    
5928
        vanish,
5929

5930
    
5931
        vertAlign,
5932

5933
    
5934
        w,
5935

5936
    
5937
        webHidden,
5938
    }
5939

5940

5941
    [Serializable]
5942

5943
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
5944
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
5945
    public class CT_PPrChange : CT_TrackChange
5946
    {
5947

5948
        private CT_PPrBase pPrField;
5949

5950
        public CT_PPrChange()
5951
        {
5952
            //this.pPrField = new CT_PPrBase();
5953
        }
5954
        public static new CT_PPrChange Parse(XmlNode node, XmlNamespaceManager namespaceManager)
5955
        {
5956
            if (node == null)
5957
                return null;
5958
            CT_PPrChange ctObj = new CT_PPrChange();
5959
            ctObj.author = XmlHelper.ReadString(node.Attributes["w:author"]);
5960
            ctObj.date = XmlHelper.ReadString(node.Attributes["w:date"]);
5961
            ctObj.id = XmlHelper.ReadString(node.Attributes["r:id"]);
5962
            foreach (XmlNode childNode in node.ChildNodes)
5963
            {
5964
                if (childNode.LocalName == "pPr")
5965
                    ctObj.pPr = CT_PPrBase.Parse(childNode, namespaceManager);
5966
            }
5967
            return ctObj;
5968
        }
5969

5970

5971

5972
        internal new void Write(StreamWriter sw, string nodeName)
5973
        {
5974
            sw.Write(string.Format("<w:{0}", nodeName));
5975
            XmlHelper.WriteAttribute(sw, "w:author", this.author);
5976
            XmlHelper.WriteAttribute(sw, "w:date", this.date);
5977
            XmlHelper.WriteAttribute(sw, "r:id", this.id);
5978
            sw.Write(">");
5979
            if (this.pPr != null)
5980
                this.pPr.Write(sw, "pPr");
5981
            sw.WriteEndW(nodeName);
5982
        }
5983

5984

5985

5986
        [XmlElement(Order = 0)]
5987
        public CT_PPrBase pPr
5988
        {
5989
            get
5990
            {
5991
                return this.pPrField;
5992
            }
5993
            set
5994
            {
5995
                this.pPrField = value;
5996
            }
5997
        }
5998
    }
5999

6000
    [XmlInclude(typeof(CT_PPr))]
6001

6002
    [Serializable]
6003

6004
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
6005
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
6006
    public class CT_PPrBase
6007
    {
6008

6009
        private CT_String pStyleField;
6010

6011
        private CT_OnOff keepNextField;
6012

6013
        private CT_OnOff keepLinesField;
6014

6015
        private CT_OnOff pageBreakBeforeField;
6016

6017
        private CT_FramePr framePrField;
6018

6019
        private CT_OnOff widowControlField;
6020

6021
        private CT_NumPr numPrField;
6022

6023
        private CT_OnOff suppressLineNumbersField;
6024

6025
        private CT_PBdr pBdrField;
6026

6027
        private CT_Shd shdField;
6028

6029
        private List<CT_TabStop> tabsField;
6030

6031
        private CT_OnOff suppressAutoHyphensField;
6032

6033
        private CT_OnOff kinsokuField;
6034

6035
        private CT_OnOff wordWrapField;
6036

6037
        private CT_OnOff overflowPunctField;
6038

6039
        private CT_OnOff topLinePunctField;
6040

6041
        private CT_OnOff autoSpaceDEField;
6042

6043
        private CT_OnOff autoSpaceDNField;
6044

6045
        private CT_OnOff bidiField;
6046

6047
        private CT_OnOff adjustRightIndField;
6048

6049
        private CT_OnOff snapToGridField;
6050

6051
        private CT_Spacing spacingField;
6052

6053
        private CT_Ind indField;
6054

6055
        private CT_OnOff contextualSpacingField;
6056

6057
        private CT_OnOff mirrorIndentsField;
6058

6059
        private CT_OnOff suppressOverlapField;
6060

6061
        private CT_Jc jcField;
6062

6063
        private CT_TextDirection textDirectionField;
6064

6065
        private CT_TextAlignment textAlignmentField;
6066

6067
        private CT_TextboxTightWrap textboxTightWrapField;
6068

6069
        private CT_DecimalNumber outlineLvlField;
6070

6071
        private CT_DecimalNumber divIdField;
6072

6073
        private CT_Cnf cnfStyleField;
6074

6075
        public virtual bool IsEmpty
6076
        {
6077
            get
6078
            {
6079
                return pStyleField == null &&
6080
keepNextField == null &&
6081
keepLinesField == null &&
6082
pageBreakBeforeField == null &&
6083
framePrField == null &&
6084
widowControlField == null &&
6085
numPrField == null &&
6086
suppressLineNumbersField == null &&
6087
pBdrField == null &&
6088
shdField == null &&
6089
tabsField == null &&
6090
suppressAutoHyphensField == null &&
6091
kinsokuField == null &&
6092
wordWrapField == null &&
6093
overflowPunctField == null &&
6094
topLinePunctField == null &&
6095
autoSpaceDEField == null &&
6096
autoSpaceDNField == null &&
6097
bidiField == null &&
6098
adjustRightIndField == null &&
6099
snapToGridField == null &&
6100
spacingField == null &&
6101
indField == null &&
6102
contextualSpacingField == null &&
6103
mirrorIndentsField == null &&
6104
suppressOverlapField == null &&
6105
jcField == null &&
6106
textDirectionField == null &&
6107
textAlignmentField == null &&
6108
textboxTightWrapField == null &&
6109
outlineLvlField == null &&
6110
divIdField == null &&
6111
cnfStyleField == null;
6112
            }
6113
        }
6114

6115
        public CT_PPrBase()
6116
        {
6117

6118
        }
6119
        public static CT_PPrBase Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6120
        {
6121
            if (node == null)
6122
                return null;
6123
            CT_PPrBase ctObj = new CT_PPrBase();
6124
            ctObj.tabs = new List<CT_TabStop>();
6125
            foreach (XmlNode childNode in node.ChildNodes)
6126
            {
6127
                if (childNode.LocalName == "pStyle")
6128
                    ctObj.pStyle = CT_String.Parse(childNode, namespaceManager);
6129
                else if (childNode.LocalName == "keepNext")
6130
                    ctObj.keepNext = CT_OnOff.Parse(childNode, namespaceManager);
6131
                else if (childNode.LocalName == "keepLines")
6132
                    ctObj.keepLines = CT_OnOff.Parse(childNode, namespaceManager);
6133
                else if (childNode.LocalName == "pageBreakBefore")
6134
                    ctObj.pageBreakBefore = CT_OnOff.Parse(childNode, namespaceManager);
6135
                else if (childNode.LocalName == "framePr")
6136
                    ctObj.framePr = CT_FramePr.Parse(childNode, namespaceManager);
6137
                else if (childNode.LocalName == "widowControl")
6138
                    ctObj.widowControl = CT_OnOff.Parse(childNode, namespaceManager);
6139
                else if (childNode.LocalName == "numPr")
6140
                    ctObj.numPr = CT_NumPr.Parse(childNode, namespaceManager);
6141
                else if (childNode.LocalName == "suppressLineNumbers")
6142
                    ctObj.suppressLineNumbers = CT_OnOff.Parse(childNode, namespaceManager);
6143
                else if (childNode.LocalName == "pBdr")
6144
                    ctObj.pBdr = CT_PBdr.Parse(childNode, namespaceManager);
6145
                else if (childNode.LocalName == "shd")
6146
                    ctObj.shd = CT_Shd.Parse(childNode, namespaceManager);
6147
                else if (childNode.LocalName == "suppressAutoHyphens")
6148
                    ctObj.suppressAutoHyphens = CT_OnOff.Parse(childNode, namespaceManager);
6149
                else if (childNode.LocalName == "kinsoku")
6150
                    ctObj.kinsoku = CT_OnOff.Parse(childNode, namespaceManager);
6151
                else if (childNode.LocalName == "wordWrap")
6152
                    ctObj.wordWrap = CT_OnOff.Parse(childNode, namespaceManager);
6153
                else if (childNode.LocalName == "overflowPunct")
6154
                    ctObj.overflowPunct = CT_OnOff.Parse(childNode, namespaceManager);
6155
                else if (childNode.LocalName == "topLinePunct")
6156
                    ctObj.topLinePunct = CT_OnOff.Parse(childNode, namespaceManager);
6157
                else if (childNode.LocalName == "autoSpaceDE")
6158
                    ctObj.autoSpaceDE = CT_OnOff.Parse(childNode, namespaceManager);
6159
                else if (childNode.LocalName == "autoSpaceDN")
6160
                    ctObj.autoSpaceDN = CT_OnOff.Parse(childNode, namespaceManager);
6161
                else if (childNode.LocalName == "bidi")
6162
                    ctObj.bidi = CT_OnOff.Parse(childNode, namespaceManager);
6163
                else if (childNode.LocalName == "adjustRightInd")
6164
                    ctObj.adjustRightInd = CT_OnOff.Parse(childNode, namespaceManager);
6165
                else if (childNode.LocalName == "snapToGrid")
6166
                    ctObj.snapToGrid = CT_OnOff.Parse(childNode, namespaceManager);
6167
                else if (childNode.LocalName == "spacing")
6168
                    ctObj.spacing = CT_Spacing.Parse(childNode, namespaceManager);
6169
                else if (childNode.LocalName == "ind")
6170
                    ctObj.ind = CT_Ind.Parse(childNode, namespaceManager);
6171
                else if (childNode.LocalName == "contextualSpacing")
6172
                    ctObj.contextualSpacing = CT_OnOff.Parse(childNode, namespaceManager);
6173
                else if (childNode.LocalName == "mirrorIndents")
6174
                    ctObj.mirrorIndents = CT_OnOff.Parse(childNode, namespaceManager);
6175
                else if (childNode.LocalName == "suppressOverlap")
6176
                    ctObj.suppressOverlap = CT_OnOff.Parse(childNode, namespaceManager);
6177
                else if (childNode.LocalName == "jc")
6178
                    ctObj.jc = CT_Jc.Parse(childNode, namespaceManager);
6179
                else if (childNode.LocalName == "textDirection")
6180
                    ctObj.textDirection = CT_TextDirection.Parse(childNode, namespaceManager);
6181
                else if (childNode.LocalName == "textAlignment")
6182
                    ctObj.textAlignment = CT_TextAlignment.Parse(childNode, namespaceManager);
6183
                else if (childNode.LocalName == "textboxTightWrap")
6184
                    ctObj.textboxTightWrap = CT_TextboxTightWrap.Parse(childNode, namespaceManager);
6185
                else if (childNode.LocalName == "outlineLvl")
6186
                    ctObj.outlineLvl = CT_DecimalNumber.Parse(childNode, namespaceManager);
6187
                else if (childNode.LocalName == "divId")
6188
                    ctObj.divId = CT_DecimalNumber.Parse(childNode, namespaceManager);
6189
                else if (childNode.LocalName == "cnfStyle")
6190
                    ctObj.cnfStyle = CT_Cnf.Parse(childNode, namespaceManager);
6191
                else if (childNode.LocalName == "tabs")
6192
                {
6193
                    foreach (XmlNode snode in childNode.ChildNodes)
6194
                    {
6195
                        ctObj.tabs.Add(CT_TabStop.Parse(snode, namespaceManager));
6196
                    }
6197
                }
6198
            }
6199
            return ctObj;
6200
        }
6201

6202

6203

6204
        internal void Write(StreamWriter sw, string nodeName)
6205
        {
6206
            sw.Write(string.Format("<w:{0}", nodeName));
6207
            sw.Write(">");
6208
            if (this.pStyle != null)
6209
                this.pStyle.Write(sw, "pStyle");
6210
            if (this.tabs != null && this.tabs.Count > 0)
6211
            {
6212
                sw.Write("<w:tabs>");
6213
                foreach (CT_TabStop x in this.tabs)
6214
                {
6215
                    x.Write(sw, "tab");
6216
                }
6217
                sw.Write("</w:tabs>");
6218
            }
6219
            if (this.keepNext != null)
6220
                this.keepNext.Write(sw, "keepNext");
6221
            if (this.keepLines != null)
6222
                this.keepLines.Write(sw, "keepLines");
6223
            if (this.pageBreakBefore != null)
6224
                this.pageBreakBefore.Write(sw, "pageBreakBefore");
6225
            if (this.framePr != null)
6226
                this.framePr.Write(sw, "framePr");
6227
            if (this.widowControl != null)
6228
                this.widowControl.Write(sw, "widowControl");
6229
            if (this.numPr != null)
6230
                this.numPr.Write(sw, "numPr");
6231
            if (this.suppressLineNumbers != null)
6232
                this.suppressLineNumbers.Write(sw, "suppressLineNumbers");
6233
            if (this.pBdr != null)
6234
                this.pBdr.Write(sw, "pBdr");
6235
            if (this.shd != null)
6236
                this.shd.Write(sw, "shd");
6237
            if (this.suppressAutoHyphens != null)
6238
                this.suppressAutoHyphens.Write(sw, "suppressAutoHyphens");
6239
            if (this.kinsoku != null)
6240
                this.kinsoku.Write(sw, "kinsoku");
6241
            if (this.wordWrap != null)
6242
                this.wordWrap.Write(sw, "wordWrap");
6243
            if (this.overflowPunct != null)
6244
                this.overflowPunct.Write(sw, "overflowPunct");
6245
            if (this.topLinePunct != null)
6246
                this.topLinePunct.Write(sw, "topLinePunct");
6247
            if (this.autoSpaceDE != null)
6248
                this.autoSpaceDE.Write(sw, "autoSpaceDE");
6249
            if (this.autoSpaceDN != null)
6250
                this.autoSpaceDN.Write(sw, "autoSpaceDN");
6251
            if (this.bidi != null)
6252
                this.bidi.Write(sw, "bidi");
6253
            if (this.adjustRightInd != null)
6254
                this.adjustRightInd.Write(sw, "adjustRightInd");
6255
            if (this.snapToGrid != null)
6256
                this.snapToGrid.Write(sw, "snapToGrid");
6257
            if (this.spacing != null)
6258
                this.spacing.Write(sw, "spacing");
6259
            if (this.ind != null)
6260
                this.ind.Write(sw, "ind");
6261
            if (this.contextualSpacing != null)
6262
                this.contextualSpacing.Write(sw, "contextualSpacing");
6263
            if (this.mirrorIndents != null)
6264
                this.mirrorIndents.Write(sw, "mirrorIndents");
6265
            if (this.suppressOverlap != null)
6266
                this.suppressOverlap.Write(sw, "suppressOverlap");
6267
            if (this.jc != null)
6268
                this.jc.Write(sw, "jc");
6269
            if (this.textDirection != null)
6270
                this.textDirection.Write(sw, "textDirection");
6271
            if (this.textAlignment != null)
6272
                this.textAlignment.Write(sw, "textAlignment");
6273
            if (this.textboxTightWrap != null)
6274
                this.textboxTightWrap.Write(sw, "textboxTightWrap");
6275
            if (this.outlineLvl != null)
6276
                this.outlineLvl.Write(sw, "outlineLvl");
6277
            if (this.divId != null)
6278
                this.divId.Write(sw, "divId");
6279
            if (this.cnfStyle != null)
6280
                this.cnfStyle.Write(sw, "cnfStyle");
6281

6282
            sw.WriteEndW(nodeName);
6283
        }
6284

6285

6286
        [XmlElement(Order = 0)]
6287
        public CT_String pStyle
6288
        {
6289
            get
6290
            {
6291
                return this.pStyleField;
6292
            }
6293
            set
6294
            {
6295
                this.pStyleField = value;
6296
            }
6297
        }
6298

6299
        [XmlElement(Order = 1)]
6300
        public CT_OnOff keepNext
6301
        {
6302
            get
6303
            {
6304
                return this.keepNextField;
6305
            }
6306
            set
6307
            {
6308
                this.keepNextField = value;
6309
            }
6310
        }
6311

6312
        [XmlElement(Order = 2)]
6313
        public CT_OnOff keepLines
6314
        {
6315
            get
6316
            {
6317
                return this.keepLinesField;
6318
            }
6319
            set
6320
            {
6321
                this.keepLinesField = value;
6322
            }
6323
        }
6324

6325
        [XmlElement(Order = 3)]
6326
        public CT_OnOff pageBreakBefore
6327
        {
6328
            get
6329
            {
6330
                return this.pageBreakBeforeField;
6331
            }
6332
            set
6333
            {
6334
                this.pageBreakBeforeField = value;
6335
            }
6336
        }
6337

6338
        [XmlElement(Order = 4)]
6339
        public CT_FramePr framePr
6340
        {
6341
            get
6342
            {
6343
                return this.framePrField;
6344
            }
6345
            set
6346
            {
6347
                this.framePrField = value;
6348
            }
6349
        }
6350

6351
        [XmlElement(Order = 5)]
6352
        public CT_OnOff widowControl
6353
        {
6354
            get
6355
            {
6356
                return this.widowControlField;
6357
            }
6358
            set
6359
            {
6360
                this.widowControlField = value;
6361
            }
6362
        }
6363

6364
        [XmlElement(Order = 6)]
6365
        public CT_NumPr numPr
6366
        {
6367
            get
6368
            {
6369
                return this.numPrField;
6370
            }
6371
            set
6372
            {
6373
                this.numPrField = value;
6374
            }
6375
        }
6376

6377
        [XmlElement(Order = 7)]
6378
        public CT_OnOff suppressLineNumbers
6379
        {
6380
            get
6381
            {
6382
                return this.suppressLineNumbersField;
6383
            }
6384
            set
6385
            {
6386
                this.suppressLineNumbersField = value;
6387
            }
6388
        }
6389

6390
        [XmlElement(Order = 8)]
6391
        public CT_PBdr pBdr
6392
        {
6393
            get
6394
            {
6395
                return this.pBdrField;
6396
            }
6397
            set
6398
            {
6399
                this.pBdrField = value;
6400
            }
6401
        }
6402

6403
        [XmlElement(Order = 9)]
6404
        public CT_Shd shd
6405
        {
6406
            get
6407
            {
6408
                return this.shdField;
6409
            }
6410
            set
6411
            {
6412
                this.shdField = value;
6413
            }
6414
        }
6415

6416
        [XmlArray(Order = 10)]
6417
        [XmlArrayItem("tab", IsNullable = false)]
6418
        public List<CT_TabStop> tabs
6419
        {
6420
            get
6421
            {
6422
                return this.tabsField;
6423
            }
6424
            set
6425
            {
6426
                this.tabsField = value;
6427
            }
6428
        }
6429

6430
        [XmlElement(Order = 11)]
6431
        public CT_OnOff suppressAutoHyphens
6432
        {
6433
            get
6434
            {
6435
                return this.suppressAutoHyphensField;
6436
            }
6437
            set
6438
            {
6439
                this.suppressAutoHyphensField = value;
6440
            }
6441
        }
6442

6443
        [XmlElement(Order = 12)]
6444
        public CT_OnOff kinsoku
6445
        {
6446
            get
6447
            {
6448
                return this.kinsokuField;
6449
            }
6450
            set
6451
            {
6452
                this.kinsokuField = value;
6453
            }
6454
        }
6455

6456
        [XmlElement(Order = 13)]
6457
        public CT_OnOff wordWrap
6458
        {
6459
            get
6460
            {
6461
                return this.wordWrapField;
6462
            }
6463
            set
6464
            {
6465
                this.wordWrapField = value;
6466
            }
6467
        }
6468

6469
        [XmlElement(Order = 14)]
6470
        public CT_OnOff overflowPunct
6471
        {
6472
            get
6473
            {
6474
                return this.overflowPunctField;
6475
            }
6476
            set
6477
            {
6478
                this.overflowPunctField = value;
6479
            }
6480
        }
6481

6482
        [XmlElement(Order = 15)]
6483
        public CT_OnOff topLinePunct
6484
        {
6485
            get
6486
            {
6487
                return this.topLinePunctField;
6488
            }
6489
            set
6490
            {
6491
                this.topLinePunctField = value;
6492
            }
6493
        }
6494

6495
        [XmlElement(Order = 16)]
6496
        public CT_OnOff autoSpaceDE
6497
        {
6498
            get
6499
            {
6500
                return this.autoSpaceDEField;
6501
            }
6502
            set
6503
            {
6504
                this.autoSpaceDEField = value;
6505
            }
6506
        }
6507

6508
        [XmlElement(Order = 17)]
6509
        public CT_OnOff autoSpaceDN
6510
        {
6511
            get
6512
            {
6513
                return this.autoSpaceDNField;
6514
            }
6515
            set
6516
            {
6517
                this.autoSpaceDNField = value;
6518
            }
6519
        }
6520

6521
        [XmlElement(Order = 18)]
6522
        public CT_OnOff bidi
6523
        {
6524
            get
6525
            {
6526
                return this.bidiField;
6527
            }
6528
            set
6529
            {
6530
                this.bidiField = value;
6531
            }
6532
        }
6533

6534
        [XmlElement(Order = 19)]
6535
        public CT_OnOff adjustRightInd
6536
        {
6537
            get
6538
            {
6539
                return this.adjustRightIndField;
6540
            }
6541
            set
6542
            {
6543
                this.adjustRightIndField = value;
6544
            }
6545
        }
6546

6547
        [XmlElement(Order = 20)]
6548
        public CT_OnOff snapToGrid
6549
        {
6550
            get
6551
            {
6552
                return this.snapToGridField;
6553
            }
6554
            set
6555
            {
6556
                this.snapToGridField = value;
6557
            }
6558
        }
6559

6560
        [XmlElement(Order = 21)]
6561
        public CT_Spacing spacing
6562
        {
6563
            get
6564
            {
6565
                return this.spacingField;
6566
            }
6567
            set
6568
            {
6569
                this.spacingField = value;
6570
            }
6571
        }
6572

6573
        [XmlElement(Order = 22)]
6574
        public CT_Ind ind
6575
        {
6576
            get
6577
            {
6578
                return this.indField;
6579
            }
6580
            set
6581
            {
6582
                this.indField = value;
6583
            }
6584
        }
6585

6586
        [XmlElement(Order = 23)]
6587
        public CT_OnOff contextualSpacing
6588
        {
6589
            get
6590
            {
6591
                return this.contextualSpacingField;
6592
            }
6593
            set
6594
            {
6595
                this.contextualSpacingField = value;
6596
            }
6597
        }
6598

6599
        [XmlElement(Order = 24)]
6600
        public CT_OnOff mirrorIndents
6601
        {
6602
            get
6603
            {
6604
                return this.mirrorIndentsField;
6605
            }
6606
            set
6607
            {
6608
                this.mirrorIndentsField = value;
6609
            }
6610
        }
6611

6612
        [XmlElement(Order = 25)]
6613
        public CT_OnOff suppressOverlap
6614
        {
6615
            get
6616
            {
6617
                return this.suppressOverlapField;
6618
            }
6619
            set
6620
            {
6621
                this.suppressOverlapField = value;
6622
            }
6623
        }
6624

6625
        [XmlElement(Order = 26)]
6626
        public CT_Jc jc
6627
        {
6628
            get
6629
            {
6630
                return this.jcField;
6631
            }
6632
            set
6633
            {
6634
                this.jcField = value;
6635
            }
6636
        }
6637

6638
        [XmlElement(Order = 27)]
6639
        public CT_TextDirection textDirection
6640
        {
6641
            get
6642
            {
6643
                return this.textDirectionField;
6644
            }
6645
            set
6646
            {
6647
                this.textDirectionField = value;
6648
            }
6649
        }
6650

6651
        [XmlElement(Order = 28)]
6652
        public CT_TextAlignment textAlignment
6653
        {
6654
            get
6655
            {
6656
                return this.textAlignmentField;
6657
            }
6658
            set
6659
            {
6660
                this.textAlignmentField = value;
6661
            }
6662
        }
6663

6664
        [XmlElement(Order = 29)]
6665
        public CT_TextboxTightWrap textboxTightWrap
6666
        {
6667
            get
6668
            {
6669
                return this.textboxTightWrapField;
6670
            }
6671
            set
6672
            {
6673
                this.textboxTightWrapField = value;
6674
            }
6675
        }
6676

6677
        [XmlElement(Order = 30)]
6678
        public CT_DecimalNumber outlineLvl
6679
        {
6680
            get
6681
            {
6682
                return this.outlineLvlField;
6683
            }
6684
            set
6685
            {
6686
                this.outlineLvlField = value;
6687
            }
6688
        }
6689

6690
        [XmlElement(Order = 31)]
6691
        public CT_DecimalNumber divId
6692
        {
6693
            get
6694
            {
6695
                return this.divIdField;
6696
            }
6697
            set
6698
            {
6699
                this.divIdField = value;
6700
            }
6701
        }
6702

6703
        [XmlElement(Order = 32)]
6704
        public CT_Cnf cnfStyle
6705
        {
6706
            get
6707
            {
6708
                return this.cnfStyleField;
6709
            }
6710
            set
6711
            {
6712
                this.cnfStyleField = value;
6713
            }
6714
        }
6715
        public bool IsSetTextAlignment()
6716
        {
6717
            if (this.textAlignmentField == null)
6718
                return false;
6719
            return this.textAlignmentField != null;
6720
        }
6721

6722
        public CT_TextAlignment AddNewTextAlignment()
6723
        {
6724
            if (this.textAlignmentField == null)
6725
                this.textAlignmentField = new CT_TextAlignment();
6726
            return this.textAlignmentField;
6727
        }
6728

6729
        public bool IsSetPStyle()
6730
        {
6731
            if (this.pStyleField == null)
6732
                return false;
6733
            return !string.IsNullOrEmpty(this.pStyleField.val);
6734
        }
6735

6736
        public CT_String AddNewPStyle()
6737
        {
6738
            if (this.pStyleField == null)
6739
                this.pStyleField = new CT_String();
6740
            return pStyleField;
6741
        }
6742

6743
        public bool IsSetShd()
6744
        {
6745
            return this.shdField != null;
6746
        }
6747
        public CT_Shd AddNewShd()
6748
        {
6749
            if (this.shdField == null)
6750
            {
6751
                this.shdField = new CT_Shd();
6752
            }
6753
            return this.shdField;
6754
        }
6755
        public bool IsSetJc()
6756
        {
6757
            return this.jcField != null;
6758
        }
6759

6760
        public CT_Jc AddNewJc()
6761
        {
6762
            if (this.jcField == null)
6763
            {
6764
                this.jcField = new CT_Jc();
6765
            }
6766
            return this.jcField;
6767
        }
6768

6769

6770

6771
        public bool IsSetPBdr()
6772
        {
6773
            return this.pBdrField != null;
6774
        }
6775

6776
        public CT_Spacing AddNewSpacing()
6777
        {
6778
            if (this.spacingField == null)
6779
                this.spacingField = new CT_Spacing();
6780
            return this.spacingField;
6781
        }
6782

6783
        public bool IsSetPageBreakBefore()
6784
        {
6785
            if (pageBreakBeforeField == null)
6786
                return false;
6787
            return this.pageBreakBeforeField.val == true;
6788
        }
6789

6790
        public CT_OnOff AddNewPageBreakBefore()
6791
        {
6792
            if (this.pageBreakBeforeField == null)
6793
                this.pageBreakBeforeField = new CT_OnOff();
6794
            return this.pageBreakBeforeField;
6795
        }
6796

6797
        public CT_PBdr AddNewPBdr()
6798
        {
6799
            if (this.pBdrField == null)
6800
                this.pBdrField = new CT_PBdr();
6801
            return this.pBdrField;
6802
        }
6803

6804
        public bool IsSetWordWrap()
6805
        {
6806
            if (wordWrapField == null)
6807
                return false;
6808
            return this.wordWrapField.val == true;
6809
        }
6810

6811
        public CT_OnOff AddNewWordWrap()
6812
        {
6813
            if (this.wordWrapField == null)
6814
                this.wordWrapField = new CT_OnOff();
6815
            return this.wordWrapField;
6816
        }
6817

6818
        public CT_Ind AddNewInd()
6819
        {
6820
            if (this.indField == null)
6821
                this.indField = new CT_Ind();
6822
            return this.indField;
6823
        }
6824

6825
        public CT_Tabs AddNewTabs()
6826
        {
6827
            CT_Tabs tab = new CT_Tabs();
6828
            this.tabsField = tab.tab;
6829

6830
            return tab;
6831
        }
6832
    }
6833
    [Serializable]
6834

6835
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
6836
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
6837
    public class CT_RPrChange : CT_TrackChange
6838
    {
6839

6840
        private CT_RPrOriginal rPrField;
6841

6842
        public CT_RPrChange()
6843
        {
6844
            //this.rPrField = new CT_RPrOriginal();
6845
        }
6846
        public static new CT_RPrChange Parse(XmlNode node, XmlNamespaceManager namespaceManager)
6847
        {
6848
            if (node == null)
6849
                return null;
6850
            CT_RPrChange ctObj = new CT_RPrChange();
6851
            ctObj.author = XmlHelper.ReadString(node.Attributes["w:author"]);
6852
            ctObj.date = XmlHelper.ReadString(node.Attributes["w:date"]);
6853
            ctObj.id = XmlHelper.ReadString(node.Attributes["r:id"]);
6854
            foreach (XmlNode childNode in node.ChildNodes)
6855
            {
6856
                if (childNode.LocalName == "rPr")
6857
                    ctObj.rPr = CT_RPrOriginal.Parse(childNode, namespaceManager);
6858
            }
6859
            return ctObj;
6860
        }
6861

6862

6863

6864
        internal new void Write(StreamWriter sw, string nodeName)
6865
        {
6866
            sw.Write(string.Format("<w:{0}", nodeName));
6867
            XmlHelper.WriteAttribute(sw, "w:author", this.author);
6868
            XmlHelper.WriteAttribute(sw, "w:date", this.date);
6869
            XmlHelper.WriteAttribute(sw, "r:id", this.id);
6870
            sw.Write(">");
6871
            if (this.rPr != null)
6872
                this.rPr.Write(sw, "rPr");
6873
            sw.WriteEndW(nodeName);
6874
        }
6875

6876

6877
        [XmlElement(Order = 0)]
6878
        public CT_RPrOriginal rPr
6879
        {
6880
            get
6881
            {
6882
                return this.rPrField;
6883
            }
6884
            set
6885
            {
6886
                this.rPrField = value;
6887
            }
6888
        }
6889
    }
6890

6891

6892
    [Serializable]
6893

6894
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
6895
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
6896
    public class CT_RPrOriginal
6897
    {
6898

6899
        public CT_RPrOriginal()
6900
        {
6901
        }
6902

6903
        List<CT_SignedTwipsMeasure> spacingField;
6904
        public List<CT_SignedTwipsMeasure> spacing
6905
        {
6906
            get { return this.spacingField; }
6907
            set { this.spacingField = value; }
6908
        }
6909

6910
        List<CT_VerticalAlignRun> vertAlignField;
6911
        public List<CT_VerticalAlignRun> vertAlign
6912
        {
6913
            get { return this.vertAlignField; }
6914
            set { this.vertAlignField = value; }
6915
        }
6916

6917
        List<CT_TextScale> wField;
6918
        public List<CT_TextScale> w
6919
        {
6920
            get { return this.wField; }
6921
            set { this.wField = value; }
6922
        }
6923

6924
        List<CT_OnOff> noProofField;
6925
        public List<CT_OnOff> noProof
6926
        {
6927
            get { return this.noProofField; }
6928
            set { this.noProofField = value; }
6929
        }
6930

6931
        List<CT_OnOff> snapToGridField;
6932
        public List<CT_OnOff> snapToGrid
6933
        {
6934
            get { return this.snapToGridField; }
6935
            set { this.snapToGridField = value; }
6936
        }
6937

6938
        List<CT_Language> langField;
6939
        public List<CT_Language> lang
6940
        {
6941
            get { return this.langField; }
6942
            set { this.langField = value; }
6943
        }
6944

6945
        List<CT_HpsMeasure> kernField;
6946
        public List<CT_HpsMeasure> kern
6947
        {
6948
            get { return this.kernField; }
6949
            set { this.kernField = value; }
6950
        }
6951

6952
        List<CT_OnOff> outlineField;
6953
        public List<CT_OnOff> outline
6954
        {
6955
            get { return this.outlineField; }
6956
            set { this.outlineField = value; }
6957
        }
6958

6959
        List<CT_SignedHpsMeasure> positionField;
6960
        public List<CT_SignedHpsMeasure> position
6961
        {
6962
            get { return this.positionField; }
6963
            set { this.positionField = value; }
6964
        }
6965

6966
        List<CT_Fonts> rFontsField;
6967
        public List<CT_Fonts> rFonts
6968
        {
6969
            get { return this.rFontsField; }
6970
            set { this.rFontsField = value; }
6971
        }
6972

6973
        List<CT_String> rStyleField;
6974
        public List<CT_String> rStyle
6975
        {
6976
            get { return this.rStyleField; }
6977
            set { this.rStyleField = value; }
6978
        }
6979

6980
        List<CT_OnOff> rtlField;
6981
        public List<CT_OnOff> rtl
6982
        {
6983
            get { return this.rtlField; }
6984
            set { this.rtlField = value; }
6985
        }
6986

6987
        List<CT_OnOff> shadowField;
6988
        public List<CT_OnOff> shadow
6989
        {
6990
            get { return this.shadowField; }
6991
            set { this.shadowField = value; }
6992
        }
6993

6994
        List<CT_OnOff> strikeField;
6995
        public List<CT_OnOff> strike
6996
        {
6997
            get { return this.strikeField; }
6998
            set { this.strikeField = value; }
6999
        }
7000

7001
        List<CT_Shd> shdField;
7002
        public List<CT_Shd> shd
7003
        {
7004
            get { return this.shdField; }
7005
            set { this.shdField = value; }
7006
        }
7007

7008
        List<CT_HpsMeasure> szField;
7009
        public List<CT_HpsMeasure> sz
7010
        {
7011
            get { return this.szField; }
7012
            set { this.szField = value; }
7013
        }
7014

7015
        List<CT_HpsMeasure> szCsField;
7016
        public List<CT_HpsMeasure> szCs
7017
        {
7018
            get { return this.szCsField; }
7019
            set { this.szCsField = value; }
7020
        }
7021

7022
        List<CT_OnOff> smallCapsField;
7023
        public List<CT_OnOff> smallCaps
7024
        {
7025
            get { return this.smallCapsField; }
7026
            set { this.smallCapsField = value; }
7027
        }
7028

7029
        List<CT_Underline> uField;
7030
        public List<CT_Underline> u
7031
        {
7032
            get { return this.uField; }
7033
            set { this.uField = value; }
7034
        }
7035

7036
        List<CT_OnOff> vanishField;
7037
        public List<CT_OnOff> vanish
7038
        {
7039
            get { return this.vanishField; }
7040
            set { this.vanishField = value; }
7041
        }
7042

7043
        List<CT_OnOff> oMathField;
7044
        public List<CT_OnOff> oMath
7045
        {
7046
            get { return this.oMathField; }
7047
            set { this.oMathField = value; }
7048
        }
7049

7050
        List<CT_OnOff> webHiddenField;
7051
        public List<CT_OnOff> webHidden
7052
        {
7053
            get { return this.webHiddenField; }
7054
            set { this.webHiddenField = value; }
7055
        }
7056

7057
        List<CT_OnOff> specVanishField;
7058
        public List<CT_OnOff> specVanish
7059
        {
7060
            get { return this.specVanishField; }
7061
            set { this.specVanishField = value; }
7062
        }
7063

7064
        List<CT_OnOff> bField;
7065
        public List<CT_OnOff> b
7066
        {
7067
            get { return this.bField; }
7068
            set { this.bField = value; }
7069
        }
7070

7071
        List<CT_OnOff> bCsField;
7072
        public List<CT_OnOff> bCs
7073
        {
7074
            get { return this.bCsField; }
7075
            set { this.bCsField = value; }
7076
        }
7077

7078
        List<CT_Border> bdrField;
7079
        public List<CT_Border> bdr
7080
        {
7081
            get { return this.bdrField; }
7082
            set { this.bdrField = value; }
7083
        }
7084

7085
        List<CT_OnOff> capsField;
7086
        public List<CT_OnOff> caps
7087
        {
7088
            get { return this.capsField; }
7089
            set { this.capsField = value; }
7090
        }
7091

7092
        List<CT_Color> colorField;
7093
        public List<CT_Color> color
7094
        {
7095
            get { return this.colorField; }
7096
            set { this.colorField = value; }
7097
        }
7098

7099
        List<CT_OnOff> csField;
7100
        public List<CT_OnOff> cs
7101
        {
7102
            get { return this.csField; }
7103
            set { this.csField = value; }
7104
        }
7105

7106
        List<CT_OnOff> dstrikeField;
7107
        public List<CT_OnOff> dstrike
7108
        {
7109
            get { return this.dstrikeField; }
7110
            set { this.dstrikeField = value; }
7111
        }
7112

7113
        List<CT_EastAsianLayout> eastAsianLayoutField;
7114
        public List<CT_EastAsianLayout> eastAsianLayout
7115
        {
7116
            get { return this.eastAsianLayoutField; }
7117
            set { this.eastAsianLayoutField = value; }
7118
        }
7119

7120
        List<CT_TextEffect> effectField;
7121
        public List<CT_TextEffect> effect
7122
        {
7123
            get { return this.effectField; }
7124
            set { this.effectField = value; }
7125
        }
7126

7127
        List<CT_Em> emField;
7128
        public List<CT_Em> em
7129
        {
7130
            get { return this.emField; }
7131
            set { this.emField = value; }
7132
        }
7133

7134
        List<CT_OnOff> embossField;
7135
        public List<CT_OnOff> emboss
7136
        {
7137
            get { return this.embossField; }
7138
            set { this.embossField = value; }
7139
        }
7140

7141
        List<CT_FitText> fitTextField;
7142
        public List<CT_FitText> fitText
7143
        {
7144
            get { return this.fitTextField; }
7145
            set { this.fitTextField = value; }
7146
        }
7147

7148
        List<CT_Highlight> highlightField;
7149
        public List<CT_Highlight> highlight
7150
        {
7151
            get { return this.highlightField; }
7152
            set { this.highlightField = value; }
7153
        }
7154

7155
        List<CT_OnOff> iField;
7156
        public List<CT_OnOff> i
7157
        {
7158
            get { return this.iField; }
7159
            set { this.iField = value; }
7160
        }
7161

7162
        List<CT_OnOff> iCsField;
7163
        public List<CT_OnOff> iCs
7164
        {
7165
            get { return this.iCsField; }
7166
            set { this.iCsField = value; }
7167
        }
7168

7169
        List<CT_OnOff> imprintField;
7170
        public List<CT_OnOff> imprint
7171
        {
7172
            get { return this.imprintField; }
7173
            set { this.imprintField = value; }
7174
        }
7175

7176

7177
        public static CT_RPrOriginal Parse(XmlNode node, XmlNamespaceManager namespaceManager)
7178
        {
7179
            if (node == null)
7180
                return null;
7181
            CT_RPrOriginal ctObj = new CT_RPrOriginal();
7182
            ctObj.spacing = new List<CT_SignedTwipsMeasure>();
7183
            ctObj.vertAlign = new List<CT_VerticalAlignRun>();
7184
            ctObj.w = new List<CT_TextScale>();
7185
            ctObj.noProof = new List<CT_OnOff>();
7186
            ctObj.snapToGrid = new List<CT_OnOff>();
7187
            ctObj.lang = new List<CT_Language>();
7188
            ctObj.kern = new List<CT_HpsMeasure>();
7189
            ctObj.outline = new List<CT_OnOff>();
7190
            ctObj.position = new List<CT_SignedHpsMeasure>();
7191
            ctObj.rFonts = new List<CT_Fonts>();
7192
            ctObj.rStyle = new List<CT_String>();
7193
            ctObj.rtl = new List<CT_OnOff>();
7194
            ctObj.shadow = new List<CT_OnOff>();
7195
            ctObj.strike = new List<CT_OnOff>();
7196
            ctObj.shd = new List<CT_Shd>();
7197
            ctObj.sz = new List<CT_HpsMeasure>();
7198
            ctObj.szCs = new List<CT_HpsMeasure>();
7199
            ctObj.smallCaps = new List<CT_OnOff>();
7200
            ctObj.u = new List<CT_Underline>();
7201
            ctObj.vanish = new List<CT_OnOff>();
7202
            ctObj.oMath = new List<CT_OnOff>();
7203
            ctObj.webHidden = new List<CT_OnOff>();
7204
            ctObj.specVanish = new List<CT_OnOff>();
7205
            ctObj.b = new List<CT_OnOff>();
7206
            ctObj.bCs = new List<CT_OnOff>();
7207
            ctObj.bdr = new List<CT_Border>();
7208
            ctObj.caps = new List<CT_OnOff>();
7209
            ctObj.color = new List<CT_Color>();
7210
            ctObj.cs = new List<CT_OnOff>();
7211
            ctObj.dstrike = new List<CT_OnOff>();
7212
            ctObj.eastAsianLayout = new List<CT_EastAsianLayout>();
7213
            ctObj.effect = new List<CT_TextEffect>();
7214
            ctObj.em = new List<CT_Em>();
7215
            ctObj.emboss = new List<CT_OnOff>();
7216
            ctObj.fitText = new List<CT_FitText>();
7217
            ctObj.highlight = new List<CT_Highlight>();
7218
            ctObj.i = new List<CT_OnOff>();
7219
            ctObj.iCs = new List<CT_OnOff>();
7220
            ctObj.imprint = new List<CT_OnOff>();
7221
            foreach (XmlNode childNode in node.ChildNodes)
7222
            {
7223
                if (childNode.LocalName == "spacing")
7224
                    ctObj.spacing.Add(CT_SignedTwipsMeasure.Parse(childNode, namespaceManager));
7225
                else if (childNode.LocalName == "vertAlign")
7226
                    ctObj.vertAlign.Add(CT_VerticalAlignRun.Parse(childNode, namespaceManager));
7227
                else if (childNode.LocalName == "w")
7228
                    ctObj.w.Add(CT_TextScale.Parse(childNode, namespaceManager));
7229
                else if (childNode.LocalName == "noProof")
7230
                    ctObj.noProof.Add(CT_OnOff.Parse(childNode, namespaceManager));
7231
                else if (childNode.LocalName == "snapToGrid")
7232
                    ctObj.snapToGrid.Add(CT_OnOff.Parse(childNode, namespaceManager));
7233
                else if (childNode.LocalName == "lang")
7234
                    ctObj.lang.Add(CT_Language.Parse(childNode, namespaceManager));
7235
                else if (childNode.LocalName == "kern")
7236
                    ctObj.kern.Add(CT_HpsMeasure.Parse(childNode, namespaceManager));
7237
                else if (childNode.LocalName == "outline")
7238
                    ctObj.outline.Add(CT_OnOff.Parse(childNode, namespaceManager));
7239
                else if (childNode.LocalName == "position")
7240
                    ctObj.position.Add(CT_SignedHpsMeasure.Parse(childNode, namespaceManager));
7241
                else if (childNode.LocalName == "rFonts")
7242
                    ctObj.rFonts.Add(CT_Fonts.Parse(childNode, namespaceManager));
7243
                else if (childNode.LocalName == "rStyle")
7244
                    ctObj.rStyle.Add(CT_String.Parse(childNode, namespaceManager));
7245
                else if (childNode.LocalName == "rtl")
7246
                    ctObj.rtl.Add(CT_OnOff.Parse(childNode, namespaceManager));
7247
                else if (childNode.LocalName == "shadow")
7248
                    ctObj.shadow.Add(CT_OnOff.Parse(childNode, namespaceManager));
7249
                else if (childNode.LocalName == "strike")
7250
                    ctObj.strike.Add(CT_OnOff.Parse(childNode, namespaceManager));
7251
                else if (childNode.LocalName == "shd")
7252
                    ctObj.shd.Add(CT_Shd.Parse(childNode, namespaceManager));
7253
                else if (childNode.LocalName == "sz")
7254
                    ctObj.sz.Add(CT_HpsMeasure.Parse(childNode, namespaceManager));
7255
                else if (childNode.LocalName == "szCs")
7256
                    ctObj.szCs.Add(CT_HpsMeasure.Parse(childNode, namespaceManager));
7257
                else if (childNode.LocalName == "smallCaps")
7258
                    ctObj.smallCaps.Add(CT_OnOff.Parse(childNode, namespaceManager));
7259
                else if (childNode.LocalName == "u")
7260
                    ctObj.u.Add(CT_Underline.Parse(childNode, namespaceManager));
7261
                else if (childNode.LocalName == "vanish")
7262
                    ctObj.vanish.Add(CT_OnOff.Parse(childNode, namespaceManager));
7263
                else if (childNode.LocalName == "oMath")
7264
                    ctObj.oMath.Add(CT_OnOff.Parse(childNode, namespaceManager));
7265
                else if (childNode.LocalName == "webHidden")
7266
                    ctObj.webHidden.Add(CT_OnOff.Parse(childNode, namespaceManager));
7267
                else if (childNode.LocalName == "specVanish")
7268
                    ctObj.specVanish.Add(CT_OnOff.Parse(childNode, namespaceManager));
7269
                else if (childNode.LocalName == "b")
7270
                    ctObj.b.Add(CT_OnOff.Parse(childNode, namespaceManager));
7271
                else if (childNode.LocalName == "bCs")
7272
                    ctObj.bCs.Add(CT_OnOff.Parse(childNode, namespaceManager));
7273
                else if (childNode.LocalName == "bdr")
7274
                    ctObj.bdr.Add(CT_Border.Parse(childNode, namespaceManager));
7275
                else if (childNode.LocalName == "caps")
7276
                    ctObj.caps.Add(CT_OnOff.Parse(childNode, namespaceManager));
7277
                else if (childNode.LocalName == "color")
7278
                    ctObj.color.Add(CT_Color.Parse(childNode, namespaceManager));
7279
                else if (childNode.LocalName == "cs")
7280
                    ctObj.cs.Add(CT_OnOff.Parse(childNode, namespaceManager));
7281
                else if (childNode.LocalName == "dstrike")
7282
                    ctObj.dstrike.Add(CT_OnOff.Parse(childNode, namespaceManager));
7283
                else if (childNode.LocalName == "eastAsianLayout")
7284
                    ctObj.eastAsianLayout.Add(CT_EastAsianLayout.Parse(childNode, namespaceManager));
7285
                else if (childNode.LocalName == "effect")
7286
                    ctObj.effect.Add(CT_TextEffect.Parse(childNode, namespaceManager));
7287
                else if (childNode.LocalName == "em")
7288
                    ctObj.em.Add(CT_Em.Parse(childNode, namespaceManager));
7289
                else if (childNode.LocalName == "emboss")
7290
                    ctObj.emboss.Add(CT_OnOff.Parse(childNode, namespaceManager));
7291
                else if (childNode.LocalName == "fitText")
7292
                    ctObj.fitText.Add(CT_FitText.Parse(childNode, namespaceManager));
7293
                else if (childNode.LocalName == "highlight")
7294
                    ctObj.highlight.Add(CT_Highlight.Parse(childNode, namespaceManager));
7295
                else if (childNode.LocalName == "i")
7296
                    ctObj.i.Add(CT_OnOff.Parse(childNode, namespaceManager));
7297
                else if (childNode.LocalName == "iCs")
7298
                    ctObj.iCs.Add(CT_OnOff.Parse(childNode, namespaceManager));
7299
                else if (childNode.LocalName == "imprint")
7300
                    ctObj.imprint.Add(CT_OnOff.Parse(childNode, namespaceManager));
7301
            }
7302
            return ctObj;
7303
        }
7304

7305

7306

7307
        internal void Write(StreamWriter sw, string nodeName)
7308
        {
7309
            sw.Write(string.Format("<w:{0}", nodeName));
7310
            sw.Write(">");
7311
            if (this.spacing != null)
7312
            {
7313
                foreach (CT_SignedTwipsMeasure x in this.spacing)
7314
                {
7315
                    x.Write(sw, "spacing");
7316
                }
7317
            }
7318
            if (this.vertAlign != null)
7319
            {
7320
                foreach (CT_VerticalAlignRun x in this.vertAlign)
7321
                {
7322
                    x.Write(sw, "vertAlign");
7323
                }
7324
            }
7325
            if (this.w != null)
7326
            {
7327
                foreach (CT_TextScale x in this.w)
7328
                {
7329
                    x.Write(sw, "w");
7330
                }
7331
            }
7332
            if (this.noProof != null)
7333
            {
7334
                foreach (CT_OnOff x in this.noProof)
7335
                {
7336
                    x.Write(sw, "noProof");
7337
                }
7338
            }
7339
            if (this.snapToGrid != null)
7340
            {
7341
                foreach (CT_OnOff x in this.snapToGrid)
7342
                {
7343
                    x.Write(sw, "snapToGrid");
7344
                }
7345
            }
7346
            if (this.lang != null)
7347
            {
7348
                foreach (CT_Language x in this.lang)
7349
                {
7350
                    x.Write(sw, "lang");
7351
                }
7352
            }
7353
            if (this.kern != null)
7354
            {
7355
                foreach (CT_HpsMeasure x in this.kern)
7356
                {
7357
                    x.Write(sw, "kern");
7358
                }
7359
            }
7360
            if (this.outline != null)
7361
            {
7362
                foreach (CT_OnOff x in this.outline)
7363
                {
7364
                    x.Write(sw, "outline");
7365
                }
7366
            }
7367
            if (this.position != null)
7368
            {
7369
                foreach (CT_SignedHpsMeasure x in this.position)
7370
                {
7371
                    x.Write(sw, "position");
7372
                }
7373
            }
7374
            if (this.rFonts != null)
7375
            {
7376
                foreach (CT_Fonts x in this.rFonts)
7377
                {
7378
                    x.Write(sw, "rFonts");
7379
                }
7380
            }
7381
            if (this.rStyle != null)
7382
            {
7383
                foreach (CT_String x in this.rStyle)
7384
                {
7385
                    x.Write(sw, "rStyle");
7386
                }
7387
            }
7388
            if (this.rtl != null)
7389
            {
7390
                foreach (CT_OnOff x in this.rtl)
7391
                {
7392
                    x.Write(sw, "rtl");
7393
                }
7394
            }
7395
            if (this.shadow != null)
7396
            {
7397
                foreach (CT_OnOff x in this.shadow)
7398
                {
7399
                    x.Write(sw, "shadow");
7400
                }
7401
            }
7402
            if (this.strike != null)
7403
            {
7404
                foreach (CT_OnOff x in this.strike)
7405
                {
7406
                    x.Write(sw, "strike");
7407
                }
7408
            }
7409
            if (this.shd != null)
7410
            {
7411
                foreach (CT_Shd x in this.shd)
7412
                {
7413
                    x.Write(sw, "shd");
7414
                }
7415
            }
7416
            if (this.sz != null)
7417
            {
7418
                foreach (CT_HpsMeasure x in this.sz)
7419
                {
7420
                    x.Write(sw, "sz");
7421
                }
7422
            }
7423
            if (this.szCs != null)
7424
            {
7425
                foreach (CT_HpsMeasure x in this.szCs)
7426
                {
7427
                    x.Write(sw, "szCs");
7428
                }
7429
            }
7430
            if (this.smallCaps != null)
7431
            {
7432
                foreach (CT_OnOff x in this.smallCaps)
7433
                {
7434
                    x.Write(sw, "smallCaps");
7435
                }
7436
            }
7437
            if (this.u != null)
7438
            {
7439
                foreach (CT_Underline x in this.u)
7440
                {
7441
                    x.Write(sw, "u");
7442
                }
7443
            }
7444
            if (this.vanish != null)
7445
            {
7446
                foreach (CT_OnOff x in this.vanish)
7447
                {
7448
                    x.Write(sw, "vanish");
7449
                }
7450
            }
7451
            if (this.oMath != null)
7452
            {
7453
                foreach (CT_OnOff x in this.oMath)
7454
                {
7455
                    x.Write(sw, "oMath");
7456
                }
7457
            }
7458
            if (this.webHidden != null)
7459
            {
7460
                foreach (CT_OnOff x in this.webHidden)
7461
                {
7462
                    x.Write(sw, "webHidden");
7463
                }
7464
            }
7465
            if (this.specVanish != null)
7466
            {
7467
                foreach (CT_OnOff x in this.specVanish)
7468
                {
7469
                    x.Write(sw, "specVanish");
7470
                }
7471
            }
7472
            if (this.b != null)
7473
            {
7474
                foreach (CT_OnOff x in this.b)
7475
                {
7476
                    x.Write(sw, "b");
7477
                }
7478
            }
7479
            if (this.bCs != null)
7480
            {
7481
                foreach (CT_OnOff x in this.bCs)
7482
                {
7483
                    x.Write(sw, "bCs");
7484
                }
7485
            }
7486
            if (this.bdr != null)
7487
            {
7488
                foreach (CT_Border x in this.bdr)
7489
                {
7490
                    x.Write(sw, "bdr");
7491
                }
7492
            }
7493
            if (this.caps != null)
7494
            {
7495
                foreach (CT_OnOff x in this.caps)
7496
                {
7497
                    x.Write(sw, "caps");
7498
                }
7499
            }
7500
            if (this.color != null)
7501
            {
7502
                foreach (CT_Color x in this.color)
7503
                {
7504
                    x.Write(sw, "color");
7505
                }
7506
            }
7507
            if (this.cs != null)
7508
            {
7509
                foreach (CT_OnOff x in this.cs)
7510
                {
7511
                    x.Write(sw, "cs");
7512
                }
7513
            }
7514
            if (this.dstrike != null)
7515
            {
7516
                foreach (CT_OnOff x in this.dstrike)
7517
                {
7518
                    x.Write(sw, "dstrike");
7519
                }
7520
            }
7521
            if (this.eastAsianLayout != null)
7522
            {
7523
                foreach (CT_EastAsianLayout x in this.eastAsianLayout)
7524
                {
7525
                    x.Write(sw, "eastAsianLayout");
7526
                }
7527
            }
7528
            if (this.effect != null)
7529
            {
7530
                foreach (CT_TextEffect x in this.effect)
7531
                {
7532
                    x.Write(sw, "effect");
7533
                }
7534
            }
7535
            if (this.em != null)
7536
            {
7537
                foreach (CT_Em x in this.em)
7538
                {
7539
                    x.Write(sw, "em");
7540
                }
7541
            }
7542
            if (this.emboss != null)
7543
            {
7544
                foreach (CT_OnOff x in this.emboss)
7545
                {
7546
                    x.Write(sw, "emboss");
7547
                }
7548
            }
7549
            if (this.fitText != null)
7550
            {
7551
                foreach (CT_FitText x in this.fitText)
7552
                {
7553
                    x.Write(sw, "fitText");
7554
                }
7555
            }
7556
            if (this.highlight != null)
7557
            {
7558
                foreach (CT_Highlight x in this.highlight)
7559
                {
7560
                    x.Write(sw, "highlight");
7561
                }
7562
            }
7563
            if (this.i != null)
7564
            {
7565
                foreach (CT_OnOff x in this.i)
7566
                {
7567
                    x.Write(sw, "i");
7568
                }
7569
            }
7570
            if (this.iCs != null)
7571
            {
7572
                foreach (CT_OnOff x in this.iCs)
7573
                {
7574
                    x.Write(sw, "iCs");
7575
                }
7576
            }
7577
            if (this.imprint != null)
7578
            {
7579
                foreach (CT_OnOff x in this.imprint)
7580
                {
7581
                    x.Write(sw, "imprint");
7582
                }
7583
            }
7584
            sw.WriteEndW(nodeName);
7585
        }
7586

7587
    }
7588

7589
    
7590

7591

7592
    [Serializable]
7593

7594
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
7595
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
7596
    public class CT_Br
7597
    {
7598

7599
        private ST_BrType typeField;
7600

7601
        private bool typeFieldSpecified;
7602

7603
        private ST_BrClear clearField;
7604

7605
        private bool clearFieldSpecified;
7606
        public static CT_Br Parse(XmlNode node, XmlNamespaceManager namespaceManager)
7607
        {
7608
            if (node == null)
7609
                return null;
7610
            CT_Br ctObj = new CT_Br();
7611
            if (node.Attributes["w:type"] != null)
7612
                ctObj.type = (ST_BrType)Enum.Parse(typeof(ST_BrType), node.Attributes["w:type"].Value);
7613
            else
7614
                ctObj.type = ST_BrType.textWrapping; // Default value as http://officeopenxml.com/WPtextSpecialContent-break.php
7615

7616
            if (node.Attributes["w:clear"] != null)
7617
                ctObj.clear = (ST_BrClear)Enum.Parse(typeof(ST_BrClear), node.Attributes["w:clear"].Value);
7618
            else
7619
            {
7620
                if (ctObj.type == ST_BrType.textWrapping)
7621
                    ctObj.clear = ST_BrClear.none;
7622
            }
7623
            return ctObj;
7624
        }
7625

7626

7627

7628
        internal void Write(StreamWriter sw, string nodeName)
7629
        {
7630
            sw.Write(string.Format("<w:{0}", nodeName));
7631
            XmlHelper.WriteAttribute(sw, "w:type", this.type.ToString());
7632
            if(this.clear!= ST_BrClear.none)
7633
                XmlHelper.WriteAttribute(sw, "w:clear", this.clear.ToString());
7634
            sw.Write(">");
7635
            sw.WriteEndW(nodeName);
7636
        }
7637

7638
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
7639
        public ST_BrType type
7640
        {
7641
            get
7642
            {
7643
                return this.typeField;
7644
            }
7645
            set
7646
            {
7647
                this.typeField = value;
7648
                this.typeFieldSpecified = true;
7649
            }
7650
        }
7651

7652
        [XmlIgnore]
7653
        public bool typeSpecified
7654
        {
7655
            get
7656
            {
7657
                return this.typeFieldSpecified;
7658
            }
7659
            set
7660
            {
7661
                this.typeFieldSpecified = value;
7662
            }
7663
        }
7664

7665
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
7666
        public ST_BrClear clear
7667
        {
7668
            get
7669
            {
7670
                return this.clearField;
7671
            }
7672
            set
7673
            {
7674
                this.clearField = value;
7675
                this.clearFieldSpecified = true;
7676
            }
7677
        }
7678

7679
        [XmlIgnore]
7680
        public bool clearSpecified
7681
        {
7682
            get
7683
            {
7684
                return this.clearFieldSpecified;
7685
            }
7686
            set
7687
            {
7688
                this.clearFieldSpecified = value;
7689
            }
7690
        }
7691
    }
7692

7693

7694
    [Serializable]
7695
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
7696
    public enum ST_BrType
7697
    {
7698

7699
    
7700
        page,
7701

7702
    
7703
        column,
7704

7705
    
7706
        textWrapping,
7707
    }
7708

7709

7710
    [Serializable]
7711
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
7712
    public enum ST_BrClear
7713
    {
7714

7715
    
7716
        none,
7717

7718
    
7719
        left,
7720

7721
    
7722
        right,
7723

7724
    
7725
        all,
7726
    }
7727

7728

7729
    [Serializable]
7730

7731
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
7732
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
7733
    public class CT_TblStylePr
7734
    {
7735

7736
        private CT_PPr pPrField;
7737

7738
        private CT_RPr rPrField;
7739

7740
        private CT_TblPrBase tblPrField;
7741

7742
        private CT_TrPr trPrField;
7743

7744
        private CT_TcPr tcPrField;
7745

7746
        private ST_TblStyleOverrideType typeField;
7747
        public static CT_TblStylePr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
7748
        {
7749
            if (node == null)
7750
                return null;
7751
            CT_TblStylePr ctObj = new CT_TblStylePr();
7752
            if (node.Attributes["w:type"] != null)
7753
                ctObj.type = (ST_TblStyleOverrideType)Enum.Parse(typeof(ST_TblStyleOverrideType), node.Attributes["w:type"].Value);
7754
            foreach (XmlNode childNode in node.ChildNodes)
7755
            {
7756
                if (childNode.LocalName == "pPr")
7757
                    ctObj.pPr = CT_PPr.Parse(childNode, namespaceManager);
7758
                else if (childNode.LocalName == "rPr")
7759
                    ctObj.rPr = CT_RPr.Parse(childNode, namespaceManager);
7760
                else if (childNode.LocalName == "tblPr")
7761
                    ctObj.tblPr = CT_TblPrBase.Parse(childNode, namespaceManager);
7762
                else if (childNode.LocalName == "trPr")
7763
                    ctObj.trPr = CT_TrPr.Parse(childNode, namespaceManager);
7764
                else if (childNode.LocalName == "tcPr")
7765
                    ctObj.tcPr = CT_TcPr.Parse(childNode, namespaceManager);
7766
            }
7767
            return ctObj;
7768
        }
7769

7770

7771

7772
        internal void Write(StreamWriter sw, string nodeName)
7773
        {
7774
            sw.Write(string.Format("<w:{0}", nodeName));
7775
            XmlHelper.WriteAttribute(sw, "w:type", this.type.ToString());
7776
            sw.Write(">");
7777
            if (this.pPr != null)
7778
                this.pPr.Write(sw, "pPr");
7779
            if (this.rPr != null)
7780
                this.rPr.Write(sw, "rPr");
7781
            if (this.tblPr != null)
7782
                this.tblPr.Write(sw, "tblPr");
7783
            if (this.trPr != null)
7784
                this.trPr.Write(sw, "trPr");
7785
            if (this.tcPr != null)
7786
                this.tcPr.Write(sw, "tcPr");
7787
            sw.WriteEndW(nodeName);
7788
        }
7789

7790
        public CT_TblStylePr()
7791
        {
7792
            //this.tcPrField = new CT_TcPr();
7793
            //this.trPrField = new CT_TrPr();
7794
            //this.tblPrField = new CT_TblPrBase();
7795
            //this.rPrField = new CT_RPr();
7796
            //this.pPrField = new CT_PPr();
7797
        }
7798

7799
        [XmlElement(Order = 0)]
7800
        public CT_PPr pPr
7801
        {
7802
            get
7803
            {
7804
                return this.pPrField;
7805
            }
7806
            set
7807
            {
7808
                this.pPrField = value;
7809
            }
7810
        }
7811

7812
        [XmlElement(Order = 1)]
7813
        public CT_RPr rPr
7814
        {
7815
            get
7816
            {
7817
                return this.rPrField;
7818
            }
7819
            set
7820
            {
7821
                this.rPrField = value;
7822
            }
7823
        }
7824

7825
        [XmlElement(Order = 2)]
7826
        public CT_TblPrBase tblPr
7827
        {
7828
            get
7829
            {
7830
                return this.tblPrField;
7831
            }
7832
            set
7833
            {
7834
                this.tblPrField = value;
7835
            }
7836
        }
7837

7838
        [XmlElement(Order = 3)]
7839
        public CT_TrPr trPr
7840
        {
7841
            get
7842
            {
7843
                return this.trPrField;
7844
            }
7845
            set
7846
            {
7847
                this.trPrField = value;
7848
            }
7849
        }
7850

7851
        [XmlElement(Order = 4)]
7852
        public CT_TcPr tcPr
7853
        {
7854
            get
7855
            {
7856
                return this.tcPrField;
7857
            }
7858
            set
7859
            {
7860
                this.tcPrField = value;
7861
            }
7862
        }
7863

7864
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
7865
        public ST_TblStyleOverrideType type
7866
        {
7867
            get
7868
            {
7869
                return this.typeField;
7870
            }
7871
            set
7872
            {
7873
                this.typeField = value;
7874
            }
7875
        }
7876
    }
7877

7878

7879
    [Serializable]
7880
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
7881
    public enum ST_TblStyleOverrideType
7882
    {
7883

7884
    
7885
        wholeTable,
7886

7887
    
7888
        firstRow,
7889

7890
    
7891
        lastRow,
7892

7893
    
7894
        firstCol,
7895

7896
    
7897
        lastCol,
7898

7899
    
7900
        band1Vert,
7901

7902
    
7903
        band2Vert,
7904

7905
    
7906
        band1Horz,
7907

7908
    
7909
        band2Horz,
7910

7911
    
7912
        neCell,
7913

7914
    
7915
        nwCell,
7916

7917
    
7918
        seCell,
7919

7920
    
7921
        swCell,
7922
    }
7923
}
7924