CompositeEntry.cs

using System.Windows.Input;
using Microsoft.Maui.Controls.Shapes;
using NeuroAccessMaui.Services;
using PathShape = Microsoft.Maui.Controls.Shapes.Path;
 
namespace NeuroAccessMaui.UI.Controls
{
    public class CompositeEntry : ContentView
    {
        private readonly Border innerBorder;
        private readonly Grid innerGrid;
        private readonly PathShape innerPath;
        private readonly PathShape clickablePath;
        private readonly Entry innerEntry;
 
        public static readonly BindableProperty FocusedCommandProperty = BindableProperty.Create(
             nameof(FocusedCommand),
             typeof(ICommand),
             typeof(CompositeEntry));
 
        public ICommand FocusedCommand
        {
            get => (ICommand)this.GetValue(FocusedCommandProperty);
            set => this.SetValue(FocusedCommandProperty, value);
        }
 
        public static readonly BindableProperty UnfocusedCommandProperty = BindableProperty.Create(
             nameof(UnfocusedCommand),
             typeof(ICommand),
             typeof(CompositeEntry));
 
        public ICommand UnfocusedCommand
        {
            get => (ICommand)this.GetValue(UnfocusedCommandProperty);
            set => this.SetValue(UnfocusedCommandProperty, value);
        }
 
        public static readonly BindableProperty PathClickedCommandProperty = BindableProperty.Create(
             nameof(PathClickedCommand),
             typeof(ICommand),
             typeof(CompositeEntry));
 
        public ICommand PathClickedCommand
        {
            get => (ICommand)this.GetValue(PathClickedCommandProperty);
            set => this.SetValue(PathClickedCommandProperty, value);
        }
 
        public static readonly BindableProperty ClickablePathDataProperty = BindableProperty.Create(
             nameof(ClickablePathData),
             typeof(Geometry),
             typeof(CompositeEntry),
             defaultValue: null,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnClickablePathDataPropertyChanged((Geometry)oldValue, (Geometry)newValue);
             });
 
        public Geometry ClickablePathData
        {
            get => (Geometry)this.GetValue(ClickablePathDataProperty);
            set => this.SetValue(ClickablePathDataProperty, value);
        }
 
