npoi

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

11
namespace NPOI.OpenXmlFormats.Wordprocessing
12
{
13

14

15
    [Serializable]
16

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

22
        private CT_RPr rPrField;
23
        private ArrayList itemsField;
24

25
        private List<RunItemsChoiceType> itemsElementNameField;
26

27
        private byte[] rsidRPrField;
28

29
        private byte[] rsidDelField;
30

31
        private byte[] rsidRField;
32
        
33
        Vml.CT_AlternateContent alternateContentField = null;
34

35
        public CT_R()
36
        {
37
            this.itemsElementNameField = new List<RunItemsChoiceType>();
38
            this.itemsField = new ArrayList();
39
            //this.rPrField = new CT_RPr();
40
        }
41

42
        [XmlElement(Order = 0, IsNullable = true)]
43
        public CT_RPr rPr
44
        {
45
            get
46
            {
47
                return this.rPrField;
48
            }
49
            set
50
            {
51
                this.rPrField = value;
52
            }
53
        }
54

55
        public bool IsSetRPr()
56
        {
57
            return this.rPrField != null;
58
        }
59

60
        public CT_RPr AddNewRPr()
61
        {
62
            if (this.rPrField == null)
63
                this.rPrField = new CT_RPr();
64
            return this.rPrField;
65
        }
66

67
        public Vml.CT_AlternateContent alternateContent
68
        {
69
            get
70
            {
71
                return alternateContentField;
72
            }
73
            set
74
            {
75
                this.alternateContentField = value;
76
            }
77
        }
78

79
        [XmlElement("annotationRef", typeof(CT_Empty), Order = 1)]
80
        [XmlElement("br", typeof(CT_Br), Order = 1)]
81
        [XmlElement("commentReference", typeof(CT_Markup), Order = 1)]
82
        [XmlElement("continuationSeparator", typeof(CT_Empty), Order = 1)]
83
        [XmlElement("cr", typeof(CT_Empty), Order = 1)]
84
        [XmlElement("dayLong", typeof(CT_Empty), Order = 1)]
85
        [XmlElement("dayShort", typeof(CT_Empty), Order = 1)]
86
        [XmlElement("delInstrText", typeof(CT_Text), Order = 1)]
87
        [XmlElement("delText", typeof(CT_Text), Order = 1)]
88
        [XmlElement("drawing", typeof(CT_Drawing), Order = 1)]
89
        [XmlElement("endnoteRef", typeof(CT_Empty), Order = 1)]
90
        [XmlElement("endnoteReference", typeof(CT_FtnEdnRef), Order = 1)]
91
        [XmlElement("fldChar", typeof(CT_FldChar), Order = 1)]
92
        [XmlElement("footnoteRef", typeof(CT_Empty), Order = 1)]
93
        [XmlElement("footnoteReference", typeof(CT_FtnEdnRef), Order = 1)]
94
        [XmlElement("instrText", typeof(CT_Text), Order = 1)]
95
        [XmlElement("lastRenderedPageBreak", typeof(CT_Empty), Order = 1)]
96
        [XmlElement("monthLong", typeof(CT_Empty), Order = 1)]
97
        [XmlElement("monthShort", typeof(CT_Empty), Order = 1)]
98
        [XmlElement("noBreakHyphen", typeof(CT_Empty), Order = 1)]
99
        [XmlElement("object", typeof(CT_Object), Order = 1)]
100
        [XmlElement("pgNum", typeof(CT_Empty), Order = 1)]
101
        [XmlElement("pict", typeof(CT_Picture), Order = 1)]
102
        [XmlElement("ptab", typeof(CT_PTab), Order = 1)]
103
        [XmlElement("ruby", typeof(CT_Ruby), Order = 1)]
104
        [XmlElement("separator", typeof(CT_Empty), Order = 1)]
105
        [XmlElement("softHyphen", typeof(CT_Empty), Order = 1)]
106
        [XmlElement("sym", typeof(CT_Sym), Order = 1)]
107
        [XmlElement("t", typeof(CT_Text), Order = 1)]
108
        [XmlElement("tab", typeof(CT_Empty), Order = 1)]
109
        [XmlElement("yearLong", typeof(CT_Empty), Order = 1)]
110
        [XmlElement("yearShort", typeof(CT_Empty), Order = 1)]
111
        [XmlChoiceIdentifier("ItemsElementName")]
112
        public ArrayList Items
113
        {
114
            get
115
            {
116
                return this.itemsField;
117
            }
118
            set
119
            {
120
               this.itemsField = new ArrayList();
121
            }
122
        }
123

124
        [XmlElement("ItemsElementName", Order = 2)]
125
        [XmlIgnore]
126
        public List<RunItemsChoiceType> ItemsElementName
127
        {
128
            get
129
            {
130
                return this.itemsElementNameField;
131
            }
132
            set
133
            {
134
               this.itemsElementNameField = new List<RunItemsChoiceType>();
135
            }
136
        }
137

138
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
139
        public byte[] rsidRPr
140
        {
141
            get
142
            {
143
                return this.rsidRPrField;
144
            }
145
            set
146
            {
147
                this.rsidRPrField = value;
148
            }
149
        }
150

151
        public bool IsSetRsidRPr()
152
        {
153
            return this.rsidRPrField != null;
154
        }
155

156
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
157
        public byte[] rsidDel
158
        {
159
            get
160
            {
161
                return this.rsidDelField;
162
            }
163
            set
164
            {
165
                this.rsidDelField = value;
166
            }
167
        }
168

169
        public bool IsSetRsidDel()
170
        {
171
            return this.rsidDelField != null;
172
        }
173

174
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "hexBinary")]
175
        public byte[] rsidR
176
        {
177
            get
178
            {
179
                return this.rsidRField;
180
            }
181
            set
182
            {
183
                this.rsidRField = value;
184
            }
185
        }
186

187
        public bool IsSetRsidR()
188
        {
189
            return this.rsidRField != null;
190
        }
191

192
        #region Generic methods for object operation
193

194
        private List<T> GetObjectList<T>(RunItemsChoiceType type) where T : class
195
        {
196
            lock (this)
197
            {
198
                List<T> list = new List<T>();
199
                for (int i = 0; i < itemsElementNameField.Count; i++)
200
                {
201
                    if (itemsElementNameField[i] == type)
202
                        list.Add(itemsField[i] as T);
203
                }
204
                return list;
205
            }
206
        }
207
        private int SizeOfArray(RunItemsChoiceType type)
208
        {
209
            lock (this)
210
            {
211
                int size = 0;
212
                for (int i = 0; i < itemsElementNameField.Count; i++)
213
                {
214
                    if (itemsElementNameField[i] == type)
215
                        size++;
216
                }
217
                return size;
218
            }
219
        }
220
        private T GetObjectArray<T>(int p, RunItemsChoiceType type) where T : class
221
        {
222
            lock (this)
223
            {
224
                int pos = GetObjectIndex(type, p);
225
                if (pos < 0 || pos >= this.itemsField.Count)
226
                    return null;
227
                return itemsField[pos] as T;
228
            }
229
        }
230
        private T InsertNewObject<T>(RunItemsChoiceType type, int p) where T : class, new()
231
        {
232
            T t = new T();
233
            lock (this)
234
            {
235
                int pos = GetObjectIndex(type, p);
236
                this.itemsElementNameField.Insert(pos, type);
237
                this.itemsField.Insert(pos, t);
238
            }
239
            return t;
240
        }
241
        private T AddNewObject<T>(RunItemsChoiceType type) where T : class, new()
242
        {
243
            T t = new T();
244
            lock (this)
245
            {
246
                this.itemsElementNameField.Add(type);
247
                this.itemsField.Add(t);
248
            }
249
            return t;
250
        }
251
        private void SetObject<T>(RunItemsChoiceType type, int p, T obj) where T : class
252
        {
253
            lock (this)
254
            {
255
                int pos = GetObjectIndex(type, p);
256
                if (pos < 0 || pos >= this.itemsField.Count)
257
                    return;
258
                if (this.itemsField[pos] is T)
259
                    this.itemsField[pos] = obj;
260
                else
261
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
262
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
263
            }
264
        }
265

266
        private int GetObjectIndex(RunItemsChoiceType type, int p)
267
        {
268
            int index = -1;
269
            int pos = 0;
270
            for (int i = 0; i < itemsElementNameField.Count; i++)
271
            {
272
                if (itemsElementNameField[i] == type)
273
                {
274
                    if (pos == p)
275
                    {
276
                        index = i;
277
                        break;
278
                    }
279
                    else
280
                        pos++;
281
                }
282
            }
283
            return index;
284
        }
285
        private void RemoveObject(RunItemsChoiceType type, int p)
286
        {
287
            lock (this)
288
            {
289
                int pos = GetObjectIndex(type, p);
290
                if (pos < 0 || pos >= this.itemsField.Count)
291
                    return;
292
                itemsElementNameField.RemoveAt(pos);
293
                itemsField.RemoveAt(pos);
294
            }
295
        }
296
        #endregion
297

298
        #pragma warning disable format
299
        public CT_Empty     AddNewAnnotationRef()         { return AddNewObject<CT_Empty>    (RunItemsChoiceType.annotationRef); }
300
        public CT_Br        AddNewBr()                    { return AddNewObject<CT_Br>       (RunItemsChoiceType.br); }
301
        public CT_Markup    AddNewCommentReference()      { return AddNewObject<CT_Markup>   (RunItemsChoiceType.commentReference); }
302
        public CT_Empty     AddNewContinuationSeparator() { return AddNewObject<CT_Empty>    (RunItemsChoiceType.continuationSeparator); }
303
        public CT_Empty     AddNewCr()                    { return AddNewObject<CT_Empty>    (RunItemsChoiceType.cr); }
304
        public CT_Empty     AddNewDayLong()               { return AddNewObject<CT_Empty>    (RunItemsChoiceType.dayLong); }
305
        public CT_Empty     AddNewDayShort()              { return AddNewObject<CT_Empty>    (RunItemsChoiceType.dayShort); }
306
        public CT_Text      AddNewDelInstrText()          { return AddNewObject<CT_Text>     (RunItemsChoiceType.delInstrText); }
307
        public CT_Text      AddNewDelText()               { return AddNewObject<CT_Text>     (RunItemsChoiceType.delText); }
308
        public CT_Drawing   AddNewDrawing()               { return AddNewObject<CT_Drawing>  (RunItemsChoiceType.drawing); }
309
        public CT_Empty     AddNewEndnoteRef()            { return AddNewObject<CT_Empty>    (RunItemsChoiceType.endnoteRef); }
310
        public CT_FtnEdnRef AddNewEndnoteReference()      { return AddNewObject<CT_FtnEdnRef>(RunItemsChoiceType.endnoteReference); }
311
        public CT_FldChar   AddNewFldChar()               { return AddNewObject<CT_FldChar>  (RunItemsChoiceType.fldChar); }
312
        public CT_Empty     AddNewFootnoteRef()           { return AddNewObject<CT_Empty>    (RunItemsChoiceType.footnoteRef); }
313
        public CT_FtnEdnRef AddNewFootnoteReference()     { return AddNewObject<CT_FtnEdnRef>(RunItemsChoiceType.footnoteReference); }
314
        public CT_Text      AddNewInstrText()             { return AddNewObject<CT_Text>     (RunItemsChoiceType.instrText); }
315
        public CT_Empty     AddNewLastRenderedPageBreak() { return AddNewObject<CT_Empty>    (RunItemsChoiceType.lastRenderedPageBreak); }
316
        public CT_Empty     AddNewMonthLong()             { return AddNewObject<CT_Empty>    (RunItemsChoiceType.monthLong); }
317
        public CT_Empty     AddNewMonthShort()            { return AddNewObject<CT_Empty>    (RunItemsChoiceType.monthShort); }
318
        public CT_Empty     AddNewNoBreakHyphen()         { return AddNewObject<CT_Empty>    (RunItemsChoiceType.noBreakHyphen); }
319
        public CT_Object    AddNewObject()                { return AddNewObject<CT_Object>   (RunItemsChoiceType.@object); }
320
        public CT_Empty     AddNewPgNum()                 { return AddNewObject<CT_Empty>    (RunItemsChoiceType.pgNum); }
321
        public CT_Picture   AddNewPict()                  { return AddNewObject<CT_Picture>  (RunItemsChoiceType.pict); }
322
        public CT_PTab      AddNewPtab()                  { return AddNewObject<CT_PTab>     (RunItemsChoiceType.ptab); }
323
        public CT_Ruby      AddNewRuby()                  { return AddNewObject<CT_Ruby>     (RunItemsChoiceType.ruby); }
324
        public CT_Empty     AddNewSeparator()             { return AddNewObject<CT_Empty>    (RunItemsChoiceType.separator); }
325
        public CT_Empty     AddNewSoftHyphen()            { return AddNewObject<CT_Empty>    (RunItemsChoiceType.softHyphen); }
