@Override public void computeScroll() { if (mScroller.computeScrollOffset()) { // This is called at drawing time by ViewGroup. We don't want to // re-show the scrollbars at this point, which scrollTo will do, // so we replicate most of scrollTo here. // // It's a little odd to call onScrollChanged from inside the drawing. // // It is, except when you remember that computeScroll() is used to // animate scrolling. So unless we want to defer the onScrollChanged() // until the end of the animated scrolling, we don't really have a // choice here. // // I agree. The alternative, which I think would be worse, is to post // something and tell the subclasses later. This is bad because there // will be a window where mScrollX/Y is different from what the app // thinks it is. // int oldX = getScrollX(); // mScrollX; int oldY = getScrollY(); // mScrollY; int x = mScroller.getCurrX(); int y = mScroller.getCurrY(); CFUtil.Log("sx=" + x + ", sy=" + y); if (oldX != x || oldY != y) { final int rangeY = getScrollRangeY(); // final int overscrollMode = getOverScrollMode(); // final boolean canOverscroll = overscrollMode == OVER_SCROLL_ALWAYS || // (overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0); // overScrollBy(x - oldX, y - oldY, oldX, oldY, 0, range, // 0, mOverflingDistance, false); scrollTo(x, y); onScrollChanged(getScrollX(), getScrollY(), oldX, oldY); // if (canOverscroll) { // if (y < 0 && oldY >= 0) { // mEdgeGlowTop.onAbsorb((int) mScroller.getCurrVelocity()); // } else if (y > range && oldY <= range) { // mEdgeGlowBottom.onAbsorb((int) mScroller.getCurrVelocity()); // } // } } postInvalidate(); // if (!awakenScrollBars()) { // // Keep on drawing until the animation has finished. // postInvalidateOnAnimation(); // } } // else { // if (mFlingStrictSpan != null) { // mFlingStrictSpan.finish(); // mFlingStrictSpan = null; // } // } }
// Returns the distance that over the scroll limit. public int startScroll(int distance, int min, int max) { int currPosition = mScroller.getCurrX(); int finalPosition = mScroller.isFinished() ? currPosition : mScroller.getFinalX(); int newPosition = Utils.clamp(finalPosition + distance, min, max); if (newPosition != currPosition) { mScroller.startScroll(currPosition, 0, newPosition - currPosition, 0, 0); } return finalPosition + distance - newPosition; }
@Override public void computeScroll() { super.computeScroll(); if (mScroller.computeScrollOffset()) { mRect.offsetTo(mScroller.getCurrX(), mScroller.getCurrY()); ViewCompat.postInvalidateOnAnimation(this); } }
public int getCurrX() { if (isPreGingerbread) { return scroller.getCurrX(); } else { return overScroller.getCurrX(); } }
@Override public void computeScroll() { if (mScroller.computeScrollOffset()) { // This is called at drawing time by ViewGroup. We don't want to // re-show the scrollbars at this point, which scrollTo will do, // so we replicate most of scrollTo here. // // It's a little odd to call onScrollChanged from inside the drawing. // // It is, except when you remember that computeScroll() is used to // animate scrolling. So unless we want to defer the onScrollChanged() // until the end of the animated scrolling, we don't really have a // choice here. // // I agree. The alternative, which I think would be worse, is to post // something and tell the subclasses later. This is bad because there // will be a window where mScrollX/Y is different from what the app // thinks it is. // int oldX = getScrollX(); int oldY = getScrollY(); int x = mScroller.getCurrX(); int y = mScroller.getCurrY(); if (oldX != x || oldY != y) { final int range = getScrollRange(); final int overscrollMode = getOverScrollMode(); final boolean canOverscroll = overscrollMode == OVER_SCROLL_ALWAYS || (overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0); overScrollBy(x - oldX, y - oldY, oldX, oldY, range, 0, mOverflingDistance, 0, false); onScrollChanged(getScrollX(), getScrollY(), oldX, oldY); } if (!awakenScrollBars()) { postInvalidateOnAnimation(); } } else { int scrollX = getScrollX(); int finalX = getScrollXFromFinalX(scrollX); if (!mIsBeingDragged && scrollX != finalX) { if (mScroller.springBack(getScrollX(), getScrollY(), finalX, finalX, 0, 0)) { postInvalidateOnAnimation(); } } } }
// Called immediately before the draw to update the scroll offset. public void computeScrollAndAbsorbGlow(OverScrollGlow overScrollGlow) { final boolean stillAnimating = mScroller.computeScrollOffset(); if (!stillAnimating) return; final int oldX = mDelegate.getContainerViewScrollX(); final int oldY = mDelegate.getContainerViewScrollY(); int x = mScroller.getCurrX(); int y = mScroller.getCurrY(); int rangeX = computeMaximumHorizontalScrollOffset(); int rangeY = computeMaximumVerticalScrollOffset(); if (overScrollGlow != null) { overScrollGlow.absorbGlow(x, y, oldX, oldY, rangeX, rangeY, mScroller.getCurrVelocity()); } // The mScroller is configured not to go outside of the scrollable range, so this call // should never result in attempting to scroll outside of the scrollable region. scrollBy(x - oldX, y - oldY); mDelegate.invalidate(); }
@Override public int getCurrX() { return mScroller.getCurrX(); }
public int getPosition() { return mScroller.getCurrX(); }
@Override protected int getCurrX() { return mScroller.getCurrX(); }