Extended NumericUpDown Control

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

namespace CoolSoft.UI
{
    [DesignerCategory("code")]
    public class NumericUpDownEx : NumericUpDown
    {
        // reference to the underlying TextBox control
        private TextBox _textbox;

        // reference to the underlying UpDownButtons control
        private Control _upDownButtons;

        /// <summary>
        /// object creator
        /// </summary>
        public NumericUpDownEx() : base()
        {
            // get a reference to the underlying UpDownButtons field
            // Underlying private type is System.Windows.Forms.UpDownBase+UpDownButtons
            _upDownButtons = base.Controls[0];
            if (_upDownButtons == null || _upDownButtons.GetType().FullName != "System.Windows.Forms.UpDownBase+UpDownButtons")
            {
                throw new ArgumentNullException(this.GetType().FullName + ": Can't find internal UpDown buttons field.");
            }
            // Get a reference to the underlying TextBox field.
            // Underlying private type is System.Windows.Forms.UpDownBase+UpDownButtons
            _textbox = base.Controls[1] as TextBox;
            if (_textbox == null || _textbox.GetType().FullName != "System.Windows.Forms.UpDownBase+UpDownEdit")
            {
                throw new ArgumentNullException(this.GetType().FullName + ": Can't find internal TextBox field.");
            }
            // add handlers (MouseEnter and MouseLeave events of NumericUpDown
            // are not working properly)
            _textbox.MouseEnter += _mouseEnterLeave;
            _textbox.MouseLeave += _mouseEnterLeave;
            _upDownButtons.MouseEnter += _mouseEnterLeave;
            _upDownButtons.MouseLeave += _mouseEnterLeave;
            base.MouseEnter += _mouseEnterLeave;
            base.MouseLeave += _mouseEnterLeave;
        }

        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
            if (_upDownButtons.Visible == false)
            {
                e.Graphics.Clear(this.BackColor);
            }
            base.OnPaint(e);
        }

        /// <summary>
        /// Change behavior of keys shift+up/down and pageUp/ pageDown, use LargeIncrement in these cases
        /// work only if InterceptArrowKeys property set to true
        /// </summary>
        protected override bool ProcessCmdKey(ref Message m, Keys keyData)
        {
            if (base.InterceptArrowKeys)
            {
                if ((m.WParam == (IntPtr) Keys.Down && ModifierKeys == Keys.Shift) || m.WParam == (IntPtr) Keys.PageDown)
                {
                    DoDecrement(true);
                    return true; // handled !
                }
                else if ((m.WParam == (IntPtr) Keys.Up && ModifierKeys == Keys.Shift) || m.WParam == (IntPtr) Keys.PageUp)
                {
                    DoIncrement(true);
                    return true;
                }
            }
            return base.ProcessCmdKey(ref m, keyData); // default processing
        }

        /// <summary>
        /// Check empty text in order to react depending on Nullable or not
        /// </summary>
        /// <param name="e"></param>
        protected override void OnKeyUp(KeyEventArgs e)
        {
            base.OnKeyUp(e);
            if (_textbox.Text.Length == 0)
            {
                if (this.Nullable)
                {
                    if (!IsNull)
                    {
                        IsNull = true;
                        base.OnValueChanged(EventArgs.Empty);
                    }
                }
                else // if not Nullable, don't accept empty field, automatically reset to Minimum
                {
                    base.Value = Minimum;
                    UpdateEditText();
                }
            }
            else if (IsNull) // so Nullable
                IsNull = false;
        }

        /// <summary>
        /// WndProc override to manage WN_MOUSEWHEEL message
        /// </summary>
        protected override void WndProc(ref System.Windows.Forms.Message m)
        {
            const int WM_MOUSEWHEEL = 0x020a;
            const int MK_SHIFT = 0x0004;
            bool manage = false;

            if (m.Msg == WM_MOUSEWHEEL)
            {
                switch (InterceptMouseWheel)
                {
                    case InterceptMouseWheelMode.Always:
                        manage = true;
                        break;
                    case InterceptMouseWheelMode.WhenMouseOver:
                        if (_mouseOver)
                        {
                            manage = true;
                        }
                        break;
                    case InterceptMouseWheelMode.Never:
                        return; // don't manage, kill the message
                }

                if (manage)
                {
                    int wheelDelta = ((int) m.WParam >> 16) / SystemInformation.MouseWheelScrollDelta;
                    if (wheelDelta < 0) // negative value for backward wheeling
                        DoDecrement(((int) m.WParam & 0xFFFF) == MK_SHIFT, -wheelDelta);
                    else // positive value for forward wheeling
                        DoIncrement(((int) m.WParam & 0xFFFF) == MK_SHIFT, wheelDelta);
                }
            }
            else
            {
                base.WndProc(ref m);
            }
        }

