Example #1
0
        public static ScrollMetrics copyWith(ScrollMetrics it,
                                             double?minScrollExtent      = null,
                                             double?maxScrollExtent      = null,
                                             double?pixels               = null,
                                             double?viewportDimension    = null,
                                             AxisDirection?axisDirection = null,
                                             double?viewportFraction     = null
                                             )
        {
            if (it is IPageMetrics)
            {
                return(new PageMetrics(
                           minScrollExtent: minScrollExtent ?? it.minScrollExtent,
                           maxScrollExtent: maxScrollExtent ?? it.maxScrollExtent,
                           pixels: pixels ?? it.pixels,
                           viewportDimension: viewportDimension ?? it.viewportDimension,
                           axisDirection: axisDirection ?? it.axisDirection,
                           viewportFraction: viewportFraction ?? ((IPageMetrics)it).viewportFraction
                           ));
            }

            return(new FixedScrollMetrics(
                       minScrollExtent: minScrollExtent ?? it.minScrollExtent,
                       maxScrollExtent: maxScrollExtent ?? it.maxScrollExtent,
                       pixels: pixels ?? it.pixels,
                       viewportDimension: viewportDimension ?? it.viewportDimension,
                       axisDirection: axisDirection ?? it.axisDirection
                       ));
        }
Example #2
0
        bool _handleScrollNotification(ScrollNotification notification)
        {
            ScrollMetrics metrics = notification.metrics;

            if (metrics.maxScrollExtent <= metrics.minScrollExtent)
            {
                return(false);
            }

            if (notification is ScrollUpdateNotification ||
                notification is OverscrollNotification)
            {
                if (_fadeoutAnimationController.status != AnimationStatus.forward)
                {
                    _fadeoutAnimationController.forward();
                }
                _fadeoutTimer?.cancel();
                _painter.update(notification.metrics, notification.metrics.axisDirection);
            }
            else if (notification is ScrollEndNotification)
            {
                if (_dragScrollbarPositionY == null)
                {
                    _startFadeoutTimer();
                }
            }
            return(false);
        }
        public override float applyBoundaryConditions(ScrollMetrics position, float value)
        {
            if (!this.enableOverScroll)
            {
                if (value < position.pixels &&
                    position.pixels <= position.minScrollExtent)
                {
                    return(value - position.pixels);
                }

                if (value < position.minScrollExtent &&
                    position.minScrollExtent < position.pixels)
                {
                    return(value - position.minScrollExtent);
                }

                if (position.maxScrollExtent <= position.pixels &&
                    position.pixels < value)
                {
                    return(value - position.pixels);
                }

                if (position.pixels < position.maxScrollExtent &&
                    position.maxScrollExtent < value)
                {
                    return(value - position.maxScrollExtent);
                }
            }

            return(0.0f);
        }
Example #4
0
 public static float extentInside(this ScrollMetrics it)
 {
     D.assert(it.minScrollExtent <= it.maxScrollExtent);
     return(it.viewportDimension
            - (it.minScrollExtent - it.pixels).clamp(0, max: it.viewportDimension)
            - (it.pixels - it.maxScrollExtent).clamp(0, max: it.viewportDimension));
 }
Example #5
0
        bool _handleScrollNotification(ScrollNotification notification)
        {
            ScrollMetrics metrics = notification.metrics;

            if (metrics.maxScrollExtent <= metrics.minScrollExtent)
            {
                return(false);
            }
            if (!_useCupertinoScrollbar.Value &&
                (notification is ScrollUpdateNotification ||
                 notification is OverscrollNotification))
            {
                if (_fadeoutAnimationController.status != AnimationStatus.forward)
                {
                    _fadeoutAnimationController.forward();
                }

                _materialPainter.update(
                    notification.metrics,
                    notification.metrics.axisDirection
                    );
                if (!widget.isAlwaysShown)
                {
                    _fadeoutTimer?.cancel();
                    _fadeoutTimer = Timer.create(ScrollbarUtils._kScrollbarTimeToFade, () => {
                        _fadeoutAnimationController.reverse();
                        _fadeoutTimer = null;
                    });
                }
            }
            return(false);
        }
