Merge pull request #268 from Unity-Technologies/zxw/support_editor_dragdrop

Add support to Editor Drag&Drop

com.unity.uiwidgets/Editor/UIWidgetsEditorPanel.cs

                 var pos = _getPointerPosition(position: evt.mousePosition);
                 _wrapper.OnMouseScroll(delta: delta, pos: pos);
             }
+            else if (evt.type == EventType.DragUpdated) {
+                var pos = _getPointerPosition(position: evt.mousePosition);
+                _wrapper.OnDragUpdateInEditor(pos: pos);
+            }
+            else if (evt.type == EventType.DragPerform || evt.type == EventType.DragExited) {
+                var pos = _getPointerPosition(position: evt.mousePosition);
+                _wrapper.OnDragReleaseInEditor(pos: pos);
+            }
             else if (evt.isKey) {
                 _wrapper.OnKeyDown(e: evt);
                 Event.current.Use();

com.unity.uiwidgets/Runtime/engine/UIWidgetsPanelWrapper.cs

         public void OnPointerLeave() {
             UIWidgetsPanel_onMouseLeave(ptr: _ptr);
         }
+        
+        public void OnDragUpdateInEditor(Vector2? pos) {
+            if (pos == null) {
+                return;
+            }
+            
+            UIWidgetsPanel_onDragUpdateInEditor(ptr: _ptr, x: pos.Value.x, y: pos.Value.y);
+        }
+        
+        public void OnDragReleaseInEditor(Vector2? pos) {
+            if (pos == null) {
+                return;
+            }
+            
+            UIWidgetsPanel_onDragReleaseInEditor(ptr: _ptr, x: pos.Value.x, y: pos.Value.y);
+        }
 
         public void OnKeyDown(Event e) {
             int modifier = 0;
 
         [DllImport(dllName: NativeBindings.dllName)]
         static extern void UIWidgetsPanel_onScroll(IntPtr ptr, float x, float y, float px, float py);
+#if UNITY_EDITOR
+        [DllImport(dllName: NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onDragUpdateInEditor(IntPtr ptr, float x ,float y);
+        
+        [DllImport(dllName: NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onDragReleaseInEditor(IntPtr ptr, float x ,float y);
+#else
+        static void UIWidgetsPanel_onDragUpdateInEditor(IntPtr ptr, float x, float y) { throw new NotImplementedException(); }
+        
+        static void UIWidgetsPanel_onDragReleaseInEditor(IntPtr ptr, float x ,float y) { throw new NotImplementedException(); }
+#endif
     }
 
     #endregion

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

                         case ui.PointerSignalKind.none:
                             D.assert(false); // This branch should already have 'none' filtered out.
                             break;
+                        case ui.PointerSignalKind.editorDragMove: {
+                            yield return new PointerDragFromEditorHoverEvent(
+                                timeStamp: timeStamp,
+                                pointer: datum.pointerIdentifier,
+                                kind: kind,
+                                device: datum.device,
+                                position: position
+                            );
+                            break;
+                        }
+                        case ui.PointerSignalKind.editorDragRelease: {
+                            yield return new PointerDragFromEditorReleaseEvent(
+                                timeStamp: timeStamp,
+                                pointer: datum.pointerIdentifier,
+                                kind: kind,
+                                device: datum.device,
+                                position: position
+                            );
+                            break;
+                        }
                         case ui.PointerSignalKind.unknown:
                             // Ignore unknown signals.
                             break;

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/Runtime/ui/pointer.cs

     public enum PointerSignalKind {
         none,
         scroll,
+        editorDragMove,
+        editorDragRelease,
         unknown,
     }
 

com.unity.uiwidgets/Runtime/widgets/binding.cs

             _renderViewElement = null;
         }
 
-        internal void scheduleAttachRootWidget(Widget rootWidget) {
+        public void scheduleAttachRootWidget(Widget rootWidget) {
             Timer.run(() => {
                 attachRootWidget(rootWidget);
                 return null;

engine/src/lib/ui/window/pointer_data.h

   enum class SignalKind : int64_t {
     kNone,
     kScroll,
+    kEditorDragUpdate,
+    kEditorDragRelease
   };
 
   int64_t time_stamp;

engine/src/lib/ui/window/pointer_data_packet_converter.cc

         converted_pointers.push_back(pointer_data);
         break;
       }
+      case PointerData::SignalKind::kEditorDragUpdate: {
+        converted_pointers.push_back(pointer_data);
+        break;
+      }
+      case PointerData::SignalKind::kEditorDragRelease: {
+        converted_pointers.push_back(pointer_data);
+        break;
+      }
       default: {
         // Ignores unknown signal kind.
         break;

engine/src/shell/platform/embedder/embedder.cc

       return PointerData::SignalKind::kNone;
     case kUIWidgetsPointerSignalKindScroll:
       return PointerData::SignalKind::kScroll;
+    case kUIWidgetsPointerSignalKindEditorDragUpdate:
+      return PointerData::SignalKind::kEditorDragUpdate;
+    case kUIWidgetsPointerSignalKindEditorDragRelease:
+      return PointerData::SignalKind::kEditorDragRelease;
   }
   return PointerData::SignalKind::kNone;
 }

engine/src/shell/platform/embedder/embedder.h

 typedef enum {
   kUIWidgetsPointerSignalKindNone,
   kUIWidgetsPointerSignalKindScroll,
+  kUIWidgetsPointerSignalKindEditorDragUpdate,
+  kUIWidgetsPointerSignalKindEditorDragRelease
 } UIWidgetsPointerSignalKind;
 
 typedef struct {

engine/src/shell/platform/unity/darwin/macos/uiwidgets_panel.h

 
   void OnMouseLeave();
 
+  void OnDragUpdateInEditor(float x, float y);
+
+  void OnDragReleaseInEditor(float x, float y);
+
   bool NeedUpdateByPlayerLoop();
 
   bool NeedUpdateByEditorLoop();

engine/src/shell/platform/unity/darwin/macos/uiwidgets_panel.mm

   }
 }
 
+void UIWidgetsPanel::OnDragUpdateInEditor(float x, float y)
+{
+  if (process_events_) {
+    UIWidgetsPointerEvent event = {};
+    event.x = x;
+    event.y = y;
+    SetEventPhaseFromCursorButtonState(&event);
+    event.signal_kind = UIWidgetsPointerSignalKind::kUIWidgetsPointerSignalKindEditorDragUpdate;
+
+    SendPointerEventWithData(event);
+  }
+}
+
+void UIWidgetsPanel::OnDragReleaseInEditor(float x, float y)
+{
+  if (process_events_) {
+    UIWidgetsPointerEvent event = {};
+    event.x = x;
+    event.y = y;
+    SetEventPhaseFromCursorButtonState(&event);
+    event.signal_kind = UIWidgetsPointerSignalKind::kUIWidgetsPointerSignalKindEditorDragRelease;
+
+    SendPointerEventWithData(event);
+  }
+}
+
 static uint64_t ConvertToUIWidgetsButton(int button) {
   switch (button) {
     case -1:
 UIWIDGETS_API(void)
 UIWidgetsPanel_onScroll(UIWidgetsPanel* panel, float x, float y, float px, float py) {
   panel->OnScroll(x, y, px, py);
+}
+
+UIWIDGETS_API(void)
+UIWidgetsPanel_onDragUpdateInEditor(UIWidgetsPanel* panel, float x, float y) {
+  if (!panel->NeedUpdateByEditorLoop()) {
+    return;
+  }
+  panel->OnDragUpdateInEditor(x, y);
+}
+
+UIWIDGETS_API(void)
+UIWidgetsPanel_onDragReleaseInEditor(UIWidgetsPanel* panel, float x, float y) {
+  if (!panel->NeedUpdateByEditorLoop()) {
+    return;
+  }
+  panel->OnDragReleaseInEditor(x, y);
 }
 
 }  // namespace uiwidgets

engine/src/shell/platform/unity/windows/uiwidgets_panel.cc

   }
 }
 
+void UIWidgetsPanel::OnDragUpdateInEditor(float x, float y)
+{
+  if (process_events_) {
+    UIWidgetsPointerEvent event = {};
+    event.x = x;
+    event.y = y;
+    SetEventPhaseFromCursorButtonState(&event);
+    event.signal_kind = UIWidgetsPointerSignalKind::kUIWidgetsPointerSignalKindEditorDragUpdate;
+
+    SendPointerEventWithData(event);
+  }
+}
+
+void UIWidgetsPanel::OnDragReleaseInEditor(float x, float y)
+{
+  if (process_events_) {
+    UIWidgetsPointerEvent event = {};
+    event.x = x;
+    event.y = y;
+    SetEventPhaseFromCursorButtonState(&event);
+    event.signal_kind = UIWidgetsPointerSignalKind::kUIWidgetsPointerSignalKindEditorDragRelease;
+
+    SendPointerEventWithData(event);
+  }
+}
+
 static uint64_t ConvertToUIWidgetsButton(int button) {
   switch (button) {
     case -1:
 UIWidgetsPanel_onScroll(UIWidgetsPanel* panel, float x, float y, float px, float py) {
   panel->OnScroll(x, y, px, py);
 }
+
+UIWIDGETS_API(void)
+UIWidgetsPanel_onDragUpdateInEditor(UIWidgetsPanel* panel, float x, float y) {
+  if (!panel->NeedUpdateByEditorLoop()) {
+    return;
+  }
+  panel->OnDragUpdateInEditor(x, y);
+}
+
+UIWIDGETS_API(void)
+UIWidgetsPanel_onDragReleaseInEditor(UIWidgetsPanel* panel, float x, float y) {
+  if (!panel->NeedUpdateByEditorLoop()) {
+    return;
+  }
+  panel->OnDragReleaseInEditor(x, y);
+}
+
 }  // namespace uiwidgets

engine/src/shell/platform/unity/windows/uiwidgets_panel.h

 
   void OnMouseLeave();
 
+  void OnDragUpdateInEditor(float x, float y);
+
+  void OnDragReleaseInEditor(float x, float y);
+
+
   bool NeedUpdateByPlayerLoop();
 
   bool NeedUpdateByEditorLoop();

Samples/UIWidgetsSamples_2019_4/Assets/Editor/EditorWindowSample/UnityObjectDragging.cs

+using System.Collections.Generic;
+using uiwidgets;
+using Unity.UIWidgets.Editor;
+using Unity.UIWidgets.gestures;
+using Unity.UIWidgets.widgets;
+using UnityEditor;
+using UnityEngine;
+
+namespace UIWidgetsEditorWindowSample
+{
+    public class UnityObjectDraggingWindow : UIWidgetsEditorPanel
+    {
+        [MenuItem("UIWidgets/EditorSample/UnityObjectDragging")]
+        public static void CountDemo()
+        {
+            CreateWindow<UnityObjectDraggingWindow>();
+        }
+
+        protected override void onEnable()
+        {
+            AddFont("Material Icons", new List<string> {"MaterialIcons-Regular.ttf"}, new List<int> {0});
+            AddFont("CupertinoIcons", new List<string> {"CupertinoIcons.ttf"}, new List<int> {0});
+            AddFont("GalleryIcons", new List<string> {"gallery/GalleryIcons.ttf"}, new List<int> {0});
+        }
+
+        protected override void main()
+        {
+            editor_ui_.runEditorApp(new MyApp());
+        }
+        
+        public class MyApp : StatelessWidget
+        {
+            public override Widget build(BuildContext context)
+            {
+                return 
+                    new Container(color: Colors.green, child:
+                    new Center(child: 
+                        new UnityObjectDetector(
+                            child: new Container(color: Colors.blue, width: 200f, height: 200f, 
+                                child: new Center(child: new Text("Drag UnityObject or file to me"))),
+                                onEnter: (details) =>
+                                {
+                                    Debug.Log("enter");
+                                },
+                                onHover: (details =>
+                                {
+                                    Debug.Log("position = " + details.position);
+                                }),
+                                onExit: () =>
+                                {
+                                    Debug.Log("on exit");
+                                },
+                                onRelease: (details) =>
+                                {
+                                    Debug.Log("on release");
+                                }
+                        )
+                        )
+                    );
+            }
+    }
+    }
+}

Samples/UIWidgetsSamples_2019_4/Assets/Editor/EditorWindowSample/UnityObjectDragging.cs.meta

+fileFormatVersion: 2
+guid: 9916a1957385427fa807b2ce6a676522
+timeCreated: 1637912586

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.meta

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

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 readonly 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;
+        }
+
+        void _handleEvent(PointerEvent evt) {
+            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 _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/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