Add platform-agnostic gesture recognition system (SKGestureDetector + SKGestureTracker)

source/SkiaSharp.Extended.UI.Maui/Controls/Gestures/SKDynamicSurfaceView.shared.cs

@@ -0,0 +1,192 @@
+namespace SkiaSharp.Extended.UI.Controls;
+
+/// <summary>
+/// A SkiaSharp view that can dynamically switch between hardware (OpenGL) and software (Canvas) rendering.
+/// </summary>
+/// <remarks>
+/// This view provides the flexibility to toggle between GPU-accelerated rendering using OpenGL/Metal
+/// and CPU-based software rendering at runtime. This is useful when:
+/// - You want to give users the option to choose based on their device capabilities
+/// - You need to switch rendering modes based on content being drawn
+/// - You want to compare performance between rendering modes
+/// </remarks>
+public class SKDynamicSurfaceView : TemplatedView
+{
+	/// <summary>
+	/// Identifies the IsHardwareAccelerated bindable property.
+	/// </summary>
+	public static readonly BindableProperty IsHardwareAcceleratedProperty = BindableProperty.Create(
+		nameof(IsHardwareAccelerated),
+		typeof(bool),
+		typeof(SKDynamicSurfaceView),
+		false,
+		propertyChanged: OnIsHardwareAcceleratedChanged);
+
+	/// <summary>
+	/// Identifies the EnableTouchEvents bindable property.
+	/// </summary>
+	public static readonly BindableProperty EnableTouchEventsProperty = BindableProperty.Create(
+		nameof(EnableTouchEvents),
+		typeof(bool),
+		typeof(SKDynamicSurfaceView),
+		false,
+		propertyChanged: OnEnableTouchEventsChanged);
+
+	private SKCanvasView? canvasView;
+	private SKGLView? glView;
+
+	/// <summary>
+	/// Creates a new instance of SKDynamicSurfaceView.
+	/// </summary>
+	public SKDynamicSurfaceView()
+	{
+		ResourceLoader<Themes.SKDynamicSurfaceViewResources>.EnsureRegistered(this);
+
+		DebugUtils.LogPropertyChanged(this);
+	}
+
+	/// <summary>
+	/// Gets or sets whether hardware acceleration is enabled.
+	/// </summary>
+	/// <remarks>
+	/// When true, rendering uses OpenGL/Metal for GPU acceleration.
+	/// When false, rendering uses the CPU-based canvas renderer.
+	/// </remarks>
+	public bool IsHardwareAccelerated
+	{
+		get => (bool)GetValue(IsHardwareAcceleratedProperty);
+		set => SetValue(IsHardwareAcceleratedProperty, value);
+	}
+
+	/// <summary>
+	/// Gets or sets whether touch events are enabled.
+	/// </summary>
+	public bool EnableTouchEvents
+	{
+		get => (bool)GetValue(EnableTouchEventsProperty);
+		set => SetValue(EnableTouchEventsProperty, value);
+	}
+
+	/// <summary>
+	/// Occurs when the surface needs to be painted.
+	/// </summary>
+	public event EventHandler<SKPaintDynamicSurfaceEventArgs>? PaintSurface;
+
+	/// <summary>
+	/// Occurs when a touch event is detected.
+	/// </summary>
+	public event EventHandler<SKTouchEventArgs>? Touch;
+
+	/// <summary>
+	/// Gets the current canvas size.
+	/// </summary>
+	public SKSize CanvasSize => canvasView?.CanvasSize ?? glView?.CanvasSize ?? SKSize.Empty;
+
+	/// <summary>
+	/// Invalidates the surface and requests a redraw.
+	/// </summary>
+	public void InvalidateSurface()
+	{
+		if (canvasView?.IsLoadedEx() == true)
+			canvasView?.InvalidateSurface();
+
+		if (glView?.IsLoadedEx() == true)
+			glView?.InvalidateSurface();
+	}
+
+	/// <inheritdoc/>
+	protected override void OnApplyTemplate()
+	{
+		base.OnApplyTemplate();
+
+		// Unsubscribe from old views
+		if (canvasView is not null)
+		{
+			canvasView.PaintSurface -= OnCanvasPaintSurface;
+			canvasView.Touch -= OnTouch;
+			canvasView = null;
+		}
+
+		if (glView is not null)
+		{
+			glView.PaintSurface -= OnGLPaintSurface;
+			glView.Touch -= OnTouch;
+			glView = null;
+		}
+
+		// Get the new canvas view from template
+		var canvasChild = GetTemplateChild("PART_CanvasSurface");
+		if (canvasChild is SKCanvasView cv)
+		{
+			canvasView = cv;
+			canvasView.PaintSurface += OnCanvasPaintSurface;
+			canvasView.Touch += OnTouch;
+			canvasView.EnableTouchEvents = EnableTouchEvents;
+			canvasView.IsVisible = !IsHardwareAccelerated;
+		}
+
+		// Get the new GL view from template
+		var glChild = GetTemplateChild("PART_GLSurface");
+		if (glChild is SKGLView gv)
+		{
+			glView = gv;
+			glView.PaintSurface += OnGLPaintSurface;
+			glView.Touch += OnTouch;
+			glView.EnableTouchEvents = EnableTouchEvents;
+			glView.IsVisible = IsHardwareAccelerated;
+		}
+	}
+
+	/// <summary>
+	/// Called when the surface needs to be painted.
+	/// </summary>
+	protected virtual void OnPaintSurface(SKPaintDynamicSurfaceEventArgs e) =>
+		PaintSurface?.Invoke(this, e);
+
+	/// <summary>
+	/// Called when a touch event occurs.
+	/// </summary>
+	protected virtual void OnTouch(SKTouchEventArgs e) =>
+		Touch?.Invoke(this, e);
+
+	private void OnCanvasPaintSurface(object? sender, SKPaintSurfaceEventArgs e) =>
+		OnPaintSurface(new SKPaintDynamicSurfaceEventArgs(e));
+
+	private void OnGLPaintSurface(object? sender, SKPaintGLSurfaceEventArgs e) =>
+		OnPaintSurface(new SKPaintDynamicSurfaceEventArgs(e));
+
+	private void OnTouch(object? sender, SKTouchEventArgs e) =>
+		OnTouch(e);
+
+	private void UpdateSurfaceVisibility()
+	{
+		if (canvasView is not null)
+			canvasView.IsVisible = !IsHardwareAccelerated;
+
+		if (glView is not null)
+			glView.IsVisible = IsHardwareAccelerated;
+
+		InvalidateSurface();
+	}
+
+	private void UpdateTouchEvents()
+	{
+		if (canvasView is not null)
+			canvasView.EnableTouchEvents = EnableTouchEvents;
+
+		if (glView is not null)
+			glView.EnableTouchEvents = EnableTouchEvents;
+	}
+
+	private static void OnIsHardwareAcceleratedChanged(BindableObject bindable, object? oldValue, object? newValue)
+	{
+		if (bindable is SKDynamicSurfaceView view)
+			view.UpdateSurfaceVisibility();
+	}
+
+	private static void OnEnableTouchEventsChanged(BindableObject bindable, object? oldValue, object? newValue)
+	{
+		if (bindable is SKDynamicSurfaceView view)
+			view.UpdateTouchEvents();
+	}
+}