Example #6
0
        public override Simulation createBallisticSimulation(ScrollMetrics position, float velocity)
        {
            D.assert(
                position is _FixedExtentScrollPosition,
                () => "FixedExtentScrollPhysics can only be used with Scrollables that uses " +
                "the FixedExtentScrollController"
                );

            _FixedExtentScrollPosition metrics = (_FixedExtentScrollPosition)position;

            if ((velocity <= 0.0f && metrics.pixels <= metrics.minScrollExtent) ||
                (velocity >= 0.0f && metrics.pixels >= metrics.maxScrollExtent))
            {
                return(base.createBallisticSimulation(metrics, velocity));
            }

            Simulation testFrictionSimulation =
                base.createBallisticSimulation(metrics, velocity);

            if (testFrictionSimulation != null &&
                (testFrictionSimulation.x(float.PositiveInfinity) == metrics.minScrollExtent ||
                 testFrictionSimulation.x(float.PositiveInfinity) == metrics.maxScrollExtent))
            {
                return(base.createBallisticSimulation(metrics, velocity));
            }

            int settlingItemIndex = ListWheelScrollViewUtils._getItemFromOffset(
                offset: testFrictionSimulation?.x(float.PositiveInfinity) ?? metrics.pixels,
                itemExtent: metrics.itemExtent,
                minScrollExtent: metrics.minScrollExtent,
                maxScrollExtent: metrics.maxScrollExtent
                );

            float settlingPixels = settlingItemIndex * metrics.itemExtent;

            if (velocity.abs() < tolerance.velocity &&
                (settlingPixels - metrics.pixels).abs() < tolerance.distance)
            {
                return(null);
            }

            if (settlingItemIndex == metrics.itemIndex)
            {
                return(new SpringSimulation(
                           spring,
                           metrics.pixels,
                           settlingPixels,
                           velocity,
                           tolerance: tolerance
                           ));
            }

            return(FrictionSimulation.through(
                       metrics.pixels,
                       settlingPixels,
                       velocity,
                       tolerance.velocity * velocity.sign()
                       ));
        }
 public ScrollStartNotification(
     ScrollMetrics metrics        = null,
     BuildContext context         = null,
     DragStartDetails dragDetails = null
     ) : base(metrics: metrics, context: context)
 {
     this.dragDetails = dragDetails;
 }
 public UserScrollNotification(
     ScrollMetrics metrics     = null,
     BuildContext context      = null,
     ScrollDirection direction = ScrollDirection.idle
     ) : base(metrics: metrics, context: context)
 {
     this.direction = direction;
 }
Example #9
0
        public override void dispatchScrollStartNotification(ScrollMetrics metrics, BuildContext context)
        {
            object lastDetails = this._controller.lastDetails;

            D.assert(lastDetails is DragStartDetails);
            new ScrollStartNotification(metrics: metrics, context: context, dragDetails: (DragStartDetails)lastDetails)
            .dispatch(context);
        }
 protected ScrollNotification(
     ScrollMetrics metrics = null,
     BuildContext context  = null
     )
 {
     this.metrics = metrics;
     this.context = context;
 }
Example #11
0
        public virtual float applyPhysicsToUserOffset(ScrollMetrics position, float offset)
        {
            if (parent == null)
            {
                return(offset);
            }

            return(parent.applyPhysicsToUserOffset(position, offset));
        }
Example #12
0
        public virtual Simulation createBallisticSimulation(ScrollMetrics position, double velocity)
        {
            if (this.parent == null)
            {
                return(null);
            }

            return(this.parent.createBallisticSimulation(position, velocity));
        }
Example #13
0
        public virtual double applyBoundaryConditions(ScrollMetrics position, double value)
        {
            if (this.parent == null)
            {
                return(0.0);
            }

            return(this.parent.applyBoundaryConditions(position, value));
        }
Example #14
0
        public virtual bool shouldAcceptUserOffset(ScrollMetrics position)
        {
            if (this.parent == null)
            {
                return(position.pixels != 0.0 || position.minScrollExtent != position.maxScrollExtent);
            }

            return(this.parent.shouldAcceptUserOffset(position));
        }
Example #15
0
        public virtual double applyPhysicsToUserOffset(ScrollMetrics position, double offset)
        {
            if (this.parent == null)
            {
                return(offset);
            }

            return(this.parent.applyPhysicsToUserOffset(position, offset));
        }
        public virtual float applyBoundaryConditions(ScrollMetrics position, float value)
        {
            if (this.parent == null)
            {
                return(0.0f);
            }

            return(this.parent.applyBoundaryConditions(position, value));
        }
Example #17
0
 public ScrollIncrementDetails(
     ScrollIncrementType type,
     ScrollMetrics metrics
     )
 {
     D.assert(metrics != null);
     this.type    = type;
     this.metrics = metrics;
 }
Example #18
0
        float _getPage(ScrollMetrics position)
        {
            if (position is _PagePosition)
            {
                return(((_PagePosition)position).page);
            }

            return(position.pixels / position.viewportDimension);
        }
Example #19
0
        float _getPixels(ScrollMetrics position, float page)
        {
            if (position is _PagePosition)
            {
                return(((_PagePosition)position).getPixelsFromPage(page));
            }

            return(page * position.viewportDimension);
        }
Example #20
0
        public override void dispatchOverscrollNotification(ScrollMetrics metrics, BuildContext context,
                                                            double overscroll)
        {
            object lastDetails = this._controller.lastDetails;

            D.assert(lastDetails is DragUpdateDetails);
            new OverscrollNotification(metrics: metrics, context: context, overscroll: overscroll,
                                       dragDetails: (DragUpdateDetails)lastDetails).dispatch(context);
        }
