1521 lines
41 KiB
Java
1521 lines
41 KiB
Java
package com.scvngr.levelup.views.gallery;
|
|
|
|
/*
|
|
* Based on the android GalleryView source. Modified to allow the view to snap to the
|
|
* left rather than the center. The biggest changes in this class are marked with comments
|
|
* with "Note:".
|
|
*
|
|
* Copyright (C) 2007 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.
|
|
*/
|
|
|
|
import android.content.Context;
|
|
import android.graphics.Rect;
|
|
import android.util.AttributeSet;
|
|
import android.view.ContextMenu.ContextMenuInfo;
|
|
import android.view.GestureDetector;
|
|
import android.view.Gravity;
|
|
import android.view.HapticFeedbackConstants;
|
|
import android.view.KeyEvent;
|
|
import android.view.MotionEvent;
|
|
import android.view.SoundEffectConstants;
|
|
import android.view.View;
|
|
import android.view.ViewConfiguration;
|
|
import android.view.ViewGroup;
|
|
import android.view.animation.Transformation;
|
|
import android.widget.Scroller;
|
|
|
|
/**
|
|
* A view that shows items in a center-locked, horizontally scrolling list.
|
|
* <p>
|
|
* The default values for the Gallery assume you will be using
|
|
* {@link android.R.styleable#Theme_GalleryItemBackground} as the background for
|
|
* each View given to the Gallery from the Adapter. If you are not doing this,
|
|
* you may need to adjust some Gallery properties, such as the spacing.
|
|
* <p>
|
|
* Views given to the Gallery should use {@link Gallery.LayoutParams} as their
|
|
* layout parameters type.
|
|
*
|
|
* <p>
|
|
* See the <a href="{@docRoot}
|
|
* resources/tutorials/views/hello-Gallery.html">Gallery tutorial</a>.
|
|
* </p>
|
|
*
|
|
* CHECKSTYLE:OFF Android comments
|
|
*
|
|
* @attr ref android.R.styleable#Gallery_animationDuration
|
|
* @attr ref android.R.styleable#Gallery_spacing
|
|
* @attr ref android.R.styleable#Gallery_gravity CHECKSTYLE:ON
|
|
*/
|
|
public final class Gallery extends AbsSpinner implements GestureDetector.OnGestureListener {
|
|
|
|
/**
|
|
* Duration in milliseconds from the start of a scroll during which we're
|
|
* unsure whether the user is scrolling or flinging.
|
|
*/
|
|
private static final int SCROLL_TO_FLING_UNCERTAINTY_TIMEOUT = 250;
|
|
|
|
/**
|
|
* Horizontal spacing between items.
|
|
*/
|
|
private int mSpacing = 0;
|
|
|
|
/**
|
|
* How long the transition animation should run when a child view changes
|
|
* position, measured in milliseconds.
|
|
*/
|
|
// CHECKSTYLE:OFF not a magic number
|
|
private int mAnimationDuration = 400;
|
|
// CHECKSTYLE:ON
|
|
|
|
/**
|
|
* The alpha of items that are not selected.
|
|
*/
|
|
private float mUnselectedAlpha;
|
|
|
|
/**
|
|
* Left most edge of a child seen so far during layout.
|
|
*/
|
|
private int mLeftMost;
|
|
|
|
/**
|
|
* Right most edge of a child seen so far during layout.
|
|
*/
|
|
private int mRightMost;
|
|
|
|
private int mGravity;
|
|
|
|
/**
|
|
* Helper for detecting touch gestures.
|
|
*/
|
|
private final GestureDetector mGestureDetector;
|
|
|
|
/**
|
|
* The position of the item that received the user's down touch.
|
|
*/
|
|
private int mDownTouchPosition;
|
|
|
|
/**
|
|
* The view of the item that received the user's down touch.
|
|
*/
|
|
private View mDownTouchView;
|
|
|
|
/**
|
|
* Executes the delta scrolls from a fling or scroll movement.
|
|
*/
|
|
private final FlingRunnable mFlingRunnable = new FlingRunnable();
|
|
|
|
/**
|
|
* Sets mSuppressSelectionChanged = false. This is used to set it to false
|
|
* in the future. It will also trigger a selection changed.
|
|
*/
|
|
private final Runnable mDisableSuppressSelectionChangedRunnable = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mSuppressSelectionChanged = false;
|
|
selectionChanged();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* When fling runnable runs, it resets this to false. Any method along the
|
|
* path until the end of its run() can set this to true to abort any
|
|
* remaining fling. For example, if we've reached either the leftmost or
|
|
* rightmost item, we will set this to true.
|
|
*/
|
|
private boolean mShouldStopFling;
|
|
|
|
/**
|
|
* The currently selected item's child.
|
|
*/
|
|
private View mSelectedChild;
|
|
|
|
/**
|
|
* Whether to continuously callback on the item selected listener during a
|
|
* fling.
|
|
*/
|
|
private boolean mShouldCallbackDuringFling = true;
|
|
|
|
/**
|
|
* Whether to callback when an item that is not selected is clicked.
|
|
*/
|
|
private boolean mShouldCallbackOnUnselectedItemClick = true;
|
|
|
|
/**
|
|
* If true, do not callback to item selected listener.
|
|
*/
|
|
private boolean mSuppressSelectionChanged;
|
|
|
|
/**
|
|
* If true, we have received the "invoke" (center or enter buttons) key
|
|
* down. This is checked before we action on the "invoke" key up, and is
|
|
* subsequently cleared.
|
|
*/
|
|
private boolean mReceivedInvokeKeyDown;
|
|
|
|
private AdapterContextMenuInfo mContextMenuInfo;
|
|
|
|
/**
|
|
* If true, this onScroll is the first for this user's drag (remember, a
|
|
* drag sends many onScrolls).
|
|
*/
|
|
private boolean mIsFirstScroll;
|
|
|
|
/**
|
|
* If true, mFirstPosition is the position of the rightmost child, and the
|
|
* children are ordered right to left.
|
|
*/
|
|
private boolean mIsRtl = true;
|
|
|
|
private boolean mScrollToChildAfterItemClickEnabled;
|
|
private boolean mRightSpacingEnabled;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param context the context to inflate into
|
|
*/
|
|
public Gallery(final Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
/**
|
|
* Constructor for XML inflation.
|
|
*
|
|
* @param context the context to inflate with
|
|
* @param attrs the xml attrs
|
|
*/
|
|
public Gallery(final Context context, final AttributeSet attrs) {
|
|
this(context, attrs, android.R.attr.galleryStyle);
|
|
}
|
|
|
|
/**
|
|
* Constructor for XML inflation.
|
|
*
|
|
* @param context the context to inflate with
|
|
* @param attrs the XML attrs
|
|
* @param defStyle the default style resource id
|
|
*/
|
|
public Gallery(final Context context, final AttributeSet attrs, final int defStyle) {
|
|
super(context, attrs, defStyle);
|
|
|
|
mGestureDetector = new GestureDetector(context, this);
|
|
mGestureDetector.setIsLongpressEnabled(true);
|
|
setScrollAfterItemClickEnabled(true);
|
|
setScrollRightSpacingEnabled(true);
|
|
}
|
|
|
|
@Override
|
|
public boolean dispatchKeyEvent(final KeyEvent event) {
|
|
// Gallery steals all key events
|
|
return event.dispatch(this, null, null);
|
|
}
|
|
|
|
@Override
|
|
public void dispatchSetSelected(final boolean selected) {
|
|
/*
|
|
* We don't want to pass the selected state given from its parent to its
|
|
* children since this widget itself has a selected state to give to its
|
|
* children.
|
|
*/
|
|
}
|
|
|
|
@Override
|
|
public ViewGroup.LayoutParams generateLayoutParams(final AttributeSet attrs) {
|
|
return new LayoutParams(getContext(), attrs);
|
|
}
|
|
|
|
@Override
|
|
public boolean onDown(final MotionEvent e) {
|
|
|
|
// Kill any existing fling/scroll
|
|
mFlingRunnable.stop(false);
|
|
|
|
// Get the item's view that was touched
|
|
mDownTouchPosition = pointToPosition((int) e.getX(), (int) e.getY());
|
|
|
|
if (mDownTouchPosition >= 0) {
|
|
mDownTouchView = getChildAt(mDownTouchPosition - mFirstPosition);
|
|
mDownTouchView.setPressed(true);
|
|
}
|
|
|
|
// Reset the multiple-scroll tracking state
|
|
mIsFirstScroll = true;
|
|
|
|
// Must return true to get matching events for this down event.
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onFling(final MotionEvent e1, final MotionEvent e2, final float velocityX, final float velocityY) {
|
|
|
|
if (!mShouldCallbackDuringFling) {
|
|
// We want to suppress selection changes
|
|
|
|
// Remove any future code to set mSuppressSelectionChanged = false
|
|
removeCallbacks(mDisableSuppressSelectionChangedRunnable);
|
|
|
|
// This will get reset once we scroll into slots
|
|
if (!mSuppressSelectionChanged) {
|
|
mSuppressSelectionChanged = true;
|
|
}
|
|
}
|
|
|
|
// Fling the Gallery!
|
|
mFlingRunnable.startUsingVelocity((int) -velocityX);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Handles left, right, and clicking.
|
|
*
|
|
* @see android.view.View#onKeyDown
|
|
*/
|
|
// CHECKSTYLE:OFF unmodified
|
|
@Override
|
|
public boolean onKeyDown(final int keyCode, final KeyEvent event) {
|
|
switch (keyCode) {
|
|
|
|
case KeyEvent.KEYCODE_DPAD_LEFT:
|
|
if (movePrevious()) {
|
|
playSoundEffect(SoundEffectConstants.NAVIGATION_LEFT);
|
|
}
|
|
return true;
|
|
|
|
case KeyEvent.KEYCODE_DPAD_RIGHT:
|
|
if (moveNext()) {
|
|
playSoundEffect(SoundEffectConstants.NAVIGATION_RIGHT);
|
|
}
|
|
return true;
|
|
|
|
case KeyEvent.KEYCODE_DPAD_CENTER:
|
|
case KeyEvent.KEYCODE_ENTER:
|
|
mReceivedInvokeKeyDown = true;
|
|
// fallthrough to default handling
|
|
}
|
|
|
|
return super.onKeyDown(keyCode, event);
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyUp(final int keyCode, final KeyEvent event) {
|
|
switch (keyCode) {
|
|
|
|
case KeyEvent.KEYCODE_DPAD_CENTER:
|
|
case KeyEvent.KEYCODE_ENTER: {
|
|
|
|
if (mReceivedInvokeKeyDown) {
|
|
if (mItemCount > 0) {
|
|
|
|
dispatchPress(mSelectedChild);
|
|
postDelayed(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
dispatchUnpress();
|
|
}
|
|
}, ViewConfiguration.getPressedStateDuration());
|
|
|
|
final int selectedIndex = mSelectedPosition - mFirstPosition;
|
|
performItemClick(getChildAt(selectedIndex), mSelectedPosition,
|
|
mAdapter.getItemId(mSelectedPosition));
|
|
}
|
|
}
|
|
|
|
// Clear the flag
|
|
mReceivedInvokeKeyDown = false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return super.onKeyUp(keyCode, event);
|
|
}
|
|
|
|
@Override
|
|
public void onLongPress(final MotionEvent e) {
|
|
|
|
if (mDownTouchPosition < 0) return;
|
|
|
|
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
|
|
final long id = getItemIdAtPosition(mDownTouchPosition);
|
|
dispatchLongPress(mDownTouchView, mDownTouchPosition, id);
|
|
}
|
|
|
|
@Override
|
|
public boolean onScroll(final MotionEvent e1, final MotionEvent e2, final float distanceX, final float distanceY) {
|
|
|
|
/*
|
|
* Now's a good time to tell our parent to stop intercepting our events!
|
|
* The user has moved more than the slop amount, since GestureDetector
|
|
* ensures this before calling this method. Also, if a parent is more
|
|
* interested in this touch's events than we are, it would have
|
|
* intercepted them by now (for example, we can assume when a Gallery is
|
|
* in the ListView, a vertical scroll would not end up in this method
|
|
* since a ListView would have intercepted it by now).
|
|
*/
|
|
getParent().requestDisallowInterceptTouchEvent(true);
|
|
|
|
/*
|
|
* As the user scrolls, we want to callback selection changes so
|
|
* related- info on the screen is up-to-date with the Gallery's
|
|
* selection
|
|
*/
|
|
if (!mShouldCallbackDuringFling) {
|
|
if (mIsFirstScroll) {
|
|
/*
|
|
* We're not notifying the client of selection changes during
|
|
* the fling, and this scroll could possibly be a fling. Don't
|
|
* do selection changes until we're sure it is not a fling.
|
|
*/
|
|
if (!mSuppressSelectionChanged) {
|
|
mSuppressSelectionChanged = true;
|
|
}
|
|
|
|
postDelayed(mDisableSuppressSelectionChangedRunnable, SCROLL_TO_FLING_UNCERTAINTY_TIMEOUT);
|
|
}
|
|
} else {
|
|
if (mSuppressSelectionChanged) {
|
|
mSuppressSelectionChanged = false;
|
|
}
|
|
}
|
|
|
|
// Track the motion
|
|
trackMotionScroll(-1 * (int) distanceX);
|
|
|
|
mIsFirstScroll = false;
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onShowPress(final MotionEvent e) {
|
|
}
|
|
|
|
@Override
|
|
public boolean onSingleTapUp(final MotionEvent e) {
|
|
|
|
if (mDownTouchPosition >= 0) {
|
|
if (mScrollToChildAfterItemClickEnabled) {
|
|
// An item tap should make it selected, so scroll to this child.
|
|
scrollToChild(mDownTouchPosition - mFirstPosition);
|
|
}
|
|
|
|
// Also pass the click so the client knows, if it wants to.
|
|
if (mShouldCallbackOnUnselectedItemClick || mDownTouchPosition == mSelectedPosition) {
|
|
performItemClick(mDownTouchView, mDownTouchPosition, mAdapter.getItemId(mDownTouchPosition));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onTouchEvent(final MotionEvent event) {
|
|
|
|
if (!isEnabled()) return false;
|
|
|
|
// Give everything to the gesture detector
|
|
final boolean retValue = mGestureDetector.onTouchEvent(event);
|
|
|
|
final int action = event.getAction();
|
|
if (action == MotionEvent.ACTION_UP) {
|
|
// Helper method for lifted finger
|
|
onUp();
|
|
} else if (action == MotionEvent.ACTION_CANCEL) {
|
|
onCancel();
|
|
}
|
|
|
|
return retValue;
|
|
}
|
|
|
|
/**
|
|
* Sets how long the transition animation should run when a child view
|
|
* changes position. Only relevant if animation is turned on.
|
|
*
|
|
* @param animationDurationMillis The duration of the transition, in
|
|
* milliseconds.
|
|
*
|
|
* @attr ref android.R.styleable#Gallery_animationDuration
|
|
*/
|
|
public void setAnimationDuration(final int animationDurationMillis) {
|
|
mAnimationDuration = animationDurationMillis;
|
|
}
|
|
|
|
/**
|
|
* Whether or not to callback on any {@link #getOnItemSelectedListener()}
|
|
* while the items are being flinged. If false, only the final selected item
|
|
* will cause the callback. If true, all items between the first and the
|
|
* final will cause callbacks.
|
|
*
|
|
* @param shouldCallback Whether or not to callback on the listener while
|
|
* the items are being flinged.
|
|
*/
|
|
public void setCallbackDuringFling(final boolean shouldCallback) {
|
|
mShouldCallbackDuringFling = shouldCallback;
|
|
}
|
|
|
|
/**
|
|
* Whether or not to callback when an item that is not selected is clicked.
|
|
* If false, the item will become selected (and re-centered). If true, the
|
|
* {@link #getOnItemClickListener()} will get the callback.
|
|
*
|
|
* @param shouldCallback Whether or not to callback on the listener when a
|
|
* item that is not selected is clicked.
|
|
* @hide
|
|
*/
|
|
public void setCallbackOnUnselectedItemClick(final boolean shouldCallback) {
|
|
mShouldCallbackOnUnselectedItemClick = shouldCallback;
|
|
}
|
|
|
|
/**
|
|
* Describes how the child views are aligned.
|
|
*
|
|
* @param gravity the gravity to set
|
|
*
|
|
* @attr ref android.R.styleable#Gallery_gravity
|
|
*/
|
|
public void setGravity(final int gravity) {
|
|
if (mGravity != gravity) {
|
|
mGravity = gravity;
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
public void setScrollAfterItemClickEnabled(final boolean enabled) {
|
|
mScrollToChildAfterItemClickEnabled = enabled;
|
|
}
|
|
|
|
public void setScrollRightSpacingEnabled(final boolean enabled) {
|
|
mRightSpacingEnabled = enabled;
|
|
}
|
|
|
|
/**
|
|
* Sets the spacing between items in a Gallery.
|
|
*
|
|
* @param spacing The spacing in pixels between items in the Gallery
|
|
*
|
|
* @attr ref android.R.styleable#Gallery_spacing
|
|
*/
|
|
public void setSpacing(final int spacing) {
|
|
mSpacing = spacing;
|
|
}
|
|
|
|
/**
|
|
* Sets the alpha of items that are not selected in the Gallery.
|
|
*
|
|
* @param unselectedAlpha the alpha for the items that are not selected.
|
|
*
|
|
* @attr ref android.R.styleable#Gallery_unselectedAlpha
|
|
*/
|
|
public void setUnselectedAlpha(final float unselectedAlpha) {
|
|
mUnselectedAlpha = unselectedAlpha;
|
|
}
|
|
|
|
@Override
|
|
public boolean showContextMenu() {
|
|
|
|
if (isPressed() && mSelectedPosition >= 0) {
|
|
final int index = mSelectedPosition - mFirstPosition;
|
|
final View v = getChildAt(index);
|
|
return dispatchLongPress(v, mSelectedPosition, mSelectedRowId);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean showContextMenuForChild(final View originalView) {
|
|
|
|
final int longPressPosition = getPositionForView(originalView);
|
|
if (longPressPosition < 0) return false;
|
|
|
|
final long longPressId = mAdapter.getItemId(longPressPosition);
|
|
return dispatchLongPress(originalView, longPressPosition, longPressId);
|
|
}
|
|
|
|
@Override
|
|
protected boolean checkLayoutParams(final ViewGroup.LayoutParams p) {
|
|
return p instanceof LayoutParams;
|
|
}
|
|
|
|
@Override
|
|
protected int computeHorizontalScrollExtent() {
|
|
// Only 1 item is considered to be selected
|
|
return 1;
|
|
}
|
|
|
|
@Override
|
|
protected int computeHorizontalScrollOffset() {
|
|
// Current scroll position is the same as the selected position
|
|
return mSelectedPosition;
|
|
}
|
|
|
|
@Override
|
|
protected int computeHorizontalScrollRange() {
|
|
// Scroll range is the same as the item count
|
|
return mItemCount;
|
|
}
|
|
|
|
@Override
|
|
protected void dispatchSetPressed(final boolean pressed) {
|
|
|
|
// Show the pressed state on the selected child
|
|
if (mSelectedChild != null) {
|
|
mSelectedChild.setPressed(pressed);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
|
|
/*
|
|
* Gallery expects Gallery.LayoutParams.
|
|
*/
|
|
return new Gallery.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
|
|
}
|
|
|
|
@Override
|
|
protected ViewGroup.LayoutParams generateLayoutParams(final ViewGroup.LayoutParams p) {
|
|
return new LayoutParams(p);
|
|
}
|
|
|
|
// CHECKSTYLE:ON
|
|
|
|
@Override
|
|
protected int getChildDrawingOrder(final int childCount, final int i) {
|
|
final int selectedIndex = mSelectedPosition - mFirstPosition;
|
|
|
|
// Just to be safe
|
|
if (selectedIndex < 0) return i;
|
|
|
|
if (i == childCount - 1)
|
|
// Draw the selected child last
|
|
return selectedIndex;
|
|
else if (i >= selectedIndex) // Move the children after the selected
|
|
// child earlier one
|
|
return i + 1;
|
|
else
|
|
// Keep the children before the selected child the same
|
|
return i;
|
|
}
|
|
|
|
// CHECKSTYLE:OFF unchanged method
|
|
@Override
|
|
protected boolean getChildStaticTransformation(final View child, final Transformation t) {
|
|
|
|
t.clear();
|
|
t.setAlpha(child == mSelectedChild ? 1.0f : mUnselectedAlpha);
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
protected ContextMenuInfo getContextMenuInfo() {
|
|
return mContextMenuInfo;
|
|
}
|
|
|
|
@Override
|
|
protected void onFocusChanged(final boolean gainFocus, final int direction, final Rect previouslyFocusedRect) {
|
|
super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
|
|
|
|
/*
|
|
* The Gallery shows focus by focusing the selected item. So, give focus
|
|
* to our selected item instead. We steal keys from our selected item
|
|
* elsewhere.
|
|
*/
|
|
if (gainFocus && mSelectedChild != null) {
|
|
mSelectedChild.requestFocus(direction);
|
|
mSelectedChild.setSelected(true);
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
protected void onLayout(final boolean changed, final int l, final int t, final int r, final int b) {
|
|
super.onLayout(changed, l, t, r, b);
|
|
|
|
/*
|
|
* Remember that we are in layout to prevent more layout request from
|
|
* being generated.
|
|
*/
|
|
mInLayout = true;
|
|
layout(0, false);
|
|
mInLayout = false;
|
|
}
|
|
|
|
/**
|
|
* Figure out vertical placement based on mGravity.
|
|
*
|
|
* @param child Child to place
|
|
* @param duringLayout if this is being called during layout
|
|
* @return Where the top of the child should be
|
|
*/
|
|
private int calculateTop(final View child, final boolean duringLayout) {
|
|
// CHECKSTYLE:OFF unmodified
|
|
final int myHeight = duringLayout ? getMeasuredHeight() : getHeight();
|
|
final int childHeight = duringLayout ? child.getMeasuredHeight() : child.getHeight();
|
|
|
|
int childTop = 0;
|
|
|
|
switch (mGravity) {
|
|
case Gravity.TOP:
|
|
childTop = mSpinnerPadding.top;
|
|
break;
|
|
case Gravity.CENTER_VERTICAL:
|
|
final int availableSpace = myHeight - mSpinnerPadding.bottom - mSpinnerPadding.top - childHeight;
|
|
childTop = mSpinnerPadding.top + availableSpace / 2;
|
|
break;
|
|
case Gravity.BOTTOM:
|
|
childTop = myHeight - mSpinnerPadding.bottom - childHeight;
|
|
break;
|
|
}
|
|
return childTop;
|
|
// CHECKSTYLE:ON
|
|
}
|
|
|
|
// CHECKSTYLE:ON
|
|
|
|
/**
|
|
* Detaches children that are off the screen (i.e.: Gallery bounds).
|
|
*
|
|
* @param toLeft Whether to detach children to the left of the Gallery, or
|
|
* to the right.
|
|
*/
|
|
private void detachOffScreenChildren(final boolean toLeft) {
|
|
final int numChildren = getChildCount();
|
|
final int firstPosition = mFirstPosition;
|
|
int start = 0;
|
|
int count = 0;
|
|
|
|
if (toLeft) {
|
|
final int galleryLeft = getPaddingLeft();
|
|
for (int i = 0; i < numChildren; i++) {
|
|
// CHECKSTYLE:OFF unmodified
|
|
final int n = mIsRtl ? numChildren - 1 - i : i;
|
|
// CHECKSTYLE:ON
|
|
final View child = getChildAt(n);
|
|
if (child.getRight() >= galleryLeft) {
|
|
break;
|
|
} else {
|
|
start = n;
|
|
count++;
|
|
mRecycler.put(firstPosition + n, child);
|
|
}
|
|
}
|
|
if (!mIsRtl) {
|
|
start = 0;
|
|
}
|
|
} else {
|
|
final int galleryRight = getWidth() - getPaddingRight();
|
|
for (int i = numChildren - 1; i >= 0; i--) {
|
|
// CHECKSTYLE:OFF unmodified
|
|
final int n = mIsRtl ? numChildren - 1 - i : i;
|
|
// CHECKSTYLE:ON
|
|
final View child = getChildAt(n);
|
|
if (child.getLeft() <= galleryRight) {
|
|
break;
|
|
} else {
|
|
start = n;
|
|
count++;
|
|
mRecycler.put(firstPosition + n, child);
|
|
}
|
|
}
|
|
if (mIsRtl) {
|
|
start = 0;
|
|
}
|
|
}
|
|
|
|
detachViewsFromParent(start, count);
|
|
|
|
if (toLeft != mIsRtl) {
|
|
mFirstPosition += count;
|
|
}
|
|
}
|
|
|
|
// CHECKSTYLE:OFF unmodified
|
|
private boolean dispatchLongPress(final View view, final int position, final long id) {
|
|
boolean handled = false;
|
|
|
|
if (mOnItemLongClickListener != null) {
|
|
handled = mOnItemLongClickListener.onItemLongClick(this, mDownTouchView, mDownTouchPosition, id);
|
|
}
|
|
|
|
if (!handled) {
|
|
mContextMenuInfo = new AdapterContextMenuInfo(view, position, id);
|
|
handled = super.showContextMenuForChild(this);
|
|
}
|
|
|
|
if (handled) {
|
|
performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
|
|
}
|
|
|
|
return handled;
|
|
}
|
|
|
|
// CHECKSTYLE:ON
|
|
|
|
// CHECKSTYLE:OFF unmodified
|
|
private void dispatchPress(final View child) {
|
|
|
|
if (child != null) {
|
|
child.setPressed(true);
|
|
}
|
|
|
|
setPressed(true);
|
|
}
|
|
|
|
private void dispatchUnpress() {
|
|
|
|
for (int i = getChildCount() - 1; i >= 0; i--) {
|
|
getChildAt(i).setPressed(false);
|
|
}
|
|
|
|
setPressed(false);
|
|
}
|
|
|
|
// CHECKSTYLE:OFF unmodified
|
|
private void fillToGalleryLeft() {
|
|
if (mIsRtl) {
|
|
fillToGalleryLeftRtl();
|
|
} else {
|
|
fillToGalleryLeftLtr();
|
|
}
|
|
}
|
|
|
|
private void fillToGalleryLeftLtr() {
|
|
final int itemSpacing = mSpacing;
|
|
final int galleryLeft = getPaddingLeft();
|
|
|
|
// Set state for initial iteration
|
|
View prevIterationView = getChildAt(0);
|
|
int curPosition;
|
|
int curRightEdge;
|
|
|
|
if (prevIterationView != null) {
|
|
curPosition = mFirstPosition - 1;
|
|
curRightEdge = prevIterationView.getLeft() - itemSpacing;
|
|
} else {
|
|
// No children available!
|
|
curPosition = 0;
|
|
curRightEdge = getRight() - getLeft() - getPaddingRight();
|
|
mShouldStopFling = true;
|
|
}
|
|
|
|
while (curRightEdge > galleryLeft && curPosition >= 0) {
|
|
prevIterationView = makeAndAddView(curPosition, curPosition - mSelectedPosition, curRightEdge, false);
|
|
|
|
// Remember some state
|
|
mFirstPosition = curPosition;
|
|
|
|
// Set state for next iteration
|
|
curRightEdge = prevIterationView.getLeft() - itemSpacing;
|
|
curPosition--;
|
|
}
|
|
}
|
|
|
|
private void fillToGalleryLeftRtl() {
|
|
final int itemSpacing = mSpacing;
|
|
final int galleryLeft = getPaddingLeft();
|
|
final int numChildren = getChildCount();
|
|
|
|
// Set state for initial iteration
|
|
View prevIterationView = getChildAt(numChildren - 1);
|
|
int curPosition;
|
|
int curRightEdge;
|
|
|
|
if (prevIterationView != null) {
|
|
curPosition = mFirstPosition + numChildren;
|
|
curRightEdge = prevIterationView.getLeft() - itemSpacing;
|
|
} else {
|
|
// No children available!
|
|
mFirstPosition = curPosition = mItemCount - 1;
|
|
curRightEdge = getRight() - getLeft() - getPaddingRight();
|
|
mShouldStopFling = true;
|
|
}
|
|
|
|
while (curRightEdge > galleryLeft && curPosition < mItemCount) {
|
|
prevIterationView = makeAndAddView(curPosition, curPosition - mSelectedPosition, curRightEdge, false);
|
|
|
|
// Set state for next iteration
|
|
curRightEdge = prevIterationView.getLeft() - itemSpacing;
|
|
curPosition++;
|
|
}
|
|
}
|
|
|
|
// CHECKSTYLE:ON
|
|
|
|
// Unused methods from GestureDetector.OnGestureListener below
|
|
|
|
private void fillToGalleryRight() {
|
|
if (mIsRtl) {
|
|
fillToGalleryRightRtl();
|
|
} else {
|
|
fillToGalleryRightLtr();
|
|
}
|
|
}
|
|
|
|
// Unused methods from GestureDetector.OnGestureListener above
|
|
|
|
private void fillToGalleryRightLtr() {
|
|
final int itemSpacing = mSpacing;
|
|
final int galleryRight = getRight() - getLeft() - getPaddingRight();
|
|
final int numChildren = getChildCount();
|
|
final int numItems = mItemCount;
|
|
|
|
// Set state for initial iteration
|
|
View prevIterationView = getChildAt(numChildren - 1);
|
|
int curPosition;
|
|
int curLeftEdge;
|
|
|
|
if (prevIterationView != null) {
|
|
curPosition = mFirstPosition + numChildren;
|
|
curLeftEdge = prevIterationView.getRight() + itemSpacing;
|
|
} else {
|
|
mFirstPosition = curPosition = mItemCount - 1;
|
|
curLeftEdge = getPaddingLeft();
|
|
mShouldStopFling = true;
|
|
}
|
|
|
|
while (curLeftEdge < galleryRight && curPosition < numItems) {
|
|
prevIterationView = makeAndAddView(curPosition, curPosition - mSelectedPosition, curLeftEdge, true);
|
|
|
|
// Set state for next iteration
|
|
curLeftEdge = prevIterationView.getRight() + itemSpacing;
|
|
curPosition++;
|
|
}
|
|
}
|
|
|
|
private void fillToGalleryRightRtl() {
|
|
final int itemSpacing = mSpacing;
|
|
final int GalleryRight = getRight() - getLeft() - getPaddingRight();
|
|
|
|
// Set state for initial iteration
|
|
View prevIterationView = getChildAt(0);
|
|
int curPosition;
|
|
int curLeftEdge;
|
|
|
|
if (prevIterationView != null) {
|
|
curPosition = mFirstPosition - 1;
|
|
curLeftEdge = prevIterationView.getRight() + itemSpacing;
|
|
} else {
|
|
curPosition = 0;
|
|
curLeftEdge = getPaddingLeft();
|
|
mShouldStopFling = true;
|
|
}
|
|
|
|
while (curLeftEdge < GalleryRight && curPosition >= 0) {
|
|
prevIterationView = makeAndAddView(curPosition, curPosition - mSelectedPosition, curLeftEdge, true);
|
|
|
|
// Remember some state
|
|
mFirstPosition = curPosition;
|
|
|
|
// Set state for next iteration
|
|
curLeftEdge = prevIterationView.getRight() + itemSpacing;
|
|
curPosition--;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Modified from getCenterOfGallery. This now gets the left of the view
|
|
* (plus padding).
|
|
*
|
|
* @return The left of this Gallery.
|
|
*/
|
|
private int getGalleryLockPoint() {
|
|
// Lock left of the view
|
|
return getPaddingLeft();
|
|
}
|
|
|
|
/**
|
|
* Obtain a view, either by pulling an existing view from the recycler or by
|
|
* getting a new one from the adapter. If we are animating, make sure there
|
|
* is enough information in the view's layout parameters to animate from the
|
|
* old to new positions.
|
|
*
|
|
* @param position Position in the Gallery for the view to obtain
|
|
* @param offset Offset from the selected position
|
|
* @param x X-coordinate indicating where this view should be placed. This
|
|
* will either be the left or right edge of the view, depending
|
|
* on the fromLeft parameter
|
|
* @param fromLeft Are we positioning views based on the left edge? (i.e.,
|
|
* building from left to right)?
|
|
* @return A view that has been added to the Gallery
|
|
*/
|
|
private View makeAndAddView(final int position, final int offset, final int x, final boolean fromLeft) {
|
|
|
|
View child;
|
|
if (!mDataChanged) {
|
|
child = mRecycler.get(position);
|
|
if (child != null) {
|
|
// Can reuse an existing view
|
|
final int childLeft = child.getLeft();
|
|
|
|
// Remember left and right edges of where views have been placed
|
|
mRightMost = Math.max(mRightMost, childLeft + child.getMeasuredWidth());
|
|
mLeftMost = Math.min(mLeftMost, childLeft);
|
|
|
|
// Position the view
|
|
setUpChild(child, offset, x, fromLeft);
|
|
|
|
return child;
|
|
}
|
|
}
|
|
|
|
// Nothing found in the recycler -- ask the adapter for a view
|
|
child = mAdapter.getView(position, null, this);
|
|
|
|
// Position the view
|
|
setUpChild(child, offset, x, fromLeft);
|
|
|
|
return child;
|
|
}
|
|
|
|
// CHECKSTYLE:ON
|
|
|
|
/**
|
|
* Offset the horizontal location of all children of this view by the
|
|
* specified number of pixels.
|
|
*
|
|
* @param offset the number of pixels to offset
|
|
*/
|
|
private void offsetChildrenLeftAndRight(final int offset) {
|
|
for (int i = getChildCount() - 1; i >= 0; i--) {
|
|
getChildAt(i).offsetLeftAndRight(offset);
|
|
}
|
|
}
|
|
|
|
// CHECKSTYLE:OFF unmodified
|
|
private void onFinishedMovement() {
|
|
if (mSuppressSelectionChanged) {
|
|
mSuppressSelectionChanged = false;
|
|
|
|
// We haven't been callbacking during the fling, so do it now
|
|
super.selectionChanged();
|
|
}
|
|
invalidate();
|
|
}
|
|
|
|
/**
|
|
* Scrolls the items so that the selected item is in its 'slot' (its center
|
|
* is the Gallery's center).
|
|
*
|
|
* Note: modifed to snap the left of a view rather than the center
|
|
*/
|
|
private void scrollIntoSlots() {
|
|
if (getChildCount() == 0 || mSelectedChild == null) return;
|
|
|
|
final int selectedCenter = getLeftOfView(mSelectedChild);
|
|
final int targetCenter = getGalleryLockPoint();
|
|
|
|
final int scrollAmount = targetCenter - selectedCenter;
|
|
if (scrollAmount != 0) {
|
|
mFlingRunnable.startUsingDistance(scrollAmount);
|
|
} else {
|
|
onFinishedMovement();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Scroll to the child at the position passed.
|
|
*
|
|
* @param childPosition the child's position
|
|
* @return if scrolling to the child is starting, false otherwise
|
|
*/
|
|
private boolean scrollToChild(final int childPosition) {
|
|
final View child = getChildAt(childPosition);
|
|
|
|
if (child != null) {
|
|
final int distance = getGalleryLockPoint() - getLeftOfView(child);
|
|
mFlingRunnable.startUsingDistance(distance);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Looks for the child that is closest to the lock point of the gallery and
|
|
* sets it as the selected child.
|
|
*
|
|
* Note: modified from setSelectionToCenterChild to now select the the
|
|
* selected view to the child closest to the gallery's "lock point" (it's
|
|
* left).
|
|
*/
|
|
private void setSelectionToChildClosestToLockPoint() {
|
|
if (mSelectedChild == null) return;
|
|
|
|
final int lockPoint = getGalleryLockPoint();
|
|
|
|
// TODO better search
|
|
int closestEdgeDistance = Integer.MAX_VALUE;
|
|
int newSelectedChildIndex = 0;
|
|
for (int i = getChildCount() - 1; i >= 0; i--) {
|
|
final View child = getChildAt(i);
|
|
|
|
/*
|
|
* Note: Since we are locking on the left edge of the scroller, we
|
|
* want to put more emphasis on the closest edge calculations
|
|
* because the left edge being on the left of the screen puts
|
|
* unnecessary weight on the currently selected item.
|
|
*/
|
|
if (child.getLeft() == lockPoint && child.getRight() >= lockPoint) {
|
|
// This child is in the lock point
|
|
newSelectedChildIndex = i;
|
|
break;
|
|
}
|
|
|
|
final int childClosestEdgeDistance = Math.min(Math.abs(child.getLeft() - lockPoint),
|
|
Math.abs(child.getRight() - lockPoint));
|
|
if (childClosestEdgeDistance < closestEdgeDistance) {
|
|
closestEdgeDistance = childClosestEdgeDistance;
|
|
newSelectedChildIndex = i;
|
|
}
|
|
}
|
|
|
|
final int newPos = mFirstPosition + newSelectedChildIndex;
|
|
|
|
if (newPos != mSelectedPosition) {
|
|
setSelectedPositionInt(newPos);
|
|
setNextSelectedPositionInt(newPos);
|
|
checkSelectionChanged();
|
|
}
|
|
}
|
|
|
|
// CHECKSTYLE:ON
|
|
|
|
/**
|
|
* Helper for makeAndAddView to set the position of a view and fill out its
|
|
* layout parameters.
|
|
*
|
|
* @param child The view to position
|
|
* @param offset Offset from the selected position
|
|
* @param x X-coordinate indicating where this view should be placed. This
|
|
* will either be the left or right edge of the view, depending
|
|
* on the fromLeft parameter
|
|
* @param fromLeft Are we positioning views based on the left edge? (i.e.,
|
|
* building from left to right)?
|
|
*/
|
|
private void setUpChild(final View child, final int offset, final int x, final boolean fromLeft) {
|
|
|
|
/*
|
|
* Respect layout params that are already in the view. Otherwise make
|
|
* some up...
|
|
*/
|
|
Gallery.LayoutParams lp = child.getLayoutParams();
|
|
if (lp == null) {
|
|
lp = generateDefaultLayoutParams();
|
|
}
|
|
|
|
// CHECKSTYLE:OFF unmodified
|
|
addViewInLayout(child, fromLeft != mIsRtl ? -1 : 0, lp);
|
|
// CHECKSTYLE:ON
|
|
|
|
child.setSelected(offset == 0);
|
|
|
|
// Get measure specs
|
|
final int childHeightSpec = ViewGroup.getChildMeasureSpec(mHeightMeasureSpec, mSpinnerPadding.top
|
|
+ mSpinnerPadding.bottom, lp.height);
|
|
final int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec, mSpinnerPadding.left
|
|
+ mSpinnerPadding.right, lp.width);
|
|
|
|
// Measure child
|
|
child.measure(childWidthSpec, childHeightSpec);
|
|
|
|
int childLeft;
|
|
int childRight;
|
|
|
|
// Position vertically based on gravity setting
|
|
final int childTop = calculateTop(child, true);
|
|
final int childBottom = childTop + child.getMeasuredHeight();
|
|
|
|
final int width = child.getMeasuredWidth();
|
|
if (fromLeft) {
|
|
childLeft = x;
|
|
childRight = childLeft + width;
|
|
} else {
|
|
childLeft = x - width;
|
|
childRight = x;
|
|
}
|
|
|
|
child.layout(childLeft, childTop, childRight, childBottom);
|
|
}
|
|
|
|
// CHECKSTYLE:OFF unmodified
|
|
private void updateSelectedItemMetadata() {
|
|
|
|
final View oldSelectedChild = mSelectedChild;
|
|
|
|
final View child = mSelectedChild = getChildAt(mSelectedPosition - mFirstPosition);
|
|
if (child == null) return;
|
|
|
|
child.setSelected(true);
|
|
child.setFocusable(true);
|
|
|
|
if (hasFocus()) {
|
|
child.requestFocus();
|
|
}
|
|
|
|
// We unfocus the old child down here so the above hasFocus check
|
|
// returns true
|
|
if (oldSelectedChild != null && oldSelectedChild != child) {
|
|
|
|
// Make sure its drawable state doesn't contain 'selected'
|
|
oldSelectedChild.setSelected(false);
|
|
|
|
/*
|
|
* Make sure it is not focusable anymore, since otherwise arrow keys
|
|
* can make this one be focused
|
|
*/
|
|
oldSelectedChild.setFocusable(false);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the limit of the amount to scroll the view. Note: Modified from the
|
|
* android source to snap to the left of the view rather than the center.
|
|
*
|
|
* @param motionToLeft if the motion is to the left of the view
|
|
* @param deltaX the change in x
|
|
* @return the clamped value to scroll
|
|
*/
|
|
// TODO
|
|
int getLimitedMotionScrollAmount(final boolean motionToLeft, final int deltaX) {
|
|
// CHECKSTYLE:OFF unmodifed code
|
|
final int extremeItemPosition = motionToLeft != mIsRtl ? mItemCount - 1 : 0;
|
|
// CHECKSTYLE:ON
|
|
final View extremeChild = getChildAt(extremeItemPosition - mFirstPosition);
|
|
|
|
if (extremeChild == null) return deltaX;
|
|
|
|
final int extremeChildLeft = getLeftOfView(extremeChild);
|
|
final int galleryLockPoint = getGalleryLockPoint();
|
|
|
|
if (motionToLeft) {
|
|
if (!mRightSpacingEnabled && extremeChild.getRight() <= getRight()) return 0;
|
|
// The extreme child is past his boundary point!
|
|
if (extremeChildLeft <= galleryLockPoint) return 0;
|
|
} else {
|
|
// The extreme child is past his boundary point!
|
|
if (extremeChildLeft >= galleryLockPoint) return 0;
|
|
}
|
|
|
|
final int centerDifference = galleryLockPoint - extremeChildLeft;
|
|
|
|
// CHECKSTYLE:OFF unmodifed return
|
|
return motionToLeft ? Math.max(centerDifference, deltaX) : Math.min(centerDifference, deltaX);
|
|
// CHECKSTYLE:ON
|
|
}
|
|
|
|
/**
|
|
* Creates and positions all views for this Gallery.
|
|
* <p>
|
|
* We layout rarely, most of the time {@link #trackMotionScroll(int)} takes
|
|
* care of repositioning, adding, and removing children.
|
|
*
|
|
* Note: modified to offset to the gallery lock point rather than based on
|
|
* the # of children.
|
|
*
|
|
* @param delta Change in the selected position. +1 means the selection is
|
|
* moving to the right, so views are scrolling to the left. -1
|
|
* means the selection is moving to the left.
|
|
* @param animate if true, animate the view
|
|
*/
|
|
@Override
|
|
void layout(final int delta, final boolean animate) {
|
|
|
|
mIsRtl = false;
|
|
|
|
if (mDataChanged) {
|
|
handleDataChanged();
|
|
}
|
|
|
|
// Handle an empty Gallery by removing all views.
|
|
if (mItemCount == 0) {
|
|
resetList();
|
|
return;
|
|
}
|
|
|
|
// Update to the new selected position.
|
|
if (mNextSelectedPosition >= 0) {
|
|
setSelectedPositionInt(mNextSelectedPosition);
|
|
}
|
|
|
|
// All views go in recycler while we are in layout
|
|
recycleAllViews();
|
|
|
|
// Clear out old views
|
|
detachAllViewsFromParent();
|
|
|
|
/*
|
|
* These will be used to give initial positions to views entering the
|
|
* Gallery as we scroll
|
|
*/
|
|
mRightMost = 0;
|
|
mLeftMost = 0;
|
|
|
|
// Make selected view and move it to the lock point
|
|
|
|
/*
|
|
* mFirstPosition will be decreased as we add views to the left later
|
|
* on. The 0 for x will be offset in a couple lines down.
|
|
*/
|
|
mFirstPosition = mSelectedPosition;
|
|
final View sel = makeAndAddView(mSelectedPosition, 0, 0, true);
|
|
|
|
// Put the selected child at the lockPoint
|
|
sel.offsetLeftAndRight(getGalleryLockPoint());
|
|
|
|
fillToGalleryRight();
|
|
fillToGalleryLeft();
|
|
|
|
// Flush any cached views that did not get reused above
|
|
mRecycler.clear();
|
|
|
|
invalidate();
|
|
checkSelectionChanged();
|
|
|
|
mDataChanged = false;
|
|
mNeedSync = false;
|
|
setNextSelectedPositionInt(mSelectedPosition);
|
|
|
|
updateSelectedItemMetadata();
|
|
}
|
|
|
|
// CHECKSTYLE:ON
|
|
|
|
boolean moveNext() {
|
|
if (mItemCount > 0 && mSelectedPosition < mItemCount - 1) {
|
|
scrollToChild(mSelectedPosition - mFirstPosition + 1);
|
|
return true;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
boolean movePrevious() {
|
|
if (mItemCount > 0 && mSelectedPosition > 0) {
|
|
/**
|
|
* used to be scrollToChild(mSelectedPosition - mFirstPosition - 1);
|
|
* Found that this did not work with trackball/keyboard navigation.
|
|
*/
|
|
setSelection(mSelectedPosition - 1);
|
|
return true;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Called when a touch event's action is MotionEvent.ACTION_CANCEL.
|
|
*/
|
|
void onCancel() {
|
|
onUp();
|
|
}
|
|
|
|
/**
|
|
* Called when a touch event's action is MotionEvent.ACTION_UP.
|
|
*/
|
|
void onUp() {
|
|
|
|
if (mFlingRunnable.mScroller.isFinished()) {
|
|
scrollIntoSlots();
|
|
}
|
|
|
|
dispatchUnpress();
|
|
}
|
|
|
|
@Override
|
|
void selectionChanged() {
|
|
if (!mSuppressSelectionChanged) {
|
|
super.selectionChanged();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
void setSelectedPositionInt(final int position) {
|
|
super.setSelectedPositionInt(position);
|
|
|
|
// Updates any metadata we keep about the selected item.
|
|
updateSelectedItemMetadata();
|
|
}
|
|
|
|
/**
|
|
* Tracks a motion scroll. In reality, this is used to do just about any
|
|
* movement to items (touch scroll, arrow-key scroll, set an item as
|
|
* selected).
|
|
*
|
|
* @param deltaX Change in X from the previous event.
|
|
*/
|
|
void trackMotionScroll(final int deltaX) {
|
|
|
|
if (getChildCount() == 0) return;
|
|
|
|
final boolean toLeft = deltaX < 0;
|
|
|
|
final int limitedDeltaX = getLimitedMotionScrollAmount(toLeft, deltaX);
|
|
if (limitedDeltaX != deltaX) {
|
|
// The above call returned a limited amount, so stop any
|
|
// scrolls/flings
|
|
mFlingRunnable.endFling(false);
|
|
onFinishedMovement();
|
|
}
|
|
|
|
offsetChildrenLeftAndRight(limitedDeltaX);
|
|
|
|
detachOffScreenChildren(toLeft);
|
|
|
|
if (toLeft) {
|
|
// If moved left, there will be empty space on the right
|
|
fillToGalleryRight();
|
|
} else {
|
|
// Similarly, empty space on the left
|
|
fillToGalleryLeft();
|
|
}
|
|
|
|
// Clear unused views
|
|
mRecycler.clear();
|
|
|
|
setSelectionToChildClosestToLockPoint();
|
|
|
|
onScrollChanged(0, 0, 0, 0); // Dummy values, View's implementation does
|
|
// not use these.
|
|
|
|
invalidate();
|
|
}
|
|
|
|
/**
|
|
* Modified from getCenterOfView to get the left of a view instead.
|
|
*
|
|
* @param view the view to get the left of
|
|
* @return The center of the given view.
|
|
*/
|
|
private static int getLeftOfView(final View view) {
|
|
return view.getLeft();
|
|
}
|
|
|
|
/**
|
|
* Responsible for fling behavior. Use {@link #startUsingVelocity(int)} to
|
|
* initiate a fling. Each frame of the fling is handled in {@link #run()}. A
|
|
* FlingRunnable will keep re-posting itself until the fling is done.
|
|
*/
|
|
private class FlingRunnable implements Runnable {
|
|
/**
|
|
* Tracks the decay of a fling scroll.
|
|
*/
|
|
private final Scroller mScroller;
|
|
|
|
/**
|
|
* X value reported by mScroller on the previous fling.
|
|
*/
|
|
private int mLastFlingX;
|
|
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
public FlingRunnable() {
|
|
mScroller = new Scroller(getContext());
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
|
|
if (mItemCount == 0) {
|
|
endFling(true);
|
|
return;
|
|
}
|
|
|
|
mShouldStopFling = false;
|
|
|
|
final Scroller scroller = mScroller;
|
|
final boolean more = scroller.computeScrollOffset();
|
|
final int x = scroller.getCurrX();
|
|
|
|
// Flip sign to convert finger direction to list items direction
|
|
// (e.g. finger moving down means list is moving towards the top)
|
|
int delta = mLastFlingX - x;
|
|
|
|
// Pretend that each frame of a fling scroll is a touch scroll
|
|
if (delta > 0) {
|
|
// Moving towards the left. Use leftmost view as
|
|
// mDownTouchPosition
|
|
mDownTouchPosition = mIsRtl ? mFirstPosition + getChildCount() - 1 : mFirstPosition;
|
|
|
|
// Don't fling more than 1 screen
|
|
delta = Math.min(getWidth() - getPaddingLeft() - getPaddingRight() - 1, delta);
|
|
} else {
|
|
// Moving towards the right. Use rightmost view as
|
|
// mDownTouchPosition
|
|
mDownTouchPosition = mIsRtl ? mFirstPosition : mFirstPosition + getChildCount() - 1;
|
|
|
|
// Don't fling more than 1 screen
|
|
delta = Math.max(-(getWidth() - getPaddingRight() - getPaddingLeft() - 1), delta);
|
|
}
|
|
|
|
trackMotionScroll(delta);
|
|
|
|
if (more && !mShouldStopFling) {
|
|
mLastFlingX = x;
|
|
post(this);
|
|
} else {
|
|
endFling(true);
|
|
}
|
|
}
|
|
|
|
public void startUsingDistance(final int distance) {
|
|
if (distance == 0) return;
|
|
|
|
startCommon();
|
|
|
|
mLastFlingX = 0;
|
|
mScroller.startScroll(0, 0, -distance, 0, mAnimationDuration);
|
|
post(this);
|
|
}
|
|
|
|
public void startUsingVelocity(final int initialVelocity) {
|
|
if (initialVelocity == 0) return;
|
|
|
|
startCommon();
|
|
|
|
final int initialX = initialVelocity < 0 ? Integer.MAX_VALUE : 0;
|
|
mLastFlingX = initialX;
|
|
mScroller.fling(initialX, 0, initialVelocity, 0, 0, Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
|
|
post(this);
|
|
}
|
|
|
|
public void stop(final boolean scrollIntoSlots) {
|
|
removeCallbacks(this);
|
|
endFling(scrollIntoSlots);
|
|
}
|
|
|
|
private void endFling(final boolean scrollIntoSlots) {
|
|
/*
|
|
* Force the scroller's status to finished (without setting its
|
|
* position to the end)
|
|
*/
|
|
mScroller.forceFinished(true);
|
|
|
|
if (scrollIntoSlots) {
|
|
scrollIntoSlots();
|
|
}
|
|
}
|
|
|
|
// CHECKSTYLE:OFF unmodified
|
|
private void startCommon() {
|
|
// Remove any pending flings
|
|
removeCallbacks(this);
|
|
}
|
|
|
|
}
|
|
}
|