PanelWidget.cs

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

public sealed class PanelWidget : ContainerWidget
{
    private int _panelZOrder;

    public PanelWidget(RenderSurfaceHostBase renderSurfaceHost,
                       View view,
                       Rectangle bounds,
                       Color backgroundColor,
                       string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.View, ValidateBounds(bounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(view);
 
        Background = new DirectRectangle(backgroundColor, renderSurfaceHost, view, bounds, $"{Nickname}.background")
            .SetFilled(true)
            .SetStrokeWidth(0f);
 
        Add(Background, keepCurrentOffset: false, explicitLocalOffsetPx: Vector2.Zero);
        DisableInput();
    }

    public PanelWidget(RenderSurfaceHostBase renderSurfaceHost,
                       SceneLayer sceneLayer,
                       Rectangle bounds,
                       Color backgroundColor,
                       string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.SceneLayer, ValidateBounds(bounds).Location, nickname)
    {
        ArgumentNullException.ThrowIfNull(sceneLayer);
 
        Background = new DirectRectangle(backgroundColor, renderSurfaceHost, sceneLayer, bounds, $"{Nickname}.background")
            .SetFilled(true)
            .SetStrokeWidth(0f);
 
        Add(Background, keepCurrentOffset: false, explicitLocalOffsetPx: Vector2.Zero);
        DisableInput();
    }

    public DirectRectangle Background { get; }

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

    public Size Size
    {
        get => Bounds.Size;
        set
        {
            ValidateSize(value);
 
            if (Mode == DirectDrawingMode.View)
                Background.ScreenBounds = new Rectangle(Background.ScreenBounds.Location, value);
            else
                Background.WorldBounds = new Rectangle(Background.WorldBounds.Location, value);
        }
    }

    public PanelWidget 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, _panelZOrder + 1);
        return this;
    }

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

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

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

    public PanelWidget SetStrokeWidth(float width)
    {
        Background.SetStrokeWidth(width);
        RefreshBackground();
        return this;
    }

    public PanelWidget SetCornerRadius(float radius)
    {
        Background.SetCornerRadius(radius);
        RefreshBackground();
        return this;
    }

    public PanelWidget 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 PanelWidget 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 PanelWidget ClearBackgroundImage()
    {
        Background.ClearFillImage();
        return this;
    }

    public PanelWidget SetPanelZOrder(int zOrder)
    {
        _panelZOrder = zOrder;
        Background.ZOrder = zOrder;
 
        foreach (WidgetBase widget in ChildWidgets)
            SetWidgetZOrder(widget, zOrder + 1);
 
        return this;
    }
 
    private void RefreshBackground()
    {
        Background.SetPosition(Background.GetPosition());
    }
 
    private void DisableInput()
    {
        IsInputEnabled = false;
        IsPointerInputEnabled = false;
        IsKeyboardInputEnabled = false;
        CanReceiveFocus = false;
    }
 
    private static Rectangle ValidateBounds(Rectangle bounds)
    {
        ValidateSize(bounds.Size);
        return bounds;
    }
 
    private static void ValidateSize(Size size)
    {
        if (size.Width <= 0 || size.Height <= 0)
            throw new ArgumentOutOfRangeException(nameof(size), size, "Panel size must be positive.");
    }
 
    private static void SetWidgetZOrder(WidgetBase widget, int zOrder)
    {
        DirectDrawingBase[] visuals = EnumerateVisuals(widget).ToArray();
        if (visuals.Length == 0)
            return;
 
        int currentMin = visuals.Min(static visual => visual.ZOrder);
        int delta = zOrder - currentMin;
 
        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;
            }
        }
    }
}