Example #21
0
        public override void dispatchScrollUpdateNotification(ScrollMetrics metrics, BuildContext context,
                                                              double scrollDelta)
        {
            object lastDetails = this._controller.lastDetails;

            D.assert(lastDetails is DragUpdateDetails);
            new ScrollUpdateNotification(metrics: metrics, context: context, scrollDelta: scrollDelta,
                                         dragDetails: (DragUpdateDetails)lastDetails).dispatch(context);
        }
 public ScrollUpdateNotification(
     ScrollMetrics metrics         = null,
     BuildContext context          = null,
     DragUpdateDetails dragDetails = null,
     float scrollDelta             = 0
     ) : base(metrics: metrics, context: context)
 {
     this.dragDetails = dragDetails;
     this.scrollDelta = scrollDelta;
 }
Example #23
0
        float _getScrollToTrack(ScrollMetrics metrics, float thumbExtent)
        {
            float scrollableExtent = metrics.maxScrollExtent - metrics.minScrollExtent;

            float fractionPast = (scrollableExtent > 0)
                ? ((metrics.pixels - metrics.minScrollExtent) / scrollableExtent).clamp(0.0f, 1.0f)
                : 0;

            return((_isReversed ? 1 - fractionPast : fractionPast) * (_trackExtent - thumbExtent));
        }
Example #24
0
        public override void dispatchScrollEndNotification(ScrollMetrics metrics, BuildContext context)
        {
            object lastDetails = this._controller.lastDetails;

            new ScrollEndNotification(
                metrics: metrics,
                context: context,
                dragDetails: lastDetails as DragEndDetails
                ).dispatch(context);
        }
 public ScrollEndNotification(
     ScrollMetrics metrics      = null,
     BuildContext context       = null,
     DragEndDetails dragDetails = null,
     float overscroll           = 0,
     float velocity             = 0
     ) : base(metrics: metrics, context: context)
 {
     this.dragDetails = dragDetails;
 }
Example #26
0
        public bool recommendDeferredLoading(float velocity, ScrollMetrics metrics, BuildContext context)
        {
            D.assert(metrics != null);
            D.assert(context != null);
            if (parent == null)
            {
                float maxPhysicalPixels = WidgetsBinding.instance.window.physicalSize.longestSide;
                return(velocity.abs() > maxPhysicalPixels);
            }

            return(parent.recommendDeferredLoading(velocity, metrics, context));
        }
 public OverscrollNotification(
     ScrollMetrics metrics         = null,
     BuildContext context          = null,
     DragUpdateDetails dragDetails = null,
     float overscroll = 0,
     float velocity   = 0
     ) : base(metrics: metrics, context: context)
 {
     this.dragDetails = dragDetails;
     this.overscroll  = overscroll;
     this.velocity    = velocity;
 }
Example #28
0
        float _getTargetPixels(ScrollMetrics position, Tolerance tolerance, float velocity)
        {
            float page = _getPage(position);

            if (velocity < -tolerance.velocity)
            {
                page -= 0.5f;
            }
            else if (velocity > tolerance.velocity)
            {
                page += 0.5f;
            }

            return(_getPixels(position, page.round()));
        }
Example #29
0
        public override Simulation createBallisticSimulation(ScrollMetrics position, double velocity)
        {
            Tolerance tolerance = this.tolerance;

            if (position.outOfRange())
            {
                double?end = null;
                if (position.pixels > position.maxScrollExtent)
                {
                    end = position.maxScrollExtent;
                }

                if (position.pixels < position.minScrollExtent)
                {
                    end = position.minScrollExtent;
                }

                D.assert(end != null);
                return(new ScrollSpringSimulation(
                           this.spring,
                           position.pixels,
                           position.maxScrollExtent,
                           Math.Min(0.0, velocity),
                           tolerance: tolerance
                           ));
            }

            if (velocity.abs() < tolerance.velocity)
            {
                return(null);
            }

            if (velocity > 0.0 && position.pixels >= position.maxScrollExtent)
            {
                return(null);
            }

            if (velocity < 0.0 && position.pixels <= position.minScrollExtent)
            {
                return(null);
            }

            return(new ClampingScrollSimulation(
                       position: position.pixels,
                       velocity: velocity,
                       tolerance: tolerance
                       ));
        }
Example #30
0
        public override Simulation createBallisticSimulation(ScrollMetrics position, float velocity)
        {
            if ((velocity <= 0.0 && position.pixels <= position.minScrollExtent) ||
                (velocity >= 0.0 && position.pixels >= position.maxScrollExtent))
            {
                return(base.createBallisticSimulation(position, velocity));
            }

            Tolerance tolerance = this.tolerance;
            float     target    = _getTargetPixels((ScrollPosition)position, tolerance, velocity);

            if (target != position.pixels)
            {
                return(new ScrollSpringSimulation(spring, position.pixels, target, velocity, tolerance: tolerance));
            }

            return(null);
        }