fix mouse tracking issue

cherry-pick from tal project

com.unity.uiwidgets/Runtime/Resources/shaders/UIWidgets_GUITexture.shader

 Shader "UIWidgets/GUITexture"
 {
-    Properties { _MainTex ("Texture", any) = "" {} }
+    Properties { _MainTex ("Texture", any) = "" {} 
+                 _Linear ("_Linear", float) = 0
+    }
 
     CGINCLUDE
     #pragma vertex vert
     };
 
     sampler2D _MainTex;
+    
+    float _Linear;
 
     uniform float4 _MainTex_ST;
 
 
     fixed4 frag (v2f i) : SV_Target
     {
-        return 2.0f * tex2D(_MainTex, i.texcoord) * i.color;
+        fixed4 colr = 2.0f * tex2D(_MainTex, i.texcoord) * i.color;
+        float gamma = 2.2;
+        colr.rgb = _Linear ? pow(colr.rgb, (1.0/gamma)) : colr.rgb;
+        return colr;
     }
     ENDCG
 

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;
 
+        //TODO (zxw): we should find out a better solution to support both EditorWindow and GameObject host here
+        //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;
                 converter: this.converter,
                 pure: this.pure,
                 shouldRebuild: this.shouldRebuild
+                //host : this.host
             );
         }
     }
         public readonly ShouldRebuildCallback<ViewModel> shouldRebuild;
 
         public readonly bool pure;
+
+        //public readonly UIWidgetsEditorWindow host;
 
         public _StoreListener(
             ViewModelBuilder<ViewModel> builder = null,
             ShouldRebuildCallback<ViewModel> shouldRebuild = 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 (this.widget.host != null) {
+            //    var preInstance = Window.instance;
+            //    using (WindowProvider.of(this.widget.host).getScope()) {
+            //        this._innerStateChanged(state);
+            //    }
+            //    Window.instance = preInstance;
+            //}
             if (Window.hasInstance) {
                 this._innerStateChanged(state);
             }

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

 using System;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
 using UnityEngine;
 using Canvas = Unity.UIWidgets.ui.Canvas;
 using Rect = UnityEngine.Rect;
 
             _guiTextureMat = new Material(guiTextureShader);
             _guiTextureMat.hideFlags = HideFlags.HideAndDontSave;
+#if UNITY_EDITOR
+            _guiTextureMat.SetFloat("_Linear", PlayerSettings.colorSpace == ColorSpace.Linear ? 1 : 0);
+#endif
             return _guiTextureMat;
         }
 

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/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/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.MouseLeaveWindow) {
                     pointerData = new PointerData(
                         timeStamp: Timer.timespanSinceStartup,
                         change: PointerChange.up,
                         physicalY: evt.mousePosition.y * this._devicePixelRatio
                     );
                 }
-                else if (evt.type == EventType.DragPerform) {
+                else if (evt.type == EventType.DragPerform || evt.type == EventType.DragExited) {
                     pointerData = new PointerData(
                         timeStamp: Timer.timespanSinceStartup,
                         change: PointerChange.dragFromEditorRelease,

com.unity.uiwidgets/Runtime/painting/decoration_image.cs

             float strideY = fundamentalRect.height;
 
             if (repeat == ImageRepeat.repeat || repeat == ImageRepeat.repeatX) {
+                if (strideX == 0) {
+                    yield break;
+                }
+                if (strideY == 0) {
+                    yield break;
+                }
                 startY = ((outputRect.top - fundamentalRect.top) / strideY).floor();
                 stopY = ((outputRect.bottom - fundamentalRect.bottom) / strideY).ceil();
             }

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();

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

                 return;
             }
 
-            int deviceId = evt.device;
+            //for mouse tracking purpose, the evt.device id makes no difference at all
+            int deviceId = 0;
             if (this._trackedAnnotations.isEmpty()) {
                 // If we are adding the device again, then we're not removing it anymore.
                 this._lastMouseEvent.Remove(deviceId);
 
             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) {