npoi

1

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

12
namespace NPOI.OpenXmlFormats.Wordprocessing
13
{
14

15
    [Serializable]
16
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
17
    public class CT_HdrFtr
18
    {
19

20
        private ArrayList itemsField;
21

22
        private List<ItemsChoiceType8> itemsElementNameField;
23

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

189
        internal void Write(StreamWriter sw, string nodeName)
190
        {
191
            sw.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
192
            sw.Write(string.Format("<w:{0} ", nodeName));
193
            sw.Write("xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" ");
194
            sw.Write("xmlns:cx=\"http://schemas.microsoft.com/office/drawing/2014/chartex\" xmlns:cx1=\"http://schemas.microsoft.com/office/drawing/2015/9/8/chartex\" xmlns:cx2=\"http://schemas.microsoft.com/office/drawing/2015/10/21/chartex\" xmlns:cx3=\"http://schemas.microsoft.com/office/drawing/2016/5/9/chartex\" xmlns:cx4=\"http://schemas.microsoft.com/office/drawing/2016/5/10/chartex\" xmlns:cx5=\"http://schemas.microsoft.com/office/drawing/2016/5/11/chartex\" xmlns:cx6=\"http://schemas.microsoft.com/office/drawing/2016/5/12/chartex\" xmlns:cx7=\"http://schemas.microsoft.com/office/drawing/2016/5/13/chartex\" xmlns:cx8=\"http://schemas.microsoft.com/office/drawing/2016/5/14/chartex\" ");
195
            sw.Write("xmlns:aink=\"http://schemas.microsoft.com/office/drawing/2016/ink\" xmlns:am3d=\"http://schemas.microsoft.com/office/drawing/2017/model3d\" ");
196
            //sw.Write("xmlns:ve=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" ");
197
            sw.Write("xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:oel=\"http://schemas.microsoft.com/office/2019/extlst\" ");
198
            sw.Write("xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" ");
199
            sw.Write("xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" ");
200
            sw.Write("xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" ");
201
            sw.Write("xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" ");
202
            sw.Write("xmlns:w16cex=\"http://schemas.microsoft.com/office/word/2018/wordml/cex\" xmlns:w16cid=\"http://schemas.microsoft.com/office/word/2016/wordml/cid\" xmlns:w16=\"http://schemas.microsoft.com/office/word/2018/wordml\" xmlns:w16du=\"http://schemas.microsoft.com/office/word/2023/wordml/word16du\" xmlns:w16sdtdh=\"http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash\" xmlns:w16se=\"http://schemas.microsoft.com/office/word/2015/wordml/symex\" ");
203
            sw.Write("xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" ");
204
            sw.Write("mc:Ignorable=\"w14 w15 w16se w16cid w16 w16cex w16sdtdh wp14\">");
205
            foreach (object o in this.Items)
206
            {
207
                if (o is CT_TrackChange)
208
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
209
                else if (o is CT_TrackChange)
210
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
211
                else if (o is CT_Markup)
212
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
213
                else if (o is CT_TrackChange)
214
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
215
                else if (o is CT_RunTrackChange)
216
                    ((CT_RunTrackChange)o).Write(sw, "del");
217
                else if (o is CT_RunTrackChange)
218
                    ((CT_RunTrackChange)o).Write(sw, "ins");
219
                else if (o is CT_RunTrackChange)
220
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
221
                else if (o is CT_MarkupRange)
222
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
223
                else if (o is CT_MoveBookmark)
224
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
225
                else if (o is CT_RunTrackChange)
226
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
227
                else if (o is CT_MarkupRange)
228
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
229
                else if (o is CT_MoveBookmark)
230
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
231
                else if (o is CT_P)
232
                    ((CT_P)o).Write(sw, "p");
233
                else if (o is CT_Perm)
234
                    ((CT_Perm)o).Write(sw, "permEnd");
235
                else if (o is CT_PermStart)
236
                    ((CT_PermStart)o).Write(sw, "permStart");
237
                else if (o is CT_ProofErr)
238
                    ((CT_ProofErr)o).Write(sw, "proofErr");
239
                else if (o is CT_SdtBlock)
240
                    ((CT_SdtBlock)o).Write(sw, "sdt");
241
                else if (o is CT_Tbl)
242
                    ((CT_Tbl)o).Write(sw, "tbl");
243
                else if (o is CT_Markup)
244
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
245
                else if (o is CT_OMath)
246
                    ((CT_OMath)o).Write(sw, "oMath");
247
                else if (o is CT_OMathPara)
248
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
249
                else if (o is CT_AltChunk)
250
                    ((CT_AltChunk)o).Write(sw, "altChunk");
251
                else if (o is CT_MarkupRange)
252
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
253
                else if (o is CT_Bookmark)
254
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
255
                else if (o is CT_MarkupRange)
256
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
257
                else if (o is CT_MarkupRange)
258
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
259
                else if (o is CT_CustomXmlBlock)
260
                    ((CT_CustomXmlBlock)o).Write(sw, "customXml");
261
                else if (o is CT_Markup)
262
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
263
                else if (o is CT_TrackChange)
264
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
265
                else if (o is CT_Markup)
266
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
267
            }
268
            sw.WriteEndW(nodeName);
269
        }
270

271
        public ArrayList Items
272
        {
273
            get
274
            {
275
                return this.itemsField;
276
            }
277
            set
278
            {
279
                this.itemsField =value;
280
            }
281
        }
282

283
        [XmlElement("ItemsElementName", Order = 1)]
284
        [XmlIgnore]
285
        public List<ItemsChoiceType8> ItemsElementName
286
        {
287
            get
288
            {
289
                return this.itemsElementNameField;
290
            }
291
            set
292
            {
293
                    this.itemsElementNameField = value;
294
            }
295
        }
296

297
        public CT_Tbl GetTblArray(int i)
298
        {
299
            return GetObjectArray<CT_Tbl>(i, ItemsChoiceType8.tbl);
300
        }
301

302
        public IList<CT_Tbl> GetTblList()
303
        {
304
            return GetObjectList<CT_Tbl>(ItemsChoiceType8.tbl);
305
        }
306

307
        public CT_P AddNewP()
308
        {
309
            return AddNewObject<CT_P>(ItemsChoiceType8.p);
310
        }
311

312
        public CT_Tbl AddNewTbl()
313
        {
314
            return AddNewObject<CT_Tbl>(ItemsChoiceType8.tbl);
315
        }
316

317
        public void SetPArray(int i, CT_P cT_P)
318
        {
319
            SetObject<CT_P>(ItemsChoiceType8.p, i, cT_P);
320
        }
321
        #region Generic methods for object operation
322

323
        private List<T> GetObjectList<T>(ItemsChoiceType8 type) where T : class
324
        {
325
            lock (this)
326
            {
327
                List<T> list = new List<T>();
328
                for (int i = 0; i < itemsElementNameField.Count; i++)
329
                {
330
                    if (itemsElementNameField[i] == type)
331
                        list.Add(itemsField[i] as T);
332
                }
333
                return list;
334
            }
335
        }
336
        private int SizeOfArray(ItemsChoiceType8 type)
337
        {
338
            lock (this)
339
            {
340
                int size = 0;
341
                for (int i = 0; i < itemsElementNameField.Count; i++)
342
                {
343
                    if (itemsElementNameField[i] == type)
344
                        size++;
345
                }
346
                return size;
347
            }
348
        }
349
        private T GetObjectArray<T>(int p, ItemsChoiceType8 type) where T : class
350
        {
351
            lock (this)
352
            {
353
                int pos = GetObjectIndex(type, p);
354
                if (pos < 0 || pos >= this.itemsField.Count)
355
                    return null;
356
                return itemsField[pos] as T;
357
            }
358
        }
359
        private T AddNewObject<T>(ItemsChoiceType8 type) where T : class, new()
360
        {
361
            T t = new T();
362
            lock (this)
363
            {
364
                this.itemsElementNameField.Add(type);
365
                this.itemsField.Add(t);
366
            }
367
            return t;
368
        }
369
        private void SetObject<T>(ItemsChoiceType8 type, int p, T obj) where T : class
370
        {
371
            lock (this)
372
            {
373
                int pos = GetObjectIndex(type, p);
374
                if (pos < 0 || pos >= this.itemsField.Count)
375
                    return;
376
                if (this.itemsField[pos] is T)
377
                    this.itemsField[pos] = obj;
378
                else
379
                    throw new Exception(string.Format(@"object types are difference, itemsField[{0}] is {1}, and parameter obj is {2}",
380
                        pos, this.itemsField[pos].GetType().Name, typeof(T).Name));
381
            }
382
        }
383
        private int GetObjectIndex(ItemsChoiceType8 type, int p)
384
        {
385
            int index = -1;
386
            int pos = 0;
387
            for (int i = 0; i < itemsElementNameField.Count; i++)
388
            {
389
                if (itemsElementNameField[i] == type)
390
                {
391
                    if (pos == p)
392
                    {
393
                        //return itemsField[p] as T;
394
                        index = i;
395
                        break;
396
                    }
397
                    else
398
                        pos++;
399
                }
400
            }
401
            return index;
402
        }
403
        private void RemoveObject(ItemsChoiceType8 type, int p)
404
        {
405
            lock (this)
406
            {
407
                int pos = GetObjectIndex(type, p);
408
                if (pos < 0 || pos >= this.itemsField.Count)
409
                    return;
410
                itemsElementNameField.RemoveAt(pos);
411
                itemsField.RemoveAt(pos);
412
            }
413
        }
414
        #endregion
415

416
    }
417
    [XmlRoot("ftr", Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = false)]
418
    public class CT_Ftr : CT_HdrFtr
419
    {
420
        public static CT_Ftr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
421
        {
422
            CT_Ftr ctObj= new CT_Ftr();
423
            return (CT_Ftr)CT_HdrFtr.Parse(ctObj, node, namespaceManager);
424
        }
425
        internal void Write(StreamWriter sw)
426
        {
427
            base.Write(sw, "ftr");
428
        }
429
    }
430
    [XmlRoot("hdr", Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = false)]
431
    public class CT_Hdr : CT_HdrFtr
432
    {
433
        public static CT_Hdr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
434
        {
435
            CT_Hdr ctObj = new CT_Hdr();
436
            return (CT_Hdr)CT_HdrFtr.Parse(ctObj, node, namespaceManager);
437
        }
438
        internal void Write(StreamWriter sw)
439
        {
440
            base.Write(sw, "hdr");
441
        }
442
    }
443
    [Serializable]
444
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
445
    public enum ItemsChoiceType8
446
    {
447

448

449
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
450
        oMath,
451

452

453
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
454
        oMathPara,
455

456

457
        altChunk,
458

459

460
        bookmarkEnd,
461

462

463
        bookmarkStart,
464

465

466
        commentRangeEnd,
467

468

469
        commentRangeStart,
470

471

472
        customXml,
473

474

475
        customXmlDelRangeEnd,
476

477

478
        customXmlDelRangeStart,
479

480

481
        customXmlInsRangeEnd,
482

483

484
        customXmlInsRangeStart,
485

486

487
        customXmlMoveFromRangeEnd,
488

489

490
        customXmlMoveFromRangeStart,
491

492

493
        customXmlMoveToRangeEnd,
494

495

496
        customXmlMoveToRangeStart,
497

498

499
        del,
500

501

502
        ins,
503

504

505
        moveFrom,
506

507

508
        moveFromRangeEnd,
509

510

511
        moveFromRangeStart,
512

513

514
        moveTo,
515

516

517
        moveToRangeEnd,
518

519

520
        moveToRangeStart,
521

522

523
        p,
524

525

526
        permEnd,
527

528

529
        permStart,
530

531

532
        proofErr,
533

534

535
        sdt,
536

537

538
        tbl,
539
    }
540

541
    [Serializable]
542

543
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
544
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
545
    public class CT_HdrFtrRef : CT_Rel
546
    {
547
        public static new CT_HdrFtrRef Parse(XmlNode node, XmlNamespaceManager namespaceManager)
548
        {
549
            if (node == null)
550
                return null;
551
            CT_HdrFtrRef ctObj = new CT_HdrFtrRef();
552
            if (node.Attributes["w:type"] != null)
553
            {
554
                try
555
                {
556
                    ctObj.type = (ST_HdrFtr)Enum.Parse(typeof(ST_HdrFtr), node.Attributes["w:type"].Value);
557
                }
558
                catch (ArgumentException)
559
                {
560
                    ctObj.type = ST_HdrFtr.@default;
561
                }
562
            }
563
            ctObj.id = XmlHelper.ReadString(node.Attributes["r:id"]);
564
            return ctObj;
565
        }
566

567

568

569
        internal new void Write(StreamWriter sw, string nodeName)
570
        {
571
            sw.Write(string.Format("<w:{0}", nodeName));
572
            XmlHelper.WriteAttribute(sw, "w:type", this.type.ToString());
573
            XmlHelper.WriteAttribute(sw, "r:id", this.id);
574
            sw.Write("/>");
575
        }
576

577
        private ST_HdrFtr typeField;
578

579
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
580
        public ST_HdrFtr type
581
        {
582
            get
583
            {
584
                return this.typeField;
585
            }
586
            set
587
            {
588
                this.typeField = value;
589
            }
590
        }
591
    }
592

593

594
    [Serializable]
595
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
596
    public enum ST_HdrFtr
597
    {
598

599

600
        [XmlEnum("even")]
601
        even,
602

603
        [XmlEnum("default")]
604
        @default,
605

606
        [XmlEnum("first")]
607
        first,
608
    }
609

610

611
    [XmlInclude(typeof(CT_FtnDocProps))]
612

613
    [Serializable]
614

615
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
616
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
617
    public class CT_FtnProps
618
    {
619

620
        private CT_FtnPos posField;
621

622
        private CT_NumFmt numFmtField;
623

624
        private CT_DecimalNumber numStartField;
625

626
        private CT_NumRestart numRestartField;
627

628
        public CT_FtnProps()
629
        {
630
            //this.numRestartField = new CT_NumRestart();
631
            //this.numStartField = new CT_DecimalNumber();
632
            //this.numFmtField = new CT_NumFmt();
633
            //this.posField = new CT_FtnPos();
634
        }
635
        public static CT_FtnProps Parse(XmlNode node, XmlNamespaceManager namespaceManager)
636
        {
637
            if (node == null)
638
                return null;
639
            CT_FtnProps ctObj = new CT_FtnProps();
640
            foreach (XmlNode childNode in node.ChildNodes)
641
            {
642
                if (childNode.LocalName == "pos")
643
                    ctObj.pos = CT_FtnPos.Parse(childNode, namespaceManager);
644
                else if (childNode.LocalName == "numFmt")
645
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
646
                else if (childNode.LocalName == "numStart")
647
                    ctObj.numStart = CT_DecimalNumber.Parse(childNode, namespaceManager);
648
                else if (childNode.LocalName == "numRestart")
649
                    ctObj.numRestart = CT_NumRestart.Parse(childNode, namespaceManager);
650
            }
651
            return ctObj;
652
        }
653

654

655

656
        internal void Write(StreamWriter sw, string nodeName)
657
        {
658
            sw.Write(string.Format("<w:{0}", nodeName));
659
            sw.Write(">");
660
            if (this.pos != null)
661
                this.pos.Write(sw, "pos");
662
            if (this.numFmt != null)
663
                this.numFmt.Write(sw, "numFmt");
664
            if (this.numStart != null)
665
                this.numStart.Write(sw, "numStart");
666
            if (this.numRestart != null)
667
                this.numRestart.Write(sw, "numRestart");
668
            sw.WriteEndW(nodeName);
669
        }
670

671
        [XmlElement(Order = 0)]
672
        public CT_FtnPos pos
673
        {
674
            get
675
            {
676
                return this.posField;
677
            }
678
            set
679
            {
680
                this.posField = value;
681
            }
682
        }
683

684
        [XmlElement(Order = 1)]
685
        public CT_NumFmt numFmt
686
        {
687
            get
688
            {
689
                return this.numFmtField;
690
            }
691
            set
692
            {
693
                this.numFmtField = value;
694
            }
695
        }
696

697
        [XmlElement(Order = 2)]
698
        public CT_DecimalNumber numStart
699
        {
700
            get
701
            {
702
                return this.numStartField;
703
            }
704
            set
705
            {
706
                this.numStartField = value;
707
            }
708
        }
709

710
        [XmlElement(Order = 3)]
711
        public CT_NumRestart numRestart
712
        {
713
            get
714
            {
715
                return this.numRestartField;
716
            }
717
            set
718
            {
719
                this.numRestartField = value;
720
            }
721
        }
722
    }
723

724

725
    [Serializable]
726

727
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
728
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
729
    public class CT_FtnPos
730
    {
731
        public static CT_FtnPos Parse(XmlNode node, XmlNamespaceManager namespaceManager)
732
        {
733
            if (node == null)
734
                return null;
735
            CT_FtnPos ctObj = new CT_FtnPos();
736
            if (node.Attributes["w:val"] != null)
737
                ctObj.val = (ST_FtnPos)Enum.Parse(typeof(ST_FtnPos), node.Attributes["w:val"].Value);
738
            return ctObj;
739
        }
740

741

742

743
        internal void Write(StreamWriter sw, string nodeName)
744
        {
745
            sw.Write(string.Format("<w:{0}", nodeName));
746
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
747
            sw.Write(">");
748
            sw.WriteEndW(nodeName);
749
        }
750

751
        private ST_FtnPos valField;
752

753
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
754
        public ST_FtnPos val
755
        {
756
            get
757
            {
758
                return this.valField;
759
            }
760
            set
761
            {
762
                this.valField = value;
763
            }
764
        }
765
    }
766

767

768
    [Serializable]
769
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
770
    public enum ST_FtnPos
771
    {
772

773

774
        pageBottom,
775

776

777
        beneathText,
778

779

780
        sectEnd,
781

782

783
        docEnd,
784
    }
785

786
    public class CT_Footnotes
787
    {
788

789
        private List<CT_FtnEdn> footnoteField;
790

791
        public CT_Footnotes()
792
        {
793
            //this.footnoteField = new List<CT_FtnEdn>();
794
        }
795
        public static CT_Footnotes Parse(XmlNode node, XmlNamespaceManager namespaceManager)
796
        {
797
            if (node == null)
798
                return null;
799
            CT_Footnotes ctObj = new CT_Footnotes();
800
            ctObj.footnote = new List<CT_FtnEdn>();
801
            foreach (XmlNode childNode in node.ChildNodes)
802
            {
803
                if (childNode.LocalName == "footnote")
804
                    ctObj.footnote.Add(CT_FtnEdn.Parse(childNode, namespaceManager));
805
            }
806
            return ctObj;
807
        }
808

809
        internal void Write(StreamWriter sw)
810
        {
811
            sw.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
812
            sw.Write("<w:footnotes xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" ");
813
            //sw.Write("xmlns:ve=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" ");
814
            sw.Write("xmlns:o=\"urn:schemas-microsoft-com:office:office\" ");
815
            sw.Write("xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" ");
816
            sw.Write("xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" ");
817
            sw.Write("xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" ");
818
            sw.Write("xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" ");
819
            sw.Write("xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" ");
820
            sw.Write("xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" ");
821
            sw.Write("mc:Ignorable=\"w14 w15 wp14\">");
822
            if (this.footnote != null)
823
            {
824
                foreach (CT_FtnEdn x in this.footnote)
825
                {
826
                    x.Write(sw, "footnote");
827
                }
828
            }
829
            sw.Write("</w:footnotes>");
830
        }
831

832
        [XmlElement("footnote", Order = 0)]
833
        public List<CT_FtnEdn> footnote
834
        {
835
            get
836
            {
837
                return this.footnoteField;
838
            }
839
            set
840
            {
841
                this.footnoteField = value;
842
            }
843
        }
844
        public CT_FtnEdn AddNewFootnote()
845
        {
846
            CT_FtnEdn f = new CT_FtnEdn();
847
            if (footnoteField == null)
848
                footnoteField = new List<CT_FtnEdn>();
849
            footnoteField.Add(f);
850
            return f;
851
        }
852
        public void RemoveFootnote(int pos)
853
        {
854
            this.footnoteField.RemoveAt(pos);
855
        }
856
        public int SizeOfFootnoteArray
857
        {
858
            get
859
            {
860
                return this.footnoteField.Count;
861
            }
862
        }
863
    }
864

865

866
    [Serializable]
867
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
868
    [XmlRoot("endnote", Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
869
    public class CT_FtnEdn
870
    {
871

872
        private ArrayList itemsField = new ArrayList();
873

874
        private List<ItemsChoiceType7> itemsElementNameField = new List<ItemsChoiceType7>();
875

876
        private ST_FtnEdn typeField;
877

878
        private bool typeFieldSpecified;
879

880
        private int idField = -1;
881

882
        public static CT_FtnEdn Parse(XmlNode node, XmlNamespaceManager namespaceManager)
883
        {
884
            if (node == null)
885
                return null;
886
            CT_FtnEdn ctObj = new CT_FtnEdn();
887
            if (node.Attributes["w:type"] != null)
888
                ctObj.type = (ST_FtnEdn)Enum.Parse(typeof(ST_FtnEdn), node.Attributes["w:type"].Value);
889
            ctObj.id = XmlHelper.ReadInt(node.Attributes["w:id"]);
890

891
            foreach (XmlNode childNode in node.ChildNodes)
892
            {
893
                if (childNode.LocalName == "customXmlDelRangeStart")
894
                {
895
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
896
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXmlDelRangeStart);
897
                }
898
                else if (childNode.LocalName == "moveToRangeEnd")
899
                {
900
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
901
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.moveToRangeEnd);
902
                }
903
                else if (childNode.LocalName == "customXmlMoveFromRangeEnd")
904
                {
905
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
906
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXmlMoveFromRangeEnd);
907
                }
908
                else if (childNode.LocalName == "ins")
909
                {
910
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
911
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.ins);
912
                }
913
                else if (childNode.LocalName == "customXmlDelRangeEnd")
914
                {
915
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
916
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXmlDelRangeEnd);
917
                }
918
                else if (childNode.LocalName == "customXmlInsRangeEnd")
919
                {
920
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
921
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXmlInsRangeEnd);
922
                }
923
                else if (childNode.LocalName == "customXmlInsRangeStart")
924
                {
925
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
926
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXmlInsRangeStart);
927
                }
928
                else if (childNode.LocalName == "moveTo")
929
                {
930
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
931
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.moveTo);
932
                }
933
                else if (childNode.LocalName == "moveToRangeStart")
934
                {
935
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
936
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.moveToRangeStart);
937
                }
938
                else if (childNode.LocalName == "customXmlMoveFromRangeStart")
939
                {
940
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
941
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXmlMoveFromRangeStart);
942
                }
943
                else if (childNode.LocalName == "customXmlMoveToRangeEnd")
944
                {
945
                    ctObj.Items.Add(CT_Markup.Parse(childNode, namespaceManager));
946
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXmlMoveToRangeEnd);
947
                }
948
                else if (childNode.LocalName == "customXmlMoveToRangeStart")
949
                {
950
                    ctObj.Items.Add(CT_TrackChange.Parse(childNode, namespaceManager));
951
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXmlMoveToRangeStart);
952
                }
953
                else if (childNode.LocalName == "del")
954
                {
955
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
956
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.del);
957
                }
958
                else if (childNode.LocalName == "p")
959
                {
960
                    ctObj.Items.Add(CT_P.Parse(childNode, namespaceManager));
961
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.p);
962
                }
963
                else if (childNode.LocalName == "permEnd")
964
                {
965
                    ctObj.Items.Add(CT_Perm.Parse(childNode, namespaceManager));
966
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.permEnd);
967
                }
968
                else if (childNode.LocalName == "permStart")
969
                {
970
                    ctObj.Items.Add(CT_PermStart.Parse(childNode, namespaceManager));
971
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.permStart);
972
                }
973
                else if (childNode.LocalName == "proofErr")
974
                {
975
                    ctObj.Items.Add(CT_ProofErr.Parse(childNode, namespaceManager));
976
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.proofErr);
977
                }
978
                else if (childNode.LocalName == "sdt")
979
                {
980
                    ctObj.Items.Add(CT_SdtBlock.Parse(childNode, namespaceManager));
981
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.sdt);
982
                }
983
                else if (childNode.LocalName == "moveFrom")
984
                {
985
                    ctObj.Items.Add(CT_RunTrackChange.Parse(childNode, namespaceManager));
986
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.moveFrom);
987
                }
