blob: 6767cf1bff37f8d1ca244143f1014d4643d89a29 [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;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080028import android.content.Context;
Joe Onorato79e56262009-09-21 15:23:04 -040029import android.content.res.Resources;
Winson Chungaafa03c2010-06-11 17:34:16 -070030import android.content.res.TypedArray;
Joe Onorato4be866d2010-10-10 11:26:02 -070031import android.graphics.Bitmap;
Winson Chungaafa03c2010-06-11 17:34:16 -070032import android.graphics.Canvas;
Joe Onorato4be866d2010-10-10 11:26:02 -070033import android.graphics.Paint;
Patrick Dubroyde7658b2010-09-27 11:15:43 -070034import android.graphics.Point;
35import android.graphics.PointF;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080036import android.graphics.Rect;
37import android.graphics.RectF;
Michael Jurka18014792010-10-14 09:01:34 -070038import android.graphics.Region;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070039import android.graphics.drawable.Drawable;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080040import android.util.AttributeSet;
Joe Onorato4be866d2010-10-10 11:26:02 -070041import android.util.Log;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080042import android.view.ContextMenu;
43import android.view.MotionEvent;
44import android.view.View;
45import android.view.ViewDebug;
46import android.view.ViewGroup;
Winson Chungaafa03c2010-06-11 17:34:16 -070047import android.view.animation.Animation;
Winson Chung150fbab2010-09-29 17:14:26 -070048import android.view.animation.DecelerateInterpolator;
Winson Chungaafa03c2010-06-11 17:34:16 -070049import android.view.animation.LayoutAnimationController;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080050
Michael Jurka3c4c20f2010-10-28 15:36:06 -070051import java.util.Arrays;
Patrick Dubroy8e58e912010-10-14 13:21:48 -070052
Michael Jurkacf6125c2011-01-28 15:20:01 -080053public class CellLayout extends CachedViewGroup {
Winson Chungaafa03c2010-06-11 17:34:16 -070054 static final String TAG = "CellLayout";
55
The Android Open Source Project31dd5032009-03-03 19:32:27 -080056 private int mCellWidth;
57 private int mCellHeight;
Winson Chungaafa03c2010-06-11 17:34:16 -070058
Winson Chungaafa03c2010-06-11 17:34:16 -070059 private int mLeftPadding;
60 private int mRightPadding;
61 private int mTopPadding;
62 private int mBottomPadding;
63
Adam Cohend22015c2010-07-26 22:02:18 -070064 private int mCountX;
65 private int mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080066
67 private int mWidthGap;
68 private int mHeightGap;
69
70 private final Rect mRect = new Rect();
71 private final CellInfo mCellInfo = new CellInfo();
Winson Chungaafa03c2010-06-11 17:34:16 -070072
Patrick Dubroyde7658b2010-09-27 11:15:43 -070073 // These are temporary variables to prevent having to allocate a new object just to
74 // return an (x, y) value from helper functions. Do NOT use them to maintain other state.
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070075 private final int[] mTmpCellXY = new int[2];
Patrick Dubroyde7658b2010-09-27 11:15:43 -070076 private final int[] mTmpPoint = new int[2];
77 private final PointF mTmpPointF = new PointF();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070078
The Android Open Source Project31dd5032009-03-03 19:32:27 -080079 boolean[][] mOccupied;
80
Michael Jurkadee05892010-07-27 10:01:56 -070081 private OnTouchListener mInterceptTouchListener;
82
Michael Jurka5f1c5092010-09-03 14:15:02 -070083 private float mBackgroundAlpha;
Adam Cohen1b0aaac2010-10-28 11:11:18 -070084 private float mBackgroundAlphaMultiplier = 1.0f;
Adam Cohenf34bab52010-09-30 14:11:56 -070085
Michael Jurka33945b22010-12-21 18:19:38 -080086 private Drawable mNormalBackground;
Michael Jurka33945b22010-12-21 18:19:38 -080087 private Drawable mActiveBackground;
88 private Drawable mActiveGlowBackground;
89 private Drawable mNormalBackgroundMini;
90 private Drawable mNormalGlowBackgroundMini;
91 private Drawable mActiveBackgroundMini;
92 private Drawable mActiveGlowBackgroundMini;
Michael Jurka18014792010-10-14 09:01:34 -070093 private Rect mBackgroundRect;
Michael Jurka33945b22010-12-21 18:19:38 -080094 private Rect mGlowBackgroundRect;
95 private float mGlowBackgroundScale;
96 private float mGlowBackgroundAlpha;
Patrick Dubroy1262e362010-10-06 15:49:50 -070097
Michael Jurka33945b22010-12-21 18:19:38 -080098 private boolean mAcceptsDrops = false;
99 // If we're actively dragging something over this screen, mIsDragOverlapping is true
100 private boolean mIsDragOverlapping = false;
101 private boolean mIsDragOccuring = false;
102 private boolean mIsDefaultDropTarget = false;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700103 private final Point mDragCenter = new Point();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700104
Winson Chung150fbab2010-09-29 17:14:26 -0700105 // These arrays are used to implement the drag visualization on x-large screens.
Joe Onorato4be866d2010-10-10 11:26:02 -0700106 // They are used as circular arrays, indexed by mDragOutlineCurrent.
107 private Point[] mDragOutlines = new Point[8];
Chet Haase472b2812010-10-14 07:02:04 -0700108 private float[] mDragOutlineAlphas = new float[mDragOutlines.length];
Joe Onorato4be866d2010-10-10 11:26:02 -0700109 private InterruptibleInOutAnimator[] mDragOutlineAnims =
110 new InterruptibleInOutAnimator[mDragOutlines.length];
Winson Chung150fbab2010-09-29 17:14:26 -0700111
112 // Used as an index into the above 3 arrays; indicates which is the most current value.
Joe Onorato4be866d2010-10-10 11:26:02 -0700113 private int mDragOutlineCurrent = 0;
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700114 private final Paint mDragOutlinePaint = new Paint();
Winson Chung150fbab2010-09-29 17:14:26 -0700115
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700116 private Drawable mCrosshairsDrawable = null;
Patrick Dubroy49250ad2010-10-08 15:33:52 -0700117 private InterruptibleInOutAnimator mCrosshairsAnimator = null;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700118 private float mCrosshairsVisibility = 0.0f;
119
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700120 // When a drag operation is in progress, holds the nearest cell to the touch point
121 private final int[] mDragCell = new int[2];
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800122
Joe Onorato4be866d2010-10-10 11:26:02 -0700123 private boolean mDragging = false;
124
Patrick Dubroyce34a972010-10-19 10:34:32 -0700125 private TimeInterpolator mEaseOutInterpolator;
Michael Jurka8c920dd2011-01-20 14:16:56 -0800126 private CellLayoutChildren mChildren;
Patrick Dubroyce34a972010-10-19 10:34:32 -0700127
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800128 public CellLayout(Context context) {
129 this(context, null);
130 }
131
132 public CellLayout(Context context, AttributeSet attrs) {
133 this(context, attrs, 0);
134 }
135
136 public CellLayout(Context context, AttributeSet attrs, int defStyle) {
137 super(context, attrs, defStyle);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700138
139 // A ViewGroup usually does not draw, but CellLayout needs to draw a rectangle to show
140 // the user where a dragged item will land when dropped.
141 setWillNotDraw(false);
Michael Jurkaa63c4522010-08-19 13:52:27 -0700142
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800143 TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CellLayout, defStyle, 0);
144
145 mCellWidth = a.getDimensionPixelSize(R.styleable.CellLayout_cellWidth, 10);
146 mCellHeight = a.getDimensionPixelSize(R.styleable.CellLayout_cellHeight, 10);
Winson Chungece7f5b2010-10-22 14:54:12 -0700147 mWidthGap = a.getDimensionPixelSize(R.styleable.CellLayout_widthGap, -1);
148 mHeightGap = a.getDimensionPixelSize(R.styleable.CellLayout_heightGap, -1);
Winson Chungaafa03c2010-06-11 17:34:16 -0700149
Adam Cohend22015c2010-07-26 22:02:18 -0700150 mLeftPadding =
151 a.getDimensionPixelSize(R.styleable.CellLayout_xAxisStartPadding, 10);
152 mRightPadding =
153 a.getDimensionPixelSize(R.styleable.CellLayout_xAxisEndPadding, 10);
154 mTopPadding =
155 a.getDimensionPixelSize(R.styleable.CellLayout_yAxisStartPadding, 10);
156 mBottomPadding =
157 a.getDimensionPixelSize(R.styleable.CellLayout_yAxisEndPadding, 10);
Winson Chungaafa03c2010-06-11 17:34:16 -0700158
Adam Cohend22015c2010-07-26 22:02:18 -0700159 mCountX = LauncherModel.getCellCountX();
160 mCountY = LauncherModel.getCellCountY();
Michael Jurka0280c3b2010-09-17 15:00:07 -0700161 mOccupied = new boolean[mCountX][mCountY];
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800162
163 a.recycle();
164
165 setAlwaysDrawnWithCacheEnabled(false);
166
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700167 final Resources res = getResources();
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700168
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700169 if (LauncherApplication.isScreenXLarge()) {
Michael Jurka33945b22010-12-21 18:19:38 -0800170 mNormalBackground = res.getDrawable(R.drawable.homescreen_large_blue);
Michael Jurka33945b22010-12-21 18:19:38 -0800171 mActiveBackground = res.getDrawable(R.drawable.homescreen_large_green);
172 mActiveGlowBackground = res.getDrawable(R.drawable.homescreen_large_green_strong);
173
174 mNormalBackgroundMini = res.getDrawable(R.drawable.homescreen_small_blue);
175 mNormalGlowBackgroundMini = res.getDrawable(R.drawable.homescreen_small_blue_strong);
176 mActiveBackgroundMini = res.getDrawable(R.drawable.homescreen_small_green);
177 mActiveGlowBackgroundMini = res.getDrawable(R.drawable.homescreen_small_green_strong);
178
179 mNormalBackground.setFilterBitmap(true);
Michael Jurka33945b22010-12-21 18:19:38 -0800180 mActiveBackground.setFilterBitmap(true);
181 mActiveGlowBackground.setFilterBitmap(true);
182 mNormalBackgroundMini.setFilterBitmap(true);
183 mNormalGlowBackgroundMini.setFilterBitmap(true);
184 mActiveBackgroundMini.setFilterBitmap(true);
185 mActiveGlowBackgroundMini.setFilterBitmap(true);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700186 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700187
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700188 // Initialize the data structures used for the drag visualization.
Winson Chung150fbab2010-09-29 17:14:26 -0700189
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700190 mCrosshairsDrawable = res.getDrawable(R.drawable.gardening_crosshairs);
Patrick Dubroyce34a972010-10-19 10:34:32 -0700191 mEaseOutInterpolator = new DecelerateInterpolator(2.5f); // Quint ease out
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700192
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700193 // Set up the animation for fading the crosshairs in and out
194 int animDuration = res.getInteger(R.integer.config_crosshairsFadeInTime);
Patrick Dubroy49250ad2010-10-08 15:33:52 -0700195 mCrosshairsAnimator = new InterruptibleInOutAnimator(animDuration, 0.0f, 1.0f);
Chet Haase472b2812010-10-14 07:02:04 -0700196 mCrosshairsAnimator.getAnimator().addUpdateListener(new AnimatorUpdateListener() {
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700197 public void onAnimationUpdate(ValueAnimator animation) {
198 mCrosshairsVisibility = ((Float) animation.getAnimatedValue()).floatValue();
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700199 invalidate();
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700200 }
201 });
Patrick Dubroyce34a972010-10-19 10:34:32 -0700202 mCrosshairsAnimator.getAnimator().setInterpolator(mEaseOutInterpolator);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700203
Joe Onorato4be866d2010-10-10 11:26:02 -0700204 for (int i = 0; i < mDragOutlines.length; i++) {
205 mDragOutlines[i] = new Point(-1, -1);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700206 }
207
208 // When dragging things around the home screens, we show a green outline of
209 // where the item will land. The outlines gradually fade out, leaving a trail
210 // behind the drag path.
211 // Set up all the animations that are used to implement this fading.
212 final int duration = res.getInteger(R.integer.config_dragOutlineFadeTime);
Chet Haase472b2812010-10-14 07:02:04 -0700213 final float fromAlphaValue = 0;
214 final float toAlphaValue = (float)res.getInteger(R.integer.config_dragOutlineMaxAlpha);
Joe Onorato4be866d2010-10-10 11:26:02 -0700215
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700216 Arrays.fill(mDragOutlineAlphas, fromAlphaValue);
Joe Onorato4be866d2010-10-10 11:26:02 -0700217
218 for (int i = 0; i < mDragOutlineAnims.length; i++) {
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700219 final InterruptibleInOutAnimator anim =
220 new InterruptibleInOutAnimator(duration, fromAlphaValue, toAlphaValue);
Patrick Dubroyce34a972010-10-19 10:34:32 -0700221 anim.getAnimator().setInterpolator(mEaseOutInterpolator);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700222 final int thisIndex = i;
Chet Haase472b2812010-10-14 07:02:04 -0700223 anim.getAnimator().addUpdateListener(new AnimatorUpdateListener() {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700224 public void onAnimationUpdate(ValueAnimator animation) {
Joe Onorato4be866d2010-10-10 11:26:02 -0700225 final Bitmap outline = (Bitmap)anim.getTag();
226
227 // If an animation is started and then stopped very quickly, we can still
228 // get spurious updates we've cleared the tag. Guard against this.
229 if (outline == null) {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -0700230 if (false) {
231 Object val = animation.getAnimatedValue();
232 Log.d(TAG, "anim " + thisIndex + " update: " + val +
233 ", isStopped " + anim.isStopped());
234 }
Joe Onorato4be866d2010-10-10 11:26:02 -0700235 // Try to prevent it from continuing to run
236 animation.cancel();
237 } else {
Chet Haase472b2812010-10-14 07:02:04 -0700238 mDragOutlineAlphas[thisIndex] = (Float) animation.getAnimatedValue();
Joe Onorato4be866d2010-10-10 11:26:02 -0700239 final int left = mDragOutlines[thisIndex].x;
240 final int top = mDragOutlines[thisIndex].y;
241 CellLayout.this.invalidate(left, top,
242 left + outline.getWidth(), top + outline.getHeight());
243 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700244 }
245 });
Joe Onorato4be866d2010-10-10 11:26:02 -0700246 // The animation holds a reference to the drag outline bitmap as long is it's
247 // running. This way the bitmap can be GCed when the animations are complete.
Chet Haase472b2812010-10-14 07:02:04 -0700248 anim.getAnimator().addListener(new AnimatorListenerAdapter() {
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700249 @Override
Joe Onorato4be866d2010-10-10 11:26:02 -0700250 public void onAnimationEnd(Animator animation) {
Chet Haase472b2812010-10-14 07:02:04 -0700251 if ((Float) ((ValueAnimator) animation).getAnimatedValue() == 0f) {
Joe Onorato4be866d2010-10-10 11:26:02 -0700252 anim.setTag(null);
253 }
254 }
255 });
256 mDragOutlineAnims[i] = anim;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700257 }
Patrick Dubroyce34a972010-10-19 10:34:32 -0700258
Michael Jurka18014792010-10-14 09:01:34 -0700259 mBackgroundRect = new Rect();
Michael Jurka33945b22010-12-21 18:19:38 -0800260 mGlowBackgroundRect = new Rect();
Michael Jurka18014792010-10-14 09:01:34 -0700261 setHoverScale(1.0f);
262 setHoverAlpha(1.0f);
Michael Jurkabea15192010-11-17 12:33:46 -0800263
Michael Jurka8c920dd2011-01-20 14:16:56 -0800264 mChildren = new CellLayoutChildren(context);
265 mChildren.setCellDimensions(
266 mCellWidth, mCellHeight, mLeftPadding, mTopPadding, mWidthGap, mHeightGap);
267 addView(mChildren);
Michael Jurka18014792010-10-14 09:01:34 -0700268 }
269
Winson Chung6e314082011-01-27 16:46:51 -0800270 public CellLayoutChildren getChildrenLayout() {
271 if (getChildCount() > 0) {
272 return (CellLayoutChildren) getChildAt(0);
273 }
274 return null;
275 }
276
Michael Jurka33945b22010-12-21 18:19:38 -0800277 public void setIsDefaultDropTarget(boolean isDefaultDropTarget) {
278 if (mIsDefaultDropTarget != isDefaultDropTarget) {
279 mIsDefaultDropTarget = isDefaultDropTarget;
280 invalidate();
281 }
282 }
283
Michael Jurka33945b22010-12-21 18:19:38 -0800284 void setIsDragOccuring(boolean isDragOccuring) {
285 if (mIsDragOccuring != isDragOccuring) {
286 mIsDragOccuring = isDragOccuring;
287 invalidate();
288 }
289 }
290
291 void setIsDragOverlapping(boolean isDragOverlapping) {
292 if (mIsDragOverlapping != isDragOverlapping) {
293 mIsDragOverlapping = isDragOverlapping;
294 invalidate();
295 }
296 }
297
298 boolean getIsDragOverlapping() {
299 return mIsDragOverlapping;
300 }
301
302 private void updateGlowRect() {
303 float marginFraction = (mGlowBackgroundScale - 1.0f) / 2.0f;
Michael Jurka18014792010-10-14 09:01:34 -0700304 int marginX = (int) (marginFraction * (mBackgroundRect.right - mBackgroundRect.left));
305 int marginY = (int) (marginFraction * (mBackgroundRect.bottom - mBackgroundRect.top));
Michael Jurka33945b22010-12-21 18:19:38 -0800306 mGlowBackgroundRect.set(mBackgroundRect.left - marginX, mBackgroundRect.top - marginY,
Michael Jurka18014792010-10-14 09:01:34 -0700307 mBackgroundRect.right + marginX, mBackgroundRect.bottom + marginY);
308 invalidate();
309 }
310
311 public void setHoverScale(float scaleFactor) {
Michael Jurka33945b22010-12-21 18:19:38 -0800312 if (scaleFactor != mGlowBackgroundScale) {
313 mGlowBackgroundScale = scaleFactor;
314 updateGlowRect();
Michael Jurka8deb1e62011-01-25 16:27:43 -0800315 if (getParent() != null) {
316 ((View) getParent()).invalidate();
317 }
Michael Jurka18014792010-10-14 09:01:34 -0700318 }
319 }
320
321 public float getHoverScale() {
Michael Jurka33945b22010-12-21 18:19:38 -0800322 return mGlowBackgroundScale;
Michael Jurka18014792010-10-14 09:01:34 -0700323 }
324
325 public float getHoverAlpha() {
Michael Jurka33945b22010-12-21 18:19:38 -0800326 return mGlowBackgroundAlpha;
Michael Jurka18014792010-10-14 09:01:34 -0700327 }
328
329 public void setHoverAlpha(float alpha) {
Michael Jurka33945b22010-12-21 18:19:38 -0800330 mGlowBackgroundAlpha = alpha;
Michael Jurka18014792010-10-14 09:01:34 -0700331 invalidate();
332 }
333
334 void animateDrop() {
335 if (LauncherApplication.isScreenXLarge()) {
336 Resources res = getResources();
337 float onDropScale = res.getInteger(R.integer.config_screenOnDropScalePercent) / 100.0f;
338 ObjectAnimator scaleUp = ObjectAnimator.ofFloat(this, "hoverScale", onDropScale);
339 scaleUp.setDuration(res.getInteger(R.integer.config_screenOnDropScaleUpDuration));
340 ObjectAnimator scaleDown = ObjectAnimator.ofFloat(this, "hoverScale", 1.0f);
341 scaleDown.setDuration(res.getInteger(R.integer.config_screenOnDropScaleDownDuration));
342 ObjectAnimator alphaFadeOut = ObjectAnimator.ofFloat(this, "hoverAlpha", 0.0f);
343
344 alphaFadeOut.setStartDelay(res.getInteger(R.integer.config_screenOnDropAlphaFadeDelay));
345 alphaFadeOut.setDuration(res.getInteger(R.integer.config_screenOnDropAlphaFadeDelay));
346
347 AnimatorSet bouncer = new AnimatorSet();
348 bouncer.play(scaleUp).before(scaleDown);
349 bouncer.play(scaleUp).with(alphaFadeOut);
Michael Jurka8edd75c2010-12-17 20:15:06 -0800350 bouncer.addListener(new AnimatorListenerAdapter() {
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700351 @Override
Michael Jurka18014792010-10-14 09:01:34 -0700352 public void onAnimationStart(Animator animation) {
Michael Jurka33945b22010-12-21 18:19:38 -0800353 setIsDragOverlapping(true);
Michael Jurka18014792010-10-14 09:01:34 -0700354 }
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700355 @Override
Michael Jurka8edd75c2010-12-17 20:15:06 -0800356 public void onAnimationEnd(Animator animation) {
Michael Jurka33945b22010-12-21 18:19:38 -0800357 setIsDragOverlapping(false);
Michael Jurka18014792010-10-14 09:01:34 -0700358 setHoverScale(1.0f);
359 setHoverAlpha(1.0f);
360 }
361 });
362 bouncer.start();
363 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800364 }
365
Jeff Sharkey83f111d2009-04-20 21:03:13 -0700366 @Override
Patrick Dubroy1262e362010-10-06 15:49:50 -0700367 protected void onDraw(Canvas canvas) {
Michael Jurka3e7c7632010-10-02 16:01:03 -0700368 // When we're large, we are either drawn in a "hover" state (ie when dragging an item to
369 // a neighboring page) or with just a normal background (if backgroundAlpha > 0.0f)
370 // When we're small, we are either drawn normally or in the "accepts drops" state (during
371 // a drag). However, we also drag the mini hover background *over* one of those two
372 // backgrounds
Winson Chung26cbf3a2011-01-06 16:25:55 -0800373 if (LauncherApplication.isScreenXLarge() && mBackgroundAlpha > 0.0f) {
Adam Cohenf34bab52010-09-30 14:11:56 -0700374 Drawable bg;
Michael Jurka33945b22010-12-21 18:19:38 -0800375 boolean mini = getScaleX() < 0.5f;
376
377 if (mIsDragOverlapping) {
378 // In the mini case, we draw the active_glow bg *over* the active background
379 bg = mini ? mActiveBackgroundMini : mActiveGlowBackground;
380 } else if (mIsDragOccuring && mAcceptsDrops) {
381 bg = mini ? mActiveBackgroundMini : mActiveBackground;
Adam Cohen3af863b2011-01-25 12:16:51 -0800382 } else if (mIsDefaultDropTarget && mini) {
383 bg = mNormalGlowBackgroundMini;
Adam Cohenf34bab52010-09-30 14:11:56 -0700384 } else {
Michael Jurka33945b22010-12-21 18:19:38 -0800385 bg = mini ? mNormalBackgroundMini : mNormalBackground;
Adam Cohenf34bab52010-09-30 14:11:56 -0700386 }
Michael Jurka33945b22010-12-21 18:19:38 -0800387
388 bg.setAlpha((int) (mBackgroundAlpha * mBackgroundAlphaMultiplier * 255));
389 bg.setBounds(mBackgroundRect);
390 bg.draw(canvas);
391
392 if (mini && mIsDragOverlapping) {
Michael Jurka18014792010-10-14 09:01:34 -0700393 boolean modifiedClipRect = false;
Michael Jurka33945b22010-12-21 18:19:38 -0800394 if (mGlowBackgroundScale > 1.0f) {
Michael Jurka18014792010-10-14 09:01:34 -0700395 // If the hover background's scale is greater than 1, we'll be drawing outside
396 // the bounds of this CellLayout. Get around that by temporarily increasing the
397 // size of the clip rect
Michael Jurka33945b22010-12-21 18:19:38 -0800398 float marginFraction = (mGlowBackgroundScale - 1.0f) / 2.0f;
Michael Jurka18014792010-10-14 09:01:34 -0700399 Rect clipRect = canvas.getClipBounds();
400 int marginX = (int) (marginFraction * (clipRect.right - clipRect.left));
401 int marginY = (int) (marginFraction * (clipRect.bottom - clipRect.top));
402 canvas.save(Canvas.CLIP_SAVE_FLAG);
403 canvas.clipRect(-marginX, -marginY,
404 getWidth() + marginX, getHeight() + marginY, Region.Op.REPLACE);
405 modifiedClipRect = true;
406 }
407
Michael Jurka33945b22010-12-21 18:19:38 -0800408 mActiveGlowBackgroundMini.setAlpha(
409 (int) (mBackgroundAlpha * mGlowBackgroundAlpha * 255));
410 mActiveGlowBackgroundMini.setBounds(mGlowBackgroundRect);
411 mActiveGlowBackgroundMini.draw(canvas);
Michael Jurka18014792010-10-14 09:01:34 -0700412 if (modifiedClipRect) {
413 canvas.restore();
414 }
Michael Jurka3e7c7632010-10-02 16:01:03 -0700415 }
Michael Jurkaa63c4522010-08-19 13:52:27 -0700416 }
Romain Guya6abce82009-11-10 02:54:41 -0800417
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700418 if (mCrosshairsVisibility > 0.0f) {
419 final int countX = mCountX;
420 final int countY = mCountY;
421
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700422 final float MAX_ALPHA = 0.4f;
423 final int MAX_VISIBLE_DISTANCE = 600;
424 final float DISTANCE_MULTIPLIER = 0.002f;
425
426 final Drawable d = mCrosshairsDrawable;
427 final int width = d.getIntrinsicWidth();
428 final int height = d.getIntrinsicHeight();
429
430 int x = getLeftPadding() - (mWidthGap / 2) - (width / 2);
431 for (int col = 0; col <= countX; col++) {
432 int y = getTopPadding() - (mHeightGap / 2) - (height / 2);
433 for (int row = 0; row <= countY; row++) {
434 mTmpPointF.set(x - mDragCenter.x, y - mDragCenter.y);
435 float dist = mTmpPointF.length();
436 // Crosshairs further from the drag point are more faint
437 float alpha = Math.min(MAX_ALPHA,
438 DISTANCE_MULTIPLIER * (MAX_VISIBLE_DISTANCE - dist));
439 if (alpha > 0.0f) {
440 d.setBounds(x, y, x + width, y + height);
441 d.setAlpha((int) (alpha * 255 * mCrosshairsVisibility));
442 d.draw(canvas);
443 }
444 y += mCellHeight + mHeightGap;
445 }
446 x += mCellWidth + mWidthGap;
447 }
Joe Onorato4be866d2010-10-10 11:26:02 -0700448 }
Winson Chung150fbab2010-09-29 17:14:26 -0700449
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700450 final Paint paint = mDragOutlinePaint;
Joe Onorato4be866d2010-10-10 11:26:02 -0700451 for (int i = 0; i < mDragOutlines.length; i++) {
Chet Haase472b2812010-10-14 07:02:04 -0700452 final float alpha = mDragOutlineAlphas[i];
Joe Onorato4be866d2010-10-10 11:26:02 -0700453 if (alpha > 0) {
454 final Point p = mDragOutlines[i];
455 final Bitmap b = (Bitmap) mDragOutlineAnims[i].getTag();
Chet Haase472b2812010-10-14 07:02:04 -0700456 paint.setAlpha((int)(alpha + .5f));
Joe Onorato4be866d2010-10-10 11:26:02 -0700457 canvas.drawBitmap(b, p.x, p.y, paint);
Winson Chung150fbab2010-09-29 17:14:26 -0700458 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700459 }
460 }
461
462 @Override
Jeff Sharkey83f111d2009-04-20 21:03:13 -0700463 public void cancelLongPress() {
464 super.cancelLongPress();
465
466 // Cancel long press for all children
467 final int count = getChildCount();
468 for (int i = 0; i < count; i++) {
469 final View child = getChildAt(i);
470 child.cancelLongPress();
471 }
472 }
473
Michael Jurkadee05892010-07-27 10:01:56 -0700474 public void setOnInterceptTouchListener(View.OnTouchListener listener) {
475 mInterceptTouchListener = listener;
476 }
477
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800478 int getCountX() {
Adam Cohend22015c2010-07-26 22:02:18 -0700479 return mCountX;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800480 }
481
482 int getCountY() {
Adam Cohend22015c2010-07-26 22:02:18 -0700483 return mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800484 }
485
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700486 public boolean addViewToCellLayout(
487 View child, int index, int childId, LayoutParams params, boolean markCells) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700488 final LayoutParams lp = params;
489
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800490 // Generate an id for each view, this assumes we have at most 256x256 cells
491 // per workspace screen
Adam Cohend22015c2010-07-26 22:02:18 -0700492 if (lp.cellX >= 0 && lp.cellX <= mCountX - 1 && lp.cellY >= 0 && lp.cellY <= mCountY - 1) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700493 // If the horizontal or vertical span is set to -1, it is taken to
494 // mean that it spans the extent of the CellLayout
Adam Cohend22015c2010-07-26 22:02:18 -0700495 if (lp.cellHSpan < 0) lp.cellHSpan = mCountX;
496 if (lp.cellVSpan < 0) lp.cellVSpan = mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800497
Winson Chungaafa03c2010-06-11 17:34:16 -0700498 child.setId(childId);
499
Michael Jurka8c920dd2011-01-20 14:16:56 -0800500 mChildren.addView(child, index, lp);
Michael Jurkadee05892010-07-27 10:01:56 -0700501
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700502 if (markCells) markCellsAsOccupiedForView(child);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700503
Winson Chungaafa03c2010-06-11 17:34:16 -0700504 return true;
505 }
506 return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800507 }
Michael Jurka3e7c7632010-10-02 16:01:03 -0700508
Michael Jurkabea15192010-11-17 12:33:46 -0800509 public void setAcceptsDrops(boolean acceptsDrops) {
510 if (mAcceptsDrops != acceptsDrops) {
511 mAcceptsDrops = acceptsDrops;
512 invalidate();
513 }
514 }
515
Michael Jurka3e7c7632010-10-02 16:01:03 -0700516 public boolean getAcceptsDrops() {
517 return mAcceptsDrops;
518 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800519
520 @Override
Michael Jurka0280c3b2010-09-17 15:00:07 -0700521 public void removeAllViews() {
522 clearOccupiedCells();
Michael Jurka8c920dd2011-01-20 14:16:56 -0800523 mChildren.removeAllViews();
Michael Jurka0280c3b2010-09-17 15:00:07 -0700524 }
525
526 @Override
527 public void removeAllViewsInLayout() {
528 clearOccupiedCells();
Michael Jurka8c920dd2011-01-20 14:16:56 -0800529 mChildren.removeAllViewsInLayout();
Michael Jurka0280c3b2010-09-17 15:00:07 -0700530 }
531
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700532 public void removeViewWithoutMarkingCells(View view) {
Michael Jurkacf6125c2011-01-28 15:20:01 -0800533 mChildren.removeView(view);
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700534 }
535
Michael Jurka0280c3b2010-09-17 15:00:07 -0700536 @Override
537 public void removeView(View view) {
538 markCellsAsUnoccupiedForView(view);
Michael Jurka8c920dd2011-01-20 14:16:56 -0800539 mChildren.removeView(view);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700540 }
541
542 @Override
543 public void removeViewAt(int index) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800544 markCellsAsUnoccupiedForView(mChildren.getChildAt(index));
545 mChildren.removeViewAt(index);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700546 }
547
548 @Override
549 public void removeViewInLayout(View view) {
550 markCellsAsUnoccupiedForView(view);
Michael Jurka8c920dd2011-01-20 14:16:56 -0800551 mChildren.removeViewInLayout(view);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700552 }
553
554 @Override
555 public void removeViews(int start, int count) {
556 for (int i = start; i < start + count; i++) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800557 markCellsAsUnoccupiedForView(mChildren.getChildAt(i));
Michael Jurka0280c3b2010-09-17 15:00:07 -0700558 }
Michael Jurka8c920dd2011-01-20 14:16:56 -0800559 mChildren.removeViews(start, count);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700560 }
561
562 @Override
563 public void removeViewsInLayout(int start, int count) {
564 for (int i = start; i < start + count; i++) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800565 markCellsAsUnoccupiedForView(mChildren.getChildAt(i));
Michael Jurka0280c3b2010-09-17 15:00:07 -0700566 }
Michael Jurka8c920dd2011-01-20 14:16:56 -0800567 mChildren.removeViewsInLayout(start, count);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700568 }
569
Michael Jurka8c920dd2011-01-20 14:16:56 -0800570 public void drawChildren(Canvas canvas) {
571 mChildren.draw(canvas);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800572 }
573
574 @Override
575 protected void onAttachedToWindow() {
576 super.onAttachedToWindow();
577 mCellInfo.screen = ((ViewGroup) getParent()).indexOfChild(this);
578 }
579
Michael Jurkaaf442092010-06-10 17:01:57 -0700580 public void setTagToCellInfoForPoint(int touchX, int touchY) {
581 final CellInfo cellInfo = mCellInfo;
582 final Rect frame = mRect;
583 final int x = touchX + mScrollX;
584 final int y = touchY + mScrollY;
Michael Jurka8c920dd2011-01-20 14:16:56 -0800585 final int count = mChildren.getChildCount();
Michael Jurkaaf442092010-06-10 17:01:57 -0700586
587 boolean found = false;
588 for (int i = count - 1; i >= 0; i--) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800589 final View child = mChildren.getChildAt(i);
Michael Jurkaaf442092010-06-10 17:01:57 -0700590
591 if ((child.getVisibility()) == VISIBLE || child.getAnimation() != null) {
592 child.getHitRect(frame);
593 if (frame.contains(x, y)) {
594 final LayoutParams lp = (LayoutParams) child.getLayoutParams();
595 cellInfo.cell = child;
596 cellInfo.cellX = lp.cellX;
597 cellInfo.cellY = lp.cellY;
598 cellInfo.spanX = lp.cellHSpan;
599 cellInfo.spanY = lp.cellVSpan;
600 cellInfo.valid = true;
601 found = true;
Michael Jurkaaf442092010-06-10 17:01:57 -0700602 break;
603 }
604 }
605 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700606
Michael Jurkaaf442092010-06-10 17:01:57 -0700607 if (!found) {
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700608 final int cellXY[] = mTmpCellXY;
Michael Jurkaaf442092010-06-10 17:01:57 -0700609 pointToCellExact(x, y, cellXY);
610
Michael Jurkaaf442092010-06-10 17:01:57 -0700611 cellInfo.cell = null;
612 cellInfo.cellX = cellXY[0];
613 cellInfo.cellY = cellXY[1];
614 cellInfo.spanX = 1;
615 cellInfo.spanY = 1;
Michael Jurka0280c3b2010-09-17 15:00:07 -0700616 cellInfo.valid = cellXY[0] >= 0 && cellXY[1] >= 0 && cellXY[0] < mCountX &&
617 cellXY[1] < mCountY && !mOccupied[cellXY[0]][cellXY[1]];
Michael Jurkaaf442092010-06-10 17:01:57 -0700618 }
619 setTag(cellInfo);
620 }
621
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800622 @Override
623 public boolean onInterceptTouchEvent(MotionEvent ev) {
Michael Jurkadee05892010-07-27 10:01:56 -0700624 if (mInterceptTouchListener != null && mInterceptTouchListener.onTouch(this, ev)) {
625 return true;
626 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800627 final int action = ev.getAction();
628 final CellInfo cellInfo = mCellInfo;
629
630 if (action == MotionEvent.ACTION_DOWN) {
Michael Jurkaaf442092010-06-10 17:01:57 -0700631 setTagToCellInfoForPoint((int) ev.getX(), (int) ev.getY());
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800632 } else if (action == MotionEvent.ACTION_UP) {
633 cellInfo.cell = null;
634 cellInfo.cellX = -1;
635 cellInfo.cellY = -1;
636 cellInfo.spanX = 0;
637 cellInfo.spanY = 0;
638 cellInfo.valid = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800639 setTag(cellInfo);
640 }
641
642 return false;
643 }
644
645 @Override
646 public CellInfo getTag() {
Michael Jurka0280c3b2010-09-17 15:00:07 -0700647 return (CellInfo) super.getTag();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800648 }
649
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700650 /**
Winson Chungaafa03c2010-06-11 17:34:16 -0700651 * Given a point, return the cell that strictly encloses that point
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800652 * @param x X coordinate of the point
653 * @param y Y coordinate of the point
654 * @param result Array of 2 ints to hold the x and y coordinate of the cell
655 */
656 void pointToCellExact(int x, int y, int[] result) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700657 final int hStartPadding = getLeftPadding();
658 final int vStartPadding = getTopPadding();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800659
660 result[0] = (x - hStartPadding) / (mCellWidth + mWidthGap);
661 result[1] = (y - vStartPadding) / (mCellHeight + mHeightGap);
662
Adam Cohend22015c2010-07-26 22:02:18 -0700663 final int xAxis = mCountX;
664 final int yAxis = mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800665
666 if (result[0] < 0) result[0] = 0;
667 if (result[0] >= xAxis) result[0] = xAxis - 1;
668 if (result[1] < 0) result[1] = 0;
669 if (result[1] >= yAxis) result[1] = yAxis - 1;
670 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700671
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800672 /**
673 * Given a point, return the cell that most closely encloses that point
674 * @param x X coordinate of the point
675 * @param y Y coordinate of the point
676 * @param result Array of 2 ints to hold the x and y coordinate of the cell
677 */
678 void pointToCellRounded(int x, int y, int[] result) {
679 pointToCellExact(x + (mCellWidth / 2), y + (mCellHeight / 2), result);
680 }
681
682 /**
683 * Given a cell coordinate, return the point that represents the upper left corner of that cell
Winson Chungaafa03c2010-06-11 17:34:16 -0700684 *
685 * @param cellX X coordinate of the cell
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800686 * @param cellY Y coordinate of the cell
Winson Chungaafa03c2010-06-11 17:34:16 -0700687 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800688 * @param result Array of 2 ints to hold the x and y coordinate of the point
689 */
690 void cellToPoint(int cellX, int cellY, int[] result) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700691 final int hStartPadding = getLeftPadding();
692 final int vStartPadding = getTopPadding();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800693
694 result[0] = hStartPadding + cellX * (mCellWidth + mWidthGap);
695 result[1] = vStartPadding + cellY * (mCellHeight + mHeightGap);
696 }
697
Romain Guy84f296c2009-11-04 15:00:44 -0800698 int getCellWidth() {
699 return mCellWidth;
700 }
701
702 int getCellHeight() {
703 return mCellHeight;
704 }
705
Romain Guy1a304a12009-11-10 00:02:32 -0800706 int getLeftPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700707 return mLeftPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800708 }
709
710 int getTopPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700711 return mTopPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800712 }
713
714 int getRightPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700715 return mRightPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800716 }
717
718 int getBottomPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700719 return mBottomPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800720 }
721
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800722 @Override
723 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
724 // TODO: currently ignoring padding
Winson Chungaafa03c2010-06-11 17:34:16 -0700725
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800726 int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
Winson Chungaafa03c2010-06-11 17:34:16 -0700727 int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
728
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800729 int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
730 int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
Winson Chungaafa03c2010-06-11 17:34:16 -0700731
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800732 if (widthSpecMode == MeasureSpec.UNSPECIFIED || heightSpecMode == MeasureSpec.UNSPECIFIED) {
733 throw new RuntimeException("CellLayout cannot have UNSPECIFIED dimensions");
734 }
735
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800736 final int cellWidth = mCellWidth;
737 final int cellHeight = mCellHeight;
738
Adam Cohend22015c2010-07-26 22:02:18 -0700739 int numWidthGaps = mCountX - 1;
740 int numHeightGaps = mCountY - 1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800741
Winson Chungece7f5b2010-10-22 14:54:12 -0700742 if (mWidthGap < 0 || mHeightGap < 0) {
743 int vSpaceLeft = heightSpecSize - mTopPadding - mBottomPadding - (cellHeight * mCountY);
744 mHeightGap = vSpaceLeft / numHeightGaps;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800745
Winson Chungece7f5b2010-10-22 14:54:12 -0700746 int hSpaceLeft = widthSpecSize - mLeftPadding - mRightPadding - (cellWidth * mCountX);
747 mWidthGap = hSpaceLeft / numWidthGaps;
Winson Chungaafa03c2010-06-11 17:34:16 -0700748
Winson Chungece7f5b2010-10-22 14:54:12 -0700749 // center it around the min gaps
750 int minGap = Math.min(mWidthGap, mHeightGap);
751 mWidthGap = mHeightGap = minGap;
752 }
Michael Jurka5f1c5092010-09-03 14:15:02 -0700753
Michael Jurka8c920dd2011-01-20 14:16:56 -0800754 // Initial values correspond to widthSpecMode == MeasureSpec.EXACTLY
755 int newWidth = widthSpecSize;
756 int newHeight = heightSpecSize;
Michael Jurka5f1c5092010-09-03 14:15:02 -0700757 if (widthSpecMode == MeasureSpec.AT_MOST) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800758 newWidth = mLeftPadding + mRightPadding + (mCountX * cellWidth) +
Winson Chungece7f5b2010-10-22 14:54:12 -0700759 ((mCountX - 1) * mWidthGap);
Michael Jurka8c920dd2011-01-20 14:16:56 -0800760 newHeight = mTopPadding + mBottomPadding + (mCountY * cellHeight) +
Winson Chungece7f5b2010-10-22 14:54:12 -0700761 ((mCountY - 1) * mHeightGap);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700762 setMeasuredDimension(newWidth, newHeight);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700763 }
Michael Jurka8c920dd2011-01-20 14:16:56 -0800764
765 int count = getChildCount();
766 for (int i = 0; i < count; i++) {
767 View child = getChildAt(i);
768 int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(newWidth, MeasureSpec.EXACTLY);
769 int childheightMeasureSpec = MeasureSpec.makeMeasureSpec(newHeight,
770 MeasureSpec.EXACTLY);
771 child.measure(childWidthMeasureSpec, childheightMeasureSpec);
772 }
773 setMeasuredDimension(newWidth, newHeight);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800774 }
775
776 @Override
Michael Jurka28750fb2010-09-24 17:43:49 -0700777 protected void onLayout(boolean changed, int l, int t, int r, int b) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800778 int count = getChildCount();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800779 for (int i = 0; i < count; i++) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800780 View child = getChildAt(i);
781 child.layout(0, 0, r - l, b - t);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800782 }
783 }
784
785 @Override
Michael Jurkadee05892010-07-27 10:01:56 -0700786 protected void onSizeChanged(int w, int h, int oldw, int oldh) {
787 super.onSizeChanged(w, h, oldw, oldh);
Michael Jurka18014792010-10-14 09:01:34 -0700788 mBackgroundRect.set(0, 0, w, h);
Michael Jurka33945b22010-12-21 18:19:38 -0800789 updateGlowRect();
Michael Jurkadee05892010-07-27 10:01:56 -0700790 }
791
792 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800793 protected void setChildrenDrawingCacheEnabled(boolean enabled) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800794 mChildren.setChildrenDrawingCacheEnabled(enabled);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800795 }
796
797 @Override
798 protected void setChildrenDrawnWithCacheEnabled(boolean enabled) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800799 mChildren.setChildrenDrawnWithCacheEnabled(enabled);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800800 }
801
Michael Jurka5f1c5092010-09-03 14:15:02 -0700802 public float getBackgroundAlpha() {
803 return mBackgroundAlpha;
Michael Jurkadee05892010-07-27 10:01:56 -0700804 }
805
Adam Cohen1b0aaac2010-10-28 11:11:18 -0700806 public void setBackgroundAlphaMultiplier(float multiplier) {
807 mBackgroundAlphaMultiplier = multiplier;
808 }
809
Adam Cohenddb82192010-11-10 16:32:54 -0800810 public float getBackgroundAlphaMultiplier() {
811 return mBackgroundAlphaMultiplier;
812 }
813
Michael Jurka5f1c5092010-09-03 14:15:02 -0700814 public void setBackgroundAlpha(float alpha) {
815 mBackgroundAlpha = alpha;
Michael Jurka0142d492010-08-25 17:46:15 -0700816 invalidate();
Michael Jurkadee05892010-07-27 10:01:56 -0700817 }
818
Michael Jurka5f1c5092010-09-03 14:15:02 -0700819 // Need to return true to let the view system know we know how to handle alpha-- this is
820 // because when our children have an alpha of 0.0f, they are still rendering their "dimmed"
821 // versions
822 @Override
823 protected boolean onSetAlpha(int alpha) {
824 return true;
825 }
826
827 public void setAlpha(float alpha) {
828 setChildrenAlpha(alpha);
829 super.setAlpha(alpha);
830 }
831
Michael Jurkadee05892010-07-27 10:01:56 -0700832 private void setChildrenAlpha(float alpha) {
Michael Jurka0142d492010-08-25 17:46:15 -0700833 final int childCount = getChildCount();
834 for (int i = 0; i < childCount; i++) {
Michael Jurkadee05892010-07-27 10:01:56 -0700835 getChildAt(i).setAlpha(alpha);
836 }
837 }
838
Patrick Dubroy440c3602010-07-13 17:50:32 -0700839 public View getChildAt(int x, int y) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800840 return mChildren.getChildAt(x, y);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700841 }
842
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700843 /**
844 * Estimate where the top left cell of the dragged item will land if it is dropped.
845 *
846 * @param originX The X value of the top left corner of the item
847 * @param originY The Y value of the top left corner of the item
848 * @param spanX The number of horizontal cells that the item spans
849 * @param spanY The number of vertical cells that the item spans
850 * @param result The estimated drop cell X and Y.
851 */
852 void estimateDropCell(int originX, int originY, int spanX, int spanY, int[] result) {
Adam Cohend22015c2010-07-26 22:02:18 -0700853 final int countX = mCountX;
854 final int countY = mCountY;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700855
Michael Jurkaa63c4522010-08-19 13:52:27 -0700856 // pointToCellRounded takes the top left of a cell but will pad that with
857 // cellWidth/2 and cellHeight/2 when finding the matching cell
858 pointToCellRounded(originX, originY, result);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700859
860 // If the item isn't fully on this screen, snap to the edges
861 int rightOverhang = result[0] + spanX - countX;
862 if (rightOverhang > 0) {
863 result[0] -= rightOverhang; // Snap to right
864 }
865 result[0] = Math.max(0, result[0]); // Snap to left
866 int bottomOverhang = result[1] + spanY - countY;
867 if (bottomOverhang > 0) {
868 result[1] -= bottomOverhang; // Snap to bottom
869 }
870 result[1] = Math.max(0, result[1]); // Snap to top
871 }
872
Joe Onorato4be866d2010-10-10 11:26:02 -0700873 void visualizeDropLocation(
874 View v, Bitmap dragOutline, int originX, int originY, int spanX, int spanY) {
875
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -0700876 final int oldDragCellX = mDragCell[0];
877 final int oldDragCellY = mDragCell[1];
Joe Onorato4be866d2010-10-10 11:26:02 -0700878 final int[] nearest = findNearestVacantArea(originX, originY, spanX, spanY, v, mDragCell);
Winson Chunga9abd0e2010-10-27 17:18:37 -0700879 if (v != null) {
880 mDragCenter.set(originX + (v.getWidth() / 2), originY + (v.getHeight() / 2));
881 } else {
882 mDragCenter.set(originX, originY);
883 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700884
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -0700885 if (nearest != null && (nearest[0] != oldDragCellX || nearest[1] != oldDragCellY)) {
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700886 // Find the top left corner of the rect the object will occupy
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700887 final int[] topLeft = mTmpPoint;
888 cellToPoint(nearest[0], nearest[1], topLeft);
889
Joe Onorato4be866d2010-10-10 11:26:02 -0700890 int left = topLeft[0];
891 int top = topLeft[1];
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700892
Winson Chunga9abd0e2010-10-27 17:18:37 -0700893 if (v != null) {
894 if (v.getParent() instanceof CellLayout) {
895 LayoutParams lp = (LayoutParams) v.getLayoutParams();
896 left += lp.leftMargin;
897 top += lp.topMargin;
898 }
Winson Chung150fbab2010-09-29 17:14:26 -0700899
Winson Chunga9abd0e2010-10-27 17:18:37 -0700900 // Offsets due to the size difference between the View and the dragOutline
901 left += (v.getWidth() - dragOutline.getWidth()) / 2;
902 top += (v.getHeight() - dragOutline.getHeight()) / 2;
903 }
Winson Chung150fbab2010-09-29 17:14:26 -0700904
Joe Onorato4be866d2010-10-10 11:26:02 -0700905 final int oldIndex = mDragOutlineCurrent;
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -0700906 mDragOutlineAnims[oldIndex].animateOut();
907 mDragOutlineCurrent = (oldIndex + 1) % mDragOutlines.length;
Winson Chung150fbab2010-09-29 17:14:26 -0700908
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -0700909 mDragOutlines[mDragOutlineCurrent].set(left, top);
910 mDragOutlineAnims[mDragOutlineCurrent].setTag(dragOutline);
911 mDragOutlineAnims[mDragOutlineCurrent].animateIn();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700912 }
Patrick Dubroy49250ad2010-10-08 15:33:52 -0700913
914 // If we are drawing crosshairs, the entire CellLayout needs to be invalidated
915 if (mCrosshairsDrawable != null) {
916 invalidate();
917 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700918 }
919
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800920 /**
Jeff Sharkey70864282009-04-07 21:08:40 -0700921 * Find a vacant area that will fit the given bounds nearest the requested
922 * cell location. Uses Euclidean distance to score multiple vacant areas.
Winson Chungaafa03c2010-06-11 17:34:16 -0700923 *
Romain Guy51afc022009-05-04 18:03:43 -0700924 * @param pixelX The X location at which you want to search for a vacant area.
925 * @param pixelY The Y location at which you want to search for a vacant area.
Jeff Sharkey70864282009-04-07 21:08:40 -0700926 * @param spanX Horizontal span of the object.
927 * @param spanY Vertical span of the object.
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700928 * @param result Array in which to place the result, or null (in which case a new array will
929 * be allocated)
Jeff Sharkey70864282009-04-07 21:08:40 -0700930 * @return The X, Y cell of a vacant area that can contain this object,
931 * nearest the requested location.
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800932 */
Michael Jurka6a1435d2010-09-27 17:35:12 -0700933 int[] findNearestVacantArea(
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700934 int pixelX, int pixelY, int spanX, int spanY, int[] result) {
935 return findNearestVacantArea(pixelX, pixelY, spanX, spanY, null, result);
Michael Jurka6a1435d2010-09-27 17:35:12 -0700936 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700937
Michael Jurka6a1435d2010-09-27 17:35:12 -0700938 /**
939 * Find a vacant area that will fit the given bounds nearest the requested
940 * cell location. Uses Euclidean distance to score multiple vacant areas.
941 *
942 * @param pixelX The X location at which you want to search for a vacant area.
943 * @param pixelY The Y location at which you want to search for a vacant area.
944 * @param spanX Horizontal span of the object.
945 * @param spanY Vertical span of the object.
Michael Jurka6a1435d2010-09-27 17:35:12 -0700946 * @param ignoreView Considers space occupied by this view as unoccupied
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700947 * @param result Previously returned value to possibly recycle.
Michael Jurka6a1435d2010-09-27 17:35:12 -0700948 * @return The X, Y cell of a vacant area that can contain this object,
949 * nearest the requested location.
950 */
951 int[] findNearestVacantArea(
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700952 int pixelX, int pixelY, int spanX, int spanY, View ignoreView, int[] result) {
Michael Jurkac6ee42e2010-09-30 12:04:50 -0700953 // mark space take by ignoreView as available (method checks if ignoreView is null)
954 markCellsAsUnoccupiedForView(ignoreView);
955
Jeff Sharkey70864282009-04-07 21:08:40 -0700956 // Keep track of best-scoring drop area
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700957 final int[] bestXY = result != null ? result : new int[2];
Jeff Sharkey70864282009-04-07 21:08:40 -0700958 double bestDistance = Double.MAX_VALUE;
Winson Chungaafa03c2010-06-11 17:34:16 -0700959
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700960 final int countX = mCountX;
961 final int countY = mCountY;
962 final boolean[][] occupied = mOccupied;
963
Winson Chungbbc60d82010-11-11 16:34:41 -0800964 for (int y = 0; y < countY - (spanY - 1); y++) {
Michael Jurkac28de512010-08-13 11:27:44 -0700965 inner:
Winson Chungbbc60d82010-11-11 16:34:41 -0800966 for (int x = 0; x < countX - (spanX - 1); x++) {
Michael Jurkac28de512010-08-13 11:27:44 -0700967 for (int i = 0; i < spanX; i++) {
968 for (int j = 0; j < spanY; j++) {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700969 if (occupied[x + i][y + j]) {
Winson Chungbbc60d82010-11-11 16:34:41 -0800970 // small optimization: we can skip to after the column we just found
Michael Jurkac28de512010-08-13 11:27:44 -0700971 // an occupied cell
Winson Chungbbc60d82010-11-11 16:34:41 -0800972 x += i;
Michael Jurkac28de512010-08-13 11:27:44 -0700973 continue inner;
974 }
975 }
976 }
977 final int[] cellXY = mTmpCellXY;
978 cellToPoint(x, y, cellXY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800979
Michael Jurkac28de512010-08-13 11:27:44 -0700980 double distance = Math.sqrt(Math.pow(cellXY[0] - pixelX, 2)
981 + Math.pow(cellXY[1] - pixelY, 2));
982 if (distance <= bestDistance) {
983 bestDistance = distance;
984 bestXY[0] = x;
985 bestXY[1] = y;
986 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800987 }
988 }
Michael Jurkac6ee42e2010-09-30 12:04:50 -0700989 // re-mark space taken by ignoreView as occupied
990 markCellsAsOccupiedForView(ignoreView);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800991
Winson Chungaafa03c2010-06-11 17:34:16 -0700992 // Return null if no suitable location found
Jeff Sharkey70864282009-04-07 21:08:40 -0700993 if (bestDistance < Double.MAX_VALUE) {
994 return bestXY;
995 } else {
996 return null;
997 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800998 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700999
Michael Jurka0280c3b2010-09-17 15:00:07 -07001000 boolean existsEmptyCell() {
1001 return findCellForSpan(null, 1, 1);
1002 }
1003
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001004 /**
Michael Jurka0280c3b2010-09-17 15:00:07 -07001005 * Finds the upper-left coordinate of the first rectangle in the grid that can
1006 * hold a cell of the specified dimensions. If intersectX and intersectY are not -1,
1007 * then this method will only return coordinates for rectangles that contain the cell
1008 * (intersectX, intersectY)
1009 *
1010 * @param cellXY The array that will contain the position of a vacant cell if such a cell
1011 * can be found.
1012 * @param spanX The horizontal span of the cell we want to find.
1013 * @param spanY The vertical span of the cell we want to find.
1014 *
1015 * @return True if a vacant cell of the specified dimension was found, false otherwise.
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001016 */
Michael Jurka0280c3b2010-09-17 15:00:07 -07001017 boolean findCellForSpan(int[] cellXY, int spanX, int spanY) {
1018 return findCellForSpanThatIntersectsIgnoring(cellXY, spanX, spanY, -1, -1, null);
1019 }
1020
1021 /**
1022 * Like above, but ignores any cells occupied by the item "ignoreView"
1023 *
1024 * @param cellXY The array that will contain the position of a vacant cell if such a cell
1025 * can be found.
1026 * @param spanX The horizontal span of the cell we want to find.
1027 * @param spanY The vertical span of the cell we want to find.
1028 * @param ignoreView The home screen item we should treat as not occupying any space
1029 * @return
1030 */
1031 boolean findCellForSpanIgnoring(int[] cellXY, int spanX, int spanY, View ignoreView) {
1032 return findCellForSpanThatIntersectsIgnoring(cellXY, spanX, spanY, -1, -1, ignoreView);
1033 }
1034
1035 /**
1036 * Like above, but if intersectX and intersectY are not -1, then this method will try to
1037 * return coordinates for rectangles that contain the cell [intersectX, intersectY]
1038 *
1039 * @param spanX The horizontal span of the cell we want to find.
1040 * @param spanY The vertical span of the cell we want to find.
1041 * @param ignoreView The home screen item we should treat as not occupying any space
1042 * @param intersectX The X coordinate of the cell that we should try to overlap
1043 * @param intersectX The Y coordinate of the cell that we should try to overlap
1044 *
1045 * @return True if a vacant cell of the specified dimension was found, false otherwise.
1046 */
1047 boolean findCellForSpanThatIntersects(int[] cellXY, int spanX, int spanY,
1048 int intersectX, int intersectY) {
1049 return findCellForSpanThatIntersectsIgnoring(
1050 cellXY, spanX, spanY, intersectX, intersectY, null);
1051 }
1052
1053 /**
1054 * The superset of the above two methods
1055 */
1056 boolean findCellForSpanThatIntersectsIgnoring(int[] cellXY, int spanX, int spanY,
1057 int intersectX, int intersectY, View ignoreView) {
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001058 // mark space take by ignoreView as available (method checks if ignoreView is null)
1059 markCellsAsUnoccupiedForView(ignoreView);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001060
Michael Jurka28750fb2010-09-24 17:43:49 -07001061 boolean foundCell = false;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001062 while (true) {
1063 int startX = 0;
1064 if (intersectX >= 0) {
1065 startX = Math.max(startX, intersectX - (spanX - 1));
1066 }
1067 int endX = mCountX - (spanX - 1);
1068 if (intersectX >= 0) {
1069 endX = Math.min(endX, intersectX + (spanX - 1) + (spanX == 1 ? 1 : 0));
1070 }
1071 int startY = 0;
1072 if (intersectY >= 0) {
1073 startY = Math.max(startY, intersectY - (spanY - 1));
1074 }
1075 int endY = mCountY - (spanY - 1);
1076 if (intersectY >= 0) {
1077 endY = Math.min(endY, intersectY + (spanY - 1) + (spanY == 1 ? 1 : 0));
1078 }
1079
Winson Chungbbc60d82010-11-11 16:34:41 -08001080 for (int y = startY; y < endY && !foundCell; y++) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001081 inner:
Winson Chungbbc60d82010-11-11 16:34:41 -08001082 for (int x = startX; x < endX; x++) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001083 for (int i = 0; i < spanX; i++) {
1084 for (int j = 0; j < spanY; j++) {
1085 if (mOccupied[x + i][y + j]) {
Winson Chungbbc60d82010-11-11 16:34:41 -08001086 // small optimization: we can skip to after the column we just found
Michael Jurka0280c3b2010-09-17 15:00:07 -07001087 // an occupied cell
Winson Chungbbc60d82010-11-11 16:34:41 -08001088 x += i;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001089 continue inner;
1090 }
1091 }
1092 }
1093 if (cellXY != null) {
1094 cellXY[0] = x;
1095 cellXY[1] = y;
1096 }
Michael Jurka28750fb2010-09-24 17:43:49 -07001097 foundCell = true;
1098 break;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001099 }
1100 }
1101 if (intersectX == -1 && intersectY == -1) {
1102 break;
1103 } else {
1104 // if we failed to find anything, try again but without any requirements of
1105 // intersecting
1106 intersectX = -1;
1107 intersectY = -1;
1108 continue;
1109 }
1110 }
1111
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001112 // re-mark space taken by ignoreView as occupied
1113 markCellsAsOccupiedForView(ignoreView);
Michael Jurka28750fb2010-09-24 17:43:49 -07001114 return foundCell;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001115 }
1116
1117 /**
1118 * Called when drag has left this CellLayout or has been completed (successfully or not)
1119 */
1120 void onDragExit() {
Joe Onorato4be866d2010-10-10 11:26:02 -07001121 // This can actually be called when we aren't in a drag, e.g. when adding a new
1122 // item to this layout via the customize drawer.
1123 // Guard against that case.
1124 if (mDragging) {
1125 mDragging = false;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001126
Joe Onorato4be866d2010-10-10 11:26:02 -07001127 // Fade out the drag indicators
1128 if (mCrosshairsAnimator != null) {
1129 mCrosshairsAnimator.animateOut();
1130 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001131 }
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001132
1133 // Invalidate the drag data
1134 mDragCell[0] = -1;
1135 mDragCell[1] = -1;
1136 mDragOutlineAnims[mDragOutlineCurrent].animateOut();
1137 mDragOutlineCurrent = (mDragOutlineCurrent + 1) % mDragOutlineAnims.length;
1138
Michael Jurka33945b22010-12-21 18:19:38 -08001139 setIsDragOverlapping(false);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001140 }
1141
1142 /**
Winson Chungaafa03c2010-06-11 17:34:16 -07001143 * Mark a child as having been dropped.
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001144 * At the beginning of the drag operation, the child may have been on another
Patrick Dubroyce34a972010-10-19 10:34:32 -07001145 * screen, but it is re-parented before this method is called.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001146 *
1147 * @param child The child that is being dropped
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001148 */
Michael Jurkad3ef3062010-11-23 16:23:58 -08001149 void onDropChild(View child, boolean animate) {
Romain Guyd94533d2009-08-17 10:01:15 -07001150 if (child != null) {
1151 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Romain Guyd94533d2009-08-17 10:01:15 -07001152 lp.isDragging = false;
Romain Guy84f296c2009-11-04 15:00:44 -08001153 lp.dropped = true;
Michael Jurkad3ef3062010-11-23 16:23:58 -08001154 lp.animateDrop = animate;
Patrick Dubroye3887cc2011-01-20 10:43:40 -08001155 child.setVisibility(animate ? View.INVISIBLE : View.VISIBLE);
Romain Guyd94533d2009-08-17 10:01:15 -07001156 child.requestLayout();
Romain Guyd94533d2009-08-17 10:01:15 -07001157 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001158 }
1159
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001160 /**
1161 * Start dragging the specified child
Winson Chungaafa03c2010-06-11 17:34:16 -07001162 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001163 * @param child The child that is being dragged
1164 */
1165 void onDragChild(View child) {
1166 LayoutParams lp = (LayoutParams) child.getLayoutParams();
1167 lp.isDragging = true;
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001168 }
1169
1170 /**
1171 * A drag event has begun over this layout.
1172 * It may have begun over this layout (in which case onDragChild is called first),
1173 * or it may have begun on another layout.
1174 */
Winson Chunga9abd0e2010-10-27 17:18:37 -07001175 void onDragEnter() {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -07001176 if (!mDragging) {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -07001177 // Fade in the drag indicators
1178 if (mCrosshairsAnimator != null) {
1179 mCrosshairsAnimator.animateIn();
1180 }
Joe Onorato4be866d2010-10-10 11:26:02 -07001181 }
1182 mDragging = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001183 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001184
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001185 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001186 * Computes a bounding rectangle for a range of cells
Winson Chungaafa03c2010-06-11 17:34:16 -07001187 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001188 * @param cellX X coordinate of upper left corner expressed as a cell position
1189 * @param cellY Y coordinate of upper left corner expressed as a cell position
Winson Chungaafa03c2010-06-11 17:34:16 -07001190 * @param cellHSpan Width in cells
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001191 * @param cellVSpan Height in cells
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001192 * @param resultRect Rect into which to put the results
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001193 */
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001194 public void cellToRect(int cellX, int cellY, int cellHSpan, int cellVSpan, RectF resultRect) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001195 final int cellWidth = mCellWidth;
1196 final int cellHeight = mCellHeight;
1197 final int widthGap = mWidthGap;
1198 final int heightGap = mHeightGap;
Winson Chungaafa03c2010-06-11 17:34:16 -07001199
1200 final int hStartPadding = getLeftPadding();
1201 final int vStartPadding = getTopPadding();
1202
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001203 int width = cellHSpan * cellWidth + ((cellHSpan - 1) * widthGap);
1204 int height = cellVSpan * cellHeight + ((cellVSpan - 1) * heightGap);
1205
1206 int x = hStartPadding + cellX * (cellWidth + widthGap);
1207 int y = vStartPadding + cellY * (cellHeight + heightGap);
Winson Chungaafa03c2010-06-11 17:34:16 -07001208
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001209 resultRect.set(x, y, x + width, y + height);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001210 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001211
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001212 /**
Winson Chungaafa03c2010-06-11 17:34:16 -07001213 * Computes the required horizontal and vertical cell spans to always
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001214 * fit the given rectangle.
Winson Chungaafa03c2010-06-11 17:34:16 -07001215 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001216 * @param width Width in pixels
1217 * @param height Height in pixels
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001218 * @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 -08001219 */
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001220 public int[] rectToCell(int width, int height, int[] result) {
Michael Jurka9987a5c2010-10-08 16:58:12 -07001221 return rectToCell(getResources(), width, height, result);
1222 }
1223
1224 public static int[] rectToCell(Resources resources, int width, int height, int[] result) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001225 // Always assume we're working with the smallest span to make sure we
1226 // reserve enough space in both orientations.
Joe Onorato79e56262009-09-21 15:23:04 -04001227 int actualWidth = resources.getDimensionPixelSize(R.dimen.workspace_cell_width);
1228 int actualHeight = resources.getDimensionPixelSize(R.dimen.workspace_cell_height);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001229 int smallerSize = Math.min(actualWidth, actualHeight);
Joe Onorato79e56262009-09-21 15:23:04 -04001230
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001231 // Always round up to next largest cell
1232 int spanX = (width + smallerSize) / smallerSize;
1233 int spanY = (height + smallerSize) / smallerSize;
Joe Onorato79e56262009-09-21 15:23:04 -04001234
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001235 if (result == null) {
1236 return new int[] { spanX, spanY };
1237 }
1238 result[0] = spanX;
1239 result[1] = spanY;
1240 return result;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001241 }
1242
Michael Jurkaf12c75c2011-01-25 22:41:40 -08001243 public int[] cellSpansToSize(int hSpans, int vSpans) {
1244 int[] size = new int[2];
1245 size[0] = hSpans * mCellWidth + (hSpans - 1) * mWidthGap;
1246 size[1] = vSpans * mCellHeight + (vSpans - 1) * mHeightGap;
1247 return size;
1248 }
1249
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001250 /**
Patrick Dubroy047379a2010-12-19 22:02:04 -08001251 * Calculate the grid spans needed to fit given item
1252 */
1253 public void calculateSpans(ItemInfo info) {
1254 final int minWidth;
1255 final int minHeight;
1256
1257 if (info instanceof LauncherAppWidgetInfo) {
1258 minWidth = ((LauncherAppWidgetInfo) info).minWidth;
1259 minHeight = ((LauncherAppWidgetInfo) info).minHeight;
1260 } else if (info instanceof PendingAddWidgetInfo) {
1261 minWidth = ((PendingAddWidgetInfo) info).minWidth;
1262 minHeight = ((PendingAddWidgetInfo) info).minHeight;
1263 } else {
1264 // It's not a widget, so it must be 1x1
1265 info.spanX = info.spanY = 1;
1266 return;
1267 }
1268 int[] spans = rectToCell(minWidth, minHeight, null);
1269 info.spanX = spans[0];
1270 info.spanY = spans[1];
1271 }
1272
1273 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001274 * Find the first vacant cell, if there is one.
1275 *
1276 * @param vacant Holds the x and y coordinate of the vacant cell
1277 * @param spanX Horizontal cell span.
1278 * @param spanY Vertical cell span.
Winson Chungaafa03c2010-06-11 17:34:16 -07001279 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001280 * @return True if a vacant cell was found
1281 */
1282 public boolean getVacantCell(int[] vacant, int spanX, int spanY) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001283
Michael Jurka0280c3b2010-09-17 15:00:07 -07001284 return findVacantCell(vacant, spanX, spanY, mCountX, mCountY, mOccupied);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001285 }
1286
1287 static boolean findVacantCell(int[] vacant, int spanX, int spanY,
1288 int xCount, int yCount, boolean[][] occupied) {
1289
1290 for (int x = 0; x < xCount; x++) {
1291 for (int y = 0; y < yCount; y++) {
1292 boolean available = !occupied[x][y];
1293out: for (int i = x; i < x + spanX - 1 && x < xCount; i++) {
1294 for (int j = y; j < y + spanY - 1 && y < yCount; j++) {
1295 available = available && !occupied[i][j];
1296 if (!available) break out;
1297 }
1298 }
1299
1300 if (available) {
1301 vacant[0] = x;
1302 vacant[1] = y;
1303 return true;
1304 }
1305 }
1306 }
1307
1308 return false;
1309 }
1310
Michael Jurka0280c3b2010-09-17 15:00:07 -07001311 private void clearOccupiedCells() {
1312 for (int x = 0; x < mCountX; x++) {
1313 for (int y = 0; y < mCountY; y++) {
1314 mOccupied[x][y] = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001315 }
1316 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001317 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001318
Michael Jurka0280c3b2010-09-17 15:00:07 -07001319 public void onMove(View view, int newCellX, int newCellY) {
1320 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1321 markCellsAsUnoccupiedForView(view);
1322 markCellsForView(newCellX, newCellY, lp.cellHSpan, lp.cellVSpan, true);
1323 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001324
Michael Jurka0280c3b2010-09-17 15:00:07 -07001325 private void markCellsAsOccupiedForView(View view) {
Michael Jurka8c920dd2011-01-20 14:16:56 -08001326 if (view == null || view.getParent() != mChildren) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001327 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1328 markCellsForView(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan, true);
1329 }
1330
1331 private void markCellsAsUnoccupiedForView(View view) {
Michael Jurka8c920dd2011-01-20 14:16:56 -08001332 if (view == null || view.getParent() != mChildren) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001333 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1334 markCellsForView(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan, false);
1335 }
1336
1337 private void markCellsForView(int cellX, int cellY, int spanX, int spanY, boolean value) {
1338 for (int x = cellX; x < cellX + spanX && x < mCountX; x++) {
1339 for (int y = cellY; y < cellY + spanY && y < mCountY; y++) {
1340 mOccupied[x][y] = value;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001341 }
1342 }
1343 }
1344
1345 @Override
1346 public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
1347 return new CellLayout.LayoutParams(getContext(), attrs);
1348 }
1349
1350 @Override
1351 protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
1352 return p instanceof CellLayout.LayoutParams;
1353 }
1354
1355 @Override
1356 protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
1357 return new CellLayout.LayoutParams(p);
1358 }
1359
Winson Chungaafa03c2010-06-11 17:34:16 -07001360 public static class CellLayoutAnimationController extends LayoutAnimationController {
1361 public CellLayoutAnimationController(Animation animation, float delay) {
1362 super(animation, delay);
1363 }
1364
1365 @Override
1366 protected long getDelayForView(View view) {
1367 return (int) (Math.random() * 150);
1368 }
1369 }
1370
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001371 public static class LayoutParams extends ViewGroup.MarginLayoutParams {
1372 /**
1373 * Horizontal location of the item in the grid.
1374 */
1375 @ViewDebug.ExportedProperty
1376 public int cellX;
1377
1378 /**
1379 * Vertical location of the item in the grid.
1380 */
1381 @ViewDebug.ExportedProperty
1382 public int cellY;
1383
1384 /**
1385 * Number of cells spanned horizontally by the item.
1386 */
1387 @ViewDebug.ExportedProperty
1388 public int cellHSpan;
1389
1390 /**
1391 * Number of cells spanned vertically by the item.
1392 */
1393 @ViewDebug.ExportedProperty
1394 public int cellVSpan;
Winson Chungaafa03c2010-06-11 17:34:16 -07001395
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001396 /**
1397 * Is this item currently being dragged
1398 */
1399 public boolean isDragging;
1400
1401 // X coordinate of the view in the layout.
1402 @ViewDebug.ExportedProperty
1403 int x;
1404 // Y coordinate of the view in the layout.
1405 @ViewDebug.ExportedProperty
1406 int y;
1407
Patrick Dubroyce34a972010-10-19 10:34:32 -07001408 /**
1409 * The old X coordinate of this item, relative to its current parent.
1410 * Used to animate the item into its new position.
1411 */
1412 int oldX;
1413
1414 /**
1415 * The old Y coordinate of this item, relative to its current parent.
1416 * Used to animate the item into its new position.
1417 */
1418 int oldY;
1419
Romain Guy84f296c2009-11-04 15:00:44 -08001420 boolean dropped;
Romain Guyfcb9e712009-10-02 16:06:52 -07001421
Michael Jurkad3ef3062010-11-23 16:23:58 -08001422 boolean animateDrop;
1423
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001424 public LayoutParams(Context c, AttributeSet attrs) {
1425 super(c, attrs);
1426 cellHSpan = 1;
1427 cellVSpan = 1;
1428 }
1429
1430 public LayoutParams(ViewGroup.LayoutParams source) {
1431 super(source);
1432 cellHSpan = 1;
1433 cellVSpan = 1;
1434 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001435
1436 public LayoutParams(LayoutParams source) {
1437 super(source);
1438 this.cellX = source.cellX;
1439 this.cellY = source.cellY;
1440 this.cellHSpan = source.cellHSpan;
1441 this.cellVSpan = source.cellVSpan;
1442 }
1443
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001444 public LayoutParams(int cellX, int cellY, int cellHSpan, int cellVSpan) {
Romain Guy8f19cdd2010-01-08 15:07:00 -08001445 super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001446 this.cellX = cellX;
1447 this.cellY = cellY;
1448 this.cellHSpan = cellHSpan;
1449 this.cellVSpan = cellVSpan;
1450 }
1451
1452 public void setup(int cellWidth, int cellHeight, int widthGap, int heightGap,
1453 int hStartPadding, int vStartPadding) {
Winson Chungaafa03c2010-06-11 17:34:16 -07001454
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001455 final int myCellHSpan = cellHSpan;
1456 final int myCellVSpan = cellVSpan;
1457 final int myCellX = cellX;
1458 final int myCellY = cellY;
Winson Chungaafa03c2010-06-11 17:34:16 -07001459
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001460 width = myCellHSpan * cellWidth + ((myCellHSpan - 1) * widthGap) -
1461 leftMargin - rightMargin;
1462 height = myCellVSpan * cellHeight + ((myCellVSpan - 1) * heightGap) -
1463 topMargin - bottomMargin;
1464
1465 x = hStartPadding + myCellX * (cellWidth + widthGap) + leftMargin;
1466 y = vStartPadding + myCellY * (cellHeight + heightGap) + topMargin;
1467 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001468
1469 public String toString() {
1470 return "(" + this.cellX + ", " + this.cellY + ")";
1471 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001472 }
1473
Michael Jurka0280c3b2010-09-17 15:00:07 -07001474 // This class stores info for two purposes:
1475 // 1. When dragging items (mDragInfo in Workspace), we store the View, its cellX & cellY,
1476 // its spanX, spanY, and the screen it is on
1477 // 2. When long clicking on an empty cell in a CellLayout, we save information about the
1478 // cellX and cellY coordinates and which page was clicked. We then set this as a tag on
1479 // the CellLayout that was long clicked
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001480 static final class CellInfo implements ContextMenu.ContextMenuInfo {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001481 View cell;
Michael Jurkaa63c4522010-08-19 13:52:27 -07001482 int cellX = -1;
1483 int cellY = -1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001484 int spanX;
1485 int spanY;
1486 int screen;
1487 boolean valid;
1488
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001489 @Override
1490 public String toString() {
Winson Chungaafa03c2010-06-11 17:34:16 -07001491 return "Cell[view=" + (cell == null ? "null" : cell.getClass())
1492 + ", x=" + cellX + ", y=" + cellY + "]";
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001493 }
1494 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001495}