WidgetBase.cs

using System.Drawing;
using Gondwana.Drawing.Direct;
using Gondwana.Rendering;
using Gondwana.Rendering.Views;
 
namespace Gondwana.Widgets;

public abstract class WidgetBase : DirectComposite
{
    private bool _isInputEnabled = true;
    private bool _isPointerInputEnabled = true;
    private bool _isKeyboardInputEnabled;
    private bool _canReceiveFocus;

    public event Action? Shown;

    public event Action? Hidden;

    public event Action? Activated;

    public event Action? Cancelled;

    public event Action<WidgetPointerEventArgs>? PointerEnter;

    public event Action<WidgetPointerEventArgs>? PointerLeave;

    public event Action<WidgetPointerEventArgs>? PointerDown;

    public event Action<WidgetPointerEventArgs>? PointerMove;

    public event Action<WidgetPointerEventArgs>? PointerUp;

    public event Action<WidgetPointerEventArgs>? PointerClick;

    public event Action<WidgetMouseWheelEventArgs>? MouseWheel;

    public event Action? FocusGained;

    public event Action? FocusLost;

    public event Action<WidgetKeyboardEventArgs>? KeyboardInput;

    protected WidgetBase(RenderSurfaceHostBase renderSurfaceHost,
                         DirectDrawingMode mode,
                         PointF anchor = default,
                         string? nickname = null)
        : base(renderSurfaceHost, mode, anchor, nickname)
    {
    }

    public bool IsInputEnabled
    {
        get => _isInputEnabled;
        set
        {
            if (_isInputEnabled == value)
                return;
 
            _isInputEnabled = value;
 
            if (!value)
                WidgetInputRouterRegistry.NotifyInputDisabled(this);
        }
    }

    public bool IsPointerInputEnabled
    {
        get => _isPointerInputEnabled;
        set
        {
            if (_isPointerInputEnabled == value)
                return;
 
            _isPointerInputEnabled = value;
 
            if (!value)
                WidgetInputRouterRegistry.NotifyPointerInputDisabled(this);
        }
    }

    public bool IsKeyboardInputEnabled
    {
        get => _isKeyboardInputEnabled;
        set
        {
            if (_isKeyboardInputEnabled == value)
                return;
 
            _isKeyboardInputEnabled = value;
 
            if (!value)
                WidgetInputRouterRegistry.NotifyKeyboardFocusDisabled(this);
        }
    }

    public bool CanReceiveFocus
    {
        get => _canReceiveFocus;
        set
        {
            if (_canReceiveFocus == value)
                return;
 
            _canReceiveFocus = value;
 
            if (!value)
                WidgetInputRouterRegistry.NotifyKeyboardFocusDisabled(this);
        }
    }

    public bool IsFocused { get; internal set; }

    public virtual bool HitTest(View view,
                                Point screenPositionPx)
    {
        ArgumentNullException.ThrowIfNull(view);
 
        if (!IsInputEnabled ||
            !IsPointerInputEnabled ||
            !Visible)
        {
            return false;
        }
 
        if (Mode == DirectDrawingMode.View
                 && !ReferenceEquals(View, view))
        {
            return false;
        }
 
        if (Mode == DirectDrawingMode.SceneLayer && SceneLayer is { } layer &&
            (layer.WrapHorizontally || layer.WrapVertically))
            return GetWrappedHitOffset(view, screenPositionPx).HasValue;
 
        RectangleF screenBounds = GetDrawLocationScreen(view);
 
        return !screenBounds.IsEmpty
            && screenBounds.Contains(screenPositionPx.X, screenPositionPx.Y);
    }
 
    internal PointF? GetWrappedHitOffset(View view, Point screenPositionPx)
    {
        if (Mode != DirectDrawingMode.SceneLayer || SceneLayer is not { } layer)
            return PointF.Empty;
        var world = view.ScreenPxToWorldPx(layer, screenPositionPx);
        foreach (var offset in layer.GetWrappedOffsets(WorldBounds, new RectangleF(world.X, world.Y, 0.01f, 0.01f)))
        {
            RectangleF bounds = WorldBounds;
            bounds.Offset(offset);
            if (bounds.Contains(world)) return offset;
        }
        return null;
    }

    public virtual bool HitTest(Point screenPositionPx)
    {
        var views = RenderSurfaceHost.ViewManager.Views;
 
        for (int index = views.Count - 1; index >= 0; index--)
        {
            View view = views[index];
 
            if (!view.Viewport.TargetRectPx.Contains(screenPositionPx))
            {
                continue;
            }
 
            return HitTest(view, screenPositionPx);
        }
 
        return false;
    }

    public WidgetBase Show()
    {
        WidgetInputRouterRegistry.TryRegister(this);
 
        SetIsVisible(true);
 
        ProcessShown();
        OnShown();
        Shown?.Invoke();
 
        return this;
    }

