scroller version 1

Runtime/editor/editor_window.cs

                         physicalX: evt.mousePosition.x * this._devicePixelRatio,
                         physicalY: evt.mousePosition.y * this._devicePixelRatio
                     );
-                }
+                } EventType.ScrollWheel
 
                 if (pointerData != null) {
                     this.onPointerEvent(new PointerDataPacket(new List<PointerData> {

Runtime/engine/WidgetCanvas.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.async;
 using Unity.UIWidgets.editor;
         Texture _texture;
         Vector2 _lastMouseMove;
         bool _mouseEntered;
+        
+        Vector2 _lastScrollMove;
+        TimeSpan _lastScrollEndTime = TimeSpan.Zero;
+        static readonly TimeSpan _ScrollEndInterval = new TimeSpan(0, 0, 0, 0, 200);
 
         protected override void OnEnable() {
             base.OnEnable();
 
             this._windowAdapter.attachRootWidget(root);
             this._lastMouseMove = Input.mousePosition;
+            this._lastScrollMove = Input.mouseScrollDelta;
+            Debug.Log(this._lastScrollMove);
         }
 
         public double pixelRatio {
                 this.handleMouseMove();
             }
 
+            if (this._mouseEntered) {
+                // 0 -> !0  => scroll start, use the current position to perform hit test and set the 
+                // current scroll target (if can, otherwise set it null), this target should be saved
+                // !0 -> !0 => use the delta to do the scroll thing.
+                // !0 -> 0 => scroll end. current scroll target = null
+                if (this._lastScrollMove.y == 0 && Input.mouseScrollDelta.y == 0) {
+                    if (this._lastScrollEndTime != TimeSpan.Zero &&
+                        (Timer.timespanSinceStartup - this._lastScrollEndTime > _ScrollEndInterval)) {
+                        this._lastScrollEndTime = TimeSpan.Zero;
+                        this._windowAdapter.postPointerEvent(new PointerData(
+                            timeStamp: Timer.timespanSinceStartup,
+                            change: PointerChange.scroll_end,
+                            kind: PointerDeviceKind.mouse,
+                            device: this.getScrollButton(),
+                            physicalX: 0,
+                            physicalY: 0
+                        ));
+                    }
+                }
+                else if (this._lastScrollMove.y != 0 && Input.mouseScrollDelta.y == 0) {
+                    //Debug.Log("scroll end");
+                    this._lastScrollEndTime = Timer.timespanSinceStartup;
+                    
+                    this._windowAdapter.postPointerEvent(new PointerData(
+                        timeStamp: Timer.timespanSinceStartup,
+                        change: PointerChange.scrolling,
+                        kind: PointerDeviceKind.mouse,
+                        device: this.getScrollButton(),
+                        physicalX: 0,
+                        physicalY: this._lastScrollMove.y
+                    ));
+                } else if (this._lastScrollMove.y == 0 && Input.mouseScrollDelta.y != 0) {
+                    //Debug.Log("scroll start");
+                    var pos = this.getPointPosition(Input.mousePosition);
+                    this._windowAdapter.postPointerEvent(new PointerData(
+                        timeStamp: Timer.timespanSinceStartup,
+                        change: PointerChange.scroll_start,
+                        kind: PointerDeviceKind.mouse,
+                        device: this.getScrollButton(),
+                        physicalX: pos.x,
+                        physicalY: pos.y
+                    ));
+                } else if (this._lastScrollMove.y != 0 && Input.mouseScrollDelta.y != 0) {
+                    //Debug.Log("scroll continue");
+                    this._windowAdapter.postPointerEvent(new PointerData(
+                        timeStamp: Timer.timespanSinceStartup,
+                        change: PointerChange.scrolling,
+                        kind: PointerDeviceKind.mouse,
+                        device: this.getScrollButton(),
+                        physicalX: 0,
+                        physicalY: this._lastScrollMove.y
+                    ));
+                }
+            }
+            this._lastScrollMove = Input.mouseScrollDelta;
+
             this._lastMouseMove = Input.mousePosition;
 
             D.assert(this._windowAdapter != null);
                 physicalX: pos.x,
                 physicalY: pos.y
             ));
+        }
+
+        int getScrollButton() {
+            return 5;
         }
 
         int getMouseButtonDown() {

Runtime/gestures/binding.cs

                 this._handlePointerHoverEvent(evt);
             }
 
+            if (evt is PointerScrollingEvent || evt is PointerScrollStartEvent || evt is PointerScrollEndEvent) {
+                this._handlePointerScrollEvent(evt);
+            }
+
             HitTestResult result;
             if (evt is PointerDownEvent) {
                 D.assert(!this._hitTests.ContainsKey(evt.pointer));
                 result = this._hitTests[evt.pointer];
                 this._hitTests.Remove(evt.pointer);
             }
-            else if (evt.down) {
+            else if (!(evt is PointerScrollStartEvent) && evt.down) {
                 result = this._hitTests[evt.pointer];
             }
             else {
                 this.dispatchEvent(evt, result);
             }
         }
+        //public Offset lastScrollStartPos = null;
+
+        void _handlePointerScrollEvent(PointerEvent evt) {
+
+            void _handleScrolling(PointerEvent subEvt, bool start) {
+                //if (this.lastScrollStartPos == null) {
+                //    return;
+               // }
+                
+                HitTestResult result = new HitTestResult();
+                this.hitTest(result, subEvt.position);
+
+                foreach (var hitTestEntry in result.path) {
+                    //Debug.Log("hitTestEntry: " + hitTestEntry);
+                    hitTestEntry.target.handleEvent(new PointerScrollingEvent(
+                        timeStamp: subEvt.timeStamp,
+                        pointer: subEvt.pointer,
+                        device: subEvt.device,
+                        kind: subEvt.kind,
+                        position: subEvt.position,
+                        delta: subEvt.delta,
+                        start: start
+                    ), hitTestEntry);
+                }
+                
+                this.dispatchEvent(evt, result);
+            }
+            // scroll start
+            // evt.position = the current pointer position
+            if (evt is PointerScrollStartEvent) { 
+                //this.lastScrollStartPos = evt.position;
+                _handleScrolling(evt, true);
+            }
+            else if (evt is PointerScrollEndEvent) {
+                //this.lastScrollStartPos = null;
+                _handleScrolling(evt, false);
+            } 
+            else if (evt is PointerScrollingEvent) {
+                _handleScrolling(evt, false);
+            }
+        }
 
         void _handlePointerHoverEvent(PointerEvent evt) {
             HitTestResult result = new HitTestResult();
         }
 
         public void handleEvent(PointerEvent evt, HitTestEntry entry) {
+            if (evt is PointerScrollingEvent) {
+                Debug.Log("ffffffffff");
+            }
-            if (evt is PointerDownEvent) {
+            if (evt is PointerDownEvent || (evt is PointerScrollingEvent && evt.down)) {
                 this.gestureArena.close(evt.pointer);
             }
             else if (evt is PointerUpEvent) {

Runtime/gestures/converter.cs

 
         int _pointer;
 
-        static int _pointerCount = 0;
+        static int _pointerCount = 10;
+        const int scrollPointer = 5;
+
+        public void initScrollPointer() {
+            this._pointer = scrollPointer;
+        }
 
         public void startNewPointer() {
             _pointerCount += 1;
                         );
                         break;
                     }
+
+                    case PointerChange.scroll_start: {
+                        _PointerState state = _ensureStateForPointer(datum, position);
+                        state.initScrollPointer();
+                        
+                        if (state.lastPosition != position) {
+                            state.lastPosition = position;
+                        }
+                        
+                        yield return new PointerScrollStartEvent(
+                            timeStamp: timeStamp,
+                            pointer: state.pointer,
+                            kind: kind,
+                            device: datum.device,
+                            position: position
+                        );
+                        break;
+                    }
+                    
+                    
+                    case PointerChange.scroll_end: {
+                        D.assert(_pointers.ContainsKey(datum.device));
+
+                        _PointerState state = _pointers[datum.device];
+
+                        Offset startPosition = state.lastPosition;
+                        yield return new PointerScrollEndEvent(
+                            timeStamp: timeStamp,
+                            pointer: state.pointer,
+                            kind: kind,
+                            device: datum.device,
+                            position: startPosition,
+                            delta: position
+                        );
+                        break;
+                    }
+                    
+                    case PointerChange.scrolling: {
+                        D.assert(_pointers.ContainsKey(datum.device));
+
+                        _PointerState state = _pointers[datum.device];
+
+                        Offset startPosition = state.lastPosition;
+                        yield return new PointerScrollingEvent(
+                            timeStamp: timeStamp,
+                            pointer: state.pointer,
+                            kind: kind,
+                            device: datum.device,
+                            position: startPosition,
+                            delta: position
+                        );
+                        break;
+                    }     
+                    
                     case PointerChange.up:
                     case PointerChange.cancel: {
                         D.assert(_pointers.ContainsKey(datum.device));

Runtime/gestures/events.cs

         }
     }
 
+    public class PointerScrollStartEvent : PointerEvent {
+        public PointerScrollStartEvent(
+            TimeSpan 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: true) {
+        }
+    }
+    
+    public class PointerScrollEndEvent : PointerEvent {
+        public PointerScrollEndEvent(
+            TimeSpan timeStamp,
+            int pointer = 0,
+            PointerDeviceKind kind = PointerDeviceKind.mouse,
+            int device = 0,
+            Offset position = null,
+            Offset delta = null)
+            : base(
+                timeStamp,
+                pointer: pointer,
+                kind: kind,
+                device: device,
+                position: position,
+                down: false,
+                delta : delta) {
+        }
+    }
+    
+    public class PointerScrollingEvent : PointerEvent {
+        public PointerScrollingEvent(
+            TimeSpan timeStamp,
+            int pointer = 0,
+            PointerDeviceKind kind = PointerDeviceKind.mouse,
+            int device = 0,
+            Offset position = null,
+            Offset delta = null,
+            bool start = false)
+            : base(
+                timeStamp,
+                pointer: pointer,
+                kind: kind,
+                device: device,
+                position: position,
+                down: start,
+                delta: delta) {
+        }
+    }
+
     public class PointerHoverEvent : PointerEvent {
         public PointerHoverEvent(
             TimeSpan timeStamp,

Runtime/gestures/monodrag.cs

 using System.Collections.Generic;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
+using UnityEngine;
 
 namespace Unity.UIWidgets.gestures {
     enum _DragState {
         }
 
         protected override void handleEvent(PointerEvent evt) {
+            Debug.Log("handle Event >>> " + evt);
-                && (evt is PointerDownEvent || evt is PointerMoveEvent)) {
+                && (evt is PointerDownEvent || evt is PointerMoveEvent || evt is PointerScrollingEvent)) {
+            if (evt is PointerScrollingEvent) {
+                Debug.Log("handle Event >>>>" + evt.position + " == " + evt.delta);
+                Offset delta = evt.delta;
+                if (this.onUpdate != null) {
+                    this.invokeCallback<object>("onUpdate", () => {
+                        this.onUpdate(new DragUpdateDetails(
+                            sourceTimeStamp: evt.timeStamp,
+                            delta: this._getDeltaForDetails(delta),
+                            primaryDelta: this._getPrimaryValueFromOffset(delta),
+                            globalPosition: evt.position
+                        ));
+                        return null;
+                    });
+                }
+            }
+
             if (evt is PointerMoveEvent) {
                 Offset delta = evt.delta;
                 if (this._state == _DragState.accepted) {
                 D.assert(tracker != null);
 
                 var estimate = tracker.getVelocityEstimate();
+                //if (estimate != null && this._isFlingGesture(estimate) || pointer == 5) {
+                //    Offset ret = pointer == 5 ? new Offset(0, 1) : estimate.pixelsPerSecond;
-                    Velocity velocity = new Velocity(pixelsPerSecond: estimate.pixelsPerSecond)
+                    Offset ret = estimate.pixelsPerSecond;
+                    Velocity velocity = new Velocity(pixelsPerSecond: ret)
                         .clampMagnitude(this.minFlingVelocity ?? Constants.kMinFlingVelocity,
                             this.maxFlingVelocity ?? Constants.kMaxFlingVelocity);
                     this.invokeCallback<object>("onEnd", () => {

Runtime/gestures/pointer_router.cs

 
         public void addRoute(int pointer, PointerRoute route) {
             var routes = this._routeMap.putIfAbsent(pointer, () => new HashSet<PointerRoute>());
-            D.assert(!routes.Contains(route));
-            routes.Add(route);
+            //D.assert(!routes.Contains(route));
+            if (!routes.Contains(route)) {
+                routes.Add(route);
+            }
         }
 
         public void removeRoute(int pointer, PointerRoute route) {

Runtime/gestures/recognizer.cs

 
         readonly Dictionary<int, GestureArenaEntry> _entries = new Dictionary<int, GestureArenaEntry>();
 
-        readonly HashSet<int> _trackedPointers = new HashSet<int>();
+        protected readonly HashSet<int> _trackedPointers = new HashSet<int>();
 
         protected abstract void handleEvent(PointerEvent evt);
 
         protected void startTrackingPointer(int pointer) {
             GestureBinding.instance.pointerRouter.addRoute(pointer, this.handleEvent);
             this._trackedPointers.Add(pointer);
-            D.assert(!this._entries.ContainsKey(pointer));
-            this._entries[pointer] = this._addPointerToArena(pointer);
+            //D.assert(!this._entries.ContainsKey(pointer));
+            if (!this._entries.ContainsKey(pointer)) {
+                this._entries[pointer] = this._addPointerToArena(pointer);
+            }
         }
 
         protected void stopTrackingPointer(int pointer) {
         protected void stopTrackingIfPointerNoLongerDown(PointerEvent evt) {
             if (evt is PointerUpEvent || evt is PointerCancelEvent) {
                 this.stopTrackingPointer(evt.pointer);
+            }
+
+            if (evt is PointerScrollingEvent) {
+                if (evt.delta == Offset.zero && !evt.down) {
+                    this.stopTrackingPointer(evt.pointer);
+                }
+                else {
+                    Debug.Log("udddddddddddddd");
+                }
             }
         }
     }

Runtime/rendering/proxy_box.cs

 
     public delegate void PointerLeaveEventListener(PointerLeaveEvent evt);
 
+    public delegate void PointerScrollEventListener(PointerScrollingEvent evt);
+
     public class RenderPointerListener : RenderProxyBoxWithHitTestBehavior {
         public RenderPointerListener(
             PointerDownEventListener onPointerDown = null,
             PointerHoverEventListener onPointerHover = null,
             PointerLeaveEventListener onPointerLeave = null,
             PointerEnterEventListener onPointerEnter = null,
+            PointerScrollEventListener onPointerScroll = null,
             HitTestBehavior behavior = HitTestBehavior.deferToChild,
             RenderBox child = null
         ) : base(behavior: behavior, child: child) {
             this.onPointerHover = onPointerHover;
             this.onPointerLeave = onPointerLeave;
             this.onPointerEnter = onPointerEnter;
+            this.onPointerScroll = onPointerScroll;
         }
 
         public PointerDownEventListener onPointerDown;
 
         public PointerEnterEventListener onPointerEnter;
 
+        public PointerScrollEventListener onPointerScroll;
+
         protected override void performResize() {
             this.size = this.constraints.biggest;
         }
             if (this.onPointerEnter != null && evt is PointerEnterEvent) {
                 this.onPointerEnter((PointerEnterEvent) evt);
                 return;
+            }
+
+            if (this.onPointerScroll != null && evt is PointerScrollingEvent) {
+                this.onPointerScroll((PointerScrollingEvent) evt);
             }
         }
 

Runtime/ui/pointer.cs

         down,
         move,
         up,
+        scroll_start,
+        scrolling,
+        scroll_end
     }
 
     public enum PointerDeviceKind {

Runtime/widgets/basic.cs

             PointerHoverEventListener onPointerHover = null,
             PointerLeaveEventListener onPointerLeave = null,
             PointerEnterEventListener onPointerEnter = null,
+            PointerScrollEventListener onPointerScroll = null,
             HitTestBehavior behavior = HitTestBehavior.deferToChild,
             Widget child = null
         ) : base(key: key, child: child) {
             this.onPointerHover = onPointerHover;
             this.onPointerLeave = onPointerLeave;
             this.onPointerEnter = onPointerEnter;
+            this.onPointerScroll = onPointerScroll;
             this.behavior = behavior;
         }
 
 
         public readonly PointerLeaveEventListener onPointerLeave;
 
+        public readonly PointerScrollEventListener onPointerScroll;
+
         public readonly HitTestBehavior behavior;
 
         public override RenderObject createRenderObject(BuildContext context) {
                 onPointerEnter: this.onPointerEnter,
                 onPointerLeave: this.onPointerLeave,
                 onPointerHover: this.onPointerHover,
+                onPointerScroll: this.onPointerScroll,
                 behavior: this.behavior
             );
         }
             renderObject.onPointerEnter = this.onPointerEnter;
             renderObject.onPointerHover = this.onPointerHover;
             renderObject.onPointerLeave = this.onPointerLeave;
+            renderObject.onPointerScroll = this.onPointerScroll;
             renderObject.behavior = this.behavior;
         }
 
 
             if (this.onPointerLeave != null) {
                 listeners.Add("leave");
+            }
+
+            if (this.onPointerScroll != null) {
+                listeners.Add("scroll");
             }
 
             properties.add(new EnumerableProperty<string>("listeners", listeners, ifEmpty: "<none>"));

Runtime/widgets/gesture_detector.cs

                 recognizer.addPointer(evt);
             }
         }
+        
+        void _handlePointerScroll(PointerScrollingEvent evt) {
+            if (!evt.down) {
+                return;
+            }
+            D.assert(this._recognizers != null);
+            foreach (GestureRecognizer recognizer in this._recognizers.Values) {
+                recognizer.addPointer(new PointerDownEvent(
+                    timeStamp:evt.timeStamp,
+                    pointer: evt.pointer,
+                    kind: evt.kind,
+                    device: evt.device,
+                    position: evt.position));
+            }
+        }
 
         HitTestBehavior _defaultBehavior {
             get { return this.widget.child == null ? HitTestBehavior.translucent : HitTestBehavior.deferToChild; }
         public override Widget build(BuildContext context) {
             Widget result = new Listener(
                 onPointerDown: this._handlePointerDown,
+                onPointerScroll: this._handlePointerScroll,
                 behavior: this.widget.behavior ?? this._defaultBehavior,
                 child: this.widget.child
             );

Samples/UIWidgetSample/ExpansionPanelCanvas.cs

 
 namespace UIWidgetsSample {
     public class ExpansionPanelCanvas : WidgetCanvas {
-        int testCaseId = 1;
+        int testCaseId = 0;
 
         readonly List<Widget> testCases = new List<Widget> {
             new SingleChildScrollWidget(),

Samples/UIWidgetSample/UIWidgetSample.unity

   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!224 &552752111
 RectTransform:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 0
+  m_IsActive: 1
 --- !u!224 &1199742532
 RectTransform:
   m_ObjectHideFlags: 0
   m_Father: {fileID: 304189374}
   m_RootOrder: 6
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0.5, y: 0.5}
-  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchorMin: {x: 0.5, y: 0}
+  m_AnchorMax: {x: 0.5, y: 0}
   m_AnchoredPosition: {x: 0, y: 0}
   m_SizeDelta: {x: 300, y: 500}
   m_Pivot: {x: 0.5, y: 0.5}