326
        public CT_Sym       AddNewSym()                   { return AddNewObject<CT_Sym>      (RunItemsChoiceType.sym); }
327
        public CT_Text      AddNewT()                     { return AddNewObject<CT_Text>     (RunItemsChoiceType.t); }
328
        public CT_Empty     AddNewTab()                   { return AddNewObject<CT_Empty>    (RunItemsChoiceType.tab); }
329
        public CT_Empty     AddNewYearLong()              { return AddNewObject<CT_Empty>    (RunItemsChoiceType.yearLong); }
330
        public CT_Empty     AddNewYearShort()             { return AddNewObject<CT_Empty>    (RunItemsChoiceType.yearShort); }
331

332
        public CT_Empty     GetAnnotationRefArray(int pos)         { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.annotationRef); }
333
        public CT_Br        GetBrArray(int pos)                    { return GetObjectArray<CT_Br>       (pos, RunItemsChoiceType.br); }
334
        public CT_Markup    GetCommentReferenceArray(int pos)      { return GetObjectArray<CT_Markup>   (pos, RunItemsChoiceType.commentReference); }
335
        public CT_Empty     GetContinuationSeparatorArray(int pos) { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.continuationSeparator); }
336
        public CT_Empty     GetCrArray(int pos)                    { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.cr); }
337
        public CT_Empty     GetDayLongArray(int pos)               { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.dayLong); }
338
        public CT_Empty     GetDayShortArray(int pos)              { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.dayShort); }
339
        public CT_Text      GetDelInstrTextArray(int pos)          { return GetObjectArray<CT_Text>     (pos, RunItemsChoiceType.delInstrText); }
340
        public CT_Text      GetDelTextArray(int pos)               { return GetObjectArray<CT_Text>     (pos, RunItemsChoiceType.delText); }
341
        public CT_Drawing   GetDrawingArray(int pos)               { return GetObjectArray<CT_Drawing>  (pos, RunItemsChoiceType.drawing); }
342
        public CT_Empty     GetEndnoteRefArray(int pos)            { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.endnoteRef); }
343
        public CT_FtnEdnRef GetEndnoteReferenceArray(int pos)      { return GetObjectArray<CT_FtnEdnRef>(pos, RunItemsChoiceType.endnoteReference); }
344
        public CT_FldChar   GetFldCharArray(int pos)               { return GetObjectArray<CT_FldChar>  (pos, RunItemsChoiceType.fldChar); }
345
        public CT_Empty     GetFootnoteRefArray(int pos)           { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.footnoteRef); }
346
        public CT_FtnEdnRef GetFootnoteReferenceArray(int pos)     { return GetObjectArray<CT_FtnEdnRef>(pos, RunItemsChoiceType.footnoteReference); }
347
        public CT_Text      GetInstrTextArray(int pos)             { return GetObjectArray<CT_Text>     (pos, RunItemsChoiceType.instrText); }
348
        public CT_Empty     GetLastRenderedPageBreakArray(int pos) { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.lastRenderedPageBreak); }
349
        public CT_Empty     GetMonthLongArray(int pos)             { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.monthLong); }
350
        public CT_Empty     GetMonthShortArray(int pos)            { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.monthShort); }
351
        public CT_Empty     GetNoBreakHyphenArray(int pos)         { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.noBreakHyphen); }
352
        public CT_Object    GetObjectArray(int pos)                { return GetObjectArray<CT_Object>   (pos, RunItemsChoiceType.@object); }
353
        public CT_Empty     GetPgNumArray(int pos)                 { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.pgNum); }
354
        public CT_Picture   GetPictArray(int pos)                  { return GetObjectArray<CT_Picture>  (pos, RunItemsChoiceType.pict); }
355
        public CT_PTab      GetPtabArray(int pos)                  { return GetObjectArray<CT_PTab>     (pos, RunItemsChoiceType.ptab); }
356
        public CT_Ruby      GetRubyArray(int pos)                  { return GetObjectArray<CT_Ruby>     (pos, RunItemsChoiceType.ruby); }
357
        public CT_Empty     GetSeparatorArray(int pos)             { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.separator); }
358
        public CT_Empty     GetSoftHyphenArray(int pos)            { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.softHyphen); }
359
        public CT_Sym       GetSymArray(int pos)                   { return GetObjectArray<CT_Sym>      (pos, RunItemsChoiceType.sym); }
360
        public CT_Text      GetTArray(int pos)                     { return GetObjectArray<CT_Text>     (pos, RunItemsChoiceType.t); }
361
        public CT_Empty     GetTabArray(int pos)                   { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.tab); }
362
        public CT_Empty     GetYearLongArray(int pos)              { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.yearLong); }
363
        public CT_Empty     GetYearShortArray(int pos)             { return GetObjectArray<CT_Empty>    (pos, RunItemsChoiceType.yearShort); }
364

365
        public IList<CT_Empty>     GetAnnotationRefList()         { return GetObjectList<CT_Empty>    (RunItemsChoiceType.annotationRef); }
366
        public IList<CT_Br>        GetBrList()                    { return GetObjectList<CT_Br>       (RunItemsChoiceType.br); }
367
        public IList<CT_Markup>    GetCommentReferenceList()      { return GetObjectList<CT_Markup>   (RunItemsChoiceType.commentReference); }
368
        public IList<CT_Empty>     GetContinuationSeparatorList() { return GetObjectList<CT_Empty>    (RunItemsChoiceType.continuationSeparator); }
369
        public IList<CT_Empty>     GetCrList()                    { return GetObjectList<CT_Empty>    (RunItemsChoiceType.cr); }
370
        public IList<CT_Empty>     GetDayLongList()               { return GetObjectList<CT_Empty>    (RunItemsChoiceType.dayLong); }
371
        public IList<CT_Empty>     GetDayShortList()              { return GetObjectList<CT_Empty>    (RunItemsChoiceType.dayShort); }
372
        public IList<CT_Text>      GetDelInstrTextList()          { return GetObjectList<CT_Text>     (RunItemsChoiceType.delInstrText); }
373
        public IList<CT_Text>      GetDelTextList()               { return GetObjectList<CT_Text>     (RunItemsChoiceType.delText); }
374
        public IList<CT_Drawing>   GetDrawingList()               { return GetObjectList<CT_Drawing>  (RunItemsChoiceType.drawing); }
375
        public IList<CT_Empty>     GetEndnoteRefList()            { return GetObjectList<CT_Empty>    (RunItemsChoiceType.endnoteRef); }
376
        public IList<CT_FtnEdnRef> GetEndnoteReferenceList()      { return GetObjectList<CT_FtnEdnRef>(RunItemsChoiceType.endnoteReference); }
377
        public IList<CT_FldChar>   GetFldCharList()               { return GetObjectList<CT_FldChar>  (RunItemsChoiceType.fldChar); }
378
        public IList<CT_Empty>     GetFootnoteRefList()           { return GetObjectList<CT_Empty>    (RunItemsChoiceType.footnoteRef); }
379
        public IList<CT_FtnEdnRef> GetFootnoteReferenceList()     { return GetObjectList<CT_FtnEdnRef>(RunItemsChoiceType.footnoteReference); }
380
        public IList<CT_Text>      GetInstrTextList()             { return GetObjectList<CT_Text>     (RunItemsChoiceType.instrText); }
381
        public IList<CT_Empty>     GetLastRenderedPageBreakList() { return GetObjectList<CT_Empty>    (RunItemsChoiceType.lastRenderedPageBreak); }
382
        public IList<CT_Empty>     GetMonthLongList()             { return GetObjectList<CT_Empty>    (RunItemsChoiceType.monthLong); }
383
        public IList<CT_Empty>     GetMonthShortList()            { return GetObjectList<CT_Empty>    (RunItemsChoiceType.monthShort); }
384
        public IList<CT_Empty>     GetNoBreakHyphenList()         { return GetObjectList<CT_Empty>    (RunItemsChoiceType.noBreakHyphen); }
385
        public IList<CT_Object>    GetObjectList()                { return GetObjectList<CT_Object>   (RunItemsChoiceType.@object); }
386
        public IList<CT_Empty>     GetPgNumList()                 { return GetObjectList<CT_Empty>    (RunItemsChoiceType.pgNum); }
387
        public IList<CT_Picture>   GetPictList()                  { return GetObjectList<CT_Picture>  (RunItemsChoiceType.pict); }
388
        public IList<CT_PTab>      GetPtabList()                  { return GetObjectList<CT_PTab>     (RunItemsChoiceType.ptab); }
389
        public IList<CT_Ruby>      GetRubyList()                  { return GetObjectList<CT_Ruby>     (RunItemsChoiceType.ruby); }
390
        public IList<CT_Empty>     GetSeparatorList()             { return GetObjectList<CT_Empty>    (RunItemsChoiceType.separator); }
391
        public IList<CT_Empty>     GetSoftHyphenList()            { return GetObjectList<CT_Empty>    (RunItemsChoiceType.softHyphen); }
392
        public IList<CT_Sym>       GetSymList()                   { return GetObjectList<CT_Sym>      (RunItemsChoiceType.sym); }
393
        public IList<CT_Text>      GetTList()                     { return GetObjectList<CT_Text>     (RunItemsChoiceType.t); }
394
        public IList<CT_Empty>     GetTabList()                   { return GetObjectList<CT_Empty>    (RunItemsChoiceType.tab); }
395
        public IList<CT_Empty>     GetYearLongList()              { return GetObjectList<CT_Empty>    (RunItemsChoiceType.yearLong); }
396
        public IList<CT_Empty>     GetYearShortList()             { return GetObjectList<CT_Empty>    (RunItemsChoiceType.yearShort); }
397

398
        public CT_Empty     InsertNewAnnotationRef(int p)         { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.annotationRef, p); }
399
        public CT_Br        InsertNewBr(int p)                    { return InsertNewObject<CT_Br>       (RunItemsChoiceType.br, p); }
400
        public CT_Markup    InsertNewCommentReference(int p)      { return InsertNewObject<CT_Markup>   (RunItemsChoiceType.commentReference, p); }
401
        public CT_Empty     InsertNewContinuationSeparator(int p) { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.continuationSeparator, p); }
402
        public CT_Empty     InsertNewCr(int p)                    { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.cr, p); }
403
        public CT_Empty     InsertNewDayLong(int p)               { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.dayLong, p); }
404
        public CT_Empty     InsertNewDayShort(int p)              { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.dayShort, p); }
405
        public CT_Text      InsertNewDelInstrText(int p)          { return InsertNewObject<CT_Text>     (RunItemsChoiceType.delInstrText, p); }
406
        public CT_Text      InsertNewDelText(int p)               { return InsertNewObject<CT_Text>     (RunItemsChoiceType.delText, p); }
407
        public CT_Drawing   InsertNewDrawing(int p)               { return InsertNewObject<CT_Drawing>  (RunItemsChoiceType.drawing, p); }
408
        public CT_Empty     InsertNewEndnoteRef(int p)            { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.endnoteRef, p); }
409
        public CT_FtnEdnRef InsertNewEndnoteReference(int p)      { return InsertNewObject<CT_FtnEdnRef>(RunItemsChoiceType.endnoteReference, p); }
410
        public CT_FldChar   InsertNewFldChar(int p)               { return InsertNewObject<CT_FldChar>  (RunItemsChoiceType.fldChar, p); }
411
        public CT_Empty     InsertNewFootnoteRef(int p)           { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.footnoteRef, p); }
412
        public CT_FtnEdnRef InsertNewFootnoteReference(int p)     { return InsertNewObject<CT_FtnEdnRef>(RunItemsChoiceType.footnoteReference, p); }
413
        public CT_Text      InsertNewInstrText(int p)             { return InsertNewObject<CT_Text>     (RunItemsChoiceType.instrText, p); }
414
        public CT_Empty     InsertNewLastRenderedPageBreak(int p) { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.lastRenderedPageBreak, p); }
415
        public CT_Empty     InsertNewMonthLong(int p)             { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.monthLong, p); }
416
        public CT_Empty     InsertNewMonthShort(int p)            { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.monthShort, p); }
417
        public CT_Empty     InsertNewNoBreakHyphen(int p)         { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.noBreakHyphen, p); }
418
        public CT_Object    InsertNewObject(int p)                { return InsertNewObject<CT_Object>   (RunItemsChoiceType.@object, p); }
419
        public CT_Empty     InsertNewPgNum(int p)                 { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.pgNum, p); }
420
        public CT_Picture   InsertNewPict(int p)                  { return InsertNewObject<CT_Picture>  (RunItemsChoiceType.pict, p); }
421
        public CT_PTab      InsertNewPtab(int p)                  { return InsertNewObject<CT_PTab>     (RunItemsChoiceType.ptab, p); }
422
        public CT_Ruby      InsertNewRuby(int p)                  { return InsertNewObject<CT_Ruby>     (RunItemsChoiceType.ruby, p); }
