DotNet 4.8.1 build of DotNetBar

2025-02-07 10:35:23 -05:00
parent 33439b63a0
commit 6b0a5d60f4
2609 changed files with 989814 additions and 7 deletions
--- a/Code/DevComponents.DotNetBar.Charts/Style/Thickness.cs
+++ b/Code/DevComponents.DotNetBar.Charts/Style/Thickness.cs
@@ -0,0 +1,619 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Globalization;
+
+namespace DevComponents.DotNetBar.Charts.Style
+{
+    /// <summary>
+    /// Defines Thickness class.
+    /// </summary>
+    [TypeConverter(typeof(ThicknessTypeConverter))]
+    public class Thickness : IEquatable<Thickness>, IProcessSerialElement, INotifyPropertyChanged
+    {
+        #region Static data
+
+        /// <summary>
+        /// Returns Empty instance of Thickness.
+        /// </summary>
+        public static Thickness Empty
+        {
+            get { return (new Thickness(0)); }
+        }
+
+        #endregion
+
+        #region Private variables
+
+        private int _Bottom;
+        private int _Left;
+        private int _Right;
+        private int _Top;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates new instance of the object.
+        /// </summary>
+        /// <param name="left">Left thickness in pixels.</param>
+        /// <param name="top">Top thickness in pixels.</param>
+        /// <param name="right">Right thickness in pixels.</param>
+        /// <param name="bottom">Bottom thickness in pixels.</param>
+        public Thickness(int left, int top, int right, int bottom)
+        {
+            _Left = left;
+            _Top = top;
+            _Right = right;
+            _Bottom = bottom;
+        }
+
+        /// <summary>
+        /// Creates new instance of the object.
+        /// </summary>
+        /// <param name="all">Specifies uniform Thickness.</param>
+        public Thickness(int all)
+            : this(all, all, all, all)
+        {
+        }
+
+        /// <summary>
+        /// Creates new instance of the object.
+        /// </summary>
+        public Thickness()
+        {
+        }
+
+        #endregion
+
+        #region Public properties
+
+        #region All
+
+        /// <summary>
+        /// Gets or sets the thickness of all sides
+        /// </summary>
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public int All
+        {
+            set { _Top = _Left = _Bottom = _Right = value; }
+        }
+
+        #endregion
+
+        #region Bottom
+
+        /// <summary>
+        /// Gets or sets the Bottom thickness in pixels.
+        /// </summary>
+        [DefaultValue(0)]
+        [Description("Indicates the Bottom thickness in pixels.")]
+        public int Bottom
+        {
+            get { return (_Bottom); }
+
+            set
+            {
+                if (_Bottom != value)
+                {
+                    _Bottom = value;
+
+                    OnPropertyChanged(new VisualPropertyChangedEventArgs("Bottom"));
+                }
+            }
+        }
+
+        #endregion
+
+        #region Horizontal
+
+        /// <summary>
+        /// Gets horizontal thickness (Left + Right)
+        /// </summary>
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public int Horizontal
+        {
+            get { return (_Left + _Right); }
+        }
+
+        #endregion
+
+        #region Left
+
+        /// <summary>
+        /// Gets or sets the left thickness in pixels
+        /// </summary>
+        [DefaultValue(0)]
+        [Description("Indicates the left thickness in pixels")]
+        public int Left
+        {
+            get { return (_Left); }
+
+            set
+            {
+                if (_Left != value)
+                {
+                    _Left = value;
+
+                    OnPropertyChanged(new VisualPropertyChangedEventArgs("Left"));
+                }
+            }
+        }
+
+        #endregion
+
+        #region Right
+
+        /// <summary>
+        /// Gets or sets the Right thickness in pixels
+        /// </summary>
+        [DefaultValue(0)]
+        [Description("Indicates the Right thickness in pixels")]
+        public int Right
+        {
+            get { return (_Right); }
+
+            set
+            {
+                if (_Right != value)
+                {
+                    _Right = value;
+
+                    OnPropertyChanged(new VisualPropertyChangedEventArgs("Right"));
+                }
+            }
+        }
+
+        #endregion
+
+        #region Top
+
+        /// <summary>
+        /// Gets or sets the Top thickness in pixels
+        /// </summary>
+        [DefaultValue(0)]
+        [Description("Indicates the Top thickness in pixels")]
+        public int Top
+        {
+            get { return (_Top); }
+
+            set
+            {
+                if (_Top != value)
+                {
+                    _Top = value;
+
+                    OnPropertyChanged(new VisualPropertyChangedEventArgs("Top"));
+                }
+            }
+        }
+
+        #endregion
+
+        #region Vertical
+
+        /// <summary>
+        /// Gets vertical thickness (Top + Bottom)
+        /// </summary>
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public int Vertical
+        {
+            get { return (_Top + _Bottom); }
+        }
+
+        #endregion
+
+        #region IsEmpty
+
+        /// <summary>
+        /// Gets whether the item is empty.
+        /// </summary>
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public bool IsEmpty
+        {
+            get
+            {
+                return (_Left == 0 && _Right == 0 &&
+                        _Top == 0 && _Bottom == 0);
+            }
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Internal properties
+
+        #region IsUniform
+
+        internal bool IsUniform
+        {
+            get
+            {
+                return (_Left == _Top &&
+                        _Left == _Right && _Left == _Bottom);
+            }
+        }
+
+        #endregion
+
+        #region IsZero
+
+        internal bool IsZero
+        {
+            get
+            {
+                return (_Left == 0 && _Top == 0 &&
+                        _Right == 0 && _Bottom == 0);
+            }
+        }
+
+        #endregion
+
+        #region Size
+
+        internal Size Size
+        {
+            get { return (new Size(_Left + _Right, _Top + _Bottom)); }
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Equals
+
+        /// <summary>
+        /// Gets whether two instances are equal.
+        /// </summary>
+        /// <param name="obj">Instance to compare to.</param>
+        /// <returns>true if equal otherwise false.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is Thickness)
+                return (this == (Thickness)obj);
+
+            return (false);
+        }
+
+        /// <summary>
+        /// Gets whether two instances are equal.
+        /// </summary>
+        /// <param name="thickness">Instance to compare to</param>
+        /// <returns>true if equal otherwise false</returns>
+        public bool Equals(Thickness thickness)
+        {
+            return (this == thickness);
+        }
+
+        #endregion
+
+        #region GetHashCode
+
+        /// <summary>
+        /// Returns hash-code.
+        /// </summary>
+        /// <returns>hash-code</returns>
+        public override int GetHashCode()
+        {
+            return (((_Left.GetHashCode() ^ _Top.GetHashCode()) ^
+                     _Right.GetHashCode()) ^ _Bottom.GetHashCode());
+        }
+
+        #endregion
+
+        #region Operators
+
+        #region "==" operator
+
+        /// <summary>
+        /// Implements == operator.
+        /// </summary>
+        /// <param name="t1">Object 1</param>
+        /// <param name="t2">Object 2</param>
+        /// <returns>true if equals</returns>
+        public static bool operator ==(Thickness t1, Thickness t2)
+        {
+            if (ReferenceEquals(t1, t2))
+                return (true);
+
+            if (((object)t1 == null) || ((object)t2 == null))
+                return (false);
+
+            return (t1._Left == t2._Left && t1._Right == t2._Right &&
+                    t1._Top == t2._Top && t1._Bottom == t2._Bottom);
+        }
+
+        #endregion
+
+        #region "!=" operator
+
+        /// <summary>
+        /// Implements != operator
+        /// </summary>
+        /// <param name="t1">Object 1</param>
+        /// <param name="t2">Object 2</param>
+        /// <returns>true if different</returns>
+        public static bool operator !=(Thickness t1, Thickness t2)
+        {
+            return ((t1 == t2) == false);
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Copy
+
+        /// <summary>
+        /// Creates an exact copy of the Thickness.
+        /// </summary>
+        /// <returns>Copy of the Thickness.</returns>
+        public Thickness Copy()
+        {
+            Thickness copy = new Thickness(_Left, _Top, _Right, _Bottom);
+
+            return (copy);
+        }
+
+        #endregion
+
+        #region GetSerialData
+
+        internal virtual SerialElementCollection GetSerialData(string name)
+        {
+            SerialElementCollection sec = new SerialElementCollection();
+
+            sec.AddStartElement(name);
+
+            if (IsUniform == true)
+            {
+                sec.AddValue("All", Left, 0);
+            }
+            else
+            {
+                sec.AddValue("Left", Left, 0);
+                sec.AddValue("Top", Top, 0);
+                sec.AddValue("Right", Right, 0);
+                sec.AddValue("Bottom", Bottom, 0);
+            }
+
+            sec.AddEndElement(name);
+
+            return (sec);
+        }
+
+        #endregion
+
+        #region PutSerialData
+
+        #region ProcessValue
+
+        void IProcessSerialElement.ProcessValue(SerialElement se)
+        {
+            ProcessValue(se);
+        }
+
+        internal virtual void ProcessValue(SerialElement se)
+        {
+            switch (se.Name)
+            {
+                case "All":
+                    All = int.Parse(se.StringValue);
+                    break;
+
+                case "Left":
+                    Left = int.Parse(se.StringValue);
+                    break;
+
+                case "Top":
+                    Top = int.Parse(se.StringValue);
+                    break;
+
+                case "Right":
+                    Right = int.Parse(se.StringValue);
+                    break;
+
+                case "Bottom":
+                    Bottom = int.Parse(se.StringValue);
+                    break;
+
+                default:
+                    throw new Exception("Unknown Serial Value (" + se.Name + ")");
+            }
+        }
+
+        #endregion
+
+        #region ProcessCollection
+
+        void IProcessSerialElement.ProcessCollection(SerialElement se)
+        {
+            throw new Exception("Unknown Serial Collection (" + se.Name + ")");
+        }
+
+        #endregion
+
+        #endregion
+
+        #region INotifyPropertyChanged Members
+
+        /// <summary>
+        /// Occurs when property value has changed.
+        /// </summary>
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        /// <summary>
+        /// Raises the PropertyChanged event.
+        /// </summary>
+        /// <param name="e">Event arguments</param>
+        void OnPropertyChanged(VisualPropertyChangedEventArgs e)
+        {
+            PropertyChangedEventHandler eh = PropertyChanged;
+
+            if (eh != null)
+                eh(this, e);
+        }
+
+        #endregion
+    }
+
+    #region ThicknessTypeConverter
+
+    ///<summary>
+    /// ThicknessTypeConverter
+    ///</summary>
+    public class ThicknessTypeConverter : ExpandableObjectConverter
+    {
+        #region CanConvertTo
+
+        /// <summary>
+        /// CanConvertTo
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="destinationType"></param>
+        /// <returns></returns>
+        public override bool CanConvertTo(
+            ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(string))
+                return (true);
+
+            return (base.CanConvertTo(context, destinationType));
+        }
+
+        #endregion
+
+        #region ConvertTo
+
+        /// <summary>
+        /// ConvertTo
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="culture"></param>
+        /// <param name="value"></param>
+        /// <param name="destinationType"></param>
+        /// <returns></returns>
+        public override object ConvertTo(
+            ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            if (destinationType == typeof(string))
+            {
+                Thickness t = value as Thickness;
+
+                if (t != null)
+                {
+                    if (t.IsUniform == true)
+                        return (t.Left.ToString());
+
+                    return (String.Format("{0:d}, {1:d}, {2:d}, {3:d}",
+                        t.Bottom, t.Left, t.Right, t.Top));
+                }
+            }
+
+            return (base.ConvertTo(context, culture, value, destinationType));
+        }
+
+        #endregion
+
+        #region CanConvertFrom
+
+        /// <summary>
+        /// CanConvertFrom
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="sourceType"></param>
+        /// <returns></returns>
+        public override bool CanConvertFrom(
+            ITypeDescriptorContext context, Type sourceType)
+        {
+            if (sourceType == typeof(string))
+                return (true);
+
+            return (base.CanConvertFrom(context, sourceType));
+        }
+
+        #endregion
+
+        #region ConvertFrom
+
+        /// <summary>
+        /// ConvertFrom
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="culture"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public override object ConvertFrom(
+            ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            if (value is string)
+            {
+                string[] values = ((string)value).Split(',');
+
+                if (values.Length != 1 && values.Length != 4)
+                    throw new ArgumentException("Invalid value to convert.");
+
+                try
+                {
+                    int[] v = new int[values.Length];
+
+                    for (int i = 0; i < values.Length; i++)
+                        v[i] = int.Parse(values[i]);
+
+                    Thickness t = (values.Length == 1)
+                        ? new Thickness(v[0])
+                        : new Thickness(v[1], v[3], v[2], v[0]);
+
+                    return (t);
+                }
+                catch (Exception)
+                {
+                    throw new ArgumentException("Invalid value to convert.");
+                }
+            }
+
+            return base.ConvertFrom(context, culture, value);
+        }
+
+        #endregion
+
+        #region GetCreateInstanceSupported
+
+        /// <summary>
+        /// GetCreateInstanceSupported
+        /// </summary>
+        /// <param name="context"></param>
+        /// <returns></returns>
+        public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
+        {
+            return (true);
+        }
+
+        #endregion
+
+        #region CreateInstance
+
+        /// <summary>
+        /// CreateInstance
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="propertyValues"></param>
+        /// <returns></returns>
+        public override object CreateInstance(
+            ITypeDescriptorContext context, IDictionary propertyValues)
+        {
+            return (new Thickness((int)propertyValues["Left"], (int)propertyValues["Top"],
+                (int)propertyValues["Right"], (int)propertyValues["Bottom"]));
+        }
+
+        #endregion
+    }
+
+    #endregion
+}