    public WidgetBase Hide()
    {
        WidgetInputRouterRegistry.NotifyHidden(this);
 
        SetIsVisible(false);
 
        ProcessHidden();
        OnHidden();
        Hidden?.Invoke();
 
        return this;
    }

    public WidgetBase Activate()
    {
        WidgetInputRouterRegistry.TryBringToFront(this);
 
        ProcessActivated();
        OnActivated();
        Activated?.Invoke();
 
        return this;
    }

    public WidgetBase Cancel()
    {
        ProcessCancelled();
        OnCancelled();
        Cancelled?.Invoke();
 
        return this;
    }

    protected internal void DispatchPointerEnter(WidgetPointerEventArgs args)
    {
        ArgumentNullException.ThrowIfNull(args);
 
        ProcessPointerEnter(args);
        OnPointerEnter(args);
        PointerEnter?.Invoke(args);
    }

    protected internal void DispatchPointerLeave(WidgetPointerEventArgs args)
    {
        ArgumentNullException.ThrowIfNull(args);
 
        ProcessPointerLeave(args);
        OnPointerLeave(args);
        PointerLeave?.Invoke(args);
    }

    protected internal void DispatchPointerDown(WidgetPointerEventArgs args)
    {
        ArgumentNullException.ThrowIfNull(args);
 
        ProcessPointerDown(args);
        OnPointerDown(args);
        PointerDown?.Invoke(args);
    }

    protected internal void DispatchPointerMove(WidgetPointerEventArgs args)
    {
        ArgumentNullException.ThrowIfNull(args);
 
        ProcessPointerMove(args);
        OnPointerMove(args);
        PointerMove?.Invoke(args);
    }

    protected internal void DispatchPointerUp(WidgetPointerEventArgs args)
    {
        ArgumentNullException.ThrowIfNull(args);
 
        ProcessPointerUp(args);
        OnPointerUp(args);
        PointerUp?.Invoke(args);
    }

    protected internal void DispatchPointerClick(WidgetPointerEventArgs args)
    {
        ArgumentNullException.ThrowIfNull(args);
 
        if (!ShouldDispatchPointerClick(args))
            return;
 
        OnPointerClick(args);
        PointerClick?.Invoke(args);
    }

    protected internal void DispatchMouseWheel(WidgetMouseWheelEventArgs args)
    {
        ArgumentNullException.ThrowIfNull(args);
 
        OnMouseWheel(args);
        MouseWheel?.Invoke(args);
    }

    protected internal void DispatchFocusGained()
    {
        IsFocused = true;
 
        ProcessFocusGained();
        OnFocusGained();
        FocusGained?.Invoke();
    }

    protected internal void DispatchFocusLost()
    {
        IsFocused = false;
 
        ProcessFocusLost();
        OnFocusLost();
        FocusLost?.Invoke();
    }

    protected internal void DispatchKeyboardInput(WidgetKeyboardEventArgs args)
    {
        ArgumentNullException.ThrowIfNull(args);
 
        ProcessKeyboardInput(args);
        OnKeyboardInput(args);
        KeyboardInput?.Invoke(args);
    }

    protected virtual void ProcessShown() { }

    protected virtual void ProcessHidden() { }

    protected virtual void ProcessActivated() { }

    protected virtual void ProcessCancelled() { }

    protected virtual void ProcessPointerEnter(WidgetPointerEventArgs args) { }

    protected virtual void ProcessPointerLeave(WidgetPointerEventArgs args) { }

    protected virtual void ProcessPointerDown(WidgetPointerEventArgs args) { }

    protected virtual void ProcessPointerMove(WidgetPointerEventArgs args) { }

    protected virtual void ProcessPointerUp(WidgetPointerEventArgs args) { }

    protected virtual void ProcessFocusGained() { }

    protected virtual void ProcessFocusLost() { }

    protected virtual void ProcessKeyboardInput(WidgetKeyboardEventArgs args) { }

    protected virtual bool ShouldDispatchPointerClick(WidgetPointerEventArgs args)
    {
        return true;
    }

    protected virtual void OnShown() { }

    protected virtual void OnHidden() { }

    protected virtual void OnActivated() { }

    protected virtual void OnCancelled() { }

    protected virtual void OnPointerEnter(WidgetPointerEventArgs args) { }

    protected virtual void OnPointerLeave(WidgetPointerEventArgs args) { }

    protected virtual void OnPointerDown(WidgetPointerEventArgs args) { }

    protected virtual void OnPointerMove(WidgetPointerEventArgs args) { }

    protected virtual void OnPointerUp(WidgetPointerEventArgs args) { }

    protected virtual void OnMouseWheel(WidgetMouseWheelEventArgs args) { }

    protected virtual void OnPointerClick(WidgetPointerEventArgs args) { }

    protected virtual void OnFocusGained() { }

    protected virtual void OnFocusLost() { }

    protected virtual void OnKeyboardInput(WidgetKeyboardEventArgs args) { }
}