acdream/src/AcDream.App/UI/UiField.cs

using System;
using System.Collections.Generic;
using System.Numerics;

namespace AcDream.App.UI;

/// <summary>
/// Generic editable field widget. Port of retail <c>UIElement_Field</c>
/// (<c>RegisterElementClass(3)</c> @ acclient_2013_pseudo_c.txt:126190). Carries
/// retail <c>Field</c>'s drag-drop hooks (<c>CatchDroppedItem</c>/<c>MouseOverTop</c>)
/// as stubs for future item-window use.
///
/// <para>
/// Caret is a glyph index; the caret pixel-X is Σ glyph advances (UiDatFont) to the
/// caret. Supports mouse + Shift-arrow SELECTION, clipboard cut/copy/paste, and
/// held-key auto-repeat (hold Backspace deletes continuously). Submit (Enter / Send)
/// fires <see cref="OnSubmit"/>, clears, and pushes history (100-entry cap,
/// sentinel 0xFFFFFFFF — port of <c>ChatInterface::ProcessCommand @0x4f5100</c>).
/// </para>
///
/// Decomp: UIElement_Text MoveCursor @0x468d00, FindPixelsFromPos @0x472b40.
/// </summary>
internal sealed class UiField : UiElement
{
    private readonly record struct WrappedLine(int Start, int Length, string Text);

    public uint ElementId { get; set; }
    public UiDatFont? DatFont { get; set; }
    public AcDream.App.Rendering.BitmapFont? Font { get; set; }
    public Vector4 TextColor { get; set; } = new(1f, 1f, 1f, 1f);
    public Vector4 BackgroundColor { get; set; } = new(0f, 0f, 0f, 0f);
    /// <summary>Selected-span highlight (translucent blue, behind the text).</summary>
    public Vector4 SelectionColor { get; set; } = new(0.25f, 0.45f, 0.85f, 0.5f);
    public float Padding { get; set; } = 4f;
    public int MaxCharacters { get; set; } = 0xFFFF;
    public bool OneLine { get; set; } = true;
    public bool Selectable { get; set; }
    public bool Centered { get; set; }
    public bool RightAligned { get; set; }
    public bool ClearOnSubmit { get; set; } = true;
    public bool RecordHistory { get; set; } = true;
    public Func<char, bool>? CharacterFilter { get; set; }
    public bool SelectAllOnFocus { get; set; }
    public UiScrollable Scroll { get; } = new();
    public Action? OnReadOnlyClick { get; set; }

    private bool _editable = true;

    /// <summary>
    /// Retail property 0x16. Read-only fields remain mouse-visible so their
    /// authored background can report why editing is unavailable, but they do
    /// not take keyboard focus or accept mutations.
    /// </summary>
    public bool Editable
    {
        get => _editable;
        set
        {
            if (_editable == value) return;
            _editable = value;
            AcceptsFocus = value;
            IsEditControl = value;
            if (!value && _focused)
                FindRoot()?.SetKeyboardFocus(null);
            if (!value)
                _repeatKey = null;
        }
    }

    /// <summary>Keyboard device for clipboard (Ctrl+C/X/V) + modifier state (Ctrl/Shift).
    /// Wired by the host from <see cref="UiHost.Keyboard"/>.</summary>
    public Silk.NET.Input.IKeyboard? Keyboard { get; set; }

    /// <summary>Dat sprite resolver (id → GL texture + size) for the focused-field
    /// background. Null = fall back to the flat <see cref="BackgroundColor"/> rect.</summary>
    public Func<uint, (GpuTextureSlot tex, int w, int h)>? SpriteResolve { get; set; }
    /// <summary>Unfocused/default state sprite imported from the DAT.</summary>
    public uint BackgroundSprite { get; set; }
    /// <summary>Gold "lit" field background drawn when focused (retail Normal_focussed
    /// state, RenderSurface 0x060011AB). 0 = no focus sprite.</summary>
    public uint FocusFieldSprite { get; set; }