988
                else if (childNode.LocalName == "moveFromRangeEnd")
989
                {
990
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
991
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.moveFromRangeEnd);
992
                }
993
                else if (childNode.LocalName == "tbl")
994
                {
995
                    ctObj.Items.Add(CT_Tbl.Parse(childNode, namespaceManager));
996
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.tbl);
997
                }
998
                else if (childNode.LocalName == "moveFromRangeStart")
999
                {
1000
                    ctObj.Items.Add(CT_MoveBookmark.Parse(childNode, namespaceManager));
1001
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.moveFromRangeStart);
1002
                }
1003
                else if (childNode.LocalName == "oMath")
1004
                {
1005
                    ctObj.Items.Add(CT_OMath.Parse(childNode, namespaceManager));
1006
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.oMath);
1007
                }
1008
                else if (childNode.LocalName == "oMathPara")
1009
                {
1010
                    ctObj.Items.Add(CT_OMathPara.Parse(childNode, namespaceManager));
1011
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.oMathPara);
1012
                }
1013
                else if (childNode.LocalName == "altChunk")
1014
                {
1015
                    ctObj.Items.Add(CT_AltChunk.Parse(childNode, namespaceManager));
1016
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.altChunk);
1017
                }
1018
                else if (childNode.LocalName == "bookmarkEnd")
