C#winform实现像触摸屏按钮那样的开关

最新推荐文章于 2024-04-20 02:16:25 发布
最新推荐文章于 2024-04-20 02:16:25 发布
阅读量800 收藏 9
点赞数 10
分类专栏： C#上位机 文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NJJML/article/details/135220648
版权

触摸屏的按钮开发起来非常方便，只要设置好样式和文本，以及绑定的变量，一个开关就做好了。

而用winform要实现同样的功能，要编写许多代码。

花木兰控件库的ToggleButton可以这样做切换，但是有几点不方便的地方。于是修改了以下几点：

  1. 文本修改成可以换行：
    在这里插入图片描述
    文本居中且可以自动换行，而且通过修改Padding可以设置每一行显示多少个字，比如我要改成每行最多三个字：
    在这里插入图片描述
  2. 圆角修改成可以设置
    在这里插入图片描述
  3. 点击时切换文本
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    最终效果就是点击切换状态、背景和文本。
    查看按钮的状态。
private void toggleButton1_Click(object sender, EventArgs e)
{
    HML.ToggleButton btn = (HML.ToggleButton)sender;
    MessageBox.Show(btn.Checked.ToString());
}

控件库源码：添加链接描述
打开解决方案把 HML 项目里面的 ToggleButton 的代码替换成下面的代码，把HML项目重新生成，获得 HML.ComplexityPropertys.dll 和 HML.dll 文件，引入自己的项目即可。

