ThemeReader.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way
 * Copyright Raphael Stoeckli © 2026
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System;
using System.IO;
using System.Xml;
using NanoXLSX.Colors;
using NanoXLSX.Interfaces;
using NanoXLSX.Interfaces.Reader;
using NanoXLSX.Registry;
using NanoXLSX.Registry.Attributes;
using NanoXLSX.Themes;
using NanoXLSX.Utils.Xml;
using IOException = NanoXLSX.Exceptions.IOException;
 
namespace NanoXLSX.Internal.Readers
{
    [NanoXlsxPlugIn(PlugInUUID = PlugInUUID.ThemeReader)]
    public class ThemeReader : IPluginBaseReader
    {
 
        private Stream stream;
 
        #region properties
        public Workbook Workbook { get; set; }
        public IOptions Options { get; set; }
        public Action<Stream, Workbook, string, IOptions, int?> InlinePluginHandler { get; set; }
        #endregion
 
        #region constructors
        internal ThemeReader()
        {
        }
        #endregion
 
        #region methods
        public void Init(Stream stream, Workbook workbook, IOptions readerOptions, Action<Stream, Workbook, string, IOptions, int?> inlinePluginHandler)
        {
            this.stream = stream;
            this.Workbook = workbook;
            this.Options = readerOptions;
            this.InlinePluginHandler = inlinePluginHandler;
        }

        public void Execute()
        {
            try
            {
                using (stream) // Close after processing
                {
                    ColorScheme colorScheme = null;
                    using (XmlReader reader = XmlReader.Create(stream, XmlStreamUtils.CreateSettings()))
                    {
                        while (reader.Read())
                        {
                            if (reader.NodeType != XmlNodeType.Element)
                            {
                                continue;
                            }
                            if (XmlStreamUtils.IsElement(reader, "theme") && colorScheme == null)
                            {
                                string themeName = reader.GetAttribute("name");
                                Workbook.WorkbookTheme = new Theme(themeName);
                                colorScheme = new ColorScheme();
                                Workbook.WorkbookTheme.Colors = colorScheme;
                            }
                            else if (XmlStreamUtils.IsElement(reader, "clrScheme") && colorScheme != null)
                            {
                                ReadClrScheme(reader, colorScheme);
                            }
                        }
                        InlinePluginHandler?.Invoke(stream, Workbook, PlugInUUID.ThemeInlineReader, Options, null);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new IOException("The XML entry could not be read from the input stream. Please see the inner exception:", ex);
            }
        }

        private static void ReadClrScheme(XmlReader reader, ColorScheme colorScheme)
        {
            colorScheme.Name = reader.GetAttribute("name") ?? string.Empty;
            using (XmlReader subtree = reader.ReadSubtree())
            {
                subtree.Read(); // consume the <clrScheme> open tag
                while (subtree.Read())
                {
                    if (subtree.NodeType != XmlNodeType.Element)
                    {
                        continue;
                    }
                    string slot = subtree.LocalName;
                    IColor color = ReadColorEntry(subtree);
                    switch (slot)
                    {
                        case "dk1":
                            colorScheme.Dark1 = color;
                            break;
                        case "lt1":
                            colorScheme.Light1 = color;
                            break;
                        case "dk2":
                            colorScheme.Dark2 = color;
                            break;
                        case "lt2":
                            colorScheme.Light2 = color;
                            break;
                        case "accent1":
                            colorScheme.Accent1 = color;
                            break;
                        case "accent2":
                            colorScheme.Accent2 = color;
                            break;
                        case "accent3":
                            colorScheme.Accent3 = color;
                            break;
                        case "accent4":
                            colorScheme.Accent4 = color;
                            break;
                        case "accent5":
                            colorScheme.Accent5 = color;
                            break;
                        case "accent6":
                            colorScheme.Accent6 = color;
                            break;
                        case "hlink":
                            colorScheme.Hyperlink = color;
                            break;
                        case "folHlink":
                            colorScheme.FollowedHyperlink = color;
                            break;
                    }
                }
            }
        }

        private static IColor ReadColorEntry(XmlReader reader)
        {
            if (reader.IsEmptyElement)
            {
                return null;
            }
            int slotDepth = reader.Depth;
            while (reader.Read())
            {
                if (reader.Depth == slotDepth)
                {
                    break; // at the slot's end element — caller's Read() moves to next sibling
                }
                if (reader.NodeType == XmlNodeType.Element)
                {
                    if (reader.LocalName.Equals("sysClr", StringComparison.OrdinalIgnoreCase))
                    {
                        string val = reader.GetAttribute("val");
                        SystemColor systemColor = new SystemColor
                        {
                            ColorValue = ParseSystemColor(val)
                        };
                        string lastColor = reader.GetAttribute("lastClr");
                        if (lastColor != null)
                        {
                            systemColor.LastColor = lastColor;
                        }
                        reader.Skip(); // advance past sysClr to the slot's end element
                        return systemColor;
                    }
                    else if (reader.LocalName.Equals("srgbClr", StringComparison.OrdinalIgnoreCase))
                    {
                        SrgbColor color = new SrgbColor
                        {
                            ColorValue = reader.GetAttribute("val")
                        };
                        reader.Skip(); // advance past srgbClr to the slot's end element
                        return color;
                    }
                }
            }
            return null;
        }

        private static SystemColor.Value ParseSystemColor(string value)
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new IOException("The system color entry was null or empty");
            }
            try
            {
                return SystemColor.MapStringToValue(value);
            }
            catch (Exception ex)
            {
                throw new IOException("The system color entry '" + value + "' could not be parsed", ex);
            }
        }
        #endregion
    }
}