BaseMatNumericUpDownFieldInternal.cs

using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace MatBlazor
{
    /// <summary>
    /// Material Design NumericUpDown for Blazor, text fields allow users to input, edit, and select text.
    /// </summary>
    /// <typeparam name="TValue">sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, decimal?</typeparam>
    public class BaseMatNumericUpDownFieldInternal<TValue> : MatInputTextComponent<TValue>
    {
        private TValue minimum;
        private TValue maximum;
        protected override EventCallback<KeyboardEventArgs> OnKeyDownEvent()
        {
            return OnKeyDownEvent2;
        }

        protected void Increase()
        {
            CurrentValue = SwitchT.Increase(CurrentValue, Step, Max);
        }

        protected void Decrease()
        {
            CurrentValue = SwitchT.Decrease(CurrentValue, Step, Min);
        }

        protected override TValue CurrentValue
        {
            get => base.CurrentValue;
            set => base.CurrentValue = SwitchT.Round(value, RoundingDecimalPlaces);
        }

        [Parameter]
        public bool AllowInput { get; set; } = true;

        [Parameter]
        public TValue Min
        {
            get => minimum;
            set
            {
                minimum = value;
            }
        }

        [Parameter]
        [Obsolete("Use parameter Min")]
        public TValue Minimum
        {
            get => minimum;
            set
            {
                minimum = value;
            }
        }
        [Parameter]
        public TValue Max
        {
            get => maximum;
            set
            {
                maximum = value;
            }
        }

        [Parameter]
        [Obsolete("Use parameter Max")]
        public TValue Maximum
        {
            get => maximum;
            set
            {
               maximum = value;
            }
        }

        [Parameter]
        public int DecimalPlaces { get; set; } = 0;

        private int RoundingDecimalPlaces => FieldType == MatNumericUpDownFieldType.Percent ? DecimalPlaces + 2 : DecimalPlaces;

        [Parameter]
        public TValue Step { get; set; }

        [Parameter]
        public MatNumericUpDownFieldType FieldType { get; set; }

        public string PlusIcon { get; set; } = MatIconNames.Keyboard_arrow_down;

        public string MinusIcon { get; set; } = MatIconNames.Keyboard_arrow_up;

        protected override bool InputTextReadOnly()
        {
            return base.InputTextReadOnly() || !AllowInput;
        }

        private readonly EventCallback<KeyboardEventArgs> OnKeyDownEvent2;
        public BaseMatNumericUpDownFieldInternal()
        {
            OnKeyDownEvent2 = EventCallback.Factory.Create<KeyboardEventArgs>(this, async (e) =>
                {
                    await OnKeyDown.InvokeAsync(e);
                    if (e.Key == "ArrowUp")
                    {
                        Increase();
                    }
                    else if (e.Key == "ArrowDown")
                    {
                        Decrease();
                    }
                });
            Max = SwitchT.GetMaximum();
            Min = SwitchT.GetMinimum();

            ClassMapper.Add("mat-numeric-up-down-field");
            ClassMapper.Add("mat-text-field-with-actions-container");
        }

        private readonly TValue ZeroValue = MatTypeConverter.ChangeType<TValue>(0);

        protected override void OnParametersSet()
        {
            if (FieldType == MatNumericUpDownFieldType.Currency)
            {
                if (Step == null || Step.Equals(ZeroValue))
                {
                    Step = SwitchT.GetStep();
                }
                Format = $"c{DecimalPlaces}";
            }
            else if (FieldType == MatNumericUpDownFieldType.Percent)
            {
                if (Step == null || Step.Equals(ZeroValue))
                {
                    Step = MatTypeConverter.ChangeType<TValue>(0.01m);
                }
                Format = $"p{DecimalPlaces}";
            }
            else if (Step == null || Step.Equals(ZeroValue))
            {
                Step = SwitchT.GetStep();
            }
        }

        protected async override Task OnFirstAfterRenderAsync()
        {
            await base.OnFirstAfterRenderAsync();
        }

        protected override bool TryParseValueFromString(string value, out TValue result, out string validationErrorMessage)
        {
            if (string.IsNullOrEmpty(value) == false)
            {
                if (value[^1] == '%')
                {
                    value = value[0..^1];
                }
            }
            var success = base.TryParseValueFromString(value, out result, out validationErrorMessage);
            
            if (success == true && FieldType == MatNumericUpDownFieldType.Percent)
            {
                // The standard percent formatter assumes 1.0 is 100%, so we divide the input by 100 to make the input match the output
                if (result != null)
                {
                    if (result is decimal decimalResult)
                    {
                        result = MatTypeConverter.ChangeType<TValue>(decimalResult * 0.01m);
                    }
                    else if (result is float floatResult)
                    {
                        result = MatTypeConverter.ChangeType<TValue>(floatResult * 0.01f);
                    }
                    else if (result is double doubleResult)
                    {
                        result = MatTypeConverter.ChangeType<TValue>(doubleResult * 0.01d);
                    }
                }
            }
            if (result != null) // Snap to Min/Max
            {
                var comparer = Comparer<TValue>.Default;
                if (Max != null && comparer.Compare(result, Max) > 0) result = Max;
                if (Min != null && comparer.Compare(result, Min) < 0) result = Min;
            }

            return success;
        }
    }
}