using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace HML
{
    /// <summary>
    /// 开关按钮控件
    /// </summary>
    [Description("开关按钮控件")]
    [ToolboxItem(true)]
    [DefaultProperty("Checked")]
    [DefaultEvent("Click")]
    [TypeConverter(typeof(PropertyOrderConverter))]
    [ToolboxBitmap(typeof(ToggleButton), "Controls.ToggleButton.ToggleButton.bmp")]
    public class ToggleButton : MainThreadAnimationControl
    {
        #region 新增事件

        private static readonly object EventCheckedChanged = new object();
        /// <summary>
        /// 开关状态更改事件
        /// </summary>
        [Description("开关状态更改事件")]
        public event EventHandler CheckedChanged
        {
            add { Events.AddHandler(EventCheckedChanged, value); }
            remove { Events.RemoveHandler(EventCheckedChanged, value); }
        }

        #endregion

        #region 停用事件

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new event EventHandler RightToLeftChanged
        {
            add { base.RightToLeftChanged += value; }
            remove { base.RightToLeftChanged -= value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new event EventHandler ImeModeChanged
        {
            add { base.ImeModeChanged += value; }
            remove { base.ImeModeChanged -= value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new event EventHandler BackColorChanged
        {
            add { base.BackColorChanged += value; }
            remove { base.BackColorChanged -= value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new event EventHandler ForeColorChanged
        {
            add { base.ForeColorChanged += value; }
            remove { base.ForeColorChanged -= value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new event EventHandler BackgroundImageChanged
        {
            add { base.BackgroundImageChanged += value; }
            remove { base.BackgroundImageChanged -= value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new event EventHandler BackgroundImageLayoutChanged
        {
            add { base.BackgroundImageLayoutChanged += value; }
            remove { base.BackgroundImageLayoutChanged -= value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new event EventHandler DoubleClick
        {
            add { base.DoubleClick += value; }
            remove { base.DoubleClick -= value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new event MouseEventHandler MouseDoubleClick
        {
            add { base.MouseDoubleClick += value; }
            remove { base.MouseDoubleClick -= value; }
        }

        #endregion

        #region 新增属性
        private string textChecked="中转爪已闭合";
        /// <summary>
        /// 图标Size
        /// </summary>
        [Description("按钮Checked文本")]
        [Category("杂项")]
        [DefaultValue(typeof(string), "中转爪已闭合")]
        public string TextChecked
        {
            get { return textChecked; }
            set { textChecked = value; Invalidate(); }
        }
        private string textUnChecked = "中转爪已打开";
        /// <summary>
        /// 图标Size
        /// </summary>
        [Description("按钮UnChecked文本")]
        [Category("杂项")]
        [DefaultValue(typeof(string), "中转爪已打开")]
        public string TextUnChecked
        {
            get { return textUnChecked; }
            set { textUnChecked = value; Invalidate(); }
        }
        private int cornerRadius = 10;
        /// <summary>
        /// 图标Size
        /// </summary>
        [Description("按钮圆角角度")]
        [Category("杂项")]
        [DefaultValue(typeof(int), "10")]
        public int CornerRadius
        {
            get { return cornerRadius; }
            set { cornerRadius = value; Invalidate(); }
        }

        private float paddingLR = 30;
        /// <summary>
        /// 图标Size
        /// </summary>
        [Description("按钮左右内边距")]
        [Category("杂项")]
        [DefaultValue(typeof(float), "30")]
        public float PaddingLR
        {
            get { return paddingLR; }
            set
            {
                paddingLR = value;
                this.Invalidate();
            }
        }
        private Color activateColor = Color.White;
        /// <summary>
        /// 控件激活的虚线框颜色
        /// </summary>
        [Description("控件激活的虚线框颜色")]
        [Category("杂项")]
        [PropertyOrder(-200)]
        [DefaultValue(typeof(Color), "White")]
        public Color ActivateColor
        {
            get { return this.activateColor; }
            set
            {
                if (this.activateColor == value)
                    return;

                this.activateColor = value;
                this.Invalidate();
            }
        }

        private bool roundEnabled = true;
        /// <summary>
        /// 是否启用圆角
        /// </summary>
        [Description("是否启用圆角")]
        [Category("杂项")]
        [PropertyOrder(-198)]
        [DefaultValue(true)]
        public bool RoundEnabled
        {
            get { return this.roundEnabled; }
            set
            {
                if (this.roundEnabled == value)
                    return;

                this.roundEnabled = value;
                this.SetControlShape();
                this.Invalidate();
            }
        }

        private bool autoCheck = true;
        /// <summary>
        /// 单击时是否自动更改控件状态
        /// </summary>
        [Description("单击时是否自动更改控件状态")]
        [Category("杂项")]
        [PropertyOrder(-197)]
        [DefaultValue(true)]
        public bool AutoCheck
        {
            get { return this.autoCheck; }
            set
            {
                if (this.autoCheck == value)
                    return;

                this.autoCheck = value;
            }
        }

        private bool _Checked = false;
        /// <summary>
        /// 开关状态
        /// </summary>
        [Description("开关状态")]
        [Category("杂项")]
        [PropertyOrder(-196)]
        [DefaultValue(false)]
        public bool Checked
        {
            get { return this._Checked; }
            set
            {
                if (this._Checked == value)
                    return;

                this._Checked = value;
                this.Invalidate();

                if (!this.DesignMode)
                {
                    this.OnCheckedChanged(new EventArgs());
                }
            }
        }

        private Color backUnCheckedColor = Color.FromArgb(33, 90, 106);
        /// <summary>
        /// 背景颜色(未选中、正常)
        /// </summary>
        [Description("背景颜色(未选中、正常)")]
        [Category("杂项")]
        [PropertyOrder(-193)]
        [DefaultValue(typeof(Color), "33,90,106")]
        public Color BackUnCheckedColor
        {
            get { return this.backUnCheckedColor; }
            set
            {
                if (this.backUnCheckedColor == value)
                    return;

                this.backUnCheckedColor = value;
                this.Invalidate();
            }
        }

        private Color textUnCheckedColor = Color.White;
        /// <summary>
        /// 文本颜色(未选中、正常)
        /// </summary>
        [Description("文本颜色(未选中、正常)")]
        [Category("杂项")]
        [PropertyOrder(-192)]
        [DefaultValue(typeof(Color), "White")]
        public Color TextUnCheckedColor
        {
            get { return this.textUnCheckedColor; }
            set
            {
                if (this.textUnCheckedColor == value)
                    return;

                this.textUnCheckedColor = value;
                this.Invalidate();
            }
        }

        private Color backCheckedColor = Color.FromArgb(157, 222, 237);
        /// <summary>
        /// 背景颜色(已选中、正常)
        /// </summary>
        [Description("背景颜色(已选中、正常)")]
        [Category("杂项")]
        [PropertyOrder(-188)]
        [DefaultValue(typeof(Color), "157,222,237")]
        public Color BackCheckedColor
        {
            get { return this.backCheckedColor; }
            set
            {
                if (this.backCheckedColor == value)
                    return;

                this.backCheckedColor = value;
                this.Invalidate();
            }
        }

        private Color textCheckedColor = Color.Black;
        /// <summary>
        /// 文本颜色(已选中、正常)
        /// </summary>
        [Description("文本颜色(已选中、正常)")]
        [Category("杂项")]
        [PropertyOrder(-187)]
        [DefaultValue(typeof(Color), "White")]
        public Color TextCheckedColor
        {
            get { return this.textCheckedColor; }
            set
            {
                if (this.textCheckedColor == value)
                    return;

                this.textCheckedColor = value;
                this.Invalidate();
            }
        }

        private Color clickColor = Color.FromArgb(106, 100, 98);
        /// <summary>
        /// 背景颜色(未选中、正常)
        /// </summary>
        [Description("点击颜色")]
        [Category("杂项")]
        [PropertyOrder(-193)]
        [DefaultValue(typeof(Color), "106,100,98")]
        public Color ClickColor
        {
            get { return this.clickColor; }
            set
            {
                if (this.clickColor == value)
                    return;
                this.clickColor = value;
                this.Invalidate();
            }
        }
        #endregion

        #region 重写属性

        protected override Padding DefaultPadding
        {
            get { return new Padding(3, 3, 3, 3); }
        }

        protected override Size DefaultSize
        {
            get { return new Size(90, 24); }
        }

        //public override string Text
        //{
        //    get { return base.Text; }
        //    set
        //    {
        //        base.Text = value;
        //        this.Invalidate();
        //    }

        //}

        protected override ImeMode DefaultImeMode
        {
            get { return ImeMode.Disable; }
        }

        #endregion

        #region 停用属性
        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new string Text
        {
            get { return base.Text; }
            set { base.Text = value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new Padding Padding
        {
            get { return base.Padding; }
            set { base.Padding = value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new ImeMode ImeMode
        {
            get { return base.ImeMode; }
            set { base.ImeMode = value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override RightToLeft RightToLeft
        {
            get { return base.RightToLeft; }
            set { base.RightToLeft = value; }
        }

        [DefaultValue(typeof(Color), "Transparent")]
        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public new Color BackColor
        {
            get { return base.BackColor; }
            set { base.BackColor = value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override Color ForeColor
        {
            get { return base.ForeColor; }
            set { base.ForeColor = value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public new Image BackgroundImage
        {
            get { return base.BackgroundImage; }
            set { base.BackgroundImage = value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public new ImageLayout BackgroundImageLayout
        {
            get { return base.BackgroundImageLayout; }
            set { base.BackgroundImageLayout = value; }
        }

        #endregion

        #region 字段

        /// <summary>
        /// 鼠标按下类型
        /// </summary>
        private MouseButtons mousedowntype = MouseButtons.None;
        /// <summary>
        /// 鼠标已进入对象
        /// </summary>
        private object mouseenterobject = null;

        /// <summary>
        /// 鼠标单击动画是否进行中
        /// </summary>
        private bool animationing = false;
        /// <summary>
        /// 鼠标单击动画动画总时间
        /// </summary>
        private double animationAllTime = 250;
        /// <summary>
        /// 鼠标单击动画已使用时间
        /// </summary>
        private double animationUsedTime = 0;
        /// <summary>
        /// 鼠标单击动画圆心坐标
        /// </summary>
        private Point animationpoint = Point.Empty;

        #endregion
        StringFormat stringFormat = new StringFormat();
        public ToggleButton()
        {
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
            SetStyle(ControlStyles.ResizeRedraw, true);
            SetStyle(ControlStyles.SupportsTransparentBackColor, true);
            SetStyle(ControlStyles.StandardClick, false);//自定义单击事件逻辑
            SetStyle(ControlStyles.StandardDoubleClick, false);//停用双加事件

            this.SuspendLayout();
            this.BackColor = Color.Transparent;
            this.SetControlShape();
            this.ResumeLayout();

            stringFormat.Alignment = StringAlignment.Center;
            stringFormat.LineAlignment = StringAlignment.Center;
        }

        #region 重写

        protected override void OnScaleDpiChangedInitialize()
        {
            this.Invalidate();
        }
        GraphicsPath graphicsPath = new GraphicsPath();
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            Graphics g = e.Graphics;
            g.SmoothingMode = SmoothingMode.HighQuality;  //图片柔顺模式选择
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
            g.CompositingQuality = CompositingQuality.HighQuality;//再加一点

            graphicsPath.Reset();

            graphicsPath.AddArc(GetCornerRect1(), 270, 90);
            var points = GetLine1();
            graphicsPath.AddLine(points.Item1, points.Item2);

            graphicsPath.AddArc(GetCornerRect2(), 0, 90);
            points = GetLine2();
            graphicsPath.AddLine(points.Item1, points.Item2);

            graphicsPath.AddArc(GetCornerRect3(), 90, 90);
            points = GetLine3();
            graphicsPath.AddLine(points.Item1, points.Item2);

            graphicsPath.AddArc(GetCornerRect4(), 180, 90);
            points = GetLine4();
            graphicsPath.AddLine(points.Item1, points.Item2);
            if (_Checked == false)
            {
                g.FillPath(new SolidBrush(backUnCheckedColor), graphicsPath);
            }
            else
            {
                g.FillPath(new SolidBrush(backCheckedColor), graphicsPath);
            }

            //SolidBrush back_sb = new SolidBrush(Color.Brown);
            //if (this.animationing)//点击动画
            //{
            //    g.SmoothingMode = SmoothingMode.AntiAlias;
            //    //int animationRadius = (int)Math.Ceiling(ControlHelper.AdjustRectangleMaxRadiusForPoint(this.ClientRectangle, this.animationpoint) * this.animationUsedTime / this.animationAllTime * 10 / 8);
            //    int animationRadius = 20;
            //    back_sb.Color = ControlHelper.ConvertToAnimationColor(clickColor);
            //    g.FillEllipse(back_sb, new RectangleF(this.animationpoint.X - animationRadius, this.animationpoint.Y - animationRadius, animationRadius * 2, animationRadius * 2));
            //    g.SmoothingMode = SmoothingMode.Default;
            //}
            // 文本
            g.SmoothingMode = SmoothingMode.Default;
            SolidBrush text_sb;
            if (_Checked == false){
                text_sb = new SolidBrush(textUnCheckedColor);
            }
            else
            {
                text_sb = new SolidBrush(textCheckedColor);
            }
            if (_Checked == false)
            {
                g.DrawString(TextUnChecked, this.Font, text_sb, new RectangleF(paddingLR, 2, Width - paddingLR * 2, Height), stringFormat);
            }
            else
            {
                g.DrawString(TextChecked, this.Font, text_sb, new RectangleF(paddingLR, 2, Width - paddingLR * 2, Height), stringFormat);
            }
            text_sb.Dispose();
            

            //控件激活状态虚线框
            if (this.Focused && this.ShowFocusCues)
            {
                Pen activated_border_pen = new Pen(this.ActivateColor) { DashStyle = DashStyle.Dot, Alignment = PenAlignment.Center };
                Rectangle activated_border_rect = new Rectangle(this.ClientRectangle.X + 3, this.ClientRectangle.Y + 3, this.ClientRectangle.Width - 7, this.ClientRectangle.Height - 7);
                g.DrawRectangle(activated_border_pen, activated_border_rect);
                activated_border_pen.Dispose();
            }
        }
        /// <summary>
        /// 右上角弧线
        /// </summary>
        /// <returns></returns>
        private Rectangle GetCornerRect1()
        {
            return new Rectangle(Width - cornerRadius - 1, 1, cornerRadius, cornerRadius);
        }
        /// <summary>
        /// 右边线段
        /// </summary>
        /// <returns></returns>
        private Tuple<Point, Point> GetLine1()
        {
            return new Tuple<Point, Point>(new Point(Width - 1, cornerRadius / 2),
                new Point(Width - 1, Height - cornerRadius / 2));
        }
        /// <summary>
        /// 右下角弧线
        /// </summary>
        /// <returns></returns>
        private Rectangle GetCornerRect2()
        {
            return new Rectangle(Width - cornerRadius - 1, Height - cornerRadius - 1, cornerRadius, cornerRadius);
        }
        /// <summary>
        /// 下边线段
        /// </summary>
        /// <returns></returns>
        private Tuple<Point, Point> GetLine2()
        {
            return new Tuple<Point, Point>(new Point(cornerRadius / 2 + 1, Height - 1),
                new Point(Width - cornerRadius / 2 - 1, Height - 1));
        }
        /// <summary>
        /// 左下角弧线
        /// </summary>
        /// <returns></returns>
        private Rectangle GetCornerRect3()
        {
            return new Rectangle(1, Height - cornerRadius - 1, cornerRadius, cornerRadius);
        }
        /// <summary>
        /// 左边线段
        /// </summary>
        /// <returns></returns>
        private Tuple<Point, Point> GetLine3()
        {
            return new Tuple<Point, Point>(new Point(1, Height - cornerRadius / 2 - 1),
                new Point(1, cornerRadius / 2 + 1));
        }
        /// <summary>
        /// 左上角弧线
        /// </summary>
        /// <returns></returns>
        private Rectangle GetCornerRect4()
        {
            return new Rectangle(1, 1, cornerRadius, cornerRadius);
        }
        /// <summary>
        /// 上边线段
        /// </summary>
        /// <returns></returns>
        private Tuple<Point, Point> GetLine4()
        {
            return new Tuple<Point, Point>(
                new Point(cornerRadius / 2 + 1, 1), new Point(Width - cornerRadius / 2 - 1, 1));
        }
        protected override void OnGotFocus(EventArgs e)
        {
            base.OnGotFocus(e);

            this.Invalidate();
        }

        protected override void OnLostFocus(EventArgs e)
        {
            base.OnLostFocus(e);

            this.mousedowntype = MouseButtons.None;
            this.Invalidate();
        }

        protected override void OnEnabledChanged(EventArgs e)
        {
            base.OnEnabledChanged(e);

            if (!this.Enabled)
            {
                this.mousedowntype = MouseButtons.None;
                this.mouseenterobject = null;
                this.Invalidate();
            }
        }

        protected override void OnVisibleChanged(EventArgs e)
        {
            base.OnVisibleChanged(e);

            if (!this.Visible)
            {
                this.mousedowntype = MouseButtons.None;
                this.mouseenterobject = null;
                this.Invalidate();
            }
        }

        protected override void OnParentChanged(EventArgs e)
        {
            base.OnParentChanged(e);

            if (this.Parent == null)
            {
                this.mousedowntype = MouseButtons.None;
                this.mouseenterobject = null;
                this.Invalidate();
            }
        }

        protected override void OnMouseEnter(EventArgs e)
        {
            base.OnMouseEnter(e);

            this.mouseenterobject = this;
            this.Invalidate();
        }

        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);

            this.mouseenterobject = null;
            this.Invalidate();
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (!this.Focused)
            {
                this.Focus();
            }

            this.mousedowntype |= e.Button;

            if (e.Button == MouseButtons.Left)
            {
                this.animationing = true;
                this.animationUsedTime = 0;
                this.animationpoint = e.Location;
                MainThreadAnimationControl.AnimationStart(this);
                this.Invalidate();
            }

            base.OnMouseDown(e);
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                if (this.mousedowntype.HasFlag(MouseButtons.Left) && this.ClientRectangle.Contains(e.Location))
                {
                    this.OnClick(e);
                    this.OnMouseClick(e);
                    if (this.AutoCheck)
                    {
                        this.Checked = !this.Checked;
                    }
                }
            }
            this.mousedowntype &= ~e.Button;

            base.OnMouseUp(e);
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            switch (e.KeyData)
            {
                case Keys.Space:
                    {
                        this.animationing = true;
                        this.animationUsedTime = 0;
                        this.animationpoint = new Point(this.ClientRectangle.X + this.ClientRectangle.Width / 2, this.ClientRectangle.Y + this.ClientRectangle.Height / 2);
                        MainThreadAnimationControl.AnimationStart(this);
                        this.Invalidate();
                        break;
                    }
            }

            base.OnKeyDown(e);
        }

        protected override void OnKeyUp(KeyEventArgs e)
        {
            switch (e.KeyData)
            {
                case Keys.Space:
                    {
                        this.OnClick(EventArgs.Empty);
                        break;
                    }
            }

            base.OnKeyUp(e);
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);

            this.SetControlShape();
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                MainThreadAnimationControl.AnimationStop(this);
            }
            base.Dispose(disposing);
        }

        /// <summary>
        /// 动画控件动画中要处理的内容(不能时耗时操作)
        /// </summary>
        /// <param name="interval">动画定时器间隔时间</param>
        protected override void Animationing(int interval)
        {
            bool finish = false;
            this.animationUsedTime += interval;
            if (this.animationUsedTime > this.animationAllTime)
            {
                this.animationUsedTime = this.animationAllTime;
                MainThreadAnimationControl.AnimationStop(this);
                finish = true;
            }

            if (finish)
            {
                this.animationing = false;
                this.animationUsedTime = 0;
                this.animationpoint = Point.Empty;
            }

            this.Invalidate();
        }

        #endregion

        #region 虚方法

        protected virtual void OnCheckedChanged(EventArgs e)
        {
            EventHandler handler = Events[EventCheckedChanged] as EventHandler;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        #endregion

        #region 私有方法

        /// <summary>
        /// 设置控件形状
        /// </summary>
        private void SetControlShape()
        {
            GraphicsPath gp = new GraphicsPath();
            if (this.RoundEnabled)
            {
                gp = ControlHelper.AdjustRectangleShapePath(this.ClientRectangle);
            }
            else
            {
                gp.AddRectangle(this.ClientRectangle);
            }

            this.Region = new Region(gp);
            gp.Dispose();
        }

        /// <summary>
        /// ImageList更改后刷新控件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void RecreateImageListHandler(object sender, EventArgs e)
        {
            if (this.IsHandleCreated)
            {
                this.Invalidate();
            }
        }

        /// <summary>
        /// ImageList释放时解绑清除清除引用
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void DetachImageListHandler(object sender, EventArgs e)
        {
        }

        #endregion
    }

}
一瓶酒九块九
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#Winform实现带指示灯的按钮button
01-19
C#Winform实现带指示灯的按钮button,代码简单易懂
C# winform 实现按钮固定到菜单栏以及右键菜单
03-01
C# winform 实现按钮固定到菜单栏以及右键菜单
winform c# 触摸屏事件
09-02
winform实现窗体界面 来回滚动 通过鼠标点击事件控制panel的自动滚动条移动，实现在触摸屏上的手指拖动效果
C# 2010 win8.1 win10 触控屏 触摸屏按钮button点击范例 by Hank
11-08
触摸屏下按钮的点击范例 在WIN8.1 X64平台上成功通过过。WIN10并未测试。 C#2010版本打开。 TouchDemoByHank.rar
C#的核心问题-WIN10系统无法响应触摸屏的按下和弹起事件怎么办.rar
06-28
个人实测能使用winfrom实现兼容触摸屏的按下和弹起事件的实例，简单好用，不需要大修大改，不需要换WPF
C#Winform窗体与界面设计
08-01
本课程是针对C#Winform开发人员的基础性课程，详尽的介绍C#Winform窗体与界面的设计，通过提供实例，让C#Winform开发人员掌握相关程序设计技巧，为后面学习完整的实战课程打下较好的基础。
winform自定义控件---USwitch切换开关
weixin_41683726的博客
01-31 818
winform自定义控件---USwitch切换开关
C# Winform 开关按钮
huang714的专栏
04-15 2348
public class BzToggleButton : CheckBox { private Color onBackColor = Color.MediumSlateBlue; private Color onToggleColor = Color.WhiteSmoke; private Color offBackColor = Color.Gray; private Color offToggleColor = C...
记录[WinForm]自定义开关控件制作学习过程
cenwenjing的博客
01-17 965
记录[WinForm]自定义开关控件制作学习过程
C# Winform FlowLayoutPanel控件在触摸屏下实现内容上下翻
vivian_tsui的博客
11-15 688
【代码】C# Winform FlowLayoutPanel控件在触摸屏下实现内容上下翻。
C#中Winform 实现Ajax效果自定义按钮
08-28
主要介绍了C#中Winform 实现Ajax效果自定义按钮的相关资料,需要的朋友可以参考下
winform触摸屏事件小例子
03-29
通过鼠标点击事件控制panel的自动滚动条移动，实现在触摸屏上的手指拖动效果
Winform 调用Windows 触屏键盘 与 OSK悬浮键盘。
qq_45548183的博客
02-09 1081
C# 调用windows TabTip触屏键盘与osk悬浮键盘
触摸事件和手势(UITouch)
Arbboter的专栏
12-17 2212
概要        本章主要简示了IOS里面的触摸手势部分，触摸分为：开始触摸、移动、结束、取消，四个部分，本章主要根据这四个方法的信息监测触摸手势，按自己理解的，不知道正确的是怎么识别的，以后可以去对比对比，看和这里的方法有什么不同的地方。 结果展示 流程概要 1.因为触摸事件是逐渐向上层传递的，所以可以直接在UIView里面处理，也可以在UIViewContro
快速入门：触摸输入（使用 C#/VB/C++ 和 XAML 的 Windows 应用商店应用）
weixin_34082789的博客
07-20 210
原文 http://technet.microsoft.com/zh-cn/subscriptions/hh465387 快速入门：触摸输入（使用 C#/VB/C++ 和 XAML 的 Windows 应用商店应用）   Windows 8 设备通常具有多点触摸屏幕，从而用户可以同时使用多个手指来进行不同的输入交互，如点击、拖动或收缩。Windows 运行时具有多种处理触控输入的不同机制，从...
c# winform 模拟触发鼠标点击按钮
weixin_38582851的博客
04-17 1876
模拟触发鼠标点击winform数据表控件列点击事件。
C# WinForm UI 触摸屏按下和抬起事件处理方法
峰回路转的博客
05-13 9384
C# WinForm UI 中触摸屏按下和抬起事件处理方法思路实现方法 思路 利用WPF互操作性elementhost控件承载 System.Windows.Controls 控件，并绑定WPF控件的TouchEnterEvent 和 TouchUpEvent。 直接使用 System.Windows.Forms 系列控件操作触摸屏不好使。 实现方法 第一步：在winform窗口上增加一个ElementHost控件，命名为ElementHost1，此控件用于wpf互操作。再增加一个form button 按
采用.net framework winform开发的触摸屏演示程序
ForWhileLoop的博客
05-25 865
采用.net framework winform开发的触摸屏演示程序。【程序内容均为演示内容，如有侵权请联系本人删除】
C#语法知识之循环语句
最新发布
AMrss的博客
04-20 509
5、循环语句。
C# winform实现点击按钮变换按钮文本
05-28
您可以通过在按钮的Click事件中修改按钮的Text属性来实现点击按钮变换按钮文本的效果。具体实现步骤如下： 1.在窗体设计器中选中按钮，进入属性窗口，在“属性”选项卡中找到“Text”属性，将其初始文本设置为您需要的文本。 2.在按钮的Click事件中添加代码，通过改变按钮的Text属性来实现文本的变换。示例代码如下： ```csharp private void button1_Click(object sender, EventArgs e) { if (button1.Text == "按钮文本1") { button1.Text = "按钮文本2"; } else { button1.Text = "按钮文本1"; } } ``` 3.在上述代码中，我们判断按钮当前的文本是“按钮文本1”还是“按钮文本2”，如果是“按钮文本1”，则将按钮的文本改为“按钮文本2”；反之，将按钮的文本改为“按钮文本1”。这样，每次点击按钮，就会在“按钮文本1”和“按钮文本2”之间切换。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值