fallback to flutter 1.0

Author: zhuxingwei

Runtime/material/slider.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.async;
 using Unity.UIWidgets.foundation;
@@ -10,6 +9,7 @@
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;
+using Canvas = Unity.UIWidgets.ui.Canvas;
 using Color = Unity.UIWidgets.ui.Color;
 using Rect = Unity.UIWidgets.ui.Rect;
 
@@ -253,14 +253,6 @@ public override void updateRenderObject(BuildContext context, RenderObject rende
     }
 
     class _RenderSlider : RenderBox {
-        //static TimeSpan _positionAnimationDuration = new TimeSpan(0, 0, 0, 0, 75);
-        //static TimeSpan _minimumInteractionTime = new TimeSpan(0, 0, 0, 0, 500);
-
-        static float _positionAnimationDurationMilliSeconds = 75;
-        static float _minimumInteractionTimeMilliSeconds = 500;
-
-        const float _minPreferredTrackWidth = 144.0f;
-
         public _RenderSlider(
             float? value = null,
             int? divisions = null,
@@ -287,7 +279,7 @@ public _RenderSlider(
             this._mediaQueryData = mediaQueryData;
             this._onChanged = onChanged;
             this._state = state;
-            
+
             this._updateLabelPainter();
             GestureArenaTeam team = new GestureArenaTeam();
             this._drag = new HorizontalDragGestureRecognizer {
@@ -304,64 +296,28 @@ public _RenderSlider(
                 onTapUp = this._handleTapUp,
                 onTapCancel = this._endInteraction
             };
-            
+
             this._overlayAnimation = new CurvedAnimation(
                 parent: this._state.overlayController,
                 curve: Curves.fastOutSlowIn);
-            
+
             this._valueIndicatorAnimation = new CurvedAnimation(
                 parent: this._state.valueIndicatorController,
                 curve: Curves.fastOutSlowIn);
-            
+
             this._enableAnimation = new CurvedAnimation(
                 parent: this._state.enableController,
                 curve: Curves.easeInOut);
         }
 
-        float _maxSliderPartWidth {
-            get {
-                float maxValue = 0;
-                foreach (Size size in this._sliderPartSizes) {
-                    if (size.width > maxValue) {
-                        maxValue = size.width;
-                    }
-                }
-                return maxValue;
-            }
-        }
-
-        float _maxSliderPartHeight {
-            get { 
-                float maxValue = 0;
-                foreach (Size size in this._sliderPartSizes) {
-                    if (size.width > maxValue) {
-                        maxValue = size.width;
-                    }
-                }
-                return maxValue; }
-        }
-
-        List<Size> __sliderPartSizes;
-        List<Size> _sliderPartSizes {
-            get {
-                if (this.__sliderPartSizes != null) {
-                    return this.__sliderPartSizes;
-                }
-                
-                this.__sliderPartSizes = new List<Size> {
-                    this._sliderTheme.overlayShape.getPreferredSize(this.isInteractive, this.isDiscrete),
-                    this._sliderTheme.thumbShape.getPreferredSize(this.isInteractive, this.isDiscrete),
-                    this._sliderTheme.tickMarkShape.getPreferredSize(isEnabled: this.isInteractive,
-                        sliderTheme: this.sliderTheme)
-                };
-                
-                return this.__sliderPartSizes;
-            }
-        }
-
-        float _minPreferredTrackHeight {
-            get { return this._sliderTheme.trackHeight; }
-        }
+        const float _positionAnimationDurationMilliSeconds = 75;
+        const float _overlayRadius = 16.0f;
+        const float _overlayDiameter = _overlayRadius * 2.0f;
+        const float _trackHeight = 2.0f;
+        const float _preferredTrackWidth = 144.0f;
+        const float _preferredTotalWidth = _preferredTrackWidth + _overlayDiameter;
+        const float _minimumInteractionTimeMilliSeconds = 500;
+        static readonly Animatable<float> _overlayRadiusTween = new FloatTween(begin: 0.0f, end: _overlayRadius);
 
         _SliderState _state;
         Animation<float> _overlayAnimation;
@@ -373,15 +329,8 @@ float _minPreferredTrackHeight {
         bool _active = false;
         float _currentDragValue = 0.0f;
 
-        Rect _trackRect {
-            get {
-                return this._sliderTheme.trackShape.getPreferredRect(
-                    parentBox: this,
-                    offset: Offset.zero,
-                    sliderTheme: this._sliderTheme,
-                    isDiscrete: false
-                );
-            }
+        float _trackLength {
+            get { return this.size.width - _overlayDiameter; }
         }
 
         bool isInteractive {
@@ -405,7 +354,7 @@ public float value {
                 if (this.isDiscrete) {
                     float distance = (this._value - this._state.positionController.value).abs();
                     this._state.positionController.duration = distance != 0.0f
-                        ? new TimeSpan(0, 0, 0, 0, (int)(_positionAnimationDurationMilliSeconds * (1.0f / distance)))
+                        ? new TimeSpan(0, 0, 0, 0, (int) (_positionAnimationDurationMilliSeconds * (1.0f / distance)))
                         : TimeSpan.Zero;
                     this._state.positionController.animateTo(convertedValue, curve: Curves.easeInOut);
                 }
@@ -438,6 +387,7 @@ public int? divisions {
                 }
 
                 this._divisions = value;
+                this.markNeedsPaint();
             }
         }
 
@@ -598,7 +548,7 @@ float _getValueFromVisualPosition(float visualPosition) {
 
         float _getValueFromGlobalPosition(Offset globalPosition) {
             float visualPosition =
-                (this.globalToLocal(globalPosition).dx - this._trackRect.left) / this._trackRect.width;
+                (this.globalToLocal(globalPosition).dx - _overlayRadius) / this._trackLength;
             return this._getValueFromVisualPosition(visualPosition);
         }
 
@@ -625,13 +575,16 @@ void _startInteraction(Offset globalPosition) {
                 if (this.showValueIndicator) {
                     this._state.valueIndicatorController.forward();
                     this._state.interactionTimer?.cancel();
-                    this._state.interactionTimer = Window.instance.run(new TimeSpan(0, 0, 0, 0, (int)(_minimumInteractionTimeMilliSeconds * SchedulerBinding.instance.timeDilation)), () => {
-                        this._state.interactionTimer = null;
-                        if (!this._active &&
-                            this._state.valueIndicatorController.status == AnimationStatus.completed) {
-                            this._state.valueIndicatorController.reverse();
-                        }
-                    });
+                    this._state.interactionTimer = Window.instance.run(
+                        new TimeSpan(0, 0, 0, 0,
+                            (int) (_minimumInteractionTimeMilliSeconds * SchedulerBinding.instance.timeDilation)),
+                        () => {
+                            this._state.interactionTimer = null;
+                            if (!this._active &&
+                                this._state.valueIndicatorController.status == AnimationStatus.completed) {
+                                this._state.valueIndicatorController.reverse();
+                            }
+                        });
                 }
             }
         }
@@ -657,7 +610,7 @@ void _handleDragStart(DragStartDetails details) {
 
         void _handleDragUpdate(DragUpdateDetails details) {
             if (this.isInteractive) {
-                float valueDelta = details.primaryDelta.Value / this._trackRect.width;
+                float valueDelta = details.primaryDelta.Value / this._trackLength;
                 this._currentDragValue += valueDelta;
                 this.onChanged(this._discretize(this._currentDragValue));
             }
@@ -689,19 +642,20 @@ public override void handleEvent(PointerEvent evt, HitTestEntry entry) {
 
 
         protected override float computeMinIntrinsicWidth(float height) {
-            return _minPreferredTrackWidth + this._maxSliderPartWidth;
+            return Mathf.Max(_overlayDiameter,
+                this._sliderTheme.thumbShape.getPreferredSize(this.isInteractive, this.isDiscrete).width);
         }
 
         protected override float computeMaxIntrinsicWidth(float height) {
-            return _minPreferredTrackWidth + this._maxSliderPartWidth;
+            return _preferredTotalWidth;
         }
 
         protected override float computeMinIntrinsicHeight(float width) {
-            return Mathf.Max(this._minPreferredTrackHeight, this._maxSliderPartHeight);
+            return _overlayDiameter;
         }
 
         protected override float computeMaxIntrinsicHeight(float width) {
-            return Mathf.Max(this._minPreferredTrackHeight, this._maxSliderPartHeight);
+            return _overlayDiameter;
         }
 
         protected override bool sizedByParent {
@@ -712,78 +666,114 @@ protected override void performResize() {
             this.size = new Size(
                 this.constraints.hasBoundedWidth
                     ? this.constraints.maxWidth
-                    : _minPreferredTrackWidth + this._maxSliderPartWidth,
+                    : _preferredTotalWidth,
                 this.constraints.hasBoundedHeight
                     ? this.constraints.maxHeight
-                    : Mathf.Max(this._minPreferredTrackHeight, this._maxSliderPartHeight)
+                    : _overlayDiameter
             );
         }
 
-        public override void paint(PaintingContext context, Offset offset) {
-            float value = this._state.positionController.value;
-            float visualPosition = value;
+        void _paintTickMarks(
+            Canvas canvas,
+            Rect trackLeft,
+            Rect trackRight,
+            Paint leftPaint,
+            Paint rightPaint) {
+            if (this.isDiscrete) {
+                const float tickRadius = _trackHeight / 2.0f;
+                float trackWidth = trackRight.right - trackLeft.left;
+                float dx = (trackWidth - _trackHeight) / this.divisions.Value;
+
+                if (dx >= 3.0 * _trackHeight) {
+                    for (int i = 0; i <= this.divisions.Value; i += 1) {
+                        float left = trackLeft.left + i * dx;
+                        Offset center = new Offset(left + tickRadius, trackLeft.top + tickRadius);
+                        if (trackLeft.contains(center)) {
+                            canvas.drawCircle(center, tickRadius, leftPaint);
+                        }
+                        else if (trackRight.contains(center)) {
+                            canvas.drawCircle(center, tickRadius, rightPaint);
+                        }
+                    }
+                }
+            }
+        }
 
-            Rect trackRect = this._sliderTheme.trackShape.getPreferredRect(
-                parentBox: this,
-                offset: offset,
-                sliderTheme: this._sliderTheme,
-                isDiscrete: this.isDiscrete
-            );
+        void _paintOverlay(
+            Canvas canvas,
+            Offset center) {
+            Paint overlayPaint = new Paint {color = this._sliderTheme.overlayColor};
+            float radius = _overlayRadiusTween.evaluate(this._overlayAnimation);
+            canvas.drawCircle(center, radius, overlayPaint);
+        }
 
-            Offset thumbCenter = new Offset(trackRect.left + visualPosition * trackRect.width, trackRect.center.dy);
+        public override void paint(PaintingContext context, Offset offset) {
+            Canvas canvas = context.canvas;
 
-            this._sliderTheme.trackShape.paint(
-                context,
-                offset,
-                parentBox: this,
-                sliderTheme: this._sliderTheme,
-                enableAnimation: this._enableAnimation,
-                thumbCenter: thumbCenter,
-                isDiscrete: this.isDiscrete,
-                isEnabled: this.isInteractive
-            );
+            float trackLength = this.size.width - 2 * _overlayRadius;
+            float value = this._state.positionController.value;
+            ColorTween activeTrackEnableColor = new ColorTween(begin: this._sliderTheme.disabledActiveTrackColor,
+                end: this._sliderTheme.activeTrackColor);
+            ColorTween inactiveTrackEnableColor = new ColorTween(begin: this._sliderTheme.disabledInactiveTrackColor,
+                end: this._sliderTheme.inactiveTrackColor);
+            ColorTween activeTickMarkEnableColor = new ColorTween(begin: this._sliderTheme.disabledActiveTickMarkColor,
+                end: this._sliderTheme.activeTickMarkColor);
+            ColorTween inactiveTickMarkEnableColor =
+                new ColorTween(begin: this._sliderTheme.disabledInactiveTickMarkColor,
+                    end: this._sliderTheme.inactiveTickMarkColor);
+
+            Paint activeTrackPaint = new Paint {color = activeTrackEnableColor.evaluate(this._enableAnimation)};
+            Paint inactiveTrackPaint = new Paint {color = inactiveTrackEnableColor.evaluate(this._enableAnimation)};
+            Paint activeTickMarkPaint = new Paint {color = activeTickMarkEnableColor.evaluate(this._enableAnimation)};
+            Paint inactiveTickMarkPaint = new Paint
+                {color = inactiveTickMarkEnableColor.evaluate(this._enableAnimation)};
 
-            if (!this._overlayAnimation.isDismissed) {
-                this._sliderTheme.overlayShape.paint(
-                    context,
-                    thumbCenter,
-                    activationAnimation: this._overlayAnimation,
-                    enableAnimation: this._enableAnimation,
-                    isDiscrete: this.isDiscrete,
-                    labelPainter: this._labelPainter,
-                    parentBox: this,
-                    sliderTheme: this._sliderTheme,
-                    value: this._value
-                );
+            float visualPosition = value;
+            Paint leftTrackPaint = activeTrackPaint;
+            Paint rightTrackPaint = inactiveTrackPaint;
+            Paint leftTickMarkPaint = activeTickMarkPaint;
+            Paint rightTickMarkPaint = inactiveTickMarkPaint;
+
+            float trackRadius = _trackHeight / 2.0f;
+            float thumbGap = 2.0f;
+
+            float trackVerticalCenter = offset.dy + (this.size.height) / 2.0f;
+            float trackLeft = offset.dx + _overlayRadius;
+            float trackTop = trackVerticalCenter - trackRadius;
+            float trackBottom = trackVerticalCenter + trackRadius;
+            float trackRight = trackLeft + trackLength;
+            float trackActive = trackLeft + trackLength * visualPosition;
+            float thumbRadius =
+                this._sliderTheme.thumbShape.getPreferredSize(this.isInteractive, this.isDiscrete).width / 2.0f;
+            float trackActiveLeft = Mathf.Max(0.0f,
+                trackActive - thumbRadius - thumbGap * (1.0f - this._enableAnimation.value));
+            float trackActiveRight =
+                Mathf.Min(trackActive + thumbRadius + thumbGap * (1.0f - this._enableAnimation.value), trackRight);
+            Rect trackLeftRect = Rect.fromLTRB(trackLeft, trackTop, trackActiveLeft, trackBottom);
+            Rect trackRightRect = Rect.fromLTRB(trackActiveRight, trackTop, trackRight, trackBottom);
+
+            Offset thumbCenter = new Offset(trackActive, trackVerticalCenter);
+
+            if (visualPosition > 0.0) {
+                canvas.drawRect(trackLeftRect, leftTrackPaint);
             }
 
-            if (this.isDiscrete) {
-                float tickMarkWidth = this._sliderTheme.tickMarkShape.getPreferredSize(
-                    isEnabled: this.isInteractive,
-                    sliderTheme: this._sliderTheme
-                ).width;
-
-                if ((trackRect.width - tickMarkWidth) / this.divisions.Value >= 3.0f * tickMarkWidth) {
-                    for (int i = 0; i <= this.divisions; i++) {
-                        float tickValue = i / this.divisions.Value;
-                        float tickX = trackRect.left +
-                                      tickValue * (trackRect.width - tickMarkWidth) + tickMarkWidth / 2;
-                        float tickY = trackRect.center.dy;
-                        Offset tickMarkOffset = new Offset(tickX, tickY);
-                        this._sliderTheme.tickMarkShape.paint(
-                            context,
-                            tickMarkOffset,
-                            parentBox: this,
-                            sliderTheme: this._sliderTheme,
-                            enableAnimation: this._enableAnimation,
-                            thumbCenter: thumbCenter,
-                            isEnabled: this.isInteractive
-                        );
-                    }
-                }
+            if (visualPosition < 1.0) {
+                canvas.drawRect(trackRightRect, rightTrackPaint);
             }
 
-            if (this.isInteractive && this.label != null && !this._valueIndicatorAnimation.isDismissed) {
+            this._paintOverlay(canvas, thumbCenter);
+
+            this._paintTickMarks(
+                canvas,
+                trackLeftRect,
+                trackRightRect,
+                leftTickMarkPaint,
+                rightTickMarkPaint
+            );
+
+            if (this.isInteractive && this.label != null &&
+                this._valueIndicatorAnimation.status != AnimationStatus.dismissed) {
                 if (this.showValueIndicator) {
                     this._sliderTheme.valueIndicatorShape.paint(
                         context,