CompositeDatePicker.cs

using System;
using System.ComponentModel;
using System.Globalization;
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
using NeuroAccessMaui.UI.Controls.Extended;
using NeuroAccessMaui.UI.Converters;
using Waher.Events;
using NeuroAccessMaui.Extensions;
 
namespace NeuroAccessMaui.UI.Controls
{
    public class CompositeDatePicker : CompositeInputView
    {
        private static readonly DateTime SafeMinDate = new DateTime(1900, 1, 1);
        private static readonly DateTime SafeMaxDate = new DateTime(2100, 12, 31);
 
        public static readonly BindableProperty FontProperty = BindableProperty.Create(
            propertyName: nameof(Font),
            returnType: typeof(Microsoft.Maui.Font),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: new Microsoft.Maui.Font());
 
        public Microsoft.Maui.Font Font
        {
            get => (Microsoft.Maui.Font)this.GetValue(FontProperty);
            set => this.SetValue(FontProperty, value);
        }
 
        public static readonly BindableProperty XAlignProperty = BindableProperty.Create(
            propertyName: nameof(XAlign),
            returnType: typeof(TextAlignment),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: TextAlignment.Start);
 
        public TextAlignment XAlign
        {
            get => (TextAlignment)this.GetValue(XAlignProperty);
            set => this.SetValue(XAlignProperty, value);
        }
 
        public static readonly BindableProperty HasBorderProperty = BindableProperty.Create(
            propertyName: nameof(HasBorder),
            returnType: typeof(bool),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: true);
 
        public bool HasBorder
        {
            get => (bool)this.GetValue(HasBorderProperty);
            set => this.SetValue(HasBorderProperty, value);
        }
 
        public static readonly BindableProperty PlaceholderProperty = BindableProperty.Create(
            propertyName: nameof(Placeholder),
            returnType: typeof(string),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: string.Empty,
            defaultBindingMode: BindingMode.OneWay);
 
        public string Placeholder
        {
            get => (string)this.GetValue(PlaceholderProperty);
            set => this.SetValue(PlaceholderProperty, value);
        }
 
        public static readonly BindableProperty PlaceholderTextColorProperty = BindableProperty.Create(
            propertyName: nameof(PlaceholderTextColor),
            returnType: typeof(Color),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: Colors.Transparent);
 
        public Color PlaceholderTextColor
        {
            get => (Color)this.GetValue(PlaceholderTextColorProperty);
            set => this.SetValue(PlaceholderTextColorProperty, value);
        }
 
        public static readonly BindableProperty TextColorProperty = BindableProperty.Create(
            propertyName: nameof(TextColor),
            returnType: typeof(Color),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: Colors.Black);
 
        public Color TextColor
        {
            get => (Color)this.GetValue(TextColorProperty);
            set => this.SetValue(TextColorProperty, value);
        }
 
        public static readonly BindableProperty PickerStyleProperty = BindableProperty.Create(
            propertyName: nameof(PickerStyle),
            returnType: typeof(Style),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: null);
 
        public Style PickerStyle
        {
            get => (Style)this.GetValue(PickerStyleProperty);
            set => this.SetValue(PickerStyleProperty, value);
        }
 
        public static readonly BindableProperty NullableDateProperty = BindableProperty.Create(
            propertyName: nameof(NullableDate),
            returnType: typeof(DateTime?),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: null,
            defaultBindingMode: BindingMode.TwoWay);
 
        public DateTime? NullableDate
        {
            get => (DateTime?)this.GetValue(NullableDateProperty);
            set => this.SetValue(NullableDateProperty, value);
        }
 
        public static readonly BindableProperty MinimumDateProperty = BindableProperty.Create(
            propertyName: nameof(MinimumDate),
            returnType: typeof(DateTime),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: SafeMinDate);
 
        public DateTime MinimumDate
        {
            get => (DateTime)this.GetValue(MinimumDateProperty);
            set => this.SetValue(MinimumDateProperty, value.SanitizeForDatePicker(SafeMinDate, SafeMaxDate));
        }
 
        public static readonly BindableProperty MaximumDateProperty = BindableProperty.Create(
            propertyName: nameof(MaximumDate),
            returnType: typeof(DateTime),
            declaringType: typeof(CompositeDatePicker),
            defaultValue: SafeMaxDate);
 