    public Action<string>? OnSubmit { get; set; }
    public Action? OnFocusGained { get; set; }
    public Action<string>? OnFocusLost { get; set; }

    private string _text = "";
    private int _caret;
    private int? _selAnchor;   // selection fixed end (null = no selection); span = [min,max] with _caret
    public string Text => _text;
    public bool IsFocused => _focused;
    public int CaretPos => _caret;

    private readonly List<string> _history = new();
    private int _historyIndex = -1;
    public int HistoryCount => _history.Count;

    private bool _focused;
    private bool _selecting;   // mouse drag in progress
    private bool _preserveFocusSelectionOnMouseDown;
    private float _scrollX;    // horizontal pixel scroll so the caret stays in the field
    private IReadOnlyList<WrappedLine> _wrappedLines = Array.Empty<WrappedLine>();
    private float _wrappedLineHeight = 14f;
    private bool _suppressNextNewlineChar;

    // Held-key auto-repeat (Silk delivers one KeyDown per physical press).
    private Silk.NET.Input.Key? _repeatKey;
    private double _repeatTimer;
    private const double RepeatDelay = 0.40;   // s before the first repeat
    private const double RepeatRate  = 0.04;   // s between repeats (~25/s)

    public UiField()
    {
        AcceptsFocus = true;
        IsEditControl = true;
        CapturesPointerDrag = true;   // interior drag selects, doesn't move the window
    }

    /// <summary>The field draws its own background + caret + caps; its dat cap sub-elements
    /// are reproduced procedurally, so the importer must not build them as widgets.</summary>
    public override bool ConsumesDatChildren => true;

    // ── Editing primitives ──────────────────────────────────────────────

    public void InsertChar(char c)
    {
        if (!Editable) return;
        if (!OneLine && (c == '\r' || c == '\n'))
            c = '\n';
        else if (c < 0x20 || c == 0x7F)
            return;
        if (CharacterFilter is not null && !CharacterFilter(c)) return;
        DeleteSelection();
        if (_text.Length >= MaxCharacters) return;
        _text = _text.Insert(_caret, c.ToString());
        _caret++;
        _historyIndex = -1;
    }

    public void Backspace()
    {
        if (!Editable) return;
        if (DeleteSelection()) return;
        if (_caret == 0) return;
        _text = _text.Remove(_caret - 1, 1);
        _caret--;
    }

    public void DeleteForward()
    {
        if (!Editable) return;
        if (DeleteSelection()) return;
        if (_caret >= _text.Length) return;
        _text = _text.Remove(_caret, 1);
    }

    private void MoveCaretTo(int target, bool shift)
    {
        target = Math.Clamp(target, 0, _text.Length);
        if (shift) _selAnchor ??= _caret;   // begin/extend selection from the old caret
        else _selAnchor = null;             // plain move collapses any selection
        _caret = target;
        _historyIndex = -1;
    }

    /// <summary>Move the caret left (negative) or right (positive) by <paramref name="delta"/>
    /// glyph positions without extending a selection. Public for test access.</summary>
    public void MoveCaret(int delta) => MoveCaretTo(_caret + delta, false);

    private void MoveCaret(int delta, bool shift) => MoveCaretTo(_caret + delta, shift);

    // ── Selection ────────────────────────────────────────────────────────

    private (int lo, int hi) SelSpan()
    {
        if (_selAnchor is not { } a || a == _caret) return (_caret, _caret);
        return (Math.Min(a, _caret), Math.Max(a, _caret));
    }

    private bool HasSelection => _selAnchor is { } a && a != _caret;

    private string SelectedText()
    {
        var (lo, hi) = SelSpan();
        return hi > lo ? _text.Substring(lo, hi - lo) : "";
    }

    /// <summary>Remove the selected span (if any). Returns true if it removed anything.</summary>
    private bool DeleteSelection()
    {
        if (!HasSelection) { _selAnchor = null; return false; }
        var (lo, hi) = SelSpan();
        _text = _text.Remove(lo, hi - lo);
        _caret = lo;
        _selAnchor = null;
        return true;
    }

