npoi

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

10

11
namespace NPOI.OpenXmlFormats.Wordprocessing
12
{
13

14
    [Serializable]
15

16
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
17
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
18
    public class CT_SdtContentCell
19
    {
20
        public override string ToString()
21
        {
22
            string text = string.Empty;
23
            using (MemoryStream ms = new MemoryStream())
24
            {
25
                using (StreamWriter sw = new StreamWriter(ms))
26
                {
27
                    this.Write(sw, "sdtContent");
28
                    sw.Flush();
29
                    ms.Position = 0;
30
                    using (StreamReader sr = new StreamReader(ms))
31
                    {
32
                        text = sr.ReadToEnd();
33
                    }
34
                }
35
            }
36
            return text;
37
        }
38
        private ArrayList itemsField;
39

40
        private List<ItemsChoiceType23> itemsElementNameField;
41

42
        public CT_SdtContentCell()
43
        {
44
            this.itemsElementNameField = new List<ItemsChoiceType23>();
45
            this.itemsField = new ArrayList();
46
        }
47
        public static CT_SdtContentCell Parse(XmlNode node, XmlNamespaceManager namespaceManager)
48
        {
49
            if (node == null)
50
                return null;
51
            CT_SdtContentCell ctObj = new CT_SdtContentCell();
52
            foreach (XmlNode childNode in node.ChildNodes)
53
            {
54
                if (childNode.LocalName == "permStart")
55
                {
56
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
57
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.permStart);
58
                }
59
                else if (childNode.LocalName == "sdt")
60
                {
61
                    ctObj.Items.Add(CT_SdtCell.Parse(childNode, namespaceManager));
62
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.sdt);
63
                }
64
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
65
                {
66
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
67
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXmlMoveToRangeEnd);
68
                }
69
                else if (childNode.LocalName == "proofErr")
70
                {
71
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
72
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.proofErr);
73
                }
74
                else if (childNode.LocalName == "customXmlDelRangeEnd")
75
                {
76
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
77
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXmlDelRangeEnd);
78
                }
79
                else if (childNode.LocalName == "moveFromRangeEnd")
80
                {
81
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
82
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.moveFromRangeEnd);
83
                }
84
                else if (childNode.LocalName == "moveFromRangeStart")
85
                {
86
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
87
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.moveFromRangeStart);
88
                }
89
                else if (childNode.LocalName == "moveTo")
90
                {
91
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
92
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.moveTo);
93
                }
94
                else if (childNode.LocalName == "moveToRangeEnd")
95
                {
96
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
97
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.moveToRangeEnd);
98
                }
99
                else if (childNode.LocalName == "moveToRangeStart")
100
                {
101
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
102
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.moveToRangeStart);
103
                }
104
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
105
                {
106
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
107
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXmlMoveToRangeStart);
108
                }
109
                else if (childNode.LocalName == "tc")
110
                {
111
                    ctObj.Items.Add(CT_Tc.Parse(childNode, namespaceManager, ctObj));
112
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.tc);
113
                }
114
                else if (childNode.LocalName == "del")
115
                {
116
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
117
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.del);
118
                }
119
                else if (childNode.LocalName == "permEnd")
120
                {
121
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
122
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.permEnd);
123
                }
124
                else if (childNode.LocalName == "commentRangeStart")
125
                {
126
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
127
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.commentRangeStart);
128
                }
129
                else if (childNode.LocalName == "moveFrom")
130
                {
131
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
132
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.moveFrom);
133
                }
134
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
135
                {
136
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
137
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXmlMoveFromRangeStart);
138
                }
139
                else if (childNode.LocalName == "customXml")
140
                {
141
                    ctObj.Items.Add(CT_CustomXmlCell.Parse(childNode, namespaceManager));
142
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXml);
143
                }
144
                else if (childNode.LocalName == "oMath")
145
                {
146
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
147
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.oMath);
148
                }
149
                else if (childNode.LocalName == "customXmlDelRangeStart")
150
                {
151
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
152
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXmlDelRangeStart);
153
                }
154
                else if (childNode.LocalName == "customXmlInsRangeEnd")
155
                {
156
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
157
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXmlInsRangeEnd);
158
                }
159
                else if (childNode.LocalName == "ins")
160
                {
161
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
162
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.ins);
163
                }
164
                else if (childNode.LocalName == "customXmlInsRangeStart")
165
                {
166
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
167
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXmlInsRangeStart);
168
                }
169
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
170
                {
171
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
172
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.customXmlMoveFromRangeEnd);
173
                }
174
                else if (childNode.LocalName == "oMathPara")
175
                {
176
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
177
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.oMathPara);
178
                }
179
                else if (childNode.LocalName == "bookmarkEnd")
180
                {
181
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
182
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.bookmarkEnd);
183
                }
184
                else if (childNode.LocalName == "bookmarkStart")
185
                {
186
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
187
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.bookmarkStart);
188
                }
189
                else if (childNode.LocalName == "commentRangeEnd")
190
                {
191
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
192
                    ctObj.ItemsElementName.Add(ItemsChoiceType23.commentRangeEnd);
193
                }
194
            }
195
            return ctObj;
196
        }
197

198
        internal void Write(StreamWriter sw, string nodeName)
199
        {
200
            sw.Write(string.Format("<w:{0}", nodeName));
201
            sw.Write(">");
202
            foreach (object o in this.Items)
203
            {
204
                if (o is CT_PermStart)
205
                    ((CT_PermStart)o).Write(sw, "permStart");
206
                else if (o is CT_SdtCell)
207
                    ((CT_SdtCell)o).Write(sw, "sdt");
208
                else if (o is CT_Markup)
209
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
210
                else if (o is CT_ProofErr)
211
                    ((CT_ProofErr)o).Write(sw, "proofErr");
212
                else if (o is CT_Markup)
213
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
214
                else if (o is CT_MarkupRange)
215
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
216
                else if (o is CT_MoveBookmark)
217
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
218
                else if (o is CT_RunTrackChange)
219
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
220
                else if (o is CT_MarkupRange)
221
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
222
                else if (o is CT_MoveBookmark)
223
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
224
                else if (o is CT_TrackChange)
225
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
226
                else if (o is CT_Tc)
227
                    ((CT_Tc)o).Write(sw, "tc");
228
                else if (o is CT_RunTrackChange)
229
                    ((CT_RunTrackChange)o).Write(sw, "del");
230
                else if (o is CT_Perm)
231
                    ((CT_Perm)o).Write(sw, "permEnd");
232
                else if (o is CT_MarkupRange)
233
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
234
                else if (o is CT_RunTrackChange)
235
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
236
                else if (o is CT_TrackChange)
237
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
238
                else if (o is CT_CustomXmlCell)
239
                    ((CT_CustomXmlCell)o).Write(sw, "customXml");
240
                else if (o is CT_OMath)
241
                    ((CT_OMath)o).Write(sw, "oMath");
242
                else if (o is CT_TrackChange)
243
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
244
                else if (o is CT_Markup)
245
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
246
                else if (o is CT_RunTrackChange)
247
                    ((CT_RunTrackChange)o).Write(sw, "ins");
248
                else if (o is CT_TrackChange)
249
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
250
                else if (o is CT_Markup)
251
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
252
                else if (o is CT_OMathPara)
253
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
254
                else if (o is CT_MarkupRange)
255
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
256
                else if (o is CT_Bookmark)
257
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
258
                else if (o is CT_MarkupRange)
259
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
260
            }
261
            sw.WriteEndW(nodeName);
262
        }
263

264
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
265
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
266
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 0)]
267
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 0)]
268
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 0)]
269
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 0)]
270
        [XmlElement("customXml", typeof(CT_CustomXmlCell), Order = 0)]
271
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 0)]
272
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 0)]
273
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 0)]
274
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 0)]
275
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 0)]
276
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 0)]
277
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 0)]
278
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 0)]
279
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 0)]
280
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 0)]
281
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 0)]
282
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 0)]
283
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 0)]
284
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 0)]
285
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 0)]
286
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 0)]
287
        [XmlElement("permEnd", typeof(CT_Perm), Order = 0)]
288
        [XmlElement("permStart", typeof(CT_PermStart), Order = 0)]
289
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 0)]
290
        [XmlElement("sdt", typeof(CT_SdtCell), Order = 0)]
291
        [XmlElement("tc", typeof(CT_Tc), Order = 0)]
292
        [XmlChoiceIdentifier("ItemsElementName")]
293
        public ArrayList Items
294
        {
295
            get
296
            {
297
                return this.itemsField;
298
            }
299
            set
300
            {
301
                this.itemsField = value;
302
            }
303
        }
304

305
        [XmlElement("ItemsElementName", Order = 1)]
306
        [XmlIgnore]
307
        public List<ItemsChoiceType23> ItemsElementName
308
        {
309
            get
310
            {
311
                return this.itemsElementNameField;
312
            }
313
            set
314
            {
315
                this.itemsElementNameField = value;
316
            }
317
        }
318
    }
319

320
    [Serializable]
321
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
322
    public enum ItemsChoiceType23
323
    {
324

325
    
326
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
327
        oMath,
328

329
    
330
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
331
        oMathPara,
332

333
    
334
        bookmarkEnd,
335

336
    
337
        bookmarkStart,
338

339
    
340
        commentRangeEnd,
341

342
    
343
        commentRangeStart,
344

345
    
346
        customXml,
347

348
    
349
        customXmlDelRangeEnd,
350

351
    
352
        customXmlDelRangeStart,
353

354
    
355
        customXmlInsRangeEnd,
356

357
    
358
        customXmlInsRangeStart,
359

360
    
361
        customXmlMoveFromRangeEnd,
362

363
    
364
        customXmlMoveFromRangeStart,
365

366
    
367
        customXmlMoveToRangeEnd,
368

369
    
370
        customXmlMoveToRangeStart,
371

372
    
373
        del,
374

375
    
376
        ins,
377

378
    
379
        moveFrom,
380

381
    
382
        moveFromRangeEnd,
383

384
    
385
        moveFromRangeStart,
386

387
    
388
        moveTo,
389

390
    
391
        moveToRangeEnd,
392

393
    
394
        moveToRangeStart,
395

396
    
397
        permEnd,
398

399
    
400
        permStart,
401

402
    
403
        proofErr,
404

405
    
406
        sdt,
407

408
    
409
        tc,
410
    }
411

412

413
    [Serializable]
414

415
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
416
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
417
    public class CT_SdtBlock
418
    {
419

420
        private CT_SdtPr sdtPrField;
421

422
        private List<CT_RPr> sdtEndPrField;
423
        private CT_SdtContentBlock sdtContentField;
424

425
        public CT_SdtBlock()
426
        {
427
            //this.sdtContentField = new CT_SdtContentBlock();
428
            //this.sdtEndPrField = new List<CT_RPr>();
429
            //this.sdtPrField = new CT_SdtPr();
430
        }
431
        public static CT_SdtBlock Parse(XmlNode node, XmlNamespaceManager namespaceManager)
432
        {
433
            if (node == null)
434
                return null;
435
            CT_SdtBlock ctObj = new CT_SdtBlock();
436
            ctObj.sdtEndPr = new List<CT_RPr>();
437
            foreach (XmlNode childNode in node.ChildNodes)
438
            {
439
                if (childNode.LocalName == "sdtPr")
440
                    ctObj.sdtPr = CT_SdtPr.Parse(childNode, namespaceManager);
441
                else if (childNode.LocalName == "sdtContent")
442
                    ctObj.sdtContent = CT_SdtContentBlock.Parse(childNode, namespaceManager);
443
                else if (childNode.LocalName == "sdtEndPr")
444
                    ctObj.sdtEndPr.Add(CT_RPr.Parse(childNode, namespaceManager));
445
            }
446
            return ctObj;
447
        }
448

449

450

451
        internal void Write(StreamWriter sw, string nodeName)
452
        {
453
            sw.Write(string.Format("<w:{0}", nodeName));
454
            sw.Write(">");
455
            if (this.sdtPr != null)
456
                this.sdtPr.Write(sw, "sdtPr");
457
            if (this.sdtEndPr != null)
458
            {
459
                foreach (CT_RPr x in this.sdtEndPr)
460
                {
461
                    x.Write(sw, "sdtEndPr");
462
                }
463
            }
464
            if (this.sdtContent != null)
465
                this.sdtContent.Write(sw, "sdtContent");
466
            sw.WriteEndW(nodeName);
467
        }
468

469
        [XmlElement(Order = 0)]
470
        public CT_SdtPr sdtPr
471
        {
472
            get
473
            {
474
                return this.sdtPrField;
475
            }
476
            set
477
            {
478
                this.sdtPrField = value;
479
            }
480
        }
481

482
        [XmlArray(Order = 1)]
483
        [XmlArrayItem("rPr", IsNullable = false)]
484
        public List<CT_RPr> sdtEndPr
485
        {
486
            get
487
            {
488
                return this.sdtEndPrField;
489
            }
490
            set
491
            {
492
                this.sdtEndPrField = value;
493
            }
494
        }
495

496
        [XmlElement(Order = 2)]
497
        public CT_SdtContentBlock sdtContent
498
        {
499
            get
500
            {
501
                return this.sdtContentField;
502
            }
503
            set
504
            {
505
                this.sdtContentField = value;
506
            }
507
        }
508

509
        public CT_SdtPr AddNewSdtPr()
510
        {
511
            if (this.sdtPrField == null)
512
                this.sdtPrField = new CT_SdtPr();
513
            return this.sdtPrField;
514
        }
515

516
        public CT_SdtEndPr AddNewSdtEndPr()
517
        {
518
            CT_SdtEndPr endPr = new CT_SdtEndPr();
519
            this.sdtEndPrField = endPr.Items;
520
            return endPr;
521
        }
522

523
        public CT_SdtContentBlock AddNewSdtContent()
524
        {
525
            if (this.sdtContentField == null)
526
                this.sdtContentField = new CT_SdtContentBlock();
527
            return this.sdtContentField;
528
        }
529
    }