        public DateTime MaximumDate
        {
            get => (DateTime)this.GetValue(MaximumDateProperty);
            set => this.SetValue(MaximumDateProperty, value.SanitizeForDatePicker(SafeMinDate, SafeMaxDate));
        }
 
        public event EventHandler<NullableDateChangedEventArgs>? NullableDateSelected;
 
        private readonly WrappedDatePicker picker;
 
        public CompositeDatePicker()
        {
            this.picker = new WrappedDatePicker();
            this.SetDefaultDate();
 
            // Ensure bounds are applied on internal picker immediately.
            this.picker.MinimumDate = SafeMinDate;
            this.picker.MaximumDate = SafeMaxDate;
 
            // Bind internal properties to this control
            this.picker.SetBinding(DatePicker.DateProperty,
                new Binding(nameof(this.NullableDate), source: this, mode: BindingMode.TwoWay));
            this.picker.SetBinding(DatePicker.MinimumDateProperty,
                new Binding(nameof(this.MinimumDate), source: this));
            this.picker.SetBinding(DatePicker.MaximumDateProperty,
                new Binding(nameof(this.MaximumDate), source: this));
            this.picker.SetBinding(DatePicker.TextColorProperty,
                new Binding(nameof(this.TextColor), source: this));
            this.picker.SetBinding(DatePicker.StyleProperty,
                new Binding(nameof(this.PickerStyle), source: this));
 
            // Apply initial format (placeholder or date)
            this.UpdateFormat();
 
            // Handle user changes and property updates
            this.picker.DateSelected += this.OnPickerDateSelected;
            if (this.picker is VisualElement E)
                E.Focused += this.OnPickerUnfocused;
            this.PropertyChanged += this.OnControlPropertyChanged;
 
            this.CenterView = this.picker;
        }
 
        private void OnControlPropertyChanged(object? Sender, PropertyChangedEventArgs E)
        {
            if (E.PropertyName == nameof(this.Placeholder) || E.PropertyName == nameof(this.NullableDate))
                this.UpdateFormat();
 
            if (E.PropertyName == nameof(this.NullableDate) && this.NullableDate.HasValue)
            {
                DateTime Clamped = this.NullableDate.Value.SanitizeForDatePicker(this.MinimumDate, this.MaximumDate);
                if (Clamped != this.NullableDate.Value)
                    this.NullableDate = Clamped;
            }
        }
 
        private void OnPickerDateSelected(object? Sender, DateChangedEventArgs E)
        {
            DateTime? OldDate = this.NullableDate;
            DateTime? NewDate = E.NewDate;
 
            if (NewDate.HasValue)
            {
                DateTime Clamped = NewDate.Value.SanitizeForDatePicker(this.MinimumDate, this.MaximumDate);
                this.NullableDate = Clamped;
            }
            else
            {
                this.NullableDate = null;
            }
 
            NullableDateSelected?.Invoke(this, new NullableDateChangedEventArgs(OldDate, this.NullableDate));
        }
 
        private void OnPickerUnfocused(object? sender, FocusEventArgs e)
        {
            if (!this.NullableDate.HasValue)
            {
                DateTime? PickerDate = this.picker.Date;
 
                if (PickerDate.HasValue)
                {
                    DateTime Picked = PickerDate.Value.SanitizeForDatePicker(this.MinimumDate, this.MaximumDate);
                    this.NullableDate = Picked;
                    NullableDateSelected?.Invoke(this, new NullableDateChangedEventArgs(null, Picked));
                }
            }
        }
 
        private void UpdateFormat()
        {
            if (this.NullableDate.HasValue)
            {
                // Use the current culture's short date pattern once a date is chosen.
                this.picker.Format = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern;
            }
            else
            {
                // Escape any single-quotes in the placeholder,
                // then wrap the whole thing in single-quotes.
                string escaped = this.Placeholder.Replace("'", "''");
                this.picker.Format = $"'{escaped}'";
            }
        }
 
        private void SetDefaultDate()
        {
            DateTime Today = DateTime.Today.SanitizeForDatePicker(SafeMinDate, SafeMaxDate);
            this.picker.Date = Today;
        }
    }
}