TabControlWidget.cs

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

public sealed class TabControlWidget : ContainerWidget, IWidgetKeyboardFallback
{
    private const int DefaultTabHeight = 32;
    private const int DefaultPreferredTabWidth = 132;
    private const float DefaultReorderDragThresholdPx = 6f;
 
    private readonly List<TabPageWidget> _tabs = [];
    private readonly Dictionary<TabPageWidget, TabHeaderWidget> _headers = [];
 
    private readonly View? _view;
    private readonly SceneLayer? _sceneLayer;
 
    private Size _size;
    private int _selectedIndex = -1;
    private int _tabRowCount = 1;
    private int _displayedRowCount = 1;
    private int _displayedColumnCount = 1;
    private int _tabHeight = DefaultTabHeight;
    private int _preferredTabWidth = DefaultPreferredTabWidth;
    private int _baseZOrder;
    private float _tabReorderDragThresholdPx = DefaultReorderDragThresholdPx;
    private bool _autoExpandRows;
    private bool _isTabReorderingEnabled;
    private bool _isShown;
    private bool _disposed;
 
    private Color _normalTabColor = Color.FromArgb(255, 60, 60, 68);
    private Color _hoverTabColor = Color.FromArgb(255, 78, 78, 88);
    private Color _pressedTabColor = Color.FromArgb(255, 42, 42, 48);
    private Color _selectedTabColor = Color.FromArgb(255, 48, 89, 142);
    private Color _tabTextColor = Color.White;

    public event Action<TabPageWidget>? SelectedTabChanged;

    public event Action<TabPageWidget, int, int>? TabReordered;

