npoi

1
using NPOI.OpenXml4Net.Util;
2
using System;
3
using System.IO;
4
using System.Xml;
5
using System.Xml.Serialization;
6

7
namespace NPOI.OpenXmlFormats.Wordprocessing
8
{
9

10
    [Serializable]
11

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

17
        private ulong wField;
18

19
        private bool wFieldSpecified;
20

21
        private ulong hField;
22

23
        private bool hFieldSpecified;
24

25
        private ST_PageOrientation orientField;
26

27
        private bool orientFieldSpecified;
28

29
        private string codeField;
30
        public static CT_PageSz Parse(XmlNode node, XmlNamespaceManager namespaceManager)
31
        {
32
            if (node == null)
33
                return null;
34
            CT_PageSz ctObj = new CT_PageSz();
35
            ctObj.w = XmlHelper.ReadULong(node.Attributes["w:w"]);
36
            ctObj.h = XmlHelper.ReadULong(node.Attributes["w:h"]);
37
            if (node.Attributes["w:orient"] != null)
38
                ctObj.orient = (ST_PageOrientation)Enum.Parse(typeof(ST_PageOrientation), node.Attributes["w:orient"].Value);
39
            ctObj.code = XmlHelper.ReadString(node.Attributes["w:code"]);
40
            return ctObj;
41
        }
42

43

44

45
        internal void Write(StreamWriter sw, string nodeName)
46
        {
47
            sw.Write(string.Format("<w:{0}", nodeName));
48
            XmlHelper.WriteAttribute(sw, "w:w", this.w);
49
            XmlHelper.WriteAttribute(sw, "w:h", this.h);
50
            if( this.orientField!= ST_PageOrientation.portrait)
51
                XmlHelper.WriteAttribute(sw, "w:orient", this.orient.ToString());
52
            XmlHelper.WriteAttribute(sw, "w:code", this.code);
53
            sw.Write("/>");
54
        }
55

56
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
57
        public ulong w
58
        {
59
            get
60
            {
61
                return this.wField;
62
            }
63
            set
64
            {
65
                this.wField = value;
66
            }
67
        }
68

69
        [XmlIgnore]
70
        public bool wSpecified
71
        {
72
            get
73
            {
74
                return this.wFieldSpecified;
75
            }
76
            set
77
            {
78
                this.wFieldSpecified = value;
79
            }
80
        }
81

82
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
83
        public ulong h
84
        {
85
            get
86
            {
87
                return this.hField;
88
            }
89
            set
90
            {
91
                this.hField = value;
92
            }
93
        }
94

95
        [XmlIgnore]
96
        public bool hSpecified
97
        {
98
            get
99
            {
100
                return this.hFieldSpecified;
101
            }
102
            set
103
            {
104
                this.hFieldSpecified = value;
105
            }
106
        }
107

108
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
109
        public ST_PageOrientation orient
110
        {
111
            get
112
            {
113
                return this.orientField;
114
            }
115
            set
116
            {
117
                this.orientField = value;
118
            }
119
        }
120

121
        [XmlIgnore]
122
        public bool orientSpecified
123
        {
124
            get
125
            {
126
                return this.orientFieldSpecified;
127
            }
128
            set
129
            {
130
                this.orientFieldSpecified = value;
131
            }
132
        }
133

134
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
135
        public string code
136
        {
137
            get
138
            {
139
                return this.codeField;
140
            }
141
            set
142
            {
143
                this.codeField = value;
144
            }
145
        }
146
    }
147

148

149
    [Serializable]
150
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
151
    public enum ST_PageOrientation
152
    {
153

154
    
155
        portrait,
156

157
    
158
        landscape,
159
    }
160

161

162
    [Serializable]
163

164
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
165
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
166
    public class CT_PageMar
