pointer hover recognizer on TextSpan

Runtime/gestures/binding.cs

                     timeStamp: evt.timeStamp,
                     pointer: evt.pointer,
                     device: evt.device,
-                    kind: evt.kind
+                    kind: evt.kind,
+                    position: evt.position
                 ), null);
             }
 
                     timeStamp: evt.timeStamp,
                     pointer: evt.pointer,
                     device: evt.device,
-                    kind: evt.kind
+                    kind: evt.kind,
+                    position: evt.position
                 ), hitTestEntry);
             }
 

Runtime/painting/text_span.cs

         public readonly string text;
         public readonly List<TextSpan> children;
         public readonly GestureRecognizer recognizer;
+        public readonly HoverRecognizer hoverRecognizer;
-            GestureRecognizer recognizer = null) {
+            GestureRecognizer recognizer = null, HoverRecognizer hoverRecognizer = null) {
+            this.hoverRecognizer = hoverRecognizer;
         }
 
         public void build(ParagraphBuilder builder, float textScaleFactor = 1.0f) {
 
             if (hasStyle) {
                 builder.pop();
+            }
+        }
+
+        public bool needHoverRecognizer {
+            get {
+                bool need = false;
+                this.visitTextSpan((text) => {
+                    if (text.hoverRecognizer != null) {
+                        need = true;
+                        return false;
+                    }
+                    return true;
+                });
+
+                return need;
             }
         }
 

Runtime/rendering/paragraph.cs

             this._selection = null;
             this.onSelectionChanged = onSelectionChanged;
             this.selectionColor = selectionColor;
+            
+            
+            this._listenToHoverEvent = this._textPainter.text.needHoverRecognizer;
+            this._previousHoverSpan = null;
+            this._pointerHoverInside = false;
         }
 
         public Action onSelectionChanged;
                         this.markNeedsLayout();
                         break;
                 }
+
+                this._listenToHoverEvent = this._textPainter.text.needHoverRecognizer;
+                this._previousHoverSpan = null;
+                this._pointerHoverInside = false;
             }
         }
 
             this.onSelectionChanged?.Invoke();
         }
 
