mouse hover

Assets/UIWidgets/Tests/Gestures.cs

         }
 
         void OnDestroy() {
+            this.windowAdapter.Destory();
             this.windowAdapter = null;
         }
 

Assets/UIWidgets/Tests/RenderBoxes.cs

         }
 
         void OnDestroy() {
+            this.windowAdapter.Destory();
             this.windowAdapter = null;
         }
 

Assets/UIWidgets/Tests/RenderEditable.cs

         }
 
         void OnDestroy() {
+            this.windowAdapter.Destory();
             this.windowAdapter = null;
         }
 

Assets/UIWidgets/Tests/Widgets.cs

 
         [NonSerialized] private bool hasInvoked = false;
 
-        Widgets() {
+        public Widgets() {
             this._options = new Func<Widget>[] {
                 this.localImage,
                 this.container,
                 this.eventsPage,
                 this.asPage,
-                this.stack
+                this.stack,
+                this.mouseHover
             };
             this._optionStrings = this._options.Select(x => x.Method.Name).ToArray();
             this._selected = 0;
         }
 
         Widget asPage() {
-            //return new AsScreen();
-            return new WidgetInspector(null, new AsScreen(), null);
+            return new WidgetsApp(null, new AsScreen());
+        }
+
+        Widget mouseHover()
+        {
+            return new WidgetsApp(null, new MouseHoverWidget(null));
         }
     }
 
                                 "All Assets",
                                 style: new TextStyle(
                                     fontSize: 16,
-                                    color: CLColors.white
+                                    color: Color.fromARGB(100, 255, 255, 0)
                                 )
                             )
                         ),
                 )
             );
         }