        #region New properties

        [DefaultValue(false)]
        [Category("Behavior")]
        [Description("Automatically select control text when it receives focus.")]
        public bool AutoSelect { get; set; }

        [DefaultValue(false)]
        [Category("Behavior")]
        [Description("Set control able to be null.")]
        public bool Nullable { get; set; }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsNull { get; internal set; }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int SelectionStart
        {
            get { return _textbox.SelectionStart; }
            set { _textbox.SelectionStart = value; }
        }


        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int SelectionLength
        {
            get { return _textbox.SelectionLength; }
            set { _textbox.SelectionLength = value; }
        }


        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string SelectedText
        {
            get { return _textbox.SelectedText; }
            set { _textbox.SelectedText = value; }
        }


        [DefaultValue(typeof(InterceptMouseWheelMode), "Always")]
        [Category("Behavior")]
        [Description("Enables MouseWheel only under certain conditions.")]
        public InterceptMouseWheelMode InterceptMouseWheel { get; set; } = InterceptMouseWheelMode.Always;

        public enum InterceptMouseWheelMode
        {
            /// <summary>MouseWheel always works (default behavior)</summary>
            Always,
            /// <summary>MouseWheel works only when mouse is over the (focused) control</summary>
            WhenMouseOver,
            /// <summary>MouseWheel never works</summary>
            Never
        }


        [Category("Behavior")]
        [DefaultValue(typeof(ShowUpDownButtonsMode), "Always")]
        [Description("Set UpDownButtons visibility mode.")]
        public ShowUpDownButtonsMode ShowUpDownButtons
        {
            get { return _showUpDownButtons; }
            set
            {
                _showUpDownButtons = value;
                // update UpDownButtons visibility
                UpdateUpDownButtonsVisibility();
            }
        }

        private ShowUpDownButtonsMode _showUpDownButtons = ShowUpDownButtonsMode.Always;

        public enum ShowUpDownButtonsMode
        {
            /// <summary>UpDownButtons are always visible (default behavior)</summary>
            Always,
            /// <summary>UpDownButtons are visible only when mouse is over the control</summary>
            WhenMouseOver,
            /// <summary>UpDownButtons are visible only when control has focus</summary>
            WhenFocus,
            /// <summary>UpDownButtons are visible when control has focus or mouse is over it</summary>
            WhenFocusOrMouseOver,
            /// <summary>UpDownButtons are never visible</summary>
            Never,
        }

        /// <summary>
        /// Large value applied when shift key is pressed in order to quickly increment or decrement the DecimalUpDown
        /// if not set (= 0) automatically use normal increment
        /// </summary>
        [Category("Behavior")]
        [DefaultValue(0)]
        [Description("Value of large increment or decrement applied when up or down buttons are clicked and shift key is pressed.")]
        public decimal LargeIncrement { get; set; }

        /// <summary>
        /// If set, incrementing value will cause it to restart from Minimum when Maximum is reached (and vice-versa).
        /// </summary>
        [Category("Behavior")]
        [DefaultValue(false)]
        [Description("If set, incrementing value will cause it to restart from Minimum when Maximum is reached (and vice-versa).")]
        public bool WrapValue { get; set; } = false;

