blob: 6c9aac1db2aca1e8529c3975c1d9bc43c7756bc8 [file] [log] [blame]
Winson Chung321e9ee2010-08-09 13:37:56 -07001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.launcher2;
18
Winson Chung04998342011-01-05 13:54:43 -080019import java.util.ArrayList;
20import java.util.Collection;
21import java.util.TreeMap;
22import java.util.TreeSet;
Patrick Dubroy9f7aec82010-09-06 11:03:37 -070023
Winson Chung321e9ee2010-08-09 13:37:56 -070024import android.content.Context;
Adam Cohen9c4949e2010-10-05 12:27:22 -070025import android.content.res.TypedArray;
Winson Chung241c3b42010-08-25 16:53:03 -070026import android.graphics.Bitmap;
Winson Chung321e9ee2010-08-09 13:37:56 -070027import android.graphics.Canvas;
28import android.graphics.Rect;
Winson Chung321e9ee2010-08-09 13:37:56 -070029import android.os.Parcel;
30import android.os.Parcelable;
31import android.util.AttributeSet;
Winson Chung5f2aa4e2010-08-20 14:49:25 -070032import android.view.ActionMode;
Winson Chung321e9ee2010-08-09 13:37:56 -070033import android.view.MotionEvent;
34import android.view.VelocityTracker;
35import android.view.View;
36import android.view.ViewConfiguration;
37import android.view.ViewGroup;
38import android.view.ViewParent;
Winson Chung80baf5a2010-08-09 16:03:15 -070039import android.view.animation.Animation;
Winson Chung04998342011-01-05 13:54:43 -080040import android.view.animation.Animation.AnimationListener;
Winson Chunge3193b92010-09-10 11:44:42 -070041import android.view.animation.AnimationUtils;
Adam Cohene0f66b52010-11-23 15:06:07 -080042import android.view.animation.Interpolator;
Winson Chung5f2aa4e2010-08-20 14:49:25 -070043import android.widget.Checkable;
Winson Chung321e9ee2010-08-09 13:37:56 -070044import android.widget.Scroller;
45
Winson Chung04998342011-01-05 13:54:43 -080046import com.android.launcher.R;
Winson Chung80baf5a2010-08-09 16:03:15 -070047
Winson Chung321e9ee2010-08-09 13:37:56 -070048/**
49 * An abstraction of the original Workspace which supports browsing through a
Michael Jurka0142d492010-08-25 17:46:15 -070050 * sequential list of "pages"
Winson Chung321e9ee2010-08-09 13:37:56 -070051 */
52public abstract class PagedView extends ViewGroup {
53 private static final String TAG = "PagedView";
Michael Jurka0142d492010-08-25 17:46:15 -070054 protected static final int INVALID_PAGE = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -070055
Winson Chung86f77532010-08-24 11:08:22 -070056 // the min drag distance for a fling to register, to prevent random page shifts
Winson Chung9cfd25f2010-10-24 16:09:28 -070057 private static final int MIN_LENGTH_FOR_FLING = 25;
58 // The min drag distance to trigger a page shift (regardless of velocity)
59 private static final int MIN_LENGTH_FOR_MOVE = 200;
Winson Chung321e9ee2010-08-09 13:37:56 -070060
Adam Cohene0f66b52010-11-23 15:06:07 -080061 private static final int PAGE_SNAP_ANIMATION_DURATION = 550;
Michael Jurka0142d492010-08-25 17:46:15 -070062 protected static final float NANOTIME_DIV = 1000000000.0f;
Winson Chung321e9ee2010-08-09 13:37:56 -070063
Adam Cohene0f66b52010-11-23 15:06:07 -080064 private static final float OVERSCROLL_DAMP_FACTOR = 0.08f;
65 private static final int MINIMUM_SNAP_VELOCITY = 2200;
66 private static final int MIN_FLING_VELOCITY = 250;
Adam Cohen68d73932010-11-15 10:50:58 -080067
Michael Jurka0142d492010-08-25 17:46:15 -070068 // the velocity at which a fling gesture will cause us to snap to the next page
69 protected int mSnapVelocity = 500;
70
71 protected float mSmoothingTime;
72 protected float mTouchX;
73
74 protected boolean mFirstLayout = true;
75
76 protected int mCurrentPage;
77 protected int mNextPage = INVALID_PAGE;
Winson Chunga12a2502010-12-20 14:41:35 -080078 protected int mRestorePage = -1;
Adam Cohen68d73932010-11-15 10:50:58 -080079 protected int mMaxScrollX;
Michael Jurka0142d492010-08-25 17:46:15 -070080 protected Scroller mScroller;
Winson Chung321e9ee2010-08-09 13:37:56 -070081 private VelocityTracker mVelocityTracker;
82
83 private float mDownMotionX;
Michael Jurka7426c422010-11-11 15:23:47 -080084 protected float mLastMotionX;
85 protected float mLastMotionY;
Adam Cohenf34bab52010-09-30 14:11:56 -070086 private int mLastScreenCenter = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -070087
Michael Jurka0142d492010-08-25 17:46:15 -070088 protected final static int TOUCH_STATE_REST = 0;
89 protected final static int TOUCH_STATE_SCROLLING = 1;
90 protected final static int TOUCH_STATE_PREV_PAGE = 2;
91 protected final static int TOUCH_STATE_NEXT_PAGE = 3;
Adam Cohene45440e2010-10-14 18:33:38 -070092 protected final static float ALPHA_QUANTIZE_LEVEL = 0.0001f;
Winson Chung321e9ee2010-08-09 13:37:56 -070093
Michael Jurka0142d492010-08-25 17:46:15 -070094 protected int mTouchState = TOUCH_STATE_REST;
Winson Chung321e9ee2010-08-09 13:37:56 -070095
Michael Jurka0142d492010-08-25 17:46:15 -070096 protected OnLongClickListener mLongClickListener;
Winson Chung321e9ee2010-08-09 13:37:56 -070097
Michael Jurka7426c422010-11-11 15:23:47 -080098 protected boolean mAllowLongPress = true;
Winson Chung321e9ee2010-08-09 13:37:56 -070099
Michael Jurka7426c422010-11-11 15:23:47 -0800100 protected int mTouchSlop;
Winson Chung321e9ee2010-08-09 13:37:56 -0700101 private int mPagingTouchSlop;
102 private int mMaximumVelocity;
Adam Cohen9c4949e2010-10-05 12:27:22 -0700103 protected int mPageSpacing;
104 protected int mPageLayoutPaddingTop;
105 protected int mPageLayoutPaddingBottom;
106 protected int mPageLayoutPaddingLeft;
107 protected int mPageLayoutPaddingRight;
Winson Chungdf4b83d2010-10-20 17:49:27 -0700108 protected int mPageLayoutWidthGap;
109 protected int mPageLayoutHeightGap;
Adam Cohen9c4949e2010-10-05 12:27:22 -0700110 protected int mCellCountX;
111 protected int mCellCountY;
Winson Chung7da10252010-10-28 16:07:04 -0700112 protected boolean mCenterPagesVertically;
Adam Cohen68d73932010-11-15 10:50:58 -0800113 protected boolean mAllowOverScroll = true;
114 protected int mUnboundedScrollX;
Winson Chung321e9ee2010-08-09 13:37:56 -0700115
Michael Jurkad3ef3062010-11-23 16:23:58 -0800116 // parameter that adjusts the layout to be optimized for CellLayouts with that scale factor
117 protected float mLayoutScale = 1.0f;
118
Michael Jurka5f1c5092010-09-03 14:15:02 -0700119 protected static final int INVALID_POINTER = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -0700120
Michael Jurka5f1c5092010-09-03 14:15:02 -0700121 protected int mActivePointerId = INVALID_POINTER;
Winson Chung321e9ee2010-08-09 13:37:56 -0700122
Winson Chung86f77532010-08-24 11:08:22 -0700123 private PageSwitchListener mPageSwitchListener;
Winson Chung321e9ee2010-08-09 13:37:56 -0700124
Winson Chung86f77532010-08-24 11:08:22 -0700125 private ArrayList<Boolean> mDirtyPageContent;
126 private boolean mDirtyPageAlpha;
Winson Chung321e9ee2010-08-09 13:37:56 -0700127
Winson Chung5f2aa4e2010-08-20 14:49:25 -0700128 // choice modes
129 protected static final int CHOICE_MODE_NONE = 0;
130 protected static final int CHOICE_MODE_SINGLE = 1;
131 // Multiple selection mode is not supported by all Launcher actions atm
132 protected static final int CHOICE_MODE_MULTIPLE = 2;
Patrick Dubroy9f7aec82010-09-06 11:03:37 -0700133
Michael Jurkae17e19c2010-09-28 11:01:39 -0700134 protected int mChoiceMode;
Winson Chung5f2aa4e2010-08-20 14:49:25 -0700135 private ActionMode mActionMode;
136
Winson Chung04998342011-01-05 13:54:43 -0800137 // NOTE: This is a shared icon cache across all the PagedViews. Currently it is only used in
138 // AllApps and Customize, and allows them to share holographic icons for the application view
139 // (which is in both).
140 protected static PagedViewIconCache mPageViewIconCache = new PagedViewIconCache();
Winson Chung241c3b42010-08-25 16:53:03 -0700141
Michael Jurka0142d492010-08-25 17:46:15 -0700142 // If true, syncPages and syncPageItems will be called to refresh pages
143 protected boolean mContentIsRefreshable = true;
144
145 // If true, modify alpha of neighboring pages as user scrolls left/right
146 protected boolean mFadeInAdjacentScreens = true;
147
148 // It true, use a different slop parameter (pagingTouchSlop = 2 * touchSlop) for deciding
149 // to switch to a new page
150 protected boolean mUsePagingTouchSlop = true;
151
152 // If true, the subclass should directly update mScrollX itself in its computeScroll method
153 // (SmoothPagedView does this)
154 protected boolean mDeferScrollUpdate = false;
155
Patrick Dubroy1262e362010-10-06 15:49:50 -0700156 protected boolean mIsPageMoving = false;
157
Winson Chung86f77532010-08-24 11:08:22 -0700158 public interface PageSwitchListener {
159 void onPageSwitch(View newPage, int newPageIndex);
Winson Chung321e9ee2010-08-09 13:37:56 -0700160 }
161
Winson Chung321e9ee2010-08-09 13:37:56 -0700162 public PagedView(Context context) {
163 this(context, null);
164 }
165
166 public PagedView(Context context, AttributeSet attrs) {
167 this(context, attrs, 0);
168 }
169
170 public PagedView(Context context, AttributeSet attrs, int defStyle) {
171 super(context, attrs, defStyle);
Winson Chung5f2aa4e2010-08-20 14:49:25 -0700172 mChoiceMode = CHOICE_MODE_NONE;
Winson Chung321e9ee2010-08-09 13:37:56 -0700173
Adam Cohen9c4949e2010-10-05 12:27:22 -0700174 TypedArray a = context.obtainStyledAttributes(attrs,
175 R.styleable.PagedView, defStyle, 0);
176 mPageSpacing = a.getDimensionPixelSize(R.styleable.PagedView_pageSpacing, 0);
177 mPageLayoutPaddingTop = a.getDimensionPixelSize(
178 R.styleable.PagedView_pageLayoutPaddingTop, 10);
179 mPageLayoutPaddingBottom = a.getDimensionPixelSize(
180 R.styleable.PagedView_pageLayoutPaddingBottom, 10);
181 mPageLayoutPaddingLeft = a.getDimensionPixelSize(
182 R.styleable.PagedView_pageLayoutPaddingLeft, 10);
183 mPageLayoutPaddingRight = a.getDimensionPixelSize(
184 R.styleable.PagedView_pageLayoutPaddingRight, 10);
Winson Chungdf4b83d2010-10-20 17:49:27 -0700185 mPageLayoutWidthGap = a.getDimensionPixelSize(
186 R.styleable.PagedView_pageLayoutWidthGap, -1);
187 mPageLayoutHeightGap = a.getDimensionPixelSize(
188 R.styleable.PagedView_pageLayoutHeightGap, -1);
Adam Cohen9c4949e2010-10-05 12:27:22 -0700189 a.recycle();
190
Winson Chung321e9ee2010-08-09 13:37:56 -0700191 setHapticFeedbackEnabled(false);
Michael Jurka0142d492010-08-25 17:46:15 -0700192 init();
Winson Chung321e9ee2010-08-09 13:37:56 -0700193 }
194
195 /**
196 * Initializes various states for this workspace.
197 */
Michael Jurka0142d492010-08-25 17:46:15 -0700198 protected void init() {
Winson Chung86f77532010-08-24 11:08:22 -0700199 mDirtyPageContent = new ArrayList<Boolean>();
200 mDirtyPageContent.ensureCapacity(32);
Adam Cohene0f66b52010-11-23 15:06:07 -0800201 mScroller = new Scroller(getContext(), new ScrollInterpolator());
Winson Chung86f77532010-08-24 11:08:22 -0700202 mCurrentPage = 0;
Winson Chung7da10252010-10-28 16:07:04 -0700203 mCenterPagesVertically = true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700204
205 final ViewConfiguration configuration = ViewConfiguration.get(getContext());
206 mTouchSlop = configuration.getScaledTouchSlop();
207 mPagingTouchSlop = configuration.getScaledPagingTouchSlop();
208 mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
209 }
210
Winson Chung86f77532010-08-24 11:08:22 -0700211 public void setPageSwitchListener(PageSwitchListener pageSwitchListener) {
212 mPageSwitchListener = pageSwitchListener;
213 if (mPageSwitchListener != null) {
214 mPageSwitchListener.onPageSwitch(getPageAt(mCurrentPage), mCurrentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700215 }
216 }
217
218 /**
Winson Chung86f77532010-08-24 11:08:22 -0700219 * Returns the index of the currently displayed page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700220 *
Winson Chung86f77532010-08-24 11:08:22 -0700221 * @return The index of the currently displayed page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700222 */
Winson Chung86f77532010-08-24 11:08:22 -0700223 int getCurrentPage() {
224 return mCurrentPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700225 }
226
Winson Chung86f77532010-08-24 11:08:22 -0700227 int getPageCount() {
Winson Chung321e9ee2010-08-09 13:37:56 -0700228 return getChildCount();
229 }
230
Winson Chung86f77532010-08-24 11:08:22 -0700231 View getPageAt(int index) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700232 return getChildAt(index);
233 }
234
235 int getScrollWidth() {
236 return getWidth();
237 }
238
239 /**
Winson Chungbbc60d82010-11-11 16:34:41 -0800240 * Updates the scroll of the current page immediately to its final scroll position. We use this
241 * in CustomizePagedView to allow tabs to share the same PagedView while resetting the scroll of
242 * the previous tab page.
243 */
244 protected void updateCurrentPageScroll() {
245 int newX = getChildOffset(mCurrentPage) - getRelativeChildOffset(mCurrentPage);
246 scrollTo(newX, 0);
247 mScroller.setFinalX(newX);
248 }
249
250 /**
Winson Chung86f77532010-08-24 11:08:22 -0700251 * Sets the current page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700252 */
Winson Chung86f77532010-08-24 11:08:22 -0700253 void setCurrentPage(int currentPage) {
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800254 if (!mScroller.isFinished()) {
255 mScroller.abortAnimation();
256 }
Michael Jurkad3ef3062010-11-23 16:23:58 -0800257 // don't introduce any checks like mCurrentPage == currentPage here-- if we change the
258 // the default
259 if (getChildCount() == 0) {
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800260 return;
261 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700262
Winson Chung86f77532010-08-24 11:08:22 -0700263 mCurrentPage = Math.max(0, Math.min(currentPage, getPageCount() - 1));
Winson Chungbbc60d82010-11-11 16:34:41 -0800264 updateCurrentPageScroll();
Winson Chung86f77532010-08-24 11:08:22 -0700265 notifyPageSwitchListener();
Winson Chunga12a2502010-12-20 14:41:35 -0800266 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -0700267 }
268
Michael Jurka0142d492010-08-25 17:46:15 -0700269 protected void notifyPageSwitchListener() {
Winson Chung86f77532010-08-24 11:08:22 -0700270 if (mPageSwitchListener != null) {
271 mPageSwitchListener.onPageSwitch(getPageAt(mCurrentPage), mCurrentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700272 }
273 }
274
Patrick Dubroy1262e362010-10-06 15:49:50 -0700275 private void pageBeginMoving() {
276 mIsPageMoving = true;
277 onPageBeginMoving();
278 }
279
280 private void pageEndMoving() {
281 onPageEndMoving();
282 mIsPageMoving = false;
Michael Jurka0142d492010-08-25 17:46:15 -0700283 }
284
285 // a method that subclasses can override to add behavior
Patrick Dubroy1262e362010-10-06 15:49:50 -0700286 protected void onPageBeginMoving() {
287 }
288
289 // a method that subclasses can override to add behavior
290 protected void onPageEndMoving() {
Michael Jurka0142d492010-08-25 17:46:15 -0700291 }
292
Winson Chung321e9ee2010-08-09 13:37:56 -0700293 /**
Winson Chung86f77532010-08-24 11:08:22 -0700294 * Registers the specified listener on each page contained in this workspace.
Winson Chung321e9ee2010-08-09 13:37:56 -0700295 *
296 * @param l The listener used to respond to long clicks.
297 */
298 @Override
299 public void setOnLongClickListener(OnLongClickListener l) {
300 mLongClickListener = l;
Winson Chung86f77532010-08-24 11:08:22 -0700301 final int count = getPageCount();
Winson Chung321e9ee2010-08-09 13:37:56 -0700302 for (int i = 0; i < count; i++) {
Winson Chung86f77532010-08-24 11:08:22 -0700303 getPageAt(i).setOnLongClickListener(l);
Winson Chung321e9ee2010-08-09 13:37:56 -0700304 }
305 }
306
307 @Override
Adam Cohen68d73932010-11-15 10:50:58 -0800308 public void scrollBy(int x, int y) {
309 scrollTo(mUnboundedScrollX + x, mScrollY + y);
310 }
311
312 @Override
Michael Jurka0142d492010-08-25 17:46:15 -0700313 public void scrollTo(int x, int y) {
Adam Cohen68d73932010-11-15 10:50:58 -0800314 mUnboundedScrollX = x;
315
316 if (x < 0) {
317 super.scrollTo(0, y);
318 if (mAllowOverScroll) {
319 overScroll(x);
320 }
321 } else if (x > mMaxScrollX) {
322 super.scrollTo(mMaxScrollX, y);
323 if (mAllowOverScroll) {
324 overScroll(x - mMaxScrollX);
325 }
326 } else {
327 super.scrollTo(x, y);
328 }
329
Michael Jurka0142d492010-08-25 17:46:15 -0700330 mTouchX = x;
331 mSmoothingTime = System.nanoTime() / NANOTIME_DIV;
332 }
333
334 // we moved this functionality to a helper function so SmoothPagedView can reuse it
335 protected boolean computeScrollHelper() {
Winson Chung321e9ee2010-08-09 13:37:56 -0700336 if (mScroller.computeScrollOffset()) {
Michael Jurka5f1c5092010-09-03 14:15:02 -0700337 mDirtyPageAlpha = true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700338 scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
Michael Jurka0142d492010-08-25 17:46:15 -0700339 invalidate();
340 return true;
Winson Chung86f77532010-08-24 11:08:22 -0700341 } else if (mNextPage != INVALID_PAGE) {
Michael Jurka5f1c5092010-09-03 14:15:02 -0700342 mDirtyPageAlpha = true;
Winson Chung86f77532010-08-24 11:08:22 -0700343 mCurrentPage = Math.max(0, Math.min(mNextPage, getPageCount() - 1));
Winson Chung86f77532010-08-24 11:08:22 -0700344 mNextPage = INVALID_PAGE;
Michael Jurka0142d492010-08-25 17:46:15 -0700345 notifyPageSwitchListener();
Adam Cohen73aa9752010-11-24 16:26:58 -0800346 // We don't want to trigger a page end moving unless the page has settled
347 // and the user has stopped scrolling
348 if (mTouchState == TOUCH_STATE_REST) {
349 pageEndMoving();
350 }
Michael Jurka0142d492010-08-25 17:46:15 -0700351 return true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700352 }
Michael Jurka0142d492010-08-25 17:46:15 -0700353 return false;
354 }
355
356 @Override
357 public void computeScroll() {
358 computeScrollHelper();
Winson Chung321e9ee2010-08-09 13:37:56 -0700359 }
360
361 @Override
362 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
363 final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
364 final int widthSize = MeasureSpec.getSize(widthMeasureSpec);
365 if (widthMode != MeasureSpec.EXACTLY) {
366 throw new IllegalStateException("Workspace can only be used in EXACTLY mode.");
367 }
368
Adam Lesinski6b879f02010-11-04 16:15:23 -0700369 /* Allow the height to be set as WRAP_CONTENT. This allows the particular case
370 * of the All apps view on XLarge displays to not take up more space then it needs. Width
371 * is still not allowed to be set as WRAP_CONTENT since many parts of the code expect
372 * each page to have the same width.
373 */
Winson Chung321e9ee2010-08-09 13:37:56 -0700374 final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
Adam Lesinski6b879f02010-11-04 16:15:23 -0700375 int heightSize = MeasureSpec.getSize(heightMeasureSpec);
376 int maxChildHeight = 0;
377
378 final int verticalPadding = mPaddingTop + mPaddingBottom;
Winson Chung321e9ee2010-08-09 13:37:56 -0700379
380 // The children are given the same width and height as the workspace
Michael Jurka5f1c5092010-09-03 14:15:02 -0700381 // unless they were set to WRAP_CONTENT
Winson Chung321e9ee2010-08-09 13:37:56 -0700382 final int childCount = getChildCount();
383 for (int i = 0; i < childCount; i++) {
Michael Jurka5f1c5092010-09-03 14:15:02 -0700384 // disallowing padding in paged view (just pass 0)
385 final View child = getChildAt(i);
386 final LayoutParams lp = (LayoutParams) child.getLayoutParams();
387
388 int childWidthMode;
389 if (lp.width == LayoutParams.WRAP_CONTENT) {
390 childWidthMode = MeasureSpec.AT_MOST;
391 } else {
392 childWidthMode = MeasureSpec.EXACTLY;
393 }
394
395 int childHeightMode;
396 if (lp.height == LayoutParams.WRAP_CONTENT) {
397 childHeightMode = MeasureSpec.AT_MOST;
398 } else {
399 childHeightMode = MeasureSpec.EXACTLY;
400 }
401
402 final int childWidthMeasureSpec =
403 MeasureSpec.makeMeasureSpec(widthSize, childWidthMode);
404 final int childHeightMeasureSpec =
Adam Lesinski6b879f02010-11-04 16:15:23 -0700405 MeasureSpec.makeMeasureSpec(heightSize - verticalPadding, childHeightMode);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700406
407 child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
Adam Lesinski6b879f02010-11-04 16:15:23 -0700408 maxChildHeight = Math.max(maxChildHeight, child.getMeasuredHeight());
409 }
410
411 if (heightMode == MeasureSpec.AT_MOST) {
412 heightSize = maxChildHeight + verticalPadding;
Winson Chung321e9ee2010-08-09 13:37:56 -0700413 }
Adam Cohenfaa28302010-11-19 12:02:18 -0800414 if (childCount > 0) {
415 mMaxScrollX = getChildOffset(childCount - 1) - getRelativeChildOffset(childCount - 1);
416 } else {
417 mMaxScrollX = 0;
418 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700419
420 setMeasuredDimension(widthSize, heightSize);
Winson Chung321e9ee2010-08-09 13:37:56 -0700421 }
422
Michael Jurkaaf91de02010-11-23 16:23:58 -0800423 protected void moveToNewPageWithoutMovingCellLayouts(int newCurrentPage) {
424 int newX = getChildOffset(newCurrentPage) - getRelativeChildOffset(newCurrentPage);
425 int delta = newX - mScrollX;
426
427 final int screenCount = getChildCount();
428 for (int i = 0; i < screenCount; i++) {
429 CellLayout cl = (CellLayout) getChildAt(i);
430 cl.setX(cl.getX() + delta);
431 }
432 setCurrentPage(newCurrentPage);
433 }
434
Michael Jurkad3ef3062010-11-23 16:23:58 -0800435 // A layout scale of 1.0f assumes that the CellLayouts, in their unshrunken state, have a
436 // scale of 1.0f. A layout scale of 0.8f assumes the CellLayouts have a scale of 0.8f, and
437 // tightens the layout accordingly
438 public void setLayoutScale(float childrenScale) {
439 mLayoutScale = childrenScale;
440
441 // Now we need to do a re-layout, but preserving absolute X and Y coordinates
442 int childCount = getChildCount();
443 float childrenX[] = new float[childCount];
444 float childrenY[] = new float[childCount];
445 for (int i = 0; i < childCount; i++) {
446 final View child = getChildAt(i);
447 childrenX[i] = child.getX();
448 childrenY[i] = child.getY();
449 }
450 onLayout(false, mLeft, mTop, mRight, mBottom);
451 for (int i = 0; i < childCount; i++) {
452 final View child = getChildAt(i);
453 child.setX(childrenX[i]);
454 child.setY(childrenY[i]);
455 }
456 // Also, the page offset has changed (since the pages are now smaller);
457 // update the page offset, but again preserving absolute X and Y coordinates
458 moveToNewPageWithoutMovingCellLayouts(mCurrentPage);
459 }
460
Winson Chung321e9ee2010-08-09 13:37:56 -0700461 @Override
Michael Jurka28750fb2010-09-24 17:43:49 -0700462 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
Michael Jurkacfc62942010-09-14 14:01:07 -0700463 if (mFirstLayout && mCurrentPage >= 0 && mCurrentPage < getChildCount()) {
464 setHorizontalScrollBarEnabled(false);
465 int newX = getChildOffset(mCurrentPage) - getRelativeChildOffset(mCurrentPage);
466 scrollTo(newX, 0);
467 mScroller.setFinalX(newX);
468 setHorizontalScrollBarEnabled(true);
469 mFirstLayout = false;
470 }
471
Adam Lesinski6b879f02010-11-04 16:15:23 -0700472 final int verticalPadding = mPaddingTop + mPaddingBottom;
Winson Chung321e9ee2010-08-09 13:37:56 -0700473 final int childCount = getChildCount();
474 int childLeft = 0;
475 if (childCount > 0) {
Winson Chunge3193b92010-09-10 11:44:42 -0700476 childLeft = getRelativeChildOffset(0);
Winson Chung321e9ee2010-08-09 13:37:56 -0700477 }
478
479 for (int i = 0; i < childCount; i++) {
480 final View child = getChildAt(i);
481 if (child.getVisibility() != View.GONE) {
Michael Jurkad3ef3062010-11-23 16:23:58 -0800482 final int childWidth = getScaledMeasuredWidth(child);
Adam Lesinski6b879f02010-11-04 16:15:23 -0700483 final int childHeight = child.getMeasuredHeight();
484 int childTop = mPaddingTop;
485 if (mCenterPagesVertically) {
486 childTop += ((getMeasuredHeight() - verticalPadding) - childHeight) / 2;
487 }
Michael Jurkad3ef3062010-11-23 16:23:58 -0800488
Adam Lesinski6b879f02010-11-04 16:15:23 -0700489 child.layout(childLeft, childTop,
Michael Jurkad3ef3062010-11-23 16:23:58 -0800490 childLeft + child.getMeasuredWidth(), childTop + childHeight);
Adam Cohen9c4949e2010-10-05 12:27:22 -0700491 childLeft += childWidth + mPageSpacing;
Winson Chung321e9ee2010-08-09 13:37:56 -0700492 }
493 }
Michael Jurkad3ef3062010-11-23 16:23:58 -0800494 if (mFirstLayout && mCurrentPage >= 0 && mCurrentPage < getChildCount()) {
495 mFirstLayout = false;
496 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700497 }
498
Winson Chunge3193b92010-09-10 11:44:42 -0700499 protected void updateAdjacentPagesAlpha() {
Michael Jurka0142d492010-08-25 17:46:15 -0700500 if (mFadeInAdjacentScreens) {
501 if (mDirtyPageAlpha || (mTouchState == TOUCH_STATE_SCROLLING) || !mScroller.isFinished()) {
Winson Chunge3193b92010-09-10 11:44:42 -0700502 int halfScreenSize = getMeasuredWidth() / 2;
503 int screenCenter = mScrollX + halfScreenSize;
Michael Jurka0142d492010-08-25 17:46:15 -0700504 final int childCount = getChildCount();
505 for (int i = 0; i < childCount; ++i) {
506 View layout = (View) getChildAt(i);
Michael Jurkad3ef3062010-11-23 16:23:58 -0800507 int childWidth = getScaledMeasuredWidth(layout);
Michael Jurka0142d492010-08-25 17:46:15 -0700508 int halfChildWidth = (childWidth / 2);
509 int childCenter = getChildOffset(i) + halfChildWidth;
Winson Chunge8878e32010-09-15 20:37:09 -0700510
Winson Chungb0b2e6f2010-10-12 17:49:56 -0700511 // On the first layout, we may not have a width nor a proper offset, so for now
512 // we should just assume full page width (and calculate the offset according to
513 // that).
514 if (childWidth <= 0) {
515 childWidth = getMeasuredWidth();
516 childCenter = (i * childWidth) + (childWidth / 2);
517 }
518
Winson Chunge8878e32010-09-15 20:37:09 -0700519 int d = halfChildWidth;
520 int distanceFromScreenCenter = childCenter - screenCenter;
521 if (distanceFromScreenCenter > 0) {
522 if (i > 0) {
Michael Jurkad3ef3062010-11-23 16:23:58 -0800523 d += getScaledMeasuredWidth(getChildAt(i - 1)) / 2;
Winson Chunge8878e32010-09-15 20:37:09 -0700524 }
Michael Jurka0142d492010-08-25 17:46:15 -0700525 } else {
Winson Chunge8878e32010-09-15 20:37:09 -0700526 if (i < childCount - 1) {
Michael Jurkad3ef3062010-11-23 16:23:58 -0800527 d += getScaledMeasuredWidth(getChildAt(i + 1)) / 2;
Winson Chunge8878e32010-09-15 20:37:09 -0700528 }
Michael Jurka0142d492010-08-25 17:46:15 -0700529 }
Adam Cohen9c4949e2010-10-05 12:27:22 -0700530 d += mPageSpacing;
Winson Chunge8878e32010-09-15 20:37:09 -0700531
Winson Chungb0b2e6f2010-10-12 17:49:56 -0700532 // Preventing potential divide-by-zero
533 d = Math.max(1, d);
534
Winson Chunge8878e32010-09-15 20:37:09 -0700535 float dimAlpha = (float) (Math.abs(distanceFromScreenCenter)) / d;
536 dimAlpha = Math.max(0.0f, Math.min(1.0f, (dimAlpha * dimAlpha)));
537 float alpha = 1.0f - dimAlpha;
538
Adam Cohenf34bab52010-09-30 14:11:56 -0700539 if (alpha < ALPHA_QUANTIZE_LEVEL) {
540 alpha = 0.0f;
541 } else if (alpha > 1.0f - ALPHA_QUANTIZE_LEVEL) {
542 alpha = 1.0f;
543 }
544
Michael Jurka0142d492010-08-25 17:46:15 -0700545 if (Float.compare(alpha, layout.getAlpha()) != 0) {
546 layout.setAlpha(alpha);
547 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700548 }
Michael Jurka0142d492010-08-25 17:46:15 -0700549 mDirtyPageAlpha = false;
Winson Chung321e9ee2010-08-09 13:37:56 -0700550 }
551 }
Winson Chunge3193b92010-09-10 11:44:42 -0700552 }
553
Adam Cohenf34bab52010-09-30 14:11:56 -0700554 protected void screenScrolled(int screenCenter) {
555 }
556
Winson Chunge3193b92010-09-10 11:44:42 -0700557 @Override
558 protected void dispatchDraw(Canvas canvas) {
Adam Cohenf34bab52010-09-30 14:11:56 -0700559 int halfScreenSize = getMeasuredWidth() / 2;
560 int screenCenter = mScrollX + halfScreenSize;
561
562 if (screenCenter != mLastScreenCenter) {
563 screenScrolled(screenCenter);
564 updateAdjacentPagesAlpha();
565 mLastScreenCenter = screenCenter;
566 }
Michael Jurka0142d492010-08-25 17:46:15 -0700567
568 // Find out which screens are visible; as an optimization we only call draw on them
Michael Jurka0142d492010-08-25 17:46:15 -0700569 // As an optimization, this code assumes that all pages have the same width as the 0th
570 // page.
Michael Jurka0142d492010-08-25 17:46:15 -0700571 final int pageCount = getChildCount();
Michael Jurkac4fb9172010-09-02 17:19:20 -0700572 if (pageCount > 0) {
Michael Jurkad3ef3062010-11-23 16:23:58 -0800573 final int pageWidth = getScaledMeasuredWidth(getChildAt(0));
Michael Jurkac4fb9172010-09-02 17:19:20 -0700574 final int screenWidth = getMeasuredWidth();
575 int x = getRelativeChildOffset(0) + pageWidth;
576 int leftScreen = 0;
577 int rightScreen = 0;
578 while (x <= mScrollX) {
579 leftScreen++;
Winson Chungc3f9f4f2010-12-14 17:25:59 -0800580 x += getScaledMeasuredWidth(getChildAt(leftScreen)) + mPageSpacing;
Michael Jurkac4fb9172010-09-02 17:19:20 -0700581 }
582 rightScreen = leftScreen;
Winson Chungc3f9f4f2010-12-14 17:25:59 -0800583 while (x < mScrollX + screenWidth && rightScreen < pageCount) {
Michael Jurkac4fb9172010-09-02 17:19:20 -0700584 rightScreen++;
Winson Chungc3f9f4f2010-12-14 17:25:59 -0800585 if (rightScreen < pageCount) {
586 x += getScaledMeasuredWidth(getChildAt(rightScreen)) + mPageSpacing;
587 }
Michael Jurkac4fb9172010-09-02 17:19:20 -0700588 }
589 rightScreen = Math.min(getChildCount() - 1, rightScreen);
Michael Jurka0142d492010-08-25 17:46:15 -0700590
Michael Jurkac4fb9172010-09-02 17:19:20 -0700591 final long drawingTime = getDrawingTime();
Winson Chung29d6fea2010-12-01 15:47:31 -0800592 // Clip to the bounds
593 canvas.save();
594 canvas.clipRect(mScrollX, mScrollY, mScrollX + mRight - mLeft,
595 mScrollY + mBottom - mTop);
596
Michael Jurkac4fb9172010-09-02 17:19:20 -0700597 for (int i = leftScreen; i <= rightScreen; i++) {
598 drawChild(canvas, getChildAt(i), drawingTime);
599 }
Winson Chung29d6fea2010-12-01 15:47:31 -0800600 canvas.restore();
Michael Jurka0142d492010-08-25 17:46:15 -0700601 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700602 }
603
604 @Override
605 public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
Winson Chung86f77532010-08-24 11:08:22 -0700606 int page = indexOfChild(child);
607 if (page != mCurrentPage || !mScroller.isFinished()) {
608 snapToPage(page);
Winson Chung321e9ee2010-08-09 13:37:56 -0700609 return true;
610 }
611 return false;
612 }
613
614 @Override
615 protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
Winson Chung86f77532010-08-24 11:08:22 -0700616 int focusablePage;
617 if (mNextPage != INVALID_PAGE) {
618 focusablePage = mNextPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700619 } else {
Winson Chung86f77532010-08-24 11:08:22 -0700620 focusablePage = mCurrentPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700621 }
Winson Chung86f77532010-08-24 11:08:22 -0700622 View v = getPageAt(focusablePage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700623 if (v != null) {
624 v.requestFocus(direction, previouslyFocusedRect);
625 }
626 return false;
627 }
628
629 @Override
630 public boolean dispatchUnhandledMove(View focused, int direction) {
631 if (direction == View.FOCUS_LEFT) {
Winson Chung86f77532010-08-24 11:08:22 -0700632 if (getCurrentPage() > 0) {
633 snapToPage(getCurrentPage() - 1);
Winson Chung321e9ee2010-08-09 13:37:56 -0700634 return true;
635 }
636 } else if (direction == View.FOCUS_RIGHT) {
Winson Chung86f77532010-08-24 11:08:22 -0700637 if (getCurrentPage() < getPageCount() - 1) {
638 snapToPage(getCurrentPage() + 1);
Winson Chung321e9ee2010-08-09 13:37:56 -0700639 return true;
640 }
641 }
642 return super.dispatchUnhandledMove(focused, direction);
643 }
644
645 @Override
646 public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
Winson Chung86f77532010-08-24 11:08:22 -0700647 if (mCurrentPage >= 0 && mCurrentPage < getPageCount()) {
648 getPageAt(mCurrentPage).addFocusables(views, direction);
Winson Chung321e9ee2010-08-09 13:37:56 -0700649 }
650 if (direction == View.FOCUS_LEFT) {
Winson Chung86f77532010-08-24 11:08:22 -0700651 if (mCurrentPage > 0) {
652 getPageAt(mCurrentPage - 1).addFocusables(views, direction);
Winson Chung321e9ee2010-08-09 13:37:56 -0700653 }
654 } else if (direction == View.FOCUS_RIGHT){
Winson Chung86f77532010-08-24 11:08:22 -0700655 if (mCurrentPage < getPageCount() - 1) {
656 getPageAt(mCurrentPage + 1).addFocusables(views, direction);
Winson Chung321e9ee2010-08-09 13:37:56 -0700657 }
658 }
659 }
660
661 /**
662 * If one of our descendant views decides that it could be focused now, only
Winson Chung86f77532010-08-24 11:08:22 -0700663 * pass that along if it's on the current page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700664 *
Winson Chung86f77532010-08-24 11:08:22 -0700665 * This happens when live folders requery, and if they're off page, they
666 * end up calling requestFocus, which pulls it on page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700667 */
668 @Override
669 public void focusableViewAvailable(View focused) {
Winson Chung86f77532010-08-24 11:08:22 -0700670 View current = getPageAt(mCurrentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700671 View v = focused;
672 while (true) {
673 if (v == current) {
674 super.focusableViewAvailable(focused);
675 return;
676 }
677 if (v == this) {
678 return;
679 }
680 ViewParent parent = v.getParent();
681 if (parent instanceof View) {
682 v = (View)v.getParent();
683 } else {
684 return;
685 }
686 }
687 }
688
689 /**
690 * {@inheritDoc}
691 */
692 @Override
693 public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
694 if (disallowIntercept) {
695 // We need to make sure to cancel our long press if
696 // a scrollable widget takes over touch events
Winson Chung86f77532010-08-24 11:08:22 -0700697 final View currentPage = getChildAt(mCurrentPage);
698 currentPage.cancelLongPress();
Winson Chung321e9ee2010-08-09 13:37:56 -0700699 }
700 super.requestDisallowInterceptTouchEvent(disallowIntercept);
701 }
702
703 @Override
704 public boolean onInterceptTouchEvent(MotionEvent ev) {
705 /*
706 * This method JUST determines whether we want to intercept the motion.
707 * If we return true, onTouchEvent will be called and we do the actual
708 * scrolling there.
709 */
710
Winson Chung45e1d6e2010-11-09 17:19:49 -0800711 // Skip touch handling if there are no pages to swipe
712 if (getChildCount() <= 0) return super.onInterceptTouchEvent(ev);
713
Winson Chung321e9ee2010-08-09 13:37:56 -0700714 /*
715 * Shortcut the most recurring case: the user is in the dragging
716 * state and he is moving his finger. We want to intercept this
717 * motion.
718 */
719 final int action = ev.getAction();
720 if ((action == MotionEvent.ACTION_MOVE) &&
721 (mTouchState == TOUCH_STATE_SCROLLING)) {
722 return true;
723 }
724
Winson Chung321e9ee2010-08-09 13:37:56 -0700725 switch (action & MotionEvent.ACTION_MASK) {
726 case MotionEvent.ACTION_MOVE: {
727 /*
728 * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check
729 * whether the user has moved far enough from his original down touch.
730 */
Michael Jurka1ff706b2010-09-14 17:35:20 -0700731 if (mActivePointerId != INVALID_POINTER) {
732 determineScrollingStart(ev);
733 break;
734 }
735 // if mActivePointerId is INVALID_POINTER, then we must have missed an ACTION_DOWN
736 // event. in that case, treat the first occurence of a move event as a ACTION_DOWN
737 // i.e. fall through to the next case (don't break)
738 // (We sometimes miss ACTION_DOWN events in Workspace because it ignores all events
739 // while it's small- this was causing a crash before we checked for INVALID_POINTER)
Winson Chung321e9ee2010-08-09 13:37:56 -0700740 }
741
742 case MotionEvent.ACTION_DOWN: {
743 final float x = ev.getX();
744 final float y = ev.getY();
745 // Remember location of down touch
746 mDownMotionX = x;
747 mLastMotionX = x;
748 mLastMotionY = y;
749 mActivePointerId = ev.getPointerId(0);
750 mAllowLongPress = true;
751
752 /*
753 * If being flinged and user touches the screen, initiate drag;
754 * otherwise don't. mScroller.isFinished should be false when
755 * being flinged.
756 */
Michael Jurkafd177c12010-10-19 15:50:43 -0700757 final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX());
Winson Chung5f2aa4e2010-08-20 14:49:25 -0700758 final boolean finishedScrolling = (mScroller.isFinished() || xDist < mTouchSlop);
759 if (finishedScrolling) {
760 mTouchState = TOUCH_STATE_REST;
761 mScroller.abortAnimation();
762 } else {
763 mTouchState = TOUCH_STATE_SCROLLING;
764 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700765
Winson Chung86f77532010-08-24 11:08:22 -0700766 // check if this can be the beginning of a tap on the side of the pages
Winson Chung321e9ee2010-08-09 13:37:56 -0700767 // to scroll the current page
Adam Cohen21f12b52010-10-07 17:15:37 -0700768 if ((mTouchState != TOUCH_STATE_PREV_PAGE) && !handlePagingClicks() &&
Winson Chung321e9ee2010-08-09 13:37:56 -0700769 (mTouchState != TOUCH_STATE_NEXT_PAGE)) {
770 if (getChildCount() > 0) {
Winson Chunge3193b92010-09-10 11:44:42 -0700771 int width = getMeasuredWidth();
772 int offset = getRelativeChildOffset(mCurrentPage);
Adam Cohen21f12b52010-10-07 17:15:37 -0700773 if (x < offset - mPageSpacing) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700774 mTouchState = TOUCH_STATE_PREV_PAGE;
Adam Cohen21f12b52010-10-07 17:15:37 -0700775 } else if (x > (width - offset + mPageSpacing)) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700776 mTouchState = TOUCH_STATE_NEXT_PAGE;
777 }
778 }
779 }
780 break;
781 }
782
Winson Chung321e9ee2010-08-09 13:37:56 -0700783 case MotionEvent.ACTION_UP:
Jeff Brown1d0867c2010-12-02 18:27:39 -0800784 onWallpaperTap(ev);
785 case MotionEvent.ACTION_CANCEL:
Winson Chung321e9ee2010-08-09 13:37:56 -0700786 mTouchState = TOUCH_STATE_REST;
787 mAllowLongPress = false;
788 mActivePointerId = INVALID_POINTER;
Winson Chung321e9ee2010-08-09 13:37:56 -0700789 break;
790
791 case MotionEvent.ACTION_POINTER_UP:
792 onSecondaryPointerUp(ev);
793 break;
794 }
795
796 /*
797 * The only time we want to intercept motion events is if we are in the
798 * drag mode.
799 */
800 return mTouchState != TOUCH_STATE_REST;
801 }
802
Winson Chung80baf5a2010-08-09 16:03:15 -0700803 protected void animateClickFeedback(View v, final Runnable r) {
804 // animate the view slightly to show click feedback running some logic after it is "pressed"
805 Animation anim = AnimationUtils.loadAnimation(getContext(),
806 R.anim.paged_view_click_feedback);
807 anim.setAnimationListener(new AnimationListener() {
808 @Override
809 public void onAnimationStart(Animation animation) {}
810 @Override
811 public void onAnimationRepeat(Animation animation) {
812 r.run();
813 }
814 @Override
815 public void onAnimationEnd(Animation animation) {}
816 });
817 v.startAnimation(anim);
818 }
819
Winson Chung321e9ee2010-08-09 13:37:56 -0700820 /*
821 * Determines if we should change the touch state to start scrolling after the
822 * user moves their touch point too far.
823 */
Michael Jurka1adf5392010-10-18 18:10:22 -0700824 protected void determineScrollingStart(MotionEvent ev) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700825 /*
826 * Locally do absolute value. mLastMotionX is set to the y value
827 * of the down event.
828 */
829 final int pointerIndex = ev.findPointerIndex(mActivePointerId);
830 final float x = ev.getX(pointerIndex);
831 final float y = ev.getY(pointerIndex);
832 final int xDiff = (int) Math.abs(x - mLastMotionX);
833 final int yDiff = (int) Math.abs(y - mLastMotionY);
834
835 final int touchSlop = mTouchSlop;
836 boolean xPaged = xDiff > mPagingTouchSlop;
837 boolean xMoved = xDiff > touchSlop;
838 boolean yMoved = yDiff > touchSlop;
839
840 if (xMoved || yMoved) {
Michael Jurka0142d492010-08-25 17:46:15 -0700841 if (mUsePagingTouchSlop ? xPaged : xMoved) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700842 // Scroll if the user moved far enough along the X axis
843 mTouchState = TOUCH_STATE_SCROLLING;
844 mLastMotionX = x;
Michael Jurka0142d492010-08-25 17:46:15 -0700845 mTouchX = mScrollX;
846 mSmoothingTime = System.nanoTime() / NANOTIME_DIV;
847 pageBeginMoving();
Winson Chung321e9ee2010-08-09 13:37:56 -0700848 }
849 // Either way, cancel any pending longpress
850 if (mAllowLongPress) {
851 mAllowLongPress = false;
852 // Try canceling the long press. It could also have been scheduled
853 // by a distant descendant, so use the mAllowLongPress flag to block
854 // everything
Winson Chung86f77532010-08-24 11:08:22 -0700855 final View currentPage = getPageAt(mCurrentPage);
Winson Chung10fefb12010-11-01 11:57:06 -0700856 if (currentPage != null) {
857 currentPage.cancelLongPress();
858 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700859 }
860 }
861 }
862
Adam Cohen21f12b52010-10-07 17:15:37 -0700863 protected boolean handlePagingClicks() {
864 return false;
865 }
866
Adam Cohene0f66b52010-11-23 15:06:07 -0800867 // This curve determines how the effect of scrolling over the limits of the page dimishes
868 // as the user pulls further and further from the bounds
869 private float overScrollInfluenceCurve(float f) {
870 f -= 1.0f;
871 return f * f * f + 1.0f;
872 }
873
Adam Cohen68d73932010-11-15 10:50:58 -0800874 protected void overScroll(float amount) {
Adam Cohene0f66b52010-11-23 15:06:07 -0800875 int screenSize = getMeasuredWidth();
876
877 float f = (amount / screenSize);
878
879 if (f == 0) return;
880 f = f / (Math.abs(f)) * (overScrollInfluenceCurve(Math.abs(f)));
881
882 int overScrollAmount = (int) Math.round(OVERSCROLL_DAMP_FACTOR * f * screenSize);
Adam Cohen68d73932010-11-15 10:50:58 -0800883 if (amount < 0) {
884 mScrollX = overScrollAmount;
885 } else {
886 mScrollX = mMaxScrollX + overScrollAmount;
887 }
888 invalidate();
889 }
890
Winson Chung321e9ee2010-08-09 13:37:56 -0700891 @Override
892 public boolean onTouchEvent(MotionEvent ev) {
Winson Chung45e1d6e2010-11-09 17:19:49 -0800893 // Skip touch handling if there are no pages to swipe
894 if (getChildCount() <= 0) return super.onTouchEvent(ev);
895
Michael Jurkab8f06722010-10-10 15:58:46 -0700896 acquireVelocityTrackerAndAddMovement(ev);
Winson Chung321e9ee2010-08-09 13:37:56 -0700897
898 final int action = ev.getAction();
899
900 switch (action & MotionEvent.ACTION_MASK) {
901 case MotionEvent.ACTION_DOWN:
902 /*
903 * If being flinged and user touches, stop the fling. isFinished
904 * will be false if being flinged.
905 */
906 if (!mScroller.isFinished()) {
907 mScroller.abortAnimation();
908 }
909
910 // Remember where the motion event started
911 mDownMotionX = mLastMotionX = ev.getX();
912 mActivePointerId = ev.getPointerId(0);
Michael Jurka0142d492010-08-25 17:46:15 -0700913 if (mTouchState == TOUCH_STATE_SCROLLING) {
914 pageBeginMoving();
915 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700916 break;
917
918 case MotionEvent.ACTION_MOVE:
919 if (mTouchState == TOUCH_STATE_SCROLLING) {
920 // Scroll to follow the motion event
921 final int pointerIndex = ev.findPointerIndex(mActivePointerId);
922 final float x = ev.getX(pointerIndex);
923 final int deltaX = (int) (mLastMotionX - x);
924 mLastMotionX = x;
925
Adam Cohen68d73932010-11-15 10:50:58 -0800926 if (deltaX != 0) {
927 mTouchX += deltaX;
928 mSmoothingTime = System.nanoTime() / NANOTIME_DIV;
929 if (!mDeferScrollUpdate) {
930 scrollBy(deltaX, 0);
931 } else {
932 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -0700933 }
934 } else {
935 awakenScrollBars();
936 }
Adam Cohen564976a2010-10-13 18:52:07 -0700937 } else {
Winson Chung321e9ee2010-08-09 13:37:56 -0700938 determineScrollingStart(ev);
939 }
940 break;
941
942 case MotionEvent.ACTION_UP:
943 if (mTouchState == TOUCH_STATE_SCROLLING) {
944 final int activePointerId = mActivePointerId;
945 final int pointerIndex = ev.findPointerIndex(activePointerId);
946 final float x = ev.getX(pointerIndex);
947 final VelocityTracker velocityTracker = mVelocityTracker;
948 velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
949 int velocityX = (int) velocityTracker.getXVelocity(activePointerId);
Winson Chung9cfd25f2010-10-24 16:09:28 -0700950 final int deltaX = (int) (x - mDownMotionX);
951 boolean isfling = Math.abs(deltaX) > MIN_LENGTH_FOR_FLING;
952 boolean isSignificantMove = Math.abs(deltaX) > MIN_LENGTH_FOR_MOVE;
Winson Chung321e9ee2010-08-09 13:37:56 -0700953
Michael Jurka0142d492010-08-25 17:46:15 -0700954 final int snapVelocity = mSnapVelocity;
Winson Chung9cfd25f2010-10-24 16:09:28 -0700955 if ((isSignificantMove && deltaX > 0 ||
Adam Cohene0f66b52010-11-23 15:06:07 -0800956 (isfling && velocityX > snapVelocity)) && mCurrentPage > 0) {
Michael Jurka0142d492010-08-25 17:46:15 -0700957 snapToPageWithVelocity(mCurrentPage - 1, velocityX);
Winson Chung9cfd25f2010-10-24 16:09:28 -0700958 } else if ((isSignificantMove && deltaX < 0 ||
959 (isfling && velocityX < -snapVelocity)) &&
Winson Chung86f77532010-08-24 11:08:22 -0700960 mCurrentPage < getChildCount() - 1) {
Michael Jurka0142d492010-08-25 17:46:15 -0700961 snapToPageWithVelocity(mCurrentPage + 1, velocityX);
Winson Chung321e9ee2010-08-09 13:37:56 -0700962 } else {
963 snapToDestination();
964 }
Adam Cohen21f12b52010-10-07 17:15:37 -0700965 } else if (mTouchState == TOUCH_STATE_PREV_PAGE && !handlePagingClicks()) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700966 // at this point we have not moved beyond the touch slop
967 // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so
968 // we can just page
Winson Chung86f77532010-08-24 11:08:22 -0700969 int nextPage = Math.max(0, mCurrentPage - 1);
970 if (nextPage != mCurrentPage) {
971 snapToPage(nextPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700972 } else {
973 snapToDestination();
974 }
Adam Cohen21f12b52010-10-07 17:15:37 -0700975 } else if (mTouchState == TOUCH_STATE_NEXT_PAGE && !handlePagingClicks()) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700976 // at this point we have not moved beyond the touch slop
977 // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so
978 // we can just page
Winson Chung86f77532010-08-24 11:08:22 -0700979 int nextPage = Math.min(getChildCount() - 1, mCurrentPage + 1);
980 if (nextPage != mCurrentPage) {
981 snapToPage(nextPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700982 } else {
983 snapToDestination();
984 }
Jeff Brown1d0867c2010-12-02 18:27:39 -0800985 } else {
986 onWallpaperTap(ev);
Winson Chung321e9ee2010-08-09 13:37:56 -0700987 }
988 mTouchState = TOUCH_STATE_REST;
989 mActivePointerId = INVALID_POINTER;
Michael Jurkab8f06722010-10-10 15:58:46 -0700990 releaseVelocityTracker();
Winson Chung321e9ee2010-08-09 13:37:56 -0700991 break;
992
993 case MotionEvent.ACTION_CANCEL:
Michael Jurkab8f06722010-10-10 15:58:46 -0700994 if (mTouchState == TOUCH_STATE_SCROLLING) {
995 snapToDestination();
996 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700997 mTouchState = TOUCH_STATE_REST;
998 mActivePointerId = INVALID_POINTER;
Michael Jurkab8f06722010-10-10 15:58:46 -0700999 releaseVelocityTracker();
Winson Chung321e9ee2010-08-09 13:37:56 -07001000 break;
1001
1002 case MotionEvent.ACTION_POINTER_UP:
1003 onSecondaryPointerUp(ev);
1004 break;
1005 }
1006
1007 return true;
1008 }
1009
Michael Jurkab8f06722010-10-10 15:58:46 -07001010 private void acquireVelocityTrackerAndAddMovement(MotionEvent ev) {
1011 if (mVelocityTracker == null) {
1012 mVelocityTracker = VelocityTracker.obtain();
1013 }
1014 mVelocityTracker.addMovement(ev);
1015 }
1016
1017 private void releaseVelocityTracker() {
1018 if (mVelocityTracker != null) {
1019 mVelocityTracker.recycle();
1020 mVelocityTracker = null;
1021 }
1022 }
1023
Winson Chung321e9ee2010-08-09 13:37:56 -07001024 private void onSecondaryPointerUp(MotionEvent ev) {
1025 final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >>
1026 MotionEvent.ACTION_POINTER_INDEX_SHIFT;
1027 final int pointerId = ev.getPointerId(pointerIndex);
1028 if (pointerId == mActivePointerId) {
1029 // This was our active pointer going up. Choose a new
1030 // active pointer and adjust accordingly.
1031 // TODO: Make this decision more intelligent.
1032 final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
1033 mLastMotionX = mDownMotionX = ev.getX(newPointerIndex);
1034 mLastMotionY = ev.getY(newPointerIndex);
1035 mActivePointerId = ev.getPointerId(newPointerIndex);
1036 if (mVelocityTracker != null) {
1037 mVelocityTracker.clear();
1038 }
1039 }
Jeff Brown1d0867c2010-12-02 18:27:39 -08001040 if (mTouchState == TOUCH_STATE_REST) {
1041 onWallpaperTap(ev);
1042 }
1043 }
1044
1045 protected void onWallpaperTap(MotionEvent ev) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001046 }
1047
1048 @Override
1049 public void requestChildFocus(View child, View focused) {
1050 super.requestChildFocus(child, focused);
Winson Chung86f77532010-08-24 11:08:22 -07001051 int page = indexOfChild(child);
1052 if (page >= 0 && !isInTouchMode()) {
1053 snapToPage(page);
Winson Chung321e9ee2010-08-09 13:37:56 -07001054 }
1055 }
1056
Winson Chunge3193b92010-09-10 11:44:42 -07001057 protected int getChildIndexForRelativeOffset(int relativeOffset) {
1058 final int childCount = getChildCount();
Adam Cohen9c4949e2010-10-05 12:27:22 -07001059 int left;
1060 int right;
Winson Chunge3193b92010-09-10 11:44:42 -07001061 for (int i = 0; i < childCount; ++i) {
Adam Cohen9c4949e2010-10-05 12:27:22 -07001062 left = getRelativeChildOffset(i);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001063 right = (left + getScaledMeasuredWidth(getChildAt(i)));
Winson Chunge3193b92010-09-10 11:44:42 -07001064 if (left <= relativeOffset && relativeOffset <= right) {
1065 return i;
1066 }
Winson Chunge3193b92010-09-10 11:44:42 -07001067 }
1068 return -1;
1069 }
1070
Winson Chung321e9ee2010-08-09 13:37:56 -07001071 protected int getRelativeChildOffset(int index) {
1072 return (getMeasuredWidth() - getChildAt(index).getMeasuredWidth()) / 2;
1073 }
1074
1075 protected int getChildOffset(int index) {
1076 if (getChildCount() == 0)
1077 return 0;
1078
1079 int offset = getRelativeChildOffset(0);
1080 for (int i = 0; i < index; ++i) {
Michael Jurkad3ef3062010-11-23 16:23:58 -08001081 offset += getScaledMeasuredWidth(getChildAt(i)) + mPageSpacing;
Winson Chung321e9ee2010-08-09 13:37:56 -07001082 }
1083 return offset;
1084 }
1085
Michael Jurkad3ef3062010-11-23 16:23:58 -08001086 protected int getScaledMeasuredWidth(View child) {
1087 return (int) (child.getMeasuredWidth() * mLayoutScale + 0.5f);
1088 }
1089
Adam Cohend19d3ca2010-09-15 14:43:42 -07001090 int getPageNearestToCenterOfScreen() {
Winson Chung321e9ee2010-08-09 13:37:56 -07001091 int minDistanceFromScreenCenter = getMeasuredWidth();
1092 int minDistanceFromScreenCenterIndex = -1;
1093 int screenCenter = mScrollX + (getMeasuredWidth() / 2);
1094 final int childCount = getChildCount();
1095 for (int i = 0; i < childCount; ++i) {
Michael Jurka0142d492010-08-25 17:46:15 -07001096 View layout = (View) getChildAt(i);
Michael Jurkad3ef3062010-11-23 16:23:58 -08001097 int childWidth = getScaledMeasuredWidth(layout);
Winson Chung321e9ee2010-08-09 13:37:56 -07001098 int halfChildWidth = (childWidth / 2);
1099 int childCenter = getChildOffset(i) + halfChildWidth;
1100 int distanceFromScreenCenter = Math.abs(childCenter - screenCenter);
1101 if (distanceFromScreenCenter < minDistanceFromScreenCenter) {
1102 minDistanceFromScreenCenter = distanceFromScreenCenter;
1103 minDistanceFromScreenCenterIndex = i;
1104 }
1105 }
Adam Cohend19d3ca2010-09-15 14:43:42 -07001106 return minDistanceFromScreenCenterIndex;
1107 }
1108
1109 protected void snapToDestination() {
1110 snapToPage(getPageNearestToCenterOfScreen(), PAGE_SNAP_ANIMATION_DURATION);
Winson Chung321e9ee2010-08-09 13:37:56 -07001111 }
1112
Adam Cohene0f66b52010-11-23 15:06:07 -08001113 private static class ScrollInterpolator implements Interpolator {
1114 public ScrollInterpolator() {
1115 }
1116
1117 public float getInterpolation(float t) {
1118 t -= 1.0f;
1119 return t*t*t*t*t + 1;
1120 }
1121 }
1122
1123 // We want the duration of the page snap animation to be influenced by the distance that
1124 // the screen has to travel, however, we don't want this duration to be effected in a
1125 // purely linear fashion. Instead, we use this method to moderate the effect that the distance
1126 // of travel has on the overall snap duration.
1127 float distanceInfluenceForSnapDuration(float f) {
1128 f -= 0.5f; // center the values about 0.
1129 f *= 0.3f * Math.PI / 2.0f;
1130 return (float) Math.sin(f);
1131 }
1132
Michael Jurka0142d492010-08-25 17:46:15 -07001133 protected void snapToPageWithVelocity(int whichPage, int velocity) {
Adam Cohene0f66b52010-11-23 15:06:07 -08001134 whichPage = Math.max(0, Math.min(whichPage, getChildCount() - 1));
1135 int halfScreenSize = getMeasuredWidth() / 2;
1136
1137 final int newX = getChildOffset(whichPage) - getRelativeChildOffset(whichPage);
1138 int delta = newX - mUnboundedScrollX;
1139 int duration = 0;
1140
1141 if (Math.abs(velocity) < MIN_FLING_VELOCITY) {
1142 // If the velocity is low enough, then treat this more as an automatic page advance
1143 // as opposed to an apparent physical response to flinging
1144 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION);
1145 return;
1146 }
1147
1148 // Here we compute a "distance" that will be used in the computation of the overall
1149 // snap duration. This is a function of the actual distance that needs to be traveled;
1150 // we keep this value close to half screen size in order to reduce the variance in snap
1151 // duration as a function of the distance the page needs to travel.
1152 float distanceRatio = 1.0f * Math.abs(delta) / 2 * halfScreenSize;
1153 float distance = halfScreenSize + halfScreenSize *
1154 distanceInfluenceForSnapDuration(distanceRatio);
1155
1156 velocity = Math.abs(velocity);
1157 velocity = Math.max(MINIMUM_SNAP_VELOCITY, velocity);
1158
1159 // we want the page's snap velocity to approximately match the velocity at which the
1160 // user flings, so we scale the duration by a value near to the derivative of the scroll
1161 // interpolator at zero, ie. 5. We use 6 to make it a little slower.
1162 duration = 6 * Math.round(1000 * Math.abs(distance / velocity));
1163
1164 snapToPage(whichPage, delta, duration);
Michael Jurka0142d492010-08-25 17:46:15 -07001165 }
1166
1167 protected void snapToPage(int whichPage) {
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001168 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION);
Winson Chung321e9ee2010-08-09 13:37:56 -07001169 }
1170
Michael Jurka0142d492010-08-25 17:46:15 -07001171 protected void snapToPage(int whichPage, int duration) {
Winson Chung86f77532010-08-24 11:08:22 -07001172 whichPage = Math.max(0, Math.min(whichPage, getPageCount() - 1));
Winson Chung321e9ee2010-08-09 13:37:56 -07001173
Winson Chung86f77532010-08-24 11:08:22 -07001174 int newX = getChildOffset(whichPage) - getRelativeChildOffset(whichPage);
Adam Cohen68d73932010-11-15 10:50:58 -08001175 final int sX = mUnboundedScrollX;
Winson Chung321e9ee2010-08-09 13:37:56 -07001176 final int delta = newX - sX;
Michael Jurka0142d492010-08-25 17:46:15 -07001177 snapToPage(whichPage, delta, duration);
1178 }
1179
1180 protected void snapToPage(int whichPage, int delta, int duration) {
1181 mNextPage = whichPage;
1182
1183 View focusedChild = getFocusedChild();
1184 if (focusedChild != null && whichPage != mCurrentPage &&
1185 focusedChild == getChildAt(mCurrentPage)) {
1186 focusedChild.clearFocus();
1187 }
1188
1189 pageBeginMoving();
Winson Chung321e9ee2010-08-09 13:37:56 -07001190 awakenScrollBars(duration);
1191 if (duration == 0) {
1192 duration = Math.abs(delta);
1193 }
1194
1195 if (!mScroller.isFinished()) mScroller.abortAnimation();
Adam Cohen68d73932010-11-15 10:50:58 -08001196 mScroller.startScroll(mUnboundedScrollX, 0, delta, 0, duration);
Winson Chung80baf5a2010-08-09 16:03:15 -07001197
1198 // only load some associated pages
Winson Chung86f77532010-08-24 11:08:22 -07001199 loadAssociatedPages(mNextPage);
Michael Jurka0142d492010-08-25 17:46:15 -07001200 notifyPageSwitchListener();
Winson Chung321e9ee2010-08-09 13:37:56 -07001201 invalidate();
1202 }
1203
Winson Chung321e9ee2010-08-09 13:37:56 -07001204 public void scrollLeft() {
1205 if (mScroller.isFinished()) {
Winson Chung86f77532010-08-24 11:08:22 -07001206 if (mCurrentPage > 0) snapToPage(mCurrentPage - 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07001207 } else {
Winson Chung86f77532010-08-24 11:08:22 -07001208 if (mNextPage > 0) snapToPage(mNextPage - 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07001209 }
1210 }
1211
1212 public void scrollRight() {
1213 if (mScroller.isFinished()) {
Winson Chung86f77532010-08-24 11:08:22 -07001214 if (mCurrentPage < getChildCount() -1) snapToPage(mCurrentPage + 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07001215 } else {
Winson Chung86f77532010-08-24 11:08:22 -07001216 if (mNextPage < getChildCount() -1) snapToPage(mNextPage + 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07001217 }
1218 }
1219
Winson Chung86f77532010-08-24 11:08:22 -07001220 public int getPageForView(View v) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001221 int result = -1;
1222 if (v != null) {
1223 ViewParent vp = v.getParent();
1224 int count = getChildCount();
1225 for (int i = 0; i < count; i++) {
1226 if (vp == getChildAt(i)) {
1227 return i;
1228 }
1229 }
1230 }
1231 return result;
1232 }
1233
1234 /**
1235 * @return True is long presses are still allowed for the current touch
1236 */
1237 public boolean allowLongPress() {
1238 return mAllowLongPress;
1239 }
1240
Michael Jurka0142d492010-08-25 17:46:15 -07001241 /**
1242 * Set true to allow long-press events to be triggered, usually checked by
1243 * {@link Launcher} to accept or block dpad-initiated long-presses.
1244 */
1245 public void setAllowLongPress(boolean allowLongPress) {
1246 mAllowLongPress = allowLongPress;
1247 }
1248
Winson Chung321e9ee2010-08-09 13:37:56 -07001249 public static class SavedState extends BaseSavedState {
Winson Chung86f77532010-08-24 11:08:22 -07001250 int currentPage = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -07001251
1252 SavedState(Parcelable superState) {
1253 super(superState);
1254 }
1255
1256 private SavedState(Parcel in) {
1257 super(in);
Winson Chung86f77532010-08-24 11:08:22 -07001258 currentPage = in.readInt();
Winson Chung321e9ee2010-08-09 13:37:56 -07001259 }
1260
1261 @Override
1262 public void writeToParcel(Parcel out, int flags) {
1263 super.writeToParcel(out, flags);
Winson Chung86f77532010-08-24 11:08:22 -07001264 out.writeInt(currentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -07001265 }
1266
1267 public static final Parcelable.Creator<SavedState> CREATOR =
1268 new Parcelable.Creator<SavedState>() {
1269 public SavedState createFromParcel(Parcel in) {
1270 return new SavedState(in);
1271 }
1272
1273 public SavedState[] newArray(int size) {
1274 return new SavedState[size];
1275 }
1276 };
1277 }
1278
Winson Chung86f77532010-08-24 11:08:22 -07001279 public void loadAssociatedPages(int page) {
Michael Jurka0142d492010-08-25 17:46:15 -07001280 if (mContentIsRefreshable) {
1281 final int count = getChildCount();
1282 if (page < count) {
Winson Chunge3193b92010-09-10 11:44:42 -07001283 int lowerPageBound = getAssociatedLowerPageBound(page);
1284 int upperPageBound = getAssociatedUpperPageBound(page);
Michael Jurka0142d492010-08-25 17:46:15 -07001285 for (int i = 0; i < count; ++i) {
1286 final ViewGroup layout = (ViewGroup) getChildAt(i);
1287 final int childCount = layout.getChildCount();
1288 if (lowerPageBound <= i && i <= upperPageBound) {
1289 if (mDirtyPageContent.get(i)) {
1290 syncPageItems(i);
1291 mDirtyPageContent.set(i, false);
1292 }
1293 } else {
1294 if (childCount > 0) {
1295 layout.removeAllViews();
1296 }
1297 mDirtyPageContent.set(i, true);
Winson Chung86f77532010-08-24 11:08:22 -07001298 }
Winson Chung80baf5a2010-08-09 16:03:15 -07001299 }
1300 }
Winson Chung80baf5a2010-08-09 16:03:15 -07001301 }
1302 }
1303
Winson Chunge3193b92010-09-10 11:44:42 -07001304 protected int getAssociatedLowerPageBound(int page) {
1305 return Math.max(0, page - 1);
1306 }
1307 protected int getAssociatedUpperPageBound(int page) {
1308 final int count = getChildCount();
1309 return Math.min(page + 1, count - 1);
1310 }
1311
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001312 protected void startChoiceMode(int mode, ActionMode.Callback callback) {
Patrick Dubroy430c53b2010-09-08 16:01:19 -07001313 if (isChoiceMode(CHOICE_MODE_NONE)) {
1314 mChoiceMode = mode;
1315 mActionMode = startActionMode(callback);
1316 }
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001317 }
1318
Patrick Dubroy2b9ff372010-09-07 17:49:27 -07001319 public void endChoiceMode() {
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001320 if (!isChoiceMode(CHOICE_MODE_NONE)) {
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001321 mChoiceMode = CHOICE_MODE_NONE;
1322 resetCheckedGrandchildren();
Michael Jurkae17e19c2010-09-28 11:01:39 -07001323 if (mActionMode != null) mActionMode.finish();
Patrick Dubroy9f7aec82010-09-06 11:03:37 -07001324 mActionMode = null;
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001325 }
1326 }
1327
1328 protected boolean isChoiceMode(int mode) {
1329 return mChoiceMode == mode;
1330 }
1331
1332 protected ArrayList<Checkable> getCheckedGrandchildren() {
1333 ArrayList<Checkable> checked = new ArrayList<Checkable>();
1334 final int childCount = getChildCount();
1335 for (int i = 0; i < childCount; ++i) {
Winson Chungd0d43012010-09-26 17:26:45 -07001336 final ViewGroup layout = (ViewGroup) getChildAt(i);
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001337 final int grandChildCount = layout.getChildCount();
1338 for (int j = 0; j < grandChildCount; ++j) {
1339 final View v = layout.getChildAt(j);
Patrick Dubroy9f7aec82010-09-06 11:03:37 -07001340 if (v instanceof Checkable && ((Checkable) v).isChecked()) {
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001341 checked.add((Checkable) v);
1342 }
1343 }
1344 }
1345 return checked;
1346 }
1347
Patrick Dubroy9f7aec82010-09-06 11:03:37 -07001348 /**
1349 * If in CHOICE_MODE_SINGLE and an item is checked, returns that item.
1350 * Otherwise, returns null.
1351 */
1352 protected Checkable getSingleCheckedGrandchild() {
1353 if (mChoiceMode == CHOICE_MODE_SINGLE) {
1354 final int childCount = getChildCount();
1355 for (int i = 0; i < childCount; ++i) {
Winson Chungd0d43012010-09-26 17:26:45 -07001356 final ViewGroup layout = (ViewGroup) getChildAt(i);
Patrick Dubroy9f7aec82010-09-06 11:03:37 -07001357 final int grandChildCount = layout.getChildCount();
1358 for (int j = 0; j < grandChildCount; ++j) {
1359 final View v = layout.getChildAt(j);
1360 if (v instanceof Checkable && ((Checkable) v).isChecked()) {
1361 return (Checkable) v;
1362 }
1363 }
1364 }
1365 }
1366 return null;
1367 }
1368
Patrick Dubroy2b9ff372010-09-07 17:49:27 -07001369 public Object getChosenItem() {
1370 View checkedView = (View) getSingleCheckedGrandchild();
1371 if (checkedView != null) {
1372 return checkedView.getTag();
1373 }
1374 return null;
1375 }
1376
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001377 protected void resetCheckedGrandchildren() {
1378 // loop through children, and set all of their children to _not_ be checked
1379 final ArrayList<Checkable> checked = getCheckedGrandchildren();
1380 for (int i = 0; i < checked.size(); ++i) {
1381 final Checkable c = checked.get(i);
1382 c.setChecked(false);
1383 }
1384 }
1385
Winson Chunga12a2502010-12-20 14:41:35 -08001386 public void setRestorePage(int restorePage) {
1387 mRestorePage = restorePage;
1388 }
1389
Winson Chung86f77532010-08-24 11:08:22 -07001390 /**
1391 * This method is called ONLY to synchronize the number of pages that the paged view has.
1392 * To actually fill the pages with information, implement syncPageItems() below. It is
1393 * guaranteed that syncPageItems() will be called for a particular page before it is shown,
1394 * and therefore, individual page items do not need to be updated in this method.
1395 */
Winson Chung321e9ee2010-08-09 13:37:56 -07001396 public abstract void syncPages();
Winson Chung86f77532010-08-24 11:08:22 -07001397
1398 /**
1399 * This method is called to synchronize the items that are on a particular page. If views on
1400 * the page can be reused, then they should be updated within this method.
1401 */
Winson Chung321e9ee2010-08-09 13:37:56 -07001402 public abstract void syncPageItems(int page);
Winson Chung86f77532010-08-24 11:08:22 -07001403
Winson Chung321e9ee2010-08-09 13:37:56 -07001404 public void invalidatePageData() {
Michael Jurka0142d492010-08-25 17:46:15 -07001405 if (mContentIsRefreshable) {
1406 // Update all the pages
1407 syncPages();
Winson Chung86f77532010-08-24 11:08:22 -07001408
Michael Jurka0142d492010-08-25 17:46:15 -07001409 // Mark each of the pages as dirty
1410 final int count = getChildCount();
1411 mDirtyPageContent.clear();
1412 for (int i = 0; i < count; ++i) {
1413 mDirtyPageContent.add(true);
1414 }
1415
Winson Chunga12a2502010-12-20 14:41:35 -08001416 // Use the restore page if necessary
1417 if (mRestorePage > -1) {
1418 mCurrentPage = mRestorePage;
1419 mRestorePage = -1;
1420 }
1421
Michael Jurka0142d492010-08-25 17:46:15 -07001422 // Load any pages that are necessary for the current window of views
1423 loadAssociatedPages(mCurrentPage);
1424 mDirtyPageAlpha = true;
Winson Chungb0b2e6f2010-10-12 17:49:56 -07001425 updateAdjacentPagesAlpha();
Michael Jurka0142d492010-08-25 17:46:15 -07001426 requestLayout();
Winson Chung86f77532010-08-24 11:08:22 -07001427 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001428 }
1429}