StyleManager.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 © 2025
 * 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.Collections.Generic;
 
namespace NanoXLSX.Styles
{
    internal class StyleManager
    {
        #region privateFields
        private List<AbstractStyle> borders;
        private List<AbstractStyle> cellXfs;
        private List<AbstractStyle> fills;
        private List<AbstractStyle> fonts;
        private List<AbstractStyle> numberFormats;
        private List<AbstractStyle> styles;
        #endregion
 
        #region constructors
        public StyleManager()
        {
            borders = new List<AbstractStyle>();
            cellXfs = new List<AbstractStyle>();
            fills = new List<AbstractStyle>();
            fonts = new List<AbstractStyle>();
            numberFormats = new List<AbstractStyle>();
            styles = new List<AbstractStyle>();
        }
        #endregion
 
        #region methods

        private static AbstractStyle GetComponentByHash(ref List<AbstractStyle> list, int hash)
        {
            int len = list.Count;
            for (int i = 0; i < len; i++)
            {
                if (list[i].GetHashCode() == hash)
                {
                    return list[i];
                }
            }
            return null;
        }

        public Border[] GetBorders()
        {
            return Array.ConvertAll(borders.ToArray(), x => (Border)x);
        }

        public int GetBorderStyleNumber()
        {
            return borders.Count;
        }
 
 
 
        /* ****************************** */

        public Fill[] GetFills()
        {
            return Array.ConvertAll(fills.ToArray(), x => (Fill)x);
        }

        public int GetFillStyleNumber()
        {
            return fills.Count;
        }
 
        /* ****************************** */

        public Font[] GetFonts()
        {
            return Array.ConvertAll(fonts.ToArray(), x => (Font)x);
        }

        public int GetFontStyleNumber()
        {
            return fonts.Count;
        }
 
        /* ****************************** */

        public NumberFormat[] GetNumberFormats()
        {
            return Array.ConvertAll(numberFormats.ToArray(), x => (NumberFormat)x);
        }

        public int GetNumberFormatStyleNumber()
        {
            return numberFormats.Count;
        }
 
        /* ****************************** */

        public Style[] GetStyles()
        {
            return Array.ConvertAll(styles.ToArray(), x => (Style)x);
        }

        public int GetStyleNumber()
        {
            return styles.Count;
        }
 
        /* ****************************** */
 

        public Style AddStyle(Style style)
        {
            int hash = AddStyleComponent(style);
            return (Style)GetComponentByHash(ref styles, hash);
        }

        private int AddStyleComponent(AbstractStyle style, int? id)
        {
            style.InternalID = id;
            return AddStyleComponent(style);
        }

        private int AddStyleComponent(AbstractStyle style)
        {
            int hash = style.GetHashCode();
            if (style.GetType() == typeof(Border))
            {
                if (GetComponentByHash(ref borders, hash) == null)
                { borders.Add(style); }
                Reorganize(ref borders);
            }
            else if (style.GetType() == typeof(CellXf))
            {
                if (GetComponentByHash(ref cellXfs, hash) == null)
                { cellXfs.Add(style); }
                Reorganize(ref cellXfs);
            }
            else if (style.GetType() == typeof(Fill))
            {
                if (GetComponentByHash(ref fills, hash) == null)
                { fills.Add(style); }
                Reorganize(ref fills);
            }
            else if (style.GetType() == typeof(Font))
            {
                if (GetComponentByHash(ref fonts, hash) == null)
                { fonts.Add(style); }
                Reorganize(ref fonts);
            }
            else if (style.GetType() == typeof(NumberFormat))
            {
                if (GetComponentByHash(ref numberFormats, hash) == null)
                { numberFormats.Add(style); }
                Reorganize(ref numberFormats);
            }
            else if (style.GetType() == typeof(Style))
            {
                Style s = (Style)style;
                if (GetComponentByHash(ref styles, hash) == null)
                {
                    int? id;
                    if (!s.InternalID.HasValue)
                    {
                        id = int.MaxValue;
                        s.InternalID = id;
                    }
                    else
                    {
                        id = s.InternalID.Value;
                    }
                    int temp = AddStyleComponent(s.CurrentBorder, id);
                    s.CurrentBorder = (Border)GetComponentByHash(ref borders, temp);
                    temp = AddStyleComponent(s.CurrentCellXf, id);
                    s.CurrentCellXf = (CellXf)GetComponentByHash(ref cellXfs, temp);
                    temp = AddStyleComponent(s.CurrentFill, id);
                    s.CurrentFill = (Fill)GetComponentByHash(ref fills, temp);
                    temp = AddStyleComponent(s.CurrentFont, id);
                    s.CurrentFont = (Font)GetComponentByHash(ref fonts, temp);
                    temp = AddStyleComponent(s.CurrentNumberFormat, id);
                    s.CurrentNumberFormat = (NumberFormat)GetComponentByHash(ref numberFormats, temp);
                    styles.Add(s);
                }
                Reorganize(ref styles);
                hash = s.GetHashCode();
            }
            return hash;
        }

        internal static StyleManager GetManagedStyles(Workbook workbook)
        {
            StyleManager styleManager = new StyleManager();
            styleManager.AddStyle(new Style("default", 0, true));
            Style borderStyle = new Style("default_border_style", 1, true)
            {
                CurrentBorder = BasicStyles.DottedFill_0_125.CurrentBorder,
                CurrentFill = BasicStyles.DottedFill_0_125.CurrentFill
            };
            styleManager.AddStyle(borderStyle);
 
            for (int i = 0; i < workbook.Worksheets.Count; i++)
            {
                foreach (KeyValuePair<string, Cell> cell in workbook.Worksheets[i].Cells)
                {
                    if (cell.Value.CellStyle != null)
                    {
                        Style resolvedStyle = styleManager.AddStyle(cell.Value.CellStyle);
                        workbook.Worksheets[i].Cells[cell.Key].SetStyle(resolvedStyle, true);
                    }
                }
                foreach (KeyValuePair<int, Column> column in workbook.Worksheets[i].Columns)
                {
                    if (column.Value.DefaultColumnStyle != null)
                    {
                        Style resolvedStyle = styleManager.AddStyle(column.Value.DefaultColumnStyle);
                        workbook.Worksheets[i].Columns[column.Key].SetDefaultColumnStyle(resolvedStyle, true);
                    }
                }
            }
            return styleManager;
        }

        private static void Reorganize(ref List<AbstractStyle> list)
        {
            int len = list.Count;
            list.Sort();
            int id = 0;
            for (int i = 0; i < len; i++)
            {
                list[i].InternalID = id;
                id++;
            }
        }
        #endregion
    }
 
}