Fill.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.Utils;
 
namespace NanoXLSX.Styles
{
    public class Fill : AbstractStyle
    {
        #region constants
        public static readonly string DefaultColor = "FF000000";
        public static readonly int DefaultIndexedColor = 64;
        public static readonly PatternValue DefaultPatternFill = PatternValue.None;
 
        #endregion
 
        #region enums
        public enum FillType
        {
            PatternColor,
            FillColor,
        }

        public enum PatternValue
        {
            None,
            Solid,
            DarkGray,
            MediumGray,
            LightGray,
            Gray0625,
            Gray125,
        }
        #endregion
 
        #region privateFields
        private string backgroundColor = DefaultColor;
        private string foregroundColor = DefaultColor;
        #endregion
 
        #region properties
        [Append]
        public string BackgroundColor
        {
            get => backgroundColor;
            set
            {
                Validators.ValidateColor(value, true);
                backgroundColor = ParserUtils.ToUpper(value);
                if (PatternFill == PatternValue.None)
                {
                    PatternFill = PatternValue.Solid;
                }
            }
        }

        [Append]
        public string ForegroundColor
        {
            get => foregroundColor;
            set
            {
                Validators.ValidateColor(value, true);
                foregroundColor = ParserUtils.ToUpper(value);
                if (PatternFill == PatternValue.None)
                {
                    PatternFill = PatternValue.Solid;
                }
            }
        }

        [Append]
        public int IndexedColor { get; set; }
        [Append]
        public PatternValue PatternFill { get; set; }
        #endregion
 
        #region constructors
        public Fill()
        {
            IndexedColor = DefaultIndexedColor;
            PatternFill = DefaultPatternFill;
            foregroundColor = DefaultColor;
            backgroundColor = DefaultColor;
        }

        public Fill(string foreground, string background)
        {
            BackgroundColor = background;
            ForegroundColor = foreground;
            IndexedColor = DefaultIndexedColor;
            PatternFill = PatternValue.Solid;
        }

        public Fill(string value, FillType fillType)
        {
            if (fillType == FillType.FillColor)
            {
                backgroundColor = DefaultColor;
                ForegroundColor = value;
            }
            else
            {
                BackgroundColor = value;
                foregroundColor = DefaultColor;
            }
            IndexedColor = DefaultIndexedColor;
            PatternFill = PatternValue.Solid;
        }
        #endregion
 
        #region methods

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("\"Fill\": {\n");
            AddPropertyAsJson(sb, "BackgroundColor", BackgroundColor);
            AddPropertyAsJson(sb, "ForegroundColor", ForegroundColor);
            AddPropertyAsJson(sb, "IndexedColor", IndexedColor);
            AddPropertyAsJson(sb, "PatternFill", PatternFill);
            AddPropertyAsJson(sb, "HashCode", this.GetHashCode(), true);
            sb.Append("\n}");
            return sb.ToString();
        }

        public override AbstractStyle Copy()
        {
            Fill copy = new Fill
            {
                BackgroundColor = BackgroundColor,
                ForegroundColor = ForegroundColor,
                IndexedColor = IndexedColor,
                PatternFill = PatternFill
            };
            return copy;
        }

        public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = -1564173520;
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(BackgroundColor);
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(ForegroundColor);
                hashCode = hashCode * -1521134295 + IndexedColor.GetHashCode();
                hashCode = hashCode * -1521134295 + PatternFill.GetHashCode();
                return hashCode;
            }
        }

        public override bool Equals(object obj)
        {
            return obj is Fill fill &&
                   BackgroundColor == fill.BackgroundColor &&
                   ForegroundColor == fill.ForegroundColor &&
                   IndexedColor == fill.IndexedColor &&
                   PatternFill == fill.PatternFill;
        }

        public Fill CopyFill()
        {
            return (Fill)Copy();
        }

        public void SetColor(string value, FillType fillType)
        {
            if (fillType == FillType.FillColor)
            {
                backgroundColor = DefaultColor;
                ForegroundColor = value;
            }
            else
            {
                BackgroundColor = value;
                foregroundColor = DefaultColor;
            }
            PatternFill = PatternValue.Solid;
        }
        #endregion
 
        #region staticMethods
        internal static string GetPatternName(PatternValue pattern)
        {
            string output;
            switch (pattern)
            {
                case PatternValue.Solid:
                    output = "solid";
                    break;
                case PatternValue.DarkGray:
                    output = "darkGray";
                    break;
                case PatternValue.MediumGray:
                    output = "mediumGray";
                    break;
                case PatternValue.LightGray:
                    output = "lightGray";
                    break;
                case PatternValue.Gray0625:
                    output = "gray0625";
                    break;
                case PatternValue.Gray125:
                    output = "gray125";
                    break;
                default:
                    output = "none";
                    break;
            }
            return output;
        }

        internal static PatternValue GetPatternEnum(string name)
        {
            switch (name)
            {
                case "none": return PatternValue.None;
                case "solid": return PatternValue.Solid;
                case "darkGray": return PatternValue.DarkGray;
                case "mediumGray": return PatternValue.MediumGray;
                case "lightGray": return PatternValue.LightGray;
                case "gray0625": return PatternValue.Gray0625;
                case "gray125": return PatternValue.Gray125;
                default:
                    return PatternValue.None;
            }
        }
 
        #endregion
 
    }
}