Mick Doherty's .net Button Tips

Windows XP themed buttons don't show an Image.

Unfortunately when you want to apply Visual Styles to a button you must set it's Flatsyle property to System. Doing this causes the button not to display the image or ForeColor associated with it. The following class overcomes this by applying Visual Styles when the button's Flatsyle is set to Standard.
A State property has also been added to the class so that if you wish to add some painting in the Paint event you will know what the current state of the button is.

			VB Code
			
			Imports System.Runtime.InteropServices
Imports System.ComponentModel

Namespace Dotnetrix.Samples.VB

    Public Enum ButtonDrawState
        [Normal] = 1
        [Hot]
        [Pressed]
        [Disabled]
        [Focused]
    End Enum

    Public Class Button
        Inherits System.Windows.Forms.Button

        Private m_State As ButtonDrawState = ButtonDrawState.Normal
        Private keyPressed As Boolean

        Public Shadows Event Paint As PaintEventHandler

        <Browsable(False)> _
        Public ReadOnly Property State() As ButtonDrawState
            Get
                Return m_State
            End Get
        End Property

        Private ReadOnly Property VisualStylesEnabled() As Boolean
            Get
                Dim dllver As New NativeMethods.DLLVERSIONINFO(Me)
                NativeMethods.CommonControlsGetVersion(dllver)
                If (dllver.dwMajorVersion >= 6) Then
                    Return NativeMethods.IsAppThemed()
                End If
                Return False
            End Get
        End Property

#Region " Draw Methods "

        Protected Overrides Sub OnPaint(ByVal pevent As System.Windows.Forms.PaintEventArgs)

            Dim Result As Boolean

            If Me.FlatStyle = FlatStyle.Standard AndAlso Me.VisualStylesEnabled Then
                pevent.Graphics.Flush()
                Result = DrawVSButton(pevent.Graphics)
                If Result Then
                    DrawImage(pevent.Graphics)
                    DrawText(pevent.Graphics)
                    DrawFocus(pevent.Graphics)
                End If
            End If

            If Not Result Then MyBase.OnPaint(pevent)
            'Raising a Paint Event allows us to custom paint the 
            'content of our Button without modifying this class.
            RaiseEvent Paint(Me, pevent)

        End Sub

        Protected Overridable Function DrawVSButton(ByVal g As Graphics) As Boolean
            Dim ReturnValue As Int32 = 1
            Dim hTheme As IntPtr = NativeMethods.OpenThemeData(Me.Handle, "BUTTON")
            If Not hTheme.Equals(IntPtr.Zero) Then
                Dim hdc As IntPtr = g.GetHdc
                Dim r As New NativeMethods.RECT(New Rectangle(Point.Empty, Me.Size))
                If NativeMethods.DrawThemeParentBackground(Handle, hdc, r) = NativeMethods.S_OK Then
                    ReturnValue = NativeMethods.DrawThemeBackground(hTheme, hdc, 1, m_State, r, r)
                End If
                g.ReleaseHdc(hdc)
                NativeMethods.CloseThemeData(hTheme)
            End If
            Return (ReturnValue = NativeMethods.S_OK)
        End Function

        Protected Overridable Sub DrawImage(ByVal g As Graphics)

            If Me.Image Is Nothing Then Return

            Dim pt As PointF

            Select Case Me.ImageAlign
                Case ContentAlignment.TopLeft
                    pt.X = 5
                    pt.Y = 5
                Case ContentAlignment.TopCenter
                    pt.X = Convert.ToSingle(Width - Me.Image.Width) / 2
                    pt.Y = 5
                Case ContentAlignment.TopRight
                    pt.X = Width - Me.Image.Width - 5
                    pt.Y = 5
                Case ContentAlignment.MiddleLeft
                    pt.X = 5
                    pt.Y = Convert.ToSingle(Height - Me.Image.Height) / 2
                Case ContentAlignment.MiddleCenter
                    pt.X = Convert.ToSingle(Width - Me.Image.Width) / 2
                    pt.Y = Convert.ToSingle(Height - Me.Image.Height) / 2
                Case ContentAlignment.MiddleRight
                    pt.X = Width - Me.Image.Width - 5
                    pt.Y = Convert.ToSingle(Height - Me.Image.Height) / 2
                Case ContentAlignment.BottomLeft
                    pt.X = 5
                    pt.Y = Height - Me.Image.Height - 5
                Case ContentAlignment.BottomCenter
                    pt.X = Convert.ToSingle(Width - Me.Image.Width) / 2
                    pt.Y = Height - Me.Image.Height - 5
                Case Else
                    pt.X = Width - Me.Image.Width - 5
                    pt.Y = Height - Me.Image.Height - 5
            End Select

            If Me.Enabled Then
                If Me.ImageList Is Nothing Then
                    g.DrawImage(Me.Image, pt.X, pt.Y)
                Else
                    Me.ImageList.Draw(g, Point.Round(pt), Me.ImageIndex)
                End If
            Else
                Dim p As Point = Point.Round(pt)
                ControlPaint.DrawImageDisabled(g, Me.Image, p.X, p.Y, Me.BackColor)
            End If

        End Sub

        Protected Overridable Sub DrawText(ByVal g As Graphics)

            Dim TextBrush As New SolidBrush(Me.ForeColor)
            Dim R As New RectangleF(3, 3, Width - 6, Height - 6)

            If Not Me.Enabled Then TextBrush.Color = SystemColors.GrayText

            Dim sf As New StringFormat(StringFormatFlags.LineLimit)

            If ShowKeyboardCues Then
                sf.HotkeyPrefix = System.Drawing.Text.HotkeyPrefix.Show
            Else
                sf.HotkeyPrefix = System.Drawing.Text.HotkeyPrefix.Hide
            End If

            Select Case Me.TextAlign
                Case ContentAlignment.TopLeft
                    sf.Alignment = StringAlignment.Near
                    sf.LineAlignment = StringAlignment.Near
                Case ContentAlignment.TopCenter
                    sf.Alignment = StringAlignment.Center
                    sf.LineAlignment = StringAlignment.Near
                Case ContentAlignment.TopRight
                    sf.Alignment = StringAlignment.Far
                    sf.LineAlignment = StringAlignment.Near
                Case ContentAlignment.MiddleLeft
                    sf.Alignment = StringAlignment.Near
                    sf.LineAlignment = StringAlignment.Center
                Case ContentAlignment.MiddleCenter
                    sf.Alignment = StringAlignment.Center
                    sf.LineAlignment = StringAlignment.Center
                Case ContentAlignment.MiddleRight
                    sf.Alignment = StringAlignment.Far
                    sf.LineAlignment = StringAlignment.Center
                Case ContentAlignment.BottomLeft
                    sf.Alignment = StringAlignment.Near
                    sf.LineAlignment = StringAlignment.Far
                Case ContentAlignment.BottomCenter
                    sf.Alignment = StringAlignment.Center
                    sf.LineAlignment = StringAlignment.Far
                Case Else
                    sf.Alignment = StringAlignment.Far
                    sf.LineAlignment = StringAlignment.Far
            End Select

            g.DrawString(Me.Text, Me.Font, TextBrush, R, sf)

        End Sub

        Protected Overridable Sub DrawFocus(ByVal g As Graphics)
            If Not (Me.ShowFocusCues AndAlso Me.Focused) Then Return
            Dim focusRect As Rectangle = Me.ClientRectangle
            focusRect.Inflate(-3, -3)
            ControlPaint.DrawFocusRectangle(g, focusRect)
        End Sub

#End Region

#Region " Control Actions "

        Protected Overrides Sub OnKeyDown(ByVal kevent As System.Windows.Forms.KeyEventArgs)
            MyBase.OnKeyDown(kevent)
            If Not Me.Enabled Then Return
            If kevent.KeyValue = Keys.Space Then
                keyPressed = True
                m_State = ButtonDrawState.Pressed
                Invalidate()
            End If
        End Sub

        Protected Overrides Sub OnKeyUp(ByVal kevent As System.Windows.Forms.KeyEventArgs)
            MyBase.OnKeyUp(kevent)
            If Not Me.Enabled Then Return
            If kevent.KeyValue = Keys.Space Then
                keyPressed = False
                m_State = ButtonDrawState.Focused
                Invalidate()
            End If
        End Sub

        Protected Overrides Sub OnMouseEnter(ByVal eventargs As System.EventArgs)
            MyBase.OnMouseEnter(eventargs)
            If Me.Enabled And Not keyPressed Then
                m_State = ButtonDrawState.Hot
                Invalidate()
            End If
        End Sub

        Protected Overrides Sub OnMouseLeave(ByVal eventargs As System.EventArgs)
            MyBase.OnMouseLeave(eventargs)
            If Me.Enabled And Not keyPressed Then
                If Me.IsDefault Then
                    m_State = ButtonDrawState.Focused
                Else
                    m_State = ButtonDrawState.Normal
                End If
                Invalidate()
            End If
        End Sub

        Protected Overrides Sub OnMouseDown(ByVal mevent As System.Windows.Forms.MouseEventArgs)
            MyBase.OnMouseDown(mevent)
            If Not Me.Enabled Then Return
            If mevent.Button = MouseButtons.Left Then
                m_State = ButtonDrawState.Pressed
                Invalidate()
            End If
        End Sub

        Protected Overrides Sub OnMouseUp(ByVal mevent As System.Windows.Forms.MouseEventArgs)
            MyBase.OnMouseUp(mevent)
            If Me.Enabled Then
                m_State = ButtonDrawState.Focused
                Invalidate()
            End If
        End Sub

        Protected Overrides Sub OnMouseMove(ByVal mevent As System.Windows.Forms.MouseEventArgs)
            MyBase.OnMouseMove(mevent)
            If Not Me.Enabled Then Return
            If New Rectangle(Point.Empty, Me.Size).Contains(mevent.X, mevent.Y) AndAlso mevent.Button = MouseButtons.Left Then
                m_State = ButtonDrawState.Pressed
            Else
                If keyPressed Then Return
                m_State = ButtonDrawState.Hot
            End If
            Invalidate()
        End Sub

        Protected Overrides Sub OnGotFocus(ByVal e As System.EventArgs)
            MyBase.OnGotFocus(e)
            If Me.Enabled Then
                m_State = ButtonDrawState.Focused
                Invalidate()
            End If
        End Sub

        Protected Overrides Sub OnLostFocus(ByVal e As System.EventArgs)
            MyBase.OnLostFocus(e)
            If Me.Enabled Then
                m_State = ButtonDrawState.Normal
                Invalidate()
            End If
        End Sub

        Protected Overrides Sub OnEnabledChanged(ByVal e As System.EventArgs)
            MyBase.OnEnabledChanged(e)
            If Me.Enabled Then
                m_State = ButtonDrawState.Normal
            Else
                m_State = ButtonDrawState.Disabled
            End If
            Invalidate()
        End Sub

        Protected Overrides Sub OnClick(ByVal e As System.EventArgs)
            MyBase.OnClick(e)
            MyBase.OnLostFocus(EventArgs.Empty)
        End Sub

        Protected Overrides Sub OnDoubleClick(ByVal e As System.EventArgs)
            MyBase.OnClick(e)
            MyBase.OnLostFocus(EventArgs.Empty)
        End Sub