167
    {
168

169
        private ulong topField;
170

171
        private ulong rightField;
172

173
        private ulong bottomField;
174

175
        private ulong leftField;
176

177
        private ulong headerField;
178

179
        private ulong footerField;
180

181
        private ulong gutterField;
182

183
        public static CT_PageMar Parse(XmlNode node, XmlNamespaceManager namespaceManager)
184
        {
185
            if (node == null)
186
                return null;
187
            CT_PageMar ctObj = new CT_PageMar();
188
            ctObj.top = XmlHelper.ReadULong(node.Attributes["w:top"]);
189
            ctObj.right = XmlHelper.ReadULong(node.Attributes["w:right"]);
190
            ctObj.bottom = XmlHelper.ReadULong(node.Attributes["w:bottom"]);
191
            ctObj.left = XmlHelper.ReadULong(node.Attributes["w:left"]);
192
            ctObj.header = XmlHelper.ReadULong(node.Attributes["w:header"]);
193
            ctObj.footer = XmlHelper.ReadULong(node.Attributes["w:footer"]);
194
            ctObj.gutter = XmlHelper.ReadULong(node.Attributes["w:gutter"]);
195
            return ctObj;
196
        }
197

198

199

200
        internal void Write(StreamWriter sw, string nodeName)
201
        {
202
            sw.Write(string.Format("<w:{0}", nodeName));
203
            XmlHelper.WriteAttribute(sw, "w:top", this.top);
204
            XmlHelper.WriteAttribute(sw, "w:right", this.right);
205
            XmlHelper.WriteAttribute(sw, "w:bottom", this.bottom);
206
            XmlHelper.WriteAttribute(sw, "w:left", this.left);
207
            XmlHelper.WriteAttribute(sw, "w:header", this.header);
208
            XmlHelper.WriteAttribute(sw, "w:footer", this.footer);
209
            XmlHelper.WriteAttribute(sw, "w:gutter", this.gutter, true);
210
            sw.Write("/>");
211
        }
212

213
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
214
        public ulong top
215
        {
216
            get
217
            {
218
                return this.topField;
219
            }
220
            set
221
            {
222
                this.topField = value;
223
            }
224
        }
225

226
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
227
        public ulong right
228
        {
229
            get
230
            {
231
                return this.rightField;
232
            }
233
            set
234
            {
235
                this.rightField = value;
236
            }
237
        }
238

239
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
240
        public ulong bottom
241
        {
242
            get
243
            {
244
                return this.bottomField;
245
            }
246
            set
247
            {
248
                this.bottomField = value;
249
            }
250
        }
251

252
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
253
        public ulong left
254
        {
255
            get
256
            {
257
                return this.leftField;
258
            }
259
            set
260
            {
261
                this.leftField = value;
262
            }
263
        }
264

265
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
266
        public ulong header
267
        {
268
            get
269
            {
270
                return this.headerField;
271
            }
272
            set
273
            {
274
                this.headerField = value;
275
            }
276
        }
277

278
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
279
        public ulong footer
280
        {
281
            get
282
            {
283
                return this.footerField;
284
            }
285
            set
286
            {
287
                this.footerField = value;
288
            }
289
        }
290

291
        public ulong gutter
292
        {
293
            get
294
            {
295
                return this.gutterField;
296
            }
297
            set
298
            {
299
                this.gutterField = value;
300
            }
301
        }
302
    }
303

304

305
    [Serializable]
306

307
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
308
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
309
    public class CT_PaperSource
