qq button

最新推荐文章于 2022-01-15 11:06:55 发布
最新推荐文章于 2022-01-15 11:06:55 发布
阅读量1.1k 收藏
点赞数
分类专栏： c#winform 文章标签： button qq alignment path null image 
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.ComponentModel;

namespace System.QQ
{
public class QQButton : System.Windows.Forms.Button
    {
        private Color _borderColor = Color.FromArgb(161, 162, 160);
        private Color _innerBorderColor = Color.FromArgb(200, 255, 255, 255);
        private Color _baseColor = Color.FromArgb(10, 66, 204, 255);
        private Color _baseColorEnd = Color.FromArgb(200, 66, 204, 255);
        private Color _arrowColor = Color.FromArgb(64,64,64);
        private int _imageWidth = 24;
        private int _imageHeight = 24;
        private RoundStyle _roundStyle = RoundStyle.All;
        private int _radius = 2;
        private int _imageTextSpace = 2;
        private bool _pressOffset = true;
        private bool _alwaysShowBorder = false;
        private bool _showSpliteButton = false;
        private int _spliteButtonWidth = 18;
        private ControlState _controlState;
        private ButtonMousePosition _mousePosition;

        private bool _contextHandle;
        private bool _contextOpened;
        private int _contextOffset = 5;

        /// <summary>
        /// 普通按钮按下事件
        /// </summary>
        public event EventHandler OnButtonClick;
        /// <summary>
        /// 分割按钮按下事件
        /// </summary>
        public event EventHandler OnSpliteButtonClick;

        /// <summary>
        /// 鼠标的当前位置
        /// </summary>
        public enum ButtonMousePosition
        {
            None,
            Button,
            Splitebutton,
        }

/// <summary>
    /// 控件的状态。
    /// </summary>
    public enum ControlState
    {
        /// <summary>
        ///  正常
        /// </summary>
        Normal,
        /// <summary>
        /// 鼠标经过
        /// </summary>
        Hover,
        /// <summary>
        /// 鼠标按下
        /// </summary>
        Pressed,
    }

/// <summary>
    /// 建立圆角路径的样式。
    /// </summary>
    public enum RoundStyle
    {
        /// <summary>
        /// 四个角都不是圆角。
        /// </summary>
        None = 0,
        /// <summary>
        /// 四个角都为圆角。
        /// </summary>
        All = 1,
        /// <summary>
        /// 左边两个角为圆角。
        /// </summary>
        Left = 2,
        /// <summary>
        /// 右边两个角为圆角。
        /// </summary>
        Right = 3,
        /// <summary>
        /// 上边两个角为圆角。
        /// </summary>
        Top = 4,
        /// <summary>
        /// 下边两个角为圆角。
        /// </summary>
        Bottom = 5,
        /// <summary>
        /// 左下角为圆角。
        /// </summary>
        BottomLeft = 6,
        /// <summary>
        /// 右下角为圆角。
        /// </summary>
        BottomRight = 7,
    }

        public QQButton()
            :base()
        {
            SetStyle(
                ControlStyles.SupportsTransparentBackColor|
                ControlStyles.UserPaint |
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.OptimizedDoubleBuffer |
                ControlStyles.ResizeRedraw |
                ControlStyles.SupportsTransparentBackColor, true);
            SetStyle(ControlStyles.Opaque, false);

            this.BackColor = Color.Transparent;
        }

        [DefaultValue(5)]
        [Description("下拉菜单与按钮的距离")]
        public int ContextOffset
        {
            get { return _contextOffset; }
            set
            {
                _contextOffset = value;
            }
        }

