diff --git a/demo/Ursa.Demo/Models/MenuKeys.cs b/demo/Ursa.Demo/Models/MenuKeys.cs
index 1b88691..b3e2753 100644
--- a/demo/Ursa.Demo/Models/MenuKeys.cs
+++ b/demo/Ursa.Demo/Models/MenuKeys.cs
@@ -15,6 +15,7 @@ public static class MenuKeys
public const string MenuKeyLoading = "Loading";
public const string MenuKeyMessageBox = "MessageBox";
public const string MenuKeyNavigation = "Navigation";
+ public const string MenuKeyNumericUpDown = "NumericUpDown";
public const string MenuKeyPagination = "Pagination";
public const string MenuKeyTagInput = "TagInput";
public const string MenuKeyTimeline = "Timeline";
diff --git a/demo/Ursa.Demo/Pages/NumericUpDownDemo.axaml b/demo/Ursa.Demo/Pages/NumericUpDownDemo.axaml
new file mode 100644
index 0000000..afe4496
--- /dev/null
+++ b/demo/Ursa.Demo/Pages/NumericUpDownDemo.axaml
@@ -0,0 +1,26 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/demo/Ursa.Demo/Pages/NumericUpDownDemo.axaml.cs b/demo/Ursa.Demo/Pages/NumericUpDownDemo.axaml.cs
new file mode 100644
index 0000000..4bdf06d
--- /dev/null
+++ b/demo/Ursa.Demo/Pages/NumericUpDownDemo.axaml.cs
@@ -0,0 +1,15 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using Ursa.Demo.ViewModels;
+
+namespace Ursa.Demo.Pages;
+
+public partial class NumericUpDownDemo : UserControl
+{
+ public NumericUpDownDemo()
+ {
+ InitializeComponent();
+ DataContext = new NumericUpDownDemoViewModel();
+ }
+}
\ No newline at end of file
diff --git a/demo/Ursa.Demo/ViewModels/MainViewViewModel.cs b/demo/Ursa.Demo/ViewModels/MainViewViewModel.cs
index 83fea1a..85312ef 100644
--- a/demo/Ursa.Demo/ViewModels/MainViewViewModel.cs
+++ b/demo/Ursa.Demo/ViewModels/MainViewViewModel.cs
@@ -37,6 +37,7 @@ public class MainViewViewModel : ViewModelBase
MenuKeys.MenuKeyLoading => new LoadingDemoViewModel(),
MenuKeys.MenuKeyMessageBox => new MessageBoxDemoViewModel(),
MenuKeys.MenuKeyNavigation => new NavigationMenuDemoViewModel(),
+ MenuKeys.MenuKeyNumericUpDown => new NumericUpDownDemoViewModel(),
MenuKeys.MenuKeyPagination => new PaginationDemoViewModel(),
MenuKeys.MenuKeyTagInput => new TagInputDemoViewModel(),
MenuKeys.MenuKeyTimeline => new TimelineDemoViewModel(),
diff --git a/demo/Ursa.Demo/ViewModels/MenuViewModel.cs b/demo/Ursa.Demo/ViewModels/MenuViewModel.cs
index c321499..ea66a5e 100644
--- a/demo/Ursa.Demo/ViewModels/MenuViewModel.cs
+++ b/demo/Ursa.Demo/ViewModels/MenuViewModel.cs
@@ -24,6 +24,7 @@ public class MenuViewModel: ViewModelBase
new() { MenuHeader = "Loading", Key = MenuKeys.MenuKeyLoading },
new() { MenuHeader = "Message Box", Key = MenuKeys.MenuKeyMessageBox },
new() { MenuHeader = "Navigation", Key = MenuKeys.MenuKeyNavigation },
+ new() { MenuHeader = "NumericUpDown", Key = MenuKeys.MenuKeyNumericUpDown },
new() { MenuHeader = "Pagination", Key = MenuKeys.MenuKeyPagination },
new() { MenuHeader = "TagInput", Key = MenuKeys.MenuKeyTagInput },
new() { MenuHeader = "Timeline", Key = MenuKeys.MenuKeyTimeline },
diff --git a/demo/Ursa.Demo/ViewModels/NumericUpDownDemoViewModel.cs b/demo/Ursa.Demo/ViewModels/NumericUpDownDemoViewModel.cs
new file mode 100644
index 0000000..9840cca
--- /dev/null
+++ b/demo/Ursa.Demo/ViewModels/NumericUpDownDemoViewModel.cs
@@ -0,0 +1,8 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace Ursa.Demo.ViewModels;
+
+public class NumericUpDownDemoViewModel: ObservableObject
+{
+
+}
\ No newline at end of file
diff --git a/src/Ursa.Themes.Semi/Controls/NumericUpDown.axaml b/src/Ursa.Themes.Semi/Controls/NumericUpDown.axaml
new file mode 100644
index 0000000..31c1aa8
--- /dev/null
+++ b/src/Ursa.Themes.Semi/Controls/NumericUpDown.axaml
@@ -0,0 +1,87 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Ursa.Themes.Semi/Controls/_index.axaml b/src/Ursa.Themes.Semi/Controls/_index.axaml
index 1fbacb9..edf9abb 100644
--- a/src/Ursa.Themes.Semi/Controls/_index.axaml
+++ b/src/Ursa.Themes.Semi/Controls/_index.axaml
@@ -13,6 +13,7 @@
+
diff --git a/src/Ursa/Controls/NumericUpDown/IntUpDown.cs b/src/Ursa/Controls/NumericUpDown/IntUpDown.cs
new file mode 100644
index 0000000..4feedcb
--- /dev/null
+++ b/src/Ursa/Controls/NumericUpDown/IntUpDown.cs
@@ -0,0 +1,236 @@
+using System.Globalization;
+using Avalonia.Controls;
+using Avalonia.Utilities;
+
+namespace Ursa.Controls;
+
+public class NumericIntUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericIntUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(int.MaxValue);
+ MinimumProperty.OverrideDefaultValue(int.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out int number) =>
+ int.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(int? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override int Zero => 0;
+
+ protected override int? Add(int? a, int? b) => a + b;
+
+ protected override int? Minus(int? a, int? b) => a - b;
+}
+
+public class NumericDoubleUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericDoubleUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(double.MaxValue);
+ MinimumProperty.OverrideDefaultValue(double.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out double number) =>
+ double.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(double? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override double Zero => 0;
+
+ protected override double? Add(double? a, double? b) => a + b;
+
+ protected override double? Minus(double? a, double? b) => a - b;
+}
+
+public class NumericByteUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericByteUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(byte.MaxValue);
+ MinimumProperty.OverrideDefaultValue(byte.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out byte number) =>
+ byte.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(byte? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override byte Zero => 0;
+
+ protected override byte? Add(byte? a, byte? b) => (byte?) (a + b);
+
+ protected override byte? Minus(byte? a, byte? b) => (byte?) (a - b);
+}
+
+public class NumericSByteUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericSByteUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(sbyte.MaxValue);
+ MinimumProperty.OverrideDefaultValue(sbyte.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out sbyte number) =>
+ sbyte.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(sbyte? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override sbyte Zero => 0;
+
+ protected override sbyte? Add(sbyte? a, sbyte? b) => (sbyte?) (a + b);
+
+ protected override sbyte? Minus(sbyte? a, sbyte? b) => (sbyte?) (a - b);
+}
+
+public class NumericShortUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericShortUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(short.MaxValue);
+ MinimumProperty.OverrideDefaultValue(short.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out short number) =>
+ short.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(short? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override short Zero => 0;
+
+ protected override short? Add(short? a, short? b) => (short?) (a + b);
+
+ protected override short? Minus(short? a, short? b) => (short?) (a - b);
+}
+
+public class NumericUShortUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericUShortUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(ushort.MaxValue);
+ MinimumProperty.OverrideDefaultValue(ushort.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out ushort number) =>
+ ushort.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(ushort? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override ushort Zero => 0;
+
+ protected override ushort? Add(ushort? a, ushort? b) => (ushort?) (a + b);
+
+ protected override ushort? Minus(ushort? a, ushort? b) => (ushort?) (a - b);
+}
+
+public class NumericLongUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericLongUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(long.MaxValue);
+ MinimumProperty.OverrideDefaultValue(long.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out long number) =>
+ long.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(long? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override long Zero => 0;
+
+ protected override long? Add(long? a, long? b) => a + b;
+
+ protected override long? Minus(long? a, long? b) => a - b;
+}
+
+public class NumericULongUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericULongUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(ulong.MaxValue);
+ MinimumProperty.OverrideDefaultValue(ulong.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out ulong number) =>
+ ulong.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(ulong? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override ulong Zero => 0;
+
+ protected override ulong? Add(ulong? a, ulong? b) => a + b;
+
+ protected override ulong? Minus(ulong? a, ulong? b) => a - b;
+}
+
+public class NumericFloatUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericFloatUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(float.MaxValue);
+ MinimumProperty.OverrideDefaultValue(float.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out float number) =>
+ float.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(float? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override float Zero => 0;
+
+ protected override float? Add(float? a, float? b) => a + b;
+
+ protected override float? Minus(float? a, float? b) => a - b;
+}
+
+public class NumericDecimalUpDown : NumericUpDownBase
+{
+ protected override Type StyleKeyOverride { get; } = typeof(NumericUpDown);
+
+ static NumericDecimalUpDown()
+ {
+ MaximumProperty.OverrideDefaultValue(decimal.MaxValue);
+ MinimumProperty.OverrideDefaultValue(decimal.MinValue);
+ StepProperty.OverrideDefaultValue(1);
+ }
+
+ protected override bool ParseText(string? text, out decimal number) =>
+ decimal.TryParse(text, ParsingNumberStyle, NumberFormat, out number);
+
+ protected override string? ValueToString(decimal? value) => value?.ToString(FormatString, NumberFormat);
+
+ protected override decimal Zero => 0;
+
+ protected override decimal? Add(decimal? a, decimal? b) => a + b;
+
+ protected override decimal? Minus(decimal? a, decimal? b) => a - b;
+}
+
diff --git a/src/Ursa/Controls/NumericUpDown/NumericUpDownBase.cs b/src/Ursa/Controls/NumericUpDown/NumericUpDownBase.cs
new file mode 100644
index 0000000..f51e43a
--- /dev/null
+++ b/src/Ursa/Controls/NumericUpDown/NumericUpDownBase.cs
@@ -0,0 +1,614 @@
+using System.Diagnostics;
+using System.Globalization;
+using System.Net.Mime;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Metadata;
+using Avalonia.Controls.Primitives;
+using Avalonia.Data.Converters;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+
+namespace Ursa.Controls;
+
+[TemplatePart(PART_Spinner, typeof(ButtonSpinner))]
+[TemplatePart(PART_TextBox, typeof(TextBox))]
+[TemplatePart(PART_DragPanel, typeof(Panel))]
+public abstract class NumericUpDown : TemplatedControl
+{
+ public const string PART_Spinner = "PART_Spinner";
+ public const string PART_TextBox = "PART_TextBox";
+ public const string PART_DragPanel = "PART_DragPanel";
+
+ protected internal ButtonSpinner? _spinner;
+ protected internal TextBox? _textBox;
+ protected internal Panel? _dragPanel;
+
+ private Point? _point;
+ protected internal bool _updateFromTextInput;
+
+ public static readonly StyledProperty AllowDragProperty = AvaloniaProperty.Register(
+ nameof(AllowDrag), defaultValue: false);
+
+ public bool AllowDrag
+ {
+ get => GetValue(AllowDragProperty);
+ set => SetValue(AllowDragProperty, value);
+ }
+
+ public static readonly StyledProperty IsReadOnlyProperty = AvaloniaProperty.Register(
+ nameof(IsReadOnly));
+
+ public bool IsReadOnly
+ {
+ get => GetValue(IsReadOnlyProperty);
+ set => SetValue(IsReadOnlyProperty, value);
+ }
+
+ public static readonly StyledProperty InnerLeftContentProperty = AvaloniaProperty.Register(
+ nameof(InnerLeftContent));
+
+ public object? InnerLeftContent
+ {
+ get => GetValue(InnerLeftContentProperty);
+ set => SetValue(InnerLeftContentProperty, value);
+ }
+
+ public static readonly StyledProperty WatermarkProperty = AvaloniaProperty.Register(
+ nameof(Watermark));
+
+ public string? Watermark
+ {
+ get => GetValue(WatermarkProperty);
+ set => SetValue(WatermarkProperty, value);
+ }
+
+ public static readonly StyledProperty NumberFormatProperty = AvaloniaProperty.Register(
+ nameof(NumberFormat), defaultValue: NumberFormatInfo.CurrentInfo);
+
+ public NumberFormatInfo? NumberFormat
+ {
+ get => GetValue(NumberFormatProperty);
+ set => SetValue(NumberFormatProperty, value);
+ }
+
+ public static readonly StyledProperty FormatStringProperty = AvaloniaProperty.Register(
+ nameof(FormatString), string.Empty);
+
+ public string FormatString
+ {
+ get => GetValue(FormatStringProperty);
+ set => SetValue(FormatStringProperty, value);
+ }
+
+ public static readonly StyledProperty ParsingNumberStyleProperty = AvaloniaProperty.Register(
+ nameof(ParsingNumberStyle), defaultValue: NumberStyles.Any);
+
+ public NumberStyles ParsingNumberStyle
+ {
+ get => GetValue(ParsingNumberStyleProperty);
+ set => SetValue(ParsingNumberStyleProperty, value);
+ }
+
+ public static readonly StyledProperty TextConverterProperty = AvaloniaProperty.Register(
+ nameof(TextConverter));
+
+ public IValueConverter? TextConverter
+ {
+ get => GetValue(TextConverterProperty);
+ set => SetValue(TextConverterProperty, value);
+ }
+
+ public static readonly StyledProperty AllowSpinProperty = AvaloniaProperty.Register(
+ nameof(AllowSpin), true);
+
+ public bool AllowSpin
+ {
+ get => GetValue(AllowSpinProperty);
+ set => SetValue(AllowSpinProperty, value);
+ }
+
+ public event EventHandler? Spinned;
+
+ static NumericUpDown()
+ {
+ NumberFormatProperty.Changed.AddClassHandler((o, e) => o.OnFormatChange(e));
+ FormatStringProperty.Changed.AddClassHandler((o, e) => o.OnFormatChange(e));
+ IsReadOnlyProperty.Changed.AddClassHandler((o,e)=>o.ChangeToSetSpinDirection(e));
+ TextConverterProperty.Changed.AddClassHandler((o, e) => o.OnFormatChange(e));
+ }
+
+ protected void ChangeToSetSpinDirection(AvaloniaPropertyChangedEventArgs avaloniaPropertyChangedEventArgs, bool afterInitialization = false)
+ {
+ if (afterInitialization)
+ {
+ if (IsInitialized)
+ {
+ SetValidSpinDirection();
+ }
+ }
+ else
+ {
+ SetValidSpinDirection();
+ }
+ }
+
+ protected virtual void OnFormatChange(AvaloniaPropertyChangedEventArgs arg)
+ {
+ if (IsInitialized)
+ {
+ SyncTextAndValue(false, null);
+ }
+ }
+
+ protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+ {
+ base.OnApplyTemplate(e);
+ if(_spinner is not null)
+ {
+ _spinner.Spin -= OnSpin;
+ }
+ if (_dragPanel is not null)
+ {
+ _dragPanel.PointerPressed -= OnDragPanelPointerPressed;
+ _dragPanel.PointerMoved -= OnDragPanelPointerMoved;
+ _dragPanel.PointerReleased -= OnDragPanelPointerReleased;
+ }
+ _spinner = e.NameScope.Find(PART_Spinner);
+ _textBox = e.NameScope.Find(PART_TextBox);
+ _dragPanel = e.NameScope.Find(PART_DragPanel);
+ if (_spinner is not null)
+ {
+ _spinner.Spin += OnSpin;
+ }
+ if (_dragPanel is not null)
+ {
+ _dragPanel.PointerPressed+= OnDragPanelPointerPressed;
+ _dragPanel.PointerMoved += OnDragPanelPointerMoved;
+ _dragPanel.PointerReleased += OnDragPanelPointerReleased;
+ }
+
+ }
+
+ protected override void OnLostFocus(RoutedEventArgs e)
+ {
+ CommitInput(true);
+ base.OnLostFocus(e);
+ if(AllowDrag && _dragPanel is not null)
+ {
+ _dragPanel.IsVisible = true;
+ }
+ }
+
+ protected override void OnKeyDown(KeyEventArgs e)
+ {
+ if (e.Key == Key.Enter)
+ {
+ var commitSuccess = CommitInput(true);
+ e.Handled = !commitSuccess;
+ }
+
+ if (e.Key == Key.Escape)
+ {
+ if (AllowDrag && _dragPanel is not null)
+ {
+ _dragPanel.IsVisible = true;
+ }
+ }
+ }
+
+ private void OnDragPanelPointerPressed(object sender, PointerPressedEventArgs e)
+ {
+ _point = e.GetPosition(this);
+ if (e.ClickCount == 2 && _dragPanel is not null && AllowDrag)
+ {
+ _dragPanel.IsVisible = false;
+ }
+ _textBox?.Focus();
+ }
+
+ private void OnDragPanelPointerReleased(object sender, PointerReleasedEventArgs e)
+ {
+ _point = null;
+ }
+
+ private void OnDragPanelPointerMoved(object sender, PointerEventArgs e)
+ {
+ if (!AllowDrag || IsReadOnly) return;
+ if(!e.GetCurrentPoint(this).Properties.IsLeftButtonPressed) return;
+ var point = e.GetPosition(this);
+ var delta = point - _point;
+ if (delta is null)
+ {
+ return;
+ }
+ int d = GetDelta(delta.Value);
+ if(d > 0)
+ {
+ Increase();
+ }
+ else if (d < 0)
+ {
+ Decrease();
+ }
+ _point = point;
+ }
+
+ private int GetDelta(Point point)
+ {
+ bool horizontal = Math.Abs(point.X) > Math.Abs(point.Y);
+ var value = horizontal ? point.X : -point.Y;
+ return value switch
+ {
+ > 0 => 1,
+ < 0 => -1,
+ _ => 0
+ };
+ }
+
+ private void OnSpin(object sender, SpinEventArgs e)
+ {
+ if (AllowSpin && !IsReadOnly)
+ {
+ var spin = !e.UsingMouseWheel;
+ spin |= _textBox is { IsFocused: true };
+ if (spin)
+ {
+ e.Handled = true;
+ var handler = Spinned;
+ handler?.Invoke(this, e);
+ if (e.Direction == SpinDirection.Increase)
+ {
+ Increase();
+ }
+ else
+ {
+ Decrease();
+ }
+ }
+ }
+ }
+
+ protected abstract void SetValidSpinDirection();
+
+ protected abstract void Increase();
+ protected abstract void Decrease();
+
+ protected virtual bool CommitInput(bool forceTextUpdate = false)
+ {
+ return SyncTextAndValue(true, _textBox?.Text, forceTextUpdate);
+ }
+
+ protected abstract bool SyncTextAndValue(bool fromTextToValue = false, string? text = null,
+ bool forceTextUpdate = false);
+
+ public abstract void Clear();
+}
+
+public abstract class NumericUpDownBase: NumericUpDown where T: struct, IComparable
+{
+ public static readonly StyledProperty ValueProperty = AvaloniaProperty.Register, T?>(
+ nameof(Value));
+
+ public T? Value
+ {
+ get => GetValue(ValueProperty);
+ set => SetValue(ValueProperty, value);
+ }
+
+ public static readonly StyledProperty MaximumProperty = AvaloniaProperty.Register, T>(
+ nameof(Maximum), coerce: CoerceMaximum);
+
+ public T Maximum
+ {
+ get => GetValue(MaximumProperty);
+ set => SetValue(MaximumProperty, value);
+ }
+
+ public static readonly StyledProperty MinimumProperty = AvaloniaProperty.Register, T>(
+ nameof(Minimum), coerce: CoerceMinimum);
+
+ public T Minimum
+ {
+ get => GetValue(MinimumProperty);
+ set => SetValue(MinimumProperty, value);
+ }
+
+ #region Max and Min Coerce
+ private static T CoerceMaximum(AvaloniaObject instance, T value)
+ {
+ if (instance is NumericUpDownBase n)
+ {
+ return n.CoerceMaximum(value);
+ }
+
+ return value;
+ }
+
+ private T CoerceMaximum(T value)
+ {
+ if (value.CompareTo(Minimum) < 0)
+ {
+ return Minimum;
+ }
+ return value;
+ }
+
+ private static T CoerceMinimum(AvaloniaObject instance, T value)
+ {
+ if (instance is NumericUpDownBase n)
+ {
+ return n.CoerceMinimum(value);
+ }
+
+ return value;
+ }
+
+ private T CoerceMinimum(T value)
+ {
+ if (value.CompareTo(Maximum) > 0)
+ {
+ return Maximum;
+ }
+ return value;
+ }
+
+ #endregion
+
+ public static readonly StyledProperty StepProperty = AvaloniaProperty.Register, T>(
+ nameof(Step));
+
+ public T Step
+ {
+ get => GetValue(StepProperty);
+ set => SetValue(StepProperty, value);
+ }
+
+ public static readonly StyledProperty EmptyInputValueProperty =
+ AvaloniaProperty.Register, T?>(
+ nameof(EmptyInputValue), defaultValue: null);
+
+ public T? EmptyInputValue
+ {
+ get => GetValue(EmptyInputValueProperty);
+ set => SetValue(EmptyInputValueProperty, value);
+ }
+
+ ///
+ /// Defines the event.
+ ///
+ public static readonly RoutedEvent> ValueChangedEvent =
+ RoutedEvent.Register>(nameof(ValueChanged), RoutingStrategies.Bubble);
+
+ ///
+ /// Raised when the changes.
+ ///
+ public event EventHandler>? ValueChanged
+ {
+ add => AddHandler(ValueChangedEvent, value);
+ remove => RemoveHandler(ValueChangedEvent, value);
+ }
+
+ static NumericUpDownBase()
+ {
+ StepProperty.Changed.AddClassHandler>((o, e) => o.ChangeToSetSpinDirection(e));
+ MaximumProperty.Changed.AddClassHandler>((o, e) => o.OnConstraintChanged(e));
+ MinimumProperty.Changed.AddClassHandler>((o, e) => o.OnConstraintChanged(e));
+ ValueProperty.Changed.AddClassHandler>((o, e) => o.OnValueChanged(e) );
+ }
+
+ private void OnConstraintChanged(AvaloniaPropertyChangedEventArgs avaloniaPropertyChangedEventArgs)
+ {
+ if (IsInitialized)
+ {
+ SetValidSpinDirection();
+ }
+ if (Value.HasValue)
+ {
+ SetCurrentValue(ValueProperty, Clamp(Value, Maximum, Minimum));
+ }
+ }
+
+ private void OnValueChanged(AvaloniaPropertyChangedEventArgs args)
+ {
+ if (IsInitialized)
+ {
+ SyncTextAndValue(false, null, true);
+ }
+ SetValidSpinDirection();
+ T? oldValue = args.GetOldValue();
+ T? newValue = args.GetNewValue();
+ var e = new ValueChangedEventArgs(ValueChangedEvent, oldValue, newValue);
+ RaiseEvent(e);
+ }
+
+ protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+ {
+ base.OnApplyTemplate(e);
+ if (_textBox != null)
+ {
+ _textBox.Text = ConvertValueToText(Value);
+ }
+ SetValidSpinDirection();
+ }
+
+ protected virtual T? Clamp(T? value, T max, T min)
+ {
+ if (value is null)
+ {
+ return null;
+ }
+ if (value.Value.CompareTo(max) > 0)
+ {
+ return max;
+ }
+ if (value.Value.CompareTo(min) < 0)
+ {
+ return min;
+ }
+ return value;
+ }
+
+ protected override void SetValidSpinDirection()
+ {
+ var validDirection = ValidSpinDirections.None;
+ if (!IsReadOnly)
+ {
+ if (Value is null)
+ {
+ validDirection = ValidSpinDirections.Increase | ValidSpinDirections.Decrease;
+ }
+ if (Value.HasValue && Value.Value.CompareTo(Maximum) < 0)
+ {
+ validDirection |= ValidSpinDirections.Increase;
+ }
+
+ if (Value.HasValue && Value.Value.CompareTo(Minimum) > 0)
+ {
+ validDirection |= ValidSpinDirections.Decrease;
+ }
+ }
+ if (_spinner != null)
+ {
+ _spinner.ValidSpinDirection = validDirection;
+ }
+ }
+
+ private bool _isSyncingTextAndValue;
+
+ protected override bool SyncTextAndValue(bool fromTextToValue = false, string? text = null, bool forceTextUpdate = false)
+ {
+ if (_isSyncingTextAndValue) return true;
+ _isSyncingTextAndValue = true;
+ var parsedTextIsValid = true;
+ try
+ {
+ if (fromTextToValue)
+ {
+ try
+ {
+ var newValue = ConvertTextToValue(text);
+ if (EmptyInputValue is not null && newValue is null)
+ {
+ newValue = EmptyInputValue;
+ }
+ if (!Equals(newValue, Value))
+ {
+ SetCurrentValue(ValueProperty, newValue);
+ }
+ }
+ catch
+ {
+ parsedTextIsValid = false;
+ }
+ }
+
+ if (!_updateFromTextInput)
+ {
+ if (forceTextUpdate)
+ {
+ var newText = ConvertValueToText(Value);
+ if (_textBox!= null && !Equals(_textBox.Text, newText))
+ {
+ _textBox.Text = newText;
+ _textBox.CaretIndex = newText?.Length ?? 0;
+ }
+ }
+ }
+
+ if (_updateFromTextInput && !parsedTextIsValid)
+ {
+ if (_spinner is not null)
+ {
+ _spinner.ValidSpinDirection = ValidSpinDirections.None;
+ }
+ }
+ else
+ {
+ SetValidSpinDirection();
+ }
+ }
+ finally
+ {
+ _isSyncingTextAndValue = false;
+ }
+ return parsedTextIsValid;
+ }
+
+ protected virtual T? ConvertTextToValue(string? text)
+ {
+ T? result;
+ if (string.IsNullOrWhiteSpace(text)) return null;
+ if (TextConverter != null)
+ {
+ var valueFromText = TextConverter.Convert(text, typeof(T?), null, CultureInfo.CurrentCulture);
+ return (T?)valueFromText;
+ }
+ else
+ {
+ if (!ParseText(text, out var outputValue))
+ {
+ throw new InvalidDataException("Input string was not in a correct format.");
+ }
+
+ result = outputValue;
+ }
+ return result;
+ }
+
+ protected virtual string? ConvertValueToText(T? value)
+ {
+ if (TextConverter is not null)
+ {
+ return TextConverter.ConvertBack(Value, typeof(int), null, CultureInfo.CurrentCulture)?.ToString();
+ }
+
+ if (FormatString.Contains("{0"))
+ {
+ return string.Format(NumberFormat, FormatString, value);
+ }
+
+ return ValueToString(Value);
+ }
+
+ protected override void Increase()
+ {
+ T? value;
+ if (Value is not null)
+ {
+ value = Add(Value.Value, Step);
+ }
+ else
+ {
+ value = IsSet(MinimumProperty) ? Minimum : Zero;
+ }
+ SetCurrentValue(ValueProperty, Clamp(value, Maximum, Minimum));
+ }
+
+ protected override void Decrease()
+ {
+ T? value;
+ if (Value is not null)
+ {
+ value = Minus(Value.Value, Step);
+ }
+ else
+ {
+ value = IsSet(MaximumProperty) ? Maximum : Zero;
+ }
+
+ SetCurrentValue(ValueProperty, Clamp(value, Maximum, Minimum));
+ }
+
+ protected abstract bool ParseText(string? text, out T number);
+ protected abstract string? ValueToString(T? value);
+ protected abstract T Zero { get; }
+ protected abstract T? Add(T? a, T? b);
+ protected abstract T? Minus(T? a, T? b);
+
+ public override void Clear()
+ {
+ SetCurrentValue(ValueProperty, EmptyInputValue);
+ SyncTextAndValue(false, forceTextUpdate: true);
+ }
+}
\ No newline at end of file
diff --git a/src/Ursa/Controls/NumericUpDown/ValueChangedEventArgs.cs b/src/Ursa/Controls/NumericUpDown/ValueChangedEventArgs.cs
new file mode 100644
index 0000000..f5929c1
--- /dev/null
+++ b/src/Ursa/Controls/NumericUpDown/ValueChangedEventArgs.cs
@@ -0,0 +1,15 @@
+using Avalonia.Interactivity;
+
+namespace Ursa.Controls;
+
+public class ValueChangedEventArgs: RoutedEventArgs where T: struct, IComparable
+{
+ public ValueChangedEventArgs(RoutedEvent routedEvent, T? oldValue, T? newValue): base(routedEvent)
+ {
+ OldValue = oldValue;
+ NewValue = newValue;
+ }
+ public T? OldValue { get; }
+ public T? NewValue { get; }
+
+}
\ No newline at end of file