npoi

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

10
namespace NPOI.OpenXmlFormats.Wordprocessing
11
{
12

13
    [XmlInclude(typeof(CT_Bookmark))]
14
    [XmlInclude(typeof(CT_MoveBookmark))]
15

16
    [Serializable]
17

18
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
19
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
20
    public class CT_BookmarkRange : CT_MarkupRange
21
    {
22

23
        private string colFirstField;
24

25
        private string colLastField;
26

27
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
28
        public string colFirst
29
        {
30
            get
31
            {
32
                return this.colFirstField;
33
            }
34
            set
35
            {
36
                this.colFirstField = value;
37
            }
38
        }
39

40
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
41
        public string colLast
42
        {
43
            get
44
            {
45
                return this.colLastField;
46
            }
47
            set
48
            {
49
                this.colLastField = value;
50
            }
51
        }
52
    }
53

54
    [XmlInclude(typeof(CT_MoveBookmark))]
55

56
    [Serializable]
57

58
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
59
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
60
    public class CT_Bookmark : CT_BookmarkRange
61
    {
62
        public static new CT_Bookmark Parse(XmlNode node, XmlNamespaceManager namespaceManager)
63
        {
64
            if (node == null)
65
                return null;
66
            CT_Bookmark ctObj = new CT_Bookmark();
67
            ctObj.name = XmlHelper.ReadString(node.Attributes["w:name"]);
68
            ctObj.colFirst = XmlHelper.ReadString(node.Attributes["w:colFirst"]);
69
            ctObj.colLast = XmlHelper.ReadString(node.Attributes["w:colLast"]);
70
            if (node.Attributes["w:displacedByCustomXml"] != null)
71
                ctObj.displacedByCustomXml = (ST_DisplacedByCustomXml)Enum.Parse(typeof(ST_DisplacedByCustomXml), node.Attributes["w:displacedByCustomXml"].Value);
72
            ctObj.id = XmlHelper.ReadString(node.Attributes["w:id"]);
73
            return ctObj;
74
        }
75

76

77

78
        internal new void Write(StreamWriter sw, string nodeName)
79
        {
80
            sw.Write(string.Format("<w:{0}", nodeName));
81
            XmlHelper.WriteAttribute(sw, "w:id", this.id);
82
            XmlHelper.WriteAttribute(sw, "w:name", this.name);
83
            XmlHelper.WriteAttribute(sw, "w:colFirst", this.colFirst);
84
            XmlHelper.WriteAttribute(sw, "w:colLast", this.colLast);
85
            if (this.displacedByCustomXml!= ST_DisplacedByCustomXml.next)
86
                XmlHelper.WriteAttribute(sw, "w:displacedByCustomXml", this.displacedByCustomXml.ToString());
87
            sw.Write("/>");
88
        }
89

90
        private string nameField;
91

92
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
93
        public string name
94
        {
95
            get
96
            {
97
                return this.nameField;
98
            }
99
            set
100
            {
101
                this.nameField = value;
102
            }
103
        }
104
    }
105

106

107
    [Serializable]
108

109
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
110
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
111
    public class CT_MoveBookmark : CT_Bookmark
112
    {
113

114
        private string authorField;
115

116
        private string dateField;
117
        public static new CT_MoveBookmark Parse(XmlNode node, XmlNamespaceManager namespaceManager)
118
        {
119
            if (node == null)
120
                return null;
121
            CT_MoveBookmark ctObj = new CT_MoveBookmark();
122
            ctObj.author = XmlHelper.ReadString(node.Attributes["w:author"]);
123
            ctObj.date = XmlHelper.ReadString(node.Attributes["w:date"]);
124
            ctObj.name = XmlHelper.ReadString(node.Attributes["w:name"]);
125
            ctObj.colFirst = XmlHelper.ReadString(node.Attributes["w:colFirst"]);
126
            ctObj.colLast = XmlHelper.ReadString(node.Attributes["w:colLast"]);
127
            if (node.Attributes["w:displacedByCustomXml"] != null)
128
                ctObj.displacedByCustomXml = (ST_DisplacedByCustomXml)Enum.Parse(typeof(ST_DisplacedByCustomXml), node.Attributes["w:displacedByCustomXml"].Value);
129
            ctObj.id = XmlHelper.ReadString(node.Attributes["w:id"]);
130
            return ctObj;
131
        }
132

133

134

135
        internal new void Write(StreamWriter sw, string nodeName)
136
        {
137
            sw.Write(string.Format("<w:{0}", nodeName));
138
            XmlHelper.WriteAttribute(sw, "w:author", this.author);
139
            XmlHelper.WriteAttribute(sw, "w:date", this.date);
140
            XmlHelper.WriteAttribute(sw, "w:name", this.name);
141
            XmlHelper.WriteAttribute(sw, "w:colFirst", this.colFirst);
142
            XmlHelper.WriteAttribute(sw, "w:colLast", this.colLast);
143
            XmlHelper.WriteAttribute(sw, "w:displacedByCustomXml", this.displacedByCustomXml.ToString());
144
            XmlHelper.WriteAttribute(sw, "w:id", this.id);
145
            sw.Write("/>");
146
        }
147

148
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
149
        public string author
150
        {
151
            get
152
            {
153
                return this.authorField;
154
            }
155
            set
156
            {
157
                this.authorField = value;
158
            }
159
        }
160

161
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
162
        public string date
163
        {
164
            get
165
            {
166
                return this.dateField;
167
            }
168
            set
169
            {
170
                this.dateField = value;
171
            }
172
        }
173
    }
174

175

176
    [Serializable]
177

178
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
179
    [XmlRoot("comments", Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = false)]
180
    public class CT_Comments
181
    {
182

183
        private List<CT_Comment> commentField;
184

185
        public CT_Comments()
186
        {
187
            this.commentField = new List<CT_Comment>();
188
        }
189
        public static CT_Comments Parse(XmlNode node, XmlNamespaceManager namespaceManager)
190
        {
191
            if (node == null)
192
                return null;
193
            CT_Comments ctObj = new CT_Comments();
194
            ctObj.comment = new List<CT_Comment>();
195
            foreach (XmlNode childNode in node.ChildNodes)
196
            {
197
                if (childNode.LocalName == "comment")
198
                    ctObj.comment.Add(CT_Comment.Parse(childNode, namespaceManager));
199
            }
200
            return ctObj;
201
        }
202

203

204

205
        internal void Write(StreamWriter sw)
206
        {
207
            sw.Write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
208
            sw.Write(string.Format("<w:comments "));
209
            sw.Write("xmlns:ve=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" ");
210
            sw.Write("xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" ");
211
            sw.Write("xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" ");
212
            sw.Write("xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" ");
213
            sw.Write("xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\">");
214
            sw.Write(">");
215
            if (this.comment != null)
216
            {
217
                foreach (CT_Comment x in this.comment)
218
                {
219
                    x.Write(sw, "comment");
220
                }
221
            }
222
            sw.Write("</w:comments>");
223
        }
224

225
        [XmlElement("comment", Order = 0)]
226
        public List<CT_Comment> comment
227
        {
228
            get
229
            {
230
                return this.commentField;
231
            }
232
            set
233
            {
234
                this.commentField = value;
235
            }
236
        }
237

238
        public CT_Comment AddNewComment()
239
        {
240
            var comment = new CT_Comment();
241
            commentField.Add(comment);
242
            return comment;
243
        }
244

245
        public void RemoveComment(int i)
246
        {
247
            commentField.RemoveAt(i);
248
        }
249
    }
250

251

252
    [Serializable]
253

254
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
255
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
256
    public class CT_Comment : CT_TrackChange
257
    {
258

259
        private ArrayList itemsField;
260

261
        private List<ItemsChoiceType50> itemsElementNameField;
262

263
        private string initialsField;
264

265
        public CT_Comment()
266
        {
267
            this.itemsElementNameField = new List<ItemsChoiceType50>();
268
            this.itemsField = new ArrayList();
269
        }
270
        public static new CT_Comment Parse(XmlNode node, XmlNamespaceManager namespaceManager)
271
        {
272
            if (node == null)
273
                return null;
274
            CT_Comment ctObj = new CT_Comment();
275
            ctObj.initials = XmlHelper.ReadString(node.Attributes["w:initials"]);
276
            ctObj.author = XmlHelper.ReadString(node.Attributes["w:author"]);
277
            ctObj.date = XmlHelper.ReadString(node.Attributes["w:date"]);
278
            ctObj.id = XmlHelper.ReadString(node.Attributes["w:id"]);
279
            foreach (XmlNode childNode in node.ChildNodes)
280
            {
281
                if (childNode.LocalName == "permStart")
282
                {
283
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
284
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.permStart);
285
                }
286
                else if (childNode.LocalName == "customXmlInsRangeEnd")
287
                {
288
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
289
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXmlInsRangeEnd);
290
                }
291
                else if (childNode.LocalName == "customXmlInsRangeStart")
292
                {
293
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
294
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXmlInsRangeStart);
295
                }
296
                else if (childNode.LocalName == "permEnd")
297
                {
298
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
299
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.permEnd);
300
                }
301
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
302
                {
303
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
304
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXmlMoveFromRangeEnd);
305
                }
306
                else if (childNode.LocalName == "proofErr")
307
                {
308
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
309
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.proofErr);
310
                }
311
                else if (childNode.LocalName == "sdt")
312
                {
313
                    ctObj.Items.Add(CT_SdtBlock.Parse(childNode, namespaceManager));
314
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.sdt);
315
                }
316
                else if (childNode.LocalName == "tbl")
317
                {
318
                    ctObj.Items.Add(CT_Tbl.Parse(childNode, namespaceManager));
319
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.tbl);
320
                }