423
        public CT_Empty     InsertNewSeparator(int p)             { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.separator, p); }
424
        public CT_Empty     InsertNewSoftHyphen(int p)            { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.softHyphen, p); }
425
        public CT_Sym       InsertNewSym(int p)                   { return InsertNewObject<CT_Sym>      (RunItemsChoiceType.sym, p); }
426
        public CT_Text      InsertNewT(int p)                     { return InsertNewObject<CT_Text>     (RunItemsChoiceType.t, p); }
427
        public CT_Empty     InsertNewTab(int p)                   { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.tab, p); }
428
        public CT_Empty     InsertNewYearLong(int p)              { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.yearLong, p); }
429
        public CT_Empty     InsertNewYearShort(int p)             { return InsertNewObject<CT_Empty>    (RunItemsChoiceType.yearShort, p); }
430

431
        public void RemoveAnnotationRef(int p)         { RemoveObject(RunItemsChoiceType.annotationRef, p); }
432
        public void RemoveBr(int p)                    { RemoveObject(RunItemsChoiceType.br, p); }
433
        public void RemoveCommentReference(int p)      { RemoveObject(RunItemsChoiceType.commentReference, p); }
434
        public void RemoveContinuationSeparator(int p) { RemoveObject(RunItemsChoiceType.continuationSeparator, p); }
435
        public void RemoveCr(int p)                    { RemoveObject(RunItemsChoiceType.cr, p); }
436
        public void RemoveDayLong(int p)               { RemoveObject(RunItemsChoiceType.dayLong, p); }
437
        public void RemoveDayShort(int p)              { RemoveObject(RunItemsChoiceType.dayShort, p); }
438
        public void RemoveDelInstrText(int p)          { RemoveObject(RunItemsChoiceType.delInstrText, p); }
439
        public void RemoveDelText(int p)               { RemoveObject(RunItemsChoiceType.delText, p); }
440
        public void RemoveDrawing(int p)               { RemoveObject(RunItemsChoiceType.drawing, p); }
441
        public void RemoveEndnoteRef(int p)            { RemoveObject(RunItemsChoiceType.endnoteRef, p); }
442
        public void RemoveEndnoteReference(int p)      { RemoveObject(RunItemsChoiceType.endnoteReference, p); }
443
        public void RemoveFldChar(int p)               { RemoveObject(RunItemsChoiceType.fldChar, p); }
444
        public void RemoveFootnoteRef(int p)           { RemoveObject(RunItemsChoiceType.footnoteRef, p); }
445
        public void RemoveFootnoteReference(int p)     { RemoveObject(RunItemsChoiceType.footnoteReference, p); }
446
        public void RemoveInstrText(int p)             { RemoveObject(RunItemsChoiceType.instrText, p); }
447
        public void RemoveLastRenderedPageBreak(int p) { RemoveObject(RunItemsChoiceType.lastRenderedPageBreak, p); }
448
        public void RemoveMonthLong(int p)             { RemoveObject(RunItemsChoiceType.monthLong, p); }
449
        public void RemoveMonthShort(int p)            { RemoveObject(RunItemsChoiceType.monthShort, p); }
450
        public void RemoveNoBreakHyphen(int p)         { RemoveObject(RunItemsChoiceType.noBreakHyphen, p); }
451
        public void RemoveObject(int p)                { RemoveObject(RunItemsChoiceType.@object, p); }
452
        public void RemovePgNum(int p)                 { RemoveObject(RunItemsChoiceType.pgNum, p); }
453
        public void RemovePict(int p)                  { RemoveObject(RunItemsChoiceType.pict, p); }
454
        public void RemovePtab(int p)                  { RemoveObject(RunItemsChoiceType.ptab, p); }
455
        public void RemoveRuby(int p)                  { RemoveObject(RunItemsChoiceType.ruby, p); }
456
        public void RemoveSeparator(int p)             { RemoveObject(RunItemsChoiceType.separator, p); }
457
        public void RemoveSoftHyphen(int p)            { RemoveObject(RunItemsChoiceType.softHyphen, p); }
458
        public void RemoveSym(int p)                   { RemoveObject(RunItemsChoiceType.sym, p); }
459
        public void RemoveT(int p)                     { RemoveObject(RunItemsChoiceType.t, p); }
460
        public void RemoveTab(int p)                   { RemoveObject(RunItemsChoiceType.tab, p); }
461
        public void RemoveYearLong(int p)              { RemoveObject(RunItemsChoiceType.yearLong, p); }
462
        public void RemoveYearShort(int p)             { RemoveObject(RunItemsChoiceType.yearShort, p); }
463

464
        public void SetAnnotationRef(int p, CT_Empty obj)             { SetObject(RunItemsChoiceType.annotationRef, p, obj); }
465
        public void SetBr(int p, CT_Br obj)                           { SetObject(RunItemsChoiceType.br, p, obj); }
466
        public void SetCommentReference(int p, CT_Markup obj)         { SetObject(RunItemsChoiceType.commentReference, p, obj); }
467
        public void SetContinuationSeparator(int p, CT_Empty obj)     { SetObject(RunItemsChoiceType.continuationSeparator, p, obj); }
468
        public void SetCr(int p, CT_Empty obj)                        { SetObject(RunItemsChoiceType.cr, p, obj); }
469
        public void SetDayLong(int p, CT_Empty obj)                   { SetObject(RunItemsChoiceType.dayLong, p, obj); }
470
        public void SetDayShort(int p, CT_Empty obj)                  { SetObject(RunItemsChoiceType.dayShort, p, obj); }
471
        public void SetDelInstrText(int p, CT_Text obj)               { SetObject(RunItemsChoiceType.delInstrText, p, obj); }
472
        public void SetDelText(int p, CT_Text obj)                    { SetObject(RunItemsChoiceType.delText, p, obj); }
473
        public void SetDrawing(int p, CT_Drawing obj)                 { SetObject(RunItemsChoiceType.drawing, p, obj); }
474
        public void SetEndnoteRef(int p, CT_Empty obj)                { SetObject(RunItemsChoiceType.endnoteRef, p, obj); }
475
        public void SetEndnoteReference(int p, CT_FtnEdnRef obj)      { SetObject(RunItemsChoiceType.endnoteReference, p, obj); }
476
        public void SetFldChar(int p, CT_FldChar obj)                 { SetObject(RunItemsChoiceType.fldChar, p, obj); }
477
        public void SetFootnoteRef(int p, CT_Empty obj)               { SetObject(RunItemsChoiceType.footnoteRef, p, obj); }
478
        public void SetFootnoteReference(int p, CT_FtnEdnRef obj)     { SetObject(RunItemsChoiceType.footnoteReference, p, obj); }
479
        public void SetInstrText(int p, CT_Text obj)                  { SetObject(RunItemsChoiceType.instrText, p, obj); }
480
        public void SetLastRenderedPageBreak(int p, CT_Empty obj)     { SetObject(RunItemsChoiceType.lastRenderedPageBreak, p, obj); }
481
        public void SetMonthLong(int p, CT_Empty obj)                 { SetObject(RunItemsChoiceType.monthLong, p, obj); }
482
        public void SetMonthShort(int p, CT_Empty obj)                { SetObject(RunItemsChoiceType.monthShort, p, obj); }
483
        public void SetNoBreakHyphen(int p, CT_Empty obj)             { SetObject(RunItemsChoiceType.noBreakHyphen, p, obj); }
484
        public void SetObject(int p, CT_Object obj)                   { SetObject(RunItemsChoiceType.@object, p, obj); }
485
        public void SetPgNum(int p, CT_Empty obj)                     { SetObject(RunItemsChoiceType.pgNum, p, obj); }
486
        public void SetPict(int p, CT_Picture obj)                    { SetObject(RunItemsChoiceType.pict, p, obj); }
487
        public void SetPtab(int p, CT_PTab obj)                       { SetObject(RunItemsChoiceType.ptab, p, obj); }
488
        public void SetRuby(int p, CT_Ruby obj)                       { SetObject(RunItemsChoiceType.ruby, p, obj); }
489
        public void SetSeparator(int p, CT_Empty obj)                 { SetObject(RunItemsChoiceType.separator, p, obj); }
490
        public void SetSoftHyphen(int p, CT_Empty obj)                { SetObject(RunItemsChoiceType.softHyphen, p, obj); }
491
        public void SetSym(int p, CT_Sym obj)                         { SetObject(RunItemsChoiceType.sym, p, obj); }
492
        public void SetT(int p, CT_Text obj)                          { SetObject(RunItemsChoiceType.t, p, obj); }
493
        public void SetTab(int p, CT_Empty obj)                       { SetObject(RunItemsChoiceType.tab, p, obj); }
494
        public void SetYearLong(int p, CT_Empty obj)                  { SetObject(RunItemsChoiceType.yearLong, p, obj); }
495
        public void SetYearShort(int p, CT_Empty obj)                 { SetObject(RunItemsChoiceType.yearShort, p, obj); }
496

497
        public int SizeOfAnnotationRefArray()         { return SizeOfArray(RunItemsChoiceType.annotationRef); }
498
        public int SizeOfBrArray()                    { return SizeOfArray(RunItemsChoiceType.br); }
499
        public int SizeOfCommentReferenceArray()      { return SizeOfArray(RunItemsChoiceType.commentReference); }
500
        public int SizeOfContinuationSeparatorArray() { return SizeOfArray(RunItemsChoiceType.continuationSeparator); }
501
        public int SizeOfCrArray()                    { return SizeOfArray(RunItemsChoiceType.cr); }
502
        public int SizeOfDayLongArray()               { return SizeOfArray(RunItemsChoiceType.dayLong); }
503
        public int SizeOfDayShortArray()              { return SizeOfArray(RunItemsChoiceType.dayShort); }
504
        public int SizeOfDelInstrTextArray()          { return SizeOfArray(RunItemsChoiceType.delInstrText); }
505
        public int SizeOfDelTextArray()               { return SizeOfArray(RunItemsChoiceType.delText); }
506
        public int SizeOfDrawingArray()               { return SizeOfArray(RunItemsChoiceType.drawing); }
507
        public int SizeOfEndnoteRefArray()            { return SizeOfArray(RunItemsChoiceType.endnoteRef); }
508
        public int SizeOfEndnoteReferenceArray()      { return SizeOfArray(RunItemsChoiceType.endnoteReference); }
509
        public int SizeOfFldCharArray()               { return SizeOfArray(RunItemsChoiceType.fldChar); }
510
        public int SizeOfFootnoteRefArray()           { return SizeOfArray(RunItemsChoiceType.footnoteRef); }
511
        public int SizeOfFootnoteReferenceArray()     { return SizeOfArray(RunItemsChoiceType.footnoteReference); }
512
        public int SizeOfInstrTextArray()             { return SizeOfArray(RunItemsChoiceType.instrText); }
513
        public int SizeOfLastRenderedPageBreakArray() { return SizeOfArray(RunItemsChoiceType.lastRenderedPageBreak); }
514
        public int SizeOfMonthLongArray()             { return SizeOfArray(RunItemsChoiceType.monthLong); }
515
        public int SizeOfMonthShortArray()            { return SizeOfArray(RunItemsChoiceType.monthShort); }
516
        public int SizeOfNoBreakHyphenArray()         { return SizeOfArray(RunItemsChoiceType.noBreakHyphen); }
517
        public int SizeOfObjectArray()                { return SizeOfArray(RunItemsChoiceType.@object); }
518
        public int SizeOfPgNumArray()                 { return SizeOfArray(RunItemsChoiceType.pgNum); }
519
        public int SizeOfPictArray()                  { return SizeOfArray(RunItemsChoiceType.pict); }
520
        public int SizeOfPtabArray()                  { return SizeOfArray(RunItemsChoiceType.ptab); }
521
        public int SizeOfRubyArray()                  { return SizeOfArray(RunItemsChoiceType.ruby); }
522
        public int SizeOfSeparatorArray()             { return SizeOfArray(RunItemsChoiceType.separator); }
523
        public int SizeOfSoftHyphenArray()            { return SizeOfArray(RunItemsChoiceType.softHyphen); }
524
        public int SizeOfSymArray()                   { return SizeOfArray(RunItemsChoiceType.sym); }
525
        public int SizeOfTArray()                     { return SizeOfArray(RunItemsChoiceType.t); }
526
        public int SizeOfTabArray()                   { return SizeOfArray(RunItemsChoiceType.tab); }
527
        public int SizeOfYearLongArray()              { return SizeOfArray(RunItemsChoiceType.yearLong); }
528
        public int SizeOfYearShortArray()             { return SizeOfArray(RunItemsChoiceType.yearShort); }
529
        #pragma warning restore format
530

531
        public static CT_R Parse(XmlNode node, XmlNamespaceManager namespaceManager)
