Merge branch 'material' into 'master'

mouse scroll support

See merge request upm-packages/ui-widgets/com.unity.uiwidgets!52

Runtime/editor/editor_window.cs

                         physicalY: evt.mousePosition.y * this._devicePixelRatio
                     );
                 }
+                else if (evt.type == EventType.ScrollWheel) {
+                    pointerData = new ScrollData(
+                        timeStamp: Timer.timespanSinceStartup,
+                        change: PointerChange.scroll,
+                        kind: PointerDeviceKind.mouse,
+                        device: evt.button,
+                        physicalX: evt.mousePosition.x * this._devicePixelRatio,
+                        physicalY: evt.mousePosition.y * this._devicePixelRatio,
+                        scrollX: -evt.delta.x,
+                        scrollY: -evt.delta.y
+                    );
+                }
 
                 if (pointerData != null) {
                     this.onPointerEvent(new PointerDataPacket(new List<PointerData> {

Runtime/engine/WidgetCanvas.cs

         Vector2 _lastMouseMove;
         bool _mouseEntered;
 
+        const int mouseButtonNum = 3;
+        const int mouseScrollId = mouseButtonNum + 1;
+
         protected override void OnEnable() {
             base.OnEnable();
 
                 this.handleMouseMove();
             }
 
+            if (this._mouseEntered) {
+                if (Input.mouseScrollDelta.y != 0) {
+                    var pos = this.getPointPosition(Input.mousePosition);
+                    this._windowAdapter.postPointerEvent(new ScrollData(
+                        timeStamp: Timer.timespanSinceStartup,
+                        change: PointerChange.scroll,
+                        kind: PointerDeviceKind.mouse,
+                        device: this.getScrollButton(),
+                        physicalX: pos.x,
+                        physicalY: pos.y,
+                        scrollX: Input.mouseScrollDelta.x,
+                        scrollY: Input.mouseScrollDelta.y * 5
+                    ));
+                }
+            }
+
+
             this._lastMouseMove = Input.mousePosition;
 
             D.assert(this._windowAdapter != null);
             ));
         }
 
+        int getScrollButton() {
+            return mouseScrollId;
+        }
+
-            for (int key = 0; key < 3; key++) {
+            for (int key = 0; key < mouseButtonNum; key++) {
                 if (Input.GetMouseButton(key)) {
                     return key;
                 }

Runtime/gestures/binding.cs

                 this._handlePointerHoverEvent(evt);
             }
 
+            if (evt is PointerScrollEvent) {
+                this._handlePointerScrollEvent(evt);
+                return;
+            }
+
             HitTestResult result;
             if (evt is PointerDownEvent) {
                 D.assert(!this._hitTests.ContainsKey(evt.pointer));
             if (result != null) {
                 this.dispatchEvent(evt, result);
             }
+        }
+
+        void _handlePointerScrollEvent(PointerEvent evt) {
+            this.pointerRouter.clearScrollRoute(evt.pointer);
+
+            HitTestResult result = new HitTestResult();
+            this.hitTest(result, evt.position);
+
+            this.dispatchEvent(evt, result);
         }
 
         void _handlePointerHoverEvent(PointerEvent evt) {

Runtime/gestures/converter.cs

 
         int _pointer;
 
-        static int _pointerCount = 0;
+        // pointers 0 ~ 9 are preserved for special unique inputs
+        static int _pointerCount = 10;
+
+        // special pointer id:
+        // mouse scroll
+        const int scrollPointer = 5;
+
+        public void initScrollPointer() {
+            this._pointer = scrollPointer;
+        }
 
         public void startNewPointer() {
             _pointerCount += 1;
                         );
                         break;
                     }
+
+                    case PointerChange.scroll: {
+                        var _scrollData = (ScrollData) datum;
+                        _PointerState state = _ensureStateForPointer(datum, position);
+                        state.initScrollPointer();
+
+                        if (state.lastPosition != position) {
+                            state.lastPosition = position;
+                        }
+
+                        yield return new PointerScrollEvent(
+                            timeStamp: timeStamp,
+                            pointer: state.pointer,
+                            kind: kind,
+                            device: _scrollData.device,
+                            position: position,
+                            delta: new Offset(_scrollData.scrollX, _scrollData.scrollY) / devicePixelRatio
+                        );
+                        break;
+                    }
+
                     case PointerChange.up:
                     case PointerChange.cancel: {
                         D.assert(_pointers.ContainsKey(datum.device));

Runtime/gestures/drag_details.cs

             TimeSpan sourceTimeStamp,
             Offset delta = null,
             double? primaryDelta = null,
-            Offset globalPosition = null) {
+            Offset globalPosition = null,
+            bool isScroll = false) {
+            this.isScroll = isScroll;
             D.assert(primaryDelta == null
                      || primaryDelta == this.delta.dx && this.delta.dy == 0.0
                      || primaryDelta == this.delta.dy && this.delta.dx == 0.0);
         public readonly double? primaryDelta;
 
         public readonly Offset globalPosition;
+
+        public readonly bool isScroll;
 
         public override string ToString() {
             return this.GetType() + "(" + this.delta + ")";

Runtime/gestures/events.cs

         }
     }
 
+    public class PointerScrollEvent : PointerEvent {
+        public PointerScrollEvent(
+            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: true,
+                delta: delta) {
+        }
+    }
+
+
     public class PointerHoverEvent : PointerEvent {
         public PointerHoverEvent(
             TimeSpan timeStamp,

Runtime/gestures/monodrag.cs

 
         readonly Dictionary<int, VelocityTracker> _velocityTrackers = new Dictionary<int, VelocityTracker>();
 
+        public override void addScrollPointer(PointerScrollEvent evt) {
+            this.startTrackingScrollerPointer(evt.pointer);
+            if (this._state == _DragState.ready) {
+                this._state = _DragState.possible;
+                this._initialPosition = evt.position;
+                if (this.onStart != null) {
+                    this.invokeCallback<object>("onStart", () => {
+                        this.onStart(new DragStartDetails(
+                            sourceTimeStamp: evt.timeStamp,
+                            globalPosition: this._initialPosition
+                        ));
+                        return null;
+                    });
+                }
+            }
+        }
+
         public override void addPointer(PointerDownEvent evt) {
             this.startTrackingPointer(evt.pointer);
             this._velocityTrackers[evt.pointer] = new VelocityTracker();
                 var tracker = this._velocityTrackers[evt.pointer];
                 D.assert(tracker != null);
                 tracker.addPosition(evt.timeStamp, evt.position);
+            }
+
+            if (evt is PointerScrollEvent) {
+                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,
+                            isScroll: true
+                        ));
+                        return null;
+                    });
+                }
+
+                this.invokeCallback<object>("onEnd", () => {
+                        this.onEnd(new DragEndDetails(
+                            velocity: Velocity.zero,
+                            primaryVelocity: 0.0
+                        ));
+                        return null;
+                    }, debugReport: () => { return ""; }
+                );
+
+
+                this._state = _DragState.ready;
+                return;
             }
 
             if (evt is PointerMoveEvent) {

Runtime/gestures/pointer_router.cs

             }
         }
 
