CellXf.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.Text;
using NanoXLSX.Exceptions;
using NanoXLSX.Utils;
using FormatException = NanoXLSX.Exceptions.FormatException;
 
namespace NanoXLSX.Styles
{
    public class CellXf : AbstractStyle
    {
        #region constants
        public static readonly HorizontalAlignValue DefaultHorizontalAlignment = HorizontalAlignValue.None;
        public static readonly TextBreakValue DefaultAlignment = TextBreakValue.None;
        public static readonly TextDirectionValue DefaultTextDirection = TextDirectionValue.Horizontal;
        public static readonly VerticalAlignValue DefaultVerticalAlignment = VerticalAlignValue.None;
        #endregion
 
        #region privateFields
        private int textRotation;
        private TextDirectionValue textDirection;
        private int indent;
        #endregion
 
        #region enums
        public enum HorizontalAlignValue
        {
            Left,
            Center,
            Right,
            Fill,
            Justify,
            General,
            CenterContinuous,
            Distributed,
            None,
        }

        public enum TextBreakValue
        {
            WrapText,
            ShrinkToFit,
            None,
        }

        public enum TextDirectionValue
        {
            Horizontal,
            Vertical,
        }

        public enum VerticalAlignValue
        {
            Bottom,
            Top,
            Center,
            Justify,
            Distributed,
            None,
        }
        #endregion
 
        #region properties
        [Append]
        public bool ForceApplyAlignment { get; set; }
        [Append]
        public bool Hidden { get; set; }
        [Append]
        public HorizontalAlignValue HorizontalAlign { get; set; }
        [Append]
        public bool Locked { get; set; }
        [Append]
        public TextBreakValue Alignment { get; set; }
        [Append]
        public TextDirectionValue TextDirection
        {
            get { return textDirection; }
            set
            {
                textDirection = value;
                CalculateInternalRotation();
            }
        }

        [Append]
        public int TextRotation
        {
            get { return textRotation; }
            set
            {
                textRotation = value;
                TextDirection = TextDirectionValue.Horizontal;
                CalculateInternalRotation();
            }
        }

        [Append]
        public VerticalAlignValue VerticalAlign { get; set; }

        [Append]
        public int Indent
        {
            get => indent;
            set
            {
                if (value >= 0)
                {
                    indent = value;
                }
                else
                {
                    throw new StyleException("The indent value '" + value + "' is not valid. It must be >= 0");
                }
            }
        }
 
        #endregion
 
        #region constructors
        public CellXf()
        {
            HorizontalAlign = DefaultHorizontalAlignment;
            Alignment = DefaultAlignment;
            textDirection = DefaultTextDirection;
            VerticalAlign = DefaultVerticalAlignment;
            Locked = true; // Default in Excel
            textRotation = 0;
            Indent = 0;
        }
        #endregion
 
        #region methods
        internal int CalculateInternalRotation()
        {
            if (textRotation < -90 || textRotation > 90)
            {
                throw new FormatException("The rotation value (" + ParserUtils.ToString(textRotation) + "°) is out of range. Range is form -90° to +90°");
            }
            if (textDirection == TextDirectionValue.Vertical)
            {
                textRotation = 255;
                return textRotation;
            }
            else
            {
                if (textRotation >= 0)
                {
                    return textRotation;
                }
                else
                {
                    return (90 - textRotation);
                }
            }
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("\"StyleXF\": {\n");
            AddPropertyAsJson(sb, "HorizontalAlign", HorizontalAlign);
            AddPropertyAsJson(sb, "Alignment", Alignment);
            AddPropertyAsJson(sb, "TextDirection", TextDirection);
            AddPropertyAsJson(sb, "TextRotation", TextRotation);
            AddPropertyAsJson(sb, "VerticalAlign", VerticalAlign);
            AddPropertyAsJson(sb, "ForceApplyAlignment", ForceApplyAlignment);
            AddPropertyAsJson(sb, "Locked", Locked);
            AddPropertyAsJson(sb, "Hidden", Hidden);
            AddPropertyAsJson(sb, "Indent", Indent);
            AddPropertyAsJson(sb, "HashCode", this.GetHashCode(), true);
            sb.Append("\n}");
            return sb.ToString();
        }