#End Region

    End Class

    Friend Class NativeMethods

        Private Sub New()
            'Uninstantiable Class
        End Sub

        <DllImport("Comctl32.dll", CallingConvention:=CallingConvention.Cdecl, entrypoint:="DllGetVersion")> _
        Public Shared Function CommonControlsGetVersion(ByRef pdvi As DLLVERSIONINFO) As Int32
        End Function

        Public Structure DLLVERSIONINFO
            Dim cbSize As Int32
            Dim dwMajorVersion As Int32
            Dim dwMinorVersion As Int32
            Dim dwBuildNumber As Int32
            Dim dwPlatformID As Int32
            Public Sub New(ByVal Owner As Object)
                cbSize = Marshal.SizeOf(GetType(DLLVERSIONINFO))
            End Sub
        End Structure

        <DllImport("UxTheme.dll", CallingConvention:=CallingConvention.Cdecl)> _
        Public Shared Function IsAppThemed() As <MarshalAs(UnmanagedType.Bool)> Boolean
        End Function

        <DllImport("UxTheme.dll", CallingConvention:=CallingConvention.Cdecl, CharSet:=CharSet.Unicode)> _
        Public Shared Function OpenThemeData(ByVal hwnd As IntPtr, ByVal pszClassList As String) As IntPtr
        End Function

        <DllImport("UxTheme.dll", CallingConvention:=CallingConvention.Cdecl)> _
        Public Shared Function CloseThemeData(ByVal hTheme As IntPtr) As Int32
        End Function

        <DllImport("UxTheme.dll", CallingConvention:=CallingConvention.Cdecl)> _
        Public Shared Function DrawThemeParentBackground(ByVal hwnd As IntPtr, ByVal hdc As IntPtr, ByRef prc As RECT) As Int32
        End Function

        <DllImport("UxTheme.dll", CallingConvention:=CallingConvention.Cdecl)> _
        Public Shared Function DrawThemeBackground(ByVal hTheme As IntPtr, ByVal hdc As IntPtr, ByVal iPartId As Int32, ByVal iStateId As Int32, ByRef pRect As RECT, ByRef pClipRect As RECT) As Int32
        End Function

        Public Structure RECT
            Public l, t, r, b As Int32
            Public Sub New(ByVal rect As Rectangle)
                l = rect.Left
                t = rect.Top
                r = rect.Right
                b = rect.Bottom
            End Sub
        End Structure

        Public Const S_OK As Int32 = 0

    End Class

End Namespace      
			
C# Code
			
			using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Windows.Forms;

using System.Runtime.InteropServices;

namespace Dotnetrix.Samples.CSharp
{
    
    public enum ButtonDrawState 
    {
        Normal = 1,
        Hot,
        Pressed,
        Disabled,
        Focused
    }