530

531

532
    [Serializable]
533

534
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
535
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
536
    public class CT_SdtRun
537
    {
538

539
        private CT_SdtPr sdtPrField;
540

541
        private List<CT_RPr> sdtEndPrField;
542

543
        private CT_SdtContentRun sdtContentField;
544

545
        public CT_SdtRun()
546
        {
547
            //this.sdtContentField = new CT_SdtContentRun();
548
            //this.sdtEndPrField = new List<CT_RPr>();
549
            //this.sdtPrField = new CT_SdtPr();
550
        }
551
        public static CT_SdtRun Parse(XmlNode node, XmlNamespaceManager namespaceManager)
552
        {
553
            if (node == null)
554
                return null;
555
            CT_SdtRun ctObj = new CT_SdtRun();
556
            ctObj.sdtEndPr = new List<CT_RPr>();
557
            foreach (XmlNode childNode in node.ChildNodes)
558
            {
559
                if (childNode.LocalName == "sdtPr")
560
                    ctObj.sdtPr = CT_SdtPr.Parse(childNode, namespaceManager);
561
                else if (childNode.LocalName == "sdtContent")
562
                    ctObj.sdtContent = CT_SdtContentRun.Parse(childNode, namespaceManager);
563
                else if (childNode.LocalName == "sdtEndPr")
564
                    ctObj.sdtEndPr.Add(CT_RPr.Parse(childNode, namespaceManager));
565
            }
566
            return ctObj;
567
        }
568

569

570

571
        internal void Write(StreamWriter sw, string nodeName)
572
        {
573
            sw.Write(string.Format("<w:{0}", nodeName));
574
            sw.Write(">");
575
            if (this.sdtPr != null)
576
                this.sdtPr.Write(sw, "sdtPr");
577
            if (this.sdtContent != null)
578
                this.sdtContent.Write(sw, "sdtContent");
579
            if (this.sdtEndPr != null)
580
            {
581
                foreach (CT_RPr x in this.sdtEndPr)
582
                {
583
                    x.Write(sw, "sdtEndPr");
584
                }
585
            }
586
            sw.WriteEndW(nodeName);
587
        }
588

589
        [XmlElement(Order = 0)]
590
        public CT_SdtPr sdtPr
591
        {
592
            get
593
            {
594
                return this.sdtPrField;
595
            }
596
            set
597
            {
598
                this.sdtPrField = value;
599
            }
600
        }
601

602
        [XmlArray(Order = 1)]
603
        [XmlArrayItem("rPr", IsNullable = false)]
604
        public List<CT_RPr> sdtEndPr
605
        {
606
            get
607
            {
608
                return this.sdtEndPrField;
609
            }
610
            set
611
            {
612
                this.sdtEndPrField = value;
613
            }
614
        }
615

616
        [XmlElement(Order = 2)]
617
        public CT_SdtContentRun sdtContent
618
        {
619
            get
620
            {
621
                return this.sdtContentField;
622
            }
623
            set
624
            {
625
                this.sdtContentField = value;
626
            }
627
        }
628
    }
629

630

631
    [Serializable]
632

633
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
634
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
635
    public class CT_SdtCell
636
    {
637

638
        private CT_SdtPr sdtPrField;
639

640
        private List<CT_RPr> sdtEndPrField;
641

642
        private CT_SdtContentCell sdtContentField;
643

644
        public CT_SdtCell()
645
        {
646
            //this.sdtContentField = new CT_SdtContentCell();
647
            //this.sdtEndPrField = new List<CT_RPr>();
648
            //this.sdtPrField = new CT_SdtPr();
649
        }
650
        public static CT_SdtCell Parse(XmlNode node, XmlNamespaceManager namespaceManager)
651
        {
652
            if (node == null)
653
                return null;
654
            CT_SdtCell ctObj = new CT_SdtCell();
655
            ctObj.sdtEndPr = new List<CT_RPr>();
656
            foreach (XmlNode childNode in node.ChildNodes)
657
            {
658
                if (childNode.LocalName == "sdtPr")
659
                    ctObj.sdtPr = CT_SdtPr.Parse(childNode, namespaceManager);
660
                else if (childNode.LocalName == "sdtContent")
661
                    ctObj.sdtContent = CT_SdtContentCell.Parse(childNode, namespaceManager);
662
                else if (childNode.LocalName == "sdtEndPr")
663
                    ctObj.sdtEndPr.Add(CT_RPr.Parse(childNode, namespaceManager));
664
            }
665
            return ctObj;
666
        }
667

668

669

670
        internal void Write(StreamWriter sw, string nodeName)
671
        {
672
            sw.Write(string.Format("<w:{0}", nodeName));
673
            sw.Write(">");
674
            if (this.sdtPr != null)
675
                this.sdtPr.Write(sw, "sdtPr");
676
            if (this.sdtContent != null)
677
                this.sdtContent.Write(sw, "sdtContent");
678
            if (this.sdtEndPr != null)
679
            {
680
                foreach (CT_RPr x in this.sdtEndPr)
681
                {
682
                    x.Write(sw, "sdtEndPr");
683
                }
684
            }
685
            sw.WriteEndW(nodeName);
686
        }
687

688
        [XmlElement(Order = 0)]
689
        public CT_SdtPr sdtPr
690
        {
691
            get
692
            {
693
                return this.sdtPrField;
694
            }
695
            set
696
            {
697
                this.sdtPrField = value;
698
            }
699
        }
700

701
        [XmlArray(Order = 1)]
702
        [XmlArrayItem("rPr", IsNullable = false)]
703
        public List<CT_RPr> sdtEndPr
704
        {
705
            get
706
            {
707
                return this.sdtEndPrField;
708
            }
709
            set
710
            {
711
                this.sdtEndPrField = value;
712
            }
713
        }
714

715
        [XmlElement(Order = 2)]
716
        public CT_SdtContentCell sdtContent
717
        {
718
            get
719
            {
720
                return this.sdtContentField;
721
            }
722
            set
723
            {
724
                this.sdtContentField = value;
725
            }
726
        }
727
    }
728

729
    [Serializable]
730

731
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
732
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
733
    public class CT_SdtComboBox
734
    {
735
        public static CT_SdtComboBox Parse(XmlNode node, XmlNamespaceManager namespaceManager)
736
        {
737
            if (node == null)
738
                return null;
739
            CT_SdtComboBox ctObj = new CT_SdtComboBox();
740
            ctObj.lastValue = XmlHelper.ReadString(node.Attributes["w:lastValue"]);
741
            ctObj.listItem = new List<CT_SdtListItem>();
742
            foreach (XmlNode childNode in node.ChildNodes)
743
            {
744
                if (childNode.LocalName == "listItem")
745
                    ctObj.listItem.Add(CT_SdtListItem.Parse(childNode, namespaceManager));
746
            }
747
            return ctObj;
748
        }
749

750

751

752
        internal void Write(StreamWriter sw, string nodeName)
753
        {
754
            sw.Write(string.Format("<w:{0}", nodeName));
755
            XmlHelper.WriteAttribute(sw, "w:lastValue", this.lastValue);
756
            sw.Write(">");
757
            if (this.listItem != null)
758
            {
759
                foreach (CT_SdtListItem x in this.listItem)
760
                {
761
                    x.Write(sw, "listItem");
762
                }
763
            }
764
            sw.WriteEndW(nodeName);
765
        }
766

767
        private List<CT_SdtListItem> listItemField;
768

769
        private string lastValueField;
770

771
        public CT_SdtComboBox()
772
        {
773
            //this.listItemField = new List<CT_SdtListItem>();
774
        }
775

776
        [XmlElement("listItem", Order = 0)]
777
        public List<CT_SdtListItem> listItem
778
        {
779
            get
780
            {
781
                return this.listItemField;
782
            }
783
            set
784
            {
785
                this.listItemField = value;
786
            }
787
        }
788

789
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
790
        public string lastValue
791
        {
792
            get
793
            {
794
                return this.lastValueField;
795
            }
796
            set
797
            {
798
                this.lastValueField = value;
799
            }
800
        }
801
    }
802

803

804
    [Serializable]
805

806
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
807
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
808
    public class CT_SdtDocPart
809
    {
810

811
        private CT_String docPartGalleryField;
812

813
        private CT_String docPartCategoryField;
814

815
        private CT_OnOff docPartUniqueField;
816

817
        public CT_SdtDocPart()
818
        {
819
            //this.docPartUniqueField = new CT_OnOff();
820
            //this.docPartCategoryField = new CT_String();
821
            //this.docPartGalleryField = new CT_String();
822
        }
823
        public static CT_SdtDocPart Parse(XmlNode node, XmlNamespaceManager namespaceManager)
824
        {
825
            if (node == null)
826
                return null;
827
            CT_SdtDocPart ctObj = new CT_SdtDocPart();
828
            foreach (XmlNode childNode in node.ChildNodes)
829
            {
830
                if (childNode.LocalName == "docPartGallery")
831
                    ctObj.docPartGallery = CT_String.Parse(childNode, namespaceManager);
832
                else if (childNode.LocalName == "docPartCategory")
833
                    ctObj.docPartCategory = CT_String.Parse(childNode, namespaceManager);
834
                else if (childNode.LocalName == "docPartUnique")
835
                    ctObj.docPartUnique = CT_OnOff.Parse(childNode, namespaceManager);
836
            }
837
            return ctObj;
838
        }
839

840

841

842
        internal void Write(StreamWriter sw, string nodeName)
843
        {
844
            sw.Write(string.Format("<w:{0}", nodeName));
845
            sw.Write(">");
846
            if (this.docPartGallery != null)
847
                this.docPartGallery.Write(sw, "docPartGallery");
848
            if (this.docPartCategory != null)
849
                this.docPartCategory.Write(sw, "docPartCategory");
850
            if (this.docPartUnique != null)
851
                this.docPartUnique.Write(sw, "docPartUnique");
852
            sw.WriteEndW(nodeName);
853
        }
854

855
        [XmlElement(Order = 0)]
856
        public CT_String docPartGallery
857
        {
858
            get
859
            {
860
                return this.docPartGalleryField;
861
            }
862
            set
863
            {
864
                this.docPartGalleryField = value;
865
            }
866
        }
867

868
        [XmlElement(Order = 1)]
869
        public CT_String docPartCategory
870
        {
871
            get
872
            {
873
                return this.docPartCategoryField;
874
            }
875
            set
876
            {
877
                this.docPartCategoryField = value;
878
            }
879
        }
880

881
        [XmlElement(Order = 2)]
882
        public CT_OnOff docPartUnique
883
        {
884
            get
885
            {
886
                return this.docPartUniqueField;
887
            }
888
            set
889
            {
890
                this.docPartUniqueField = value;
891
            }
892
        }
893

894
        public CT_String AddNewDocPartGallery()
895
        {
896
            if (this.docPartGalleryField == null)
897
                this.docPartGalleryField = new CT_String();
898
            return this.docPartGalleryField;
899
        }
900
    }
901

902

903
    [Serializable]