        public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = 626307906;
                hashCode = hashCode * -1521134295 + ForceApplyAlignment.GetHashCode();
                hashCode = hashCode * -1521134295 + Hidden.GetHashCode();
                hashCode = hashCode * -1521134295 + HorizontalAlign.GetHashCode();
                hashCode = hashCode * -1521134295 + Locked.GetHashCode();
                hashCode = hashCode * -1521134295 + Alignment.GetHashCode();
                hashCode = hashCode * -1521134295 + TextDirection.GetHashCode();
                hashCode = hashCode * -1521134295 + TextRotation.GetHashCode();
                hashCode = hashCode * -1521134295 + VerticalAlign.GetHashCode();
                hashCode = hashCode * -1521134295 + Indent.GetHashCode();
                return hashCode;
            }
        }

        public override bool Equals(object obj)
        {
            return obj is CellXf xf &&
                   ForceApplyAlignment == xf.ForceApplyAlignment &&
                   Hidden == xf.Hidden &&
                   HorizontalAlign == xf.HorizontalAlign &&
                   Locked == xf.Locked &&
                   Alignment == xf.Alignment &&
                   TextDirection == xf.TextDirection &&
                   TextRotation == xf.TextRotation &&
                   VerticalAlign == xf.VerticalAlign &&
                   Indent == xf.Indent;
        }
 
 

        public override AbstractStyle Copy()
        {
            CellXf copy = new CellXf
            {
                HorizontalAlign = HorizontalAlign,
                Alignment = Alignment,
                TextDirection = TextDirection,
                TextRotation = TextRotation,
                VerticalAlign = VerticalAlign,
                ForceApplyAlignment = ForceApplyAlignment,
                Locked = Locked,
                Hidden = Hidden,
                Indent = Indent
            };
            return copy;
        }

        public CellXf CopyCellXf()
        {
            return (CellXf)Copy();
        }
        #endregion
 
        #region staticMethods

        internal static string GetHorizontalAlignName(HorizontalAlignValue align)
        {
            string output = "";
            switch (align)
            {
                case HorizontalAlignValue.Left: output = "left"; break;
                case HorizontalAlignValue.Center: output = "center"; break;
                case HorizontalAlignValue.Right: output = "right"; break;
                case HorizontalAlignValue.Fill: output = "fill"; break;
                case HorizontalAlignValue.Justify: output = "justify"; break;
                case HorizontalAlignValue.General: output = "general"; break;
                case HorizontalAlignValue.CenterContinuous: output = "centerContinuous"; break;
                case HorizontalAlignValue.Distributed: output = "distributed"; break;
            }
            return output;
        }

        internal static HorizontalAlignValue GetHorizontalAlignEnum(string name)
        {
            switch (name)
            {
                case "left": return HorizontalAlignValue.Left;
                case "center": return HorizontalAlignValue.Center;
                case "right": return HorizontalAlignValue.Right;
                case "fill": return HorizontalAlignValue.Fill;
                case "justify": return HorizontalAlignValue.Justify;
                case "general": return HorizontalAlignValue.General;
                case "centerContinuous": return HorizontalAlignValue.CenterContinuous;
                case "distributed": return HorizontalAlignValue.Distributed;
                default:
                    return HorizontalAlignValue.None;
            }
        }

        internal static string GetVerticalAlignName(VerticalAlignValue align)
        {
            string output = "";
            switch (align)
            {
                case VerticalAlignValue.Bottom: output = "bottom"; break;
                case VerticalAlignValue.Top: output = "top"; break;
                case VerticalAlignValue.Center: output = "center"; break;
                case VerticalAlignValue.Justify: output = "justify"; break;
                case VerticalAlignValue.Distributed: output = "distributed"; break;
            }
            return output;
        }

        internal static VerticalAlignValue GetVerticalAlignEnum(string name)
        {
            switch (name)
            {
                case "bottom": return VerticalAlignValue.Bottom;
                case "top": return VerticalAlignValue.Top;
                case "center": return VerticalAlignValue.Center;
                case "justify": return VerticalAlignValue.Justify;
                case "distributed": return VerticalAlignValue.Distributed;
                default:
                    return VerticalAlignValue.None;
            }
        }
 
        #endregion
 
    }
 
}