Font.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.Collections.Generic;
using System.Text;
using NanoXLSX.Colors;
using NanoXLSX.Exceptions;
 
namespace NanoXLSX.Styles
{
    public class Font : AbstractStyle
    {
        #region constants
        public static readonly float MinFontSize = 1f;

        public static readonly float MaxFontSize = 409f;

        public static readonly float DefaultFontSize = 11f;

        public static readonly string DefaultMajorFont = "Calibri Light";
        public static readonly string DefaultMinorFont = "Calibri";

        public static readonly string DefaultFontName = DefaultMinorFont;

        public static readonly FontFamilyValue DefaultFontFamily = FontFamilyValue.Swiss;

        public static readonly SchemeValue DefaultFontScheme = SchemeValue.Minor;

        public static readonly VerticalTextAlignValue DefaultVerticalAlign = VerticalTextAlignValue.None;
        #endregion
 
        #region enums
        public enum SchemeValue
        {
            Major,
            Minor,
            None,
        }

        public enum VerticalTextAlignValue
        {
            // baseline, // Maybe not used in Excel
            Subscript,
            Superscript,
            None,
        }

        public enum UnderlineValue
        {
#pragma warning disable CA1720 // Suppress: Identifiers should not contain type
            Single,
            Double,
#pragma warning restore CA1707
            SingleAccounting,
            DoubleAccounting,
            None,
        }

        public enum CharsetValue
        {
            ApplicationDefined = -1,
            ANSI = 0,
            Default = 1,
            Symbols = 2,
            Macintosh = 77,
            JIS = 128,
            Hangul = 129,
            Johab = 130,
            GBK = 134,
            Big5 = 136,
            Greek = 161,
            Turkish = 162,
            Vietnamese = 163,
            Hebrew = 177,
            Arabic = 178,
            Baltic = 186,
            Russian = 204,
            Thai = 222,
            EasternEuropean = 238,
            OEM = 255
        }

        public enum FontFamilyValue
        {
            NotApplicable = 0,
            Roman = 1,
            Swiss = 2,
            Modern = 3,
            Script = 4,
            Decorative = 5,
            Reserved1 = 6,
            Reserved2 = 7,
            Reserved3 = 8,
            Reserved4 = 9,
            Reserved5 = 10,
            Reserved6 = 11,
            Reserved7 = 12,
            Reserved8 = 13,
            Reserved9 = 14,
        }
        #endregion
 
        #region privateFields
        private float size;
        private string name = DefaultFontName;
        #endregion
 
        #region properties
 
 

        [Append]
        public bool Bold { get; set; }
        [Append]
        public bool Italic { get; set; }
        [Append]
        public bool Strike { get; set; }
        [Append]
        public UnderlineValue Underline { get; set; } = UnderlineValue.None;
        [Append]
        public bool Outline { get; set; }
        [Append]
        public bool Shadow { get; set; }

        [Append]
        public bool Condense { get; set; }
        [Append]
        public bool Extend { get; set; }

        [Append]
        public CharsetValue Charset { get; set; } = CharsetValue.Default;

        [Append]
        public Color ColorValue
        {
            get; set;
        }

        [Append]
        public FontFamilyValue Family { get; set; }
        [Append(Ignore = true)]
        public bool IsDefaultFont
        {
            get
            {
                Font temp = new Font();
                return Equals(temp);
            }
        }

        [Append]
        public string Name //OOXML: Chp.18.8.29
        {
            get { return name; }
            set
            {
                name = value;
                ValidateFontScheme();
            }
        }

        [Append]
        public SchemeValue Scheme { get; set; }
        [Append]
        public float Size
        {
            get { return size; }
            set
            {
                if (value < MinFontSize)
                { size = MinFontSize; }
                else if (value > MaxFontSize)
                { size = MaxFontSize; }
                else { size = value; }
            }
        }

        [Append]
        public VerticalTextAlignValue VerticalAlign { get; set; }
 
        #endregion
 
        #region constructors
        public Font()
        {
            size = DefaultFontSize;
            Name = DefaultFontName;
            Family = DefaultFontFamily;
            ColorValue = Color.CreateNone();// Default is none
            Scheme = DefaultFontScheme;
            VerticalAlign = DefaultVerticalAlign;
        }
        #endregion
 
        #region methods  