        /// <summary>
        /// Allow nullable value for DecimalUpDown control
        /// Nullable property has to be set to true to allow null value otherwise throw error
        /// Way to set null: by program or by deleting text value
        /// </summary>
        public new decimal? Value
        {
            get
            {
                return IsNull ? (decimal?) null : base.Value;
            }
            set
            {
                if (value == null)
                {
                    if (this.Nullable)
                    {
                        IsNull = true;
                        _textbox.Text = "";
                    }
                    else
                    {
                        throw new ArgumentNullException("Value", "Value cannot be null!\nControl accept null value only if 'Nullable' property is set to true.");
                    }
                }
                else
                {
                    IsNull = false;
                    base.Value = (decimal) value;
                    UpdateEditText();
                }
            }
        }

        #endregion

        #region Text selection

        // select all the text on focus enter
        protected override void OnGotFocus(EventArgs e)
        {
            _haveFocus = true;
            if (AutoSelect)
            {
                _textbox.SelectAll();
            }
            // Update UpDownButtons visibility
            if (_showUpDownButtons == ShowUpDownButtonsMode.WhenFocus | _showUpDownButtons == ShowUpDownButtonsMode.WhenFocusOrMouseOver)
            {
                UpdateUpDownButtonsVisibility();
            }
            base.OnGotFocus(e);
        }

        // indicate that we have lost the focus
        protected override void OnLostFocus(EventArgs e)
        {
            _haveFocus = false;
            // Update UpDownButtons visibility
            if (_showUpDownButtons == ShowUpDownButtonsMode.WhenFocus | _showUpDownButtons == ShowUpDownButtonsMode.WhenFocusOrMouseOver)
            {
                UpdateUpDownButtonsVisibility();
            }
            base.OnLostFocus(e);
        }

        // MouseUp will kill the SelectAll made on GotFocus.
        // Will restore it, but only if user have not made a partial text selection.
        protected override void OnMouseUp(MouseEventArgs mevent)
        {
            if (AutoSelect && _textbox.SelectionLength == 0)
            {
                _textbox.SelectAll();
            }
            base.OnMouseUp(mevent);
        }

        #endregion

        #region Additional events

        // these events will be raised correctly, when mouse enters on the textbox
        public new event EventHandler<EventArgs> MouseEnter;
        public new event EventHandler<EventArgs> MouseLeave;

        // Events raised BEFORE value decrement(increment
        public event CancelEventHandler BeforeValueDecrement;
        public event CancelEventHandler BeforeValueIncrement;

        // flag to track mouse position
        private bool _mouseOver = false;

        // flag to track focus
        private bool _haveFocus = false;

        // this handler is called at each mouse Enter/Leave movement
        private void _mouseEnterLeave(object sender, EventArgs e)
        {
            Rectangle cr = RectangleToScreen(ClientRectangle);
            Point mp = MousePosition;

            // actual state
            bool isOver = cr.Contains(mp);

            // test if status changed
            if (_mouseOver ^ isOver)
            {
                // update state
                _mouseOver = isOver;
                if (_mouseOver)
                {
                    if (MouseEnter != null)
                    {
                        MouseEnter(this, EventArgs.Empty);
                    }
                }
                else
                {
                    if (MouseLeave != null)
                    {
                        MouseLeave(this, EventArgs.Empty);
                    }
                }
            }

            // update UpDownButtons visibility
            if (_showUpDownButtons != ShowUpDownButtonsMode.Always)
            {
                UpdateUpDownButtonsVisibility();
            }
        }

        #endregion

        #region Value increment/decrement management

        /// <summary>
        /// Perform decrement taking into account all cases
        /// </summary>
        /// <param name="Large">Use large increment (true) or normal increment (false)</param>
        /// <param name="Count">Number of times action has to be done (see mousewheel management)</param>
        private void DoDecrement(bool Large, int Count = 1)
        {
            if (IsNull)
            {
                IsNull = false;
                if (base.Value == Maximum) // already set to maximum ?
                {
                    base.Value = Maximum - Increment;  // to force refresh value, otherwise ValueChanged not raised and text not displayed
                }
                base.Value = Maximum;
                UpdateEditText();
            }
            else
            {
                decimal CurIncrement = (Large ? (LargeIncrement == 0 ? Increment : LargeIncrement) : Increment) * Count;
                if (base.Value - CurIncrement < Minimum)
                {
                    base.Value = WrapValue ? Maximum : Minimum;
                }
                else
                {
                    base.Value -= CurIncrement;
                }
            }
            UpdateEditText();
        }