+        public void clearScrollRoute(int pointer) {
+            if (this._routeMap.ContainsKey(pointer)) {
+                this._routeMap.Remove(pointer);
+            }
+        }
+
         public void addGlobalRoute(PointerRoute route) {
             D.assert(!this._globalRoutes.Contains(route));
             this._globalRoutes.Add(route);

Runtime/gestures/recognizer.cs

 
         public abstract void addPointer(PointerDownEvent evt);
 
+        public virtual void addScrollPointer(PointerScrollEvent evt) {
+        }
+
         public virtual void dispose() {
         }
 
             }
 
             return GestureBinding.instance.gestureArena.add(pointer, this);
+        }
+
+        protected void startTrackingScrollerPointer(int pointer) {
+            GestureBinding.instance.pointerRouter.addRoute(pointer, this.handleEvent);
         }
 
         protected void startTrackingPointer(int pointer) {

Runtime/rendering/proxy_box.cs

 
     public delegate void PointerLeaveEventListener(PointerLeaveEvent evt);
 
+    public delegate void PointerScrollEventListener(PointerScrollEvent 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 PointerScrollEvent) {
+                this.onPointerScroll((PointerScrollEvent) evt);
             }
         }
 

Runtime/ui/pointer.cs

         down,
         move,
         up,
