Merge pull request #142 from Unity-Technologies/zxw/dev_k12

Zxw/dev k12

com.unity.uiwidgets/Runtime/editor/editor_mouse_tracking.cs

             var lastMouseEvent = new List<PointerEvent>();
             foreach (int deviceId in this._lastMouseEvent.Keys) {
                 var _deviceId = deviceId;
+                var deviceEvent = this._lastMouseEvent[_deviceId];
+                
+                //only process PointerEditorDragEvents
+                if (!(deviceEvent is PointerDragFromEditorEnterEvent ||
+                      deviceEvent is PointerDragFromEditorHoverEvent ||
+                      deviceEvent is PointerDragFromEditorExitEvent)) {
+                    continue;
+                }
+
                 lastMouseEvent.Add(this._lastMouseEvent[_deviceId]);
                 SchedulerBinding.instance.addPostFrameCallback(_ => {
                     foreach (var lastEvent in lastMouseEvent) {

com.unity.uiwidgets/Runtime/editor/editor_window.cs

         public Window window {
             get { return this._windowAdapter; }
         }
+
+        public void forceUpdate() {
+            Widget root;
+            using (this._windowAdapter.getScope()) {
+                root = this.createWidget();
+            }
+
+            this._windowAdapter.attachRootWidget(root);
+        }
     }
 
     public class EditorWindowAdapter : WindowAdapter {
                         physicalY: evt.mousePosition.y * this._devicePixelRatio
                     );
                 }
-                else if (evt.type == EventType.MouseUp || evt.rawType == EventType.MouseUp) {
+                else if (evt.type == EventType.MouseUp || evt.rawType == EventType.MouseUp ||
+                        evt.type == EventType.DragExited || evt.type == EventType.MouseLeaveWindow) {
                     pointerData = new PointerData(
                         timeStamp: Timer.timespanSinceStartup,
                         change: PointerChange.up,

com.unity.uiwidgets/Runtime/editor/widgets/unity_object_detector.cs

 
     public delegate void DragFromEditorExitCallback();
 
+    public delegate void DragFromEditorStartCallback();
+
+    public delegate void DragFromEditorCancelCallback();
+
+
     public delegate void DragFromEditorReleaseCallback(DragFromEditorDetails details);
 
     public class DragFromEditorDetails {
             DragFromEditorHoverCallback onHover = null,
             DragFromEditorExitCallback onExit = null,
             DragFromEditorReleaseCallback onRelease = null,
+            DragFromEditorStartCallback onStart = null,
+            DragFromEditorCancelCallback onCancel = null,
             HitTestBehavior? behavior = null
         ) : base(key: key) {
             this.child = child;
             this.onDragFromEditorRelease = onRelease;
+            this.onDragFromEditorStart = onStart;
+            this.onDragFromEditorCancel = onCancel;
             this.behavior = behavior;
         }
 
         public readonly DragFromEditorHoverCallback onDragFromEditorHover;
         public readonly DragFromEditorExitCallback onDragFromEditorExit;
         public readonly DragFromEditorReleaseCallback onDragFromEditorRelease;
+        public readonly DragFromEditorStartCallback onDragFromEditorStart;
+        public readonly DragFromEditorCancelCallback onDragFromEditorCancel;
 
         public readonly HitTestBehavior? behavior;
 
         public override Widget build(BuildContext context) {
             Widget result = new Listener(
                 child: this.widget.child,
+                onPointerDown: (evt) => {
+                    this.widget.onDragFromEditorStart?.Invoke();
+                    },
+                onPointerUp: (evt) => {
+                    this.widget.onDragFromEditorCancel?.Invoke();
+                    },
+                onPointerCancel: (evt) => {
+                    this.widget.onDragFromEditorCancel?.Invoke();
+                    },
                 onPointerDragFromEditorEnter: this.widget.onDragFromEditorEnter == null
                     ? ((PointerDragFromEditorEnterEventListener) null)
                     : (evt) => { this.widget.onDragFromEditorEnter.Invoke(); },

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

 #if UNITY_EDITOR
                     case PointerChange.dragFromEditorMove: {
                         _PointerState state = _ensureStateForPointer(datum, position);
-                        state.startNewPointer();
+                        //state.startNewPointer();
                         yield return new PointerDragFromEditorHoverEvent(
                             timeStamp: timeStamp,
                             pointer: state.pointer,
                         break;
                     case PointerChange.dragFromEditorRelease: {
                         _PointerState state = _ensureStateForPointer(datum, position);
-                        state.startNewPointer();
+                        //state.startNewPointer();
                         yield return new PointerDragFromEditorReleaseEvent(
                             timeStamp: timeStamp,
                             pointer: state.pointer,

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

 
             foreach (int deviceId in this._lastMouseEvent.Keys) {
                 PointerEvent lastEvent = this._lastMouseEvent[deviceId];
+                
+                //only process PointerEvents
+                if (!(lastEvent is PointerMoveEvent ||
+                      lastEvent is PointerHoverEvent ||
+                      lastEvent is PointerDownEvent)) {
+                    continue;
+                }
                 MouseTrackerAnnotation hit = this.annotationFinder(lastEvent.position);
 
                 if (hit == null) {

com.unity.uiwidgets/Runtime/redux/widget_redux.cs

 using System;
+using Unity.UIWidgets.editor;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 
         public readonly bool pure;
 
+        public readonly UIWidgetsEditorWindow host;
+
+            UIWidgetsEditorWindow host = null,
             ViewModelBuilder<ViewModel> builder = null,
             StoreConverter<State, ViewModel> converter = null,
             bool pure = false, 
             D.assert(converter != null);
+            this.host = host;
             this.pure = pure;
             this.builder = builder;
             this.converter = converter;
                 builder: this.builder,
                 converter: this.converter,
                 pure: this.pure,
-                shouldRebuild: this.shouldRebuild
+                shouldRebuild: this.shouldRebuild,
+                host : this.host
             );
         }
     }
 
         public readonly bool pure;
 
+        public readonly UIWidgetsEditorWindow host;
+
         public _StoreListener(
             ViewModelBuilder<ViewModel> builder = null,
             StoreConverter<State, ViewModel> converter = null,
+            UIWidgetsEditorWindow host = null,
             Key key = null) : base(key) {
             D.assert(builder != null);
             D.assert(converter != null);
             this.converter = converter;
             this.pure = pure;
             this.shouldRebuild = shouldRebuild;
+            this.host = host;
         }
 
         public override widgets.State createState() {
         }
 
         void _handleStateChanged(State state) {
-            if (Window.hasInstance) {
+            if (this.widget.host != null) {
+                var preInstance = Window.instance;
+                using (WindowProvider.of(this.widget.host).getScope()) {
+                    this._innerStateChanged(state);
+                }
+                Window.instance = preInstance;
+            }
+            else if (Window.hasInstance) {
                 this._innerStateChanged(state);
             }
             else {

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

             }, this.inEditorWindow);
         }
 
-        protected virtual void drawFrame() {
+        protected virtual void drawFrame(bool layoutOnly = false) {
+            if (layoutOnly) return;
+            
             this.pipelineOwner.flushCompositingBits();
             this.pipelineOwner.flushPaint();
             this.renderView.compositeFrame();

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

 
         protected bool debugBuildingDirtyElements = false;
 
-        protected override void drawFrame() {
+        protected override void drawFrame(bool layoutOnly = false) {
             D.assert(!this.debugBuildingDirtyElements);
             D.assert(() => {
                 this.debugBuildingDirtyElements = true;
                     this.buildOwner.buildScope(this.renderViewElement);
                 }
 
-                base.drawFrame();
+                base.drawFrame(layoutOnly);
                 this.buildOwner.finalizeTree();
             }
             finally {
             }
             
             //The former widget tree must be layout first before its destruction
-            this.drawFrame();
+            this.drawFrame(true);
             this.attachRootWidget(null);
             this.buildOwner.buildScope(this._renderViewElement);
             this.buildOwner.finalizeTree();