Fixes #4621. Replace TimeField/DateField with new TimeEditor/DateEditor based on TextValidateField

Examples/UICatalog/Scenarios/TimeAndDate.cs

@@ -1,5 +1,6 @@
 #nullable enable
 using System;
+using System.Globalization;
 
 namespace UICatalog.Scenarios;
 
@@ -14,6 +15,7 @@ public class TimeAndDate : Scenario
     private Label? _lblOldDate;
     private Label? _lblOldTime;
     private Label? _lblTimeFmt;
+    private Label? _lblTimeEditorValue;
 
     public override void Main ()
     {
@@ -23,10 +25,20 @@ public override void Main ()
         app.Init ();
 
         using Window win = new () { Title = GetQuitKeyAndName () };
+
+        // TimeField examples (existing)
+        Label tfLabel = new ()
+        {
+            X = Pos.Center (),
+            Y = 1,
+            Text = "TimeField (Legacy):"
+        };
+        win.Add (tfLabel);
+
         TimeField longTime = new ()
         {
             X = Pos.Center (),
-            Y = 2,
+            Y = Pos.Bottom (tfLabel),
             IsShortFormat = false,
             ReadOnly = false,
             Value = DateTime.Now.TimeOfDay
@@ -44,10 +56,53 @@ public override void Main ()
         };
         shortTime.ValueChanged += TimeChanged;
         win.Add (shortTime);
+
+        // TimeEditor examples (new)
+        Label teLabel = new ()
+        {
+            X = Pos.Center (),
+            Y = Pos.Bottom (shortTime) + 1,
+            Text = "TimeEditor (New - based on TextValidateField):"
+        };
+        win.Add (teLabel);
+
+        // Default culture time editor
+        TimeEditor defaultTimeEditor = new ()
+        {
+            X = Pos.Center (),
+            Y = Pos.Bottom (teLabel),
+            Value = DateTime.Now.TimeOfDay
+        };
+        defaultTimeEditor.ValueChanged += TimeEditorChanged;
+        win.Add (defaultTimeEditor);
+
+        // 24-hour format time editor
+        TimeEditor time24Editor = new ()
+        {
+            X = Pos.Center (),
+            Y = Pos.Bottom (defaultTimeEditor) + 1,
+            Value = DateTime.Now.TimeOfDay,
+            Format = (DateTimeFormatInfo)System.Globalization.CultureInfo.GetCultureInfo ("en-GB").DateTimeFormat.Clone ()
+        };
+        time24Editor.ValueChanged += TimeEditorChanged;
+        win.Add (time24Editor);
+
+        // Short time format time editor
+        DateTimeFormatInfo shortFormat = (DateTimeFormatInfo)System.Globalization.CultureInfo.CurrentCulture.DateTimeFormat.Clone ();
+        shortFormat.LongTimePattern = shortFormat.ShortTimePattern;
+        TimeEditor shortTimeEditor = new ()
+        {
+            X = Pos.Center (),
+            Y = Pos.Bottom (time24Editor) + 1,
+            Value = DateTime.Now.TimeOfDay,
+            Format = shortFormat
+        };
+        shortTimeEditor.ValueChanged += TimeEditorChanged;
+        win.Add (shortTimeEditor);
 
         DateField shortDate = new (DateTime.Now)
         {
-            X = Pos.Center (), Y = Pos.Bottom (shortTime) + 1, ReadOnly = true
+            X = Pos.Center (), Y = Pos.Bottom (shortTimeEditor) + 1, ReadOnly = true
         };
         shortDate.ValueChanged += DateChanged;
         win.Add (shortDate);
@@ -91,11 +146,22 @@ public override void Main ()
             Text = "Time Format: "
         };
         win.Add (_lblTimeFmt);
