diff options
| -rw-r--r-- | core/java/android/view/View.java | 514 | ||||
| -rw-r--r-- | core/java/android/view/ViewConfiguration.java | 18 | ||||
| -rw-r--r-- | graphics/java/android/graphics/drawable/Drawable.java | 16 |
3 files changed, 295 insertions, 253 deletions
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java index 5ee3c16..6d3c07a 100644 --- a/core/java/android/view/View.java +++ b/core/java/android/view/View.java @@ -16,9 +16,7 @@ package android.view; -import android.animation.Animator; import android.animation.AnimatorInflater; -import android.animation.ObjectAnimator; import android.animation.StateListAnimator; import android.annotation.DrawableRes; import android.annotation.IdRes; @@ -34,10 +32,13 @@ import android.content.res.TypedArray; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Insets; +import android.graphics.Interpolator; import android.graphics.LinearGradient; import android.graphics.Matrix; import android.graphics.Outline; import android.graphics.Paint; +import android.graphics.Path; +import android.graphics.PathMeasure; import android.graphics.PixelFormat; import android.graphics.Point; import android.graphics.PorterDuff; @@ -4325,7 +4326,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * @hide This is the real method; the public one is shimmed to be safe to call from apps. */ protected void initializeFadingEdgeInternal(TypedArray a) { - getScrollCache().fadingEdgeLength = a.getDimensionPixelSize( + initScrollCache(); + + mScrollCache.fadingEdgeLength = a.getDimensionPixelSize( R.styleable.View_fadingEdgeLength, ViewConfiguration.get(mContext).getScaledFadingEdgeLength()); } @@ -4359,7 +4362,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * content in this view is visible. */ public void setFadingEdgeLength(int length) { - getScrollCache().fadingEdgeLength = length; + initScrollCache(); + mScrollCache.fadingEdgeLength = length; } /** @@ -4463,7 +4467,10 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * @hide */ protected void initializeScrollbarsInternal(TypedArray a) { - final ScrollabilityCache scrollabilityCache = getScrollCache(); + initScrollCache(); + + final ScrollabilityCache scrollabilityCache = mScrollCache; + if (scrollabilityCache.scrollBar == null) { scrollabilityCache.scrollBar = new ScrollBarDrawable(); scrollabilityCache.scrollBar.setCallback(this); @@ -4471,16 +4478,23 @@ public class View implements Drawable.Callback, KeyEvent.Callback, } final boolean fadeScrollbars = a.getBoolean(R.styleable.View_fadeScrollbars, true); - scrollabilityCache.setFadingEnabled(fadeScrollbars); + + if (!fadeScrollbars) { + scrollabilityCache.state = ScrollabilityCache.ON; + } + scrollabilityCache.fadeScrollBars = fadeScrollbars; + scrollabilityCache.scrollBarFadeDuration = a.getInt( - R.styleable.View_scrollbarFadeDuration, - ViewConfiguration.getScrollBarFadeDuration()); + R.styleable.View_scrollbarFadeDuration, ViewConfiguration + .getScrollBarFadeDuration()); scrollabilityCache.scrollBarDefaultDelayBeforeFade = a.getInt( R.styleable.View_scrollbarDefaultDelayBeforeFade, ViewConfiguration.getScrollDefaultDelay()); + + scrollabilityCache.scrollBarSize = a.getDimensionPixelSize( - R.styleable.View_scrollbarSize, + com.android.internal.R.styleable.View_scrollbarSize, ViewConfiguration.get(mContext).getScaledScrollBarSize()); Drawable track = a.getDrawable(R.styleable.View_scrollbarTrackHorizontal); @@ -4525,12 +4539,18 @@ public class View implements Drawable.Callback, KeyEvent.Callback, } /** - * Returns the scrollability cache, initializing a new cache if necessary. + * <p> + * Initalizes the scrollability cache if necessary. + * </p> */ - private ScrollabilityCache getScrollCache() { + private void initScrollCache() { if (mScrollCache == null) { - mScrollCache = new ScrollabilityCache(this); + mScrollCache = new ScrollabilityCache(ViewConfiguration.get(mContext), this); } + } + + private ScrollabilityCache getScrollCache() { + initScrollCache(); return mScrollCache; } @@ -11559,30 +11579,31 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * @see #setVerticalScrollBarEnabled(boolean) */ protected boolean awakenScrollBars() { - return mScrollCache != null - && awakenScrollBars(mScrollCache.scrollBarDefaultDelayBeforeFade, true); + return mScrollCache != null && + awakenScrollBars(mScrollCache.scrollBarDefaultDelayBeforeFade, true); } /** * Trigger the scrollbars to draw. - * <p> * This method differs from awakenScrollBars() only in its default duration. * initialAwakenScrollBars() will show the scroll bars for longer than * usual to give the user more of a chance to notice them. * * @return true if the animation is played, false otherwise. - * @see #awakenScrollBars() */ private boolean initialAwakenScrollBars() { - return mScrollCache != null - && awakenScrollBars(mScrollCache.scrollBarDelayBeforeInitialFade, true); + return mScrollCache != null && + awakenScrollBars(mScrollCache.scrollBarDefaultDelayBeforeFade * 4, true); } /** + * <p> * Trigger the scrollbars to draw. When invoked this method starts an * animation to fade the scrollbars out after a fixed delay. If a subclass * provides animated scrolling, the start delay should equal the duration of * the scrolling animation. + * </p> + * * <p> * The animation starts only if at least one of the scrollbars is enabled, * as specified by {@link #isHorizontalScrollBarEnabled()} and @@ -11590,14 +11611,18 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * this method returns true, and false otherwise. If the animation is * started, this method calls {@link #invalidate()}; in that case the caller * should not call {@link #invalidate()}. + * </p> + * * <p> * This method should be invoked every time a subclass directly updates the * scroll parameters. + * </p> * - * @param fadeOutDelay the delay in milliseconds before the fade out - * animation should start, or 0 to start the animation - * immediately + * @param startDelay the delay, in milliseconds, after which the animation + * should start; when the delay is 0, the animation starts + * immediately * @return true if the animation is played, false otherwise + * * @see #scrollBy(int, int) * @see #scrollTo(int, int) * @see #isHorizontalScrollBarEnabled() @@ -11605,15 +11630,18 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * @see #setHorizontalScrollBarEnabled(boolean) * @see #setVerticalScrollBarEnabled(boolean) */ - protected boolean awakenScrollBars(int fadeOutDelay) { - return awakenScrollBars(fadeOutDelay, true); + protected boolean awakenScrollBars(int startDelay) { + return awakenScrollBars(startDelay, true); } /** + * <p> * Trigger the scrollbars to draw. When invoked this method starts an * animation to fade the scrollbars out after a fixed delay. If a subclass * provides animated scrolling, the start delay should equal the duration of * the scrolling animation. + * </p> + * * <p> * The animation starts only if at least one of the scrollbars is enabled, * as specified by {@link #isHorizontalScrollBarEnabled()} and @@ -11622,18 +11650,21 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * started, this method calls {@link #invalidate()} if the invalidate parameter * is set to true; in that case the caller * should not call {@link #invalidate()}. + * </p> + * * <p> * This method should be invoked every time a subclass directly updates the * scroll parameters. - * <p> - * <strong>Note:</strong> If the view has not explicitly requested - * scrollbars prior calling this method, this is a no-op. + * </p> + * + * @param startDelay the delay, in milliseconds, after which the animation + * should start; when the delay is 0, the animation starts + * immediately + * + * @param invalidate Whether this method should call invalidate * - * @param fadeOutDelay the delay in milliseconds before the fade out - * animation should start, or 0 to start the animation - * immediately - * @param invalidate whether this method should call invalidate * @return true if the animation is played, false otherwise + * * @see #scrollBy(int, int) * @see #scrollTo(int, int) * @see #isHorizontalScrollBarEnabled() @@ -11641,15 +11672,50 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * @see #setHorizontalScrollBarEnabled(boolean) * @see #setVerticalScrollBarEnabled(boolean) */ - protected boolean awakenScrollBars(int fadeOutDelay, boolean invalidate) { - if (mScrollCache == null - || (!isHorizontalScrollBarEnabled() && !isVerticalScrollBarEnabled())) { - // We're not supposed to show scroll bars right now. + protected boolean awakenScrollBars(int startDelay, boolean invalidate) { + final ScrollabilityCache scrollCache = mScrollCache; + + if (scrollCache == null || !scrollCache.fadeScrollBars) { return false; } - mScrollCache.awakenScrollBars(fadeOutDelay); - return true; + if (scrollCache.scrollBar == null) { + scrollCache.scrollBar = new ScrollBarDrawable(); + scrollCache.scrollBar.setCallback(this); + scrollCache.scrollBar.setState(getDrawableState()); + } + + if (isHorizontalScrollBarEnabled() || isVerticalScrollBarEnabled()) { + + if (invalidate) { + // Invalidate to show the scrollbars + postInvalidateOnAnimation(); + } + + if (scrollCache.state == ScrollabilityCache.OFF) { + // FIXME: this is copied from WindowManagerService. + // We should get this value from the system when it + // is possible to do so. + final int KEY_REPEAT_FIRST_DELAY = 750; + startDelay = Math.max(KEY_REPEAT_FIRST_DELAY, startDelay); + } + + // Tell mScrollCache when we should start fading. This may + // extend the fade start time if one was already scheduled + long fadeStartTime = AnimationUtils.currentAnimationTimeMillis() + startDelay; + scrollCache.fadeStartTime = fadeStartTime; + scrollCache.state = ScrollabilityCache.ON; + + // Schedule our fader to run, unscheduling any old ones first + if (mAttachInfo != null) { + mAttachInfo.mHandler.removeCallbacks(scrollCache); + mAttachInfo.mHandler.postAtTime(scrollCache, fadeStartTime); + } + + return true; + } + + return false; } /** @@ -12330,7 +12396,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, public void setHorizontalFadingEdgeEnabled(boolean horizontalFadingEdgeEnabled) { if (isHorizontalFadingEdgeEnabled() != horizontalFadingEdgeEnabled) { if (horizontalFadingEdgeEnabled) { - getScrollCache(); + initScrollCache(); } mViewFlags ^= FADING_EDGE_HORIZONTAL; @@ -12367,7 +12433,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, public void setVerticalFadingEdgeEnabled(boolean verticalFadingEdgeEnabled) { if (isVerticalFadingEdgeEnabled() != verticalFadingEdgeEnabled) { if (verticalFadingEdgeEnabled) { - getScrollCache(); + initScrollCache(); } mViewFlags ^= FADING_EDGE_VERTICAL; @@ -12507,7 +12573,14 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * @attr ref android.R.styleable#View_fadeScrollbars */ public void setScrollbarFadingEnabled(boolean fadeScrollbars) { - getScrollCache().setFadingEnabled(fadeScrollbars); + initScrollCache(); + final ScrollabilityCache scrollabilityCache = mScrollCache; + scrollabilityCache.fadeScrollBars = fadeScrollbars; + if (fadeScrollbars) { + scrollabilityCache.state = ScrollabilityCache.OFF; + } else { + scrollabilityCache.state = ScrollabilityCache.ON; + } } /** @@ -12519,7 +12592,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * @attr ref android.R.styleable#View_fadeScrollbars */ public boolean isScrollbarFadingEnabled() { - return mScrollCache != null && mScrollCache.isFadingEnabled(); + return mScrollCache != null && mScrollCache.fadeScrollBars; } /** @@ -12801,85 +12874,129 @@ public class View implements Drawable.Callback, KeyEvent.Callback, } /** - * Request the drawing of the horizontal and the vertical scrollbar. The - * scrollbars are painted only if they have been awakened first. + * <p>Request the drawing of the horizontal and the vertical scrollbar. The + * scrollbars are painted only if they have been awakened first.</p> * * @param canvas the canvas on which to draw the scrollbars + * * @see #awakenScrollBars(int) */ protected final void onDrawScrollBars(Canvas canvas) { + // scrollbars are drawn only when the animation is running final ScrollabilityCache cache = mScrollCache; - if (cache == null) { - // This view does not currently support scrolling. - return; - } - - final int viewFlags = mViewFlags; - final boolean drawHorizontalScrollBar = - (viewFlags & SCROLLBARS_HORIZONTAL) == SCROLLBARS_HORIZONTAL; - final boolean drawVerticalScrollBar = - (viewFlags & SCROLLBARS_VERTICAL) == SCROLLBARS_VERTICAL - && !isVerticalScrollBarHidden(); - if (!drawVerticalScrollBar && !drawHorizontalScrollBar) { - // This view does not currently draw scrollbars. - return; - } + if (cache != null) { - final ScrollBarDrawable scrollBar = cache.scrollBar; - final int width = mRight - mLeft; - final int height = mBottom - mTop; - final int scrollX = mScrollX; - final int scrollY = mScrollY; - final int inside = (viewFlags & SCROLLBARS_OUTSIDE_MASK) == 0 ? ~0 : 0; + int state = cache.state; - if (drawHorizontalScrollBar) { - int size = scrollBar.getSize(false); - if (size <= 0) { - size = cache.scrollBarSize; + if (state == ScrollabilityCache.OFF) { + return; } - scrollBar.setParameters(computeHorizontalScrollRange(), computeHorizontalScrollOffset(), - computeHorizontalScrollExtent(), false); - final int verticalScrollBarGap = drawVerticalScrollBar ? - getVerticalScrollbarWidth() : 0; + boolean invalidate = false; - final int left = scrollX + (mPaddingLeft & inside); - final int right = scrollX + width - (mUserPaddingRight & inside) - verticalScrollBarGap; - final int top = scrollY + height - size - (mUserPaddingBottom & inside); - final int bottom = top + size; - - onDrawHorizontalScrollBar(canvas, scrollBar, left, top, right, bottom); - } + if (state == ScrollabilityCache.FADING) { + // We're fading -- get our fade interpolation + if (cache.interpolatorValues == null) { + cache.interpolatorValues = new float[1]; + } - if (drawVerticalScrollBar) { - int size = scrollBar.getSize(true); - if (size <= 0) { - size = cache.scrollBarSize; - } + float[] values = cache.interpolatorValues; - scrollBar.setParameters(computeVerticalScrollRange(), computeVerticalScrollOffset(), - computeVerticalScrollExtent(), true); + // Stops the animation if we're done + if (cache.scrollBarInterpolator.timeToValues(values) == + Interpolator.Result.FREEZE_END) { + cache.state = ScrollabilityCache.OFF; + } else { + cache.scrollBar.mutate().setAlpha(Math.round(values[0])); + } - final int verticalScrollbarPosition; - if (mVerticalScrollbarPosition == SCROLLBAR_POSITION_DEFAULT) { - verticalScrollbarPosition = isLayoutRtl() ? - SCROLLBAR_POSITION_LEFT : SCROLLBAR_POSITION_RIGHT; + // This will make the scroll bars inval themselves after + // drawing. We only want this when we're fading so that + // we prevent excessive redraws + invalidate = true; } else { - verticalScrollbarPosition = mVerticalScrollbarPosition; + // We're just on -- but we may have been fading before so + // reset alpha + cache.scrollBar.mutate().setAlpha(255); } - final int left; - if (verticalScrollbarPosition == SCROLLBAR_POSITION_LEFT) { - left = scrollX + (mUserPaddingLeft & inside); - } else { - left = scrollX + width - size - (mUserPaddingRight & inside); - } - final int top = scrollY + (mPaddingTop & inside); - final int right = left + size; - final int bottom = scrollY + height - (mUserPaddingBottom & inside); + final int viewFlags = mViewFlags; + + final boolean drawHorizontalScrollBar = + (viewFlags & SCROLLBARS_HORIZONTAL) == SCROLLBARS_HORIZONTAL; + final boolean drawVerticalScrollBar = + (viewFlags & SCROLLBARS_VERTICAL) == SCROLLBARS_VERTICAL + && !isVerticalScrollBarHidden(); + + if (drawVerticalScrollBar || drawHorizontalScrollBar) { + final int width = mRight - mLeft; + final int height = mBottom - mTop; + + final ScrollBarDrawable scrollBar = cache.scrollBar; + + final int scrollX = mScrollX; + final int scrollY = mScrollY; + final int inside = (viewFlags & SCROLLBARS_OUTSIDE_MASK) == 0 ? ~0 : 0; + + int left; + int top; + int right; + int bottom; - onDrawVerticalScrollBar(canvas, scrollBar, left, top, right, bottom); + if (drawHorizontalScrollBar) { + int size = scrollBar.getSize(false); + if (size <= 0) { + size = cache.scrollBarSize; + } + + scrollBar.setParameters(computeHorizontalScrollRange(), + computeHorizontalScrollOffset(), + computeHorizontalScrollExtent(), false); + final int verticalScrollBarGap = drawVerticalScrollBar ? + getVerticalScrollbarWidth() : 0; + top = scrollY + height - size - (mUserPaddingBottom & inside); + left = scrollX + (mPaddingLeft & inside); + right = scrollX + width - (mUserPaddingRight & inside) - verticalScrollBarGap; + bottom = top + size; + onDrawHorizontalScrollBar(canvas, scrollBar, left, top, right, bottom); + if (invalidate) { + invalidate(left, top, right, bottom); + } + } + + if (drawVerticalScrollBar) { + int size = scrollBar.getSize(true); + if (size <= 0) { + size = cache.scrollBarSize; + } + + scrollBar.setParameters(computeVerticalScrollRange(), + computeVerticalScrollOffset(), + computeVerticalScrollExtent(), true); + int verticalScrollbarPosition = mVerticalScrollbarPosition; + if (verticalScrollbarPosition == SCROLLBAR_POSITION_DEFAULT) { + verticalScrollbarPosition = isLayoutRtl() ? + SCROLLBAR_POSITION_LEFT : SCROLLBAR_POSITION_RIGHT; + } + switch (verticalScrollbarPosition) { + default: + case SCROLLBAR_POSITION_RIGHT: + left = scrollX + width - size - (mUserPaddingRight & inside); + break; + case SCROLLBAR_POSITION_LEFT: + left = scrollX + (mUserPaddingLeft & inside); + break; + } + top = scrollY + (mPaddingTop & inside); + right = left + size; + bottom = scrollY + height - (mUserPaddingBottom & inside); + onDrawVerticalScrollBar(canvas, scrollBar, left, top, right, bottom); + if (invalidate) { + invalidate(left, top, right, bottom); + } + } + } } } @@ -15245,7 +15362,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, canvas.saveLayer(right - length, top, right, bottom, null, flags); } } else { - scrollabilityCache.setFadingEdgeColor(solidColor); + scrollabilityCache.setFadeColor(solidColor); } // Step 3, draw the content @@ -15255,9 +15372,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback, dispatchDraw(canvas); // Step 5, draw the fade effect and restore layers - final Paint p = scrollabilityCache.fadingEdgePaint; + final Paint p = scrollabilityCache.paint; final Matrix matrix = scrollabilityCache.matrix; - final Shader fade = scrollabilityCache.fadingEdgeShader; + final Shader fade = scrollabilityCache.shader; if (drawTop) { matrix.setScale(1, fadeHeight * topFadeStrength); @@ -20517,164 +20634,121 @@ public class View implements Drawable.Callback, KeyEvent.Callback, } /** - * ScrollabilityCache holds various fields used by a View when scrolling + * <p>ScrollabilityCache holds various fields used by a View when scrolling * is supported. This avoids keeping too many unused fields in most - * instances of View. + * instances of View.</p> */ - private static class ScrollabilityCache { - public final Paint fadingEdgePaint = new Paint(); - public final Matrix matrix = new Matrix(); - - /** The view that owns this cache. */ - private final View mHost; + private static class ScrollabilityCache implements Runnable { /** - * Minimum delay in milliseconds before the fade-out animation begins. - * Only used if the scrollbar was previously invisible. + * Scrollbars are not visible */ - private static final int MIN_FADE_DELAY_FROM_OFF = 750; + public static final int OFF = 0; /** - * Default delay in milliseconds before the fade-out animation begins. + * Scrollbars are visible */ - public int scrollBarDefaultDelayBeforeFade; + public static final int ON = 1; /** - * Delay in milliseconds before the fade-out animation begins. Only - * used if the scrollbar is being shown to the user for the first time. + * Scrollbars are fading away */ - public int scrollBarDelayBeforeInitialFade; + public static final int FADING = 2; - /** Duration in milliseconds of the fade-out animation. */ - public int scrollBarFadeDuration; + public boolean fadeScrollBars; - public ScrollBarDrawable scrollBar; - public Shader fadingEdgeShader; public int fadingEdgeLength; + public int scrollBarDefaultDelayBeforeFade; + public int scrollBarFadeDuration; + public int scrollBarSize; + public ScrollBarDrawable scrollBar; + public float[] interpolatorValues; + public View host; + + public final Paint paint; + public final Matrix matrix; + public Shader shader; + + public final Interpolator scrollBarInterpolator = new Interpolator(1, 2); + + private static final float[] OPAQUE = { 255 }; + private static final float[] TRANSPARENT = { 0.0f }; /** - * Whether scrollbar fading is enabled. If false, scrollbars are always - * visible. + * When fading should start. This time moves into the future every time + * a new scroll happens. Measured based on SystemClock.uptimeMillis() */ - private boolean mIsFadingEnabled; + public long fadeStartTime; - private Animator mFadeAnim; - private int mFadingEdgeLastColor; - public ScrollabilityCache(View host) { - mHost = host; + /** + * The current state of the scrollbars: ON, OFF, or FADING + */ + public int state = OFF; - scrollBarFadeDuration = ViewConfiguration.getScrollBarFadeDuration(); - scrollBarDefaultDelayBeforeFade = ViewConfiguration.getScrollDefaultDelay(); - scrollBarDelayBeforeInitialFade = ViewConfiguration.getScrollDefaultInitialDelay(); + private int mLastColor; - final ViewConfiguration configuration = ViewConfiguration.get(host.getContext()); - scrollBarSize = configuration.getScaledScrollBarSize(); + public ScrollabilityCache(ViewConfiguration configuration, View host) { fadingEdgeLength = configuration.getScaledFadingEdgeLength(); + scrollBarSize = configuration.getScaledScrollBarSize(); + scrollBarDefaultDelayBeforeFade = ViewConfiguration.getScrollDefaultDelay(); + scrollBarFadeDuration = ViewConfiguration.getScrollBarFadeDuration(); + + paint = new Paint(); + matrix = new Matrix(); + // use use a height of 1, and then wack the matrix each time we + // actually use it. + shader = new LinearGradient(0, 0, 0, 1, 0xFF000000, 0, Shader.TileMode.CLAMP); + paint.setShader(shader); + paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT)); - // Force the fading edge color to change. - mFadingEdgeLastColor = -1; - setFadingEdgeColor(0); + this.host = host; } - public void setFadingEdgeColor(int color) { - if (mFadingEdgeLastColor != color) { - mFadingEdgeLastColor = color; + public void setFadeColor(int color) { + if (color != mLastColor) { + mLastColor = color; - final int color0; - final int color1; - final PorterDuffXfermode xfermode; if (color != 0) { - color0 = color | 0xFF000000; - color1 = color & 0x00FFFFFF; - xfermode = null; + shader = new LinearGradient(0, 0, 0, 1, color | 0xFF000000, + color & 0x00FFFFFF, Shader.TileMode.CLAMP); + paint.setShader(shader); + // Restore the default transfer mode (src_over) + paint.setXfermode(null); } else { - color0 = 0xFF000000; - color1 = 0; - xfermode = new PorterDuffXfermode(PorterDuff.Mode.DST_OUT); + shader = new LinearGradient(0, 0, 0, 1, 0xFF000000, 0, Shader.TileMode.CLAMP); + paint.setShader(shader); + paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT)); } - - // Use a height of 1 and then whack the matrix each time we - // actually use it. - fadingEdgeShader = new LinearGradient( - 0, 0, 0, 1, color0, color1, Shader.TileMode.CLAMP); - fadingEdgePaint.setShader(fadingEdgeShader); - fadingEdgePaint.setXfermode(xfermode); - } - } - - public void setFadingEnabled(boolean enabled) { - if (mIsFadingEnabled != enabled) { - mIsFadingEnabled = enabled; - - setFadingAlpha(enabled ? 0 : 255); } } - public boolean isFadingEnabled() { - return mIsFadingEnabled; - } + public void run() { + long now = AnimationUtils.currentAnimationTimeMillis(); + if (now >= fadeStartTime) { - /** - * Cancels any ongoing or pending fade animations and immediately sets - * the scroll bar alpha value. - * - * @param alpha the scrollbar alpha value - */ - public void setFadingAlpha(int alpha) { - if (mFadeAnim != null) { - mFadeAnim.cancel(); - mFadeAnim = null; - } - mHost.removeCallbacks(mFadeOutRunnable); + // the animation fades the scrollbars out by changing + // the opacity (alpha) from fully opaque to fully + // transparent + int nextFrame = (int) now; + int framesCount = 0; - scrollBar.setAlpha(alpha); - } + Interpolator interpolator = scrollBarInterpolator; - /** - * If fading is enabled, cancels any ongoing or pending fade animations - * and immediately sets the scroll bar alpha value to the maximum, then - * posts a delayed fade-out animation. - * - * @param fadeOutDelay the delay before the fade-out animation starts - * @return {@code true} if the scroll bars changed, false otherwise - */ - public boolean awakenScrollBars(int fadeOutDelay) { - if (!mIsFadingEnabled) { - return false; - } + // Start opaque + interpolator.setKeyFrame(framesCount++, nextFrame, OPAQUE); - if (scrollBar == null) { - scrollBar = new ScrollBarDrawable(); - scrollBar.setCallback(mHost); - scrollBar.setState(mHost.getDrawableState()); - } + // End transparent + nextFrame += scrollBarFadeDuration; + interpolator.setKeyFrame(framesCount, nextFrame, TRANSPARENT); - // Removes pending callbacks. - setFadingAlpha(255); + state = FADING; - final int startingAlpha = scrollBar.getAlpha(); - if (startingAlpha == 0) { - fadeOutDelay = Math.max(ScrollabilityCache.MIN_FADE_DELAY_FROM_OFF, fadeOutDelay); + // Kick off the fade animation + host.invalidate(true); } - - mHost.postDelayed(mFadeOutRunnable, fadeOutDelay); - - return true; } - - private final Runnable mFadeOutRunnable = new Runnable() { - @Override - public void run() { - final ObjectAnimator anim = ObjectAnimator.ofInt( - scrollBar, ScrollBarDrawable.ALPHA, 0); - anim.setDuration(scrollBarFadeDuration); - anim.start(); - - mFadeAnim = anim; - } - }; } /** diff --git a/core/java/android/view/ViewConfiguration.java b/core/java/android/view/ViewConfiguration.java index d733513..4e91ad4 100644 --- a/core/java/android/view/ViewConfiguration.java +++ b/core/java/android/view/ViewConfiguration.java @@ -47,12 +47,6 @@ public class ViewConfiguration { private static final int SCROLL_BAR_DEFAULT_DELAY = 300; /** - * Default delay before the scrollbars fade in milliseconds for the first - * time they are shown to the user. - */ - private static final int SCROLL_BAR_DEFAULT_INITIAL_DELAY = 1500; - - /** * Defines the length of the fading edges in dips */ private static final int FADING_EDGE_LENGTH = 12; @@ -401,23 +395,13 @@ public class ViewConfiguration { } /** - * @return Default delay in milliseconds before the scrollbars fade out - * after they have been awoken. + * @return Default delay before the scrollbars fade in milliseconds */ public static int getScrollDefaultDelay() { return SCROLL_BAR_DEFAULT_DELAY; } /** - * @return Default delay in milliseconds before the scrollbars fade out - * after they are initially shown to the user. - * @hide Pending cleanup of ViewConfiguration values. - */ - public static int getScrollDefaultInitialDelay() { - return SCROLL_BAR_DEFAULT_INITIAL_DELAY; - } - - /** * @return the length of the fading edges in dips * * @deprecated Use {@link #getScaledFadingEdgeLength()} instead. diff --git a/graphics/java/android/graphics/drawable/Drawable.java b/graphics/java/android/graphics/drawable/Drawable.java index 98767a7..247f94a 100644 --- a/graphics/java/android/graphics/drawable/Drawable.java +++ b/graphics/java/android/graphics/drawable/Drawable.java @@ -39,7 +39,6 @@ import android.graphics.Xfermode; import android.os.Trace; import android.util.AttributeSet; import android.util.DisplayMetrics; -import android.util.IntProperty; import android.util.StateSet; import android.util.TypedValue; import android.util.Xml; @@ -1372,20 +1371,5 @@ public abstract class Drawable { default: return defaultMode; } } - - /** @hide */ - public static final IntProperty<Drawable> ALPHA = new IntProperty<Drawable>("alpha") { - @Override - public void setValue(Drawable object, int value) { - object.mutate(); - object.setAlpha(value); - object.invalidateSelf(); - } - - @Override - public Integer get(Drawable object) { - return object.getAlpha(); - } - }; } |