        /// <summary>
        /// Perform increment taking into account all cases
        /// </summary>
        private void DoIncrement(bool Large, int Count = 1)
        {
            if (IsNull)
            {
                IsNull = false;
                if (base.Value == Minimum)
                {
                    base.Value = Minimum + Increment;
                }
                base.Value = Minimum;
                UpdateEditText();
            }
            else
            {
                decimal CurIncrement = (Large ? (LargeIncrement == 0 ? Increment : LargeIncrement) : Increment) * Count;
                if (base.Value + CurIncrement > Maximum)
                {
                    base.Value = WrapValue ? Minimum : Maximum;
                }
                else
                {
                    base.Value += CurIncrement;
                }
            }
            UpdateEditText();
        }

        // raises the two new events
        public override void DownButton()
        {
            if (base.ReadOnly) return;
            CancelEventArgs e = new CancelEventArgs();
            if (BeforeValueDecrement != null)
            {
                BeforeValueDecrement(this, e);
            }
            if (e.Cancel) return;

            DoDecrement(ModifierKeys == Keys.Shift);
        }

        public override void UpButton()
        {
            if (base.ReadOnly) return;
            CancelEventArgs e = new CancelEventArgs();
            if (BeforeValueIncrement != null)
            {
                BeforeValueIncrement(this, e);
            }
            if (e.Cancel) return;

            DoIncrement(ModifierKeys == Keys.Shift);
        }

        #endregion

        #region UpDownButtons visibility management

        /// <summary>
        /// Show or hide the UpDownButtons, according to ShowUpDownButtons property value
        /// </summary>
        public void UpdateUpDownButtonsVisibility()
        {
            // test new state
            bool newVisible = false;
            switch (_showUpDownButtons)
            {
                case ShowUpDownButtonsMode.WhenMouseOver:
                    newVisible = _mouseOver;
                    break;
                case ShowUpDownButtonsMode.WhenFocus:
                    newVisible = _haveFocus;
                    break;
                case ShowUpDownButtonsMode.WhenFocusOrMouseOver:
                    newVisible = _mouseOver | _haveFocus;
                    break;
                case ShowUpDownButtonsMode.Never:
                    newVisible = false;
                    break;
                default:
                    newVisible = true;
                    break;
            }

            // assign only if needed
            if (_upDownButtons.Visible != newVisible)
            {
                if (newVisible)
                {
                    _textbox.Width = this.ClientRectangle.Width - _upDownButtons.Width;
                }
                else
                {
                    _textbox.Width = this.ClientRectangle.Width;
                }
                _upDownButtons.Visible = newVisible;
                OnTextBoxResize(_textbox, EventArgs.Empty);
                this.Invalidate();
            }
        }

        /// <summary>
        /// Custom textbox size management
        /// </summary>
        protected override void OnTextBoxResize(object source, System.EventArgs e)
        {
            if (_textbox == null)
                return;
            if (_showUpDownButtons == ShowUpDownButtonsMode.Always)
            {
                // standard management
                base.OnTextBoxResize(source, e);
            }
            else
            {
                // custom management

                // change position if RTL
                bool fixPos = this.RightToLeft == RightToLeft.Yes ^ this.UpDownAlign == LeftRightAlignment.Left;

                if (_mouseOver)
                {
                    _textbox.Width = this.ClientSize.Width - _textbox.Left - _upDownButtons.Width - 2;
                    if (fixPos)
                        _textbox.Location = new Point(16, _textbox.Location.Y);
                }
                else
                {
                    if (fixPos)
                        _textbox.Location = new Point(2, _textbox.Location.Y);
                    _textbox.Width = this.ClientSize.Width - _textbox.Left - 2;
                }
            }
        }

        #endregion
    }
}

if (_upDownButtons.Visible != newVisible)
           {
               if (newVisible)
               {
                   _textbox.Width = this.ClientRectangle.Width - _upDownButtons.Width;
               }
               else
               {
                   _textbox.Width = this.ClientRectangle.Width;
               }
               _upDownButtons.Visible = newVisible;
               //OnTextBoxResize(_textbox, EventArgs.Empty);
               //this.Invalidate();
           }
           else
           {
               _textbox.Width = this.ClientRectangle.Width;
               _upDownButtons.Visible = newVisible;
           }
           OnTextBoxResize(_textbox, EventArgs.Empty);
           this.Invalidate();