+        scroll
     }
 
     public enum PointerDeviceKind {
         public int device;
         public double physicalX;
         public double physicalY;
+    }
+
+    public class ScrollData : PointerData {
+        public ScrollData(
+            TimeSpan timeStamp,
+            PointerChange change,
+            PointerDeviceKind kind,
+            int device,
+            double physicalX,
+            double physicalY,
+            double scrollX,
+            double scrollY) : base(timeStamp, change, kind, device, physicalX, physicalY) {
+            this.scrollX = scrollX;
+            this.scrollY = scrollY;
+        }
+
+        public double scrollX;
+        public double scrollY;
     }
 
     public class PointerDataPacket {

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

             }
         }
 
+        void _handlePointerScroll(PointerScrollEvent evt) {
+            D.assert(this._recognizers != null);
+            foreach (GestureRecognizer recognizer in this._recognizers.Values) {
+                recognizer.addScrollPointer(evt);
+            }
+        }
+
         HitTestBehavior _defaultBehavior {
             get { return this.widget.child == null ? HitTestBehavior.translucent : HitTestBehavior.deferToChild; }
         }
             Widget result = new Listener(
                 onPointerDown: this._handlePointerDown,
+                onPointerScroll: this._handlePointerScroll,
                 behavior: this.widget.behavior ?? this._defaultBehavior,
                 child: this.widget.child
             );

Runtime/widgets/scroll_activity.cs

 
         void applyUserOffset(double delta);
 
+        void applyUserScrollOffset(double delta);
+
         void goIdle();
 
         void goBallistic(double velocity);
             D.assert(details.primaryDelta != null);
             this._lastDetails = details;
             double offset = details.primaryDelta.Value;
+
+            if (details.isScroll) {
+                if (offset == 0.0) {
+                    return;
+                }
+
+                if (this._reversed) {
+                    offset = -offset;
+                }
+
+
+                this.del.applyUserScrollOffset(offset);
+                return;
+            }
+
+
             if (offset != 0.0) {
                 this._lastNonStationaryTimestamp = details.sourceTimeStamp;
             }

Runtime/widgets/scroll_position_with_single_context.cs

             }
         }
 
+        public virtual void applyUserScrollOffset(double delta) {
+            this.updateUserScrollDirection(delta > 0.0 ? ScrollDirection.forward : ScrollDirection.reverse);
+
+            var pixel = this.pixels - this.physics.applyPhysicsToUserOffset(this, delta);
+            if (pixel < this.minScrollExtent) {
+                pixel = this.minScrollExtent;
+            }
+
+            if (pixel > this.maxScrollExtent) {
+                pixel = this.maxScrollExtent;
+            }
+
+            this.setPixels(pixel);
+        }
+
         public virtual void applyUserOffset(double delta) {
             this.updateUserScrollDirection(delta > 0.0 ? ScrollDirection.forward : ScrollDirection.reverse);
             this.setPixels(this.pixels - this.physics.applyPhysicsToUserOffset(this, delta));

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_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}
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 0
+  m_IsActive: 1
 --- !u!224 &1387978527
 RectTransform:
   m_ObjectHideFlags: 0