add unity object detector support

com.unity.uiwidgets/Runtime/gestures/converter.cs

                             D.assert(false); // This branch should already have 'none' filtered out.
                             break;
                         case ui.PointerSignalKind.editorDragMove: {
-                            Debug.Log($"c++ side editor drag move {position}");
                             yield return new PointerDragFromEditorHoverEvent(
                                 timeStamp: timeStamp,
                                 pointer: datum.pointerIdentifier,
                             break;
                         }
                         case ui.PointerSignalKind.editorDragRelease: {
-                            Debug.Log($"c++ side editor drag release {position}");
                             yield return new PointerDragFromEditorReleaseEvent(
                                 timeStamp: timeStamp,
                                 pointer: datum.pointerIdentifier,

com.unity.uiwidgets/Runtime/gestures/events.cs

             Offset position = null,
             Offset localPosition = null,
             Matrix4 transform = null,
+            Object[] objectReferences = null,
+            string[] paths = null,
             PointerDragFromEditorEnterEvent original = null
         ) : base(
             timeStamp,
             transform: transform,
             original: original
         ) {
+            this.objectReferences = objectReferences;
+            this.paths = paths;
+        
+        public Object[] objectReferences;
+        public string[] paths;
-        public static PointerDragFromEditorEnterEvent fromDragFromEditorEvent(PointerEvent evt) {
+        public static PointerDragFromEditorEnterEvent fromDragFromEditorEvent(PointerEvent evt,
+            Object[] objectReferences, string[] paths) {
             return new PointerDragFromEditorEnterEvent(
                 timeStamp: evt.timeStamp,
                 pointer: evt.pointer,
                 localPosition: evt.localPosition,
                 transform: evt.transform,
+                objectReferences: objectReferences,
+                paths: paths,
                 original: evt.original as PointerDragFromEditorEnterEvent
             );
         }
                 position: position,
                 localPosition: transformPosition(transform, position),
                 transform: transform,
+                objectReferences: objectReferences,
+                paths: paths,
                 original: original as PointerDragFromEditorEnterEvent ?? this
             );
         }
             Offset position = null,
             Offset localPosition = null,
             Object[] objectReferences = null,
+            string[] paths = null,
             Matrix4 transform = null,
             PointerDragFromEditorReleaseEvent original = null
         ) : base(
             original: original
         ) {
             this.objectReferences = objectReferences;
+            this.paths = paths;
+        public string[] paths;
-            Object[] objectReferences) {
+            Object[] objectReferences, string[] paths) {
             return new PointerDragFromEditorReleaseEvent(
                 timeStamp: evt.timeStamp,
                 pointer: evt.pointer,
                 localPosition: evt.localPosition,
                 objectReferences: objectReferences,
+                paths: paths,
                 transform: evt.transform,
                 original: evt.original as PointerDragFromEditorReleaseEvent
             );

com.unity.uiwidgets/Editor/gesture.meta

+fileFormatVersion: 2
+guid: acbe72faebec34ea3832cc33152ff6ab
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.uiwidgets/Editor/widgets.meta

+fileFormatVersion: 2
+guid: 3bdd889f92fa4e7a9fc1fa29df736e55
+timeCreated: 1637914329

com.unity.uiwidgets/Editor/gesture/binding.cs

+using System;
+using System.Collections.Generic;
+using Unity.UIWidgets.gestures;
+using Unity.UIWidgets.ui;
+
+namespace Unity.UIWidgets.widgets {
+    public class UiWidgetsEditorBinding : UiWidgetsBinding {
+        public new static UiWidgetsEditorBinding instance {
+            get { return (UiWidgetsEditorBinding) UiWidgetsBinding.instance; }
+            set { UiWidgetsBinding.instance = value; }
+        }
+        
+        public static UiWidgetsEditorBinding ensureInitializedForEditor() {
+            if (UiWidgetsEditorBinding.instance == null) {
+                return new UiWidgetsEditorBinding();
+            }
+            
+            return UiWidgetsEditorBinding.instance;
+        }
+        
+        public EditorMouseTracker editorMouseTracker {
+            get { return _editorMouseTracker; }
+        }
+
+        EditorMouseTracker _editorMouseTracker;
+
+        private void initEditorMouseTracker(EditorMouseTracker tracker  = null) {
+            _editorMouseTracker?.dispose();
+            _editorMouseTracker = tracker ?? new EditorMouseTracker(pointerRouter, hitTestMouseTrackers);
+        }
+
+        public EditorMouseTrackerAnnotation hitTestMouseTrackers(Offset position) {
+            List<EditorMouseTrackerAnnotation> annotations = 
+                new List<EditorMouseTrackerAnnotation>(renderView.layer.findAllAnnotations<EditorMouseTrackerAnnotation>(
+                position * renderView.configuration.devicePixelRatio
+            ).annotations);
+
+            if (annotations is null || annotations.Count == 0) {
+                return null;
+            }
+
+            return annotations[0];
+        }
+
+        protected override void initInstances() {
+            base.initInstances();
+            
+            addPersistentFrameCallback(_handlePersistentFrameCallbackForEditor);
+            initEditorMouseTracker();
+        }
+
+        private void _handlePersistentFrameCallbackForEditor(TimeSpan timeStamp) {
+            _editorMouseTracker.schedulePostFrameCheck();
+        }
+    }
+    
+    public static class editor_ui_ {
+        public static void runEditorApp(Widget app) {
+            var instance = UiWidgetsEditorBinding.ensureInitializedForEditor();
+            instance.scheduleAttachRootWidget(app);
+            instance.scheduleWarmUpFrame();
+        }
+    }
+}

com.unity.uiwidgets/Editor/gesture/binding.cs.meta

+fileFormatVersion: 2
+guid: 4a770ce594324a7eb95b9457697ace16
+timeCreated: 1637749525

com.unity.uiwidgets/Editor/gesture/editor_mouse_tracking.cs

+using System.Collections.Generic;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.scheduler;
+using Unity.UIWidgets.ui;
+using UnityEditor;
+
+namespace Unity.UIWidgets.gestures {
+    public delegate void PointerDragFromEditorEnterEventListener(PointerDragFromEditorEnterEvent evt);
+
+    public delegate void PointerDragFromEditorHoverEventListener(PointerDragFromEditorHoverEvent evt);
+
+    public delegate void PointerDragFromEditorExitEventListener(PointerDragFromEditorExitEvent evt);
+
+    public delegate void PointerDragFromEditorReleaseEventListener(PointerDragFromEditorReleaseEvent evt);
+    
+    public delegate EditorMouseTrackerAnnotation EditorMouseDetectorAnnotationFinder(Offset offset);
+
+    public class EditorMouseTrackerAnnotation {
+        public EditorMouseTrackerAnnotation(
+            PointerDragFromEditorEnterEventListener onDragFromEditorEnter = null,
+            PointerDragFromEditorHoverEventListener onDragFromEditorHover = null,
+            PointerDragFromEditorExitEventListener onDragFromEditorExit = null,
+            PointerDragFromEditorReleaseEventListener onDragFromEditorRelease = null
+        ) {
+            this.onDragFromEditorEnter = onDragFromEditorEnter;
+            this.onDragFromEditorHover = onDragFromEditorHover;
+            this.onDragFromEditorExit = onDragFromEditorExit;
+            this.onDragFromEditorRelease = onDragFromEditorRelease;
+        }
+
+        public readonly PointerDragFromEditorEnterEventListener onDragFromEditorEnter;
+        public readonly PointerDragFromEditorHoverEventListener onDragFromEditorHover;
+        public readonly PointerDragFromEditorExitEventListener onDragFromEditorExit;
+        public readonly PointerDragFromEditorReleaseEventListener onDragFromEditorRelease;
+    }
+
+    public class _EditorTrackedAnnotation {
+        public _EditorTrackedAnnotation(EditorMouseTrackerAnnotation annotation) {
+            this.annotation = annotation;
+        }
+
+        public readonly EditorMouseTrackerAnnotation annotation;
+
+        public HashSet<int> activeDevices = new HashSet<int>();
+    }
+
+    public class EditorMouseTracker : ChangeNotifier {
+        public readonly Dictionary<int, PointerEvent> _lastMouseEvent = new Dictionary<int, PointerEvent>();
+        public bool mouseIsConnected => _lastMouseEvent.isNotEmpty();
+
+        public readonly EditorMouseDetectorAnnotationFinder annotationFinder;
+
+        public readonly Dictionary<EditorMouseTrackerAnnotation, _EditorTrackedAnnotation> _trackedAnnotations =
+            new Dictionary<EditorMouseTrackerAnnotation, _EditorTrackedAnnotation>();
+
+        public void attachDragFromEditorAnnotation(EditorMouseTrackerAnnotation annotation) {
+            _trackedAnnotations[annotation] = new _EditorTrackedAnnotation(annotation);
+            _scheduleDragFromEditorMousePositionCheck();
+        }
+
+        public void detachDragFromEditorAnnotation(EditorMouseTrackerAnnotation annotation) {
+            var trackedAnnotation = _findAnnotation(annotation);
+            foreach (var deviceId in trackedAnnotation.activeDevices) {
+                annotation.onDragFromEditorExit(PointerDragFromEditorExitEvent.fromDragFromEditorEvent(
+                    _lastMouseEvent[deviceId]
+                ));
+            }
+
+            _trackedAnnotations.Remove(annotation);
+        }
+
+        _EditorTrackedAnnotation _findAnnotation(EditorMouseTrackerAnnotation annotation) {
+            if (!_trackedAnnotations.TryGetValue(annotation, out var trackedAnnotation)) {
+                D.assert(false, () => $"Unable to find annotation {annotation} in tracked annotations.");
+            }
+
+            return trackedAnnotation;
+        }
+
+        public EditorMouseTracker(
+            PointerRouter router,
+            EditorMouseDetectorAnnotationFinder annotationFinder
+        ) {
+            D.assert(router != null);
+            D.assert(annotationFinder != null);
+            router.addGlobalRoute(route: _handleEvent);
+            this.annotationFinder = annotationFinder;
+        }
+
+        public void _handleEvent(PointerEvent evt) {
+
+            //Debug.Log("handle editor mouse tracker event = " + evt.position);
+            int deviceId = 0;
+
+            if (_trackedAnnotations.isEmpty()) {
+                _lastMouseEvent.Remove(deviceId);
+                return;
+            }
+            
+            if (evt is PointerDragFromEditorReleaseEvent) {
+                _scheduleDragFromEditorReleaseCheck();
+                _lastMouseEvent.Remove(deviceId);
+            }
+            else if (evt is PointerDragFromEditorEnterEvent ||
+                     evt is PointerDragFromEditorHoverEvent ||
+                     evt is PointerDragFromEditorExitEvent) {
+                if (!_lastMouseEvent.ContainsKey(deviceId) ||
+                    _lastMouseEvent[deviceId].position != evt.position) {
+                    _scheduleDragFromEditorMousePositionCheck();
+                }
+
+                _lastMouseEvent[deviceId] = evt;
+            }
+        }
+
+        public void schedulePostFrameCheck() {
+            
+        }
+
+        void _handleDragFromEditorEvent(PointerEvent evt, int deviceId) {
+            if (evt is PointerDragFromEditorReleaseEvent) {
+                _scheduleDragFromEditorReleaseCheck();
+                _lastMouseEvent.Remove(deviceId);
+            }
+            else if (evt is PointerDragFromEditorEnterEvent ||
+                     evt is PointerDragFromEditorHoverEvent ||
+                     evt is PointerDragFromEditorExitEvent) {
+                if (!_lastMouseEvent.ContainsKey(deviceId) ||
+                    _lastMouseEvent[deviceId].position != evt.position) {
+                    _scheduleDragFromEditorMousePositionCheck();
+                }
+
+                _lastMouseEvent[deviceId] = evt;
+            }
+        }
+
+        void _scheduleDragFromEditorReleaseCheck() {
+            DragAndDrop.AcceptDrag();
+
+            var lastMouseEvent = new List<PointerEvent>();
+            foreach (int deviceId in _lastMouseEvent.Keys) {
+                var _deviceId = deviceId;
+                var deviceEvent = _lastMouseEvent[_deviceId];
+
+                //only process PointerEditorDragEvents
+                if (!(deviceEvent is PointerDragFromEditorEnterEvent ||
+                      deviceEvent is PointerDragFromEditorHoverEvent ||
+                      deviceEvent is PointerDragFromEditorExitEvent)) {
+                    continue;
+                }
+
+                lastMouseEvent.Add(_lastMouseEvent[_deviceId]);
+                SchedulerBinding.instance.addPostFrameCallback(_ => {
+                    foreach (var lastEvent in lastMouseEvent) {
+                        EditorMouseTrackerAnnotation hit = annotationFinder(lastEvent.position);
+
+                        if (hit == null) {
+                            foreach (_EditorTrackedAnnotation trackedAnnotation in _trackedAnnotations.Values) {
+                                if (trackedAnnotation.activeDevices.Contains(_deviceId)) {
+                                    trackedAnnotation.activeDevices.Remove(_deviceId);
+                                }
+                            }
+
+                            return;
+                        }
+
+                        _EditorTrackedAnnotation hitAnnotation = _findAnnotation(hit);
+
+                        // release
+                        if (hitAnnotation.activeDevices.Contains(_deviceId)) {
+                            if (hitAnnotation.annotation?.onDragFromEditorRelease != null) {
+                                hitAnnotation.annotation.onDragFromEditorRelease(
+                                    PointerDragFromEditorReleaseEvent
+                                        .fromDragFromEditorEvent(
+                                            lastEvent, DragAndDrop.objectReferences, DragAndDrop.paths));
+                            }
+
+                            hitAnnotation.activeDevices.Remove(_deviceId);
+                        }
+                    }
+                });
+            }
+
+            SchedulerBinding.instance.scheduleFrame();
+        }
+
+        void _scheduleDragFromEditorMousePositionCheck() {
+            SchedulerBinding.instance.addPostFrameCallback(_ => { collectDragFromEditorMousePositions(); });
+            SchedulerBinding.instance.scheduleFrame();
+        }
+
+        public void collectDragFromEditorMousePositions() {
+            void exitAnnotation(_EditorTrackedAnnotation trackedAnnotation, int deviceId) {
+                if (trackedAnnotation.activeDevices.Contains(deviceId)) {
+                    if (trackedAnnotation.annotation?.onDragFromEditorExit != null) {
+                        trackedAnnotation.annotation.onDragFromEditorExit(
+                            PointerDragFromEditorExitEvent.fromDragFromEditorEvent(
+                                _lastMouseEvent[deviceId]));
+                    }
+
+                    trackedAnnotation.activeDevices.Remove(deviceId);
+                }
+            }
+
+            void exitAllDevices(_EditorTrackedAnnotation trackedAnnotation) {
+                if (trackedAnnotation.activeDevices.isNotEmpty()) {
+                    HashSet<int> deviceIds = new HashSet<int>(trackedAnnotation.activeDevices);
+                    foreach (int deviceId in deviceIds) {
+                        exitAnnotation(trackedAnnotation, deviceId);
+                    }
+                }
+            }
+
+            if (!mouseIsConnected) {
+                foreach (var annotation in _trackedAnnotations.Values) {
+                    exitAllDevices(annotation);
+                }
+
+                return;
+            }
+
+            foreach (int deviceId in _lastMouseEvent.Keys) {
+                PointerEvent lastEvent = _lastMouseEvent[deviceId];
+                EditorMouseTrackerAnnotation hit = annotationFinder(lastEvent.position);
+
+                if (hit == null) {
+                    foreach (_EditorTrackedAnnotation trackedAnnotation in _trackedAnnotations.Values) {
+                        exitAnnotation(trackedAnnotation, deviceId);
+                    }
+
+                    return;
+                }
+
+                _EditorTrackedAnnotation hitAnnotation = _findAnnotation(hit);
+
+                // While acrossing two areas, set the flag to true to prevent setting the Pointer Copy VisualMode to None
+                bool enterFlag = false;
+
+                // enter
+                if (!hitAnnotation.activeDevices.Contains(deviceId)) {
+                    hitAnnotation.activeDevices.Add(deviceId);
+                    enterFlag = true;
+                    // Both onRelease or onEnter event will enable Copy VisualMode
+                    if (hitAnnotation.annotation?.onDragFromEditorRelease != null ||
+                        hitAnnotation.annotation?.onDragFromEditorEnter != null) {
+                        if (hitAnnotation.annotation?.onDragFromEditorEnter != null) {
+                            hitAnnotation.annotation.onDragFromEditorEnter(
+                                PointerDragFromEditorEnterEvent
+                                    .fromDragFromEditorEvent(lastEvent, DragAndDrop.objectReferences, DragAndDrop.paths));
+                        }
+                    }
+                }
+
+                // hover
+                if (hitAnnotation.annotation?.onDragFromEditorHover != null) {
+                    hitAnnotation.annotation.onDragFromEditorHover(
+                        PointerDragFromEditorHoverEvent.fromDragFromEditorEvent(lastEvent));
+                }
+
+                // leave
+                foreach (_EditorTrackedAnnotation trackedAnnotation in _trackedAnnotations.Values) {
+                    if (hitAnnotation == trackedAnnotation) {
+                        continue;
+                    }
+
+                    if (trackedAnnotation.activeDevices.Contains(deviceId)) {
+                        if (trackedAnnotation.annotation?.onDragFromEditorExit != null) {
+                            trackedAnnotation.annotation.onDragFromEditorExit(
+                                PointerDragFromEditorExitEvent
+                                    .fromDragFromEditorEvent(lastEvent));
+                        }
+
+                        trackedAnnotation.activeDevices.Remove(deviceId);
+                    }
+                }
+            }
+        }
+    }
+}

com.unity.uiwidgets/Editor/gesture/editor_mouse_tracking.cs.meta

+fileFormatVersion: 2
+guid: d4a8f193e3d549a8bf5093b001ea327b
+timeCreated: 1637750451

com.unity.uiwidgets/Editor/widgets/unity_editor_listener.cs

+using System.Collections.Generic;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.rendering;
+using Unity.UIWidgets.ui;
+using Unity.UIWidgets.widgets;
+
+namespace Unity.UIWidgets.gestures
+{
+    public class UnityEditorListener : SingleChildRenderObjectWidget
+    {
+        public UnityEditorListener(
+            Key key = null,
+            PointerDragFromEditorEnterEventListener onPointerDragFromEditorEnter = null,
+            PointerDragFromEditorHoverEventListener onPointerDragFromEditorHover = null,
+            PointerDragFromEditorExitEventListener onPointerDragFromEditorExit = null,
+            PointerDragFromEditorReleaseEventListener onPointerDragFromEditorRelease = null,
+            HitTestBehavior behavior = HitTestBehavior.deferToChild,
+            Widget child = null) : base(key: key, child: child)
+        {
+            this.onPointerDragFromEditorEnter = onPointerDragFromEditorEnter;
+            this.onPointerDragFromEditorHover = onPointerDragFromEditorHover;
+            this.onPointerDragFromEditorExit = onPointerDragFromEditorExit;
+            this.onPointerDragFromEditorRelease = onPointerDragFromEditorRelease;
+            this.behavior = behavior;
+        }
+
+        public readonly PointerDragFromEditorEnterEventListener onPointerDragFromEditorEnter;
+        public readonly PointerDragFromEditorHoverEventListener onPointerDragFromEditorHover;
+        public readonly PointerDragFromEditorExitEventListener onPointerDragFromEditorExit;
+        public readonly PointerDragFromEditorReleaseEventListener onPointerDragFromEditorRelease;
+        public readonly HitTestBehavior behavior;
+        
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new UnityEditorRenderPointerListener(
+                onPointerDragFromEditorEnter: onPointerDragFromEditorEnter,
+                onPointerDragFromEditorHover: onPointerDragFromEditorHover,
+                onPointerDragFromEditorExit: onPointerDragFromEditorExit,
+                onPointerDragFromEditorRelease: onPointerDragFromEditorRelease,
+                behavior: behavior
+            );
+        }
+
+        public override void updateRenderObject(BuildContext context, RenderObject renderObjectRaw) {
+            var renderObject = (UnityEditorRenderPointerListener) renderObjectRaw;
+            renderObject.behavior = behavior;
+            renderObject.onPointerDragFromEditorEnter = onPointerDragFromEditorEnter;
+            renderObject.onPointerDragFromEditorHover = onPointerDragFromEditorHover;
+            renderObject.onPointerDragFromEditorExit = onPointerDragFromEditorExit;
+            renderObject.onPointerDragFromEditorRelease = onPointerDragFromEditorRelease;
+        }
+
+        public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+            base.debugFillProperties(properties);
+            List<string> listeners = new List<string>();
+            if (onPointerDragFromEditorEnter != null) {
+                listeners.Add("dragFromEditorEnter");
+            }
+
+            if (onPointerDragFromEditorHover != null) {
+                listeners.Add("dragFromEditorHover");
+            }
+
+            if (onPointerDragFromEditorExit != null) {
+                listeners.Add("dragFromEditorExit");
+            }
+
+            if (onPointerDragFromEditorRelease != null) {
+                listeners.Add("dragFromEditorRelease");
+            }
+            properties.add(new EnumerableProperty<string>("listeners", listeners, ifEmpty: "<none>"));
+            properties.add(new EnumProperty<HitTestBehavior>("behavior", behavior));
+        }
+    }
+    
+    
+    public class UnityEditorRenderPointerListener : RenderProxyBoxWithHitTestBehavior {
+    public UnityEditorRenderPointerListener(
+        PointerDragFromEditorEnterEventListener onPointerDragFromEditorEnter = null,
+        PointerDragFromEditorHoverEventListener onPointerDragFromEditorHover = null,
+        PointerDragFromEditorExitEventListener onPointerDragFromEditorExit = null,
+        PointerDragFromEditorReleaseEventListener onPointerDragFromEditorRelease = null,
+        HitTestBehavior behavior = HitTestBehavior.deferToChild,
+        RenderBox child = null
+    ) : base(behavior: behavior, child: child) {
+        _onPointerDragFromEditorEnter = onPointerDragFromEditorEnter;
+        _onPointerDragFromEditorHover = onPointerDragFromEditorHover;
+        _onPointerDragFromEditorExit = onPointerDragFromEditorExit;
+        _onPointerDragFromEditorRelease = onPointerDragFromEditorRelease;
+
+        if (_onPointerDragFromEditorEnter != null ||
+            _onPointerDragFromEditorHover != null ||
+            _onPointerDragFromEditorExit != null ||
+            _onPointerDragFromEditorRelease != null
+        ) {
+            _hoverAnnotation = new EditorMouseTrackerAnnotation(
+                onDragFromEditorEnter: _onPointerDragFromEditorEnter,
+                onDragFromEditorHover: _onPointerDragFromEditorHover,
+                onDragFromEditorExit: _onPointerDragFromEditorExit,
+                onDragFromEditorRelease: _onPointerDragFromEditorRelease
+            );
+        }
+    }
+
+    PointerDragFromEditorEnterEventListener _onPointerDragFromEditorEnter;
+
+    public PointerDragFromEditorEnterEventListener onPointerDragFromEditorEnter {
+        get { return _onPointerDragFromEditorEnter; }
+        set {
+            if (_onPointerDragFromEditorEnter != value) {
+                _onPointerDragFromEditorEnter = value;
+                _updateAnnotations();
+            }
+        }
+    }
+
+    PointerDragFromEditorExitEventListener _onPointerDragFromEditorExit;
+
+    public PointerDragFromEditorExitEventListener onPointerDragFromEditorExit {
+        get { return _onPointerDragFromEditorExit; }
+        set {
+            if (_onPointerDragFromEditorExit != value) {
+                _onPointerDragFromEditorExit = value;
+                _updateAnnotations();
+            }
+        }
+    }
+
+    PointerDragFromEditorHoverEventListener _onPointerDragFromEditorHover;
+
+    public PointerDragFromEditorHoverEventListener onPointerDragFromEditorHover {
+        get { return _onPointerDragFromEditorHover; }
+        set {
+            if (_onPointerDragFromEditorHover != value) {
+                _onPointerDragFromEditorHover = value;
+                _updateAnnotations();
+            }
+        }
+    }
+
+    PointerDragFromEditorReleaseEventListener _onPointerDragFromEditorRelease;
+
+    public PointerDragFromEditorReleaseEventListener onPointerDragFromEditorRelease {
+        get { return _onPointerDragFromEditorRelease; }
+        set {
+            if (_onPointerDragFromEditorRelease != value) {
+                _onPointerDragFromEditorRelease = value;
+                _updateAnnotations();
+            }
+        }
+    }
+
+    EditorMouseTrackerAnnotation _hoverAnnotation;
+
+        public EditorMouseTrackerAnnotation hoverAnnotation {
+            get { return _hoverAnnotation; }
+        }
+
+        void _updateAnnotations() {
+            D.assert(_onPointerDragFromEditorEnter != _hoverAnnotation.onDragFromEditorEnter
+                     || _onPointerDragFromEditorHover != _hoverAnnotation.onDragFromEditorHover
+                     || _onPointerDragFromEditorExit != _hoverAnnotation.onDragFromEditorExit
+                     || _onPointerDragFromEditorRelease != _hoverAnnotation.onDragFromEditorRelease
+                     , () => "Shouldn't call _updateAnnotations if nothing has changed.");
+
+            if (_hoverAnnotation != null && attached) {
+                UiWidgetsEditorBinding.instance.editorMouseTracker.detachDragFromEditorAnnotation(_hoverAnnotation);
+            }
+
+            if (_onPointerDragFromEditorEnter != null
+                || _onPointerDragFromEditorHover != null
+                || _onPointerDragFromEditorExit != null
+                || _onPointerDragFromEditorRelease != null
+            ) {
+                _hoverAnnotation = new EditorMouseTrackerAnnotation(
+                    onDragFromEditorEnter: _onPointerDragFromEditorEnter
+                    , onDragFromEditorHover: _onPointerDragFromEditorHover
+                    , onDragFromEditorExit: _onPointerDragFromEditorExit
+                    , onDragFromEditorRelease: _onPointerDragFromEditorRelease
+                );
+
+                if (attached) {
+                    UiWidgetsEditorBinding.instance.editorMouseTracker.attachDragFromEditorAnnotation(_hoverAnnotation);
+                }
+            }
+            else {
+                _hoverAnnotation = null;
+            }
+
+            markNeedsPaint();
+        }
+
+        public override void attach(object owner) {
+            base.attach(owner);
+            if (_hoverAnnotation != null) {
+                UiWidgetsEditorBinding.instance.editorMouseTracker.attachDragFromEditorAnnotation(_hoverAnnotation);
+            }
+        }
+
+        public override void detach() {
+            base.detach();
+            if (_hoverAnnotation != null) {
+                UiWidgetsEditorBinding.instance.editorMouseTracker.detachDragFromEditorAnnotation(_hoverAnnotation);
+            }
+        }
+
+        public override void paint(PaintingContext context, Offset offset) {
+            if (_hoverAnnotation != null) {
+                AnnotatedRegionLayer<EditorMouseTrackerAnnotation> layer = new AnnotatedRegionLayer<EditorMouseTrackerAnnotation>(
+                    _hoverAnnotation, size: size, offset: offset);
+
+                context.pushLayer(layer, base.paint, offset);
+            }
+            else {
+                base.paint(context, offset);
+            }
+        }
+
+        protected override void performResize() {
+            size = constraints.biggest;
+        }
+    }
+}

