/** * Call when the effect absorbs an impact at the given velocity. Used when a fling reaches the * scroll boundary. * * <p>When using a {@link android.widget.Scroller} or {@link android.widget.OverScroller}, the * method <code>getCurrVelocity</code> will provide a reasonable approximation to use here. * * @param velocity Velocity at impact in pixels per second. * @return true if the host view should invalidate, false if it should not. */ public boolean onAbsorb(int velocity) { return IMPL.onAbsorb(mEdgeEffect, velocity); }
/** * Draw into the provided canvas. Assumes that the canvas has been rotated accordingly and the * size has been set. The effect will be drawn the full width of X=0 to X=width, beginning from * Y=0 and extending to some factor < 1.f of height. * * @param canvas Canvas to draw into * @return true if drawing should continue beyond this frame to continue the animation */ public boolean draw(Canvas canvas) { return IMPL.draw(mEdgeEffect, canvas); }
/** * A view should call this when content is pulled away from an edge by the user. This will update * the state of the current visual effect and its associated animation. The host view should * always {@link android.view.View#invalidate()} if this method returns true and draw the results * accordingly. * * @param deltaDistance Change in distance since the last call. Values may be 0 (no change) to 1.f * (full length of the view) or negative values to express change back toward the edge reached * to initiate the effect. * @return true if the host view should call invalidate, false if it should not. */ public boolean onPull(float deltaDistance) { return IMPL.onPull(mEdgeEffect, deltaDistance); }
/** * Call when the object is released after being pulled. This will begin the "decay" phase of the * effect. After calling this method the host view should {@link android.view.View#invalidate()} * if this method returns true and thereby draw the results accordingly. * * @return true if the host view should invalidate, false if it should not. */ public boolean onRelease() { return IMPL.onRelease(mEdgeEffect); }
/** * Reports if this EdgeEffectCompat's animation is finished. If this method returns false after a * call to {@link #draw(Canvas)} the host widget should schedule another drawing pass to continue * the animation. * * @return true if animation is finished, false if drawing should continue on the next frame. */ public boolean isFinished() { return IMPL.isFinished(mEdgeEffect); }
/** * Immediately finish the current animation. After this call {@link #isFinished()} will return * true. */ public void finish() { IMPL.finish(mEdgeEffect); }
/** * Construct a new EdgeEffect themed using the given context. * * <p>Note: On platform versions that do not support EdgeEffect, all operations on the newly * constructed object will be mocked/no-ops. * * @param context Context to use for theming the effect */ public EdgeEffectCompat(Context context) { mEdgeEffect = IMPL.newEdgeEffect(context); }
/** * Set the size of this edge effect in pixels. * * @param width Effect width in pixels * @param height Effect height in pixels */ public void setSize(int width, int height) { IMPL.setSize(mEdgeEffect, width, height); }
public void setSize(int paramInt1, int paramInt2) { IMPL.setSize(this.mEdgeEffect, paramInt1, paramInt2); }
public boolean onPull(float paramFloat) { return IMPL.onPull(this.mEdgeEffect, paramFloat); }
public boolean onAbsorb(int paramInt) { return IMPL.onAbsorb(this.mEdgeEffect, paramInt); }
public boolean draw(Canvas paramCanvas) { return IMPL.draw(this.mEdgeEffect, paramCanvas); }
public EdgeEffectCompat(Context paramContext) { this.mEdgeEffect = IMPL.newEdgeEffect(paramContext); }