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
namespace NPOI.OpenXmlFormats.Wordprocessing
11
{
12

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

19
        private CT_CustomXmlPr customXmlPrField;
20

21
        private ArrayList itemsField;
22

23
        private List<ItemsChoiceType21> itemsElementNameField;
24

25
        private string uriField;
26

27
        private string elementField;
28

29
        public CT_CustomXmlRow()
30
        {
31
            this.itemsElementNameField = new List<ItemsChoiceType21>();
32
            this.itemsField = new ArrayList();
33
            //this.customXmlPrField = new CT_CustomXmlPr();
34
        }
35

36
        public static CT_CustomXmlRow Parse(XmlNode node, XmlNamespaceManager namespaceManager)
37
        {
38
            if (node == null)
39
                return null;
40
            CT_CustomXmlRow ctObj = new CT_CustomXmlRow();
41
            ctObj.uri = XmlHelper.ReadString(node.Attributes["w:uri"]);
42
            ctObj.element = XmlHelper.ReadString(node.Attributes["w:element"]);
43

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

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

264
        [XmlElement(Order = 0)]
265
        public CT_CustomXmlPr customXmlPr
266
        {
267
            get
268
            {
269
                return this.customXmlPrField;
270
            }
271
            set
272
            {
273
                this.customXmlPrField = value;
274
            }
275
        }
276

277
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
278
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
279
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 1)]
280
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 1)]
281
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 1)]
282
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 1)]
283
        [XmlElement("customXml", typeof(CT_CustomXmlRow), Order = 1)]
284
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 1)]
285
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 1)]
286
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 1)]
287
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 1)]
288
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 1)]
289
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 1)]
290
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 1)]
291
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 1)]
292
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 1)]
293
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 1)]
294
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 1)]
295
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 1)]
296
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 1)]
297
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 1)]
298
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 1)]
299
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 1)]
300
        [XmlElement("permEnd", typeof(CT_Perm), Order = 1)]
301
        [XmlElement("permStart", typeof(CT_PermStart), Order = 1)]
302
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 1)]
303
        [XmlElement("sdt", typeof(CT_SdtRow), Order = 1)]
304
        [XmlElement("tr", typeof(CT_Row), Order = 1)]
305
        [XmlChoiceIdentifier("ItemsElementName")]
306
        public ArrayList Items
307
        {
308
            get
309
            {
310
                return this.itemsField;
311
            }
312
            set
313
            {
314
                this.itemsField = value;
315
            }
316
        }
317

318
        [XmlElement("ItemsElementName", Order = 2)]
319
        [XmlIgnore]
320
        public List<ItemsChoiceType21> ItemsElementName
321
        {
322
            get
323
            {
324
                return this.itemsElementNameField;
325
            }
326
            set
327
            {
328
                this.itemsElementNameField = value;
329
            }
330
        }
331

332
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
333
        public string uri
334
        {
335
            get
336
            {
337
                return this.uriField;
338
            }
339
            set
340
            {
341
                this.uriField = value;
342
            }
343
        }
344

345
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
346
        public string element
347
        {
348
            get
349
            {
350
                return this.elementField;
351
            }
352
            set
353
            {
354
                this.elementField = value;
355
            }
356
        }
357
    }
358

359

360
    [Serializable]
361

362
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
363
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
364
    public class CT_CustomXmlPr
365
    {
366

367
        private CT_String placeholderField;
368

369
        private List<CT_Attr> attrField;
370

371
        public CT_CustomXmlPr()
372
        {            //this.attrField = new List<CT_Attr>();
373
            //this.placeholderField = new CT_String();
374

375
        }
376
        public static CT_CustomXmlPr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
377
        {
378
            if (node == null)
379
                return null;
380
            CT_CustomXmlPr ctObj = new CT_CustomXmlPr();
381
            ctObj.attr = new List<CT_Attr>();
382
            foreach (XmlNode childNode in node.ChildNodes)
383
            {
384
                if (childNode.LocalName == "placeholder")
385
                    ctObj.placeholder = CT_String.Parse(childNode, namespaceManager);
386
                else if (childNode.LocalName == "attr")
387
                    ctObj.attr.Add(CT_Attr.Parse(childNode, namespaceManager));
388
            }
389
            return ctObj;
390
        }
391

392

393

394
        internal void Write(StreamWriter sw, string nodeName)
395
        {
396
            sw.Write(string.Format("<w:{0}", nodeName));
397
            sw.Write(">");
398
            if (this.placeholder != null)
399
                this.placeholder.Write(sw, "placeholder");
400
            if (this.attr != null)
401
            {
402
                foreach (CT_Attr x in this.attr)
403
                {
404
                    x.Write(sw, "attr");
405
                }
406
            }
407
            sw.WriteEndW(nodeName);
408
        }
409

410
        [XmlElement(Order = 0)]
411
        public CT_String placeholder
412
        {
413
            get
414
            {
415
                return this.placeholderField;
416
            }
417
            set
418
            {
419
                this.placeholderField = value;
420
            }
421
        }
422

423
        [XmlElement("attr", Order = 1)]
424
        public List<CT_Attr> attr
425
        {
426
            get
427
            {
428
                return this.attrField;
429
            }
430
            set
431
            {
432
                this.attrField = value;
433
            }
434
        }
435
    }
436

437

438
    [Serializable]
439

440
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
441
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
442
    public class CT_Attr
443
    {
444

445
        private string uriField;
446

447
        private string nameField;
448

449
        private string valField;
450
        public static CT_Attr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
451
        {
452
            if (node == null)
453
                return null;
454
            CT_Attr ctObj = new CT_Attr();
455
            ctObj.uri = XmlHelper.ReadString(node.Attributes["w:uri"]);
456
            ctObj.name = XmlHelper.ReadString(node.Attributes["w:name"]);
457
            ctObj.val = XmlHelper.ReadString(node.Attributes["w:val"]);
458
            return ctObj;
459
        }
460

461

462

463
        internal void Write(StreamWriter sw, string nodeName)
464
        {
465
            sw.Write(string.Format("<w:{0}", nodeName));
466
            XmlHelper.WriteAttribute(sw, "w:uri", this.uri);
467
            XmlHelper.WriteAttribute(sw, "w:name", this.name);
468
            XmlHelper.WriteAttribute(sw, "w:val", this.val);
469
            sw.Write(">");
470
            sw.WriteEndW(nodeName);
471
        }
472

473
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
474
        public string uri
475
        {
476
            get
477
            {
478
                return this.uriField;
479
            }
480
            set
481
            {
482
                this.uriField = value;
483
            }
484
        }
485

486
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
487
        public string name
488
        {
489
            get
490
            {
491
                return this.nameField;
492
            }
493
            set
494
            {
495
                this.nameField = value;
496
            }
497
        }
498

499
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
500
        public string val
501
        {
502
            get
503
            {
504
                return this.valField;
505
            }
506
            set
507
            {
508
                this.valField = value;
509
            }
510
        }
511
    }
512

513

514

515
    [Serializable]
516
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
517
    public enum ItemsChoiceType21
518
    {
519

520

521
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
522
        oMath,
523

524

525
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
526
        oMathPara,
527

528

529
        bookmarkEnd,
530

531

532
        bookmarkStart,
533

534

535
        commentRangeEnd,
536

537

538
        commentRangeStart,
539

540

541
        customXml,
542

543

544
        customXmlDelRangeEnd,
545

546

547
        customXmlDelRangeStart,
548

549

550
        customXmlInsRangeEnd,
551

552

553
        customXmlInsRangeStart,
554

555

556
        customXmlMoveFromRangeEnd,
557

558

559
        customXmlMoveFromRangeStart,
560

561

562
        customXmlMoveToRangeEnd,
563

564

565
        customXmlMoveToRangeStart,
566

567

568
        del,
569

570

571
        ins,
572

573

574
        moveFrom,
575

576

577
        moveFromRangeEnd,
578

579

580
        moveFromRangeStart,
581

582

583
        moveTo,
584

585

586
        moveToRangeEnd,
587

588

589
        moveToRangeStart,
590

591

592
        permEnd,
593

594

595
        permStart,
596

597

598
        proofErr,
599

600

601
        sdt,
602

603

604
        tr,
605
    }