532
        {
533
            if (node == null)
534
                return null;
535
            CT_R ctObj = new CT_R();
536
            ctObj.rsidRPr = XmlHelper.ReadBytes(node.Attributes["w:rsidRPr"]);
537
            ctObj.rsidDel = XmlHelper.ReadBytes(node.Attributes["w:rsidDel"]);
538
            ctObj.rsidR = XmlHelper.ReadBytes(node.Attributes["w:rsidR"]);
539
            
540
            foreach (XmlNode childNode in node.ChildNodes)
541
            {
542
                if (childNode.LocalName == "rPr")
543
                {
544
                    ctObj.rPr = CT_RPr.Parse(childNode, namespaceManager);
545
                }
546
                else if (childNode.LocalName == "instrText")
547
                {
548
                    ctObj.Items.Add(CT_Text.Parse(childNode, namespaceManager));
549
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.instrText);
550
                }
551
                else if (childNode.LocalName == "object")
552
                {
553
                    ctObj.Items.Add(CT_Object.Parse(childNode, namespaceManager));
554
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.@object);
555
                }
556
                else if (childNode.LocalName == "pgNum")
557
                {
558
                    ctObj.Items.Add(new CT_Empty());
559
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.pgNum);
560
                }
561
                else if (childNode.LocalName == "annotationRef")
562
                {
563
                    ctObj.Items.Add(new CT_Empty());
564
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.annotationRef);
565
                }
566
                else if (childNode.LocalName == "br")
567
                {
568
                    ctObj.Items.Add(CT_Br.Parse(childNode, namespaceManager));
569
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.br);
570
                }
571
                else if (childNode.LocalName == "commentReference")
572
                {
573
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
574
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.commentReference);
575
                }
576
                else if (childNode.LocalName == "continuationSeparator")
577
                {
578
                    ctObj.Items.Add(new CT_Empty());
579
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.continuationSeparator);
580
                }
581
                else if (childNode.LocalName == "cr")
582
                {
583
                    ctObj.Items.Add(new CT_Empty());
584
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.cr);
585
                }
586
                else if (childNode.LocalName == "dayLong")
587
                {
588
                    ctObj.Items.Add(new CT_Empty());
589
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.dayLong);
590
                }
591
                else if (childNode.LocalName == "dayShort")
592
                {
593
                    ctObj.Items.Add(new CT_Empty());
594
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.dayShort);
595
                }
596
                else if (childNode.LocalName == "delInstrText")
597
                {
598
                    ctObj.Items.Add(CT_Text.Parse(childNode, namespaceManager));
599
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.delInstrText);
600
                }
601
                else if (childNode.LocalName == "delText")
602
                {
603
                    ctObj.Items.Add(CT_Text.Parse(childNode, namespaceManager));
604
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.delText);
605
                }
606
                else if (childNode.LocalName == "drawing")
607
                {
608
                    ctObj.Items.Add(CT_Drawing.Parse(childNode, namespaceManager));
609
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.drawing);
610
                }
611
                else if (childNode.LocalName == "AlternateContent")
612
                {
613
                    ctObj.alternateContent = Vml.CT_AlternateContent.Parse(childNode, namespaceManager);
614
                }
615
                else if (childNode.LocalName == "endnoteRef")
616
                {
617
                    ctObj.Items.Add(new CT_Empty());
618
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.endnoteRef);
619
                }
620
                else if (childNode.LocalName == "endnoteReference")
621
                {
622
                    ctObj.Items.Add(CT_FtnEdnRef.Parse(childNode, namespaceManager));
623
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.endnoteReference);
624
                }
625
                else if (childNode.LocalName == "fldChar")
626
                {
627
                    ctObj.Items.Add(CT_FldChar.Parse(childNode, namespaceManager));
628
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.fldChar);
629
                }
630
                else if (childNode.LocalName == "footnoteRef")
631
                {
632
                    ctObj.Items.Add(new CT_Empty());
633
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.footnoteRef);
634
                }
635
                else if (childNode.LocalName == "footnoteReference")
636
                {
637
                    ctObj.Items.Add(CT_FtnEdnRef.Parse(childNode, namespaceManager));
638
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.footnoteReference);
639
                }
640
                else if (childNode.LocalName == "lastRenderedPageBreak")
641
                {
642
                    ctObj.Items.Add(new CT_Empty());
643
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.lastRenderedPageBreak);
644
                }
645
                else if (childNode.LocalName == "monthLong")
646
                {
647
                    ctObj.Items.Add(new CT_Empty());
648
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.monthLong);
649
                }
650
                else if (childNode.LocalName == "monthShort")
651
                {
652
                    ctObj.Items.Add(new CT_Empty());
653
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.monthShort);
654
                }
655
                else if (childNode.LocalName == "noBreakHyphen")
656
                {
657
                    ctObj.Items.Add(new CT_Empty());
658
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.noBreakHyphen);
659
                }
660
                else if (childNode.LocalName == "yearLong")
661
                {
662
                    ctObj.Items.Add(new CT_Empty());
663
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.yearLong);
664
                }
665
                else if (childNode.LocalName == "pict")
666
                {
667
                    ctObj.Items.Add(CT_Picture.Parse(childNode, namespaceManager));
668
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.pict);
669
                }
670
                else if (childNode.LocalName == "ptab")
671
                {
672
                    ctObj.Items.Add(CT_PTab.Parse(childNode, namespaceManager));
673
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.ptab);
674
                }
675
                else if (childNode.LocalName == "ruby")
676
                {
677
                    ctObj.Items.Add(CT_Ruby.Parse(childNode, namespaceManager));
678
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.ruby);
679
                }
680
                else if (childNode.LocalName == "separator")
681
                {
682
                    ctObj.Items.Add(new CT_Empty());
683
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.separator);
684
                }
685
                else if (childNode.LocalName == "softHyphen")
686
                {
687
                    ctObj.Items.Add(new CT_Empty());
688
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.softHyphen);
689
                }
690
                else if (childNode.LocalName == "sym")
691
                {
692
                    ctObj.Items.Add(CT_Sym.Parse(childNode, namespaceManager));
693
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.sym);
694
                }
695
                else if (childNode.LocalName == "t")
696
                {
697
                    ctObj.Items.Add(CT_Text.Parse(childNode, namespaceManager));
698
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.t);
699
                }
700
                else if (childNode.LocalName == "tab")
701
                {
702
                    ctObj.Items.Add(new CT_Empty());
703
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.tab);
704
                }
705
                else if (childNode.LocalName == "yearShort")
706
                {
707
                    ctObj.Items.Add(new CT_Empty());
708
                    ctObj.ItemsElementName.Add(RunItemsChoiceType.yearShort);
709
                }
710
            }
711
            return ctObj;
712
        }
713

714
        internal void Write(StreamWriter sw, string nodeName)
715
        {
716
            sw.Write(string.Format("<w:{0}", nodeName));
717
            XmlHelper.WriteAttribute(sw, "w:rsidR", this.rsidR);
718
            XmlHelper.WriteAttribute(sw, "w:rsidRPr", this.rsidRPr);
719
            XmlHelper.WriteAttribute(sw, "w:rsidDel", this.rsidDel);
720
            sw.Write(">");
721
            if (this.rPr != null)
722
                this.rPr.Write(sw, "rPr");
723

724
            int i = 0;
725
            foreach (object o in this.Items)
726
            {
727
                if ((o is CT_Text) && this.ItemsElementName[i] == RunItemsChoiceType.instrText)
728
                    ((CT_Text)o).Write(sw, "instrText");
729
                else if (o is CT_Object)
730
                    ((CT_Object)o).Write(sw, "object");
731
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.pgNum)
732
                    sw.Write("<w:pgNum/>");
733
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.annotationRef)
734
                    sw.Write("<w:annotationRef/>");
735
                else if (o is CT_Br)
736
                    ((CT_Br)o).Write(sw, "br");
737
                else if (o is CT_Markup)
738
                    ((CT_Markup)o).Write(sw, "commentReference");
739
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.continuationSeparator)
740
                    sw.Write("<w:continuationSeparator/>");
741
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.cr)
742
                    sw.Write("<w:cr/>");
743
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.dayLong)
744
                    sw.Write("<w:dayLong/>");
745
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.dayShort)
746
                    sw.Write("<w:dayShort/>");
747
                else if ((o is CT_Text) && this.ItemsElementName[i] == RunItemsChoiceType.delInstrText)
748
                    ((CT_Text)o).Write(sw, "delInstrText");
749
                else if (o is CT_Text && this.ItemsElementName[i] == RunItemsChoiceType.delText)
750
                    ((CT_Text)o).Write(sw, "delText");
751
                else if (o is CT_Drawing)
752
                    ((CT_Drawing)o).Write(sw, "drawing");
753
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.endnoteRef)
754
                    sw.Write("<w:endnoteRef/>");
755
                else if (o is CT_FtnEdnRef && this.ItemsElementName[i] == RunItemsChoiceType.endnoteReference)
756
                    ((CT_FtnEdnRef)o).Write(sw, "endnoteReference");
757
                else if (o is CT_FtnEdnRef && this.ItemsElementName[i] == RunItemsChoiceType.footnoteReference)
758
                    ((CT_FtnEdnRef)o).Write(sw, "footnoteReference");
759
                else if (o is CT_FldChar)
760
                    ((CT_FldChar)o).Write(sw, "fldChar");
761
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.footnoteRef)
762
                    sw.Write("<w:footnoteRef/>");
763
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.lastRenderedPageBreak)
764
                    sw.Write("<w:lastRenderedPageBreak/>");
765
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.monthLong)
766
                    sw.Write("<w:monthLong/>");
767
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.monthShort)
768
                    sw.Write("<w:monthShort/>");
769
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.noBreakHyphen)
770
                    sw.Write("<w:noBreakHyphen/>");
771
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.yearLong)
772
                    sw.Write("<w:yearLong/>");
773
                else if (o is CT_Picture)
774
                    ((CT_Picture)o).Write(sw, "pict");
775
                else if (o is CT_PTab)
776
                    ((CT_PTab)o).Write(sw, "ptab");
777
                else if (o is CT_Ruby)
778
                    ((CT_Ruby)o).Write(sw, "ruby");
779
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.separator)
780
                    sw.Write("<w:separator/>");
781
                else if (o is CT_Empty && this.ItemsElementName[i] == RunItemsChoiceType.softHyphen)
782
                    sw.Write("<w:softHyphen/>");
783
                else if (o is CT_Sym)
784
                    ((CT_Sym)o).Write(sw, "sym");
785
                else if ((o is CT_Text) && this.ItemsElementName[i] == RunItemsChoiceType.t)
786
                    ((CT_Text)o).Write(sw, "t");
787
                else if (o is CT_Empty&& this.ItemsElementName[i]== RunItemsChoiceType.tab)
788
                    sw.Write("<w:tab/>");
789
                else if (o is CT_Empty&& this.ItemsElementName[i]== RunItemsChoiceType.yearShort)
790
                    sw.Write("<w:yearShort/>");
791
                i++;
792
            }
793
            if (this.alternateContent != null)
794
            {
795
                this.alternateContent.Write(sw, "AlternateContent");
796
            }
797
            sw.WriteEndW(nodeName);
798
        }
799
    }
800

801

802
    [Serializable]
803
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
804
    public enum RunItemsChoiceType
805
    {
806

807
    
808
        annotationRef,
809

810
    
811
        br,
812

813
    
814
        commentReference,
815

816
    
817
        continuationSeparator,
818

819
    
820
        cr,
821

822
    
823
        dayLong,
824

825
    
826
        dayShort,
827

828
    
829
        delInstrText,
830

831
    
832
        delText,
833

834
    
835
        drawing,
836

837
    
838
        endnoteRef,
839

840
    
841
        endnoteReference,
842

843
    
844
        fldChar,
845

846
    
847
        footnoteRef,
848

849
    
850
        footnoteReference,
851

852
    
853
        instrText,
854

855
    
856
        lastRenderedPageBreak,
857

858
    
859
        monthLong,
860

861
    
862
        monthShort,
863

864
    
865
        noBreakHyphen,
866

867
    
868
        @object,
869

870
    
871
        pgNum,
872

873
    
874
        pict,
875

876
    
877
        ptab,
878

879
    
880
        ruby,
881

882
    
883
        separator,
884

885
    
886
        softHyphen,
887

888
    
889
        sym,
890

891
    
892
        t,
893

894
    
895
        tab,
896

897
    
898
        yearLong,
899

900
    
901
        yearShort,
902
    }
903

904

905
    [Serializable]
906

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

912
        private ST_RubyAlign valField;
913
        public static CT_RubyAlign Parse(XmlNode node, XmlNamespaceManager namespaceManager)
914
        {
915
            if (node == null)
916
                return null;
917
            CT_RubyAlign ctObj = new CT_RubyAlign();
918
            if (node.Attributes["w:val"] != null)
919
                ctObj.val = (ST_RubyAlign)Enum.Parse(typeof(ST_RubyAlign), node.Attributes["w:val"].Value);
920
            return ctObj;
921
        }
