DialogBox.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 Gondwana.Widgets.Controls;
using SkiaSharp;
 
namespace Gondwana.Widgets.Dialogs;

public abstract class DialogBox : DraggableContainerWidget
{
    protected const int DefaultTitleBarHeight = 36;
    protected const int DefaultCloseButtonSize = 28;

    protected readonly static Color DefaultPanelColor = Color.FromArgb(245, 36, 36, 44);
    protected readonly static Color DefaultPanelBorderColor = Color.FromArgb(255, 140, 140, 155);
    protected readonly static Color DefaultTitleBarColor = Color.FromArgb(255, 57, 57, 72);
 
    private const int DialogZOrderStart = 100_000;
    private const int DialogZOrderGap = 100;
 
    private static readonly object _zOrderSyncRoot = new();
    private static int _nextDialogZOrder = DialogZOrderStart;
 
    private bool _disposed;

    public event Action<DialogResult>? Closed;
 
    #region constructors

    protected DialogBox(RenderSurfaceHostBase renderSurfaceHost,
                        View view,
                        Rectangle bounds,
                        string title,
                        bool showCloseButton = true,
                        string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.View, bounds.Location, nickname)
    {
        ValidateBounds(bounds);
 
        DialogSize = bounds.Size;
 
        Panel = CreatePanel(renderSurfaceHost, view, bounds);
        TitleBar = CreateTitleBar(renderSurfaceHost, view, bounds);
        TitleText = CreateTitleText(renderSurfaceHost, view, bounds, title);
 
        Add(Panel);
        Add(TitleBar);
        Add(TitleText);
 
        if (showCloseButton)
        {
            CloseButton = CreateCloseButton(renderSurfaceHost, view, bounds);
            Add(CloseButton, GetCloseButtonOffset(bounds.Size));
 
            CloseButton.Clicked += OnCloseButtonClicked;
        }
 
        CompleteInitialization();
    }

    protected DialogBox(RenderSurfaceHostBase renderSurfaceHost,
                        SceneLayer sceneLayer,
                        Rectangle bounds,
                        string title,
                        bool showCloseButton = true,
                        string? nickname = null)
        : base(renderSurfaceHost, DirectDrawingMode.SceneLayer, bounds.Location, nickname)
    {
        ValidateBounds(bounds);
 
        DialogSize = bounds.Size;
 
        Panel = CreatePanel(renderSurfaceHost, sceneLayer, bounds);
        TitleBar = CreateTitleBar(renderSurfaceHost, sceneLayer, bounds);
        TitleText = CreateTitleText(renderSurfaceHost, sceneLayer, bounds, title);
 
        Add(Panel);
        Add(TitleBar);
        Add(TitleText);
 
        if (showCloseButton)
        {
            CloseButton = CreateCloseButton(renderSurfaceHost, sceneLayer, bounds);
            Add(CloseButton, GetCloseButtonOffset(bounds.Size));
 
            CloseButton.Clicked += OnCloseButtonClicked;
        }
 
        CompleteInitialization();
    }
 
    #endregion constructors
 
    #region public properties

    public DirectRectangle Panel { get; }

    public DirectRectangle TitleBar { get; }

    public TextBlock TitleText { get; }

    public ButtonWidget? CloseButton { get; }

    public Size DialogSize { get; }

    public bool IsClosed { get; private set; }

    public DialogResult Result { get; private set; }

    public bool DisposeOnClose { get; set; } = true;

    public int AcceptKey { get; set; } = 13;

    public int CancelKey { get; set; } = 27;
 
    #endregion public properties
 
    #region exposed methods and hooks

    public void Close(DialogResult result = DialogResult.Close)
    {
        if (IsClosed)
            return;
 
        IsClosed = true;
        Result = result;
 
        Hide();
 
        OnClosed(result);
        Closed?.Invoke(result);
 
        if (DisposeOnClose)
            Dispose();
    }

    protected virtual void OnClosed(DialogResult result)
    {
    }

    protected virtual void OnAcceptRequested()
    {
        Close(DialogResult.OK);
    }

    protected override void ProcessActivated()
    {
        BringVisualTreeToFront();
        base.ProcessActivated();
    }
 