606

607
    [Serializable]
608
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
609
    public enum ItemsChoiceType22
610
    {
611

612

613
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
614
        oMath,
615

616

617
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
618
        oMathPara,
619

620

621
        bookmarkEnd,
622

623

624
        bookmarkStart,
625

626

627
        commentRangeEnd,
628

629

630
        commentRangeStart,
631

632

633
        customXml,
634

635

636
        customXmlDelRangeEnd,
637

638

639
        customXmlDelRangeStart,
640

641

642
        customXmlInsRangeEnd,
643

644

645
        customXmlInsRangeStart,
646

647

648
        customXmlMoveFromRangeEnd,
649

650

651
        customXmlMoveFromRangeStart,
652

653

654
        customXmlMoveToRangeEnd,
655

656

657
        customXmlMoveToRangeStart,
658

659

660
        del,
661

662

663
        ins,
664

665

666
        moveFrom,
667

668

669
        moveFromRangeEnd,
670

671

672
        moveFromRangeStart,
673

674

675
        moveTo,
676

677

678
        moveToRangeEnd,
679

680

681
        moveToRangeStart,
682

683

684
        permEnd,
685

686

687
        permStart,
688

689

690
        proofErr,
691

692

693
        sdt,
694

695

696
        tr,
697
    }
698

699

700

701
    [Serializable]
702

703
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
704
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
705
    public class CT_CustomXmlRun
706
    {
707

708
        private CT_CustomXmlPr customXmlPrField;
709

710
        private ArrayList itemsField;
711

712
        private List<ItemsChoiceType24> itemsElementNameField;
713

714
        private string uriField;
715

716
        private string elementField;
717

718
        public CT_CustomXmlRun()
719
        {
720
            this.itemsElementNameField = new List<ItemsChoiceType24>();
721
            this.itemsField = new ArrayList();
722
            //this.customXmlPrField = new CT_CustomXmlPr();
723
        }
724

725
        [XmlElement(Order = 0)]
726
        public CT_CustomXmlPr customXmlPr
727
        {
728
            get
729
            {
730
                return this.customXmlPrField;
731
            }
732
            set
733
            {
734
                this.customXmlPrField = value;
735
            }
736
        }
737

738
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
739
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
740
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 1)]
741
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 1)]
742
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 1)]
743
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 1)]
744
        [XmlElement("customXml", typeof(CT_CustomXmlRun), Order = 1)]
745
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 1)]
746
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 1)]
747
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 1)]
748
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 1)]
749
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 1)]
750
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 1)]
751
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 1)]
752
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 1)]
753
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 1)]
754
        [XmlElement("fldSimple", typeof(CT_SimpleField), Order = 1)]
755
        [XmlElement("hyperlink", typeof(CT_Hyperlink1), Order = 1)]
756
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 1)]
757
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 1)]
758
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 1)]
759
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 1)]
760
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 1)]
761
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 1)]
762
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 1)]
763
        [XmlElement("permEnd", typeof(CT_Perm), Order = 1)]
764
        [XmlElement("permStart", typeof(CT_PermStart), Order = 1)]
765
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 1)]
766
        [XmlElement("r", typeof(CT_R), Order = 1)]
767
        [XmlElement("sdt", typeof(CT_SdtRun), Order = 1)]
768
        [XmlElement("smartTag", typeof(CT_SmartTagRun), Order = 1)]
769
        [XmlElement("subDoc", typeof(CT_Rel), Order = 1)]
770
        [XmlChoiceIdentifier("ItemsElementName")]
771
        public ArrayList Items
772
        {
773
            get
774
            {
775
                return this.itemsField;
776
            }
777
            set
778
            {
779
                this.itemsField = value;
780
            }
781
        }
782

783
        [XmlElement("ItemsElementName", Order = 2)]
784
        [XmlIgnore]
785
        public List<ItemsChoiceType24> ItemsElementName
786
        {
787
            get
788
            {
789
                return this.itemsElementNameField;
790
            }
791
            set
792
            {
793
                this.itemsElementNameField = value;
794
            }
795
        }
796

797
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
798
        public string uri
799
        {
800
            get
801
            {
802
                return this.uriField;
803
            }
804
            set
805
            {
806
                this.uriField = value;
807
            }
808
        }
809

810
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
811
        public string element
812
        {
813
            get
814
            {
815
                return this.elementField;
816
            }
817
            set
818
            {
819
                this.elementField = value;
820
            }
821
        }
822

823
        public static CT_CustomXmlRun Parse(XmlNode node, XmlNamespaceManager namespaceManager)
824
        {
825
            if (node == null)
826
                return null;
827
            CT_CustomXmlRun ctObj = new CT_CustomXmlRun();
828
            ctObj.uri = XmlHelper.ReadString(node.Attributes["w:uri"]);
829
            ctObj.element = XmlHelper.ReadString(node.Attributes["w:element"]);
830

831
            foreach (XmlNode childNode in node.ChildNodes)
832
            {
833
                if (childNode.LocalName == "bookmarkStart")
834
                {
835
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
836
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.bookmarkStart);
837
                }
838
                else if (childNode.LocalName == "moveFromRangeStart")
839
                {
840
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
841
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.moveFromRangeStart);
842
                }
843
                else if (childNode.LocalName == "moveTo")
844
                {
845
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
846
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.moveTo);
847
                }
848
                else if (childNode.LocalName == "oMath")
849
                {
850
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
851
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.oMath);
852
                }
853
                else if (childNode.LocalName == "customXmlDelRangeEnd")
854
                {
855
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
856
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXmlDelRangeEnd);
857
                }
858
                else if (childNode.LocalName == "customXmlDelRangeStart")
859
                {
860
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
861
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXmlDelRangeStart);
862
                }
863
                else if (childNode.LocalName == "customXmlInsRangeEnd")
864
                {
865
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
866
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXmlInsRangeEnd);
867
                }
868
                else if (childNode.LocalName == "customXmlInsRangeStart")
869
                {
870
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
871
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXmlInsRangeStart);
872
                }
873
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
874
                {
875
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
876
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXmlMoveFromRangeEnd);
877
                }
878
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
879
                {
880
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
881
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXmlMoveFromRangeStart);
882
                }
883
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
884
                {
885
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
886
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXmlMoveToRangeEnd);
887
                }
888
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
889
                {
890
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
891
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXmlMoveToRangeStart);
892
                }
893
                else if (childNode.LocalName == "del")
894
                {
895
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
896
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.del);
897
                }
898
                else if (childNode.LocalName == "commentRangeEnd")
899
                {
900
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
901
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.commentRangeEnd);
902
                }
903
                else if (childNode.LocalName == "fldSimple")
904
                {
905
                    ctObj.Items.Add(CT_SimpleField.Parse(childNode, namespaceManager));
906
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.fldSimple);
907
                }
908
                else if (childNode.LocalName == "hyperlink")
909
                {
910
                    ctObj.Items.Add(CT_Hyperlink1.Parse(childNode, namespaceManager));
911
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.hyperlink);
912
                }
913
                else if (childNode.LocalName == "ins")
914
                {
915
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
916
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.ins);
917
                }
918
                else if (childNode.LocalName == "moveFrom")
919
                {
920
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
921
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.moveFrom);
922
                }
923
                else if (childNode.LocalName == "moveFromRangeEnd")
