C#实现仪表盘

1、仪表盘控件

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace DashboardApp
{
   
    [ToolboxBitmapAttribute(typeof(Dashboard), "Dashboard.bmp"),
    DefaultEvent("ValueInRangeChanged"),
    Description("Displays a value on an analog gauge. Raises an event if the value enters one of the definable ranges.")]
    public class Dashboard:Control
    {
   
        public Dashboard()
        {
   
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
        }

        #region enum, var, delegate, event
        public enum NeedleColorEnum
        {
   
            Gray = 0,
            Red = 1,
            Green = 2,
            Blue = 3,
            Yellow = 4,
            Violet = 5,
            Magenta = 6
        };

        private const Byte ZERO = 0;
        private const Byte NUMOFCAPS = 5;
        private const Byte NUMOFRANGES = 5;

        private Single fontBoundY1;
        private Single fontBoundY2;
        private Bitmap gaugeBitmap;
        private Boolean drawGaugeBackground = true;

        private Single m_value;
        private Boolean[] m_valueIsInRange = {
    false, false, false, false, false };
        private Byte m_CapIdx = 1;
        private Color[] m_CapColor = {
    Color.Black, Color.Black, Color.Black, Color.Black, Color.Black };
        private String[] m_CapText = {
    "", "", "", "", "" };
        private Point[] m_CapPosition = {
    new Point(10, 10), new Point(10, 10), new Point(10, 10), new Point(10, 10), new Point(10, 10) };
        private Point m_Center = new Point(100, 100);
        private Single m_MinValue = -100;
        private Single m_MaxValue = 400;

        private Color m_BaseArcColor = Color.Gray;
        private Int32 m_BaseArcRadius = 80;
        private Int32 m_BaseArcStart = 135;
        private Int32 m_BaseArcSweep = 270;
        private Int32 m_BaseArcWidth = 2;

        private Color m_ScaleLinesInterColor = Color.Black;
        private Int32 m_ScaleLinesInterInnerRadius = 73;
        private Int32 m_ScaleLinesInterOuterRadius = 80;
        private Int32 m_ScaleLinesInterWidth = 1;

        private Int32 m_ScaleLinesMinorNumOf = 9;
        private Color m_ScaleLinesMinorColor = Color.Gray;
        private Int32 m_ScaleLinesMinorInnerRadius = 75;
        private Int32 m_ScaleLinesMinorOuterRadius = 80;
        private Int32 m_ScaleLinesMinorWidth = 1;

        private Single m_ScaleLinesMajorStepValue = 50.0f;
        private Color m_ScaleLinesMajorColor = Color.Black;
        private Int32 m_ScaleLinesMajorInnerRadius = 70;
        private Int32 m_ScaleLinesMajorOuterRadius = 80;
        private Int32 m_ScaleLinesMajorWidth = 2;

        private Byte m_RangeIdx;
        private Boolean[] m_RangeEnabled = {
    true, true, false, false, false };
        private Color[] m_RangeColor = {
    Color.LightGreen, Color.Red, Color.FromKnownColor(KnownColor.Control), Color.FromKnownColor(KnownColor.Control), Color.FromKnownColor(KnownColor.Control) };
        private Single[] m_RangeStartValue = {
    -100.0f, 300.0f, 0.0f, 0.0f, 0.0f };
        private Single[] m_RangeEndValue = {
    300.0f, 400.0f, 0.0f, 0.0f, 0.0f };
        private Int32[] m_RangeInnerRadius = {
    70, 70, 70, 70, 70 };
        private Int32[] m_RangeOuterRadius = {
    80, 80, 80, 80, 80 };

        private Int32 m_ScaleNumbersRadius = 95;
        private Color m_ScaleNumbersColor = Color.Black;
        private String m_ScaleNumbersFormat;
        private Int32 m_ScaleNumbersStartScaleLine;
        private Int32 m_ScaleNumbersStepScaleLines = 1;
        private Int32 m_ScaleNumbersRotation = 0;

        private Int32 m_NeedleType = 0;
        private Int32 m_NeedleRadius = 80;
        private NeedleColorEnum m_NeedleColor1 = NeedleColorEnum.Gray;
        private Color m_NeedleColor2 = Color.DimGray;
        private Int32 m_NeedleWidth = 2;

        public class ValueInRangeChangedEventArgs : EventArgs
        {
   
            public Int32 valueInRange;

            public ValueInRangeChangedEventArgs(Int32 valueInRange)
            {
   
                this.valueInRange = valueInRange;
            }
        }

        public delegate void ValueInRangeChangedDelegate(Object sender, ValueInRangeChangedEventArgs e);
        [Description("This event is raised if the value falls into a defined range.")]
        public event ValueInRangeChangedDelegate ValueInRangeChanged;
        #endregion

        #region hidden , overridden inherited properties
        public new Boolean AllowDrop
        {
   
            get
            {
   
                return false;
            }
            set
            {
   

            }
        }
        public new Boolean AutoSize
        {
   
            get
            {
   
                return false;
            }
            set
            {
   

            }
        }
        public new Boolean ForeColor
        {
   
            get
            {
   
                return false;
            }
            set
            {
   
            }
        }
        public new Boolean ImeMode
        {
   
            get
            {
   
                return false;
            }
            set
            {
   
            }
        }

        public override System.Drawing.Color BackColor
        {
   
            get
            {
   
                return base.BackColor;
            }
            set
            {
   
                base.BackColor = value;
                drawGaugeBackground = true;
                Refresh();
            }
        }
        public override System.Drawing.Font Font
        {
   
            get
            {
   
                return base.Font;
            }
            set
            {
   
                base.Font = value;
                drawGaugeBackground = true;
                Refresh();
            }
        }
        public override System.Windows.Forms.ImageLayout BackgroundImageLayout
        {
   
            get
            {
   
                return base.BackgroundImageLayout;
            }
            set
            {
   
                base.BackgroundImageLayout = value;
                drawGaugeBackground = true;
                Refresh();
            }
        }
        #endregion

        #region properties
        [System.ComponentModel.Browsable(true),
        System.ComponentModel.Category("AGauge"),
        System.ComponentModel.Description("The value.")]
        public Single Value
        {
   
            get
            {
   
                return m_value;
            }
            set
            {
   
                if (m_value != value)
                {
   
                    m_value = Math.Min(Math.Max(value, m_MinValue), m_MaxValue);

                    if (this.DesignMode)
                    {
   
                        drawGaugeBackground = true;
                    }

                    for (Int32 counter = 0; counter < NUMOFRANGES - 1; counter++)
                    {
   
                        if ((m_RangeStartValue[counter] <= m_value)
                        && (m_value <= m_RangeEndValue[counter])
                        && (m_RangeEnabled[counter]))
                        {
   
                            if (!m_valueIsInRange[counter])
                            {
   
                                if (ValueInRangeChanged != null)
                                {
   
                                    ValueInRangeChanged(this, new ValueInRangeChangedEventArgs(counter));
                                }
                            }
                        }
                        else
                        {
   
                            m_valueIsInRange[counter] = false;
                        }
                    }
                    Refresh();
                }
            }
        }

        [System.ComponentModel.Browsable(true),
        System.ComponentModel.Category("AGauge"),
        System.ComponentModel.RefreshProperties(RefreshProperties.All),
        System.ComponentModel.Description("The caption index. set this to a value of 0 up to 4 to change the corresponding caption's properties.")]
        public Byte Cap_Idx
        {
   
            get
            {
   
                return m_CapIdx;
            }
            set
            {
   
                if ((m_CapIdx != value)
                && (0 <= value)
                && (value < 5))
                {
   
                    m_CapIdx = value;
                }
            }
        }

        [System.ComponentModel.Browsable(true),
        System.ComponentModel.Category("AGauge"),
        System.ComponentModel.Description("The color of the caption text.")]
        private Color CapColor
        {
   
            get
            {
   
                return m_CapColor[m_CapIdx];
            }
            set
            {
   
                if (m_CapColor[m_CapIdx] != value)
                {
   
                    m_CapColor[m_CapIdx] = value;
                    CapColors = m_CapColor;
                    drawGaugeBackground = true;
                    Refresh();
                }
            }
        }

        [System.ComponentModel.Browsable(false)]
        public Color[] CapColors
        {
   
            get
            {
   
                return m_CapColor;
            }
            set
            {
   
                m_CapColor = value;
            }
        }

        [System.ComponentModel.Browsable(true),
        System.ComponentModel.Category("AGauge"),
        System.ComponentModel.Description("The text of the caption.")]
        public String CapText
        {
   
            get
            {
   
                return m_CapText[m_CapIdx];
            }
            set
            {
   
                if (m_CapText[m_CapIdx] != value)
                {
   
                    m_CapText[m_CapIdx] = value;
                    CapsText = m_CapText;
                    drawGaugeBackground = true;
                    Refresh();
                }
            }
        }

        [System.ComponentModel.Browsable(false)]
        public String[] CapsText
        {
   
            get
            {
   
                return m_CapText;
            }
            set
            {
   
                for (Int32 counter = 0; counter < 5; counter++)
                {
   
                    m_CapText[counter] = value[counter];
                }
            }
        }

        [System.ComponentModel.Browsable(true),
        System.ComponentModel.Category("AGauge"),
        System.ComponentModel.Description("The position of the caption.")]
        public Point CapPosition
        {
   
            get
            {
   
                return m_CapPosition[m_CapIdx];
            }
            set
            {
   
                if (m_CapPosition[m_CapIdx] != value)
                {
   
                    m_CapPosition[m_CapIdx] = value;
                    CapsPosition = m_CapPosition;
                    drawGaugeBackground = true;
                    Refresh();
                }
            }
        }

        [System.ComponentModel.Browsable(false)]
        public Point[] CapsPosition
        {
   
            get
            {
   
                return m_CapPosition;
            }
            set
            {
   
                m_CapPosition = value;
            }
        }

        [System.ComponentModel.Browsable(true),
        System.ComponentModel.Category("AGauge"),
        System.ComponentModel.Description("The center of the gauge (in the control's client area).")]
        public Point Center
        {
   
            get
            {
   
                return m_Center;
            }
            set
            {
   
                if (m_Center != value)
                {
   
                    m_Center = value;
                    drawGaugeBackground = true;
                    Refresh();
                }
            }
        }

        [System.ComponentModel.Browsable(true),
        System.ComponentModel.Category("AGauge"),
        System.ComponentModel.Description("The minimum value to show on the scale.")]
        public Single MinValue
        {
   
            get
            {
   
                return m_MinValue;
            }
            set
            {
   
                if ((m_MinValue != value)
                && (value < m_MaxValue))
                {
   
                    m_MinValue = value;
                    drawGaugeBackground = true;
                    Refresh();
                }
            }
        }

        [System.ComponentModel.Browsable(true),
        System.ComponentModel.Category("AGauge"),
        System.ComponentModel.Description("The maximum value to show on the scale.")]
        public Single MaxValue
        {
   
            get
            {
   
                return m_MaxValue;
            }
            set
            {
   
                if ((m_MaxValue != value)
                && (value > m_MinValue))
                {
   
                    m_MaxValue = value;
                    drawGaugeBackground = true;
                    Refresh();
                }
            }
        }

        [System.ComponentModel.Browsable

你可能感兴趣的:(Winform,c#,开发语言,仪表盘)