1019
                {
1020
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1021
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.bookmarkEnd);
1022
                }
1023
                else if (childNode.LocalName == "bookmarkStart")
1024
                {
1025
                    ctObj.Items.Add(CT_Bookmark.Parse(childNode, namespaceManager));
1026
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.bookmarkStart);
1027
                }
1028
                else if (childNode.LocalName == "commentRangeEnd")
1029
                {
1030
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1031
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.commentRangeEnd);
1032
                }
1033
                else if (childNode.LocalName == "commentRangeStart")
1034
                {
1035
                    ctObj.Items.Add(CT_MarkupRange.Parse(childNode, namespaceManager));
1036
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.commentRangeStart);
1037
                }
1038
                else if (childNode.LocalName == "customXml")
1039
                {
1040
                    ctObj.Items.Add(CT_CustomXmlBlock.Parse(childNode, namespaceManager));
1041
                    ctObj.ItemsElementName.Add(ItemsChoiceType7.customXml);
1042
                }
1043
            }
1044
            return ctObj;
1045
        }
1046

1047
        internal void Write(StreamWriter sw, string nodeName)
1048
        {
1049
            sw.Write(string.Format("<w:{0}", nodeName));
1050
            XmlHelper.WriteAttribute(sw, "w:type", this.type.ToString());
1051
            XmlHelper.WriteAttribute(sw, "w:id", this.id, true);
1052
            sw.Write(">");
1053
            int i = 0;
1054
            foreach (object o in this.Items)
1055
            {
1056
                if (o is CT_TrackChange&& this.itemsElementNameField[i]== ItemsChoiceType7.customXmlDelRangeStart)
1057
                    ((CT_TrackChange)o).Write(sw, "customXmlDelRangeStart");
1058
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType7.moveToRangeEnd)
1059
                    ((CT_MarkupRange)o).Write(sw, "moveToRangeEnd");
1060
                else if (o is CT_Markup && this.itemsElementNameField[i] == ItemsChoiceType7.customXmlMoveFromRangeEnd)
1061
                    ((CT_Markup)o).Write(sw, "customXmlMoveFromRangeEnd");
1062
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ItemsChoiceType7.ins)
1063
                    ((CT_RunTrackChange)o).Write(sw, "ins");