    public TabControlWidget(RenderSurfaceHostBase renderSurfaceHost,
                            View view,
                            Rectangle bounds,
                            string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.View, ValidateBounds(bounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(view);
 
        _view = view;
        _size = bounds.Size;
 
        InitializeInput();
    }

    public TabControlWidget(RenderSurfaceHostBase renderSurfaceHost,
                            SceneLayer sceneLayer,
                            Rectangle bounds,
                            string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.SceneLayer, ValidateBounds(bounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(sceneLayer);
 
        _sceneLayer = sceneLayer;
        _size = bounds.Size;
 
        InitializeInput();
    }

    public Rectangle Bounds
    {
        get
        {
            Vector2 position = GetPosition();
            return new Rectangle(
                (int)MathF.Round(position.X),
                (int)MathF.Round(position.Y),
                _size.Width,
                _size.Height);
        }
    }

    public Size Size
    {
        get => _size;
        set
        {
            ValidateSize(value);
 
            if (_size == value)
                return;
 
            _size = value;
            Relayout();
        }
    }

    public IReadOnlyList<TabPageWidget> Tabs => _tabs.AsReadOnly();

    public int SelectedIndex => _selectedIndex;

    public TabPageWidget? SelectedTab => _selectedIndex >= 0 && _selectedIndex < _tabs.Count
        ? _tabs[_selectedIndex]
        : null;

    public int TabHeight
    {
        get => _tabHeight;
        set
        {
            if (value < 20)
                throw new ArgumentOutOfRangeException(nameof(value), "The tab height must be at least 20 pixels.");
 
            if (_tabHeight == value)
                return;
 
            _tabHeight = value;
            Relayout();
        }
    }

    public int TabRowCount
    {
        get => _tabRowCount;
        set
        {
            if (value < 1)
                throw new ArgumentOutOfRangeException(nameof(value), "At least one tab row is required.");
 
            if (_tabRowCount == value)
                return;
 
            _tabRowCount = value;
            Relayout();
        }
    }

    public bool AutoExpandRows
    {
        get => _autoExpandRows;
        set
        {
            if (_autoExpandRows == value)
                return;
 
            _autoExpandRows = value;
            Relayout();
        }
    }

    public int PreferredTabWidth
    {
        get => _preferredTabWidth;
        set
        {
            if (value < 48)
                throw new ArgumentOutOfRangeException(nameof(value), "The preferred tab width must be at least 48 pixels.");
 
            if (_preferredTabWidth == value)
                return;
 
            _preferredTabWidth = value;
            Relayout();
        }
    }

    public int DisplayedTabRowCount => _displayedRowCount;

    public int DisplayedTabColumnCount => _displayedColumnCount;

    public bool IsTabReorderingEnabled
    {
        get => _isTabReorderingEnabled;
        set
        {
            if (_isTabReorderingEnabled == value)
                return;
 
            _isTabReorderingEnabled = value;
 
            foreach (TabHeaderWidget header in _headers.Values)
                header.IsDragEnabled = value;
        }
    }

    public float TabReorderDragThresholdPx
    {
        get => _tabReorderDragThresholdPx;
        set
        {
            if (value < 0f)
                throw new ArgumentOutOfRangeException(nameof(value), "The tab reordering threshold cannot be negative.");
 
            if (Math.Abs(_tabReorderDragThresholdPx - value) < float.Epsilon)
                return;
 
            _tabReorderDragThresholdPx = value;
 
            foreach (TabHeaderWidget header in _headers.Values)
                header.DragThresholdPx = value;
        }
    }

    public TabPageWidget AddTab(string title,
                                char? mnemonic = null,
                                string? nickname = null)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ValidateTitle(title);
        ValidateMnemonic(mnemonic);
 
        Rectangle initialHeaderBounds = new(Bounds.Location, new Size(1, TabHeight));
        Rectangle initialContentBounds = new(
            Bounds.Left,
            Bounds.Top + TabHeight,
            Bounds.Width,
            Math.Max(1, Bounds.Height - TabHeight));
 
        TabPageWidget page = Mode == DirectDrawingMode.View
            ? new TabPageWidget(RenderSurfaceHost, _view!, initialContentBounds, title, mnemonic, nickname)
            : new TabPageWidget(RenderSurfaceHost, _sceneLayer!, initialContentBounds, title, mnemonic, nickname);
 
        TabHeaderWidget header = Mode == DirectDrawingMode.View
            ? new TabHeaderWidget(RenderSurfaceHost, _view!, initialHeaderBounds, title, $"{page.Nickname}.header")
            : new TabHeaderWidget(RenderSurfaceHost, _sceneLayer!, initialHeaderBounds, title, $"{page.Nickname}.header");
 
        page.TitleChanged += OnPageTitleChanged;
        page.Disposing += OnPageDisposing;
        header.Invoked += OnHeaderInvoked;
        header.ReorderDragged += OnHeaderDragged;
        header.ReorderDragEnded += OnHeaderDragEnded;
        header.Disposing += OnHeaderDisposing;
        header.IsDragEnabled = IsTabReorderingEnabled;
        header.DragThresholdPx = TabReorderDragThresholdPx;
 
        _tabs.Add(page);
        _headers.Add(page, header);
 
        Add(page, Vector2.Zero);
        Add(header, Vector2.Zero);
 
        if (_selectedIndex < 0)
            _selectedIndex = 0;
 
        Relayout();
        UpdateSelectedTabVisuals();
        UpdatePageVisibility();
 
        return page;
    }

    public bool RemoveTab(TabPageWidget page,
                          bool dispose = false)
    {
        ArgumentNullException.ThrowIfNull(page);
        return RemoveTabCore(page, dispose, raiseSelectionChanged: true);
    }

    public TabControlWidget SelectTab(int index)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
 
        if (index < 0 || index >= _tabs.Count)
            throw new ArgumentOutOfRangeException(nameof(index));
 
        if (_selectedIndex == index)
            return this;
 
        _selectedIndex = index;
        UpdateSelectedTabVisuals();
        UpdatePageVisibility();
 
        SelectedTabChanged?.Invoke(_tabs[index]);
        return this;
    }

    public TabControlWidget SelectTab(TabPageWidget page)
    {
        ArgumentNullException.ThrowIfNull(page);
 
        int index = _tabs.IndexOf(page);
        if (index < 0)
            throw new ArgumentException("The page is not owned by this tab control.", nameof(page));
 
        return SelectTab(index);
    }

    public TabControlWidget MoveTab(int fromIndex,
                                    int toIndex)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
 
