mouse tracking (refer to 1811d574 (diff-f41d041ddd3fe665cc9e123f992bb5e0))

Runtime/gestures/binding.cs

 
             //leave events
             foreach (var lastMoveTarget in this.lastMoveTargets) {
-                lastMoveTarget.handleEvent(new PointerLeaveEvent(
+                lastMoveTarget.handleEvent(new PointerExitEvent(
                     timeStamp: evt.timeStamp,
                     pointer: evt.pointer,
                     device: evt.device,

Runtime/gestures/events.cs

                 position: position,
                 down: false) {
         }
+
+        public static PointerEnterEvent fromHoverEvent(PointerHoverEvent hover) {
+            return new PointerEnterEvent(
+                timeStamp: hover.timeStamp,
+                pointer: hover.pointer,
+                kind: hover.kind,
+                device: hover.device,
+                position: hover.position
+                );
+        }
-    public class PointerLeaveEvent : PointerEvent {
-        public PointerLeaveEvent(
+    public class PointerExitEvent : PointerEvent {
+        public PointerExitEvent(
             TimeSpan timeStamp,
             int pointer = 0,
             PointerDeviceKind kind = PointerDeviceKind.mouse,
                 device: device,
                 position: position,
                 down: false) {
+        }
+        
+        public static PointerExitEvent fromHoverEvent(PointerHoverEvent hover) {
+            return new PointerExitEvent(
+                timeStamp: hover.timeStamp,
+                pointer: hover.pointer,
+                kind: hover.kind,
+                device: hover.device,
+                position: hover.position
+            );
         }
     }
 

Runtime/rendering/binding.cs

             this.initRenderView();
             D.assert(this.renderView != null);
             this.addPersistentFrameCallback(this._handlePersistentFrameCallback);
+            this._mouseTracker = this._createMouseTracker();
         }
 
         public void initRenderView() {
         }
+
+        public MouseTracker mouseTracker {
+            get { return this._mouseTracker; }
+        }
+        MouseTracker _mouseTracker;
 
         public PipelineOwner pipelineOwner {
             get { return this._pipelineOwner; }
 
         void _handlePersistentFrameCallback(TimeSpan timeStamp) {
             this.drawFrame();
+        }
+
+        MouseTracker _createMouseTracker() {
+            return new MouseTracker(this.pointerRouter, (Offset offset) => {
+                return this.renderView.layer.find<MouseTrackerAnnotation>(
+                        offset * Window.instance.devicePixelRatio
+                    );
+            });
         }
 
         protected virtual void drawFrame() {

Runtime/rendering/layer.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using Unity.UIWidgets.external.simplejson;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.ui;
             D.assert(!this.attached);
         }
 
+        internal abstract S find<S>(Offset regionOffset) where S : class;
+
         internal abstract flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null);
 
         internal void _addToSceneWithRetainedRendering(SceneBuilder builder) {
             }
         }
 
+        internal override S find<S>(Offset regionOffset) {
+            return null;
+        }
+
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
 
         public readonly bool freeze;
 
+        internal override S find<S>(Offset regionOffset) {
+            return null;
+        }
+
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
         public Layer lastChild {
             get { return this._lastChild; }
         }
+        
+        internal override S find<S>(Offset regionOffset) {
+            Layer current = this.lastChild;
+            while (current != null) {
+                S value = current.find<S>(regionOffset);
+                if (value != null) {
+                    return value;
+                }
+
+                current = current.previousSibling;
+            }
+
+            return null;
+        }
 
         internal Layer _lastChild;
 
             }
         }
 
+        internal override S find<S>(Offset regionOffset) {
+            return base.find<S>(regionOffset - this.offset);
+        }
+
         public override void applyTransform(Layer child, Matrix3 transform) {
             D.assert(child != null);
             D.assert(transform != null);
             }
         }
 
+        internal override S find<S>(Offset regionOffset) {
+            if (!this.clipRect.contains(regionOffset)) {
+                return null;
+            }
+
+            return base.find<S>(regionOffset);
+        }
+
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             }
         }
 
+        internal override S find<S>(Offset regionOffset) {
+            if (!this.clipRRect.contains(regionOffset)) {
+                return null;
+            }
+
+            return base.find<S>(regionOffset);
+        }
+
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
             }
         }
 
