/** * Start scrolling based on a fling gesture. The distance traveled will depend on the initial * velocity of the fling. * * @param startX Starting point of the scroll (X) * @param startY Starting point of the scroll (Y) * @param velocityX Initial velocity of the fling (X) measured in pixels per second. * @param velocityY Initial velocity of the fling (Y) measured in pixels per second * @param minX Minimum X value. The scroller will not scroll past this point unless overX > 0. If * overfling is allowed, it will use minX as a springback boundary. * @param maxX Maximum X value. The scroller will not scroll past this point unless overX > 0. If * overfling is allowed, it will use maxX as a springback boundary. * @param minY Minimum Y value. The scroller will not scroll past this point unless overY > 0. If * overfling is allowed, it will use minY as a springback boundary. * @param maxY Maximum Y value. The scroller will not scroll past this point unless overY > 0. If * overfling is allowed, it will use maxY as a springback boundary. * @param overX Overfling range. If > 0, horizontal overfling in either direction will be * possible. * @param overY Overfling range. If > 0, vertical overfling in either direction will be possible. */ public void fling( int startX, int startY, int velocityX, int velocityY, int minX, int maxX, int minY, int maxY, int overX, int overY) { // Continue a scroll or fling in progress if (mFlywheel && !isFinished()) { float oldVelocityX = mScrollerX.mCurrVelocity; float oldVelocityY = mScrollerY.mCurrVelocity; if (Math.signum(velocityX) == Math.signum(oldVelocityX) && Math.signum(velocityY) == Math.signum(oldVelocityY)) { velocityX += oldVelocityX; velocityY += oldVelocityY; } } mMode = FLING_MODE; mScrollerX.fling(startX, velocityX, minX, maxX, overX); mScrollerY.fling(startY, velocityY, minY, maxY, overY); }
/** * Call this when you want to 'spring back' into a valid coordinate range. * * @param startX Starting X coordinate * @param startY Starting Y coordinate * @param minX Minimum valid X value * @param maxX Maximum valid X value * @param minY Minimum valid Y value * @param maxY Minimum valid Y value * @return true if a springback was initiated, false if startX and startY were already within the * valid range. */ public boolean springBack(int startX, int startY, int minX, int maxX, int minY, int maxY) { mMode = FLING_MODE; // Make sure both methods are called. final boolean spingbackX = mScrollerX.springback(startX, minX, maxX); final boolean spingbackY = mScrollerY.springback(startY, minY, maxY); return spingbackX || spingbackY; }
/** * Call this when you want to know the new location. If it returns true, the animation is not yet * finished. */ public boolean computeScrollOffset() { if (isFinished()) { return false; } switch (mMode) { case SCROLL_MODE: long time = AnimationUtils.currentAnimationTimeMillis(); // Any scroller can be used for time, since they were started // together in scroll mode. We use X here. final long elapsedTime = time - mScrollerX.mStartTime; final int duration = mScrollerX.mDuration; if (elapsedTime < duration) { final float q = mInterpolator.getInterpolation(elapsedTime / (float) duration); mScrollerX.updateScroll(q); mScrollerY.updateScroll(q); } else { abortAnimation(); } break; case FLING_MODE: if (!mScrollerX.mFinished) { if (!mScrollerX.update()) { if (!mScrollerX.continueWhenFinished()) { mScrollerX.finish(); } } } if (!mScrollerY.mFinished) { if (!mScrollerY.update()) { if (!mScrollerY.continueWhenFinished()) { mScrollerY.finish(); } } } break; } return true; }
/** * Stops the animation. Contrary to {@link #forceFinished(boolean)}, aborting the animating causes * the scroller to move to the final x and y positions. * * @see #forceFinished(boolean) */ public void abortAnimation() { mScrollerX.finish(); mScrollerY.finish(); }
/** * Notify the scroller that we've reached a vertical boundary. Normally the information to handle * this will already be known when the animation is started, such as in a call to one of the fling * functions. However there are cases where this cannot be known in advance. This function will * animate a parabolic motion from startY to finalY. * * @param startY Starting/current Y position * @param finalY Desired final Y position * @param overY Magnitude of overscroll allowed. This should be the maximum desired distance from * finalY. Absolute value - must be positive. */ public void notifyVerticalEdgeReached(int startY, int finalY, int overY) { mScrollerY.notifyEdgeReached(startY, finalY, overY); }
/** * Notify the scroller that we've reached a horizontal boundary. Normally the information to * handle this will already be known when the animation is started, such as in a call to one of * the fling functions. However there are cases where this cannot be known in advance. This * function will transition the current motion and animate from startX to finalX as appropriate. * * @param startX Starting/current X position * @param finalX Desired final X position * @param overX Magnitude of overscroll allowed. This should be the maximum desired distance from * finalX. Absolute value - must be positive. */ public void notifyHorizontalEdgeReached(int startX, int finalX, int overX) { mScrollerX.notifyEdgeReached(startX, finalX, overX); }
/** * Start scrolling by providing a starting point and the distance to travel. * * @param startX Starting horizontal scroll offset in pixels. Positive numbers will scroll the * content to the left. * @param startY Starting vertical scroll offset in pixels. Positive numbers will scroll the * content up. * @param dx Horizontal distance to travel. Positive numbers will scroll the content to the left. * @param dy Vertical distance to travel. Positive numbers will scroll the content up. * @param duration Duration of the scroll in milliseconds. */ public void startScroll(int startX, int startY, int dx, int dy, int duration) { mMode = SCROLL_MODE; mScrollerX.startScroll(startX, dx, duration); mScrollerY.startScroll(startY, dy, duration); }
/** * Sets the final position (Y) for this scroller. * * @param newY The new Y offset as an absolute distance from the origin. * @see #extendDuration(int) * @see #setFinalX(int) * @hide Pending removal once nothing depends on it * @deprecated OverScroller's final position may change during an animation. Instead of setting a * new final position and extending the duration of an existing scroll, use startScroll to * begin a new animation. */ @Deprecated public void setFinalY(int newY) { mScrollerY.setFinalPosition(newY); }
/** * Sets the final position (X) for this scroller. * * @param newX The new X offset as an absolute distance from the origin. * @see #extendDuration(int) * @see #setFinalY(int) * @hide Pending removal once nothing depends on it * @deprecated OverScroller's final position may change during an animation. Instead of setting a * new final position and extending the duration of an existing scroll, use startScroll to * begin a new animation. */ @Deprecated public void setFinalX(int newX) { mScrollerX.setFinalPosition(newX); }
/** * Extend the scroll animation. This allows a running animation to scroll further and longer, when * used with {@link #setFinalX(int)} or {@link #setFinalY(int)}. * * @param extend Additional time to scroll in milliseconds. * @see #setFinalX(int) * @see #setFinalY(int) * @hide Pending removal once nothing depends on it * @deprecated OverScrollers don't necessarily have a fixed duration. Instead of setting a new * final position and extending the duration of an existing scroll, use startScroll to begin a * new animation. */ @Deprecated public void extendDuration(int extend) { mScrollerX.extendDuration(extend); mScrollerY.extendDuration(extend); }
/** * Force the finished field to a particular value. Contrary to {@link #abortAnimation()}, forcing * the animation to finished does NOT cause the scroller to move to the final x and y position. * * @param finished The new finished value. */ public final void forceFinished(boolean finished) { mScrollerX.mFinished = mScrollerY.mFinished = finished; }
/** * The amount of friction applied to flings. The default value is {@link * ViewConfiguration#getScrollFriction}. * * @param friction A scalar dimension-less value representing the coefficient of friction. */ public final void setFriction(float friction) { mScrollerX.setFriction(friction); mScrollerY.setFriction(friction); }