924
                {
925
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
926
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.moveFromRangeEnd);
927
                }
928
                else if (childNode.LocalName == "customXml")
929
                {
930
                    ctObj.Items.Add(CT_CustomXmlRun.Parse(childNode, namespaceManager));
931
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.customXml);
932
                }
933
                else if (childNode.LocalName == "moveToRangeEnd")
934
                {
935
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
936
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.moveToRangeEnd);
937
                }
938
                else if (childNode.LocalName == "moveToRangeStart")
939
                {
940
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
941
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.moveToRangeStart);
942
                }
943
                else if (childNode.LocalName == "permEnd")
944
                {
945
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
946
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.permEnd);
947
                }
948
                else if (childNode.LocalName == "permStart")
949
                {
950
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
951
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.permStart);
952
                }
953
                else if (childNode.LocalName == "bookmarkEnd")
954
                {
955
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
956
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.bookmarkEnd);
957
                }
958
                else if (childNode.LocalName == "r")
959
                {
960
                    ctObj.Items.Add(CT_R.Parse(childNode, namespaceManager));
961
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.r);
962
                }
963
                else if (childNode.LocalName == "sdt")
964
                {
965
                    ctObj.Items.Add(CT_SdtRun.Parse(childNode, namespaceManager));
966
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.sdt);
967
                }
968
                else if (childNode.LocalName == "smartTag")
969
                {
970
                    ctObj.Items.Add(CT_SmartTagRun.Parse(childNode, namespaceManager));
971
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.smartTag);
972
                }
973
                else if (childNode.LocalName == "subDoc")
974
                {
975
                    ctObj.Items.Add(CT_Rel.Parse(childNode, namespaceManager));
976
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.subDoc);
977
                }
978
                else if (childNode.LocalName == "proofErr")
979
                {
980
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
981
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.proofErr);
982
                }
983
                else if (childNode.LocalName == "commentRangeStart")
984
                {
985
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
986
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.commentRangeStart);
987
                }
988
                else if (childNode.LocalName == "oMathPara")
989
                {
990
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
991
                    ctObj.ItemsElementName.Add(ItemsChoiceType24.oMathPara);
992
                }
993
            }
994
            return ctObj;
995
        }
996

997
        internal void Write(StreamWriter sw, string nodeName)
998
        {
999
            sw.Write(string.Format("<w:{0}", nodeName));
1000
            XmlHelper.WriteAttribute(sw, "w:uri", this.uri);
1001
            XmlHelper.WriteAttribute(sw, "w:element", this.element);
1002
            sw.Write(">");
1003
            foreach (object o in this.Items)
1004
            {
1005
                if (o is CT_Bookmark)
1006
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
1007
                else if (o is CT_MoveBookmark)
1008
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
1009
                else if (o is CT_RunTrackChange)
1010
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
1011
                else if (o is CT_OMath)
1012
                    ((CT_OMath)o).Write(sw, "oMath");
1013
                else if (o is CT_Markup)
1014
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
1015
                else if (o is CT_TrackChange)
1016
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
1017
                else if (o is CT_Markup)
1018
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
1019
                else if (o is CT_TrackChange)
1020
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
1021
                else if (o is CT_Markup)
1022
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
1023
                else if (o is CT_TrackChange)
1024
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
1025
                else if (o is CT_Markup)
1026
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
1027
                else if (o is CT_TrackChange)
1028
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
1029
                else if (o is CT_RunTrackChange)
1030
                    ((CT_RunTrackChange)o).Write(sw, "del");
1031
                else if (o is CT_MarkupRange)
1032
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
1033
                else if (o is CT_SimpleField)
1034
                    ((CT_SimpleField)o).Write(sw, "fldSimple");
1035
                else if (o is CT_Hyperlink1)
1036
                    ((CT_Hyperlink1)o).Write(sw, "hyperlink");
1037
                else if (o is CT_RunTrackChange)
1038
                    ((CT_RunTrackChange)o).Write(sw, "ins");
1039
                else if (o is CT_RunTrackChange)
1040
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
1041
                else if (o is CT_MarkupRange)
1042
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
1043
                else if (o is CT_CustomXmlRun)
1044
                    ((CT_CustomXmlRun)o).Write(sw, "customXml");
1045
                else if (o is CT_MarkupRange)
1046
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
1047
                else if (o is CT_MoveBookmark)
1048
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
1049
                else if (o is CT_Perm)
1050
                    ((CT_Perm)o).Write(sw, "permEnd");
1051
                else if (o is CT_PermStart)
1052
                    ((CT_PermStart)o).Write(sw, "permStart");
1053
                else if (o is CT_MarkupRange)
1054
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
1055
                else if (o is CT_R)
1056
                    ((CT_R)o).Write(sw, "r");
1057
                else if (o is CT_SdtRun)
1058
                    ((CT_SdtRun)o).Write(sw, "sdt");
1059
                else if (o is CT_SmartTagRun)
1060
                    ((CT_SmartTagRun)o).Write(sw, "smartTag");
1061
                else if (o is CT_Rel)
1062
                    ((CT_Rel)o).Write(sw, "subDoc");
1063
                else if (o is CT_ProofErr)
1064
                    ((CT_ProofErr)o).Write(sw, "proofErr");
1065
                else if (o is CT_MarkupRange)
1066
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
1067
                else if (o is CT_OMathPara)
1068
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
1069
            }
1070
            sw.WriteEndW(nodeName);
1071
        }
1072

1073
    }
1074

1075

1076
    [Serializable]
1077
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
1078
    public enum ItemsChoiceType24
1079
    {
1080

1081

1082
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
1083
        oMath,
1084

1085

1086
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
1087
        oMathPara,
1088

1089

1090
        bookmarkEnd,
1091

1092

1093
        bookmarkStart,
1094

1095

1096
        commentRangeEnd,
1097

1098

1099
        commentRangeStart,
1100

1101

1102
        customXml,
1103

1104

1105
        customXmlDelRangeEnd,
1106

1107

1108
        customXmlDelRangeStart,
1109

1110

1111
        customXmlInsRangeEnd,
1112

1113

1114
        customXmlInsRangeStart,
1115

1116

1117
        customXmlMoveFromRangeEnd,
1118

1119

1120
        customXmlMoveFromRangeStart,
1121

1122

1123
        customXmlMoveToRangeEnd,
1124

1125

1126
        customXmlMoveToRangeStart,
1127

1128

1129
        del,
1130

1131

1132
        fldSimple,
1133

1134

1135
        hyperlink,
1136

1137

1138
        ins,
1139

1140

1141
        moveFrom,
1142

1143

1144
        moveFromRangeEnd,
1145

1146

1147
        moveFromRangeStart,
1148

1149

1150
        moveTo,
1151

1152

1153
        moveToRangeEnd,
1154

1155

1156
        moveToRangeStart,
1157

1158

1159
        permEnd,
1160

1161

1162
        permStart,
1163

1164

1165
        proofErr,
1166

1167

1168
        r,
1169

1170

1171
        sdt,
1172

1173

1174
        smartTag,
1175

1176

1177
        subDoc,
1178
    }
1179

1180

1181
    [Serializable]
1182

1183
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1184
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1185
    public class CT_SmartTagRun