321
                else if (childNode.LocalName == "moveFromRangeStart")
322
                {
323
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
324
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.moveFromRangeStart);
325
                }
326
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
327
                {
328
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
329
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXmlMoveToRangeEnd);
330
                }
331
                else if (childNode.LocalName == "oMath")
332
                {
333
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
334
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.oMath);
335
                }
336
                else if (childNode.LocalName == "oMathPara")
337
                {
338
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
339
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.oMathPara);
340
                }
341
                else if (childNode.LocalName == "altChunk")
342
                {
343
                    ctObj.Items.Add(CT_AltChunk.Parse(childNode, namespaceManager));
344
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.altChunk);
345
                }
346
                else if (childNode.LocalName == "bookmarkEnd")
347
                {
348
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
349
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.bookmarkEnd);
350
                }
351
                else if (childNode.LocalName == "bookmarkStart")
352
                {
353
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
354
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.bookmarkStart);
355
                }
356
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
357
                {
358
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
359
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXmlMoveToRangeStart);
360
                }
361
                else if (childNode.LocalName == "commentRangeEnd")
362
                {
363
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
364
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.commentRangeEnd);
365
                }
366
                else if (childNode.LocalName == "commentRangeStart")
367
                {
368
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
369
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.commentRangeStart);
370
                }
371
                else if (childNode.LocalName == "moveTo")
372
                {
373
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
374
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.moveTo);
375
                }
376
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
377
                {
378
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
379
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXmlMoveFromRangeStart);
380
                }
381
                else if (childNode.LocalName == "moveToRangeEnd")
382
                {
383
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
384
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.moveToRangeEnd);
385
                }
386
                else if (childNode.LocalName == "customXml")
387
                {
388
                    ctObj.Items.Add(CT_CustomXmlBlock.Parse(childNode, namespaceManager));
389
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXml);
390
                }
391
                else if (childNode.LocalName == "moveToRangeStart")
392
                {
393
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
394
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.moveToRangeStart);
395
                }
396
                else if (childNode.LocalName == "p")
397
                {
398
                    ctObj.Items.Add(CT_P.Parse(childNode, namespaceManager));
399
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.p);
400
                }
401
                else if (childNode.LocalName == "customXmlDelRangeEnd")
402
                {
403
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
404
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXmlDelRangeEnd);
405
                }
406
                else if (childNode.LocalName == "del")
407
                {
408
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
409
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.del);
410
                }
411
                else if (childNode.LocalName == "ins")
412
                {
413
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
414
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.ins);
415
                }
416
                else if (childNode.LocalName == "moveFrom")
417
                {
418
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
419
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.moveFrom);
420
                }
421
                else if (childNode.LocalName == "customXmlDelRangeStart")
422
                {
423
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
424
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.customXmlDelRangeStart);
425
                }
426
                else if (childNode.LocalName == "moveFromRangeEnd")
427
                {
428
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
429
                    ctObj.ItemsElementName.Add(ItemsChoiceType50.moveFromRangeEnd);
430
                }
431
            }
432
            return ctObj;
433
        }
434

435
        internal new void Write(StreamWriter sw, string nodeName)
436
        {
437
            sw.Write(string.Format("<w:{0}", nodeName));
438
            XmlHelper.WriteAttribute(sw, "w:initials", this.initials);
439
            XmlHelper.WriteAttribute(sw, "w:author", this.author);
440
            XmlHelper.WriteAttribute(sw, "w:date", this.date);
441
            XmlHelper.WriteAttribute(sw, "w:id", this.id);
442
            sw.Write(">");
443
            foreach (object o in this.Items)
444
            {
445
                if (o is CT_PermStart)
446
                    ((CT_PermStart)o).Write(sw, "permStart");
447
                else if (o is CT_Markup)
448
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
449
                else if (o is CT_TrackChange)
450
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
451
                else if (o is CT_Perm)
452
                    ((CT_Perm)o).Write(sw, "permEnd");
453
                else if (o is CT_Markup)
454
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
455
                else if (o is CT_ProofErr)
456
                    ((CT_ProofErr)o).Write(sw, "proofErr");
457
                else if (o is CT_SdtBlock)
458
                    ((CT_SdtBlock)o).Write(sw, "sdt");
459
                else if (o is CT_Tbl)
460
                    ((CT_Tbl)o).Write(sw, "tbl");
461
                else if (o is CT_MoveBookmark)
462
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
463
                else if (o is CT_Markup)
464
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
465
                else if (o is CT_OMath)
466
                    ((CT_OMath)o).Write(sw, "oMath");
467
                else if (o is CT_OMathPara)
468
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
469
                else if (o is CT_AltChunk)
470
                    ((CT_AltChunk)o).Write(sw, "altChunk");
471
                else if (o is CT_MarkupRange)
472
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
473
                else if (o is CT_Bookmark)
474
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
475
                else if (o is CT_TrackChange)
476
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
477
                else if (o is CT_MarkupRange)
478
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
479
                else if (o is CT_MarkupRange)
480
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
481
                else if (o is CT_RunTrackChange)
482
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
483
                else if (o is CT_TrackChange)
484
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
485
                else if (o is CT_MarkupRange)
486
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
487
                else if (o is CT_CustomXmlBlock)
488
                    ((CT_CustomXmlBlock)o).Write(sw, "customXml");
489
                else if (o is CT_MoveBookmark)
490
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
491
                else if (o is CT_P)
492
                    ((CT_P)o).Write(sw, "p");
493
                else if (o is CT_Markup)
494
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
495
                else if (o is CT_RunTrackChange)
496
                    ((CT_RunTrackChange)o).Write(sw, "del");
497
                else if (o is CT_RunTrackChange)
498
                    ((CT_RunTrackChange)o).Write(sw, "ins");
499
                else if (o is CT_RunTrackChange)
500
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
501
                else if (o is CT_TrackChange)
502
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
503
                else if (o is CT_MarkupRange)
504
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
505
            }
506
            sw.WriteEndW(nodeName);
507
        }
508

