DotNet 4.8.1 build of DotNetBar

PROMS/DotNetBar Source Code/DevComponents.DotNetBar.SuperGrid/SuperGrid/Primitives/SymbolDef.cs

@@ -0,0 +1,476 @@
+using System;
+using System.ComponentModel;
+using System.Drawing;
+using System.Drawing.Design;
+using System.Globalization;
+using System.Windows.Forms;
+using DevComponents.DotNetBar.SuperGrid.Style;
+
+namespace DevComponents.DotNetBar.SuperGrid.Primitives
+{
+    [TypeConverter(typeof(SymbolDefConvertor))]
+    [Editor(typeof(SymbolDefEditor), typeof(UITypeEditor))]
+    public class SymbolDef : INotifyPropertyChanged, IDisposable
+    {
+        #region Private variables
+
+        private string _Symbol = "";
+        private string _SymbolRealized;
+
+        private float _SymbolSize;
+        private Color _SymbolColor = Color.Empty;
+        private eSymbolSet _SymbolSet = eSymbolSet.Awesome;
+
+        private Font _SymbolFont;
+        private Size _RealSymbolSize;
+
+        #endregion
+
+        #region Public properties
+
+        #region Symbol
+
+        /// <summary>
+        /// Indicates the displayed Symbol. Symbol setting takes precedence over Image setting.
+        /// </summary>
+        [DefaultValue(""), Category("Appearance"), Description("displayed Symbol. Symbol setting takes precedence over Image setting.")]
+        [Editor("DevComponents.DotNetBar.Design.SymbolTypeEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor))]
+        public string Symbol
+        {
+            get { return (_Symbol); }
+
+            set
+            {
+                if (value == null)
+                    value = "";
+
+                if (value != _Symbol)
+                {
+                    _Symbol = value;
+                    _SymbolRealized = null;
+
+                    OnPropertyChangedEx("Symbol");
+                }
+            }
+        }
+
+        #endregion
+
+        #region SymbolColor
+
+        /// <summary>
+        /// Gets or sets the color of the Symbol.
+        /// </summary>
+        [Category("Appearance"), Description("Indicates color of the Symbol.")]
+        public Color SymbolColor
+        {
+            get { return (_SymbolColor); }
+
+            set
+            {
+                if (_SymbolColor != value)
+                {
+                    _SymbolColor = value;
+
+                    OnPropertyChangedEx("SymbolColor", VisualChangeType.Render);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets whether property should be serialized.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        private bool ShouldSerializeSymbolColor()
+        {
+            return (_SymbolColor.IsEmpty == false);
+        }
+
+        /// <summary>
+        /// Resets property to its default value.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        private void ResetSymbolColor()
+        {
+            SymbolColor = Color.Empty;
+        }
+
+        #endregion
+
+        #region SymbolRealized
+
+        /// <summary>
+        /// Gets the realized symbol string.
+        /// </summary>
+        [Browsable(false)]
+        public string SymbolRealized
+        {
+            get
+            {
+                if (_SymbolRealized == null)
+                {
+                    if (_Symbol != null)
+                        _SymbolRealized = Symbols.GetSymbol(_Symbol);
+                }
+
+                return (_SymbolRealized);
+            }
+        }
+
+        #endregion
+
+        #region SymbolSet
+
+        /// <summary>
+        /// Gets or sets the symbol set used to represent the Symbol.
+        /// </summary>
+        [DefaultValue(eSymbolSet.Awesome)]
+        public eSymbolSet SymbolSet
+        {
+            get { return (_SymbolSet); }
+
+            set
+            {
+                if (_SymbolSet != value)
+                {
+                    _SymbolSet = value;
+
+                    _SymbolRealized = null;
+                    _SymbolFont = null;
+                    _RealSymbolSize = Size.Empty;
+
+                    OnPropertyChangedEx("SymbolSet");
+                }
+            }
+        }
+
+        #endregion
+
+        #region SymbolSize
+
+        /// <summary>
+        /// Indicates the size of the symbol in points.
+        /// </summary>
+        [DefaultValue(0f), Category("Appearance")]
+        [Description("Indicates the size of the symbol in points.")]
+        public float SymbolSize
+        {
+            get { return (_SymbolSize); }
+
+            set
+            {
+                if (value != _SymbolSize)
+                {
+                    _SymbolSize = value;
+                    _SymbolFont = null;
+                    _RealSymbolSize = Size.Empty;
+
+                    OnPropertyChangedEx("SymbolSize");
+                }
+            }
+        }
+
+        #endregion
+
+        #region IsEmpty
+
+        /// <summary>
+        /// Gets whether SymbolDef is Empty.
+        /// </summary>
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public bool IsEmpty
+        {
+            get
+            {
+                return ((string.IsNullOrEmpty(_Symbol) == true) &&
+                    (_SymbolColor.IsEmpty == true) &&
+                    (_SymbolSize == 0f));
+            }
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Internal properties
+
+        #region SymbolFont
+
+        internal Font SymbolFont
+        {
+            get
+            {
+                if (_SymbolFont == null)
+                    _SymbolFont = Symbols.GetFont(SymbolSize, SymbolSet);
+
+                return (_SymbolFont);
+            }
+
+            set
+            {
+                _SymbolFont = value;
+            }
+        }
+
+        #endregion
+
+        #region IsValidSymbol
+
+        internal bool IsValidSymbol
+        {
+            get { return (string.IsNullOrEmpty(SymbolRealized) == false); }
+        }
+
+        #endregion
+
+        #endregion
+
+        #region GetSymbolSize
+
+        internal Size GetSymbolSize(Control control)
+        {
+            if (_RealSymbolSize == Size.Empty)
+            {
+                if (control != null)
+                {
+                    Font font = SymbolFont;
+
+                    using (Graphics g = control.CreateGraphics())
+                    {
+                        Size size = g.MeasureString(SymbolRealized, font).ToSize();
+
+                        size.Width++;
+                        size.Height++;
+
+                        _RealSymbolSize = size;
+                    }
+                }
+            }
+
+            return (_RealSymbolSize);
+        }
+
+        #endregion
+
+        #region Copy
+
+        /// <summary>
+        /// Creates an exact copy of the SymbolDef.
+        /// </summary>
+        /// <returns>Copy of the SymbolDef.</returns>
+        public SymbolDef Copy()
+        {
+            SymbolDef style = new SymbolDef();
+
+            CopyTo(style);
+
+            return (style);
+        }
+
+        #endregion
+
+        #region CopyTo
+
+        /// <summary>
+        /// Returns the copy of the style.
+        /// </summary>
+        /// <returns>Copy of the style.</returns>
+        public void CopyTo(SymbolDef style)
+        {
+            style.Symbol = _Symbol;
+
+            style.SymbolColor = _SymbolColor;
+            style.SymbolSet = _SymbolSet;
+            style.SymbolSize = _SymbolSize;
+        }
+
+        #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>
+        protected virtual void OnPropertyChanged(VisualPropertyChangedEventArgs e)
+        {
+            PropertyChangedEventHandler eh = PropertyChanged;
+
+            if (eh != null)
+                eh(this, e);
+        }
+
+        /// <summary>
+        /// Raises the PropertyChanged event.
+        /// </summary>
+        /// <param name="s">Event arguments</param>
+        protected virtual void OnPropertyChangedEx(string s)
+        {
+            PropertyChangedEventHandler eh = PropertyChanged;
+
+            if (eh != null)
+            {
+                VisualPropertyChangedEventArgs e =
+                    new VisualPropertyChangedEventArgs(s);
+
+                eh(this, e);
+            }
+        }
+
+        /// <summary>
+        /// Raises the PropertyChanged event.
+        /// </summary>
+        /// <param name="s">Event arguments</param>
+        protected virtual void OnPropertyChangedEx(string s, VisualChangeType changeType)
+        {
+            PropertyChangedEventHandler eh = PropertyChanged;
+
+            if (eh != null)
+            {
+                VisualPropertyChangedEventArgs e =
+                    new VisualPropertyChangedEventArgs(s, changeType);
+
+                eh(this, e);
+            }
+        }
+
+        #endregion
+
+        #region UpdateChangeHandler
+
+        private void UpdateChangeHandler(
+            INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
+        {
+            if (oldValue != null)
+                oldValue.PropertyChanged -= StyleChanged;
+
+            if (newValue != null)
+                newValue.PropertyChanged += StyleChanged;
+        }
+
+        #endregion
+
+        #region StyleChanged
+
+        /// <summary>
+        /// StyleChanged
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        protected virtual void StyleChanged(
+            object sender, PropertyChangedEventArgs e)
+        {
+            OnPropertyChanged((VisualPropertyChangedEventArgs)e);
+        }
+
+        #endregion
+
+        #region IDisposable
+
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        public void Dispose()
+        {
+            SymbolFont = null;
+        }
+ 
+        #endregion
+    }
+
+    #region SymbolDefConvertor
+
+    ///<summary>
+    /// SymbolDefConvertor
+    ///</summary>
+    public class SymbolDefConvertor : ExpandableObjectConverter
+    {
+        /// <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))
+            {
+                SymbolDef sd = value as SymbolDef;
+
+                if (sd != null)
+                    return (sd.SymbolSet.ToString());
+            }
+
+            return (base.ConvertTo(context, culture, value, destinationType));
+        }
+    }
+
+    #endregion
+
+    #region SymbolDefEditor
+
+    ///<summary>
+    /// SymbolDefEditor
+    ///</summary>
+    public class SymbolDefEditor : UITypeEditor
+    {
+        #region GetPaintValueSupported
+
+        /// <summary>
+        /// GetPaintValueSupported
+        /// </summary>
+        /// <param name="context"></param>
+        /// <returns></returns>
+        public override bool GetPaintValueSupported(ITypeDescriptorContext context)
+        {
+            return (true);
+        }
+
+        #endregion
+
+        #region PaintValue
+
+        /// <summary>
+        /// PaintValue
+        /// </summary>
+        /// <param name="e"></param>
+        public override void PaintValue(PaintValueEventArgs e)
+        {
+            SymbolDef sd = e.Value as SymbolDef;
+
+            if (sd != null)
+            {
+                Font font = Symbols.GetFont(10, sd.SymbolSet);
+
+                Color color = sd.SymbolColor;
+
+                if (sd.SymbolColor.IsEmpty || sd.SymbolColor == Color.White)
+                    color = Color.Brown;
+
+                using (Brush br = new SolidBrush(color))
+                {
+                    using (StringFormat sf = new StringFormat())
+                    {
+                        sf.Alignment = StringAlignment.Center;
+                        sf.LineAlignment = StringAlignment.Center;
+
+                        e.Graphics.DrawString(sd.SymbolRealized, font, br, e.Bounds, sf);
+                    }
+                }
+            }
+        }
+
+        #endregion
+    }
+
+    #endregion
+}