blob: 2b3bb9a63024ff1e8604bcf44ca9e128981ecbfd [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
Adam Cohen66396872011-04-15 17:50:36 -070019import java.util.Arrays;
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.MotionEvent;
43import android.view.View;
44import android.view.ViewDebug;
45import android.view.ViewGroup;
Winson Chungaafa03c2010-06-11 17:34:16 -070046import android.view.animation.Animation;
Winson Chung150fbab2010-09-29 17:14:26 -070047import android.view.animation.DecelerateInterpolator;
Winson Chungaafa03c2010-06-11 17:34:16 -070048import android.view.animation.LayoutAnimationController;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080049
Adam Cohen66396872011-04-15 17:50:36 -070050import com.android.launcher.R;
Patrick Dubroy8e58e912010-10-14 13:21:48 -070051
Michael Jurkabdb5c532011-02-01 15:05:06 -080052public class CellLayout extends ViewGroup {
Winson Chungaafa03c2010-06-11 17:34:16 -070053 static final String TAG = "CellLayout";
54
The Android Open Source Project31dd5032009-03-03 19:32:27 -080055 private int mCellWidth;
56 private int mCellHeight;
Winson Chungaafa03c2010-06-11 17:34:16 -070057
Winson Chungaafa03c2010-06-11 17:34:16 -070058 private int mLeftPadding;
59 private int mRightPadding;
60 private int mTopPadding;
61 private int mBottomPadding;
62
Adam Cohend22015c2010-07-26 22:02:18 -070063 private int mCountX;
64 private int mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080065
66 private int mWidthGap;
67 private int mHeightGap;
68
69 private final Rect mRect = new Rect();
70 private final CellInfo mCellInfo = new CellInfo();
Winson Chungaafa03c2010-06-11 17:34:16 -070071
Patrick Dubroyde7658b2010-09-27 11:15:43 -070072 // These are temporary variables to prevent having to allocate a new object just to
73 // return an (x, y) value from helper functions. Do NOT use them to maintain other state.
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070074 private final int[] mTmpCellXY = new int[2];
Patrick Dubroyde7658b2010-09-27 11:15:43 -070075 private final int[] mTmpPoint = new int[2];
76 private final PointF mTmpPointF = new PointF();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070077
The Android Open Source Project31dd5032009-03-03 19:32:27 -080078 boolean[][] mOccupied;
79
Michael Jurkadee05892010-07-27 10:01:56 -070080 private OnTouchListener mInterceptTouchListener;
81
Michael Jurka5f1c5092010-09-03 14:15:02 -070082 private float mBackgroundAlpha;
Adam Cohen1b0aaac2010-10-28 11:11:18 -070083 private float mBackgroundAlphaMultiplier = 1.0f;
Adam Cohenf34bab52010-09-30 14:11:56 -070084
Michael Jurka33945b22010-12-21 18:19:38 -080085 private Drawable mNormalBackground;
Michael Jurka33945b22010-12-21 18:19:38 -080086 private Drawable mActiveBackground;
87 private Drawable mActiveGlowBackground;
88 private Drawable mNormalBackgroundMini;
89 private Drawable mNormalGlowBackgroundMini;
90 private Drawable mActiveBackgroundMini;
91 private Drawable mActiveGlowBackgroundMini;
Michael Jurka18014792010-10-14 09:01:34 -070092 private Rect mBackgroundRect;
Michael Jurka33945b22010-12-21 18:19:38 -080093 private Rect mGlowBackgroundRect;
94 private float mGlowBackgroundScale;
95 private float mGlowBackgroundAlpha;
Patrick Dubroy1262e362010-10-06 15:49:50 -070096
Adam Cohendf035382011-04-11 17:22:04 -070097 private boolean mAcceptsDrops = true;
Michael Jurka33945b22010-12-21 18:19:38 -080098 // If we're actively dragging something over this screen, mIsDragOverlapping is true
99 private boolean mIsDragOverlapping = false;
100 private boolean mIsDragOccuring = false;
101 private boolean mIsDefaultDropTarget = false;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700102 private final Point mDragCenter = new Point();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700103
Winson Chung150fbab2010-09-29 17:14:26 -0700104 // These arrays are used to implement the drag visualization on x-large screens.
Joe Onorato4be866d2010-10-10 11:26:02 -0700105 // They are used as circular arrays, indexed by mDragOutlineCurrent.
106 private Point[] mDragOutlines = new Point[8];
Chet Haase472b2812010-10-14 07:02:04 -0700107 private float[] mDragOutlineAlphas = new float[mDragOutlines.length];
Joe Onorato4be866d2010-10-10 11:26:02 -0700108 private InterruptibleInOutAnimator[] mDragOutlineAnims =
109 new InterruptibleInOutAnimator[mDragOutlines.length];
Winson Chung150fbab2010-09-29 17:14:26 -0700110
111 // Used as an index into the above 3 arrays; indicates which is the most current value.
Joe Onorato4be866d2010-10-10 11:26:02 -0700112 private int mDragOutlineCurrent = 0;
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700113 private final Paint mDragOutlinePaint = new Paint();
Winson Chung150fbab2010-09-29 17:14:26 -0700114
Patrick Dubroy96864c32011-03-10 17:17:23 -0800115 private BubbleTextView mPressedOrFocusedIcon;
116
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700117 private Drawable mCrosshairsDrawable = null;
Patrick Dubroy49250ad2010-10-08 15:33:52 -0700118 private InterruptibleInOutAnimator mCrosshairsAnimator = null;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700119 private float mCrosshairsVisibility = 0.0f;
120
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700121 // When a drag operation is in progress, holds the nearest cell to the touch point
122 private final int[] mDragCell = new int[2];
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800123
Joe Onorato4be866d2010-10-10 11:26:02 -0700124 private boolean mDragging = false;
125
Patrick Dubroyce34a972010-10-19 10:34:32 -0700126 private TimeInterpolator mEaseOutInterpolator;
Michael Jurka8c920dd2011-01-20 14:16:56 -0800127 private CellLayoutChildren mChildren;
Patrick Dubroyce34a972010-10-19 10:34:32 -0700128
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800129 public CellLayout(Context context) {
130 this(context, null);
131 }
132
133 public CellLayout(Context context, AttributeSet attrs) {
134 this(context, attrs, 0);
135 }
136
137 public CellLayout(Context context, AttributeSet attrs, int defStyle) {
138 super(context, attrs, defStyle);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700139
140 // A ViewGroup usually does not draw, but CellLayout needs to draw a rectangle to show
141 // the user where a dragged item will land when dropped.
142 setWillNotDraw(false);
Michael Jurkaa63c4522010-08-19 13:52:27 -0700143
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800144 TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CellLayout, defStyle, 0);
145
146 mCellWidth = a.getDimensionPixelSize(R.styleable.CellLayout_cellWidth, 10);
147 mCellHeight = a.getDimensionPixelSize(R.styleable.CellLayout_cellHeight, 10);
Winson Chungece7f5b2010-10-22 14:54:12 -0700148 mWidthGap = a.getDimensionPixelSize(R.styleable.CellLayout_widthGap, -1);
149 mHeightGap = a.getDimensionPixelSize(R.styleable.CellLayout_heightGap, -1);
Winson Chungaafa03c2010-06-11 17:34:16 -0700150
Adam Cohend22015c2010-07-26 22:02:18 -0700151 mLeftPadding =
152 a.getDimensionPixelSize(R.styleable.CellLayout_xAxisStartPadding, 10);
153 mRightPadding =
154 a.getDimensionPixelSize(R.styleable.CellLayout_xAxisEndPadding, 10);
155 mTopPadding =
156 a.getDimensionPixelSize(R.styleable.CellLayout_yAxisStartPadding, 10);
157 mBottomPadding =
158 a.getDimensionPixelSize(R.styleable.CellLayout_yAxisEndPadding, 10);
Winson Chungaafa03c2010-06-11 17:34:16 -0700159
Adam Cohend22015c2010-07-26 22:02:18 -0700160 mCountX = LauncherModel.getCellCountX();
161 mCountY = LauncherModel.getCellCountY();
Michael Jurka0280c3b2010-09-17 15:00:07 -0700162 mOccupied = new boolean[mCountX][mCountY];
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800163
164 a.recycle();
165
166 setAlwaysDrawnWithCacheEnabled(false);
167
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700168 final Resources res = getResources();
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700169
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700170 if (LauncherApplication.isScreenXLarge()) {
Michael Jurka33945b22010-12-21 18:19:38 -0800171 mNormalBackground = res.getDrawable(R.drawable.homescreen_large_blue);
Michael Jurka33945b22010-12-21 18:19:38 -0800172 mActiveBackground = res.getDrawable(R.drawable.homescreen_large_green);
173 mActiveGlowBackground = res.getDrawable(R.drawable.homescreen_large_green_strong);
174
175 mNormalBackgroundMini = res.getDrawable(R.drawable.homescreen_small_blue);
176 mNormalGlowBackgroundMini = res.getDrawable(R.drawable.homescreen_small_blue_strong);
177 mActiveBackgroundMini = res.getDrawable(R.drawable.homescreen_small_green);
178 mActiveGlowBackgroundMini = res.getDrawable(R.drawable.homescreen_small_green_strong);
179
180 mNormalBackground.setFilterBitmap(true);
Michael Jurka33945b22010-12-21 18:19:38 -0800181 mActiveBackground.setFilterBitmap(true);
182 mActiveGlowBackground.setFilterBitmap(true);
183 mNormalBackgroundMini.setFilterBitmap(true);
184 mNormalGlowBackgroundMini.setFilterBitmap(true);
185 mActiveBackgroundMini.setFilterBitmap(true);
186 mActiveGlowBackgroundMini.setFilterBitmap(true);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700187 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700188
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700189 // Initialize the data structures used for the drag visualization.
Winson Chung150fbab2010-09-29 17:14:26 -0700190
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700191 mCrosshairsDrawable = res.getDrawable(R.drawable.gardening_crosshairs);
Patrick Dubroyce34a972010-10-19 10:34:32 -0700192 mEaseOutInterpolator = new DecelerateInterpolator(2.5f); // Quint ease out
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700193
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700194 // Set up the animation for fading the crosshairs in and out
195 int animDuration = res.getInteger(R.integer.config_crosshairsFadeInTime);
Patrick Dubroy49250ad2010-10-08 15:33:52 -0700196 mCrosshairsAnimator = new InterruptibleInOutAnimator(animDuration, 0.0f, 1.0f);
Chet Haase472b2812010-10-14 07:02:04 -0700197 mCrosshairsAnimator.getAnimator().addUpdateListener(new AnimatorUpdateListener() {
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700198 public void onAnimationUpdate(ValueAnimator animation) {
199 mCrosshairsVisibility = ((Float) animation.getAnimatedValue()).floatValue();
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700200 invalidate();
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700201 }
202 });
Patrick Dubroyce34a972010-10-19 10:34:32 -0700203 mCrosshairsAnimator.getAnimator().setInterpolator(mEaseOutInterpolator);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700204
Joe Onorato4be866d2010-10-10 11:26:02 -0700205 for (int i = 0; i < mDragOutlines.length; i++) {
206 mDragOutlines[i] = new Point(-1, -1);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700207 }
208
209 // When dragging things around the home screens, we show a green outline of
210 // where the item will land. The outlines gradually fade out, leaving a trail
211 // behind the drag path.
212 // Set up all the animations that are used to implement this fading.
213 final int duration = res.getInteger(R.integer.config_dragOutlineFadeTime);
Chet Haase472b2812010-10-14 07:02:04 -0700214 final float fromAlphaValue = 0;
215 final float toAlphaValue = (float)res.getInteger(R.integer.config_dragOutlineMaxAlpha);
Joe Onorato4be866d2010-10-10 11:26:02 -0700216
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700217 Arrays.fill(mDragOutlineAlphas, fromAlphaValue);
Joe Onorato4be866d2010-10-10 11:26:02 -0700218
219 for (int i = 0; i < mDragOutlineAnims.length; i++) {
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700220 final InterruptibleInOutAnimator anim =
221 new InterruptibleInOutAnimator(duration, fromAlphaValue, toAlphaValue);
Patrick Dubroyce34a972010-10-19 10:34:32 -0700222 anim.getAnimator().setInterpolator(mEaseOutInterpolator);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700223 final int thisIndex = i;
Chet Haase472b2812010-10-14 07:02:04 -0700224 anim.getAnimator().addUpdateListener(new AnimatorUpdateListener() {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700225 public void onAnimationUpdate(ValueAnimator animation) {
Joe Onorato4be866d2010-10-10 11:26:02 -0700226 final Bitmap outline = (Bitmap)anim.getTag();
227
228 // If an animation is started and then stopped very quickly, we can still
229 // get spurious updates we've cleared the tag. Guard against this.
230 if (outline == null) {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -0700231 if (false) {
232 Object val = animation.getAnimatedValue();
233 Log.d(TAG, "anim " + thisIndex + " update: " + val +
234 ", isStopped " + anim.isStopped());
235 }
Joe Onorato4be866d2010-10-10 11:26:02 -0700236 // Try to prevent it from continuing to run
237 animation.cancel();
238 } else {
Chet Haase472b2812010-10-14 07:02:04 -0700239 mDragOutlineAlphas[thisIndex] = (Float) animation.getAnimatedValue();
Joe Onorato4be866d2010-10-10 11:26:02 -0700240 final int left = mDragOutlines[thisIndex].x;
241 final int top = mDragOutlines[thisIndex].y;
242 CellLayout.this.invalidate(left, top,
243 left + outline.getWidth(), top + outline.getHeight());
244 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700245 }
246 });
Joe Onorato4be866d2010-10-10 11:26:02 -0700247 // The animation holds a reference to the drag outline bitmap as long is it's
248 // running. This way the bitmap can be GCed when the animations are complete.
Chet Haase472b2812010-10-14 07:02:04 -0700249 anim.getAnimator().addListener(new AnimatorListenerAdapter() {
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700250 @Override
Joe Onorato4be866d2010-10-10 11:26:02 -0700251 public void onAnimationEnd(Animator animation) {
Chet Haase472b2812010-10-14 07:02:04 -0700252 if ((Float) ((ValueAnimator) animation).getAnimatedValue() == 0f) {
Joe Onorato4be866d2010-10-10 11:26:02 -0700253 anim.setTag(null);
254 }
255 }
256 });
257 mDragOutlineAnims[i] = anim;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700258 }
Patrick Dubroyce34a972010-10-19 10:34:32 -0700259
Michael Jurka18014792010-10-14 09:01:34 -0700260 mBackgroundRect = new Rect();
Michael Jurka33945b22010-12-21 18:19:38 -0800261 mGlowBackgroundRect = new Rect();
Michael Jurka18014792010-10-14 09:01:34 -0700262 setHoverScale(1.0f);
263 setHoverAlpha(1.0f);
Michael Jurkabea15192010-11-17 12:33:46 -0800264
Michael Jurka8c920dd2011-01-20 14:16:56 -0800265 mChildren = new CellLayoutChildren(context);
266 mChildren.setCellDimensions(
267 mCellWidth, mCellHeight, mLeftPadding, mTopPadding, mWidthGap, mHeightGap);
268 addView(mChildren);
Michael Jurka18014792010-10-14 09:01:34 -0700269 }
270
Patrick Dubroy96864c32011-03-10 17:17:23 -0800271 private void invalidateBubbleTextView(BubbleTextView icon) {
272 final int padding = icon.getPressedOrFocusedBackgroundPadding();
273 invalidate(icon.getLeft() - padding,
274 icon.getTop() - padding,
275 icon.getRight() + padding,
276 icon.getBottom() + padding);
277 }
278
279 void setPressedOrFocusedIcon(BubbleTextView icon) {
280 // We draw the pressed or focused BubbleTextView's background in CellLayout because it
281 // requires an expanded clip rect (due to the glow's blur radius)
282 BubbleTextView oldIcon = mPressedOrFocusedIcon;
283 mPressedOrFocusedIcon = icon;
284 if (oldIcon != null) {
285 invalidateBubbleTextView(oldIcon);
286 }
287 if (mPressedOrFocusedIcon != null) {
288 invalidateBubbleTextView(mPressedOrFocusedIcon);
289 }
290 }
291
Winson Chung6e314082011-01-27 16:46:51 -0800292 public CellLayoutChildren getChildrenLayout() {
293 if (getChildCount() > 0) {
294 return (CellLayoutChildren) getChildAt(0);
295 }
296 return null;
297 }
298
Michael Jurka33945b22010-12-21 18:19:38 -0800299 public void setIsDefaultDropTarget(boolean isDefaultDropTarget) {
300 if (mIsDefaultDropTarget != isDefaultDropTarget) {
301 mIsDefaultDropTarget = isDefaultDropTarget;
302 invalidate();
303 }
304 }
305
Michael Jurka33945b22010-12-21 18:19:38 -0800306 void setIsDragOccuring(boolean isDragOccuring) {
307 if (mIsDragOccuring != isDragOccuring) {
308 mIsDragOccuring = isDragOccuring;
309 invalidate();
310 }
311 }
312
313 void setIsDragOverlapping(boolean isDragOverlapping) {
314 if (mIsDragOverlapping != isDragOverlapping) {
315 mIsDragOverlapping = isDragOverlapping;
316 invalidate();
317 }
318 }
319
320 boolean getIsDragOverlapping() {
321 return mIsDragOverlapping;
322 }
323
324 private void updateGlowRect() {
325 float marginFraction = (mGlowBackgroundScale - 1.0f) / 2.0f;
Michael Jurka18014792010-10-14 09:01:34 -0700326 int marginX = (int) (marginFraction * (mBackgroundRect.right - mBackgroundRect.left));
327 int marginY = (int) (marginFraction * (mBackgroundRect.bottom - mBackgroundRect.top));
Michael Jurka33945b22010-12-21 18:19:38 -0800328 mGlowBackgroundRect.set(mBackgroundRect.left - marginX, mBackgroundRect.top - marginY,
Michael Jurka18014792010-10-14 09:01:34 -0700329 mBackgroundRect.right + marginX, mBackgroundRect.bottom + marginY);
330 invalidate();
331 }
332
333 public void setHoverScale(float scaleFactor) {
Michael Jurka33945b22010-12-21 18:19:38 -0800334 if (scaleFactor != mGlowBackgroundScale) {
335 mGlowBackgroundScale = scaleFactor;
336 updateGlowRect();
Michael Jurka8deb1e62011-01-25 16:27:43 -0800337 if (getParent() != null) {
338 ((View) getParent()).invalidate();
339 }
Michael Jurka18014792010-10-14 09:01:34 -0700340 }
341 }
342
343 public float getHoverScale() {
Michael Jurka33945b22010-12-21 18:19:38 -0800344 return mGlowBackgroundScale;
Michael Jurka18014792010-10-14 09:01:34 -0700345 }
346
347 public float getHoverAlpha() {
Michael Jurka33945b22010-12-21 18:19:38 -0800348 return mGlowBackgroundAlpha;
Michael Jurka18014792010-10-14 09:01:34 -0700349 }
350
351 public void setHoverAlpha(float alpha) {
Michael Jurka33945b22010-12-21 18:19:38 -0800352 mGlowBackgroundAlpha = alpha;
Michael Jurka18014792010-10-14 09:01:34 -0700353 invalidate();
354 }
355
356 void animateDrop() {
357 if (LauncherApplication.isScreenXLarge()) {
358 Resources res = getResources();
359 float onDropScale = res.getInteger(R.integer.config_screenOnDropScalePercent) / 100.0f;
360 ObjectAnimator scaleUp = ObjectAnimator.ofFloat(this, "hoverScale", onDropScale);
361 scaleUp.setDuration(res.getInteger(R.integer.config_screenOnDropScaleUpDuration));
362 ObjectAnimator scaleDown = ObjectAnimator.ofFloat(this, "hoverScale", 1.0f);
363 scaleDown.setDuration(res.getInteger(R.integer.config_screenOnDropScaleDownDuration));
364 ObjectAnimator alphaFadeOut = ObjectAnimator.ofFloat(this, "hoverAlpha", 0.0f);
365
366 alphaFadeOut.setStartDelay(res.getInteger(R.integer.config_screenOnDropAlphaFadeDelay));
367 alphaFadeOut.setDuration(res.getInteger(R.integer.config_screenOnDropAlphaFadeDelay));
368
369 AnimatorSet bouncer = new AnimatorSet();
370 bouncer.play(scaleUp).before(scaleDown);
371 bouncer.play(scaleUp).with(alphaFadeOut);
Michael Jurka8edd75c2010-12-17 20:15:06 -0800372 bouncer.addListener(new AnimatorListenerAdapter() {
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700373 @Override
Michael Jurka18014792010-10-14 09:01:34 -0700374 public void onAnimationStart(Animator animation) {
Michael Jurka33945b22010-12-21 18:19:38 -0800375 setIsDragOverlapping(true);
Michael Jurka18014792010-10-14 09:01:34 -0700376 }
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700377 @Override
Michael Jurka8edd75c2010-12-17 20:15:06 -0800378 public void onAnimationEnd(Animator animation) {
Michael Jurka33945b22010-12-21 18:19:38 -0800379 setIsDragOverlapping(false);
Michael Jurka18014792010-10-14 09:01:34 -0700380 setHoverScale(1.0f);
381 setHoverAlpha(1.0f);
382 }
383 });
384 bouncer.start();
385 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800386 }
387
Jeff Sharkey83f111d2009-04-20 21:03:13 -0700388 @Override
Patrick Dubroy1262e362010-10-06 15:49:50 -0700389 protected void onDraw(Canvas canvas) {
Michael Jurka3e7c7632010-10-02 16:01:03 -0700390 // When we're large, we are either drawn in a "hover" state (ie when dragging an item to
391 // a neighboring page) or with just a normal background (if backgroundAlpha > 0.0f)
392 // When we're small, we are either drawn normally or in the "accepts drops" state (during
393 // a drag). However, we also drag the mini hover background *over* one of those two
394 // backgrounds
Winson Chung26cbf3a2011-01-06 16:25:55 -0800395 if (LauncherApplication.isScreenXLarge() && mBackgroundAlpha > 0.0f) {
Adam Cohenf34bab52010-09-30 14:11:56 -0700396 Drawable bg;
Michael Jurka33945b22010-12-21 18:19:38 -0800397 boolean mini = getScaleX() < 0.5f;
398
399 if (mIsDragOverlapping) {
400 // In the mini case, we draw the active_glow bg *over* the active background
401 bg = mini ? mActiveBackgroundMini : mActiveGlowBackground;
402 } else if (mIsDragOccuring && mAcceptsDrops) {
403 bg = mini ? mActiveBackgroundMini : mActiveBackground;
Adam Cohen3af863b2011-01-25 12:16:51 -0800404 } else if (mIsDefaultDropTarget && mini) {
405 bg = mNormalGlowBackgroundMini;
Adam Cohenf34bab52010-09-30 14:11:56 -0700406 } else {
Michael Jurka33945b22010-12-21 18:19:38 -0800407 bg = mini ? mNormalBackgroundMini : mNormalBackground;
Adam Cohenf34bab52010-09-30 14:11:56 -0700408 }
Michael Jurka33945b22010-12-21 18:19:38 -0800409
410 bg.setAlpha((int) (mBackgroundAlpha * mBackgroundAlphaMultiplier * 255));
411 bg.setBounds(mBackgroundRect);
412 bg.draw(canvas);
413
414 if (mini && mIsDragOverlapping) {
Michael Jurka18014792010-10-14 09:01:34 -0700415 boolean modifiedClipRect = false;
Michael Jurka33945b22010-12-21 18:19:38 -0800416 if (mGlowBackgroundScale > 1.0f) {
Michael Jurka18014792010-10-14 09:01:34 -0700417 // If the hover background's scale is greater than 1, we'll be drawing outside
418 // the bounds of this CellLayout. Get around that by temporarily increasing the
419 // size of the clip rect
Michael Jurka33945b22010-12-21 18:19:38 -0800420 float marginFraction = (mGlowBackgroundScale - 1.0f) / 2.0f;
Michael Jurka18014792010-10-14 09:01:34 -0700421 Rect clipRect = canvas.getClipBounds();
422 int marginX = (int) (marginFraction * (clipRect.right - clipRect.left));
423 int marginY = (int) (marginFraction * (clipRect.bottom - clipRect.top));
424 canvas.save(Canvas.CLIP_SAVE_FLAG);
425 canvas.clipRect(-marginX, -marginY,
426 getWidth() + marginX, getHeight() + marginY, Region.Op.REPLACE);
427 modifiedClipRect = true;
428 }
429
Michael Jurka33945b22010-12-21 18:19:38 -0800430 mActiveGlowBackgroundMini.setAlpha(
431 (int) (mBackgroundAlpha * mGlowBackgroundAlpha * 255));
432 mActiveGlowBackgroundMini.setBounds(mGlowBackgroundRect);
433 mActiveGlowBackgroundMini.draw(canvas);
Michael Jurka18014792010-10-14 09:01:34 -0700434 if (modifiedClipRect) {
435 canvas.restore();
436 }
Michael Jurka3e7c7632010-10-02 16:01:03 -0700437 }
Michael Jurkaa63c4522010-08-19 13:52:27 -0700438 }
Romain Guya6abce82009-11-10 02:54:41 -0800439
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700440 if (mCrosshairsVisibility > 0.0f) {
441 final int countX = mCountX;
442 final int countY = mCountY;
443
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700444 final float MAX_ALPHA = 0.4f;
445 final int MAX_VISIBLE_DISTANCE = 600;
446 final float DISTANCE_MULTIPLIER = 0.002f;
447
448 final Drawable d = mCrosshairsDrawable;
449 final int width = d.getIntrinsicWidth();
450 final int height = d.getIntrinsicHeight();
451
452 int x = getLeftPadding() - (mWidthGap / 2) - (width / 2);
453 for (int col = 0; col <= countX; col++) {
454 int y = getTopPadding() - (mHeightGap / 2) - (height / 2);
455 for (int row = 0; row <= countY; row++) {
456 mTmpPointF.set(x - mDragCenter.x, y - mDragCenter.y);
457 float dist = mTmpPointF.length();
458 // Crosshairs further from the drag point are more faint
459 float alpha = Math.min(MAX_ALPHA,
460 DISTANCE_MULTIPLIER * (MAX_VISIBLE_DISTANCE - dist));
461 if (alpha > 0.0f) {
462 d.setBounds(x, y, x + width, y + height);
463 d.setAlpha((int) (alpha * 255 * mCrosshairsVisibility));
464 d.draw(canvas);
465 }
466 y += mCellHeight + mHeightGap;
467 }
468 x += mCellWidth + mWidthGap;
469 }
Joe Onorato4be866d2010-10-10 11:26:02 -0700470 }
Winson Chung150fbab2010-09-29 17:14:26 -0700471
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700472 final Paint paint = mDragOutlinePaint;
Joe Onorato4be866d2010-10-10 11:26:02 -0700473 for (int i = 0; i < mDragOutlines.length; i++) {
Chet Haase472b2812010-10-14 07:02:04 -0700474 final float alpha = mDragOutlineAlphas[i];
Joe Onorato4be866d2010-10-10 11:26:02 -0700475 if (alpha > 0) {
476 final Point p = mDragOutlines[i];
477 final Bitmap b = (Bitmap) mDragOutlineAnims[i].getTag();
Chet Haase472b2812010-10-14 07:02:04 -0700478 paint.setAlpha((int)(alpha + .5f));
Joe Onorato4be866d2010-10-10 11:26:02 -0700479 canvas.drawBitmap(b, p.x, p.y, paint);
Winson Chung150fbab2010-09-29 17:14:26 -0700480 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700481 }
Patrick Dubroy96864c32011-03-10 17:17:23 -0800482
483 // We draw the pressed or focused BubbleTextView's background in CellLayout because it
484 // requires an expanded clip rect (due to the glow's blur radius)
485 if (mPressedOrFocusedIcon != null) {
486 final int padding = mPressedOrFocusedIcon.getPressedOrFocusedBackgroundPadding();
487 final Bitmap b = mPressedOrFocusedIcon.getPressedOrFocusedBackground();
488 if (b != null) {
489 canvas.drawBitmap(b,
490 mPressedOrFocusedIcon.getLeft() - padding,
491 mPressedOrFocusedIcon.getTop() - padding,
492 null);
493 }
494 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700495 }
496
497 @Override
Jeff Sharkey83f111d2009-04-20 21:03:13 -0700498 public void cancelLongPress() {
499 super.cancelLongPress();
500
501 // Cancel long press for all children
502 final int count = getChildCount();
503 for (int i = 0; i < count; i++) {
504 final View child = getChildAt(i);
505 child.cancelLongPress();
506 }
507 }
508
Michael Jurkadee05892010-07-27 10:01:56 -0700509 public void setOnInterceptTouchListener(View.OnTouchListener listener) {
510 mInterceptTouchListener = listener;
511 }
512
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800513 int getCountX() {
Adam Cohend22015c2010-07-26 22:02:18 -0700514 return mCountX;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800515 }
516
517 int getCountY() {
Adam Cohend22015c2010-07-26 22:02:18 -0700518 return mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800519 }
520
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700521 public boolean addViewToCellLayout(
522 View child, int index, int childId, LayoutParams params, boolean markCells) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700523 final LayoutParams lp = params;
524
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800525 // Generate an id for each view, this assumes we have at most 256x256 cells
526 // per workspace screen
Adam Cohend22015c2010-07-26 22:02:18 -0700527 if (lp.cellX >= 0 && lp.cellX <= mCountX - 1 && lp.cellY >= 0 && lp.cellY <= mCountY - 1) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700528 // If the horizontal or vertical span is set to -1, it is taken to
529 // mean that it spans the extent of the CellLayout
Adam Cohend22015c2010-07-26 22:02:18 -0700530 if (lp.cellHSpan < 0) lp.cellHSpan = mCountX;
531 if (lp.cellVSpan < 0) lp.cellVSpan = mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800532
Winson Chungaafa03c2010-06-11 17:34:16 -0700533 child.setId(childId);
534
Michael Jurka8c920dd2011-01-20 14:16:56 -0800535 mChildren.addView(child, index, lp);
Michael Jurkadee05892010-07-27 10:01:56 -0700536
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700537 if (markCells) markCellsAsOccupiedForView(child);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700538
Winson Chungaafa03c2010-06-11 17:34:16 -0700539 return true;
540 }
541 return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800542 }
Michael Jurka3e7c7632010-10-02 16:01:03 -0700543
Michael Jurkabea15192010-11-17 12:33:46 -0800544 public void setAcceptsDrops(boolean acceptsDrops) {
545 if (mAcceptsDrops != acceptsDrops) {
546 mAcceptsDrops = acceptsDrops;
547 invalidate();
548 }
549 }
550
Michael Jurka3e7c7632010-10-02 16:01:03 -0700551 public boolean getAcceptsDrops() {
552 return mAcceptsDrops;
553 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800554
555 @Override
Michael Jurka0280c3b2010-09-17 15:00:07 -0700556 public void removeAllViews() {
557 clearOccupiedCells();
Michael Jurka8c920dd2011-01-20 14:16:56 -0800558 mChildren.removeAllViews();
Michael Jurka0280c3b2010-09-17 15:00:07 -0700559 }
560
561 @Override
562 public void removeAllViewsInLayout() {
563 clearOccupiedCells();
Michael Jurka8c920dd2011-01-20 14:16:56 -0800564 mChildren.removeAllViewsInLayout();
Michael Jurka0280c3b2010-09-17 15:00:07 -0700565 }
566
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700567 public void removeViewWithoutMarkingCells(View view) {
Michael Jurkacf6125c2011-01-28 15:20:01 -0800568 mChildren.removeView(view);
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700569 }
570
Michael Jurka0280c3b2010-09-17 15:00:07 -0700571 @Override
572 public void removeView(View view) {
573 markCellsAsUnoccupiedForView(view);
Michael Jurka8c920dd2011-01-20 14:16:56 -0800574 mChildren.removeView(view);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700575 }
576
577 @Override
578 public void removeViewAt(int index) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800579 markCellsAsUnoccupiedForView(mChildren.getChildAt(index));
580 mChildren.removeViewAt(index);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700581 }
582
583 @Override
584 public void removeViewInLayout(View view) {
585 markCellsAsUnoccupiedForView(view);
Michael Jurka8c920dd2011-01-20 14:16:56 -0800586 mChildren.removeViewInLayout(view);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700587 }
588
589 @Override
590 public void removeViews(int start, int count) {
591 for (int i = start; i < start + count; i++) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800592 markCellsAsUnoccupiedForView(mChildren.getChildAt(i));
Michael Jurka0280c3b2010-09-17 15:00:07 -0700593 }
Michael Jurka8c920dd2011-01-20 14:16:56 -0800594 mChildren.removeViews(start, count);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700595 }
596
597 @Override
598 public void removeViewsInLayout(int start, int count) {
599 for (int i = start; i < start + count; i++) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800600 markCellsAsUnoccupiedForView(mChildren.getChildAt(i));
Michael Jurka0280c3b2010-09-17 15:00:07 -0700601 }
Michael Jurka8c920dd2011-01-20 14:16:56 -0800602 mChildren.removeViewsInLayout(start, count);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700603 }
604
Michael Jurka8c920dd2011-01-20 14:16:56 -0800605 public void drawChildren(Canvas canvas) {
606 mChildren.draw(canvas);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800607 }
608
Michael Jurkaabded662011-03-04 12:06:57 -0800609 void buildChildrenLayer() {
610 mChildren.buildLayer();
611 }
612
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800613 @Override
614 protected void onAttachedToWindow() {
615 super.onAttachedToWindow();
616 mCellInfo.screen = ((ViewGroup) getParent()).indexOfChild(this);
617 }
618
Michael Jurkaaf442092010-06-10 17:01:57 -0700619 public void setTagToCellInfoForPoint(int touchX, int touchY) {
620 final CellInfo cellInfo = mCellInfo;
621 final Rect frame = mRect;
622 final int x = touchX + mScrollX;
623 final int y = touchY + mScrollY;
Michael Jurka8c920dd2011-01-20 14:16:56 -0800624 final int count = mChildren.getChildCount();
Michael Jurkaaf442092010-06-10 17:01:57 -0700625
626 boolean found = false;
627 for (int i = count - 1; i >= 0; i--) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800628 final View child = mChildren.getChildAt(i);
Adam Cohend4844c32011-02-18 19:25:06 -0800629 final LayoutParams lp = (LayoutParams) child.getLayoutParams();
Michael Jurkaaf442092010-06-10 17:01:57 -0700630
Adam Cohen1b607ed2011-03-03 17:26:50 -0800631 if ((child.getVisibility() == VISIBLE || child.getAnimation() != null) &&
632 lp.isLockedToGrid) {
Michael Jurkaaf442092010-06-10 17:01:57 -0700633 child.getHitRect(frame);
634 if (frame.contains(x, y)) {
Michael Jurkaaf442092010-06-10 17:01:57 -0700635 cellInfo.cell = child;
636 cellInfo.cellX = lp.cellX;
637 cellInfo.cellY = lp.cellY;
638 cellInfo.spanX = lp.cellHSpan;
639 cellInfo.spanY = lp.cellVSpan;
640 cellInfo.valid = true;
641 found = true;
Michael Jurkaaf442092010-06-10 17:01:57 -0700642 break;
643 }
644 }
645 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700646
Michael Jurkaaf442092010-06-10 17:01:57 -0700647 if (!found) {
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700648 final int cellXY[] = mTmpCellXY;
Michael Jurkaaf442092010-06-10 17:01:57 -0700649 pointToCellExact(x, y, cellXY);
650
Michael Jurkaaf442092010-06-10 17:01:57 -0700651 cellInfo.cell = null;
652 cellInfo.cellX = cellXY[0];
653 cellInfo.cellY = cellXY[1];
654 cellInfo.spanX = 1;
655 cellInfo.spanY = 1;
Michael Jurka0280c3b2010-09-17 15:00:07 -0700656 cellInfo.valid = cellXY[0] >= 0 && cellXY[1] >= 0 && cellXY[0] < mCountX &&
657 cellXY[1] < mCountY && !mOccupied[cellXY[0]][cellXY[1]];
Michael Jurkaaf442092010-06-10 17:01:57 -0700658 }
659 setTag(cellInfo);
660 }
661
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800662 @Override
663 public boolean onInterceptTouchEvent(MotionEvent ev) {
Michael Jurkadee05892010-07-27 10:01:56 -0700664 if (mInterceptTouchListener != null && mInterceptTouchListener.onTouch(this, ev)) {
665 return true;
666 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800667 final int action = ev.getAction();
668 final CellInfo cellInfo = mCellInfo;
669
670 if (action == MotionEvent.ACTION_DOWN) {
Michael Jurkaaf442092010-06-10 17:01:57 -0700671 setTagToCellInfoForPoint((int) ev.getX(), (int) ev.getY());
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800672 } else if (action == MotionEvent.ACTION_UP) {
673 cellInfo.cell = null;
674 cellInfo.cellX = -1;
675 cellInfo.cellY = -1;
676 cellInfo.spanX = 0;
677 cellInfo.spanY = 0;
678 cellInfo.valid = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800679 setTag(cellInfo);
680 }
681
682 return false;
683 }
684
685 @Override
686 public CellInfo getTag() {
Michael Jurka0280c3b2010-09-17 15:00:07 -0700687 return (CellInfo) super.getTag();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800688 }
689
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700690 /**
Winson Chungaafa03c2010-06-11 17:34:16 -0700691 * Given a point, return the cell that strictly encloses that point
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800692 * @param x X coordinate of the point
693 * @param y Y coordinate of the point
694 * @param result Array of 2 ints to hold the x and y coordinate of the cell
695 */
696 void pointToCellExact(int x, int y, int[] result) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700697 final int hStartPadding = getLeftPadding();
698 final int vStartPadding = getTopPadding();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800699
700 result[0] = (x - hStartPadding) / (mCellWidth + mWidthGap);
701 result[1] = (y - vStartPadding) / (mCellHeight + mHeightGap);
702
Adam Cohend22015c2010-07-26 22:02:18 -0700703 final int xAxis = mCountX;
704 final int yAxis = mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800705
706 if (result[0] < 0) result[0] = 0;
707 if (result[0] >= xAxis) result[0] = xAxis - 1;
708 if (result[1] < 0) result[1] = 0;
709 if (result[1] >= yAxis) result[1] = yAxis - 1;
710 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700711
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800712 /**
713 * Given a point, return the cell that most closely encloses that point
714 * @param x X coordinate of the point
715 * @param y Y coordinate of the point
716 * @param result Array of 2 ints to hold the x and y coordinate of the cell
717 */
718 void pointToCellRounded(int x, int y, int[] result) {
719 pointToCellExact(x + (mCellWidth / 2), y + (mCellHeight / 2), result);
720 }
721
722 /**
723 * Given a cell coordinate, return the point that represents the upper left corner of that cell
Winson Chungaafa03c2010-06-11 17:34:16 -0700724 *
725 * @param cellX X coordinate of the cell
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800726 * @param cellY Y coordinate of the cell
Winson Chungaafa03c2010-06-11 17:34:16 -0700727 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800728 * @param result Array of 2 ints to hold the x and y coordinate of the point
729 */
730 void cellToPoint(int cellX, int cellY, int[] result) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700731 final int hStartPadding = getLeftPadding();
732 final int vStartPadding = getTopPadding();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800733
734 result[0] = hStartPadding + cellX * (mCellWidth + mWidthGap);
735 result[1] = vStartPadding + cellY * (mCellHeight + mHeightGap);
736 }
737
Adam Cohene3e27a82011-04-15 12:07:39 -0700738 /**
739 * Given a cell coordinate, return the point that represents the upper left corner of that cell
740 *
741 * @param cellX X coordinate of the cell
742 * @param cellY Y coordinate of the cell
743 *
744 * @param result Array of 2 ints to hold the x and y coordinate of the point
745 */
746 void cellToCenterPoint(int cellX, int cellY, int[] result) {
747 final int hStartPadding = getLeftPadding();
748 final int vStartPadding = getTopPadding();
749
750 result[0] = hStartPadding + cellX * (mCellWidth + mWidthGap) + mCellWidth / 2;
751 result[1] = vStartPadding + cellY * (mCellHeight + mHeightGap) + mCellHeight / 2;
752 }
753
Romain Guy84f296c2009-11-04 15:00:44 -0800754 int getCellWidth() {
755 return mCellWidth;
756 }
757
758 int getCellHeight() {
759 return mCellHeight;
760 }
761
Adam Cohend4844c32011-02-18 19:25:06 -0800762 int getWidthGap() {
763 return mWidthGap;
764 }
765
766 int getHeightGap() {
767 return mHeightGap;
768 }
769
Romain Guy1a304a12009-11-10 00:02:32 -0800770 int getLeftPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700771 return mLeftPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800772 }
773
774 int getTopPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700775 return mTopPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800776 }
777
778 int getRightPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700779 return mRightPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800780 }
781
782 int getBottomPadding() {
Winson Chungaafa03c2010-06-11 17:34:16 -0700783 return mBottomPadding;
Romain Guy1a304a12009-11-10 00:02:32 -0800784 }
785
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800786 @Override
787 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
788 // TODO: currently ignoring padding
Winson Chungaafa03c2010-06-11 17:34:16 -0700789
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800790 int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
Winson Chungaafa03c2010-06-11 17:34:16 -0700791 int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
792
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800793 int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
794 int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
Winson Chungaafa03c2010-06-11 17:34:16 -0700795
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800796 if (widthSpecMode == MeasureSpec.UNSPECIFIED || heightSpecMode == MeasureSpec.UNSPECIFIED) {
797 throw new RuntimeException("CellLayout cannot have UNSPECIFIED dimensions");
798 }
799
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800800 final int cellWidth = mCellWidth;
801 final int cellHeight = mCellHeight;
802
Adam Cohend22015c2010-07-26 22:02:18 -0700803 int numWidthGaps = mCountX - 1;
804 int numHeightGaps = mCountY - 1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800805
Winson Chungece7f5b2010-10-22 14:54:12 -0700806 if (mWidthGap < 0 || mHeightGap < 0) {
807 int vSpaceLeft = heightSpecSize - mTopPadding - mBottomPadding - (cellHeight * mCountY);
808 mHeightGap = vSpaceLeft / numHeightGaps;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800809
Winson Chungece7f5b2010-10-22 14:54:12 -0700810 int hSpaceLeft = widthSpecSize - mLeftPadding - mRightPadding - (cellWidth * mCountX);
811 mWidthGap = hSpaceLeft / numWidthGaps;
Winson Chungaafa03c2010-06-11 17:34:16 -0700812
Winson Chungece7f5b2010-10-22 14:54:12 -0700813 // center it around the min gaps
814 int minGap = Math.min(mWidthGap, mHeightGap);
815 mWidthGap = mHeightGap = minGap;
816 }
Michael Jurka5f1c5092010-09-03 14:15:02 -0700817
Michael Jurka8c920dd2011-01-20 14:16:56 -0800818 // Initial values correspond to widthSpecMode == MeasureSpec.EXACTLY
819 int newWidth = widthSpecSize;
820 int newHeight = heightSpecSize;
Michael Jurka5f1c5092010-09-03 14:15:02 -0700821 if (widthSpecMode == MeasureSpec.AT_MOST) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800822 newWidth = mLeftPadding + mRightPadding + (mCountX * cellWidth) +
Winson Chungece7f5b2010-10-22 14:54:12 -0700823 ((mCountX - 1) * mWidthGap);
Michael Jurka8c920dd2011-01-20 14:16:56 -0800824 newHeight = mTopPadding + mBottomPadding + (mCountY * cellHeight) +
Winson Chungece7f5b2010-10-22 14:54:12 -0700825 ((mCountY - 1) * mHeightGap);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700826 setMeasuredDimension(newWidth, newHeight);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700827 }
Michael Jurka8c920dd2011-01-20 14:16:56 -0800828
829 int count = getChildCount();
830 for (int i = 0; i < count; i++) {
831 View child = getChildAt(i);
832 int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(newWidth, MeasureSpec.EXACTLY);
833 int childheightMeasureSpec = MeasureSpec.makeMeasureSpec(newHeight,
834 MeasureSpec.EXACTLY);
835 child.measure(childWidthMeasureSpec, childheightMeasureSpec);
836 }
837 setMeasuredDimension(newWidth, newHeight);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800838 }
839
840 @Override
Michael Jurka28750fb2010-09-24 17:43:49 -0700841 protected void onLayout(boolean changed, int l, int t, int r, int b) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800842 int count = getChildCount();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800843 for (int i = 0; i < count; i++) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800844 View child = getChildAt(i);
845 child.layout(0, 0, r - l, b - t);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800846 }
847 }
848
849 @Override
Michael Jurkadee05892010-07-27 10:01:56 -0700850 protected void onSizeChanged(int w, int h, int oldw, int oldh) {
851 super.onSizeChanged(w, h, oldw, oldh);
Michael Jurka18014792010-10-14 09:01:34 -0700852 mBackgroundRect.set(0, 0, w, h);
Michael Jurka33945b22010-12-21 18:19:38 -0800853 updateGlowRect();
Michael Jurkadee05892010-07-27 10:01:56 -0700854 }
855
856 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800857 protected void setChildrenDrawingCacheEnabled(boolean enabled) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800858 mChildren.setChildrenDrawingCacheEnabled(enabled);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800859 }
860
861 @Override
862 protected void setChildrenDrawnWithCacheEnabled(boolean enabled) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800863 mChildren.setChildrenDrawnWithCacheEnabled(enabled);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800864 }
865
Michael Jurka5f1c5092010-09-03 14:15:02 -0700866 public float getBackgroundAlpha() {
867 return mBackgroundAlpha;
Michael Jurkadee05892010-07-27 10:01:56 -0700868 }
869
Michael Jurka742574b2011-02-02 23:51:01 -0800870 public void setFastBackgroundAlpha(float alpha) {
871 mBackgroundAlpha = alpha;
872 }
873
Adam Cohen1b0aaac2010-10-28 11:11:18 -0700874 public void setBackgroundAlphaMultiplier(float multiplier) {
875 mBackgroundAlphaMultiplier = multiplier;
876 }
877
Adam Cohenddb82192010-11-10 16:32:54 -0800878 public float getBackgroundAlphaMultiplier() {
879 return mBackgroundAlphaMultiplier;
880 }
881
Michael Jurka5f1c5092010-09-03 14:15:02 -0700882 public void setBackgroundAlpha(float alpha) {
883 mBackgroundAlpha = alpha;
Michael Jurka0142d492010-08-25 17:46:15 -0700884 invalidate();
Michael Jurkadee05892010-07-27 10:01:56 -0700885 }
886
Michael Jurka5f1c5092010-09-03 14:15:02 -0700887 // Need to return true to let the view system know we know how to handle alpha-- this is
888 // because when our children have an alpha of 0.0f, they are still rendering their "dimmed"
889 // versions
890 @Override
891 protected boolean onSetAlpha(int alpha) {
892 return true;
893 }
894
895 public void setAlpha(float alpha) {
896 setChildrenAlpha(alpha);
897 super.setAlpha(alpha);
898 }
899
Michael Jurka742574b2011-02-02 23:51:01 -0800900 public void setFastAlpha(float alpha) {
901 setFastChildrenAlpha(alpha);
902 super.setFastAlpha(alpha);
903 }
904
Michael Jurkadee05892010-07-27 10:01:56 -0700905 private void setChildrenAlpha(float alpha) {
Michael Jurka0142d492010-08-25 17:46:15 -0700906 final int childCount = getChildCount();
907 for (int i = 0; i < childCount; i++) {
Michael Jurkadee05892010-07-27 10:01:56 -0700908 getChildAt(i).setAlpha(alpha);
909 }
910 }
911
Michael Jurka742574b2011-02-02 23:51:01 -0800912 private void setFastChildrenAlpha(float alpha) {
913 final int childCount = getChildCount();
914 for (int i = 0; i < childCount; i++) {
915 getChildAt(i).setFastAlpha(alpha);
916 }
917 }
918
Patrick Dubroy440c3602010-07-13 17:50:32 -0700919 public View getChildAt(int x, int y) {
Michael Jurka8c920dd2011-01-20 14:16:56 -0800920 return mChildren.getChildAt(x, y);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700921 }
922
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700923 /**
924 * Estimate where the top left cell of the dragged item will land if it is dropped.
925 *
926 * @param originX The X value of the top left corner of the item
927 * @param originY The Y value of the top left corner of the item
928 * @param spanX The number of horizontal cells that the item spans
929 * @param spanY The number of vertical cells that the item spans
930 * @param result The estimated drop cell X and Y.
931 */
932 void estimateDropCell(int originX, int originY, int spanX, int spanY, int[] result) {
Adam Cohend22015c2010-07-26 22:02:18 -0700933 final int countX = mCountX;
934 final int countY = mCountY;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700935
Michael Jurkaa63c4522010-08-19 13:52:27 -0700936 // pointToCellRounded takes the top left of a cell but will pad that with
937 // cellWidth/2 and cellHeight/2 when finding the matching cell
938 pointToCellRounded(originX, originY, result);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700939
940 // If the item isn't fully on this screen, snap to the edges
941 int rightOverhang = result[0] + spanX - countX;
942 if (rightOverhang > 0) {
943 result[0] -= rightOverhang; // Snap to right
944 }
945 result[0] = Math.max(0, result[0]); // Snap to left
946 int bottomOverhang = result[1] + spanY - countY;
947 if (bottomOverhang > 0) {
948 result[1] -= bottomOverhang; // Snap to bottom
949 }
950 result[1] = Math.max(0, result[1]); // Snap to top
951 }
952
Joe Onorato4be866d2010-10-10 11:26:02 -0700953 void visualizeDropLocation(
954 View v, Bitmap dragOutline, int originX, int originY, int spanX, int spanY) {
955
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -0700956 final int oldDragCellX = mDragCell[0];
957 final int oldDragCellY = mDragCell[1];
Joe Onorato4be866d2010-10-10 11:26:02 -0700958 final int[] nearest = findNearestVacantArea(originX, originY, spanX, spanY, v, mDragCell);
Winson Chunga9abd0e2010-10-27 17:18:37 -0700959 if (v != null) {
960 mDragCenter.set(originX + (v.getWidth() / 2), originY + (v.getHeight() / 2));
961 } else {
962 mDragCenter.set(originX, originY);
963 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700964
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -0700965 if (nearest != null && (nearest[0] != oldDragCellX || nearest[1] != oldDragCellY)) {
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700966 // Find the top left corner of the rect the object will occupy
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700967 final int[] topLeft = mTmpPoint;
968 cellToPoint(nearest[0], nearest[1], topLeft);
969
Joe Onorato4be866d2010-10-10 11:26:02 -0700970 int left = topLeft[0];
971 int top = topLeft[1];
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700972
Winson Chunga9abd0e2010-10-27 17:18:37 -0700973 if (v != null) {
Adam Cohen99e8b402011-03-25 19:23:43 -0700974 // When drawing the drag outline, it did not account for margin offsets
975 // added by the view's parent.
976 MarginLayoutParams lp = (MarginLayoutParams) v.getLayoutParams();
977 left += lp.leftMargin;
978 top += lp.topMargin;
Winson Chung150fbab2010-09-29 17:14:26 -0700979
Adam Cohen99e8b402011-03-25 19:23:43 -0700980 // Offsets due to the size difference between the View and the dragOutline.
981 // There is a size difference to account for the outer blur, which may lie
982 // outside the bounds of the view.
Winson Chunga9abd0e2010-10-27 17:18:37 -0700983 left += (v.getWidth() - dragOutline.getWidth()) / 2;
984 top += (v.getHeight() - dragOutline.getHeight()) / 2;
Adam Cohen66396872011-04-15 17:50:36 -0700985 } else {
986 // Center the drag outline in the cell
987 left += (mCellWidth - dragOutline.getWidth()) / 2;
988 top += (mCellHeight - dragOutline.getHeight()) / 2;
Winson Chunga9abd0e2010-10-27 17:18:37 -0700989 }
Winson Chung150fbab2010-09-29 17:14:26 -0700990
Joe Onorato4be866d2010-10-10 11:26:02 -0700991 final int oldIndex = mDragOutlineCurrent;
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -0700992 mDragOutlineAnims[oldIndex].animateOut();
993 mDragOutlineCurrent = (oldIndex + 1) % mDragOutlines.length;
Winson Chung150fbab2010-09-29 17:14:26 -0700994
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -0700995 mDragOutlines[mDragOutlineCurrent].set(left, top);
996 mDragOutlineAnims[mDragOutlineCurrent].setTag(dragOutline);
997 mDragOutlineAnims[mDragOutlineCurrent].animateIn();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700998 }
Patrick Dubroy49250ad2010-10-08 15:33:52 -0700999
1000 // If we are drawing crosshairs, the entire CellLayout needs to be invalidated
1001 if (mCrosshairsDrawable != null) {
1002 invalidate();
1003 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001004 }
1005
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001006 /**
Jeff Sharkey70864282009-04-07 21:08:40 -07001007 * Find a vacant area that will fit the given bounds nearest the requested
1008 * cell location. Uses Euclidean distance to score multiple vacant areas.
Winson Chungaafa03c2010-06-11 17:34:16 -07001009 *
Romain Guy51afc022009-05-04 18:03:43 -07001010 * @param pixelX The X location at which you want to search for a vacant area.
1011 * @param pixelY The Y location at which you want to search for a vacant area.
Jeff Sharkey70864282009-04-07 21:08:40 -07001012 * @param spanX Horizontal span of the object.
1013 * @param spanY Vertical span of the object.
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001014 * @param result Array in which to place the result, or null (in which case a new array will
1015 * be allocated)
Jeff Sharkey70864282009-04-07 21:08:40 -07001016 * @return The X, Y cell of a vacant area that can contain this object,
1017 * nearest the requested location.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001018 */
Michael Jurka6a1435d2010-09-27 17:35:12 -07001019 int[] findNearestVacantArea(
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001020 int pixelX, int pixelY, int spanX, int spanY, int[] result) {
1021 return findNearestVacantArea(pixelX, pixelY, spanX, spanY, null, result);
Michael Jurka6a1435d2010-09-27 17:35:12 -07001022 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001023
Michael Jurka6a1435d2010-09-27 17:35:12 -07001024 /**
1025 * Find a vacant area that will fit the given bounds nearest the requested
1026 * cell location. Uses Euclidean distance to score multiple vacant areas.
1027 *
1028 * @param pixelX The X location at which you want to search for a vacant area.
1029 * @param pixelY The Y location at which you want to search for a vacant area.
1030 * @param spanX Horizontal span of the object.
1031 * @param spanY Vertical span of the object.
Adam Cohendf035382011-04-11 17:22:04 -07001032 * @param ignoreOccupied If true, the result can be an occupied cell
1033 * @param result Array in which to place the result, or null (in which case a new array will
1034 * be allocated)
Michael Jurka6a1435d2010-09-27 17:35:12 -07001035 * @return The X, Y cell of a vacant area that can contain this object,
1036 * nearest the requested location.
1037 */
Adam Cohendf035382011-04-11 17:22:04 -07001038 int[] findNearestArea(int pixelX, int pixelY, int spanX, int spanY, View ignoreView,
1039 boolean ignoreOccupied, int[] result) {
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001040 // mark space take by ignoreView as available (method checks if ignoreView is null)
1041 markCellsAsUnoccupiedForView(ignoreView);
1042
Adam Cohene3e27a82011-04-15 12:07:39 -07001043 // For items with a spanX / spanY > 1, the passed in point (pixelX, pixelY) corresponds
1044 // to the center of the item, but we are searching based on the top-left cell, so
1045 // we translate the point over to correspond to the top-left.
1046 pixelX -= (mCellWidth + mWidthGap) * (spanX - 1) / 2f;
1047 pixelY -= (mCellHeight + mHeightGap) * (spanY - 1) / 2f;
1048
Jeff Sharkey70864282009-04-07 21:08:40 -07001049 // Keep track of best-scoring drop area
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001050 final int[] bestXY = result != null ? result : new int[2];
Jeff Sharkey70864282009-04-07 21:08:40 -07001051 double bestDistance = Double.MAX_VALUE;
Winson Chungaafa03c2010-06-11 17:34:16 -07001052
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001053 final int countX = mCountX;
1054 final int countY = mCountY;
1055 final boolean[][] occupied = mOccupied;
1056
Winson Chungbbc60d82010-11-11 16:34:41 -08001057 for (int y = 0; y < countY - (spanY - 1); y++) {
Michael Jurkac28de512010-08-13 11:27:44 -07001058 inner:
Winson Chungbbc60d82010-11-11 16:34:41 -08001059 for (int x = 0; x < countX - (spanX - 1); x++) {
Adam Cohendf035382011-04-11 17:22:04 -07001060 if (ignoreOccupied) {
1061 for (int i = 0; i < spanX; i++) {
1062 for (int j = 0; j < spanY; j++) {
1063 if (occupied[x + i][y + j]) {
1064 // small optimization: we can skip to after the column we
1065 // just found an occupied cell
1066 x += i;
1067 continue inner;
1068 }
Michael Jurkac28de512010-08-13 11:27:44 -07001069 }
1070 }
1071 }
1072 final int[] cellXY = mTmpCellXY;
Adam Cohene3e27a82011-04-15 12:07:39 -07001073 cellToCenterPoint(x, y, cellXY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001074
Michael Jurkac28de512010-08-13 11:27:44 -07001075 double distance = Math.sqrt(Math.pow(cellXY[0] - pixelX, 2)
1076 + Math.pow(cellXY[1] - pixelY, 2));
1077 if (distance <= bestDistance) {
1078 bestDistance = distance;
1079 bestXY[0] = x;
1080 bestXY[1] = y;
1081 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001082 }
1083 }
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001084 // re-mark space taken by ignoreView as occupied
1085 markCellsAsOccupiedForView(ignoreView);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001086
Winson Chungaafa03c2010-06-11 17:34:16 -07001087 // Return null if no suitable location found
Jeff Sharkey70864282009-04-07 21:08:40 -07001088 if (bestDistance < Double.MAX_VALUE) {
1089 return bestXY;
1090 } else {
1091 return null;
1092 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001093 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001094
Adam Cohendf035382011-04-11 17:22:04 -07001095 /**
1096 * Find a vacant area that will fit the given bounds nearest the requested
1097 * cell location. Uses Euclidean distance to score multiple vacant areas.
1098 *
1099 * @param pixelX The X location at which you want to search for a vacant area.
1100 * @param pixelY The Y location at which you want to search for a vacant area.
1101 * @param spanX Horizontal span of the object.
1102 * @param spanY Vertical span of the object.
1103 * @param ignoreView Considers space occupied by this view as unoccupied
1104 * @param result Previously returned value to possibly recycle.
1105 * @return The X, Y cell of a vacant area that can contain this object,
1106 * nearest the requested location.
1107 */
1108 int[] findNearestVacantArea(
1109 int pixelX, int pixelY, int spanX, int spanY, View ignoreView, int[] result) {
1110 return findNearestArea(pixelX, pixelY, spanX, spanY, ignoreView, true, result);
1111 }
1112
1113 /**
1114 * Find a starting cell position that will fit the given bounds nearest the requested
1115 * cell location. Uses Euclidean distance to score multiple vacant areas.
1116 *
1117 * @param pixelX The X location at which you want to search for a vacant area.
1118 * @param pixelY The Y location at which you want to search for a vacant area.
1119 * @param spanX Horizontal span of the object.
1120 * @param spanY Vertical span of the object.
1121 * @param ignoreView Considers space occupied by this view as unoccupied
1122 * @param result Previously returned value to possibly recycle.
1123 * @return The X, Y cell of a vacant area that can contain this object,
1124 * nearest the requested location.
1125 */
1126 int[] findNearestArea(
1127 int pixelX, int pixelY, int spanX, int spanY, int[] result) {
1128 return findNearestArea(pixelX, pixelY, spanX, spanY, null, false, result);
1129 }
1130
Michael Jurka0280c3b2010-09-17 15:00:07 -07001131 boolean existsEmptyCell() {
1132 return findCellForSpan(null, 1, 1);
1133 }
1134
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001135 /**
Michael Jurka0280c3b2010-09-17 15:00:07 -07001136 * Finds the upper-left coordinate of the first rectangle in the grid that can
1137 * hold a cell of the specified dimensions. If intersectX and intersectY are not -1,
1138 * then this method will only return coordinates for rectangles that contain the cell
1139 * (intersectX, intersectY)
1140 *
1141 * @param cellXY The array that will contain the position of a vacant cell if such a cell
1142 * can be found.
1143 * @param spanX The horizontal span of the cell we want to find.
1144 * @param spanY The vertical span of the cell we want to find.
1145 *
1146 * @return True if a vacant cell of the specified dimension was found, false otherwise.
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001147 */
Michael Jurka0280c3b2010-09-17 15:00:07 -07001148 boolean findCellForSpan(int[] cellXY, int spanX, int spanY) {
1149 return findCellForSpanThatIntersectsIgnoring(cellXY, spanX, spanY, -1, -1, null);
1150 }
1151
1152 /**
1153 * Like above, but ignores any cells occupied by the item "ignoreView"
1154 *
1155 * @param cellXY The array that will contain the position of a vacant cell if such a cell
1156 * can be found.
1157 * @param spanX The horizontal span of the cell we want to find.
1158 * @param spanY The vertical span of the cell we want to find.
1159 * @param ignoreView The home screen item we should treat as not occupying any space
1160 * @return
1161 */
1162 boolean findCellForSpanIgnoring(int[] cellXY, int spanX, int spanY, View ignoreView) {
1163 return findCellForSpanThatIntersectsIgnoring(cellXY, spanX, spanY, -1, -1, ignoreView);
1164 }
1165
1166 /**
1167 * Like above, but if intersectX and intersectY are not -1, then this method will try to
1168 * return coordinates for rectangles that contain the cell [intersectX, intersectY]
1169 *
1170 * @param spanX The horizontal span of the cell we want to find.
1171 * @param spanY The vertical span of the cell we want to find.
1172 * @param ignoreView The home screen item we should treat as not occupying any space
1173 * @param intersectX The X coordinate of the cell that we should try to overlap
1174 * @param intersectX The Y coordinate of the cell that we should try to overlap
1175 *
1176 * @return True if a vacant cell of the specified dimension was found, false otherwise.
1177 */
1178 boolean findCellForSpanThatIntersects(int[] cellXY, int spanX, int spanY,
1179 int intersectX, int intersectY) {
1180 return findCellForSpanThatIntersectsIgnoring(
1181 cellXY, spanX, spanY, intersectX, intersectY, null);
1182 }
1183
1184 /**
1185 * The superset of the above two methods
1186 */
1187 boolean findCellForSpanThatIntersectsIgnoring(int[] cellXY, int spanX, int spanY,
1188 int intersectX, int intersectY, View ignoreView) {
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001189 // mark space take by ignoreView as available (method checks if ignoreView is null)
1190 markCellsAsUnoccupiedForView(ignoreView);
Michael Jurka0280c3b2010-09-17 15:00:07 -07001191
Michael Jurka28750fb2010-09-24 17:43:49 -07001192 boolean foundCell = false;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001193 while (true) {
1194 int startX = 0;
1195 if (intersectX >= 0) {
1196 startX = Math.max(startX, intersectX - (spanX - 1));
1197 }
1198 int endX = mCountX - (spanX - 1);
1199 if (intersectX >= 0) {
1200 endX = Math.min(endX, intersectX + (spanX - 1) + (spanX == 1 ? 1 : 0));
1201 }
1202 int startY = 0;
1203 if (intersectY >= 0) {
1204 startY = Math.max(startY, intersectY - (spanY - 1));
1205 }
1206 int endY = mCountY - (spanY - 1);
1207 if (intersectY >= 0) {
1208 endY = Math.min(endY, intersectY + (spanY - 1) + (spanY == 1 ? 1 : 0));
1209 }
1210
Winson Chungbbc60d82010-11-11 16:34:41 -08001211 for (int y = startY; y < endY && !foundCell; y++) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001212 inner:
Winson Chungbbc60d82010-11-11 16:34:41 -08001213 for (int x = startX; x < endX; x++) {
Michael Jurka0280c3b2010-09-17 15:00:07 -07001214 for (int i = 0; i < spanX; i++) {
1215 for (int j = 0; j < spanY; j++) {
1216 if (mOccupied[x + i][y + j]) {
Winson Chungbbc60d82010-11-11 16:34:41 -08001217 // small optimization: we can skip to after the column we just found
Michael Jurka0280c3b2010-09-17 15:00:07 -07001218 // an occupied cell
Winson Chungbbc60d82010-11-11 16:34:41 -08001219 x += i;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001220 continue inner;
1221 }
1222 }
1223 }
1224 if (cellXY != null) {
1225 cellXY[0] = x;
1226 cellXY[1] = y;
1227 }
Michael Jurka28750fb2010-09-24 17:43:49 -07001228 foundCell = true;
1229 break;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001230 }
1231 }
1232 if (intersectX == -1 && intersectY == -1) {
1233 break;
1234 } else {
1235 // if we failed to find anything, try again but without any requirements of
1236 // intersecting
1237 intersectX = -1;
1238 intersectY = -1;
1239 continue;
1240 }
1241 }
1242
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001243 // re-mark space taken by ignoreView as occupied
1244 markCellsAsOccupiedForView(ignoreView);
Michael Jurka28750fb2010-09-24 17:43:49 -07001245 return foundCell;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001246 }
1247
1248 /**
1249 * Called when drag has left this CellLayout or has been completed (successfully or not)
1250 */
1251 void onDragExit() {
Joe Onorato4be866d2010-10-10 11:26:02 -07001252 // This can actually be called when we aren't in a drag, e.g. when adding a new
1253 // item to this layout via the customize drawer.
1254 // Guard against that case.
1255 if (mDragging) {
1256 mDragging = false;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001257
Joe Onorato4be866d2010-10-10 11:26:02 -07001258 // Fade out the drag indicators
1259 if (mCrosshairsAnimator != null) {
1260 mCrosshairsAnimator.animateOut();
1261 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001262 }
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001263
1264 // Invalidate the drag data
1265 mDragCell[0] = -1;
1266 mDragCell[1] = -1;
1267 mDragOutlineAnims[mDragOutlineCurrent].animateOut();
1268 mDragOutlineCurrent = (mDragOutlineCurrent + 1) % mDragOutlineAnims.length;
1269
Michael Jurka33945b22010-12-21 18:19:38 -08001270 setIsDragOverlapping(false);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001271 }
1272
1273 /**
Winson Chungaafa03c2010-06-11 17:34:16 -07001274 * Mark a child as having been dropped.
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001275 * At the beginning of the drag operation, the child may have been on another
Patrick Dubroyce34a972010-10-19 10:34:32 -07001276 * screen, but it is re-parented before this method is called.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001277 *
1278 * @param child The child that is being dropped
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001279 */
Michael Jurkad3ef3062010-11-23 16:23:58 -08001280 void onDropChild(View child, boolean animate) {
Romain Guyd94533d2009-08-17 10:01:15 -07001281 if (child != null) {
1282 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Romain Guyd94533d2009-08-17 10:01:15 -07001283 lp.isDragging = false;
Romain Guy84f296c2009-11-04 15:00:44 -08001284 lp.dropped = true;
Michael Jurkad3ef3062010-11-23 16:23:58 -08001285 lp.animateDrop = animate;
Patrick Dubroye3887cc2011-01-20 10:43:40 -08001286 child.setVisibility(animate ? View.INVISIBLE : View.VISIBLE);
Romain Guyd94533d2009-08-17 10:01:15 -07001287 child.requestLayout();
Romain Guyd94533d2009-08-17 10:01:15 -07001288 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001289 }
1290
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001291 /**
1292 * Start dragging the specified child
Winson Chungaafa03c2010-06-11 17:34:16 -07001293 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001294 * @param child The child that is being dragged
1295 */
1296 void onDragChild(View child) {
1297 LayoutParams lp = (LayoutParams) child.getLayoutParams();
1298 lp.isDragging = true;
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001299 }
1300
1301 /**
1302 * A drag event has begun over this layout.
1303 * It may have begun over this layout (in which case onDragChild is called first),
1304 * or it may have begun on another layout.
1305 */
Winson Chunga9abd0e2010-10-27 17:18:37 -07001306 void onDragEnter() {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -07001307 if (!mDragging) {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -07001308 // Fade in the drag indicators
1309 if (mCrosshairsAnimator != null) {
1310 mCrosshairsAnimator.animateIn();
1311 }
Joe Onorato4be866d2010-10-10 11:26:02 -07001312 }
1313 mDragging = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001314 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001315
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001316 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001317 * Computes a bounding rectangle for a range of cells
Winson Chungaafa03c2010-06-11 17:34:16 -07001318 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001319 * @param cellX X coordinate of upper left corner expressed as a cell position
1320 * @param cellY Y coordinate of upper left corner expressed as a cell position
Winson Chungaafa03c2010-06-11 17:34:16 -07001321 * @param cellHSpan Width in cells
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001322 * @param cellVSpan Height in cells
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001323 * @param resultRect Rect into which to put the results
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001324 */
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001325 public void cellToRect(int cellX, int cellY, int cellHSpan, int cellVSpan, RectF resultRect) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001326 final int cellWidth = mCellWidth;
1327 final int cellHeight = mCellHeight;
1328 final int widthGap = mWidthGap;
1329 final int heightGap = mHeightGap;
Winson Chungaafa03c2010-06-11 17:34:16 -07001330
1331 final int hStartPadding = getLeftPadding();
1332 final int vStartPadding = getTopPadding();
1333
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001334 int width = cellHSpan * cellWidth + ((cellHSpan - 1) * widthGap);
1335 int height = cellVSpan * cellHeight + ((cellVSpan - 1) * heightGap);
1336
1337 int x = hStartPadding + cellX * (cellWidth + widthGap);
1338 int y = vStartPadding + cellY * (cellHeight + heightGap);
Winson Chungaafa03c2010-06-11 17:34:16 -07001339
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001340 resultRect.set(x, y, x + width, y + height);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001341 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001342
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001343 /**
Winson Chungaafa03c2010-06-11 17:34:16 -07001344 * Computes the required horizontal and vertical cell spans to always
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001345 * fit the given rectangle.
Winson Chungaafa03c2010-06-11 17:34:16 -07001346 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001347 * @param width Width in pixels
1348 * @param height Height in pixels
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001349 * @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 -08001350 */
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001351 public int[] rectToCell(int width, int height, int[] result) {
Michael Jurka9987a5c2010-10-08 16:58:12 -07001352 return rectToCell(getResources(), width, height, result);
1353 }
1354
1355 public static int[] rectToCell(Resources resources, int width, int height, int[] result) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001356 // Always assume we're working with the smallest span to make sure we
1357 // reserve enough space in both orientations.
Joe Onorato79e56262009-09-21 15:23:04 -04001358 int actualWidth = resources.getDimensionPixelSize(R.dimen.workspace_cell_width);
1359 int actualHeight = resources.getDimensionPixelSize(R.dimen.workspace_cell_height);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001360 int smallerSize = Math.min(actualWidth, actualHeight);
Joe Onorato79e56262009-09-21 15:23:04 -04001361
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001362 // Always round up to next largest cell
1363 int spanX = (width + smallerSize) / smallerSize;
1364 int spanY = (height + smallerSize) / smallerSize;
Joe Onorato79e56262009-09-21 15:23:04 -04001365
Patrick Dubroy8f86ddc2010-07-16 13:55:32 -07001366 if (result == null) {
1367 return new int[] { spanX, spanY };
1368 }
1369 result[0] = spanX;
1370 result[1] = spanY;
1371 return result;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001372 }
1373
Michael Jurkaf12c75c2011-01-25 22:41:40 -08001374 public int[] cellSpansToSize(int hSpans, int vSpans) {
1375 int[] size = new int[2];
1376 size[0] = hSpans * mCellWidth + (hSpans - 1) * mWidthGap;
1377 size[1] = vSpans * mCellHeight + (vSpans - 1) * mHeightGap;
1378 return size;
1379 }
1380
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001381 /**
Patrick Dubroy047379a2010-12-19 22:02:04 -08001382 * Calculate the grid spans needed to fit given item
1383 */
1384 public void calculateSpans(ItemInfo info) {
1385 final int minWidth;
1386 final int minHeight;
1387
1388 if (info instanceof LauncherAppWidgetInfo) {
1389 minWidth = ((LauncherAppWidgetInfo) info).minWidth;
1390 minHeight = ((LauncherAppWidgetInfo) info).minHeight;
1391 } else if (info instanceof PendingAddWidgetInfo) {
1392 minWidth = ((PendingAddWidgetInfo) info).minWidth;
1393 minHeight = ((PendingAddWidgetInfo) info).minHeight;
1394 } else {
1395 // It's not a widget, so it must be 1x1
1396 info.spanX = info.spanY = 1;
1397 return;
1398 }
1399 int[] spans = rectToCell(minWidth, minHeight, null);
1400 info.spanX = spans[0];
1401 info.spanY = spans[1];
1402 }
1403
1404 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001405 * Find the first vacant cell, if there is one.
1406 *
1407 * @param vacant Holds the x and y coordinate of the vacant cell
1408 * @param spanX Horizontal cell span.
1409 * @param spanY Vertical cell span.
Winson Chungaafa03c2010-06-11 17:34:16 -07001410 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001411 * @return True if a vacant cell was found
1412 */
1413 public boolean getVacantCell(int[] vacant, int spanX, int spanY) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001414
Michael Jurka0280c3b2010-09-17 15:00:07 -07001415 return findVacantCell(vacant, spanX, spanY, mCountX, mCountY, mOccupied);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001416 }
1417
1418 static boolean findVacantCell(int[] vacant, int spanX, int spanY,
1419 int xCount, int yCount, boolean[][] occupied) {
1420
1421 for (int x = 0; x < xCount; x++) {
1422 for (int y = 0; y < yCount; y++) {
1423 boolean available = !occupied[x][y];
1424out: for (int i = x; i < x + spanX - 1 && x < xCount; i++) {
1425 for (int j = y; j < y + spanY - 1 && y < yCount; j++) {
1426 available = available && !occupied[i][j];
1427 if (!available) break out;
1428 }
1429 }
1430
1431 if (available) {
1432 vacant[0] = x;
1433 vacant[1] = y;
1434 return true;
1435 }
1436 }
1437 }
1438
1439 return false;
1440 }
1441
Michael Jurka0280c3b2010-09-17 15:00:07 -07001442 private void clearOccupiedCells() {
1443 for (int x = 0; x < mCountX; x++) {
1444 for (int y = 0; y < mCountY; y++) {
1445 mOccupied[x][y] = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001446 }
1447 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07001448 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001449
Adam Cohen1b607ed2011-03-03 17:26:50 -08001450 /**
1451 * Given a view, determines how much that view can be expanded in all directions, in terms of
1452 * whether or not there are other items occupying adjacent cells. Used by the
1453 * AppWidgetResizeFrame to determine how the widget can be resized.
1454 */
Adam Cohend4844c32011-02-18 19:25:06 -08001455 public void getExpandabilityArrayForView(View view, int[] expandability) {
Adam Cohen1b607ed2011-03-03 17:26:50 -08001456 final LayoutParams lp = (LayoutParams) view.getLayoutParams();
Adam Cohend4844c32011-02-18 19:25:06 -08001457 boolean flag;
1458
Adam Cohen1b607ed2011-03-03 17:26:50 -08001459 expandability[AppWidgetResizeFrame.LEFT] = 0;
Adam Cohend4844c32011-02-18 19:25:06 -08001460 for (int x = lp.cellX - 1; x >= 0; x--) {
1461 flag = false;
1462 for (int y = lp.cellY; y < lp.cellY + lp.cellVSpan; y++) {
1463 if (mOccupied[x][y]) flag = true;
1464 }
1465 if (flag) break;
Adam Cohen1b607ed2011-03-03 17:26:50 -08001466 expandability[AppWidgetResizeFrame.LEFT]++;
Adam Cohend4844c32011-02-18 19:25:06 -08001467 }
1468
Adam Cohen1b607ed2011-03-03 17:26:50 -08001469 expandability[AppWidgetResizeFrame.TOP] = 0;
Adam Cohend4844c32011-02-18 19:25:06 -08001470 for (int y = lp.cellY - 1; y >= 0; y--) {
1471 flag = false;
1472 for (int x = lp.cellX; x < lp.cellX + lp.cellHSpan; x++) {
1473 if (mOccupied[x][y]) flag = true;
1474 }
1475 if (flag) break;
Adam Cohen1b607ed2011-03-03 17:26:50 -08001476 expandability[AppWidgetResizeFrame.TOP]++;
1477 }
Adam Cohend4844c32011-02-18 19:25:06 -08001478
Adam Cohen1b607ed2011-03-03 17:26:50 -08001479 expandability[AppWidgetResizeFrame.RIGHT] = 0;
Adam Cohend4844c32011-02-18 19:25:06 -08001480 for (int x = lp.cellX + lp.cellHSpan; x < mCountX; x++) {
1481 flag = false;
1482 for (int y = lp.cellY; y < lp.cellY + lp.cellVSpan; y++) {
1483 if (mOccupied[x][y]) flag = true;
1484 }
1485 if (flag) break;
Adam Cohen1b607ed2011-03-03 17:26:50 -08001486 expandability[AppWidgetResizeFrame.RIGHT]++;
1487 }
Adam Cohend4844c32011-02-18 19:25:06 -08001488
Adam Cohen1b607ed2011-03-03 17:26:50 -08001489 expandability[AppWidgetResizeFrame.BOTTOM] = 0;
Adam Cohend4844c32011-02-18 19:25:06 -08001490 for (int y = lp.cellY + lp.cellVSpan; y < mCountY; y++) {
1491 flag = false;
1492 for (int x = lp.cellX; x < lp.cellX + lp.cellHSpan; x++) {
1493 if (mOccupied[x][y]) flag = true;
1494 }
1495 if (flag) break;
Adam Cohen1b607ed2011-03-03 17:26:50 -08001496 expandability[AppWidgetResizeFrame.BOTTOM]++;
1497 }
Adam Cohend4844c32011-02-18 19:25:06 -08001498 }
1499
Michael Jurka0280c3b2010-09-17 15:00:07 -07001500 public void onMove(View view, int newCellX, int newCellY) {
1501 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1502 markCellsAsUnoccupiedForView(view);
1503 markCellsForView(newCellX, newCellY, lp.cellHSpan, lp.cellVSpan, true);
1504 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001505
Adam Cohend4844c32011-02-18 19:25:06 -08001506 public void markCellsAsOccupiedForView(View view) {
Michael Jurka8c920dd2011-01-20 14:16:56 -08001507 if (view == null || view.getParent() != mChildren) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001508 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1509 markCellsForView(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan, true);
1510 }
1511
Adam Cohend4844c32011-02-18 19:25:06 -08001512 public void markCellsAsUnoccupiedForView(View view) {
Michael Jurka8c920dd2011-01-20 14:16:56 -08001513 if (view == null || view.getParent() != mChildren) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07001514 LayoutParams lp = (LayoutParams) view.getLayoutParams();
1515 markCellsForView(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan, false);
1516 }
1517
1518 private void markCellsForView(int cellX, int cellY, int spanX, int spanY, boolean value) {
1519 for (int x = cellX; x < cellX + spanX && x < mCountX; x++) {
1520 for (int y = cellY; y < cellY + spanY && y < mCountY; y++) {
1521 mOccupied[x][y] = value;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001522 }
1523 }
1524 }
1525
Michael Jurka66d72172011-04-12 16:29:25 -07001526 public boolean isOccupied(int x, int y) {
1527 if (x < mCountX && y < mCountY) {
1528 return mOccupied[x][y];
1529 } else {
1530 throw new RuntimeException("Position exceeds the bound of this CellLayout");
1531 }
1532 }
1533
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001534 @Override
1535 public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
1536 return new CellLayout.LayoutParams(getContext(), attrs);
1537 }
1538
1539 @Override
1540 protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
1541 return p instanceof CellLayout.LayoutParams;
1542 }
1543
1544 @Override
1545 protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
1546 return new CellLayout.LayoutParams(p);
1547 }
1548
Winson Chungaafa03c2010-06-11 17:34:16 -07001549 public static class CellLayoutAnimationController extends LayoutAnimationController {
1550 public CellLayoutAnimationController(Animation animation, float delay) {
1551 super(animation, delay);
1552 }
1553
1554 @Override
1555 protected long getDelayForView(View view) {
1556 return (int) (Math.random() * 150);
1557 }
1558 }
1559
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001560 public static class LayoutParams extends ViewGroup.MarginLayoutParams {
1561 /**
1562 * Horizontal location of the item in the grid.
1563 */
1564 @ViewDebug.ExportedProperty
1565 public int cellX;
1566
1567 /**
1568 * Vertical location of the item in the grid.
1569 */
1570 @ViewDebug.ExportedProperty
1571 public int cellY;
1572
1573 /**
1574 * Number of cells spanned horizontally by the item.
1575 */
1576 @ViewDebug.ExportedProperty
1577 public int cellHSpan;
1578
1579 /**
1580 * Number of cells spanned vertically by the item.
1581 */
1582 @ViewDebug.ExportedProperty
1583 public int cellVSpan;
Winson Chungaafa03c2010-06-11 17:34:16 -07001584
Adam Cohen1b607ed2011-03-03 17:26:50 -08001585 /**
1586 * Indicates whether the item will set its x, y, width and height parameters freely,
1587 * or whether these will be computed based on cellX, cellY, cellHSpan and cellVSpan.
1588 */
Adam Cohend4844c32011-02-18 19:25:06 -08001589 public boolean isLockedToGrid = true;
1590
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001591 /**
1592 * Is this item currently being dragged
1593 */
1594 public boolean isDragging;
1595
1596 // X coordinate of the view in the layout.
1597 @ViewDebug.ExportedProperty
1598 int x;
1599 // Y coordinate of the view in the layout.
1600 @ViewDebug.ExportedProperty
1601 int y;
1602
Patrick Dubroyce34a972010-10-19 10:34:32 -07001603 /**
1604 * The old X coordinate of this item, relative to its current parent.
1605 * Used to animate the item into its new position.
1606 */
1607 int oldX;
1608
1609 /**
1610 * The old Y coordinate of this item, relative to its current parent.
1611 * Used to animate the item into its new position.
1612 */
1613 int oldY;
1614
Romain Guy84f296c2009-11-04 15:00:44 -08001615 boolean dropped;
Romain Guyfcb9e712009-10-02 16:06:52 -07001616
Michael Jurkad3ef3062010-11-23 16:23:58 -08001617 boolean animateDrop;
1618
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001619 public LayoutParams(Context c, AttributeSet attrs) {
1620 super(c, attrs);
1621 cellHSpan = 1;
1622 cellVSpan = 1;
1623 }
1624
1625 public LayoutParams(ViewGroup.LayoutParams source) {
1626 super(source);
1627 cellHSpan = 1;
1628 cellVSpan = 1;
1629 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001630
1631 public LayoutParams(LayoutParams source) {
1632 super(source);
1633 this.cellX = source.cellX;
1634 this.cellY = source.cellY;
1635 this.cellHSpan = source.cellHSpan;
1636 this.cellVSpan = source.cellVSpan;
1637 }
1638
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001639 public LayoutParams(int cellX, int cellY, int cellHSpan, int cellVSpan) {
Romain Guy8f19cdd2010-01-08 15:07:00 -08001640 super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001641 this.cellX = cellX;
1642 this.cellY = cellY;
1643 this.cellHSpan = cellHSpan;
1644 this.cellVSpan = cellVSpan;
1645 }
1646
1647 public void setup(int cellWidth, int cellHeight, int widthGap, int heightGap,
1648 int hStartPadding, int vStartPadding) {
Adam Cohend4844c32011-02-18 19:25:06 -08001649 if (isLockedToGrid) {
1650 final int myCellHSpan = cellHSpan;
1651 final int myCellVSpan = cellVSpan;
1652 final int myCellX = cellX;
1653 final int myCellY = cellY;
Adam Cohen1b607ed2011-03-03 17:26:50 -08001654
Adam Cohend4844c32011-02-18 19:25:06 -08001655 width = myCellHSpan * cellWidth + ((myCellHSpan - 1) * widthGap) -
1656 leftMargin - rightMargin;
1657 height = myCellVSpan * cellHeight + ((myCellVSpan - 1) * heightGap) -
1658 topMargin - bottomMargin;
Adam Cohend4844c32011-02-18 19:25:06 -08001659 x = hStartPadding + myCellX * (cellWidth + widthGap) + leftMargin;
1660 y = vStartPadding + myCellY * (cellHeight + heightGap) + topMargin;
1661 }
1662 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001663
Winson Chungaafa03c2010-06-11 17:34:16 -07001664 public String toString() {
1665 return "(" + this.cellX + ", " + this.cellY + ")";
1666 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001667 }
1668
Michael Jurka0280c3b2010-09-17 15:00:07 -07001669 // This class stores info for two purposes:
1670 // 1. When dragging items (mDragInfo in Workspace), we store the View, its cellX & cellY,
1671 // its spanX, spanY, and the screen it is on
1672 // 2. When long clicking on an empty cell in a CellLayout, we save information about the
1673 // cellX and cellY coordinates and which page was clicked. We then set this as a tag on
1674 // the CellLayout that was long clicked
Michael Jurkae5fb0f22011-04-11 13:27:46 -07001675 static final class CellInfo {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001676 View cell;
Michael Jurkaa63c4522010-08-19 13:52:27 -07001677 int cellX = -1;
1678 int cellY = -1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001679 int spanX;
1680 int spanY;
1681 int screen;
1682 boolean valid;
1683
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001684 @Override
1685 public String toString() {
Winson Chungaafa03c2010-06-11 17:34:16 -07001686 return "Cell[view=" + (cell == null ? "null" : cell.getClass())
1687 + ", x=" + cellX + ", y=" + cellY + "]";
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001688 }
1689 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001690}