922

923

924

925
        internal void Write(StreamWriter sw, string nodeName)
926
        {
927
            sw.Write(string.Format("<w:{0}", nodeName));
928
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
929
            sw.Write(">");
930
            sw.WriteEndW(nodeName);
931
        }
932

933
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
934
        public ST_RubyAlign val
935
        {
936
            get
937
            {
938
                return this.valField;
939
            }
940
            set
941
            {
942
                this.valField = value;
943
            }
944
        }
945
    }
946

947

948
    [Serializable]
949
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
950
    public enum ST_RubyAlign
951
    {
952

953
    
954
        center,
955

956
    
957
        distributeLetter,
958

959
    
960
        distributeSpace,
961

962
    
963
        left,
964

965
    
966
        right,
967

968
    
969
        rightVertical,
970
    }
971

972

973
    [Serializable]
974

975
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
976
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
977
    public class CT_RubyPr
978
    {
979

980
        private CT_RubyAlign rubyAlignField;
981

982
        private CT_HpsMeasure hpsField;
983

984
        private CT_HpsMeasure hpsRaiseField;
985

986
        private CT_HpsMeasure hpsBaseTextField;
987

988
        private CT_Lang lidField;
989

990
        private CT_OnOff dirtyField;
991

992
        public CT_RubyPr()
993
        {
994
            //this.dirtyField = new CT_OnOff();
995
            //this.lidField = new CT_Lang();
996
            //this.hpsBaseTextField = new CT_HpsMeasure();
997
            //this.hpsRaiseField = new CT_HpsMeasure();
998
            //this.hpsField = new CT_HpsMeasure();
999
            //this.rubyAlignField = new CT_RubyAlign();
1000
        }
1001
        public static CT_RubyPr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1002
        {
1003
            if (node == null)
1004
                return null;
1005
            CT_RubyPr ctObj = new CT_RubyPr();
1006
            foreach (XmlNode childNode in node.ChildNodes)
1007
            {
1008
                if (childNode.LocalName == "rubyAlign")
1009
                    ctObj.rubyAlign = CT_RubyAlign.Parse(childNode, namespaceManager);
1010
                else if (childNode.LocalName == "hps")
1011
                    ctObj.hps = CT_HpsMeasure.Parse(childNode, namespaceManager);
1012
                else if (childNode.LocalName == "hpsRaise")
1013
                    ctObj.hpsRaise = CT_HpsMeasure.Parse(childNode, namespaceManager);
1014
                else if (childNode.LocalName == "hpsBaseText")
1015
                    ctObj.hpsBaseText = CT_HpsMeasure.Parse(childNode, namespaceManager);
1016
                else if (childNode.LocalName == "lid")
1017
                    ctObj.lid = CT_Lang.Parse(childNode, namespaceManager);
1018
                else if (childNode.LocalName == "dirty")
1019
                    ctObj.dirty = CT_OnOff.Parse(childNode, namespaceManager);
1020
            }
1021
            return ctObj;
1022
        }
1023

1024

1025

1026
        internal void Write(StreamWriter sw, string nodeName)
1027
        {
1028
            sw.Write(string.Format("<w:{0}", nodeName));
1029
            sw.Write(">");
1030
            if (this.rubyAlign != null)
1031
                this.rubyAlign.Write(sw, "rubyAlign");
1032
            if (this.hps != null)
1033
                this.hps.Write(sw, "hps");
1034
            if (this.hpsRaise != null)
1035
                this.hpsRaise.Write(sw, "hpsRaise");
1036
            if (this.hpsBaseText != null)
1037
                this.hpsBaseText.Write(sw, "hpsBaseText");
1038
            if (this.lid != null)
1039
                this.lid.Write(sw, "lid");
1040
            if (this.dirty != null)
1041
                this.dirty.Write(sw, "dirty");
1042
            sw.WriteEndW(nodeName);
1043
        }
1044

1045
        [XmlElement(Order = 0)]
1046
        public CT_RubyAlign rubyAlign
1047
        {
1048
            get
1049
            {
1050
                return this.rubyAlignField;
1051
            }
1052
            set
1053
            {
1054
                this.rubyAlignField = value;
1055
            }
1056
        }
1057

1058
        [XmlElement(Order = 1)]
1059
        public CT_HpsMeasure hps
1060
        {
1061
            get
1062
            {
1063
                return this.hpsField;
1064
            }
1065
            set
1066
            {
1067
                this.hpsField = value;
1068
            }
1069
        }
1070

1071
        [XmlElement(Order = 2)]
1072
        public CT_HpsMeasure hpsRaise
1073
        {
1074
            get
1075
            {
1076
                return this.hpsRaiseField;
1077
            }
1078
            set
1079
            {
1080
                this.hpsRaiseField = value;
1081
            }
1082
        }
1083

1084
        [XmlElement(Order = 3)]
1085
        public CT_HpsMeasure hpsBaseText
1086
        {
1087
            get
1088
            {
1089
                return this.hpsBaseTextField;
1090
            }
1091
            set
1092
            {
1093
                this.hpsBaseTextField = value;
1094
            }
1095
        }
1096

1097
        [XmlElement(Order = 4)]
1098
        public CT_Lang lid
1099
        {
1100
            get
1101
            {
1102
                return this.lidField;
1103
            }
1104
            set
1105
            {
1106
                this.lidField = value;
1107
            }
1108
        }
1109

1110
        [XmlElement(Order = 5)]
1111
        public CT_OnOff dirty
1112
        {
1113
            get
1114
            {
1115
                return this.dirtyField;
1116
            }
1117
            set
1118
            {
1119
                this.dirtyField = value;
1120
            }
1121
        }
1122
    }
1123

1124

1125
    [Serializable]
1126

1127
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1128
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1129
    public class CT_RubyContent
1130
    {
1131

1132
        private ArrayList itemsField;
1133

1134
        private List<ItemsChoiceType16> itemsElementNameField;
1135

1136
        public CT_RubyContent()
1137
        {
1138
            this.itemsElementNameField = new List<ItemsChoiceType16>();
1139
            this.itemsField = new ArrayList();
1140
        }
1141

1142
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
1143
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
1144
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 0)]
1145
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 0)]
1146
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1147
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 0)]
1148
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 0)]
1149
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 0)]
1150
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 0)]
1151
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 0)]
1152
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 0)]
1153
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 0)]
1154
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 0)]
1155
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 0)]
1156
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 0)]
1157
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 0)]
1158
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 0)]
1159
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1160
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 0)]
1161
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 0)]
1162
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1163
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 0)]
1164
        [XmlElement("permEnd", typeof(CT_Perm), Order = 0)]
1165
        [XmlElement("permStart", typeof(CT_PermStart), Order = 0)]
1166
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 0)]
1167
        [XmlElement("r", typeof(CT_R), Order = 0)]
1168
        [XmlChoiceIdentifier("ItemsElementName")]
1169
        public ArrayList Items
1170
        {
1171
            get
1172
            {
1173
                return this.itemsField;
1174
            }
1175
            set
1176
            {
1177
                this.itemsField = value;
1178
            }
1179
        }
1180

1181
        [XmlElement("ItemsElementName", Order = 1)]
1182
        [XmlIgnore]
1183
        public List<ItemsChoiceType16> ItemsElementName
1184
        {
1185
            get
1186
            {
1187
                return this.itemsElementNameField;
1188
            }
1189
            set
1190
            {
1191
                this.itemsElementNameField = value;
1192
            }
1193
        }
1194

1195
        public static CT_RubyContent Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1196
        {
1197
            if (node == null)
1198
                return null;
1199
            CT_RubyContent ctObj = new CT_RubyContent();
1200
            foreach (XmlNode childNode in node.ChildNodes)
1201
            {
1202
                if (childNode.LocalName == "oMath")
1203
                {
1204
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
1205
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.oMath);
1206
                }
1207
                else if (childNode.LocalName == "permStart")
1208
                {
1209
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
1210
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.permStart);
1211
                }
1212
                else if (childNode.LocalName == "proofErr")
1213
                {
1214
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
1215
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.proofErr);
1216
                }
1217
                else if (childNode.LocalName == "permEnd")
1218
                {
1219
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
1220
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.permEnd);
1221
                }
1222
                else if (childNode.LocalName == "moveToRangeStart")
1223
                {
1224
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1225
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.moveToRangeStart);
1226
                }
1227
                else if (childNode.LocalName == "moveToRangeEnd")
1228
                {
1229
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1230
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.moveToRangeEnd);
1231
                }
1232
                else if (childNode.LocalName == "moveTo")
1233
                {
1234
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1235
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.moveTo);
1236
                }
1237
                else if (childNode.LocalName == "moveFromRangeStart")
1238
                {
1239
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1240
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.moveFromRangeStart);
1241
                }
1242
                else if (childNode.LocalName == "moveFromRangeEnd")
1243
                {
1244
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1245
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.moveFromRangeEnd);
1246
                }
1247
                else if (childNode.LocalName == "moveFrom")
1248
                {
1249
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1250
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.moveFrom);
1251
                }
1252
                else if (childNode.LocalName == "customXmlInsRangeEnd")
1253
                {
1254
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1255
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.customXmlInsRangeEnd);
1256
                }
1257
                else if (childNode.LocalName == "customXmlInsRangeStart")
1258
                {
1259
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1260
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.customXmlInsRangeStart);
1261
                }
1262
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
1263
                {
1264
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1265
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.customXmlMoveFromRangeEnd);
1266
                }
1267
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
1268
                {
1269
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1270
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.customXmlMoveFromRangeStart);
1271
                }
1272
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
1273
                {
1274
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1275
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.customXmlMoveToRangeEnd);
1276
                }
1277
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
1278
                {
1279
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1280
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.customXmlMoveToRangeStart);
1281
                }
1282
                else if (childNode.LocalName == "del")
1283
                {
1284
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1285
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.del);
1286
                }
1287
                else if (childNode.LocalName == "ins")
1288
                {
1289
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
1290
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.ins);
1291
                }
1292
                else if (childNode.LocalName == "customXmlDelRangeStart")
1293
                {
1294
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
1295
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.customXmlDelRangeStart);
1296
                }
1297
                else if (childNode.LocalName == "commentRangeStart")
1298
                {
1299
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1300
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.commentRangeStart);
1301
                }
1302
                else if (childNode.LocalName == "commentRangeEnd")
1303
                {
1304
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1305
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.commentRangeEnd);
1306
                }
1307
                else if (childNode.LocalName == "bookmarkStart")
1308
                {
1309
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
1310
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.bookmarkStart);
1311
                }
1312
                else if (childNode.LocalName == "bookmarkEnd")
1313
                {
1314
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1315
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.bookmarkEnd);
1316
                }
1317
                else if (childNode.LocalName == "oMathPara")
1318
                {
1319
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
1320
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.oMathPara);
1321
                }
1322
                else if (childNode.LocalName == "customXmlDelRangeEnd")
1323
                {
1324
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
1325
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.customXmlDelRangeEnd);
1326
                }
1327
                else if (childNode.LocalName == "r")
1328
                {
1329
                    ctObj.Items.Add(CT_R.Parse(childNode, namespaceManager));
1330
                    ctObj.ItemsElementName.Add(ItemsChoiceType16.r);
1331
                }
1332
            }
1333
            return ctObj;
1334
        }
1335

1336
        internal void Write(StreamWriter sw, string nodeName)
1337
        {
1338
            sw.Write(string.Format("<w:{0}", nodeName));
1339
            sw.Write(">");
1340
            int i = 0;
1341
            foreach (object o in this.Items)
1342
            {
1343
                if (o is CT_OMath)
1344
                    ((CT_OMath)o).Write(sw, "oMath");
1345
                else if (o is CT_PermStart)
1346
                    ((CT_PermStart)o).Write(sw, "permStart");
1347
                else if (o is CT_ProofErr)
1348
                    ((CT_ProofErr)o).Write(sw, "proofErr");
1349
                else if (o is CT_Perm)
1350
                    ((CT_Perm)o).Write(sw, "permEnd");
1351
                else if (o is CT_MoveBookmark && this.itemsElementNameField[i] == ItemsChoiceType16.moveToRangeStart)
1352
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
1353
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType16.moveToRangeEnd)
1354
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
1355
                else if (o is CT_RunTrackChange&& this.itemsElementNameField[i]== ItemsChoiceType16.moveTo)
1356
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
1357
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ItemsChoiceType16.moveFrom)
1358
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
1359
                else if (o is CT_MoveBookmark && this.itemsElementNameField[i] == ItemsChoiceType16.moveFromRangeStart)
1360
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
1361
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType16.moveFromRangeEnd)
1362
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
1363
                else if (o is CT_Markup && this.itemsElementNameField[i] == ItemsChoiceType16.customXmlInsRangeEnd)
