PinchGestureRecognizer.cs

using System.Drawing;
 
namespace Gondwana.Input.Touch.Gestures;

public sealed class PinchGestureRecognizer : IDisposable
{
    private readonly ITouchInput _touchInput;
    private readonly Dictionary<int, Point> _activePoints = new();
    private double _startingDistance;
    private double _lastDistance = 0;
    private bool _isDisposed;

    public event EventHandler<PinchedEventArgs>? PinchStarted;

    public event EventHandler<PinchedEventArgs>? PinchUpdated;

    public event EventHandler<PinchedEventArgs>? PinchEnded;

    public PinchGestureRecognizer(ITouchInput touchInput)
    {
        _touchInput = touchInput ?? throw new ArgumentNullException(nameof(touchInput));
        _touchInput.TouchBegan += OnTouchBegan;
        _touchInput.TouchMoved += OnTouchMoved;
        _touchInput.TouchEnded += OnTouchEnded;
    }
 
    private void OnTouchBegan(object? sender, TouchEventArgs e)
    {
        var prevCount = _activePoints.Count;
 
        if (prevCount == 2)
            Emit(PinchPhase.Ended, PinchEnded);
 
        _activePoints[e.Touch.Id] = e.Touch.Position;
        var newCount = _activePoints.Count;
 
        if (prevCount != 2 && newCount == 2)
            BeginPinch();
        else if (newCount != 2)
            ClearBaseline();
    }
 
    private void OnTouchMoved(object? sender, TouchEventArgs e)
    {
        if (!_activePoints.ContainsKey(e.Touch.Id))
            return;
 
        _activePoints[e.Touch.Id] = e.Touch.Position;
 
        // Only emit updates when exactly two contacts are tracked and a baseline exists.
        if (_activePoints.Count == 2 && _lastDistance > 0)
        {
            var currentDistance = GetCurrentDistance();
 
            if (currentDistance > 0)
            {
                Emit(PinchPhase.Updated, PinchUpdated, currentDistance);
            }
 
            _lastDistance = currentDistance;
        }
    }
 
    private void OnTouchEnded(object? sender, TouchEventArgs e)
    {
        var prevCount = _activePoints.Count;
 
        if (_activePoints.ContainsKey(e.Touch.Id))
            _activePoints[e.Touch.Id] = e.Touch.Position;
 
        if (prevCount == 2)
            Emit(PinchPhase.Ended, PinchEnded);
 
        _activePoints.Remove(e.Touch.Id);
        var newCount = _activePoints.Count;
 
        if (prevCount != 2 && newCount == 2)
            BeginPinch();
        else if (newCount < 2)
            ClearBaseline();
    }
 
    private void BeginPinch()
    {
        _startingDistance = GetCurrentDistance();
        _lastDistance = _startingDistance;
        Emit(PinchPhase.Began, PinchStarted, _startingDistance);
    }
 
    private void ClearBaseline()
    {
        _startingDistance = 0;
        _lastDistance = 0;
    }
 
    private void Emit(PinchPhase phase,
                      EventHandler<PinchedEventArgs>? handler,
                      double? currentDistance = null)
    {
        if (_activePoints.Count != 2)
            return;
 
        var pair = _activePoints.OrderBy(kvp => kvp.Key).Take(2).ToArray();
        var a = pair[0].Value;
        var b = pair[1].Value;
        var distance = currentDistance ?? GetDistance(a, b);
        var center = new PointF((a.X + b.X) / 2f, (a.Y + b.Y) / 2f);
 
        handler?.Invoke(this, new PinchedEventArgs(phase,
                                                   new[] { pair[0].Key, pair[1].Key },
                                                   center,
                                                   _startingDistance,
                                                   _lastDistance,
                                                   distance));
    }
 
    private double GetCurrentDistance()
    {
        using var enumerator = _activePoints.Values.GetEnumerator();
        if (!enumerator.MoveNext())
            return 0;
 
        var a = enumerator.Current;
 
        if (!enumerator.MoveNext())
            return 0;
 
        var b = enumerator.Current;
 
        return GetDistance(a, b);
    }
 
    private static double GetDistance(Point a, Point b)
    {
        var dx = a.X - b.X;
        var dy = a.Y - b.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }

    public void Dispose()
    {
        if (_isDisposed) return;
        _isDisposed = true;
 
        _touchInput.TouchBegan -= OnTouchBegan;
        _touchInput.TouchMoved -= OnTouchMoved;
        _touchInput.TouchEnded -= OnTouchEnded;
        Reset();
    }
 
    internal void Reset()
    {
        _activePoints.Clear();
        ClearBaseline();
    }
}