DraggableWidgetBase.cs

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

public abstract class DraggableWidgetBase : WidgetBase
{
    private readonly WidgetDragBehavior _dragBehavior;

    public event Action<WidgetDragEventArgs>? DragStarted;

    public event Action<WidgetDragEventArgs>? Dragged;

    public event Action<WidgetDragEventArgs>? DragEnded;

    protected DraggableWidgetBase(RenderSurfaceHostBase renderSurfaceHost,
                                  DirectDrawingMode mode,
                                  PointF anchor = default,
                                  string? nickname = null)
        : base(renderSurfaceHost, mode, anchor, nickname)
    {
        _dragBehavior = new WidgetDragBehavior(this);
    }

    public bool IsDragEnabled
    {
        get => _dragBehavior.IsDragEnabled;
        set => _dragBehavior.IsDragEnabled = value;
    }

    public bool IsDragging => _dragBehavior.IsDragging;

    public float DragThresholdPx
    {
        get => _dragBehavior.DragThresholdPx;
        set => _dragBehavior.DragThresholdPx = value;
    }

    protected sealed override void ProcessHidden()
    {
        base.ProcessHidden();
        _dragBehavior.ResetPointerState(clearClickSuppression: true);
    }

    protected sealed override void ProcessCancelled()
    {
        base.ProcessCancelled();
        _dragBehavior.ResetPointerState(clearClickSuppression: true);
    }

    protected sealed override void ProcessPointerDown(WidgetPointerEventArgs args)
    {
        base.ProcessPointerDown(args);
        _dragBehavior.ProcessPointerDown(args, CanStartDrag);
    }

    protected sealed override void ProcessPointerMove(WidgetPointerEventArgs args)
    {
        base.ProcessPointerMove(args);
 
        _dragBehavior.ProcessPointerMove(
            args,
            ConvertScreenDeltaToPositionDelta,
            ConstrainDragPosition,
            DispatchDragStarted,
            DispatchDragged);
    }

    protected sealed override void ProcessPointerUp(WidgetPointerEventArgs args)
    {
        base.ProcessPointerUp(args);
 
        _dragBehavior.ProcessPointerUp(
            args,
            ConvertScreenDeltaToPositionDelta,
            ConstrainDragPosition,
            DispatchDragEnded);
    }

    protected sealed override bool ShouldDispatchPointerClick(WidgetPointerEventArgs args)
    {
        return base.ShouldDispatchPointerClick(args) &&
               _dragBehavior.ShouldDispatchPointerClick(args);
    }

    protected virtual bool CanStartDrag(WidgetPointerEventArgs args)
    {
        return _dragBehavior.CanStartDrag(args);
    }

    protected virtual Vector2 ConvertScreenDeltaToPositionDelta(Vector2 totalScreenDeltaPx,
                                                                View view)
    {
        return _dragBehavior.ConvertScreenDeltaToPositionDelta(totalScreenDeltaPx, view);
    }

    protected virtual Vector2 ConstrainDragPosition(Vector2 proposedPositionPx)
    {
        return proposedPositionPx;
    }

    protected virtual void OnDragStarted(WidgetDragEventArgs args)
    {
    }

    protected virtual void OnDragged(WidgetDragEventArgs args)
    {
    }

    protected virtual void OnDragEnded(WidgetDragEventArgs args)
    {
    }
 
    private void DispatchDragStarted(WidgetDragEventArgs args)
    {
        OnDragStarted(args);
        DragStarted?.Invoke(args);
    }
 
    private void DispatchDragged(WidgetDragEventArgs args)
    {
        OnDragged(args);
        Dragged?.Invoke(args);
    }
 
    private void DispatchDragEnded(WidgetDragEventArgs args)
    {
        OnDragEnded(args);
        DragEnded?.Invoke(args);
    }
}