[Feature] Rearrange the code

Runtime/editor/editor_mouse_tracking.cs

         bool _enableDragFromEditorRelease = false;
 
         void _handleDragFromEditorEvent(PointerEvent evt, int deviceId) {
+            if (!this.inEditorWindow) {
+                return;
+            }
+
             if (evt is PointerDragFromEditorReleaseEvent) {
                 this._enableDragFromEditorRelease = false;
                 this._scheduleDragFromEditorReleaseCheck();
                 }
 
                 this._lastMouseEvent[deviceId] = evt;
+            }
+        }
+
+        void detachDragFromEditorAnnotation(MouseTrackerAnnotation annotation, int deviceId) {
+            if (!this.inEditorWindow) {
+                return;
+            }
+
+            if (annotation.onDragFromEditorExit != null) {
+                annotation.onDragFromEditorExit(
+                    PointerDragFromEditorExitEvent.fromDragFromEditorEvent(this._lastMouseEvent[deviceId]));
             }
         }
 
         }
 
         void _scheduleDragFromEditorMousePositionCheck() {
+            if (!this.inEditorWindow) {
+                return;
+            }
+
             SchedulerBinding.instance.addPostFrameCallback(_ => { this.collectDragFromEditorMousePositions(); });
             SchedulerBinding.instance.scheduleFrame();
         }

Runtime/editor/editor_window.cs

     public abstract class WindowAdapter : Window {
         static readonly List<WindowAdapter> _windowAdapters = new List<WindowAdapter>();
 
-        public WindowAdapter(bool inEditor = false) {
-            this.inEditor = inEditor;
+        public WindowAdapter(bool inEditorWindow = false) {
+            this.inEditorWindow = inEditorWindow;
         }
 
         public static List<WindowAdapter> windowAdapters {
             this._surface = null;
         }
 
-        readonly protected bool inEditor;
+        readonly protected bool inEditorWindow;
 
         public override IDisposable getScope() {
             WindowAdapter oldInstance = (WindowAdapter) _instance;
-                this._binding = new WidgetsBinding(this.inEditor);
+                this._binding = new WidgetsBinding(this.inEditorWindow);
             }
 
             SchedulerBinding._instance = this._binding;

Runtime/gestures/mouse_tracking.cs

         public MouseTracker(
             PointerRouter router,
             MouseDetectorAnnotationFinder annotationFinder,
-            bool inEditor = false
+            bool inEditorWindow = false
-            this.inEditor = inEditor;
+            this.inEditorWindow = inEditorWindow;
-        readonly bool inEditor;
+        readonly bool inEditorWindow;
 
         readonly Dictionary<int, PointerEvent> _lastMouseEvent = new Dictionary<int, PointerEvent>();
 
             this._scheduleMousePositionCheck();
 
 #if UNITY_EDITOR
-            if (this.inEditor) {
-                this._scheduleDragFromEditorMousePositionCheck();
-            }
+            this._scheduleDragFromEditorMousePositionCheck();
 #endif
         }
 
                         PointerExitEvent.fromHoverEvent((PointerHoverEvent) this._lastMouseEvent[deviceId]));
                 }
 #if UNITY_EDITOR
-                if (this.inEditor && annotation.onDragFromEditorExit != null) {
-                    annotation.onDragFromEditorExit(
-                        PointerDragFromEditorExitEvent.fromDragFromEditorEvent(this._lastMouseEvent[deviceId]));
+                this.detachDragFromEditorAnnotation(annotation, deviceId);
-                }
             }
 
             this._trackedAnnotations.Remove(annotation);
             }
 
 #if UNITY_EDITOR
-            if (this.inEditor) {
-                this._handleDragFromEditorEvent(evt, deviceId);
-            }
+            this._handleDragFromEditorEvent(evt, deviceId);
 #endif
         }
 
                 }
 
                 _TrackedAnnotation hitAnnotation = this._findAnnotation(hit);
+
                 //enter
                 if (!hitAnnotation.activeDevices.Contains(deviceId)) {
                     hitAnnotation.activeDevices.Add(deviceId);

Runtime/rendering/binding.cs

             set { PaintingBinding.instance = value; }
         }
 
-        public RendererBinding(bool inEditor = false) {
+        public RendererBinding(bool inEditorWindow = false) {
             this._pipelineOwner = new PipelineOwner(
                 onNeedVisualUpdate: this.ensureVisualUpdate
             );
             D.assert(this.renderView != null);
             this.addPersistentFrameCallback(this._handlePersistentFrameCallback);
 
-            this.inEditor = inEditor;
+            this.inEditorWindow = inEditorWindow;
             this._mouseTracker = this._createMouseTracker();
         }
 
             this.drawFrame();
         }
 
-        readonly protected bool inEditor;
+        readonly protected bool inEditorWindow;
 
         MouseTracker _createMouseTracker() {
             return new MouseTracker(this.pointerRouter, (Offset offset) => {
-            }, this.inEditor);
+            }, this.inEditorWindow);
         }
 
         protected virtual void drawFrame() {

Runtime/widgets/binding.cs

             set { RendererBinding.instance = value; }
         }
 
-        public WidgetsBinding(bool inEditor = false) : base(inEditor) {
+        public WidgetsBinding(bool inEditorWindow = false) : base(inEditorWindow) {
             this.buildOwner.onBuildScheduled = this._handleBuildScheduled;
             Window.instance.onLocaleChanged += this.handleLocaleChanged;
             this.widgetInspectorService = new WidgetInspectorService(this);