1364
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
1365
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ItemsChoiceType16.customXmlInsRangeStart)
1366
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
1367
                else if (o is CT_Markup && this.itemsElementNameField[i] == ItemsChoiceType16.customXmlMoveFromRangeEnd)
1368
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
1369
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ItemsChoiceType16.customXmlMoveFromRangeStart)
1370
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
1371
                else if (o is CT_Markup && this.itemsElementNameField[i] == ItemsChoiceType16.customXmlMoveToRangeEnd)
1372
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
1373
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ItemsChoiceType16.customXmlMoveToRangeStart)
1374
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
1375
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ItemsChoiceType16.del)
1376
                    ((CT_RunTrackChange)o).Write(sw, "del");
1377
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ItemsChoiceType16.ins)
1378
                    ((CT_RunTrackChange)o).Write(sw, "ins");
1379
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ItemsChoiceType16.customXmlDelRangeStart)
1380
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
1381
                else if (o is CT_Markup && this.itemsElementNameField[i] == ItemsChoiceType16.customXmlDelRangeEnd)
1382
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
1383
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType16.commentRangeStart)
1384
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
1385
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType16.commentRangeEnd)
1386
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
1387
                else if (o is CT_Bookmark)
1388
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
1389
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType16.bookmarkEnd)
1390
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
1391
                else if (o is CT_OMathPara)
1392
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
1393
                else if (o is CT_R)
1394
                    ((CT_R)o).Write(sw, "r");
1395
                i++;
1396
            }
1397
            sw.WriteEndW(nodeName);
1398
        }
1399

1400
    }
1401

1402

1403
    [Serializable]
1404
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
1405
    public enum ItemsChoiceType16
1406
    {
1407

1408
    
1409
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
1410
        oMath,
1411

1412
    
1413
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
1414
        oMathPara,
1415

1416
    
1417
        bookmarkEnd,
1418

1419
    
1420
        bookmarkStart,
1421

1422
    
1423
        commentRangeEnd,
1424

1425
    
1426
        commentRangeStart,
1427

1428
    
1429
        customXmlDelRangeEnd,
1430

1431
    
1432
        customXmlDelRangeStart,
1433

1434
    
1435
        customXmlInsRangeEnd,
1436

1437
    
1438
        customXmlInsRangeStart,
1439

1440
    
1441
        customXmlMoveFromRangeEnd,
1442

1443
    
1444
        customXmlMoveFromRangeStart,
1445

1446
    
1447
        customXmlMoveToRangeEnd,
1448

1449
    
1450
        customXmlMoveToRangeStart,
1451

1452
    
1453
        del,
1454

1455
    
1456
        ins,
1457

1458
    
1459
        moveFrom,
1460

1461
    
1462
        moveFromRangeEnd,
1463

1464
    
1465
        moveFromRangeStart,
1466

1467
    
1468
        moveTo,
1469

1470
    
1471
        moveToRangeEnd,
1472

1473
    
1474
        moveToRangeStart,
1475

1476
    
1477
        permEnd,
1478

1479
    
1480
        permStart,
1481

1482
    
1483
        proofErr,
1484

1485
    
1486
        r,
1487
    }
1488

1489
    [Serializable]
1490

1491
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1492
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1493
    public class CT_Ruby
1494
    {
1495

1496
        private CT_RubyPr rubyPrField;
1497

1498
        private CT_RubyContent rtField;
1499

1500
        private CT_RubyContent rubyBaseField;
1501

1502
        public CT_Ruby()
1503
        {
1504
            //this.rubyBaseField = new CT_RubyContent();
1505
            //this.rtField = new CT_RubyContent();
1506
            //this.rubyPrField = new CT_RubyPr();
1507
        }
1508

1509
        public static CT_Ruby Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1510
        {
1511
            if (node == null)
1512
                return null;
1513
            CT_Ruby ctObj = new CT_Ruby();
1514
            foreach (XmlNode childNode in node.ChildNodes)
1515
            {
1516
                if (childNode.LocalName == "rubyPr")
1517
                    ctObj.rubyPr = CT_RubyPr.Parse(childNode, namespaceManager);
1518
                else if (childNode.LocalName == "rt")
1519
                    ctObj.rt = CT_RubyContent.Parse(childNode, namespaceManager);
1520
                else if (childNode.LocalName == "rubyBase")
1521
                    ctObj.rubyBase = CT_RubyContent.Parse(childNode, namespaceManager);
1522
            }
1523
            return ctObj;
1524
        }
1525

1526

1527

1528
        internal void Write(StreamWriter sw, string nodeName)
1529
        {
1530
            sw.Write(string.Format("<w:{0}", nodeName));
1531
            sw.Write(">");
1532
            if (this.rubyPr != null)
1533
                this.rubyPr.Write(sw, "rubyPr");
1534
            if (this.rt != null)
1535
                this.rt.Write(sw, "rt");
1536
            if (this.rubyBase != null)
1537
                this.rubyBase.Write(sw, "rubyBase");
1538
            sw.WriteEndW(nodeName);
1539
        }
1540

1541
        [XmlElement(Order = 0)]
1542
        public CT_RubyPr rubyPr
1543
        {
1544
            get
1545
            {
1546
                return this.rubyPrField;
1547
            }
1548
            set
1549
            {
1550
                this.rubyPrField = value;
1551
            }
1552
        }
1553

1554
        [XmlElement(Order = 1)]
1555
        public CT_RubyContent rt
1556
        {
1557
            get
1558
            {
1559
                return this.rtField;
1560
            }
1561
            set
1562
            {
1563
                this.rtField = value;
1564
            }
1565
        }
1566

1567
        [XmlElement(Order = 2)]
1568
        public CT_RubyContent rubyBase
1569
        {
1570
            get
1571
            {
1572
                return this.rubyBaseField;
1573
            }
1574
            set
1575
            {
1576
                this.rubyBaseField = value;
1577
            }
1578
        }
1579
    }
1580

1581
    [Serializable]
1582

1583
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1584
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1585
    public class CT_Jc
1586
    {
1587
        public static CT_Jc Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1588
        {
1589
            if (node == null)
1590
                return null;
1591
            CT_Jc ctObj = new CT_Jc();
1592
            if (node.Attributes["w:val"] != null)
1593
                ctObj.val = (ST_Jc)Enum.Parse(typeof(ST_Jc), node.Attributes["w:val"].Value);
1594
            return ctObj;
1595
        }
1596

1597

1598

1599
        internal void Write(StreamWriter sw, string nodeName)
1600
        {
1601
            sw.Write(string.Format("<w:{0}", nodeName));
1602
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1603
            sw.Write("/>");
1604
        }
1605

1606

1607
        private ST_Jc valField;
1608

1609
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1610
        public ST_Jc val
1611
        {
1612
            get
1613
            {
1614
                return this.valField;
1615
            }
1616
            set
1617
            {
1618
                this.valField = value;
1619
            }
1620
        }
1621
    }
1622

1623

1624
    [Serializable]
1625
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1626
    public enum ST_Jc
1627
    {
1628
    
1629
        left,
1630

1631
    
1632
        center,
1633

1634
    
1635
        right,
1636

1637
    
1638
        both,
1639

1640
    
1641
        mediumKashida,
1642

1643
    
1644
        distribute,
1645

1646
    
1647
        numTab,
1648

1649
    
1650
        highKashida,
1651

1652
    
1653
        lowKashida,
1654

1655
    
1656
        thaiDistribute,
1657
    }
1658

1659

1660
    [Serializable]
1661

1662
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1663
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1664
    public class CT_TextDirection
1665
    {
1666
        public static CT_TextDirection Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1667
        {
1668
            if (node == null)
1669
                return null;
1670
            CT_TextDirection ctObj = new CT_TextDirection();
1671
            if (node.Attributes["w:val"] != null)
1672
                ctObj.val = (ST_TextDirection)Enum.Parse(typeof(ST_TextDirection), node.Attributes["w:val"].Value);
1673
            return ctObj;
1674
        }
1675

1676

1677

1678
        internal void Write(StreamWriter sw, string nodeName)
1679
        {
1680
            sw.Write(string.Format("<w:{0}", nodeName));
1681
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1682
            sw.Write("/>");
1683
        }
1684

1685

1686
        private ST_TextDirection valField;
1687

1688
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1689
        public ST_TextDirection val
1690
        {
1691
            get
1692
            {
1693
                return this.valField;
1694
            }
1695
            set
1696
            {
1697
                this.valField = value;
1698
            }
1699
        }
1700
    }
1701

1702

1703
    [Serializable]
1704
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1705
    public enum ST_TextDirection
1706
    {
1707

1708
    
1709
        lrTb,
1710

1711
    
1712
        tbRl,
1713

1714
    
1715
        btLr,
1716

1717
    
1718
        lrTbV,
1719

1720
    
1721
        tbRlV,
1722

1723
    
1724
        tbLrV,
1725
    }
1726

1727

1728
    [Serializable]
1729

1730
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1731
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1732
    public class CT_TextAlignment
1733
    {
1734
        public static CT_TextAlignment Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1735
        {
1736
            if (node == null)
1737
                return null;
1738
            CT_TextAlignment ctObj = new CT_TextAlignment();
1739
            if (node.Attributes["w:val"] != null)
1740
                ctObj.val = (ST_TextAlignment)Enum.Parse(typeof(ST_TextAlignment), node.Attributes["w:val"].Value);
1741
            return ctObj;
1742
        }
1743

1744

1745

1746
        internal void Write(StreamWriter sw, string nodeName)
1747
        {
1748
            sw.Write(string.Format("<w:{0}", nodeName));
1749
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1750
            sw.Write("/>");
1751
        }
1752

1753

1754
        private ST_TextAlignment valField;
1755

1756
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1757
        public ST_TextAlignment val
1758
        {
1759
            get
1760
            {
1761
                return this.valField;
1762
            }
1763
            set
1764
            {
1765
                this.valField = value;
1766
            }
1767
        }
1768
    }
1769

1770

1771
    [Serializable]
1772
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1773
    public enum ST_TextAlignment
1774
    {
1775

1776
    
1777
        top,
1778

1779
    
1780
        center,
1781

1782
    
1783
        baseline,
1784

1785
    
1786
        bottom,
1787

1788
    
1789
        auto,
1790
    }
1791

1792

1793
    [Serializable]
1794

1795
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1796
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1797
    public class CT_TextboxTightWrap
1798
    {
1799
        public static CT_TextboxTightWrap Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1800
        {
1801
            if (node == null)
1802
                return null;
1803
            CT_TextboxTightWrap ctObj = new CT_TextboxTightWrap();
1804
            if (node.Attributes["w:val"] != null)
1805
                ctObj.val = (ST_TextboxTightWrap)Enum.Parse(typeof(ST_TextboxTightWrap), node.Attributes["w:val"].Value);
1806
            return ctObj;
1807
        }
1808

1809

1810

1811
        internal void Write(StreamWriter sw, string nodeName)
1812
        {
1813
            sw.Write(string.Format("<w:{0}", nodeName));
1814
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1815
            sw.Write(">");
1816
            sw.WriteEndW(nodeName);
1817
        }
1818

1819
        private ST_TextboxTightWrap valField;
1820

1821
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1822
        public ST_TextboxTightWrap val
1823
        {
1824
            get
1825
            {
1826
                return this.valField;
1827
            }
1828
            set
1829
            {
1830
                this.valField = value;
1831
            }
1832
        }
1833
    }
1834

1835

1836
    [Serializable]
1837
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1838
    public enum ST_TextboxTightWrap
1839
    {
1840

1841
    
1842
        none,
1843

1844
    
1845
        allLines,
1846

1847
    
1848
        firstAndLastLine,
1849

1850
    
1851
        firstLineOnly,
1852

1853
    
1854
        lastLineOnly,
1855
    }
1856

1857

1858

1859
    [Serializable]
1860

1861
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1862
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1863
    public class CT_VerticalAlignRun
1864
    {
1865
        public static CT_VerticalAlignRun Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1866
        {
1867
            if (node == null)
1868
                return null;
1869
            CT_VerticalAlignRun ctObj = new CT_VerticalAlignRun();
1870
            if (node.Attributes["w:val"] != null)
1871
                ctObj.val = (ST_VerticalAlignRun)Enum.Parse(typeof(ST_VerticalAlignRun), node.Attributes["w:val"].Value);
1872
            return ctObj;
1873
        }
1874

1875

1876

1877
        internal void Write(StreamWriter sw, string nodeName)
1878
        {
1879
            sw.Write(string.Format("<w:{0}", nodeName));
1880
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1881
            sw.Write(">");
1882
            sw.WriteEndW(nodeName);
1883
        }
1884

1885

1886
        private ST_VerticalAlignRun valField;
1887

1888
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1889
        public ST_VerticalAlignRun val
1890
        {
1891
            get
1892
            {
1893
                return this.valField;
1894
            }
1895
            set
1896
            {
1897
                this.valField = value;
1898
            }
1899
        }
1900
    }