904

905
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
906
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
907
    public class CT_SdtDropDownList
908
    {
909

910
        private List<CT_SdtListItem> listItemField;
911

912
        private string lastValueField;
913

914
        public CT_SdtDropDownList()
915
        {
916
            //this.listItemField = new List<CT_SdtListItem>();
917
        }
918
        public static CT_SdtDropDownList Parse(XmlNode node, XmlNamespaceManager namespaceManager)
919
        {
920
            if (node == null)
921
                return null;
922
            CT_SdtDropDownList ctObj = new CT_SdtDropDownList();
923
            ctObj.lastValue = XmlHelper.ReadString(node.Attributes["w:lastValue"]);
924
            ctObj.listItem = new List<CT_SdtListItem>();
925
            foreach (XmlNode childNode in node.ChildNodes)
926
            {
927
                if (childNode.LocalName == "listItem")
928
                    ctObj.listItem.Add(CT_SdtListItem.Parse(childNode, namespaceManager));
929
            }
930
            return ctObj;
931
        }
932

933

934

935
        internal void Write(StreamWriter sw, string nodeName)
936
        {
937
            sw.Write(string.Format("<w:{0}", nodeName));
938
            XmlHelper.WriteAttribute(sw, "w:lastValue", this.lastValue);
939
            sw.Write(">");
940
            if (this.listItem != null)
941
            {
942
                foreach (CT_SdtListItem x in this.listItem)
943
                {
944
                    x.Write(sw, "listItem");
945
                }
946
            }
947
            sw.WriteEndW(nodeName);
948
        }
949

950
        [XmlElement("listItem", Order = 0)]
951
        public List<CT_SdtListItem> listItem
952
        {
953
            get
954
            {
955
                return this.listItemField;
956
            }
957
            set
958
            {
959
                this.listItemField = value;
960
            }
961
        }
962

963
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
964
        public string lastValue
965
        {
966
            get
967
            {
968
                return this.lastValueField;
969
            }
970
            set
971
            {
972
                this.lastValueField = value;
973
            }
974
        }
975
    }
976

977
    [Serializable]
978

979
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
980
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
981
    public class CT_SdtContentBlock
982
    {
983

984
        private ArrayList itemsField;
985

986
        private List<ItemsChoiceType19> itemsElementNameField;
987

988
        public CT_SdtContentBlock()
989
        {
990
            this.itemsElementNameField = new List<ItemsChoiceType19>();
991
            this.itemsField = new ArrayList();
992
        }
993
        public static CT_SdtContentBlock Parse(XmlNode node, XmlNamespaceManager namespaceManager)
994
        {
995
            if (node == null)
996
                return null;
997
            CT_SdtContentBlock ctObj = new CT_SdtContentBlock();
998
            foreach (XmlNode childNode in node.ChildNodes)
999
            {
1000
                if (childNode.LocalName == "bookmarkStart")
1001
                {
1002
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
1003
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.bookmarkStart);
1004
                }
1005
                else if (childNode.LocalName == "oMath")
1006
                {
1007
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
1008
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.oMath);
1009
                }
1010
                else if (childNode.LocalName == "oMathPara")
1011
                {
1012
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
1013
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.oMathPara);
1014
                }
1015
                else if (childNode.LocalName == "bookmarkEnd")
1016
                {
1017
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1018
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.bookmarkEnd);
1019
                }
1020
                else if (childNode.LocalName == "commentRangeEnd")
1021
                {
1022
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1023
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.commentRangeEnd);
1024
                }
1025
                else if (childNode.LocalName == "commentRangeStart")
1026
                {
1027
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1028
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.commentRangeStart);
1029
                }
1030
                else if (childNode.LocalName == "customXml")
1031
                {
1032
                    ctObj.Items.Add(CT_CustomXmlBlock.Parse(childNode, namespaceManager));
1033
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXml);
1034
                }
1035
                else if (childNode.LocalName == "customXmlDelRangeEnd")
1036
                {
1037
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1038
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXmlDelRangeEnd);
1039
                }
1040
                else if (childNode.LocalName == "customXmlDelRangeStart")
1041
                {
1042
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1043
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXmlDelRangeStart);
1044
                }
1045
                else if (childNode.LocalName == "customXmlInsRangeEnd")
1046
                {
1047
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1048
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXmlInsRangeEnd);
1049
                }
1050
                else if (childNode.LocalName == "customXmlInsRangeStart")
1051
                {
1052
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1053
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXmlInsRangeStart);
1054
                }
1055
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
1056
                {
1057
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1058
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXmlMoveFromRangeEnd);
1059
                }
1060
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
1061
                {
1062
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1063
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXmlMoveFromRangeStart);
1064
                }
1065
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
1066
                {
1067
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1068
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXmlMoveToRangeEnd);
1069
                }
1070
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
1071
                {
1072
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1073
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.customXmlMoveToRangeStart);
1074
                }
1075
                else if (childNode.LocalName == "del")
1076
                {
1077
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1078
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.del);
1079
                }
1080
                else if (childNode.LocalName == "ins")
1081
                {
1082
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1083
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.ins);
1084
                }
1085
                else if (childNode.LocalName == "moveFrom")
1086
                {
1087
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1088
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.moveFrom);
1089
                }
1090
                else if (childNode.LocalName == "moveFromRangeEnd")
1091
                {
1092
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1093
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.moveFromRangeEnd);
1094
                }
1095
                else if (childNode.LocalName == "moveFromRangeStart")
1096
                {
1097
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1098
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.moveFromRangeStart);
1099
                }
1100
                else if (childNode.LocalName == "moveTo")
1101
                {
1102
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1103
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.moveTo);
1104
                }
1105
                else if (childNode.LocalName == "moveToRangeEnd")
1106
                {
1107
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1108
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.moveToRangeEnd);
1109
                }
1110
                else if (childNode.LocalName == "moveToRangeStart")
1111
                {
1112
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1113
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.moveToRangeStart);
1114
                }
1115
                else if (childNode.LocalName == "p")
1116
                {
1117
                    ctObj.Items.Add(CT_P.Parse(childNode, namespaceManager));
1118
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.p);
1119
                }
1120
                else if (childNode.LocalName == "permEnd")
1121
                {
1122
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
1123
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.permEnd);
1124
                }
1125
                else if (childNode.LocalName == "permStart")
1126
                {
1127
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
1128
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.permStart);
1129
                }
1130
                else if (childNode.LocalName == "proofErr")
1131
                {
1132
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
1133
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.proofErr);
1134
                }
1135
                else if (childNode.LocalName == "sdt")
1136
                {
1137
                    ctObj.Items.Add(CT_SdtBlock.Parse(childNode, namespaceManager));
1138
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.sdt);
1139
                }
1140
                else if (childNode.LocalName == "tbl")
1141
                {
1142
                    ctObj.Items.Add(CT_Tbl.Parse(childNode, namespaceManager));
1143
                    ctObj.ItemsElementName.Add(ItemsChoiceType19.tbl);
1144
                }
1145
            }
1146
            return ctObj;
1147
        }
1148

1149
        internal void Write(StreamWriter sw, string nodeName)
1150
        {
1151
            sw.Write(string.Format("<w:{0}", nodeName));
1152
            sw.Write(">");
1153
            foreach (object o in this.Items)
1154
            {
1155
                if (o is CT_Bookmark)
1156
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
1157
                else if (o is CT_OMath)
1158
                    ((CT_OMath)o).Write(sw, "oMath");
1159
                else if (o is CT_OMathPara)
1160
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
1161
                else if (o is CT_MarkupRange)
1162
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
1163
                else if (o is CT_MarkupRange)
1164
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
1165
                else if (o is CT_MarkupRange)
1166
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
1167
                else if (o is CT_CustomXmlBlock)
1168
                    ((CT_CustomXmlBlock)o).Write(sw, "customXml");
1169
                else if (o is CT_Markup)
1170
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
1171
                else if (o is CT_TrackChange)
1172
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
1173
                else if (o is CT_Markup)
1174
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
1175
                else if (o is CT_TrackChange)
1176
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
1177
                else if (o is CT_Markup)
1178
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
1179
                else if (o is CT_TrackChange)
1180
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
1181
                else if (o is CT_Markup)
1182
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
1183
                else if (o is CT_TrackChange)
1184
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
1185
                else if (o is CT_RunTrackChange)
1186
                    ((CT_RunTrackChange)o).Write(sw, "del");
1187
                else if (o is CT_RunTrackChange)
1188
                    ((CT_RunTrackChange)o).Write(sw, "ins");
1189
                else if (o is CT_RunTrackChange)
1190
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
1191
                else if (o is CT_MarkupRange)
1192
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
1193
                else if (o is CT_MoveBookmark)
1194
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
1195
                else if (o is CT_RunTrackChange)
1196
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
1197
                else if (o is CT_MarkupRange)
1198
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
1199
                else if (o is CT_MoveBookmark)
1200
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
1201
                else if (o is CT_P)
1202
                    ((CT_P)o).Write(sw, "p");
1203
                else if (o is CT_Perm)
1204
                    ((CT_Perm)o).Write(sw, "permEnd");
1205
                else if (o is CT_PermStart)
1206
                    ((CT_PermStart)o).Write(sw, "permStart");
1207
                else if (o is CT_ProofErr)
1208
                    ((CT_ProofErr)o).Write(sw, "proofErr");
1209
                else if (o is CT_SdtBlock)
1210
                    ((CT_SdtBlock)o).Write(sw, "sdt");
1211
                else if (o is CT_Tbl)
1212
                    ((CT_Tbl)o).Write(sw, "tbl");
1213
            }
1214
            sw.WriteEndW(nodeName);
1215
        }
1216

1217
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
1218
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
1219
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 0)]
1220
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 0)]
1221
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1222
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 0)]
1223
        [XmlElement("customXml", typeof(CT_CustomXmlBlock), Order = 0)]
1224
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 0)]
1225
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 0)]
1226
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 0)]
1227
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 0)]
1228
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 0)]
1229
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 0)]
1230
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 0)]
1231
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 0)]
1232
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 0)]
1233
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 0)]
1234
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 0)]
1235
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1236
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 0)]
1237
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 0)]
1238
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1239
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 0)]
1240
        [XmlElement("p", typeof(CT_P), Order = 0)]
1241
        [XmlElement("permEnd", typeof(CT_Perm), Order = 0)]
1242
        [XmlElement("permStart", typeof(CT_PermStart), Order = 0)]
1243
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 0)]
1244
        [XmlElement("sdt", typeof(CT_SdtBlock), Order = 0)]
1245
        [XmlElement("tbl", typeof(CT_Tbl), Order = 0)]
1246
        [XmlChoiceIdentifier("ItemsElementName")]
1247
        public ArrayList Items
1248
        {
1249
            get
1250
            {
1251
                return this.itemsField;
1252
            }
1253
            set
1254
            {
1255
                this.itemsField = value;
1256
            }
1257
        }
1258

1259
        [XmlElement("ItemsElementName", Order = 1)]
1260
        [XmlIgnore]
1261
        public List<ItemsChoiceType19> ItemsElementName
1262
        {
1263
            get
1264
            {
1265
                return this.itemsElementNameField ;
1266
            }
1267
            set
1268
            {
1269
               this.itemsElementNameField = value;
1270
            }
1271
        }
1272

1273
        public CT_P AddNewP()
1274
        {
1275
            return AddNewObject<CT_P>(ItemsChoiceType19.p);
1276
        }
1277
        #region Generic methods for object operation
1278

1279
        private List<T> GetObjectList<T>(ItemsChoiceType19 type) where T : class
1280
        {
1281
            lock (this)
1282
            {
1283
                List<T> list = new List<T>();
1284
                for (int i = 0; i < itemsElementNameField.Count; i++)
1285
                {
1286
                    if (itemsElementNameField[i] == type)
1287
                        list.Add(itemsField[i] as T);
1288
                }
1289
                return list;
1290
            }
1291
        }
1292
        private int SizeOfArray(ItemsChoiceType19 type)
1293
        {
1294
            lock (this)
1295
            {
1296
                int size = 0;
1297
                for (int i = 0; i < itemsElementNameField.Count; i++)
1298
                {
1299
                    if (itemsElementNameField[i] == type)
1300
                        size++;
1301
                }
1302
                return size;
1303
            }
1304
        }
1305
        private T GetObjectArray<T>(int p, ItemsChoiceType19 type) where T : class