1186
    {
1187

1188
        private List<CT_Attr> smartTagPrField;
1189

1190
        private ArrayList itemsField;
1191

1192
        private List<ItemsChoiceType25> itemsElementNameField;
1193

1194
        private string uriField;
1195

1196
        private string elementField;
1197

1198
        public CT_SmartTagRun()
1199
        {
1200
            this.itemsElementNameField = new List<ItemsChoiceType25>();
1201
            this.itemsField = new ArrayList();
1202
            //this.smartTagPrField = new List<CT_Attr>();
1203
        }
1204

1205
        [XmlArray(Order = 0)]
1206
        [XmlArrayItem("attr", IsNullable = false)]
1207
        public List<CT_Attr> smartTagPr
1208
        {
1209
            get
1210
            {
1211
                return this.smartTagPrField;
1212
            }
1213
            set
1214
            {
1215
                this.smartTagPrField = value;
1216
            }
1217
        }
1218

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

1264
        [XmlElement("ItemsElementName", Order = 2)]
1265
        [XmlIgnore]
1266
        public List<ItemsChoiceType25> ItemsElementName
1267
        {
1268
            get
1269
            {
1270
                return this.itemsElementNameField;
1271
            }
1272
            set
1273
            {
1274
                this.itemsElementNameField = value;
1275
            }
1276
        }
1277

1278
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1279
        public string uri
1280
        {
1281
            get
1282
            {
1283
                return this.uriField;
1284
            }
1285
            set
1286
            {
1287
                this.uriField = value;
1288
            }
1289
        }
1290

1291
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1292
        public string element
1293
        {
1294
            get
1295
            {
1296
                return this.elementField;
1297
            }
1298
            set
1299
            {
1300
                this.elementField = value;
1301
            }
1302
        }
1303

1304
        public static CT_SmartTagRun Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1305
        {
1306
            if (node == null)
1307
                return null;
1308
            CT_SmartTagRun ctObj = new CT_SmartTagRun();
1309
            ctObj.uri = XmlHelper.ReadString(node.Attributes["w:uri"]);
1310
            ctObj.element = XmlHelper.ReadString(node.Attributes["w:element"]);
1311
            ctObj.smartTagPr = new List<CT_Attr>();
1312

1313
            foreach (XmlNode childNode in node.ChildNodes)
1314
            {
1315
                if (childNode.LocalName == "customXmlMoveToRangeStart")
1316
                {
1317
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1318
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXmlMoveToRangeStart);
1319
                }
1320
                else if (childNode.LocalName == "smartTagPr")
1321
                {
1322
                    ctObj.smartTagPr.Add(CT_Attr.Parse(childNode, namespaceManager));
1323
                }
1324
                else if (childNode.LocalName == "fldSimple")
1325
                {
1326
                    ctObj.Items.Add(CT_SimpleField.Parse(childNode, namespaceManager));
1327
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.fldSimple);
1328
                }
1329
                else if (childNode.LocalName == "hyperlink")
1330
                {
1331
                    ctObj.Items.Add(CT_Hyperlink1.Parse(childNode, namespaceManager));
1332
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.hyperlink);
1333
                }
1334
                else if (childNode.LocalName == "ins")
1335
                {
1336
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1337
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.ins);
1338
                }
1339
                else if (childNode.LocalName == "moveFrom")
1340
                {
1341
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1342
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.moveFrom);
1343
                }
1344
                else if (childNode.LocalName == "moveFromRangeEnd")
1345
                {
1346
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1347
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.moveFromRangeEnd);
1348
                }
1349
                else if (childNode.LocalName == "moveFromRangeStart")
1350
                {
1351
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1352
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.moveFromRangeStart);
1353
                }
1354
                else if (childNode.LocalName == "moveTo")
1355
                {
1356
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1357
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.moveTo);
1358
                }
1359
                else if (childNode.LocalName == "moveToRangeEnd")
1360
                {
1361
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1362
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.moveToRangeEnd);
1363
                }
1364
                else if (childNode.LocalName == "moveToRangeStart")
1365
                {
1366
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1367
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.moveToRangeStart);
1368
                }
1369
                else if (childNode.LocalName == "permEnd")
1370
                {
1371
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
1372
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.permEnd);
1373
                }
1374
                else if (childNode.LocalName == "permStart")
1375
                {
1376
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
1377
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.permStart);
1378
                }
1379
                else if (childNode.LocalName == "proofErr")
1380
                {
1381
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
1382
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.proofErr);
1383
                }
1384
                else if (childNode.LocalName == "r")
1385
                {
1386
                    ctObj.Items.Add(CT_R.Parse(childNode, namespaceManager));
1387
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.r);
1388
                }
1389
                else if (childNode.LocalName == "sdt")
1390
                {
1391
                    ctObj.Items.Add(CT_SdtRun.Parse(childNode, namespaceManager));
1392
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.sdt);
1393
                }
1394
                else if (childNode.LocalName == "smartTag")
1395
                {
1396
                    ctObj.Items.Add(CT_SmartTagRun.Parse(childNode, namespaceManager));
1397
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.smartTag);
1398
                }
1399
                else if (childNode.LocalName == "subDoc")
1400
                {
1401
                    ctObj.Items.Add(CT_Rel.Parse(childNode, namespaceManager));
1402
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.subDoc);
1403
                }
1404
                else if (childNode.LocalName == "oMath")
1405
                {
1406
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
1407
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.oMath);
1408
                }
1409
                else if (childNode.LocalName == "del")
1410
                {
1411
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1412
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.del);
1413
                }
1414
                else if (childNode.LocalName == "oMathPara")
1415
                {
1416
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
1417
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.oMathPara);
1418
                }
1419
                else if (childNode.LocalName == "bookmarkEnd")
1420
                {
1421
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1422
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.bookmarkEnd);
1423
                }
1424
                else if (childNode.LocalName == "bookmarkStart")
1425
                {
1426
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
1427
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.bookmarkStart);
1428
                }
1429
                else if (childNode.LocalName == "commentRangeEnd")
1430
                {
1431
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1432
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.commentRangeEnd);
1433
                }
1434
                else if (childNode.LocalName == "commentRangeStart")
1435
                {
1436
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1437
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.commentRangeStart);
1438
                }
1439
                else if (childNode.LocalName == "customXml")
1440
                {
1441
                    ctObj.Items.Add(CT_CustomXmlRun.Parse(childNode, namespaceManager));
1442
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXml);
1443
                }
1444
                else if (childNode.LocalName == "customXmlDelRangeEnd")
1445
                {
1446
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1447
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXmlDelRangeEnd);
1448
                }
1449
                else if (childNode.LocalName == "customXmlDelRangeStart")
1450
                {
1451
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1452
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXmlDelRangeStart);
1453
                }
1454
                else if (childNode.LocalName == "customXmlInsRangeEnd")
1455
                {
1456
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1457
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXmlInsRangeEnd);
1458
                }
1459
                else if (childNode.LocalName == "customXmlInsRangeStart")
1460
                {
1461
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1462
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXmlInsRangeStart);
1463
                }
1464
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
1465
                {
1466
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1467
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXmlMoveFromRangeEnd);
1468
                }
1469
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
1470
                {
1471
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1472
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXmlMoveFromRangeStart);
1473
                }
1474
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
1475
                {
1476
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1477
                    ctObj.ItemsElementName.Add(ItemsChoiceType25.customXmlMoveToRangeEnd);
1478
                }
1479
            }
1480
            return ctObj;
1481
        }
1482
        internal void Write(StreamWriter sw, string nodeName)
