BasicStyles.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 NanoXLSX.Exceptions;
using NanoXLSX.Utils;
using static NanoXLSX.Styles.Border;
using static NanoXLSX.Styles.Fill;
using static NanoXLSX.Styles.Font;
using static NanoXLSX.Styles.NumberFormat;
 
namespace NanoXLSX.Styles
{
    public static class BasicStyles
    {
        #region enums
        private enum StyleEnum
        {
            bold,
            italic,
            boldItalic,
            underline,
            doubleUnderline,
            strike,
            dateFormat,
            timeFormat,
            roundFormat,
            borderFrame,
            borderFrameHeader,
            dottedFill_0_125,
            mergeCellStyle
        }
        #endregion
 
        #region staticFields
        private static Style bold;
        private static Style italic;
        private static Style boldItalic;
        private static Style underline;
        private static Style doubleUnderline;
        private static Style strike;
        private static Style dateFormat;
        private static Style timeFormat;
        private static Style roundFormat;
        private static Style borderFrame;
        private static Style borderFrameHeader;
        private static Style dottedFill_0_125;
        private static Style mergeCellStyle;
        #endregion
 
        #region staticProperties
        public static Style Bold
        { get { return GetStyle(StyleEnum.bold); } }

        public static Style BoldItalic
        { get { return GetStyle(StyleEnum.boldItalic); } }

        public static Style BorderFrame
        { get { return GetStyle(StyleEnum.borderFrame); } }

        public static Style BorderFrameHeader
        { get { return GetStyle(StyleEnum.borderFrameHeader); } }

        public static Style DateFormat
        { get { return GetStyle(StyleEnum.dateFormat); } }

        public static Style TimeFormat
        { get { return GetStyle(StyleEnum.timeFormat); } }

        public static Style DoubleUnderline
        { get { return GetStyle(StyleEnum.doubleUnderline); } }

#pragma warning disable CA1707 // Suppress: Identifiers should not contain underscores
        public static Style DottedFill_0_125
#pragma warning restore CA1707 
        { get { return GetStyle(StyleEnum.dottedFill_0_125); } }

        public static Style Italic
        { get { return GetStyle(StyleEnum.italic); } }

        public static Style MergeCellStyle
        { get { return GetStyle(StyleEnum.mergeCellStyle); } }

        public static Style RoundFormat
        { get { return GetStyle(StyleEnum.roundFormat); } }

        public static Style Strike
        { get { return GetStyle(StyleEnum.strike); } }

        public static Style Underline
        { get { return GetStyle(StyleEnum.underline); } }
        #endregion
 
        #region staticMethods
        private static Style GetStyle(StyleEnum value)
        {
            Style s = null;
            switch (value)
            {
                case StyleEnum.bold:
                    if (bold == null)
                    {
                        bold = new Style();
                        bold.CurrentFont.Bold = true;
                    }
                    s = bold;
                    break;
                case StyleEnum.italic:
                    if (italic == null)
                    {
                        italic = new Style();
                        italic.CurrentFont.Italic = true;
                    }
                    s = italic;
                    break;
                case StyleEnum.boldItalic:
                    if (boldItalic == null)
                    {
                        boldItalic = new Style();
                        boldItalic.CurrentFont.Italic = true;
                        boldItalic.CurrentFont.Bold = true;
                    }
                    s = boldItalic;
                    break;
                case StyleEnum.underline:
                    if (underline == null)
                    {
                        underline = new Style();
                        underline.CurrentFont.Underline = UnderlineValue.Single;
                    }
                    s = underline;
                    break;
                case StyleEnum.doubleUnderline:
                    if (doubleUnderline == null)
                    {
                        doubleUnderline = new Style();
                        doubleUnderline.CurrentFont.Underline = UnderlineValue.Double;
                    }
                    s = doubleUnderline;
                    break;
                case StyleEnum.strike:
                    if (strike == null)
                    {
                        strike = new Style();
                        strike.CurrentFont.Strike = true;
                    }
                    s = strike;
                    break;
                case StyleEnum.dateFormat:
                    if (dateFormat == null)
                    {
                        dateFormat = new Style();
                        dateFormat.CurrentNumberFormat.Number = FormatNumber.Format14;
                    }
                    s = dateFormat;
                    break;
                case StyleEnum.timeFormat:
                    if (timeFormat == null)
                    {
                        timeFormat = new Style();
                        timeFormat.CurrentNumberFormat.Number = FormatNumber.Format21;
                    }
                    s = timeFormat;
                    break;
                case StyleEnum.roundFormat:
                    if (roundFormat == null)
                    {
                        roundFormat = new Style();
                        roundFormat.CurrentNumberFormat.Number = FormatNumber.Format1;
                    }
                    s = roundFormat;
                    break;
                case StyleEnum.borderFrame:
                    if (borderFrame == null)
                    {
                        borderFrame = new Style();
                        borderFrame.CurrentBorder.TopStyle = StyleValue.Thin;
                        borderFrame.CurrentBorder.BottomStyle = StyleValue.Thin;
                        borderFrame.CurrentBorder.LeftStyle = StyleValue.Thin;
                        borderFrame.CurrentBorder.RightStyle = StyleValue.Thin;
                    }
                    s = borderFrame;
                    break;
                case StyleEnum.borderFrameHeader:
                    if (borderFrameHeader == null)
                    {
                        borderFrameHeader = new Style();
                        borderFrameHeader.CurrentBorder.TopStyle = StyleValue.Thin;
                        borderFrameHeader.CurrentBorder.BottomStyle = StyleValue.Medium;
                        borderFrameHeader.CurrentBorder.LeftStyle = StyleValue.Thin;
                        borderFrameHeader.CurrentBorder.RightStyle = StyleValue.Thin;
                        borderFrameHeader.CurrentFont.Bold = true;
                    }
                    s = borderFrameHeader;
                    break;
                case StyleEnum.dottedFill_0_125:
                    if (dottedFill_0_125 == null)
                    {
                        dottedFill_0_125 = new Style();
                        dottedFill_0_125.CurrentFill.PatternFill = PatternValue.Gray125;
                    }
                    s = dottedFill_0_125;
                    break;
                case StyleEnum.mergeCellStyle:
                    if (mergeCellStyle == null)
                    {
                        mergeCellStyle = new Style();
                        mergeCellStyle.CurrentCellXf.ForceApplyAlignment = true;
                    }
                    s = mergeCellStyle;
                    break;
            }
            return s.CopyStyle(); // Copy makes basic styles immutable
        }

        public static Style ColorizedText(string rgb)
        {
            Validators.ValidateColor(rgb, false);
            Style s = new Style();
            s.CurrentFont.ColorValue = ParserUtils.ToUpper("FF" + rgb);
            return s;
        }

        public static Style ColorizedBackground(string rgb)
        {
            Validators.ValidateColor(rgb, false);
            Style s = new Style();
            s.CurrentFill.SetColor(ParserUtils.ToUpper("FF" + rgb), FillType.FillColor);
 
            return s;
        }

        public static Style Font(string fontName, float fontSize = 11f, bool isBold = false, bool isItalic = false)
        {
            Style s = new Style();
            s.CurrentFont.Name = fontName;
            s.CurrentFont.Size = fontSize;
            s.CurrentFont.Bold = isBold;
            s.CurrentFont.Italic = isItalic;
            return s;
        }
        #endregion
    }
}