TabPageWidget.cs

using System.Drawing;
using System.Numerics;
using Gondwana.Drawing.Direct;
using Gondwana.Rendering;
using SkiaSharp;
 
namespace Gondwana.Widgets.Controls;

public sealed class TabPageWidget : ContainerWidget
{
    private int _pageZOrder;
    private string _title;

    internal TabPageWidget(RenderSurfaceHostBase renderSurfaceHost,
                           Gondwana.Rendering.Views.View view,
                           Rectangle contentBounds,
                           string title,
                           char? mnemonic,
                           string? nickname)
        : base(renderSurfaceHost, DirectDrawingMode.View, ValidateBounds(contentBounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(view);
 
        _title = ValidateTitle(title);
        Mnemonic = mnemonic;
 
        Background = new DirectRectangle(DefaultBackgroundColor,
                                         renderSurfaceHost,
                                         view,
                                         contentBounds,
                                         $"{Nickname}.background")
            .SetFilled(true)
            .SetBorderColor(DefaultBorderColor)
            .SetStrokeWidth(1f);
 
        Add(Background);
 
        DisablePageInput();
    }

    internal TabPageWidget(RenderSurfaceHostBase renderSurfaceHost,
                           Gondwana.Scenes.SceneLayer sceneLayer,
                           Rectangle contentBounds,
                           string title,
                           char? mnemonic,
                           string? nickname)
        : base(renderSurfaceHost, DirectDrawingMode.SceneLayer, ValidateBounds(contentBounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(sceneLayer);
 
        _title = ValidateTitle(title);
        Mnemonic = mnemonic;
 
        Background = new DirectRectangle(DefaultBackgroundColor,
                                         renderSurfaceHost,
                                         sceneLayer,
                                         contentBounds,
                                         $"{Nickname}.background")
            .SetFilled(true)
            .SetBorderColor(DefaultBorderColor)
            .SetStrokeWidth(1f);
 
        Add(Background);
 
        DisablePageInput();
    }

    public DirectRectangle Background { get; }

    public string Title => _title;

    public char? Mnemonic { get; }

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

    public Rectangle HeaderBounds { get; internal set; }

    public TabPageWidget AddWidget(WidgetBase widget,
                                   Point? offsetPx = null)
    {
        ArgumentNullException.ThrowIfNull(widget);
 
        Point offset = offsetPx ?? Point.Empty;
        Add(widget,
            keepCurrentOffset: false,
            explicitLocalOffsetPx: new Vector2(offset.X, offset.Y));
        SetWidgetZOrder(widget, _pageZOrder + 1);
 
        return this;
    }

    public TabPageWidget RemoveWidget(WidgetBase widget,
                                      bool dispose = false)
    {
        RemoveChild(widget, dispose);
        return this;
    }

    public TabPageWidget SetTitle(string title)
    {
        string validatedTitle = ValidateTitle(title);
        if (string.Equals(_title, validatedTitle, StringComparison.Ordinal))
            return this;
 
        _title = validatedTitle;
        TitleChanged?.Invoke(this);
        return this;
    }

    public TabPageWidget SetBackgroundColor(Color color)
    {
        Background.SetColor(color);
        RefreshBackground();
        return this;
    }

    public TabPageWidget SetBorderColor(Color color)
    {
        Background.SetBorderColor(color);
        RefreshBackground();
        return this;
    }

    public TabPageWidget SetStrokeWidth(float width)
    {
        if (width < 0f)
            throw new ArgumentOutOfRangeException(nameof(width), "The page border width cannot be negative.");
 
        Background.SetStrokeWidth(width);
        RefreshBackground();
        return this;
    }

    public TabPageWidget SetCornerRadius(float radius)
    {
        if (radius < 0f)
            throw new ArgumentOutOfRangeException(nameof(radius), "The page corner radius cannot be negative.");
 
        Background.SetCornerRadius(radius);
        RefreshBackground();
        return this;
    }

    public TabPageWidget SetBackgroundImage(SKBitmap bitmap,
                                            DirectRectangle.ImageFillMode mode = DirectRectangle.ImageFillMode.Stretch,
                                            float scale = 1f,
                                            SKPoint? offsetPx = null,
                                            SKFilterQuality filterQuality = SKFilterQuality.Medium)
    {
        Background.SetFillImage(bitmap, mode, scale, offsetPx, filterQuality);
        return this;
    }

    public TabPageWidget SetBackgroundImage(SKImage image,
                                            DirectRectangle.ImageFillMode mode = DirectRectangle.ImageFillMode.Stretch,
                                            float scale = 1f,
                                            SKPoint? offsetPx = null,
                                            SKFilterQuality filterQuality = SKFilterQuality.Medium)
    {
        Background.SetFillImage(image, mode, scale, offsetPx, filterQuality);
        return this;
    }

    public TabPageWidget ClearBackgroundImage()
    {
        Background.ClearFillImage();
        return this;
    }

    internal event Action<TabPageWidget>? TitleChanged;

    internal void SetContentBounds(Rectangle bounds)
    {
        ValidateBounds(bounds);
 
        if (Mode == DirectDrawingMode.View)
            Background.ScreenBounds = new Rectangle(Background.ScreenBounds.Location, bounds.Size);
        else
            Background.WorldBounds = new Rectangle(Background.WorldBounds.Location, bounds.Size);
    }

    internal void SetPageZOrder(int zOrder)
    {
        _pageZOrder = zOrder;
        Background.ZOrder = zOrder;
 
        foreach (WidgetBase widget in ChildWidgets)
            SetWidgetZOrder(widget, zOrder + 1);
    }
 
    private const int DefaultBackgroundAlpha = 235;
 
    private static readonly Color DefaultBackgroundColor = Color.FromArgb(DefaultBackgroundAlpha, 25, 28, 36);
    private static readonly Color DefaultBorderColor = Color.FromArgb(255, 110, 120, 140);
 
    private void DisablePageInput()
    {
        IsInputEnabled = false;
        IsPointerInputEnabled = false;
        IsKeyboardInputEnabled = false;
        CanReceiveFocus = false;
    }
 
    private void RefreshBackground()
    {
        Background.SetPosition(Background.GetPosition());
    }
 
    private static Rectangle ValidateBounds(Rectangle bounds)
    {
        if (bounds.Width <= 0 || bounds.Height <= 0)
        {
            throw new ArgumentOutOfRangeException(
                nameof(bounds),
                bounds,
                "Tab-page bounds must have positive width and height.");
        }
 
        return bounds;
    }
 
    private static string ValidateTitle(string title)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(title);
        return title;
    }
 
    private static void SetWidgetZOrder(WidgetBase widget,
                                        int zOrder)
    {
        DirectDrawingBase[] visuals = EnumerateVisuals(widget).ToArray();
        if (visuals.Length == 0)
            return;
 
        int currentMinimum = visuals.Min(static visual => visual.ZOrder);
        int delta = zOrder - currentMinimum;
 
        foreach (DirectDrawingBase visual in visuals)
            visual.ZOrder += delta;
    }
 
    private static IEnumerable<DirectDrawingBase> EnumerateVisuals(IDirectCompositeContainer container)
    {
        foreach (IDirectCompositeChild child in container.Children)
        {
            if (child is DirectDrawingBase drawing)
                yield return drawing;
 
            if (child is IDirectCompositeContainer nestedContainer)
            {
                foreach (DirectDrawingBase nestedDrawing in EnumerateVisuals(nestedContainer))
                    yield return nestedDrawing;
            }
        }
    }
}