310
    {
311

312
        private string firstField;
313

314
        private string otherField;
315
        public static CT_PaperSource Parse(XmlNode node, XmlNamespaceManager namespaceManager)
316
        {
317
            if (node == null)
318
                return null;
319
            CT_PaperSource ctObj = new CT_PaperSource();
320
            ctObj.first = XmlHelper.ReadString(node.Attributes["w:first"]);
321
            ctObj.other = XmlHelper.ReadString(node.Attributes["w:other"]);
322
            return ctObj;
323
        }
324

325

326

327
        internal void Write(StreamWriter sw, string nodeName)
328
        {
329
            sw.Write(string.Format("<w:{0}", nodeName));
330
            XmlHelper.WriteAttribute(sw, "w:first", this.first);
331
            XmlHelper.WriteAttribute(sw, "w:other", this.other);
332
            sw.Write(">");
333
            sw.WriteEndW(nodeName);
334
        }
335

336
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
337
        public string first
338
        {
339
            get
340
            {
341
                return this.firstField;
342
            }
343
            set
344
            {
345
                this.firstField = value;
346
            }
347
        }
348

349
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
350
        public string other
351
        {
352
            get
353
            {
354
                return this.otherField;
355
            }
356
            set
357
            {
358
                this.otherField = value;
359
            }
360
        }
361
    }
362

363

364
    [Serializable]
365

366
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
367
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
368
    public class CT_PageBorders
369
    {
370

371
        private CT_Border topField;
372

373
        private CT_Border leftField;
374

375
        private CT_Border bottomField;
376

377
        private CT_Border rightField;
378

379
        private ST_PageBorderZOrder zOrderField;
380

381
        private bool zOrderFieldSpecified;
382

383
        private ST_PageBorderDisplay displayField;
384

385
        private bool displayFieldSpecified;
386

387
        private ST_PageBorderOffset offsetFromField;
388

389
        private bool offsetFromFieldSpecified;
390

391
        public CT_PageBorders()
392
        {
393
            //this.rightField = new CT_Border();
394
            //this.bottomField = new CT_Border();
395
            //this.leftField = new CT_Border();
396
            //this.topField = new CT_Border();
397
        }
398
        public static CT_PageBorders Parse(XmlNode node, XmlNamespaceManager namespaceManager)
399
        {
400
            if (node == null)
401
                return null;
402
            CT_PageBorders ctObj = new CT_PageBorders();
403
            if (node.Attributes["w:zOrder"] != null)
404
                ctObj.zOrder = (ST_PageBorderZOrder)Enum.Parse(typeof(ST_PageBorderZOrder), node.Attributes["w:zOrder"].Value);
405
            if (node.Attributes["w:display"] != null)
406
                ctObj.display = (ST_PageBorderDisplay)Enum.Parse(typeof(ST_PageBorderDisplay), node.Attributes["w:display"].Value);
407
            if (node.Attributes["w:offsetFrom"] != null)
408
                ctObj.offsetFrom = (ST_PageBorderOffset)Enum.Parse(typeof(ST_PageBorderOffset), node.Attributes["w:offsetFrom"].Value);
409
            foreach (XmlNode childNode in node.ChildNodes)
410
            {
411
                if (childNode.LocalName == "top")
412
                    ctObj.top = CT_Border.Parse(childNode, namespaceManager);
413
                else if (childNode.LocalName == "left")
414
                    ctObj.left = CT_Border.Parse(childNode, namespaceManager);
415
                else if (childNode.LocalName == "bottom")
416
                    ctObj.bottom = CT_Border.Parse(childNode, namespaceManager);
417
                else if (childNode.LocalName == "right")
418
                    ctObj.right = CT_Border.Parse(childNode, namespaceManager);
419
            }
420
            return ctObj;
421
        }
422

423

424

425
        internal void Write(StreamWriter sw, string nodeName)
426
        {
427
            sw.Write(string.Format("<w:{0}", nodeName));
428
            XmlHelper.WriteAttribute(sw, "w:zOrder", this.zOrder.ToString());
429
            XmlHelper.WriteAttribute(sw, "w:display", this.display.ToString());
430
            XmlHelper.WriteAttribute(sw, "w:offsetFrom", this.offsetFrom.ToString());
431
            sw.Write(">");
432
            if (this.top != null)
433
                this.top.Write(sw, "top");
434
            if (this.left != null)
435
                this.left.Write(sw, "left");
436
            if (this.bottom != null)
437
                this.bottom.Write(sw, "bottom");
438
            if (this.right != null)
439
                this.right.Write(sw, "right");
440
            sw.WriteEndW(nodeName);
441
        }
442

443

444
        [XmlElement(Order = 0)]
445
        public CT_Border top
446
        {
447
            get
448
            {
449
                return this.topField;
450
            }
451
            set
452
            {
453
                this.topField = value;
454
            }
455
        }
456

457
        [XmlElement(Order = 1)]
458
        public CT_Border left
459
        {
460
            get
461
            {
462
                return this.leftField;
463
            }
464
            set
465
            {
466
                this.leftField = value;
467
            }
468
        }
469

470
        [XmlElement(Order = 2)]
471
        public CT_Border bottom
472
        {
473
            get
474
            {
475
                return this.bottomField;
476
            }
477
            set
478
            {
479
                this.bottomField = value;
480
            }
481
        }
482

483
        [XmlElement(Order = 3)]
484
        public CT_Border right
485
        {
486
            get
487
            {
488
                return this.rightField;
489
            }
490
            set
491
            {
492
                this.rightField = value;
493
            }
494
        }
495

496
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
497
        public ST_PageBorderZOrder zOrder
498
        {
499
            get
500
            {
501
                return this.zOrderField;
502
            }
503
            set
504
            {
505
                this.zOrderField = value;
506
            }
507
        }
508

509
        [XmlIgnore]
510
        public bool zOrderSpecified
511
        {
512
            get
513
            {
514
                return this.zOrderFieldSpecified;
515
            }
516
            set
517
            {
518
                this.zOrderFieldSpecified = value;
519
            }
520
        }
521

522
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
523
        public ST_PageBorderDisplay display
524
        {
525
            get
526
            {
527
                return this.displayField;
528
            }
529
            set
530
            {
531
                this.displayField = value;
532
            }
533
        }
534

535
        [XmlIgnore]
536
        public bool displaySpecified
537
        {
538
            get
539
            {
540
                return this.displayFieldSpecified;
541
            }
542
            set
543
            {
544
                this.displayFieldSpecified = value;
545
            }
546
        }
547

548
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
549
        public ST_PageBorderOffset offsetFrom
550
        {
551
            get
552
            {
553
                return this.offsetFromField;
554
            }
555
            set
556
            {
557
                this.offsetFromField = value;
558
            }
559
        }
560

561
        [XmlIgnore]
562
        public bool offsetFromSpecified
563
        {
564
            get
565
            {
566
                return this.offsetFromFieldSpecified;
567
            }
568
            set
569
            {
570
                this.offsetFromFieldSpecified = value;
571
            }
572
        }
573
    }