+        internal override S find<S>(Offset regionOffset) {
+            if (!this.clipPath.contains(regionOffset)) {
+                return null;
+            }
+
+            return base.find<S>(regionOffset);
+        }
+
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
 
         public Matrix3 transform {
             get { return this._transform; }
-            set { this._transform = value; }
+            set {
+                this._transform = value;
+                this._inverseDirty = true;
+            }
+        readonly Matrix3 _invertedTransform = Matrix3.I();
+        bool _inverseDirty = true;
+
+        internal override S find<S>(Offset regionOffset) {
+            if (this._inverseDirty) {
+                this.transform.invert(this._invertedTransform);
+                this._inverseDirty = false;
+            }
+
+            if (this._invertedTransform == null) {
+                return null;
+            }
+            
+            Offset transform = this._invertedTransform.mapXY(regionOffset.dx, regionOffset.dy);
+            return base.find<S>(transform);
+        }
+
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
 
         internal Offset _lastOffset;
 
+        internal override S find<S>(Offset regionOffset) {
+            return base.find<S>(regionOffset - this.offset);
+        }
+
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
 
         Offset _lastOffset;
         Matrix3 _lastTransform;
+
+        Matrix3 _invertedTransform = Matrix3.I();
+        bool _inverseDirty = true;
+
+        internal override S find<S>(Offset regionOffset) {
+            if (this.link.leader == null) {
+                return this.showWhenUnlinked ? base.find<S>(regionOffset - this.unlinkedOffset) : null;
+            }
+
+            if (this._inverseDirty) {
+                this.getLastTransform().invert(this._invertedTransform);
+                this._inverseDirty = false;
+            }
+
+            if (this._invertedTransform == null) {
+                return null;
+            }
+
+            Offset transform = this._invertedTransform.mapXY(regionOffset.dx, regionOffset.dy);
+            return base.find<S>(transform - this.linkedOffset);
+        }
 
         public Matrix3 getLastTransform() {
             if (this._lastTransform == null) {
             inverseTransform.preConcat(forwardTransform);
             inverseTransform.preTranslate(this.linkedOffset.dx, this.linkedOffset.dy);
             this._lastTransform = inverseTransform;
+            this._inverseDirty = true;
+        
 
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
                 this._lastTransform = null;
                 this._lastOffset = null;
+                this._inverseDirty = true;
                 return null;
             }
 
                 builder.pop();
             }
 
+            this._inverseDirty = true;
             return null;
         }
 
 
         public readonly int optionsMask;
 
+        internal override S find<S>(Offset regionOffset) {
+            return null;
+        }
+
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
 
 
         public readonly Offset offset;
 
+        internal override S find<S>(Offset regionOffset) {
+            S result = base.find<S>(regionOffset);
+            if (result != null) {
+                return result;
+            }
+
+            if (this.size != null && !(this.offset & this.size).contains(regionOffset)) {
+                return null;
+            }
+
+            if (typeof(T) == typeof(S)) {
+                S typedResult = this.value as S;
+                return typedResult;
+            }
+
+            return base.find<S>(regionOffset);
+        }
+
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             base.debugFillProperties(properties);
             properties.add(new DiagnosticsProperty<T>("value", this.value));
         }
 
         Color _shadowColor;
+
+        internal override S find<S>(Offset regionOffset) {
+            if (!this.clipPath.contains(regionOffset)) {
+                return null;
+            }
+
+            return base.find<S>(regionOffset);
+        }
 
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;

Runtime/rendering/paragraph.cs

             if (evt is PointerEnterEvent) {
                 this._pointerHoverInside = true;
             }