-
+        
         public override Widget build(BuildContext context) {
             var container = new Container(
                 //  color: CLColors.background1,

Assets/UIWidgets/editor/editor_window.cs

         {
             this._alive = true;
             this.editorWindow = editorWindow;
-            this.editorWindow.wantsMouseMove = false;
-            this.editorWindow.wantsMouseEnterLeaveWindow = false;
+            this.editorWindow.wantsMouseMove = true;
+            this.editorWindow.wantsMouseEnterLeaveWindow = true;
 
             this._devicePixelRatio = EditorGUIUtility.pixelsPerPoint;
 
                     pointerData = new PointerData(
                         timeStamp: DateTime.Now,
                         change: PointerChange.move,
+                        kind: PointerDeviceKind.mouse,
+                        device: evt.button,
+                        physicalX: evt.mousePosition.x * this._devicePixelRatio,
+                        physicalY: evt.mousePosition.y * this._devicePixelRatio
+                    );
+                } else if (evt.type == EventType.MouseMove)
+                {
+                    pointerData = new PointerData(
+                        timeStamp: DateTime.Now,
+                        change: PointerChange.hover,
                         kind: PointerDeviceKind.mouse,
                         device: evt.button,
                         physicalX: evt.mousePosition.x * this._devicePixelRatio,

Assets/UIWidgets/gestures/binding.cs

 using System;
 using System.Collections.Generic;
 using UIWidgets.foundation;
+using UIWidgets.rendering;
 using UIWidgets.scheduler;
 using UIWidgets.ui;
 using UnityEngine;
         public readonly GestureArenaManager gestureArena;
 
         public readonly Dictionary<int, HitTestResult> _hitTests = new Dictionary<int, HitTestResult>();
+        
+        public readonly HashSet<HitTestTarget> lastMoveTargets = new HashSet<HitTestTarget>();
+            if (evt is PointerHoverEvent || evt is PointerMoveEvent)
+            {
+                this._handlePointerHoverEvent(evt);
+            }
+            
             HitTestResult result;
             if (evt is PointerDownEvent) {
                 D.assert(!this._hitTests.ContainsKey(evt.pointer));
             if (result != null) {
                 this.dispatchEvent(evt, result);
             }
+        }
+
+        void _handlePointerHoverEvent(PointerEvent evt)
+        {
+            HitTestResult result = new HitTestResult();
+            this.hitTest(result, evt.position);
+                
+            // enter event
+            foreach (var hitTestEntry in result.path)
+            {
+                if (lastMoveTargets.Contains(hitTestEntry.target))
+                {
+                    hitTestEntry.target.handleEvent(evt, hitTestEntry);
+                    lastMoveTargets.Remove(hitTestEntry.target);
+                }
+                else
+                {
+                    hitTestEntry.target.handleEvent(new PointerEnterEvent(
+                        timeStamp:evt.timeStamp,
+                        pointer:evt.pointer,
+                        device:evt.device,
+                        kind:evt.kind
+                    ), hitTestEntry);
+                }
+            }
+            foreach (var lastMoveTarget in lastMoveTargets)
+            {
+                lastMoveTarget.handleEvent(new PointerLeaveEvent(
+                    timeStamp:evt.timeStamp,
+                    pointer:evt.pointer,
+                    device:evt.device,
+                    kind:evt.kind
+                ), null);
+            }
+            lastMoveTargets.Clear();
+            foreach (var hitTestEntry in result.path)
+            {
+                lastMoveTargets.Add(hitTestEntry.target);
+            }
+
+            this.dispatchEvent(evt, result);
         }
 
         public virtual void hitTest(HitTestResult result, Offset position) {

Assets/UIWidgets/gestures/converter.cs

                         );
                     }
                         break;
+
+                    case PointerChange.hover:
+                    {
+                        yield return new PointerHoverEvent(
+                            timeStamp: timeStamp,
+                            kind: kind,
+                            device: datum.device,
+                            position: position
+                            );
+                        break;
+                    }
                     case PointerChange.up:
                     case PointerChange.cancel: {
                         D.assert(_pointers.ContainsKey(datum.device));

Assets/UIWidgets/gestures/events.cs

         }
     }
 
+    public class PointerHoverEvent : PointerEvent
+    {
+        public PointerHoverEvent(
+            DateTime timeStamp,
+            int pointer = 0,
+            PointerDeviceKind kind = PointerDeviceKind.mouse,
+            int device = 0,
+            Offset position = null)
+            : base(
+                timeStamp,
+                pointer: pointer,
+                kind: kind,
+                device: device,
+                position: position,
+                down: false) {
+        }
+    }
+    
+    public class PointerEnterEvent : PointerEvent
+    {
+        public PointerEnterEvent(
+            DateTime timeStamp,
+            int pointer = 0,
+            PointerDeviceKind kind = PointerDeviceKind.mouse,
+            int device = 0,
+            Offset position = null)
+            : base(
+                timeStamp,
+                pointer: pointer,
+                kind: kind,
+                device: device,
+                position: position,
+                down: false) {
+        }
+    }
+    
+    public class PointerLeaveEvent : PointerEvent
+    {
+        public PointerLeaveEvent(
+            DateTime timeStamp,
+            int pointer = 0,
+            PointerDeviceKind kind = PointerDeviceKind.mouse,
+            int device = 0,
+            Offset position = null)
+            : base(
+                timeStamp,
+                pointer: pointer,
+                kind: kind,
+                device: device,
+                position: position,
+                down: false) {
+        }
+    }
+
     public class PointerDownEvent : PointerEvent {
         public PointerDownEvent(
             DateTime timeStamp,

Assets/UIWidgets/rendering/proxy_box.cs

     public delegate void PointerUpEventListener(PointerUpEvent evt);
 
     public delegate void PointerCancelEventListener(PointerCancelEvent evt);
+    
+    public delegate void PointerHoverEventListener(PointerHoverEvent evt);
+    
+    public delegate void PointerEnterEventListener(PointerEnterEvent evt);
+    
+    public delegate void PointerLeaveEventListener(PointerLeaveEvent evt);
 
     public class RenderPointerListener : RenderProxyBoxWithHitTestBehavior {
         public RenderPointerListener(
             PointerCancelEventListener onPointerCancel = null,
+            PointerHoverEventListener onPointerHover = null,
+            PointerLeaveEventListener onPointerLeave = null,
+            PointerEnterEventListener onPointerEnter = null,
             HitTestBehavior behavior = HitTestBehavior.deferToChild,
             RenderBox child = null
         ) : base(behavior: behavior, child: child) {
             this.onPointerCancel = onPointerCancel;
+            this.onPointerHover = onPointerHover;
+            this.onPointerLeave = onPointerLeave;
+            this.onPointerEnter = onPointerEnter;
         }
 
         public PointerDownEventListener onPointerDown;
 
         public PointerCancelEventListener onPointerCancel;
 
+        public PointerHoverEventListener onPointerHover;
+        
+        public PointerLeaveEventListener onPointerLeave;
+        
+        public PointerEnterEventListener onPointerEnter;
+
-        }
-
+        }    
+        
         public override void handleEvent(PointerEvent evt, HitTestEntry entry) {
             D.assert(this.debugHandleEvent(evt, entry));
 
                 this.onPointerCancel((PointerCancelEvent) evt);
                 return;
             }
+
+            if (this.onPointerHover != null && evt is PointerHoverEvent)
+            {
+                this.onPointerHover((PointerHoverEvent) evt);
+                return;
+            }
+            
+            if (this.onPointerLeave != null && evt is PointerLeaveEvent)
+            {
+                this.onPointerLeave((PointerLeaveEvent) evt);
+                return;
+            }
+            
+            if (this.onPointerEnter != null && evt is PointerEnterEvent)
+            {
+                this.onPointerEnter((PointerEnterEvent) evt);
+                return;
+            }
         }
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
                 listeners.Add("up");
             if (this.onPointerCancel != null)
                 listeners.Add("cancel");
+            if (this.onPointerHover != null)
+                listeners.Add("hover");
+            if (this.onPointerEnter != null)
+                listeners.Add("enter");
+            if (this.onPointerLeave != null)
+                listeners.Add("leave");
             if (listeners.isEmpty()) {
                 listeners.Add("<none>");
             }

Assets/UIWidgets/widgets/basic.cs

             PointerMoveEventListener onPointerMove = null,
             PointerUpEventListener onPointerUp = null,
             PointerCancelEventListener onPointerCancel = null,
+            PointerHoverEventListener onPointerHover = null,
+            PointerLeaveEventListener onPointerLeave = null,
+            PointerEnterEventListener onPointerEnter = null,
             HitTestBehavior behavior = HitTestBehavior.deferToChild,
             Widget child = null
         ) : base(key: key, child: child) {
             this.onPointerCancel = onPointerCancel;
+            this.onPointerHover = onPointerHover;
+            this.onPointerLeave = onPointerLeave;
+            this.onPointerEnter = onPointerEnter;
             this.behavior = behavior;
         }
 
         public readonly PointerUpEventListener onPointerUp;
 
         public readonly PointerCancelEventListener onPointerCancel;
+        
+        public readonly PointerHoverEventListener onPointerHover;
+
+        public readonly PointerEnterEventListener  onPointerEnter;
+
+        public readonly PointerLeaveEventListener  onPointerLeave;
 
         public readonly HitTestBehavior behavior;
 
                 onPointerMove: this.onPointerMove,
                 onPointerUp: this.onPointerUp,
                 onPointerCancel: this.onPointerCancel,
+                onPointerEnter: this.onPointerEnter,
+                onPointerLeave: this.onPointerLeave,
+                onPointerHover: this.onPointerHover,
                 behavior: this.behavior
             );
         }
             renderObject.onPointerMove = this.onPointerMove;
             renderObject.onPointerUp = this.onPointerUp;
             renderObject.onPointerCancel = this.onPointerCancel;