574

575

576
    [Serializable]
577
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
578
    public enum ST_PageBorderZOrder
579
    {
580

581
    
582
        front,
583

584
    
585
        back,
586
    }
587

588

589
    [Serializable]
590
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
591
    public enum ST_PageBorderDisplay
592
    {
593

594
    
595
        allPages,
596

597
    
598
        firstPage,
599

600
    
601
        notFirstPage,
602
    }
603

604

605
    [Serializable]
606
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
607
    public enum ST_PageBorderOffset
608
    {
609

610
    
611
        page,
612

613
    
614
        text,
615
    }
616

617

618
    [Serializable]
619

620
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
621
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
622
    public class CT_PageNumber
623
    {
624

625
        private ST_NumberFormat fmtField;
626

627
        private bool fmtFieldSpecified;
628

629
        private string startField;
630

631
        private string chapStyleField;
632

633
        private ST_ChapterSep chapSepField;
634

635
        private bool chapSepFieldSpecified;
636
        public static CT_PageNumber Parse(XmlNode node, XmlNamespaceManager namespaceManager)
637
        {
638
            if (node == null)
639
                return null;
640
            CT_PageNumber ctObj = new CT_PageNumber();
641
            if (node.Attributes["w:fmt"] != null)
642
                ctObj.fmt = (ST_NumberFormat)Enum.Parse(typeof(ST_NumberFormat), node.Attributes["w:fmt"].Value);
643
            ctObj.start = XmlHelper.ReadString(node.Attributes["w:start"]);
644
            ctObj.chapStyle = XmlHelper.ReadString(node.Attributes["w:chapStyle"]);
645
            if (node.Attributes["w:chapSep"] != null)
646
                ctObj.chapSep = (ST_ChapterSep)Enum.Parse(typeof(ST_ChapterSep), node.Attributes["w:chapSep"].Value);
647
            return ctObj;
648
        }
649

650

651

652
        internal void Write(StreamWriter sw, string nodeName)
653
        {
654
            sw.Write(string.Format("<w:{0}", nodeName));
655
            XmlHelper.WriteAttribute(sw, "w:fmt", this.fmt.ToString());
656
            XmlHelper.WriteAttribute(sw, "w:start", this.start);
657
            XmlHelper.WriteAttribute(sw, "w:chapStyle", this.chapStyle);
658
            XmlHelper.WriteAttribute(sw, "w:chapSep", this.chapSep.ToString());
659
            sw.Write("/>");
660
        }
661

662
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
663
        public ST_NumberFormat fmt
664
        {
665
            get
666
            {
667
                return this.fmtField;
668
            }
669
            set
670
            {
671
                this.fmtField = value;
672
            }
673
        }
674

675
        [XmlIgnore]
676
        public bool fmtSpecified
677
        {
678
            get
679
            {
680
                return this.fmtFieldSpecified;
681
            }
682
            set
683
            {
684
                this.fmtFieldSpecified = value;
685
            }
686
        }
687

688
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
689
        public string start
690
        {
691
            get
692
            {
693
                return this.startField;
694
            }
695
            set
696
            {
697
                this.startField = value;
698
            }
699
        }
700

701
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
702
        public string chapStyle
703
        {
704
            get
705
            {
706
                return this.chapStyleField;
707
            }
708
            set
709
            {
710
                this.chapStyleField = value;
711
            }
712
        }
713

714
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
715
        public ST_ChapterSep chapSep
716
        {
717
            get
718
            {
719
                return this.chapSepField;
720
            }
721
            set
722
            {
723
                this.chapSepField = value;
724
            }
725
        }
726

727
        [XmlIgnore]
728
        public bool chapSepSpecified
729
        {
730
            get
731
            {
732
                return this.chapSepFieldSpecified;
733
            }
734
            set
735
            {
736
                this.chapSepFieldSpecified = value;
737
            }
738
        }
739
    }