        if (fromIndex < 0 || fromIndex >= _tabs.Count)
            throw new ArgumentOutOfRangeException(nameof(fromIndex));
 
        if (toIndex < 0 || toIndex >= _tabs.Count)
            throw new ArgumentOutOfRangeException(nameof(toIndex));
 
        if (fromIndex == toIndex)
            return this;
 
        TabPageWidget page = _tabs[fromIndex];
        TabPageWidget? selectedPage = SelectedTab;
 
        _tabs.RemoveAt(fromIndex);
        _tabs.Insert(toIndex, page);
        _selectedIndex = selectedPage is null ? -1 : _tabs.IndexOf(selectedPage);
 
        Relayout();
        TabReordered?.Invoke(page, fromIndex, toIndex);
 
        return this;
    }

    public TabControlWidget MoveTab(TabPageWidget page,
                                    int toIndex)
    {
        ArgumentNullException.ThrowIfNull(page);
 
        int fromIndex = _tabs.IndexOf(page);
        if (fromIndex < 0)
            throw new ArgumentException("The page is not owned by this tab control.", nameof(page));
 
        return MoveTab(fromIndex, toIndex);
    }

    public TabControlWidget Relayout()
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
 
        Rectangle bounds = Bounds;
        (_displayedRowCount, _displayedColumnCount) = ResolveGrid(bounds);
        Rectangle contentBounds = CreateContentBounds(bounds, _displayedRowCount);
 
        for (int index = 0; index < _tabs.Count; index++)
        {
            TabPageWidget page = _tabs[index];
            TabHeaderWidget header = _headers[page];
            Rectangle headerBounds = CreateHeaderBounds(bounds, index, _displayedColumnCount);
 
            header.SetBounds(headerBounds);
            page.HeaderBounds = headerBounds;
            page.SetContentBounds(contentBounds);
 
            SetLocalOffset(header, new Vector2(headerBounds.Left - bounds.Left, headerBounds.Top - bounds.Top));
            SetLocalOffset(page, new Vector2(contentBounds.Left - bounds.Left, contentBounds.Top - bounds.Top));
        }
 
        ApplyZOrder();
        return this;
    }

    public TabControlWidget SetTabColors(Color normal,
                                         Color hover,
                                         Color pressed,
                                         Color selected)
    {
        _normalTabColor = normal;
        _hoverTabColor = hover;
        _pressedTabColor = pressed;
        _selectedTabColor = selected;
        UpdateSelectedTabVisuals();
 
        return this;
    }

    public TabControlWidget SetTabTextColor(Color color)
    {
        _tabTextColor = color;
 
        foreach (TabHeaderWidget header in _headers.Values)
            header.SetTextColor(color);
 
        return this;
    }

    public TabControlWidget SetTabControlZOrder(int zOrder)
    {
        _baseZOrder = zOrder;
        ApplyZOrder();
 
        return this;
    }

    public override void Dispose()
    {
        if (_disposed)
            return;
 
        _disposed = true;
 
        foreach (TabPageWidget page in _tabs)
        {
            page.TitleChanged -= OnPageTitleChanged;
            page.Disposing -= OnPageDisposing;
 
            TabHeaderWidget header = _headers[page];
            header.Invoked -= OnHeaderInvoked;
            header.ReorderDragged -= OnHeaderDragged;
            header.ReorderDragEnded -= OnHeaderDragEnded;
            header.Disposing -= OnHeaderDisposing;
        }
 
        base.Dispose();
 
        _tabs.Clear();
        _headers.Clear();
        SelectedTabChanged = null;
        TabReordered = null;
    }

    protected override void ProcessShown()
    {
        base.ProcessShown();
        _isShown = true;
        UpdatePageVisibility();
    }

    protected override void ProcessHidden()
    {
        _isShown = false;
        base.ProcessHidden();
    }

    protected override void ProcessActivated()
    {
        base.ProcessActivated();
 
        SelectedTab?.Activate();
    }

    protected override void OnKeyboardInput(WidgetKeyboardEventArgs args)
    {
        base.OnKeyboardInput(args);
        HandleKeyboardInput(args);
    }

    void IWidgetKeyboardFallback.HandleUnhandledKeyboardInput(WidgetKeyboardEventArgs args)
    {
        HandleKeyboardInput(args);
    }
 
    private void InitializeInput()
    {
        IsPointerInputEnabled = false;
        IsKeyboardInputEnabled = true;
        CanReceiveFocus = false;
    }
 
    private bool RemoveTabCore(TabPageWidget page,
                               bool dispose,
                               bool raiseSelectionChanged)
    {
        int removedIndex = _tabs.IndexOf(page);
        if (removedIndex < 0)
            return false;
 
        TabPageWidget? previouslySelected = SelectedTab;
        TabHeaderWidget header = _headers[page];
 
        page.TitleChanged -= OnPageTitleChanged;
        page.Disposing -= OnPageDisposing;
        header.Invoked -= OnHeaderInvoked;
        header.ReorderDragged -= OnHeaderDragged;
        header.ReorderDragEnded -= OnHeaderDragEnded;
        header.Disposing -= OnHeaderDisposing;
 
        _tabs.RemoveAt(removedIndex);
        _headers.Remove(page);
 
        Remove(header);
        Remove(page);
 
        header.Dispose();
 
        if (dispose)
            page.Dispose();
 
        if (_tabs.Count == 0)
        {
            _selectedIndex = -1;
        }
        else if (ReferenceEquals(previouslySelected, page))
        {
            _selectedIndex = Math.Min(removedIndex, _tabs.Count - 1);
        }
        else
        {
            _selectedIndex = previouslySelected is null ? 0 : _tabs.IndexOf(previouslySelected);
        }
 
        Relayout();
        UpdateSelectedTabVisuals();
        UpdatePageVisibility();
 
        if (raiseSelectionChanged && SelectedTab is not null && !ReferenceEquals(previouslySelected, SelectedTab))
            SelectedTabChanged?.Invoke(SelectedTab);
 
        return true;
    }
 
    private void OnPageTitleChanged(TabPageWidget page)
    {
        if (_headers.TryGetValue(page, out TabHeaderWidget? header))
            header.SetText(page.Title);
    }
 
    private void OnPageDisposing(object? sender,
                                 IDirectDrawable _)
    {
        if (!_disposed && sender is TabPageWidget page)
            RemoveTabCore(page, dispose: true, raiseSelectionChanged: true);
    }
 
    private void OnHeaderDisposing(object? sender,
                                   IDirectDrawable _)
    {
        if (_disposed || sender is not TabHeaderWidget header)
            return;
 
        TabPageWidget? page = _headers.FirstOrDefault(pair => ReferenceEquals(pair.Value, header)).Key;
        if (page is not null)
            RemoveTabCore(page, dispose: true, raiseSelectionChanged: true);
    }
 
    private void OnHeaderInvoked(TabHeaderWidget header)
    {
        TabPageWidget? page = _headers.FirstOrDefault(pair => ReferenceEquals(pair.Value, header)).Key;
        if (page is not null)
            SelectTab(page);
    }
 
    private void OnHeaderDragged(TabHeaderWidget header,
                                 WidgetDragEventArgs args,
                                 View view)
    {
        if (!IsTabReorderingEnabled)
            return;
 
        TabPageWidget? page = _headers.FirstOrDefault(pair => ReferenceEquals(pair.Value, header)).Key;
        if (page is null)
            return;
 
        int fromIndex = _tabs.IndexOf(page);
        int targetIndex = GetHeaderIndexAt(args.CurrentScreenPositionPx, view);
 
        if (targetIndex >= 0 && targetIndex != fromIndex)
            MoveTab(fromIndex, targetIndex);
    }
 
    private void OnHeaderDragEnded(TabHeaderWidget _)
    {
        Relayout();
    }
 
    private int GetHeaderIndexAt(PointF screenPositionPx,
                                 View view)
    {
        Point screenPosition = Point.Round(screenPositionPx);
 
        for (int index = 0; index < _tabs.Count; index++)
        {
            TabHeaderWidget header = _headers[_tabs[index]];
            if (header.HitTest(view, screenPosition))
            {
                return index;
            }
        }
 
        return -1;
    }
 
    private void HandleKeyboardInput(WidgetKeyboardEventArgs args)
    {
        if (args.Handled || args.KeyAction != KeyAction.Pressed || args.Modifiers != KeyboardModifierState.Alt)
            return;
 
        for (int index = 0; index < _tabs.Count; index++)
        {
            if (!MatchesMnemonic(_tabs[index].Mnemonic, args.Key))
                continue;
 
            args.Handled = true;
            SelectTab(index);
            return;
        }
    }
 
    private void UpdateSelectedTabVisuals()
    {
        for (int index = 0; index < _tabs.Count; index++)
        {
            TabHeaderWidget header = _headers[_tabs[index]];
            bool selected = index == _selectedIndex;
 
            header.SetColors(
                selected ? _selectedTabColor : _normalTabColor,
                selected ? _selectedTabColor : _hoverTabColor,
                selected ? _selectedTabColor : _pressedTabColor);
            header.SetTextColor(_tabTextColor);
        }
    }
 
    private void UpdatePageVisibility()
    {
        for (int index = 0; index < _tabs.Count; index++)
        {
            TabPageWidget page = _tabs[index];
            bool isSelected = index == _selectedIndex;
 
            if (_isShown && isSelected)
            {
                page.Show();
                page.Activate();
            }
            else if (!isSelected || _isShown)
            {
                page.Hide();
            }
        }
    }
 
    private void ApplyZOrder()
    {
        foreach (TabPageWidget page in _tabs)
        {
            page.SetPageZOrder(_baseZOrder);
            _headers[page].SetHeaderZOrder(_baseZOrder + 100);
        }
    }
 
    private (int Rows, int Columns) ResolveGrid(Rectangle bounds)
    {
        if (!AutoExpandRows)
        {
            int columns = Math.Max(1, (int)Math.Ceiling(_tabs.Count / (double)TabRowCount));
            return (TabRowCount, columns);
        }
 
        int autoColumns = _tabs.Count == 0
            ? 1
            : Math.Min(_tabs.Count, Math.Max(1, bounds.Width / PreferredTabWidth));
        int autoRows = Math.Max(1, (int)Math.Ceiling(_tabs.Count / (double)autoColumns));
 
        return (autoRows, autoColumns);
    }
 
    private Rectangle CreateHeaderBounds(Rectangle bounds,
                                         int index,
                                         int columns)
    {
        int row = index / columns;
        int column = index % columns;
        int left = bounds.Left + column * bounds.Width / columns;
        int right = bounds.Left + (column + 1) * bounds.Width / columns;
 
        return Rectangle.FromLTRB(
            left,
            bounds.Top + row * TabHeight,
            right,
            bounds.Top + (row + 1) * TabHeight);
    }
 
    private Rectangle CreateContentBounds(Rectangle bounds,
                                          int rowCount)
    {
        int contentTop = bounds.Top + rowCount * TabHeight;
 
        return new Rectangle(
            bounds.Left,
            contentTop,
            bounds.Width,
            Math.Max(1, bounds.Bottom - contentTop));
    }
 
    private static Rectangle ValidateBounds(Rectangle bounds)
    {
        ValidateSize(bounds.Size);
        return bounds;
    }
 
    private static void ValidateSize(Size size)
    {
        if (size.Width <= 0 || size.Height <= DefaultTabHeight)
        {
            throw new ArgumentOutOfRangeException(
                nameof(size),
                size,
                "Tab-control bounds must be positive and taller than one tab row.");
        }
    }
 
    private void ValidateMnemonic(char? mnemonic)
    {
        if (mnemonic is not char value)
            return;
 
        if (_tabs.Any(tab => tab.Mnemonic is char existing &&
                             char.ToUpperInvariant(existing) == char.ToUpperInvariant(value)))
        {
            throw new ArgumentException($"Duplicate tab mnemonic '{value}'.", nameof(mnemonic));
        }
    }
 
    private static void ValidateTitle(string title)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(title);
    }
 
    private static bool MatchesMnemonic(char? mnemonic,
                                        int key)
    {
        return mnemonic is char character &&
               key >= 0 &&
               key <= char.MaxValue &&
               char.ToUpperInvariant(character) == char.ToUpperInvariant((char)key);
    }
 
    private sealed class TabHeaderWidget : DraggableWidgetBase
    {
        private Color _normalColor = Color.FromArgb(255, 60, 60, 68);
        private Color _hoverColor = Color.FromArgb(255, 78, 78, 88);
        private Color _pressedColor = Color.FromArgb(255, 42, 42, 48);

        internal event Action<TabHeaderWidget>? Invoked;

        internal event Action<TabHeaderWidget, WidgetDragEventArgs, View>? ReorderDragged;

        internal event Action<TabHeaderWidget>? ReorderDragEnded;
 
        private View? _dragView;
        private bool _disposed;

        internal TabHeaderWidget(RenderSurfaceHostBase renderSurfaceHost,
                                 View view,
                                 Rectangle bounds,
                                 string text,
                                 string nickname)
            : base(renderSurfaceHost, DirectDrawingMode.View, bounds.Location, nickname)
        {
            ArgumentNullException.ThrowIfNull(view);
 
            Background = CreateBackground(renderSurfaceHost, view, bounds, nickname);
            Label = CreateLabel(renderSurfaceHost, view, bounds, text);
            CompleteInitialization();
        }

        internal TabHeaderWidget(RenderSurfaceHostBase renderSurfaceHost,
                                 SceneLayer sceneLayer,
                                 Rectangle bounds,
                                 string text,
                                 string nickname)
            : base(renderSurfaceHost, DirectDrawingMode.SceneLayer, bounds.Location, nickname)
        {
            ArgumentNullException.ThrowIfNull(sceneLayer);
 
            Background = CreateBackground(renderSurfaceHost, sceneLayer, bounds, nickname);
            Label = CreateLabel(renderSurfaceHost, sceneLayer, bounds, text);
            CompleteInitialization();
        }

        internal DirectRectangle Background { get; }

        internal TextBlock Label { get; }

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

        internal void SetBounds(Rectangle bounds)
        {
            if (bounds.Width <= 0 || bounds.Height <= 0)
                throw new ArgumentOutOfRangeException(nameof(bounds));
 
            if (Mode == DirectDrawingMode.View)
            {
                Background.ScreenBounds = bounds;
                Label.ScreenBounds = bounds;
            }
            else
            {
                Background.WorldBounds = bounds;
                Label.WorldBounds = bounds;
            }
 
            SetPosition(bounds.Location.X, bounds.Location.Y);
        }

        internal void SetText(string text)
        {
            Label.SetText(text);
        }

        internal void SetColors(Color normal,
                                Color hover,
                                Color pressed)
        {
            _normalColor = normal;
            _hoverColor = hover;
            _pressedColor = pressed;
            UpdateBackgroundColor(normal);
        }

        internal void SetTextColor(Color color)
        {
            Label.SetColors(color, Color.Transparent);
        }

        internal void SetHeaderZOrder(int zOrder)
        {
            Background.ZOrder = zOrder;
            Label.ZOrder = zOrder + 1;
        }

        protected override Vector2 ConvertScreenDeltaToPositionDelta(Vector2 totalScreenDeltaPx,
                                                                       View view)
        {
            return Vector2.Zero;
        }

        protected override void OnPointerEnter(WidgetPointerEventArgs args)
        {
            base.OnPointerEnter(args);
            UpdateBackgroundColor(_hoverColor);
        }

        protected override void OnPointerLeave(WidgetPointerEventArgs args)
        {
            base.OnPointerLeave(args);
            UpdateBackgroundColor(_normalColor);
        }

        protected override void OnPointerDown(WidgetPointerEventArgs args)
        {
            base.OnPointerDown(args);
 
            if (args.IsPrimaryButton)
            {
                _dragView = args.View;
                UpdateBackgroundColor(_pressedColor);
            }
        }

        protected override void OnPointerUp(WidgetPointerEventArgs args)
        {
            base.OnPointerUp(args);
            UpdateBackgroundColor(_hoverColor);
        }

        protected override void OnPointerClick(WidgetPointerEventArgs args)
        {
            base.OnPointerClick(args);
 
            if (!args.IsPrimaryButton)
                return;
 
            args.Handled = true;
            Invoked?.Invoke(this);
        }

        protected override void OnKeyboardInput(WidgetKeyboardEventArgs args)
        {
            base.OnKeyboardInput(args);
 
            if (args.KeyAction != KeyAction.Pressed || args.Key is not 13 and not 32)
                return;
 
            args.Handled = true;
            Invoked?.Invoke(this);
        }

        protected override void OnDragged(WidgetDragEventArgs args)
        {
            base.OnDragged(args);
            if (_dragView is not null)
                ReorderDragged?.Invoke(this, args, _dragView);
        }

        protected override void OnDragEnded(WidgetDragEventArgs args)
        {
            base.OnDragEnded(args);
            ReorderDragEnded?.Invoke(this);
            _dragView = null;
        }

        public override void Dispose()
        {
            if (_disposed)
                return;
 
            _disposed = true;
            base.Dispose();
            Invoked = null;
            ReorderDragged = null;
            ReorderDragEnded = null;
        }
 
        private void CompleteInitialization()
        {
            Add(Background);
            Add(Label);
 
            SetHeaderZOrder(0);
            CanReceiveFocus = true;
            IsKeyboardInputEnabled = true;
            IsDragEnabled = false;
        }
 
        private void UpdateBackgroundColor(Color color)
        {
            Background.SetColor(color);
            Background.SetPosition(Background.GetPosition());
        }
 
        private static DirectRectangle CreateBackground(RenderSurfaceHostBase renderSurfaceHost,
                                                        View view,
                                                        Rectangle bounds,
                                                        string nickname)
        {
            return new DirectRectangle(Color.FromArgb(255, 60, 60, 68),
                                       renderSurfaceHost,
                                       view,
                                       bounds,
                                       $"{nickname}.background")
                .SetFilled(true)
                .SetBorderColor(Color.FromArgb(255, 150, 150, 160))
                .SetStrokeWidth(1.5f)
                .SetCornerRadius(5f);
        }
 
        private static DirectRectangle CreateBackground(RenderSurfaceHostBase renderSurfaceHost,
                                                        SceneLayer sceneLayer,
                                                        Rectangle bounds,
                                                        string nickname)
        {
            return new DirectRectangle(Color.FromArgb(255, 60, 60, 68),
                                       renderSurfaceHost,
                                       sceneLayer,
                                       bounds,
                                       $"{nickname}.background")
                .SetFilled(true)
                .SetBorderColor(Color.FromArgb(255, 150, 150, 160))
                .SetStrokeWidth(1.5f)
                .SetCornerRadius(5f);
        }
 
        private static TextBlock CreateLabel(RenderSurfaceHostBase renderSurfaceHost,
                                             View view,
                                             Rectangle bounds,
                                             string text)
        {
            return new TextBlock(renderSurfaceHost, view, bounds)
                .SetText(text)
                .SetFont(SKTypeface.Default, 16f, minSize: 10f)
                .SetColors(SKColors.White, SKColors.Transparent)
                .SetAlignment(SKTextAlign.Center, TextBlock.VerticalAlign.Center)
                .EnableWrapping(false);
        }
 
        private static TextBlock CreateLabel(RenderSurfaceHostBase renderSurfaceHost,
                                             SceneLayer sceneLayer,
                                             Rectangle bounds,
                                             string text)
        {
            return new TextBlock(renderSurfaceHost, sceneLayer, view: null, worldBounds: bounds)
                .SetText(text)
                .SetFont(SKTypeface.Default, 16f, minSize: 10f)
                .SetColors(SKColors.White, SKColors.Transparent)
                .SetAlignment(SKTextAlign.Center, TextBlock.VerticalAlign.Center)
                .EnableWrapping(false);
        }
    }
}