+
+        _lblTimeEditorValue = new()
+        {
+            X = Pos.Center (),
+            Y = Pos.Bottom (_lblTimeFmt) + 1,
+            TextAlignment = Alignment.Center,
+
+            Width = Dim.Fill (),
+            Text = "TimeEditor Value: "
+        };
+        win.Add (_lblTimeEditorValue);
 
         _lblOldDate = new()
         {
             X = Pos.Center (),
-            Y = Pos.Bottom (_lblTimeFmt) + 2,
+            Y = Pos.Bottom (_lblTimeEditorValue) + 1,
             TextAlignment = Alignment.Center,
 
             Width = Dim.Fill (),
@@ -155,4 +221,9 @@ private void TimeChanged (object? sender, ValueChangedEventArgs<TimeSpan> e)
     {
         _lblNewTime!.Text = $"New Time: {e.NewValue}";
     }
+
+    private void TimeEditorChanged (object? sender, ValueChangedEventArgs<TimeSpan> e)
+    {
+        _lblTimeEditorValue!.Text = $"TimeEditor Value: {e.NewValue}";
+    }
 }

Terminal.Gui/Views/TextInput/TimeEditor.cs

@@ -0,0 +1,182 @@
+using System.Globalization;
+using Terminal.Gui.ViewBase;
+
+namespace Terminal.Gui.Views;
+
+/// <summary>
+///     Provides time editing functionality using <see cref="TextValidateField"/> with culture-aware formatting.
+/// </summary>
+/// <remarks>
+///     <para>
+///         TimeEditor extends <see cref="TextValidateField"/> with time-specific functionality:
+///         <list type="bullet">
+///             <item><description>Uses <see cref="TimeTextProvider"/> for validation and formatting</description></item>
+///             <item><description>Supports both 12-hour and 24-hour formats via <see cref="DateTimeFormatInfo"/></description></item>
+///             <item><description>Cursor automatically skips over separator characters</description></item>
+///             <item><description>Supports AM/PM toggling for 12-hour formats</description></item>
+///             <item><description>Auto-adjusts width based on time pattern</description></item>
+///         </list>
+///     </para>
+///     <para>
+///         <b>Usage Examples:</b>
+///         <code>
+///         // Use default (current culture's long time pattern)
+///         TimeEditor timeEditor = new () { Value = TimeSpan.FromHours (14.5) };
+///         // en-US displays: " 2:30:00 PM"
+///         // en-GB displays: " 14:30:00"
+///         
+///         // Use specific culture's format
+///         timeEditor.Format = CultureInfo.GetCultureInfo ("de-DE").DateTimeFormat;
+///         // Displays: " 14:30:00"
+///         
+///         // Want short time? Modify the LongTimePattern
+///         DateTimeFormatInfo format = (DateTimeFormatInfo)CultureInfo.CurrentCulture.DateTimeFormat.Clone ();
+///         format.LongTimePattern = format.ShortTimePattern;
+///         timeEditor.Format = format;
+///         // en-US displays: " 2:30 PM"
+///         
+///         // Custom pattern with milliseconds
+///         DateTimeFormatInfo customFormat = (DateTimeFormatInfo)CultureInfo.CurrentCulture.DateTimeFormat.Clone ();
+///         customFormat.LongTimePattern = "HH:mm:ss.fff";
+///         timeEditor.Format = customFormat;
+///         // Displays: " 14:30:00.000"
+///         </code>
+///     </para>
+/// </remarks>
+public class TimeEditor : TextValidateField, IValue<TimeSpan>
+{
+    private TimeTextProvider TimeProvider => (TimeTextProvider)Provider!;
+    private TimeSpan _lastKnownValue = TimeSpan.Zero;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="TimeEditor"/> class.
+    /// </summary>
+    public TimeEditor ()
+    {
+        Provider = new TimeTextProvider ();
+        Width = Dim.Auto (minimumContentDim: 10);
+
+        // Subscribe to provider's text changed to raise our value events
+        TimeProvider.TextChanged += (_, _) => RaiseValueChangedEvents ();
+
+        // Initialize last known value
+        _lastKnownValue = TimeProvider.TimeValue;
+    }
+
+    /// <summary>
+    ///     Gets or sets the <see cref="DateTimeFormatInfo"/> used for time formatting.
+    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///         The editor uses <see cref="DateTimeFormatInfo.LongTimePattern"/> to determine the display format.
+    ///         To use a short time format, clone the DateTimeFormatInfo and set LongTimePattern to ShortTimePattern.
+    ///     </para>
+    ///     <para>
+    ///         The width automatically adjusts when the format changes to accommodate the new pattern.
+    ///     </para>
+    /// </remarks>
+    public DateTimeFormatInfo Format
+    {
+        get => TimeProvider.Format;
+        set
+        {
+            TimeProvider.Format = value;
+            Width = TimeProvider.DisplayText.Length + 2;
+            SetNeedsDraw ();
+        }
+    }
+
+    /// <summary>
+    ///     Gets or sets the current time value.
+    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///         Setting this property raises <see cref="ValueChanging"/> (cancellable) and <see cref="ValueChanged"/> events.
+    ///         The change can be prevented by handling <see cref="ValueChanging"/> and setting
+    ///         <see cref="ValueChangingEventArgs{T}.Handled"/> to <see langword="true"/>.
+    ///     </para>
+    /// </remarks>
+    public TimeSpan Value
+    {
+        get => TimeProvider.TimeValue;
+        set
+        {
+            TimeSpan oldValue = TimeProvider.TimeValue;
+
+            if (oldValue == value)
+            {
+                return;
+            }
+
+            ValueChangingEventArgs<TimeSpan> changingArgs = new (oldValue, value);
+
+            if (OnValueChanging (changingArgs) || changingArgs.Handled)
+            {
+                return;
+            }
+
+            ValueChanging?.Invoke (this, changingArgs);
+
+            if (changingArgs.Handled)
+            {
+                return;
+            }
+
+            TimeProvider.TimeValue = value;
+            Text = TimeProvider.Text;
+
+            ValueChangedEventArgs<TimeSpan> changedArgs = new (oldValue, value);
+            OnValueChanged (changedArgs);
+            ValueChanged?.Invoke (this, changedArgs);
+
+            SetNeedsDraw ();
+        }
+    }
+
+    /// <inheritdoc/>
+    public event EventHandler<ValueChangingEventArgs<TimeSpan>>? ValueChanging;
+
+    /// <inheritdoc/>
+    public event EventHandler<ValueChangedEventArgs<TimeSpan>>? ValueChanged;
+
+    /// <inheritdoc/>
+    object? IValue.GetValue () => Value;
+
+    /// <summary>
+    ///     Called when the <see cref="Value"/> is changing.
+    ///     Allows derived classes to cancel the change.
+    /// </summary>
+    /// <param name="args">The event arguments.</param>
+    /// <returns><see langword="true"/> to cancel the change; otherwise <see langword="false"/>.</returns>
+    protected virtual bool OnValueChanging (ValueChangingEventArgs<TimeSpan> args)
+    {
+        return false;
+    }
+
+    /// <summary>
+    ///     Called when the <see cref="Value"/> has changed.
+    ///     Allows derived classes to react to value changes.
+    /// </summary>
+    /// <param name="args">The event arguments.</param>
+    protected virtual void OnValueChanged (ValueChangedEventArgs<TimeSpan> args)
+    {
+    }
+
+    /// <summary>
+    ///     Raises value events when the text changes through user input.
+    /// </summary>
+    private void RaiseValueChangedEvents ()
+    {
+        TimeSpan currentValue = TimeProvider.TimeValue;
+
+        if (_lastKnownValue == currentValue)
+        {
+            return;
+        }
+
+        ValueChangedEventArgs<TimeSpan> changedArgs = new (_lastKnownValue, currentValue);
+        _lastKnownValue = currentValue;
+        OnValueChanged (changedArgs);
+        ValueChanged?.Invoke (this, changedArgs);
+    }
+}