    private void BringVisualTreeToFront()
    {
        DirectDrawingBase[] visuals = GetVisualDescendants(this).ToArray();
        if (visuals.Length == 0)
            return;
 
        int minimumZOrder = visuals.Min(static visual => visual.ZOrder);
        int maximumZOrder = visuals.Max(static visual => visual.ZOrder);
        int span = maximumZOrder - minimumZOrder;
 
        int targetMinimum;
        lock (_zOrderSyncRoot)
        {
            targetMinimum = _nextDialogZOrder;
            _nextDialogZOrder = checked(targetMinimum + span + DialogZOrderGap);
        }
 
        int delta = targetMinimum - minimumZOrder;
        foreach (DirectDrawingBase visual in visuals)
            visual.ZOrder += delta;
    }
 
    private static IEnumerable<DirectDrawingBase> GetVisualDescendants(IDirectCompositeContainer container)
    {
        foreach (IDirectCompositeChild child in container.Children)
        {
            if (child is DirectDrawingBase visual)
                yield return visual;
 
            if (child is not IDirectCompositeContainer childContainer)
                continue;
 
            foreach (DirectDrawingBase descendant in GetVisualDescendants(childContainer))
                yield return descendant;
        }
    }

    protected override bool CanStartDrag(WidgetPointerEventArgs args)
    {
        if (!base.CanStartDrag(args))
            return false;
 
        RectangleF titleBarBounds = TitleBar.GetDrawLocationScreen(args.View);
        titleBarBounds.Offset(args.WrappedOffsetWorldPx.X * args.View.Viewport.Zoom, args.WrappedOffsetWorldPx.Y * args.View.Viewport.Zoom);
 
        return titleBarBounds.Contains(args.ScreenPositionPx.X, args.ScreenPositionPx.Y);
    }

    protected override void OnKeyboardInput(WidgetKeyboardEventArgs args)
    {
        base.OnKeyboardInput(args);
 
        if (args.Handled || args.KeyAction != KeyAction.Pressed)
            return;
 
        if (args.Key == CancelKey)
        {
            args.Handled = true;
            Close(DialogResult.Cancel);
            return;
        }
 
        if (args.Key == AcceptKey)
        {
            args.Handled = true;
            OnAcceptRequested();
        }
    }

    protected override void OnCancelled()
    {
        base.OnCancelled();
        Close(DialogResult.Cancel);
    }

    public override void Dispose()
    {
        if (_disposed)
            return;
 
        _disposed = true;
 
        if (CloseButton is not null)
        {
            CloseButton.Clicked -= OnCloseButtonClicked;
        }
 
        base.Dispose();
        GC.SuppressFinalize(this);
    }
 
    #endregion exposed methods and hooks
 
    #region private methods
 
    private void CompleteInitialization()
    {
        CanReceiveFocus = true;
        IsKeyboardInputEnabled = true;
        IsPointerInputEnabled = true;
    }
 
    private void OnCloseButtonClicked()
    {
        Close(DialogResult.Cancel);
    }
 
    private static void ValidateBounds(Rectangle bounds)
    {
        if (bounds.Width <= 0 || bounds.Height <= DefaultTitleBarHeight)
        {
            throw new ArgumentOutOfRangeException(
                nameof(bounds),
                bounds,
                "Dialog bounds must have positive width and enough height for the title bar.");
        }
    }
 
    private static Vector2 GetCloseButtonOffset(Size size)
    {
        return new Vector2(size.Width - DefaultCloseButtonSize - 4, 4);
    }
 
    private static DirectRectangle CreatePanel(RenderSurfaceHostBase host,
                                               View view,
                                               Rectangle bounds)
    {
        return ConfigurePanel(new DirectRectangle(DefaultPanelColor,
                              host,
                              view,
                              bounds));
    }
 
    private static DirectRectangle CreatePanel(RenderSurfaceHostBase host,
                                               SceneLayer layer,
                                               Rectangle bounds)
    {
        return ConfigurePanel(new DirectRectangle(DefaultPanelColor,
                              host,
                              layer,
                              bounds));
    }
 
