CompositeEntry.cs

using System.Windows.Input;
using Microsoft.Maui.Controls;
using Microsoft.Maui.Controls.Shapes;
using Waher.Events;
using Path = Microsoft.Maui.Controls.Shapes.Path;
 
namespace NeuroAccessMaui.UI.Controls
{
    public class CompositeEntry : CompositeInputView
    {
        #region Bindable Properties
 
        public static readonly BindableProperty EntryDataProperty = BindableProperty.Create(
             nameof(EntryData),
             typeof(string),
             typeof(CompositeEntry),
             default(string),
             BindingMode.TwoWay);
 
        public string EntryData
        {
            get => (string)this.GetValue(EntryDataProperty);
            set => this.SetValue(EntryDataProperty, value);
        }
 
        public static readonly BindableProperty PlaceholderProperty = BindableProperty.Create(
             nameof(Placeholder),
             typeof(string),
             typeof(CompositeEntry),
             default(string));
 
        public string Placeholder
        {
            get => (string)this.GetValue(PlaceholderProperty);
            set => this.SetValue(PlaceholderProperty, value);
        }
 
        public static readonly BindableProperty IsPasswordProperty = BindableProperty.Create(
             nameof(IsPassword),
             typeof(bool),
             typeof(CompositeEntry),
             false);
 
        public bool IsPassword
        {
            get => (bool)this.GetValue(IsPasswordProperty);
            set => this.SetValue(IsPasswordProperty, value);
        }
 
        public static readonly BindableProperty EntryStyleProperty = BindableProperty.Create(
             nameof(EntryStyle),
             typeof(Style),
             typeof(CompositeEntry));
 
        public Style EntryStyle
        {
            get => (Style)this.GetValue(EntryStyleProperty);
            set => this.SetValue(EntryStyleProperty, value);
        }
 
        public static readonly BindableProperty KeyboardProperty = BindableProperty.Create(
             nameof(Keyboard),
             typeof(Keyboard),
             typeof(CompositeEntry),
             Keyboard.Default);
 
        public Keyboard Keyboard
        {
            get => (Keyboard)this.GetValue(KeyboardProperty);
            set => this.SetValue(KeyboardProperty, value);
        }
 
        public static readonly BindableProperty TextColorProperty = BindableProperty.Create(
             nameof(TextColor),
             typeof(Color),
             typeof(CompositeEntry),
             Colors.Black);
 
        public Color TextColor
        {
            get => (Color)this.GetValue(TextColorProperty);
            set => this.SetValue(TextColorProperty, value);
        }
 
 
 
 
        public static readonly BindableProperty IsSpellCheckEnabledProperty = BindableProperty.Create(
             nameof(IsSpellCheckEnabled),
             typeof(bool),
             typeof(CompositeEntry),
             true);
 
        public bool IsSpellCheckEnabled
        {
            get => (bool)this.GetValue(IsSpellCheckEnabledProperty);
            set => this.SetValue(IsSpellCheckEnabledProperty, value);
        }
 
        public static readonly BindableProperty IsTextPredictionEnabledProperty = BindableProperty.Create(
             nameof(IsTextPredictionEnabled),
             typeof(bool),
             typeof(CompositeEntry),
             true);
 
        public bool IsTextPredictionEnabled
        {
            get => (bool)this.GetValue(IsTextPredictionEnabledProperty);
            set => this.SetValue(IsTextPredictionEnabledProperty, value);
        }
 
        public static readonly BindableProperty IsReadOnlyProperty = BindableProperty.Create(
             nameof(IsReadOnly),
             typeof(bool),
             typeof(CompositeEntry),
             false);
 
        public bool IsReadOnly
        {
            get => (bool)this.GetValue(IsReadOnlyProperty);
            set => this.SetValue(IsReadOnlyProperty, value);
        }
 
        // Define the new BackgroundColor property
        public static new readonly BindableProperty BackgroundColorProperty = BindableProperty.Create(
             nameof(BackgroundColor),
             typeof(Color),
             typeof(CompositeEntry),
             Colors.Transparent);
 
        public new Color BackgroundColor
        {
            get => (Color)this.GetValue(BackgroundColorProperty);
            set => this.SetValue(BackgroundColorProperty, value);
        }
 
        #endregion
 
        #region Fields
 
        private readonly Entry innerEntry;
 
        #endregion
 
        #region Events
 
        public event EventHandler? Completed;
 
        public event EventHandler<TextChangedEventArgs>? TextChanged;
 
        public new event EventHandler<FocusEventArgs>? Focused;
 
        public new event EventHandler<FocusEventArgs>? Unfocused;
 
        #endregion
 
        #region Constructor
 
        public CompositeEntry()
        {
            // Initialize the inner Entry
            this.innerEntry = new Entry
            {
                VerticalOptions = LayoutOptions.Center,
                HorizontalOptions = LayoutOptions.Fill,
                BackgroundColor = Colors.Transparent
            };
 
            // Set up bindings for the Entry
            this.innerEntry.SetBinding(Entry.TextProperty, new Binding(nameof(this.EntryData), 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.KeyboardProperty, new Binding(nameof(this.Keyboard), 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));
            this.innerEntry.SetBinding(InputView.IsSpellCheckEnabledProperty, new Binding(nameof(this.IsSpellCheckEnabled), source: this));
            this.innerEntry.SetBinding(InputView.IsTextPredictionEnabledProperty, new Binding(nameof(this.IsTextPredictionEnabled), source: this));
            this.innerEntry.SetBinding(Entry.IsReadOnlyProperty, new Binding(nameof(this.IsReadOnly), source: this));
 
            // Handle events
            this.innerEntry.Completed += this.OnEntryCompleted;
            this.innerEntry.TextChanged += this.OnEntryTextChanged;
            this.innerEntry.Focused += this.OnEntryFocused;
            this.innerEntry.Unfocused += this.OnEntryUnfocused;
 
            // Initialize the top label
            this.CenterView = this.innerEntry;
        }
 
        #endregion
 
        #region Property Overrides
 
        public new string StyleId
        {
            get => this.innerEntry.StyleId;
            set => this.innerEntry.StyleId = value;
        }
 
        public new string AutomationId
        {
            get => this.innerEntry.AutomationId;
            set => this.innerEntry.AutomationId = value;
        }
 
        #endregion
 
        #region Methods
 
        public new bool Focus()
        {
            return this.innerEntry.Focus();
        }
 
        public new void Unfocus()
        {
            this.innerEntry.Unfocus();
        }
 
        #endregion
 
        #region Property Changed Callbacks
 
        #endregion
 
        #region Event Handlers
 
        private void OnEntryTextChanged(object? sender, TextChangedEventArgs e)
        {
            TextChanged.Raise(this, e);
        }
 
        private void OnEntryCompleted(object? sender, EventArgs e)
        {
            Completed.Raise(this, e);
        }
 
        private void OnEntryFocused(object? sender, FocusEventArgs e)
        {
            Focused.Raise(this, e);
 
        }
 
        private void OnEntryUnfocused(object? sender, FocusEventArgs e)
        {
            Unfocused.Raise(this, e);
        }
 
        #endregion
    }
}