        private void ValidateFontScheme()
        {
            if ((string.IsNullOrEmpty(name)) && !StyleRepository.Instance.ImportInProgress)
            {
                throw new StyleException("The font name was null or empty");
            }
            if (name.Equals(DefaultMinorFont, System.StringComparison.Ordinal))
            {
                Scheme = SchemeValue.Minor;
            }
            else if (name.Equals(DefaultMajorFont, System.StringComparison.Ordinal))
            {
                Scheme = SchemeValue.Major;
            }
            else
            {
                Scheme = SchemeValue.None;
            }
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("\"Font\": {\n");
            AddPropertyAsJson(sb, "Bold", Bold);
            AddPropertyAsJson(sb, "Charset", Charset);
            AddPropertyAsJson(sb, "ColorValue", ColorValue);
            AddPropertyAsJson(sb, "VerticalAlign", VerticalAlign);
            AddPropertyAsJson(sb, "Family", Family);
            AddPropertyAsJson(sb, "Italic", Italic);
            AddPropertyAsJson(sb, "Name", Name);
            AddPropertyAsJson(sb, "Scheme", Scheme);
            AddPropertyAsJson(sb, "Size", Size);
            AddPropertyAsJson(sb, "Strike", Strike);
            AddPropertyAsJson(sb, "Underline", Underline);
            AddPropertyAsJson(sb, "Outline", Outline);
            AddPropertyAsJson(sb, "Shadow", Shadow);
            AddPropertyAsJson(sb, "Condense", Condense);
            AddPropertyAsJson(sb, "Extend", Extend);
            AddPropertyAsJson(sb, "HashCode", this.GetHashCode(), true);
            sb.Append("\n}");
            return sb.ToString();
        }

        public override AbstractStyle Copy()
        {
            Font copy = new Font
            {
                Bold = Bold,
                Charset = Charset,
                ColorValue = ColorValue,
                VerticalAlign = VerticalAlign,
                Family = Family,
                Italic = Italic,
                Name = Name,
                Scheme = Scheme,
                Size = Size,
                Strike = Strike,
                Underline = Underline,
                Outline = Outline,
                Shadow = Shadow,
                Condense = Condense,
                Extend = Extend,
            };
            return copy;
        }

        public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = -924704582;
                hashCode = hashCode * -1521134295 + size.GetHashCode();
                hashCode = hashCode * -1521134295 + Bold.GetHashCode();
                hashCode = hashCode * -1521134295 + Charset.GetHashCode();
                hashCode = hashCode * -1521134295 + EqualityComparer<Color>.Default.GetHashCode(ColorValue);
                hashCode = hashCode * -1521134295 + Family.GetHashCode();
                hashCode = hashCode * -1521134295 + Italic.GetHashCode();
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Name);
                hashCode = hashCode * -1521134295 + Scheme.GetHashCode();
                hashCode = hashCode * -1521134295 + Strike.GetHashCode();
                hashCode = hashCode * -1521134295 + Underline.GetHashCode();
                hashCode = hashCode * -1521134295 + Outline.GetHashCode();
                hashCode = hashCode * -1521134295 + Shadow.GetHashCode();
                hashCode = hashCode * -1521134295 + Condense.GetHashCode();
                hashCode = hashCode * -1521134295 + Extend.GetHashCode();
                hashCode = hashCode * -1521134295 + VerticalAlign.GetHashCode();
                return hashCode;
            }
        }

        public override bool Equals(object obj)
        {
            return obj is Font font &&
                   size == font.size &&
                   Bold == font.Bold &&
                   Italic == font.Italic &&
                   Strike == font.Strike &&
                   Underline == font.Underline &&
                   Outline == font.Outline &&
                   Shadow == font.Shadow &&
                   Condense == font.Condense &&
                   Extend == font.Extend &&
                   Charset == font.Charset &&
                   ColorValue == font.ColorValue &&
                   Family == font.Family &&
                   Name == font.Name &&
                   Scheme == font.Scheme &&
                   VerticalAlign == font.VerticalAlign;
        }

        public Font CopyFont()
        {
            return (Font)Copy();
        }
 
        #endregion
 
        #region staticMethods

        internal static string GetVerticalTextAlignName(VerticalTextAlignValue align)
        {
            string output = "";
            switch (align)
            {
                case VerticalTextAlignValue.Subscript: output = "subscript"; break;
                case VerticalTextAlignValue.Superscript: output = "superscript"; break;
            }
            return output;
        }

        internal static VerticalTextAlignValue GetVerticalTextAlignEnum(string name)
        {
            switch (name)
            {
                case "subscript": return VerticalTextAlignValue.Subscript;
                case "superscript": return VerticalTextAlignValue.Superscript;
                default:
                    return VerticalTextAlignValue.None;
            }
        }

        internal static string GetUnderlineName(UnderlineValue underline)
        {
            string output = "";
            switch (underline)
            {
                case UnderlineValue.Double: output = "double"; break;
                case UnderlineValue.SingleAccounting: output = "singleAccounting"; break;
                case UnderlineValue.DoubleAccounting: output = "doubleAccounting"; break;
            }
            return output;
        }

        internal static UnderlineValue GetUnderlineEnum(string name)
        {
            UnderlineValue output = UnderlineValue.None;
            switch (name)
            {
                case "double": output = UnderlineValue.Double; break;
                case "singleAccounting": output = UnderlineValue.SingleAccounting; break;
                case "doubleAccounting": output = UnderlineValue.DoubleAccounting; break;
            }
            return output;
        }
 
        #endregion
 
    }
}