fix: a date that is not set drew as 1/1/1926

Reported against a GeoPackage with an empty DATE column, which is what a
freshly created file looks like.

Bound through a classic {Binding}, a null reaching CalendarDatePicker.Date
arrives as default(DateTimeOffset) - the first of January in year one - and
the picker clamps that to the earliest date it will show, a hundred years ago.
The row was right throughout and nothing was written to the model; the value
was lost between the row and the control.

So the three date editors stop binding their pickers. One control now pushes
the values in and pulls them out, where "no date" can stay no date and the
picker shows its placeholder. The same guard the other editors already had
covers DateValue and TimeValue too: a picker being realized pushes its own
empty state, and a plain DateTime has nowhere to put it.

Making that control taught me a rule worth having in writing. The editor
templates live in a dictionary merged into Application.Resources; the control
styles live in the control dictionary, which is not. A {ThemeResource} across
that line resolves to nothing and takes the process down with an unhandled
XAML exception - it cost a crash with no message beyond a fault in
Microsoft.UI.Xaml.dll. The mode is a plain enum on the control instead, so
nothing has to look anything up.

Author: joseangelmt

CHANGELOG.md

@@ -85,6 +85,11 @@ API can still change. Builds before the tag are published as `0.1.0-dev.N`.
   switching objects cleared the value on the one being left behind. A null now reaches the model
   only when nothing is a choice the list actually offered, and the control is told to read again so
   it does not sit there showing an empty state.
+- A date that was not set drew as a real one. Bound through a classic `{Binding}`, a null reaching
+  `CalendarDatePicker.Date` arrives as `default(DateTimeOffset)` and is clamped to the earliest date
+  the picker shows — a hundred years ago — so an empty column read as `1/1/1926`. The three date
+  editors are now one control that pushes and pulls the values itself, and an empty date shows the
+  placeholder.
 - A `bool` holding true was drawn as an indeterminate check box. Same cause seen from the other
   side: the box pushed null on creation, the write was refused because a `bool` cannot be cleared,
   and nothing then told the box to go and read the real value. The same guard now covers a number

samples/PropertyGridGallery/SampleModel.cs

@@ -26,6 +26,7 @@ public class SampleModel : ObservableObject
     private DateTime moment = new(2026, 8, 13, 9, 30, 0, DateTimeKind.Local);
     private DateOnly day = new(2026, 3, 1);
     private TimeOnly clock = new(9, 30);
+    private DateTime? missing;
     private TimeSpan every = TimeSpan.FromMinutes(90);
     private Windows.UI.Color fill = Microsoft.UI.Colors.CornflowerBlue;
     private Uri? address = new("https://example.com/parcels.gpkg");
@@ -174,6 +175,15 @@ public TimeOnly Clock
 
     [Category("Standard items")]
     [PropertyOrder(14)]
+    [Description("A nullable date that is empty, which is what a column nobody has filled in looks like.")]
+    public DateTime? Missing
+    {
+        get => missing;
+        set => SetProperty(ref missing, value);
+    }
+
+    [Category("Standard items")]
+    [PropertyOrder(15)]
     [Description("A duration, in a text box: a clock cannot express more than a day or less than zero.")]
     public TimeSpan Every
     {

src/Digi21.WinUI.PropertyGrid/Model/PropertyGridPropertyRow.cs

@@ -200,7 +200,16 @@ public DateTimeOffset? DateValue
             DateOnly date => new DateTimeOffset(date.ToDateTime(TimeOnly.MinValue, DateTimeKind.Local)),
             _ => null,
         };
-        set => TryWrite(value is null ? null : FromDate(value.Value));
+        set
+        {
+            if (value is null && !AcceptsNull)
+            {
+                RejectEditorDefault();
+                return;
+            }
+
+            TryWrite(value is null ? null : FromDate(value.Value));
+        }
     }
 
     /// <summary>Gets or sets the time of day part of the value, for the clock editors.</summary>
