TextBoxWidget.cs

using System.Drawing;
using Gondwana.Drawing.Direct;
using Gondwana.Input.Keyboard;
using Gondwana.Rendering;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.Timers;
using SkiaSharp;
 
namespace Gondwana.Widgets.Controls;

public sealed class TextBoxWidget : WidgetBase
{
    private Color _backgroundColor = Color.FromArgb(255, 32, 32, 40);
    private Color _borderColor = Color.FromArgb(255, 135, 135, 150);
    private Color _focusedBorderColor = Color.FromArgb(255, 105, 155, 230);
    private SKColor _textColor = SKColors.White;
    private SKColor _placeholderColor = new(170, 170, 180);
 
    private string _text = string.Empty;
    private string _placeholder = string.Empty;
    private int _caretIndex;
    private int? _maxLength;
    private double _initialKeyRepeatDelaySeconds = 1.25;
    private double _repeatedKeyIntervalSeconds = 0.05;
    private int? _repeatingKey;
    private long _keyPressedTick;
    private long _lastRepeatTick;
    private Func<WidgetKeyboardEventArgs, char?> _characterResolver = ResolveWindowsVirtualKeyCharacter;

    public event Action<string>? TextChanged;

    public event Action<string>? Submitted;

    public TextBoxWidget(RenderSurfaceHostBase renderSurfaceHost,
                         View view,
                         Rectangle bounds,
                         string text = "",
                         string? placeholder = null,
                         string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.View, ValidateBounds(bounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(view);
 
        _text = NormalizeText(text);
        _placeholder = placeholder ?? string.Empty;
        _caretIndex = _text.Length;
 
        Background = CreateBackground(renderSurfaceHost, view, bounds);
        TextBlock = CreateTextBlock(renderSurfaceHost, view, bounds);
 
        Add(Background);
        Add(TextBlock);
 
        CompleteInitialization();
    }

    public TextBoxWidget(RenderSurfaceHostBase renderSurfaceHost,
                         SceneLayer sceneLayer,
                         Rectangle bounds,
                         string text = "",
                         string? placeholder = null,
                         string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.SceneLayer, ValidateBounds(bounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(sceneLayer);
 
        _text = NormalizeText(text);
        _placeholder = placeholder ?? string.Empty;
        _caretIndex = _text.Length;
 
        Background = CreateBackground(renderSurfaceHost, sceneLayer, bounds);
        TextBlock = CreateTextBlock(renderSurfaceHost, sceneLayer, bounds);
 
        Add(Background);
        Add(TextBlock);
 
        CompleteInitialization();
    }

    public DirectRectangle Background { get; }

    public TextBlock TextBlock { get; }

    public string Text
    {
        get => _text;
        set => SetText(value);
    }

    public string Placeholder
    {
        get => _placeholder;
        set
        {
            _placeholder = value ?? string.Empty;
            RefreshDisplayedText();
        }
    }

    public int CaretIndex
    {
        get => _caretIndex;
        set
        {
            _caretIndex = Math.Clamp(value, 0, _text.Length);
            RefreshDisplayedText();
        }
    }

    public int? MaxLength
    {
        get => _maxLength;
        set
        {
            if (value.HasValue && value.Value < 0)
                throw new ArgumentOutOfRangeException(nameof(value));
 
            _maxLength = value;
 
            if (_maxLength.HasValue && _text.Length > _maxLength.Value)
                SetText(_text[.._maxLength.Value]);
        }
    }

    public double InitialKeyRepeatDelaySeconds
    {
        get => _initialKeyRepeatDelaySeconds;
        set
        {
            if (!double.IsFinite(value) || value < 0d)
                throw new ArgumentOutOfRangeException(nameof(value));
 
            _initialKeyRepeatDelaySeconds = value;
        }
    }

    public double RepeatedKeyIntervalSeconds
    {
        get => _repeatedKeyIntervalSeconds;
        set
        {
            if (!double.IsFinite(value) || value < 0d)
                throw new ArgumentOutOfRangeException(nameof(value));
 
            _repeatedKeyIntervalSeconds = value;
        }
    }

    public bool IsReadOnly { get; set; }

    public Rectangle Bounds => Mode == DirectDrawingMode.View
        ? Background.ScreenBounds
        : Background.WorldBounds;

    public int SubmitKey { get; set; } = 13;

    public int BackspaceKey { get; set; } = 8;

    public int DeleteKey { get; set; } = 46;

    public int LeftKey { get; set; } = 37;

    public int RightKey { get; set; } = 39;

    public int HomeKey { get; set; } = 36;

    public int EndKey { get; set; } = 35;

    public Func<WidgetKeyboardEventArgs, char?> CharacterResolver
    {
        get => _characterResolver;
        set => _characterResolver = value ?? NoCharacterResolver;
    }

    public TextBoxWidget SetText(string? text)
    {
        string normalized = NormalizeText(text);
 
        if (MaxLength.HasValue && normalized.Length > MaxLength.Value)
            normalized = normalized[..MaxLength.Value];
 
        if (_text == normalized)
        {
            _caretIndex = Math.Min(_caretIndex, _text.Length);
            RefreshDisplayedText();
            return this;
        }
 
        _text = normalized;
        _caretIndex = _text.Length;
        RefreshDisplayedText();
        TextChanged?.Invoke(_text);
        return this;
    }

    public TextBoxWidget InsertText(string? text)
    {
        if (IsReadOnly || string.IsNullOrEmpty(text))
            return this;
 
        string insertion = NormalizeText(text);
        if (insertion.Length == 0)
            return this;
 
        if (MaxLength.HasValue)
        {
            int available = MaxLength.Value - _text.Length;
            if (available <= 0)
                return this;
 
            if (insertion.Length > available)
                insertion = insertion[..available];
        }
 
        _text = _text.Insert(_caretIndex, insertion);
        _caretIndex += insertion.Length;
        RefreshDisplayedText();
        TextChanged?.Invoke(_text);
        return this;
    }

    public TextBoxWidget Backspace()
    {
        if (IsReadOnly || _caretIndex <= 0 || _text.Length == 0)
            return this;
 
        _text = _text.Remove(_caretIndex - 1, 1);
        _caretIndex--;
        RefreshDisplayedText();
        TextChanged?.Invoke(_text);
        return this;
    }

    public TextBoxWidget Delete()
    {
        if (IsReadOnly || _caretIndex < 0 || _caretIndex >= _text.Length)
            return this;
 
        _text = _text.Remove(_caretIndex, 1);
        RefreshDisplayedText();
        TextChanged?.Invoke(_text);
        return this;
    }

    public TextBoxWidget MoveCaret(int delta)
    {
        CaretIndex = Math.Clamp(_caretIndex + delta, 0, _text.Length);
        return this;
    }

    public TextBoxWidget SetColors(Color background,
                                   Color border,
                                   Color focusedBorder)
    {
        _backgroundColor = background;
        _borderColor = border;
        _focusedBorderColor = focusedBorder;
 
        Background.SetColor(_backgroundColor)
                  .SetBorderColor(IsFocused ? _focusedBorderColor : _borderColor);
        Refresh(Background);
        return this;
    }

    public TextBoxWidget SetTextColors(SKColor text, SKColor placeholder)
    {
        _textColor = text;
        _placeholderColor = placeholder;
        RefreshDisplayedText();
        return this;
    }

    public TextBoxWidget SetTextBoxZOrder(int zOrder)
    {
        Background.ZOrder = zOrder;
        TextBlock.ZOrder = zOrder + 1;
        return this;
    }

    protected override void OnPointerClick(WidgetPointerEventArgs args)
    {
        base.OnPointerClick(args);
 
        if (!args.IsPrimaryButton)
            return;
 
        _caretIndex = _text.Length;
        RefreshDisplayedText();
        args.Handled = true;
    }

    protected override void OnFocusGained()
    {
        base.OnFocusGained();
        Background.SetBorderColor(_focusedBorderColor);
        Refresh(Background);
        RefreshDisplayedText();
    }

    protected override void OnFocusLost()
    {
        base.OnFocusLost();
        ResetKeyRepeatState();
        Background.SetBorderColor(_borderColor);
        Refresh(Background);
        RefreshDisplayedText();
    }

    protected override void OnKeyboardInput(WidgetKeyboardEventArgs args)
    {
        base.OnKeyboardInput(args);
 
        if (args.KeyAction == KeyAction.Released)
        {
            if (_repeatingKey == args.Key)
                ResetKeyRepeatState();
 
            return;
        }
 
        if (args.KeyAction is not KeyAction.Pressed and not KeyAction.Repeated)
            return;
 
        long currentTick = HighResTimer.GetCurrentTick();
 
        if (args.KeyAction == KeyAction.Pressed)
        {
            _repeatingKey = args.Key;
            _keyPressedTick = currentTick;
            _lastRepeatTick = currentTick;
        }
        else
        {
            if (_repeatingKey != args.Key ||
                _keyPressedTick == 0 ||
                HighResTimer.GetDuration(_keyPressedTick, currentTick) < _initialKeyRepeatDelaySeconds ||
                (_lastRepeatTick != 0 &&
                 HighResTimer.GetDuration(_lastRepeatTick, currentTick) < _repeatedKeyIntervalSeconds))
            {
                args.Handled = true;
                return;
            }
 
            _lastRepeatTick = currentTick;
        }
 
        if (args.Key == SubmitKey)
        {
            if (args.KeyAction != KeyAction.Pressed)
                return;
 
            args.Handled = true;
            Submitted?.Invoke(_text);
            return;
        }
 
        if (args.Key == LeftKey)
        {
            args.Handled = true;
            MoveCaret(-1);
            return;
        }
 
        if (args.Key == RightKey)
        {
            args.Handled = true;
            MoveCaret(1);
            return;
        }
 
        if (args.Key == HomeKey)
        {
            args.Handled = true;
            CaretIndex = 0;
            return;
        }
 
        if (args.Key == EndKey)
        {
            args.Handled = true;
            CaretIndex = _text.Length;
            return;
        }
 
        if (args.Key == BackspaceKey)
        {
            args.Handled = true;
            Backspace();
            return;
        }
 
        if (args.Key == DeleteKey)
        {
            args.Handled = true;
            Delete();
            return;
        }
 
        if (IsReadOnly)
            return;
 
        char? character = CharacterResolver(args);
        if (!character.HasValue)
            return;
 
        args.Handled = true;
        InsertText(character.Value.ToString());
    }
 
    private void ResetKeyRepeatState()
    {
        _repeatingKey = null;
        _keyPressedTick = 0;
        _lastRepeatTick = 0;
    }
 
    private void CompleteInitialization()
    {
        CanReceiveFocus = true;
        IsKeyboardInputEnabled = true;
        SetTextBoxZOrder(0);
        RefreshDisplayedText();
    }
 
    private void RefreshDisplayedText()
    {
        if (IsFocused)
        {
            string withCaret = _text.Insert(_caretIndex, "|");
            TextBlock.SetText(withCaret)
                     .SetColors(_textColor, SKColors.Transparent);
            return;
        }
 
        bool showPlaceholder = _text.Length == 0 && _placeholder.Length > 0;
        TextBlock.SetText(showPlaceholder ? _placeholder : _text)
                 .SetColors(showPlaceholder ? _placeholderColor : _textColor, SKColors.Transparent);
    }
 
    private DirectRectangle CreateBackground(RenderSurfaceHostBase host,
                                             View view,
                                             Rectangle bounds)
    {
        return ConfigureBackground(new DirectRectangle(_backgroundColor, host, view, bounds));
    }
 
    private DirectRectangle CreateBackground(RenderSurfaceHostBase host,
                                             SceneLayer layer,
                                             Rectangle bounds)
    {
        return ConfigureBackground(new DirectRectangle(_backgroundColor, host, layer, bounds));
    }
 
    private DirectRectangle ConfigureBackground(DirectRectangle background)
    {
        return background.SetFilled(true)
                         .SetBorderColor(_borderColor)
                         .SetStrokeWidth(1.5f)
                         .SetCornerRadius(4f);
    }
 
    private static TextBlock CreateTextBlock(RenderSurfaceHostBase host,
                                             View view,
                                             Rectangle bounds)
    {
        return ConfigureTextBlock(new TextBlock(host, view, bounds));
    }
 
    private static TextBlock CreateTextBlock(RenderSurfaceHostBase host,
                                             SceneLayer layer,
                                             Rectangle bounds)
    {
        return ConfigureTextBlock(new TextBlock(host, layer, view: null, worldBounds: bounds));
    }
 
    private static TextBlock ConfigureTextBlock(TextBlock textBlock)
    {
        return textBlock.SetFont(SKTypeface.Default, 16f, minSize: 10f)
                        .SetColors(SKColors.White, SKColors.Transparent)
                        .SetAlignment(SKTextAlign.Left, TextBlock.VerticalAlign.Center)
                        .SetPadding(8f, 0f)
                        .EnableWrapping(false);
    }
 
    private static string NormalizeText(string? text)
    {
        return (text ?? string.Empty)
            .Replace('\r', ' ')
            .Replace('\n', ' ');
    }
 
    private static char? NoCharacterResolver(WidgetKeyboardEventArgs args)
    {
        return null;
    }
 
    private static char? ResolveWindowsVirtualKeyCharacter(WidgetKeyboardEventArgs args)
    {
        if ((args.Modifiers & (KeyboardModifierState.Ctrl | KeyboardModifierState.Alt)) != 0)
            return null;
 
        bool shift = (args.Modifiers & KeyboardModifierState.Shift) != 0;
        int key = args.Key;
 
        if (key is >= 65 and <= 90)
        {
            char letter = (char)key;
            return shift ? letter : char.ToLowerInvariant(letter);
        }
 
        if (key is >= 48 and <= 57)
        {
            if (!shift)
                return (char)key;
 
            const string shiftedDigits = ")!@#$%^&*(";
            return shiftedDigits[key - 48];
        }
 
        if (key is >= 96 and <= 105)
            return (char)('0' + key - 96);
 
        return key switch
        {
            32 => ' ',
            106 => '*',
            107 => '+',
            109 => '-',
            110 => '.',
            111 => '/',
            186 => shift ? ':' : ';',
            187 => shift ? '+' : '=',
            188 => shift ? '<' : ',',
            189 => shift ? '_' : '-',
            190 => shift ? '>' : '.',
            191 => shift ? '?' : '/',
            192 => shift ? '~' : '`',
            219 => shift ? '{' : '[',
            220 => shift ? '|' : '\\',
            221 => shift ? '}' : ']',
            222 => shift ? '"' : '\'',
            _ => null
        };
    }
 
    private static void Refresh(DirectRectangle rectangle)
    {
        rectangle.SetPosition(rectangle.GetPosition());
    }
 
    private static Rectangle ValidateBounds(Rectangle bounds)
    {
        if (bounds.Width < 40 || bounds.Height < 18)
            throw new ArgumentOutOfRangeException(nameof(bounds), bounds, "Text-box bounds are too small.");
 
        return bounds;
    }
}