740

741
    [Serializable]
742

743
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
744
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
745
    public class CT_SectType
746
    {
747

748
        private ST_SectionMark valField;
749

750
        private bool valFieldSpecified;
751
        public static CT_SectType Parse(XmlNode node, XmlNamespaceManager namespaceManager)
752
        {
753
            if (node == null)
754
                return null;
755
            CT_SectType ctObj = new CT_SectType();
756
            if (node.Attributes["w:val"] != null)
757
                ctObj.val = (ST_SectionMark)Enum.Parse(typeof(ST_SectionMark), node.Attributes["w:val"].Value);
758
            return ctObj;
759
        }
760

761

762

763
        internal void Write(StreamWriter sw, string nodeName)
764
        {
765
            sw.Write(string.Format("<w:{0}", nodeName));
766
            XmlHelper.WriteAttribute(sw, "w:val", this.val.ToString());
767
            sw.Write(">");
768
            sw.WriteEndW(nodeName);
769
        }
770

771
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
772
        public ST_SectionMark val
773
        {
774
            get
775
            {
776
                return this.valField;
777
            }
778
            set
779
            {
780
                this.valField = value;
781
            }
782
        }
783

784
        [XmlIgnore]
785
        public bool valSpecified
786
        {
787
            get
788
            {
789
                return this.valFieldSpecified;
790
            }
791
            set
792
            {
793
                this.valFieldSpecified = value;
794
            }
795
        }
796
    }