    public void SelectAllText()
    {
        if (_text.Length == 0) { _selAnchor = null; return; }
        _selAnchor = 0;
        _caret = _text.Length;
    }

    public void SetText(string? text)
    {
        _text = text ?? "";
        if (_text.Length > MaxCharacters)
            _text = _text[..MaxCharacters];
        _caret = _text.Length;
        _selAnchor = null;
        _historyIndex = -1;
    }

    private void CopySelection()
    {
        var s = SelectedText();
        if (s.Length > 0 && Keyboard is not null) Keyboard.ClipboardText = s;
    }

    private void CutSelection()
    {
        if (!Editable) return;
        if (!HasSelection) return;
        CopySelection();
        DeleteSelection();
        _historyIndex = -1;
    }

    private void Paste()
    {
        if (!Editable) return;
        if (Keyboard is null) return;
        string clip = Keyboard.ClipboardText ?? "";
        if (clip.Length == 0) return;

        // Retail one-line fields strip controls. Multi-line fields preserve CR/LF
        // as one normalized newline and still reject other controls.
        var sb = new System.Text.StringBuilder(clip.Length);
        bool previousCr = false;
        foreach (char ch in clip)
        {
            if (!OneLine && (ch == '\r' || ch == '\n'))
            {
                if (ch == '\n' && previousCr)
                {
                    previousCr = false;
                    continue;
                }
                sb.Append('\n');
                previousCr = ch == '\r';
                continue;
            }
            previousCr = false;
            if (ch >= 0x20 && ch != 0x7F
                && (CharacterFilter is null || CharacterFilter(ch)))
                sb.Append(ch);
        }
        if (sb.Length == 0) return;

        DeleteSelection();
        int room = MaxCharacters - _text.Length;
        if (room <= 0) return;
        string ins = sb.Length > room ? sb.ToString(0, room) : sb.ToString();
        _text = _text.Insert(_caret, ins);
        _caret += ins.Length;
        _historyIndex = -1;
    }

    // ── Submit + history ─────────────────────────────────────────────────

    public void Submit()
    {
        if (!Editable) return;
        var t = _text;
        if (t.Trim().Length == 0)
        {
            if (ClearOnSubmit) Clear();
            return;
        }
        OnSubmit?.Invoke(t);
        if (RecordHistory) PushHistory(t);
        if (ClearOnSubmit) Clear();
    }

    private void Clear() { _text = ""; _caret = 0; _selAnchor = null; _historyIndex = -1; }

    private void PushHistory(string t)
    {
        _history.Add(t);
        if (_history.Count > 100) _history.RemoveAt(0);
        _historyIndex = -1;
    }

    public void HistoryPrev()
    {
        if (_history.Count == 0) return;
        _historyIndex = _historyIndex < 0 ? _history.Count - 1 : Math.Max(0, _historyIndex - 1);
        SetTextFromHistory();
    }

    public void HistoryNext()
    {
        if (_historyIndex < 0) return;
        _historyIndex++;
        if (_historyIndex >= _history.Count) { _historyIndex = -1; Clear(); return; }
        SetTextFromHistory();
    }

    private void SetTextFromHistory()
    {
        _text = _history[_historyIndex];
        _caret = _text.Length;
        _selAnchor = null;
    }

    // ── Geometry ─────────────────────────────────────────────────────────

    /// <summary>Pixel-X of the caret (Σ glyph advances to <paramref name="i"/>).</summary>
    private float MeasureTo(int i)
    {
        if (i <= 0) return 0f;
        string s = _text.Substring(0, Math.Min(i, _text.Length));
        return DatFont is { } df ? df.MeasureWidth(s)
             : Font is { } bf ? bf.MeasureWidth(s) : 0f;
    }

    public float CaretPixelX() => MeasureTo(_caret);

