[Windows]Fixed the PointerGestureRecognizer behaves incorrectly when multiple windows are open. (dotnet#30537)

* Fixed the PointerGestureRecognizer events from another window interfere with the active window

* Optimize the fix

* Logging the error

* missed paramter

* - add some code to debounce when there are multi window scenarios

---------

Co-authored-by: Shane Neuville <shneuvil@microsoft.com>

Author: 2 people

src/Controls/src/Core/Platform/GestureManager/GesturePlatformManager.Windows.cs

@@ -19,6 +19,13 @@ class GesturePlatformManager : IDisposable
 		readonly IPlatformViewHandler _handler;
 		readonly NotifyCollectionChangedEventHandler _collectionChangedHandler;
 		readonly List<uint> _fingers = new List<uint>();
+		// Dictionary to track when each pointer last entered, used to work around a bug where
+		// PointerEntered events fire unexpectedly in multi-window scenarios
+		readonly Dictionary<uint, DateTime> _lastPointerEnteredTime = new();
+		// Debounce window in milliseconds - if two PointerEntered events for the same pointer
+		// occur within this timeframe in a multi-window scenario, the second one is likely
+		// the bug manifesting and should be ignored
+		const int POINTER_DEBOUNCE_MS = 1000;
 		FrameworkElement? _container;
 		FrameworkElement? _control;
 		VisualElement? _element;
@@ -594,12 +601,55 @@ void OnPointerReleased(object sender, PointerRoutedEventArgs e)
 		}
 
 		void OnPgrPointerEntered(object sender, PointerRoutedEventArgs e)
-			=> HandlePgrPointerEvent(e, (view, recognizer)
-				=> recognizer.SendPointerEntered(view, (relativeTo)
-					=> GetPosition(relativeTo, e), _control is null ? null : new PlatformPointerEventArgs(_control, e)));
+		{
+
+			var pointerId = e.Pointer?.PointerId ?? uint.MaxValue;
+			var now = DateTime.UtcNow;
+			
+			// Periodic cleanup when dictionary gets large - this should never happen since each
+			// PointerEntered should have a matching PointerExited that cleans up the entry,
+			// but we include this as a safety measure to prevent unbounded memory growth.
+			// We clean up entries older than twice the debounce window.
+			if (_lastPointerEnteredTime.Count > 5)
+			{
+				var cutoff = now.AddMilliseconds(-POINTER_DEBOUNCE_MS * 2);
+				var keysToRemove = _lastPointerEnteredTime.Where(kvp => kvp.Value < cutoff).Select(kvp => kvp.Key).ToList();
+				foreach (var key in keysToRemove)
+					_lastPointerEnteredTime.Remove(key);
+			}
+			
+			// Multi-window bug workaround: There's a specific bug where PointerEntered events
+			// fire unexpectedly when multiple windows are open. We work around this by 
+			// debouncing - if the same pointer had an Enter event recently and we have multiple
+			// windows open, we ignore the duplicate event. Only applies in multi-window scenarios
+			// to avoid performance overhead in normal single-window usage.
+			if (_lastPointerEnteredTime.TryGetValue(pointerId, out var lastTime) && 
+				(now - lastTime).TotalMilliseconds < POINTER_DEBOUNCE_MS && HasMultipleWindows())
+			{
+				return;
+			}
+			
+			// Track this pointer's entry time for future debounce checks
+			_lastPointerEnteredTime[pointerId] = now;
+			
+			HandlePgrPointerEvent(e, (view, recognizer)
+						=> recognizer.SendPointerEntered(view, (relativeTo)
+							=> GetPosition(relativeTo, e), _control is null ? null : new PlatformPointerEventArgs(_control, e)));
+		}
 
 		void OnPgrPointerExited(object sender, PointerRoutedEventArgs e)
 		{
+			
+			// Clean up debounce tracking when pointer exits, but only for relevant events.
+			// This is part of the multi-window bug workaround. We only clean up tracking
+			// for events that are relevant to our current element's window to avoid clearing
+			// tracking data when spurious events from other windows occur.
+			if (IsPointerEventRelevantToCurrentElement(e))
+			{
+				var pointerId = e.Pointer?.PointerId ?? uint.MaxValue;
+				_lastPointerEnteredTime.Remove(pointerId);
+			}
+			
 			HandlePgrPointerEvent(e, (view, recognizer)
 						=> recognizer.SendPointerExited(view, (relativeTo)
 							=> GetPosition(relativeTo, e), _control is null ? null : new PlatformPointerEventArgs(_control, e)));
@@ -647,13 +697,54 @@ private void HandlePgrPointerEvent(PointerRoutedEventArgs e, Action<View, Pointe
 				return;
 			}
 
+			// Check if the pointer event is relevant to the current element's window
+			if (!IsPointerEventRelevantToCurrentElement(e))
+			{
+				return;
+			}
 			var pointerGestures = ElementGestureRecognizers.GetGesturesFor<PointerGestureRecognizer>();
 			foreach (var recognizer in pointerGestures)
 			{
 				SendPointerEvent.Invoke(view, recognizer);
 			}
 		}
 
+		/// <summary>
+		/// Determines if multiple windows are currently open. This is used to decide
+		/// whether to apply pointer event debouncing to work around a specific bug where
+		/// PointerEntered events fire unexpectedly in multi-window scenarios.
+		/// </summary>
+		/// <returns>True if multiple windows are open, false otherwise</returns>
+		bool HasMultipleWindows() => 
+			Application.Current?.Windows?.Count > 1;
+
+		bool IsPointerEventRelevantToCurrentElement(PointerRoutedEventArgs e)
+		{
+			// For multi-window scenarios, we need to validate that the pointer event
+			// is actually relevant to the current element's window
+			try
+			{
+				// Check if the container has a valid XamlRoot (indicates it's in a live window)
+				if (_container?.XamlRoot is null || e?.OriginalSource is null)
+				{
+					return false;
+				}
+				// Validate that the event source is from the same visual tree as our container
+				if (e.OriginalSource is FrameworkElement sourceElement && sourceElement.XamlRoot != _container.XamlRoot)
+				{
+					return false; // Event is from a different window
+				}
+
+				return true;
+			}
+			catch (Exception ex)
+			{
+				// Log the exception for diagnostics
+				Application.Current?.FindMauiContext()?.CreateLogger<GesturePlatformManager>()?.LogError(ex, "An error occurred while validating pointer event relevance.");
+				return false;
+			}
+		}
+
 		Point? GetPosition(IElement? relativeTo, RoutedEventArgs e)
 		{
 			var result = e.GetPositionRelativeToElement(relativeTo);