@@ -214,7 +223,16 @@ public TimeSpan? TimeValue
             DateTime moment => moment.TimeOfDay,
             _ => null,
         };
-        set => TryWrite(value is null ? null : FromTime(value.Value));
+        set
+        {
+            if (value is null && !AcceptsNull)
+            {
+                RejectEditorDefault();
+                return;
+            }
+
+            TryWrite(value is null ? null : FromTime(value.Value));
+        }
     }
 
     /// <summary>Gets the members to choose from when the property is an enumeration, or an empty list.</summary>

src/Digi21.WinUI.PropertyGrid/Primitives/PropertyGridDateEditor.cs

@@ -0,0 +1,201 @@
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+
+namespace Digi21.WinUI.PropertyGrid.Primitives;
+
+/// <summary>Which halves of a moment a <see cref="PropertyGridDateEditor"/> lets the user set.</summary>
+public enum PropertyGridDateEditorMode
+{
+    /// <summary>A calendar and a clock.</summary>
+    DateAndTime,
+
+    /// <summary>A calendar only.</summary>
+    Date,
+
+    /// <summary>A clock only.</summary>
+    Time,
+}
+
+/// <summary>A calendar, a clock, or both, for the date and time properties.</summary>
+/// <remarks>
+/// <para>
+/// A control rather than a plain template because of what a binding does to nothing. Bound with a
+/// classic <c>{Binding}</c>, a null reaching <c>CalendarDatePicker.Date</c> arrives as
+/// <c>default(DateTimeOffset)</c> — the first of January in year one — which the picker then clamps
+/// to the earliest date it will show, a hundred years ago. An empty date came out as
+/// <c>1/1/1926</c>, which is a date somebody could believe.
+/// </para>
+/// <para>
+/// So nothing is bound: the values are pushed in and pulled out here, where "no date" can stay no
+/// date and the picker shows its placeholder instead.
+/// </para>
+/// </remarks>
+public partial class PropertyGridDateEditor : Control
+{
+    /// <summary>Identifies the <see cref="Row"/> dependency property.</summary>
+    public static readonly DependencyProperty RowProperty = DependencyProperty.Register(
+        nameof(Row),
+        typeof(PropertyGridPropertyRow),
+        typeof(PropertyGridDateEditor),
+        new PropertyMetadata(null, (d, _) => ((PropertyGridDateEditor)d).OnRowChanged()));
+
+    /// <summary>Identifies the <see cref="Mode"/> dependency property.</summary>
+    public static readonly DependencyProperty ModeProperty = DependencyProperty.Register(
+        nameof(Mode),
+        typeof(PropertyGridDateEditorMode),
+        typeof(PropertyGridDateEditor),
+        new PropertyMetadata(PropertyGridDateEditorMode.DateAndTime, (d, _) => ((PropertyGridDateEditor)d).Show()));
+
+    private CalendarDatePicker? calendar;
+    private TimePicker? clock;
+    private PropertyGridPropertyRow? subscribed;
+    private bool showing;
+
+    /// <summary>Initializes a new instance of the <see cref="PropertyGridDateEditor"/> class.</summary>
+    public PropertyGridDateEditor()
+    {
+        DefaultStyleKey = typeof(PropertyGridDateEditor);
+        DefaultStyleResourceUri = new Uri("ms-appx:///Digi21.WinUI.PropertyGrid/Themes/Generic.xaml");
+        PropertyGridThemeResources.Ensure();
+
+        DataContextChanged += (_, arguments) =>
+        {
+            if (arguments.NewValue is PropertyGridPropertyRow row)
+            {
+                Row = row;
+            }
+        };
+    }
+
+    /// <summary>Gets or sets the property being edited.</summary>
+    public PropertyGridPropertyRow? Row
+    {
+        get => (PropertyGridPropertyRow?)GetValue(RowProperty);
+        set => SetValue(RowProperty, value);
+    }
+
+    /// <summary>Gets or sets which halves of a moment the user can set.</summary>
+    /// <remarks>
+    /// One template holds both pickers and the mode hides whichever is not wanted, rather than there
+    /// being three styles to choose between. The editor templates live in a dictionary merged into
+    /// the application's resources and the styles would live in the control dictionary, which is not
+    /// — a <c>{ThemeResource}</c> across that line resolves to nothing and takes the process with it.
+    /// </remarks>
+    public PropertyGridDateEditorMode Mode
+    {
+        get => (PropertyGridDateEditorMode)GetValue(ModeProperty);
+        set => SetValue(ModeProperty, value);
+    }
+
+    /// <inheritdoc />
+    protected override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        Detach();
+
+        // Whichever parts the template has: one editor serves the calendar, the clock and both.
+        calendar = GetTemplateChild("PART_Calendar") as CalendarDatePicker;
+        clock = GetTemplateChild("PART_Clock") as TimePicker;
+
+        if (calendar is not null)
+        {
+            calendar.DateChanged += OnCalendarChanged;
+        }
+
+        if (clock is not null)
+        {
+            clock.SelectedTimeChanged += OnClockChanged;
+        }
+
+        Show();
+    }
+
+    private void OnRowChanged()
+    {
+        if (subscribed is not null)
+        {
+            subscribed.PropertyChanged -= OnRowPropertyChanged;
+        }
+
+        subscribed = Row;
+
+        if (subscribed is not null)
+        {
+            subscribed.PropertyChanged += OnRowPropertyChanged;
+        }
+
+        Show();
+    }
+
+    private void OnRowPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName is nameof(PropertyGridPropertyRow.DateValue)
+            or nameof(PropertyGridPropertyRow.TimeValue)
+            or nameof(PropertyGridPropertyRow.Value))
+        {
+            Show();
+        }
+    }
+
+    // Row to controls. The flag is up throughout, because setting either picker raises the same
+    // event the user does and the answer would go straight back to the row.
+    private void Show()
+    {
+        if (showing)
+        {
+            return;
+        }
+
+        showing = true;
+        try
+        {
+            if (calendar is not null)
+            {
+                calendar.Visibility = Mode == PropertyGridDateEditorMode.Time ? Visibility.Collapsed : Visibility.Visible;
+                calendar.Date = Row?.DateValue;
+                calendar.IsEnabled = Row?.IsEditable ?? false;
+            }
+
+            if (clock is not null)
+            {
+                clock.Visibility = Mode == PropertyGridDateEditorMode.Date ? Visibility.Collapsed : Visibility.Visible;
+                clock.SelectedTime = Row?.TimeValue;
+                clock.IsEnabled = Row?.IsEditable ?? false;
+            }
+        }
+        finally
+        {
+            showing = false;
+        }
+    }
+
+    private void OnCalendarChanged(CalendarDatePicker sender, CalendarDatePickerDateChangedEventArgs arguments)
+    {
+        if (!showing && Row is { } row)
+        {
+            row.DateValue = arguments.NewDate;
+        }
+    }
+
+    private void OnClockChanged(object? sender, TimePickerSelectedValueChangedEventArgs arguments)
+    {
+        if (!showing && Row is { } row)
+        {
+            row.TimeValue = arguments.NewTime;
+        }
+    }
+
+    private void Detach()
+    {
+        if (calendar is not null)
+        {
+            calendar.DateChanged -= OnCalendarChanged;
+        }
+
+        if (clock is not null)
+        {
+            clock.SelectedTimeChanged -= OnClockChanged;
+        }
+    }
+}