1306
        {
1307
            lock (this)
1308
            {
1309
                int pos = GetObjectIndex(type, p);
1310
                if (pos < 0 || pos >= this.itemsField.Count)
1311
                    return null;
1312
                return itemsField[pos] as T;
1313
            }
1314
        }
1315
        private T InsertNewObject<T>(ItemsChoiceType19 type, int p) where T : class, new()
1316
        {
1317
            T t = new T();
1318
            lock (this)
1319
            {
1320
                int pos = GetObjectIndex(type, p);
1321
                this.itemsElementNameField.Insert(pos, type);
1322
                this.itemsField.Insert(pos, t);
1323
            }
1324
            return t;
1325
        }
1326
        private T AddNewObject<T>(ItemsChoiceType19 type) where T : class, new()
1327
        {
1328
            T t = new T();
1329
            lock (this)
1330
            {
1331
                this.itemsElementNameField.Add(type);
1332
                this.itemsField.Add(t);
1333
            }
1334
            return t;
1335
        }
1336
        private void SetObject<T>(ItemsChoiceType19 type, int p, T obj) where T : class
1337
        {
1338
            lock (this)
1339
            {
1340
                int pos = GetObjectIndex(type, p);
1341
                if (pos < 0 || pos >= this.itemsField.Count)
1342
                    return;
1343
                if (this.itemsField[pos] is T)
1344
                    this.itemsField[pos] = obj;
1345
                else
1346
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
1347
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
1348
            }
1349
        }
1350
        private int GetObjectIndex(ItemsChoiceType19 type, int p)
1351
        {
1352
            int index = -1;
1353
            int pos = 0;
1354
            for (int i = 0; i < itemsElementNameField.Count; i++)
1355
            {
1356
                if (itemsElementNameField[i] == type)
1357
                {
1358
                    if (pos == p)
1359
                    {
1360
                        index = i;
1361
                        break;
1362
                    }
1363
                    else
1364
                        pos++;
1365
                }
1366
            }
1367
            return index;
1368
        }
1369
        private void RemoveObject(ItemsChoiceType19 type, int p)
1370
        {
1371
            lock (this)
1372
            {
1373
                int pos = GetObjectIndex(type, p);
1374
                if (pos < 0 || pos >= this.itemsField.Count)
1375
                    return;
1376
                itemsElementNameField.RemoveAt(pos);
1377
                itemsField.RemoveAt(pos);
1378
            }
1379
        }
1380
        #endregion
1381
    }
1382

1383
    [Serializable]
1384
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
1385
    public enum ItemsChoiceType19
1386
    {
1387

1388
    
1389
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
1390
        oMath,
1391

1392
    
1393
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
1394
        oMathPara,
1395

1396
    
1397
        bookmarkEnd,
1398

1399
    
1400
        bookmarkStart,
1401

1402
    
1403
        commentRangeEnd,
1404

1405
    
1406
        commentRangeStart,
1407

1408
    
1409
        customXml,
1410

1411
    
1412
        customXmlDelRangeEnd,
1413

1414
    
1415
        customXmlDelRangeStart,
1416

1417
    
1418
        customXmlInsRangeEnd,
1419

1420
    
1421
        customXmlInsRangeStart,
1422

1423
    
1424
        customXmlMoveFromRangeEnd,
1425

1426
    
1427
        customXmlMoveFromRangeStart,
1428

1429
    
1430
        customXmlMoveToRangeEnd,
1431

1432
    
1433
        customXmlMoveToRangeStart,
1434

1435
    
1436
        del,
1437

1438
    
1439
        ins,
1440

1441
    
1442
        moveFrom,
1443

1444
    
1445
        moveFromRangeEnd,
1446

1447
    
1448
        moveFromRangeStart,
1449

1450
    
1451
        moveTo,
1452

1453
    
1454
        moveToRangeEnd,
1455

1456
    
1457
        moveToRangeStart,
1458

1459
    
1460
        p,
1461

1462
    
1463
        permEnd,
1464

1465
    
1466
        permStart,
1467

1468
    
1469
        proofErr,
1470

1471
    
1472
        sdt,
1473

1474
    
1475
        tbl,
1476
    }
1477

1478
    [Serializable]
1479

1480
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1481
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1482
    public class CT_SdtContentRow
1483
    {
1484

1485
        private ArrayList itemsField;
1486

1487
        private List<ItemsChoiceType22> itemsElementNameField;
1488

1489
        public CT_SdtContentRow()
1490
        {
1491
            this.itemsElementNameField = new List<ItemsChoiceType22>();
1492
            this.itemsField = new ArrayList();
1493
        }
1494
        public static CT_SdtContentRow Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1495
        {
1496
            if (node == null)
1497
                return null;
1498
            CT_SdtContentRow ctObj = new CT_SdtContentRow();
1499
            foreach (XmlNode childNode in node.ChildNodes)
1500
            {
1501
                if (childNode.LocalName == "oMath")
1502
                {
1503
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
1504
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.oMath);
1505
                }
1506
                else if (childNode.LocalName == "oMathPara")
1507
                {
1508
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
1509
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.oMathPara);
1510
                }
1511
                else if (childNode.LocalName == "bookmarkEnd")
1512
                {
1513
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1514
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.bookmarkEnd);
1515
                }
1516
                else if (childNode.LocalName == "bookmarkStart")
1517
                {
1518
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
1519
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.bookmarkStart);
1520
                }
1521
                else if (childNode.LocalName == "commentRangeEnd")
1522
                {
1523
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1524
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.commentRangeEnd);
1525
                }
1526
                else if (childNode.LocalName == "commentRangeStart")
1527
                {
1528
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1529
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.commentRangeStart);
1530
                }
1531
                else if (childNode.LocalName == "customXml")
1532
                {
1533
                    ctObj.Items.Add(CT_CustomXmlRow.Parse(childNode, namespaceManager));
1534
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXml);
1535
                }
1536
                else if (childNode.LocalName == "customXmlDelRangeEnd")
1537
                {
1538
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1539
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXmlDelRangeEnd);
1540
                }
1541
                else if (childNode.LocalName == "customXmlDelRangeStart")
1542
                {
1543
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1544
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXmlDelRangeStart);
1545
                }
1546
                else if (childNode.LocalName == "customXmlInsRangeEnd")
1547
                {
1548
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1549
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXmlInsRangeEnd);
1550
                }
1551
                else if (childNode.LocalName == "customXmlInsRangeStart")
1552
                {
1553
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1554
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXmlInsRangeStart);
1555
                }
1556
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
1557
                {
1558
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1559
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXmlMoveFromRangeEnd);
1560
                }
1561
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
1562
                {
1563
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1564
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXmlMoveFromRangeStart);
1565
                }
1566
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
1567
                {
1568
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1569
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXmlMoveToRangeEnd);
1570
                }
1571
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
1572
                {
1573
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1574
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.customXmlMoveToRangeStart);
1575
                }
1576
                else if (childNode.LocalName == "del")
1577
                {
1578
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1579
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.del);
1580
                }
1581
                else if (childNode.LocalName == "ins")
1582
                {
1583
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1584
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.ins);
1585
                }
1586
                else if (childNode.LocalName == "moveFrom")
1587
                {
1588
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1589
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.moveFrom);
1590
                }
1591
                else if (childNode.LocalName == "moveFromRangeEnd")
1592
                {
1593
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1594
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.moveFromRangeEnd);
1595
                }
1596
                else if (childNode.LocalName == "moveFromRangeStart")
1597
                {
1598
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1599
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.moveFromRangeStart);
1600
                }
1601
                else if (childNode.LocalName == "moveTo")
1602
                {
1603
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1604
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.moveTo);
1605
                }
1606
                else if (childNode.LocalName == "moveToRangeEnd")
1607
                {
1608
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1609
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.moveToRangeEnd);
1610
                }
1611
                else if (childNode.LocalName == "moveToRangeStart")
1612
                {
1613
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1614
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.moveToRangeStart);
1615
                }
1616
                else if (childNode.LocalName == "permEnd")
1617
                {
1618
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
1619
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.permEnd);
1620
                }
1621
                else if (childNode.LocalName == "permStart")
1622
                {
1623
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
1624
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.permStart);
1625
                }
1626
                else if (childNode.LocalName == "proofErr")
1627
                {
1628
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
1629
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.proofErr);
1630
                }
1631
                else if (childNode.LocalName == "sdt")
1632
                {
1633
                    ctObj.Items.Add(CT_SdtRow.Parse(childNode, namespaceManager));
1634
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.sdt);
1635
                }
1636
                else if (childNode.LocalName == "tr")
1637
                {
1638
                    ctObj.Items.Add(CT_Row.Parse(childNode, namespaceManager, ctObj));
1639
                    ctObj.ItemsElementName.Add(ItemsChoiceType22.tr);
1640
                }
1641
            }
1642
            return ctObj;
1643
        }
1644

1645
        internal void Write(StreamWriter sw, string nodeName)
1646
        {
1647
            sw.Write(string.Format("<w:{0}", nodeName));
1648
            sw.Write(">");
1649
            foreach (object o in this.Items)
1650
            {
1651
                if (o is CT_OMath)
1652
                    ((CT_OMath)o).Write(sw, "oMath");
1653
                else if (o is CT_OMathPara)
1654
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
1655
                else if (o is CT_MarkupRange)
1656
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
1657
                else if (o is CT_Bookmark)
1658
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
1659
                else if (o is CT_MarkupRange)
1660
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
1661
                else if (o is CT_MarkupRange)
1662
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
1663
                else if (o is CT_CustomXmlRow)
1664
                    ((CT_CustomXmlRow)o).Write(sw, "customXml");
1665
                else if (o is CT_Markup)
1666
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
1667
                else if (o is CT_TrackChange)
1668
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
1669
                else if (o is CT_Markup)
1670
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
1671
                else if (o is CT_TrackChange)
1672
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
1673
                else if (o is CT_Markup)
1674
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
1675
                else if (o is CT_TrackChange)
1676
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
1677
                else if (o is CT_Markup)
1678
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
1679
                else if (o is CT_TrackChange)
1680
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
1681
                else if (o is CT_RunTrackChange)
1682
                    ((CT_RunTrackChange)o).Write(sw, "del");
1683
                else if (o is CT_RunTrackChange)
1684
                    ((CT_RunTrackChange)o).Write(sw, "ins");
1685
                else if (o is CT_RunTrackChange)
1686
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
1687
                else if (o is CT_MarkupRange)
1688
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
1689
                else if (o is CT_MoveBookmark)
1690
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
1691
                else if (o is CT_RunTrackChange)
1692
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
1693
                else if (o is CT_MarkupRange)
1694
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
1695
                else if (o is CT_MoveBookmark)
1696
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
1697
                else if (o is CT_Perm)
1698
                    ((CT_Perm)o).Write(sw, "permEnd");
1699
                else if (o is CT_PermStart)
1700
                    ((CT_PermStart)o).Write(sw, "permStart");
1701
                else if (o is CT_ProofErr)
1702
                    ((CT_ProofErr)o).Write(sw, "proofErr");
1703
                else if (o is CT_SdtRow)
1704
                    ((CT_SdtRow)o).Write(sw, "sdt");
1705
                else if (o is CT_Row)
1706
                    ((CT_Row)o).Write(sw, "tr");
1707
            }
1708
            sw.WriteEndW(nodeName);
1709
        }
1710

1711
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
1712
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
1713
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 0)]
1714
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 0)]
1715
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1716
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 0)]
1717
        [XmlElement("customXml", typeof(CT_CustomXmlRow), Order = 0)]
1718
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 0)]
1719
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 0)]
1720
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 0)]
1721
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 0)]
1722
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 0)]
1723
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 0)]
1724
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 0)]
1725
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 0)]
1726
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 0)]
1727
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 0)]
1728
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 0)]
1729
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1730
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 0)]
1731
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 0)]
1732
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1733
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 0)]
1734
        [XmlElement("permEnd", typeof(CT_Perm), Order = 0)]
1735
        [XmlElement("permStart", typeof(CT_PermStart), Order = 0)]
1736
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 0)]
1737
        [XmlElement("sdt", typeof(CT_SdtRow), Order = 0)]
1738
        [XmlElement("tr", typeof(CT_Row), Order = 0)]
1739
        [XmlChoiceIdentifier("ItemsElementName")]
1740
        public ArrayList Items
1741
        {
1742
            get
1743
            {
1744
                return this.itemsField;
1745
            }
1746
            set
1747
            {
1748
                this.itemsField = value;
1749
            }
1750
        }
1751

1752
        [XmlElement("ItemsElementName", Order = 1)]