        [DefaultValue(false)]
        [Description("是否启用分割按钮")]
        public bool ShowSpliteButton
        {
            get { return _showSpliteButton; }
            set
            {
                if (_showSpliteButton != value)
                {
                    _showSpliteButton = value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(18)]
        [Description("分割按钮的宽度")]
        public int SpliteButtonWidth
        {
            get { return _spliteButtonWidth; }
            set
            {
                if (_spliteButtonWidth != value)
                {
                    _spliteButtonWidth = value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(true)]
        [Description("当鼠标按下时图片和文字是否产生偏移")]
        public bool PressOffset
        {
            get { return _pressOffset; }
            set
            {
                _pressOffset = value;
            }
        }

        [DefaultValue(false)]
        [Description("是否一直显示按钮边框\n设置为false则只在鼠标经过和按下时显示边框")]
        public bool AlwaysShowBorder
        {
            get { return _alwaysShowBorder; }
            set
            {
                if (_alwaysShowBorder != value)
                {
                    _alwaysShowBorder = value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(typeof(Color), "64,64,64")]
        [Description("当显示分割按钮时，分割按钮的箭头颜色")]
        public Color ArrowColor
        {
            get { return _arrowColor; }
            set
            {
                if (_arrowColor != value)
                {
                    _arrowColor = value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(typeof(Color), "161, 162, 160")]
        [Description("按钮的边框颜色")]
        public Color BorderColor
        {
            get { return _borderColor; }
            set
            {
                if (_borderColor != value)
                {
                    _borderColor = value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(typeof(Color), "200, 255, 255, 255")]
        [Description("按钮内边框颜色")]
        public Color InnerBorderColor
        {
            get { return _innerBorderColor; }
            set
            {
                if (_innerBorderColor != value)
                {
                    _innerBorderColor = value;
                    base.Invalidate();
                }
            }
        }


        [DefaultValue(typeof(Color), "10 ,66, 204, 160")]
        [Description("鼠标经过和按下时按钮的渐变背景颜色")]
        public Color BaseColor
        {
            get { return _baseColor; }
            set
            {
                if (_baseColor != value)
                {
                    _baseColor = value;
                }
            }
        }

        [DefaultValue(typeof(Color), "200 ,66, 204, 160")]
        [Description("鼠标经过和按下时按钮的渐变背景颜色")]
        public Color BaseColorEnd
        {
            get { return _baseColorEnd; }
            set
            {
                if (_baseColorEnd != value)
                {
                    _baseColorEnd = value;
                }
            }
        }

        [DefaultValue(24)]
        [Description("图片宽度")]
        public int ImageWidth
        {
            get { return _imageWidth; }
            set
            {
                if (value != _imageWidth)
                {

                    _imageWidth = value < 12 ? 12 : value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(24)]
        [Description("图片高度")]
        public int ImageHeight
        {
            get { return _imageHeight; }
            set
            {
                if (value != _imageHeight)
                {

                    _imageHeight = value < 12 ? 12 : value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(typeof(RoundStyle), "1")]
        [Description("按钮圆角样式")]
        public RoundStyle RoundStyle
        {
            get { return _roundStyle; }
            set
            {
                if (_roundStyle != value)
                {
                    _roundStyle = value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(2)]
        [Description("按钮圆角弧度")]
        public int Radius
        {
            get { return _radius; }
            set
            {
                if (_radius != value)
                {
                    _radius = value < 2 ? 2 : value;
                    base.Invalidate();
                }
            }
        }

        [DefaultValue(2)]
        [Description("图片与文字之间的间距")]
        public int ImageTextSpace
        {
            get { return _imageTextSpace; }
            set
            {
                if (_imageTextSpace != value)
                {
                    _imageTextSpace=value < 0 ? 0 : value;
                    base.Invalidate();
                }
            }
        }

        /// <summary>
        /// 按钮当前状态
        /// </summary>
        internal ControlState ControlState
        {
            get { return _controlState; }
            set
            {
                if (_controlState != value)
                {
                    _controlState = value;
                    base.Invalidate();
                }
            }
        }

        /// <summary>
        /// 鼠标当前所在位置
        /// </summary>
        internal ButtonMousePosition CurrentMousePosition
        {
            get { return _mousePosition; }
            set
            {
                if (_mousePosition != value)
                {
                    _mousePosition = value;
                    base.Invalidate();
                }
            }
        }

        /// <summary>
        /// 普通按钮矩形位置
        /// </summary>
        internal Rectangle ButtonRect
        {
            get
            {
                if (ShowSpliteButton)
                {
                    return new Rectangle(0, 0, ClientRectangle.Width - SpliteButtonWidth, ClientRectangle.Height);
                }
                else
                {
                    return ClientRectangle;
                }
            }
        }

        /// <summary>
        /// 分割按钮矩形位置
        /// </summary>
        internal Rectangle SpliteButtonRect
        {
            get
            {
                if (ShowSpliteButton)
                {
                    return new Rectangle(ClientRectangle.Width - SpliteButtonWidth, 0, SpliteButtonWidth, ClientRectangle.Height);
                }
                else
                {
                    return Rectangle.Empty;
                }
            }
        }


        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);
            if (!_contextOpened)
            {
                ControlState = ControlState.Normal;
                CurrentMousePosition = ButtonMousePosition.None;
            }
        }

        protected override void OnMouseMove(MouseEventArgs mevent)
        {
            base.OnMouseMove(mevent);
            if (ClientRectangle.Contains(mevent.Location))
            {
                ControlState = ControlState.Hover;
                if (ShowSpliteButton)
                {
                    CurrentMousePosition = ButtonRect.Contains(mevent.Location) ? ButtonMousePosition.Button : ButtonMousePosition.Splitebutton;
                }
                else
                {
                    CurrentMousePosition = ButtonMousePosition.Button;
                }
            }
            else
            {
                ControlState = ControlState.Normal;
                CurrentMousePosition = ButtonMousePosition.None;
            }
        }


        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
            if (e.Button == MouseButtons.Left && e.Clicks == 1)
            {
                ControlState = ControlState.Pressed;
                if (ShowSpliteButton)
                {
                    CurrentMousePosition = ButtonRect.Contains(e.Location) ? ButtonMousePosition.Button : ButtonMousePosition.Splitebutton;
                }
                else
                {
                    CurrentMousePosition = ButtonMousePosition.Button;
                }
            }
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            if (e.Button == MouseButtons.Left && e.Clicks == 1)
            {
                if (ClientRectangle.Contains(e.Location))
                {
                    ControlState = ControlState.Hover;
                    if (ShowSpliteButton)
                    {
                        CurrentMousePosition = ButtonRect.Contains(e.Location) ? ButtonMousePosition.Button : ButtonMousePosition.Splitebutton;
                        if (CurrentMousePosition == ButtonMousePosition.Splitebutton)
                        {
                            if (OnSpliteButtonClick != null)
                            {
                                OnSpliteButtonClick(this, EventArgs.Empty);
                            }
                            if (this.ContextMenuStrip != null)
                            {
                                if (!_contextHandle)
                                {
                                    _contextHandle = true;
                                    this.ContextMenuStrip.Opening += new CancelEventHandler(ContextMenuStrip_Opening);
                                    this.ContextMenuStrip.Closed += new ToolStripDropDownClosedEventHandler(ContextMenuStrip_Closed);
                                }
                                this.ContextMenuStrip.Opacity = 1.0;
                                this.ContextMenuStrip.Show(this, 0, this.Height+ContextOffset);
                            }
                        }
                        else
                        {
                            if (OnButtonClick != null)
                            {
                                OnButtonClick(this, EventArgs.Empty);
                            }
                        }
                    }
                    else
                    {
                        CurrentMousePosition = ButtonMousePosition.Button;
                    }
                }
                else
                {
                     ControlState = ControlState.Normal;
                     CurrentMousePosition = ButtonMousePosition.None;
                }
            }
        }

        private void ContextMenuStrip_Closed(object sender, ToolStripDropDownClosedEventArgs e)
        {
            _contextOpened = false;
            ControlState = ControlState.Normal;
            CurrentMousePosition = ButtonMousePosition.None;
            base.Invalidate();
        }


        private void ContextMenuStrip_Opening(object sender, CancelEventArgs e)
        {
            _contextOpened = true;
        }


        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            base.OnPaintBackground(e);

            Graphics g = e.Graphics;
            Rectangle imageRect;
            Rectangle textRect;

            CalculateRect(out imageRect, out textRect,g);
            g.SmoothingMode = SmoothingMode.AntiAlias;
            

            //画边框与背景
            RenderBackGroundInternal(
                g,
                ClientRectangle,
                RoundStyle,
                Radius
                );
            //画图像
            if (Image != null)
            {
                g.InterpolationMode = InterpolationMode.HighQualityBilinear;
                g.DrawImage(
                    Image,
                    imageRect,
                    0,
                    0,
                    Image.Width,
                    Image.Height,
                    GraphicsUnit.Pixel);
            }
            //画文字
            if (Text != "")
            {
                TextRenderer.DrawText(
                    g,
                    Text,
                    Font,
                    textRect,
                    ForeColor,
                    GetTextFormatFlags(TextAlign, RightToLeft == RightToLeft.Yes));
            }
            //画分割按钮
            if (ShowSpliteButton)
            {
                RenderSpliteButton(g,ClientRectangle);
            }
        }

        /// <summary>
        /// 获取图像以及文字的位置
        /// </summary>
        /// <param name="imageRect"></param>
        /// <param name="textRect"></param>
        private void CalculateRect(
            out Rectangle imageRect, out Rectangle textRect, Graphics g)
        {
            imageRect = Rectangle.Empty;
            textRect = Rectangle.Empty;
            SizeF textSize = g.MeasureString(Text, Font);
            if (Image == null)
            {
                switch (TextAlign)
                {
                    case ContentAlignment.BottomCenter:
                        textRect = new Rectangle((ButtonRect.Width - (int)textSize.Width) / 2, Height - (int)textSize.Height - 3, (int)textSize.Width, (int)textSize.Height);
                        break;
                    case ContentAlignment.BottomLeft:
                        textRect = new Rectangle(2, Height - (int)textSize.Height - 3, (int)textSize.Width, (int)textSize.Height);
                        break;
                    case ContentAlignment.BottomRight:
                        textRect = new Rectangle(ButtonRect.Width - (int)textSize.Width - 3, Height - (int)textSize.Height - 3, (int)textSize.Width, (int)textSize.Height);
                        break;
                    case ContentAlignment.MiddleCenter:
                        textRect = new Rectangle((ButtonRect.Width - (int)textSize.Width) / 2, (Height - (int)textSize.Height) / 2, (int)textSize.Width, (int)textSize.Height);
                        break;
                    case ContentAlignment.MiddleLeft:
                        textRect = new Rectangle(2, (Height - (int)textSize.Height) / 2, (int)textSize.Width, (int)textSize.Height);
                        break;
                    case ContentAlignment.MiddleRight:
                        textRect = new Rectangle(ButtonRect.Width - (int)textSize.Width - 3, (Height - (int)textSize.Height) / 2, (int)textSize.Width, (int)textSize.Height);
                        break;
                    case ContentAlignment.TopCenter:
                        textRect = new Rectangle((ButtonRect.Width - (int)textSize.Width) / 2, 2, (int)textSize.Width, (int)textSize.Height);
                        break;
                    case ContentAlignment.TopLeft:
                        textRect = new Rectangle(2, 2, (int)textSize.Width, (int)textSize.Height);
                        break;
                    case ContentAlignment.TopRight:
                        textRect = new Rectangle(ButtonRect.Width - (int)textSize.Width - 3, 2, (int)textSize.Width, (int)textSize.Height);
                        break;
                }
                if (PressOffset && ControlState == ControlState.Pressed && CurrentMousePosition== ButtonMousePosition.Button)
                {
                    textRect.X += 1;
                    textRect.Y += 1;
                }
                if (RightToLeft == RightToLeft.Yes)
                {
                    textRect.X = ButtonRect.Width - textRect.Right;
                }
                return;
            }
            if (this.Text == "")
            {
                switch (ImageAlign)
                {
                    case ContentAlignment.BottomCenter:
                        imageRect = new Rectangle((ButtonRect.Width - ImageWidth) / 2, Height - ImageHeight - 3, ImageWidth, ImageHeight);
                        break;
                    case ContentAlignment.BottomLeft:
                        imageRect = new Rectangle(2, Height - ImageHeight - 3, ImageWidth, ImageHeight);
                        break;
                    case ContentAlignment.BottomRight:
                        imageRect = new Rectangle(ButtonRect.Width - ImageWidth - 3, Height - ImageHeight - 3, ImageWidth, ImageHeight);
                        break;
                    case ContentAlignment.MiddleCenter:
                        imageRect = new Rectangle((ButtonRect.Width - ImageWidth) / 2, (Height - ImageHeight) / 2, ImageWidth, ImageHeight);
                        break;
                    case ContentAlignment.MiddleLeft:
                        imageRect = new Rectangle(2, (Height - ImageHeight) / 2, ImageWidth, ImageHeight);
                        break;
                    case ContentAlignment.MiddleRight:
                        imageRect = new Rectangle(ButtonRect.Width - ImageWidth - 3, (Height - ImageHeight) / 2, ImageWidth, ImageHeight);
                        break;
                    case ContentAlignment.TopCenter:
                        imageRect = new Rectangle((ButtonRect.Width - ImageWidth) / 2, 2, ImageWidth, ImageHeight);
                        break;
                    case ContentAlignment.TopLeft:
                        imageRect = new Rectangle(2, 2, ImageWidth, ImageHeight);
                        break;
                    case ContentAlignment.TopRight:
                        imageRect = new Rectangle(ButtonRect.Width - ImageWidth - 3, 2, ImageWidth, ImageHeight);
                        break;
                }
                if (PressOffset && ControlState == ControlState.Pressed && CurrentMousePosition== ButtonMousePosition.Button)
                {
                    imageRect.X += 1;
                    imageRect.Y += 1;
                }
                if (RightToLeft == RightToLeft.Yes)
                {
                    imageRect.X = ButtonRect.Width - imageRect.Right;
                }
                return;
            }
            switch (TextImageRelation)
            {
                case TextImageRelation.Overlay:
                    imageRect = new Rectangle(
                        (ButtonRect.Width - ImageWidth - (int)textSize.Width - ImageTextSpace) / 2,
                        (Height - ImageHeight) / 2,
                        ImageWidth,
                        ImageHeight);
                    textRect = new Rectangle(
                        imageRect.Right + ImageTextSpace,
                        (Height-(int)textSize.Height)/2,
                        (int)textSize.Width,
                        (int)textSize.Height);
                    break;
                case TextImageRelation.ImageAboveText:
                    imageRect = new Rectangle(
                        (ButtonRect.Width - ImageWidth) / 2,
                        (Height-ImageHeight-(int)textSize.Height-ImageTextSpace)/2,
                        ImageWidth,
                        ImageHeight);
                    textRect = new Rectangle(
                        (ButtonRect.Width - (int)textSize.Width) / 2,
                        imageRect.Bottom + ImageTextSpace,
                        (int)textSize.Width,
                        (int)textSize.Height);
                    break;
                case TextImageRelation.ImageBeforeText:
                    imageRect = new Rectangle(
                        (ButtonRect.Width - ImageWidth - (int)textSize.Width - ImageTextSpace) / 2,
                        (Height - ImageHeight) / 2,
                        ImageWidth,
                        ImageHeight);
                    textRect = new Rectangle(
                        imageRect.Right + ImageTextSpace,
                        (Height - (int)textSize.Height) / 2,
                        (int)textSize.Width,
                        (int)textSize.Height);
                    break;
                case TextImageRelation.TextAboveImage:
                    textRect = new Rectangle(
                        (ButtonRect.Width - (int)textSize.Width) / 2,
                        (Height-(int)textSize.Height-ImageHeight-ImageTextSpace)/2,
                        (int)textSize.Width,
                        (int)textSize.Height);
                    imageRect = new Rectangle(
                        (ButtonRect.Width - ImageWidth) / 2,
                        textRect.Bottom+ImageTextSpace,
                        ImageWidth,
                        ImageHeight);
                    break;
                case TextImageRelation.TextBeforeImage:
                    textRect = new Rectangle(
                        (ButtonRect.Width - ImageWidth - (int)textSize.Width - ImageTextSpace) / 2,
                        (Height - (int)textSize.Height) / 2,
                        (int)textSize.Width,
                        (int)textSize.Height);
                    imageRect = new Rectangle(
                        textRect.Right + ImageTextSpace,
                        (Height - ImageHeight) / 2,
                        ImageWidth,
                        ImageHeight);
                    break;
            }
            if (PressOffset && ControlState == ControlState.Pressed && CurrentMousePosition== ButtonMousePosition.Button)
            {
                imageRect.X += 1;
                imageRect.Y += 1;
                textRect.X += 1;
                textRect.Y += 1;
            }

            if (RightToLeft == RightToLeft.Yes)
            {
                imageRect.X = ButtonRect.Width - imageRect.Right;
                textRect.X = ButtonRect.Width - textRect.Right;
            }
        }

        /// <summary>
        /// 画边框与背景
        /// </summary>
        internal void RenderBackGroundInternal(
           Graphics g,
           Rectangle rect,
           RoundStyle style,
           int roundWidth
           )
        {
            if (ControlState != ControlState.Normal || AlwaysShowBorder)
            {
                rect.Width--;
                rect.Height--;
                if (style != RoundStyle.None)
                {
                    using (GraphicsPath path = GraphicsPathHelper.CreatePath(rect, roundWidth, style, false))
                    {
                        if (ControlState != ControlState.Normal)
                        {
                            using (LinearGradientBrush brush = (ControlState == ControlState.Pressed) ? new LinearGradientBrush(rect, BaseColorEnd, BaseColor, LinearGradientMode.ForwardDiagonal) : new LinearGradientBrush(rect, BaseColor, BaseColorEnd,LinearGradientMode.Vertical))
                            {
                                if (!ShowSpliteButton)
                                {
                                    g.FillPath(brush, path);
                                }
                                else
                                {
                                    if (CurrentMousePosition == ButtonMousePosition.Button)
                                    {
                                        using (GraphicsPath buttonpath = GraphicsPathHelper.CreatePath(ButtonRect, roundWidth, RoundStyle.Left, true))
                                        {
                                            g.FillPath(brush, buttonpath);
                                        }
                                    }
                                    else
                                    {
                                        using (GraphicsPath splitepath = GraphicsPathHelper.CreatePath(SpliteButtonRect, roundWidth, RoundStyle.Right, true))
                                        {
                                            g.FillPath(brush, splitepath);
                                        }
                                    }
                                }
                            }
                        }
                        using (Pen pen = new Pen(_borderColor))
                        {
                            g.DrawPath(pen, path);
                        }
                    }
                    rect.Inflate(-1, -1);
                    using (GraphicsPath path = GraphicsPathHelper.CreatePath(rect, roundWidth, style, false))
                    {
                        using (Pen pen = new Pen(InnerBorderColor))
                        {
                            g.DrawPath(pen, path);
                        }
                    }
                }
                else
                {
                    if (ControlState != ControlState.Normal)
                    {
                        using (LinearGradientBrush brush = (ControlState == ControlState.Pressed) ? new LinearGradientBrush(rect, BaseColorEnd, BaseColor, LinearGradientMode.ForwardDiagonal) : new LinearGradientBrush(rect, BaseColor, BaseColorEnd, LinearGradientMode.Vertical))
                        {
                            if (!ShowSpliteButton)
                            {
                                g.FillRectangle(brush, rect);
                            }
                            else
                            {
                                if (CurrentMousePosition == ButtonMousePosition.Button)
                                {
                                    g.FillRectangle(brush, ButtonRect);
                                }
                                else
                                {
                                    g.FillRectangle(brush, SpliteButtonRect);
                                }
                            }
                        }
                    }
                    using (Pen pen = new Pen(_borderColor))
                    {
                        g.DrawRectangle(pen, rect);
                    }
                    rect.Inflate(-1, -1);
                    using (Pen pen = new Pen(InnerBorderColor))
                    {
                        g.DrawRectangle(pen, rect);
                    }
                }
            }
        }

        /// <summary>
        /// 画分割按钮
        /// </summary>
        /// <param name="g"></param>
        /// <param name="rect"></param>
        internal void RenderSpliteButton(Graphics g, Rectangle rect)
        {
            Point[] points = new Point[3];
            points[0]=new Point(rect.Width - SpliteButtonWidth + 2, (rect.Height - 4) / 2);
            points[1]=new Point(rect.Width - SpliteButtonWidth + 2 + 8, (rect.Height - 4) / 2);
            points[2]=new Point( rect.Width - SpliteButtonWidth + 2 + 4, (rect.Height - 4) / 2 + 4);

            if (PressOffset && ControlState == ControlState.Pressed && CurrentMousePosition == ButtonMousePosition.Splitebutton)
            {
                points[0].X += 1;
                points[0].Y += 1;
                points[1].X += 1;
                points[1].Y += 1;
                points[2].X += 1;
                points[2].Y += 1;
            }
            using (SolidBrush brush = new SolidBrush(ArrowColor))
            {
                g.FillPolygon(brush, points);
            }
        }

        internal static TextFormatFlags GetTextFormatFlags(
            ContentAlignment alignment,
            bool rightToleft)
        {
            TextFormatFlags flags = TextFormatFlags.WordBreak |
                TextFormatFlags.SingleLine;
            if (rightToleft)
            {
                flags |= TextFormatFlags.RightToLeft | TextFormatFlags.Right;
            }

            switch (alignment)
            {
                case ContentAlignment.BottomCenter:
                    flags |= TextFormatFlags.Bottom | TextFormatFlags.HorizontalCenter;
                    break;
                case ContentAlignment.BottomLeft:
                    flags |= TextFormatFlags.Bottom | TextFormatFlags.Left;
                    break;
                case ContentAlignment.BottomRight:
                    flags |= TextFormatFlags.Bottom | TextFormatFlags.Right;
                    break;
                case ContentAlignment.MiddleCenter:
                    flags |= TextFormatFlags.HorizontalCenter |
                        TextFormatFlags.VerticalCenter;
                    break;
                case ContentAlignment.MiddleLeft:
                    flags |= TextFormatFlags.VerticalCenter | TextFormatFlags.Left;
                    break;
                case ContentAlignment.MiddleRight:
                    flags |= TextFormatFlags.VerticalCenter | TextFormatFlags.Right;
                    break;
                case ContentAlignment.TopCenter:
                    flags |= TextFormatFlags.Top | TextFormatFlags.HorizontalCenter;
                    break;
                case ContentAlignment.TopLeft:
                    flags |= TextFormatFlags.Top | TextFormatFlags.Left;
                    break;
                case ContentAlignment.TopRight:
                    flags |= TextFormatFlags.Top | TextFormatFlags.Right;
                    break;
            }
            return flags;
        }
    }
}

public static class GraphicsPathHelper
    {
        /// <summary>
        /// 建立带有圆角样式的矩形路径
        /// </summary>
        /// <param name="rect">用来建立路径的矩形。</param>
        /// <param name="_radius">圆角的大小</param>
        /// <param name="style">圆角的样式</param>
        /// <param name="correction">是否把矩形长宽减 1,以便画出边框</param>
        /// <returns>建立的路径</returns>
        public static GraphicsPath CreatePath(
            Rectangle rect, int radius, RoundStyle style, bool correction)
        {
            GraphicsPath path = new GraphicsPath();
            int radiusCorrection = correction ? 1 : 0;
            switch (style)
            {
                case RoundStyle.None:
                    path.AddRectangle(rect);
                    break;
                case RoundStyle.All:
                    path.AddArc(rect.X, rect.Y, radius, radius, 180, 90);
                    path.AddArc(
                        rect.Right - radius - radiusCorrection,
                        rect.Y,
                        radius,
                        radius,
                        270,
                        90);
                    path.AddArc(
                        rect.Right - radius - radiusCorrection,
                        rect.Bottom - radius - radiusCorrection,
                        radius,
                        radius, 0, 90);
                    path.AddArc(
                        rect.X,
                        rect.Bottom - radius - radiusCorrection,
                        radius,
                        radius,
                        90,
                        90);
                    break;
                case RoundStyle.Left:
                    path.AddArc(rect.X, rect.Y, radius, radius, 180, 90);
                    path.AddLine(
                        rect.Right - radiusCorrection, rect.Y,
                        rect.Right - radiusCorrection, rect.Bottom - radiusCorrection);
                    path.AddArc(
                        rect.X,
                        rect.Bottom - radius - radiusCorrection,
                        radius,
                        radius,
                        90,
                        90);
                    break;
                case RoundStyle.Right:
                    path.AddArc(
                        rect.Right - radius - radiusCorrection,
                        rect.Y,
                        radius,
                        radius,
                        270,
                        90);
                    path.AddArc(
                       rect.Right - radius - radiusCorrection,
                       rect.Bottom - radius - radiusCorrection,
                       radius,
                       radius,
                       0,
                       90);
                    path.AddLine(rect.X, rect.Bottom - radiusCorrection, rect.X, rect.Y);
                    break;
                case RoundStyle.Top:
                    path.AddArc(rect.X, rect.Y, radius, radius, 180, 90);
                    path.AddArc(
                        rect.Right - radius - radiusCorrection,
                        rect.Y,
                        radius,
                        radius,
                        270,
                        90);
                    path.AddLine(
                        rect.Right - radiusCorrection, rect.Bottom - radiusCorrection,
                        rect.X, rect.Bottom - radiusCorrection);
                    break;
                case RoundStyle.Bottom:
                    path.AddArc(
                        rect.Right - radius - radiusCorrection,
                        rect.Bottom - radius - radiusCorrection,
                        radius,
                        radius,
                        0,
                        90);
                    path.AddArc(
                        rect.X,
                        rect.Bottom - radius - radiusCorrection,
                        radius,
                        radius,
                        90,
                        90);
                    path.AddLine(rect.X, rect.Y, rect.Right - radiusCorrection, rect.Y);
                    break;
                case RoundStyle.BottomLeft:
                    path.AddArc(
                        rect.X,
                        rect.Bottom - radius - radiusCorrection,
                        radius,
                        radius,
                        90,
                        90);
                    path.AddLine(rect.X, rect.Y, rect.Right - radiusCorrection, rect.Y);
                    path.AddLine(
                        rect.Right - radiusCorrection,
                        rect.Y,
                        rect.Right - radiusCorrection,
                        rect.Bottom - radiusCorrection);
                    break;
                case RoundStyle.BottomRight:
                    path.AddArc(
                        rect.Right - radius - radiusCorrection,
                        rect.Bottom - radius - radiusCorrection,
                        radius,
                        radius,
                        0,
                        90);
                    path.AddLine(rect.X, rect.Bottom - radiusCorrection, rect.X, rect.Y);
                    path.AddLine(rect.X, rect.Y, rect.Right - radiusCorrection, rect.Y);
                    break;
            }
            path.CloseFigure();

            return path;
        }
    }



}

susubuhui
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android button padding,解决在Android中给Button设置Padding无效的问题
weixin_42548816的博客
05-27 970
转自：http://blog.csdn.net/qq_35071078/article/details/75570940在Xml中给Button设置padding=0和利用代码给Button设置padding=0都是无效的，是因为，这种情况下，Button的宽高是受TextView中的变量：mMinWidth，mMinHeight和View中的变量：mMinWidth，mMinHeight来共同决...
WPFButton样式
10-09
在Windows Presentation Foundation (WPF) 中，按钮控件（Button）是用户界面中常见的元素，用于触发一个操作或事件。WPF 提供了强大的样式和模板功能，允许开发者自定义按钮的外观，以满足各种设计需求。本资源...
仿QQ切换button，纯代码实现，告别图片
adr5970的博客
08-14 102
这个是我非常久曾经实现的了，当时记录到我有道云笔记里面，翻阅笔记的时候，发现了这个东西的存在，打算分享给大家，可能对大家来说已经不是什么新奇货了。可是能够帮助新学的了解一下android xml相关的知识。 首先我来看两张效果图： 看到这两张图片，可能对于非常多新学Android的同学来说，第一时间想到的可能就是RadioGroup里面包裹两个RadioB...
自己做的一个button
qq_28585545的博客
10-15 209
自己做的一个button，通过css样式控制button各种状态的样式，分享一下
C# 实现完整功能的截图控件(1)-实现绘图工具栏控件
awark的博客
09-26 738
控件实现了截图、绘制矩形、圆形、箭头、线条、文字，还需要可以撤销绘制步骤、保存图形等功能，基本实现了跟QQ2008截图一样的功能，还可以更换颜色样式和鼠标的样式。截图时候的效果图如下：相关文章：1、C# 实现完整功能的截图控件(1)-实现绘图工具栏控件2、C# 实现完整功能的截图控件(2)-实现颜色和字体选择控件3、C# 实现完整功能的截图控件(3)-实现漂亮的快捷菜单4、C# 实现完整功能的截图...
defaultValue与value、placeholder的区别 (react.js)
热门推荐
宁静致远
05-17 2万+
1.value 某些表单元素的设定值。 例如&lt;input&gt; 标签的 value 属性 2.defaultValue defaultValue 属性可设置或返回文本域的默认值。 注意： 该默认值是规定于 HTML "value" 属性的值。 返回 defaultValue 属性： textObject.defaultValue 设置 defaultValue 属性： ...
java button_java Jbutton常用操作
weixin_42460407的博客
02-12 1564
转：在JFrame中我们经常要对Jbutten做一些特殊的设置，下面的方法是我的一些收集和总结吧1、 对JButton大小的设置button.setPreferredSize(new Dimension(30,30));//(30，30) 是你要设置按钮的大小2、 对JButton透明的设置——按钮设置为透明，这样就不会挡着后面的背景button.setContentAreaFill...
QQ登录界面
A_D_I_D_A_S的博客
08-15 2236
QQ是大家平时使用比较多的一个交友软件，今天我们来实现一下QQ的登录界面。 在实现之前，我们先来想一下QQ的登录界面有哪些基本的组件： 输入框（账号和密码） 登录按钮 复选框 标签 使用的布局：边框布局 代码实现 界面类 package qq; import java.awt.BorderLayout; import java.awt.Dimension; import javax.swi...
QQ分享功能实现-Android
hequnwang10的博客
08-06 1798
这篇主要介绍实现QQ的分享图片功能，这里用QQ官方提供的SDK。QQ的分享功能直接使用，不需要授权软件，所以比较方便。 一、准备工作 1、创建应用 腾讯QQ互联官网进行注册登录，并且创建应用管理，，获取到你的APP ID和APP Key。这里我已经完成了 2、集成SDK QQ互联的官方文档下载SDK，并将jar包导入项目中，这里我已经导入完成了。按照官方文档的步骤一步一步的完成。 二、代码 1、将open-sdk.jar加入编译路径 在app目录下的build.gradle中添加 dependencies
Unity自定义Button
青衫磊落长歌行的博客
01-15 4468
今天给大家带来，Unity中的自定义按钮：CustomButton。因为好多时候吧，UGUI中的Button并不能满足我们的需求，那怎么办？自己写一个！绝对不向困难妥协，但可以向困难拖鞋，熏死困难~！
java button设置_JAVA中JButton常用设置
weixin_34672536的博客
02-20 2026
1、 对JButton大小的设置 ——因为JButen是属于小器件类型的，所以一般的setSize不能对其惊醒大小的设置，所以一般我们用 button.setPreferredSize(new Dimension(30,30)); //(30，30) 是你要设置按钮的大小 2、 对JButton透明的设置 ——按钮设置为透明，这样就不会挡着后面的背...
qml 自定义 button
01-08
此文件夹里面是实现qml 自定义 button的代码，具体的示例在我的博客里面可以查看，不好用不要下载。https://blog.csdn.net/qq_21078557/article/details/86063632
QQ自动登录
09-02
QQ自动登录程序是基于C#编程语言开发的一个实用工具，其主要目的是为了简化用户登录QQ的过程，通过XML文件存储和管理多个账号的信息，实现一键快速登录。本文将深入探讨这个程序涉及的技术点、原理和实现过程。 ...
FabButton.zip
07-30
【标题】"FabButton.zip" 是一个包含FabButton相关源码的压缩文件，可能是用于Android开发的一个组件库。"Floating Action Button"（简称FabButton）是Android应用中常见的一种设计元素，它通常表现为一个圆形的按钮...
C#高仿QQ2014
06-20
开发者会使用Windows Forms控件（如Label、TextBox、Button等）来构建QQ的界面，并通过事件处理程序来响应用户的操作。 2. **WPF (Windows Presentation Foundation)**：虽然描述中未明确提及，但为了创建更现代、...
新型智慧城市项目技术方案（2283页）.pdf
08-16
新型智慧城市项目技术方案（2283页）
openssh windows安装程序
08-16
openssh windows安装程序
java-团员管理系统（源码+数据库+论文）.rar
08-16
共青团员做为我们先进积极分子的培养对象，是未来党人和民的重点培养对象。但随着知识和认识的不断提高，越来越多的青少年选择积极入团，由此而引发的团员管理也成为当下需要解决的问题。日益成熟的互联网技术大大推动了共青团信息化建设的发展，此次毕业设计就是要通过技术的手段来实现团员的信息化管理。 那么业务实现就是为了实现共青团团员的管理系统，那么技术上我们采用的手段还是以目前主流的Java技术为主，那么采用的框架是SSM框架，这样一来更加方便的进行一个团员信息的管理。数据库方面我们使用的是MYSQL数据库，可以有效的快速上手，容易我们开发。 关键词：SSM框架；信息技术；团员管理；
vb+access高校固定资产管理系统(论文+程序).zip
最新发布
08-16
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
jcombobox button
08-19
JComboBox和JButton是Java Swing中的两种常用组件。JComboBox是一个下拉列表框，可以让用户从多个选项中选择一个，而JButton是一个按钮，用于触发特定的操作。 在你提供的引用中，JButton的单击事件代码如下： ```java JButton but = new JButton("按钮"); but.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent arg0) { System.out.println("==================="); } }); ``` 这段代码创建了一个名为"按钮"的JButton，并添加了一个ActionListener监听器。当按钮被点击时，会执行`actionPerformed`方法中的代码，即打印"==================="。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [Swing中JButton和JComboBox的单击事件](https://blog.csdn.net/qq_36880602/article/details/80661136)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *3* [图形用户界面与事件处理机制源文件.rar](https://download.csdn.net/download/qq_44156482/12445544)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值