1064
                else if (o is CT_Markup && this.itemsElementNameField[i] == ItemsChoiceType7.customXmlDelRangeEnd)
1065
                    ((CT_Markup)o).Write(sw, "customXmlDelRangeEnd");
1066
                else if (o is CT_Markup && this.itemsElementNameField[i] == ItemsChoiceType7.customXmlInsRangeEnd)
1067
                    ((CT_Markup)o).Write(sw, "customXmlInsRangeEnd");
1068
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ItemsChoiceType7.customXmlInsRangeStart)
1069
                    ((CT_TrackChange)o).Write(sw, "customXmlInsRangeStart");
1070
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ItemsChoiceType7.moveTo)
1071
                    ((CT_RunTrackChange)o).Write(sw, "moveTo");
1072
                else if (o is CT_MoveBookmark && this.itemsElementNameField[i] == ItemsChoiceType7.moveToRangeStart)
1073
                    ((CT_MoveBookmark)o).Write(sw, "moveToRangeStart");
1074
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ItemsChoiceType7.customXmlMoveFromRangeStart)
1075
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveFromRangeStart");
1076
                else if (o is CT_Markup && this.itemsElementNameField[i] == ItemsChoiceType7.customXmlMoveToRangeEnd)
1077
                    ((CT_Markup)o).Write(sw, "customXmlMoveToRangeEnd");