797

798

799
    [Serializable]
800
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
801
    public enum ST_SectionMark
802
    {
803

804
    
805
        nextPage,
806

807
    
808
        nextColumn,
809

810
    
811
        continuous,
812

813
    
814
        evenPage,
815

816
    
817
        oddPage,
818
    }
819
    [Serializable]
820

821
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
822
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
823
    public class CT_LineNumber
824
    {
825

826
        private string countByField;
827

828
        private string startField;
829

830
        private ulong distanceField;
831

832
        private bool distanceFieldSpecified;
833

834
        private ST_LineNumberRestart restartField;
835

836
        private bool restartFieldSpecified;
837
        public static CT_LineNumber Parse(XmlNode node, XmlNamespaceManager namespaceManager)
838
        {
839
            if (node == null)
840
                return null;
841
            CT_LineNumber ctObj = new CT_LineNumber();
842
            ctObj.countBy = XmlHelper.ReadString(node.Attributes["w:countBy"]);
843
            ctObj.start = XmlHelper.ReadString(node.Attributes["w:start"]);
844
            ctObj.distance = XmlHelper.ReadULong(node.Attributes["w:distance"]);
845
            if (node.Attributes["w:restart"] != null)
846
                ctObj.restart = (ST_LineNumberRestart)Enum.Parse(typeof(ST_LineNumberRestart), node.Attributes["w:restart"].Value);
847
            return ctObj;
848
        }
849

850

851

852
        internal void Write(StreamWriter sw, string nodeName)
853
        {
854
            sw.Write(string.Format("<w:{0}", nodeName));
855
            XmlHelper.WriteAttribute(sw, "w:countBy", this.countBy);
856
            XmlHelper.WriteAttribute(sw, "w:start", this.start);
857
            XmlHelper.WriteAttribute(sw, "w:distance", this.distance);
858
            XmlHelper.WriteAttribute(sw, "w:restart", this.restart.ToString());
859
            sw.Write(">");
860
            sw.WriteEndW(nodeName);
861
        }
862

863
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
864
        public string countBy
865
        {
866
            get
867
            {
868
                return this.countByField;
869
            }
870
            set
871
            {
872
                this.countByField = value;
873
            }
874
        }
875

876
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
877
        public string start
878
        {
879
            get
880
            {
881
                return this.startField;
882
            }
883
            set
884
            {
885
                this.startField = value;
886
            }
887
        }
888

889
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
890
        public ulong distance
891
        {
892
            get
893
            {
894
                return this.distanceField;
895
            }
896
            set
897
            {
898
                this.distanceField = value;
899
            }
900
        }
901

902
        [XmlIgnore]
903
        public bool distanceSpecified
904
        {
905
            get
906
            {
907
                return this.distanceFieldSpecified;
908
            }
909
            set
910
            {
911
                this.distanceFieldSpecified = value;
912
            }
913
        }
914

915
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
916
        public ST_LineNumberRestart restart
917
        {
918
            get
919
            {
920
                return this.restartField;
921
            }
922
            set
923
            {
924
                this.restartField = value;
925
            }
926
        }
927

928
        [XmlIgnore]
929
        public bool restartSpecified
930
        {
931
            get
932
            {
933
                return this.restartFieldSpecified;
934
            }
935
            set
936
            {
937
                this.restartFieldSpecified = value;
938
            }
939
        }
940
    }
941

942

943
    [Serializable]
944
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
945
    public enum ST_LineNumberRestart
946
    {
947

948
    
949
        newPage,
950

951
    
952
        newSection,
953

954
    
955
        continuous,
956
    }
957
}
958