+        TextSpan _previousHoverSpan = null;
+        bool _pointerHoverInside = false;
+        bool _listenToHoverEvent = false;
+
-            if (!(evt is PointerDownEvent)) {
+            if (evt is PointerDownEvent) {
+                this._layoutTextWithConstraints(this.constraints);
+                Offset offset = ((BoxHitTestEntry) entry).localPosition;
+                TextPosition position = this._textPainter.getPositionForOffset(offset);
+                TextSpan span = this._textPainter.text.getSpanForPosition(position);
+                span?.recognizer?.addPointer((PointerDownEvent) evt);
+            }
+
+            if (!this._listenToHoverEvent) {
-            this._layoutTextWithConstraints(this.constraints);
-            Offset offset = ((BoxHitTestEntry) entry).localPosition;
-            TextPosition position = this._textPainter.getPositionForOffset(offset);
-            TextSpan span = this._textPainter.text.getSpanForPosition(position);
-            span?.recognizer?.addPointer((PointerDownEvent) evt);
+            if (evt is PointerEnterEvent) {
+                this._pointerHoverInside = true;
+            } else if (evt is PointerLeaveEvent) {
+                this._pointerHoverInside = false;
+                this._previousHoverSpan?.hoverRecognizer?.OnPointerLeave();
+                this._previousHoverSpan = null;
+            }
+            else if (evt is PointerHoverEvent && this._pointerHoverInside) {
+                this._layoutTextWithConstraints(this.constraints);
+                Offset offset = this.globalToLocal(evt.position);
+                TextPosition position = this._textPainter.getPositionForOffset(offset);
+                TextSpan span = this._textPainter.text.getSpanForPosition(position);
+
+                if (this._previousHoverSpan != span) {
+                    this._previousHoverSpan?.hoverRecognizer?.OnPointerLeave();
+                    span?.hoverRecognizer?.OnPointerEnter();
+                    this._previousHoverSpan = span;
+                }
+            }
         }
 
         protected override void performLayout() {

Samples/UIWidgetSample/MaterialSample.cs

 using System.Collections.Generic;
 using RSG;
 using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
         GlobalKey<ScaffoldState> _scaffoldKey = GlobalKey<ScaffoldState>.key();
 
         VoidCallback _showBottomSheetCallback;
+        
+        TapGestureRecognizer _tapRecognizer;
+        HoverRecognizer _hoverRecognizer;
+            
+            this._tapRecognizer = new TapGestureRecognizer();
+            this._tapRecognizer.onTap = () => {
+                Debug.Log("Tap");
+            };
+            this._hoverRecognizer = new HoverRecognizer();
+            this._hoverRecognizer.OnPointerEnter = () => { Debug.Log("Pointer Enter"); };
+            this._hoverRecognizer.OnPointerLeave = () => { Debug.Log("Pointer Leave"); };
         }
 
         void _showBottomSheet() {
             return new Scaffold(
                 key: this._scaffoldKey,
                 appBar: new AppBar(
-                    title: new Text("Basic AppBar"),
+                    title: new RichText(
+                        text: new TextSpan(
+                            text: "Can you ",
+                            style: new TextStyle(color: Colors.black),
+                            children: new List<TextSpan>() {
+                                new TextSpan(
+                                    text: "find the",
+                                    style: new TextStyle(
+                                        color: Colors.green,
+                                        decoration: TextDecoration.underline
+                                    ),
+                                    recognizer: this._tapRecognizer,
+                                    hoverRecognizer: this._hoverRecognizer
+                                ),
+                                new TextSpan(
+                                    text: " secret?"
+                                )
+                            }
+                        )),
                     actions: new List<Widget> {
                         new IconButton(
                             icon: new Icon(Choice.choices[0].icon),
                         children: new List<Widget> {
                             new Icon(this.choice.icon, size: 128.0f, color: textStyle.color),
                             new RaisedButton(
-                                child: new Text(this.choice.title, style: textStyle),
+                                //child: new Text(this.choice.title, style: textStyle),
+                                child: new Icon(Unity.UIWidgets.material.Icons.pool),
                                 onPressed: () => {
                                     SnackBar snackBar = new SnackBar(
                                         content: new Text(this.choice.title + " is chosen !"),

Samples/UIWidgetSample/txt/TextSpanGesture.cs

     }
 
     class _BuzzingTextState : State<BuzzingText> {
-        LongPressGestureRecognizer _longPressRecognizer;
+        TapGestureRecognizer _tapRecognizer;
+        HoverRecognizer _hoverRecognizer;
-            this._longPressRecognizer = new LongPressGestureRecognizer();
-            this._longPressRecognizer.onLongPress = this._handlePress;
+            this._tapRecognizer = new TapGestureRecognizer();
+            this._tapRecognizer.onTap = () => {
+                Debug.Log("Tap");
+            };
+            this._hoverRecognizer = new HoverRecognizer();
+            this._hoverRecognizer.OnPointerEnter = () => { Debug.Log("Pointer Enter"); };
+            this._hoverRecognizer.OnPointerLeave = () => { Debug.Log("Pointer Leave"); };
-            this._longPressRecognizer.dispose();
+            this._tapRecognizer.dispose();
-        void _handlePress() {
-            Debug.Log("Long Pressed Text");
+        void _handleEnter() {
+            Debug.Log("Enter");
+        }
+
+        void _handleLeave() {
+            Debug.Log("Leave");
         }
         /*
         
                             style: new TextStyle(
                                 color: Colors.green,
                                 decoration: TextDecoration.underline
-                            )
-                          //  recognizer: this._longPressRecognizer
+                            ),
+                            recognizer: this._tapRecognizer,
+                            hoverRecognizer: this._hoverRecognizer
                         ),
                         new TextSpan(
                             text: " secret?"

Runtime/gestures/hover.cs

+using System;
+using Unity.UIWidgets.foundation;
+using UnityEngine;
+
+namespace Unity.UIWidgets.gestures {
+    
+    public class HoverRecognizer : DiagnosticableTree {
+        public HoverRecognizer(object debugOwner = null) {
+            this.debugOwner = debugOwner;
+        }
+
+        readonly object debugOwner;
+        
+        public Action OnPointerEnter = () => {};
+
+        public Action OnPointerLeave = () => {};
+    }
+}

Runtime/gestures/hover.cs.meta

+fileFormatVersion: 2
+guid: 0482dd5944bd647da9d8a1a32a86801b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: