[转]下拉按钮 C#_Winform 自定义控件

最新推荐文章于 2023-11-13 10:54:17 发布
最新推荐文章于 2023-11-13 10:54:17 发布
阅读量167 收藏
点赞数
原文链接：http://www.cnblogs.com/z5337/p/3758621.html
版权 
using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace SplitButtonDemo
{
    public class SplitButton : Button
    {
        #region Fields

        private bool _DoubleClickedEnabled;

        private bool _AlwaysDropDown;
        private bool _AlwaysHoverChange;

        private bool _CalculateSplitRect = true;
        private bool _FillSplitHeight = true;
        private int _SplitHeight;
        private int _SplitWidth;

        private String _NormalImage;
        private String _HoverImage;
        private String _ClickedImage;
        private String _DisabledImage;
        private String _FocusedImage;

        private ImageList _DefaultSplitImages;


        [Browsable(true)]
        [Category("Action")]
        [Description("Occurs when the button part of the SplitButton is clicked.")]
        public event EventHandler ButtonClick;

        [Browsable(true)]
        [Category("Action")]
        [Description("Occurs when the button part of the SplitButton is clicked.")]
        public event EventHandler ButtonDoubleClick;

        #endregion


        #region Properties
        /// <summary>
        /// 
        /// </summary>
        [Category("Behavior")]
        [Description("Indicates whether the double click event is raised on the SplitButton")]
        [DefaultValue(false)]
        public bool DoubleClickedEnabled
        {
            get
            {
                return _DoubleClickedEnabled;
            }
            set
            {
                _DoubleClickedEnabled = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button")]
        [Description("Indicates whether the SplitButton always shows the drop down menu even if the button part of the SplitButton is clicked.")]
        [DefaultValue(false)]
        public bool AlwaysDropDown
        {
            get
            {
                return _AlwaysDropDown;
            }
            set
            {
                _AlwaysDropDown = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button")]
        [Description("Indicates whether the SplitButton always shows the Hover image status in the split part even if the button part of the SplitButton is hovered.")]
        [DefaultValue(false)]
        public bool AlwaysHoverChange
        {
            get
            {
                return _AlwaysHoverChange;
            }
            set
            {
                _AlwaysHoverChange = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button")]
        [Description("Indicates whether the split rectange must be calculated (basing on Split image size)")]
        [DefaultValue(true)]
        public bool CalculateSplitRect
        {
            get
            {
                return _CalculateSplitRect;
            }
            set
            {
                bool flag1 = _CalculateSplitRect;

                _CalculateSplitRect = value;

                if (flag1 != _CalculateSplitRect)
                {
                    if (_SplitWidth > 0 && _SplitHeight > 0)
                    {
                        InitDefaultSplitImages(true);
                    }
                }
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [fill split height].
        /// </summary>
        /// <value><c>true</c> if [fill split height]; otherwise, <c>false</c>.</value>
        [Category("Split Button")]
        [Description("Indicates whether the split height must be filled to the button height even if the split image height is lower.")]
        [DefaultValue(true)]
        public bool FillSplitHeight
        {
            get
            {
                return _FillSplitHeight;
            }
            set
            {
                _FillSplitHeight = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button")]
        [Description("The split height (ignored if CalculateSplitRect is setted to true).")]
        [DefaultValue(0)]
        public int SplitHeight
        {
            get
            {
                return _SplitHeight;
            }
            set
            {
                _SplitHeight = value;

                if (!_CalculateSplitRect)
                {
                    if (_SplitWidth > 0 && _SplitHeight > 0)
                    {
                        InitDefaultSplitImages(true);
                    }
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button")]
        [Description("The split width (ignored if CalculateSplitRect is setted to true).")]
        [DefaultValue(0)]
        public int SplitWidth
        {
            get
            {
                return _SplitWidth;
            }
            set
            {
                _SplitWidth = value;

                if (!_CalculateSplitRect)
                {
                    if (_SplitWidth > 0 && _SplitHeight > 0)
                    {
                        InitDefaultSplitImages(true);
                    }
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button Images")]
        [Description("The Normal status image name in the ImageList.")]
        [DefaultValue("")]
        [Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), Localizable(true), RefreshProperties(RefreshProperties.Repaint), TypeConverter(typeof(ImageKeyConverter))]
        public String NormalImage
        {
            get
            {
                return _NormalImage;
            }
            set
            {
                _NormalImage = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button Images")]
        [Description("The Hover status image name in the ImageList.")]
        [DefaultValue("")]
        [Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), Localizable(true), RefreshProperties(RefreshProperties.Repaint), TypeConverter(typeof(ImageKeyConverter))]
        public String HoverImage
        {
            get
            {
                return _HoverImage;
            }
            set
            {
                _HoverImage = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button Images")]
        [Description("The Clicked status image name in the ImageList.")]
        [DefaultValue("")]
        [Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), Localizable(true), RefreshProperties(RefreshProperties.Repaint), TypeConverter(typeof(ImageKeyConverter))]
        public String ClickedImage
        {
            get
            {
                return _ClickedImage;
            }
            set
            {
                _ClickedImage = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button Images")]
        [Description("The Disabled status image name in the ImageList.")]
        [DefaultValue("")]
        [Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), Localizable(true), RefreshProperties(RefreshProperties.Repaint), TypeConverter(typeof(ImageKeyConverter))]
        public String DisabledImage
        {
            get
            {
                return _DisabledImage;
            }
            set
            {
                _DisabledImage = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        [Category("Split Button Images")]
        [Description("The Focused status image name in the ImageList.")]
        [DefaultValue("")]
        [Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), Localizable(true), RefreshProperties(RefreshProperties.Repaint), TypeConverter(typeof(ImageKeyConverter))]
        public String FocusedImage
        {
            get
            {
                return _FocusedImage;
            }
            set
            {
                _FocusedImage = value;
            }
        }

        #endregion


        #region Construction

        public SplitButton()
        {
            InitializeComponent();
        }

        #endregion


        #region Methods

        protected override void OnCreateControl()
        {
            InitDefaultSplitImages();

            if (this.ImageList == null)
            {
                this.ImageList = _DefaultSplitImages;
            }

            if (Enabled)
            {
                SetSplit(_NormalImage);
            }
            else
            {
                SetSplit(_DisabledImage);
            }
            
            base.OnCreateControl();
        }

        private void InitDefaultSplitImages()
        {
            InitDefaultSplitImages(false);
        }

        private void InitDefaultSplitImages(bool refresh)
        {
            if (String.IsNullOrEmpty(_NormalImage))
            {
                _NormalImage = "Normal";
            }

            if (String.IsNullOrEmpty(_HoverImage))
            {
                _HoverImage = "Hover";
            }

            if (String.IsNullOrEmpty(_ClickedImage))
            {
                _ClickedImage = "Clicked";
            }

            if (String.IsNullOrEmpty(_DisabledImage))
            {
                _DisabledImage = "Disabled";
            }

            if (String.IsNullOrEmpty(_FocusedImage))
            {
                _FocusedImage = "Focused";
            }

            if (_DefaultSplitImages == null)
            {
                _DefaultSplitImages = new ImageList();
            }

            if (_DefaultSplitImages.Images.Count == 0 || refresh)
            {
                if (_DefaultSplitImages.Images.Count > 0)
                {
                    _DefaultSplitImages.Images.Clear();
                }

                try
                {
                    int w = 0;
                    int h = 0;

                    if (!_CalculateSplitRect && _SplitWidth > 0)
                    {
                        w = _SplitWidth;
                    }
                    else
                    {
                        w = 18;
                    }

                    if (!CalculateSplitRect && SplitHeight > 0)
                    {
                        h = SplitHeight;
                    }
                    else
                    {
                        h = Height;
                    }

                    h -= 8;

                    _DefaultSplitImages.ImageSize = new Size(w, h);

                    int mw = w / 2;
                    mw += (mw % 2);
                    int mh = h / 2;

                    Pen fPen = new Pen(ForeColor, 1);
                    SolidBrush fBrush = new SolidBrush(ForeColor);

                    Bitmap imgN = new Bitmap(w, h);
                    Graphics g = Graphics.FromImage(imgN);

                    g.CompositingQuality = CompositingQuality.HighQuality;

                    g.DrawLine(SystemPens.ButtonShadow, new Point(1, 1), new Point(1, h - 2));
                    g.DrawLine(SystemPens.ButtonFace, new Point(2, 1), new Point(2, h));

                    g.FillPolygon(fBrush, new Point[] { new Point(mw - 2, mh - 1), 
                                                         new Point(mw + 3, mh - 1),
                                                         new Point(mw, mh + 2) });

                    g.Dispose();

                    Bitmap imgH = new Bitmap(w, h);
                    g = Graphics.FromImage(imgH);

                    g.CompositingQuality = CompositingQuality.HighQuality;

                    g.DrawLine(SystemPens.ButtonShadow, new Point(1, 1), new Point(1, h - 2));
                    g.DrawLine(SystemPens.ButtonFace, new Point(2, 1), new Point(2, h));

                    g.FillPolygon(fBrush, new Point[] { new Point(mw - 3, mh - 2), 
                                                         new Point(mw + 4, mh - 2),
                                                         new Point(mw, mh + 2) });

                    g.Dispose();

                    Bitmap imgC = new Bitmap(w, h);
                    g = Graphics.FromImage(imgC);

                    g.CompositingQuality = CompositingQuality.HighQuality;

                    g.DrawLine(SystemPens.ButtonShadow, new Point(1, 1), new Point(1, h - 2));
                    g.DrawLine(SystemPens.ButtonFace, new Point(2, 1), new Point(2, h));

                    g.FillPolygon(fBrush, new Point[] { new Point(mw - 2, mh - 1), 
                                                         new Point(mw + 3, mh - 1),
                                                         new Point(mw, mh + 2) });

                    g.Dispose();

                    Bitmap imgD = new Bitmap(w, h);
                    g = Graphics.FromImage(imgD);

                    g.CompositingQuality = CompositingQuality.HighQuality;

                    g.DrawLine(SystemPens.GrayText, new Point(1, 1), new Point(1, h - 2));

                    g.FillPolygon(new SolidBrush(SystemColors.GrayText), new Point[] { new Point(mw - 2, mh - 1), 
                                                         new Point(mw + 3, mh - 1),
                                                         new Point(mw, mh + 2) });

                    g.Dispose();

                    Bitmap imgF = new Bitmap(w, h);
                    g = Graphics.FromImage(imgF);

                    g.CompositingQuality = CompositingQuality.HighQuality;

                    g.DrawLine(SystemPens.ButtonShadow, new Point(1, 1), new Point(1, h - 2));
                    g.DrawLine(SystemPens.ButtonFace, new Point(2, 1), new Point(2, h));

                    g.FillPolygon(fBrush, new Point[] { new Point(mw - 2, mh - 1), 
                                                         new Point(mw + 3, mh - 1),
                                                         new Point(mw, mh + 2) });

                    g.Dispose();

                    fPen.Dispose();
                    fBrush.Dispose();

                    _DefaultSplitImages.Images.Add(_NormalImage, imgN);
                    _DefaultSplitImages.Images.Add(_HoverImage, imgH);
                    _DefaultSplitImages.Images.Add(_ClickedImage, imgC);
                    _DefaultSplitImages.Images.Add(_DisabledImage, imgD);
                    _DefaultSplitImages.Images.Add(_FocusedImage, imgF);
                }
                catch
                { }
            }
        }

        protected override void OnMouseMove(MouseEventArgs mevent)
        {
            if (_AlwaysDropDown || _AlwaysHoverChange || MouseInSplit())
            {
                if (Enabled)
                {
                    SetSplit(_HoverImage);
                }
            }
            else
            {
                if (Enabled)
                {
                    SetSplit(_NormalImage);
                }
            }

            base.OnMouseMove(mevent);
        }

        protected override void OnMouseLeave(EventArgs e)
        {
            if (Enabled)
            {
                SetSplit(_NormalImage);
            }

            base.OnMouseLeave(e);
        }

        protected override void OnMouseDown(MouseEventArgs mevent)
        {
            if (_AlwaysDropDown || MouseInSplit())
            {
                if (Enabled)
                {
                    SetSplit(_ClickedImage);

                    if (this.ContextMenuStrip != null && this.ContextMenuStrip.Items.Count > 0)
                    {
                        this.ContextMenuStrip.Show(this, new Point(0, Height));
                    }
                }
            }
            else
            {
                if (Enabled)
                {
                    SetSplit(_NormalImage);
                }
            }

            base.OnMouseDown(mevent);
        }

        protected override void OnMouseUp(MouseEventArgs mevent)
        {
            if (_AlwaysDropDown || _AlwaysHoverChange || MouseInSplit())
            {
                if (Enabled)
                {
                    SetSplit(_HoverImage);
                }
            }
            else
            {
                if (Enabled)
                {
                    SetSplit(_NormalImage);
                }
            }

            base.OnMouseUp(mevent);
        }

        protected override void OnEnabledChanged(EventArgs e)
        {
            if (!Enabled)
            {
                SetSplit(_DisabledImage);
            }
            else
            {
                if (MouseInSplit())
                {
                    SetSplit(_HoverImage);
                }
                else
                {
                    SetSplit(_NormalImage);
                }
            }

            base.OnEnabledChanged(e);
        }

        protected override void OnGotFocus(EventArgs e)
        {
            if (Enabled)
            {
                SetSplit(_FocusedImage);
            }

            base.OnGotFocus(e);
        }

        protected override void OnLostFocus(EventArgs e)
        {
            if (Enabled)
            {
                SetSplit(_NormalImage);
            }

            base.OnLostFocus(e);
        }

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

            if (!MouseInSplit() && !_AlwaysDropDown)
            {
                if (ButtonClick != null)
                {
                    ButtonClick(this, e);
                }
            }
        }

        protected override void OnDoubleClick(EventArgs e)
        {
            if (_DoubleClickedEnabled)
            {
                base.OnDoubleClick(e);

                if (!MouseInSplit() && !_AlwaysDropDown)
                {
                    if (ButtonClick != null)
                    {
                        ButtonDoubleClick(this, e);
                    }
                }
            }
        }

        private void SetSplit(String imageName)
        {
            if (imageName != null && ImageList != null && ImageList.Images.ContainsKey(imageName))
            {
                this.ImageKey = imageName;
            }
        }

        public bool MouseInSplit()
        {
            return PointInSplit(PointToClient(MousePosition));
        }

        public bool PointInSplit(Point pt)
        {
            Rectangle splitRect = GetImageRect(_NormalImage);

            if (!_CalculateSplitRect)
            {
                splitRect.Width = _SplitWidth;
                splitRect.Height = _SplitHeight;
            }

            return splitRect.Contains(pt);
        }

        public Rectangle GetImageRect(String imageKey)
        {
                Image currImg = GetImage(imageKey);

                if (currImg != null)
                {
                    int x = 0,
                        y = 0,
                        w = currImg.Width+1,
                        h = currImg.Height+1;

                    if (w > this.Width)
                    {
                        w = this.Width;
                    }

                    if (h > this.Width)
                    {
                        h = this.Width;
                    }

                    switch (ImageAlign)
                    {
                        case ContentAlignment.TopLeft:
                            {
                                x = 0;
                                y = 0;

                                break;
                            }
                        case ContentAlignment.TopCenter:
                            {
                                x = (this.Width - w) / 2;
                                y = 0;

                                if ((this.Width - w) % 2 > 0)
                                {
                                    x += 1;
                                }

                                break;
                            }
                        case ContentAlignment.TopRight:
                            {
                                x = this.Width - w;
                                y = 0;

                                break;
                            }
                        case ContentAlignment.MiddleLeft:
                            {
                                x = 0;
                                y = (this.Height - h) / 2;

                                if ((this.Height - h) % 2 > 0)
                                {
                                    y += 1;
                                }

                                break;
                            }
                        case ContentAlignment.MiddleCenter:
                            {
                                x = (this.Width - w) / 2;
                                y = (this.Height - h) / 2;

                                if ((this.Width - w) % 2 > 0)
                                {
                                    x += 1;
                                }
                                if ((this.Height - h) % 2 > 0)
                                {
                                    y += 1;
                                }

                                break;
                            }
                        case ContentAlignment.MiddleRight:
                            {
                                x = this.Width - w;
                                y = (this.Height - h) / 2;

                                if ((this.Height - h) % 2 > 0)
                                {
                                    y += 1;
                                }

                                break;
                            }
                        case ContentAlignment.BottomLeft:
                            {
                                x = 0;
                                y = this.Height - h;

                                if ((this.Height - h) % 2 > 0)
                                {
                                    y += 1;
                                }

                                break;
                            }
                        case ContentAlignment.BottomCenter:
                            {
                                x = (this.Width - w) / 2;
                                y = this.Height - h;

                                if ((this.Width - w) % 2 > 0)
                                {
                                    x += 1;
                                }

                                break;
                            }
                        case ContentAlignment.BottomRight:
                            {
                                x = this.Width - w;
                                y = this.Height - h;

                                break;
                            }
                    }

                    if (_FillSplitHeight && h < this.Height)
                    {
                        h = this.Height;
                    }

                    if (x > 0)
                    {
                        x -= 1;
                    }
                    if (y > 0)
                    {
                        y -= 1;
                    }

                    return new Rectangle(x, y, w, h);
                }

            return Rectangle.Empty;
        }

        private Image GetImage(String imageName)
        {
            if (this.ImageList != null && this.ImageList.Images.ContainsKey(imageName))
            {
                return this.ImageList.Images[imageName];
            }

            return null;
        }

        #endregion

        /// <summary> 
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Component Designer generated code

        /// <summary> 
        /// Required method for Designer support - do not modify 
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
        }

        #endregion
    }
}

 

转载于:https://www.cnblogs.com/z5337/p/3758621.html

weixin_30654583
关注
c# winform自定义下拉列表（源码）
01-10
控件有个DropDownControl属性，你可以指定给这个控件点下拉按钮时弹出datagridview,richTextBox等等系统控件甚至是自己定义的UserControl控件。。。下载后自己看吧，有源码有示例有真像
自定义下拉列表
01-04
自定义下拉列表，通过PopupWindow实现下拉列表，下拉列表的宽度和下拉框的宽度一样，使下拉列表看起来更整体。
C# 带下拉控件的按钮Button
最新发布
weixin_42462516的博客
11-13 914
C# winform 下拉选项Button
（四十八）c#Winform自定义控件-下拉按钮
dengxuanxian9113的博客
08-27 290
前提 入行已经7,8年了，一直想做一套漂亮点的自定义控件，于是就有了本系列文章。 GitHub：https://github.com/kwwwvagaa/NetWinformControl 码云：https://gitee.com/kwwwvagaa/net_winform_custom_control.git 如果觉得写的还行，请点个 star 支持一下吧 欢迎前来交流探讨：...
自定义下拉选择框_winform_下拉选择框_
09-30
C# 自定义下拉选择框（下拉智能提示文本框）
C# winForm自定义控件多选框
09-12
C# 中WinForm 自定义 多选框， 不过改自定义控件的性能不太好，欢迎大家多多协助改进。 软件架构 使用微软最新dotNet6 框架开发，里面的自定定义控件理论上能在net 所有winform 系列中通用 使用说明 初始化选中...
C# winform 自定义控件 下拉框树结构 且可以选中
09-06
C# winform 自定义控件 下拉框树结构 且可以选中（免积分下载） 详情请看我的文章介绍，有图片效果展示 ：https://blog.csdn.net/m0_65636467/article/details/132711246
ribbon.rar_C# winform ribbon_C#控件购买_Winform Ribbon_winform ri
07-14
在本文中，我们将深入探讨C# WinForm应用中使用的Ribbon控件，以及如何利用开源项目来提升开发效率。Ribbon控件源自Microsoft Office界面，为应用程序提供了现代化、直观的用户交互界面。在Windows Forms（WinForm）...
WinForm自定义下拉列表框用户控件
10-11
在.NET Framework中，Windows Forms（WinForm）是一个用于构建桌面应用程序的强大工具，它提供了一系列丰富的控件供...通过学习和实践这个项目，开发者可以深化对WinForm控件定制的理解，进一步提升软件开发技能。
c#winform下拉多选自定义控件(带全选)
01-04
在C# WinForm开发中，有时我们需要创建具有更多功能的自定义控件，例如一个下拉多选框，它不仅支持多项选择，还提供全选/全取消的功能。这个自定义控件对于需要用户从一系列选项中进行复选选择的情况非常有用。下面...
C# 自定义带搜索下拉框
06-26
C# 自定义带搜索下拉框，和系统自带下拉框用法一样，但是加了搜索功能
C# WinForm 自定义ComboBox 显示颜色下拉框
09-02
在WinForm界面上，采用自定义ComboBox控件实现在下拉框中显示颜色列表。本程序在VS2008下编译通过。
winform-下拉框多选
08-15
支持下拉框多选、全选
C#自定义ComboBox下拉框
12-25
这个是从国外网站直接下载的自定义ComboBox下拉框，支持下拉列表中带复选框，下来列表多列列表。
winform 下拉框（自定义下拉框控件）
热门推荐
pyc_01的博客
06-08 1万+
项目中遇到需要下拉框列表内容为线类型或点类型图形的需求，想到可以使用手绘线条和图形的方式来实现下拉列表内容自定义，记录下来供大家参考学习之用。 在项目中添加一个组件 添加完之后会显示如下设计界面 这里直接点击切换到代码视图即可 注意：新建的组件默认继承Component，我们这里是要自定义一个ComboBox下拉框，所以要继承自ComboBox，此类位于using System.Windows.Forms命名空间下 下拉列表显示为线的类型 using System; using System.Co
（四十九）c#Winform自定义控件-下拉框（表格）
冰封一夏
09-10 2374
前提 入行已经7,8年了，一直想做一套漂亮点的自定义控件，于是就有了本系列文章。 GitHub：https://github.com/kwwwvagaa/NetWinformControl 码云：https://gitee.com/kwwwvagaa/net_winform_custom_control.git 如果觉得写的还行，请点个 star 支持一下吧 欢迎前来交流探讨： 企鹅群5...
C# WinForm 按钮下拉列(SplitButton)简单使用示例
weixin_34049948的博客
09-11 4219
关于SplitButton网上有很多的示例教程,这里我就以 https://wyday.com/splitbutton/ 为例给大家简单的讲解下。 1.下载控件 前往 https://wyday.com/splitbutton/ 下载控件 2.引入控件 在VS工具箱栏右键，选择 选择项(I)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值