1483
        {
1484
            sw.Write(string.Format("<w:{0}", nodeName));
1485
            XmlHelper.WriteAttribute(sw, "w:uri", this.uri);
1486
            XmlHelper.WriteAttribute(sw, "w:element", this.element);
1487
            sw.Write(">");
1488
            if (this.smartTagPr != null)
1489
            {
1490
                foreach (CT_Attr x in this.smartTagPr)
1491
                {
1492
                    x.Write(sw, "smartTagPr");
1493
                }
1494
            }
1495
            foreach (object o in this.Items)
1496
            {
1497
                if (o is CT_TrackChange)
1498
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
1499
                else if (o is CT_SimpleField)
1500
                    ((CT_SimpleField)o).Write(sw, "fldSimple");
1501
                else if (o is CT_Hyperlink1)
1502
                    ((CT_Hyperlink1)o).Write(sw, "hyperlink");
1503
                else if (o is CT_RunTrackChange)
1504
                    ((CT_RunTrackChange)o).Write(sw, "ins");
1505
                else if (o is CT_RunTrackChange)
1506
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
1507
                else if (o is CT_MarkupRange)
1508
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
1509
                else if (o is CT_MoveBookmark)
1510
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
1511
                else if (o is CT_RunTrackChange)
1512
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
1513
                else if (o is CT_MarkupRange)
1514
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
1515
                else if (o is CT_MoveBookmark)
1516
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
1517
                else if (o is CT_Perm)
1518
                    ((CT_Perm)o).Write(sw, "permEnd");
1519
                else if (o is CT_PermStart)
1520
                    ((CT_PermStart)o).Write(sw, "permStart");
1521
                else if (o is CT_ProofErr)
1522
                    ((CT_ProofErr)o).Write(sw, "proofErr");
1523
                else if (o is CT_R)
1524
                    ((CT_R)o).Write(sw, "r");
1525
                else if (o is CT_SdtRun)
1526
                    ((CT_SdtRun)o).Write(sw, "sdt");
1527
                else if (o is CT_SmartTagRun)
1528
                    ((CT_SmartTagRun)o).Write(sw, "smartTag");
1529
                else if (o is CT_Rel)
1530
                    ((CT_Rel)o).Write(sw, "subDoc");
1531
                else if (o is CT_OMath)
1532
                    ((CT_OMath)o).Write(sw, "oMath");
1533
                else if (o is CT_RunTrackChange)
1534
                    ((CT_RunTrackChange)o).Write(sw, "del");
1535
                else if (o is CT_OMathPara)
1536
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
1537
                else if (o is CT_MarkupRange)
1538
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
1539
                else if (o is CT_Bookmark)
1540
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
1541
                else if (o is CT_MarkupRange)
1542
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
1543
                else if (o is CT_MarkupRange)
1544
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
1545
                else if (o is CT_CustomXmlRun)
1546
                    ((CT_CustomXmlRun)o).Write(sw, "customXml");
1547
                else if (o is CT_Markup)
1548
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
1549
                else if (o is CT_TrackChange)
1550
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
1551
                else if (o is CT_Markup)
1552
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
1553
                else if (o is CT_TrackChange)
1554
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
1555
                else if (o is CT_Markup)
1556
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
1557
                else if (o is CT_TrackChange)
1558
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
1559
                else if (o is CT_Markup)
1560
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
1561
            }
1562
            sw.WriteEndW(nodeName);
1563
        }
1564

1565
    }
1566

1567

1568
    [Serializable]
1569
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
1570
    public enum ItemsChoiceType25
1571
    {
1572

1573

1574
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
1575
        oMath,
1576

1577

1578
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
1579
        oMathPara,
1580

1581

1582
        bookmarkEnd,
1583

1584

1585
        bookmarkStart,
1586

1587

1588
        commentRangeEnd,
1589

1590

1591
        commentRangeStart,
1592

1593

1594
        customXml,
1595

1596

1597
        customXmlDelRangeEnd,
1598

1599

1600
        customXmlDelRangeStart,
1601

1602

1603
        customXmlInsRangeEnd,
1604

1605

1606
        customXmlInsRangeStart,
1607

1608

1609
        customXmlMoveFromRangeEnd,
1610

1611

1612
        customXmlMoveFromRangeStart,
1613

1614

1615
        customXmlMoveToRangeEnd,
1616

1617

1618
        customXmlMoveToRangeStart,
1619

1620

1621
        del,
1622

1623

1624
        fldSimple,
1625

1626

1627
        hyperlink,
1628

1629

1630
        ins,
1631

1632

1633
        moveFrom,
1634

1635

1636
        moveFromRangeEnd,
1637

1638

1639
        moveFromRangeStart,
1640

1641

1642
        moveTo,
1643

1644

1645
        moveToRangeEnd,
1646

1647

1648
        moveToRangeStart,
1649

1650

1651
        permEnd,
1652

1653

1654
        permStart,
1655

1656

1657
        proofErr,
1658

1659

1660
        r,
1661

1662

1663
        sdt,
1664

1665

1666
        smartTag,
1667

1668

1669
        subDoc,
1670
    }
1671

1672

1673
    [Serializable]
1674

1675
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1676
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1677
    public class CT_CustomXmlBlock
1678
    {
1679

1680
        private CT_CustomXmlPr customXmlPrField;
1681

1682
        private ArrayList itemsField;
1683

1684
        private List<ItemsChoiceType26> itemsElementNameField;
1685

1686
        private string uriField;
1687

1688
        private string elementField;
1689

1690
        public CT_CustomXmlBlock()
1691
        {
1692
            this.itemsElementNameField = new List<ItemsChoiceType26>();
1693
            this.itemsField = new ArrayList();
1694
            //this.customXmlPrField = new CT_CustomXmlPr();
1695
        }
1696

1697
        [XmlElement(Order = 0)]
1698
        public CT_CustomXmlPr customXmlPr
1699
        {
1700
            get
1701
            {
1702
                return this.customXmlPrField;
1703
            }
1704
            set
1705
            {
1706
                this.customXmlPrField = value;
1707
            }
1708
        }
1709
        public static CT_CustomXmlBlock Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1710
        {
1711
            if (node == null)
1712
                return null;
1713
            CT_CustomXmlBlock ctObj = new CT_CustomXmlBlock();
1714
            ctObj.uri = XmlHelper.ReadString(node.Attributes["w:uri"]);
1715
            ctObj.element = XmlHelper.ReadString(node.Attributes["w:element"]);
1716

1717
            foreach (XmlNode childNode in node.ChildNodes)
1718
            {
1719
                if (childNode.LocalName == "del")
1720
                {
1721
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1722
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.del);
1723
                }
1724
                else if (childNode.LocalName == "moveFrom")
1725
                {
1726
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1727
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.moveFrom);
1728
                }
1729
                else if (childNode.LocalName == "moveTo")
1730
                {
1731
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1732
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.moveTo);
1733
                }
1734
                else if (childNode.LocalName == "bookmarkStart")
1735
                {
1736
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
1737
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.bookmarkStart);
1738
                }
1739
                else if (childNode.LocalName == "commentRangeStart")
1740
                {
1741
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1742
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.commentRangeStart);
1743
                }
1744
                else if (childNode.LocalName == "customXml")
1745
                {
1746
                    ctObj.Items.Add(CT_CustomXmlBlock.Parse(childNode, namespaceManager));
1747
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXml);
1748
                }
1749
                else if (childNode.LocalName == "customXmlDelRangeEnd")
1750
                {
1751
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1752
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXmlDelRangeEnd);
1753
                }
1754
                else if (childNode.LocalName == "customXmlDelRangeStart")
1755
                {
1756
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1757
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXmlDelRangeStart);
1758
                }
1759
                else if (childNode.LocalName == "customXmlInsRangeEnd")
1760
                {
1761
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1762
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXmlInsRangeEnd);
1763
                }
1764
                else if (childNode.LocalName == "customXmlInsRangeStart")
1765
                {
1766
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1767
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXmlInsRangeStart);
1768
                }
1769
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
1770
                {
1771
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1772
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXmlMoveFromRangeEnd);
1773
                }
1774
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
1775
                {
1776
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1777
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXmlMoveFromRangeStart);
1778
                }
1779
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
1780
                {
1781
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1782
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXmlMoveToRangeEnd);
1783
                }
1784
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
1785
                {
1786
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1787
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.customXmlMoveToRangeStart);
1788
                }
1789
                else if (childNode.LocalName == "oMath")