source/SkiaSharp.Extended.UI.Maui/Controls/Gestures/SKDynamicSurfaceViewResources.shared.xaml

@@ -0,0 +1,29 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+                    xmlns:local="clr-namespace:SkiaSharp.Extended.UI.Controls"
+                    xmlns:skia="clr-namespace:SkiaSharp.Views.Maui.Controls;assembly=SkiaSharp.Views.Maui.Controls"
+                    x:Class="SkiaSharp.Extended.UI.Controls.Themes.SKDynamicSurfaceViewResources">
+
+    <!-- 
+        Control template for SKDynamicSurfaceView.
+        Uses both a Canvas view (software) and GL view (hardware) with visibility toggling.
+    -->
+    <ControlTemplate x:Key="SKDynamicSurfaceViewControlTemplate">
+        <Grid>
+            <skia:SKCanvasView x:Name="PART_CanvasSurface" />
+            <skia:SKGLView x:Name="PART_GLSurface" IsVisible="False" />
+        </Grid>
+    </ControlTemplate>
+
+    <!-- The explicit style that allows for extension -->
+    <Style x:Key="SKDynamicSurfaceViewStyle" TargetType="local:SKDynamicSurfaceView">
+        <Setter Property="ControlTemplate"
+                Value="{StaticResource SKDynamicSurfaceViewControlTemplate}" />
+    </Style>
+
+    <!-- The implicit style that applies to all controls -->
+    <Style TargetType="local:SKDynamicSurfaceView"
+           ApplyToDerivedTypes="True"
+           BasedOn="{StaticResource SKDynamicSurfaceViewStyle}" />
+
+</ResourceDictionary>

source/SkiaSharp.Extended.UI.Maui/Controls/Gestures/SKDynamicSurfaceViewResources.shared.xaml.cs

@@ -0,0 +1,15 @@
+namespace SkiaSharp.Extended.UI.Controls.Themes;
+
+/// <summary>
+/// XAML resources for <see cref="SKDynamicSurfaceView"/>.
+/// </summary>
+public partial class SKDynamicSurfaceViewResources : ResourceDictionary
+{
+	/// <summary>
+	/// Creates a new instance.
+	/// </summary>
+	public SKDynamicSurfaceViewResources()
+	{
+		InitializeComponent();
+	}
+}

source/SkiaSharp.Extended.UI.Maui/Controls/Gestures/SKFlingDetectedEventArgs.shared.cs

