ContainerWidget.cs

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

public abstract class ContainerWidget : WidgetBase
{
    private bool _isShown;
 
    #region constructors

    protected ContainerWidget(RenderSurfaceHostBase renderSurfaceHost,
                              DirectDrawingMode mode,
                              PointF anchor = default,
                              string? nickname = null)
        : base(renderSurfaceHost, mode, anchor, nickname)
    {
    }
 
    #endregion constructors
 
    #region public properties

    public IReadOnlyList<WidgetBase> ChildWidgets => Children.OfType<WidgetBase>().ToArray();
 
    #endregion public properties
 
    #region public methods

    public override DirectComposite Add(IDirectCompositeChild child,
                                        bool keepCurrentOffset = true,
                                        Vector2? explicitLocalOffsetPx = null)
    {
        ArgumentNullException.ThrowIfNull(child);
 
        bool alreadyAdded =
            Children.Contains(child);
 
        base.Add(
            child,
            keepCurrentOffset,
            explicitLocalOffsetPx);
 
        if (!alreadyAdded &&
            _isShown &&
            child is WidgetBase widget)
        {
            widget.Show();
        }
 
        return this;
    }

    public override DirectComposite Remove(
        IDirectCompositeChild child)
    {
        ArgumentNullException.ThrowIfNull(child);
 
        if (_isShown &&
            child is WidgetBase widget &&
            Children.Contains(child))
        {
            widget.Hide();
        }
 
        return base.Remove(child);
    }

    public override DirectComposite Clear()
    {
        if (_isShown)
        {
            foreach (WidgetBase child in GetChildWidgetSnapshot())
                child.Hide();
        }
 
        return base.Clear();
    }
 
    #endregion public methods
 
    #region protected methods

    protected TWidget Add<TWidget>(
        TWidget widget,
        Vector2 localOffsetPx)
        where TWidget : WidgetBase
    {
        ArgumentNullException.ThrowIfNull(widget);
 
        Add(
            (IDirectCompositeChild)widget,
            keepCurrentOffset: false,
            explicitLocalOffsetPx: localOffsetPx);
 
        return widget;
    }

    protected bool RemoveChild(
        WidgetBase widget,
        bool dispose = false)
    {
        ArgumentNullException.ThrowIfNull(widget);
 
        if (!Children.Contains(widget))
            return false;
 
        Remove(widget);
 
        if (dispose)
            widget.Dispose();
 
        return true;
    }

    protected override void OnChildAdded(
        IDirectCompositeChild child)
    {
        base.OnChildAdded(child);
 
        if (child is WidgetBase widget)
            widget.KeyboardInput += OnChildKeyboardInput;
    }

    protected override void OnChildRemoved(
        IDirectCompositeChild child)
    {
        if (child is WidgetBase widget)
            widget.KeyboardInput -= OnChildKeyboardInput;
 
        base.OnChildRemoved(child);
    }

    protected override void ProcessShown()
    {
        base.ProcessShown();
 
        _isShown = true;
 
        foreach (WidgetBase child in GetChildWidgetSnapshot())
            child.Show();
    }

    protected override void ProcessHidden()
    {
        foreach (WidgetBase child in GetChildWidgetSnapshot())
            child.Hide();
 
        _isShown = false;
 
        base.ProcessHidden();
    }

    protected override void ProcessActivated()
    {
        base.ProcessActivated();
 
        // Children are activated after their parent so they appear later in
        // the router's hit-test order.
        foreach (WidgetBase child in GetChildWidgetSnapshot())
            child.Activate();
    }

    protected override void ProcessCancelled()
    {
        foreach (WidgetBase child in GetChildWidgetSnapshot())
            child.Cancel();
 
        base.ProcessCancelled();
    }
 
    #endregion protected methods
 
    #region private methods
 
    private void OnChildKeyboardInput(
        WidgetKeyboardEventArgs args)
    {
        if (args.Handled)
            return;
 
        var parentArgs = new WidgetKeyboardEventArgs(
            this,
            args.Key,
            args.KeyAction,
            args.Modifiers,
            args.Tick);
 
        DispatchKeyboardInput(parentArgs);
 
        args.Handled = parentArgs.Handled;
    }
 
    private WidgetBase[] GetChildWidgetSnapshot()
    {
        return Children
            .OfType<WidgetBase>()
            .ToArray();
    }
 
    #endregion private methods
}