Refactor to handle bad luck in accelerated mouse deltas.

Basically, bias towards choosing mouse, but if timestamps are available,
we can check the previous event and ensure that false-mouses are avoided.

Author: moffatman

lib/web_ui/lib/src/engine/pointer_binding.dart

@@ -349,7 +349,7 @@ mixin _WheelEventListenerMixin on _BaseAdapter {
     return (wheelDelta - (-3 * delta)).abs() > 1;
   }
 
-  bool _isTrackpadEvent(DomWheelEvent event, DomWheelEvent? lastWheelEvent) {
+  bool _isTrackpadEvent(DomWheelEvent event, DomWheelEvent? lastEvent) {
     // This function relies on deprecated and non-standard implementation
     // details. Useful reference material can be found below.
     //
@@ -364,25 +364,38 @@ mixin _WheelEventListenerMixin on _BaseAdapter {
       // wheel events.
       return false;
     }
-    if ((event.deltaX % 120 == 0) && (event.deltaY % 120 == 0)) {
+    if (_isAcceleratedMouseWheelDelta(event.deltaX, event.wheelDeltaX) ||
+        _isAcceleratedMouseWheelDelta(event.deltaY, event.wheelDeltaY)) {
+      return false;
+    }
+    if (((event.deltaX % 120 == 0) && (event.deltaY % 120 == 0)) ||
+        (((event.wheelDeltaX ?? 1) % 240 == 0) && ((event.wheelDeltaY ?? 1) % 240) == 0)) {
       // While not in any formal web standard, `blink` and `webkit` browsers use
       // a delta of 120 to represent one mouse wheel turn. If both dimensions of
       // the delta are divisible by 120, this event is probably from a mouse.
-      final num deltaXChange = (event.deltaX - (lastWheelEvent?.deltaX ?? 0)).abs();
-      final num deltaYChange = (event.deltaY - (lastWheelEvent?.deltaY ?? 0)).abs();
-      if ((lastWheelEvent == null) ||
+      // Checking if wheelDeltaX and wheelDeltaY are both divisible by 240
+      // catches any macOS accelerated mouse wheel deltas which by random chance
+      // are not caught by _isAcceleratedMouseWheelDelta.
+      final num deltaXChange = (event.deltaX - (lastEvent?.deltaX ?? 0)).abs();
+      final num deltaYChange = (event.deltaY - (lastEvent?.deltaY ?? 0)).abs();
+      if ((lastEvent == null) ||
           (deltaXChange == 0 && deltaYChange == 0) ||
-          !(deltaXChange < 10 && deltaYChange < 10)) {
+          !(deltaXChange < 20 && deltaYChange < 20)) {
         // A trackpad event might by chance have a delta of exactly 120, so
         // make sure this event does not have a similar delta to the previous
         // one before calling it a mouse event.
+        if (event.timeStamp != null && lastEvent?.timeStamp != null) {
+          // If the event has a large delta to the previous event, check if
+          // it was preceded within 50 milliseconds by a trackpad event. This
+          // handles unlucky 120-delta trackpad events during rapid movement.
+          final num diffMs = event.timeStamp! - lastEvent!.timeStamp!;
+          if (diffMs < 50 && _isTrackpadEvent(lastEvent, null)) {
+            return true;
+          }
+        }
         return false;
       }
     }
-    if (_isAcceleratedMouseWheelDelta(event.deltaX, event.wheelDeltaX) ||
-        _isAcceleratedMouseWheelDelta(event.deltaY, event.wheelDeltaY)) {
-      return false;
-    }
     return true;
   }
 

lib/web_ui/test/engine/pointer_binding_test.dart

@@ -1185,6 +1185,28 @@ void testMain() {
         wheelDeltaY: -360,
       ));
 
+      glassPane.dispatchEvent(context.wheel(
+        buttons: 0,
+        clientX: 10,
+        clientY: 10,
+        deltaX: 119,
+        deltaY: 119,
+        wheelDeltaX: -357,
+        wheelDeltaY: -357,
+        timeStamp: 10,
+      ));
+
+      glassPane.dispatchEvent(context.wheel(
+        buttons: 0,
+        clientX: 10,
+        clientY: 10,
+        deltaX: -120,
+        deltaY: -120,
+        wheelDeltaX: 360,
+        wheelDeltaY: 360,
+        timeStamp: 20,
+      ));
+
       glassPane.dispatchEvent(context.wheel(
         buttons: 0,
         clientX: 10,
@@ -1205,7 +1227,7 @@ void testMain() {
         wheelDeltaY: -360,
       ));
 
-      expect(packets, hasLength(4));
+      expect(packets, hasLength(6));
 
       // An add will be synthesized.
       expect(packets[0].data, hasLength(2));
@@ -1248,39 +1270,72 @@ void testMain() {
       expect(packets[1].data[0].scrollDeltaX, equals(120.0));
       expect(packets[1].data[0].scrollDeltaY, equals(120.0));
 
-      // Because the delta is in increments of 120, and is not similar to
-      // the previous event, it will be a mouse event.
-      expect(packets[2].data, hasLength(1));
+      // Because the delta is not in increments of 120 and has matching wheelDelta,
+      // it will be a trackpad event.
       expect(packets[2].data[0].change, equals(ui.PointerChange.hover));
       expect(
           packets[2].data[0].signalKind, equals(ui.PointerSignalKind.scroll));
       expect(
-          packets[2].data[0].kind, equals(ui.PointerDeviceKind.mouse));
+          packets[2].data[0].kind, equals(ui.PointerDeviceKind.trackpad));
       expect(packets[2].data[0].pointerIdentifier, equals(0));
       expect(packets[2].data[0].synthesized, isFalse);
       expect(packets[2].data[0].physicalX, equals(10.0 * dpi));
       expect(packets[2].data[0].physicalY, equals(10.0 * dpi));
       expect(packets[2].data[0].physicalDeltaX, equals(0.0));
       expect(packets[2].data[0].physicalDeltaY, equals(0.0));
-      expect(packets[2].data[0].scrollDeltaX, equals(0.0));
-      expect(packets[2].data[0].scrollDeltaY, equals(-120.0));
+      expect(packets[2].data[0].scrollDeltaX, equals(119.0));
+      expect(packets[2].data[0].scrollDeltaY, equals(119.0));
 
-      // Because the delta is not in increments of 120 and has non-matching
-      // wheelDelta, it will be a mouse event.
-      expect(packets[3].data, hasLength(1));
+      // Because the delta is in increments of 120, and is not similar to the
+      // previous event, but occured soon after the previous event, it will be
+      // a trackpad event.
       expect(packets[3].data[0].change, equals(ui.PointerChange.hover));
       expect(
           packets[3].data[0].signalKind, equals(ui.PointerSignalKind.scroll));
       expect(
-          packets[3].data[0].kind, equals(ui.PointerDeviceKind.mouse));
+          packets[3].data[0].kind, equals(ui.PointerDeviceKind.trackpad));
       expect(packets[3].data[0].pointerIdentifier, equals(0));
       expect(packets[3].data[0].synthesized, isFalse);
       expect(packets[3].data[0].physicalX, equals(10.0 * dpi));
       expect(packets[3].data[0].physicalY, equals(10.0 * dpi));
       expect(packets[3].data[0].physicalDeltaX, equals(0.0));
       expect(packets[3].data[0].physicalDeltaY, equals(0.0));
-      expect(packets[3].data[0].scrollDeltaX, equals(0.0));
-      expect(packets[3].data[0].scrollDeltaY, equals(40.0));
+      expect(packets[3].data[0].scrollDeltaX, equals(-120.0));
+      expect(packets[3].data[0].scrollDeltaY, equals(-120.0));
+
+      // Because the delta is in increments of 120, and is not similar to
+      // the previous event, and does not have a timestamp, it will be a mouse event.
+      expect(packets[4].data, hasLength(1));
+      expect(packets[4].data[0].change, equals(ui.PointerChange.hover));
+      expect(
+          packets[4].data[0].signalKind, equals(ui.PointerSignalKind.scroll));
+      expect(
+          packets[4].data[0].kind, equals(ui.PointerDeviceKind.mouse));
+      expect(packets[4].data[0].pointerIdentifier, equals(0));
+      expect(packets[4].data[0].synthesized, isFalse);
+      expect(packets[4].data[0].physicalX, equals(10.0 * dpi));
+      expect(packets[4].data[0].physicalY, equals(10.0 * dpi));
+      expect(packets[4].data[0].physicalDeltaX, equals(0.0));
+      expect(packets[4].data[0].physicalDeltaY, equals(0.0));
+      expect(packets[4].data[0].scrollDeltaX, equals(0.0));
+      expect(packets[4].data[0].scrollDeltaY, equals(-120.0));
+
+      // Because the delta is not in increments of 120 and has non-matching
+      // wheelDelta, it will be a mouse event.
+      expect(packets[5].data, hasLength(1));
+      expect(packets[5].data[0].change, equals(ui.PointerChange.hover));
+      expect(
+          packets[5].data[0].signalKind, equals(ui.PointerSignalKind.scroll));
+      expect(
+          packets[5].data[0].kind, equals(ui.PointerDeviceKind.mouse));
+      expect(packets[5].data[0].pointerIdentifier, equals(0));
+      expect(packets[5].data[0].synthesized, isFalse);
+      expect(packets[5].data[0].physicalX, equals(10.0 * dpi));
+      expect(packets[5].data[0].physicalY, equals(10.0 * dpi));
+      expect(packets[5].data[0].physicalDeltaX, equals(0.0));
+      expect(packets[5].data[0].physicalDeltaY, equals(0.0));
+      expect(packets[5].data[0].scrollDeltaX, equals(0.0));
+      expect(packets[5].data[0].scrollDeltaY, equals(40.0));
     },
   );
 
@@ -2993,6 +3048,7 @@ mixin _ButtonedEventMixin on _BasicEventContext {
     required double? deltaY,
     double? wheelDeltaX,
     double? wheelDeltaY,
+    int? timeStamp,
   }) {
     final Function jsWheelEvent = js_util.getProperty<Function>(domWindow, 'WheelEvent');
     final List<dynamic> eventArgs = <dynamic>[
@@ -3005,6 +3061,7 @@ mixin _ButtonedEventMixin on _BasicEventContext {
         'deltaY': deltaY,
         'wheelDeltaX': wheelDeltaX,
         'wheelDeltaY': wheelDeltaY,
+        'timeStamp': timeStamp,
       }
     ];
     return js_util.callConstructor<DomEvent>(