    /// <summary>
    /// Summary description for Button.
    /// </summary>
    public class Button : System.Windows.Forms.Button
    {
        /// <summary> 
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public Button()
        {
            // This call is required by the Windows.Forms Form Designer.
            InitializeComponent();

            // TODO: Add any initialization after the InitializeComponent call

        }


        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose( bool disposing )
        {
            if( disposing )
            {
                if(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

        private ButtonDrawState m_State  = ButtonDrawState.Normal;
        private bool keyPressed;
        
        public new event PaintEventHandler Paint;

        [Browsable(false)]
        public ButtonDrawState State
        {
            get{return m_State;}
        }


        private bool VisualStylesEnabled
        {
            get
            {
                NativeMethods.DLLVERSIONINFO dllver = new NativeMethods.DLLVERSIONINFO();
                dllver.cbSize = Marshal.SizeOf(dllver);
                NativeMethods.CommonControlsGetVersion(ref dllver);
                if (dllver.dwMajorVersion >= 6)
                {
                    return NativeMethods.IsAppThemed();
                }
                return false;
            }
        }
        

        #region Draw Methods

        protected override void OnPaint(PaintEventArgs e)
        {
            bool Result=false;

            if (this.FlatStyle == FlatStyle.Standard && this.VisualStylesEnabled)
            {
                e.Graphics.Flush();
                Result = DrawVSButton(e.Graphics);
                if (Result)
                {
                    DrawImage(e.Graphics);
                    DrawText(e.Graphics);
                    DrawFocus(e.Graphics);
                }
            }

            if (Result == false) base.OnPaint (e);
            //Raising a Paint Event allows us to custom paint the 
            //content of our Button without modifying this class.
            if (Paint != null)
                Paint(this, e);

        }


        protected bool DrawVSButton(Graphics g)
        {
            int ReturnValue = 1;
            IntPtr hTheme = NativeMethods.OpenThemeData(this.Handle, "BUTTON");
            if (!hTheme.Equals(IntPtr.Zero))
            {
                IntPtr hdc = g.GetHdc();
                NativeMethods.RECT r = new NativeMethods.RECT(new Rectangle(Point.Empty, this.Size));
                if (NativeMethods.DrawThemeParentBackground(Handle, hdc, ref r) == NativeMethods.S_OK)
                {
                    ReturnValue = NativeMethods.DrawThemeBackground(hTheme, hdc, 1, (int)m_State, ref r, ref r);
                }
                g.ReleaseHdc(hdc);
                NativeMethods.CloseThemeData(hTheme);
            }
            return (ReturnValue == NativeMethods.S_OK);
        }


        protected void DrawImage(Graphics g)
        {
            if (this.Image == null) return;
            
            PointF pt = new Point();
            
            switch (this.ImageAlign)
            {
                case ContentAlignment.TopLeft:
                {
                    pt.X = 5;
                    pt.Y = 5;
                    break;
                }
                case ContentAlignment.TopCenter:
                {
                    pt.X = Convert.ToSingle(Width - this.Image.Width) / 2;
                    pt.Y = 5;
                    break;
                }
                case ContentAlignment.TopRight:
                {
                    pt.X = Width - this.Image.Width - 5;
                    pt.Y = 5;
                    break;
                }
                case ContentAlignment.MiddleLeft:
                {
                    pt.X = 5;
                    pt.Y = Convert.ToSingle(Height - this.Image.Height) / 2;
                    break;
                }
                case ContentAlignment.MiddleCenter:
                {
                    pt.X = Convert.ToSingle(Width - this.Image.Width) / 2;
                    pt.Y = Convert.ToSingle(Height - this.Image.Height) / 2;
                    break;
                }
                case ContentAlignment.MiddleRight:
                {
                    pt.X = Width - this.Image.Width - 5;
                    pt.Y = Convert.ToSingle(Height - this.Image.Height) / 2;
                    break;
                }
                case ContentAlignment.BottomLeft:
                {
                    pt.X = 5;
                    pt.Y = Height - this.Image.Height - 5;
                    break;
                }
                case ContentAlignment.BottomCenter:
                {
                    pt.X = Convert.ToSingle(Width - this.Image.Width) / 2;
                    pt.Y = Height - this.Image.Height - 5;
                    break;
                }
                default:
                {
                    pt.X = Width - this.Image.Width - 5;
                    pt.Y = Height - this.Image.Height - 5;
                    break;
                }
            }
            
            if (this.Enabled)
            {
                if (this.ImageList == null)
                    g.DrawImage(this.Image, pt.X, pt.Y);
                else
                    this.ImageList.Draw(g, Point.Round(pt), this.ImageIndex);
            }
            else
                ControlPaint.DrawImageDisabled(g, this.Image, (int)pt.X, (int)pt.Y, this.BackColor);
        }


        protected void DrawText(Graphics g)
        {
            SolidBrush TextBrush = new SolidBrush(this.ForeColor);
            RectangleF R = new RectangleF(3, 3, Width - 6, Height - 6);
            
            if (!this.Enabled) TextBrush.Color = SystemColors.GrayText;
            
            StringFormat sf = new StringFormat(StringFormatFlags.LineLimit);
            
            if (ShowKeyboardCues)
                sf.HotkeyPrefix = System.Drawing.Text.HotkeyPrefix.Show;
            else
                sf.HotkeyPrefix = System.Drawing.Text.HotkeyPrefix.Hide;

            switch (this.TextAlign)
            {
                case ContentAlignment.TopLeft:
                {
                    sf.Alignment = StringAlignment.Near;
                    sf.LineAlignment = StringAlignment.Near;
                    break;
                }
                case ContentAlignment.TopCenter:
                {
                    sf.Alignment = StringAlignment.Center;
                    sf.LineAlignment = StringAlignment.Near;
                    break;
                }
                case ContentAlignment.TopRight:
                {
                    sf.Alignment = StringAlignment.Far;
                    sf.LineAlignment = StringAlignment.Near;
                    break;
                }
                case ContentAlignment.MiddleLeft:
                {
                    sf.Alignment = StringAlignment.Near;
                    sf.LineAlignment = StringAlignment.Center;
                    break;
                }
                case ContentAlignment.MiddleCenter:
                {
                    sf.Alignment = StringAlignment.Center;
                    sf.LineAlignment = StringAlignment.Center;
                    break;
                }
                case ContentAlignment.MiddleRight:
                {
                    sf.Alignment = StringAlignment.Far;
                    sf.LineAlignment = StringAlignment.Center;
                    break;
                }
                case ContentAlignment.BottomLeft:
                {
                    sf.Alignment = StringAlignment.Near;
                    sf.LineAlignment = StringAlignment.Far;
                    break;
                }
                case ContentAlignment.BottomCenter:
                {
                    sf.Alignment = StringAlignment.Center;
                    sf.LineAlignment = StringAlignment.Far;
                    break;
                }
                default:
                {
                    sf.Alignment = StringAlignment.Far;
                    sf.LineAlignment = StringAlignment.Far;
                    break;
                }
            }

            g.DrawString(this.Text, this.Font, TextBrush, R, sf);

        }
        

        protected void DrawFocus(Graphics g)
        {
            if ((this.ShowFocusCues && this.Focused)==false) return;
            Rectangle focusRect = this.ClientRectangle;
            focusRect.Inflate(-3, -3);
            ControlPaint.DrawFocusRectangle(g, focusRect);
        }


        #endregion

        #region Control Actions

        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown (e);
            if (!this.Enabled) return;
            if (e.KeyValue==(int)Keys.Space)
            {
                keyPressed = true;
                m_State = ButtonDrawState.Pressed;
                Invalidate();
            }
        }


        protected override void OnKeyUp(KeyEventArgs e)
        {
            base.OnKeyUp (e);
            if (e.KeyValue == (int)Keys.Space)
            {
                keyPressed = false;
                m_State = ButtonDrawState.Focused;
                Invalidate();
            }
        }

        
        protected override void OnMouseEnter(EventArgs e)
        {
            base.OnMouseEnter (e);
            if (this.Enabled && !keyPressed)
            {
                m_State = ButtonDrawState.Hot;
                Invalidate();
            }
        }


        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave (e);
            if (this.Enabled && !keyPressed)
            {
                if (this.IsDefault)
                {
                    m_State = ButtonDrawState.Focused;
                }
                else
                {
                    m_State = ButtonDrawState.Normal;
                }
                Invalidate();
            }
        }


        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown (e);
            if (!this.Enabled) return;
            if (e.Button == MouseButtons.Left)
            {
                m_State = ButtonDrawState.Pressed;
                Invalidate();
            }
        }


        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp (e);
            if (this.Enabled) 
            {
                m_State = ButtonDrawState.Focused;
                Invalidate();
            }
        }


        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove (e);
            if (!this.Enabled) return;
            if (Rectangle.FromLTRB(0,0,Width,Height).Contains(e.X, e.Y) && e.Button == MouseButtons.Left)
                m_State = ButtonDrawState.Pressed;
            else
            {
                if (keyPressed) return;
                m_State = ButtonDrawState.Hot;
            }
            Invalidate();
        }

        
        protected override void OnGotFocus(EventArgs e)
        {
            base.OnGotFocus (e);
            if (this.Enabled)
            {
                m_State = ButtonDrawState.Focused;
                Invalidate();
            }
        }


        protected override void OnLostFocus(EventArgs e)
        {
            base.OnLostFocus (e);
            if (this.Enabled)
            {
                m_State = ButtonDrawState.Normal;
                Invalidate();
            }
        }
        

        protected override void OnEnabledChanged(EventArgs e)
        {
            base.OnEnabledChanged (e);
            if (this.Enabled)
            {
                m_State = ButtonDrawState.Normal;
            }
            else
            {
                m_State = ButtonDrawState.Disabled;
            }
            Invalidate();

        }


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


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


        #endregion

    }

    internal class NativeMethods
    {
        private NativeMethods()
        {
            //Uninstantiable Class
        }

        [DllImport("Comctl32.dll", CallingConvention=CallingConvention.Cdecl, EntryPoint="DllGetVersion")]
        public static extern int CommonControlsGetVersion(ref DLLVERSIONINFO pdvi);

        public struct DLLVERSIONINFO
        {
            public int cbSize, dwMajorVersion, dwMinorVersion, dwBuildNumber, dwPlatformID;
        }


        [DllImport("UxTheme.dll", CallingConvention=CallingConvention.Cdecl)]
        public static extern bool IsAppThemed();

        [DllImport("UxTheme.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Unicode)]
        public static extern IntPtr OpenThemeData(IntPtr hwnd, String pszClassList);

        [DllImport("UxTheme.dll", CallingConvention=CallingConvention.Cdecl)]
        public static extern int CloseThemeData(IntPtr hTheme);

        [DllImport("UxTheme.dll", CallingConvention=CallingConvention.Cdecl)]
        public static extern int DrawThemeParentBackground(IntPtr hwnd, IntPtr hdc, ref RECT prc);

        [DllImport("UxTheme.dll", CallingConvention=CallingConvention.Cdecl)]
        public static extern int DrawThemeBackground(IntPtr hTheme, IntPtr hdc, int iPartId, int iStateId, ref RECT pRect, ref RECT pClipRect);

        public struct RECT
        {
            public int l, t, r, b;
            public RECT(Rectangle rect)
            {
                l = rect.Left;
                t = rect.Top;
                r = rect.Right;
                b = rect.Bottom;
            }
        }


        public const int S_OK  = 0;

    }
}
			
			

			

There's a bit more to it than just overriding OnPaint.

Windows XP themed buttons don't show an Image (an alternative method).

This class is much simpler than the one above, but it only works on XP Styled System buttons. If XP Visual Styles are not in use then the button will still not show an image. The advantage to this method is that there is no special handling necessary in order to know which state to draw the button in as we still allow the System to draw the button, unlike in the class above in which we draw the Visual Styled button ourselves.

			VB Code
			
			Imports System.Runtime.InteropServices

Namespace Dotnetrix.Samples.VB

    Public Class ButtonPlus
        Inherits System.Windows.Forms.Button

        Protected Overrides Sub WndProc(ByRef m As System.Windows.Forms.Message)
            MyBase.WndProc(m)
            If m.Msg = (NativeMethods.WM_REFLECT Or NativeMethods.WM_NOTIFY) Then
                Dim CustomDrawHeader As NativeMethods.NMCUSTOMDRAW = DirectCast(Marshal.PtrToStructure(m.LParam, GetType(NativeMethods.NMCUSTOMDRAW)), NativeMethods.NMCUSTOMDRAW)
                If CustomDrawHeader.dwDrawStage = NativeMethods.CustomDrawDrawStage.CDDS_PREPAINT Then
                    Dim g As Graphics = Graphics.FromHdc(CustomDrawHeader.hdc)
                    Dim pe As New PaintEventArgs(g, Me.Bounds)
                    OnPaint(pe)
                    pe.Dispose()
                    g.Dispose()
                End If
            End If
        End Sub

        Protected Overrides Sub OnPaint(ByVal pevent As System.Windows.Forms.PaintEventArgs)
            MyBase.OnPaint(pevent)
            DrawImage(pevent.Graphics)
        End Sub

        Protected Overridable Sub DrawImage(ByVal g As Graphics)

            If Me.Image Is Nothing Then Return

            Dim pt As PointF

            Select Case Me.ImageAlign
                Case ContentAlignment.TopLeft
                    pt.X = 5
                    pt.Y = 5
                Case ContentAlignment.TopCenter
                    pt.X = Convert.ToSingle(Width - Me.Image.Width) / 2
                    pt.Y = 5
                Case ContentAlignment.TopRight
                    pt.X = Width - Me.Image.Width - 5
                    pt.Y = 5
                Case ContentAlignment.MiddleLeft
                    pt.X = 5
                    pt.Y = Convert.ToSingle(Height - Me.Image.Height) / 2
                Case ContentAlignment.MiddleCenter
                    pt.X = Convert.ToSingle(Width - Me.Image.Width) / 2
                    pt.Y = Convert.ToSingle(Height - Me.Image.Height) / 2
                Case ContentAlignment.MiddleRight
                    pt.X = Width - Me.Image.Width - 5
                    pt.Y = Convert.ToSingle(Height - Me.Image.Height) / 2
                Case ContentAlignment.BottomLeft
                    pt.X = 5
                    pt.Y = Height - Me.Image.Height - 5
                Case ContentAlignment.BottomCenter
                    pt.X = Convert.ToSingle(Width - Me.Image.Width) / 2
                    pt.Y = Height - Me.Image.Height - 5
                Case Else
                    pt.X = Width - Me.Image.Width - 5
                    pt.Y = Height - Me.Image.Height - 5
            End Select

            If Me.Enabled Then
                If Me.ImageList Is Nothing Then
                    g.DrawImage(Me.Image, pt.X, pt.Y)
                Else
                    Me.ImageList.Draw(g, Point.Round(pt), Me.ImageIndex)
                End If
            Else
                Dim p As Point = Point.Round(pt)
                ControlPaint.DrawImageDisabled(g, Me.Image, p.X, p.Y, Me.BackColor)
            End If

        End Sub

    End Class

    Friend Class NativeMethods

        Private Sub New()
            'Uninstantiable Class
        End Sub

        Public Const WM_USER As Int32 = &H400&
        Public Const WM_NOTIFY As Int32 = &H4E&
        Public Const WM_REFLECT As Int32 = WM_USER + &H1C00&
        Public Const NM_FIRST As Int32 = 0
        Public Const NM_CUSTOMDRAW As Int32 = NM_FIRST Or -12

        Public Enum CustomDrawDrawStage
            CDDS_PREPAINT = &H1
            CDDS_POSTPAINT = &H2
            CDDS_PREERASE = &H3
            CDDS_POSTERASE = &H4
            CDDS_ITEM = &H10000
            CDDS_ITEMPREPAINT = (CDDS_ITEM Or CDDS_PREPAINT)
            CDDS_ITEMPOSTPAINT = (CDDS_ITEM Or CDDS_POSTPAINT)
            CDDS_ITEMPREERASE = (CDDS_ITEM Or CDDS_PREERASE)
            CDDS_ITEMPOSTERASE = (CDDS_ITEM Or CDDS_POSTERASE)
            CDDS_SUBITEM = &H20000
        End Enum

        Public Enum CustomDrawItemState
            CDIS_SELECTED = &H1
            CDIS_GRAYED = &H2
            CDIS_DISABLED = &H4
            CDIS_CHECKED = &H8
            CDIS_FOCUS = &H10
            CDIS_DEFAULT = &H20
            CDIS_HOT = &H40
            CDIS_MARKED = &H80
            CDIS_INDETERMINATE = &H100
            CDIS_SHOWKEYBOARDCUES = &H200
        End Enum

        <StructLayout(LayoutKind.Sequential)> _
        Public Structure NMHDR
            Public HWND As Int32
            Public idFrom As Int32
            Public code As Int32
            Public Overloads Function ToString() As String
                Return String.Format("Hwnd: {0}, ControlID: {1}, Code: {2}", HWND, idFrom, code)
            End Function
        End Structure

        <StructLayout(LayoutKind.Sequential)> _
        Public Structure NMCUSTOMDRAW
            Public hdr As NMHDR
            Public dwDrawStage As CustomDrawDrawStage
            Public hdc As IntPtr
            Public rc As RECT
            Public dwItemSpec As IntPtr
            Public uItemState As CustomDrawItemState
            Public lItemlParam As IntPtr
        End Structure

        <StructLayout(LayoutKind.Sequential)> _
        Public Structure RECT
            Public left, top, right, bottom As Int32
        End Structure

    End Class

End Namespace      
			
C# Code
			
			using System;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace Dotnetrix.Samples.CSharp
{
    /// <summary>
    /// Summary description for ButtonPlus.
    /// </summary>
    public class ButtonPlus : System.Windows.Forms.Button
    {

        protected override void WndProc(ref System.Windows.Forms.Message m)
        {
            base.WndProc (ref m);
            if (m.Msg == (NativeMethods.WM_REFLECT | NativeMethods.WM_NOTIFY))
            {
                NativeMethods.NMCUSTOMDRAW CustomDrawHeader = (NativeMethods.NMCUSTOMDRAW)Marshal.PtrToStructure(m.LParam, typeof(NativeMethods.NMCUSTOMDRAW));
                if (CustomDrawHeader.dwDrawStage == NativeMethods.CustomDrawDrawStage.CDDS_PREPAINT)
                {
                    Graphics g = Graphics.FromHdc(CustomDrawHeader.hdc);
                    PaintEventArgs pe = new PaintEventArgs(g, this.Bounds);
                    OnPaint(pe);
                    pe.Dispose();
                    g.Dispose();
                }
            }
        }


        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
            base.OnPaint(e);
            DrawImage(e.Graphics);
        }


        protected void DrawImage(Graphics g)
        {
            if (this.Image == null) return;
            
            PointF pt = new Point();
            
            switch (this.ImageAlign)
            {
                case ContentAlignment.TopLeft:
                {
                    pt.X = 5;
                    pt.Y = 5;
                    break;
                }
                case ContentAlignment.TopCenter:
                {
                    pt.X = Convert.ToSingle(Width - this.Image.Width) / 2;
                    pt.Y = 5;
                    break;
                }
                case ContentAlignment.TopRight:
                {
                    pt.X = Width - this.Image.Width - 5;
                    pt.Y = 5;
                    break;
                }
                case ContentAlignment.MiddleLeft:
                {
                    pt.X = 5;
                    pt.Y = Convert.ToSingle(Height - this.Image.Height) / 2;
                    break;
                }
                case ContentAlignment.MiddleCenter:
                {
                    pt.X = Convert.ToSingle(Width - this.Image.Width) / 2;
                    pt.Y = Convert.ToSingle(Height - this.Image.Height) / 2;
                    break;
                }
                case ContentAlignment.MiddleRight:
                {
                    pt.X = Width - this.Image.Width - 5;
                    pt.Y = Convert.ToSingle(Height - this.Image.Height) / 2;
                    break;
                }
                case ContentAlignment.BottomLeft:
                {
                    pt.X = 5;
                    pt.Y = Height - this.Image.Height - 5;
                    break;
                }
                case ContentAlignment.BottomCenter:
                {
                    pt.X = Convert.ToSingle(Width - this.Image.Width) / 2;
                    pt.Y = Height - this.Image.Height - 5;
                    break;
                }
                default:
                {
                    pt.X = Width - this.Image.Width - 5;
                    pt.Y = Height - this.Image.Height - 5;
                    break;
                }
            }
            
            if (this.Enabled)
            {
                if (this.ImageList == null)
                    g.DrawImage(this.Image, pt.X, pt.Y);
                else
                    this.ImageList.Draw(g, Point.Round(pt), this.ImageIndex);
            }
            else
                ControlPaint.DrawImageDisabled(g, this.Image, (int)pt.X, (int)pt.Y, this.BackColor);
        }
    
    }

    internal class NativeMethods
    {
        private NativeMethods()
        {
            //Uninstantiable Class
        }
        

        public const int WM_USER  = 0x400;
        public const int WM_NOTIFY = 0x4E;
        public const int WM_REFLECT = WM_USER + 0x1C00;
        public const int NM_FIRST = 0;
        public const int NM_CUSTOMDRAW = NM_FIRST | -12;

        public enum CustomDrawDrawStage
        {
            CDDS_PREPAINT = 0x1,
            CDDS_POSTPAINT = 0x2,
            CDDS_PREERASE = 0x3,
            CDDS_POSTERASE = 0x4,
            CDDS_ITEM = 0x10000,
            CDDS_ITEMPREPAINT = (CDDS_ITEM | CDDS_PREPAINT),
            CDDS_ITEMPOSTPAINT = (CDDS_ITEM | CDDS_POSTPAINT),
            CDDS_ITEMPREERASE = (CDDS_ITEM | CDDS_PREERASE),
            CDDS_ITEMPOSTERASE = (CDDS_ITEM | CDDS_POSTERASE),
            CDDS_SUBITEM = 0x20000
        }

        
        public enum CustomDrawItemState
        {
            CDIS_SELECTED = 0x1,
            CDIS_GRAYED = 0x2,
            CDIS_DISABLED = 0x4,
            CDIS_CHECKED = 0x8,
            CDIS_FOCUS = 0x10,
            CDIS_DEFAULT = 0x20,
            CDIS_HOT = 0x40,
            CDIS_MARKED = 0x80,
            CDIS_INDETERMINATE = 0x100,
            CDIS_SHOWKEYBOARDCUES = 0x200
        }

        
        [StructLayout(LayoutKind.Sequential)]
        public struct NMHDR
        {
            public IntPtr HWND;
            public int idFrom;
            public int code;
            public override String ToString()
            {
                return String.Format("Hwnd: {0}, ControlID: {1}, Code: {2}", HWND, idFrom, code);
            }
        }


        [StructLayout(LayoutKind.Sequential)]
        public struct NMCUSTOMDRAW
        {
            public NMHDR hdr;
            public CustomDrawDrawStage dwDrawStage;
            public IntPtr hdc;
            public RECT rc;
            public IntPtr dwItemSpec;
            public CustomDrawItemState uItemState;
            public IntPtr lItemlParam;
        }
        

        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int left, top, right, bottom;
        }


    }


}
			
			

			