@@ -0,0 +1,33 @@
+namespace SkiaSharp.Extended.UI.Controls;
+
+/// <summary>
+/// Event arguments for when a fling gesture is detected.
+/// </summary>
+public class SKFlingDetectedEventArgs : EventArgs
+{
+	/// <summary>
+	/// Creates a new instance with the specified velocities.
+	/// </summary>
+	/// <param name="velocityX">The velocity in the X direction in pixels per second.</param>
+	/// <param name="velocityY">The velocity in the Y direction in pixels per second.</param>
+	public SKFlingDetectedEventArgs(float velocityX, float velocityY)
+	{
+		VelocityX = velocityX;
+		VelocityY = velocityY;
+	}
+
+	/// <summary>
+	/// Gets the velocity in the X direction in pixels per second.
+	/// </summary>
+	public float VelocityX { get; }
+
+	/// <summary>
+	/// Gets the velocity in the Y direction in pixels per second.
+	/// </summary>
+	public float VelocityY { get; }
+
+	/// <summary>
+	/// Gets or sets whether the event has been handled.
+	/// </summary>
+	public bool Handled { get; set; }
+}

source/SkiaSharp.Extended.UI.Maui/Controls/Gestures/SKGestureEventArgs.shared.cs

@@ -0,0 +1,27 @@
+namespace SkiaSharp.Extended.UI.Controls;
+
+/// <summary>
+/// Event arguments for gesture start and end events.
+/// </summary>
+public class SKGestureEventArgs : EventArgs
+{
+	/// <summary>
+	/// Creates a new instance with the specified touch locations.
+	/// </summary>
+	/// <param name="locations">The locations of all active touch points.</param>
+	public SKGestureEventArgs(IEnumerable<SKPoint> locations)
+	{
+		ArgumentNullException.ThrowIfNull(locations);
+		Locations = locations.ToArray();
+	}
+
+	/// <summary>
+	/// Gets the locations of all active touch points.
+	/// </summary>
+	public IReadOnlyList<SKPoint> Locations { get; }
+
+	/// <summary>
+	/// Gets or sets whether the event has been handled.
+	/// </summary>
+	public bool Handled { get; set; }
+}

source/SkiaSharp.Extended.UI.Maui/Controls/Gestures/SKGestureSurfaceView.FlingTracker.shared.cs

@@ -0,0 +1,85 @@
+namespace SkiaSharp.Extended.UI.Controls;
+
+public partial class SKGestureSurfaceView
+{
+	/// <summary>
+	/// Tracks touch events to calculate fling velocity.
+	/// </summary>
+	private sealed class FlingTracker
+	{
+		// Use only events from the last 200 ms
+		private const long ThresholdTicks = 200 * TimeSpan.TicksPerMillisecond;
+		private const int MaxSize = 2;
+
+		private readonly Dictionary<long, Queue<FlingTrackerEvent>> events = new();
+
+		public void AddEvent(long id, SKPoint location, long ticks)
+		{
+			if (!events.TryGetValue(id, out var queue))
+			{
+				queue = new Queue<FlingTrackerEvent>();
+				events[id] = queue;
+			}
+
+			queue.Enqueue(new FlingTrackerEvent(location.X, location.Y, ticks));
+
+			if (queue.Count > MaxSize)
+				queue.Dequeue();
+		}
+
+		public void RemoveId(long id)
+		{
+			events.Remove(id);
+		}
+
+		public void Clear()
+		{
+			events.Clear();
+		}
+
+		public SKPoint CalculateVelocity(long id, long now)
+		{
+			float velocityX = 0;
+			float velocityY = 0;
+
+			if (!events.TryGetValue(id, out var queue) || queue.Count != 2)
+				return SKPoint.Empty;
+
+			var array = queue.ToArray();
+
+			var lastItem = array[0];
+			var nowItem = array[1];
+
+			// Use last 2 events to calculate velocity
+			if (now - lastItem.TimeTicks < ThresholdTicks)
+			{
+				var timeDelta = nowItem.TimeTicks - lastItem.TimeTicks;
+				if (timeDelta > 0)
+				{
+					velocityX = (nowItem.X - lastItem.X) * TimeSpan.TicksPerSecond / timeDelta;
+					velocityY = (nowItem.Y - lastItem.Y) * TimeSpan.TicksPerSecond / timeDelta;
+				}
+			}
+
+			// Return the velocity in pixels per second
+			return new SKPoint(velocityX, velocityY);
+		}
+
+		/// <summary>
+		/// Represents a single event used for fling velocity calculation.
+		/// </summary>
+		private readonly struct FlingTrackerEvent
+		{
+			public FlingTrackerEvent(float x, float y, long timeTicks)
+			{
+				X = x;
+				Y = y;
+				TimeTicks = timeTicks;
+			}
+
+			public float X { get; }
+			public float Y { get; }
+			public long TimeTicks { get; }
+		}
+	}
+}