-            else if (evt is PointerLeaveEvent) {
+            else if (evt is PointerExitEvent) {
                 this._pointerHoverInside = false;
                 this._previousHoverSpan?.hoverRecognizer?.OnPointerLeave?.Invoke();
                 this._previousHoverSpan = null;

Runtime/rendering/proxy_box.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 
     public delegate void PointerCancelEventListener(PointerCancelEvent evt);
 
-    public delegate void PointerHoverEventListener(PointerHoverEvent evt);
-
-    public delegate void PointerEnterEventListener(PointerEnterEvent evt);
-
-    public delegate void PointerLeaveEventListener(PointerLeaveEvent evt);
-
     public delegate void PointerScrollEventListener(PointerScrollEvent evt);
 
     public class RenderPointerListener : RenderProxyBoxWithHitTestBehavior {
+            PointerEnterEventListener onPointerEnter = null,
+            PointerHoverEventListener onPointerHover = null,
+            PointerExitEventListener onPointerExit = null,
-            PointerHoverEventListener onPointerHover = null,
-            PointerLeaveEventListener onPointerLeave = null,
-            PointerEnterEventListener onPointerEnter = null,
             PointerScrollEventListener onPointerScroll = null,
             HitTestBehavior behavior = HitTestBehavior.deferToChild,
             RenderBox child = null
             this.onPointerUp = onPointerUp;
             this.onPointerCancel = onPointerCancel;
-            this.onPointerHover = onPointerHover;
-            this.onPointerLeave = onPointerLeave;
-            this.onPointerEnter = onPointerEnter;
+
+            this._onPointerEnter = onPointerEnter;
+            this._onPointerHover = onPointerHover;
+            this._onPointerExit = onPointerExit;
+
+            if (this._onPointerEnter != null || this._onPointerHover != null || this._onPointerExit != null) {
+                this._hoverAnnotation = new MouseTrackerAnnotation(
+                    onEnter: this._onPointerEnter,
+                    onHover: this._onPointerHover,
+                    onExit: this._onPointerExit);
+            }
         }
 
         public PointerDownEventListener onPointerDown;
+        public PointerEnterEventListener onPointerEnter {
+            get { return this._onPointerEnter; }
+            set {
+                if (this._onPointerEnter != value) {
+                    this._onPointerEnter = value;
+                    this._updateAnnotations();
+                }
+            }
+        }
+        PointerEnterEventListener _onPointerEnter;
+
+        public PointerHoverEventListener onPointerHover {
+            get { return this._onPointerHover; }
+            set {
+                if (this._onPointerHover != value) {
+                    this._onPointerHover = value;
+                    this._updateAnnotations();
+                }
+            }
+        }
+        PointerHoverEventListener _onPointerHover;
+
+        public PointerExitEventListener onPointerExit {
+            get { return this._onPointerExit; }
+            set {
+                if (this._onPointerExit != value) {
+                    this._onPointerExit = value;
+                    this._updateAnnotations();
+                }
+            }
+        }
+        PointerExitEventListener _onPointerExit;
+
-        public PointerHoverEventListener onPointerHover;
+        public PointerScrollEventListener onPointerScroll;
+
+        MouseTrackerAnnotation _hoverAnnotation;
+
+        void _updateAnnotations() {
+            if (this._hoverAnnotation != null && this.attached) {
+                RendererBinding.instance.mouseTracker.detachAnnotation(this._hoverAnnotation);
+            }
+            
+            if (this._onPointerEnter != null || this._onPointerHover != null || this._onPointerExit != null)
+            {
+                this._hoverAnnotation = new MouseTrackerAnnotation(
+                    onEnter: this._onPointerEnter,
+                    onHover: this._onPointerHover,
+                    onExit: this._onPointerExit);
-        public PointerLeaveEventListener onPointerLeave;
+                if (this.attached) {
+                    RendererBinding.instance.mouseTracker.attachAnnotation(this._hoverAnnotation);
+                }
+            }
+            else {
+                this._hoverAnnotation = null;
+            }
+        }
-        public PointerEnterEventListener onPointerEnter;
+        public override void attach(Object owner) {
+            base.attach(owner);
+            if (this._hoverAnnotation != null) {
+                RendererBinding.instance.mouseTracker.attachAnnotation(this._hoverAnnotation);
+            }
+        }
-        public PointerScrollEventListener onPointerScroll;
+        public override void detach() {
+            base.detach();
+            if (this._hoverAnnotation != null) {
+                RendererBinding.instance.mouseTracker.detachAnnotation(this._hoverAnnotation);
+            }
+        }
+
+        public override void paint(PaintingContext context, Offset offset) {
+            if (this._hoverAnnotation != null) {
+                AnnotatedRegionLayer<MouseTrackerAnnotation> layer = new AnnotatedRegionLayer<MouseTrackerAnnotation>(
+                    this._hoverAnnotation, size: this.size, offset: offset);
+                
+                context.pushLayer(layer, base.paint, offset);
+            }
+            base.paint(context, offset);
+        }
 
         protected override void performResize() {
             this.size = this.constraints.biggest;
                 return;
             }
 
-            if (this.onPointerHover != null && evt is PointerHoverEvent) {
-                this.onPointerHover((PointerHoverEvent) evt);
-                return;
-            }
-
-            if (this.onPointerLeave != null && evt is PointerLeaveEvent) {
-                this.onPointerLeave((PointerLeaveEvent) evt);
-                return;
-            }
-
-            if (this.onPointerEnter != null && evt is PointerEnterEvent) {
-                this.onPointerEnter((PointerEnterEvent) evt);
-                return;
-            }
-
             if (this.onPointerScroll != null && evt is PointerScrollEvent) {
                 this.onPointerScroll((PointerScrollEvent) evt);
             }
                 listeners.Add("move");
             }
 
-            if (this.onPointerUp != null) {
-                listeners.Add("up");
+            if (this.onPointerEnter != null) {
+                listeners.Add("enter");
-            if (this.onPointerCancel != null) {
-                listeners.Add("cancel");
+            if (this.onPointerHover != null) {
+                listeners.Add("hover");
-            if (this.onPointerHover != null) {
-                listeners.Add("hover");
+            if (this.onPointerExit != null) {
+                listeners.Add("exit");
-            if (this.onPointerEnter != null) {
-                listeners.Add("enter");
+            if (this.onPointerUp != null) {
+                listeners.Add("up");
-            if (this.onPointerLeave != null) {
-                listeners.Add("leave");
+            if (this.onPointerCancel != null) {
+                listeners.Add("cancel");
             }
 
             if (listeners.isEmpty()) {
 
         public override void paint(PaintingContext context, Offset offset) {
             AnnotatedRegionLayer<T> layer =
-                new AnnotatedRegionLayer<T>(value: this.value, size: this.sized ? this.size : null);
+                new AnnotatedRegionLayer<T>(
+                    value: this.value, 
+                    size: this.sized ? this.size : null,
+                    offset: this.sized ? offset : null);
+            
             context.pushLayer(layer, base.paint, offset);
         }
     }

Runtime/widgets/basic.cs

 using System.Collections.Generic;
 using System.Linq;
 using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
 using Unity.UIWidgets.ui;
             Key key = null,
             PointerDownEventListener onPointerDown = null,
             PointerMoveEventListener onPointerMove = null,
+            PointerEnterEventListener onPointerEnter = null,
+            PointerExitEventListener onPointerExit = null,
+            PointerHoverEventListener onPointerHover = null,
-            PointerHoverEventListener onPointerHover = null,
-            PointerLeaveEventListener onPointerLeave = null,
-            PointerEnterEventListener onPointerEnter = null,
             PointerScrollEventListener onPointerScroll = null,
             HitTestBehavior behavior = HitTestBehavior.deferToChild,
             Widget child = null
             this.onPointerUp = onPointerUp;
             this.onPointerCancel = onPointerCancel;
             this.onPointerHover = onPointerHover;
-            this.onPointerLeave = onPointerLeave;
+            this.onPointerExit = onPointerExit;
             this.onPointerEnter = onPointerEnter;
             this.onPointerScroll = onPointerScroll;
             this.behavior = behavior;
 
         public readonly PointerEnterEventListener onPointerEnter;
 
-        public readonly PointerLeaveEventListener onPointerLeave;
+        public readonly PointerExitEventListener onPointerExit;
 
         public readonly PointerScrollEventListener onPointerScroll;
 
                 onPointerUp: this.onPointerUp,
                 onPointerCancel: this.onPointerCancel,
                 onPointerEnter: this.onPointerEnter,
-                onPointerLeave: this.onPointerLeave,
+                onPointerExit: this.onPointerExit,
                 onPointerHover: this.onPointerHover,
                 onPointerScroll: this.onPointerScroll,
                 behavior: this.behavior
             renderObject.onPointerCancel = this.onPointerCancel;
             renderObject.onPointerEnter = this.onPointerEnter;
             renderObject.onPointerHover = this.onPointerHover;
-            renderObject.onPointerLeave = this.onPointerLeave;
+            renderObject.onPointerExit = this.onPointerExit;
             renderObject.onPointerScroll = this.onPointerScroll;
             renderObject.behavior = this.behavior;
         }
                 listeners.Add("hover");
             }
 
-            if (this.onPointerLeave != null) {
-                listeners.Add("leave");
+            if (this.onPointerExit != null) {
+                listeners.Add("exit");
             }
 
             if (this.onPointerScroll != null) {

Runtime/widgets/widget_inspector.cs

         // public  TextPainter _textPainter;
         // public float _textPainterMaxWidth;
 
+        internal override S find<S>(Offset regionOffset) {
+            return null;
+        }
 
         internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;

Samples/UIWidgetsGallery/gallery/app.cs

         public GalleryApp(
             Key key = null,
             UpdateUrlFetcher updateUrlFetcher = null,
-            bool enablePerformanceOverlay = true,
+            bool enablePerformanceOverlay = false,
             bool enableRasterCacheImagesCheckerboard = true,
             bool enableOffscreenLayersCheckerboard = true,
             VoidCallback onSendFeedback = null,

Tests/Editor/MouseHover.cs

                         this.setState(() => { this.hover = true; });
                     }
                 },
-                onPointerLeave: (evt) => {
+                onPointerExit: (evt) => {
                     if (this.mounted) {
                         this.setState(() => { this.hover = false; });
                     }

Runtime/gestures/mouse_tracking.cs

+using System.Collections.Generic;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.scheduler;
+using Unity.UIWidgets.ui;
+
+namespace Unity.UIWidgets.gestures {
+    
+    public delegate void PointerHoverEventListener(PointerHoverEvent evt);
+
+    public delegate void PointerEnterEventListener(PointerEnterEvent evt);
+
+    public delegate void PointerExitEventListener(PointerExitEvent evt);
+    
+    
+    public class MouseTrackerAnnotation {
+        public MouseTrackerAnnotation(
+            PointerEnterEventListener onEnter = null,
+            PointerHoverEventListener onHover = null,
+            PointerExitEventListener onExit = null
+        ) {
+            this.onEnter = onEnter;
+            this.onHover = onHover;
+            this.onExit = onExit;
+        }
+
+        public readonly PointerEnterEventListener onEnter;
+
+        public readonly PointerHoverEventListener onHover;
+
+        public readonly PointerExitEventListener onExit;
+
+        public override string ToString() {
+            return $"{this.GetType()}#{this.GetHashCode()}{(this.onEnter == null ? "" : " onEnter")}{(this.onHover == null ? "" : " onHover")}{(this.onExit == null ? "" : " onExit")}";
+        }
+    }
+
+    public class _TrackedAnnotation {
+        public _TrackedAnnotation(
+            MouseTrackerAnnotation annotation) {
+            this.annotation = annotation;
+        }
+        
+        public readonly MouseTrackerAnnotation annotation;
+
+        public HashSet<int> activeDevices = new HashSet<int>();
+    }
+
+    public delegate MouseTrackerAnnotation MouseDetectorAnnotationFinder(Offset offset);
+
+
+    public class MouseTracker {
+        public MouseTracker(
+            PointerRouter router,
+            MouseDetectorAnnotationFinder annotationFinder) {
+            router.addGlobalRoute(this._handleEvent);
+            this.annotationFinder = annotationFinder;
+        }
+        
+        Dictionary<int, PointerEvent> _lastMouseEvent = new Dictionary<int, PointerEvent>();
+
+        public bool mouseIsConnected {
+            get { return this._lastMouseEvent.isNotEmpty(); }
+        }
+
+        public readonly MouseDetectorAnnotationFinder annotationFinder;
+
+        public readonly Dictionary<MouseTrackerAnnotation, _TrackedAnnotation> _trackedAnnotations =
+            new Dictionary<MouseTrackerAnnotation, _TrackedAnnotation>();
+
+
+        public void attachAnnotation(MouseTrackerAnnotation annotation) {
+            this._trackedAnnotations[annotation] = new _TrackedAnnotation(annotation);
+            this._scheduleMousePositionCheck();
+        }
+
+        public void detachAnnotation(MouseTrackerAnnotation annotation) {
+            _TrackedAnnotation trackedAnnotation = this._findAnnotation(annotation);
+            D.assert(trackedAnnotation != null, $"Tried to detach an annotation that wasn't attached: {annotation}");
+            foreach (int deviceId in trackedAnnotation.activeDevices) {
+                annotation.onExit(PointerExitEvent.fromHoverEvent((PointerHoverEvent) this._lastMouseEvent[deviceId]));
+            }
+
+            this._trackedAnnotations.Remove(annotation);
+        }
+
+        void _scheduleMousePositionCheck() {
+            SchedulerBinding.instance.addPostFrameCallback(_ => { this.collectMousePositions();});
+            SchedulerBinding.instance.scheduleFrame();
+        }
+        
+        void _handleEvent(PointerEvent evt) {
+            if (evt.kind != PointerDeviceKind.mouse) {
+                return;
+            }
+
+            int deviceId = evt.device;
+            if (this._trackedAnnotations.isEmpty()) {
+                this._lastMouseEvent.Remove(deviceId);
+                return;
+            }
+
+            if (evt is PointerRemovedEvent) {
+                this._lastMouseEvent.Remove(deviceId);
+                this._scheduleMousePositionCheck();
+            }
+            else {
+                if (evt is PointerMoveEvent ||
+                    evt is PointerHoverEvent ||
+                    evt is PointerDownEvent) {
+                    if (!this._lastMouseEvent.ContainsKey(deviceId) ||
+                        this._lastMouseEvent[deviceId].position != evt.position) {
+                        this._scheduleMousePositionCheck();
+                    }
+
+                    this._lastMouseEvent[deviceId] = evt;
+                }
+            }
+        }
+
+        _TrackedAnnotation _findAnnotation(MouseTrackerAnnotation annotation) {
+            if (!this._trackedAnnotations.TryGetValue(annotation, out var trackedAnnotation)) {
+                D.assert(false, "Unable to find annotation $annotation in tracked annotations. " +
+                                "Check that attachAnnotation has been called for all annotated layers.");
+            }
+            
+            return trackedAnnotation;
+        }
+
+        public void collectMousePositions() {
+            void exitAnnotation(_TrackedAnnotation trackedAnnotation, int deviceId) {
+                if (trackedAnnotation.annotation?.onExit != null &&
+                    trackedAnnotation.activeDevices.Contains(deviceId)) {
+                    trackedAnnotation.annotation.onExit(PointerExitEvent.fromHoverEvent((PointerHoverEvent)this._lastMouseEvent[deviceId]));
+                }
+            }
+
+            void exitAllDevices(_TrackedAnnotation trackedAnnotation) {
+                if (trackedAnnotation.activeDevices.isNotEmpty()) {
+                    HashSet<int> deviceIds = new HashSet<int>(trackedAnnotation.activeDevices);
+                    foreach (int deviceId in deviceIds) {
+                        exitAnnotation(trackedAnnotation, deviceId);
+                    }
+                }
+            }
+
+            if (!this.mouseIsConnected) {
+                foreach (var annotation in this._trackedAnnotations.Values) {
+                    exitAllDevices(annotation);
+                }
+
+                return;
+            }
+
+            foreach (int deviceId in this._lastMouseEvent.Keys) {
+                PointerEvent lastEvent = this._lastMouseEvent[deviceId];
+                MouseTrackerAnnotation hit = this.annotationFinder(lastEvent.position);
+
+                if (hit == null) {
+                    foreach (_TrackedAnnotation trackedAnnotation in this._trackedAnnotations.Values) {
+                        exitAnnotation(trackedAnnotation, deviceId);
+                    }
+
+                    return;
+                }
+
+                _TrackedAnnotation hitAnnotation = this._findAnnotation(hit);
+                if (!hitAnnotation.activeDevices.Contains(deviceId)) {
+                    hitAnnotation.activeDevices.Add(deviceId);
+                    if (hitAnnotation.annotation?.onEnter != null) {
+                        hitAnnotation.annotation.onEnter(PointerEnterEvent.fromHoverEvent((PointerHoverEvent)lastEvent));
+                    }
+                }
+
+                if (hitAnnotation.annotation?.onHover != null) {
+                    hitAnnotation.annotation.onHover((PointerHoverEvent)lastEvent);
+                }
+
+                foreach (_TrackedAnnotation trackedAnnotation in this._trackedAnnotations.Values) {
+                    if (hitAnnotation == trackedAnnotation) {
+                        continue;
+                    }
+
+                    if (trackedAnnotation.activeDevices.Contains(deviceId)) {
+                        if (trackedAnnotation.annotation?.onExit != null) {
+                            trackedAnnotation.annotation.onExit(PointerExitEvent.fromHoverEvent((PointerHoverEvent)lastEvent));
+                        }
+
+                        trackedAnnotation.activeDevices.Remove(deviceId);
+                    }
+                }
+            }
+        }
+    }
+}