/
aprogrammer
/
npoi
GigaCode
beta
ОбзорЦентр заботыВойти

npoi

Форк
0
Ветки: 14Коммиты: 3670Теги: 27
npoi
/OpenXmlFormats
/Drawing
/
ShapeStyle.cs 
470 строк · 13.4 Кб
1


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


8


9
namespace NPOI.OpenXmlFormats.Dml
10
{
11


12


13


14
    [Serializable]
15
    [System.Diagnostics.DebuggerStepThrough]
16
    [System.ComponentModel.DesignerCategory("code")]
17
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
18
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
19
    public class CT_StyleMatrixReference
20
    {
21


22
        private CT_ScRgbColor scrgbClrField;
23


24
        private CT_SRgbColor srgbClrField;
25


26
        private CT_HslColor hslClrField;
27


28
        private CT_SystemColor sysClrField;
29


30
        private CT_SchemeColor schemeClrField;
31


32
        private CT_PresetColor prstClrField;
33


34
        private uint idxField;
35
        public static CT_StyleMatrixReference Parse(XmlNode node, XmlNamespaceManager namespaceManager)
36
        {
37
            if (node == null)
38
                return null;
39
            CT_StyleMatrixReference ctObj = new CT_StyleMatrixReference();
40
            ctObj.idx = XmlHelper.ReadUInt(node.Attributes["idx"]);
41
            foreach (XmlNode childNode in node.ChildNodes)
42
            {
43
                if (childNode.LocalName == "scrgbClr")
44
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
45
                else if (childNode.LocalName == "srgbClr")
46
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
47
                else if (childNode.LocalName == "hslClr")
48
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
49
                else if (childNode.LocalName == "sysClr")
50
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
51
                else if (childNode.LocalName == "schemeClr")
52
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
53
                else if (childNode.LocalName == "prstClr")
54
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
55
            }
56
            return ctObj;
57
        }
58


59


60


61
        internal void Write(StreamWriter sw, string nodeName)
62
        {
63
            sw.Write(string.Format("<a:{0}", nodeName));
64
            XmlHelper.WriteAttribute(sw, "idx", this.idx, true);
65
            sw.Write(">");
66
            if (this.scrgbClr != null)
67
                this.scrgbClr.Write(sw, "scrgbClr");
68
            if (this.srgbClr != null)
69
                this.srgbClr.Write(sw, "srgbClr");
70
            if (this.hslClr != null)
71
                this.hslClr.Write(sw, "hslClr");
72
            if (this.sysClr != null)
73
                this.sysClr.Write(sw, "sysClr");
74
            if (this.schemeClr != null)
75
                this.schemeClr.Write(sw, "schemeClr");
76
            if (this.prstClr != null)
77
                this.prstClr.Write(sw, "prstClr");
78
            sw.Write(string.Format("</a:{0}>", nodeName));
79
        }
80


81
        [XmlElement(Order = 0)]
82
        public CT_ScRgbColor scrgbClr
83
        {
84
            get
85
            {
86
                return this.scrgbClrField;
87
            }
88
            set
89
            {
90
                this.scrgbClrField = value;
91
            }
92
        }
93


94
        [XmlElement(Order = 1)]
95
        public CT_SRgbColor srgbClr
96
        {
97
            get
98
            {
99
                return this.srgbClrField;
100
            }
101
            set
102
            {
103
                this.srgbClrField = value;
104
            }
105
        }
106


107
        [XmlElement(Order = 2)]
108
        public CT_HslColor hslClr
109
        {
110
            get
111
            {
112
                return this.hslClrField;
113
            }
114
            set
115
            {
116
                this.hslClrField = value;
117
            }
118
        }
119


120
        [XmlElement(Order = 3)]
121
        public CT_SystemColor sysClr
122
        {
123
            get
124
            {
125
                return this.sysClrField;
126
            }
127
            set
128
            {
129
                this.sysClrField = value;
130
            }
131
        }
132
        public CT_SchemeColor AddNewSchemeClr()
133
        {
134
            this.schemeClrField = new CT_SchemeColor();
135
            return this.schemeClrField;
136
        }
137
        [XmlElement(Order = 4)]
138
        public CT_SchemeColor schemeClr
139
        {
140
            get
141
            {
142
                return this.schemeClrField;
143
            }
144
            set
145
            {
146
                this.schemeClrField = value;
147
            }
148
        }
149


150
        [XmlElement(Order = 5)]
151
        public CT_PresetColor prstClr
152
        {
153
            get
154
            {
155
                return this.prstClrField;
156
            }
157
            set
158
            {
159
                this.prstClrField = value;
160
            }
161
        }
162


163


164
        [XmlAttribute]
165
        public uint idx
166
        {
167
            get
168
            {
169
                return this.idxField;
170
            }
171
            set
172
            {
173
                this.idxField = value;
174
            }
175
        }
176
    }
177


178


179


180


181
    [Serializable]
182
    [System.Diagnostics.DebuggerStepThrough]
183
    [System.ComponentModel.DesignerCategory("code")]
184
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
185
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
186
    public class CT_FontReference
187
    {
188


189
        private CT_ScRgbColor scrgbClrField;
190


191
        private CT_SRgbColor srgbClrField;
192


193
        private CT_HslColor hslClrField;
194


195
        private CT_SystemColor sysClrField;
196


197
        private CT_SchemeColor schemeClrField;
198


199
        private CT_PresetColor prstClrField;
200


201
        private ST_FontCollectionIndex idxField;
202
        public static CT_FontReference Parse(XmlNode node, XmlNamespaceManager namespaceManager)
203
        {
204
            if (node == null)
205
                return null;
206
            CT_FontReference ctObj = new CT_FontReference();
207
            if (node.Attributes["idx"] != null)
208
                ctObj.idx = (ST_FontCollectionIndex)Enum.Parse(typeof(ST_FontCollectionIndex), node.Attributes["idx"].Value);
209
            foreach (XmlNode childNode in node.ChildNodes)
210
            {
211
                if (childNode.LocalName == "scrgbClr")
212
                    ctObj.scrgbClr = CT_ScRgbColor.Parse(childNode, namespaceManager);
213
                else if (childNode.LocalName == "srgbClr")
214
                    ctObj.srgbClr = CT_SRgbColor.Parse(childNode, namespaceManager);
215
                else if (childNode.LocalName == "hslClr")
216
                    ctObj.hslClr = CT_HslColor.Parse(childNode, namespaceManager);
217
                else if (childNode.LocalName == "sysClr")
218
                    ctObj.sysClr = CT_SystemColor.Parse(childNode, namespaceManager);
219
                else if (childNode.LocalName == "schemeClr")
220
                    ctObj.schemeClr = CT_SchemeColor.Parse(childNode, namespaceManager);
221
                else if (childNode.LocalName == "prstClr")
222
                    ctObj.prstClr = CT_PresetColor.Parse(childNode, namespaceManager);
223
            }
224
            return ctObj;
225
        }
226


227


228


229
        internal void Write(StreamWriter sw, string nodeName)
230
        {
231
            sw.Write(string.Format("<a:{0}", nodeName));
232
            XmlHelper.WriteAttribute(sw, "idx", this.idx.ToString());
233
            sw.Write(">");
234
            if (this.scrgbClr != null)
235
                this.scrgbClr.Write(sw, "scrgbClr");
236
            if (this.srgbClr != null)
237
                this.srgbClr.Write(sw, "srgbClr");
238
            if (this.hslClr != null)
239
                this.hslClr.Write(sw, "hslClr");
240
            if (this.sysClr != null)
241
                this.sysClr.Write(sw, "sysClr");
242
            if (this.schemeClr != null)
243
                this.schemeClr.Write(sw, "schemeClr");
244
            if (this.prstClr != null)
245
                this.prstClr.Write(sw, "prstClr");
246
            sw.Write(string.Format("</a:{0}>", nodeName));
247
        }
248
        [XmlElement(Order = 0)]
249
        public CT_ScRgbColor scrgbClr
250
        {
251
            get
252
            {
253
                return this.scrgbClrField;
254
            }
255
            set
256
            {
257
                this.scrgbClrField = value;
258
            }
259
        }
260


261
        [XmlElement(Order = 1)]
262
        public CT_SRgbColor srgbClr
263
        {
264
            get
265
            {
266
                return this.srgbClrField;
267
            }
268
            set
269
            {
270
                this.srgbClrField = value;
271
            }
272
        }
273


274
        [XmlElement(Order = 2)]
275
        public CT_HslColor hslClr
276
        {
277
            get
278
            {
279
                return this.hslClrField;
280
            }
281
            set
282
            {
283
                this.hslClrField = value;
284
            }
285
        }
286


287
        [XmlElement(Order = 3)]
288
        public CT_SystemColor sysClr
289
        {
290
            get
291
            {
292
                return this.sysClrField;
293
            }
294
            set
295
            {
296
                this.sysClrField = value;
297
            }
298
        }
299
        public CT_SchemeColor AddNewSchemeClr()
300
        {
301
            this.schemeClrField = new CT_SchemeColor();
302
            return this.schemeClrField;
303
        }
304
        [XmlElement(Order = 4)]
305
        public CT_SchemeColor schemeClr
306
        {
307
            get
308
            {
309
                return this.schemeClrField;
310
            }
311
            set
312
            {
313
                this.schemeClrField = value;
314
            }
315
        }
316


317
        [XmlElement(Order = 5)]
318
        public CT_PresetColor prstClr
319
        {
320
            get
321
            {
322
                return this.prstClrField;
323
            }
324
            set
325
            {
326
                this.prstClrField = value;
327
            }
328
        }
329


330


331
        [XmlAttribute]
332
        public ST_FontCollectionIndex idx
333
        {
334
            get
335
            {
336
                return this.idxField;
337
            }
338
            set
339
            {
340
                this.idxField = value;
341
            }
342
        }
343
    }
344


345


346


347


348
    [Serializable]
349
    [System.Diagnostics.DebuggerStepThrough]
350
    [System.ComponentModel.DesignerCategory("code")]
351
    [XmlType(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")]
352
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", IsNullable = true)]
353
    public class CT_ShapeStyle
354
    {
355


356
        private CT_StyleMatrixReference lnRefField;
357


358
        private CT_StyleMatrixReference fillRefField;
359


360
        private CT_StyleMatrixReference effectRefField;
361


362
        private CT_FontReference fontRefField;
363
        public static CT_ShapeStyle Parse(XmlNode node, XmlNamespaceManager namespaceManager)
364
        {
365
            if (node == null)
366
                return null;
367
            CT_ShapeStyle ctObj = new CT_ShapeStyle();
368
            foreach (XmlNode childNode in node.ChildNodes)
369
            {
370
                if (childNode.LocalName == "lnRef")
371
                    ctObj.lnRef = CT_StyleMatrixReference.Parse(childNode, namespaceManager);
372
                else if (childNode.LocalName == "fillRef")
373
                    ctObj.fillRef = CT_StyleMatrixReference.Parse(childNode, namespaceManager);
374
                else if (childNode.LocalName == "effectRef")
375
                    ctObj.effectRef = CT_StyleMatrixReference.Parse(childNode, namespaceManager);
376
                else if (childNode.LocalName == "fontRef")
377
                    ctObj.fontRef = CT_FontReference.Parse(childNode, namespaceManager);
378
            }
379
            return ctObj;
380
        }
381


382


383


384
        internal void Write(StreamWriter sw, string nodeName)
385
        {
386
            sw.Write(string.Format("<a:{0}", nodeName));
387
            sw.Write(">");
388
            if (this.lnRef != null)
389
                this.lnRef.Write(sw, "lnRef");
390
            if (this.fillRef != null)
391
                this.fillRef.Write(sw, "fillRef");
392
            if (this.effectRef != null)
393
                this.effectRef.Write(sw, "effectRef");
394
            if (this.fontRef != null)
395
                this.fontRef.Write(sw, "fontRef");
396
            sw.Write(string.Format("</a:{0}>", nodeName));
397
        }
398


399
        public CT_StyleMatrixReference AddNewFillRef()
400
        {
401
            this.fillRefField = new CT_StyleMatrixReference();
402
            return this.fillRefField;
403
        }
404
        public CT_StyleMatrixReference AddNewLnRef()
405
        {
406
            this.lnRefField = new CT_StyleMatrixReference();
407
            return this.lnRefField;
408
        }
409
        public CT_FontReference AddNewFontRef()
410
        {
411
            this.fontRefField = new CT_FontReference();
412
            return this.fontRefField;
413
        }
414
        public CT_StyleMatrixReference AddNewEffectRef()
415
        {
416
            this.effectRefField = new CT_StyleMatrixReference();
417
            return this.effectRefField;
418
        }
419
        [XmlElement(Order = 0)]
420
        public CT_StyleMatrixReference lnRef
421
        {
422
            get
423
            {
424
                return this.lnRefField;
425
            }
426
            set
427
            {
428
                this.lnRefField = value;
429
            }
430
        }
431


432
        [XmlElement(Order = 1)]
433
        public CT_StyleMatrixReference fillRef
434
        {
435
            get
436
            {
437
                return this.fillRefField;
438
            }
439
            set
440
            {
441
                this.fillRefField = value;
442
            }
443
        }
444


445
        [XmlElement(Order = 2)]
446
        public CT_StyleMatrixReference effectRef
447
        {
448
            get
449
            {
450
                return this.effectRefField;
451
            }
452
            set
453
            {
454
                this.effectRefField = value;
455
            }
456
        }
457


458
        [XmlElement(Order = 3)]
459
        public CT_FontReference fontRef
460
        {
461
            get
462
            {
463
                return this.fontRefField;
464
            }
465
            set
466
            {
467
                this.fontRefField = value;
468
            }
469
        }
470
    }
471
}
472

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.