Fix 5254974: Add EdgeEffect for PhotoView.
Change-Id: Ib9ea8fff14a932e8ec25c3f272fe0539776bb062
diff --git a/res/drawable-hdpi/overscroll_edge.png b/res/drawable-hdpi/overscroll_edge.png
new file mode 100644
index 0000000..08fc022
--- /dev/null
+++ b/res/drawable-hdpi/overscroll_edge.png
Binary files differ
diff --git a/res/drawable-hdpi/overscroll_glow.png b/res/drawable-hdpi/overscroll_glow.png
new file mode 100644
index 0000000..8f0c2cb
--- /dev/null
+++ b/res/drawable-hdpi/overscroll_glow.png
Binary files differ
diff --git a/res/drawable-mdpi/overscroll_edge.png b/res/drawable-mdpi/overscroll_edge.png
new file mode 100644
index 0000000..4c87a8b
--- /dev/null
+++ b/res/drawable-mdpi/overscroll_edge.png
Binary files differ
diff --git a/res/drawable-mdpi/overscroll_glow.png b/res/drawable-mdpi/overscroll_glow.png
new file mode 100644
index 0000000..8389ef4
--- /dev/null
+++ b/res/drawable-mdpi/overscroll_glow.png
Binary files differ
diff --git a/res/drawable-xhdpi/overscroll_edge.png b/res/drawable-xhdpi/overscroll_edge.png
new file mode 100644
index 0000000..4fe6c27
--- /dev/null
+++ b/res/drawable-xhdpi/overscroll_edge.png
Binary files differ
diff --git a/res/drawable-xhdpi/overscroll_glow.png b/res/drawable-xhdpi/overscroll_glow.png
new file mode 100644
index 0000000..75c3eb4
--- /dev/null
+++ b/res/drawable-xhdpi/overscroll_glow.png
Binary files differ
diff --git a/src/com/android/gallery3d/ui/EdgeEffect.java b/src/com/android/gallery3d/ui/EdgeEffect.java
new file mode 100644
index 0000000..b2d83f5
--- /dev/null
+++ b/src/com/android/gallery3d/ui/EdgeEffect.java
@@ -0,0 +1,440 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gallery3d.ui;
+
+import com.android.gallery3d.R;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.view.animation.AnimationUtils;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
+
+// This is copied from android.widget.EdgeEffect with some small modifications:
+// (1) Copy the images (overscroll_{edge|glow}.png) to local resources.
+// (2) Use "GLCanvas" instead of "Canvas" for draw()'s parameter.
+// (3) Use a private Drawable class (which inherits from ResourceTexture)
+// instead of android.graphics.drawable.Drawable to hold the images.
+// The private Drawable class is used to translate original Canvas calls to
+// corresponding GLCanvas calls.
+
+/**
+ * This class performs the graphical effect used at the edges of scrollable widgets
+ * when the user scrolls beyond the content bounds in 2D space.
+ *
+ * <p>EdgeEffect is stateful. Custom widgets using EdgeEffect should create an
+ * instance for each edge that should show the effect, feed it input data using
+ * the methods {@link #onAbsorb(int)}, {@link #onPull(float)}, and {@link #onRelease()},
+ * and draw the effect using {@link #draw(Canvas)} in the widget's overridden
+ * {@link android.view.View#draw(Canvas)} method. If {@link #isFinished()} returns
+ * false after drawing, the edge effect's animation is not yet complete and the widget
+ * should schedule another drawing pass to continue the animation.</p>
+ *
+ * <p>When drawing, widgets should draw their main content and child views first,
+ * usually by invoking <code>super.draw(canvas)</code> from an overridden <code>draw</code>
+ * method. (This will invoke onDraw and dispatch drawing to child views as needed.)
+ * The edge effect may then be drawn on top of the view's content using the
+ * {@link #draw(Canvas)} method.</p>
+ */
+public class EdgeEffect {
+ private static final String TAG = "EdgeEffect";
+
+ // Time it will take the effect to fully recede in ms
+ private static final int RECEDE_TIME = 1000;
+
+ // Time it will take before a pulled glow begins receding in ms
+ private static final int PULL_TIME = 167;
+
+ // Time it will take in ms for a pulled glow to decay to partial strength before release
+ private static final int PULL_DECAY_TIME = 1000;
+
+ private static final float MAX_ALPHA = 0.8f;
+ private static final float HELD_EDGE_ALPHA = 0.7f;
+ private static final float HELD_EDGE_SCALE_Y = 0.5f;
+ private static final float HELD_GLOW_ALPHA = 0.5f;
+ private static final float HELD_GLOW_SCALE_Y = 0.5f;
+
+ private static final float MAX_GLOW_HEIGHT = 4.f;
+
+ private static final float PULL_GLOW_BEGIN = 1.f;
+ private static final float PULL_EDGE_BEGIN = 0.6f;
+
+ // Minimum velocity that will be absorbed
+ private static final int MIN_VELOCITY = 100;
+
+ private static final float EPSILON = 0.001f;
+
+ private final Drawable mEdge;
+ private final Drawable mGlow;
+ private int mWidth;
+ private int mHeight;
+ private final int MIN_WIDTH = 300;
+ private final int mMinWidth;
+
+ private float mEdgeAlpha;
+ private float mEdgeScaleY;
+ private float mGlowAlpha;
+ private float mGlowScaleY;
+
+ private float mEdgeAlphaStart;
+ private float mEdgeAlphaFinish;
+ private float mEdgeScaleYStart;
+ private float mEdgeScaleYFinish;
+ private float mGlowAlphaStart;
+ private float mGlowAlphaFinish;
+ private float mGlowScaleYStart;
+ private float mGlowScaleYFinish;
+
+ private long mStartTime;
+ private float mDuration;
+
+ private final Interpolator mInterpolator;
+
+ private static final int STATE_IDLE = 0;
+ private static final int STATE_PULL = 1;
+ private static final int STATE_ABSORB = 2;
+ private static final int STATE_RECEDE = 3;
+ private static final int STATE_PULL_DECAY = 4;
+
+ // How much dragging should effect the height of the edge image.
+ // Number determined by user testing.
+ private static final int PULL_DISTANCE_EDGE_FACTOR = 7;
+
+ // How much dragging should effect the height of the glow image.
+ // Number determined by user testing.
+ private static final int PULL_DISTANCE_GLOW_FACTOR = 7;
+ private static final float PULL_DISTANCE_ALPHA_GLOW_FACTOR = 1.1f;
+
+ private static final int VELOCITY_EDGE_FACTOR = 8;
+ private static final int VELOCITY_GLOW_FACTOR = 16;
+
+ private int mState = STATE_IDLE;
+
+ private float mPullDistance;
+
+ /**
+ * Construct a new EdgeEffect with a theme appropriate for the provided context.
+ * @param context Context used to provide theming and resource information for the EdgeEffect
+ */
+ public EdgeEffect(Context context) {
+ mEdge = new Drawable(context, R.drawable.overscroll_edge);
+ mGlow = new Drawable(context, R.drawable.overscroll_glow);
+
+ mMinWidth = (int) (context.getResources().getDisplayMetrics().density * MIN_WIDTH + 0.5f);
+ mInterpolator = new DecelerateInterpolator();
+ }
+
+ /**
+ * 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) {
+ mWidth = width;
+ mHeight = height;
+ }
+
+ /**
+ * Reports if this EdgeEffect'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 mState == STATE_IDLE;
+ }
+
+ /**
+ * Immediately finish the current animation.
+ * After this call {@link #isFinished()} will return true.
+ */
+ public void finish() {
+ mState = STATE_IDLE;
+ }
+
+ /**
+ * 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()} after this
+ * 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.
+ */
+ public void onPull(float deltaDistance) {
+ final long now = AnimationUtils.currentAnimationTimeMillis();
+ if (mState == STATE_PULL_DECAY && now - mStartTime < mDuration) {
+ return;
+ }
+ if (mState != STATE_PULL) {
+ mGlowScaleY = PULL_GLOW_BEGIN;
+ }
+ mState = STATE_PULL;
+
+ mStartTime = now;
+ mDuration = PULL_TIME;
+
+ mPullDistance += deltaDistance;
+ float distance = Math.abs(mPullDistance);
+
+ mEdgeAlpha = mEdgeAlphaStart = Math.max(PULL_EDGE_BEGIN, Math.min(distance, MAX_ALPHA));
+ mEdgeScaleY = mEdgeScaleYStart = Math.max(
+ HELD_EDGE_SCALE_Y, Math.min(distance * PULL_DISTANCE_EDGE_FACTOR, 1.f));
+
+ mGlowAlpha = mGlowAlphaStart = Math.min(MAX_ALPHA,
+ mGlowAlpha +
+ (Math.abs(deltaDistance) * PULL_DISTANCE_ALPHA_GLOW_FACTOR));
+
+ float glowChange = Math.abs(deltaDistance);
+ if (deltaDistance > 0 && mPullDistance < 0) {
+ glowChange = -glowChange;
+ }
+ if (mPullDistance == 0) {
+ mGlowScaleY = 0;
+ }
+
+ // Do not allow glow to get larger than MAX_GLOW_HEIGHT.
+ mGlowScaleY = mGlowScaleYStart = Math.min(MAX_GLOW_HEIGHT, Math.max(
+ 0, mGlowScaleY + glowChange * PULL_DISTANCE_GLOW_FACTOR));
+
+ mEdgeAlphaFinish = mEdgeAlpha;
+ mEdgeScaleYFinish = mEdgeScaleY;
+ mGlowAlphaFinish = mGlowAlpha;
+ mGlowScaleYFinish = mGlowScaleY;
+ }
+
+ /**
+ * 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()} and thereby
+ * draw the results accordingly.
+ */
+ public void onRelease() {
+ mPullDistance = 0;
+
+ if (mState != STATE_PULL && mState != STATE_PULL_DECAY) {
+ return;
+ }
+
+ mState = STATE_RECEDE;
+ mEdgeAlphaStart = mEdgeAlpha;
+ mEdgeScaleYStart = mEdgeScaleY;
+ mGlowAlphaStart = mGlowAlpha;
+ mGlowScaleYStart = mGlowScaleY;
+
+ mEdgeAlphaFinish = 0.f;
+ mEdgeScaleYFinish = 0.f;
+ mGlowAlphaFinish = 0.f;
+ mGlowScaleYFinish = 0.f;
+
+ mStartTime = AnimationUtils.currentAnimationTimeMillis();
+ mDuration = RECEDE_TIME;
+ }
+
+ /**
+ * 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.</p>
+ *
+ * @param velocity Velocity at impact in pixels per second.
+ */
+ public void onAbsorb(int velocity) {
+ mState = STATE_ABSORB;
+ velocity = Math.max(MIN_VELOCITY, Math.abs(velocity));
+
+ mStartTime = AnimationUtils.currentAnimationTimeMillis();
+ mDuration = 0.1f + (velocity * 0.03f);
+
+ // The edge should always be at least partially visible, regardless
+ // of velocity.
+ mEdgeAlphaStart = 0.f;
+ mEdgeScaleY = mEdgeScaleYStart = 0.f;
+ // The glow depends more on the velocity, and therefore starts out
+ // nearly invisible.
+ mGlowAlphaStart = 0.5f;
+ mGlowScaleYStart = 0.f;
+
+ // Factor the velocity by 8. Testing on device shows this works best to
+ // reflect the strength of the user's scrolling.
+ mEdgeAlphaFinish = Math.max(0, Math.min(velocity * VELOCITY_EDGE_FACTOR, 1));
+ // Edge should never get larger than the size of its asset.
+ mEdgeScaleYFinish = Math.max(
+ HELD_EDGE_SCALE_Y, Math.min(velocity * VELOCITY_EDGE_FACTOR, 1.f));
+
+ // Growth for the size of the glow should be quadratic to properly
+ // respond
+ // to a user's scrolling speed. The faster the scrolling speed, the more
+ // intense the effect should be for both the size and the saturation.
+ mGlowScaleYFinish = Math.min(0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f);
+ // Alpha should change for the glow as well as size.
+ mGlowAlphaFinish = Math.max(
+ mGlowAlphaStart, Math.min(velocity * VELOCITY_GLOW_FACTOR * .00001f, MAX_ALPHA));
+ }
+
+
+ /**
+ * 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(GLCanvas canvas) {
+ update();
+
+ final int edgeHeight = mEdge.getIntrinsicHeight();
+ final int edgeWidth = mEdge.getIntrinsicWidth();
+ final int glowHeight = mGlow.getIntrinsicHeight();
+ final int glowWidth = mGlow.getIntrinsicWidth();
+
+ mGlow.setAlpha((int) (Math.max(0, Math.min(mGlowAlpha, 1)) * 255));
+
+ int glowBottom = (int) Math.min(
+ glowHeight * mGlowScaleY * glowHeight/ glowWidth * 0.6f,
+ glowHeight * MAX_GLOW_HEIGHT);
+ if (mWidth < mMinWidth) {
+ // Center the glow and clip it.
+ int glowLeft = (mWidth - mMinWidth)/2;
+ mGlow.setBounds(glowLeft, 0, mWidth - glowLeft, glowBottom);
+ } else {
+ // Stretch the glow to fit.
+ mGlow.setBounds(0, 0, mWidth, glowBottom);
+ }
+
+ mGlow.draw(canvas);
+
+ mEdge.setAlpha((int) (Math.max(0, Math.min(mEdgeAlpha, 1)) * 255));
+
+ int edgeBottom = (int) (edgeHeight * mEdgeScaleY);
+ if (mWidth < mMinWidth) {
+ // Center the edge and clip it.
+ int edgeLeft = (mWidth - mMinWidth)/2;
+ mEdge.setBounds(edgeLeft, 0, mWidth - edgeLeft, edgeBottom);
+ } else {
+ // Stretch the edge to fit.
+ mEdge.setBounds(0, 0, mWidth, edgeBottom);
+ }
+ mEdge.draw(canvas);
+
+ return mState != STATE_IDLE;
+ }
+
+ private void update() {
+ final long time = AnimationUtils.currentAnimationTimeMillis();
+ final float t = Math.min((time - mStartTime) / mDuration, 1.f);
+
+ final float interp = mInterpolator.getInterpolation(t);
+
+ mEdgeAlpha = mEdgeAlphaStart + (mEdgeAlphaFinish - mEdgeAlphaStart) * interp;
+ mEdgeScaleY = mEdgeScaleYStart + (mEdgeScaleYFinish - mEdgeScaleYStart) * interp;
+ mGlowAlpha = mGlowAlphaStart + (mGlowAlphaFinish - mGlowAlphaStart) * interp;
+ mGlowScaleY = mGlowScaleYStart + (mGlowScaleYFinish - mGlowScaleYStart) * interp;
+
+ if (t >= 1.f - EPSILON) {
+ switch (mState) {
+ case STATE_ABSORB:
+ mState = STATE_RECEDE;
+ mStartTime = AnimationUtils.currentAnimationTimeMillis();
+ mDuration = RECEDE_TIME;
+
+ mEdgeAlphaStart = mEdgeAlpha;
+ mEdgeScaleYStart = mEdgeScaleY;
+ mGlowAlphaStart = mGlowAlpha;
+ mGlowScaleYStart = mGlowScaleY;
+
+ // After absorb, the glow and edge should fade to nothing.
+ mEdgeAlphaFinish = 0.f;
+ mEdgeScaleYFinish = 0.f;
+ mGlowAlphaFinish = 0.f;
+ mGlowScaleYFinish = 0.f;
+ break;
+ case STATE_PULL:
+ mState = STATE_PULL_DECAY;
+ mStartTime = AnimationUtils.currentAnimationTimeMillis();
+ mDuration = PULL_DECAY_TIME;
+
+ mEdgeAlphaStart = mEdgeAlpha;
+ mEdgeScaleYStart = mEdgeScaleY;
+ mGlowAlphaStart = mGlowAlpha;
+ mGlowScaleYStart = mGlowScaleY;
+
+ // After pull, the glow and edge should fade to nothing.
+ mEdgeAlphaFinish = 0.f;
+ mEdgeScaleYFinish = 0.f;
+ mGlowAlphaFinish = 0.f;
+ mGlowScaleYFinish = 0.f;
+ break;
+ case STATE_PULL_DECAY:
+ // When receding, we want edge to decrease more slowly
+ // than the glow.
+ float factor = mGlowScaleYFinish != 0 ? 1
+ / (mGlowScaleYFinish * mGlowScaleYFinish)
+ : Float.MAX_VALUE;
+ mEdgeScaleY = mEdgeScaleYStart +
+ (mEdgeScaleYFinish - mEdgeScaleYStart) *
+ interp * factor;
+ mState = STATE_RECEDE;
+ break;
+ case STATE_RECEDE:
+ mState = STATE_IDLE;
+ break;
+ }
+ }
+ }
+
+ private static class Drawable extends ResourceTexture {
+ private Rect mBounds = new Rect();
+ private int mAlpha = 255;
+
+ public Drawable(Context context, int resId) {
+ super(context, resId);
+ }
+
+ public int getIntrinsicWidth() {
+ return getWidth();
+ }
+
+ public int getIntrinsicHeight() {
+ return getHeight();
+ }
+
+ public void setBounds(int left, int top, int right, int bottom) {
+ mBounds.set(left, top, right, bottom);
+ }
+
+ public void setAlpha(int alpha) {
+ mAlpha = alpha;
+ }
+
+ public void draw(GLCanvas canvas) {
+ canvas.save(GLCanvas.SAVE_FLAG_ALPHA);
+ canvas.multiplyAlpha(mAlpha / 255.0f);
+ Rect b = mBounds;
+ draw(canvas, b.left, b.top, b.width(), b.height());
+ canvas.restore();
+ }
+ }
+}
diff --git a/src/com/android/gallery3d/ui/EdgeView.java b/src/com/android/gallery3d/ui/EdgeView.java
new file mode 100644
index 0000000..db6a45c
--- /dev/null
+++ b/src/com/android/gallery3d/ui/EdgeView.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gallery3d.ui;
+
+import android.content.Context;
+import android.opengl.Matrix;
+
+// EdgeView draws EdgeEffect (blue glow) at four sides of the view.
+public class EdgeView extends GLView {
+ private static final String TAG = "EdgeView";
+
+ public static final int TOP = 0;
+ public static final int LEFT = 1;
+ public static final int BOTTOM = 2;
+ public static final int RIGHT = 3;
+
+ // Each edge effect has a transform matrix, and each matrix has 16 elements.
+ // We put all the elements in one array. These constants specify the
+ // starting index of each matrix.
+ private static final int TOP_M = TOP * 16;
+ private static final int LEFT_M = LEFT * 16;
+ private static final int BOTTOM_M = BOTTOM * 16;
+ private static final int RIGHT_M = RIGHT * 16;
+
+ private EdgeEffect[] mEffect = new EdgeEffect[4];
+ private float[] mMatrix = new float[4 * 16];
+
+ public EdgeView(Context context) {
+ for (int i = 0; i < 4; i++) {
+ mEffect[i] = new EdgeEffect(context);
+ }
+ }
+
+ @Override
+ protected void onLayout(
+ boolean changeSize, int left, int top, int right, int bottom) {
+ if (!changeSize) return;
+
+ int w = right - left;
+ int h = bottom - top;
+ for (int i = 0; i < 4; i++) {
+ if ((i & 1) == 0) { // top or bottom
+ mEffect[i].setSize(w, h);
+ } else { // left or right
+ mEffect[i].setSize(h, w);
+ }
+ }
+
+ // Set up transforms for the four edges. Without transforms an
+ // EdgeEffect draws the TOP edge from (0, 0) to (w, Y * h) where Y
+ // is some factor < 1. For other edges we need to move, rotate, and
+ // flip the effects into proper places.
+ Matrix.setIdentityM(mMatrix, TOP_M);
+ Matrix.setIdentityM(mMatrix, LEFT_M);
+ Matrix.setIdentityM(mMatrix, BOTTOM_M);
+ Matrix.setIdentityM(mMatrix, RIGHT_M);
+
+ Matrix.rotateM(mMatrix, LEFT_M, 90, 0, 0, 1);
+ Matrix.scaleM(mMatrix, LEFT_M, 1, -1, 1);
+
+ Matrix.translateM(mMatrix, BOTTOM_M, 0, h, 0);
+ Matrix.scaleM(mMatrix, BOTTOM_M, 1, -1, 1);
+
+ Matrix.translateM(mMatrix, RIGHT_M, w, 0, 0);
+ Matrix.rotateM(mMatrix, RIGHT_M, 90, 0, 0, 1);
+ }
+
+ @Override
+ protected void render(GLCanvas canvas) {
+ super.render(canvas);
+ boolean more = false;
+ for (int i = 0; i < 4; i++) {
+ canvas.save(GLCanvas.SAVE_FLAG_MATRIX);
+ canvas.multiplyMatrix(mMatrix, i * 16);
+ more |= mEffect[i].draw(canvas);
+ canvas.restore();
+ }
+ if (more) {
+ invalidate();
+ }
+ }
+
+ // Called when the content is pulled away from the edge.
+ // offset is in pixels. direction is one of {TOP, LEFT, BOTTOM, RIGHT}.
+ public void onPull(int offset, int direction) {
+ int fullLength = ((direction & 1) == 0) ? getWidth() : getHeight();
+ mEffect[direction].onPull((float)offset / fullLength);
+ if (!mEffect[direction].isFinished()) {
+ invalidate();
+ }
+ }
+
+ // Call when the object is released after being pulled.
+ public void onRelease() {
+ boolean more = false;
+ for (int i = 0; i < 4; i++) {
+ mEffect[i].onRelease();
+ more |= !mEffect[i].isFinished();
+ }
+ if (more) {
+ invalidate();
+ }
+ }
+
+ // Call when the effect absorbs an impact at the given velocity.
+ // Used when a fling reaches the scroll boundary. velocity is in pixels
+ // per second. direction is one of {TOP, LEFT, BOTTOM, RIGHT}.
+ public void onAbsorb(int velocity, int direction) {
+ mEffect[direction].onAbsorb(velocity);
+ if (!mEffect[direction].isFinished()) {
+ invalidate();
+ }
+ }
+}
diff --git a/src/com/android/gallery3d/ui/FilmStripView.java b/src/com/android/gallery3d/ui/FilmStripView.java
index eaf041e..e6ed49b 100644
--- a/src/com/android/gallery3d/ui/FilmStripView.java
+++ b/src/com/android/gallery3d/ui/FilmStripView.java
@@ -79,7 +79,7 @@
spec.slotWidth = thumbSize;
spec.slotHeight = thumbSize;
mAlbumView = new AlbumView(activity, spec, thumbSize);
- mAlbumView.setOverscrollEffect(SlotView.OVERSCROLL_SYSTEM);
+ mAlbumView.setOverscrollEffect(SlotView.OVERSCROLL_NONE);
mAlbumView.setSelectionDrawer(mStripDrawer);
mAlbumView.setListener(new SlotView.SimpleListener() {
@Override
diff --git a/src/com/android/gallery3d/ui/FlingScroller.java b/src/com/android/gallery3d/ui/FlingScroller.java
index 0ba3d5d..9aef074 100644
--- a/src/com/android/gallery3d/ui/FlingScroller.java
+++ b/src/com/android/gallery3d/ui/FlingScroller.java
@@ -42,6 +42,7 @@
private int mFinalX, mFinalY;
private int mCurrX, mCurrY;
+ private double mCurrV;
public int getFinalX() {
return mFinalX;
@@ -64,6 +65,14 @@
return mCurrY;
}
+ public int getCurrVelocityX() {
+ return (int)Math.round(mCurrV * mCosAngle);
+ }
+
+ public int getCurrVelocityY() {
+ return (int)Math.round(mCurrV * mSinAngle);
+ }
+
public void fling(int startX, int startY, int velocityX, int velocityY,
int minX, int maxX, int minY, int maxY) {
mStartX = startX;
@@ -101,6 +110,7 @@
f = 1 - (float) Math.pow(f, DECELERATED_FACTOR);
mCurrX = getX(f);
mCurrY = getY(f);
+ mCurrV = getV(progress);
}
private int getX(float f) {
@@ -112,4 +122,10 @@
return (int) Utils.clamp(
Math.round(mStartY + f * mDistance * mSinAngle), mMinY, mMaxY);
}
+
+ private double getV(float progress) {
+ // velocity formula: v(t) = d * (e - s) * (1 - t / T) ^ (d - 1) / T
+ return DECELERATED_FACTOR * mDistance * 1000 *
+ Math.pow(1 - progress, DECELERATED_FACTOR - 1) / mDuration;
+ }
}
diff --git a/src/com/android/gallery3d/ui/GLCanvasImpl.java b/src/com/android/gallery3d/ui/GLCanvasImpl.java
index ab0d91b..612c7c4 100644
--- a/src/com/android/gallery3d/ui/GLCanvasImpl.java
+++ b/src/com/android/gallery3d/ui/GLCanvasImpl.java
@@ -231,7 +231,7 @@
public void multiplyMatrix(float matrix[], int offset) {
float[] temp = mTempMatrix;
- Matrix.multiplyMM(temp, 0, mMatrixValues , 0, matrix, 0);
+ Matrix.multiplyMM(temp, 0, mMatrixValues, 0, matrix, offset);
System.arraycopy(temp, 0, mMatrixValues, 0, 16);
}
diff --git a/src/com/android/gallery3d/ui/PhotoView.java b/src/com/android/gallery3d/ui/PhotoView.java
index f0e5142..5062c0e 100644
--- a/src/com/android/gallery3d/ui/PhotoView.java
+++ b/src/com/android/gallery3d/ui/PhotoView.java
@@ -85,6 +85,7 @@
private StringTexture mNoThumbnailText;
private int mTransitionMode = TRANS_NONE;
private final TileImageView mTileView;
+ private EdgeView mEdgeView;
private Texture mVideoPlayIcon;
private boolean mShowVideoPlayIcon;
@@ -104,6 +105,8 @@
mTileView = new TileImageView(activity);
addComponent(mTileView);
Context context = activity.getAndroidContext();
+ mEdgeView = new EdgeView(context);
+ addComponent(mEdgeView);
mLoadingSpinner = new ProgressSpinner(context);
mLoadingText = StringTexture.newInstance(
context.getString(R.string.loading),
@@ -145,7 +148,7 @@
mScreenNails[i] = new ScreenNailEntry();
}
- mPositionController = new PositionController(this, context);
+ mPositionController = new PositionController(this, context, mEdgeView);
mVideoPlayIcon = new ResourceTexture(context, R.drawable.ic_control_play);
}
@@ -281,6 +284,7 @@
protected void onLayout(
boolean changeSize, int left, int top, int right, int bottom) {
mTileView.layout(left, top, right, bottom);
+ mEdgeView.layout(left, top, right, bottom);
if (changeSize) {
mPositionController.setViewSize(getWidth(), getHeight());
for (ScreenNailEntry entry : mScreenNails) {
@@ -410,33 +414,41 @@
int width = getWidth();
- // If the edge of the current photo is visible and the sweeping velocity
- // exceed the threshold, switch to next / previous image
+ // If we are at the edge of the current photo and the sweeping velocity
+ // exceeds the threshold, switch to next / previous image.
PositionController controller = mPositionController;
- if (controller.isAtMinimalScale()) {
- if (velocity < -SWIPE_THRESHOLD) {
- stopCurrentSwipingIfNeeded();
- if (next.isEnabled()) {
- mTransitionMode = TRANS_SWITCH_NEXT;
- controller.startHorizontalSlide(next.mOffsetX - width / 2);
- return true;
- }
- return false;
+ boolean isMinimal = controller.isAtMinimalScale();
+
+ if (velocity < -SWIPE_THRESHOLD &&
+ (isMinimal || controller.isAtRightEdge())) {
+ stopCurrentSwipingIfNeeded();
+ if (next.isEnabled()) {
+ mTransitionMode = TRANS_SWITCH_NEXT;
+ controller.startHorizontalSlide(next.mOffsetX - width / 2);
+ return true;
}
- if (velocity > SWIPE_THRESHOLD) {
- stopCurrentSwipingIfNeeded();
- if (prev.isEnabled()) {
- mTransitionMode = TRANS_SWITCH_PREVIOUS;
- controller.startHorizontalSlide(prev.mOffsetX - width / 2);
- return true;
- }
- return false;
+ } else if (velocity > SWIPE_THRESHOLD &&
+ (isMinimal || controller.isAtLeftEdge())) {
+ stopCurrentSwipingIfNeeded();
+ if (prev.isEnabled()) {
+ mTransitionMode = TRANS_SWITCH_PREVIOUS;
+ controller.startHorizontalSlide(prev.mOffsetX - width / 2);
+ return true;
}
}
+ return false;
+ }
+
+ public boolean snapToNeighborImage() {
if (mTransitionMode != TRANS_NONE) return false;
- // Decide whether to swiping to the next/prev image in the zoom-in case
+ ScreenNailEntry next = mScreenNails[ENTRY_NEXT];
+ ScreenNailEntry prev = mScreenNails[ENTRY_PREVIOUS];
+
+ int width = getWidth();
+ PositionController controller = mPositionController;
+
RectF bounds = controller.getImageBounds();
int left = Math.round(bounds.left);
int right = Math.round(bounds.right);
@@ -465,7 +477,12 @@
public boolean onScroll(
MotionEvent e1, MotionEvent e2, float dx, float dy) {
if (mTransitionMode != TRANS_NONE) return true;
- mPositionController.startScroll(dx, dy);
+
+ ScreenNailEntry next = mScreenNails[ENTRY_NEXT];
+ ScreenNailEntry prev = mScreenNails[ENTRY_PREVIOUS];
+
+ mPositionController.startScroll(dx, dy, next.isEnabled(),
+ prev.isEnabled());
return true;
}
@@ -532,7 +549,7 @@
@Override
public void onScaleEnd(ScaleGestureDetector detector) {
mPositionController.endScale();
- swipeImages(0);
+ snapToNeighborImage();
}
}
@@ -565,11 +582,13 @@
}
public void onUp(MotionEvent e) {
+ mEdgeView.onRelease();
+
if (mIgnoreUpEvent) {
mIgnoreUpEvent = false;
return;
}
- if (!swipeImages(0) && mTransitionMode == TRANS_NONE) {
+ if (!snapToNeighborImage() && mTransitionMode == TRANS_NONE) {
mPositionController.up();
}
}
diff --git a/src/com/android/gallery3d/ui/PositionController.java b/src/com/android/gallery3d/ui/PositionController.java
index 5d66f70..abffbc5 100644
--- a/src/com/android/gallery3d/ui/PositionController.java
+++ b/src/com/android/gallery3d/ui/PositionController.java
@@ -63,6 +63,7 @@
private static final float SCALE_LIMIT = 4;
private PhotoView mViewer;
+ private EdgeView mEdgeView;
private int mImageW, mImageH;
private int mViewW, mViewH;
@@ -95,8 +96,10 @@
private RectF mTempRect = new RectF();
private float[] mTempPoints = new float[8];
- public PositionController(PhotoView viewer, Context context) {
+ public PositionController(PhotoView viewer, Context context,
+ EdgeView edgeView) {
mViewer = viewer;
+ mEdgeView = edgeView;
mScroller = new FlingScroller();
}
@@ -325,16 +328,46 @@
scrollBy(distance, 0, ANIM_KIND_SLIDE);
}
- public void startScroll(float dx, float dy) {
- scrollBy(dx, dy, ANIM_KIND_SCROLL);
- }
-
private void scrollBy(float dx, float dy, int type) {
startAnimation(getTargetX() + Math.round(dx / mCurrentScale),
getTargetY() + Math.round(dy / mCurrentScale),
mCurrentScale, type);
}
+ public void startScroll(float dx, float dy, boolean hasNext,
+ boolean hasPrev) {
+ int x = getTargetX() + Math.round(dx / mCurrentScale);
+ int y = getTargetY() + Math.round(dy / mCurrentScale);
+
+ calculateStableBound(mCurrentScale);
+
+ // Vertical direction: If we have space to move in the vertical
+ // direction, we show the edge effect when scrolling reaches the edge.
+ if (mBoundTop != mBoundBottom) {
+ if (y < mBoundTop) {
+ mEdgeView.onPull(mBoundTop - y, EdgeView.TOP);
+ } else if (y > mBoundBottom) {
+ mEdgeView.onPull(y - mBoundBottom, EdgeView.BOTTOM);
+ }
+ }
+
+ y = Utils.clamp(y, mBoundTop, mBoundBottom);
+
+ // Horizontal direction: we show the edge effect when the scrolling
+ // tries to go left of the first image or go right of the last image.
+ if (!hasPrev && x < mBoundLeft) {
+ int pixels = Math.round((mBoundLeft - x) * mCurrentScale);
+ mEdgeView.onPull(pixels, EdgeView.LEFT);
+ x = mBoundLeft;
+ } else if (!hasNext && x > mBoundRight) {
+ int pixels = Math.round((x - mBoundRight) * mCurrentScale);
+ mEdgeView.onPull(pixels, EdgeView.RIGHT);
+ x = mBoundRight;
+ }
+
+ startAnimation(x, y, mCurrentScale, ANIM_KIND_SCROLL);
+ }
+
public boolean fling(float velocityX, float velocityY) {
// We only want to do fling when the picture is zoomed-in.
if (mImageW * mCurrentScale <= mViewW &&
@@ -439,9 +472,27 @@
private void flingInterpolate(float progress) {
mScroller.computeScrollOffset(progress);
+ int oldX = mCurrentX;
+ int oldY = mCurrentY;
mCurrentX = mScroller.getCurrX();
mCurrentY = mScroller.getCurrY();
- mViewer.setPosition(mCurrentX, mCurrentY, mCurrentScale);
+
+ // Check if we hit the edges; show edge effects if we do.
+ if (oldX > mBoundLeft && mCurrentX == mBoundLeft) {
+ int v = Math.round(-mScroller.getCurrVelocityX() * mCurrentScale);
+ mEdgeView.onAbsorb(v, EdgeView.LEFT);
+ } else if (oldX < mBoundRight && mCurrentX == mBoundRight) {
+ int v = Math.round(mScroller.getCurrVelocityX() * mCurrentScale);
+ mEdgeView.onAbsorb(v, EdgeView.RIGHT);
+ }
+
+ if (oldY > mBoundTop && mCurrentY == mBoundTop) {
+ int v = Math.round(-mScroller.getCurrVelocityY() * mCurrentScale);
+ mEdgeView.onAbsorb(v, EdgeView.TOP);
+ } else if (oldY < mBoundBottom && mCurrentY == mBoundBottom) {
+ int v = Math.round(mScroller.getCurrVelocityY() * mCurrentScale);
+ mEdgeView.onAbsorb(v, EdgeView.BOTTOM);
+ }
}
// Interpolates mCurrent{X,Y,Scale} given the progress in [0, 1].
@@ -596,4 +647,14 @@
public int getImageHeight() {
return mImageH;
}
+
+ public boolean isAtLeftEdge() {
+ calculateStableBound(mCurrentScale);
+ return mCurrentX <= mBoundLeft;
+ }
+
+ public boolean isAtRightEdge() {
+ calculateStableBound(mCurrentScale);
+ return mCurrentX >= mBoundRight;
+ }
}
