blob: 53a584e0bc6533753d9a14a24efee0e729bb711c [file] [log] [blame]
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001/*
2 * Copyright (C) 2008 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
Joe Onoratoa5902522009-07-30 13:37:37 -070017package com.android.launcher2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080018
Michael Jurka3c4c20f2010-10-28 15:36:06 -070019import com.android.launcher.R;
Winson Chungaafa03c2010-06-11 17:34:16 -070020
Joe Onorato4be866d2010-10-10 11:26:02 -070021import android.animation.Animator;
22import android.animation.AnimatorListenerAdapter;
Michael Jurka18014792010-10-14 09:01:34 -070023import android.animation.AnimatorSet;
24import android.animation.ObjectAnimator;
Chet Haase00397b12010-10-07 11:13:10 -070025import android.animation.TimeInterpolator;
Patrick Dubroyde7658b2010-09-27 11:15:43 -070026import android.animation.ValueAnimator;
27import android.animation.ValueAnimator.AnimatorUpdateListener;
Winson Chungaafa03c2010-06-11 17:34:16 -070028import android.app.WallpaperManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080029import android.content.Context;
Joe Onorato79e56262009-09-21 15:23:04 -040030import android.content.res.Resources;
Winson Chungaafa03c2010-06-11 17:34:16 -070031import android.content.res.TypedArray;
Joe Onorato4be866d2010-10-10 11:26:02 -070032import android.graphics.Bitmap;
Winson Chungaafa03c2010-06-11 17:34:16 -070033import android.graphics.Canvas;
Joe Onorato4be866d2010-10-10 11:26:02 -070034import android.graphics.Paint;
Patrick Dubroyde7658b2010-09-27 11:15:43 -070035import android.graphics.Point;
36import android.graphics.PointF;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080037import android.graphics.Rect;
38import android.graphics.RectF;
Michael Jurka18014792010-10-14 09:01:34 -070039import android.graphics.Region;
Michael Jurkabea15192010-11-17 12:33:46 -080040import android.graphics.Bitmap.Config;
41import android.graphics.PorterDuff.Mode;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070042import android.graphics.drawable.Drawable;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080043import android.util.AttributeSet;
Joe Onorato4be866d2010-10-10 11:26:02 -070044import android.util.Log;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080045import android.view.ContextMenu;
46import android.view.MotionEvent;
47import android.view.View;
48import android.view.ViewDebug;
49import android.view.ViewGroup;
Winson Chungaafa03c2010-06-11 17:34:16 -070050import android.view.animation.Animation;
Winson Chung150fbab2010-09-29 17:14:26 -070051import android.view.animation.DecelerateInterpolator;
Winson Chungaafa03c2010-06-11 17:34:16 -070052import android.view.animation.LayoutAnimationController;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080053
Michael Jurka3c4c20f2010-10-28 15:36:06 -070054import java.util.Arrays;
Patrick Dubroy8e58e912010-10-14 13:21:48 -070055
Adam Cohenf34bab52010-09-30 14:11:56 -070056public class CellLayout extends ViewGroup implements Dimmable {
Winson Chungaafa03c2010-06-11 17:34:16 -070057 static final String TAG = "CellLayout";
58
The Android Open Source Project31dd5032009-03-03 19:32:27 -080059 private int mCellWidth;
60 private int mCellHeight;
Winson Chungaafa03c2010-06-11 17:34:16 -070061
Winson Chungaafa03c2010-06-11 17:34:16 -070062 private int mLeftPadding;
63 private int mRightPadding;
64 private int mTopPadding;
65 private int mBottomPadding;
66
Adam Cohend22015c2010-07-26 22:02:18 -070067 private int mCountX;
68 private int mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080069
70 private int mWidthGap;
71 private int mHeightGap;
72
73 private final Rect mRect = new Rect();
74 private final CellInfo mCellInfo = new CellInfo();
Winson Chungaafa03c2010-06-11 17:34:16 -070075
Patrick Dubroyde7658b2010-09-27 11:15:43 -070076 // These are temporary variables to prevent having to allocate a new object just to
77 // return an (x, y) value from helper functions. Do NOT use them to maintain other state.
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070078 private final int[] mTmpCellXY = new int[2];
Patrick Dubroyde7658b2010-09-27 11:15:43 -070079 private final int[] mTmpPoint = new int[2];
80 private final PointF mTmpPointF = new PointF();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070081
The Android Open Source Project31dd5032009-03-03 19:32:27 -080082 boolean[][] mOccupied;
83
Michael Jurkadee05892010-07-27 10:01:56 -070084 private OnTouchListener mInterceptTouchListener;
85
Michael Jurka5f1c5092010-09-03 14:15:02 -070086 private float mBackgroundAlpha;
Adam Cohen1b0aaac2010-10-28 11:11:18 -070087 private float mBackgroundAlphaMultiplier = 1.0f;
Adam Cohenf34bab52010-09-30 14:11:56 -070088
Michael Jurka33945b22010-12-21 18:19:38 -080089 private Drawable mNormalBackground;
90 private Drawable mNormalGlowBackground;
91 private Drawable mActiveBackground;
92 private Drawable mActiveGlowBackground;
93 private Drawable mNormalBackgroundMini;
94 private Drawable mNormalGlowBackgroundMini;
95 private Drawable mActiveBackgroundMini;
96 private Drawable mActiveGlowBackgroundMini;
Michael Jurka18014792010-10-14 09:01:34 -070097 private Rect mBackgroundRect;
Michael Jurka33945b22010-12-21 18:19:38 -080098 private Rect mGlowBackgroundRect;
99 private float mGlowBackgroundScale;
100 private float mGlowBackgroundAlpha;
Patrick Dubroy1262e362010-10-06 15:49:50 -0700101
Michael Jurkabea15192010-11-17 12:33:46 -0800102 private Bitmap mCache;
103 private Canvas mCacheCanvas;
104 private Rect mCacheRect;
105 private Paint mCachePaint;
106
107 private boolean mIsCacheEnabled = true;
108 private boolean mDisableCacheUpdates = false;
109 private boolean mForceCacheUpdate = false;
110 private boolean mIsCacheDirty = true;
111 private float mBitmapCacheScale;
112 private float mMaxScaleForUsingBitmapCache;
113
Michael Jurka33945b22010-12-21 18:19:38 -0800114 private boolean mAcceptsDrops = false;
115 // If we're actively dragging something over this screen, mIsDragOverlapping is true
116 private boolean mIsDragOverlapping = false;
117 private boolean mIsDragOccuring = false;
118 private boolean mIsDefaultDropTarget = false;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700119 private final Point mDragCenter = new Point();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700120
Winson Chung150fbab2010-09-29 17:14:26 -0700121 // These arrays are used to implement the drag visualization on x-large screens.
Joe Onorato4be866d2010-10-10 11:26:02 -0700122 // They are used as circular arrays, indexed by mDragOutlineCurrent.
123 private Point[] mDragOutlines = new Point[8];
Chet Haase472b2812010-10-14 07:02:04 -0700124 private float[] mDragOutlineAlphas = new float[mDragOutlines.length];
Joe Onorato4be866d2010-10-10 11:26:02 -0700125 private InterruptibleInOutAnimator[] mDragOutlineAnims =
126 new InterruptibleInOutAnimator[mDragOutlines.length];
Winson Chung150fbab2010-09-29 17:14:26 -0700127
128 // Used as an index into the above 3 arrays; indicates which is the most current value.
Joe Onorato4be866d2010-10-10 11:26:02 -0700129 private int mDragOutlineCurrent = 0;
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700130 private final Paint mDragOutlinePaint = new Paint();
Winson Chung150fbab2010-09-29 17:14:26 -0700131
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700132 private Drawable mCrosshairsDrawable = null;
Patrick Dubroy49250ad2010-10-08 15:33:52 -0700133 private InterruptibleInOutAnimator mCrosshairsAnimator = null;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700134 private float mCrosshairsVisibility = 0.0f;
135
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700136 // When a drag operation is in progress, holds the nearest cell to the touch point
137 private final int[] mDragCell = new int[2];
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800138
Winson Chungaafa03c2010-06-11 17:34:16 -0700139 private final WallpaperManager mWallpaperManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800140
Joe Onorato4be866d2010-10-10 11:26:02 -0700141 private boolean mDragging = false;
142
Patrick Dubroyce34a972010-10-19 10:34:32 -0700143 private TimeInterpolator mEaseOutInterpolator;
144
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800145 public CellLayout(Context context) {
146 this(context, null);
147 }
148
149 public CellLayout(Context context, AttributeSet attrs) {
150 this(context, attrs, 0);
151 }
152
153 public CellLayout(Context context, AttributeSet attrs, int defStyle) {
154 super(context, attrs, defStyle);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700155
156 // A ViewGroup usually does not draw, but CellLayout needs to draw a rectangle to show
157 // the user where a dragged item will land when dropped.
158 setWillNotDraw(false);
Michael Jurkaa63c4522010-08-19 13:52:27 -0700159
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800160 TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CellLayout, defStyle, 0);
161
162 mCellWidth = a.getDimensionPixelSize(R.styleable.CellLayout_cellWidth, 10);
163 mCellHeight = a.getDimensionPixelSize(R.styleable.CellLayout_cellHeight, 10);
Winson Chungece7f5b2010-10-22 14:54:12 -0700164 mWidthGap = a.getDimensionPixelSize(R.styleable.CellLayout_widthGap, -1);
165 mHeightGap = a.getDimensionPixelSize(R.styleable.CellLayout_heightGap, -1);
Winson Chungaafa03c2010-06-11 17:34:16 -0700166
Adam Cohend22015c2010-07-26 22:02:18 -0700167 mLeftPadding =
168 a.getDimensionPixelSize(R.styleable.CellLayout_xAxisStartPadding, 10);
169 mRightPadding =
170 a.getDimensionPixelSize(R.styleable.CellLayout_xAxisEndPadding, 10);
171 mTopPadding =
172 a.getDimensionPixelSize(R.styleable.CellLayout_yAxisStartPadding, 10);
173 mBottomPadding =
174 a.getDimensionPixelSize(R.styleable.CellLayout_yAxisEndPadding, 10);
Winson Chungaafa03c2010-06-11 17:34:16 -0700175
Adam Cohend22015c2010-07-26 22:02:18 -0700176 mCountX = LauncherModel.getCellCountX();
177 mCountY = LauncherModel.getCellCountY();
Michael Jurka0280c3b2010-09-17 15:00:07 -0700178 mOccupied = new boolean[mCountX][mCountY];
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800179
180 a.recycle();
181
182 setAlwaysDrawnWithCacheEnabled(false);
183
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700184 mWallpaperManager = WallpaperManager.getInstance(context);
185
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700186 final Resources res = getResources();
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700187
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700188 if (LauncherApplication.isScreenXLarge()) {
Michael Jurka33945b22010-12-21 18:19:38 -0800189 mNormalBackground = res.getDrawable(R.drawable.homescreen_large_blue);
190 mNormalGlowBackground = res.getDrawable(R.drawable.homescreen_large_blue_strong);
191 mActiveBackground = res.getDrawable(R.drawable.homescreen_large_green);
192 mActiveGlowBackground = res.getDrawable(R.drawable.homescreen_large_green_strong);
193
194 mNormalBackgroundMini = res.getDrawable(R.drawable.homescreen_small_blue);
195 mNormalGlowBackgroundMini = res.getDrawable(R.drawable.homescreen_small_blue_strong);
196 mActiveBackgroundMini = res.getDrawable(R.drawable.homescreen_small_green);
197 mActiveGlowBackgroundMini = res.getDrawable(R.drawable.homescreen_small_green_strong);
198
199 mNormalBackground.setFilterBitmap(true);
200 mNormalGlowBackground.setFilterBitmap(true);
201 mActiveBackground.setFilterBitmap(true);
202 mActiveGlowBackground.setFilterBitmap(true);
203 mNormalBackgroundMini.setFilterBitmap(true);
204 mNormalGlowBackgroundMini.setFilterBitmap(true);
205 mActiveBackgroundMini.setFilterBitmap(true);
206 mActiveGlowBackgroundMini.setFilterBitmap(true);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700207 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700208
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700209 // Initialize the data structures used for the drag visualization.
Winson Chung150fbab2010-09-29 17:14:26 -0700210
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700211 mCrosshairsDrawable = res.getDrawable(R.drawable.gardening_crosshairs);
Patrick Dubroyce34a972010-10-19 10:34:32 -0700212 mEaseOutInterpolator = new DecelerateInterpolator(2.5f); // Quint ease out
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700213
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700214 // Set up the animation for fading the crosshairs in and out
215 int animDuration = res.getInteger(R.integer.config_crosshairsFadeInTime);
Patrick Dubroy49250ad2010-10-08 15:33:52 -0700216 mCrosshairsAnimator = new InterruptibleInOutAnimator(animDuration, 0.0f, 1.0f);
Chet Haase472b2812010-10-14 07:02:04 -0700217 mCrosshairsAnimator.getAnimator().addUpdateListener(new AnimatorUpdateListener() {
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700218 public void onAnimationUpdate(ValueAnimator animation) {
219 mCrosshairsVisibility = ((Float) animation.getAnimatedValue()).floatValue();
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700220 invalidate();
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700221 }
222 });
Patrick Dubroyce34a972010-10-19 10:34:32 -0700223 mCrosshairsAnimator.getAnimator().setInterpolator(mEaseOutInterpolator);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700224
Joe Onorato4be866d2010-10-10 11:26:02 -0700225 for (int i = 0; i < mDragOutlines.length; i++) {
226 mDragOutlines[i] = new Point(-1, -1);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700227 }
228
229 // When dragging things around the home screens, we show a green outline of
230 // where the item will land. The outlines gradually fade out, leaving a trail
231 // behind the drag path.
232 // Set up all the animations that are used to implement this fading.
233 final int duration = res.getInteger(R.integer.config_dragOutlineFadeTime);
Chet Haase472b2812010-10-14 07:02:04 -0700234 final float fromAlphaValue = 0;
235 final float toAlphaValue = (float)res.getInteger(R.integer.config_dragOutlineMaxAlpha);
Joe Onorato4be866d2010-10-10 11:26:02 -0700236
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700237 Arrays.fill(mDragOutlineAlphas, fromAlphaValue);
Joe Onorato4be866d2010-10-10 11:26:02 -0700238
239 for (int i = 0; i < mDragOutlineAnims.length; i++) {
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700240 final InterruptibleInOutAnimator anim =
241 new InterruptibleInOutAnimator(duration, fromAlphaValue, toAlphaValue);
Patrick Dubroyce34a972010-10-19 10:34:32 -0700242 anim.getAnimator().setInterpolator(mEaseOutInterpolator);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700243 final int thisIndex = i;
Chet Haase472b2812010-10-14 07:02:04 -0700244 anim.getAnimator().addUpdateListener(new AnimatorUpdateListener() {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700245 public void onAnimationUpdate(ValueAnimator animation) {
Joe Onorato4be866d2010-10-10 11:26:02 -0700246 final Bitmap outline = (Bitmap)anim.getTag();
247
248 // If an animation is started and then stopped very quickly, we can still
249 // get spurious updates we've cleared the tag. Guard against this.
250 if (outline == null) {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -0700251 if (false) {
252 Object val = animation.getAnimatedValue();
253 Log.d(TAG, "anim " + thisIndex + " update: " + val +
254 ", isStopped " + anim.isStopped());
255 }
Joe Onorato4be866d2010-10-10 11:26:02 -0700256 // Try to prevent it from continuing to run
257 animation.cancel();
258 } else {
Chet Haase472b2812010-10-14 07:02:04 -0700259 mDragOutlineAlphas[thisIndex] = (Float) animation.getAnimatedValue();
Joe Onorato4be866d2010-10-10 11:26:02 -0700260 final int left = mDragOutlines[thisIndex].x;
261 final int top = mDragOutlines[thisIndex].y;
262 CellLayout.this.invalidate(left, top,
263 left + outline.getWidth(), top + outline.getHeight());
264 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700265 }
266 });
Joe Onorato4be866d2010-10-10 11:26:02 -0700267 // The animation holds a reference to the drag outline bitmap as long is it's
268 // running. This way the bitmap can be GCed when the animations are complete.
Chet Haase472b2812010-10-14 07:02:04 -0700269 anim.getAnimator().addListener(new AnimatorListenerAdapter() {
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700270 @Override
Joe Onorato4be866d2010-10-10 11:26:02 -0700271 public void onAnimationEnd(Animator animation) {
Chet Haase472b2812010-10-14 07:02:04 -0700272 if ((Float) ((ValueAnimator) animation).getAnimatedValue() == 0f) {
Joe Onorato4be866d2010-10-10 11:26:02 -0700273 anim.setTag(null);
274 }
275 }
276 });
277 mDragOutlineAnims[i] = anim;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700278 }
Patrick Dubroyce34a972010-10-19 10:34:32 -0700279
Michael Jurka18014792010-10-14 09:01:34 -0700280 mBackgroundRect = new Rect();
Michael Jurka33945b22010-12-21 18:19:38 -0800281 mGlowBackgroundRect = new Rect();
Michael Jurkabea15192010-11-17 12:33:46 -0800282 mCacheRect = new Rect();
Michael Jurka18014792010-10-14 09:01:34 -0700283 setHoverScale(1.0f);
284 setHoverAlpha(1.0f);
Michael Jurkabea15192010-11-17 12:33:46 -0800285
286 mBitmapCacheScale =
287 res.getInteger(R.integer.config_workspaceScreenBitmapCacheScale) / 100.0f;
288 mMaxScaleForUsingBitmapCache =
289 res.getInteger(R.integer.config_maxScaleForUsingWorkspaceScreenBitmapCache) / 100.0f;
290 mCacheCanvas = new Canvas();
Michael Jurka18014792010-10-14 09:01:34 -0700291 }
292
Michael Jurka33945b22010-12-21 18:19:38 -0800293 public void setIsDefaultDropTarget(boolean isDefaultDropTarget) {
294 if (mIsDefaultDropTarget != isDefaultDropTarget) {
295 mIsDefaultDropTarget = isDefaultDropTarget;
296 invalidate();
297 }
298 }
299
Michael Jurka33945b22010-12-21 18:19:38 -0800300 void setIsDragOccuring(boolean isDragOccuring) {
301 if (mIsDragOccuring != isDragOccuring) {
302 mIsDragOccuring = isDragOccuring;
303 invalidate();
304 }
305 }
306
307 void setIsDragOverlapping(boolean isDragOverlapping) {
308 if (mIsDragOverlapping != isDragOverlapping) {
309 mIsDragOverlapping = isDragOverlapping;
310 invalidate();
311 }
312 }
313
314 boolean getIsDragOverlapping() {
315 return mIsDragOverlapping;
316 }
317
318 private void updateGlowRect() {
319 float marginFraction = (mGlowBackgroundScale - 1.0f) / 2.0f;
Michael Jurka18014792010-10-14 09:01:34 -0700320 int marginX = (int) (marginFraction * (mBackgroundRect.right - mBackgroundRect.left));
321 int marginY = (int) (marginFraction * (mBackgroundRect.bottom - mBackgroundRect.top));
Michael Jurka33945b22010-12-21 18:19:38 -0800322 mGlowBackgroundRect.set(mBackgroundRect.left - marginX, mBackgroundRect.top - marginY,
Michael Jurka18014792010-10-14 09:01:34 -0700323 mBackgroundRect.right + marginX, mBackgroundRect.bottom + marginY);
324 invalidate();
325 }
326
327 public void setHoverScale(float scaleFactor) {
Michael Jurka33945b22010-12-21 18:19:38 -0800328 if (scaleFactor != mGlowBackgroundScale) {
329 mGlowBackgroundScale = scaleFactor;
330 updateGlowRect();
Michael Jurka18014792010-10-14 09:01:34 -0700331 }
332 }
333
334 public float getHoverScale() {
Michael Jurka33945b22010-12-21 18:19:38 -0800335 return mGlowBackgroundScale;
Michael Jurka18014792010-10-14 09:01:34 -0700336 }
337
338 public float getHoverAlpha() {
Michael Jurka33945b22010-12-21 18:19:38 -0800339 return mGlowBackgroundAlpha;
Michael Jurka18014792010-10-14 09:01:34 -0700340 }
341
342 public void setHoverAlpha(float alpha) {
Michael Jurka33945b22010-12-21 18:19:38 -0800343 mGlowBackgroundAlpha = alpha;
Michael Jurka18014792010-10-14 09:01:34 -0700344 invalidate();
345 }
346
347 void animateDrop() {
348 if (LauncherApplication.isScreenXLarge()) {
349 Resources res = getResources();
350 float onDropScale = res.getInteger(R.integer.config_screenOnDropScalePercent) / 100.0f;
351 ObjectAnimator scaleUp = ObjectAnimator.ofFloat(this, "hoverScale", onDropScale);
352 scaleUp.setDuration(res.getInteger(R.integer.config_screenOnDropScaleUpDuration));
353 ObjectAnimator scaleDown = ObjectAnimator.ofFloat(this, "hoverScale", 1.0f);
354 scaleDown.setDuration(res.getInteger(R.integer.config_screenOnDropScaleDownDuration));
355 ObjectAnimator alphaFadeOut = ObjectAnimator.ofFloat(this, "hoverAlpha", 0.0f);
356
357 alphaFadeOut.setStartDelay(res.getInteger(R.integer.config_screenOnDropAlphaFadeDelay));
358 alphaFadeOut.setDuration(res.getInteger(R.integer.config_screenOnDropAlphaFadeDelay));
359
360 AnimatorSet bouncer = new AnimatorSet();
361 bouncer.play(scaleUp).before(scaleDown);
362 bouncer.play(scaleUp).with(alphaFadeOut);
Michael Jurka8edd75c2010-12-17 20:15:06 -0800363 bouncer.addListener(new AnimatorListenerAdapter() {
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700364 @Override
Michael Jurka18014792010-10-14 09:01:34 -0700365 public void onAnimationStart(Animator animation) {
Michael Jurka33945b22010-12-21 18:19:38 -0800366 setIsDragOverlapping(true);
Michael Jurka18014792010-10-14 09:01:34 -0700367 }
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700368 @Override
Michael Jurka8edd75c2010-12-17 20:15:06 -0800369 public void onAnimationEnd(Animator animation) {
Michael Jurka33945b22010-12-21 18:19:38 -0800370 setIsDragOverlapping(false);
Michael Jurka18014792010-10-14 09:01:34 -0700371 setHoverScale(1.0f);
372 setHoverAlpha(1.0f);
373 }
374 });
375 bouncer.start();
376 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800377 }
378
Patrick Dubroy1262e362010-10-06 15:49:50 -0700379 public void drawChildren(Canvas canvas) {
380 super.dispatchDraw(canvas);
381 }
382
Michael Jurkabea15192010-11-17 12:33:46 -0800383 private void invalidateIfNeeded() {
384 if (mIsCacheDirty) {
385 // Force a redraw to update the cache if it's dirty
386 invalidate();
387 }
388 }
389
390 public void enableCache() {
391 mIsCacheEnabled = true;
392 invalidateIfNeeded();
393 }
394
395 public void disableCache() {
396 mIsCacheEnabled = false;
397 }
398
399 public void disableCacheUpdates() {
400 mDisableCacheUpdates = true;
401 // Force just one update before we enter a period of no cache updates
402 mForceCacheUpdate = true;
403 }
404
405 public void enableCacheUpdates() {
406 mDisableCacheUpdates = false;
407 invalidateIfNeeded();
408 }
409
410 private void invalidateCache() {
411 mIsCacheDirty = true;
412 invalidateIfNeeded();
413 }
414
415 public void updateCache() {
416 mCacheCanvas.drawColor(0x00000000, Mode.CLEAR);
417
418 float alpha = getAlpha();
419 setAlpha(1.0f);
420 drawChildren(mCacheCanvas);
421 setAlpha(alpha);
422
423 mIsCacheDirty = false;
424 }
425
426 public void dispatchDraw(Canvas canvas) {
427 final int count = getChildCount();
428
429 if (!mIsCacheDirty) {
430 // Check if one of the children (an icon or widget) is dirty
431 for (int i = 0; i < count; i++) {
432 final View child = getChildAt(i);
433 if (child.isDirty()) {
434 mIsCacheDirty = true;
435 break;
436 }
437 }
438 }
439
440 if (mForceCacheUpdate ||
441 (mIsCacheEnabled && !mDisableCacheUpdates)) {
442 // Sometimes we force a cache update-- this is used to make sure the cache will look as
443 // up-to-date as possible right when we disable cache updates
444 if (mIsCacheDirty) {
445 updateCache();
446 }
447 mForceCacheUpdate = false;
448 }
449
450 if (mIsCacheEnabled && getScaleX() < mMaxScaleForUsingBitmapCache) {
451 mCachePaint.setAlpha((int)(255*getAlpha()));
452 canvas.drawBitmap(mCache, mCacheRect, mBackgroundRect, mCachePaint);
453 } else {
454 super.dispatchDraw(canvas);
455 }
456 }
457
458 private void prepareCacheBitmap() {
459 if (mCache == null) {
460 mCache = Bitmap.createBitmap((int) (getWidth() * mBitmapCacheScale),
461 (int) (getHeight() * mBitmapCacheScale), Config.ARGB_8888);
462
463 mCachePaint = new Paint();
464 mCachePaint.setFilterBitmap(true);
465 mCacheCanvas.setBitmap(mCache);
466 mCacheCanvas.scale(mBitmapCacheScale, mBitmapCacheScale);
467 }
468 }
469
Jeff Sharkey83f111d2009-04-20 21:03:13 -0700470 @Override
Patrick Dubroy1262e362010-10-06 15:49:50 -0700471 protected void onDraw(Canvas canvas) {
Michael Jurka3e7c7632010-10-02 16:01:03 -0700472 // When we're large, we are either drawn in a "hover" state (ie when dragging an item to
473 // a neighboring page) or with just a normal background (if backgroundAlpha > 0.0f)
474 // When we're small, we are either drawn normally or in the "accepts drops" state (during
475 // a drag). However, we also drag the mini hover background *over* one of those two
476 // backgrounds
Michael Jurka5f1c5092010-09-03 14:15:02 -0700477 if (mBackgroundAlpha > 0.0f) {
Adam Cohenf34bab52010-09-30 14:11:56 -0700478 Drawable bg;
Michael Jurka33945b22010-12-21 18:19:38 -0800479 boolean mini = getScaleX() < 0.5f;
480
481 if (mIsDragOverlapping) {
482 // In the mini case, we draw the active_glow bg *over* the active background
483 bg = mini ? mActiveBackgroundMini : mActiveGlowBackground;
484 } else if (mIsDragOccuring && mAcceptsDrops) {
485 bg = mini ? mActiveBackgroundMini : mActiveBackground;
486 } else if (mIsDefaultDropTarget) {
487 bg = mini ? mNormalGlowBackgroundMini : mNormalGlowBackground;
Adam Cohenf34bab52010-09-30 14:11:56 -0700488 } else {
Michael Jurka33945b22010-12-21 18:19:38 -0800489 bg = mini ? mNormalBackgroundMini : mNormalBackground;
Adam Cohenf34bab52010-09-30 14:11:56 -0700490 }
Michael Jurka33945b22010-12-21 18:19:38 -0800491
492 bg.setAlpha((int) (mBackgroundAlpha * mBackgroundAlphaMultiplier * 255));
493 bg.setBounds(mBackgroundRect);
494 bg.draw(canvas);
495
496 if (mini && mIsDragOverlapping) {
Michael Jurka18014792010-10-14 09:01:34 -0700497 boolean modifiedClipRect = false;
Michael Jurka33945b22010-12-21 18:19:38 -0800498 if (mGlowBackgroundScale > 1.0f) {
Michael Jurka18014792010-10-14 09:01:34 -0700499 // If the hover background's scale is greater than 1, we'll be drawing outside
500 // the bounds of this CellLayout. Get around that by temporarily increasing the
501 // size of the clip rect
Michael Jurka33945b22010-12-21 18:19:38 -0800502 float marginFraction = (mGlowBackgroundScale - 1.0f) / 2.0f;
Michael Jurka18014792010-10-14 09:01:34 -0700503 Rect clipRect = canvas.getClipBounds();
504 int marginX = (int) (marginFraction * (clipRect.right - clipRect.left));
505 int marginY = (int) (marginFraction * (clipRect.bottom - clipRect.top));
506 canvas.save(Canvas.CLIP_SAVE_FLAG);
507 canvas.clipRect(-marginX, -marginY,
508 getWidth() + marginX, getHeight() + marginY, Region.Op.REPLACE);
509 modifiedClipRect = true;
510 }
511
Michael Jurka33945b22010-12-21 18:19:38 -0800512 mActiveGlowBackgroundMini.setAlpha(
513 (int) (mBackgroundAlpha * mGlowBackgroundAlpha * 255));
514 mActiveGlowBackgroundMini.setBounds(mGlowBackgroundRect);
515 mActiveGlowBackgroundMini.draw(canvas);
Michael Jurka18014792010-10-14 09:01:34 -0700516 if (modifiedClipRect) {
517 canvas.restore();
518 }
Michael Jurka3e7c7632010-10-02 16:01:03 -0700519 }
Michael Jurkaa63c4522010-08-19 13:52:27 -0700520 }
Romain Guya6abce82009-11-10 02:54:41 -0800521
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700522 if (mCrosshairsVisibility > 0.0f) {
523 final int countX = mCountX;
524 final int countY = mCountY;
525
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700526 final float MAX_ALPHA = 0.4f;
527 final int MAX_VISIBLE_DISTANCE = 600;
528 final float DISTANCE_MULTIPLIER = 0.002f;
529
530 final Drawable d = mCrosshairsDrawable;
531 final int width = d.getIntrinsicWidth();
532 final int height = d.getIntrinsicHeight();
533
534 int x = getLeftPadding() - (mWidthGap / 2) - (width / 2);
535 for (int col = 0; col <= countX; col++) {
536 int y = getTopPadding() - (mHeightGap / 2) - (height / 2);
537 for (int row = 0; row <= countY; row++) {
538 mTmpPointF.set(x - mDragCenter.x, y - mDragCenter.y);
539 float dist = mTmpPointF.length();
540 // Crosshairs further from the drag point are more faint
541 float alpha = Math.min(MAX_ALPHA,
542 DISTANCE_MULTIPLIER * (MAX_VISIBLE_DISTANCE - dist));
543 if (alpha > 0.0f) {
544 d.setBounds(x, y, x + width, y + height);
545 d.setAlpha((int) (alpha * 255 * mCrosshairsVisibility));
546 d.draw(canvas);
547 }
548 y += mCellHeight + mHeightGap;
549 }
550 x += mCellWidth + mWidthGap;
551 }
Joe Onorato4be866d2010-10-10 11:26:02 -0700552 }
Winson Chung150fbab2010-09-29 17:14:26 -0700553
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700554 final Paint paint = mDragOutlinePaint;
Joe Onorato4be866d2010-10-10 11:26:02 -0700555 for (int i = 0; i < mDragOutlines.length; i++) {
Chet Haase472b2812010-10-14 07:02:04 -0700556 final float alpha = mDragOutlineAlphas[i];
Joe Onorato4be866d2010-10-10 11:26:02 -0700557 if (alpha > 0) {
558 final Point p = mDragOutlines[i];
559 final Bitmap b = (Bitmap) mDragOutlineAnims[i].getTag();
Chet Haase472b2812010-10-14 07:02:04 -0700560 paint.setAlpha((int)(alpha + .5f));
Joe Onorato4be866d2010-10-10 11:26:02 -0700561 canvas.drawBitmap(b, p.x, p.y, paint);
Winson Chung150fbab2010-09-29 17:14:26 -0700562 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700563 }
564 }
565
Adam Cohenf34bab52010-09-30 14:11:56 -0700566 public void setDimmableProgress(float progress) {
567 for (int i = 0; i < getChildCount(); i++) {
568 Dimmable d = (Dimmable) getChildAt(i);
569 d.setDimmableProgress(progress);
570 }
571 }
572
573 public float getDimmableProgress() {
574 if (getChildCount() > 0) {
575 return ((Dimmable) getChildAt(0)).getDimmableProgress();
576 }
577 return 0.0f;
578 }
579
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700580 @Override
Jeff Sharkey83f111d2009-04-20 21:03:13 -0700581 public void cancelLongPress() {
582 super.cancelLongPress();
583
584 // Cancel long press for all children
585 final int count = getChildCount();
586 for (int i = 0; i < count; i++) {
587 final View child = getChildAt(i);
588 child.cancelLongPress();
589 }
590 }
591
Michael Jurkadee05892010-07-27 10:01:56 -0700592 public void setOnInterceptTouchListener(View.OnTouchListener listener) {
593 mInterceptTouchListener = listener;
594 }
595
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800596 int getCountX() {
Adam Cohend22015c2010-07-26 22:02:18 -0700597 return mCountX;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800598 }
599
600 int getCountY() {
Adam Cohend22015c2010-07-26 22:02:18 -0700601 return mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800602 }
603
Winson Chungaafa03c2010-06-11 17:34:16 -0700604 public boolean addViewToCellLayout(View child, int index, int childId, LayoutParams params) {
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700605 return addViewToCellLayout(child, index, childId, params, true);
606 }
607
608 public boolean addViewToCellLayout(
609 View child, int index, int childId, LayoutParams params, boolean markCells) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700610 final LayoutParams lp = params;
611
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800612 // Generate an id for each view, this assumes we have at most 256x256 cells
613 // per workspace screen
Adam Cohend22015c2010-07-26 22:02:18 -0700614 if (lp.cellX >= 0 && lp.cellX <= mCountX - 1 && lp.cellY >= 0 && lp.cellY <= mCountY - 1) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700615 // If the horizontal or vertical span is set to -1, it is taken to
616 // mean that it spans the extent of the CellLayout
Adam Cohend22015c2010-07-26 22:02:18 -0700617 if (lp.cellHSpan < 0) lp.cellHSpan = mCountX;
618 if (lp.cellVSpan < 0) lp.cellVSpan = mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800619
Winson Chungaafa03c2010-06-11 17:34:16 -0700620 child.setId(childId);
621
Michael Jurkadee05892010-07-27 10:01:56 -0700622 // We might be in the middle or end of shrinking/fading to a dimmed view
623 // Make sure this view's alpha is set the same as all the rest of the views
Michael Jurka5f1c5092010-09-03 14:15:02 -0700624 child.setAlpha(getAlpha());
Winson Chungaafa03c2010-06-11 17:34:16 -0700625 addView(child, index, lp);
Michael Jurkadee05892010-07-27 10:01:56 -0700626
Michael Jurkabea15192010-11-17 12:33:46 -0800627 // invalidate the cache to have it reflect the new item
628 invalidateCache();
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700629 if (markCells) markCellsAsOccupiedForView(child);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700630
Winson Chungaafa03c2010-06-11 17:34:16 -0700631 return true;
632 }
633 return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800634 }
Michael Jurka3e7c7632010-10-02 16:01:03 -0700635
Michael Jurkabea15192010-11-17 12:33:46 -0800636 public void setAcceptsDrops(boolean acceptsDrops) {
637 if (mAcceptsDrops != acceptsDrops) {
638 mAcceptsDrops = acceptsDrops;
639 invalidate();
640 }
641 }
642
Michael Jurka3e7c7632010-10-02 16:01:03 -0700643 public boolean getAcceptsDrops() {
644 return mAcceptsDrops;
645 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800646
647 @Override
Michael Jurka0280c3b2010-09-17 15:00:07 -0700648 public void removeAllViews() {
649 clearOccupiedCells();
650 }
651
652 @Override
653 public void removeAllViewsInLayout() {
654 clearOccupiedCells();
655 }
656
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700657 public void removeViewWithoutMarkingCells(View view) {
658 super.removeView(view);
659 }
660
Michael Jurka0280c3b2010-09-17 15:00:07 -0700661 @Override
662 public void removeView(View view) {
663 markCellsAsUnoccupiedForView(view);
664 super.removeView(view);
665 }
666
667 @Override
668 public void removeViewAt(int index) {
669 markCellsAsUnoccupiedForView(getChildAt(index));
670 super.removeViewAt(index);
671 }
672
673 @Override
674 public void removeViewInLayout(View view) {
675 markCellsAsUnoccupiedForView(view);
676 super.removeViewInLayout(view);
677 }
678
679 @Override
680 public void removeViews(int start, int count) {
681 for (int i = start; i < start + count; i++) {
682 markCellsAsUnoccupiedForView(getChildAt(i));
683 }
684 super.removeViews(start, count);
685 }
686
687 @Override
688 public void removeViewsInLayout(int start, int count) {
689 for (int i = start; i < start + count; i++) {
690 markCellsAsUnoccupiedForView(getChildAt(i));
691 }
692 super.removeViewsInLayout(start, count);
693 }
694
695 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800696 public void requestChildFocus(View child, View focused) {
697 super.requestChildFocus(child, focused);
698 if (child != null) {
699 Rect r = new Rect();
700 child.getDrawingRect(r);
701 requestRectangleOnScreen(r);
702 }
703 }
704
705 @Override
706 protected void onAttachedToWindow() {
707 super.onAttachedToWindow();
708 mCellInfo.screen = ((ViewGroup) getParent()).indexOfChild(this);
709 }
710
Michael Jurkaaf442092010-06-10 17:01:57 -0700711 public void setTagToCellInfoForPoint(int touchX, int touchY) {
712 final CellInfo cellInfo = mCellInfo;
713 final Rect frame = mRect;
714 final int x = touchX + mScrollX;
715 final int y = touchY + mScrollY;
716 final int count = getChildCount();
717
718 boolean found = false;
719 for (int i = count - 1; i >= 0; i--) {
720 final View child = getChildAt(i);
721
722 if ((child.getVisibility()) == VISIBLE || child.getAnimation() != null) {
723 child.getHitRect(frame);
724 if (frame.contains(x, y)) {
725 final LayoutParams lp = (LayoutParams) child.getLayoutParams();
726 cellInfo.cell = child;
727 cellInfo.cellX = lp.cellX;
728 cellInfo.cellY = lp.cellY;
729 cellInfo.spanX = lp.cellHSpan;
730 cellInfo.spanY = lp.cellVSpan;
731 cellInfo.valid = true;
732 found = true;
Michael Jurkaaf442092010-06-10 17:01:57 -0700733 break;
734 }
735 }
736 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700737
Michael Jurkaaf442092010-06-10 17:01:57 -0700738 if (!found) {
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700739 final int cellXY[] = mTmpCellXY;
Michael Jurkaaf442092010-06-10 17:01:57 -0700740 pointToCellExact(x, y, cellXY);
741
Michael Jurkaaf442092010-06-10 17:01:57 -0700742 cellInfo.cell = null;
743 cellInfo.cellX = cellXY[0];
744 cellInfo.cellY = cellXY[1];
745 cellInfo.spanX = 1;
746 cellInfo.spanY = 1;
Michael Jurka0280c3b2010-09-17 15:00:07 -0700747 cellInfo.valid = cellXY[0] >= 0 && cellXY[1] >= 0 && cellXY[0] < mCountX &&
748 cellXY[1] < mCountY && !mOccupied[cellXY[0]][cellXY[1]];
Michael Jurkaaf442092010-06-10 17:01:57 -0700749 }
750 setTag(cellInfo);
751 }
752
Winson Chungaafa03c2010-06-11 17:34:16 -0700753
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800754 @Override
755 public boolean onInterceptTouchEvent(MotionEvent ev) {
Michael Jurkadee05892010-07-27 10:01:56 -0700756 if (mInterceptTouchListener != null && mInterceptTouchListener.onTouch(this, ev)) {
757 return true;
758 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800759 final int action = ev.getAction();
760 final CellInfo cellInfo = mCellInfo;
761
762 if (action == MotionEvent.ACTION_DOWN) {
Michael Jurkaaf442092010-06-10 17:01:57 -0700763 setTagToCellInfoForPoint((int) ev.getX(), (int) ev.getY());
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800764 } else if (action == MotionEvent.ACTION_UP) {
765 cellInfo.cell = null;
766 cellInfo.cellX = -1;
767 cellInfo.cellY = -1;
768 cellInfo.spanX = 0;
769 cellInfo.spanY = 0;
770 cellInfo.valid = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800771 setTag(cellInfo);
772 }
773
774 return false;
775 }
776
777 @Override
778 public CellInfo getTag() {
Michael Jurka0280c3b2010-09-17 15:00:07 -0700779 return (CellInfo) super.getTag();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800780 }
781
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700782 /**
783 * Check if the row 'y' is empty from columns 'left' to 'right', inclusive.
784 */
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800785 private static boolean isRowEmpty(int y, int left, int right, boolean[][] occupied) {
786 for (int x = left; x <= right; x++) {
787 if (occupied[x][y]) {
788 return false;
789 }
790 }
791 return true;
792 }
793
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800794 /**
Winson Chungaafa03c2010-06-11 17:34:16 -0700795 * Given a point, return the cell that strictly encloses that point
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800796 * @param x X coordinate of the point
797 * @param y Y coordinate of the point
798 * @param result Array of 2 ints to hold the x and y coordinate of the cell
799 */
800 void pointToCellExact(int x, int y, int[] result) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700801 final int hStartPadding = getLeftPadding();
802 final int vStartPadding = getTopPadding();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800803
804 result[0] = (x - hStartPadding) / (mCellWidth + mWidthGap);
805 result[1] = (y - vStartPadding) / (mCellHeight + mHeightGap);
806
Adam Cohend22015c2010-07-26 22:02:18 -0700807 final int xAxis = mCountX;
808 final int yAxis = mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800809
810 if (result[0] < 0) result[0] = 0;
811 if (result[0] >= xAxis) result[0] = xAxis - 1;
812 if (result[1] < 0) result[1] = 0;
813 if (result[1] >= yAxis) result[1] = yAxis - 1;
814 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700815
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800816 /**
817 * Given a point, return the cell that most closely encloses that point
818 * @param x X coordinate of the point
819 * @param y Y coordinate of the point
820 * @param result Array of 2 ints to hold the x and y coordinate of the cell
821 */
822 void pointToCellRounded(int x, int y, int[] result) {
823 pointToCellExact(x + (mCellWidth / 2), y + (mCellHeight / 2), result);
824 }
825
826 /**
827 * Given a cell coordinate, return the point that represents the upper left corner of that cell
Winson Chungaafa03c2010-06-11 17:34:16 -0700828 *
829 * @param cellX X coordinate of the cell
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800830 * @param cellY Y coordinate of the cell
Winson Chungaafa03c2010-06-11 17:34:16 -0700831 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800832 * @param result Array of 2 ints to hold the x and y coordinate of the point
833 */
834 void cellToPoint(int cellX, int cellY, int[] result) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700835 final int hStartPadding = getLeftPadding();
836 final int vStartPadding = getTopPadding();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800837
838 result[0] = hStartPadding + cellX * (mCellWidth + mWidthGap);
839 result[1] = vStartPadding + cellY * (mCellHeight + mHeightGap);
840 }
841
Romain Guy84f296c2009-11-04 15:00:44 -0800842 int getCellWidth() {
843 return mCellWidth;
844 }
845
846 int getCellHeight() {
847 return mCellHeight;
848 }
849
Romain Guy1a304a12009-11-10 00:02:32 -0800850 int getLeftPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700851 return mLeftPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800852 }
853
854 int getTopPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700855 return mTopPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800856 }
857
858 int getRightPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700859 return mRightPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800860 }
861
862 int getBottomPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700863 return mBottomPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800864 }
865
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800866 @Override
867 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
868 // TODO: currently ignoring padding
Winson Chungaafa03c2010-06-11 17:34:16 -0700869
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800870 int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
Winson Chungaafa03c2010-06-11 17:34:16 -0700871 int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
872
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800873 int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
874 int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
Winson Chungaafa03c2010-06-11 17:34:16 -0700875
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800876 if (widthSpecMode == MeasureSpec.UNSPECIFIED || heightSpecMode == MeasureSpec.UNSPECIFIED) {
877 throw new RuntimeException("CellLayout cannot have UNSPECIFIED dimensions");
878 }
879
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800880 final int cellWidth = mCellWidth;
881 final int cellHeight = mCellHeight;
882
Adam Cohend22015c2010-07-26 22:02:18 -0700883 int numWidthGaps = mCountX - 1;
884 int numHeightGaps = mCountY - 1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800885
Winson Chungece7f5b2010-10-22 14:54:12 -0700886 if (mWidthGap < 0 || mHeightGap < 0) {
887 int vSpaceLeft = heightSpecSize - mTopPadding - mBottomPadding - (cellHeight * mCountY);
888 mHeightGap = vSpaceLeft / numHeightGaps;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800889
Winson Chungece7f5b2010-10-22 14:54:12 -0700890 int hSpaceLeft = widthSpecSize - mLeftPadding - mRightPadding - (cellWidth * mCountX);
891 mWidthGap = hSpaceLeft / numWidthGaps;
Winson Chungaafa03c2010-06-11 17:34:16 -0700892
Winson Chungece7f5b2010-10-22 14:54:12 -0700893 // center it around the min gaps
894 int minGap = Math.min(mWidthGap, mHeightGap);
895 mWidthGap = mHeightGap = minGap;
896 }
Michael Jurka5f1c5092010-09-03 14:15:02 -0700897
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800898 int count = getChildCount();
899
900 for (int i = 0; i < count; i++) {
901 View child = getChildAt(i);
902 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Winson Chungaafa03c2010-06-11 17:34:16 -0700903 lp.setup(cellWidth, cellHeight, mWidthGap, mHeightGap,
904 mLeftPadding, mTopPadding);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800905
Michael Jurka0280c3b2010-09-17 15:00:07 -0700906 int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(lp.width, MeasureSpec.EXACTLY);
Winson Chungaafa03c2010-06-11 17:34:16 -0700907 int childheightMeasureSpec = MeasureSpec.makeMeasureSpec(lp.height,
908 MeasureSpec.EXACTLY);
909
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800910 child.measure(childWidthMeasureSpec, childheightMeasureSpec);
911 }
Michael Jurka5f1c5092010-09-03 14:15:02 -0700912 if (widthSpecMode == MeasureSpec.AT_MOST) {
913 int newWidth = mLeftPadding + mRightPadding + (mCountX * cellWidth) +
Winson Chungece7f5b2010-10-22 14:54:12 -0700914 ((mCountX - 1) * mWidthGap);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700915 int newHeight = mTopPadding + mBottomPadding + (mCountY * cellHeight) +
Winson Chungece7f5b2010-10-22 14:54:12 -0700916 ((mCountY - 1) * mHeightGap);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700917 setMeasuredDimension(newWidth, newHeight);
918 } else if (widthSpecMode == MeasureSpec.EXACTLY) {
919 setMeasuredDimension(widthSpecSize, heightSpecSize);
920 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800921 }
922
923 @Override
Michael Jurka28750fb2010-09-24 17:43:49 -0700924 protected void onLayout(boolean changed, int l, int t, int r, int b) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800925 int count = getChildCount();
926
927 for (int i = 0; i < count; i++) {
Patrick Dubroyce34a972010-10-19 10:34:32 -0700928 final View child = getChildAt(i);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800929 if (child.getVisibility() != GONE) {
930
931 CellLayout.LayoutParams lp = (CellLayout.LayoutParams) child.getLayoutParams();
932
933 int childLeft = lp.x;
934 int childTop = lp.y;
935 child.layout(childLeft, childTop, childLeft + lp.width, childTop + lp.height);
Romain Guy84f296c2009-11-04 15:00:44 -0800936
937 if (lp.dropped) {
938 lp.dropped = false;
939
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700940 final int[] cellXY = mTmpCellXY;
Romain Guy06762ab2010-01-25 16:51:08 -0800941 getLocationOnScreen(cellXY);
Jeff Brown1d0867c2010-12-02 18:27:39 -0800942 mWallpaperManager.sendWallpaperCommand(getWindowToken(),
943 WallpaperManager.COMMAND_DROP,
Romain Guy06762ab2010-01-25 16:51:08 -0800944 cellXY[0] + childLeft + lp.width / 2,
945 cellXY[1] + childTop + lp.height / 2, 0, null);
Patrick Dubroyce34a972010-10-19 10:34:32 -0700946
Michael Jurkad3ef3062010-11-23 16:23:58 -0800947 if (lp.animateDrop) {
948 lp.animateDrop = false;
949 ((Workspace) mParent).animateViewIntoPosition(child);
950 }
Romain Guy84f296c2009-11-04 15:00:44 -0800951 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800952 }
953 }
Michael Jurkabea15192010-11-17 12:33:46 -0800954 prepareCacheBitmap();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800955 }
956
957 @Override
Michael Jurkadee05892010-07-27 10:01:56 -0700958 protected void onSizeChanged(int w, int h, int oldw, int oldh) {
959 super.onSizeChanged(w, h, oldw, oldh);
Michael Jurka18014792010-10-14 09:01:34 -0700960 mBackgroundRect.set(0, 0, w, h);
Michael Jurka33945b22010-12-21 18:19:38 -0800961 updateGlowRect();
Michael Jurkabea15192010-11-17 12:33:46 -0800962 mCacheRect.set(0, 0, (int) (mBitmapCacheScale * w), (int) (mBitmapCacheScale * h));
963 mCache = null;
964 prepareCacheBitmap();
965 invalidateCache();
Michael Jurkadee05892010-07-27 10:01:56 -0700966 }
967
968 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800969 protected void setChildrenDrawingCacheEnabled(boolean enabled) {
970 final int count = getChildCount();
971 for (int i = 0; i < count; i++) {
972 final View view = getChildAt(i);
973 view.setDrawingCacheEnabled(enabled);
974 // Update the drawing caches
Romain Guy3cf4c032010-10-26 14:29:35 -0700975 if (!view.isHardwareAccelerated()) {
976 view.buildDrawingCache(true);
977 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800978 }
979 }
980
981 @Override
982 protected void setChildrenDrawnWithCacheEnabled(boolean enabled) {
983 super.setChildrenDrawnWithCacheEnabled(enabled);
984 }
985
Michael Jurka5f1c5092010-09-03 14:15:02 -0700986 public float getBackgroundAlpha() {
987 return mBackgroundAlpha;
Michael Jurkadee05892010-07-27 10:01:56 -0700988 }
989
Adam Cohen1b0aaac2010-10-28 11:11:18 -0700990 public void setBackgroundAlphaMultiplier(float multiplier) {
991 mBackgroundAlphaMultiplier = multiplier;
992 }
993
Adam Cohenddb82192010-11-10 16:32:54 -0800994 public float getBackgroundAlphaMultiplier() {
995 return mBackgroundAlphaMultiplier;
996 }
997
Michael Jurka5f1c5092010-09-03 14:15:02 -0700998 public void setBackgroundAlpha(float alpha) {
999 mBackgroundAlpha = alpha;
Michael Jurka0142d492010-08-25 17:46:15 -07001000 invalidate();
Michael Jurkadee05892010-07-27 10:01:56 -07001001 }
1002
Michael Jurka5f1c5092010-09-03 14:15:02 -07001003 // Need to return true to let the view system know we know how to handle alpha-- this is
1004 // because when our children have an alpha of 0.0f, they are still rendering their "dimmed"
1005 // versions
1006 @Override
1007 protected boolean onSetAlpha(int alpha) {
1008 return true;
1009 }
1010
1011 public void setAlpha(float alpha) {
1012 setChildrenAlpha(alpha);
1013 super.setAlpha(alpha);
1014 }
1015
Michael Jurkadee05892010-07-27 10:01:56 -07001016 private void setChildrenAlpha(float alpha) {
Michael Jurka0142d492010-08-25 17:46:15 -07001017 final int childCount = getChildCount();
1018 for (int i = 0; i < childCount; i++) {
Michael Jurkadee05892010-07-27 10:01:56 -07001019 getChildAt(i).setAlpha(alpha);
1020 }
1021 }
1022
Michael Jurka0280c3b2010-09-17 15:00:07 -07001023 private boolean isVacantIgnoring(
1024 int originX, int originY, int spanX, int spanY, View ignoreView) {
1025 if (ignoreView != null) {
1026 markCellsAsUnoccupiedForView(ignoreView);
1027 }
Michael Jurka28750fb2010-09-24 17:43:49 -07001028 boolean isVacant = true;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001029 for (int i = 0; i < spanY; i++) {
1030 if (!isRowEmpty(originY + i, originX, originX + spanX - 1, mOccupied)) {
Michael Jurka28750fb2010-09-24 17:43:49 -07001031 isVacant = false;
1032 break;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001033 }
1034 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001035 if (ignoreView != null) {
1036 markCellsAsOccupiedForView(ignoreView);
1037 }
Michael Jurka28750fb2010-09-24 17:43:49 -07001038 return isVacant;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001039 }
1040
Michael Jurka0280c3b2010-09-17 15:00:07 -07001041 private boolean isVacant(int originX, int originY, int spanX, int spanY) {
1042 return isVacantIgnoring(originX, originY, spanX, spanY, null);
1043 }
1044
Patrick Dubroy440c3602010-07-13 17:50:32 -07001045 public View getChildAt(int x, int y) {
1046 final int count = getChildCount();
1047 for (int i = 0; i < count; i++) {
1048 View child = getChildAt(i);
1049 LayoutParams lp = (LayoutParams) child.getLayoutParams();
1050
1051 if ((lp.cellX <= x) && (x < lp.cellX + lp.cellHSpan) &&
1052 (lp.cellY <= y) && (y < lp.cellY + lp.cellHSpan)) {
1053 return child;
1054 }
1055 }
1056 return null;
1057 }
1058
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001059 /**
1060 * Estimate where the top left cell of the dragged item will land if it is dropped.
1061 *
1062 * @param originX The X value of the top left corner of the item
1063 * @param originY The Y value of the top left corner of the item
1064 * @param spanX The number of horizontal cells that the item spans
1065 * @param spanY The number of vertical cells that the item spans
1066 * @param result The estimated drop cell X and Y.
1067 */
1068 void estimateDropCell(int originX, int originY, int spanX, int spanY, int[] result) {
Adam Cohend22015c2010-07-26 22:02:18 -07001069 final int countX = mCountX;
1070 final int countY = mCountY;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001071
Michael Jurkaa63c4522010-08-19 13:52:27 -07001072 // pointToCellRounded takes the top left of a cell but will pad that with
1073 // cellWidth/2 and cellHeight/2 when finding the matching cell
1074 pointToCellRounded(originX, originY, result);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001075
1076 // If the item isn't fully on this screen, snap to the edges
1077 int rightOverhang = result[0] + spanX - countX;
1078 if (rightOverhang > 0) {
1079 result[0] -= rightOverhang; // Snap to right
1080 }
1081 result[0] = Math.max(0, result[0]); // Snap to left
1082 int bottomOverhang = result[1] + spanY - countY;
1083 if (bottomOverhang > 0) {
1084 result[1] -= bottomOverhang; // Snap to bottom
1085 }
1086 result[1] = Math.max(0, result[1]); // Snap to top
1087 }
1088
Joe Onorato4be866d2010-10-10 11:26:02 -07001089 void visualizeDropLocation(
1090 View v, Bitmap dragOutline, int originX, int originY, int spanX, int spanY) {
1091
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001092 final int oldDragCellX = mDragCell[0];
1093 final int oldDragCellY = mDragCell[1];
Joe Onorato4be866d2010-10-10 11:26:02 -07001094 final int[] nearest = findNearestVacantArea(originX, originY, spanX, spanY, v, mDragCell);
Winson Chunga9abd0e2010-10-27 17:18:37 -07001095 if (v != null) {
1096 mDragCenter.set(originX + (v.getWidth() / 2), originY + (v.getHeight() / 2));
1097 } else {
1098 mDragCenter.set(originX, originY);
1099 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001100
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001101 if (nearest != null && (nearest[0] != oldDragCellX || nearest[1] != oldDragCellY)) {
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001102 // Find the top left corner of the rect the object will occupy
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001103 final int[] topLeft = mTmpPoint;
1104 cellToPoint(nearest[0], nearest[1], topLeft);
1105
Joe Onorato4be866d2010-10-10 11:26:02 -07001106 int left = topLeft[0];
1107 int top = topLeft[1];
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001108
Winson Chunga9abd0e2010-10-27 17:18:37 -07001109 if (v != null) {
1110 if (v.getParent() instanceof CellLayout) {
1111 LayoutParams lp = (LayoutParams) v.getLayoutParams();
1112 left += lp.leftMargin;
1113 top += lp.topMargin;
1114 }
Winson Chung150fbab2010-09-29 17:14:26 -07001115
Winson Chunga9abd0e2010-10-27 17:18:37 -07001116 // Offsets due to the size difference between the View and the dragOutline
1117 left += (v.getWidth() - dragOutline.getWidth()) / 2;
1118 top += (v.getHeight() - dragOutline.getHeight()) / 2;
1119 }
Winson Chung150fbab2010-09-29 17:14:26 -07001120
Joe Onorato4be866d2010-10-10 11:26:02 -07001121 final int oldIndex = mDragOutlineCurrent;
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001122 mDragOutlineAnims[oldIndex].animateOut();
1123 mDragOutlineCurrent = (oldIndex + 1) % mDragOutlines.length;
Winson Chung150fbab2010-09-29 17:14:26 -07001124
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001125 mDragOutlines[mDragOutlineCurrent].set(left, top);
1126 mDragOutlineAnims[mDragOutlineCurrent].setTag(dragOutline);
1127 mDragOutlineAnims[mDragOutlineCurrent].animateIn();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001128 }
Patrick Dubroy49250ad2010-10-08 15:33:52 -07001129
1130 // If we are drawing crosshairs, the entire CellLayout needs to be invalidated
1131 if (mCrosshairsDrawable != null) {
1132 invalidate();
1133 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001134 }
1135
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001136 /**
Jeff Sharkey70864282009-04-07 21:08:40 -07001137 * Find a vacant area that will fit the given bounds nearest the requested
1138 * cell location. Uses Euclidean distance to score multiple vacant areas.
Winson Chungaafa03c2010-06-11 17:34:16 -07001139 *
Romain Guy51afc022009-05-04 18:03:43 -07001140 * @param pixelX The X location at which you want to search for a vacant area.
1141 * @param pixelY The Y location at which you want to search for a vacant area.
Jeff Sharkey70864282009-04-07 21:08:40 -07001142 * @param spanX Horizontal span of the object.
1143 * @param spanY Vertical span of the object.
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001144 * @param result Array in which to place the result, or null (in which case a new array will
1145 * be allocated)
Jeff Sharkey70864282009-04-07 21:08:40 -07001146 * @return The X, Y cell of a vacant area that can contain this object,
1147 * nearest the requested location.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001148 */
Michael Jurka6a1435d2010-09-27 17:35:12 -07001149 int[] findNearestVacantArea(
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001150 int pixelX, int pixelY, int spanX, int spanY, int[] result) {
1151 return findNearestVacantArea(pixelX, pixelY, spanX, spanY, null, result);
Michael Jurka6a1435d2010-09-27 17:35:12 -07001152 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001153
Michael Jurka6a1435d2010-09-27 17:35:12 -07001154 /**
1155 * Find a vacant area that will fit the given bounds nearest the requested
1156 * cell location. Uses Euclidean distance to score multiple vacant areas.
1157 *
1158 * @param pixelX The X location at which you want to search for a vacant area.
1159 * @param pixelY The Y location at which you want to search for a vacant area.
1160 * @param spanX Horizontal span of the object.
1161 * @param spanY Vertical span of the object.
Michael Jurka6a1435d2010-09-27 17:35:12 -07001162 * @param ignoreView Considers space occupied by this view as unoccupied
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001163 * @param result Previously returned value to possibly recycle.
Michael Jurka6a1435d2010-09-27 17:35:12 -07001164 * @return The X, Y cell of a vacant area that can contain this object,
1165 * nearest the requested location.
1166 */
1167 int[] findNearestVacantArea(
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001168 int pixelX, int pixelY, int spanX, int spanY, View ignoreView, int[] result) {
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001169 // mark space take by ignoreView as available (method checks if ignoreView is null)
1170 markCellsAsUnoccupiedForView(ignoreView);
1171
Jeff Sharkey70864282009-04-07 21:08:40 -07001172 // Keep track of best-scoring drop area
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001173 final int[] bestXY = result != null ? result : new int[2];
Jeff Sharkey70864282009-04-07 21:08:40 -07001174 double bestDistance = Double.MAX_VALUE;
Winson Chungaafa03c2010-06-11 17:34:16 -07001175
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001176 final int countX = mCountX;
1177 final int countY = mCountY;
1178 final boolean[][] occupied = mOccupied;
1179
Winson Chungbbc60d82010-11-11 16:34:41 -08001180 for (int y = 0; y < countY - (spanY - 1); y++) {
Michael Jurkac28de512010-08-13 11:27:44 -07001181 inner:
Winson Chungbbc60d82010-11-11 16:34:41 -08001182 for (int x = 0; x < countX - (spanX - 1); x++) {
Michael Jurkac28de512010-08-13 11:27:44 -07001183 for (int i = 0; i < spanX; i++) {
1184 for (int j = 0; j < spanY; j++) {
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001185 if (occupied[x + i][y + j]) {
Winson Chungbbc60d82010-11-11 16:34:41 -08001186 // small optimization: we can skip to after the column we just found
Michael Jurkac28de512010-08-13 11:27:44 -07001187 // an occupied cell
Winson Chungbbc60d82010-11-11 16:34:41 -08001188 x += i;
Michael Jurkac28de512010-08-13 11:27:44 -07001189 continue inner;
1190 }
1191 }
1192 }
1193 final int[] cellXY = mTmpCellXY;
1194 cellToPoint(x, y, cellXY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001195
Michael Jurkac28de512010-08-13 11:27:44 -07001196 double distance = Math.sqrt(Math.pow(cellXY[0] - pixelX, 2)
1197 + Math.pow(cellXY[1] - pixelY, 2));
1198 if (distance <= bestDistance) {
1199 bestDistance = distance;
1200 bestXY[0] = x;
1201 bestXY[1] = y;
1202 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001203 }
1204 }
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001205 // re-mark space taken by ignoreView as occupied
1206 markCellsAsOccupiedForView(ignoreView);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001207
Winson Chungaafa03c2010-06-11 17:34:16 -07001208 // Return null if no suitable location found
Jeff Sharkey70864282009-04-07 21:08:40 -07001209 if (bestDistance < Double.MAX_VALUE) {
1210 return bestXY;
1211 } else {
1212 return null;
1213 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001214 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001215
Michael Jurka0280c3b2010-09-17 15:00:07 -07001216 boolean existsEmptyCell() {
1217 return findCellForSpan(null, 1, 1);
1218 }
1219
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001220 /**
Michael Jurka0280c3b2010-09-17 15:00:07 -07001221 * Finds the upper-left coordinate of the first rectangle in the grid that can
1222 * hold a cell of the specified dimensions. If intersectX and intersectY are not -1,
1223 * then this method will only return coordinates for rectangles that contain the cell
1224 * (intersectX, intersectY)
1225 *
1226 * @param cellXY The array that will contain the position of a vacant cell if such a cell
1227 * can be found.
1228 * @param spanX The horizontal span of the cell we want to find.
1229 * @param spanY The vertical span of the cell we want to find.
1230 *
1231 * @return True if a vacant cell of the specified dimension was found, false otherwise.
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001232 */
Michael Jurka0280c3b2010-09-17 15:00:07 -07001233 boolean findCellForSpan(int[] cellXY, int spanX, int spanY) {
1234 return findCellForSpanThatIntersectsIgnoring(cellXY, spanX, spanY, -1, -1, null);
1235 }
1236
1237 /**
1238 * Like above, but ignores any cells occupied by the item "ignoreView"
1239 *
1240 * @param cellXY The array that will contain the position of a vacant cell if such a cell
1241 * can be found.
1242 * @param spanX The horizontal span of the cell we want to find.
1243 * @param spanY The vertical span of the cell we want to find.
1244 * @param ignoreView The home screen item we should treat as not occupying any space
1245 * @return
1246 */
1247 boolean findCellForSpanIgnoring(int[] cellXY, int spanX, int spanY, View ignoreView) {
1248 return findCellForSpanThatIntersectsIgnoring(cellXY, spanX, spanY, -1, -1, ignoreView);
1249 }
1250
1251 /**
1252 * Like above, but if intersectX and intersectY are not -1, then this method will try to
1253 * return coordinates for rectangles that contain the cell [intersectX, intersectY]
1254 *
1255 * @param spanX The horizontal span of the cell we want to find.
1256 * @param spanY The vertical span of the cell we want to find.
1257 * @param ignoreView The home screen item we should treat as not occupying any space
1258 * @param intersectX The X coordinate of the cell that we should try to overlap
1259 * @param intersectX The Y coordinate of the cell that we should try to overlap
1260 *
1261 * @return True if a vacant cell of the specified dimension was found, false otherwise.
1262 */
1263 boolean findCellForSpanThatIntersects(int[] cellXY, int spanX, int spanY,
1264 int intersectX, int intersectY) {
1265 return findCellForSpanThatIntersectsIgnoring(
1266 cellXY, spanX, spanY, intersectX, intersectY, null);
1267 }
1268
1269 /**
1270 * The superset of the above two methods
1271 */
1272 boolean findCellForSpanThatIntersectsIgnoring(int[] cellXY, int spanX, int spanY,
1273 int intersectX, int intersectY, View ignoreView) {
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001274 // mark space take by ignoreView as available (method checks if ignoreView is null)
1275 markCellsAsUnoccupiedForView(ignoreView);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001276
Michael Jurka28750fb2010-09-24 17:43:49 -07001277 boolean foundCell = false;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001278 while (true) {
1279 int startX = 0;
1280 if (intersectX >= 0) {
1281 startX = Math.max(startX, intersectX - (spanX - 1));
1282 }
1283 int endX = mCountX - (spanX - 1);
1284 if (intersectX >= 0) {
1285 endX = Math.min(endX, intersectX + (spanX - 1) + (spanX == 1 ? 1 : 0));
1286 }
1287 int startY = 0;
1288 if (intersectY >= 0) {
1289 startY = Math.max(startY, intersectY - (spanY - 1));
1290 }
1291 int endY = mCountY - (spanY - 1);
1292 if (intersectY >= 0) {
1293 endY = Math.min(endY, intersectY + (spanY - 1) + (spanY == 1 ? 1 : 0));
1294 }
1295
Winson Chungbbc60d82010-11-11 16:34:41 -08001296 for (int y = startY; y < endY && !foundCell; y++) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001297 inner:
Winson Chungbbc60d82010-11-11 16:34:41 -08001298 for (int x = startX; x < endX; x++) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001299 for (int i = 0; i < spanX; i++) {
1300 for (int j = 0; j < spanY; j++) {
1301 if (mOccupied[x + i][y + j]) {
Winson Chungbbc60d82010-11-11 16:34:41 -08001302 // small optimization: we can skip to after the column we just found
Michael Jurka0280c3b2010-09-17 15:00:07 -07001303 // an occupied cell
Winson Chungbbc60d82010-11-11 16:34:41 -08001304 x += i;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001305 continue inner;
1306 }
1307 }
1308 }
1309 if (cellXY != null) {
1310 cellXY[0] = x;
1311 cellXY[1] = y;
1312 }
Michael Jurka28750fb2010-09-24 17:43:49 -07001313 foundCell = true;
1314 break;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001315 }
1316 }
1317 if (intersectX == -1 && intersectY == -1) {
1318 break;
1319 } else {
1320 // if we failed to find anything, try again but without any requirements of
1321 // intersecting
1322 intersectX = -1;
1323 intersectY = -1;
1324 continue;
1325 }
1326 }
1327
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001328 // re-mark space taken by ignoreView as occupied
1329 markCellsAsOccupiedForView(ignoreView);
Michael Jurka28750fb2010-09-24 17:43:49 -07001330 return foundCell;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001331 }
1332
1333 /**
1334 * Called when drag has left this CellLayout or has been completed (successfully or not)
1335 */
1336 void onDragExit() {
Joe Onorato4be866d2010-10-10 11:26:02 -07001337 // This can actually be called when we aren't in a drag, e.g. when adding a new
1338 // item to this layout via the customize drawer.
1339 // Guard against that case.
1340 if (mDragging) {
1341 mDragging = false;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001342
Joe Onorato4be866d2010-10-10 11:26:02 -07001343 // Fade out the drag indicators
1344 if (mCrosshairsAnimator != null) {
1345 mCrosshairsAnimator.animateOut();
1346 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001347 }
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001348
1349 // Invalidate the drag data
1350 mDragCell[0] = -1;
1351 mDragCell[1] = -1;
1352 mDragOutlineAnims[mDragOutlineCurrent].animateOut();
1353 mDragOutlineCurrent = (mDragOutlineCurrent + 1) % mDragOutlineAnims.length;
1354
Michael Jurka33945b22010-12-21 18:19:38 -08001355 setIsDragOverlapping(false);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001356 }
1357
1358 /**
Winson Chungaafa03c2010-06-11 17:34:16 -07001359 * Mark a child as having been dropped.
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001360 * At the beginning of the drag operation, the child may have been on another
Patrick Dubroyce34a972010-10-19 10:34:32 -07001361 * screen, but it is re-parented before this method is called.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001362 *
1363 * @param child The child that is being dropped
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001364 */
Michael Jurkad3ef3062010-11-23 16:23:58 -08001365 void onDropChild(View child, boolean animate) {
Romain Guyd94533d2009-08-17 10:01:15 -07001366 if (child != null) {
1367 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Romain Guyd94533d2009-08-17 10:01:15 -07001368 lp.isDragging = false;
Romain Guy84f296c2009-11-04 15:00:44 -08001369 lp.dropped = true;
Michael Jurkad3ef3062010-11-23 16:23:58 -08001370 lp.animateDrop = animate;
Patrick Dubroyce34a972010-10-19 10:34:32 -07001371 child.setVisibility(View.VISIBLE);
Romain Guyd94533d2009-08-17 10:01:15 -07001372 child.requestLayout();
Romain Guyd94533d2009-08-17 10:01:15 -07001373 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001374 }
1375
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001376 /**
1377 * Start dragging the specified child
Winson Chungaafa03c2010-06-11 17:34:16 -07001378 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001379 * @param child The child that is being dragged
1380 */
1381 void onDragChild(View child) {
1382 LayoutParams lp = (LayoutParams) child.getLayoutParams();
1383 lp.isDragging = true;
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001384 }
1385
1386 /**
1387 * A drag event has begun over this layout.
1388 * It may have begun over this layout (in which case onDragChild is called first),
1389 * or it may have begun on another layout.
1390 */
Winson Chunga9abd0e2010-10-27 17:18:37 -07001391 void onDragEnter() {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -07001392 if (!mDragging) {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -07001393 // Fade in the drag indicators
1394 if (mCrosshairsAnimator != null) {
1395 mCrosshairsAnimator.animateIn();
1396 }
Joe Onorato4be866d2010-10-10 11:26:02 -07001397 }
1398 mDragging = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001399 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001400
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001401 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001402 * Computes a bounding rectangle for a range of cells
Winson Chungaafa03c2010-06-11 17:34:16 -07001403 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001404 * @param cellX X coordinate of upper left corner expressed as a cell position
1405 * @param cellY Y coordinate of upper left corner expressed as a cell position
Winson Chungaafa03c2010-06-11 17:34:16 -07001406 * @param cellHSpan Width in cells
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001407 * @param cellVSpan Height in cells
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001408 * @param resultRect Rect into which to put the results
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001409 */
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001410 public void cellToRect(int cellX, int cellY, int cellHSpan, int cellVSpan, RectF resultRect) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001411 final int cellWidth = mCellWidth;
1412 final int cellHeight = mCellHeight;
1413 final int widthGap = mWidthGap;
1414 final int heightGap = mHeightGap;
Winson Chungaafa03c2010-06-11 17:34:16 -07001415
1416 final int hStartPadding = getLeftPadding();
1417 final int vStartPadding = getTopPadding();
1418
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001419 int width = cellHSpan * cellWidth + ((cellHSpan - 1) * widthGap);
1420 int height = cellVSpan * cellHeight + ((cellVSpan - 1) * heightGap);
1421
1422 int x = hStartPadding + cellX * (cellWidth + widthGap);
1423 int y = vStartPadding + cellY * (cellHeight + heightGap);
Winson Chungaafa03c2010-06-11 17:34:16 -07001424
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001425 resultRect.set(x, y, x + width, y + height);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001426 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001427
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001428 /**
Winson Chungaafa03c2010-06-11 17:34:16 -07001429 * Computes the required horizontal and vertical cell spans to always
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001430 * fit the given rectangle.
Winson Chungaafa03c2010-06-11 17:34:16 -07001431 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001432 * @param width Width in pixels
1433 * @param height Height in pixels
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001434 * @param result An array of length 2 in which to store the result (may be null).
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001435 */
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001436 public int[] rectToCell(int width, int height, int[] result) {
Michael Jurka9987a5c2010-10-08 16:58:12 -07001437 return rectToCell(getResources(), width, height, result);
1438 }
1439
1440 public static int[] rectToCell(Resources resources, int width, int height, int[] result) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001441 // Always assume we're working with the smallest span to make sure we
1442 // reserve enough space in both orientations.
Joe Onorato79e56262009-09-21 15:23:04 -04001443 int actualWidth = resources.getDimensionPixelSize(R.dimen.workspace_cell_width);
1444 int actualHeight = resources.getDimensionPixelSize(R.dimen.workspace_cell_height);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001445 int smallerSize = Math.min(actualWidth, actualHeight);
Joe Onorato79e56262009-09-21 15:23:04 -04001446
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001447 // Always round up to next largest cell
1448 int spanX = (width + smallerSize) / smallerSize;
1449 int spanY = (height + smallerSize) / smallerSize;
Joe Onorato79e56262009-09-21 15:23:04 -04001450
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001451 if (result == null) {
1452 return new int[] { spanX, spanY };
1453 }
1454 result[0] = spanX;
1455 result[1] = spanY;
1456 return result;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001457 }
1458
1459 /**
Patrick Dubroy047379a2010-12-19 22:02:04 -08001460 * Calculate the grid spans needed to fit given item
1461 */
1462 public void calculateSpans(ItemInfo info) {
1463 final int minWidth;
1464 final int minHeight;
1465
1466 if (info instanceof LauncherAppWidgetInfo) {
1467 minWidth = ((LauncherAppWidgetInfo) info).minWidth;
1468 minHeight = ((LauncherAppWidgetInfo) info).minHeight;
1469 } else if (info instanceof PendingAddWidgetInfo) {
1470 minWidth = ((PendingAddWidgetInfo) info).minWidth;
1471 minHeight = ((PendingAddWidgetInfo) info).minHeight;
1472 } else {
1473 // It's not a widget, so it must be 1x1
1474 info.spanX = info.spanY = 1;
1475 return;
1476 }
1477 int[] spans = rectToCell(minWidth, minHeight, null);
1478 info.spanX = spans[0];
1479 info.spanY = spans[1];
1480 }
1481
1482 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001483 * Find the first vacant cell, if there is one.
1484 *
1485 * @param vacant Holds the x and y coordinate of the vacant cell
1486 * @param spanX Horizontal cell span.
1487 * @param spanY Vertical cell span.
Winson Chungaafa03c2010-06-11 17:34:16 -07001488 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001489 * @return True if a vacant cell was found
1490 */
1491 public boolean getVacantCell(int[] vacant, int spanX, int spanY) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001492
Michael Jurka0280c3b2010-09-17 15:00:07 -07001493 return findVacantCell(vacant, spanX, spanY, mCountX, mCountY, mOccupied);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001494 }
1495
1496 static boolean findVacantCell(int[] vacant, int spanX, int spanY,
1497 int xCount, int yCount, boolean[][] occupied) {
1498
1499 for (int x = 0; x < xCount; x++) {
1500 for (int y = 0; y < yCount; y++) {
1501 boolean available = !occupied[x][y];
1502out: for (int i = x; i < x + spanX - 1 && x < xCount; i++) {
1503 for (int j = y; j < y + spanY - 1 && y < yCount; j++) {
1504 available = available && !occupied[i][j];
1505 if (!available) break out;
1506 }
1507 }
1508
1509 if (available) {
1510 vacant[0] = x;
1511 vacant[1] = y;
1512 return true;
1513 }
1514 }
1515 }
1516
1517 return false;
1518 }
1519
Michael Jurka0280c3b2010-09-17 15:00:07 -07001520 private void clearOccupiedCells() {
1521 for (int x = 0; x < mCountX; x++) {
1522 for (int y = 0; y < mCountY; y++) {
1523 mOccupied[x][y] = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001524 }
1525 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001526 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001527
Michael Jurka0280c3b2010-09-17 15:00:07 -07001528 public void onMove(View view, int newCellX, int newCellY) {
1529 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1530 markCellsAsUnoccupiedForView(view);
1531 markCellsForView(newCellX, newCellY, lp.cellHSpan, lp.cellVSpan, true);
1532 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001533
Michael Jurka0280c3b2010-09-17 15:00:07 -07001534 private void markCellsAsOccupiedForView(View view) {
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001535 if (view == null || view.getParent() != this) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001536 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1537 markCellsForView(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan, true);
1538 }
1539
1540 private void markCellsAsUnoccupiedForView(View view) {
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001541 if (view == null || view.getParent() != this) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001542 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1543 markCellsForView(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan, false);
1544 }
1545
1546 private void markCellsForView(int cellX, int cellY, int spanX, int spanY, boolean value) {
1547 for (int x = cellX; x < cellX + spanX && x < mCountX; x++) {
1548 for (int y = cellY; y < cellY + spanY && y < mCountY; y++) {
1549 mOccupied[x][y] = value;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001550 }
1551 }
1552 }
1553
1554 @Override
1555 public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
1556 return new CellLayout.LayoutParams(getContext(), attrs);
1557 }
1558
1559 @Override
1560 protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
1561 return p instanceof CellLayout.LayoutParams;
1562 }
1563
1564 @Override
1565 protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
1566 return new CellLayout.LayoutParams(p);
1567 }
1568
Winson Chungaafa03c2010-06-11 17:34:16 -07001569 public static class CellLayoutAnimationController extends LayoutAnimationController {
1570 public CellLayoutAnimationController(Animation animation, float delay) {
1571 super(animation, delay);
1572 }
1573
1574 @Override
1575 protected long getDelayForView(View view) {
1576 return (int) (Math.random() * 150);
1577 }
1578 }
1579
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001580 public static class LayoutParams extends ViewGroup.MarginLayoutParams {
1581 /**
1582 * Horizontal location of the item in the grid.
1583 */
1584 @ViewDebug.ExportedProperty
1585 public int cellX;
1586
1587 /**
1588 * Vertical location of the item in the grid.
1589 */
1590 @ViewDebug.ExportedProperty
1591 public int cellY;
1592
1593 /**
1594 * Number of cells spanned horizontally by the item.
1595 */
1596 @ViewDebug.ExportedProperty
1597 public int cellHSpan;
1598
1599 /**
1600 * Number of cells spanned vertically by the item.
1601 */
1602 @ViewDebug.ExportedProperty
1603 public int cellVSpan;
Winson Chungaafa03c2010-06-11 17:34:16 -07001604
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001605 /**
1606 * Is this item currently being dragged
1607 */
1608 public boolean isDragging;
1609
1610 // X coordinate of the view in the layout.
1611 @ViewDebug.ExportedProperty
1612 int x;
1613 // Y coordinate of the view in the layout.
1614 @ViewDebug.ExportedProperty
1615 int y;
1616
Patrick Dubroyce34a972010-10-19 10:34:32 -07001617 /**
1618 * The old X coordinate of this item, relative to its current parent.
1619 * Used to animate the item into its new position.
1620 */
1621 int oldX;
1622
1623 /**
1624 * The old Y coordinate of this item, relative to its current parent.
1625 * Used to animate the item into its new position.
1626 */
1627 int oldY;
1628
Romain Guy84f296c2009-11-04 15:00:44 -08001629 boolean dropped;
Romain Guyfcb9e712009-10-02 16:06:52 -07001630
Michael Jurkad3ef3062010-11-23 16:23:58 -08001631 boolean animateDrop;
1632
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001633 public LayoutParams(Context c, AttributeSet attrs) {
1634 super(c, attrs);
1635 cellHSpan = 1;
1636 cellVSpan = 1;
1637 }
1638
1639 public LayoutParams(ViewGroup.LayoutParams source) {
1640 super(source);
1641 cellHSpan = 1;
1642 cellVSpan = 1;
1643 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001644
1645 public LayoutParams(LayoutParams source) {
1646 super(source);
1647 this.cellX = source.cellX;
1648 this.cellY = source.cellY;
1649 this.cellHSpan = source.cellHSpan;
1650 this.cellVSpan = source.cellVSpan;
1651 }
1652
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001653 public LayoutParams(int cellX, int cellY, int cellHSpan, int cellVSpan) {
Romain Guy8f19cdd2010-01-08 15:07:00 -08001654 super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001655 this.cellX = cellX;
1656 this.cellY = cellY;
1657 this.cellHSpan = cellHSpan;
1658 this.cellVSpan = cellVSpan;
1659 }
1660
1661 public void setup(int cellWidth, int cellHeight, int widthGap, int heightGap,
1662 int hStartPadding, int vStartPadding) {
Winson Chungaafa03c2010-06-11 17:34:16 -07001663
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001664 final int myCellHSpan = cellHSpan;
1665 final int myCellVSpan = cellVSpan;
1666 final int myCellX = cellX;
1667 final int myCellY = cellY;
Winson Chungaafa03c2010-06-11 17:34:16 -07001668
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001669 width = myCellHSpan * cellWidth + ((myCellHSpan - 1) * widthGap) -
1670 leftMargin - rightMargin;
1671 height = myCellVSpan * cellHeight + ((myCellVSpan - 1) * heightGap) -
1672 topMargin - bottomMargin;
1673
1674 x = hStartPadding + myCellX * (cellWidth + widthGap) + leftMargin;
1675 y = vStartPadding + myCellY * (cellHeight + heightGap) + topMargin;
1676 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001677
1678 public String toString() {
1679 return "(" + this.cellX + ", " + this.cellY + ")";
1680 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001681 }
1682
Michael Jurka0280c3b2010-09-17 15:00:07 -07001683 // This class stores info for two purposes:
1684 // 1. When dragging items (mDragInfo in Workspace), we store the View, its cellX & cellY,
1685 // its spanX, spanY, and the screen it is on
1686 // 2. When long clicking on an empty cell in a CellLayout, we save information about the
1687 // cellX and cellY coordinates and which page was clicked. We then set this as a tag on
1688 // the CellLayout that was long clicked
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001689 static final class CellInfo implements ContextMenu.ContextMenuInfo {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001690 View cell;
Michael Jurkaa63c4522010-08-19 13:52:27 -07001691 int cellX = -1;
1692 int cellY = -1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001693 int spanX;
1694 int spanY;
1695 int screen;
1696 boolean valid;
1697
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001698 @Override
1699 public String toString() {
Winson Chungaafa03c2010-06-11 17:34:16 -07001700 return "Cell[view=" + (cell == null ? "null" : cell.getClass())
1701 + ", x=" + cellX + ", y=" + cellY + "]";
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001702 }
1703 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001704}