1078
                else if (o is CT_TrackChange && this.itemsElementNameField[i] == ItemsChoiceType7.customXmlMoveToRangeStart)
1079
                    ((CT_TrackChange)o).Write(sw, "customXmlMoveToRangeStart");
1080
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ItemsChoiceType7.del)
1081
                    ((CT_RunTrackChange)o).Write(sw, "del");
1082
                else if (o is CT_P)
1083
                    ((CT_P)o).Write(sw, "p");
1084
                else if (o is CT_Perm)
1085
                    ((CT_Perm)o).Write(sw, "permEnd");
1086
                else if (o is CT_PermStart)
1087
                    ((CT_PermStart)o).Write(sw, "permStart");
1088
                else if (o is CT_ProofErr)
1089
                    ((CT_ProofErr)o).Write(sw, "proofErr");
1090
                else if (o is CT_SdtBlock)
1091
                    ((CT_SdtBlock)o).Write(sw, "sdt");
1092
                else if (o is CT_RunTrackChange && this.itemsElementNameField[i] == ItemsChoiceType7.moveFrom)
1093
                    ((CT_RunTrackChange)o).Write(sw, "moveFrom");
1094
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType7.moveFromRangeEnd)
1095
                    ((CT_MarkupRange)o).Write(sw, "moveFromRangeEnd");
1096
                else if (o is CT_Tbl)
1097
                    ((CT_Tbl)o).Write(sw, "tbl");
1098
                else if (o is CT_MoveBookmark && this.itemsElementNameField[i] == ItemsChoiceType7.moveFromRangeStart)
1099
                    ((CT_MoveBookmark)o).Write(sw, "moveFromRangeStart");
1100
                else if (o is CT_OMath)
1101
                    ((CT_OMath)o).Write(sw, "oMath");
1102
                else if (o is CT_OMathPara)
1103
                    ((CT_OMathPara)o).Write(sw, "oMathPara");
1104
                else if (o is CT_AltChunk)
1105
                    ((CT_AltChunk)o).Write(sw, "altChunk");
1106
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType7.bookmarkEnd)
1107
                    ((CT_MarkupRange)o).Write(sw, "bookmarkEnd");
1108
                else if (o is CT_Bookmark && this.itemsElementNameField[i] == ItemsChoiceType7.bookmarkStart)
1109
                    ((CT_Bookmark)o).Write(sw, "bookmarkStart");
1110
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType7.commentRangeEnd)
1111
                    ((CT_MarkupRange)o).Write(sw, "commentRangeEnd");
1112
                else if (o is CT_MarkupRange && this.itemsElementNameField[i] == ItemsChoiceType7.commentRangeStart)
1113
                    ((CT_MarkupRange)o).Write(sw, "commentRangeStart");
1114
                else if (o is CT_CustomXmlBlock)
1115
                    ((CT_CustomXmlBlock)o).Write(sw, "customXml");
1116
                i++;
1117
            }
1118
            sw.WriteEndW(nodeName);
1119
        }
1120

1121

