ListBoxWidget.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 ListBoxWidget : WidgetBase
{
    private const int ContentPadding = 2;
    private const int DefaultItemHeight = 24;
    private const int ScrollBarWidth = 12;
    private const int ScrollBarMargin = 3;
    private const int MinimumScrollBarThumbHeight = 18;
 
    private readonly List<string> _items = [];
    private readonly List<TextBlock> _rowTextBlocks = [];
 
    private int _selectedIndex = -1;
    private int _topIndex;
    private int _itemHeight = DefaultItemHeight;
    private int _baseZOrder;
    private int _mouseWheelScrollItems = 3;
    private ScrollBarVisibility _verticalScrollBarVisibility = ScrollBarVisibility.Auto;
    private bool _isDraggingScrollBarThumb;
    private float _scrollBarDragOffset;
    private int? _scrollBarPointerId;
    private bool _suppressScrollBarClick;

    public event Action<int>? SelectedIndexChanged;

    public event Action<int>? SelectionCommitted;

    public ListBoxWidget(RenderSurfaceHostBase renderSurfaceHost,
                         View view,
                         Rectangle bounds,
                         IEnumerable<string>? items = null,
                         string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.View, ValidateBounds(bounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(view);
 
        Background = CreateBackground(renderSurfaceHost, view, bounds);
        SelectionHighlight = CreateSelectionHighlight(renderSurfaceHost, view, GetInitialSelectionBounds(bounds));
        VerticalScrollBarTrack = CreateScrollBarTrack(renderSurfaceHost, view, bounds);
        VerticalScrollBarThumb = CreateScrollBarThumb(renderSurfaceHost, view, bounds);
 
        Add(Background);
        Add(SelectionHighlight);
        Add(VerticalScrollBarTrack);
        Add(VerticalScrollBarThumb);
 
        CompleteInitialization(items);
    }

    public ListBoxWidget(RenderSurfaceHostBase renderSurfaceHost,
                         SceneLayer sceneLayer,
                         Rectangle bounds,
                         IEnumerable<string>? items = null,
                         string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.SceneLayer, ValidateBounds(bounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(sceneLayer);
 
        Background = CreateBackground(renderSurfaceHost, sceneLayer, bounds);
        SelectionHighlight = CreateSelectionHighlight(renderSurfaceHost, sceneLayer, GetInitialSelectionBounds(bounds));
        VerticalScrollBarTrack = CreateScrollBarTrack(renderSurfaceHost, sceneLayer, bounds);
        VerticalScrollBarThumb = CreateScrollBarThumb(renderSurfaceHost, sceneLayer, bounds);
 
        Add(Background);
        Add(SelectionHighlight);
        Add(VerticalScrollBarTrack);
        Add(VerticalScrollBarThumb);
 
        CompleteInitialization(items);
    }

    public DirectRectangle Background { get; }

    public DirectRectangle SelectionHighlight { get; }

    public DirectRectangle VerticalScrollBarTrack { get; }

    public DirectRectangle VerticalScrollBarThumb { get; }

    public IReadOnlyList<string> Items => _items;

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

    public int ItemHeight
    {
        get => _itemHeight;
        set
        {
            if (value < 12)
                throw new ArgumentOutOfRangeException(nameof(value), "Item height must be at least 12 pixels.");
 
            if (_itemHeight == value)
                return;
 
            _itemHeight = value;
            ClampTopIndex();
            EnsureSelectionVisible();
            RefreshRows();
        }
    }

    public int VisibleItemCount => Math.Max(1, (Bounds.Height - ContentPadding * 2) / ItemHeight);

    public ScrollBarVisibility VerticalScrollBarVisibility
    {
        get => _verticalScrollBarVisibility;
        set
        {
            if (!Enum.IsDefined(value))
                throw new ArgumentOutOfRangeException(nameof(value));
 
            if (_verticalScrollBarVisibility == value)
                return;
 
            _verticalScrollBarVisibility = value;
            RefreshRows();
        }
    }

    public bool IsVerticalScrollBarVisible => Visible && NeedsVerticalScrollBar;
 
    private bool NeedsVerticalScrollBar => VerticalScrollBarVisibility != ScrollBarVisibility.Never
        && (VerticalScrollBarVisibility == ScrollBarVisibility.Always || _items.Count > VisibleItemCount);

    public int MouseWheelScrollItems
    {
        get => _mouseWheelScrollItems;
        set => _mouseWheelScrollItems = value > 0
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value), "Mouse-wheel scrolling must advance at least one item.");
    }

    public int VerticalScrollBarMinimumThumbHeight => MinimumScrollBarThumbHeight;

    public int TopIndex
    {
        get => _topIndex;
        set
        {
            int clamped = Math.Clamp(value, 0, GetMaximumTopIndex());
            if (_topIndex == clamped)
                return;
 
            _topIndex = clamped;
            RefreshRows();
        }
    }

    public int SelectedIndex
    {
        get => _selectedIndex;
        set => SetSelectedIndex(value);
    }

    public string? SelectedItem => _selectedIndex >= 0 && _selectedIndex < _items.Count
        ? _items[_selectedIndex]
        : null;

    public ListBoxWidget SetItems(IEnumerable<string> items)
    {
        ArgumentNullException.ThrowIfNull(items);
 
        bool hadSelection = _selectedIndex >= 0;
        string[] replacement = items.Select(static item => item ?? string.Empty).ToArray();
        _items.Clear();
        _items.AddRange(replacement);
        _selectedIndex = -1;
        _topIndex = 0;
        RefreshRows();
 
        if (hadSelection)
            SelectedIndexChanged?.Invoke(-1);
 
        return this;
    }

    public ListBoxWidget AddItem(string item)
    {
        _items.Add(item ?? string.Empty);
        ClampTopIndex();
        RefreshRows();
        return this;
    }

    public ListBoxWidget RemoveAt(int index)
    {
        if (index < 0 || index >= _items.Count)
            throw new ArgumentOutOfRangeException(nameof(index));
 
        int oldSelectedIndex = _selectedIndex;
        bool selectedItemWasRemoved = index == oldSelectedIndex;
 
        _items.RemoveAt(index);
 
        if (_items.Count == 0)
        {
            _selectedIndex = -1;
        }
        else if (index < oldSelectedIndex)
        {
            _selectedIndex = oldSelectedIndex - 1;
        }
        else if (selectedItemWasRemoved)
        {
            _selectedIndex = Math.Min(index, _items.Count - 1);
        }
 
        ClampTopIndex();
        EnsureSelectionVisible();
        RefreshRows();
 
        if (_selectedIndex != oldSelectedIndex || selectedItemWasRemoved)
            SelectedIndexChanged?.Invoke(_selectedIndex);
 
        return this;
    }

    public ListBoxWidget ClearItems()
    {
        bool hadSelection = _selectedIndex >= 0;
        _items.Clear();
        _selectedIndex = -1;
        _topIndex = 0;
        RefreshRows();
 
        if (hadSelection)
            SelectedIndexChanged?.Invoke(-1);
 
        return this;
    }

    public ListBoxWidget SetSelectedIndex(int index)
    {
        if (index < -1 || index >= _items.Count)
            throw new ArgumentOutOfRangeException(nameof(index));
 
        if (_selectedIndex == index)
        {
            EnsureSelectionVisible();
            return this;
        }
 
        _selectedIndex = index;
        EnsureSelectionVisible();
        RefreshSelectionHighlight();
        SelectedIndexChanged?.Invoke(index);
        return this;
    }

    public ListBoxWidget SelectNext()
    {
        if (_items.Count == 0)
            return this;
 
        int next = _selectedIndex < 0 ? 0 : Math.Min(_selectedIndex + 1, _items.Count - 1);
        return SetSelectedIndex(next);
    }

    public ListBoxWidget SelectPrevious()
    {
        if (_items.Count == 0)
            return this;
 
        int previous = _selectedIndex < 0 ? 0 : Math.Max(_selectedIndex - 1, 0);
        return SetSelectedIndex(previous);
    }

    public ListBoxWidget SetListBoxZOrder(int zOrder)
    {
        _baseZOrder = zOrder;
        Background.ZOrder = zOrder;
        SelectionHighlight.ZOrder = zOrder + 1;
 
        foreach (TextBlock row in _rowTextBlocks)
            row.ZOrder = zOrder + 2;
 
        VerticalScrollBarTrack.ZOrder = zOrder + 3;
        VerticalScrollBarThumb.ZOrder = zOrder + 4;
 
        return this;
    }

    public ListBoxWidget SetSelectionColor(Color color)
    {
        SelectionHighlight.SetColor(color);
        Refresh(SelectionHighlight);
        return this;
    }

    protected override void ProcessShown()
    {
        base.ProcessShown();
        RefreshScrollBar();
        RefreshSelectionHighlight();
    }

    protected override void ProcessHidden()
    {
        _isDraggingScrollBarThumb = false;
        _scrollBarPointerId = null;
        _suppressScrollBarClick = false;
        base.ProcessHidden();
    }

    protected override void OnPointerClick(WidgetPointerEventArgs args)
    {
        base.OnPointerClick(args);
 
        if (!args.IsPrimaryButton || _items.Count == 0)
            return;
 
        if (_suppressScrollBarClick || IsPointerOverScrollBar(args))
        {
            _suppressScrollBarClick = false;
            args.Handled = true;
            return;
        }
 
        RectangleF screenBounds = Background.GetDrawLocationScreen(args.View);
        screenBounds.Offset(args.WrappedOffsetWorldPx.X * args.View.Viewport.Zoom, args.WrappedOffsetWorldPx.Y * args.View.Viewport.Zoom);
        if (screenBounds.Height <= 0f || Bounds.Height <= 0)
            return;
 
        float scaleY = screenBounds.Height / Bounds.Height;
        float localY = args.ScreenPositionPx.Y - screenBounds.Top - ContentPadding * scaleY;
        float rowHeightScreen = ItemHeight * scaleY;
 
        if (localY < 0f || rowHeightScreen <= 0f)
            return;
 
        int row = (int)(localY / rowHeightScreen);
        int index = TopIndex + row;
 
        if (row < 0 || row >= VisibleItemCount || index >= _items.Count)
            return;
 
        args.Handled = true;
        SetSelectedIndex(index);
        SelectionCommitted?.Invoke(index);
    }

    protected override void OnPointerDown(WidgetPointerEventArgs args)
    {
        base.OnPointerDown(args);
 
        if (_scrollBarPointerId.HasValue)
            return;
 
        _suppressScrollBarClick = false;
 
        if (!args.IsPrimaryButton || !IsVerticalScrollBarVisible)
            return;
 
        PointF local = GetLocalPointerPosition(args);
        Rectangle thumbBounds = GetScrollBarThumbBounds(Bounds);
        Rectangle trackBounds = GetScrollBarTrackBounds(Bounds);
 
        if (!trackBounds.Contains(Point.Round(local)))
            return;
 
        args.Handled = true;
        _scrollBarPointerId = args.PointerId;
        _suppressScrollBarClick = true;
        if (thumbBounds.Contains(Point.Round(local)))
        {
            _isDraggingScrollBarThumb = true;
            _scrollBarDragOffset = local.Y - thumbBounds.Top;
            return;
        }
 
        TopIndex += local.Y < thumbBounds.Top ? -VisibleItemCount : VisibleItemCount;
    }

    protected override void OnPointerMove(WidgetPointerEventArgs args)
    {
        base.OnPointerMove(args);
 
        if (!_isDraggingScrollBarThumb || _scrollBarPointerId != args.PointerId || !IsVerticalScrollBarVisible)
            return;
 
        Rectangle trackBounds = GetScrollBarTrackBounds(Bounds);
        Rectangle thumbBounds = GetScrollBarThumbBounds(Bounds);
        float travel = trackBounds.Height - thumbBounds.Height;
 
        if (travel <= 0f || GetMaximumTopIndex() == 0)
            return;
 
        float desiredTop = GetLocalPointerPosition(args).Y - _scrollBarDragOffset;
        float fraction = Math.Clamp((desiredTop - trackBounds.Top) / travel, 0f, 1f);
        TopIndex = (int)MathF.Round(fraction * GetMaximumTopIndex());
        args.Handled = true;
    }

    protected override void OnPointerUp(WidgetPointerEventArgs args)
    {
        base.OnPointerUp(args);
 
        if (_scrollBarPointerId == args.PointerId)
        {
            _isDraggingScrollBarThumb = false;
            _scrollBarPointerId = null;
            args.Handled = true;
        }
    }

    protected override void OnMouseWheel(WidgetMouseWheelEventArgs args)
    {
        base.OnMouseWheel(args);
 
        if (args.Delta == 0 || GetMaximumTopIndex() == 0)
            return;
 
        long notches = Math.Max(1, Math.Abs((long)args.Delta) / 120);
        long change = notches * MouseWheelScrollItems * (args.Delta > 0 ? -1 : 1);
        TopIndex = (int)Math.Clamp(TopIndex + change, 0, GetMaximumTopIndex());
        args.Handled = true;
    }

    protected override void OnKeyboardInput(WidgetKeyboardEventArgs args)
    {
        base.OnKeyboardInput(args);
 
        if (_items.Count == 0)
            return;
 
        if (args.Key == 13)
        {
            if (args.KeyAction != KeyAction.Pressed || _selectedIndex < 0)
                return;
 
            args.Handled = true;
            SelectionCommitted?.Invoke(_selectedIndex);
            return;
        }
 
        if (args.KeyAction is not KeyAction.Pressed and not KeyAction.Repeated)
            return;
 
        switch (args.Key)
        {
            case 38: // Up
                SelectPrevious();
                break;
            case 40: // Down
                SelectNext();
                break;
            case 36: // Home
                SetSelectedIndex(0);
                break;
            case 35: // End
                SetSelectedIndex(_items.Count - 1);
                break;
            case 33: // Page Up
                SetSelectedIndex(Math.Max(0, (_selectedIndex < 0 ? 0 : _selectedIndex) - VisibleItemCount));
                break;
            case 34: // Page Down
                SetSelectedIndex(Math.Min(_items.Count - 1, (_selectedIndex < 0 ? 0 : _selectedIndex) + VisibleItemCount));
                break;
            default:
                return;
        }
 
        args.Handled = true;
    }
 
    private void CompleteInitialization(IEnumerable<string>? items)
    {
        SelectionHighlight.Visible = false;
        VerticalScrollBarTrack.Visible = false;
        VerticalScrollBarThumb.Visible = false;
        CanReceiveFocus = true;
        IsKeyboardInputEnabled = true;
        SetListBoxZOrder(0);
 
        if (items is not null)
            _items.AddRange(items.Select(static item => item ?? string.Empty));
 
        RefreshRows();
    }
 
    private void EnsureSelectionVisible()
    {
        if (_selectedIndex < 0)
            return;
 
        if (_selectedIndex < _topIndex)
        {
            _topIndex = _selectedIndex;
            RefreshRows();
            return;
        }
 
        int lastVisible = _topIndex + VisibleItemCount - 1;
        if (_selectedIndex > lastVisible)
        {
            _topIndex = Math.Min(GetMaximumTopIndex(), _selectedIndex - VisibleItemCount + 1);
            RefreshRows();
        }
    }
 
    private void ClampTopIndex()
    {
        _topIndex = Math.Clamp(_topIndex, 0, GetMaximumTopIndex());
    }
 
    private int GetMaximumTopIndex()
    {
        return Math.Max(0, _items.Count - VisibleItemCount);
    }
 
    private void RefreshRows()
    {
        bool wasVisible = Visible;
 
        RefreshScrollBar();
 
        foreach (TextBlock row in _rowTextBlocks)
        {
            Remove(row);
            row.Dispose();
        }
 
        _rowTextBlocks.Clear();
 
        Rectangle bounds = Bounds;
        int count = Math.Min(VisibleItemCount, Math.Max(0, _items.Count - TopIndex));
 
        for (int rowIndex = 0; rowIndex < count; rowIndex++)
        {
            int itemIndex = TopIndex + rowIndex;
            Rectangle rowBounds = GetRowBounds(bounds, rowIndex);
            TextBlock row = CreateRowText(rowBounds, _items[itemIndex]);
            row.ZOrder = _baseZOrder + 2;
            Add(row);
            _rowTextBlocks.Add(row);
        }
 
        RefreshSelectionHighlight();
 
        if (!wasVisible)
            SetIsVisible(false);
    }
 
    private TextBlock CreateRowText(Rectangle bounds, string text)
    {
        TextBlock row = Mode == DirectDrawingMode.View
            ? new TextBlock(RenderSurfaceHost, View!, bounds)
            : new TextBlock(RenderSurfaceHost, SceneLayer!, view: null, worldBounds: bounds);
 
        return row.SetText(text)
                  .SetFont(SKTypeface.Default, 15f, minSize: 9f)
                  .SetColors(SKColors.White, SKColors.Transparent)
                  .SetAlignment(SKTextAlign.Left, TextBlock.VerticalAlign.Center)
                  .SetPadding(6f, 0f)
                  .EnableWrapping(false);
    }
 
    private void RefreshSelectionHighlight()
    {
        if (!Visible || _selectedIndex < TopIndex || _selectedIndex >= TopIndex + VisibleItemCount || _selectedIndex >= _items.Count)
        {
            SelectionHighlight.Visible = false;
            return;
        }
 
        int rowIndex = _selectedIndex - TopIndex;
        Rectangle selectionBounds = GetRowBounds(Bounds, rowIndex);
        Rectangle currentBounds = Mode == DirectDrawingMode.View
            ? SelectionHighlight.ScreenBounds
            : SelectionHighlight.WorldBounds;
        Rectangle resizedBounds = new(currentBounds.Location, selectionBounds.Size);
 
        if (Mode == DirectDrawingMode.View)
            SelectionHighlight.ScreenBounds = resizedBounds;
        else
            SelectionHighlight.WorldBounds = resizedBounds;
 
        SetLocalOffset(
            SelectionHighlight,
            new Vector2(ContentPadding, ContentPadding + rowIndex * ItemHeight));
 
        SelectionHighlight.Visible = true;
    }
 
    private Rectangle GetRowBounds(Rectangle bounds, int rowIndex)
    {
        int y = bounds.Y + ContentPadding + rowIndex * ItemHeight;
        return new Rectangle(bounds.X + ContentPadding,
                             y,
                             Math.Max(1, bounds.Width - ContentPadding * 2 - (NeedsVerticalScrollBar ? ScrollBarWidth + ScrollBarMargin * 2 : 0)),
                             Math.Min(ItemHeight, Math.Max(1, bounds.Bottom - ContentPadding - y)));
    }
 
    private void RefreshScrollBar()
    {
        bool visible = IsVerticalScrollBarVisible;
        VerticalScrollBarTrack.Visible = visible;
        VerticalScrollBarThumb.Visible = visible;
 
        if (!visible)
            return;
 
        Rectangle trackBounds = GetScrollBarTrackBounds(Bounds);
        Rectangle thumbBounds = GetScrollBarThumbBounds(Bounds);
        SetRectangleBounds(VerticalScrollBarTrack, trackBounds);
        SetRectangleBounds(VerticalScrollBarThumb, thumbBounds);
    }
 
    private Rectangle GetScrollBarTrackBounds(Rectangle bounds)
    {
        return new Rectangle(bounds.Right - ScrollBarMargin - ScrollBarWidth,
                             bounds.Top + ContentPadding + ScrollBarMargin,
                             ScrollBarWidth,
                             Math.Max(1, bounds.Height - (ContentPadding + ScrollBarMargin) * 2));
    }
 
    private Rectangle GetScrollBarThumbBounds(Rectangle bounds)
    {
        Rectangle trackBounds = GetScrollBarTrackBounds(bounds);
        int thumbHeight = _items.Count == 0
            ? trackBounds.Height
            : Math.Clamp((int)MathF.Round(trackBounds.Height * Math.Min(1f, (float)VisibleItemCount / _items.Count)),
                         Math.Min(MinimumScrollBarThumbHeight, trackBounds.Height),
                         trackBounds.Height);
        int travel = trackBounds.Height - thumbHeight;
        int maximumTopIndex = GetMaximumTopIndex();
        int offset = maximumTopIndex == 0 ? 0 : (int)MathF.Round(travel * ((float)TopIndex / maximumTopIndex));
        return new Rectangle(trackBounds.Left, trackBounds.Top + offset, trackBounds.Width, thumbHeight);
    }
 
    private PointF GetLocalPointerPosition(WidgetPointerEventArgs args)
    {
        RectangleF screenBounds = Background.GetDrawLocationScreen(args.View);
        screenBounds.Offset(args.WrappedOffsetWorldPx.X * args.View.Viewport.Zoom,
                            args.WrappedOffsetWorldPx.Y * args.View.Viewport.Zoom);
        float scaleX = screenBounds.Width / Bounds.Width;
        float scaleY = screenBounds.Height / Bounds.Height;
        return new PointF(Bounds.Left + (args.ScreenPositionPx.X - screenBounds.Left) / scaleX,
                          Bounds.Top + (args.ScreenPositionPx.Y - screenBounds.Top) / scaleY);
    }
 
    private bool IsPointerOverScrollBar(WidgetPointerEventArgs args)
    {
        // The entire reserved gutter belongs to the scrollbar, including its margins.
        return IsVerticalScrollBarVisible && GetLocalPointerPosition(args).X >= GetRowBounds(Bounds, 0).Right;
    }
 
    private void SetRectangleBounds(DirectRectangle rectangle, Rectangle bounds)
    {
        if (Mode == DirectDrawingMode.View)
            rectangle.ScreenBounds = bounds;
        else
            rectangle.WorldBounds = bounds;
 
        SetLocalOffset(rectangle, new Vector2(bounds.X, bounds.Y) - GetPosition());
    }
 
    private static DirectRectangle CreateBackground(RenderSurfaceHostBase host,
                                                    View view,
                                                    Rectangle bounds)
    {
        return ConfigureBackground(new DirectRectangle(Color.FromArgb(255, 36, 36, 44), host, view, bounds));
    }
 
    private static DirectRectangle CreateBackground(RenderSurfaceHostBase host,
                                                    SceneLayer layer,
                                                    Rectangle bounds)
    {
        return ConfigureBackground(new DirectRectangle(Color.FromArgb(255, 36, 36, 44), host, layer, bounds));
    }
 
    private static DirectRectangle ConfigureBackground(DirectRectangle background)
    {
        return background.SetFilled(true)
                         .SetBorderColor(Color.FromArgb(255, 140, 140, 155))
                         .SetStrokeWidth(1.5f)
                         .SetCornerRadius(4f);
    }
 
    private static DirectRectangle CreateSelectionHighlight(RenderSurfaceHostBase host,
                                                            View view,
                                                            Rectangle bounds)
    {
        return ConfigureSelectionHighlight(new DirectRectangle(Color.FromArgb(220, 63, 91, 138), host, view, bounds));
    }
 
    private static DirectRectangle CreateSelectionHighlight(RenderSurfaceHostBase host,
                                                            SceneLayer layer,
                                                            Rectangle bounds)
    {
        return ConfigureSelectionHighlight(new DirectRectangle(Color.FromArgb(220, 63, 91, 138), host, layer, bounds));
    }
 
    private static DirectRectangle ConfigureSelectionHighlight(DirectRectangle highlight)
    {
        return highlight.SetFilled(true)
                        .SetStrokeWidth(0f)
                        .SetCornerRadius(2f);
    }
 
    private static DirectRectangle CreateScrollBarTrack(RenderSurfaceHostBase host, View view, Rectangle bounds)
    {
        return ConfigureScrollBarTrack(new DirectRectangle(Color.FromArgb(255, 26, 26, 32), host, view, bounds));
    }
 
    private static DirectRectangle CreateScrollBarTrack(RenderSurfaceHostBase host, SceneLayer layer, Rectangle bounds)
    {
        return ConfigureScrollBarTrack(new DirectRectangle(Color.FromArgb(255, 26, 26, 32), host, layer, bounds));
    }
 
    private static DirectRectangle ConfigureScrollBarTrack(DirectRectangle track)
    {
        return track.SetFilled(true).SetStrokeWidth(0f).SetCornerRadius(3f);
    }
 
    private static DirectRectangle CreateScrollBarThumb(RenderSurfaceHostBase host, View view, Rectangle bounds)
    {
        return ConfigureScrollBarThumb(new DirectRectangle(Color.FromArgb(255, 126, 126, 142), host, view, bounds));
    }
 
    private static DirectRectangle CreateScrollBarThumb(RenderSurfaceHostBase host, SceneLayer layer, Rectangle bounds)
    {
        return ConfigureScrollBarThumb(new DirectRectangle(Color.FromArgb(255, 126, 126, 142), host, layer, bounds));
    }
 
    private static DirectRectangle ConfigureScrollBarThumb(DirectRectangle thumb)
    {
        return thumb.SetFilled(true).SetStrokeWidth(0f).SetCornerRadius(3f);
    }
 
    private static Rectangle GetInitialSelectionBounds(Rectangle bounds)
    {
        return new Rectangle(bounds.X + ContentPadding,
                             bounds.Y + ContentPadding,
                             Math.Max(1, bounds.Width - ContentPadding * 2),
                             DefaultItemHeight);
    }
 
    private static void Refresh(DirectRectangle rectangle)
    {
        rectangle.SetPosition(rectangle.GetPosition());
    }
 
    private static Rectangle ValidateBounds(Rectangle bounds)
    {
        if (bounds.Width < 24 || bounds.Height < DefaultItemHeight + ContentPadding * 2)
            throw new ArgumentOutOfRangeException(nameof(bounds), bounds, "List-box bounds are too small.");
 
        return bounds;
    }
}