Creating Custom Buttons by Implementing IButtonControl.

No need to Inherit from Button if you want a button with a completely custom appearance. The following class defines a Custom Button which can be set as a forms AcceptButton or CancelButton, but which is inherited from Control rather than Button. It also includes a custom TypeEditor to allow selection of corners to be rounded.

			VB Code
			
			    Imports System.ComponentModel
    Imports System.Security.Permissions
    Imports System.Drawing.Design
    Imports System.Windows.Forms.Design

    Namespace Dotnetrix.Samples.VB

        <Flags()> _
        Public Enum Corners
            None = 0
            TopLeft = 1
            TopRight = 2
            BottomLeft = 4
            BottomRight = 8
            All = TopLeft Or TopRight Or BottomLeft Or BottomRight
        End Enum

        Public Enum CustomButtonState
            [Normal] = 1
            [Hot]
            [Pressed]
            [Disabled]
            [Focused]
        End Enum

        Public Class CustomButton
            Inherits Control
            Implements IButtonControl

            Public Sub New()
                MyBase.New()
                Me.SetStyle(ControlStyles.Selectable Or ControlStyles.StandardClick Or ControlStyles.ResizeRedraw Or ControlStyles.AllPaintingInWmPaint Or ControlStyles.DoubleBuffer Or ControlStyles.UserPaint Or ControlStyles.SupportsTransparentBackColor, True)
            End Sub

    #Region " Private Instance Variables "

            Private m_DialogResult As DialogResult
            Private m_IsDefault As Boolean

            Private m_CornerRadius As Int32 = 8
            Private m_RoundCorners As Corners
            Private m_ButtonState As CustomButtonState = CustomButtonState.Normal

            Private m_ImageAlign As ContentAlignment = ContentAlignment.MiddleCenter
            Private m_TextAlign As ContentAlignment = ContentAlignment.MiddleCenter
            Private m_ImageList As ImageList
            Private m_ImageIndex As Int32 = -1

            Private keyPressed As Boolean
            Private contentRect As Rectangle

    #End Region

    #Region " IButtonControl Implementation "

            <Category("Behavior"), DefaultValue(GetType(DialogResult), "None"), _
            Description("The dialog result produced in a modal form by clicking the button.")> _
            Public Property DialogResult() As System.Windows.Forms.DialogResult Implements System.Windows.Forms.IButtonControl.DialogResult
                Get
                    Return m_DialogResult
                End Get
                Set(ByVal Value As System.Windows.Forms.DialogResult)
                    If [Enum].IsDefined(GetType(DialogResult), Value) Then
                        m_DialogResult = Value
                    End If
                End Set
            End Property

            Public Sub NotifyDefault(ByVal value As Boolean) Implements System.Windows.Forms.IButtonControl.NotifyDefault
                If m_IsDefault <> value Then
                    m_IsDefault = value
                End If
                Me.Invalidate()
            End Sub

            Public Sub PerformClick() Implements System.Windows.Forms.IButtonControl.PerformClick
                If Me.CanSelect Then
                    MyBase.OnClick(EventArgs.Empty)
                End If
            End Sub

    #End Region

    #Region " Properties "

            'ButtonState
            <Browsable(False)> _
            Public ReadOnly Property ButtonState() As CustomButtonState
                Get
                    Return m_ButtonState
                End Get
            End Property

            'CornerRadius
            <Category("Appearance"), _
            DefaultValue(8), _
            Description("Defines the radius of the controls RoundedCorners.")> _
            Public Property CornerRadius() As Int32
                Get
                    Return m_CornerRadius
                End Get
                Set(ByVal Value As Int32)
                    If m_CornerRadius = Value Then Return
                    m_CornerRadius = Value
                    Me.Invalidate()
                End Set
            End Property

            'DefaultSize
            Protected Overrides ReadOnly Property DefaultSize() As System.Drawing.Size
                Get
                    Return New Size(75, 23)
                End Get
            End Property

            'IsDefault
            <Browsable(False)> _
            Public ReadOnly Property IsDefault() As Boolean
                Get
                    Return m_IsDefault
                End Get
            End Property

            'ImageList
            <Category("Appearance"), DefaultValue(GetType(ImageList), Nothing), _
            Description("The image list to get the image to display in the face of the control.")> _
            Public Property ImageList() As ImageList
                Get
                    Return m_ImageList
                End Get
                Set(ByVal Value As ImageList)
                    m_ImageList = Value
                    Me.Invalidate()
                End Set
            End Property

            'ImageIndex
            <Category("Appearance"), DefaultValue(-1), _
            Description("The index of the image in the image list to display in the face of the control."), _
            TypeConverter(GetType(ImageIndexConverter)), _
            Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design", GetType(System.Drawing.Design.UITypeEditor))> _
            Public Property ImageIndex() As Int32
                Get
                    Return m_ImageIndex
                End Get
                Set(ByVal Value As Int32)
                    m_ImageIndex = Value
                    Me.Invalidate()
                End Set
            End Property

            'ImageAlign
            <Category("Appearance"), DefaultValue(GetType(ContentAlignment), "MiddleCenter"), _
            Description("The alignment of the image that will be displayed in the face of the control.")> _
            Public Property ImageAlign() As ContentAlignment
                Get
                    Return m_ImageAlign
                End Get
                Set(ByVal Value As ContentAlignment)
                    If Not [Enum].IsDefined(GetType(ContentAlignment), Value) Then
                        Throw New InvalidEnumArgumentException("value", CInt(Value), GetType(ContentAlignment))
                    End If
                    If m_ImageAlign = Value Then Return
                    m_ImageAlign = Value
                    Invalidate()
                End Set
            End Property

            'RoundCorners
            <Category("Appearance"), _
            DefaultValue(GetType(Corners), "None"), _
            Description("Gets/sets the corners of the control to round."), _
            Editor(GetType(RoundCornersEditor), GetType(UITypeEditor)), _
            DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)> _
            Public Property RoundCorners() As Corners
                Get
                    Return m_RoundCorners
                End Get
                Set(ByVal Value As Corners)
                    If m_RoundCorners = Value Then Return
                    m_RoundCorners = Value
                    Me.Invalidate()
                End Set
            End Property

            'TextAlign
            <Category("Appearance"), DefaultValue(GetType(ContentAlignment), "MiddleCenter"), _
            Description("The alignment of the text that will be displayed in the face of the control.")> _
            Public Property TextAlign() As ContentAlignment
                Get
                    Return m_TextAlign
                End Get
                Set(ByVal Value As ContentAlignment)
                    If Not [Enum].IsDefined(GetType(ContentAlignment), Value) Then
                        Throw New InvalidEnumArgumentException("value", CInt(Value), GetType(ContentAlignment))
                    End If
                    If m_TextAlign = Value Then Return
                    m_TextAlign = Value
                    Invalidate()
                End Set
            End Property

    #End Region

    #Region " Overriden Methods "

            Protected Overrides Sub OnKeyDown(ByVal kevent As System.Windows.Forms.KeyEventArgs)
                MyBase.OnKeyDown(kevent)
                If kevent.KeyValue = Keys.Space Then
                    keyPressed = True
                    m_ButtonState = CustomButtonState.Pressed
                End If
                OnStateChange(EventArgs.Empty)
            End Sub

            Protected Overrides Sub OnKeyUp(ByVal kevent As System.Windows.Forms.KeyEventArgs)
                MyBase.OnKeyUp(kevent)
                If kevent.KeyValue = Keys.Space Then
                    If Me.ButtonState = CustomButtonState.Pressed Then
                        Me.PerformClick()
                    End If
                    keyPressed = False
                    m_ButtonState = CustomButtonState.Focused
                End If
                OnStateChange(EventArgs.Empty)
            End Sub

            Protected Overrides Sub OnMouseEnter(ByVal eventargs As System.EventArgs)
                MyBase.OnMouseEnter(eventargs)
                If Not keyPressed Then
                    m_ButtonState = CustomButtonState.Hot
                End If
                OnStateChange(eventargs.Empty)
            End Sub

            Protected Overrides Sub OnMouseLeave(ByVal eventargs As System.EventArgs)
                MyBase.OnMouseLeave(eventargs)
                If Not keyPressed Then
                    If Me.IsDefault Then
                        m_ButtonState = CustomButtonState.Focused
                    Else
                        m_ButtonState = CustomButtonState.Normal
                    End If
                End If
                OnStateChange(eventargs.Empty)
            End Sub

            Protected Overrides Sub OnMouseDown(ByVal mevent As System.Windows.Forms.MouseEventArgs)
                MyBase.OnMouseDown(mevent)
                If mevent.Button = MouseButtons.Left Then
                    Me.Focus()
                    m_ButtonState = CustomButtonState.Pressed
                End If
                OnStateChange(EventArgs.Empty)
            End Sub

            Protected Overrides Sub OnMouseUp(ByVal mevent As System.Windows.Forms.MouseEventArgs)
                MyBase.OnMouseUp(mevent)
                m_ButtonState = CustomButtonState.Focused
                OnStateChange(EventArgs.Empty)
            End Sub

            Protected Overrides Sub OnMouseMove(ByVal mevent As System.Windows.Forms.MouseEventArgs)
                MyBase.OnMouseMove(mevent)
                If New Rectangle(Point.Empty, Me.Size).Contains(mevent.X, mevent.Y) AndAlso mevent.Button = MouseButtons.Left Then
                    m_ButtonState = CustomButtonState.Pressed
                Else
                    If keyPressed Then Return
                    m_ButtonState = CustomButtonState.Hot
                End If
                OnStateChange(EventArgs.Empty)
            End Sub

            Protected Overrides Sub OnGotFocus(ByVal e As System.EventArgs)
                MyBase.OnGotFocus(e)
                m_ButtonState = CustomButtonState.Focused
                Me.NotifyDefault(True)
            End Sub

            Protected Overrides Sub OnLostFocus(ByVal e As System.EventArgs)
                MyBase.OnLostFocus(e)
                If Me.FindForm.Focused Then
                    Me.NotifyDefault(False)
                End If
                m_ButtonState = CustomButtonState.Normal
            End Sub

            Protected Overrides Sub OnEnabledChanged(ByVal e As System.EventArgs)
                MyBase.OnEnabledChanged(e)
                If Me.Enabled Then
                    m_ButtonState = CustomButtonState.Normal
                Else
                    m_ButtonState = CustomButtonState.Disabled
                End If
                OnStateChange(EventArgs.Empty)
            End Sub

            Protected Overrides Sub OnClick(ByVal e As System.EventArgs)
                'Click gets fired before MouseUp which is handy
                If Me.ButtonState = CustomButtonState.Pressed Then
                    Me.Focus()
                    Me.PerformClick()
                End If
            End Sub

            Protected Overrides Sub OnDoubleClick(ByVal e As System.EventArgs)
                If Me.ButtonState = CustomButtonState.Pressed Then
                    Me.Focus()
                    Me.PerformClick()
                End If
            End Sub

            Protected Overrides Function ProcessMnemonic(ByVal charCode As Char) As Boolean
                If IsMnemonic(charCode, Me.Text) Then
                    MyBase.OnClick(EventArgs.Empty)
                    Return True
                End If
                Return MyBase.ProcessMnemonic(charCode)
            End Function

            Protected Overrides Sub OnTextChanged(ByVal e As System.EventArgs)
                MyBase.OnTextChanged(e)
                Me.Invalidate()
            End Sub

            Protected Overrides Sub OnPaintBackground(ByVal pevent As System.Windows.Forms.PaintEventArgs)

                'Simulate Transparency
                Dim g As System.Drawing.Drawing2D.GraphicsContainer = pevent.Graphics.BeginContainer()
                Dim translateRect As Rectangle = Me.Bounds
                pevent.Graphics.TranslateTransform(-Me.Left, -Me.Top)
                Dim pe As PaintEventArgs = New PaintEventArgs(pevent.Graphics, translateRect)
                Me.InvokePaintBackground(Me.Parent, pe)
                Me.InvokePaint(Me.Parent, pe)
                pevent.Graphics.ResetTransform()
                pevent.Graphics.EndContainer(g)

                pevent.Graphics.SmoothingMode = Drawing2D.SmoothingMode.AntiAlias

                Dim shadeColor, fillColor As Color
                Dim darkColor As Color = DarkenColor(Me.BackColor, 10)
                Dim darkDarkColor As Color = DarkenColor(Me.BackColor, 25)
                Dim lightColor As Color = LightenColor(Me.BackColor, 25)
                Dim lightLightColor As Color = LightenColor(Me.BackColor, 60)

                If Me.ButtonState = CustomButtonState.Hot Then
                    fillColor = lightColor
                    shadeColor = darkDarkColor
                ElseIf Me.ButtonState = CustomButtonState.Pressed Then
                    fillColor = Me.BackColor
                    shadeColor = Me.BackColor
                Else
                    fillColor = Me.BackColor
                    shadeColor = darkDarkColor
                End If

                Dim r As Rectangle = Me.ClientRectangle
                Dim path As Drawing2D.GraphicsPath = RoundRectangle(r, Me.CornerRadius, Me.RoundCorners)

                Dim paintBrush As New Drawing2D.LinearGradientBrush(r, fillColor, shadeColor, Drawing2D.LinearGradientMode.Vertical)

                'We want a sharp change in the colors so define a Blend for the brush
                Dim b As New Drawing2D.Blend
                b.Positions = New Single() {0, 0.45, 0.55, 1}
                b.Factors = New Single() {0, 0, 1, 1}
                paintBrush.Blend = b

                'Draw the Button Background
                pevent.Graphics.FillPath(paintBrush, path)
                paintBrush.Dispose()

                '...and border
                Dim drawingPen As New Pen(darkDarkColor)
                pevent.Graphics.DrawPath(drawingPen, path)
                drawingPen.Dispose()

                'Get the Rectangle to be used for Content
                Dim inBounds As Boolean
                'We could use some Math to get this from the radius but I'm 
                'not great at Math so for the example this hack will suffice.
                While Not (inBounds) AndAlso r.Width >= 1 AndAlso r.Height >= 1
                    inBounds = path.IsVisible(r.Left, r.Top) AndAlso _
                                path.IsVisible(r.Right, r.Top) AndAlso _
                                path.IsVisible(r.Left, r.Bottom) AndAlso _
                                path.IsVisible(r.Right, r.Bottom)
                    r.Inflate(-1, -1)

                End While

                contentRect = r

            End Sub

            Protected Overrides Sub OnPaint(ByVal e As System.Windows.Forms.PaintEventArgs)
                DrawImage(e.Graphics)
                DrawText(e.Graphics)
                DrawFocus(e.Graphics)
                MyBase.OnPaint(e)
            End Sub

            Protected Overrides Sub OnParentBackColorChanged(ByVal e As System.EventArgs)
                MyBase.OnParentBackColorChanged(e)
                Me.Invalidate()
            End Sub

            Protected Overrides Sub OnParentBackgroundImageChanged(ByVal e As System.EventArgs)
                MyBase.OnParentBackgroundImageChanged(e)
                Me.Invalidate()
            End Sub

    #End Region

    #Region " Internal Draw Methods "

            Private Sub DrawImage(ByVal g As Graphics)

                If Me.ImageList Is Nothing OrElse Me.ImageIndex = -1 Then Return
                If Me.ImageIndex < 0 OrElse Me.ImageIndex >= Me.ImageList.Images.Count Then Return

                Dim _Image As Image = Me.ImageList.Images(Me.ImageIndex)

                Dim pt As Point

                Select Case Me.ImageAlign

                    Case ContentAlignment.TopLeft
                        pt.X = contentRect.Left
                        pt.Y = contentRect.Top

                    Case ContentAlignment.TopCenter
                        pt.X = (Width - _Image.Width) \ 2
                        pt.Y = contentRect.Top

                    Case ContentAlignment.TopRight
                        pt.X = contentRect.Right - _Image.Width
                        pt.Y = contentRect.Top

                    Case ContentAlignment.MiddleLeft
                        pt.X = contentRect.Left
                        pt.Y = (Height - _Image.Height) \ 2

                    Case ContentAlignment.MiddleCenter
                        pt.X = (Width - _Image.Width) \ 2
                        pt.Y = (Height - _Image.Height) \ 2

                    Case ContentAlignment.MiddleRight
                        pt.X = contentRect.Right - _Image.Width
                        pt.Y = (Height - _Image.Height) \ 2

                    Case ContentAlignment.BottomLeft
                        pt.X = contentRect.Left
                        pt.Y = contentRect.Bottom - _Image.Height

                    Case ContentAlignment.BottomCenter
                        pt.X = (Width - _Image.Width) \ 2
                        pt.Y = contentRect.Bottom - _Image.Height

                    Case ContentAlignment.BottomRight
                        pt.X = contentRect.Right - _Image.Width
                        pt.Y = contentRect.Bottom - _Image.Height

                End Select

                If Me.ButtonState = CustomButtonState.Pressed Then
                    pt.Offset(1, 1)
                End If

                If Me.Enabled Then
                    Me.ImageList.Draw(g, pt, Me.ImageIndex)
                Else
                    ControlPaint.DrawImageDisabled(g, _Image, pt.X, pt.Y, Me.BackColor)
                End If

            End Sub

            Private Sub DrawText(ByVal g As Graphics)

                Dim TextBrush As New SolidBrush(Me.ForeColor)

                Dim R As RectangleF = RectangleF.op_Implicit(contentRect)

                If Not Me.Enabled Then TextBrush.Color = SystemColors.GrayText

                Dim sf As New StringFormat(StringFormatFlags.NoWrap Or StringFormatFlags.NoClip)

                If ShowKeyboardCues Then
                    sf.HotkeyPrefix = System.Drawing.Text.HotkeyPrefix.Show
                Else
                    sf.HotkeyPrefix = System.Drawing.Text.HotkeyPrefix.Hide
                End If

                Select Case Me.TextAlign
                    Case ContentAlignment.TopLeft
                        sf.Alignment = StringAlignment.Near
                        sf.LineAlignment = StringAlignment.Near

                    Case ContentAlignment.TopCenter
                        sf.Alignment = StringAlignment.Center
                        sf.LineAlignment = StringAlignment.Near

                    Case ContentAlignment.TopRight
                        sf.Alignment = StringAlignment.Far
                        sf.LineAlignment = StringAlignment.Near

                    Case ContentAlignment.MiddleLeft
                        sf.Alignment = StringAlignment.Near
                        sf.LineAlignment = StringAlignment.Center

                    Case ContentAlignment.MiddleCenter
                        sf.Alignment = StringAlignment.Center
                        sf.LineAlignment = StringAlignment.Center

                    Case ContentAlignment.MiddleRight
                        sf.Alignment = StringAlignment.Far
                        sf.LineAlignment = StringAlignment.Center

                    Case ContentAlignment.BottomLeft
                        sf.Alignment = StringAlignment.Near
                        sf.LineAlignment = StringAlignment.Far

                    Case ContentAlignment.BottomCenter
                        sf.Alignment = StringAlignment.Center
                        sf.LineAlignment = StringAlignment.Far

                    Case ContentAlignment.BottomRight
                        sf.Alignment = StringAlignment.Far
                        sf.LineAlignment = StringAlignment.Far

                End Select

                If Me.ButtonState = CustomButtonState.Pressed Then
                    R.Offset(1, 1)
                End If

                If Me.Enabled Then
                    g.DrawString(Me.Text, Me.Font, TextBrush, R, sf)
                Else
                    ControlPaint.DrawStringDisabled(g, Me.Text, Me.Font, Me.BackColor, R, sf)
                End If

            End Sub

            Private Sub DrawFocus(ByVal g As Graphics)
                Dim r As Rectangle = contentRect
                r.Inflate(1, 1)
                If Me.Focused AndAlso Me.ShowFocusCues AndAlso Me.TabStop Then
                    ControlPaint.DrawFocusRectangle(g, r, Me.ForeColor, Me.BackColor)
                End If

            End Sub

    #End Region

    #Region " Helper Methods "

            Private Function RoundRectangle(ByVal r As Rectangle, ByVal radius As Int32, ByVal corners As Corners) As System.Drawing.Drawing2D.GraphicsPath

                'Make sure the Path fits inside the rectangle
                r.Width -= 1
                r.Height -= 1

                'Scale the radius if it's too large to fit.
                If (radius > (r.Width)) Then radius = r.Width
                If (radius > (r.Height)) Then radius = r.Height

                Dim path As New System.Drawing.Drawing2D.GraphicsPath

                If radius <= 0 Then
                    path.AddRectangle(r)
                Else
                    If (corners And corners.TopLeft) = corners.TopLeft Then
                        path.AddArc(r.Left, r.Top, radius, radius, 180, 90)
                    Else
                        path.AddLine(r.Left, r.Top, r.Left, r.Top)
                    End If

                    If (corners And corners.TopRight) = corners.TopRight Then
                        path.AddArc(r.Right - radius, r.Top, radius, radius, 270, 90)
                    Else
                        path.AddLine(r.Right, r.Top, r.Right, r.Top)
                    End If


                    If (corners And corners.BottomRight) = corners.BottomRight Then
                        path.AddArc(r.Right - radius, r.Bottom - radius, radius, radius, 0, 90)
                    Else
                        path.AddLine(r.Right, r.Bottom, r.Right, r.Bottom)
                    End If

                    If (corners And corners.BottomLeft) = corners.BottomLeft Then
                        path.AddArc(r.Left, r.Bottom - radius, radius, radius, 90, 90)
                    Else
                        path.AddLine(r.Left, r.Bottom, r.Left, r.Bottom)
                    End If

                    path.CloseFigure()

                End If

                Return path

            End Function

            'The ControlPaint Class has methods to Lighten and Darken Colors, but they return a Solid Color.
            'The Following 2 methods return a modified color with original Alpha.
            Private Function DarkenColor(ByVal colorIn As Color, ByVal percent As Int32) As Color
                'This method returns Black if you Darken by 100%

                If percent < 0 OrElse percent > 100 Then
                    Throw New ArgumentOutOfRangeException("percent")
                End If

                Dim a, r, g, b As Int32

                a = colorIn.A
                r = colorIn.R - CInt((colorIn.R / 100) * percent)
                g = colorIn.G - CInt((colorIn.G / 100) * percent)
                b = colorIn.B - CInt((colorIn.B / 100) * percent)

                Return Color.FromArgb(a, r, g, b)

            End Function

            Private Function LightenColor(ByVal colorIn As Color, ByVal percent As Int32) As Color

                'This method returns White if you lighten by 100%
                If percent < 0 OrElse percent > 100 Then
                    Throw New ArgumentOutOfRangeException("percent")
                End If

                Dim a, r, g, b As Int32

                a = colorIn.A
                r = colorIn.R + CInt(((255 - colorIn.R) / 100) * percent)
                g = colorIn.G + CInt(((255 - colorIn.G) / 100) * percent)
                b = colorIn.B + CInt(((255 - colorIn.B) / 100) * percent)

                Return Color.FromArgb(a, r, g, b)
            End Function

    #End Region

            Private Sub OnStateChange(ByVal e As EventArgs)
                Static currentState As CustomButtonState
                'Repaint the button only if the state has actually changed
                If Me.ButtonState = currentState Then Return
                currentState = Me.ButtonState
                Me.Invalidate()
            End Sub

        End Class

    #Region " Custom TypeEditor for RoundCorners property "

        <PermissionSetAttribute(SecurityAction.LinkDemand, Unrestricted:=True), PermissionSetAttribute(SecurityAction.InheritanceDemand, Unrestricted:=True)> _
        Public Class RoundCornersEditor
            Inherits UITypeEditor

            Public Overloads Overrides Function GetEditStyle(ByVal context As System.ComponentModel.ITypeDescriptorContext) As System.Drawing.Design.UITypeEditorEditStyle
                Return UITypeEditorEditStyle.DropDown
            End Function

            Public Overloads Overrides Function EditValue(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal provider As System.IServiceProvider, ByVal value As Object) As Object

                If Not TypeOf value Is Corners OrElse _
                            provider Is Nothing Then
                    Return value
                End If

                Dim edSvc As IWindowsFormsEditorService = CType(provider.GetService(GetType(IWindowsFormsEditorService)), IWindowsFormsEditorService)
                If Not (edSvc Is Nothing) Then
                    Dim lb As New CheckedListBox
                    lb.BorderStyle = System.Windows.Forms.BorderStyle.None
                    lb.CheckOnClick = True

                    lb.Items.Add("TopLeft", (DirectCast(context.Instance, CustomButton).RoundCorners And Corners.TopLeft) = Corners.TopLeft)
                    lb.Items.Add("TopRight", (DirectCast(context.Instance, CustomButton).RoundCorners And Corners.TopRight) = Corners.TopRight)
                    lb.Items.Add("BottomLeft", (DirectCast(context.Instance, CustomButton).RoundCorners And Corners.BottomLeft) = Corners.BottomLeft)
                    lb.Items.Add("BottomRight", (DirectCast(context.Instance, CustomButton).RoundCorners And Corners.BottomRight) = Corners.BottomRight)

                    edSvc.DropDownControl(lb)
                    Dim cornerFlags As Corners
                    For Each o As Object In lb.CheckedItems
                        cornerFlags = cornerFlags Or DirectCast([Enum].Parse(GetType(Corners), o.ToString), Corners)
                    Next
                    lb.Dispose()
                    edSvc.CloseDropDown()
                    Return cornerFlags
                End If

                Return value

            End Function

        End Class

    #End Region

    End Namespace      
			