+            renderObject.onPointerEnter = this.onPointerEnter;
+            renderObject.onPointerHover = this.onPointerHover;
+            renderObject.onPointerLeave = this.onPointerLeave;
             renderObject.behavior = this.behavior;
         }
 
             if (this.onPointerCancel != null) {
                 listeners.Add("cancel");
             }
+            
+            if (this.onPointerEnter != null) {
+                listeners.Add("enter");
+            }
+            if (this.onPointerHover != null) {
+                listeners.Add("hover");
+            }
+
+            if (this.onPointerLeave != null) {
+                listeners.Add("leave");
+            }
             properties.add(new EnumerableProperty<string>("listeners", listeners, ifEmpty: "<none>"));
             properties.add(new EnumProperty<HitTestBehavior>("behavior", this.behavior));
         }

Assets/UIWidgets/Tests/MouseHover.cs

+using System.Collections.Generic;
+using UIWidgets.foundation;
+using UIWidgets.painting;
+using UIWidgets.rendering;
+using UIWidgets.widgets;
+using Color = UIWidgets.ui.Color;
+
+namespace UIWidgets.Tests
+{
+    public class MouseHoverWidget:StatefulWidget
+    {
+        public MouseHoverWidget(Key key) : base(key)
+        {
+        }
+
+        public override State createState()
+        {
+            return new _MouseHoverWidgetState();
+        }
+    }
+
+    class _MouseHoverWidgetState:State<MouseHoverWidget>
+    {
+
+        public static Widget createRow(bool canHover = true, bool nest = false)
+        {
+            Widget result = new Container(width: 200, height: 60, color: Color.fromARGB(255, 255, 0, 255));
+            if (canHover)
+            {
+                result = new HoverTrackWidget(null,
+                    result);
+            }
+
+            if (nest)
+            {
+                result = new Container(child:result, padding: EdgeInsets.all(40), color: Color.fromARGB(255, 255, 0, 0));
+                result = new HoverTrackWidget(null,
+                    result);
+            }
+
+            return result;
+        }
+        
+        public override Widget build(BuildContext context)
+        {//1 131231
+            return new Container(
+                alignment: Alignment.center, color: Color.fromARGB(255, 0, 255, 0),
+                child: new Column(
+                    mainAxisAlignment:MainAxisAlignment.spaceAround,
+                    children: new List<Widget>
+                    {
+                        createRow(),
+                        createRow(false),
+                        createRow(),
+                        createRow(true, true),
+                    }));
+        }
+    }
+
+    public class HoverTrackWidget : StatefulWidget
+    {
+        public readonly Widget child;
+        public HoverTrackWidget(Key key, Widget child) : base(key)
+        {
+            this.child = child;
+        }
+
+        public override State createState()
+        {
+            return new _HoverTrackWidgetState();
+        }
+    }
+
+    class _HoverTrackWidgetState : State<HoverTrackWidget>
+    {
+        private bool hover;
+        public override Widget build(BuildContext context)
+        {
+            return new Listener(child:
+                new Container(
+                    forgroundDecoration: hover ? new BoxDecoration(color: Color.fromARGB(80, 255, 255, 255)) : null,
+                    child: widget.child
+                ),
+                onPointerEnter: (evt) => {
+                    if (mounted)
+                    {
+                        setState(() => { hover = true; });
+                    } },
+                onPointerLeave: (evt) =>
+                {
+                    if (mounted)
+                    {
+                        setState(() => { hover = false; });
+                    }
+                }
+            );
+        }
+    }
+    
+}

Assets/UIWidgets/Tests/MouseHover.cs.meta

+fileFormatVersion: 2
+guid: ec7305290445466da6da50593cdaa4b7
+timeCreated: 1542181137