1122
        [XmlElement("oMath", typeof(CT_OMath), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
1123
        [XmlElement("oMathPara", typeof(CT_OMathPara), Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/math", Order = 0)]
1124
        [XmlElement("altChunk", typeof(CT_AltChunk), Order = 0)]
1125
        [XmlElement("bookmarkEnd", typeof(CT_MarkupRange), Order = 0)]
1126
        [XmlElement("bookmarkStart", typeof(CT_Bookmark), Order = 0)]
1127
        [XmlElement("commentRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1128
        [XmlElement("commentRangeStart", typeof(CT_MarkupRange), Order = 0)]
1129
        [XmlElement("customXml", typeof(CT_CustomXmlBlock), Order = 0)]
1130
        [XmlElement("customXmlDelRangeEnd", typeof(CT_Markup), Order = 0)]
1131
        [XmlElement("customXmlDelRangeStart", typeof(CT_TrackChange), Order = 0)]
1132
        [XmlElement("customXmlInsRangeEnd", typeof(CT_Markup), Order = 0)]
1133
        [XmlElement("customXmlInsRangeStart", typeof(CT_TrackChange), Order = 0)]
1134
        [XmlElement("customXmlMoveFromRangeEnd", typeof(CT_Markup), Order = 0)]
1135
        [XmlElement("customXmlMoveFromRangeStart", typeof(CT_TrackChange), Order = 0)]
1136
        [XmlElement("customXmlMoveToRangeEnd", typeof(CT_Markup), Order = 0)]
1137
        [XmlElement("customXmlMoveToRangeStart", typeof(CT_TrackChange), Order = 0)]
1138
        [XmlElement("del", typeof(CT_RunTrackChange), Order = 0)]
1139
        [XmlElement("ins", typeof(CT_RunTrackChange), Order = 0)]
1140
        [XmlElement("moveFrom", typeof(CT_RunTrackChange), Order = 0)]
1141
        [XmlElement("moveFromRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1142
        [XmlElement("moveFromRangeStart", typeof(CT_MoveBookmark), Order = 0)]
1143
        [XmlElement("moveTo", typeof(CT_RunTrackChange), Order = 0)]
1144
        [XmlElement("moveToRangeEnd", typeof(CT_MarkupRange), Order = 0)]
1145
        [XmlElement("moveToRangeStart", typeof(CT_MoveBookmark), Order = 0)]
1146
        [XmlElement("p", typeof(CT_P), Order = 0)]
1147
        [XmlElement("permEnd", typeof(CT_Perm), Order = 0)]
1148
        [XmlElement("permStart", typeof(CT_PermStart), Order = 0)]
1149
        [XmlElement("proofErr", typeof(CT_ProofErr), Order = 0)]
1150
        [XmlElement("sdt", typeof(CT_SdtBlock), Order = 0)]
1151
        [XmlElement("tbl", typeof(CT_Tbl), Order = 0)]
1152
        [XmlChoiceIdentifier("ItemsElementName")]
1153
        public ArrayList Items
1154
        {
1155
            get
1156
            {
1157
                return this.itemsField;
1158
            }
1159
            set
1160
            {
1161
                this.itemsField = value;
1162
            }
1163
        }
1164

1165
        [XmlElement("ItemsElementName", Order = 1)]
1166
        [XmlIgnore]
1167
        public List<ItemsChoiceType7> ItemsElementName
1168
        {
1169
            get
1170
            {
1171
                return this.itemsElementNameField;
1172
            }
1173
            set
1174
            {
1175
               this.itemsElementNameField = value;
1176
            }
1177
        }
1178

1179
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1180
        public ST_FtnEdn type
1181
        {
1182
            get
1183
            {
1184
                return this.typeField;
1185
            }
1186
            set
1187
            {
1188
                this.typeField = value;
1189
            }
1190
        }
1191

1192
        [XmlIgnore]
1193
        public bool typeSpecified
1194
        {
1195
            get
1196
            {
1197
                return this.typeFieldSpecified;
1198
            }
1199
            set
1200
            {
1201
                this.typeFieldSpecified = value;
1202
            }
1203
        }
1204

1205
        [XmlAttribute(Form = XmlSchemaForm.Qualified, DataType = "integer", Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1206
        public int id
1207
        {
1208
            get
1209
            {
1210
                return this.idField;
1211
            }
1212
            set
1213
            {
1214
                this.idField = value;
1215
            }
1216
        }
1217
        public void Set(CT_FtnEdn note)
1218
        {
1219
            this.idField = note.idField;
1220
            this.itemsElementNameField = note.itemsElementNameField;
1221
            this.itemsField = note.itemsField;
1222
            this.typeField = note.typeField;
1223
        }
1224
        private List<T> GetObjectList<T>(ItemsChoiceType7 type) where T : class
1225
        {
1226
            lock (this)
1227
            {
1228
                List<T> list = new List<T>();
1229
                for (int i = 0; i < itemsElementNameField.Count; i++)
1230
                {
1231
                    if (itemsElementNameField[i] == type)
1232
                        list.Add(itemsField[i] as T);
1233
                }
1234
                return list;
1235
            }
1236
        }
1237
        private int SizeOfArray(ItemsChoiceType7 type)
1238
        {
1239
            lock (this)
1240
            {
1241
                int size = 0;
1242
                for (int i = 0; i < itemsElementNameField.Count; i++)
1243
                {
1244
                    if (itemsElementNameField[i] == type)
1245
                        size++;
1246
                }
1247
                return size;
1248
            }
1249
        }
1250
        private T GetObjectArray<T>(int p, ItemsChoiceType7 type) where T : class
1251
        {
1252
            lock (this)
1253
            {
1254
                int pos = 0;
1255
                for (int i = 0; i < itemsElementNameField.Count; i++)
1256
                {
1257
                    if (itemsElementNameField[i] == type)
1258
                    {
1259
                        if (pos == p)
1260
                            return itemsField[i] as T;
1261
                        else
1262
                            pos++;
1263
                    }
1264
                }
1265
                return null;
1266
            }
1267
        }
1268
        private T AddNewObject<T>(ItemsChoiceType7 type) where T : class, new()
1269
        {
1270
            T t = new T();
1271
            lock (this)
1272
            {
1273
                this.itemsElementNameField.Add(type);
1274
                this.itemsField.Add(t);
1275
            }
1276
            return t;
1277
        }
1278
        private T AddNewObject<T>(ItemsChoiceType7 type, T t) where T : class, new()
1279
        {
1280
            lock (this)
1281
            {
1282
                this.itemsElementNameField.Add(type);
1283
                this.itemsField.Add(t);
1284
            }
1285
            return t;
1286
        }
1287
        public IList<CT_P> GetPList()
1288
        {
1289
            return GetObjectList<CT_P>(ItemsChoiceType7.p);
1290
        }
1291

1292
        public IList<CT_Tbl> GetTblList()
1293
        {
1294
            return GetObjectList<CT_Tbl>(ItemsChoiceType7.tbl);
1295
        }
1296

1297
        public CT_Tbl GetTblArray(int i)
1298
        {
1299
            return GetObjectArray<CT_Tbl>(i, ItemsChoiceType7.tbl);
1300
        }
1301

1302
        public CT_Tbl AddNewTbl()
1303
        {
1304
            return AddNewObject<CT_Tbl>(ItemsChoiceType7.tbl);
1305
        }
1306

1307
        public CT_P AddNewP()
1308
        {
1309
            return AddNewObject<CT_P>(ItemsChoiceType7.p);
1310
        }
1311

1312
        public CT_P AddNewP(CT_P paragraph)
1313
        {
1314
            return AddNewObject<CT_P>(ItemsChoiceType7.p, paragraph);
1315
        }
1316
    }
1317

1318

1319
    [Serializable]
1320
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IncludeInSchema = false)]
1321
    public enum ItemsChoiceType7
1322
    {
1323

1324

1325
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMath")]
1326
        oMath,
1327

1328

1329
        [XmlEnum("http://schemas.openxmlformats.org/officeDocument/2006/math:oMathPara")]
1330
        oMathPara,
1331

1332

1333
        altChunk,
1334

1335

1336
        bookmarkEnd,
1337

1338

1339
        bookmarkStart,
1340

1341

1342
        commentRangeEnd,
1343

1344

1345
        commentRangeStart,
1346

1347

1348
        customXml,
1349

1350

1351
        customXmlDelRangeEnd,
1352

1353

1354
        customXmlDelRangeStart,
1355

1356

1357
        customXmlInsRangeEnd,
1358

1359

1360
        customXmlInsRangeStart,
1361

1362

1363
        customXmlMoveFromRangeEnd,
1364

1365

1366
        customXmlMoveFromRangeStart,
1367

1368

1369
        customXmlMoveToRangeEnd,
1370

1371

1372
        customXmlMoveToRangeStart,
1373

1374

1375
        del,
1376

1377

1378
        ins,
1379

1380

1381
        moveFrom,
1382

1383

1384
        moveFromRangeEnd,
1385

1386

1387
        moveFromRangeStart,
1388

1389

1390
        moveTo,
1391

1392

1393
        moveToRangeEnd,
1394

1395

1396
        moveToRangeStart,
1397

1398

1399
        p,
1400

1401

1402
        permEnd,
1403

1404

1405
        permStart,
1406

1407

1408
        proofErr,
1409

1410

1411
        sdt,
1412

1413

1414
        tbl,
1415
    }
1416

1417

1418
    [Serializable]
1419
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1420
    public enum ST_FtnEdn
1421
    {
1422

1423

1424
        normal,
1425

1426

1427
        separator,
1428

1429

1430
        continuationSeparator,
1431

1432

1433
        continuationNotice,
1434
    }
1435

1436

1437
    public class CT_Endnotes
1438
    {
1439

1440
        private List<CT_FtnEdn> endnoteField = new List<CT_FtnEdn>();
1441
        public static CT_Endnotes Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1442
        {
1443
            if (node == null)
1444
                return null;
1445
            CT_Endnotes ctObj = new CT_Endnotes();
1446
            ctObj.endnote = new List<CT_FtnEdn>();
1447
            foreach (XmlNode childNode in node.ChildNodes)
1448
            {
1449
                if (childNode.LocalName == "endnote")
1450
                    ctObj.endnote.Add(CT_FtnEdn.Parse(childNode, namespaceManager));
1451
            }
1452
            return ctObj;
1453
        }
1454

1455
        internal void Write(StreamWriter sw)
1456
        {
1457
            sw.Write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
1458
            sw.Write("<w:endnotes xmlns:ve=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" ");
1459
            sw.Write("xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" ");
1460
            sw.Write("xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" ");
1461
            sw.Write("xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" ");
1462
            sw.Write("xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\">");
1463
            if (this.endnote != null)
1464
            {
1465
                foreach (CT_FtnEdn x in this.endnote)
1466
                {
1467
                    x.Write(sw, "endnote");
1468
                }
1469
            }
1470
            sw.Write("</w:endnotes>");
1471
        }
1472

1473
        [XmlElement("endnote", Order = 0)]
1474
        public List<CT_FtnEdn> endnote
1475
        {
1476
            get
1477
            {
1478
                return this.endnoteField;
1479
            }
1480
            set
1481
            {
1482
                this.endnoteField = value;
1483
            }
1484
        }
1485
    }
1486

1487
    [Serializable]
1488

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

1494
        private List<CT_FtnEdnSepRef> footnoteField;
1495

1496
        public CT_FtnDocProps()
1497
        {
1498
            //this.footnoteField = new List<CT_FtnEdnSepRef>();
1499
        }
1500
        public static new CT_FtnDocProps Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1501
        {
1502
            if (node == null)
1503
                return null;
1504
            CT_FtnDocProps ctObj = new CT_FtnDocProps();
1505
            ctObj.footnote = new List<CT_FtnEdnSepRef>();
1506
            foreach (XmlNode childNode in node.ChildNodes)
1507
            {
1508
                if (childNode.LocalName == "pos")
1509
                    ctObj.pos = CT_FtnPos.Parse(childNode, namespaceManager);
1510
                else if (childNode.LocalName == "numFmt")
1511
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
1512
                else if (childNode.LocalName == "numStart")
1513
                    ctObj.numStart = CT_DecimalNumber.Parse(childNode, namespaceManager);
1514
                else if (childNode.LocalName == "numRestart")
1515
                    ctObj.numRestart = CT_NumRestart.Parse(childNode, namespaceManager);
1516
                else if (childNode.LocalName == "footnote")
1517
                    ctObj.footnote.Add(CT_FtnEdnSepRef.Parse(childNode, namespaceManager));
1518
            }
1519
            return ctObj;
1520
        }
1521

1522

1523

1524
        internal new void Write(StreamWriter sw, string nodeName)
1525
        {
1526
            sw.Write(string.Format("<w:{0}", nodeName));
1527
            sw.Write(">");
1528
            if (this.pos != null)
1529
                this.pos.Write(sw, "pos");
1530
            if (this.numFmt != null)
1531
                this.numFmt.Write(sw, "numFmt");
1532
            if (this.numStart != null)
1533
                this.numStart.Write(sw, "numStart");
1534
            if (this.numRestart != null)
1535
                this.numRestart.Write(sw, "numRestart");
1536
            if (this.footnote != null)
1537
            {
1538
                foreach (CT_FtnEdnSepRef x in this.footnote)
1539
                {
1540
                    x.Write(sw, "footnote");
1541
                }
1542
            }
1543
            sw.WriteEndW(nodeName);
1544
        }
1545

1546
        [XmlElement("footnote", Order = 0)]
1547
        public List<CT_FtnEdnSepRef> footnote
1548
        {
1549
            get
1550
            {
1551
                return this.footnoteField;
1552
            }
1553
            set
1554
            {
1555
                this.footnoteField = value;
1556
            }
1557
        }
1558
    }
1559

1560

1561
    [Serializable]
1562
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1563
    public class CT_FtnEdnSepRef
1564
    {
1565
        private string idField;
1566
        public static CT_FtnEdnSepRef Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1567
        {
1568
            if (node == null)
1569
                return null;
1570
            CT_FtnEdnSepRef ctObj = new CT_FtnEdnSepRef();
1571
            ctObj.id = XmlHelper.ReadString(node.Attributes["w:id"]);
1572
            return ctObj;
1573
        }
1574

1575

1576

1577
        internal void Write(StreamWriter sw, string nodeName)
1578
        {
1579
            sw.Write(string.Format("<w:{0}", nodeName));
1580
            XmlHelper.WriteAttribute(sw, "w:id", this.id);
1581
            sw.Write("/>");
1582
        }
1583

1584
        //[XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
1585
        [XmlAttribute(DataType = "integer")]
1586
        public string id
1587
        {
1588
            get
1589
            {
1590
                return this.idField;
1591
            }
1592
            set
1593
            {
1594
                this.idField = value;
1595
            }
1596
        }
1597
    }
1598

1599
    [XmlInclude(typeof(CT_EdnDocProps))]
1600

1601
    [Serializable]
1602

1603
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1604
    public class CT_EdnProps
1605
    {
1606

1607
        private CT_EdnPos posField;
1608

1609
        private CT_NumFmt numFmtField;
1610

1611
        private CT_DecimalNumber numStartField;
1612

1613
        private CT_NumRestart numRestartField;
1614

1615
        public CT_EdnProps()
1616
        {
1617
            //this.numRestartField = new CT_NumRestart();
1618
            //this.numStartField = new CT_DecimalNumber();
1619
            //this.numFmtField = new CT_NumFmt();
1620
            //this.posField = new CT_EdnPos();
1621
        }
1622
        public static CT_EdnProps Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1623
        {
1624
            if (node == null)
1625
                return null;
1626
            CT_EdnProps ctObj = new CT_EdnProps();
1627
            foreach (XmlNode childNode in node.ChildNodes)
1628
            {
1629
                if (childNode.LocalName == "pos")
1630
                    ctObj.pos = CT_EdnPos.Parse(childNode, namespaceManager);
1631
                else if (childNode.LocalName == "numFmt")
1632
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
1633
                else if (childNode.LocalName == "numStart")
1634
                    ctObj.numStart = CT_DecimalNumber.Parse(childNode, namespaceManager);
1635
                else if (childNode.LocalName == "numRestart")
1636
                    ctObj.numRestart = CT_NumRestart.Parse(childNode, namespaceManager);
1637
            }
1638
            return ctObj;
1639
        }
1640

1641

1642

1643
        internal void Write(StreamWriter sw, string nodeName)
1644
        {
1645
            sw.Write(string.Format("<w:{0}", nodeName));
1646
            sw.Write(">");
1647
            if (this.pos != null)
1648
                this.pos.Write(sw, "pos");
1649
            if (this.numFmt != null)
1650
                this.numFmt.Write(sw, "numFmt");
1651
            if (this.numStart != null)
1652
                this.numStart.Write(sw, "numStart");
1653
            if (this.numRestart != null)
1654
                this.numRestart.Write(sw, "numRestart");
1655
            sw.WriteEndW(nodeName);
1656
        }
1657

1658
        [XmlElement(Order = 0)]
1659
        public CT_EdnPos pos
1660
        {
1661
            get
1662
            {
1663
                return this.posField;
1664
            }
1665
            set
1666
            {
1667
                this.posField = value;
1668
            }
1669
        }
1670

1671
        [XmlElement(Order = 1)]
1672
        public CT_NumFmt numFmt
1673
        {
1674
            get
1675
            {
1676
                return this.numFmtField;
1677
            }
1678
            set
1679
            {
1680
                this.numFmtField = value;
1681
            }
1682
        }
1683

1684
        [XmlElement(Order = 2)]
1685
        public CT_DecimalNumber numStart
1686
        {
1687
            get
1688
            {
1689
                return this.numStartField;
1690
            }
1691
            set
1692
            {
1693
                this.numStartField = value;
1694
            }
1695
        }
1696

1697
        [XmlElement(Order = 3)]
1698
        public CT_NumRestart numRestart
1699
        {
1700
            get
1701
            {
1702
                return this.numRestartField;
1703
            }
1704
            set
1705
            {
1706
                this.numRestartField = value;
1707
            }
1708
        }
1709
    }
1710

1711

1712
    [Serializable]
1713

1714
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1715
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1716
    public class CT_EdnPos
1717
    {
1718
        public static CT_EdnPos Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1719
        {
1720
            if (node == null)
1721
                return null;
1722
            CT_EdnPos ctObj = new CT_EdnPos();
1723
            if (node.Attributes["w:val"] != null)
1724
                ctObj.val = (ST_EdnPos)Enum.Parse(typeof(ST_EdnPos), node.Attributes["w:val"].Value);
1725
            return ctObj;
1726
        }
1727

1728

1729

1730
        internal void Write(StreamWriter sw, string nodeName)
1731
        {
1732
            sw.Write(string.Format("<w:{0}", nodeName));
1733
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
1734
            sw.Write(">");
1735
            sw.WriteEndW(nodeName);
1736
        }
1737

1738
        private ST_EdnPos valField;
1739

1740
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1741
        public ST_EdnPos val
1742
        {
1743
            get
1744
            {
1745
                return this.valField;
1746
            }
1747
            set
1748
            {
1749
                this.valField = value;
1750
            }
1751
        }
1752
    }
1753

1754

1755
    [Serializable]
1756
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1757
    public enum ST_EdnPos
1758
    {
1759

1760

1761
        sectEnd,
1762

1763

1764
        docEnd,
1765
    }
1766

1767

1768
    [Serializable]
1769

1770
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1771
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1772
    public class CT_EdnDocProps : CT_EdnProps
1773
    {
1774
        public new static CT_EdnDocProps Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1775
        {
1776
            if (node == null)
1777
                return null;
1778
            CT_EdnDocProps ctObj = new CT_EdnDocProps();
1779
            ctObj.endnote = new List<CT_FtnEdnSepRef>();
1780
            foreach (XmlNode childNode in node.ChildNodes)
1781
            {
1782
                if (childNode.LocalName == "pos")
1783
                    ctObj.pos = CT_EdnPos.Parse(childNode, namespaceManager);
1784
                else if (childNode.LocalName == "numFmt")
1785
                    ctObj.numFmt = CT_NumFmt.Parse(childNode, namespaceManager);
1786
                else if (childNode.LocalName == "numStart")
1787
                    ctObj.numStart = CT_DecimalNumber.Parse(childNode, namespaceManager);
1788
                else if (childNode.LocalName == "numRestart")
1789
                    ctObj.numRestart = CT_NumRestart.Parse(childNode, namespaceManager);
1790
                else if (childNode.LocalName == "endnote")
1791
                    ctObj.endnote.Add(CT_FtnEdnSepRef.Parse(childNode, namespaceManager));
1792
            }
1793
            return ctObj;
1794
        }
1795

1796

1797

1798
        internal new void Write(StreamWriter sw, string nodeName)
1799
        {
1800
            sw.Write(string.Format("<w:{0}", nodeName));
1801
            sw.Write(">");
1802
            if (this.pos != null)
1803
                this.pos.Write(sw, "pos");
1804
            if (this.numFmt != null)
1805
                this.numFmt.Write(sw, "numFmt");
1806
            if (this.numStart != null)
1807
                this.numStart.Write(sw, "numStart");
1808
            if (this.numRestart != null)
1809
                this.numRestart.Write(sw, "numRestart");
1810
            if (this.endnote != null)
1811
            {
1812
                foreach (CT_FtnEdnSepRef x in this.endnote)
1813
                {
1814
                    x.Write(sw, "endnote");
1815
                }
1816
            }
1817
            sw.WriteEndW(nodeName);
1818
        }
1819

1820
        private List<CT_FtnEdnSepRef> endnoteField;
1821

1822
        public CT_EdnDocProps()
1823
        {
1824
            //this.endnoteField = new List<CT_FtnEdnSepRef>();
1825
        }
1826

1827
        [XmlElement("endnote", Order = 0)]
1828
        public List<CT_FtnEdnSepRef> endnote
1829
        {
1830
            get
1831
            {
1832
                return this.endnoteField;
1833
            }
1834
            set
1835
            {
1836
                this.endnoteField = value;
1837
            }
1838
        }
1839
    }
1840

1841
    [Serializable]
1842

1843
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
1844
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
1845
    public class CT_FtnEdnRef
1846
    {
1847
        public XmlNode DomNode
1848
        {
1849
            get;
1850
            set;
1851
        }
1852
        private ST_OnOff customMarkFollowsField;
1853

1854
        private bool customMarkFollowsFieldSpecified;
1855

1856
        private string idField;
1857
        public static CT_FtnEdnRef Parse(XmlNode node, XmlNamespaceManager namespaceManager)
1858
        {
1859
            if (node == null)
1860
                return null;
1861
            CT_FtnEdnRef ctObj = new CT_FtnEdnRef();
1862
            if (node.Attributes["w:customMarkFollows"] != null)
1863
                ctObj.customMarkFollows = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:customMarkFollows"].Value,true);
1864
            ctObj.id = XmlHelper.ReadString(node.Attributes["w:id"]);
1865
            ctObj.DomNode = node;
1866
            return ctObj;
1867
        }
1868

1869

1870

1871
        internal void Write(StreamWriter sw, string nodeName)
1872
        {
1873
            sw.Write(string.Format("<w:{0}", nodeName));
1874
            XmlHelper.WriteAttribute(sw, "w:customMarkFollows", this.customMarkFollows.ToString());
1875
            XmlHelper.WriteAttribute(sw, "w:id", this.id);
1876
            sw.Write(">");
1877
            sw.WriteEndW(nodeName);
1878
        }
1879

1880
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
1881
        public ST_OnOff customMarkFollows
1882
        {
1883
            get
1884
            {
1885
                return this.customMarkFollowsField;
1886
            }
1887
            set
1888
            {
1889
                this.customMarkFollowsField = value;
1890
            }
1891
        }
1892

1893
        [XmlIgnore]
1894
        public bool customMarkFollowsSpecified
1895
        {
1896
            get
1897
            {
1898
                return this.customMarkFollowsFieldSpecified;
1899
            }
1900
            set
1901
            {
1902
                this.customMarkFollowsFieldSpecified = value;
1903
            }
1904
        }
1905

1906
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, Namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships")]
1907
        public string id
1908
        {
1909
            get
1910
            {
1911
                return this.idField;
1912
            }
1913
            set
1914
            {
1915
                this.idField = value;
1916
            }
1917
        }
1918
    }
1919
}
1920