[LoongArch64] Part-5:add loongarch support in some files for LoongArch64. (#21769)

[mono-project.git] / mcs / class / System.Windows.Forms / System.Windows.Forms / NumericUpDown.cs

// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2005 Novell, Inc.
//
// Authors:
//      Jonathan Gilbert        <logic@deltaq.org>
//
// Integration into MWF:
//      Peter Bartok            <pbartok@novell.com>
//

using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;

namespace System.Windows.Forms {
        [DefaultEvent("ValueChanged")]
        [DefaultProperty("Value")]
        [DefaultBindingProperty ("Value")]
        [ClassInterface (ClassInterfaceType.AutoDispatch)]
        [ComVisible (true)]
        public class NumericUpDown : UpDownBase, ISupportInitialize {
                #region Local Variables
                private bool    suppress_validation;
                private int     decimal_places;
                private bool    hexadecimal;
                private decimal increment;
                private decimal maximum;
                private decimal minimum;
                private bool    thousands_separator;
                private decimal dvalue;
                

                NumericUpDownAccelerationCollection accelerations;
//              private long buttonPressedTicks;
                //private bool isSpinning;
                #endregion      // Local Variables

                #region UIA FrameWork Events
                static object UIAMinimumChangedEvent = new object ();

                internal event EventHandler UIAMinimumChanged {
                        add { Events.AddHandler (UIAMinimumChangedEvent, value); }
                        remove { Events.RemoveHandler (UIAMinimumChangedEvent, value); }
                }

                internal void OnUIAMinimumChanged (EventArgs e)
                {
                        EventHandler eh = (EventHandler) Events [UIAMinimumChangedEvent];
                        if (eh != null)
                                eh (this, e);
                }

                static object UIAMaximumChangedEvent = new object ();

                internal event EventHandler UIAMaximumChanged {
                        add { Events.AddHandler (UIAMaximumChangedEvent, value); }
                        remove { Events.RemoveHandler (UIAMaximumChangedEvent, value); }
                }

                internal void OnUIAMaximumChanged (EventArgs e)
                {
                        EventHandler eh = (EventHandler) Events [UIAMaximumChangedEvent];
                        if (eh != null)
                                eh (this, e);
                }

                static object UIASmallChangeChangedEvent = new object ();

                internal event EventHandler UIASmallChangeChanged {
                        add { Events.AddHandler (UIASmallChangeChangedEvent, value); }
                        remove { Events.RemoveHandler (UIASmallChangeChangedEvent, value); }
                }

                internal void OnUIASmallChangeChanged (EventArgs e)
                {
                        EventHandler eh = (EventHandler) Events [UIASmallChangeChangedEvent];
                        if (eh != null)
                                eh (this, e);
                }
                #endregion

                #region Public Constructors
                public NumericUpDown() {
                        suppress_validation = false;
                        decimal_places = 0;
                        hexadecimal = false;
                        increment = 1M;
                        maximum = 100M;
                        minimum = 0M;
                        thousands_separator = false;

                        Text = "0";
                }
                #endregion      // Public Constructors

                #region Public Instance Properties

                [Browsable (false)]
                [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
                public NumericUpDownAccelerationCollection Accelerations {
                        get {
                                if (accelerations == null)
                                        accelerations = new NumericUpDownAccelerationCollection ();
                                return accelerations;
                        }
                }

                [DefaultValue(0)]
                public int DecimalPlaces {
                        get {
                                return decimal_places;
                        }

                        set {
                                decimal_places = value;
                                UpdateEditText();
                        }
                }

                [DefaultValue(false)]
                public bool Hexadecimal {
                        get {
                                return hexadecimal;
                        }

                        set {
                                hexadecimal = value;
                                UpdateEditText();
                        }
                }

                public decimal Increment {
                        get {

                                return increment;
                        }

                        set {
                                if (value < 0) {
                                        throw new ArgumentOutOfRangeException("value", value, "NumericUpDown increment cannot be negative");
                                }

                                increment = value;

                                // UIA Framework Event: SmallChange Changed
                                OnUIASmallChangeChanged (EventArgs.Empty);
                        }
                }

                [RefreshProperties(RefreshProperties.All)]
                public decimal Maximum {
                        get {
                                return maximum;
                        }

                        set {
                                maximum = value;

                                if (minimum > maximum)
                                        minimum = maximum;

                                if (dvalue > maximum)
                                        Value = maximum;

                                // UIA Framework Event: Maximum Changed
                                OnUIAMaximumChanged (EventArgs.Empty);
                        }
                }

                [RefreshProperties(RefreshProperties.All)]
                public decimal Minimum {
                        get {
                                return minimum;
                        }

                        set {
                                minimum = value;

                                if (maximum < minimum)
                                        maximum = minimum;

                                if (dvalue < minimum)
                                        Value = minimum;

                                // UIA Framework Event: Minimum Changed
                                OnUIAMinimumChanged (EventArgs.Empty);
                        }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
                public new Padding Padding {
                        get { return Padding.Empty; }
                        set { }
                }

                [Bindable(false)]
                [Browsable(false)]
                [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
                [EditorBrowsable(EditorBrowsableState.Never)]
                public override string Text {
                        get {
                                return base.Text;
                        }

                        set {
                                base.Text = value;
                        }
                }

                [DefaultValue(false)]
                [Localizable(true)]
                public bool ThousandsSeparator {
                        get {
                                return thousands_separator;
                        }

                        set {
                                thousands_separator = value;
                                UpdateEditText();
                        }
                }

                [Bindable(true)]
                public decimal Value {
                        get {
                                if (UserEdit)
                                        ValidateEditText ();
                                return dvalue;
                        }

                        set {
                                if (value != dvalue) {
                                        if (!suppress_validation && ((value < minimum) || (value > maximum))) {
                                                throw new ArgumentOutOfRangeException ("value", "NumericUpDown.Value must be within the specified Minimum and Maximum values");
                                        }

                                        dvalue = value;
                                        OnValueChanged (EventArgs.Empty);
                                        UpdateEditText ();
                                }
                        }
                }
                #endregion      // Public Instance Properties

                #region Public Instance Methods
                public void BeginInit() {
                        suppress_validation = true;
                }

                public void EndInit() {
                        suppress_validation = false;
                        Value = Check (dvalue);
                        UpdateEditText ();
                }

                public override string ToString() {
                        return string.Format("{0}, Minimum = {1}, Maximum = {2}", base.ToString(), minimum, maximum);
                }

                public override void DownButton() {
                        if (UserEdit) {
                                ParseEditText ();
                        }

                        Value = Math.Max (minimum, unchecked (dvalue - increment));

                        // UIA Framework Event: DownButton Click
                        OnUIADownButtonClick (EventArgs.Empty);
                }

                public override void UpButton() {
                        if (UserEdit) {
                                ParseEditText ();
                        }

                        Value = Math.Min (maximum, unchecked (dvalue + increment));

                        // UIA Framework Event: UpButton Click
                        OnUIAUpButtonClick (EventArgs.Empty);
                }
                #endregion      // Public Instance Methods

                #region Protected Instance Methods
                protected override AccessibleObject CreateAccessibilityInstance() {
                        AccessibleObject        acc;

                        acc = new AccessibleObject(this);
                        acc.role = AccessibleRole.SpinButton;

                        return acc;
                }

                protected override void OnTextBoxKeyPress(object source, KeyPressEventArgs e) {
                        if ((ModifierKeys & ~Keys.Shift) != Keys.None) {
                                return;
                        }

                        NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
                        string pressedKey = e.KeyChar.ToString ();

                        if ((pressedKey != nfi.NegativeSign) && (pressedKey != nfi.NumberDecimalSeparator) && 
                                (pressedKey != nfi.NumberGroupSeparator)) {
                                string acceptable = hexadecimal ? "\b0123456789abcdefABCDEF" : "\b0123456789";
                                if (acceptable.IndexOf (e.KeyChar) == -1) {
                                        // FIXME: produce beep to signal that "invalid" key was pressed
                                        // prevent the key from reaching the text box
                                        e.Handled = true;
                                }
                        }

                        base.OnTextBoxKeyPress(source, e);
                }

                protected virtual void OnValueChanged(EventArgs e) {
                        EventHandler eh = (EventHandler)(Events [ValueChangedEvent]);
                        if (eh != null)
                                eh (this, e);
                }

                protected void ParseEditText () {
                        try {
                                if (!hexadecimal) {
                                        Value = Check (decimal.Parse (Text, CultureInfo.CurrentCulture));
                                } else {
                                        Value = Check (Convert.ToDecimal (Convert.ToInt32 (Text, 16)));
                                }
                        }
                        catch { }
                        finally {
                                UserEdit = false;
                        }
                }

                private decimal Check (decimal val)
                {
                        decimal ret = val;
                        if (ret < minimum) {
                                ret = minimum;
                        }

                        if (ret > maximum) {
                                ret = maximum;
                        }

                        return ret;
                }

                protected override void UpdateEditText () {
                        if (suppress_validation)
                                return;

                        if (UserEdit)
                                ParseEditText ();

                        ChangingText = true;
                        if (!hexadecimal) {
                                // "N" and "F" differ only in that "N" includes commas
                                // every 3 digits to the left of the decimal and "F"
                                // does not.

                                string format_string;

                                if (thousands_separator) {
                                        format_string = "N";
                                } else {
                                        format_string = "F";
                                }

                                format_string += decimal_places;

                                Text = dvalue.ToString (format_string, CultureInfo.CurrentCulture);

                        } else {
                                // Cast to Int64 to be able to use the "X" formatter.
                                // If the value is below Int64.MinValue or above Int64.MaxValue,
                                // then an OverflowException will be thrown, as with .NET.
                                Text = ((Int64)dvalue).ToString("X", CultureInfo.CurrentCulture);
                        }
                }


                protected override void ValidateEditText() {
                        ParseEditText ();
                        UpdateEditText ();
                }

                protected override void OnLostFocus(EventArgs e) {
                        base.OnLostFocus(e);
                        if (UserEdit)
                                UpdateEditText();
                }

                protected override void OnKeyUp (KeyEventArgs e)
                {
//                      isSpinning = false;
                        base.OnKeyUp (e);
                }

                protected override void OnKeyDown (KeyEventArgs e)
                {
//                      buttonPressedTicks = DateTime.Now.Ticks;
//                      isSpinning = true;
                        base.OnKeyDown (e);
                }
                #endregion      // Protected Instance Methods

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

                static object ValueChangedEvent = new object ();

                public event EventHandler ValueChanged {
                        add { Events.AddHandler (ValueChangedEvent, value); }
                        remove { Events.RemoveHandler (ValueChangedEvent, value); }
                }

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