1753
        [XmlIgnore]
1754
        public List<ItemsChoiceType22> ItemsElementName
1755
        {
1756
            get
1757
            {
1758
                return this.itemsElementNameField;
1759
            }
1760
            set
1761
            {
1762
                this.itemsElementNameField = value;
1763
            }
1764
        }
1765
    }
1766

1767

1768
    [Serializable]
1769

1770
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1771
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1772
    public class CT_SdtPr
1773
    {
1774

1775
        private ArrayList itemsField;
1776

1777
        private List<SdtPrElementType> itemsElementNameField;
1778

1779
        public CT_SdtPr()
1780
        {
1781
            this.itemsElementNameField = new List<SdtPrElementType>();
1782
            this.itemsField = new ArrayList();
1783
        }
1784

1785
        [XmlElement("alias", typeof(CT_String), Order = 0)]
1786
        [XmlElement("bibliography", typeof(CT_Empty), Order = 0)]
1787
        [XmlElement("citation", typeof(CT_Empty), Order = 0)]
1788
        [XmlElement("comboBox", typeof(CT_SdtComboBox), Order = 0)]
1789
        [XmlElement("dataBinding", typeof(CT_DataBinding), Order = 0)]
1790
        [XmlElement("date", typeof(CT_SdtDate), Order = 0)]
1791
        [XmlElement("docPartList", typeof(CT_SdtDocPart), Order = 0)]
1792
        [XmlElement("docPartObj", typeof(CT_SdtDocPart), Order = 0)]
1793
        [XmlElement("dropDownList", typeof(CT_SdtDropDownList), Order = 0)]
1794
        [XmlElement("equation", typeof(CT_Empty), Order = 0)]
1795
        [XmlElement("group", typeof(CT_Empty), Order = 0)]
1796
        [XmlElement("id", typeof(CT_DecimalNumber), Order = 0)]
1797
        [XmlElement("lock", typeof(CT_Lock), Order = 0)]
1798
        [XmlElement("picture", typeof(CT_Empty), Order = 0)]
1799
        [XmlElement("placeholder", typeof(CT_Placeholder), Order = 0)]
1800
        [XmlElement("rPr", typeof(CT_RPr), Order = 0)]
1801
        [XmlElement("richText", typeof(CT_Empty), Order = 0)]
1802
        [XmlElement("showingPlcHdr", typeof(CT_OnOff), Order = 0)]
1803
        [XmlElement("tag", typeof(CT_String), Order = 0)]
1804
        [XmlElement("temporary", typeof(CT_OnOff), Order = 0)]
1805
        [XmlElement("text", typeof(CT_SdtText), Order = 0)]
1806
        [XmlChoiceIdentifier("ItemsElementName")]
1807
        public ArrayList Items
1808
        {
1809
            get
1810
            {
1811
                return this.itemsField;
1812
            }
1813
            set
1814
            {
1815
                 this.itemsField = value;
1816
            }
1817
        }
1818

1819
        [XmlElement("ItemsElementName", Order = 1)]
1820
        [XmlIgnore]
1821
        public List<SdtPrElementType> ItemsElementName
1822
        {
1823
            get
1824
            {
1825
                return this.itemsElementNameField;
1826
            }
1827
            set
1828
            {
1829
                this.itemsElementNameField = value;
1830
            }
1831
        }
1832
        public static CT_SdtPr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1833
        {
1834
            if (node == null)
1835
                return null;
1836
            CT_SdtPr ctObj = new CT_SdtPr();
1837
            foreach (XmlNode childNode in node.ChildNodes)
1838
            {
1839
                if (childNode.LocalName == "richText")
1840
                {
1841
                    ctObj.Items.Add(new CT_Empty());
1842
                    ctObj.ItemsElementName.Add(SdtPrElementType.richText);
1843
                }
1844
                else if (childNode.LocalName == "docPartList")
1845
                {
1846
                    ctObj.Items.Add(CT_SdtDocPart.Parse(childNode, namespaceManager));
1847
                    ctObj.ItemsElementName.Add(SdtPrElementType.docPartList);
1848
                }
1849
                else if (childNode.LocalName == "docPartObj")
1850
                {
1851
                    ctObj.Items.Add(CT_SdtDocPart.Parse(childNode, namespaceManager));
1852
                    ctObj.ItemsElementName.Add(SdtPrElementType.docPartObj);
1853
                }
1854
                else if (childNode.LocalName == "dropDownList")
1855
                {
1856
                    ctObj.Items.Add(CT_SdtDropDownList.Parse(childNode, namespaceManager));
1857
                    ctObj.ItemsElementName.Add(SdtPrElementType.dropDownList);
1858
                }
1859
                else if (childNode.LocalName == "equation")
1860
                {
1861
                    ctObj.Items.Add(new CT_Empty());
1862
                    ctObj.ItemsElementName.Add(SdtPrElementType.equation);
1863
                }
1864
                else if (childNode.LocalName == "group")
1865
                {
1866
                    ctObj.Items.Add(new CT_Empty());
1867
                    ctObj.ItemsElementName.Add(SdtPrElementType.group);
1868
                }
1869
                else if (childNode.LocalName == "id")
1870
                {
1871
                    ctObj.Items.Add(CT_DecimalNumber.Parse(childNode, namespaceManager));
1872
                    ctObj.ItemsElementName.Add(SdtPrElementType.id);
1873
                }
1874
                else if (childNode.LocalName == "lock")
1875
                {
1876
                    ctObj.Items.Add(CT_Lock.Parse(childNode, namespaceManager));
1877
                    ctObj.ItemsElementName.Add(SdtPrElementType.@lock);
1878
                }
1879
                else if (childNode.LocalName == "date")
1880
                {
1881
                    ctObj.Items.Add(CT_SdtDate.Parse(childNode, namespaceManager));
1882
                    ctObj.ItemsElementName.Add(SdtPrElementType.date);
1883
                }
1884
                else if (childNode.LocalName == "placeholder")
1885
                {
1886
                    ctObj.Items.Add(CT_Placeholder.Parse(childNode, namespaceManager));
1887
                    ctObj.ItemsElementName.Add(SdtPrElementType.placeholder);
1888
                }
1889
                else if (childNode.LocalName == "rPr")
1890
                {
1891
                    ctObj.Items.Add(CT_RPr.Parse(childNode, namespaceManager));
1892
                    ctObj.ItemsElementName.Add(SdtPrElementType.rPr);
1893
                }
1894
                else if (childNode.LocalName == "showingPlcHdr")
1895
                {
1896
                    ctObj.Items.Add(CT_OnOff.Parse(childNode, namespaceManager));
1897
                    ctObj.ItemsElementName.Add(SdtPrElementType.showingPlcHdr);
1898
                }
1899
                else if (childNode.LocalName == "tag")
1900
                {
1901
                    ctObj.Items.Add(CT_String.Parse(childNode, namespaceManager));
1902
                    ctObj.ItemsElementName.Add(SdtPrElementType.tag);
1903
                }
1904
                else if (childNode.LocalName == "temporary")
1905
                {
1906
                    ctObj.Items.Add(CT_OnOff.Parse(childNode, namespaceManager));
1907
                    ctObj.ItemsElementName.Add(SdtPrElementType.temporary);
1908
                }
1909
                else if (childNode.LocalName == "text")
1910
                {
1911
                    ctObj.Items.Add(CT_SdtText.Parse(childNode, namespaceManager));
1912
                    ctObj.ItemsElementName.Add(SdtPrElementType.text);
1913
                }
1914
                else if (childNode.LocalName == "picture")
1915
                {
1916
                    ctObj.Items.Add(new CT_Empty());
1917
                    ctObj.ItemsElementName.Add(SdtPrElementType.picture);
1918
                }
1919
                else if (childNode.LocalName == "alias")
1920
                {
1921
                    ctObj.Items.Add(CT_String.Parse(childNode, namespaceManager));
1922
                    ctObj.ItemsElementName.Add(SdtPrElementType.alias);
1923
                }
1924
                else if (childNode.LocalName == "bibliography")
1925
                {
1926
                    ctObj.Items.Add(new CT_Empty());
1927
                    ctObj.ItemsElementName.Add(SdtPrElementType.bibliography);
1928
                }
1929
                else if (childNode.LocalName == "citation")
1930
                {
1931
                    ctObj.Items.Add(new CT_Empty());
1932
                    ctObj.ItemsElementName.Add(SdtPrElementType.citation);
1933
                }
1934
                else if (childNode.LocalName == "comboBox")
1935
                {
1936
                    ctObj.Items.Add(CT_SdtComboBox.Parse(childNode, namespaceManager));
1937
                    ctObj.ItemsElementName.Add(SdtPrElementType.comboBox);
1938
                }
1939
                else if (childNode.LocalName == "dataBinding")
1940
                {
1941
                    ctObj.Items.Add(CT_DataBinding.Parse(childNode, namespaceManager));
1942
                    ctObj.ItemsElementName.Add(SdtPrElementType.dataBinding);
1943
                }
1944
            }
1945
            return ctObj;
1946
        }
1947

1948
        internal void Write(StreamWriter sw, string nodeName)
1949
        {
1950
            sw.Write(string.Format("<w:{0}", nodeName));
1951
            sw.Write(">");
1952
            
1953
            for (int i=0;i<this.Items.Count;i++)
1954
            {
1955
                object o = Items[i];
1956
                SdtPrElementType t= this.itemsElementNameField[i];
1957
                if (o is CT_Empty && t== SdtPrElementType.richText)
1958
                    sw.Write("<w:richText/>");
1959
                else if (o is CT_SdtDocPart&& t  == SdtPrElementType.docPartList)
1960
                    ((CT_SdtDocPart)o).Write(sw, "docPartList");
1961
                else if (o is CT_SdtDocPart&& t == SdtPrElementType.docPartObj)
1962
                    ((CT_SdtDocPart)o).Write(sw, "docPartObj");
1963
                else if (o is CT_SdtDropDownList)
1964
                    ((CT_SdtDropDownList)o).Write(sw, "dropDownList");
1965
                else if (o is CT_Empty&& t== SdtPrElementType.equation)
1966
                    sw.Write("<w:equation/>");
1967
                else if (o is CT_Empty&& t== SdtPrElementType.group)
1968
                    sw.Write("<w:group/>");
1969
                else if (o is CT_DecimalNumber&& t== SdtPrElementType.id)
1970
                    ((CT_DecimalNumber)o).Write(sw, "id");
1971
                else if (o is CT_Lock)
1972
                    ((CT_Lock)o).Write(sw, "lock");
1973
                else if (o is CT_SdtDate)
1974
                    ((CT_SdtDate)o).Write(sw, "date");
1975
                else if (o is CT_Placeholder)
1976
                    ((CT_Placeholder)o).Write(sw, "placeholder");
1977
                else if (o is CT_RPr)
1978
                    ((CT_RPr)o).Write(sw, "rPr");
1979
                else if (o is CT_OnOff && t== SdtPrElementType.showingPlcHdr)
1980
                    ((CT_OnOff)o).Write(sw, "showingPlcHdr");
1981
                else if (o is CT_String&& t== SdtPrElementType.tag)
1982
                    ((CT_String)o).Write(sw, "tag");
1983
                else if (o is CT_OnOff && t== SdtPrElementType.temporary)
1984
                    ((CT_OnOff)o).Write(sw, "temporary");
1985
                else if (o is CT_SdtText)
1986
                    ((CT_SdtText)o).Write(sw, "text");
1987
                else if (o is CT_Empty && t== SdtPrElementType.picture)
1988
                    sw.Write("<w:picture/>");
1989
                else if (o is CT_String&& t== SdtPrElementType.alias)
1990
                    ((CT_String)o).Write(sw, "alias");
1991
                else if (o is CT_Empty && t== SdtPrElementType.bibliography)
1992
                    sw.Write("<w:bibliography/>");
1993
                else if (o is CT_Empty && t== SdtPrElementType.citation)
1994
                    sw.Write("<w:citation/>");
1995
                else if (o is CT_SdtComboBox)
1996
                    ((CT_SdtComboBox)o).Write(sw, "comboBox");
1997
                else if (o is CT_DataBinding)
1998
                    ((CT_DataBinding)o).Write(sw, "dataBinding");
1999
                
2000
            }
2001
            sw.WriteEndW(nodeName);
2002
        }
2003

2004
        public CT_DecimalNumber AddNewId()
2005
        {
2006
            return AddNewObject<CT_DecimalNumber>(SdtPrElementType.id);
2007
        }
2008

2009
        public CT_SdtDocPart AddNewDocPartObj()
2010
        {
2011
            return AddNewObject<CT_SdtDocPart>(SdtPrElementType.docPartObj);
2012
        }
2013

2014
        public CT_String[] GetAliasArray()
2015
        {
2016
            return GetObjectList<CT_String>(SdtPrElementType.alias).ToArray();
2017
        }
2018

2019
        #region Generic methods for object operation
2020

2021
        public List<T> GetObjectList<T>(SdtPrElementType type) where T : class
2022
        {
2023
            lock (this)
2024
            {
2025
                List<T> list = new List<T>();
2026
                for (int i = 0; i < itemsElementNameField.Count; i++)
2027
                {
2028
                    if (itemsElementNameField[i] == type)
2029
                        list.Add(itemsField[i] as T);
2030
                }
2031
                return list;
2032
            }
2033
        }
2034
        private int SizeOfArray(SdtPrElementType type)
2035
        {
2036
            lock (this)
2037
            {
2038
                int size = 0;
2039
                for (int i = 0; i < itemsElementNameField.Count; i++)
2040
                {
2041
                    if (itemsElementNameField[i] == type)
2042
                        size++;
2043
                }
2044
                return size;
2045
            }
2046
        }
2047
        private T GetObjectArray<T>(int p, SdtPrElementType type) where T : class
2048
        {
2049
            lock (this)
2050
            {
2051
                int pos = GetObjectIndex(type, p);
2052
                if (pos < 0 || pos >= this.itemsField.Count)
2053
                    return null;
2054
                return itemsField[pos] as T;
2055
            }
2056
        }
2057
        private T InsertNewObject<T>(SdtPrElementType type, int p) where T : class, new()
2058
        {
2059
            T t = new T();
2060
            lock (this)
2061
            {
2062
                int pos = GetObjectIndex(type, p);
2063
                this.itemsElementNameField.Insert(pos, type);
2064
                this.itemsField.Insert(pos, t);
2065
            }
2066
            return t;
2067
        }
2068
        private T AddNewObject<T>(SdtPrElementType type) where T : class, new()
2069
        {
2070
            T t = new T();
2071
            lock (this)
2072
            {
2073
                this.itemsElementNameField.Add(type);
2074
                this.itemsField.Add(t);
2075
            }
2076
            return t;
2077
        }
2078
        private void SetObject<T>(SdtPrElementType type, int p, T obj) where T : class
2079
        {
2080
            lock (this)
2081
            {
2082
                int pos = GetObjectIndex(type, p);
2083
                if (pos < 0 || pos >= this.itemsField.Count)
2084
                    return;
2085
                if (this.itemsField[pos] is T)
2086
                    this.itemsField[pos] = obj;
2087
                else
2088
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
2089
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
2090
            }
2091
        }
2092
        private int GetObjectIndex(SdtPrElementType type, int p)
2093
        {
2094
            int index = -1;
2095
            int pos = 0;
2096
            for (int i = 0; i < itemsElementNameField.Count; i++)
2097
            {
2098
                if (itemsElementNameField[i] == type)
2099
                {
2100
                    if (pos == p)
2101
                    {
2102
                        index = i;
2103
                        break;
2104
                    }
2105
                    else
2106
                        pos++;
2107
                }
2108
            }
2109
            return index;
2110
        }
2111
        private void RemoveObject(SdtPrElementType type, int p)
2112
        {
2113
            lock (this)
2114
            {
2115
                int pos = GetObjectIndex(type, p);
2116
                if (pos < 0 || pos >= this.itemsField.Count)
2117
                    return;
2118
                itemsElementNameField.RemoveAt(pos);
2119
                itemsField.RemoveAt(pos);
2120
            }
2121
        }
2122
        #endregion
2123
    }