1901

1902

1903
    [Serializable]
1904
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1905
    public enum ST_VerticalAlignRun
1906
    {
1907

1908
    
1909
        baseline,
1910

1911
    
1912
        superscript,
1913

1914
    
1915
        subscript,
1916
    }
1917

1918

1919

1920

1921
    [Serializable]
1922
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
1923
    public enum ItemsChoiceType5
1924
    {
1925

1926
    
1927
        b,
1928

1929
    
1930
        bCs,
1931

1932
    
1933
        bdr,
1934

1935
    
1936
        caps,
1937

1938
    
1939
        color,
1940

1941
    
1942
        cs,
1943

1944
    
1945
        dstrike,
1946

1947
    
1948
        eastAsianLayout,
1949

1950
    
1951
        effect,
1952

1953
    
1954
        em,
1955

1956
    
1957
        emboss,
1958

1959
    
1960
        fitText,
1961

1962
    
1963
        highlight,
1964

1965
    
1966
        i,
1967

1968
    
1969
        iCs,
1970

1971
    
1972
        imprint,
1973

1974
    
1975
        kern,
1976

1977
    
1978
        lang,
1979

1980
    
1981
        noProof,
1982

1983
    
1984
        oMath,
1985

1986
    
1987
        outline,
1988

1989
    
1990
        position,
1991

1992
    
1993
        rFonts,
1994

1995
    
1996
        rStyle,
1997

1998
    
1999
        rtl,
2000

2001
    
2002
        shadow,
2003

2004
    
2005
        shd,
2006

2007
    
2008
        smallCaps,
2009

2010
    
2011
        snapToGrid,
2012

2013
    
2014
        spacing,
2015

2016
    
2017
        specVanish,
2018

2019
    
2020
        strike,
2021

2022
    
2023
        sz,
2024

2025
    
2026
        szCs,
2027

2028
    
2029
        u,
2030

2031
    
2032
        vanish,
2033

2034
    
2035
        vertAlign,
2036

2037
    
2038
        w,
2039

2040
    
2041
        webHidden,
2042
    }
2043

2044
    [Serializable]
2045

2046
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
2047
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
2048
    public class CT_RunTrackChange : CT_TrackChange
2049
    {
2050
        private ArrayList itemsField;
2051

2052
        private List<ItemsChoiceType6> itemsElementNameField;
2053

2054
        public CT_RunTrackChange()
2055
        {
2056
            this.itemsElementNameField = new List<ItemsChoiceType6>();
2057
            this.itemsField = new ArrayList();
2058
        }
2059
        public new static CT_RunTrackChange Parse(XmlNode node, XmlNamespaceManager namespaceManager)
2060
        {
2061
            if (node == null)
2062
                return null;
2063
            CT_RunTrackChange ctObj = new CT_RunTrackChange();
2064
            foreach (XmlNode childNode in node.ChildNodes)
2065
            {
2066
                if (childNode.LocalName == "func")
2067
                {
2068
                    ctObj.Items.Add(CT_Func.Parse(childNode, namespaceManager));
2069
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.func);
2070
                }
2071
                else if (childNode.LocalName == "sSubSup")
2072
                {
2073
                    ctObj.Items.Add(CT_SSubSup.Parse(childNode, namespaceManager));
2074
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.sSubSup);
2075
                }
2076
                else if (childNode.LocalName == "customXmlInsRangeStart")
2077
                {
2078
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2079
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXmlInsRangeStart);
2080
                }
2081
                else if (childNode.LocalName == "acc")
2082
                {
2083
                    ctObj.Items.Add(CT_Acc.Parse(childNode, namespaceManager));
2084
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.acc);
2085
                }
2086
                else if (childNode.LocalName == "bar")
2087
                {
2088
                    ctObj.Items.Add(CT_Bar.Parse(childNode, namespaceManager));
2089
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.bar);
2090
                }
2091
                else if (childNode.LocalName == "borderBox")
2092
                {
2093
                    ctObj.Items.Add(CT_BorderBox.Parse(childNode, namespaceManager));
2094
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.borderBox);
2095
                }
2096
                else if (childNode.LocalName == "box")
2097
                {
2098
                    ctObj.Items.Add(CT_Box.Parse(childNode, namespaceManager));
2099
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.box);
2100
                }
2101
                else if (childNode.LocalName == "d")
2102
                {
2103
                    ctObj.Items.Add(CT_D.Parse(childNode, namespaceManager));
2104
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.d);
2105
                }
2106
                else if (childNode.LocalName == "eqArr")
2107
                {
2108
                    ctObj.Items.Add(CT_EqArr.Parse(childNode, namespaceManager));
2109
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.eqArr);
2110
                }
2111
                else if (childNode.LocalName == "f")
2112
                {
2113
                    ctObj.Items.Add(CT_F.Parse(childNode, namespaceManager));
2114
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.f);
2115
                }
2116
                else if (childNode.LocalName == "groupChr")
2117
                {
2118
                    ctObj.Items.Add(CT_GroupChr.Parse(childNode, namespaceManager));
2119
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.groupChr);
2120
                }
2121
                else if (childNode.LocalName == "limLow")
2122
                {
2123
                    ctObj.Items.Add(CT_LimLow.Parse(childNode, namespaceManager));
2124
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.limLow);
2125
                }
2126
                else if (childNode.LocalName == "m")
2127
                {
2128
                    ctObj.Items.Add(CT_M.Parse(childNode, namespaceManager));
2129
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.m);
2130
                }
2131
                else if (childNode.LocalName == "nary")
2132
                {
2133
                    ctObj.Items.Add(CT_Nary.Parse(childNode, namespaceManager));
2134
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.nary);
2135
                }
2136
                else if (childNode.LocalName == "oMath")
2137
                {
2138
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
2139
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.oMath);
2140
                }
2141
                else if (childNode.LocalName == "oMathPara")
2142
                {
2143
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
2144
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.oMathPara);
2145
                }
2146
                else if (childNode.LocalName == "phant")
2147
                {
2148
                    ctObj.Items.Add(CT_Phant.Parse(childNode, namespaceManager));
2149
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.phant);
2150
                }
2151
                else if (childNode.LocalName == "r")
2152
                {
2153
                    ctObj.Items.Add(CT_R.Parse(childNode, namespaceManager));
2154
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.r);
2155
                }
2156
                else if (childNode.LocalName == "rad")
2157
                {
2158
                    ctObj.Items.Add(CT_Rad.Parse(childNode, namespaceManager));
2159
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.rad);
2160
                }
2161
                else if (childNode.LocalName == "sPre")
2162
                {
2163
                    ctObj.Items.Add(CT_SPre.Parse(childNode, namespaceManager));
2164
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.sPre);
2165
                }
2166
                else if (childNode.LocalName == "sSub")
2167
                {
2168
                    ctObj.Items.Add(CT_SSub.Parse(childNode, namespaceManager));
2169
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.sSub);
2170
                }
2171
                else if (childNode.LocalName == "sSup")
2172
                {
2173
                    ctObj.Items.Add(CT_SSup.Parse(childNode, namespaceManager));
2174
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.sSup);
2175
                }
2176
                else if (childNode.LocalName == "bookmarkEnd")
2177
                {
2178
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2179
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.bookmarkEnd);
2180
                }
2181
                else if (childNode.LocalName == "bookmarkStart")
2182
                {
2183
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
2184
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.bookmarkStart);
2185
                }
2186
                else if (childNode.LocalName == "commentRangeEnd")
2187
                {
2188
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2189
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.commentRangeEnd);
2190
                }
2191
                else if (childNode.LocalName == "commentRangeStart")
2192
                {
2193
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2194
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.commentRangeStart);
2195
                }
2196
                else if (childNode.LocalName == "customXml")
2197
                {
2198
                    ctObj.Items.Add(CT_CustomXmlRun.Parse(childNode, namespaceManager));
2199
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXml);
2200
                }
2201
                else if (childNode.LocalName == "customXmlDelRangeEnd")
2202
                {
2203
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2204
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXmlDelRangeEnd);
2205
                }
2206
                else if (childNode.LocalName == "customXmlDelRangeStart")
2207
                {
2208
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2209
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXmlDelRangeStart);
2210
                }
2211
                else if (childNode.LocalName == "customXmlInsRangeEnd")
2212
                {
2213
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2214
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXmlInsRangeEnd);
2215
                }
2216
                else if (childNode.LocalName == "limUpp")
2217
                {
2218
                    ctObj.Items.Add(CT_LimUpp.Parse(childNode, namespaceManager));
2219
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.limUpp);
2220
                }
2221
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
2222
                {
2223
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2224
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXmlMoveFromRangeEnd);
2225
                }
2226
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
2227
                {
2228
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2229
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXmlMoveFromRangeStart);
2230
                }
2231
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
2232
                {
2233
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
2234
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXmlMoveToRangeEnd);
2235
                }
2236
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
2237
                {
2238
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
2239
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.customXmlMoveToRangeStart);
2240
                }
2241
                else if (childNode.LocalName == "del")
2242
                {
2243
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2244
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.del);
2245
                }
2246
                else if (childNode.LocalName == "ins")
2247
                {
2248
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2249
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.ins);
2250
                }
2251
                else if (childNode.LocalName == "moveFrom")
2252
                {
2253
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2254
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.moveFrom);
2255
                }
2256
                else if (childNode.LocalName == "moveFromRangeEnd")
2257
                {
2258
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2259
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.moveFromRangeEnd);
2260
                }
2261
                else if (childNode.LocalName == "moveFromRangeStart")
2262
                {
2263
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
2264
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.moveFromRangeStart);
2265
                }
2266
                else if (childNode.LocalName == "moveTo")
2267
                {
2268
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
2269
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.moveTo);
2270
                }
2271
                else if (childNode.LocalName == "moveToRangeEnd")
2272
                {
2273
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
2274
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.moveToRangeEnd);
2275
                }
2276
                else if (childNode.LocalName == "moveToRangeStart")
2277
                {
2278
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
2279
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.moveToRangeStart);
2280
                }
2281
                else if (childNode.LocalName == "permEnd")
2282
                {
2283
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
2284
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.permEnd);
2285
                }
2286
                else if (childNode.LocalName == "permStart")
2287
                {
2288
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
2289
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.permStart);
2290
                }
2291
                else if (childNode.LocalName == "proofErr")
2292
                {
2293
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
2294
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.proofErr);
2295
                }
2296
                else if (childNode.LocalName == "r")
2297
                {
2298
                    ctObj.Items.Add(CT_R.Parse(childNode, namespaceManager));
2299
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.r);
2300
                }
2301
                else if (childNode.LocalName == "sdt")
2302
                {
2303
                    ctObj.Items.Add(CT_SdtRun.Parse(childNode, namespaceManager));
2304
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.sdt);
2305
                }
2306
                else if (childNode.LocalName == "smartTag")
2307
                {
2308
                    ctObj.Items.Add(CT_SmartTagRun.Parse(childNode, namespaceManager));
2309
                    ctObj.ItemsElementName.Add(ItemsChoiceType6.smartTag);
2310
                }
2311
            }
2312
            return ctObj;
2313
        }
2314

2315
        internal new void Write(StreamWriter sw, string nodeName)