    private static DirectRectangle ConfigurePanel(DirectRectangle panel)
    {
        panel.SetFilled(true)
             .SetBorderColor(DefaultPanelBorderColor)
             .SetStrokeWidth(2f)
             .SetCornerRadius(8f);
 
        panel.ZOrder = 10_000;
 
        return panel;
    }
 
    private static DirectRectangle CreateTitleBar(RenderSurfaceHostBase host,
                                                  View view,
                                                  Rectangle bounds)
    {
        return ConfigureTitleBar(new DirectRectangle(DefaultTitleBarColor,
                                                     host,
                                                     view,
                                                     GetTitleBarBounds(bounds)));
    }
 
    private static DirectRectangle CreateTitleBar(RenderSurfaceHostBase host,
                                                  SceneLayer layer,
                                                  Rectangle bounds)
    {
        return ConfigureTitleBar(new DirectRectangle(DefaultTitleBarColor,
                                                     host,
                                                     layer,
                                                     GetTitleBarBounds(bounds)));
    }
 
    private static DirectRectangle ConfigureTitleBar(DirectRectangle titleBar)
    {
        titleBar.SetFilled(true)
                .SetCornerRadius(8f);
 
        titleBar.ZOrder = 10_001;
 
        return titleBar;
    }
 
    private static TextBlock CreateTitleText(RenderSurfaceHostBase host,
                                             View view,
                                             Rectangle bounds,
                                             string title)
    {
        return ConfigureTitleText(new TextBlock(host, view, GetTitleTextBounds(bounds)), title);
    }
 
    private static TextBlock CreateTitleText(RenderSurfaceHostBase host,
                                             SceneLayer layer,
                                             Rectangle bounds,
                                             string title)
    {
        return ConfigureTitleText(new TextBlock(host, layer, view: null, worldBounds: GetTitleTextBounds(bounds)), title);
    }
 
    private static TextBlock ConfigureTitleText(TextBlock titleText, string title)
    {
        titleText.SetText(title)
                 .SetFont(SKTypeface.Default, 18f, minSize: 12f)
                 .SetColors(SKColors.White, SKColors.Transparent)
                 .SetAlignment(SKTextAlign.Left, TextBlock.VerticalAlign.Center)
                 .EnableWrapping(false);
 
        titleText.HorizontalPadding = 12f;
        titleText.ZOrder = 10_002;
 
        return titleText;
    }
 
    private static ButtonWidget CreateCloseButton(RenderSurfaceHostBase host,
                                                  View view,
                                                  Rectangle bounds)
    {
        return ConfigureCloseButton(new ButtonWidget(host, view, GetCloseButtonBounds(bounds), "×"));
    }
 
    private static ButtonWidget CreateCloseButton(RenderSurfaceHostBase host,
                                                  SceneLayer layer,
                                                  Rectangle bounds)
    {
        return ConfigureCloseButton(new ButtonWidget(host, layer, GetCloseButtonBounds(bounds), "×"));
    }
 
    private static ButtonWidget ConfigureCloseButton(ButtonWidget closeButton)
    {
        closeButton.SetBackgroundColors(Color.FromArgb(0, 0, 0, 0),
                                        Color.FromArgb(255, 110, 55, 62),
                                        Color.FromArgb(255, 145, 45, 55))
                   .SetTextColor(Color.White)
                   .SetButtonZOrder(10_003);
 
        return closeButton;
    }
 
    private static Rectangle GetTitleBarBounds(Rectangle bounds)
    {
        return new Rectangle(bounds.X, bounds.Y, bounds.Width, DefaultTitleBarHeight);
    }
 
    private static Rectangle GetTitleTextBounds(
        Rectangle bounds)
    {
        return new Rectangle(bounds.X, bounds.Y, bounds.Width - DefaultCloseButtonSize - 12, DefaultTitleBarHeight);
    }
 
    private static Rectangle GetCloseButtonBounds(
        Rectangle bounds)
    {
        return new Rectangle(bounds.Right - DefaultCloseButtonSize - 4, bounds.Y + 4, DefaultCloseButtonSize, DefaultCloseButtonSize);
    }
 
    #endregion private methods
}