    /// <summary>Map a local X (click) to the nearest caret index — retail
    /// FindPixelsFromPos inverse. Accounts for the horizontal scroll offset.</summary>
    private int HitCharX(float localX)
    {
        float target = localX - Padding - TextAlignmentOffset() + _scrollX;
        if (target <= 0f) return 0;
        int best = 0;
        float bestDist = float.MaxValue;
        for (int i = 0; i <= _text.Length; i++)
        {
            float d = MathF.Abs(MeasureTo(i) - target);
            if (d < bestDist) { bestDist = d; best = i; }
        }
        return best;
    }

    // ── Draw ─────────────────────────────────────────────────────────────

    protected override void OnDraw(UiRenderContext ctx)
    {
        // Focused = "write mode": draw the gold lit field sprite (retail Normal_focussed).
        // Unfocused: draw the imported default state, then the flat translucent fallback.
        // Both go through the sprite bucket
        // (DrawFill / DrawSprite) so the text — also sprite-bucket — draws on top.
        bool lit = _focused && SpriteResolve is not null && FocusFieldSprite != 0;
        if (lit)
        {
            var (tex, tw, th) = SpriteResolve!(FocusFieldSprite);
            if (tex.IsAssigned && tw > 0) ctx.DrawSprite(tex, 0, 0, Width, Height, 0f, 0f, 1f, 1f, Vector4.One);
            else lit = false;
        }
        if (!lit && SpriteResolve is not null && BackgroundSprite != 0)
        {
            var (tex, tw, th) = SpriteResolve(BackgroundSprite);
            if (tex.IsAssigned && tw > 0 && th > 0)
            {
                ctx.DrawSprite(tex, 0, 0, Width, Height, 0f, 0f,
                    Width / tw, Height / th, Vector4.One);
                lit = true;
            }
        }
        if (!lit) ctx.DrawFill(0, 0, Width, Height, BackgroundColor);

        if (!OneLine)
        {
            DrawMultiLine(ctx);
            return;
        }

        float lh = DatFont?.LineHeight ?? Font?.LineHeight ?? 14f;
        float ty = (Height - lh) * 0.5f;
        float visibleW = MathF.Max(1f, Width - 2f * Padding);

        // Horizontal scroll: keep the caret inside the field; clamp so we never scroll past
        // the text. Then draw only the glyph window that lands inside the field — a single-
        // line text box clips + scrolls (retail UIElement_Text) rather than overflowing the
        // field (which previously spilled the text out into the 3D world).
        float caretX = MeasureTo(_caret);
        float fullW = MeasureTo(_text.Length);
        if (caretX - _scrollX > visibleW) _scrollX = caretX - visibleW;
        if (caretX < _scrollX) _scrollX = caretX;
        _scrollX = Math.Clamp(_scrollX, 0f, MathF.Max(0f, fullW - visibleW));
        float alignX = TextAlignmentOffset();

        // Visible character window [start, end).
        int start = 0;
        while (start < _text.Length && MeasureTo(start + 1) <= _scrollX) start++;
        int end = start;
        while (end < _text.Length && MeasureTo(end + 1) - _scrollX <= visibleW) end++;

        // Selection highlight BEHIND the text, clipped to the field.
        if (HasSelection)
        {
            var (lo, hi) = SelSpan();
            float h0 = MathF.Max(alignX + MeasureTo(lo) - _scrollX, 0f);
            float h1 = MathF.Min(alignX + MeasureTo(hi) - _scrollX, visibleW);
            if (h1 > h0) ctx.DrawFill(Padding + h0, ty, h1 - h0, lh, SelectionColor);
        }

        if (end > start)
        {
            string vis = _text.Substring(start, end - start);
            float vx = Padding + alignX + (MeasureTo(start) - _scrollX);
            if (DatFont is { } df2) ctx.DrawStringDat(df2, vis, vx, ty, TextColor);
            else ctx.DrawString(vis, vx, ty, TextColor, Font);
        }

        if (_focused)
        {
            // Caret on TOP of the text → submitted after the text in the same bucket.
            float cx = Padding + alignX + (caretX - _scrollX);
            if (cx >= Padding - 1f && cx <= Width - Padding + 1f)
                ctx.DrawFill(cx, ty, 1f, lh, TextColor);
        }
    }