1790
                {
1791
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
1792
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.oMath);
1793
                }
1794
                else if (childNode.LocalName == "ins")
1795
                {
1796
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1797
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.ins);
1798
                }
1799
                else if (childNode.LocalName == "moveFromRangeEnd")
1800
                {
1801
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1802
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.moveFromRangeEnd);
1803
                }
1804
                else if (childNode.LocalName == "moveFromRangeStart")
1805
                {
1806
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1807
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.moveFromRangeStart);
1808
                }
1809
                else if (childNode.LocalName == "commentRangeEnd")
1810
                {
1811
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1812
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.commentRangeEnd);
1813
                }
1814
                else if (childNode.LocalName == "moveToRangeEnd")
1815
                {
1816
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1817
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.moveToRangeEnd);
1818
                }
1819
                else if (childNode.LocalName == "moveToRangeStart")
1820
                {
1821
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1822
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.moveToRangeStart);
1823
                }
1824
                else if (childNode.LocalName == "p")
1825
                {
1826
                    ctObj.Items.Add(CT_P.Parse(childNode, namespaceManager));
1827
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.p);
1828
                }
1829
                else if (childNode.LocalName == "permEnd")
1830
                {
1831
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
1832
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.permEnd);
1833
                }
1834
                else if (childNode.LocalName == "bookmarkEnd")
1835
                {
1836
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1837
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.bookmarkEnd);
1838
                }
1839
                else if (childNode.LocalName == "proofErr")
1840
                {
1841
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
1842
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.proofErr);
1843
                }
1844
                else if (childNode.LocalName == "sdt")
1845
                {
1846
                    ctObj.Items.Add(CT_SdtBlock.Parse(childNode, namespaceManager));
1847
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.sdt);
1848
                }
1849
                else if (childNode.LocalName == "tbl")
1850
                {
1851
                    ctObj.Items.Add(CT_Tbl.Parse(childNode, namespaceManager));
1852
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.tbl);
1853
                }
1854
                else if (childNode.LocalName == "permStart")
1855
                {
1856
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
1857
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.permStart);
1858
                }
1859
                else if (childNode.LocalName == "oMathPara")
1860
                {
1861
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
1862
                    ctObj.ItemsElementName.Add(ItemsChoiceType26.oMathPara);
1863
                }
1864
            }
1865
            return ctObj;
1866
        }
1867

1868
        internal void Write(StreamWriter sw, string nodeName)
1869
        {
1870
            sw.Write(string.Format("<w:{0}", nodeName));
1871
            XmlHelper.WriteAttribute(sw, "w:uri", this.uri);
1872
            XmlHelper.WriteAttribute(sw, "w:element", this.element);
1873
            sw.Write(">");
1874
            foreach (object o in this.Items)
1875
            {
1876
                if (o is CT_RunTrackChange)
1877
                    ((CT_RunTrackChange)o).Write(sw, "del");
1878
                else if (o is CT_RunTrackChange)
1879
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
1880
                else if (o is CT_RunTrackChange)
1881
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
1882
                else if (o is CT_Bookmark)
1883
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
1884
                else if (o is CT_MarkupRange)
1885
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
1886
                else if (o is CT_CustomXmlBlock)
1887
                    ((CT_CustomXmlBlock)o).Write(sw, "customXml");
1888
                else if (o is CT_Markup)
1889
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
1890
                else if (o is CT_TrackChange)
1891
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
1892
                else if (o is CT_Markup)
1893
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
1894
                else if (o is CT_TrackChange)
1895
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
1896
                else if (o is CT_Markup)
1897
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
1898
                else if (o is CT_TrackChange)
1899
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
1900
                else if (o is CT_Markup)
1901
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
1902
                else if (o is CT_TrackChange)
1903
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
1904
                else if (o is CT_OMath)
1905
                    ((CT_OMath)o).Write(sw, "oMath");
1906
                else if (o is CT_RunTrackChange)
1907
                    ((CT_RunTrackChange)o).Write(sw, "ins");
1908
                else if (o is CT_MarkupRange)
1909
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
1910
                else if (o is CT_MoveBookmark)
1911
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
1912
                else if (o is CT_MarkupRange)
1913
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
1914
                else if (o is CT_MarkupRange)
1915
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
1916
                else if (o is CT_MoveBookmark)
1917
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
1918
                else if (o is CT_P)
1919
                    ((CT_P)o).Write(sw, "p");
1920
                else if (o is CT_Perm)
1921
                    ((CT_Perm)o).Write(sw, "permEnd");
1922
                else if (o is CT_MarkupRange)
1923
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
1924
                else if (o is CT_ProofErr)
1925
                    ((CT_ProofErr)o).Write(sw, "proofErr");
1926
                else if (o is CT_SdtBlock)
1927
                    ((CT_SdtBlock)o).Write(sw, "sdt");
1928
                else if (o is CT_Tbl)
1929
                    ((CT_Tbl)o).Write(sw, "tbl");
1930
                else if (o is CT_PermStart)
1931
                    ((CT_PermStart)o).Write(sw, "permStart");
1932
                else if (o is CT_OMathPara)
1933
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
1934
            }
1935
            sw.WriteEndW(nodeName);
1936
        }
1937

1938
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
1939
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
1940
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 1)]
1941
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 1)]
1942
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 1)]
1943
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 1)]
1944
        [XmlElement("customXml", typeof(CT_CustomXmlBlock), Order = 1)]
1945
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 1)]
1946
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 1)]
1947
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 1)]
1948
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 1)]
1949
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 1)]
1950
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 1)]
1951
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 1)]
1952
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 1)]
1953
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 1)]
1954
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 1)]
1955
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 1)]
1956
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 1)]
1957
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 1)]
1958
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 1)]
1959
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 1)]
1960
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 1)]
1961
        [XmlElement("p", typeof(CT_P), Order = 1)]
1962
        [XmlElement("permEnd", typeof(CT_Perm), Order = 1)]
1963
        [XmlElement("permStart", typeof(CT_PermStart), Order = 1)]
1964
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 1)]
1965
        [XmlElement("sdt", typeof(CT_SdtBlock), Order = 1)]
1966
        [XmlElement("tbl", typeof(CT_Tbl), Order = 1)]
1967
        [XmlChoiceIdentifier("ItemsElementName")]
1968
        public ArrayList Items
1969
        {
1970
            get
1971
            {
1972
                return this.itemsField;
1973
            }
1974
            set
1975
            {
1976
                this.itemsField = value;
1977
            }
1978
        }
1979

1980
        [XmlElement("ItemsElementName", Order = 2)]
1981
        [XmlIgnore]
1982
        public List<ItemsChoiceType26> ItemsElementName
1983
        {
1984
            get
1985
            {
1986
                return this.itemsElementNameField;
1987
            }
1988
            set
1989
            {
1990
                this.itemsElementNameField = value;
1991
            }
1992
        }
1993

1994
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1995
        public string uri
1996
        {
1997
            get
1998
            {
1999
                return this.uriField;
2000
            }
2001
            set
2002
            {
2003
                this.uriField = value;
2004
            }
2005
        }
2006

2007
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2008
        public string element
2009
        {
2010
            get
2011
            {
2012
                return this.elementField;
2013
            }
2014
            set
2015
            {
2016
                this.elementField = value;
2017
            }
2018
        }
2019
    }
2020

2021

2022
    [Serializable]
2023
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
2024
    public enum ItemsChoiceType26