com.unity.uiwidgets/Editor/widgets/unity_editor_listener.cs.meta

+fileFormatVersion: 2
+guid: ce9c6d444c634f238d062461e1b513b7
+timeCreated: 1637724477

com.unity.uiwidgets/Editor/widgets/unity_object_detector.cs

+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.rendering;
+using Unity.UIWidgets.ui;
+using Unity.UIWidgets.widgets;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.UIWidgets.gestures
+{
+    public delegate void DragInEditorEnterCallback(DragFromEditorDetails details);
+
+    public delegate void DragInEditorHoverCallback(DragFromHoverEditorDetails details);
+
+    public delegate void DragInEditorExitCallback();
+
+    public delegate void DragInEditorReleaseCallback(DragFromEditorDetails details);
+
+    public class DragFromEditorDetails {
+        public DragFromEditorDetails(Object[] objectReferences, string[] paths, Offset position) {
+            this.objectReferences = objectReferences;
+            this.paths = paths;
+            this.position = position;
+        }
+
+        public readonly Object[] objectReferences;
+        public readonly string[] paths;
+        public readonly Offset position;
+    }
+    public class DragFromHoverEditorDetails {
+        public DragFromHoverEditorDetails( Offset position) {
+        
+            this.position = position;
+        }
+        public readonly Offset position;
+    }
+
+    public class UnityObjectDetector : StatefulWidget {
+        public UnityObjectDetector(
+            Key key = null,
+            Widget child = null,
+            DragInEditorEnterCallback onEnter = null,
+            DragInEditorHoverCallback onHover = null,
+            DragInEditorExitCallback onExit = null,
+            DragInEditorReleaseCallback onRelease = null,
+            HitTestBehavior? behavior = null
+        ) : base(key: key) {
+            this.child = child;
+            onDragInEditorEnter = onEnter;
+            onDragInEditorHover = onHover;
+            onDragInEditorExit = onExit;
+            onDragInEditorRelease = onRelease;
+            this.behavior = behavior;
+        }
+
+        public readonly Widget child;
+
+        public readonly DragInEditorEnterCallback onDragInEditorEnter;
+        public readonly DragInEditorHoverCallback onDragInEditorHover;
+        public readonly DragInEditorExitCallback onDragInEditorExit;
+        public readonly DragInEditorReleaseCallback onDragInEditorRelease;
+
+        public readonly HitTestBehavior? behavior;
+
+        public override State createState() {
+            return new UnityObjectDetectorState();
+        }
+    }
+
+    public class UnityObjectDetectorState : State<UnityObjectDetector> {
+        HitTestBehavior _defaultBehavior {
+            get { return widget.child == null ? HitTestBehavior.translucent : HitTestBehavior.deferToChild; }
+        }
+
+        private bool isActivated = false;
+
+        private Object[] objectReferences;
+
+        private string[] paths;
+
+        private Offset position;
+
+        private bool isUnityObjectDragging()
+        {
+            var dragObjects = DragAndDrop.objectReferences;
+            var dragPaths = DragAndDrop.paths;
+
+            if (dragObjects != null && dragObjects.Length == 1 ||
+                dragPaths != null && dragPaths.Length == 1)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public override Widget build(BuildContext context) 
+        {
+            Widget result = new UnityEditorListener(
+                child: widget.child,
+                onPointerDragFromEditorEnter: widget.onDragInEditorEnter == null
+                    ? ((PointerDragFromEditorEnterEventListener) null)
+                    : evt => { widget.onDragInEditorEnter.Invoke(new DragFromEditorDetails(evt.objectReferences, evt.paths, evt.position)); },
+                onPointerDragFromEditorHover: widget.onDragInEditorHover == null
+                    ? ((PointerDragFromEditorHoverEventListener) null)
+                    : evt => {
+                       widget.onDragInEditorHover.Invoke(new DragFromHoverEditorDetails(evt.position));
+                    },
+                onPointerDragFromEditorExit: widget.onDragInEditorExit == null
+                    ? ((PointerDragFromEditorExitEventListener) null)
+                    : evt => { widget.onDragInEditorExit.Invoke(); },
+                onPointerDragFromEditorRelease: widget.onDragInEditorRelease == null
+                    ? ((PointerDragFromEditorReleaseEventListener) null)
+                    : evt => {
+                        widget.onDragInEditorRelease.Invoke(new DragFromEditorDetails(evt.objectReferences, evt.paths, evt.position));
+                    },
+                behavior: widget.behavior ?? _defaultBehavior
+            );
+            return result;
+        }
+    }
+}

com.unity.uiwidgets/Editor/widgets/unity_object_detector.cs.meta

+fileFormatVersion: 2
+guid: 1e9774220f644e23992deb96ca656908
+timeCreated: 1637723510