2124

2125
    [Serializable]
2126
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
2127
    public enum SdtPrElementType
2128
    {
2129

2130
    
2131
        alias,
2132

2133
    
2134
        bibliography,
2135

2136
    
2137
        citation,
2138

2139
    
2140
        comboBox,
2141

2142
    
2143
        dataBinding,
2144

2145
    
2146
        date,
2147

2148
    
2149
        docPartList,
2150

2151
    
2152
        docPartObj,
2153

2154
    
2155
        dropDownList,
2156

2157
    
2158
        equation,
2159

2160
    
2161
        group,
2162

2163
    
2164
        id,
2165

2166
    
2167
        @lock,
2168

2169
    
2170
        picture,
2171

2172
    
2173
        placeholder,
2174

2175
    
2176
        rPr,
2177

2178
    
2179
        richText,
2180

2181
    
2182
        showingPlcHdr,
2183

2184
    
2185
        tag,
2186

2187
    
2188
        temporary,
2189

2190
    
2191
        text,
2192
    }
2193

2194
    [Serializable]
2195

2196
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2197
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2198
    public class CT_SdtEndPr
2199
    {
2200

2201
        private List<CT_RPr> itemsField;
2202

2203
        public CT_SdtEndPr()
2204
        {
2205
            this.itemsField = new List<CT_RPr>();
2206
        }
2207

2208
        [XmlElement("rPr", Order = 0)]
2209
        public List<CT_RPr> Items
2210
        {
2211
            get
2212
            {
2213
                return this.itemsField;
2214
            }
2215
            set
2216
            {
2217
                this.itemsField = value;
2218
            }
2219
        }
2220

2221
        public CT_RPr AddNewRPr()
2222
        {
2223
            CT_RPr r = new CT_RPr();
2224
            this.itemsField.Add(r);
2225
            return r;
2226
        }
2227
    }
2228

2229

2230
    [Serializable]
2231

2232
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2233
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2234
    public class CT_SdtContentRun
2235
    {
2236

2237
        private ArrayList itemsField;
2238

2239
        private List<ItemsChoiceType18> itemsElementNameField;
2240

2241
        public CT_SdtContentRun()
2242
        {
2243
            this.itemsElementNameField = new List<ItemsChoiceType18>();
2244
            this.itemsField = new ArrayList();
2245
        }
2246
        public static CT_SdtContentRun Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2247
        {
2248
            if (node == null)
2249
                return null;
2250
            CT_SdtContentRun ctObj = new CT_SdtContentRun();
2251
            foreach (XmlNode childNode in node.ChildNodes)
2252
            {
2253
                if (childNode.LocalName == "permStart")
2254
                {
2255
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
2256
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.permStart);
2257
                }
2258
                else if (childNode.LocalName == "moveToRangeEnd")
2259
                {
2260
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2261
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.moveToRangeEnd);
2262
                }
2263
                else if (childNode.LocalName == "moveToRangeStart")
2264
                {
2265
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
2266
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.moveToRangeStart);
2267
                }
2268
                else if (childNode.LocalName == "commentRangeEnd")
2269
                {
2270
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2271
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.commentRangeEnd);
2272
                }
2273
                else if (childNode.LocalName == "commentRangeStart")
2274
                {
2275
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2276
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.commentRangeStart);
2277
                }
2278
                else if (childNode.LocalName == "customXml")
2279
                {
2280
                    ctObj.Items.Add(CT_CustomXmlRun.Parse(childNode, namespaceManager));
2281
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXml);
2282
                }
2283
                else if (childNode.LocalName == "customXmlDelRangeEnd")
2284
                {
2285
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2286
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXmlDelRangeEnd);
2287
                }
2288
                else if (childNode.LocalName == "customXmlDelRangeStart")
2289
                {
2290
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2291
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXmlDelRangeStart);
2292
                }
2293
                else if (childNode.LocalName == "customXmlInsRangeEnd")
2294
                {
2295
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2296
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXmlInsRangeEnd);
2297
                }
2298
                else if (childNode.LocalName == "customXmlInsRangeStart")
2299
                {
2300
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2301
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXmlInsRangeStart);
2302
                }
2303
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
2304
                {
2305
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2306
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXmlMoveFromRangeEnd);
2307
                }
2308
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
2309
                {
2310
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2311
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXmlMoveFromRangeStart);
2312
                }
2313
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
2314
                {
2315
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2316
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXmlMoveToRangeEnd);
2317
                }
2318
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
2319
                {
2320
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2321
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.customXmlMoveToRangeStart);
2322
                }
2323
                else if (childNode.LocalName == "del")
2324
                {
2325
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2326
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.del);
2327
                }
2328
                else if (childNode.LocalName == "fldSimple")
2329
                {
2330
                    ctObj.Items.Add(CT_SimpleField.Parse(childNode, namespaceManager));
2331
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.fldSimple);
2332
                }
2333
                else if (childNode.LocalName == "hyperlink")
2334
                {
2335
                    ctObj.Items.Add(CT_Hyperlink1.Parse(childNode, namespaceManager));
2336
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.hyperlink);
2337
                }
2338
                else if (childNode.LocalName == "ins")
2339
                {
2340
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2341
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.ins);
2342
                }
2343
                else if (childNode.LocalName == "moveFrom")
2344
                {
2345
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2346
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.moveFrom);
2347
                }
2348
                else if (childNode.LocalName == "bookmarkStart")
2349
                {
2350
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
2351
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.bookmarkStart);
2352
                }
2353
                else if (childNode.LocalName == "moveFromRangeStart")
2354
                {
2355
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
2356
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.moveFromRangeStart);
2357
                }
2358
                else if (childNode.LocalName == "moveTo")
2359
                {
2360
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2361
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.moveTo);
2362
                }
2363
                else if (childNode.LocalName == "permEnd")
2364
                {
2365
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
2366
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.permEnd);
2367
                }
2368
                else if (childNode.LocalName == "oMath")
2369
                {
2370
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
2371
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.oMath);
2372
                }
2373
                else if (childNode.LocalName == "proofErr")
2374
                {
2375
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
2376
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.proofErr);
2377
                }
2378
                else if (childNode.LocalName == "r")
2379
                {
2380
                    ctObj.Items.Add(CT_R.Parse(childNode, namespaceManager));
2381
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.r);
2382
                }
2383
                else if (childNode.LocalName == "sdt")
2384
                {
2385
                    ctObj.Items.Add(CT_SdtRun.Parse(childNode, namespaceManager));
2386
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.sdt);
2387
                }
2388
                else if (childNode.LocalName == "smartTag")
2389
                {
2390
                    ctObj.Items.Add(CT_SmartTagRun.Parse(childNode, namespaceManager));
2391
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.smartTag);
2392
                }
2393
                else if (childNode.LocalName == "subDoc")
2394
                {
2395
                    ctObj.Items.Add(CT_Rel.Parse(childNode, namespaceManager));
2396
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.subDoc);
2397
                }
2398
                else if (childNode.LocalName == "moveFromRangeEnd")
2399
                {
2400
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2401
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.moveFromRangeEnd);
2402
                }
2403
                else if (childNode.LocalName == "oMathPara")
2404
                {
2405
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
2406
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.oMathPara);
2407
                }
2408
                else if (childNode.LocalName == "bookmarkEnd")
2409
                {
2410
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2411
                    ctObj.ItemsElementName.Add(ItemsChoiceType18.bookmarkEnd);
2412
                }
2413
            }
2414
            return ctObj;
2415
        }
2416

2417
        internal void Write(StreamWriter sw, string nodeName)
