npoi

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

10
namespace NPOI.OpenXmlFormats.Dml.Chart
11
{
12

13

14
    [Serializable]
15

16
    [System.ComponentModel.DesignerCategoryAttribute("code")]
17
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
18
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
19
    public class CT_RadarSer
20
    {
21

22
        private CT_UnsignedInt idxField;
23

24
        private CT_UnsignedInt orderField;
25

26
        private CT_SerTx txField;
27

28
        private CT_ShapeProperties spPrField;
29

30
        private CT_Marker markerField;
31

32
        private List<CT_DPt> dPtField;
33

34
        private CT_DLbls dLblsField;
35

36
        private CT_AxDataSource catField;
37

38
        private CT_NumDataSource valField;
39

40
        private List<CT_Extension> extLstField;
41

42
        public CT_RadarSer()
43
        {
44

45
        }
46
        public static CT_RadarSer Parse(XmlNode node, XmlNamespaceManager namespaceManager)
47
        {
48
            if (node == null)
49
                return null;
50
            CT_RadarSer ctObj = new CT_RadarSer();
51
            ctObj.dPt = new List<CT_DPt>();
52
            ctObj.extLst = new List<CT_Extension>();
53
            foreach (XmlNode childNode in node.ChildNodes)
54
            {
55
                if (childNode.LocalName == "idx")
56
                    ctObj.idx = CT_UnsignedInt.Parse(childNode, namespaceManager);
57
                else if (childNode.LocalName == "order")
58
                    ctObj.order = CT_UnsignedInt.Parse(childNode, namespaceManager);
59
                else if (childNode.LocalName == "tx")
60
                    ctObj.tx = CT_SerTx.Parse(childNode, namespaceManager);
61
                else if (childNode.LocalName == "spPr")
62
                    ctObj.spPr = CT_ShapeProperties.Parse(childNode, namespaceManager);
63
                else if (childNode.LocalName == "marker")
64
                    ctObj.marker = CT_Marker.Parse(childNode, namespaceManager);
65
                else if (childNode.LocalName == "dLbls")
66
                    ctObj.dLbls = CT_DLbls.Parse(childNode, namespaceManager);
67
                else if (childNode.LocalName == "cat")
68
                    ctObj.cat = CT_AxDataSource.Parse(childNode, namespaceManager);
69
                else if (childNode.LocalName == "val")
70
                    ctObj.val = CT_NumDataSource.Parse(childNode, namespaceManager);
71
                else if (childNode.LocalName == "dPt")
72
                    ctObj.dPt.Add(CT_DPt.Parse(childNode, namespaceManager));
73
                else if (childNode.LocalName == "extLst")
74
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
75
            }
76
            return ctObj;
77
        }
78

79

80

81
        internal void Write(StreamWriter sw, string nodeName)
82
        {
83
            sw.Write(string.Format("<c:{0}", nodeName));
84
            sw.Write(">");
85
            if (this.idx != null)
86
                this.idx.Write(sw, "idx");
87
            if (this.order != null)
88
                this.order.Write(sw, "order");
89
            if (this.tx != null)
90
                this.tx.Write(sw, "tx");
91
            if (this.spPr != null)
92
                this.spPr.Write(sw, "spPr");
93
            if (this.marker != null)
94
                this.marker.Write(sw, "marker");
95
            if (this.dLbls != null)
96
                this.dLbls.Write(sw, "dLbls");
97
            if (this.cat != null)
98
                this.cat.Write(sw, "cat");
99
            if (this.val != null)
100
                this.val.Write(sw, "val");
101
            if (this.dPt != null)
102
            {
103
                foreach (CT_DPt x in this.dPt)
104
                {
105
                    x.Write(sw, "dPt");
106
                }
107
            }
108
            if (this.extLst != null)
109
            {
110
                foreach (CT_Extension x in this.extLst)
111
                {
112
                    x.Write(sw, "extLst");
113
                }
114
            }
115
            sw.Write(string.Format("</c:{0}>", nodeName));
116
        }
117

118

119
        [XmlElement(Order = 0)]
120
        public CT_UnsignedInt idx
121
        {
122
            get
123
            {
124
                return this.idxField;
125
            }
126
            set
127
            {
128
                this.idxField = value;
129
            }
130
        }
131

132
        [XmlElement(Order = 1)]
133
        public CT_UnsignedInt order
134
        {
135
            get
136
            {
137
                return this.orderField;
138
            }
139
            set
140
            {
141
                this.orderField = value;
142
            }
143
        }
144

145
        [XmlElement(Order = 2)]
146
        public CT_SerTx tx
147
        {
148
            get
149
            {
150
                return this.txField;
151
            }
152
            set
153
            {
154
                this.txField = value;
155
            }
156
        }
157

158
        [XmlElement(Order = 3)]
159
        public CT_ShapeProperties spPr
160
        {
161
            get
162
            {
163
                return this.spPrField;
164
            }
165
            set
166
            {
167
                this.spPrField = value;
168
            }
169
        }
170

171
        [XmlElement(Order = 4)]
172
        public CT_Marker marker
173
        {
174
            get
175
            {
176
                return this.markerField;
177
            }
178
            set
179
            {
180
                this.markerField = value;
181
            }
182
        }
183

184
        [XmlElement("dPt", Order = 5)]
185
        public List<CT_DPt> dPt
186
        {
187
            get
188
            {
189
                return this.dPtField;
190
            }
191
            set
192
            {
193
                this.dPtField = value;
194
            }
195
        }
196

197
        [XmlElement(Order = 6)]
198
        public CT_DLbls dLbls
199
        {
200
            get
201
            {
202
                return this.dLblsField;
203
            }
204
            set
205
            {
206
                this.dLblsField = value;
207
            }
208
        }
209

210
        [XmlElement(Order = 7)]
211
        public CT_AxDataSource cat
212
        {
213
            get
214
            {
215
                return this.catField;
216
            }
217
            set
218
            {
219
                this.catField = value;
220
            }
221
        }
222

223
        [XmlElement(Order = 8)]
224
        public CT_NumDataSource val
225
        {
226
            get
227
            {
228
                return this.valField;
229
            }
230
            set
231
            {
232
                this.valField = value;
233
            }
234
        }
235

236
        [XmlElement(Order = 9)]
237
        public List<CT_Extension> extLst
238
        {
239
            get
240
            {
241
                return this.extLstField;
242
            }
243
            set
244
            {
245
                this.extLstField = value;
246
            }
247
        }
248
    }
249
    [Serializable]
250

251
    [System.ComponentModel.DesignerCategoryAttribute("code")]
252
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
253
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
254
    public class CT_RadarStyle
255
    {
256

257
        private ST_RadarStyle valField;
258

259
        public CT_RadarStyle()
260
        {
261
            this.valField = ST_RadarStyle.standard;
262
        }
263
        public static CT_RadarStyle Parse(XmlNode node, XmlNamespaceManager namespaceManager)
264
        {
265
            if (node == null)
266
                return null;
267
            CT_RadarStyle ctObj = new CT_RadarStyle();
268
            if (node.Attributes["val"] != null)
269
                ctObj.val = (ST_RadarStyle)Enum.Parse(typeof(ST_RadarStyle), node.Attributes["val"].Value);
270
            return ctObj;
271
        }
272

273

274

275
        internal void Write(StreamWriter sw, string nodeName)
276
        {
277
            sw.Write(string.Format("<c:{0}", nodeName));
278
            XmlHelper.WriteAttribute(sw, "val", this.val.ToString());
279
            sw.Write(">");
280
            sw.Write(string.Format("</c:{0}>", nodeName));
281
        }
282

283
        [XmlAttribute]
284
        [DefaultValue(ST_RadarStyle.standard)]
285
        public ST_RadarStyle val
286
        {
287
            get
288
            {
289
                return this.valField;
290
            }
291
            set
292
            {
293
                this.valField = value;
294
            }
295
        }
296
    }
297

298

299
    [Serializable]
300
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
301
    public enum ST_RadarStyle
302
    {
303

304
        /// <remarks/>
305
        standard,
306

307
        /// <remarks/>
308
        marker,
309

310
        /// <remarks/>
311
        filled,
312
    }
313

314

315
    [Serializable]
316

317
    [System.ComponentModel.DesignerCategoryAttribute("code")]
318
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart")]
319
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/chart", IsNullable = true)]
320
    public class CT_RadarChart
321
    {
322

323
        private CT_RadarStyle radarStyleField;
324

325
        private CT_Boolean varyColorsField;
326

327
        private List<CT_RadarSer> serField;
328

329
        private CT_DLbls dLblsField;
330

331
        private List<CT_UnsignedInt> axIdField;
332

333
        private List<CT_Extension> extLstField;
334

335
        public CT_RadarChart()
336
        {
337
        }
338
        public static CT_RadarChart Parse(XmlNode node, XmlNamespaceManager namespaceManager)
339
        {
340
            if (node == null)
341
                return null;
342
            CT_RadarChart ctObj = new CT_RadarChart();
343
            ctObj.ser = new List<CT_RadarSer>();
344
            ctObj.axId = new List<CT_UnsignedInt>();
345
            ctObj.extLst = new List<CT_Extension>();
346
            foreach (XmlNode childNode in node.ChildNodes)
347
            {
348
                if (childNode.LocalName == "radarStyle")
349
                    ctObj.radarStyle = CT_RadarStyle.Parse(childNode, namespaceManager);
350
                else if (childNode.LocalName == "varyColors")
351
                    ctObj.varyColors = CT_Boolean.Parse(childNode, namespaceManager);
352
                else if (childNode.LocalName == "dLbls")
353
                    ctObj.dLbls = CT_DLbls.Parse(childNode, namespaceManager);
354
                else if (childNode.LocalName == "ser")
355
                    ctObj.ser.Add(CT_RadarSer.Parse(childNode, namespaceManager));
356
                else if (childNode.LocalName == "axId")
357
                    ctObj.axId.Add(CT_UnsignedInt.Parse(childNode, namespaceManager));
358
                else if (childNode.LocalName == "extLst")
359
                    ctObj.extLst.Add(CT_Extension.Parse(childNode, namespaceManager));
360
            }
361
            return ctObj;
362
        }
363

364

365

366
        internal void Write(StreamWriter sw, string nodeName)
367
        {
368
            sw.Write(string.Format("<c:{0}", nodeName));
369
            sw.Write(">");
370
            if (this.radarStyle != null)
371
                this.radarStyle.Write(sw, "radarStyle");
372
            if (this.varyColors != null)
373
                this.varyColors.Write(sw, "varyColors");
374
            if (this.ser != null)
375
            {
376
                foreach (CT_RadarSer x in this.ser)
377
                {
378
                    x.Write(sw, "ser");
379
                }
380
            }
381
            if (this.dLbls != null)
382
                this.dLbls.Write(sw, "dLbls");
383
            if (this.axId != null)
384
            {
385
                foreach (CT_UnsignedInt x in this.axId)
386
                {
387
                    x.Write(sw, "axId");
388
                }
389
            }
390
            if (this.extLst != null)
391
            {
392
                foreach (CT_Extension x in this.extLst)
393
                {
394
                    x.Write(sw, "extLst");
395
                }
396
            }
397
            sw.Write(string.Format("</c:{0}>", nodeName));
398
        }
399

400
        public int GetSeriesCount()
401
        {
402
            return this.serField == null ? 0 : this.serField.Count;
403
        }
404

405
        [XmlElement(Order = 0)]
406
        public CT_RadarStyle radarStyle
407
        {
408
            get
409
            {
410
                return this.radarStyleField;
411
            }
412
            set
413
            {
414
                this.radarStyleField = value;
415
            }
416
        }
417

418
        [XmlElement(Order = 1)]
419
        public CT_Boolean varyColors
420
        {
421
            get
422
            {
423
                return this.varyColorsField;
424
            }
425
            set
426
            {
427
                this.varyColorsField = value;
428
            }
429
        }
430

431
        [XmlElement("ser", Order = 2)]
432
        public List<CT_RadarSer> ser
433
        {
434
            get
435
            {
436
                return this.serField;
437
            }
438
            set
439
            {
440
                this.serField = value;
441
            }
442
        }
443

444
        [XmlElement(Order = 3)]
445
        public CT_DLbls dLbls
446
        {
447
            get
448
            {
449
                return this.dLblsField;
450
            }
451
            set
452
            {
453
                this.dLblsField = value;
454
            }
455
        }
456

457
        [XmlElement("axId", Order = 4)]
458
        public List<CT_UnsignedInt> axId
459
        {
460
            get
461
            {
462
                return this.axIdField;
463
            }
464
            set
465
            {
466
                this.axIdField = value;
467
            }
468
        }
469

470
        [XmlElement(Order = 5)]
471
        public List<CT_Extension> extLst
472
        {
473
            get
474
            {
475
                return this.extLstField;
476
            }
477
            set
478
            {
479
                this.extLstField = value;
480
            }
481
        }
482
    }
483

484
}
485