src/Digi21.WinUI.PropertyGrid/Themes/Generic.xaml

@@ -452,6 +452,32 @@
         </Setter>
     </Style>
 
+    <Style BasedOn="{StaticResource DefaultPropertyGridDateEditorStyle}" TargetType="primitives:PropertyGridDateEditor" />
+
+    <Style x:Key="DefaultPropertyGridDateEditorStyle" TargetType="primitives:PropertyGridDateEditor">
+        <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+        <Setter Property="IsTabStop" Value="False" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="primitives:PropertyGridDateEditor">
+                    <StackPanel Orientation="Horizontal" Spacing="4">
+                        <CalendarDatePicker
+                            x:Name="PART_Calendar"
+                            MinHeight="0"
+                            VerticalAlignment="Center"
+                            BorderThickness="0"
+                            PlaceholderText="{ThemeResource PropertyGridSelectDatePlaceholderText}" />
+                        <TimePicker
+                            x:Name="PART_Clock"
+                            MinHeight="0"
+                            VerticalAlignment="Center"
+                            BorderThickness="0" />
+                    </StackPanel>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
     <Style x:Key="DefaultPropertyGridPathEditorStyle" TargetType="primitives:PropertyGridPathEditor">
         <Setter Property="HorizontalContentAlignment" Value="Stretch" />
         <Setter Property="IsTabStop" Value="False" />

