NanoXLSX.Reader 3.2.1
Loading...
Searching...
No Matches
StyleReader.cs
1/*
2 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way
3 * Copyright Raphael Stoeckli © 2026
4 * This library is licensed under the MIT License.
5 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
6 */
7
8namespace NanoXLSX.Internal.Readers
9{
10 using System;
11 using System.Collections.Generic;
12 using System.IO;
13 using System.Xml;
14 using NanoXLSX.Colors;
15 using NanoXLSX.Interfaces;
16 using NanoXLSX.Interfaces.Reader;
17 using NanoXLSX.Registry;
18 using NanoXLSX.Registry.Attributes;
19 using NanoXLSX.Styles;
20 using NanoXLSX.Themes;
21 using NanoXLSX.Utils;
22 using NanoXLSX.Utils.Xml;
23 using static NanoXLSX.Styles.Border;
24 using static NanoXLSX.Styles.CellXf;
25 using static NanoXLSX.Styles.Font;
26 using static NanoXLSX.Styles.NumberFormat;
27 using static NanoXLSX.Themes.Theme;
28 using IOException = Exceptions.IOException;
29
33 [NanoXlsxPlugIn(PlugInUUID = PlugInUUID.StyleReader)]
34 public class StyleReader : IDocumentReader
35 {
36
37 private Stream stream;
38 private StyleReaderContainer styleReaderContainer;
39 private ReaderOptions options;
40
41 #region properties
45 public virtual string DocumentType { get { return @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"; } }
46
50 public Workbook Workbook { get; set; }
54 public IOptions Options { get; set; }
58 public Action<Stream, Workbook, string, IOptions, int?> InlinePluginHandler { get; set; }
59 #endregion
60
61 #region constructors
65 public StyleReader()
66 {
67 }
68 #endregion
69
70 #region methods
71
79 public void Init(Stream stream, Workbook workbook, IOptions readerOptions, Action<Stream, Workbook, string, IOptions, int?> inlinePluginHandler)
80 {
81 this.stream = stream;
82 this.Workbook = workbook;
83 this.Options = readerOptions;
84 this.options = readerOptions as ReaderOptions;
85 this.InlinePluginHandler = inlinePluginHandler;
86 }
87
92 public void Execute()
93 {
94 this.styleReaderContainer = new StyleReaderContainer();
95 try
96 {
97 using (stream) // Close after processing
98 {
99 using (XmlReader reader = XmlReader.Create(stream, XmlStreamUtils.CreateSettings()))
100 {
101 while (reader.Read())
102 {
103 if (reader.NodeType != XmlNodeType.Element)
104 {
105 continue;
106 }
107 switch (reader.LocalName.ToLowerInvariant())
108 {
109 case "numfmts":
110 GetNumberFormats(reader);
111 break;
112 case "borders":
113 GetBorders(reader);
114 break;
115 case "fills":
116 GetFills(reader);
117 break;
118 case "fonts":
119 GetFonts(reader);
120 break;
121 case "colors":
122 GetColors(reader);
123 break;
124 case "cellxfs":
125 GetCellXfs(reader);
126 break;
127 }
128 }
129 HandleMruColors();
130 InlinePluginHandler?.Invoke(stream, Workbook, PlugInUUID.StyleInlineReader, Options, null);
131 }
132 }
133 Workbook.AuxiliaryData.SetData(PlugInUUID.StyleReader, PlugInUUID.StyleEntity, styleReaderContainer);
134 }
135 catch (Exception ex)
136 {
137 throw new IOException("The XML entry could not be read from the input stream. Please see the inner exception:", ex);
138 }
139 }
140
144 private void HandleMruColors()
145 {
146 List<string> mruColors = styleReaderContainer.GetMruColors();
147 foreach (string color in mruColors)
148 {
149 Workbook.AddMruColor(color);
150 }
151 }
152
157 private void GetNumberFormats(XmlReader reader)
158 {
159 using (XmlReader subtree = reader.ReadSubtree())
160 {
161 subtree.Read(); // consume <numFmts>
162 while (subtree.Read())
163 {
164 if (!XmlStreamUtils.IsElement(subtree, "numFmt"))
165 {
166 continue;
167 }
168 NumberFormat numberFormat = new NumberFormat();
169 int id = ParserUtils.ParseInt(subtree.GetAttribute("numFmtId")); // null will rightly throw
170 string code = subtree.GetAttribute("formatCode");
171 if (string.IsNullOrEmpty(code))
172 {
173 if (options.EnforceStrictValidation)
174 {
175 throw new Exceptions.FormatException("A format code cannot be null or empty, but was read so in the styles");
176 }
177 continue; // Skip an invalid number format
178 }
179 numberFormat.CustomFormatID = id;
180 numberFormat.Number = FormatNumber.Custom;
181 numberFormat.InternalID = id;
182 numberFormat.CustomFormatCode = code;
183 this.styleReaderContainer.AddStyleComponent(numberFormat);
184 }
185 }
186 }
187
192 private void GetBorders(XmlReader reader)
193 {
194 using (XmlReader subtree = reader.ReadSubtree())
195 {
196 subtree.Read(); // consume <borders>
197 while (subtree.Read())
198 {
199 if (!XmlStreamUtils.IsElement(subtree, "border"))
200 {
201 continue;
202 }
203 Border borderStyle = new Border();
204 string diagonalDown = subtree.GetAttribute("diagonalDown");
205 if (diagonalDown != null && ParserUtils.ParseBinaryBool(diagonalDown) == 1)
206 {
207 borderStyle.DiagonalDown = true;
208 }
209 string diagonalUp = subtree.GetAttribute("diagonalUp");
210 if (diagonalUp != null && ParserUtils.ParseBinaryBool(diagonalUp) == 1)
211 {
212 borderStyle.DiagonalUp = true;
213 }
214 StyleValue sideStyle;
215 string sideColor;
216 using (XmlReader borderSubtree = subtree.ReadSubtree())
217 {
218 borderSubtree.Read(); // consume <border>
219 while (borderSubtree.Read())
220 {
221 if (borderSubtree.NodeType != XmlNodeType.Element)
222 {
223 continue;
224 }
225 switch (borderSubtree.LocalName.ToLowerInvariant())
226 {
227 case "diagonal":
228 ReadBorderSide(borderSubtree, out sideStyle, out sideColor);
229 borderStyle.DiagonalStyle = sideStyle;
230 borderStyle.DiagonalColor = sideColor;
231 break;
232 case "top":
233 ReadBorderSide(borderSubtree, out sideStyle, out sideColor);
234 borderStyle.TopStyle = sideStyle;
235 borderStyle.TopColor = sideColor;
236 break;
237 case "bottom":
238 ReadBorderSide(borderSubtree, out sideStyle, out sideColor);
239 borderStyle.BottomStyle = sideStyle;
240 borderStyle.BottomColor = sideColor;
241 break;
242 case "left":
243 ReadBorderSide(borderSubtree, out sideStyle, out sideColor);
244 borderStyle.LeftStyle = sideStyle;
245 borderStyle.LeftColor = sideColor;
246 break;
247 case "right":
248 ReadBorderSide(borderSubtree, out sideStyle, out sideColor);
249 borderStyle.RightStyle = sideStyle;
250 borderStyle.RightColor = sideColor;
251 break;
252 }
253 }
254 }
255 borderStyle.InternalID = this.styleReaderContainer.GetNextBorderId();
256 this.styleReaderContainer.AddStyleComponent(borderStyle);
257 }
258 }
259 }
260
265 private static void ReadBorderSide(XmlReader reader, out StyleValue style, out string color)
266 {
267 style = StyleValue.None;
268 color = Border.DefaultBorderColor;
269 string styleAttr = reader.GetAttribute("style");
270 if (styleAttr != null)
271 {
272 style = Border.GetStyleEnum(styleAttr);
273 }
274 if (reader.IsEmptyElement)
275 {
276 return;
277 }
278 using (XmlReader subtree = reader.ReadSubtree())
279 {
280 subtree.Read(); // consume the side element open tag
281 while (subtree.Read())
282 {
283 if (subtree.NodeType == XmlNodeType.Element
284 && subtree.LocalName.Equals("color", StringComparison.OrdinalIgnoreCase))
285 {
286 string rgb = subtree.GetAttribute("rgb");
287 if (rgb != null)
288 {
289 color = rgb;
290 }
291 break;
292 }
293 }
294 }
295 }
296
301 private void GetFills(XmlReader reader)
302 {
303 using (XmlReader subtree = reader.ReadSubtree())
304 {
305 subtree.Read(); // consume <fills>
306 while (subtree.Read())
307 {
308 if (!XmlStreamUtils.IsElement(subtree, "fill"))
309 {
310 continue;
311 }
312 Fill fillStyle = new Fill();
313 using (XmlReader fillSubtree = subtree.ReadSubtree())
314 {
315 fillSubtree.Read(); // consume <fill>
316 while (fillSubtree.Read())
317 {
318 if (!XmlStreamUtils.IsElement(fillSubtree, "patternFill"))
319 {
320 continue;
321 }
322 fillStyle.PatternFill = Fill.GetPatternEnum(fillSubtree.GetAttribute("patternType") ?? string.Empty);
323 using (XmlReader patternSubtree = fillSubtree.ReadSubtree())
324 {
325 patternSubtree.Read(); // consume <patternFill>
326 while (patternSubtree.Read())
327 {
328 if (patternSubtree.NodeType != XmlNodeType.Element)
329 {
330 continue;
331 }
332 if (patternSubtree.LocalName.Equals("fgColor", StringComparison.OrdinalIgnoreCase))
333 {
334 fillStyle.ForegroundColor = ReadColorFromNode(patternSubtree);
335 }
336 else if (patternSubtree.LocalName.Equals("bgColor", StringComparison.OrdinalIgnoreCase))
337 {
338 fillStyle.BackgroundColor = ReadColorFromNode(patternSubtree);
339 }
340 }
341 }
342 }
343 }
344 fillStyle.InternalID = this.styleReaderContainer.GetNextFillId();
345 this.styleReaderContainer.AddStyleComponent(fillStyle);
346 }
347 }
348 }
349
353 private static Color ReadColorFromNode(XmlReader reader)
354 {
355 string autoAttr = reader.GetAttribute("auto");
356 if (!string.IsNullOrEmpty(autoAttr) && ParserUtils.ParseBinaryBool(autoAttr) == 1)
357 {
358 return Color.CreateAuto();
359 }
360 string rgbAttr = reader.GetAttribute("rgb");
361 if (!string.IsNullOrEmpty(rgbAttr))
362 {
363 return Color.CreateRgb(rgbAttr);
364 }
365 string indexedAttr = reader.GetAttribute("indexed");
366 if (!string.IsNullOrEmpty(indexedAttr))
367 {
368 return Color.CreateIndexed(ParserUtils.ParseInt(indexedAttr));
369 }
370 string themeAttr = reader.GetAttribute("theme");
371 if (!string.IsNullOrEmpty(themeAttr))
372 {
373 int themeIndex = ParserUtils.ParseInt(themeAttr);
374 string tintAttr = reader.GetAttribute("tint");
375 double? tint = null;
376 if (!string.IsNullOrEmpty(tintAttr))
377 {
378 tint = ParserUtils.ParseDouble(tintAttr);
379 }
380 return Color.CreateTheme((Theme.ColorSchemeElement)themeIndex, tint);
381 }
382 string systemAttr = reader.GetAttribute("system");
383 if (!string.IsNullOrEmpty(systemAttr))
384 {
385 return Color.CreateSystem(new SystemColor(SystemColor.MapStringToValue(systemAttr)));
386 }
387 return Color.CreateNone();
388 }
389
394 private void GetFonts(XmlReader reader)
395 {
396 using (XmlReader subtree = reader.ReadSubtree())
397 {
398 subtree.Read(); // consume <fonts>
399 while (subtree.Read())
400 {
401 if (!XmlStreamUtils.IsElement(subtree, "font"))
402 {
403 continue;
404 }
405 Font fontStyle = new Font();
406 ReadFontElement(subtree, fontStyle);
407 fontStyle.InternalID = this.styleReaderContainer.GetNextFontId();
408 this.styleReaderContainer.AddStyleComponent(fontStyle);
409 }
410 }
411 }
412
416 private static void ReadFontElement(XmlReader reader, Font fontStyle)
417 {
418 using (XmlReader fontSubtree = reader.ReadSubtree())
419 {
420 fontSubtree.Read(); // consume <font>
421 while (fontSubtree.Read())
422 {
423 if (fontSubtree.NodeType != XmlNodeType.Element)
424 {
425 continue;
426 }
427 string val;
428 switch (fontSubtree.LocalName.ToLowerInvariant())
429 {
430 case "b":
431 fontStyle.Bold = true;
432 break;
433 case "i":
434 fontStyle.Italic = true;
435 break;
436 case "strike":
437 fontStyle.Strike = true;
438 break;
439 case "outline":
440 fontStyle.Outline = true;
441 break;
442 case "shadow":
443 fontStyle.Shadow = true;
444 break;
445 case "condense":
446 fontStyle.Condense = true;
447 break;
448 case "extend":
449 fontStyle.Extend = true;
450 break;
451 case "u":
452 val = fontSubtree.GetAttribute("val");
453 fontStyle.Underline = val == null ? Font.UnderlineValue.Single : Font.GetUnderlineEnum(val);
454 break;
455 case "vertalign":
456 fontStyle.VerticalAlign = Font.GetVerticalTextAlignEnum(fontSubtree.GetAttribute("val"));
457 break;
458 case "sz":
459 fontStyle.Size = ParserUtils.ParseFloat(fontSubtree.GetAttribute("val"));
460 break;
461 case "color":
462 string themeVal = fontSubtree.GetAttribute("theme");
463 if (themeVal != null)
464 {
465 fontStyle.ColorValue = Color.CreateTheme(ParseFontColorSchemeElement(themeVal));
466 }
467 string rgbVal = fontSubtree.GetAttribute("rgb");
468 if (rgbVal != null)
469 {
470 fontStyle.ColorValue = Color.CreateRgb(rgbVal);
471 }
472 break;
473 case "name":
474 fontStyle.Name = fontSubtree.GetAttribute("val");
475 break;
476 case "family":
477 val = fontSubtree.GetAttribute("val");
478 if (val != null)
479 {
480 fontStyle.Family = ParseFontFamilyValue(val);
481 }
482 break;
483 case "scheme":
484 val = fontSubtree.GetAttribute("val");
485 if (val != null)
486 {
487 switch (val)
488 {
489 case "major":
490 fontStyle.Scheme = SchemeValue.Major;
491 break;
492 case "minor":
493 fontStyle.Scheme = SchemeValue.Minor;
494 break;
495 }
496 }
497 break;
498 case "charset":
499 val = fontSubtree.GetAttribute("val");
500 if (val != null)
501 {
502 fontStyle.Charset = ParseFontCharsetValue(val);
503 }
504 break;
505 }
506 }
507 }
508 }
509
513 private static ColorSchemeElement ParseFontColorSchemeElement(string value)
514 {
515 switch (value)
516 {
517 case "1": return ColorSchemeElement.Light1;
518 case "2": return ColorSchemeElement.Dark2;
519 case "3": return ColorSchemeElement.Light2;
520 case "4": return ColorSchemeElement.Accent1;
521 case "5": return ColorSchemeElement.Accent2;
522 case "6": return ColorSchemeElement.Accent3;
523 case "7": return ColorSchemeElement.Accent4;
524 case "8": return ColorSchemeElement.Accent5;
525 case "9": return ColorSchemeElement.Accent6;
526 case "10": return ColorSchemeElement.Hyperlink;
527 case "11": return ColorSchemeElement.FollowedHyperlink;
528 default: return ColorSchemeElement.Dark1;
529 }
530 }
531
535 private static FontFamilyValue ParseFontFamilyValue(string value)
536 {
537 switch (value)
538 {
539 case "1": return FontFamilyValue.Roman;
540 case "2": return FontFamilyValue.Swiss;
541 case "3": return FontFamilyValue.Modern;
542 case "4": return FontFamilyValue.Script;
543 case "5": return FontFamilyValue.Decorative;
544 case "6": return FontFamilyValue.Reserved1;
545 case "7": return FontFamilyValue.Reserved2;
546 case "8": return FontFamilyValue.Reserved3;
547 case "9": return FontFamilyValue.Reserved4;
548 case "10": return FontFamilyValue.Reserved5;
549 case "11": return FontFamilyValue.Reserved6;
550 case "12": return FontFamilyValue.Reserved7;
551 case "13": return FontFamilyValue.Reserved8;
552 case "14": return FontFamilyValue.Reserved9;
553 default: return FontFamilyValue.NotApplicable;
554 }
555 }
556
560 private static CharsetValue ParseFontCharsetValue(string value)
561 {
562 switch (value)
563 {
564 case "0": return CharsetValue.ANSI;
565 case "1": return CharsetValue.Default;
566 case "2": return CharsetValue.Symbols;
567 case "77": return CharsetValue.Macintosh;
568 case "128": return CharsetValue.JIS;
569 case "129": return CharsetValue.Hangul;
570 case "130": return CharsetValue.Johab;
571 case "134": return CharsetValue.GBK;
572 case "136": return CharsetValue.Big5;
573 case "161": return CharsetValue.Greek;
574 case "162": return CharsetValue.Turkish;
575 case "163": return CharsetValue.Vietnamese;
576 case "177": return CharsetValue.Hebrew;
577 case "178": return CharsetValue.Arabic;
578 case "186": return CharsetValue.Baltic;
579 case "204": return CharsetValue.Russian;
580 case "222": return CharsetValue.Thai;
581 case "238": return CharsetValue.EasternEuropean;
582 case "255": return CharsetValue.OEM;
583 default: return CharsetValue.ApplicationDefined;
584 }
585 }
586
592 private void GetCellXfs(XmlReader reader)
593 {
594 using (XmlReader subtree = reader.ReadSubtree())
595 {
596 subtree.Read(); // consume <cellXfs>
597 while (subtree.Read())
598 {
599 if (!XmlStreamUtils.IsElement(subtree, "xf"))
600 {
601 continue;
602 }
603 CellXf cellXfStyle = new CellXf();
604 string applyAlignment = subtree.GetAttribute("applyAlignment");
605 if (applyAlignment != null)
606 {
607 cellXfStyle.ForceApplyAlignment = ParserUtils.ParseBinaryBool(applyAlignment) == 1;
608 }
609 string numFmtIdStr = subtree.GetAttribute("numFmtId");
610 string borderIdStr = subtree.GetAttribute("borderId");
611 string fillIdStr = subtree.GetAttribute("fillId");
612 string fontIdStr = subtree.GetAttribute("fontId");
613 if (!subtree.IsEmptyElement)
614 {
615 using (XmlReader xfSubtree = subtree.ReadSubtree())
616 {
617 xfSubtree.Read(); // consume <xf>
618 while (xfSubtree.Read())
619 {
620 if (xfSubtree.NodeType != XmlNodeType.Element)
621 {
622 continue;
623 }
624 if (xfSubtree.LocalName.Equals("alignment", StringComparison.OrdinalIgnoreCase))
625 {
626 ReadXfAlignment(xfSubtree, cellXfStyle);
627 }
628 else if (xfSubtree.LocalName.Equals("protection", StringComparison.OrdinalIgnoreCase))
629 {
630 ReadXfProtection(xfSubtree, cellXfStyle);
631 }
632 }
633 }
634 }
635 cellXfStyle.InternalID = this.styleReaderContainer.GetNextCellXFId();
636 this.styleReaderContainer.AddStyleComponent(cellXfStyle);
637
638 Style style = new Style();
639 int id;
640 bool hasId;
641
642 hasId = ParserUtils.TryParseInt(numFmtIdStr, out id);
643 NumberFormat format = this.styleReaderContainer.GetNumberFormat(id);
644 if (!hasId || format == null)
645 {
646 FormatNumber formatNumber;
647 NumberFormat.TryParseFormatNumber(id, out formatNumber);
648 format = new NumberFormat
649 {
650 Number = formatNumber,
651 InternalID = id
652 };
653 this.styleReaderContainer.AddStyleComponent(format);
654 }
655 hasId = ParserUtils.TryParseInt(borderIdStr, out id);
656 Border border = this.styleReaderContainer.GetBorder(id);
657 if (!hasId || border == null)
658 {
659 border = new Border
660 {
661 InternalID = this.styleReaderContainer.GetNextBorderId()
662 };
663 }
664 hasId = ParserUtils.TryParseInt(fillIdStr, out id);
665 Fill fill = this.styleReaderContainer.GetFill(id);
666 if (!hasId || fill == null)
667 {
668 fill = new Fill
669 {
670 InternalID = this.styleReaderContainer.GetNextFillId()
671 };
672 }
673 hasId = ParserUtils.TryParseInt(fontIdStr, out id);
674 Font font = this.styleReaderContainer.GetFont(id);
675 if (!hasId || font == null)
676 {
677 font = new Font
678 {
679 InternalID = this.styleReaderContainer.GetNextFontId()
680 };
681 }
682 style.CurrentNumberFormat = format;
683 style.CurrentBorder = border;
684 style.CurrentFill = fill;
685 style.CurrentFont = font;
686 style.CurrentCellXf = cellXfStyle;
687 style.InternalID = this.styleReaderContainer.GetNextStyleId();
688 this.styleReaderContainer.AddStyleComponent(style);
689 }
690 }
691 }
692
696 private static void ReadXfAlignment(XmlReader reader, CellXf cellXfStyle)
697 {
698 string shrinkToFit = reader.GetAttribute("shrinkToFit");
699 if (shrinkToFit != null && ParserUtils.ParseBinaryBool(shrinkToFit) == 1)
700 {
701 cellXfStyle.Alignment = TextBreakValue.ShrinkToFit;
702 }
703 string wrapText = reader.GetAttribute("wrapText");
704 if (wrapText != null && wrapText == "1")
705 {
706 cellXfStyle.Alignment = TextBreakValue.WrapText;
707 }
708 cellXfStyle.HorizontalAlign = CellXf.GetHorizontalAlignEnum(reader.GetAttribute("horizontal") ?? string.Empty);
709 cellXfStyle.VerticalAlign = CellXf.GetVerticalAlignEnum(reader.GetAttribute("vertical") ?? string.Empty);
710 string indent = reader.GetAttribute("indent");
711 if (indent != null)
712 {
713 cellXfStyle.Indent = ParserUtils.ParseInt(indent);
714 }
715 string textRotation = reader.GetAttribute("textRotation");
716 if (textRotation != null)
717 {
718 int rotation = ParserUtils.ParseInt(textRotation);
719 cellXfStyle.TextRotation = rotation > 90 ? 90 - rotation : rotation;
720 }
721 }
722
726 private static void ReadXfProtection(XmlReader reader, CellXf cellXfStyle)
727 {
728 string hidden = reader.GetAttribute("hidden");
729 if (hidden != null && hidden == "1")
730 {
731 cellXfStyle.Hidden = true;
732 }
733 string locked = reader.GetAttribute("locked");
734 if (locked != null && locked == "0")
735 {
736 cellXfStyle.Locked = false;
737 }
738 }
739
744 private void GetColors(XmlReader reader)
745 {
746 using (XmlReader subtree = reader.ReadSubtree())
747 {
748 subtree.Read(); // consume <colors>
749 while (subtree.Read())
750 {
751 if (subtree.NodeType == XmlNodeType.Element
752 && subtree.LocalName.Equals("mruColors", StringComparison.OrdinalIgnoreCase))
753 {
754 ReadMruColors(subtree);
755 }
756 }
757 }
758 }
759
763 private void ReadMruColors(XmlReader reader)
764 {
765 using (XmlReader subtree = reader.ReadSubtree())
766 {
767 subtree.Read(); // consume <mruColors>
768 while (subtree.Read())
769 {
770 if (subtree.NodeType == XmlNodeType.Element
771 && subtree.LocalName.Equals("color", StringComparison.OrdinalIgnoreCase))
772 {
773 string rgb = subtree.GetAttribute("rgb");
774 if (rgb != null)
775 {
776 this.styleReaderContainer.AddMruColor(rgb);
777 }
778 }
779 }
780 }
781 }
782 #endregion
783 }
784}
NanoXLSX.Internal.Readers.StyleReader.InlinePluginHandler
Action< Stream, Workbook, string, IOptions, int?> InlinePluginHandler
Reference to the ReaderPlugInHandler, to be used for post operations in the Execute method.
Definition StyleReader.cs:58
NanoXLSX.Internal.Readers.StyleReader.StyleReader
StyleReader()
Default constructor - Must be defined for instantiation of the plug-ins.
Definition StyleReader.cs:65
NanoXLSX.Internal.Readers.StyleReader.DocumentType
virtual string DocumentType
Gets the relationship type URI of a style document.
Definition StyleReader.cs:45
NanoXLSX.Internal.Readers.StyleReader.Workbook
Workbook Workbook
Workbook reference where read data is stored (should not be null).
Definition StyleReader.cs:50
NanoXLSX.Internal.Readers.StyleReader.Init
void Init(Stream stream, Workbook workbook, IOptions readerOptions, Action< Stream, Workbook, string, IOptions, int?> inlinePluginHandler)
Initialization method (interface implementation).
Definition StyleReader.cs:79
NanoXLSX.Internal.Readers.StyleReader.Execute
void Execute()
Method to execute the main logic of the plug-in (interface implementation).
Definition StyleReader.cs:92
NanoXLSX.Internal.Readers.StyleReader.Options
IOptions Options
Reader options.
Definition StyleReader.cs:54
NanoXLSX.Internal.StyleReaderContainer
Class representing a collection of pre-processed styles and their components. This class is internall...
Definition StyleReaderContainer.cs:19
NanoXLSX.Internal.Readers.IOException
Exceptions.IOException IOException
Definition StyleReader.cs:28