C# Code
			
			    using System;
    using System.ComponentModel;
    using System.Drawing;
    using System.Drawing.Design;
    using System.Windows.Forms;
    using System.Windows.Forms.Design;
    using System.Security.Permissions;

    namespace Dotnetrix.Samples.CSharp
    {
        [System.Flags]
        public enum Corners
        {
            None = 0,
            TopLeft = 1,
            TopRight = 2,
            BottomLeft = 4,
            BottomRight = 8,
            All = TopLeft | TopRight | BottomLeft | BottomRight
        }


        public enum CustomButtonState
        {
            Normal = 1,
            Hot,
            Pressed,
            Disabled,
            Focused
        }


        public class CustomButton : Control, IButtonControl
        {
            public CustomButton():base()
            {
                this.SetStyle(ControlStyles.Selectable | ControlStyles.StandardClick | ControlStyles.ResizeRedraw | ControlStyles.AllPaintingInWmPaint | ControlStyles.DoubleBuffer | ControlStyles.UserPaint | ControlStyles.SupportsTransparentBackColor, true);
            }


    #region Private Instance Variables

            private DialogResult m_DialogResult;
            private bool m_IsDefault;
            
            private int m_CornerRadius  = 8;
            private Corners m_RoundCorners;
            private CustomButtonState m_ButtonState = CustomButtonState.Normal;
            
            private ContentAlignment m_ImageAlign = ContentAlignment.MiddleCenter;
            private ContentAlignment m_TextAlign = ContentAlignment.MiddleCenter;
            private ImageList m_ImageList;
            private int m_ImageIndex = -1;
            
            private bool keyPressed;
            private Rectangle contentRect;

    #endregion

    #region IButtonControl Implementation

            [Category("Behavior"), DefaultValue(typeof(DialogResult), "None")]
            [Description("The dialog result produced in a modal form by clicking the button.")]
            public DialogResult DialogResult
            {
                get{return m_DialogResult;}
                set
                {
                    if (Enum.IsDefined(typeof(DialogResult), value))
                        m_DialogResult = value;
                }
            }
            

            public void NotifyDefault(bool value)
            {
                if (m_IsDefault != value)
                    m_IsDefault = value;
                this.Invalidate();
            }


            public void PerformClick()
            {
                if (this.CanSelect)
                    base.OnClick(EventArgs.Empty);
            }


    #endregion

    #region Properties

            //ButtonState
            [Browsable(false)]
            public CustomButtonState ButtonState
            {
                get{return m_ButtonState;}
            }


            //CornerRadius
            [Category("Appearance")]
            [DefaultValue(8)]
            [Description("Defines the radius of the controls RoundedCorners.")]
            public int CornerRadius
            {
                get{return m_CornerRadius;}
                set
                {
                    if (m_CornerRadius == value) 
                        return;
                    m_CornerRadius = value;
                    this.Invalidate();
                }
            }


            //DefaultSize
            protected override System.Drawing.Size DefaultSize
            {
                get{return new Size(75, 23);}
            }


            //IsDefault
            [Browsable(false)]
            public bool IsDefault
            {
                get{return m_IsDefault;}
            }


            //ImageList
            [Category("Appearance"), DefaultValue(typeof(ImageList), null)]
            [Description("The image list to get the image to display in the face of the control.")]
            public ImageList ImageList
            {
                get{return m_ImageList;}
                set
                {
                    m_ImageList = value;
                    this.Invalidate();
                }
            }


            //ImageIndex
            [Category("Appearance"), DefaultValue(-1)]
            [Description("The index of the image in the image list to display in the face of the control.")]
            [TypeConverter(typeof(ImageIndexConverter))]
            [Editor("System.Windows.Forms.Design.ImageIndexEditor, System.Design", typeof(System.Drawing.Design.UITypeEditor))]
            public int ImageIndex
            {
                get{return m_ImageIndex;}
                set
                {
                    m_ImageIndex = value;
                    this.Invalidate();
                }
            }


            //ImageAlign
            [Category("Appearance"), DefaultValue(typeof(ContentAlignment), "MiddleCenter")]
            [Description("The alignment of the image that will be displayed in the face of the control.")]
            public ContentAlignment ImageAlign
            {
                get{return m_ImageAlign;}
                set
                {
                    if (!Enum.IsDefined(typeof(ContentAlignment), value))
                        throw new InvalidEnumArgumentException("value", (int)value, typeof(ContentAlignment));
                    if (m_ImageAlign == value )
                        return;
                    m_ImageAlign = value;
                    this.Invalidate();
                }
            }


            //RoundCorners
            [Category("Appearance")]
            [DefaultValue(typeof(Corners), "None")]
            [Description("Gets/sets the corners of the control to round.")]
            [Editor(typeof(RoundCornersEditor), typeof(UITypeEditor))]
            [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
            public Corners RoundCorners
            {
                get{return m_RoundCorners;}
                set
                {
                    if (m_RoundCorners == value)
                        return;
                    m_RoundCorners = value;
                    this.Invalidate();
                }
            }


            //TextAlign
            [Category("Appearance"), DefaultValue(typeof(ContentAlignment), "MiddleCenter")]
            [Description("The alignment of the text that will be displayed in the face of the control.")]
            public ContentAlignment TextAlign
            {
                get{return m_TextAlign;}
                set
                {
                    if (!Enum.IsDefined(typeof(ContentAlignment), value))
                        throw new InvalidEnumArgumentException("value", (int)value, typeof(ContentAlignment));
                    if (m_TextAlign == value)
                        return;
                    m_TextAlign = value;
                    this.Invalidate();
                }
            }


    #endregion

    #region Overriden Methods

            protected override void OnKeyDown(KeyEventArgs e)
            {
                base.OnKeyDown (e);
                if (e.KeyCode == Keys.Space)
                {
                    keyPressed = true;
                    m_ButtonState = CustomButtonState.Pressed;
                }
                OnStateChange(EventArgs.Empty);
            }


            protected override void OnKeyUp(KeyEventArgs e)
            {
                base.OnKeyUp (e);
                if (e.KeyCode == Keys.Space)
                {
                    if (this.ButtonState == CustomButtonState.Pressed)
                        this.PerformClick();
                    keyPressed = false;
                    m_ButtonState = CustomButtonState.Focused;
                }
                OnStateChange(EventArgs.Empty);
            }


            protected override void OnMouseEnter(EventArgs e)
            {
                base.OnMouseEnter (e);
                if (!keyPressed)
                    m_ButtonState = CustomButtonState.Hot;
                OnStateChange(EventArgs.Empty);
            }


            protected override void OnMouseLeave(EventArgs e)
            {
                base.OnMouseLeave (e);
                if (!keyPressed)
                    if (this.IsDefault)
                        m_ButtonState = CustomButtonState.Focused;
                    else
                        m_ButtonState = CustomButtonState.Normal;
                OnStateChange(EventArgs.Empty);
            }


            protected override void OnMouseDown(MouseEventArgs e)
            {
                base.OnMouseDown (e);
                if (e.Button == MouseButtons.Left)
                {
                    this.Focus();
                    m_ButtonState = CustomButtonState.Pressed;
                }
                OnStateChange(EventArgs.Empty);
            }


            protected override void OnMouseUp(MouseEventArgs e)
            {
                base.OnMouseUp (e);
                m_ButtonState = CustomButtonState.Focused;
                OnStateChange(EventArgs.Empty);
            }


            protected override void OnMouseMove(MouseEventArgs e)
            {
                base.OnMouseMove (e);
                if (new Rectangle(Point.Empty, this.Size).Contains(e.X, e.Y) && e.Button == MouseButtons.Left)
                    m_ButtonState = CustomButtonState.Pressed;
                else
                {
                    if(keyPressed)
                        return;
                    m_ButtonState = CustomButtonState.Hot;
                }
                OnStateChange(EventArgs.Empty);
            }


            protected override void OnGotFocus(EventArgs e)
            {
                base.OnGotFocus (e);
                m_ButtonState = CustomButtonState.Focused;
                this.NotifyDefault(true);
            }


            protected override void OnLostFocus(EventArgs e)
            {
                base.OnLostFocus (e);
                if (this.FindForm().Focused)
                    this.NotifyDefault(false);
                m_ButtonState = CustomButtonState.Normal;
            }


            protected override void OnEnabledChanged(EventArgs e)
            {
                base.OnEnabledChanged (e);
                if (this.Enabled)
                    m_ButtonState = CustomButtonState.Normal;
                else
                    m_ButtonState = CustomButtonState.Disabled;
                OnStateChange(EventArgs.Empty);
            }


            protected override void OnClick(EventArgs e)
            {
                //Click gets fired before MouseUp which is handy
                if (this.ButtonState == CustomButtonState.Pressed)
                {
                    this.Focus();
                    this.PerformClick();
                }
            }


            protected override void OnDoubleClick(EventArgs e)
            {
                if (this.ButtonState == CustomButtonState.Pressed)
                {
                    this.Focus();
                    this.PerformClick();
                }
            }


            protected override bool ProcessMnemonic(char charCode)
            {
                if (IsMnemonic(charCode, this.Text))
                {
                    base.OnClick(EventArgs.Empty);
                    return true;
                }
                return base.ProcessMnemonic(charCode);
            }


            protected override void OnTextChanged(EventArgs e)
            {
                base.OnTextChanged(e);
                this.Invalidate();
            }


            protected override void OnPaintBackground(PaintEventArgs pevent)
            {
                //Simulate Transparency
                System.Drawing.Drawing2D.GraphicsContainer g = pevent.Graphics.BeginContainer();
                Rectangle translateRect = this.Bounds;
                pevent.Graphics.TranslateTransform(-this.Left, -this.Top);
                PaintEventArgs pe = new PaintEventArgs(pevent.Graphics, translateRect);
                this.InvokePaintBackground(this.Parent, pe);
                this.InvokePaint(this.Parent, pe);
                pevent.Graphics.ResetTransform();
                pevent.Graphics.EndContainer(g);

                pevent.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

                Color shadeColor, fillColor; 
                Color darkColor = DarkenColor(this.BackColor, 10);
                Color darkDarkColor = DarkenColor(this.BackColor, 25);
                Color lightColor = LightenColor(this.BackColor, 25);
                Color lightLightColor = LightenColor(this.BackColor, 60);

                if (this.ButtonState == CustomButtonState.Hot)
                {
                    fillColor = lightColor;
                    shadeColor = darkDarkColor;
                }
                else if (this.ButtonState == CustomButtonState.Pressed)
                {
                    fillColor = this.BackColor;
                    shadeColor = this.BackColor;
                }
                else
                {
                    fillColor = this.BackColor;
                    shadeColor = darkDarkColor;
                }

                Rectangle r = this.ClientRectangle;
                System.Drawing.Drawing2D.GraphicsPath path = RoundRectangle(r, this.CornerRadius, this.RoundCorners);

                System.Drawing.Drawing2D.LinearGradientBrush paintBrush = new System.Drawing.Drawing2D.LinearGradientBrush(r, fillColor, shadeColor, System.Drawing.Drawing2D.LinearGradientMode.Vertical);

                //We want a sharp change in the colors so define a Blend for the brush
                System.Drawing.Drawing2D.Blend b = new System.Drawing.Drawing2D.Blend();
                b.Positions = new float[] {0, 0.45F, 0.55F, 1};
                b.Factors = new float[] {0, 0, 1, 1};
                paintBrush.Blend = b;

                //Draw the Button Background
                pevent.Graphics.FillPath(paintBrush, path);
                paintBrush.Dispose();

                //...and border
                Pen drawingPen = new Pen(darkDarkColor);
                pevent.Graphics.DrawPath(drawingPen, path);
                drawingPen.Dispose();

                //Get the Rectangle to be used for Content
                bool inBounds = false;
                //We could use some Math to get this from the radius but I'm 
                //not great at Math so for the example this hack will suffice.
                while (!inBounds && r.Width >= 1 && r.Height >= 1)
                {
                    inBounds = path.IsVisible(r.Left, r.Top) &&
                                path.IsVisible(r.Right, r.Top) &&
                                path.IsVisible(r.Left, r.Bottom) &&
                                path.IsVisible(r.Right, r.Bottom);
                    r.Inflate(-1, -1);
                    
                }

                contentRect = r;

            }


            protected override void OnPaint(PaintEventArgs e)
            {
                DrawImage(e.Graphics);
                DrawText(e.Graphics);
                DrawFocus(e.Graphics);
                base.OnPaint (e);
            }


            protected override void OnParentBackColorChanged(EventArgs e)
            {
                base.OnParentBackColorChanged (e);
                this.Invalidate();
            }


            protected override void OnParentBackgroundImageChanged(EventArgs e)
            {
                base.OnParentBackgroundImageChanged (e);
                this.Invalidate();
            }


    #endregion

    #region Internal Draw Methods

            private void DrawImage(Graphics g)
            {
                if (this.ImageList == null || this.ImageIndex == -1)
                    return;
                if (this.ImageIndex < 0 || this.ImageIndex >= this.ImageList.Images.Count)
                    return;

                Image _Image = this.ImageList.Images[this.ImageIndex];

                Point pt = Point.Empty;

                switch (this.ImageAlign)
                {
                    case ContentAlignment.TopLeft:
                        pt.X = contentRect.Left;
                        pt.Y = contentRect.Top;
                        break;

                    case ContentAlignment.TopCenter:
                        pt.X = (Width - _Image.Width) / 2;
                        pt.Y = contentRect.Top;
                        break;

                    case ContentAlignment.TopRight:
                        pt.X = contentRect.Right - _Image.Width;
                        pt.Y = contentRect.Top;
                        break;

                    case ContentAlignment.MiddleLeft:
                        pt.X = contentRect.Left;
                        pt.Y = (Height - _Image.Height) / 2;
                        break;

                    case ContentAlignment.MiddleCenter:
                        pt.X = (Width - _Image.Width) / 2;
                        pt.Y = (Height - _Image.Height) / 2;
                        break;

                    case ContentAlignment.MiddleRight:
                        pt.X = contentRect.Right - _Image.Width;
                        pt.Y = (Height - _Image.Height) / 2;
                        break;

                    case ContentAlignment.BottomLeft:
                        pt.X = contentRect.Left;
                        pt.Y = contentRect.Bottom - _Image.Height;
                        break;

                    case ContentAlignment.BottomCenter:
                        pt.X = (Width - _Image.Width) / 2;
                        pt.Y = contentRect.Bottom - _Image.Height;
                        break;

                    case ContentAlignment.BottomRight:
                        pt.X = contentRect.Right - _Image.Width;
                        pt.Y = contentRect.Bottom - _Image.Height;
                        break;
                }

                if (this.ButtonState == CustomButtonState.Pressed)
                    pt.Offset(1, 1);

                if (this.Enabled)
                    this.ImageList.Draw(g, pt, this.ImageIndex);
                else
                    ControlPaint.DrawImageDisabled(g, _Image, pt.X, pt.Y, this.BackColor);

            }


            private void DrawText(Graphics g)
            {
                SolidBrush TextBrush = new SolidBrush(this.ForeColor);
                
                RectangleF R = (RectangleF)contentRect;
                
                if (!this.Enabled)
                    TextBrush.Color = SystemColors.GrayText;
                
                StringFormat sf = new StringFormat(StringFormatFlags.NoWrap | StringFormatFlags.NoClip);
                
                if (ShowKeyboardCues)
                    sf.HotkeyPrefix = System.Drawing.Text.HotkeyPrefix.Show;
                else
                    sf.HotkeyPrefix = System.Drawing.Text.HotkeyPrefix.Hide;
                
                switch (this.TextAlign)
                {
                    case ContentAlignment.TopLeft:
                        sf.Alignment = StringAlignment.Near;
                        sf.LineAlignment = StringAlignment.Near;
                        break;

                    case ContentAlignment.TopCenter:
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Near;
                        break;

                    case ContentAlignment.TopRight:
                        sf.Alignment = StringAlignment.Far;
                        sf.LineAlignment = StringAlignment.Near;
                        break;
                        
                    case ContentAlignment.MiddleLeft:
                        sf.Alignment = StringAlignment.Near;
                        sf.LineAlignment = StringAlignment.Center;
                        break;

                    case ContentAlignment.MiddleCenter:
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Center;
                        break;

                    case ContentAlignment.MiddleRight:
                        sf.Alignment = StringAlignment.Far;
                        sf.LineAlignment = StringAlignment.Center;
                        break;

                    case ContentAlignment.BottomLeft:
                        sf.Alignment = StringAlignment.Near;
                        sf.LineAlignment = StringAlignment.Far;
                        break;

                    case ContentAlignment.BottomCenter:
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Far;
                        break;

                    case ContentAlignment.BottomRight:
                        sf.Alignment = StringAlignment.Far;
                        sf.LineAlignment = StringAlignment.Far;
                        break;
                }

                if (this.ButtonState == CustomButtonState.Pressed)
                    R.Offset(1, 1);

                if (this.Enabled)
                    g.DrawString(this.Text, this.Font, TextBrush, R, sf);
                else
                    ControlPaint.DrawStringDisabled(g, this.Text, this.Font, this.BackColor, R, sf);
                
            }


            private void DrawFocus(Graphics g)
            {
                Rectangle r = contentRect;
                r.Inflate(1, 1);
                if (this.Focused && this.ShowFocusCues && this.TabStop)
                    ControlPaint.DrawFocusRectangle(g, r, this.ForeColor, this.BackColor);
            }

            
    #endregion

    #region Helper Methods

            private System.Drawing.Drawing2D.GraphicsPath RoundRectangle(Rectangle r, int radius, Corners corners)
            {
                //Make sure the Path fits inside the rectangle
                r.Width -= 1;
                r.Height -= 1;
                
                //Scale the radius if it's too large to fit.
                if (radius > (r.Width))
                    radius = r.Width;
                if (radius > (r.Height))
                    radius = r.Height;
                
                System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
                
                if (radius <= 0 )
                    path.AddRectangle(r);
                else
                    if ((corners & Corners.TopLeft) == Corners.TopLeft)
                    path.AddArc(r.Left, r.Top, radius, radius, 180, 90);
                else
                    path.AddLine(r.Left, r.Top, r.Left, r.Top);
                
                if ((corners & Corners.TopRight) == Corners.TopRight)
                    path.AddArc(r.Right - radius, r.Top, radius, radius, 270, 90);
                else
                    path.AddLine(r.Right, r.Top, r.Right, r.Top);
                
                if ((corners & Corners.BottomRight) == Corners.BottomRight)
                    path.AddArc(r.Right - radius, r.Bottom - radius, radius, radius, 0, 90);
                else
                    path.AddLine(r.Right, r.Bottom, r.Right, r.Bottom);
                
                if ((corners & Corners.BottomLeft) == Corners.BottomLeft)
                    path.AddArc(r.Left, r.Bottom - radius, radius, radius, 90, 90);
                else
                    path.AddLine(r.Left, r.Bottom, r.Left, r.Bottom);
                
                path.CloseFigure();

                return path;
            }


            //The ControlPaint Class has methods to Lighten and Darken Colors, but they return a Solid Color.
            //The Following 2 methods return a modified color with original Alpha.
            private Color DarkenColor(Color colorIn, int percent)
            {
                //This method returns Black if you Darken by 100%
                
                if (percent < 0 || percent > 100)
                    throw new ArgumentOutOfRangeException("percent");
                
                int a, r, g, b;
                
                a = colorIn.A;
                r = colorIn.R - (int)((colorIn.R / 100f) * percent);
                g = colorIn.G - (int)((colorIn.G / 100f) * percent);
                b = colorIn.B - (int)((colorIn.B / 100f) * percent);
                
                return Color.FromArgb(a, r, g, b);
            }
            

            private Color LightenColor(Color colorIn, int percent)
            {
                //This method returns White if you lighten by 100%
                
                if (percent < 0 || percent > 100)
                    throw new ArgumentOutOfRangeException("percent");
                
                int a, r, g, b;
                
                a = colorIn.A;
                r = colorIn.R + (int)(((255f - colorIn.R) / 100f) * percent);
                g = colorIn.G + (int)(((255f - colorIn.G) / 100f) * percent);
                b = colorIn.B + (int)(((255f - colorIn.B) / 100f) * percent);
                
                return Color.FromArgb(a, r, g, b);
            }


    #endregion

            private CustomButtonState currentState; 
            private void OnStateChange(EventArgs e)
            {
                //Repaint the button only if the state has actually changed
                if (this.ButtonState == currentState)
                    return;
                currentState = this.ButtonState;
                this.Invalidate();
            }


        }

    #region Custom TypeEditor for RoundCorners property

        [PermissionSetAttribute(SecurityAction.LinkDemand, Unrestricted=true)]
        [PermissionSetAttribute(SecurityAction.InheritanceDemand, Unrestricted=true)]
        public class RoundCornersEditor : UITypeEditor
        {
            public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
            {
                return UITypeEditorEditStyle.DropDown;
            }
            
            public override Object EditValue(ITypeDescriptorContext context, IServiceProvider provider, Object value)
            {
                if (value != typeof(Corners) ||    provider == null)
                    return value;
                
                IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
                if (edSvc != null)
                {
                    CheckedListBox lb = new CheckedListBox();
                    lb.BorderStyle = BorderStyle.None;
                    lb.CheckOnClick = true;
                    
                    lb.Items.Add("TopLeft", (((CustomButton)context.Instance).RoundCorners & Corners.TopLeft) == Corners.TopLeft);
                    lb.Items.Add("TopRight", (((CustomButton)context.Instance).RoundCorners & Corners.TopRight) == Corners.TopRight);
                    lb.Items.Add("BottomLeft", (((CustomButton)context.Instance).RoundCorners & Corners.BottomLeft) == Corners.BottomLeft);
                    lb.Items.Add("BottomRight", (((CustomButton)context.Instance).RoundCorners & Corners.BottomRight) == Corners.BottomRight);

                    edSvc.DropDownControl(lb);
                    Corners cornerFlags = Corners.None;
                    foreach (object o in lb.CheckedItems)
                    {
                        cornerFlags = cornerFlags | (Corners)Enum.Parse(typeof(Corners), o.ToString());
                    }
                    lb.Dispose();
                    edSvc.CloseDropDown();
                    return cornerFlags;
                }
                return value;
            }
            
        }

    #endregion

    }
			
			

			

note that this example needs a reference to System.Design.dll since it uses a custom TypeEditor.