protected override void OnTextBoxResize(object source, System.EventArgs e)
       {
           if (_textbox == null)
               return;
           if (_showUpDownButtons == ShowUpDownButtonsMode.Always) {
               // standard management
               base.OnTextBoxResize(source, e);
           } else {
               // custom management

               // change position if RTL
               bool fixPos = this.RightToLeft == RightToLeft.Yes ^ this.UpDownAlign == LeftRightAlignment.Left;

               if (_mouseOver && (_showUpDownButtons==ShowUpDownButtonsMode.WhenMouseOver || _showUpDownButtons==ShowUpDownButtonsMode.WhenFocusOrMouseOver))  //2018/01/05 by Dong Fei
               {
                   _textbox.Width = this.ClientSize.Width - _textbox.Left - _upDownButtons.Width - 2;
                   if (fixPos)
                       _textbox.Location = new Point(16, _textbox.Location.Y);
               }
               else
               {
                   if (fixPos)
                       _textbox.Location = new Point(2, _textbox.Location.Y);
                   _textbox.Width = this.ClientSize.Width - _textbox.Left - 2;
               }

           }

       }

FieldInfo m_Field
      Type t = typeof(UpDownBase);
      m_Field = t.GetField("defaultButtonsWidth",  BindingFlags.NonPublic | BindingFlags.Static);
      field.SetValue(null, 30);

oldvalue  =  (int)m_Field.GetValue(null);

m_Field.SetValue(null, oldvalue);

Protected Overrides Sub OnLeave(e As EventArgs)
    Dim ce As New System.ComponentModel.CancelEventArgs(False)
    MyBase.OnValidating(ce)
    If ce.Cancel Then
        Me.Select()
    Else
        MyBase.OnLeave(e)
    End If
End Sub

public enum ShowUpDownButtonsMode
{
    /// <summary>UpDownButtons are always visible (default behavior)</summary>
    Always,
    /// <summary>UpDownButtons are visble only when mouse is over the control</summary>
    WhenMouseOver,
    /// <summary>UpDownButtons are visible only when control has the focus</summary>
    WhenFocus,
    /// <summary>UpDownButtons are visible when control has focus or mouse is over the control</summary>
    WhenFocusOrMouseOver
}

// flag to track mouse position
private bool _mouseOver = false;
// flag to track focus
private bool _haveFocus = false;

// select all the text on focus enter
protected override void OnGotFocus(EventArgs e)
{
    _haveFocus = true;
    if (_autoSelect)
    {
        _textbox.SelectAll();
    }
    // Update UpDownButtons visibility
    if (_showUpDownButtons == ShowUpDownButtonsMode.WhenFocus | _showUpDownButtons == ShowUpDownButtonsMode.WhenFocusOrMouseOver)
    {
        UpdateUpDownButtonsVisibility();
    }
    base.OnGotFocus(e);
}

// indicate that we have lost the focus
protected override void OnLostFocus(EventArgs e)
{
    _haveFocus = false;
    // Update UpDownButtons visibility
    if (_showUpDownButtons == ShowUpDownButtonsMode.WhenFocus | _showUpDownButtons == ShowUpDownButtonsMode.WhenFocusOrMouseOver)
    {
        UpdateUpDownButtonsVisibility();
    }
    base.OnLostFocus(e);
}

public void UpdateUpDownButtonsVisibility()
{
    // test new state
    bool newVisible = false;
    switch (_showUpDownButtons)
    {
        case ShowUpDownButtonsMode.WhenMouseOver:
            newVisible = _mouseOver;
            break;
        case ShowUpDownButtonsMode.WhenFocus:
            newVisible = _haveFocus;
            break;
        case ShowUpDownButtonsMode.WhenFocusOrMouseOver:
            newVisible = _mouseOver | _haveFocus;
            break;
        default:
            newVisible = true;
            break;
    }

    // assign only if needed
    .....
}