2418
        {
2419
            sw.Write(string.Format("<w:{0}", nodeName));
2420
            sw.Write(">");
2421
            foreach (object o in this.Items)
2422
            {
2423
                if (o is CT_PermStart)
2424
                    ((CT_PermStart)o).Write(sw, "permStart");
2425
                else if (o is CT_MarkupRange)
2426
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
2427
                else if (o is CT_MoveBookmark)
2428
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
2429
                else if (o is CT_MarkupRange)
2430
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
2431
                else if (o is CT_MarkupRange)
2432
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
2433
                else if (o is CT_CustomXmlRun)
2434
                    ((CT_CustomXmlRun)o).Write(sw, "customXml");
2435
                else if (o is CT_Markup)
2436
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
2437
                else if (o is CT_TrackChange)
2438
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
2439
                else if (o is CT_Markup)
2440
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
2441
                else if (o is CT_TrackChange)
2442
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
2443
                else if (o is CT_Markup)
2444
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
2445
                else if (o is CT_TrackChange)
2446
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
2447
                else if (o is CT_Markup)
2448
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
2449
                else if (o is CT_TrackChange)
2450
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
2451
                else if (o is CT_RunTrackChange)
2452
                    ((CT_RunTrackChange)o).Write(sw, "del");
2453
                else if (o is CT_SimpleField)
2454
                    ((CT_SimpleField)o).Write(sw, "fldSimple");
2455
                else if (o is CT_Hyperlink1)
2456
                    ((CT_Hyperlink1)o).Write(sw, "hyperlink");
2457
                else if (o is CT_RunTrackChange)
2458
                    ((CT_RunTrackChange)o).Write(sw, "ins");
2459
                else if (o is CT_RunTrackChange)
2460
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
2461
                else if (o is CT_Bookmark)
2462
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
2463
                else if (o is CT_MoveBookmark)
2464
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
2465
                else if (o is CT_RunTrackChange)
2466
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
2467
                else if (o is CT_Perm)
2468
                    ((CT_Perm)o).Write(sw, "permEnd");
2469
                else if (o is CT_OMath)
2470
                    ((CT_OMath)o).Write(sw, "oMath");
2471
                else if (o is CT_ProofErr)
2472
                    ((CT_ProofErr)o).Write(sw, "proofErr");
2473
                else if (o is CT_R)
2474
                    ((CT_R)o).Write(sw, "r");
2475
                else if (o is CT_SdtRun)
2476
                    ((CT_SdtRun)o).Write(sw, "sdt");
2477
                else if (o is CT_SmartTagRun)
2478
                    ((CT_SmartTagRun)o).Write(sw, "smartTag");
2479
                else if (o is CT_Rel)
2480
                    ((CT_Rel)o).Write(sw, "subDoc");
2481
                else if (o is CT_MarkupRange)
2482
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
2483
                else if (o is CT_OMathPara)
2484
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
2485
                else if (o is CT_MarkupRange)
2486
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
2487
            }
2488
            sw.WriteEndW(nodeName);
2489
        }
2490

2491
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2492
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2493
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 0)]
2494
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 0)]
2495
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 0)]
2496
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 0)]
2497
        [XmlElement("customXml", typeof(CT_CustomXmlRun), Order = 0)]
2498
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 0)]
2499
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 0)]
2500
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 0)]
2501
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 0)]
2502
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 0)]
2503
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 0)]
2504
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 0)]
2505
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 0)]
2506
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 0)]
2507
        [XmlElement("fldSimple", typeof(CT_SimpleField), Order = 0)]
2508
        [XmlElement("hyperlink", typeof(CT_Hyperlink1), Order = 0)]
2509
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 0)]
2510
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 0)]
2511
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 0)]
2512
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 0)]
2513
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 0)]
2514
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 0)]
2515
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 0)]
2516
        [XmlElement("permEnd", typeof(CT_Perm), Order = 0)]
2517
        [XmlElement("permStart", typeof(CT_PermStart), Order = 0)]
2518
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 0)]
2519
        [XmlElement("r", typeof(CT_R), Order = 0)]
2520
        [XmlElement("sdt", typeof(CT_SdtRun), Order = 0)]
2521
        [XmlElement("smartTag", typeof(CT_SmartTagRun), Order = 0)]
2522
        [XmlElement("subDoc", typeof(CT_Rel), Order = 0)]
2523
        [XmlChoiceIdentifier("ItemsElementName")]
2524
        public ArrayList Items
2525
        {
2526
            get
2527
            {
2528
                return this.itemsField;
2529
            }
2530
            set
2531
            {
2532
                this.itemsField = value;
2533
            }
2534
        }
2535

2536
        [XmlElement("ItemsElementName", Order = 1)]
2537
        [XmlIgnore]
2538
        public List<ItemsChoiceType18> ItemsElementName
2539
        {
2540
            get
2541
            {
2542
                return this.itemsElementNameField;
2543
            }
2544
            set
2545
            {
2546
                this.itemsElementNameField = value;
2547
            }
2548
        }
2549

2550
        public IEnumerable<CT_R> GetRList()
2551
        {
2552
            return GetObjectList<CT_R>(ItemsChoiceType18.r);
2553
        }
2554
        #region Generic methods for object operation
2555

2556
        private List<T> GetObjectList<T>(ItemsChoiceType18 type) where T : class
2557
        {
2558
            lock (this)
2559
            {
2560
                List<T> list = new List<T>();
2561
                for (int i = 0; i < itemsElementNameField.Count; i++)
2562
                {
2563
                    if (itemsElementNameField[i] == type)
2564
                        list.Add(itemsField[i] as T);
2565
                }
2566
                return list;
2567
            }
2568
        }
2569
        private int SizeOfArray(ItemsChoiceType18 type)
2570
        {
2571
            lock (this)
2572
            {
2573
                int size = 0;
2574
                for (int i = 0; i < itemsElementNameField.Count; i++)
2575
                {
2576
                    if (itemsElementNameField[i] == type)
2577
                        size++;
2578
                }
2579
                return size;
2580
            }
2581
        }
2582
        private T GetObjectArray<T>(int p, ItemsChoiceType18 type) where T : class
2583
        {
2584
            lock (this)
2585
            {
2586
                int pos = GetObjectIndex(type, p);
2587
                if (pos < 0 || pos >= this.itemsField.Count)
2588
                    return null;
2589
                return itemsField[pos] as T;
2590
            }
2591
        }
2592
        private T InsertNewObject<T>(ItemsChoiceType18 type, int p) where T : class, new()
2593
        {
2594
            T t = new T();
2595
            lock (this)
2596
            {
2597
                int pos = GetObjectIndex(type, p);
2598
                this.itemsElementNameField.Insert(pos, type);
2599
                this.itemsField.Insert(pos, t);
2600
            }
2601
            return t;
2602
        }
2603
        private T AddNewObject<T>(ItemsChoiceType18 type) where T : class, new()
2604
        {
2605
            T t = new T();
2606
            lock (this)
2607
            {
2608
                this.itemsElementNameField.Add(type);
2609
                this.itemsField.Add(t);
2610
            }
2611
            return t;
2612
        }
2613
        private void SetObject<T>(ItemsChoiceType18 type, int p, T obj) where T : class
2614
        {
2615
            lock (this)
2616
            {
2617
                int pos = GetObjectIndex(type, p);
2618
                if (pos < 0 || pos >= this.itemsField.Count)
2619
                    return;
2620
                if (this.itemsField[pos] is T)
2621
                    this.itemsField[pos] = obj;
2622
                else
2623
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
2624
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
2625
            }
2626
        }
2627
        private int GetObjectIndex(ItemsChoiceType18 type, int p)
2628
        {
2629
            int index = -1;
2630
            int pos = 0;
2631
            for (int i = 0; i < itemsElementNameField.Count; i++)
2632
            {
2633
                if (itemsElementNameField[i] == type)
2634
                {
2635
                    if (pos == p)
2636
                    {
2637
                        index = i;
2638
                        break;
2639
                    }
2640
                    else
2641
                        pos++;
2642
                }
2643
            }
2644
            return index;
2645
        }
2646
        private void RemoveObject(ItemsChoiceType18 type, int p)
2647
        {
2648
            lock (this)
2649
            {
2650
                int pos = GetObjectIndex(type, p);
2651
                if (pos < 0 || pos >= this.itemsField.Count)
2652
                    return;
2653
                itemsElementNameField.RemoveAt(pos);
2654
                itemsField.RemoveAt(pos);
2655
            }
2656
        }
2657
        #endregion
2658
    }
2659

2660
    [Serializable]
2661
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
2662
    public enum ItemsChoiceType18
2663
    {
2664

2665
    
2666
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
2667
        oMath,
2668

2669
    
2670
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
2671
        oMathPara,
2672

2673
    
2674
        bookmarkEnd,
2675

2676
    
2677
        bookmarkStart,
2678

2679
    
2680
        commentRangeEnd,
2681

2682
    
2683
        commentRangeStart,
2684

2685
    
2686
        customXml,
2687

2688
    
2689
        customXmlDelRangeEnd,
2690

2691
    
2692
        customXmlDelRangeStart,
2693

2694
    
2695
        customXmlInsRangeEnd,
2696

2697
    
2698
        customXmlInsRangeStart,
2699

2700
    
2701
        customXmlMoveFromRangeEnd,
2702

2703
    
2704
        customXmlMoveFromRangeStart,
2705

2706
    
2707
        customXmlMoveToRangeEnd,
2708

2709
    
2710
        customXmlMoveToRangeStart,
2711

2712
    
2713
        del,
2714

2715
    
2716
        fldSimple,
2717

2718
    
2719
        hyperlink,
2720

2721
    
2722
        ins,
2723

2724
    
2725
        moveFrom,
2726

2727
    
2728
        moveFromRangeEnd,
2729

2730
    
2731
        moveFromRangeStart,
2732

2733
    
2734
        moveTo,
2735

2736
    
2737
        moveToRangeEnd,
2738

2739
    
2740
        moveToRangeStart,
2741

2742
    
2743
        permEnd,
2744

2745
    
2746
        permStart,
2747

2748
    
2749
        proofErr,
2750

2751
    
2752
        r,
2753

2754
    
2755
        sdt,
2756

2757
    
2758
        smartTag,
2759

2760
    
2761
        subDoc,
2762
    }
2763

2764
    [Serializable]
2765

2766
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2767
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2768
    public class CT_SdtListItem
2769
    {
2770

2771
        private string displayTextField;
2772

2773
        private string valueField;
2774
        public static CT_SdtListItem Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2775
        {
2776
            if (node == null)
2777
                return null;
2778
            CT_SdtListItem ctObj = new CT_SdtListItem();
2779
            ctObj.displayText = XmlHelper.ReadString(node.Attributes["w:displayText"]);
2780
            ctObj.value = XmlHelper.ReadString(node.Attributes["w:value"]);
2781
            return ctObj;
2782
        }
2783

2784

2785

2786
        internal void Write(StreamWriter sw, string nodeName)
2787
        {
2788
            sw.Write(string.Format("<w:{0}", nodeName));
2789
            XmlHelper.WriteAttribute(sw, "w:displayText", this.displayText);
2790
            XmlHelper.WriteAttribute(sw, "w:value", this.value);
2791
            sw.Write(">");
2792
            sw.WriteEndW(nodeName);
2793
        }
2794

2795
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2796
        public string displayText
2797
        {
2798
            get
2799
            {
2800
                return this.displayTextField;
2801
            }
2802
            set
2803
            {
2804
                this.displayTextField = value;
2805
            }
2806
        }
2807

2808
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2809
        public string value
2810
        {
2811
            get
2812
            {
2813
                return this.valueField;
2814
            }
2815
            set
2816
            {
2817
                this.valueField = value;
2818
            }
2819
        }
2820
    }
2821

2822

2823
    [Serializable]
2824

2825
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2826
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2827
    public class CT_SdtDateMappingType
2828
    {
2829

2830
        private ST_SdtDateMappingType valField;
2831

2832
        private bool valFieldSpecified;
2833
        public static CT_SdtDateMappingType Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2834
        {
2835
            if (node == null)
2836
                return null;
2837
            CT_SdtDateMappingType ctObj = new CT_SdtDateMappingType();
2838
            if (node.Attributes["w:val"] != null)
2839
                ctObj.val = (ST_SdtDateMappingType)Enum.Parse(typeof(ST_SdtDateMappingType), node.Attributes["w:val"].Value);
2840
            return ctObj;
2841
        }
2842

2843

2844

2845
        internal void Write(StreamWriter sw, string nodeName)
2846
        {
2847
            sw.Write(string.Format("<w:{0}", nodeName));
2848
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
2849
            sw.Write(">");
2850
            sw.WriteEndW(nodeName);
2851
        }
2852

2853
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2854
        public ST_SdtDateMappingType val
2855
        {
2856
            get
2857
            {
2858
                return this.valField;
2859
            }
2860
            set
2861
            {
2862
                this.valField = value;
2863
            }
2864
        }
2865

2866
        [XmlIgnore]
2867
        public bool valSpecified
2868
        {
2869
            get
2870
            {
2871
                return this.valFieldSpecified;
2872
            }
2873
            set
2874
            {
2875
                this.valFieldSpecified = value;
2876
            }
2877
        }
2878
    }
2879

2880

2881
    [Serializable]
2882
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2883
    public enum ST_SdtDateMappingType
2884
    {
2885

2886
    
2887
        text,
2888

2889
    
2890
        date,
2891

2892
    
2893
        dateTime,
2894
    }
2895

2896

2897
    [Serializable]
2898

2899
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2900
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2901
    public class CT_CalendarType