        public static readonly BindableProperty KeyboardProperty = BindableProperty.Create(
             nameof(Keyboard),
             typeof(Keyboard),
             typeof(CompositeEntry),
             defaultValue: Keyboard.Default,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnKeyboardPropertyChanged((Keyboard)oldValue, (Keyboard)newValue);
             });
 
        public Keyboard Keyboard
        {
            get => (Keyboard)this.GetValue(KeyboardProperty);
            set => this.SetValue(KeyboardProperty, value);
        }
 
        public static readonly BindableProperty BorderStyleProperty = BindableProperty.Create(
             nameof(BorderStyle),
             typeof(Style),
             typeof(CompositeEntry),
             defaultValue: null,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnBorderStylePropertyChanged((Style)oldValue, (Style)newValue);
             });
 
        public Style BorderStyle
        {
            get => (Style)this.GetValue(BorderStyleProperty);
            set => this.SetValue(BorderStyleProperty, value);
        }
 
        public static readonly BindableProperty StackSpacingProperty = BindableProperty.Create(
             nameof(StackSpacing),
             typeof(double),
             typeof(CompositeEntry),
             defaultValue: 0.0,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnStackSpacingPropertyChanged((double)oldValue, (double)newValue);
             });
 
        public double StackSpacing
        {
            get => (double)this.GetValue(StackSpacingProperty);
            set => this.SetValue(StackSpacingProperty, value);
        }
 
        public static readonly BindableProperty PathDataProperty = BindableProperty.Create(
             nameof(PathData),
             typeof(Geometry),
             typeof(CompositeEntry),
             defaultValue: null,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnPathDataPropertyChanged((Geometry)oldValue, (Geometry)newValue);
             });
 
        public Geometry PathData
        {
            get => (Geometry)this.GetValue(PathDataProperty);
            set => this.SetValue(PathDataProperty, value);
        }
 
        public static readonly BindableProperty PathStyleProperty = BindableProperty.Create(
             nameof(PathStyle),
             typeof(Style),
             typeof(CompositeEntry),
             defaultValue: null,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnPathStylePropertyChanged((Style)oldValue, (Style)newValue);
             });
 
        public Style PathStyle
        {
            get => (Style)this.GetValue(PathStyleProperty);
            set => this.SetValue(PathStyleProperty, value);
        }
 
        public static readonly BindableProperty EntryDataProperty = BindableProperty.Create(
             nameof(EntryData),
             typeof(string),
             typeof(CompositeEntry),
             defaultValue: string.Empty,
             defaultBindingMode: BindingMode.TwoWay);
 
        public string EntryData
        {
            get => (string)this.GetValue(EntryDataProperty);
            set => this.SetValue(EntryDataProperty, value);
        }
 
        public static readonly BindableProperty EntryHintProperty = BindableProperty.Create(
             nameof(EntryHint),
             typeof(string),
             typeof(CompositeEntry),
             defaultValue: string.Empty,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnEntryHintPropertyChanged((string)oldValue, (string)newValue);
             });
 
        public string EntryHint
        {
            get => (string)this.GetValue(EntryHintProperty);
            set => this.SetValue(EntryHintProperty, value);
        }
 
        public static readonly BindableProperty EntryStyleProperty = BindableProperty.Create(
             nameof(EntryStyle),
             typeof(Style),
             typeof(CompositeEntry),
             defaultValue: null,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnEntryStylePropertyChanged((Style)oldValue, (Style)newValue);
             });
 
        public Style EntryStyle
        {
            get => (Style)this.GetValue(EntryStyleProperty);
            set => this.SetValue(EntryStyleProperty, value);
        }
 
        public static readonly BindableProperty ReturnCommandProperty = BindableProperty.Create(
             nameof(ReturnCommand),
             typeof(ICommand),
             typeof(CompositeEntry),
             defaultValue: null,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnReturnCommandPropertyChanged((ICommand)oldValue, (ICommand)newValue);
             });
 
        public ICommand ReturnCommand
        {
            get => (ICommand)this.GetValue(ReturnCommandProperty);
            set => this.SetValue(ReturnCommandProperty, value);
        }
 
        public static readonly BindableProperty IsPasswordProperty = BindableProperty.Create(
             nameof(IsPassword),
             typeof(bool),
             typeof(CompositeEntry),
             defaultValue: false,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnIsPasswordPropertyChanged((bool)oldValue, (bool)newValue);
             });
 
        public bool IsPassword
        {
            get => (bool)this.GetValue(IsPasswordProperty);
            set => this.SetValue(IsPasswordProperty, value);
        }
 
        public static readonly BindableProperty IsReadOnlyProperty = BindableProperty.Create(
             nameof(IsReadOnly),
             typeof(bool),
             typeof(CompositeEntry),
             defaultValue: false,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnIsReadOnlyPropertyChanged((bool)oldValue, (bool)newValue);
             });
 
        public bool IsReadOnly
        {
            get => (bool)this.GetValue(IsReadOnlyProperty);
            set => this.SetValue(IsReadOnlyProperty, value);
        }
 
        public static readonly BindableProperty PlaceholderProperty = BindableProperty.Create(
             nameof(Placeholder),
             typeof(string),
             typeof(CompositeEntry),
             defaultValue: string.Empty,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnPlaceholderPropertyChanged((string)oldValue, (string)newValue);
             });
 
        public string Placeholder
        {
            get => (string)this.GetValue(PlaceholderProperty);
            set => this.SetValue(PlaceholderProperty, value);
        }
 
        public static readonly BindableProperty TextColorProperty = BindableProperty.Create(
             nameof(TextColor),
             typeof(Color),
             typeof(CompositeEntry),
             defaultValue: Colors.Black,
             propertyChanged: (bindable, oldValue, newValue) =>
             {
                 ((CompositeEntry)bindable).OnTextColorPropertyChanged((Color)oldValue, (Color)newValue);
             });
 
        public Color TextColor
        {
            get => (Color)this.GetValue(TextColorProperty);
            set => this.SetValue(TextColorProperty, value);
        }
 
        public event EventHandler Completed;
 
        public Entry Entry => this.innerEntry;
 
        public Border Border => this.innerBorder;
 
        public CompositeEntry()
        {
            this.innerPath = new PathShape
            {
                VerticalOptions = LayoutOptions.Center,
                IsVisible = this.PathData != null,
                HeightRequest = 24,
                WidthRequest = 24,
                Aspect = Stretch.Uniform
            };
 
            this.clickablePath = new PathShape
            {
                VerticalOptions = LayoutOptions.Center,
                IsVisible = this.ClickablePathData != null,
                HeightRequest = 24,
                WidthRequest = 24,
                Aspect = Stretch.Uniform
            };
 
            TapGestureRecognizer tapGestureRecognizer = new TapGestureRecognizer();
            tapGestureRecognizer.Tapped += (s, e) =>
            {
                if (this.PathClickedCommand?.CanExecute(null) ?? false)
                    this.PathClickedCommand.Execute(null);
            };
            this.clickablePath.GestureRecognizers.Add(tapGestureRecognizer);
 
            this.innerEntry = new Entry
            {
                VerticalOptions = LayoutOptions.Center,
                HorizontalOptions = LayoutOptions.Fill,
                BackgroundColor = this.BackgroundColor,
                TextColor = this.TextColor
            };
 
            this.innerEntry.Completed += this.InnerEntry_Completed;
 
            this.innerGrid = new Grid
            {
                HorizontalOptions = LayoutOptions.Fill,
                ColumnDefinitions =
                     {
                          new ColumnDefinition { Width = GridLength.Auto },
                          new ColumnDefinition { Width = GridLength.Star },
                          new ColumnDefinition { Width = GridLength.Auto },
                     },
                RowDefinitions =
                     {
                          new RowDefinition { Height = GridLength.Auto },
                     }
            };
 
            this.innerGrid.Add(this.innerPath, 0, 0);
            this.innerGrid.Add(this.innerEntry, 1, 0);
            this.innerGrid.Add(this.clickablePath, 2, 0);
 
            this.innerBorder = new Border
            {
                StrokeThickness = 2,
                Content = this.innerGrid,
                BackgroundColor = this.BackgroundColor
            };
 
            this.Content = this.innerBorder;
 
            // Bind Entry properties to the CompositeEntry properties
            this.innerEntry.SetBinding(Entry.TextProperty, new Binding(nameof(this.EntryData), source: this, mode: BindingMode.TwoWay));
            this.innerEntry.SetBinding(Entry.KeyboardProperty, new Binding(nameof(this.Keyboard), source: this));
            this.innerEntry.SetBinding(Entry.PlaceholderProperty, new Binding(nameof(this.Placeholder), source: this));
            this.innerEntry.SetBinding(Entry.IsPasswordProperty, new Binding(nameof(this.IsPassword), source: this));
            this.innerEntry.SetBinding(Entry.IsReadOnlyProperty, new Binding(nameof(this.IsReadOnly), source: this));
            this.innerEntry.SetBinding(Entry.ReturnCommandProperty, new Binding(nameof(this.ReturnCommand), source: this));
            this.innerEntry.SetBinding(Entry.StyleProperty, new Binding(nameof(this.EntryStyle), source: this));
            this.innerEntry.SetBinding(Entry.TextColorProperty, new Binding(nameof(this.TextColor), source: this));
 
            // Handle focus events
            this.innerEntry.Focused += this.OnEntryFocused;
            this.innerEntry.Unfocused += this.OnEntryUnfocused;
        }
 
        private void OnKeyboardPropertyChanged(Keyboard oldValue, Keyboard newValue)
        {
            this.innerEntry.Keyboard = newValue;
        }
 
        private void OnBorderStylePropertyChanged(Style oldValue, Style newValue)
        {
            this.innerBorder.Style = newValue;
        }
 
        private void OnStackSpacingPropertyChanged(double oldValue, double newValue)
        {
            this.innerGrid.ColumnSpacing = (this.innerPath.IsVisible || this.clickablePath.IsVisible) ? newValue : 0;
        }
 
        private void OnPathDataPropertyChanged(Geometry oldValue, Geometry newValue)
        {
            this.innerPath.Data = newValue;
            this.innerPath.IsVisible = newValue != null;
            this.innerGrid.ColumnSpacing = (this.innerPath.IsVisible || this.clickablePath.IsVisible) ? this.StackSpacing : 0;
        }
 
        private void OnClickablePathDataPropertyChanged(Geometry oldValue, Geometry newValue)
        {
            this.clickablePath.Data = newValue;
            this.clickablePath.IsVisible = newValue != null;
            this.innerGrid.ColumnSpacing = (this.innerPath.IsVisible || this.clickablePath.IsVisible) ? this.StackSpacing : 0;
        }
 
        private void OnPathStylePropertyChanged(Style oldValue, Style newValue)
        {
            this.innerPath.Style = newValue;
            this.clickablePath.Style = newValue;
        }
 
        private void OnEntryHintPropertyChanged(string oldValue, string newValue)
        {
            this.innerEntry.Placeholder = newValue;
        }
 
        private void OnEntryStylePropertyChanged(Style oldValue, Style newValue)
        {
            this.innerEntry.Style = newValue;
        }
 
        private void OnReturnCommandPropertyChanged(ICommand oldValue, ICommand newValue)
        {
            this.innerEntry.ReturnCommand = newValue;
        }
 
        private void OnIsPasswordPropertyChanged(bool oldValue, bool newValue)
        {
            this.innerEntry.IsPassword = newValue;
        }
 
        private void OnIsReadOnlyPropertyChanged(bool oldValue, bool newValue)
        {
            this.innerEntry.IsReadOnly = newValue;
        }
 
        private void OnPlaceholderPropertyChanged(string oldValue, string newValue)
        {
            this.innerEntry.Placeholder = newValue;
        }
 
        private void OnTextColorPropertyChanged(Color oldValue, Color newValue)
        {
            this.innerEntry.TextColor = newValue;
        }
 
        private void OnEntryFocused(object sender, FocusEventArgs e)
        {
            if (this.FocusedCommand?.CanExecute(e) ?? false)
            {
                this.FocusedCommand.Execute(e);
            }
        }
 
        private void OnEntryUnfocused(object sender, FocusEventArgs e)
        {
            if (this.UnfocusedCommand?.CanExecute(e) ?? false)
            {
                this.UnfocusedCommand.Execute(e);
            }
        }
 
        private void InnerEntry_Completed(object sender, EventArgs e)
        {
            try
            {
                this.Completed?.Invoke(sender, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public override string ToString()
        {
            return this.innerEntry.Text;
        }
    }
}