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.ComponentModel;
using System.Text;
using NanoXLSX.Colors;
using NanoXLSX.Interfaces;
 
namespace NanoXLSX.Styles
{
    public class Fill : AbstractStyle
    {
        #region constants
        public static readonly Color DefaultColor = Color.CreateRgb(SrgbColor.DefaultSrgbColor);
        public static readonly Color DefaultIndexedColor = Color.CreateIndexed(IndexedColor.DefaultIndexedColor);
        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 Color backgroundColor = DefaultColor;
        private Color foregroundColor = DefaultColor;
        #endregion
 
        #region properties
        [Append]
        public Color BackgroundColor
        {
            get => backgroundColor;
            set
            {
                backgroundColor = value;
                if (PatternFill == PatternValue.None)
                {
                    PatternFill = PatternValue.Solid;
                }
            }
        }

        [Append]
        public Color ForegroundColor
        {
            get => foregroundColor;
            set
            {
                foregroundColor = value;
                if (PatternFill == PatternValue.None)
                {
                    PatternFill = PatternValue.Solid;
                }
            }
        }

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

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

        public Fill(string value, FillType fillType)
        {
            if (fillType == FillType.FillColor)
            {
                backgroundColor = DefaultColor;
                ForegroundColor = Color.CreateRgb(value);
            }
            else
            {
                BackgroundColor = Color.CreateRgb(value);
                foregroundColor = DefaultColor;
            }
            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, "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,
                PatternFill = PatternFill
            };
            return copy;
        }

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

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

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

        public void SetColor(string value, FillType fillType)
        {
            if (fillType == FillType.FillColor)
            {
                backgroundColor = DefaultColor;
                ForegroundColor = Color.CreateRgb(value);
            }
            else
            {
                BackgroundColor = Color.CreateRgb(value);
                foregroundColor = DefaultColor;
            }
            PatternFill = PatternValue.Solid;
        }

        public void SetColor(Color value, FillType fillType)
        {
            if (fillType == FillType.FillColor)
            {
                backgroundColor = DefaultColor;
                ForegroundColor = value;
            }
            else
            {
                BackgroundColor = value;
                foregroundColor = DefaultColor;
            }
            PatternFill = PatternValue.Solid;
        }

        public void SetColor(IColor value, FillType fillType)
        {
            SetColor(GetColorByComponent(value), fillType);
        }
        #endregion
 
        #region staticMethods
        public static implicit operator Fill(string value)
        {
            return new Fill(value, FillType.FillColor);
        }

        public static implicit operator Fill(IndexedColor.Value index)
        {
            Fill fill = new Fill();
            fill.PatternFill = PatternValue.Solid;
            fill.ForegroundColor = Color.CreateIndexed(index);
            return fill;
        }

        public static implicit operator Fill(int index)
        {
            Fill fill = new Fill();
            fill.PatternFill = PatternValue.Solid;
            fill.ForegroundColor = Color.CreateIndexed(index);
            return fill;
        }
 

        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;
            }
        }

        private static Color GetColorByComponent(IColor component)
        {
            if (component is SrgbColor)
            {
                return Color.CreateRgb((SrgbColor)component);
            }
            else if (component is IndexedColor)
            {
                return Color.CreateIndexed((IndexedColor)component);
            }
            else if (component is ThemeColor)
            {
                return Color.CreateTheme((ThemeColor)component);
            }
            else if (component is SystemColor)
            {
                return Color.CreateSystem((SystemColor)component);
            }
            else // AutoColor
            {
                return Color.CreateAuto();
            }
        }
        #endregion
 
    }
}