2025
    {
2026

2027

2028
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
2029
        oMath,
2030

2031

2032
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
2033
        oMathPara,
2034

2035

2036
        bookmarkEnd,
2037

2038

2039
        bookmarkStart,
2040

2041

2042
        commentRangeEnd,
2043

2044

2045
        commentRangeStart,
2046

2047

2048
        customXml,
2049

2050

2051
        customXmlDelRangeEnd,
2052

2053

2054
        customXmlDelRangeStart,
2055

2056

2057
        customXmlInsRangeEnd,
2058

2059

2060
        customXmlInsRangeStart,
2061

2062

2063
        customXmlMoveFromRangeEnd,
2064

2065

2066
        customXmlMoveFromRangeStart,
2067

2068

2069
        customXmlMoveToRangeEnd,
2070

2071

2072
        customXmlMoveToRangeStart,
2073

2074

2075
        del,
2076

2077

2078
        ins,
2079

2080

2081
        moveFrom,
2082

2083

2084
        moveFromRangeEnd,
2085

2086

2087
        moveFromRangeStart,
2088

2089

2090
        moveTo,
2091

2092

2093
        moveToRangeEnd,
2094

2095

2096
        moveToRangeStart,
2097

2098

2099
        p,
2100

2101

2102
        permEnd,
2103

2104

2105
        permStart,
2106

2107

2108
        proofErr,
2109

2110

2111
        sdt,
2112

2113

2114
        tbl,
2115
    }
2116

2117

2118
    [Serializable]
2119

2120
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2121
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2122
    public class CT_CustomXmlCell
2123
    {
2124

2125
        private CT_CustomXmlPr customXmlPrField;
2126

2127
        private ArrayList itemsField;
2128

2129
        private List<ItemsChoiceType27> itemsElementNameField;
2130

2131
        private string uriField;
2132

2133
        private string elementField;
2134

2135
        public CT_CustomXmlCell()
2136
        {
2137
            this.itemsElementNameField = new List<ItemsChoiceType27>();
2138
            this.itemsField = new ArrayList();
2139
            //this.customXmlPrField = new CT_CustomXmlPr();
2140
        }
2141
        public static CT_CustomXmlCell Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2142
        {
2143
            if (node == null)
2144
                return null;
2145
            CT_CustomXmlCell ctObj = new CT_CustomXmlCell();
2146
            ctObj.uri = XmlHelper.ReadString(node.Attributes["w:uri"]);
2147
            ctObj.element = XmlHelper.ReadString(node.Attributes["w:element"]);
2148

2149
            foreach (XmlNode childNode in node.ChildNodes)
2150
            {
2151
                if (childNode.LocalName == "customXmlMoveToRangeStart")
2152
                {
2153
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2154
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXmlMoveToRangeStart);
2155
                }
2156
                else if (childNode.LocalName == "customXmlPr")
2157
                {
2158
                    ctObj.customXmlPr = CT_CustomXmlPr.Parse(childNode, namespaceManager);
2159
                }
2160
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
2161
                {
2162
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2163
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXmlMoveFromRangeEnd);
2164
                }
2165
                else if (childNode.LocalName == "sdt")
2166
                {
2167
                    ctObj.Items.Add(CT_SdtCell.Parse(childNode, namespaceManager));
2168
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.sdt);
2169
                }
2170
                else if (childNode.LocalName == "tc")
2171
                {
2172
                    ctObj.Items.Add(CT_Tc.Parse(childNode, namespaceManager, ctObj));
2173
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.tc);
2174
                }
2175
                else if (childNode.LocalName == "permEnd")
2176
                {
2177
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
2178
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.permEnd);
2179
                }
2180
                else if (childNode.LocalName == "customXmlInsRangeStart")
2181
                {
2182
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2183
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXmlInsRangeStart);
2184
                }
2185
                else if (childNode.LocalName == "del")
2186
                {
2187
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2188
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.del);
2189
                }
2190
                else if (childNode.LocalName == "ins")
2191
                {
2192
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2193
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.ins);
2194
                }
2195
                else if (childNode.LocalName == "moveFrom")
2196
                {
2197
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2198
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.moveFrom);
2199
                }
2200
                else if (childNode.LocalName == "moveFromRangeEnd")
2201
                {
2202
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2203
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.moveFromRangeEnd);
2204
                }
2205
                else if (childNode.LocalName == "moveFromRangeStart")
2206
                {
2207
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
2208
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.moveFromRangeStart);
2209
                }
2210
                else if (childNode.LocalName == "moveTo")
2211
                {
2212
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2213
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.moveTo);
2214
                }
2215
                else if (childNode.LocalName == "moveToRangeEnd")
2216
                {
2217
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2218
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.moveToRangeEnd);
2219
                }
2220
                else if (childNode.LocalName == "moveToRangeStart")
2221
                {
2222
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
2223
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.moveToRangeStart);
2224
                }
2225
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
2226
                {
2227
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2228
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXmlMoveToRangeEnd);
2229
                }
2230
                else if (childNode.LocalName == "permStart")
2231
                {
2232
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
2233
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.permStart);
2234
                }
2235
                else if (childNode.LocalName == "proofErr")
2236
                {
2237
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
2238
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.proofErr);
2239
                }
2240
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
2241
                {
2242
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2243
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXmlMoveFromRangeStart);
2244
                }
2245
                else if (childNode.LocalName == "oMath")
2246
                {
2247
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
2248
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.oMath);
2249
                }
2250
                else if (childNode.LocalName == "oMathPara")
2251
                {
2252
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
2253
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.oMathPara);
2254
                }
2255
                else if (childNode.LocalName == "bookmarkEnd")
2256
                {
2257
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2258
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.bookmarkEnd);
2259
                }
2260
                else if (childNode.LocalName == "bookmarkStart")
2261
                {
2262
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
2263
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.bookmarkStart);
2264
                }
2265
                else if (childNode.LocalName == "commentRangeEnd")
2266
                {
2267
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2268
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.commentRangeEnd);
2269
                }
2270
                else if (childNode.LocalName == "commentRangeStart")
2271
                {
2272
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2273
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.commentRangeStart);
2274
                }
2275
                else if (childNode.LocalName == "customXml")
2276
                {
2277
                    ctObj.Items.Add(CT_CustomXmlCell.Parse(childNode, namespaceManager));
2278
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXml);
2279
                }
2280
                else if (childNode.LocalName == "customXmlDelRangeEnd")
2281
                {
2282
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2283
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXmlDelRangeEnd);
2284
                }
2285
                else if (childNode.LocalName == "customXmlDelRangeStart")
2286
                {
2287
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2288
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXmlDelRangeStart);
2289
                }
2290
                else if (childNode.LocalName == "customXmlInsRangeEnd")
2291
                {
2292
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2293
                    ctObj.ItemsElementName.Add(ItemsChoiceType27.customXmlInsRangeEnd);
2294
                }
2295
            }
2296
            return ctObj;
2297
        }
2298

2299
        internal void Write(StreamWriter sw, string nodeName)