    private float TextAlignmentOffset()
    {
        float visibleW = MathF.Max(1f, Width - 2f * Padding);
        float spare = MathF.Max(0f, visibleW - MeasureTo(_text.Length));
        if (RightAligned) return spare;
        if (Centered) return spare * 0.5f;
        return 0f;
    }

    private void DrawMultiLine(UiRenderContext ctx)
    {
        float lineHeight = DatFont?.LineHeight ?? Font?.LineHeight ?? 14f;
        float visibleWidth = MathF.Max(1f, Width - (2f * Padding));
        float visibleHeight = MathF.Max(1f, Height - (2f * Padding));
        IReadOnlyList<WrappedLine> lines = BuildWrappedLines(visibleWidth);
        _wrappedLines = lines;
        _wrappedLineHeight = lineHeight;

        Scroll.LineHeight = Math.Max(1, (int)MathF.Round(lineHeight));
        Scroll.SetExtents(
            Math.Max(1, (int)MathF.Ceiling(lines.Count * lineHeight)),
            Math.Max(1, (int)MathF.Floor(visibleHeight)),
            preserveEnd: false);

        int caretLine = FindCaretLine(lines, _caret);
        if (_focused)
        {
            float caretTop = caretLine * lineHeight;
            float caretBottom = caretTop + lineHeight;
            if (caretTop < Scroll.ScrollY)
                Scroll.SetScrollY((int)MathF.Floor(caretTop));
            else if (caretBottom > Scroll.ScrollY + visibleHeight)
                Scroll.SetScrollY((int)MathF.Ceiling(caretBottom - visibleHeight));
        }

        ctx.PushClip(0f, 0f, Width, Height);
        try
        {
            var (selectionLow, selectionHigh) = SelSpan();
            for (int i = 0; i < lines.Count; i++)
            {
                WrappedLine line = lines[i];
                float y = Padding + (i * lineHeight) - Scroll.ScrollY;
                if (y + lineHeight <= Padding || y >= Height - Padding)
                    continue;

                int lineEnd = line.Start + line.Length;
                int highlightLow = Math.Max(selectionLow, line.Start);
                int highlightHigh = Math.Min(selectionHigh, lineEnd);
                if (HasSelection && highlightHigh > highlightLow)
                {
                    float x0 = Padding + MeasureRange(
                        line.Start,
                        highlightLow - line.Start);
                    float x1 = Padding + MeasureRange(
                        line.Start,
                        highlightHigh - line.Start);
                    ctx.DrawFill(
                        x0,
                        y,
                        MathF.Max(0f, x1 - x0),
                        lineHeight,
                        SelectionColor);
                }

                if (DatFont is { } dat)
                    ctx.DrawStringDat(dat, line.Text, Padding, y, TextColor);
                else if (Font is { } bitmap)
                    ctx.DrawString(line.Text, Padding, y, TextColor, bitmap);
            }

            if (_focused && lines.Count > 0)
            {
                WrappedLine line = lines[caretLine];
                int lineColumn = Math.Clamp(
                    _caret - line.Start,
                    0,
                    line.Length);
                float x = Padding + MeasureRange(line.Start, lineColumn);
                float y = Padding + (caretLine * lineHeight) - Scroll.ScrollY;
                ctx.DrawFill(x, y, 1f, lineHeight, TextColor);
            }
        }
        finally
        {
            ctx.PopClip();
        }
    }