2902
    {
2903

2904
        private ST_CalendarType valField;
2905

2906
        private bool valFieldSpecified;
2907

2908
        public static CT_CalendarType Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2909
        {
2910
            if (node == null)
2911
                return null;
2912
            CT_CalendarType ctObj = new CT_CalendarType();
2913
            if (node.Attributes["w:val"] != null)
2914
                ctObj.val = (ST_CalendarType)Enum.Parse(typeof(ST_CalendarType), node.Attributes["w:val"].Value);
2915
            return ctObj;
2916
        }
2917

2918

2919

2920
        internal void Write(StreamWriter sw, string nodeName)
2921
        {
2922
            sw.Write(string.Format("<w:{0}", nodeName));
2923
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
2924
            sw.Write(">");
2925
            sw.WriteEndW(nodeName);
2926
        }
2927

2928

2929
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2930
        public ST_CalendarType val
2931
        {
2932
            get
2933
            {
2934
                return this.valField;
2935
            }
2936
            set
2937
            {
2938
                this.valField = value;
2939
            }
2940
        }
2941

2942
        [XmlIgnore]
2943
        public bool valSpecified
2944
        {
2945
            get
2946
            {
2947
                return this.valFieldSpecified;
2948
            }
2949
            set
2950
            {
2951
                this.valFieldSpecified = value;
2952
            }
2953
        }
2954
    }
2955

2956

2957
    [Serializable]
2958
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2959
    public enum ST_CalendarType
2960
    {
2961

2962
    
2963
        gregorian,
2964

2965
    
2966
        hijri,
2967

2968
    
2969
        hebrew,
2970

2971
    
2972
        taiwan,
2973

2974
    
2975
        japan,
2976

2977
    
2978
        thai,
2979

2980
    
2981
        korea,
2982

2983
    
2984
        saka,
2985

2986
    
2987
        gregorianXlitEnglish,
2988

2989
    
2990
        gregorianXlitFrench,
2991
    }
2992

2993

2994
    [Serializable]
2995

2996
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2997
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2998
    public class CT_SdtDate
2999
    {
3000

3001
        private CT_String dateFormatField;
3002

3003
        private CT_Lang lidField;
3004

3005
        private CT_SdtDateMappingType storeMappedDataAsField;
3006

3007
        private CT_CalendarType calendarField;
3008

3009
        private string fullDateField;
3010

3011
        private bool fullDateFieldSpecified;
3012

3013
        public CT_SdtDate()
3014
        {
3015
            //this.calendarField = new CT_CalendarType();
3016
            //this.storeMappedDataAsField = new CT_SdtDateMappingType();
3017
            //this.lidField = new CT_Lang();
3018
            //this.dateFormatField = new CT_String();
3019
        }
3020
        public static CT_SdtDate Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3021
        {
3022
            if (node == null)
3023
                return null;
3024
            CT_SdtDate ctObj = new CT_SdtDate();
3025
            ctObj.fullDateField = XmlHelper.ReadString(node.Attributes["w.fullDate"]);
3026
            foreach (XmlNode childNode in node.ChildNodes)
3027
            {
3028
                if (childNode.LocalName == "dateFormat")
3029
                    ctObj.dateFormat = CT_String.Parse(childNode, namespaceManager);
3030
                else if (childNode.LocalName == "lid")
3031
                    ctObj.lid = CT_Lang.Parse(childNode, namespaceManager);
3032
                else if (childNode.LocalName == "storeMappedDataAs")
3033
                    ctObj.storeMappedDataAs = CT_SdtDateMappingType.Parse(childNode, namespaceManager);
3034
                else if (childNode.LocalName == "calendar")
3035
                    ctObj.calendar = CT_CalendarType.Parse(childNode, namespaceManager);
3036
            }
3037
            return ctObj;
3038
        }
3039

3040

3041

3042
        internal void Write(StreamWriter sw, string nodeName)
3043
        {
3044
            sw.Write(string.Format("<w:{0}", nodeName));
3045
            XmlHelper.WriteAttribute(sw, "w:fullDate", this.fullDateField);
3046
            sw.Write(">");
3047
            if (this.dateFormat != null)
3048
                this.dateFormat.Write(sw, "dateFormat");
3049
            if (this.lid != null)
3050
                this.lid.Write(sw, "lid");
3051
            if (this.storeMappedDataAs != null)
3052
                this.storeMappedDataAs.Write(sw, "storeMappedDataAs");
3053
            if (this.calendar != null)
3054
                this.calendar.Write(sw, "calendar");
3055
            sw.WriteEndW(nodeName);
3056
        }
3057

3058
        [XmlElement(Order = 0)]
3059
        public CT_String dateFormat
3060
        {
3061
            get
3062
            {
3063
                return this.dateFormatField;
3064
            }
3065
            set
3066
            {
3067
                this.dateFormatField = value;
3068
            }
3069
        }
3070

3071
        [XmlElement(Order = 1)]
3072
        public CT_Lang lid
3073
        {
3074
            get
3075
            {
3076
                return this.lidField;
3077
            }
3078
            set
3079
            {
3080
                this.lidField = value;
3081
            }
3082
        }
3083

3084
        [XmlElement(Order = 2)]
3085
        public CT_SdtDateMappingType storeMappedDataAs
3086
        {
3087
            get
3088
            {
3089
                return this.storeMappedDataAsField;
3090
            }
3091
            set
3092
            {
3093
                this.storeMappedDataAsField = value;
3094
            }
3095
        }
3096

3097
        [XmlElement(Order = 3)]
3098
        public CT_CalendarType calendar
3099
        {
3100
            get
3101
            {
3102
                return this.calendarField;
3103
            }
3104
            set
3105
            {
3106
                this.calendarField = value;
3107
            }
3108
        }
3109

3110
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3111
        public string fullDate
3112
        {
3113
            get
3114
            {
3115
                return this.fullDateField;
3116
            }
3117
            set
3118
            {
3119
                this.fullDateField = value;
3120
            }
3121
        }
3122

3123
        [XmlIgnore]
3124
        public bool fullDateSpecified
3125
        {
3126
            get
3127
            {
3128
                return this.fullDateFieldSpecified;
3129
            }
3130
            set
3131
            {
3132
                this.fullDateFieldSpecified = value;
3133
            }
3134
        }
3135
    }
3136
    [Serializable]
3137

3138
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3139
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
3140
    public class CT_SdtRow
3141
    {
3142

3143
        private CT_SdtPr sdtPrField;
3144

3145
        private List<CT_RPr> sdtEndPrField;
3146

3147
        private CT_SdtContentRow sdtContentField;
3148

3149
        public CT_SdtRow()
3150
        {
3151
            //this.sdtContentField = new CT_SdtContentRow();
3152
            //this.sdtEndPrField = new List<CT_RPr>();
3153
            //this.sdtPrField = new CT_SdtPr();
3154
        }
3155

3156
        public static CT_SdtRow Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3157
        {
3158
            if (node == null)
3159
                return null;
3160
            CT_SdtRow ctObj = new CT_SdtRow();
3161
            ctObj.sdtEndPr = new List<CT_RPr>();
3162
            foreach (XmlNode childNode in node.ChildNodes)
3163
            {
3164
                if (childNode.LocalName == "sdtPr")
3165
                    ctObj.sdtPr = CT_SdtPr.Parse(childNode, namespaceManager);
3166
                else if (childNode.LocalName == "sdtContent")
3167
                    ctObj.sdtContent = CT_SdtContentRow.Parse(childNode, namespaceManager);
3168
                else if (childNode.LocalName == "sdtEndPr")
3169
                    ctObj.sdtEndPr.Add(CT_RPr.Parse(childNode, namespaceManager));
3170
            }
3171
            return ctObj;
3172
        }
3173

3174

3175

3176
        internal void Write(StreamWriter sw, string nodeName)
3177
        {
3178
            sw.Write(string.Format("<w:{0}", nodeName));
3179
            sw.Write(">");
3180
            if (this.sdtPr != null)
3181
                this.sdtPr.Write(sw, "sdtPr");
3182
            if (this.sdtContent != null)
3183
                this.sdtContent.Write(sw, "sdtContent");
3184
            if (this.sdtEndPr != null)
3185
            {
3186
                foreach (CT_RPr x in this.sdtEndPr)
3187
                {
3188
                    x.Write(sw, "sdtEndPr");
3189
                }
3190
            }
3191
            sw.WriteEndW(nodeName);
3192
        }
3193

3194
        [XmlElement(Order = 0)]
3195
        public CT_SdtPr sdtPr
3196
        {
3197
            get
3198
            {
3199
                return this.sdtPrField;
3200
            }
3201
            set
3202
            {
3203
                this.sdtPrField = value;
3204
            }
3205
        }
3206

3207
        [XmlArray(Order = 1)]
3208
        [XmlArrayItem("rPr", IsNullable = false)]
3209
        public List<CT_RPr> sdtEndPr
3210
        {
3211
            get
3212
            {
3213
                return this.sdtEndPrField;
3214
            }
3215
            set
3216
            {
3217
                this.sdtEndPrField = value;
3218
            }
3219
        }
3220

3221
        [XmlElement(Order = 2)]
3222
        public CT_SdtContentRow sdtContent
3223
        {
3224
            get
3225
            {
3226
                return this.sdtContentField;
3227
            }
3228
            set
3229
            {
3230
                this.sdtContentField = value;
3231
            }
3232
        }
3233
    }
3234
    [Serializable]
3235

3236
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3237
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
3238
    public class CT_SdtText
3239
    {
3240

3241
        private ST_OnOff multiLineField;
3242

3243
        private bool multiLineFieldSpecified;
3244
        public static CT_SdtText Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3245
        {
3246
            if (node == null)
3247
                return null;
3248
            CT_SdtText ctObj = new CT_SdtText();
3249
            if (node.Attributes["w:multiLine"] != null)
3250
                ctObj.multiLine = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:multiLine"].Value,true);
3251
            return ctObj;
3252
        }
3253

3254

3255

3256
        internal void Write(StreamWriter sw, string nodeName)
3257
        {
3258
            sw.Write(string.Format("<w:{0}", nodeName));
3259
            XmlHelper.WriteAttribute(sw, "w:multiLine", this.multiLine.ToString());
3260
            sw.Write(">");
3261
            sw.WriteEndW(nodeName);
3262
        }
3263

3264
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3265
        public ST_OnOff multiLine
3266
        {
3267
            get
3268
            {
3269
                return this.multiLineField;
3270
            }
3271
            set
3272
            {
3273
                this.multiLineField = value;
3274
            }
3275
        }
3276

3277
        [XmlIgnore]
3278
        public bool multiLineSpecified
3279
        {
3280
            get
3281
            {
3282
                return this.multiLineFieldSpecified;
3283
            }
3284
            set
3285
            {
3286
                this.multiLineFieldSpecified = value;
3287
            }
3288
        }
3289
    }
3290

3291
    [Serializable]
3292

3293
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3294
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
3295
    public class CT_Lock
3296
    {
3297
        public static CT_Lock Parse(XmlNode node, XmlNamespaceManager namespaceManager)
3298
        {
3299
            if (node == null)
3300
                return null;
3301
            CT_Lock ctObj = new CT_Lock();
3302
            if (node.Attributes["w:val"] != null)
3303
                ctObj.val = (ST_Lock)Enum.Parse(typeof(ST_Lock), node.Attributes["w:val"].Value);
3304
            return ctObj;
3305
        }
3306

3307

3308

3309
        internal void Write(StreamWriter sw, string nodeName)
3310
        {
3311
            sw.Write(string.Format("<w:{0}", nodeName));
3312
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
3313
            sw.Write(">");
3314
            sw.WriteEndW(nodeName);
3315
        }
3316

3317
        private ST_Lock valField;
3318

3319
        private bool valFieldSpecified;
3320

3321
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
3322
        public ST_Lock val
3323
        {
3324
            get
3325
            {
3326
                return this.valField;
3327
            }
3328
            set
3329
            {
3330
                this.valField = value;
3331
            }
3332
        }
3333

3334
        [XmlIgnore]
3335
        public bool valSpecified
3336
        {
3337
            get
3338
            {
3339
                return this.valFieldSpecified;
3340
            }
3341
            set
3342
            {
3343
                this.valFieldSpecified = value;
3344
            }
3345
        }
3346
    }
3347

3348

3349
    [Serializable]
3350
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
3351
    public enum ST_Lock
3352
    {
3353

3354
    
3355
        sdtLocked,
3356

3357
    
3358
        contentLocked,
3359

3360
    
3361
        unlocked,
3362

3363
    
3364
        sdtContentLocked,
3365
    }
3366
}