src/Digi21.WinUI.PropertyGrid/Themes/PropertyGridEditors.xaml

@@ -164,41 +164,21 @@
             SelectedItem="{Binding SelectedStandardValue, Mode=TwoWay}" />
     </DataTemplate>
 
+    <!--
+        None of the three binds its picker. A null reaching CalendarDatePicker.Date through a classic
+        binding arrives as default(DateTimeOffset) and is clamped to a hundred years ago, so an empty
+        date drew as a real one. PropertyGridDateEditor pushes and pulls the values itself.
+    -->
     <DataTemplate x:Key="PropertyGridDateTimeEditorTemplate">
-        <StackPanel Orientation="Horizontal" Spacing="4">
-            <CalendarDatePicker
-                MinHeight="0"
-                VerticalAlignment="Center"
-                BorderThickness="0"
-                Date="{Binding DateValue, Mode=TwoWay}"
-                IsEnabled="{Binding IsEditable}" />
-            <TimePicker
-                MinHeight="0"
-                VerticalAlignment="Center"
-                BorderThickness="0"
-                IsEnabled="{Binding IsEditable}"
-                SelectedTime="{Binding TimeValue, Mode=TwoWay}" />
-        </StackPanel>
+        <primitives:PropertyGridDateEditor Mode="DateAndTime" />
     </DataTemplate>
 
     <DataTemplate x:Key="PropertyGridDateEditorTemplate">
-        <CalendarDatePicker
-            MinHeight="0"
-            HorizontalAlignment="Stretch"
-            VerticalAlignment="Center"
-            BorderThickness="0"
-            Date="{Binding DateValue, Mode=TwoWay}"
-            IsEnabled="{Binding IsEditable}" />
+        <primitives:PropertyGridDateEditor Mode="Date" />
     </DataTemplate>
 
     <DataTemplate x:Key="PropertyGridTimeEditorTemplate">
-        <TimePicker
-            MinHeight="0"
-            HorizontalAlignment="Stretch"
-            VerticalAlignment="Center"
-            BorderThickness="0"
-            IsEnabled="{Binding IsEditable}"
-            SelectedTime="{Binding TimeValue, Mode=TwoWay}" />
+        <primitives:PropertyGridDateEditor Mode="Time" />
     </DataTemplate>
 
     <!--

src/Digi21.WinUI.PropertyGrid/Themes/PropertyGridResources.xaml

@@ -135,6 +135,7 @@
         validation message has no control to ask.
     -->
     <x:String x:Key="PropertyGridSearchPlaceholderText">Search properties</x:String>
+    <x:String x:Key="PropertyGridSelectDatePlaceholderText">Pick a date</x:String>
     <x:String x:Key="PropertyGridBrowseToolTipText">Browse…</x:String>
     <x:String x:Key="PropertyGridEditToolTipText">Edit…</x:String>
     <x:String x:Key="PropertyGridOkButtonText">OK</x:String>