    private IReadOnlyList<WrappedLine> BuildWrappedLines(float maximumWidth)
    {
        var lines = new List<WrappedLine>();
        if (_text.Length == 0)
        {
            lines.Add(new WrappedLine(0, 0, string.Empty));
            return lines;
        }

        int start = 0;
        while (start < _text.Length)
        {
            if (_text[start] == '\n')
            {
                lines.Add(new WrappedLine(start, 0, string.Empty));
                start++;
                continue;
            }

            int paragraphEnd = _text.IndexOf('\n', start);
            if (paragraphEnd < 0)
                paragraphEnd = _text.Length;
            int end = start;
            int lastWhitespaceEnd = -1;
            while (end < paragraphEnd)
            {
                int candidateEnd = end + 1;
                if (MeasureRange(start, candidateEnd - start) > maximumWidth
                    && end > start)
                    break;
                end = candidateEnd;
                if (char.IsWhiteSpace(_text[end - 1]))
                    lastWhitespaceEnd = end;
            }

            if (end < paragraphEnd && lastWhitespaceEnd > start)
                end = lastWhitespaceEnd;
            if (end == start)
                end++;

            int length = end - start;
            lines.Add(new WrappedLine(
                start,
                length,
                _text.Substring(start, length)));
            start = end;
            if (start == paragraphEnd && start < _text.Length)
                start++;
        }

        if (_text.EndsWith('\n'))
            lines.Add(new WrappedLine(_text.Length, 0, string.Empty));
        return lines;
    }

    private int FindCaretLine(IReadOnlyList<WrappedLine> lines, int caret)
    {
        for (int i = 0; i < lines.Count; i++)
        {
            WrappedLine line = lines[i];
            int end = line.Start + line.Length;
            if (caret < end || caret == end && i == lines.Count - 1)
                return i;
            if (caret == end && i + 1 < lines.Count
                && lines[i + 1].Start > caret)
                return i;
        }
        return Math.Max(0, lines.Count - 1);
    }

    private float MeasureRange(int start, int length)
    {
        if (length <= 0) return 0f;
        string value = _text.Substring(start, length);
        return DatFont?.MeasureWidth(value)
               ?? Font?.MeasureWidth(value)
               ?? value.Length * 8f;
    }

    private int HitChar(float localX, float localY)
    {
        if (OneLine)
            return HitCharX(localX);
        if (_wrappedLines.Count == 0)
            return _text.Length;

        int lineIndex = Math.Clamp(
            (int)MathF.Floor(
                (localY - Padding + Scroll.ScrollY)
                / MathF.Max(1f, _wrappedLineHeight)),
            0,
            _wrappedLines.Count - 1);
        WrappedLine line = _wrappedLines[lineIndex];
        float target = MathF.Max(0f, localX - Padding);
        int best = 0;
        float bestDistance = float.MaxValue;
        for (int col = 0; col <= line.Length; col++)
        {
            float distance = MathF.Abs(
                MeasureRange(line.Start, col) - target);
            if (distance >= bestDistance) continue;
            bestDistance = distance;
            best = col;
        }
        return line.Start + best;
    }

    // ── Auto-repeat ──────────────────────────────────────────────────────

    protected override void OnTick(double deltaSeconds)
    {
        if (!Editable || _repeatKey is not { } k) return;
        _repeatTimer -= deltaSeconds;
        if (_repeatTimer > 0) return;
        _repeatTimer = RepeatRate;
        bool shift = ShiftHeld();
        switch (k)
        {
            case Silk.NET.Input.Key.Backspace: Backspace(); break;
            case Silk.NET.Input.Key.Delete:    DeleteForward(); break;
            case Silk.NET.Input.Key.Left:      MoveCaret(-1, shift); break;
            case Silk.NET.Input.Key.Right:     MoveCaret(1, shift); break;
            default: _repeatKey = null; break;
        }
    }

    private void StartRepeat(Silk.NET.Input.Key k) { _repeatKey = k; _repeatTimer = RepeatDelay; }

    private bool CtrlHeld() => Keyboard is not null
        && (Keyboard.IsKeyPressed(Silk.NET.Input.Key.ControlLeft)
            || Keyboard.IsKeyPressed(Silk.NET.Input.Key.ControlRight));

    private bool ShiftHeld() => Keyboard is not null
        && (Keyboard.IsKeyPressed(Silk.NET.Input.Key.ShiftLeft)
            || Keyboard.IsKeyPressed(Silk.NET.Input.Key.ShiftRight));

    // ── Events ───────────────────────────────────────────────────────────