2300
        {
2301
            sw.Write(string.Format("<w:{0}", nodeName));
2302
            XmlHelper.WriteAttribute(sw, "w:uri", this.uri);
2303
            XmlHelper.WriteAttribute(sw, "w:element", this.element);
2304
            sw.Write(">");
2305
            if (this.customXmlPr != null)
2306
                this.customXmlPr.Write(sw, "customXmlPr");
2307
            foreach (object o in this.Items)
2308
            {
2309
                if (o is CT_TrackChange)
2310
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
2311
                else if (o is CT_Markup)
2312
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
2313
                else if (o is CT_SdtCell)
2314
                    ((CT_SdtCell)o).Write(sw, "sdt");
2315
                else if (o is CT_Tc)
2316
                    ((CT_Tc)o).Write(sw, "tc");
2317
                else if (o is CT_Perm)
2318
                    ((CT_Perm)o).Write(sw, "permEnd");
2319
                else if (o is CT_TrackChange)
2320
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
2321
                else if (o is CT_RunTrackChange)
2322
                    ((CT_RunTrackChange)o).Write(sw, "del");
2323
                else if (o is CT_RunTrackChange)
2324
                    ((CT_RunTrackChange)o).Write(sw, "ins");
2325
                else if (o is CT_RunTrackChange)
2326
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
2327
                else if (o is CT_MarkupRange)
2328
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
2329
                else if (o is CT_MoveBookmark)
2330
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
2331
                else if (o is CT_RunTrackChange)
2332
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
2333
                else if (o is CT_MarkupRange)
2334
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
2335
                else if (o is CT_MoveBookmark)
2336
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
2337
                else if (o is CT_Markup)
2338
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
2339
                else if (o is CT_PermStart)
2340
                    ((CT_PermStart)o).Write(sw, "permStart");
2341
                else if (o is CT_ProofErr)
2342
                    ((CT_ProofErr)o).Write(sw, "proofErr");
2343
                else if (o is CT_TrackChange)
2344
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
2345
                else if (o is CT_OMath)
2346
                    ((CT_OMath)o).Write(sw, "oMath");
2347
                else if (o is CT_OMathPara)
2348
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
2349
                else if (o is CT_MarkupRange)
2350
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
2351
                else if (o is CT_Bookmark)
2352
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
2353
                else if (o is CT_MarkupRange)
2354
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
2355
                else if (o is CT_MarkupRange)
2356
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
2357
                else if (o is CT_CustomXmlCell)
2358
                    ((CT_CustomXmlCell)o).Write(sw, "customXml");
2359
                else if (o is CT_Markup)
2360
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
2361
                else if (o is CT_TrackChange)
2362
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
2363
                else if (o is CT_Markup)
2364
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
2365
            }
2366
            sw.WriteEndW(nodeName);
2367
        }
2368

2369
        [XmlElement(Order = 0)]
2370
        public CT_CustomXmlPr customXmlPr
2371
        {
2372
            get
2373
            {
2374
                return this.customXmlPrField;
2375
            }
2376
            set
2377
            {
2378
                this.customXmlPrField = value;
2379
            }
2380
        }
2381

2382
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
2383
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 1)]
2384
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 1)]
2385
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 1)]
2386
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 1)]
2387
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 1)]
2388
        [XmlElement("customXml", typeof(CT_CustomXmlCell), Order = 1)]
2389
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 1)]
2390
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 1)]
2391
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 1)]
2392
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 1)]
2393
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 1)]
2394
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 1)]
2395
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 1)]
2396
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 1)]
2397
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 1)]
2398
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 1)]
2399
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 1)]
2400
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 1)]
2401
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 1)]
2402
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 1)]
2403
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 1)]
2404
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 1)]
2405
        [XmlElement("permEnd", typeof(CT_Perm), Order = 1)]
2406
        [XmlElement("permStart", typeof(CT_PermStart), Order = 1)]
2407
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 1)]
2408
        [XmlElement("sdt", typeof(CT_SdtCell), Order = 1)]
2409
        [XmlElement("tc", typeof(CT_Tc), Order = 1)]
2410
        [XmlChoiceIdentifier("ItemsElementName")]
2411
        public ArrayList Items
2412
        {
2413
            get
2414
            {
2415
                return this.itemsField;
2416
            }
2417
            set
2418
            {
2419
                this.itemsField = value;
2420
            }
2421
        }
2422

2423
        [XmlElement("ItemsElementName", Order = 2)]
2424
        [XmlIgnore]
2425
        public List<ItemsChoiceType27> ItemsElementName
2426
        {
2427
            get
2428
            {
2429
                return this.itemsElementNameField;
2430
            }
2431
            set
2432
            {
2433
                this.itemsElementNameField = value;
2434
            }
2435
        }
2436

2437
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2438
        public string uri
2439
        {
2440
            get
2441
            {
2442
                return this.uriField;
2443
            }
2444
            set
2445
            {
2446
                this.uriField = value;
2447
            }
2448
        }
2449

2450
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
2451
        public string element
2452
        {
2453
            get
2454
            {
2455
                return this.elementField;
2456
            }
2457
            set
2458
            {
2459
                this.elementField = value;
2460
            }
2461
        }
2462
    }
2463

2464

2465
    [Serializable]
2466
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
2467
    public enum ItemsChoiceType27
2468
    {
2469

2470

2471
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
2472
        oMath,
2473

2474

2475
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
2476
        oMathPara,
2477

2478

2479
        bookmarkEnd,
2480

2481

2482
        bookmarkStart,
2483

2484

2485
        commentRangeEnd,
2486

2487

2488
        commentRangeStart,
2489

2490

2491
        customXml,
2492

2493

2494
        customXmlDelRangeEnd,
2495

2496

2497
        customXmlDelRangeStart,
2498

2499

2500
        customXmlInsRangeEnd,
2501

2502

2503
        customXmlInsRangeStart,
2504

2505

2506
        customXmlMoveFromRangeEnd,
2507

2508

2509
        customXmlMoveFromRangeStart,
2510

2511

2512
        customXmlMoveToRangeEnd,
2513

2514

2515
        customXmlMoveToRangeStart,
2516

2517

2518
        del,
2519

2520

2521
        ins,
2522

2523

2524
        moveFrom,
2525

2526

2527
        moveFromRangeEnd,
2528

2529

2530
        moveFromRangeStart,
2531

2532

2533
        moveTo,
2534

2535

2536
        moveToRangeEnd,
2537

2538

2539
        moveToRangeStart,
2540

2541

2542
        permEnd,
2543

2544

2545
        permStart,
2546

2547

2548
        proofErr,
2549

2550

2551
        sdt,
2552

2553

2554
        tc,
2555
    }
2556

2557

2558
    [Serializable]
2559

2560
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2561
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2562
    public class CT_SmartTagPr
2563
    {
2564

2565
        private List<CT_Attr> attrField;
2566

2567
        public CT_SmartTagPr()
2568
        {
2569
            this.attrField = new List<CT_Attr>();
2570
        }
2571

2572
        [XmlElement("attr", Order = 0)]
2573
        public List<CT_Attr> attr
2574
        {
2575
            get
2576
            {
2577
                return this.attrField;
2578
            }
2579
            set
2580
            {
2581
                this.attrField = value;
2582
            }
2583
        }
2584
    }
2585

2586

2587
    [Serializable]
2588
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
2589
    public enum Items1ChoiceType
2590
    {
2591

2592

2593
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
2594
        oMath,
2595

2596

2597
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
2598
        oMathPara,
2599

2600

2601
        bookmarkEnd,
2602

2603

2604
        bookmarkStart,
2605

2606

2607
        commentRangeEnd,
2608

2609

2610
        commentRangeStart,
2611

2612

2613
        customXml,
2614

2615

2616
        customXmlDelRangeEnd,
2617

2618

2619
        customXmlDelRangeStart,
2620

2621

2622
        customXmlInsRangeEnd,
2623

2624

2625
        customXmlInsRangeStart,
2626

2627

2628
        customXmlMoveFromRangeEnd,
2629

2630

2631
        customXmlMoveFromRangeStart,
2632

2633

2634
        customXmlMoveToRangeEnd,
2635

2636

2637
        customXmlMoveToRangeStart,
2638

2639

2640
        del,
2641

2642

2643
        ins,
2644

2645

2646
        moveFrom,
2647

2648

2649
        moveFromRangeEnd,
2650

2651

2652
        moveFromRangeStart,
2653

2654

2655
        moveTo,
2656

2657

2658
        moveToRangeEnd,
2659

2660

2661
        moveToRangeStart,
2662

2663

2664
        permEnd,
2665

2666

2667
        permStart,
2668

2669

2670
        proofErr,
2671

2672

2673
        sdt,
2674

2675

2676
        tr,
2677
    }
2678

2679
}