2316
        {
2317
            sw.Write(string.Format("<w:{0}", nodeName));
2318
            sw.Write(">");
2319
            foreach (object o in this.Items)
2320
            {
2321
                if (o is CT_Func)
2322
                    ((CT_Func)o).Write(sw, "func");
2323
                else if (o is CT_SSubSup)
2324
                    ((CT_SSubSup)o).Write(sw, "sSubSup");
2325
                else if (o is CT_TrackChange)
2326
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
2327
                else if (o is CT_Acc)
2328
                    ((CT_Acc)o).Write(sw, "acc");
2329
                else if (o is CT_Bar)
2330
                    ((CT_Bar)o).Write(sw, "bar");
2331
                else if (o is CT_BorderBox)
2332
                    ((CT_BorderBox)o).Write(sw, "borderBox");
2333
                else if (o is CT_Box)
2334
                    ((CT_Box)o).Write(sw, "box");
2335
                else if (o is CT_D)
2336
                    ((CT_D)o).Write(sw, "d");
2337
                else if (o is CT_EqArr)
2338
                    ((CT_EqArr)o).Write(sw, "eqArr");
2339
                else if (o is CT_F)
2340
                    ((CT_F)o).Write(sw, "f");
2341
                else if (o is CT_GroupChr)
2342
                    ((CT_GroupChr)o).Write(sw, "groupChr");
2343
                else if (o is CT_LimLow)
2344
                    ((CT_LimLow)o).Write(sw, "limLow");
2345
                else if (o is CT_M)
2346
                    ((CT_M)o).Write(sw, "m");
2347
                else if (o is CT_Nary)
2348
                    ((CT_Nary)o).Write(sw, "nary");
2349
                else if (o is CT_OMath)
2350
                    ((CT_OMath)o).Write(sw, "oMath");
2351
                else if (o is CT_OMathPara)
2352
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
2353
                else if (o is CT_Phant)
2354
                    ((CT_Phant)o).Write(sw, "phant");
2355
                else if (o is CT_R)
2356
                    ((CT_R)o).Write(sw, "r");
2357
                else if (o is CT_Rad)
2358
                    ((CT_Rad)o).Write(sw, "rad");
2359
                else if (o is CT_SPre)
2360
                    ((CT_SPre)o).Write(sw, "sPre");
2361
                else if (o is CT_SSub)
2362
                    ((CT_SSub)o).Write(sw, "sSub");
2363
                else if (o is CT_SSup)
2364
                    ((CT_SSup)o).Write(sw, "sSup");
2365
                else if (o is CT_MarkupRange)
2366
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
2367
                else if (o is CT_Bookmark)
2368
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
2369
                else if (o is CT_MarkupRange)
2370
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
2371
                else if (o is CT_MarkupRange)
2372
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
2373
                else if (o is CT_CustomXmlRun)
2374
                    ((CT_CustomXmlRun)o).Write(sw, "customXml");
2375
                else if (o is CT_Markup)
2376
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
2377
                else if (o is CT_TrackChange)
2378
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
2379
                else if (o is CT_Markup)
2380
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
2381
                else if (o is CT_LimUpp)
2382
                    ((CT_LimUpp)o).Write(sw, "limUpp");
2383
                else if (o is CT_Markup)
2384
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
2385
                else if (o is CT_TrackChange)
2386
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
2387
                else if (o is CT_Markup)
2388
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
2389
                else if (o is CT_TrackChange)
2390
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
2391
                else if (o is CT_RunTrackChange)
2392
                    ((CT_RunTrackChange)o).Write(sw, "del");
2393
                else if (o is CT_RunTrackChange)
2394
                    ((CT_RunTrackChange)o).Write(sw, "ins");
2395
                else if (o is CT_RunTrackChange)
2396
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
2397
                else if (o is CT_MarkupRange)
2398
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
2399
                else if (o is CT_MoveBookmark)
2400
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
2401
                else if (o is CT_RunTrackChange)
2402
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
2403
                else if (o is CT_MarkupRange)
2404
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
2405
                else if (o is CT_MoveBookmark)
2406
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
2407
                else if (o is CT_Perm)
2408
                    ((CT_Perm)o).Write(sw, "permEnd");
2409
                else if (o is CT_PermStart)
2410
                    ((CT_PermStart)o).Write(sw, "permStart");
2411
                else if (o is CT_ProofErr)
2412
                    ((CT_ProofErr)o).Write(sw, "proofErr");
2413
                else if (o is CT_R)
2414
                    ((CT_R)o).Write(sw, "r");
2415
                else if (o is CT_SdtRun)
2416
                    ((CT_SdtRun)o).Write(sw, "sdt");
2417
                else if (o is CT_SmartTagRun)
2418
                    ((CT_SmartTagRun)o).Write(sw, "smartTag");
2419
            }
2420
            sw.Write(string.Format("</w:{0}", nodeName));
2421
        }
2422

2423
        [XmlElement("acc", typeof(CT_Acc), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2424
        [XmlElement("bar", typeof(CT_Bar), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2425
        [XmlElement("borderBox", typeof(CT_BorderBox), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2426
        [XmlElement("box", typeof(CT_Box), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2427
        [XmlElement("d", typeof(CT_D), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2428
        [XmlElement("eqArr", typeof(CT_EqArr), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2429
        [XmlElement("f", typeof(CT_F), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2430
        [XmlElement("func", typeof(CT_Func), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2431
        [XmlElement("groupChr", typeof(CT_GroupChr), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2432
        [XmlElement("limLow", typeof(CT_LimLow), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2433
        [XmlElement("limUpp", typeof(CT_LimUpp), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2434
        [XmlElement("m", typeof(CT_M), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2435
        [XmlElement("nary", typeof(CT_Nary), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2436
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2437
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2438
        [XmlElement("phant", typeof(CT_Phant), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2439
        [XmlElement("r", typeof(NPOI.OpenXmlFormats.Shared.CT_R), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2440
        [XmlElement("rad", typeof(CT_Rad), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2441
        [XmlElement("sPre", typeof(CT_SPre), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2442
        [XmlElement("sSub", typeof(CT_SSub), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2443
        [XmlElement("sSubSup", typeof(CT_SSubSup), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2444
        [XmlElement("sSup", typeof(CT_SSup), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
2445
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 0)]
2446
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 0)]
2447
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 0)]
2448
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 0)]
2449
        [XmlElement("customXml", typeof(CT_CustomXmlRun), Order = 0)]
2450
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 0)]
2451
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 0)]
2452
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 0)]
2453
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 0)]
2454
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 0)]
2455
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 0)]
2456
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 0)]
2457
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 0)]
2458
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 0)]
2459
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 0)]
2460
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 0)]
2461
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 0)]
2462
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 0)]
2463
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 0)]
2464
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 0)]
2465
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 0)]
2466
        [XmlElement("permEnd", typeof(CT_Perm), Order = 0)]
2467
        [XmlElement("permStart", typeof(CT_PermStart), Order = 0)]
2468
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 0)]
2469
        [XmlElement("r", typeof(CT_R), Order = 0)]
2470
        [XmlElement("sdt", typeof(CT_SdtRun), Order = 0)]
2471
        [XmlElement("smartTag", typeof(CT_SmartTagRun), Order = 0)]
2472
        [XmlChoiceIdentifier("ItemsElementName")]
2473
        public ArrayList Items
2474
        {
2475
            get
2476
            {
2477
                return this.itemsField;
2478
            }
2479
            set
2480
            {
2481
                    this.itemsField = value;
2482
            }
2483
        }
2484

2485
        [XmlElement("ItemsElementName", Order = 1)]
2486
        [XmlIgnore]
2487
        public List<ItemsChoiceType6> ItemsElementName
2488
        {
2489
            get
2490
            {
2491
                return this.itemsElementNameField;
2492
            }
2493
            set
2494
            {
2495
                this.itemsElementNameField = value;
2496
            }
2497
        }
2498
        public List<CT_RunTrackChange> GetInsList()
2499
        {
2500
            return GetObjectList<CT_RunTrackChange>(ItemsChoiceType6.ins);
2501
        }
2502
        public List<CT_R> GetRList()
2503
        {
2504
            return GetObjectList<CT_R>(ItemsChoiceType6.r);
2505
        }
2506
        #region Generic methods for object operation
2507

2508
        private List<T> GetObjectList<T>(ItemsChoiceType6 type) where T : class
2509
        {
2510
            lock (this)
2511
            {
2512
                List<T> list = new List<T>();
2513
                for (int i = 0; i < itemsElementNameField.Count; i++)
2514
                {
2515
                    if (itemsElementNameField[i] == type)
2516
                        list.Add(itemsField[i] as T);
2517
                }
2518
                return list;
2519
            }
2520
        }
2521
        private int SizeOfArray(ItemsChoiceType6 type)
2522
        {
2523
            lock (this)
2524
            {
2525
                int size = 0;
2526
                for (int i = 0; i < itemsElementNameField.Count; i++)
2527
                {
2528
                    if (itemsElementNameField[i] == type)
2529
                        size++;
2530
                }
2531
                return size;
2532
            }
2533
        }
2534
        private T GetObjectArray<T>(int p, ItemsChoiceType6 type) where T : class
2535
        {
2536
            lock (this)
2537
            {
2538
                int pos = GetObjectIndex(type, p);
2539
                if (pos < 0 || pos >= this.itemsField.Count)
2540
                    return null;
2541
                return itemsField[pos] as T;
2542
            }
2543
        }
2544
        private T InsertNewObject<T>(ItemsChoiceType6 type, int p) where T : class, new()
2545
        {
2546
            T t = new T();
2547
            lock (this)
2548
            {
2549
                int pos = GetObjectIndex(type, p);
2550
                this.itemsElementNameField.Insert(pos, type);
2551
                this.itemsField.Insert(pos, t);
2552
            }
2553
            return t;
2554
        }
2555
        private T AddNewObject<T>(ItemsChoiceType6 type) where T : class, new()
2556
        {
2557
            T t = new T();
2558
            lock (this)
2559
            {
2560
                this.itemsElementNameField.Add(type);
2561
                this.itemsField.Add(t);
2562
            }
2563
            return t;
2564
        }
2565
        private void SetObject<T>(ItemsChoiceType6 type, int p, T obj) where T : class
2566
        {
2567
            lock (this)
2568
            {
2569
                int pos = GetObjectIndex(type, p);
2570
                if (pos < 0 || pos >= this.itemsField.Count)
2571
                    return;
2572
                if (this.itemsField[pos] is T)
2573
                    this.itemsField[pos] = obj;
2574
                else
2575
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
2576
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
2577
            }
2578
        }
2579
        private int GetObjectIndex(ItemsChoiceType6 type, int p)
2580
        {
2581
            int index = -1;
2582
            int pos = 0;
2583
            for (int i = 0; i < itemsElementNameField.Count; i++)
2584
            {
2585
                if (itemsElementNameField[i] == type)
2586
                {
2587
                    if (pos == p)
2588
                    {
2589
                        index = i;
2590
                        break;
2591
                    }
2592
                    else
2593
                        pos++;
2594
                }
2595
            }
2596
            return index;
2597
        }
2598
        private void RemoveObject(ItemsChoiceType6 type, int p)
2599
        {
2600
            lock (this)
2601
            {
2602
                int pos = GetObjectIndex(type, p);
2603
                if (pos < 0 || pos >= this.itemsField.Count)
2604
                    return;
2605
                itemsElementNameField.RemoveAt(pos);
2606
                itemsField.RemoveAt(pos);
2607
            }
2608
        }
2609
        #endregion
2610
    }
2611

2612
    [Serializable]
2613
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
2614
    public enum ItemsChoiceType6
2615
    {
2616

2617
    
2618
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:acc")]
2619
        acc,
2620

2621
    
2622
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:bar")]
2623
        bar,
2624

2625
    
2626
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:borderBox")]
2627
        borderBox,
2628

2629
    
2630
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:box")]
2631
        box,
2632

2633
    
2634
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:d")]
2635
        d,
2636

2637
    
2638
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:eqArr")]
2639
        eqArr,
2640

2641
    
2642
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:f")]
2643
        f,
2644

2645
    
2646
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:func")]
2647
        func,
2648

2649
    
2650
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:groupChr")]
2651
        groupChr,
2652

2653
    
2654
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:limLow")]
2655
        limLow,
2656

2657
    
2658
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:limUpp")]
2659
        limUpp,
2660

2661
    
2662
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:m")]
2663
        m,
2664

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

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

2673
    
2674
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
2675
        oMathPara,
2676

2677
    
2678
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:phant")]
2679
        phant,
2680

2681
    
2682
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:r")]
2683
        r,
2684

2685
    
2686
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:rad")]
2687
        rad,
2688

2689
    
2690
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:sPre")]
2691
        sPre,
2692

2693
    
2694
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:sSub")]
2695
        sSub,
2696

2697
    
2698
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:sSubSup")]
2699
        sSubSup,
2700

2701
    
2702
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:sSup")]
2703
        sSup,
2704

2705
    
2706
        bookmarkEnd,
2707

2708
    
2709
        bookmarkStart,
2710

2711
    
2712
        commentRangeEnd,
2713

2714
    
2715
        commentRangeStart,
2716

2717
    
2718
        customXml,
2719

2720
    
2721
        customXmlDelRangeEnd,
2722

2723
    
2724
        customXmlDelRangeStart,
2725

2726
    
2727
        customXmlInsRangeEnd,
2728

2729
    
2730
        customXmlInsRangeStart,
2731

2732
    
2733
        customXmlMoveFromRangeEnd,
2734

2735
    
2736
        customXmlMoveFromRangeStart,
2737

2738
    
2739
        customXmlMoveToRangeEnd,
2740

2741
    
2742
        customXmlMoveToRangeStart,
2743

2744
    
2745
        del,
2746

2747
    
2748
        ins,
2749

2750
    
2751
        moveFrom,
2752

2753
    
2754
        moveFromRangeEnd,
2755

2756
    
2757
        moveFromRangeStart,
2758

2759
    
2760
        moveTo,
2761

2762
    
2763
        moveToRangeEnd,
2764

2765
    
2766
        moveToRangeStart,
2767

2768
    
2769
        permEnd,
2770

2771
    
2772
        permStart,
2773

2774
    
2775
        proofErr,
2776

2777
    
2778
        [XmlEnum("r")]
2779
        r1,
2780

2781
    
2782
        sdt,
2783

2784
    
2785
        smartTag,
2786
    }
2787
    
2788
}