509
        [System.Xml.Serialization.XmlElementAttribute("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
510
        [System.Xml.Serialization.XmlElementAttribute("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
511
        [System.Xml.Serialization.XmlElementAttribute("altChunk", typeof(CT_AltChunk), Order = 0)]
512
        [System.Xml.Serialization.XmlElementAttribute("bookmarkEnd", typeof(CT_MarkupRange), Order = 0)]
513
        [System.Xml.Serialization.XmlElementAttribute("bookmarkStart", typeof(CT_Bookmark), Order = 0)]
514
        [System.Xml.Serialization.XmlElementAttribute("commentRangeEnd", typeof(CT_MarkupRange), Order = 0)]
515
        [System.Xml.Serialization.XmlElementAttribute("commentRangeStart", typeof(CT_MarkupRange), Order = 0)]
516
        [System.Xml.Serialization.XmlElementAttribute("customXml", typeof(CT_CustomXmlBlock), Order = 0)]
517
        [System.Xml.Serialization.XmlElementAttribute("customXmlDelRangeEnd", typeof(CT_Markup), Order = 0)]
518
        [System.Xml.Serialization.XmlElementAttribute("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 0)]
519
        [System.Xml.Serialization.XmlElementAttribute("customXmlInsRangeEnd", typeof(CT_Markup), Order = 0)]
520
        [System.Xml.Serialization.XmlElementAttribute("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 0)]
521
        [System.Xml.Serialization.XmlElementAttribute("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 0)]
522
        [System.Xml.Serialization.XmlElementAttribute("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 0)]
523
        [System.Xml.Serialization.XmlElementAttribute("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 0)]
524
        [System.Xml.Serialization.XmlElementAttribute("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 0)]
525
        [System.Xml.Serialization.XmlElementAttribute("del", typeof(CT_RunTrackChange), Order = 0)]
526
        [System.Xml.Serialization.XmlElementAttribute("ins", typeof(CT_RunTrackChange), Order = 0)]
527
        [System.Xml.Serialization.XmlElementAttribute("moveFrom", typeof(CT_RunTrackChange), Order = 0)]
528
        [System.Xml.Serialization.XmlElementAttribute("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 0)]
529
        [System.Xml.Serialization.XmlElementAttribute("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 0)]
530
        [System.Xml.Serialization.XmlElementAttribute("moveTo", typeof(CT_RunTrackChange), Order = 0)]
531
        [System.Xml.Serialization.XmlElementAttribute("moveToRangeEnd", typeof(CT_MarkupRange), Order = 0)]
532
        [System.Xml.Serialization.XmlElementAttribute("moveToRangeStart", typeof(CT_MoveBookmark), Order = 0)]
533
        [System.Xml.Serialization.XmlElementAttribute("p", typeof(CT_P), Order = 0)]
534
        [System.Xml.Serialization.XmlElementAttribute("permEnd", typeof(CT_Perm), Order = 0)]
535
        [System.Xml.Serialization.XmlElementAttribute("permStart", typeof(CT_PermStart), Order = 0)]
536
        [System.Xml.Serialization.XmlElementAttribute("proofErr", typeof(CT_ProofErr), Order = 0)]
537
        [System.Xml.Serialization.XmlElementAttribute("sdt", typeof(CT_SdtBlock), Order = 0)]
538
        [System.Xml.Serialization.XmlElementAttribute("tbl", typeof(CT_Tbl), Order = 0)]
539
        [System.Xml.Serialization.XmlChoiceIdentifierAttribute("ItemsElementName")]
540
        public ArrayList Items
541
        {
542
            get
543
            {
544
                return this.itemsField;
545
            }
546
            set
547
            {
548
               this.itemsField = value;
549
            }
550
        }
551

552
        [System.Xml.Serialization.XmlElementAttribute("ItemsElementName", Order = 1)]
553
        [System.Xml.Serialization.XmlIgnoreAttribute()]
554
        public List<ItemsChoiceType50> ItemsElementName
555
        {
556
            get
557
            {
558
                return this.itemsElementNameField;
559
            }
560
            set
561
            {
562
                this.itemsElementNameField = value;
563
            }
564
        }
565

566

567

568
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
569
        public string initials
570
        {
571
            get
572
            {
573
                return this.initialsField;
574
            }
575
            set
576
            {
577
                this.initialsField = value;
578
            }
579
        }
580

581
        #region Generic methods for object operation
582

583
        private List<T> GetObjectList<T>(ItemsChoiceType50 type) where T : class
584
        {
585
            lock (this)
586
            {
587
                List<T> list = new List<T>();
588
                for (int i = 0; i < itemsElementNameField.Count; i++)
589
                {
590
                    if (itemsElementNameField[i] == type)
591
                        list.Add(itemsField[i] as T);
592
                }
593
                return list;
594
            }
595
        }
596
        private int SizeOfArray(ItemsChoiceType50 type)
597
        {
598
            lock (this)
599
            {
600
                int size = 0;
601
                for (int i = 0; i < itemsElementNameField.Count; i++)
602
                {
603
                    if (itemsElementNameField[i] == type)
604
                        size++;
605
                }
606
                return size;
607
            }
608
        }
609
        private T GetObjectArray<T>(int p, ItemsChoiceType50 type) where T : class
610
        {
611
            lock (this)
612
            {
613
                int pos = GetObjectIndex(type, p);
614
                if (pos < 0 || pos >= this.itemsField.Count)
615
                    return null;
616
                return itemsField[pos] as T;
617
            }
618
        }
619
        private T InsertNewObject<T>(ItemsChoiceType50 type, int p) where T : class, new()
620
        {
621
            T t = new T();
622
            lock (this)
623
            {
624
                int pos = GetObjectIndex(type, p);
625
                this.itemsElementNameField.Insert(pos, type);
626
                this.itemsField.Insert(pos, t);
627
            }
628
            return t;
629
        }
630
        private T AddNewObject<T>(ItemsChoiceType50 type) where T : class, new()
631
        {
632
            T t = new T();
633
            lock (this)
634
            {
635
                this.itemsElementNameField.Add(type);
636
                this.itemsField.Add(t);
637
            }
638
            return t;
639
        }
640
        private void SetObject<T>(ItemsChoiceType50 type, int p, T obj) where T : class
641
        {
642
            lock (this)
643
            {
644
                int pos = GetObjectIndex(type, p);
645
                if (pos < 0 || pos >= this.itemsField.Count)
646
                    return;
647
                if (this.itemsField[pos] is T)
648
                    this.itemsField[pos] = obj;
649
                else
650
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
651
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
652
            }
653
        }
654
        private int GetObjectIndex(ItemsChoiceType50 type, int p)
655
        {
656
            int index = -1;
657
            int pos = 0;
658
            for (int i = 0; i < itemsElementNameField.Count; i++)
659
            {
660
                if (itemsElementNameField[i] == type)
661
                {
662
                    if (pos == p)
663
                    {
664
                        index = i;
665
                        break;
666
                    }
667
                    else
668
                        pos++;
669
                }
670
            }
671
            return index;
672
        }
673
        private void RemoveObject(ItemsChoiceType50 type, int p)
674
        {
675
            lock (this)
676
            {
677
                int pos = GetObjectIndex(type, p);
678
                if (pos < 0 || pos >= this.itemsField.Count)
679
                    return;
680
                itemsElementNameField.RemoveAt(pos);
681
                itemsField.RemoveAt(pos);
682
            }
683
        }
684
        #endregion
685

686
        #pragma warning disable format
687
        public CT_AltChunk       AddNewAltChunk()                    { return AddNewObject<CT_AltChunk>      (ItemsChoiceType50.altChunk); }
688
        public CT_MarkupRange    AddNewBookmarkEnd()                 { return AddNewObject<CT_MarkupRange>   (ItemsChoiceType50.bookmarkEnd); }
689
        public CT_Bookmark       AddNewBookmarkStart()               { return AddNewObject<CT_Bookmark>      (ItemsChoiceType50.bookmarkStart); }
690
        public CT_MarkupRange    AddNewCommentRangeEnd()             { return AddNewObject<CT_MarkupRange>   (ItemsChoiceType50.commentRangeEnd); }
691
        public CT_MarkupRange    AddNewCommentRangeStart()           { return AddNewObject<CT_MarkupRange>   (ItemsChoiceType50.commentRangeStart); }
692
        public CT_CustomXmlBlock AddNewCustomXml()                   { return AddNewObject<CT_CustomXmlBlock>(ItemsChoiceType50.customXml); }
693
        public CT_Markup         AddNewCustomXmlDelRangeEnd()        { return AddNewObject<CT_Markup>        (ItemsChoiceType50.customXmlDelRangeEnd); }
694
        public CT_TrackChange    AddNewCustomXmlDelRangeStart()      { return AddNewObject<CT_TrackChange>   (ItemsChoiceType50.customXmlDelRangeStart); }
695
        public CT_Markup         AddNewCustomXmlInsRangeEnd()        { return AddNewObject<CT_Markup>        (ItemsChoiceType50.customXmlInsRangeEnd); }
696
        public CT_TrackChange    AddNewCustomXmlInsRangeStart()      { return AddNewObject<CT_TrackChange>   (ItemsChoiceType50.customXmlInsRangeStart); }
697
        public CT_Markup         AddNewCustomXmlMoveFromRangeEnd()   { return AddNewObject<CT_Markup>        (ItemsChoiceType50.customXmlMoveFromRangeEnd); }
698
        public CT_TrackChange    AddNewCustomXmlMoveFromRangeStart() { return AddNewObject<CT_TrackChange>   (ItemsChoiceType50.customXmlMoveFromRangeStart); }
699
        public CT_Markup         AddNewCustomXmlMoveToRangeEnd()     { return AddNewObject<CT_Markup>        (ItemsChoiceType50.customXmlMoveToRangeEnd); }
700
        public CT_TrackChange    AddNewCustomXmlMoveToRangeStart()   { return AddNewObject<CT_TrackChange>   (ItemsChoiceType50.customXmlMoveToRangeStart); }
701
        public CT_RunTrackChange AddNewDel()                         { return AddNewObject<CT_RunTrackChange>(ItemsChoiceType50.del); }
702
        public CT_RunTrackChange AddNewIns()                         { return AddNewObject<CT_RunTrackChange>(ItemsChoiceType50.ins); }
703
        public CT_RunTrackChange AddNewMoveFrom()                    { return AddNewObject<CT_RunTrackChange>(ItemsChoiceType50.moveFrom); }
704
        public CT_MarkupRange    AddNewMoveFromRangeEnd()            { return AddNewObject<CT_MarkupRange>   (ItemsChoiceType50.moveFromRangeEnd); }
705
        public CT_MoveBookmark   AddNewMoveFromRangeStart()          { return AddNewObject<CT_MoveBookmark>  (ItemsChoiceType50.moveFromRangeStart); }
706
        public CT_RunTrackChange AddNewMoveTo()                      { return AddNewObject<CT_RunTrackChange>(ItemsChoiceType50.moveTo); }
707
        public CT_MarkupRange    AddNewMoveToRangeEnd()              { return AddNewObject<CT_MarkupRange>   (ItemsChoiceType50.moveToRangeEnd); }
708
        public CT_MoveBookmark   AddNewMoveToRangeStart()            { return AddNewObject<CT_MoveBookmark>  (ItemsChoiceType50.moveToRangeStart); }
709
        public CT_OMath          AddNewOMath()                       { return AddNewObject<CT_OMath>         (ItemsChoiceType50.oMath); }
710
        public CT_OMathPara      AddNewOMathPara()                   { return AddNewObject<CT_OMathPara>     (ItemsChoiceType50.oMathPara); }
711
        public CT_P              AddNewP()                           { return AddNewObject<CT_P>             (ItemsChoiceType50.p); }
712
        public CT_Perm           AddNewPermEnd()                     { return AddNewObject<CT_Perm>          (ItemsChoiceType50.permEnd); }
713
        public CT_PermStart      AddNewPermStart()                   { return AddNewObject<CT_PermStart>     (ItemsChoiceType50.permStart); }
714
        public CT_ProofErr       AddNewProofErr()                    { return AddNewObject<CT_ProofErr>      (ItemsChoiceType50.proofErr); }
715
        public CT_SdtBlock       AddNewSdt()                         { return AddNewObject<CT_SdtBlock>      (ItemsChoiceType50.sdt); }
716
        public CT_Tbl            AddNewTbl()                         { return AddNewObject<CT_Tbl>           (ItemsChoiceType50.tbl); }
717

718
        public CT_AltChunk       GetAltChunkArray(int p)                    { return GetObjectArray<CT_AltChunk>      (p, ItemsChoiceType50.altChunk); }
719
        public CT_MarkupRange    GetBookmarkEndArray(int p)                 { return GetObjectArray<CT_MarkupRange>   (p, ItemsChoiceType50.bookmarkEnd); }
720
        public CT_Bookmark       GetBookmarkStartArray(int p)               { return GetObjectArray<CT_Bookmark>      (p, ItemsChoiceType50.bookmarkStart); }
721
        public CT_MarkupRange    GetCommentRangeEndArray(int p)             { return GetObjectArray<CT_MarkupRange>   (p, ItemsChoiceType50.commentRangeEnd); }
722
        public CT_MarkupRange    GetCommentRangeStartArray(int p)           { return GetObjectArray<CT_MarkupRange>   (p, ItemsChoiceType50.commentRangeStart); }
723
        public CT_CustomXmlBlock GetCustomXmlArray(int p)                   { return GetObjectArray<CT_CustomXmlBlock>(p, ItemsChoiceType50.customXml); }
724
        public CT_Markup         GetCustomXmlDelRangeEndArray(int p)        { return GetObjectArray<CT_Markup>        (p, ItemsChoiceType50.customXmlDelRangeEnd); }
725
        public CT_TrackChange    GetCustomXmlDelRangeStartArray(int p)      { return GetObjectArray<CT_TrackChange>   (p, ItemsChoiceType50.customXmlDelRangeStart); }
726
        public CT_Markup         GetCustomXmlInsRangeEndArray(int p)        { return GetObjectArray<CT_Markup>        (p, ItemsChoiceType50.customXmlInsRangeEnd); }
727
        public CT_TrackChange    GetCustomXmlInsRangeStartArray(int p)      { return GetObjectArray<CT_TrackChange>   (p, ItemsChoiceType50.customXmlInsRangeStart); }
728
        public CT_Markup         GetCustomXmlMoveFromRangeEndArray(int p)   { return GetObjectArray<CT_Markup>        (p, ItemsChoiceType50.customXmlMoveFromRangeEnd); }
729
        public CT_TrackChange    GetCustomXmlMoveFromRangeStartArray(int p) { return GetObjectArray<CT_TrackChange>   (p, ItemsChoiceType50.customXmlMoveFromRangeStart); }
730
        public CT_Markup         GetCustomXmlMoveToRangeEndArray(int p)     { return GetObjectArray<CT_Markup>        (p, ItemsChoiceType50.customXmlMoveToRangeEnd); }
731
        public CT_TrackChange    GetCustomXmlMoveToRangeStartArray(int p)   { return GetObjectArray<CT_TrackChange>   (p, ItemsChoiceType50.customXmlMoveToRangeStart); }
732
        public CT_RunTrackChange GetDelArray(int p)                         { return GetObjectArray<CT_RunTrackChange>(p, ItemsChoiceType50.del); }
733
        public CT_RunTrackChange GetInsArray(int p)                         { return GetObjectArray<CT_RunTrackChange>(p, ItemsChoiceType50.ins); }
734
        public CT_RunTrackChange GetMoveFromArray(int p)                    { return GetObjectArray<CT_RunTrackChange>(p, ItemsChoiceType50.moveFrom); }
735
        public CT_MarkupRange    GetMoveFromRangeEndArray(int p)            { return GetObjectArray<CT_MarkupRange>   (p, ItemsChoiceType50.moveFromRangeEnd); }
736
        public CT_MoveBookmark   GetMoveFromRangeStartArray(int p)          { return GetObjectArray<CT_MoveBookmark>  (p, ItemsChoiceType50.moveFromRangeStart); }
737
        public CT_RunTrackChange GetMoveToArray(int p)                      { return GetObjectArray<CT_RunTrackChange>(p, ItemsChoiceType50.moveTo); }
738
        public CT_MarkupRange    GetMoveToRangeEndArray(int p)              { return GetObjectArray<CT_MarkupRange>   (p, ItemsChoiceType50.moveToRangeEnd); }
739
        public CT_MoveBookmark   GetMoveToRangeStartArray(int p)            { return GetObjectArray<CT_MoveBookmark>  (p, ItemsChoiceType50.moveToRangeStart); }
740
        public CT_OMath          GetOMathArray(int p)                       { return GetObjectArray<CT_OMath>         (p, ItemsChoiceType50.oMath); }
741
        public CT_OMathPara      GetOMathParaArray(int p)                   { return GetObjectArray<CT_OMathPara>     (p, ItemsChoiceType50.oMathPara); }
742
        public CT_P              GetPArray(int p)                           { return GetObjectArray<CT_P>             (p, ItemsChoiceType50.p); }
743
        public CT_Perm           GetPermEndArray(int p)                     { return GetObjectArray<CT_Perm>          (p, ItemsChoiceType50.permEnd); }
744
        public CT_PermStart      GetPermStartArray(int p)                   { return GetObjectArray<CT_PermStart>     (p, ItemsChoiceType50.permStart); }
745
        public CT_ProofErr       GetProofErrArray(int p)                    { return GetObjectArray<CT_ProofErr>      (p, ItemsChoiceType50.proofErr); }
746
        public CT_SdtBlock       GetSdtArray(int p)                         { return GetObjectArray<CT_SdtBlock>      (p, ItemsChoiceType50.sdt); }
747
        public CT_Tbl            GetTblArray(int p)                         { return GetObjectArray<CT_Tbl>           (p, ItemsChoiceType50.tbl); }
748

749
        public IList<CT_AltChunk>       GetAltChunkList()                    { return GetObjectList<CT_AltChunk>      (ItemsChoiceType50.altChunk); }
750
        public IList<CT_MarkupRange>    GetBookmarkEndList()                 { return GetObjectList<CT_MarkupRange>   (ItemsChoiceType50.bookmarkEnd); }
751
        public IList<CT_Bookmark>       GetBookmarkStartList()               { return GetObjectList<CT_Bookmark>      (ItemsChoiceType50.bookmarkStart); }
752
        public IList<CT_MarkupRange>    GetCommentRangeEndList()             { return GetObjectList<CT_MarkupRange>   (ItemsChoiceType50.commentRangeEnd); }
753
        public IList<CT_MarkupRange>    GetCommentRangeStartList()           { return GetObjectList<CT_MarkupRange>   (ItemsChoiceType50.commentRangeStart); }
754
        public IList<CT_CustomXmlBlock> GetCustomXmlList()                   { return GetObjectList<CT_CustomXmlBlock>(ItemsChoiceType50.customXml); }
755
        public IList<CT_Markup>         GetCustomXmlDelRangeEndList()        { return GetObjectList<CT_Markup>        (ItemsChoiceType50.customXmlDelRangeEnd); }
756
        public IList<CT_TrackChange>    GetCustomXmlDelRangeStartList()      { return GetObjectList<CT_TrackChange>   (ItemsChoiceType50.customXmlDelRangeStart); }
757
        public IList<CT_Markup>         GetCustomXmlInsRangeEndList()        { return GetObjectList<CT_Markup>        (ItemsChoiceType50.customXmlInsRangeEnd); }
758
        public IList<CT_TrackChange>    GetCustomXmlInsRangeStartList()      { return GetObjectList<CT_TrackChange>   (ItemsChoiceType50.customXmlInsRangeStart); }
759
        public IList<CT_Markup>         GetCustomXmlMoveFromRangeEndList()   { return GetObjectList<CT_Markup>        (ItemsChoiceType50.customXmlMoveFromRangeEnd); }
760
        public IList<CT_TrackChange>    GetCustomXmlMoveFromRangeStartList() { return GetObjectList<CT_TrackChange>   (ItemsChoiceType50.customXmlMoveFromRangeStart); }
761
        public IList<CT_Markup>         GetCustomXmlMoveToRangeEndList()     { return GetObjectList<CT_Markup>        (ItemsChoiceType50.customXmlMoveToRangeEnd); }
762
        public IList<CT_TrackChange>    GetCustomXmlMoveToRangeStartList()   { return GetObjectList<CT_TrackChange>   (ItemsChoiceType50.customXmlMoveToRangeStart); }
763
        public IList<CT_RunTrackChange> GetDelList()                         { return GetObjectList<CT_RunTrackChange>(ItemsChoiceType50.del); }
764
        public IList<CT_RunTrackChange> GetInsList()                         { return GetObjectList<CT_RunTrackChange>(ItemsChoiceType50.ins); }
765
        public IList<CT_RunTrackChange> GetMoveFromList()                    { return GetObjectList<CT_RunTrackChange>(ItemsChoiceType50.moveFrom); }
766
        public IList<CT_MarkupRange>    GetMoveFromRangeEndList()            { return GetObjectList<CT_MarkupRange>   (ItemsChoiceType50.moveFromRangeEnd); }
767
        public IList<CT_MoveBookmark>   GetMoveFromRangeStartList()          { return GetObjectList<CT_MoveBookmark>  (ItemsChoiceType50.moveFromRangeStart); }
768
        public IList<CT_RunTrackChange> GetMoveToList()                      { return GetObjectList<CT_RunTrackChange>(ItemsChoiceType50.moveTo); }
769
        public IList<CT_MarkupRange>    GetMoveToRangeEndList()              { return GetObjectList<CT_MarkupRange>   (ItemsChoiceType50.moveToRangeEnd); }
770
        public IList<CT_MoveBookmark>   GetMoveToRangeStartList()            { return GetObjectList<CT_MoveBookmark>  (ItemsChoiceType50.moveToRangeStart); }
771
        public IList<CT_OMath>          GetOMathList()                       { return GetObjectList<CT_OMath>         (ItemsChoiceType50.oMath); }
772
        public IList<CT_OMathPara>      GetOMathParaList()                   { return GetObjectList<CT_OMathPara>     (ItemsChoiceType50.oMathPara); }
773
        public IList<CT_P>              GetPList()                           { return GetObjectList<CT_P>             (ItemsChoiceType50.p); }
774
        public IList<CT_Perm>           GetPermEndList()                     { return GetObjectList<CT_Perm>          (ItemsChoiceType50.permEnd); }
775
        public IList<CT_PermStart>      GetPermStartList()                   { return GetObjectList<CT_PermStart>     (ItemsChoiceType50.permStart); }
776
        public IList<CT_ProofErr>       GetProofErrList()                    { return GetObjectList<CT_ProofErr>      (ItemsChoiceType50.proofErr); }
777
        public IList<CT_SdtBlock>       GetSdtList()                         { return GetObjectList<CT_SdtBlock>      (ItemsChoiceType50.sdt); }
778
        public IList<CT_Tbl>            GetTblList()                         { return GetObjectList<CT_Tbl>           (ItemsChoiceType50.tbl); }
779

780
        public CT_AltChunk       InsertNewAltChunk(int p)                    { return InsertNewObject<CT_AltChunk>      (ItemsChoiceType50.altChunk, p); }
781
        public CT_MarkupRange    InsertNewBookmarkEnd(int p)                 { return InsertNewObject<CT_MarkupRange>   (ItemsChoiceType50.bookmarkEnd, p); }
782
        public CT_Bookmark       InsertNewBookmarkStart(int p)               { return InsertNewObject<CT_Bookmark>      (ItemsChoiceType50.bookmarkStart, p); }
783
        public CT_MarkupRange    InsertNewCommentRangeEnd(int p)             { return InsertNewObject<CT_MarkupRange>   (ItemsChoiceType50.commentRangeEnd, p); }
784
        public CT_MarkupRange    InsertNewCommentRangeStart(int p)           { return InsertNewObject<CT_MarkupRange>   (ItemsChoiceType50.commentRangeStart, p); }
785
        public CT_CustomXmlBlock InsertNewCustomXml(int p)                   { return InsertNewObject<CT_CustomXmlBlock>(ItemsChoiceType50.customXml, p); }
786
        public CT_Markup         InsertNewCustomXmlDelRangeEnd(int p)        { return InsertNewObject<CT_Markup>        (ItemsChoiceType50.customXmlDelRangeEnd, p); }
787
        public CT_TrackChange    InsertNewCustomXmlDelRangeStart(int p)      { return InsertNewObject<CT_TrackChange>   (ItemsChoiceType50.customXmlDelRangeStart, p); }
788
        public CT_Markup         InsertNewCustomXmlInsRangeEnd(int p)        { return InsertNewObject<CT_Markup>        (ItemsChoiceType50.customXmlInsRangeEnd, p); }
789
        public CT_TrackChange    InsertNewCustomXmlInsRangeStart(int p)      { return InsertNewObject<CT_TrackChange>   (ItemsChoiceType50.customXmlInsRangeStart, p); }
790
        public CT_Markup         InsertNewCustomXmlMoveFromRangeEnd(int p)   { return InsertNewObject<CT_Markup>        (ItemsChoiceType50.customXmlMoveFromRangeEnd, p); }
791
        public CT_TrackChange    InsertNewCustomXmlMoveFromRangeStart(int p) { return InsertNewObject<CT_TrackChange>   (ItemsChoiceType50.customXmlMoveFromRangeStart, p); }
792
        public CT_Markup         InsertNewCustomXmlMoveToRangeEnd(int p)     { return InsertNewObject<CT_Markup>        (ItemsChoiceType50.customXmlMoveToRangeEnd, p); }
793
        public CT_TrackChange    InsertNewCustomXmlMoveToRangeStart(int p)   { return InsertNewObject<CT_TrackChange>   (ItemsChoiceType50.customXmlMoveToRangeStart, p); }
794
        public CT_RunTrackChange InsertNewDel(int p)                         { return InsertNewObject<CT_RunTrackChange>(ItemsChoiceType50.del, p); }
795
        public CT_RunTrackChange InsertNewIns(int p)                         { return InsertNewObject<CT_RunTrackChange>(ItemsChoiceType50.ins, p); }
796
        public CT_RunTrackChange InsertNewMoveFrom(int p)                    { return InsertNewObject<CT_RunTrackChange>(ItemsChoiceType50.moveFrom, p); }
797
        public CT_MarkupRange    InsertNewMoveFromRangeEnd(int p)            { return InsertNewObject<CT_MarkupRange>   (ItemsChoiceType50.moveFromRangeEnd, p); }
798
        public CT_MoveBookmark   InsertNewMoveFromRangeStart(int p)          { return InsertNewObject<CT_MoveBookmark>  (ItemsChoiceType50.moveFromRangeStart, p); }
799
        public CT_RunTrackChange InsertNewMoveTo(int p)                      { return InsertNewObject<CT_RunTrackChange>(ItemsChoiceType50.moveTo, p); }
800
        public CT_MarkupRange    InsertNewMoveToRangeEnd(int p)              { return InsertNewObject<CT_MarkupRange>   (ItemsChoiceType50.moveToRangeEnd, p); }
801
        public CT_MoveBookmark   InsertNewMoveToRangeStart(int p)            { return InsertNewObject<CT_MoveBookmark>  (ItemsChoiceType50.moveToRangeStart, p); }
802
        public CT_OMath          InsertNewOMath(int p)                       { return InsertNewObject<CT_OMath>         (ItemsChoiceType50.oMath, p); }
803
        public CT_OMathPara      InsertNewOMathPara(int p)                   { return InsertNewObject<CT_OMathPara>     (ItemsChoiceType50.oMathPara, p); }
804
        public CT_P              InsertNewP(int p)                           { return InsertNewObject<CT_P>             (ItemsChoiceType50.p, p); }
805
        public CT_Perm           InsertNewPermEnd(int p)                     { return InsertNewObject<CT_Perm>          (ItemsChoiceType50.permEnd, p); }
806
        public CT_PermStart      InsertNewPermStart(int p)                   { return InsertNewObject<CT_PermStart>     (ItemsChoiceType50.permStart, p); }
807
        public CT_ProofErr       InsertNewProofErr(int p)                    { return InsertNewObject<CT_ProofErr>      (ItemsChoiceType50.proofErr, p); }
808
        public CT_SdtBlock       InsertNewSdt(int p)                         { return InsertNewObject<CT_SdtBlock>      (ItemsChoiceType50.sdt, p); }
809
        public CT_Tbl            InsertNewTbl(int p)                         { return InsertNewObject<CT_Tbl>           (ItemsChoiceType50.tbl, p); }
810

811
        public void RemoveAltChunk(int p)                    { RemoveObject(ItemsChoiceType50.altChunk, p); }
812
        public void RemoveBookmarkEnd(int p)                 { RemoveObject(ItemsChoiceType50.bookmarkEnd, p); }
813
        public void RemoveBookmarkStart(int p)               { RemoveObject(ItemsChoiceType50.bookmarkStart, p); }
814
        public void RemoveCommentRangeEnd(int p)             { RemoveObject(ItemsChoiceType50.commentRangeEnd, p); }
815
        public void RemoveCommentRangeStart(int p)           { RemoveObject(ItemsChoiceType50.commentRangeStart, p); }
816
        public void RemoveCustomXml(int p)                   { RemoveObject(ItemsChoiceType50.customXml, p); }
817
        public void RemoveCustomXmlDelRangeEnd(int p)        { RemoveObject(ItemsChoiceType50.customXmlDelRangeEnd, p); }
818
        public void RemoveCustomXmlDelRangeStart(int p)      { RemoveObject(ItemsChoiceType50.customXmlDelRangeStart, p); }
819
        public void RemoveCustomXmlInsRangeEnd(int p)        { RemoveObject(ItemsChoiceType50.customXmlInsRangeEnd, p); }
820
        public void RemoveCustomXmlInsRangeStart(int p)      { RemoveObject(ItemsChoiceType50.customXmlInsRangeStart, p); }
821
        public void RemoveCustomXmlMoveFromRangeEnd(int p)   { RemoveObject(ItemsChoiceType50.customXmlMoveFromRangeEnd, p); }
822
        public void RemoveCustomXmlMoveFromRangeStart(int p) { RemoveObject(ItemsChoiceType50.customXmlMoveFromRangeStart, p); }
823
        public void RemoveCustomXmlMoveToRangeEnd(int p)     { RemoveObject(ItemsChoiceType50.customXmlMoveToRangeEnd, p); }
824
        public void RemoveCustomXmlMoveToRangeStart(int p)   { RemoveObject(ItemsChoiceType50.customXmlMoveToRangeStart, p); }
825
        public void RemoveDel(int p)                         { RemoveObject(ItemsChoiceType50.del, p); }
826
        public void RemoveIns(int p)                         { RemoveObject(ItemsChoiceType50.ins, p); }
827
        public void RemoveMoveFrom(int p)                    { RemoveObject(ItemsChoiceType50.moveFrom, p); }
828
        public void RemoveMoveFromRangeEnd(int p)            { RemoveObject(ItemsChoiceType50.moveFromRangeEnd, p); }
829
        public void RemoveMoveFromRangeStart(int p)          { RemoveObject(ItemsChoiceType50.moveFromRangeStart, p); }
830
        public void RemoveMoveTo(int p)                      { RemoveObject(ItemsChoiceType50.moveTo, p); }
831
        public void RemoveMoveToRangeEnd(int p)              { RemoveObject(ItemsChoiceType50.moveToRangeEnd, p); }
832
        public void RemoveMoveToRangeStart(int p)            { RemoveObject(ItemsChoiceType50.moveToRangeStart, p); }
833
        public void RemoveOMath(int p)                       { RemoveObject(ItemsChoiceType50.oMath, p); }
834
        public void RemoveOMathPara(int p)                   { RemoveObject(ItemsChoiceType50.oMathPara, p); }
835
        public void RemoveP(int p)                           { RemoveObject(ItemsChoiceType50.p, p); }
836
        public void RemovePermEnd(int p)                     { RemoveObject(ItemsChoiceType50.permEnd, p); }
837
        public void RemovePermStart(int p)                   { RemoveObject(ItemsChoiceType50.permStart, p); }
838
        public void RemoveProofErr(int p)                    { RemoveObject(ItemsChoiceType50.proofErr, p); }
839
        public void RemoveSdt(int p)                         { RemoveObject(ItemsChoiceType50.sdt, p); }
840
        public void RemoveTbl(int p)                         { RemoveObject(ItemsChoiceType50.tbl, p); }
841

842
        public void SetAltChunkArray(int p, CT_AltChunk obj)                       { SetObject(ItemsChoiceType50.altChunk, p, obj); }
843
        public void SetBookmarkEndArray(int p, CT_MarkupRange obj)                 { SetObject(ItemsChoiceType50.bookmarkEnd, p, obj); }
844
        public void SetBookmarkStartArray(int p, CT_Bookmark obj)                  { SetObject(ItemsChoiceType50.bookmarkStart, p, obj); }
845
        public void SetCommentRangeEndArray(int p, CT_MarkupRange obj)             { SetObject(ItemsChoiceType50.commentRangeEnd, p, obj); }
846
        public void SetCommentRangeStartArray(int p, CT_MarkupRange obj)           { SetObject(ItemsChoiceType50.commentRangeStart, p, obj); }
847
        public void SetCustomXmlArray(int p, CT_CustomXmlBlock obj)                { SetObject(ItemsChoiceType50.customXml, p, obj); }
848
        public void SetCustomXmlDelRangeEndArray(int p, CT_Markup obj)             { SetObject(ItemsChoiceType50.customXmlDelRangeEnd, p, obj); }
849
        public void SetCustomXmlDelRangeStartArray(int p, CT_TrackChange obj)      { SetObject(ItemsChoiceType50.customXmlDelRangeStart, p, obj); }
850
        public void SetCustomXmlInsRangeEndArray(int p, CT_Markup obj)             { SetObject(ItemsChoiceType50.customXmlInsRangeEnd, p, obj); }
851
        public void SetCustomXmlInsRangeStartArray(int p, CT_TrackChange obj)      { SetObject(ItemsChoiceType50.customXmlInsRangeStart, p, obj); }
852
        public void SetCustomXmlMoveFromRangeEndArray(int p, CT_Markup obj)        { SetObject(ItemsChoiceType50.customXmlMoveFromRangeEnd, p, obj); }
853
        public void SetCustomXmlMoveFromRangeStartArray(int p, CT_TrackChange obj) { SetObject(ItemsChoiceType50.customXmlMoveFromRangeStart, p, obj); }
854
        public void SetCustomXmlMoveToRangeEndArray(int p, CT_Markup obj)          { SetObject(ItemsChoiceType50.customXmlMoveToRangeEnd, p, obj); }
855
        public void SetCustomXmlMoveToRangeStartArray(int p, CT_TrackChange obj)   { SetObject(ItemsChoiceType50.customXmlMoveToRangeStart, p, obj); }
856
        public void SetDelArray(int p, CT_RunTrackChange obj)                      { SetObject(ItemsChoiceType50.del, p, obj); }
857
        public void SetInsArray(int p, CT_RunTrackChange obj)                      { SetObject(ItemsChoiceType50.ins, p, obj); }
858
        public void SetMoveFromArray(int p, CT_RunTrackChange obj)                 { SetObject(ItemsChoiceType50.moveFrom, p, obj); }
859
        public void SetMoveFromRangeEndArray(int p, CT_MarkupRange obj)            { SetObject(ItemsChoiceType50.moveFromRangeEnd, p, obj); }
860
        public void SetMoveFromRangeStartArray(int p, CT_MoveBookmark obj)         { SetObject(ItemsChoiceType50.moveFromRangeStart, p, obj); }
861
        public void SetMoveToArray(int p, CT_RunTrackChange obj)                   { SetObject(ItemsChoiceType50.moveTo, p, obj); }
862
        public void SetMoveToRangeEndArray(int p, CT_MarkupRange obj)              { SetObject(ItemsChoiceType50.moveToRangeEnd, p, obj); }
863
        public void SetMoveToRangeStartArray(int p, CT_MoveBookmark obj)           { SetObject(ItemsChoiceType50.moveToRangeStart, p, obj); }
864
        public void SetOMathArray(int p, CT_OMath obj)                             { SetObject(ItemsChoiceType50.oMath, p, obj); }
865
        public void SetOMathParaArray(int p, CT_OMathPara obj)                     { SetObject(ItemsChoiceType50.oMathPara, p, obj); }
866
        public void SetPArray(int p, CT_P obj)                                     { SetObject(ItemsChoiceType50.p, p, obj); }
867
        public void SetPermEndArray(int p, CT_Perm obj)                            { SetObject(ItemsChoiceType50.permEnd, p, obj); }
868
        public void SetPermStartArray(int p, CT_PermStart obj)                     { SetObject(ItemsChoiceType50.permStart, p, obj); }
869
        public void SetProofErrArray(int p, CT_ProofErr obj)                       { SetObject(ItemsChoiceType50.proofErr, p, obj); }
870
        public void SetSdtArray(int p, CT_SdtBlock obj)                            { SetObject(ItemsChoiceType50.sdt, p, obj); }
871
        public void SetTblArray(int p, CT_Tbl obj)                                 { SetObject(ItemsChoiceType50.tbl, p, obj); }
872

873
        public int SizeOfAltChunkArray()                    { return SizeOfArray(ItemsChoiceType50.altChunk); }
874
        public int SizeOfBookmarkEndArray()                 { return SizeOfArray(ItemsChoiceType50.bookmarkEnd); }
875
        public int SizeOfBookmarkStartArray()               { return SizeOfArray(ItemsChoiceType50.bookmarkStart); }
876
        public int SizeOfCommentRangeEndArray()             { return SizeOfArray(ItemsChoiceType50.commentRangeEnd); }
877
        public int SizeOfCommentRangeStartArray()           { return SizeOfArray(ItemsChoiceType50.commentRangeStart); }
878
        public int SizeOfCustomXmlArray()                   { return SizeOfArray(ItemsChoiceType50.customXml); }
879
        public int SizeOfCustomXmlDelRangeEndArray()        { return SizeOfArray(ItemsChoiceType50.customXmlDelRangeEnd); }
880
        public int SizeOfCustomXmlDelRangeStartArray()      { return SizeOfArray(ItemsChoiceType50.customXmlDelRangeStart); }
881
        public int SizeOfCustomXmlInsRangeEndArray()        { return SizeOfArray(ItemsChoiceType50.customXmlInsRangeEnd); }
882
        public int SizeOfCustomXmlInsRangeStartArray()      { return SizeOfArray(ItemsChoiceType50.customXmlInsRangeStart); }
883
        public int SizeOfCustomXmlMoveFromRangeEndArray()   { return SizeOfArray(ItemsChoiceType50.customXmlMoveFromRangeEnd); }
884
        public int SizeOfCustomXmlMoveFromRangeStartArray() { return SizeOfArray(ItemsChoiceType50.customXmlMoveFromRangeStart); }
885
        public int SizeOfCustomXmlMoveToRangeEndArray()     { return SizeOfArray(ItemsChoiceType50.customXmlMoveToRangeEnd); }
886
        public int SizeOfCustomXmlMoveToRangeStartArray()   { return SizeOfArray(ItemsChoiceType50.customXmlMoveToRangeStart); }
887
        public int SizeOfDelArray()                         { return SizeOfArray(ItemsChoiceType50.del); }
888
        public int SizeOfInsArray()                         { return SizeOfArray(ItemsChoiceType50.ins); }
889
        public int SizeOfMoveFromArray()                    { return SizeOfArray(ItemsChoiceType50.moveFrom); }
890
        public int SizeOfMoveFromRangeEndArray()            { return SizeOfArray(ItemsChoiceType50.moveFromRangeEnd); }
891
        public int SizeOfMoveFromRangeStartArray()          { return SizeOfArray(ItemsChoiceType50.moveFromRangeStart); }
892
        public int SizeOfMoveToArray()                      { return SizeOfArray(ItemsChoiceType50.moveTo); }
893
        public int SizeOfMoveToRangeEndArray()              { return SizeOfArray(ItemsChoiceType50.moveToRangeEnd); }
894
        public int SizeOfMoveToRangeStartArray()            { return SizeOfArray(ItemsChoiceType50.moveToRangeStart); }
895
        public int SizeOfOMathArray()                       { return SizeOfArray(ItemsChoiceType50.oMath); }
896
        public int SizeOfOMathParaArray()                   { return SizeOfArray(ItemsChoiceType50.oMathPara); }
897
        public int SizeOfPArray()                           { return SizeOfArray(ItemsChoiceType50.p); }
898
        public int SizeOfPermEndArray()                     { return SizeOfArray(ItemsChoiceType50.permEnd); }
899
        public int SizeOfPermStartArray()                   { return SizeOfArray(ItemsChoiceType50.permStart); }
900
        public int SizeOfProofErrArray()                    { return SizeOfArray(ItemsChoiceType50.proofErr); }
901
        public int SizeOfSdtArray()                         { return SizeOfArray(ItemsChoiceType50.sdt); }
902
        public int SizeOfTblArray()                         { return SizeOfArray(ItemsChoiceType50.tbl); }
903
        #pragma warning restore format
904
    }
905
    [System.SerializableAttribute()]
906
    [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
907
    public enum ItemsChoiceType50
908
    {
909

910
        /// <remarks/>
911
        [System.Xml.Serialization.XmlEnumAttribute("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
912
        oMath,
913

914
        /// <remarks/>
915
        [System.Xml.Serialization.XmlEnumAttribute("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
916
        oMathPara,
917

918
        /// <remarks/>
919
        altChunk,
920

921
        /// <remarks/>
922
        bookmarkEnd,
923

924
        /// <remarks/>
925
        bookmarkStart,
926

927
        /// <remarks/>
928
        commentRangeEnd,
929

930
        /// <remarks/>
931
        commentRangeStart,
932

933
        /// <remarks/>
934
        customXml,
935

936
        /// <remarks/>
937
        customXmlDelRangeEnd,
938

939
        /// <remarks/>
940
        customXmlDelRangeStart,
941

942
        /// <remarks/>
943
        customXmlInsRangeEnd,
944

945
        /// <remarks/>
946
        customXmlInsRangeStart,
947

948
        /// <remarks/>
949
        customXmlMoveFromRangeEnd,
950

951
        /// <remarks/>
952
        customXmlMoveFromRangeStart,
953

954
        /// <remarks/>
955
        customXmlMoveToRangeEnd,
956

957
        /// <remarks/>
958
        customXmlMoveToRangeStart,
959

960
        /// <remarks/>
961
        del,
962

963
        /// <remarks/>
964
        ins,
965

966
        /// <remarks/>
967
        moveFrom,
968

969
        /// <remarks/>
970
        moveFromRangeEnd,
971

972
        /// <remarks/>
973
        moveFromRangeStart,
974

975
        /// <remarks/>
976
        moveTo,
977

978
        /// <remarks/>
979
        moveToRangeEnd,
980

981
        /// <remarks/>
982
        moveToRangeStart,
983

984
        /// <remarks/>
985
        p,
986

987
        /// <remarks/>
988
        permEnd,
989

990
        /// <remarks/>
991
        permStart,
992

993
        /// <remarks/>
994
        proofErr,
995

996
        /// <remarks/>
997
        sdt,
998

999
        /// <remarks/>
1000
        tbl,
1001
    }
1002
    [XmlInclude(typeof(CT_RunTrackChange))]
1003
    [XmlInclude(typeof(CT_RPrChange))]
1004
    [XmlInclude(typeof(CT_ParaRPrChange))]
1005
    [XmlInclude(typeof(CT_PPrChange))]
1006
    [XmlInclude(typeof(CT_SectPrChange))]
1007
    [XmlInclude(typeof(CT_TblPrChange))]
1008
    [XmlInclude(typeof(CT_TrPrChange))]
1009
    [XmlInclude(typeof(CT_TcPrChange))]
1010
    [XmlInclude(typeof(CT_TblPrExChange))]
1011
    [XmlInclude(typeof(CT_TrackChangeNumbering))]
1012
    [XmlInclude(typeof(CT_Comment))]
1013
    [XmlInclude(typeof(CT_TrackChangeRange))]
1014
    [XmlInclude(typeof(CT_CellMergeTrackChange))]
1015

1016
    [Serializable]
1017

1018
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1019
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1020
    public class CT_TrackChange : CT_Markup
1021
    {
1022

1023
        private string authorField;
1024

1025
        private string dateField;
1026

1027
        private bool dateFieldSpecified;
1028

1029
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1030
        public string author
1031
        {
1032
            get
1033
            {
1034
                return this.authorField;
1035
            }
1036
            set
1037
            {
1038
                this.authorField = value;
1039
            }
1040
        }
1041

1042
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1043
        public string date
1044
        {
1045
            get
1046
            {
1047
                return this.dateField;
1048
            }
1049
            set
1050
            {
1051
                this.dateField = value;
1052
            }
1053
        }
1054

1055
        [XmlIgnore]
1056
        public bool dateSpecified
1057
        {
1058
            get
1059
            {
1060
                return this.dateFieldSpecified;
1061
            }
1062
            set
1063
            {
1064
                this.dateFieldSpecified = value;
1065
            }
1066
        }
1067
        public new static CT_TrackChange Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1068
        {
1069
            if (node == null)
1070
                return null;
1071
            CT_TrackChange ctObj = new CT_TrackChange();
1072
            ctObj.author = XmlHelper.ReadString(node.Attributes["w:author"]);
1073
            ctObj.date = XmlHelper.ReadString(node.Attributes["w:date"]);
1074
            ctObj.id = XmlHelper.ReadString(node.Attributes["w:id"]);
1075
            return ctObj;
1076
        }
1077

1078

1079

1080
        internal new void Write(StreamWriter sw, string nodeName)
1081
        {
1082
            sw.Write(string.Format("<w:{0}", nodeName));
1083
            XmlHelper.WriteAttribute(sw, "w:author", this.author, true);
1084
            XmlHelper.WriteAttribute(sw, "w:date", this.date);
1085
            XmlHelper.WriteAttribute(sw, "w:id", this.id, true);
1086
            sw.Write("/>");
1087
        }
1088

1089

1090

1091
    }
1092

1093
    [XmlInclude(typeof(CT_TblGridChange))]
1094
    [XmlInclude(typeof(CT_MarkupRange))]
1095
    [XmlInclude(typeof(CT_BookmarkRange))]
1096
    [XmlInclude(typeof(CT_Bookmark))]
1097
    [XmlInclude(typeof(CT_MoveBookmark))]
1098
    [XmlInclude(typeof(CT_TrackChange))]
1099
    [XmlInclude(typeof(CT_RunTrackChange))]
1100
    [XmlInclude(typeof(CT_RPrChange))]
1101
    [XmlInclude(typeof(CT_ParaRPrChange))]
1102
    [XmlInclude(typeof(CT_PPrChange))]
1103
    [XmlInclude(typeof(CT_SectPrChange))]
1104
    [XmlInclude(typeof(CT_TblPrChange))]
1105
    [XmlInclude(typeof(CT_TrPrChange))]
1106
    [XmlInclude(typeof(CT_TcPrChange))]
1107
    [XmlInclude(typeof(CT_TblPrExChange))]
1108
    [XmlInclude(typeof(CT_TrackChangeNumbering))]
1109
    [XmlInclude(typeof(CT_Comment))]
1110
    [XmlInclude(typeof(CT_TrackChangeRange))]
1111
    [XmlInclude(typeof(CT_CellMergeTrackChange))]
1112

1113
    [Serializable]
1114

1115
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1116
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1117
    public class CT_Markup
1118
    {
1119

1120
        private string idField;
1121

1122
        public static CT_Markup Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1123
        {
1124
            if (node == null)
1125
                return null;
1126
            CT_Markup ctObj = new CT_Markup();
1127
            ctObj.id = XmlHelper.ReadString(node.Attributes["w:id"]);
1128
            return ctObj;
1129
        }
1130

1131

1132

1133
        internal void Write(StreamWriter sw, string nodeName)
1134
        {
1135
            sw.Write(string.Format("<w:{0}", nodeName));
1136
            XmlHelper.WriteAttribute(sw, "w:id", this.id);
1137
            sw.Write("/>");
1138
        }
1139

1140
        public string id
1141
        {
1142
            get
1143
            {
1144
                return this.idField;
1145
            }
1146
            set
1147
            {
1148
                this.idField = value;
1149
            }
1150
        }
1151
    }
1152

1153

1154

1155

1156
    [XmlInclude(typeof(CT_BookmarkRange))]
1157
    [XmlInclude(typeof(CT_Bookmark))]
1158
    [XmlInclude(typeof(CT_MoveBookmark))]
1159

1160
    [Serializable]
1161

1162
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1163
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1164
    public class CT_MarkupRange : CT_Markup
1165
    {
1166
        public static new CT_MarkupRange Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1167
        {
1168
            if (node == null)
1169
                return null;
1170
            CT_MarkupRange ctObj = new CT_MarkupRange();
1171
            if (node.Attributes["w:displacedByCustomXml"] != null)
1172
                ctObj.displacedByCustomXml = (ST_DisplacedByCustomXml)Enum.Parse(typeof(ST_DisplacedByCustomXml), node.Attributes["w:displacedByCustomXml"].Value);
1173
            ctObj.id = XmlHelper.ReadString(node.Attributes["w:id"]);
1174
            return ctObj;
1175
        }
1176

1177

1178

1179
        internal new void Write(StreamWriter sw, string nodeName)
1180
        {
1181
            sw.Write(string.Format("<w:{0}", nodeName));
1182
            if (this.displacedByCustomXml!= ST_DisplacedByCustomXml.next)
1183
                XmlHelper.WriteAttribute(sw, "w:displacedByCustomXml", this.displacedByCustomXml.ToString());
1184
            XmlHelper.WriteAttribute(sw, "w:id", this.id);
1185
            sw.Write("/>");
1186
        }
1187

1188
        private ST_DisplacedByCustomXml displacedByCustomXmlField;
1189

1190
        private bool displacedByCustomXmlFieldSpecified;
1191

1192
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1193
        public ST_DisplacedByCustomXml displacedByCustomXml
1194
        {
1195
            get
1196
            {
1197
                return this.displacedByCustomXmlField;
1198
            }
1199
            set
1200
            {
1201
                this.displacedByCustomXmlField = value;
1202
            }
1203
        }
1204

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