    public override bool OnEvent(in UiEvent e)
    {
        switch (e.Type)
        {
            case UiEventType.FocusGained:
                _focused = true;
                if (SelectAllOnFocus)
                {
                    SelectAllText();
                    // UiRoot assigns focus before delivering the initiating MouseDown.
                    // Retail's activation notice selects all after that press, so preserve
                    // this selection across the one MouseDown that caused focus.
                    _preserveFocusSelectionOnMouseDown = true;
                }
                OnFocusGained?.Invoke();
                return true;
            case UiEventType.FocusLost:
                OnFocusLost?.Invoke(_text);
                _focused = false; _historyIndex = -1;
                _selAnchor = null; _selecting = false; _repeatKey = null;
                _preserveFocusSelectionOnMouseDown = false;
                return true;

            case UiEventType.Char:
            {
                char value = (char)e.Data0;
                if (_suppressNextNewlineChar
                    && (value == '\r' || value == '\n'))
                {
                    _suppressNextNewlineChar = false;
                    return true;
                }
                _suppressNextNewlineChar = false;
                InsertChar(value);
                return true;
            }

            case UiEventType.MouseDown:
                if (_preserveFocusSelectionOnMouseDown)
                {
                    _preserveFocusSelectionOnMouseDown = false;
                    _selecting = false;
                    return true;
                }
                _caret = HitChar(e.Data1, e.Data2);
                _selAnchor = Selectable ? _caret : null;
                _selecting = Selectable;
                return true;
            case UiEventType.MouseMove:
                if (Selectable && _selecting)
                    _caret = HitChar(e.Data1, e.Data2);
                return true;
            case UiEventType.MouseUp:
                _selecting = false;
                return true;

            case UiEventType.KeyUp:
                if ((Silk.NET.Input.Key)e.Data0 == _repeatKey) _repeatKey = null;
                return true;

            case UiEventType.KeyDown:
            {
                if (!Editable)
                    return true;
                var key = (Silk.NET.Input.Key)e.Data0;
                if (CtrlHeld())
                {
                    switch (key)
                    {
                        case Silk.NET.Input.Key.A when Selectable: SelectAllText(); return true;
                        case Silk.NET.Input.Key.C when Selectable: CopySelection(); return true;
                        case Silk.NET.Input.Key.X when Selectable: CutSelection(); return true;
                        case Silk.NET.Input.Key.V: Paste();         return true;
                    }
                    return true;   // swallow other Ctrl combos while typing
                }

                bool shift = Selectable && ShiftHeld();
                switch (key)
                {
                    case Silk.NET.Input.Key.Enter:
                    case Silk.NET.Input.Key.KeypadEnter:
                        if (!OneLine)
                        {
                            InsertChar('\n');
                            _suppressNextNewlineChar = true;
                            return true;
                        }
                        Submit();
                        FindRoot()?.SetKeyboardFocus(null);   // exit write mode after sending
                        return true;
                    case Silk.NET.Input.Key.Backspace: Backspace();        StartRepeat(key); return true;
                    case Silk.NET.Input.Key.Delete:    DeleteForward();    StartRepeat(key); return true;
                    case Silk.NET.Input.Key.Left:      MoveCaret(-1, shift); StartRepeat(key); return true;
                    case Silk.NET.Input.Key.Right:     MoveCaret(1, shift);  StartRepeat(key); return true;
                    case Silk.NET.Input.Key.Home:      MoveCaretTo(0, shift); return true;
                    case Silk.NET.Input.Key.End:       MoveCaretTo(_text.Length, shift); return true;
                    case Silk.NET.Input.Key.Up:        HistoryPrev(); return true;
                    case Silk.NET.Input.Key.Down:      HistoryNext(); return true;
                }
                return false;
            }
            case UiEventType.Scroll:
                if (!OneLine)
                {
                    Scroll.ScrollByLines(-Math.Sign(e.Data0));
                    return true;
                }
                return false;
            case UiEventType.Click:
                if (!Editable)
                {
                    OnReadOnlyClick?.Invoke();
                    return true;
                }
                return false;
        }
        return false;
    }
}