blob: 71a1df30fcd65d79b4262e2e84245544a64d8124 [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
Daniel Sandler325dc232013-06-05 22:57:57 -040017package com.android.launcher3;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080018
Joe Onorato4be866d2010-10-10 11:26:02 -070019import android.animation.Animator;
Michael Jurka629758f2012-06-14 16:18:21 -070020import android.animation.AnimatorListenerAdapter;
Brandon Keely50e6e562012-05-08 16:28:49 -070021import android.animation.AnimatorSet;
Chet Haase00397b12010-10-07 11:13:10 -070022import android.animation.TimeInterpolator;
Patrick Dubroyde7658b2010-09-27 11:15:43 -070023import android.animation.ValueAnimator;
24import android.animation.ValueAnimator.AnimatorUpdateListener;
Adam Cohenc9735cf2015-01-23 16:11:55 -080025import android.annotation.TargetApi;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080026import android.content.Context;
Joe Onorato79e56262009-09-21 15:23:04 -040027import android.content.res.Resources;
Joe Onorato4be866d2010-10-10 11:26:02 -070028import android.graphics.Bitmap;
Winson Chungaafa03c2010-06-11 17:34:16 -070029import android.graphics.Canvas;
Andrew Flynn0dca1ec2012-02-29 13:33:22 -080030import android.graphics.Color;
Joe Onorato4be866d2010-10-10 11:26:02 -070031import android.graphics.Paint;
Patrick Dubroyde7658b2010-09-27 11:15:43 -070032import android.graphics.Point;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080033import android.graphics.Rect;
Adam Cohen482ed822012-03-02 14:15:13 -080034import android.graphics.drawable.ColorDrawable;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070035import android.graphics.drawable.Drawable;
Sunny Goyal2805e632015-05-20 15:35:32 -070036import android.graphics.drawable.TransitionDrawable;
Adam Cohenc9735cf2015-01-23 16:11:55 -080037import android.os.Build;
Adam Cohen1462de32012-07-24 22:34:36 -070038import android.os.Parcelable;
Tony Wickham489fc562015-09-02 14:45:39 -070039import android.os.PowerManager;
Adam Cohenc9735cf2015-01-23 16:11:55 -080040import android.support.v4.view.ViewCompat;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080041import android.util.AttributeSet;
Joe Onorato4be866d2010-10-10 11:26:02 -070042import android.util.Log;
Adam Cohen1462de32012-07-24 22:34:36 -070043import android.util.SparseArray;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080044import android.view.MotionEvent;
45import android.view.View;
46import android.view.ViewDebug;
47import android.view.ViewGroup;
Adam Cohenc9735cf2015-01-23 16:11:55 -080048import android.view.accessibility.AccessibilityEvent;
Winson Chung150fbab2010-09-29 17:14:26 -070049import android.view.animation.DecelerateInterpolator;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080050
Sunny Goyal4b6eb262015-05-14 19:24:40 -070051import com.android.launcher3.BubbleTextView.BubbleTextShadowHandler;
Daniel Sandler325dc232013-06-05 22:57:57 -040052import com.android.launcher3.FolderIcon.FolderRingAnimator;
Sunny Goyale9b651e2015-04-24 11:44:51 -070053import com.android.launcher3.accessibility.DragAndDropAccessibilityDelegate;
54import com.android.launcher3.accessibility.FolderAccessibilityHelper;
55import com.android.launcher3.accessibility.WorkspaceAccessibilityHelper;
Sunny Goyald1a0e8b2015-08-27 17:45:46 -070056import com.android.launcher3.util.ParcelableSparseArray;
Adam Cohen091440a2015-03-18 14:16:05 -070057import com.android.launcher3.util.Thunk;
Patrick Dubroy8e58e912010-10-14 13:21:48 -070058
Adam Cohen69ce2e52011-07-03 19:25:21 -070059import java.util.ArrayList;
Adam Cohenc0dcf592011-06-01 15:30:43 -070060import java.util.Arrays;
Adam Cohenf3900c22012-11-16 18:28:11 -080061import java.util.Collections;
62import java.util.Comparator;
Adam Cohenbfbfd262011-06-13 16:55:12 -070063import java.util.HashMap;
Adam Cohend41fbf52012-02-16 23:53:59 -080064import java.util.Stack;
Adam Cohenc0dcf592011-06-01 15:30:43 -070065
Sunny Goyal4b6eb262015-05-14 19:24:40 -070066public class CellLayout extends ViewGroup implements BubbleTextShadowHandler {
Sunny Goyale9b651e2015-04-24 11:44:51 -070067 public static final int WORKSPACE_ACCESSIBILITY_DRAG = 2;
68 public static final int FOLDER_ACCESSIBILITY_DRAG = 1;
69
Tony Wickhama0628cc2015-10-14 15:23:04 -070070 private static final String TAG = "CellLayout";
71 private static final boolean LOGD = false;
Winson Chungaafa03c2010-06-11 17:34:16 -070072
Adam Cohen2acce882012-03-28 19:03:19 -070073 private Launcher mLauncher;
Adam Cohen091440a2015-03-18 14:16:05 -070074 @Thunk int mCellWidth;
75 @Thunk int mCellHeight;
Winson Chung11a1a532013-09-13 11:14:45 -070076 private int mFixedCellWidth;
77 private int mFixedCellHeight;
Winson Chungaafa03c2010-06-11 17:34:16 -070078
Adam Cohen091440a2015-03-18 14:16:05 -070079 @Thunk int mCountX;
80 @Thunk int mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080081
Adam Cohen234c4cd2011-07-17 21:03:04 -070082 private int mOriginalWidthGap;
83 private int mOriginalHeightGap;
Adam Cohen091440a2015-03-18 14:16:05 -070084 @Thunk int mWidthGap;
85 @Thunk int mHeightGap;
Winson Chung4b825dcd2011-06-19 12:41:22 -070086 private int mMaxGap;
Adam Cohen917e3882013-10-31 15:03:35 -070087 private boolean mDropPending = false;
Adam Cohenc50438c2014-08-19 17:43:05 -070088 private boolean mIsDragTarget = true;
Sunny Goyald1a0e8b2015-08-27 17:45:46 -070089 private boolean mJailContent = true;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080090
Patrick Dubroyde7658b2010-09-27 11:15:43 -070091 // These are temporary variables to prevent having to allocate a new object just to
92 // return an (x, y) value from helper functions. Do NOT use them to maintain other state.
Adam Cohen091440a2015-03-18 14:16:05 -070093 @Thunk final int[] mTmpPoint = new int[2];
Sunny Goyal2805e632015-05-20 15:35:32 -070094 @Thunk final int[] mTempLocation = new int[2];
Patrick Dubroy6569f2c2010-07-12 14:25:18 -070095
The Android Open Source Project31dd5032009-03-03 19:32:27 -080096 boolean[][] mOccupied;
Adam Cohen482ed822012-03-02 14:15:13 -080097 boolean[][] mTmpOccupied;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080098
Michael Jurkadee05892010-07-27 10:01:56 -070099 private OnTouchListener mInterceptTouchListener;
Mady Melloref044dd2015-06-02 15:35:07 -0700100 private StylusEventHelper mStylusEventHelper;
Michael Jurkadee05892010-07-27 10:01:56 -0700101
Adam Cohen69ce2e52011-07-03 19:25:21 -0700102 private ArrayList<FolderRingAnimator> mFolderOuterRings = new ArrayList<FolderRingAnimator>();
Adam Cohenc51934b2011-07-26 21:07:43 -0700103 private int[] mFolderLeaveBehindCell = {-1, -1};
Adam Cohen69ce2e52011-07-03 19:25:21 -0700104
Michael Jurka5f1c5092010-09-03 14:15:02 -0700105 private float mBackgroundAlpha;
Adam Cohenf34bab52010-09-30 14:11:56 -0700106
Sunny Goyal2805e632015-05-20 15:35:32 -0700107 private static final int BACKGROUND_ACTIVATE_DURATION = 120;
108 private final TransitionDrawable mBackground;
109
Adam Cohenf0f4eda2013-06-06 21:27:03 -0700110 // These values allow a fixed measurement to be set on the CellLayout.
111 private int mFixedWidth = -1;
112 private int mFixedHeight = -1;
113
Michael Jurka33945b22010-12-21 18:19:38 -0800114 // If we're actively dragging something over this screen, mIsDragOverlapping is true
115 private boolean mIsDragOverlapping = false;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700116
Winson Chung150fbab2010-09-29 17:14:26 -0700117 // These arrays are used to implement the drag visualization on x-large screens.
Joe Onorato4be866d2010-10-10 11:26:02 -0700118 // They are used as circular arrays, indexed by mDragOutlineCurrent.
Adam Cohen091440a2015-03-18 14:16:05 -0700119 @Thunk Rect[] mDragOutlines = new Rect[4];
120 @Thunk float[] mDragOutlineAlphas = new float[mDragOutlines.length];
Joe Onorato4be866d2010-10-10 11:26:02 -0700121 private InterruptibleInOutAnimator[] mDragOutlineAnims =
122 new InterruptibleInOutAnimator[mDragOutlines.length];
Winson Chung150fbab2010-09-29 17:14:26 -0700123
124 // Used as an index into the above 3 arrays; indicates which is the most current value.
Joe Onorato4be866d2010-10-10 11:26:02 -0700125 private int mDragOutlineCurrent = 0;
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700126 private final Paint mDragOutlinePaint = new Paint();
Winson Chung150fbab2010-09-29 17:14:26 -0700127
Sunny Goyal4fe5a372015-05-14 19:55:10 -0700128 private final ClickShadowView mTouchFeedbackView;
Patrick Dubroy96864c32011-03-10 17:17:23 -0800129
Sunny Goyal316490e2015-06-02 09:38:28 -0700130 @Thunk HashMap<CellLayout.LayoutParams, Animator> mReorderAnimators = new HashMap<>();
131 @Thunk HashMap<View, ReorderPreviewAnimation> mShakeAnimators = new HashMap<>();
Adam Cohen19f37922012-03-21 11:59:11 -0700132
133 private boolean mItemPlacementDirty = false;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700134
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700135 // When a drag operation is in progress, holds the nearest cell to the touch point
136 private final int[] mDragCell = new int[2];
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800137
Joe Onorato4be866d2010-10-10 11:26:02 -0700138 private boolean mDragging = false;
139
Patrick Dubroyce34a972010-10-19 10:34:32 -0700140 private TimeInterpolator mEaseOutInterpolator;
Michael Jurkaa52570f2012-03-20 03:18:20 -0700141 private ShortcutAndWidgetContainer mShortcutsAndWidgets;
Patrick Dubroyce34a972010-10-19 10:34:32 -0700142
Andrew Flynn0dca1ec2012-02-29 13:33:22 -0800143 private boolean mIsHotseat = false;
Adam Cohen307fe232012-08-16 17:55:58 -0700144 private float mHotseatScale = 1f;
Andrew Flynn0dca1ec2012-02-29 13:33:22 -0800145
Adam Cohenfa3c58f2013-12-06 16:10:55 -0800146 public static final int MODE_SHOW_REORDER_HINT = 0;
147 public static final int MODE_DRAG_OVER = 1;
148 public static final int MODE_ON_DROP = 2;
149 public static final int MODE_ON_DROP_EXTERNAL = 3;
150 public static final int MODE_ACCEPT_DROP = 4;
Adam Cohen19f37922012-03-21 11:59:11 -0700151 private static final boolean DESTRUCTIVE_REORDER = false;
Adam Cohen482ed822012-03-02 14:15:13 -0800152 private static final boolean DEBUG_VISUALIZE_OCCUPIED = false;
153
Adam Cohena897f392012-04-27 18:12:05 -0700154 static final int LANDSCAPE = 0;
155 static final int PORTRAIT = 1;
156
Adam Cohenfa3c58f2013-12-06 16:10:55 -0800157 private static final float REORDER_PREVIEW_MAGNITUDE = 0.12f;
Adam Cohen19f37922012-03-21 11:59:11 -0700158 private static final int REORDER_ANIMATION_DURATION = 150;
Adam Cohen091440a2015-03-18 14:16:05 -0700159 @Thunk float mReorderPreviewAnimationMagnitude;
Adam Cohen19f37922012-03-21 11:59:11 -0700160
Adam Cohen482ed822012-03-02 14:15:13 -0800161 private ArrayList<View> mIntersectingViews = new ArrayList<View>();
162 private Rect mOccupiedRect = new Rect();
163 private int[] mDirectionVector = new int[2];
Adam Cohen19f37922012-03-21 11:59:11 -0700164 int[] mPreviousReorderDirection = new int[2];
Adam Cohenb209e632012-03-27 17:09:36 -0700165 private static final int INVALID_DIRECTION = -100;
Adam Cohen482ed822012-03-02 14:15:13 -0800166
Sunny Goyal2805e632015-05-20 15:35:32 -0700167 private final Rect mTempRect = new Rect();
Winson Chung3a6e7f32013-10-09 15:50:52 -0700168
Michael Jurkaca993832012-06-29 15:17:04 -0700169 private final static Paint sPaint = new Paint();
Romain Guy8a0bff52012-05-06 13:14:33 -0700170
Adam Cohenc9735cf2015-01-23 16:11:55 -0800171 // Related to accessible drag and drop
Sunny Goyale9b651e2015-04-24 11:44:51 -0700172 private DragAndDropAccessibilityDelegate mTouchHelper;
Adam Cohenc9735cf2015-01-23 16:11:55 -0800173 private boolean mUseTouchHelper = false;
Adam Cohenc9735cf2015-01-23 16:11:55 -0800174
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800175 public CellLayout(Context context) {
176 this(context, null);
177 }
178
179 public CellLayout(Context context, AttributeSet attrs) {
180 this(context, attrs, 0);
181 }
182
183 public CellLayout(Context context, AttributeSet attrs, int defStyle) {
184 super(context, attrs, defStyle);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700185
186 // A ViewGroup usually does not draw, but CellLayout needs to draw a rectangle to show
187 // the user where a dragged item will land when dropped.
188 setWillNotDraw(false);
Romain Guyce3cbd12013-02-25 15:00:36 -0800189 setClipToPadding(false);
Adam Cohen2acce882012-03-28 19:03:19 -0700190 mLauncher = (Launcher) context;
Michael Jurkaa63c4522010-08-19 13:52:27 -0700191
Adam Cohen2e6da152015-05-06 11:42:25 -0700192 DeviceProfile grid = mLauncher.getDeviceProfile();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800193
Winson Chung11a1a532013-09-13 11:14:45 -0700194 mCellWidth = mCellHeight = -1;
Nilesh Agrawal5f7099a2014-01-02 15:54:57 -0800195 mFixedCellWidth = mFixedCellHeight = -1;
Winson Chung5f8afe62013-08-12 16:19:28 -0700196 mWidthGap = mOriginalWidthGap = 0;
197 mHeightGap = mOriginalHeightGap = 0;
198 mMaxGap = Integer.MAX_VALUE;
Adam Cohen2e6da152015-05-06 11:42:25 -0700199 mCountX = (int) grid.inv.numColumns;
200 mCountY = (int) grid.inv.numRows;
Michael Jurka0280c3b2010-09-17 15:00:07 -0700201 mOccupied = new boolean[mCountX][mCountY];
Adam Cohen482ed822012-03-02 14:15:13 -0800202 mTmpOccupied = new boolean[mCountX][mCountY];
Adam Cohen5b53f292012-03-29 14:30:35 -0700203 mPreviousReorderDirection[0] = INVALID_DIRECTION;
204 mPreviousReorderDirection[1] = INVALID_DIRECTION;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800205
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800206 setAlwaysDrawnWithCacheEnabled(false);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700207 final Resources res = getResources();
Winson Chung6e1c0d32013-10-25 15:24:24 -0700208 mHotseatScale = (float) grid.hotseatIconSizePx / grid.iconSizePx;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700209
Sunny Goyal2805e632015-05-20 15:35:32 -0700210 mBackground = (TransitionDrawable) res.getDrawable(R.drawable.bg_screenpanel);
211 mBackground.setCallback(this);
Winson Chunge8f1d042015-07-31 12:39:57 -0700212 mBackground.setAlpha((int) (mBackgroundAlpha * 255));
Michael Jurka33945b22010-12-21 18:19:38 -0800213
Adam Cohenfa3c58f2013-12-06 16:10:55 -0800214 mReorderPreviewAnimationMagnitude = (REORDER_PREVIEW_MAGNITUDE *
Winson Chung5f8afe62013-08-12 16:19:28 -0700215 grid.iconSizePx);
Adam Cohen19f37922012-03-21 11:59:11 -0700216
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700217 // Initialize the data structures used for the drag visualization.
Patrick Dubroyce34a972010-10-19 10:34:32 -0700218 mEaseOutInterpolator = new DecelerateInterpolator(2.5f); // Quint ease out
Winson Chungb8c69f32011-10-19 21:36:08 -0700219 mDragCell[0] = mDragCell[1] = -1;
Joe Onorato4be866d2010-10-10 11:26:02 -0700220 for (int i = 0; i < mDragOutlines.length; i++) {
Adam Cohend41fbf52012-02-16 23:53:59 -0800221 mDragOutlines[i] = new Rect(-1, -1, -1, -1);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700222 }
223
224 // When dragging things around the home screens, we show a green outline of
225 // where the item will land. The outlines gradually fade out, leaving a trail
226 // behind the drag path.
227 // Set up all the animations that are used to implement this fading.
228 final int duration = res.getInteger(R.integer.config_dragOutlineFadeTime);
Chet Haase472b2812010-10-14 07:02:04 -0700229 final float fromAlphaValue = 0;
230 final float toAlphaValue = (float)res.getInteger(R.integer.config_dragOutlineMaxAlpha);
Joe Onorato4be866d2010-10-10 11:26:02 -0700231
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700232 Arrays.fill(mDragOutlineAlphas, fromAlphaValue);
Joe Onorato4be866d2010-10-10 11:26:02 -0700233
234 for (int i = 0; i < mDragOutlineAnims.length; i++) {
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700235 final InterruptibleInOutAnimator anim =
Michael Jurkaf1ad6082013-03-13 12:55:46 +0100236 new InterruptibleInOutAnimator(this, duration, fromAlphaValue, toAlphaValue);
Patrick Dubroyce34a972010-10-19 10:34:32 -0700237 anim.getAnimator().setInterpolator(mEaseOutInterpolator);
Patrick Dubroy046e7eb2010-10-06 12:14:43 -0700238 final int thisIndex = i;
Chet Haase472b2812010-10-14 07:02:04 -0700239 anim.getAnimator().addUpdateListener(new AnimatorUpdateListener() {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700240 public void onAnimationUpdate(ValueAnimator animation) {
Joe Onorato4be866d2010-10-10 11:26:02 -0700241 final Bitmap outline = (Bitmap)anim.getTag();
242
243 // If an animation is started and then stopped very quickly, we can still
244 // get spurious updates we've cleared the tag. Guard against this.
245 if (outline == null) {
Tony Wickhama0628cc2015-10-14 15:23:04 -0700246 if (LOGD) {
Patrick Dubroyfe6bd872010-10-13 17:32:10 -0700247 Object val = animation.getAnimatedValue();
248 Log.d(TAG, "anim " + thisIndex + " update: " + val +
249 ", isStopped " + anim.isStopped());
250 }
Joe Onorato4be866d2010-10-10 11:26:02 -0700251 // Try to prevent it from continuing to run
252 animation.cancel();
253 } else {
Chet Haase472b2812010-10-14 07:02:04 -0700254 mDragOutlineAlphas[thisIndex] = (Float) animation.getAnimatedValue();
Adam Cohend41fbf52012-02-16 23:53:59 -0800255 CellLayout.this.invalidate(mDragOutlines[thisIndex]);
Joe Onorato4be866d2010-10-10 11:26:02 -0700256 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700257 }
258 });
Joe Onorato4be866d2010-10-10 11:26:02 -0700259 // The animation holds a reference to the drag outline bitmap as long is it's
260 // running. This way the bitmap can be GCed when the animations are complete.
Chet Haase472b2812010-10-14 07:02:04 -0700261 anim.getAnimator().addListener(new AnimatorListenerAdapter() {
Michael Jurka3c4c20f2010-10-28 15:36:06 -0700262 @Override
Joe Onorato4be866d2010-10-10 11:26:02 -0700263 public void onAnimationEnd(Animator animation) {
Chet Haase472b2812010-10-14 07:02:04 -0700264 if ((Float) ((ValueAnimator) animation).getAnimatedValue() == 0f) {
Joe Onorato4be866d2010-10-10 11:26:02 -0700265 anim.setTag(null);
266 }
267 }
268 });
269 mDragOutlineAnims[i] = anim;
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700270 }
Patrick Dubroyce34a972010-10-19 10:34:32 -0700271
Michael Jurkaa52570f2012-03-20 03:18:20 -0700272 mShortcutsAndWidgets = new ShortcutAndWidgetContainer(context);
Adam Cohen2374abf2013-04-16 14:56:57 -0700273 mShortcutsAndWidgets.setCellDimensions(mCellWidth, mCellHeight, mWidthGap, mHeightGap,
Winson Chung5f8afe62013-08-12 16:19:28 -0700274 mCountX, mCountY);
Adam Cohen2374abf2013-04-16 14:56:57 -0700275
Mady Melloref044dd2015-06-02 15:35:07 -0700276 mStylusEventHelper = new StylusEventHelper(this);
277
Sunny Goyal4fe5a372015-05-14 19:55:10 -0700278 mTouchFeedbackView = new ClickShadowView(context);
279 addView(mTouchFeedbackView);
Michael Jurkaa52570f2012-03-20 03:18:20 -0700280 addView(mShortcutsAndWidgets);
Michael Jurka18014792010-10-14 09:01:34 -0700281 }
282
Adam Cohenc9735cf2015-01-23 16:11:55 -0800283 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
Sunny Goyale9b651e2015-04-24 11:44:51 -0700284 public void enableAccessibleDrag(boolean enable, int dragType) {
Adam Cohenc9735cf2015-01-23 16:11:55 -0800285 mUseTouchHelper = enable;
286 if (!enable) {
287 ViewCompat.setAccessibilityDelegate(this, null);
288 setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_NO);
289 getShortcutsAndWidgets().setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_NO);
290 setOnClickListener(mLauncher);
291 } else {
Sunny Goyale9b651e2015-04-24 11:44:51 -0700292 if (dragType == WORKSPACE_ACCESSIBILITY_DRAG &&
293 !(mTouchHelper instanceof WorkspaceAccessibilityHelper)) {
294 mTouchHelper = new WorkspaceAccessibilityHelper(this);
295 } else if (dragType == FOLDER_ACCESSIBILITY_DRAG &&
296 !(mTouchHelper instanceof FolderAccessibilityHelper)) {
297 mTouchHelper = new FolderAccessibilityHelper(this);
298 }
Adam Cohenc9735cf2015-01-23 16:11:55 -0800299 ViewCompat.setAccessibilityDelegate(this, mTouchHelper);
300 setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_YES);
301 getShortcutsAndWidgets().setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_YES);
302 setOnClickListener(mTouchHelper);
303 }
304
305 // Invalidate the accessibility hierarchy
306 if (getParent() != null) {
307 getParent().notifySubtreeAccessibilityStateChanged(
308 this, this, AccessibilityEvent.CONTENT_CHANGE_TYPE_SUBTREE);
309 }
310 }
311
312 @Override
313 public boolean dispatchHoverEvent(MotionEvent event) {
314 // Always attempt to dispatch hover events to accessibility first.
315 if (mUseTouchHelper && mTouchHelper.dispatchHoverEvent(event)) {
316 return true;
317 }
318 return super.dispatchHoverEvent(event);
319 }
320
321 @Override
Adam Cohenc9735cf2015-01-23 16:11:55 -0800322 public boolean onInterceptTouchEvent(MotionEvent ev) {
323 if (mUseTouchHelper ||
324 (mInterceptTouchListener != null && mInterceptTouchListener.onTouch(this, ev))) {
325 return true;
326 }
327 return false;
328 }
329
Mady Melloref044dd2015-06-02 15:35:07 -0700330 @Override
331 public boolean onTouchEvent(MotionEvent ev) {
332 boolean handled = super.onTouchEvent(ev);
333 // Stylus button press on a home screen should not switch between overview mode and
334 // the home screen mode, however, once in overview mode stylus button press should be
335 // enabled to allow rearranging the different home screens. So check what mode
336 // the workspace is in, and only perform stylus button presses while in overview mode.
337 if (mLauncher.mWorkspace.isInOverviewMode()
338 && mStylusEventHelper.checkAndPerformStylusEvent(ev)) {
339 return true;
340 }
341 return handled;
342 }
343
Chris Craik01f2d7f2013-10-01 14:41:56 -0700344 public void enableHardwareLayer(boolean hasLayer) {
345 mShortcutsAndWidgets.setLayerType(hasLayer ? LAYER_TYPE_HARDWARE : LAYER_TYPE_NONE, sPaint);
Michael Jurkad51f33a2012-06-28 15:35:26 -0700346 }
347
348 public void buildHardwareLayer() {
349 mShortcutsAndWidgets.buildLayer();
Adam Cohen2801caf2011-05-13 20:57:39 -0700350 }
351
Adam Cohen307fe232012-08-16 17:55:58 -0700352 public float getChildrenScale() {
353 return mIsHotseat ? mHotseatScale : 1.0f;
354 }
355
Winson Chung5f8afe62013-08-12 16:19:28 -0700356 public void setCellDimensions(int width, int height) {
Winson Chung11a1a532013-09-13 11:14:45 -0700357 mFixedCellWidth = mCellWidth = width;
358 mFixedCellHeight = mCellHeight = height;
Winson Chung5f8afe62013-08-12 16:19:28 -0700359 mShortcutsAndWidgets.setCellDimensions(mCellWidth, mCellHeight, mWidthGap, mHeightGap,
360 mCountX, mCountY);
361 }
362
Adam Cohen2801caf2011-05-13 20:57:39 -0700363 public void setGridSize(int x, int y) {
364 mCountX = x;
365 mCountY = y;
366 mOccupied = new boolean[mCountX][mCountY];
Adam Cohen482ed822012-03-02 14:15:13 -0800367 mTmpOccupied = new boolean[mCountX][mCountY];
Adam Cohen7fbec102012-03-27 12:42:19 -0700368 mTempRectStack.clear();
Adam Cohen2374abf2013-04-16 14:56:57 -0700369 mShortcutsAndWidgets.setCellDimensions(mCellWidth, mCellHeight, mWidthGap, mHeightGap,
Winson Chung5f8afe62013-08-12 16:19:28 -0700370 mCountX, mCountY);
Adam Cohen76fc0852011-06-17 13:26:23 -0700371 requestLayout();
Adam Cohen2801caf2011-05-13 20:57:39 -0700372 }
373
Adam Cohen2374abf2013-04-16 14:56:57 -0700374 // Set whether or not to invert the layout horizontally if the layout is in RTL mode.
375 public void setInvertIfRtl(boolean invert) {
376 mShortcutsAndWidgets.setInvertIfRtl(invert);
377 }
378
Adam Cohen917e3882013-10-31 15:03:35 -0700379 public void setDropPending(boolean pending) {
380 mDropPending = pending;
381 }
382
383 public boolean isDropPending() {
384 return mDropPending;
385 }
386
Sunny Goyal4b6eb262015-05-14 19:24:40 -0700387 @Override
388 public void setPressedIcon(BubbleTextView icon, Bitmap background) {
Sunny Goyal508da152014-08-14 10:53:27 -0700389 if (icon == null || background == null) {
390 mTouchFeedbackView.setBitmap(null);
391 mTouchFeedbackView.animate().cancel();
392 } else {
Sunny Goyal508da152014-08-14 10:53:27 -0700393 if (mTouchFeedbackView.setBitmap(background)) {
Sunny Goyal4fe5a372015-05-14 19:55:10 -0700394 mTouchFeedbackView.alignWithIconView(icon, mShortcutsAndWidgets);
395 mTouchFeedbackView.animateShadow();
Sunny Goyal508da152014-08-14 10:53:27 -0700396 }
Patrick Dubroy96864c32011-03-10 17:17:23 -0800397 }
398 }
399
Adam Cohenc50438c2014-08-19 17:43:05 -0700400 void disableDragTarget() {
401 mIsDragTarget = false;
402 }
403
404 boolean isDragTarget() {
405 return mIsDragTarget;
406 }
407
408 void setIsDragOverlapping(boolean isDragOverlapping) {
409 if (mIsDragOverlapping != isDragOverlapping) {
410 mIsDragOverlapping = isDragOverlapping;
Sunny Goyal2805e632015-05-20 15:35:32 -0700411 if (mIsDragOverlapping) {
412 mBackground.startTransition(BACKGROUND_ACTIVATE_DURATION);
413 } else {
Winson Chunge8f1d042015-07-31 12:39:57 -0700414 if (mBackgroundAlpha > 0f) {
415 mBackground.reverseTransition(BACKGROUND_ACTIVATE_DURATION);
416 } else {
417 mBackground.resetTransition();
418 }
Sunny Goyal2805e632015-05-20 15:35:32 -0700419 }
Adam Cohenc50438c2014-08-19 17:43:05 -0700420 invalidate();
421 }
422 }
423
Sunny Goyald1a0e8b2015-08-27 17:45:46 -0700424 public boolean getIsDragOverlapping() {
Michael Jurka33945b22010-12-21 18:19:38 -0800425 return mIsDragOverlapping;
426 }
427
Sunny Goyald1a0e8b2015-08-27 17:45:46 -0700428 public void disableJailContent() {
429 mJailContent = false;
430 }
431
432 @Override
433 protected void dispatchSaveInstanceState(SparseArray<Parcelable> container) {
434 if (mJailContent) {
435 ParcelableSparseArray jail = getJailedArray(container);
436 super.dispatchSaveInstanceState(jail);
437 container.put(R.id.cell_layout_jail_id, jail);
438 } else {
439 super.dispatchSaveInstanceState(container);
440 }
441 }
442
443 @Override
444 protected void dispatchRestoreInstanceState(SparseArray<Parcelable> container) {
445 super.dispatchRestoreInstanceState(mJailContent ? getJailedArray(container) : container);
446 }
447
448 private ParcelableSparseArray getJailedArray(SparseArray<Parcelable> container) {
449 final Parcelable parcelable = container.get(R.id.cell_layout_jail_id);
450 return parcelable instanceof ParcelableSparseArray ?
451 (ParcelableSparseArray) parcelable : new ParcelableSparseArray();
452 }
453
Jeff Sharkey83f111d2009-04-20 21:03:13 -0700454 @Override
Patrick Dubroy1262e362010-10-06 15:49:50 -0700455 protected void onDraw(Canvas canvas) {
Sunny Goyal05739772015-05-19 19:59:09 -0700456 if (!mIsDragTarget) {
457 return;
458 }
459
Michael Jurka3e7c7632010-10-02 16:01:03 -0700460 // When we're large, we are either drawn in a "hover" state (ie when dragging an item to
461 // a neighboring page) or with just a normal background (if backgroundAlpha > 0.0f)
462 // When we're small, we are either drawn normally or in the "accepts drops" state (during
463 // a drag). However, we also drag the mini hover background *over* one of those two
464 // backgrounds
Sunny Goyal05739772015-05-19 19:59:09 -0700465 if (mBackgroundAlpha > 0.0f) {
Sunny Goyal2805e632015-05-20 15:35:32 -0700466 mBackground.draw(canvas);
Michael Jurkaa63c4522010-08-19 13:52:27 -0700467 }
Romain Guya6abce82009-11-10 02:54:41 -0800468
Patrick Dubroy8e58e912010-10-14 13:21:48 -0700469 final Paint paint = mDragOutlinePaint;
Joe Onorato4be866d2010-10-10 11:26:02 -0700470 for (int i = 0; i < mDragOutlines.length; i++) {
Chet Haase472b2812010-10-14 07:02:04 -0700471 final float alpha = mDragOutlineAlphas[i];
Joe Onorato4be866d2010-10-10 11:26:02 -0700472 if (alpha > 0) {
Adam Cohend41fbf52012-02-16 23:53:59 -0800473 final Rect r = mDragOutlines[i];
Winson Chung3a6e7f32013-10-09 15:50:52 -0700474 mTempRect.set(r);
475 Utilities.scaleRectAboutCenter(mTempRect, getChildrenScale());
Joe Onorato4be866d2010-10-10 11:26:02 -0700476 final Bitmap b = (Bitmap) mDragOutlineAnims[i].getTag();
Chet Haase472b2812010-10-14 07:02:04 -0700477 paint.setAlpha((int)(alpha + .5f));
Winson Chung3a6e7f32013-10-09 15:50:52 -0700478 canvas.drawBitmap(b, null, mTempRect, paint);
Winson Chung150fbab2010-09-29 17:14:26 -0700479 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700480 }
Patrick Dubroy96864c32011-03-10 17:17:23 -0800481
Adam Cohen482ed822012-03-02 14:15:13 -0800482 if (DEBUG_VISUALIZE_OCCUPIED) {
483 int[] pt = new int[2];
484 ColorDrawable cd = new ColorDrawable(Color.RED);
Adam Cohene7587d22012-05-24 18:50:02 -0700485 cd.setBounds(0, 0, mCellWidth, mCellHeight);
Adam Cohen482ed822012-03-02 14:15:13 -0800486 for (int i = 0; i < mCountX; i++) {
487 for (int j = 0; j < mCountY; j++) {
488 if (mOccupied[i][j]) {
489 cellToPoint(i, j, pt);
490 canvas.save();
491 canvas.translate(pt[0], pt[1]);
492 cd.draw(canvas);
493 canvas.restore();
494 }
495 }
496 }
497 }
498
Andrew Flynn850d2e72012-04-26 16:51:20 -0700499 int previewOffset = FolderRingAnimator.sPreviewSize;
500
Adam Cohen69ce2e52011-07-03 19:25:21 -0700501 // The folder outer / inner ring image(s)
Adam Cohen2e6da152015-05-06 11:42:25 -0700502 DeviceProfile grid = mLauncher.getDeviceProfile();
Adam Cohen69ce2e52011-07-03 19:25:21 -0700503 for (int i = 0; i < mFolderOuterRings.size(); i++) {
504 FolderRingAnimator fra = mFolderOuterRings.get(i);
505
Adam Cohen5108bc02013-09-20 17:04:51 -0700506 Drawable d;
507 int width, height;
Adam Cohen69ce2e52011-07-03 19:25:21 -0700508 cellToPoint(fra.mCellX, fra.mCellY, mTempLocation);
Winson Chung5f8afe62013-08-12 16:19:28 -0700509 View child = getChildAt(fra.mCellX, fra.mCellY);
Adam Cohen558f1c22013-10-09 15:15:24 -0700510
Winson Chung89f97052013-09-20 11:32:26 -0700511 if (child != null) {
Adam Cohen558f1c22013-10-09 15:15:24 -0700512 int centerX = mTempLocation[0] + mCellWidth / 2;
513 int centerY = mTempLocation[1] + previewOffset / 2 +
514 child.getPaddingTop() + grid.folderBackgroundOffset;
515
Adam Cohen5108bc02013-09-20 17:04:51 -0700516 // Draw outer ring, if it exists
517 if (FolderIcon.HAS_OUTER_RING) {
518 d = FolderRingAnimator.sSharedOuterRingDrawable;
519 width = (int) (fra.getOuterRingSize() * getChildrenScale());
520 height = width;
521 canvas.save();
522 canvas.translate(centerX - width / 2, centerY - height / 2);
523 d.setBounds(0, 0, width, height);
524 d.draw(canvas);
525 canvas.restore();
526 }
Adam Cohen69ce2e52011-07-03 19:25:21 -0700527
Winson Chung89f97052013-09-20 11:32:26 -0700528 // Draw inner ring
529 d = FolderRingAnimator.sSharedInnerRingDrawable;
530 width = (int) (fra.getInnerRingSize() * getChildrenScale());
531 height = width;
Winson Chung89f97052013-09-20 11:32:26 -0700532 canvas.save();
533 canvas.translate(centerX - width / 2, centerY - width / 2);
534 d.setBounds(0, 0, width, height);
535 d.draw(canvas);
536 canvas.restore();
537 }
Adam Cohen69ce2e52011-07-03 19:25:21 -0700538 }
Adam Cohenc51934b2011-07-26 21:07:43 -0700539
540 if (mFolderLeaveBehindCell[0] >= 0 && mFolderLeaveBehindCell[1] >= 0) {
541 Drawable d = FolderIcon.sSharedFolderLeaveBehind;
542 int width = d.getIntrinsicWidth();
543 int height = d.getIntrinsicHeight();
544
545 cellToPoint(mFolderLeaveBehindCell[0], mFolderLeaveBehindCell[1], mTempLocation);
Winson Chung5f8afe62013-08-12 16:19:28 -0700546 View child = getChildAt(mFolderLeaveBehindCell[0], mFolderLeaveBehindCell[1]);
Winson Chung89f97052013-09-20 11:32:26 -0700547 if (child != null) {
548 int centerX = mTempLocation[0] + mCellWidth / 2;
549 int centerY = mTempLocation[1] + previewOffset / 2 +
550 child.getPaddingTop() + grid.folderBackgroundOffset;
Adam Cohenc51934b2011-07-26 21:07:43 -0700551
Winson Chung89f97052013-09-20 11:32:26 -0700552 canvas.save();
553 canvas.translate(centerX - width / 2, centerY - width / 2);
554 d.setBounds(0, 0, width, height);
555 d.draw(canvas);
556 canvas.restore();
557 }
Adam Cohenc51934b2011-07-26 21:07:43 -0700558 }
Adam Cohen69ce2e52011-07-03 19:25:21 -0700559 }
560
561 public void showFolderAccept(FolderRingAnimator fra) {
562 mFolderOuterRings.add(fra);
563 }
564
565 public void hideFolderAccept(FolderRingAnimator fra) {
566 if (mFolderOuterRings.contains(fra)) {
567 mFolderOuterRings.remove(fra);
568 }
569 invalidate();
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700570 }
571
Adam Cohenc51934b2011-07-26 21:07:43 -0700572 public void setFolderLeaveBehindCell(int x, int y) {
573 mFolderLeaveBehindCell[0] = x;
574 mFolderLeaveBehindCell[1] = y;
575 invalidate();
576 }
577
578 public void clearFolderLeaveBehind() {
579 mFolderLeaveBehindCell[0] = -1;
580 mFolderLeaveBehindCell[1] = -1;
581 invalidate();
582 }
583
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700584 @Override
Michael Jurkae6235dd2011-10-04 15:02:05 -0700585 public boolean shouldDelayChildPressedState() {
586 return false;
587 }
588
Adam Cohen1462de32012-07-24 22:34:36 -0700589 public void restoreInstanceState(SparseArray<Parcelable> states) {
Sunny Goyal33a152f2014-07-22 12:13:14 -0700590 try {
591 dispatchRestoreInstanceState(states);
592 } catch (IllegalArgumentException ex) {
593 if (LauncherAppState.isDogfoodBuild()) {
594 throw ex;
595 }
596 // Mismatched viewId / viewType preventing restore. Skip restore on production builds.
597 Log.e(TAG, "Ignoring an error while restoring a view instance state", ex);
598 }
Adam Cohen1462de32012-07-24 22:34:36 -0700599 }
600
Michael Jurkae6235dd2011-10-04 15:02:05 -0700601 @Override
Jeff Sharkey83f111d2009-04-20 21:03:13 -0700602 public void cancelLongPress() {
603 super.cancelLongPress();
604
605 // Cancel long press for all children
606 final int count = getChildCount();
607 for (int i = 0; i < count; i++) {
608 final View child = getChildAt(i);
609 child.cancelLongPress();
610 }
611 }
612
Michael Jurkadee05892010-07-27 10:01:56 -0700613 public void setOnInterceptTouchListener(View.OnTouchListener listener) {
614 mInterceptTouchListener = listener;
615 }
616
Hyunyoung Songee3e6a72015-02-20 14:25:27 -0800617 public int getCountX() {
Adam Cohend22015c2010-07-26 22:02:18 -0700618 return mCountX;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800619 }
620
Hyunyoung Songee3e6a72015-02-20 14:25:27 -0800621 public int getCountY() {
Adam Cohend22015c2010-07-26 22:02:18 -0700622 return mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800623 }
624
Andrew Flynn0dca1ec2012-02-29 13:33:22 -0800625 public void setIsHotseat(boolean isHotseat) {
626 mIsHotseat = isHotseat;
Winson Chung5f8afe62013-08-12 16:19:28 -0700627 mShortcutsAndWidgets.setIsHotseat(isHotseat);
Andrew Flynn0dca1ec2012-02-29 13:33:22 -0800628 }
629
Sunny Goyale9b651e2015-04-24 11:44:51 -0700630 public boolean isHotseat() {
631 return mIsHotseat;
632 }
633
Andrew Flynn0dca1ec2012-02-29 13:33:22 -0800634 public boolean addViewToCellLayout(View child, int index, int childId, LayoutParams params,
Sunny Goyalf7a29e82015-04-24 15:20:43 -0700635 boolean markCells) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700636 final LayoutParams lp = params;
637
Andrew Flynnde38e422012-05-08 11:22:15 -0700638 // Hotseat icons - remove text
Andrew Flynn0dca1ec2012-02-29 13:33:22 -0800639 if (child instanceof BubbleTextView) {
640 BubbleTextView bubbleChild = (BubbleTextView) child;
Winson Chung5f8afe62013-08-12 16:19:28 -0700641 bubbleChild.setTextVisibility(!mIsHotseat);
Andrew Flynn0dca1ec2012-02-29 13:33:22 -0800642 }
643
Adam Cohen307fe232012-08-16 17:55:58 -0700644 child.setScaleX(getChildrenScale());
645 child.setScaleY(getChildrenScale());
646
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800647 // Generate an id for each view, this assumes we have at most 256x256 cells
648 // per workspace screen
Adam Cohend22015c2010-07-26 22:02:18 -0700649 if (lp.cellX >= 0 && lp.cellX <= mCountX - 1 && lp.cellY >= 0 && lp.cellY <= mCountY - 1) {
Winson Chungaafa03c2010-06-11 17:34:16 -0700650 // If the horizontal or vertical span is set to -1, it is taken to
651 // mean that it spans the extent of the CellLayout
Adam Cohend22015c2010-07-26 22:02:18 -0700652 if (lp.cellHSpan < 0) lp.cellHSpan = mCountX;
653 if (lp.cellVSpan < 0) lp.cellVSpan = mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800654
Winson Chungaafa03c2010-06-11 17:34:16 -0700655 child.setId(childId);
Tony Wickhama0628cc2015-10-14 15:23:04 -0700656 if (LOGD) {
657 Log.d(TAG, "Adding view to ShortcutsAndWidgetsContainer: " + child);
658 }
Sunny Goyalf7a29e82015-04-24 15:20:43 -0700659 mShortcutsAndWidgets.addView(child, index, lp);
Michael Jurkadee05892010-07-27 10:01:56 -0700660
Michael Jurkaf3ca3ab2010-10-20 17:08:24 -0700661 if (markCells) markCellsAsOccupiedForView(child);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700662
Winson Chungaafa03c2010-06-11 17:34:16 -0700663 return true;
664 }
665 return false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800666 }
Michael Jurka3e7c7632010-10-02 16:01:03 -0700667
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800668 @Override
Michael Jurka0280c3b2010-09-17 15:00:07 -0700669 public void removeAllViews() {
670 clearOccupiedCells();
Michael Jurkaa52570f2012-03-20 03:18:20 -0700671 mShortcutsAndWidgets.removeAllViews();
Michael Jurka0280c3b2010-09-17 15:00:07 -0700672 }
673
674 @Override
675 public void removeAllViewsInLayout() {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700676 if (mShortcutsAndWidgets.getChildCount() > 0) {
Michael Jurka7cfc2822011-08-02 20:19:24 -0700677 clearOccupiedCells();
Michael Jurkaa52570f2012-03-20 03:18:20 -0700678 mShortcutsAndWidgets.removeAllViewsInLayout();
Michael Jurka7cfc2822011-08-02 20:19:24 -0700679 }
Michael Jurka0280c3b2010-09-17 15:00:07 -0700680 }
681
682 @Override
683 public void removeView(View view) {
684 markCellsAsUnoccupiedForView(view);
Michael Jurkaa52570f2012-03-20 03:18:20 -0700685 mShortcutsAndWidgets.removeView(view);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700686 }
687
688 @Override
689 public void removeViewAt(int index) {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700690 markCellsAsUnoccupiedForView(mShortcutsAndWidgets.getChildAt(index));
691 mShortcutsAndWidgets.removeViewAt(index);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700692 }
693
694 @Override
695 public void removeViewInLayout(View view) {
696 markCellsAsUnoccupiedForView(view);
Michael Jurkaa52570f2012-03-20 03:18:20 -0700697 mShortcutsAndWidgets.removeViewInLayout(view);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700698 }
699
700 @Override
701 public void removeViews(int start, int count) {
702 for (int i = start; i < start + count; i++) {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700703 markCellsAsUnoccupiedForView(mShortcutsAndWidgets.getChildAt(i));
Michael Jurka0280c3b2010-09-17 15:00:07 -0700704 }
Michael Jurkaa52570f2012-03-20 03:18:20 -0700705 mShortcutsAndWidgets.removeViews(start, count);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700706 }
707
708 @Override
709 public void removeViewsInLayout(int start, int count) {
710 for (int i = start; i < start + count; i++) {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700711 markCellsAsUnoccupiedForView(mShortcutsAndWidgets.getChildAt(i));
Michael Jurka0280c3b2010-09-17 15:00:07 -0700712 }
Michael Jurkaa52570f2012-03-20 03:18:20 -0700713 mShortcutsAndWidgets.removeViewsInLayout(start, count);
Michael Jurkaabded662011-03-04 12:06:57 -0800714 }
715
Patrick Dubroy6569f2c2010-07-12 14:25:18 -0700716 /**
Winson Chungaafa03c2010-06-11 17:34:16 -0700717 * Given a point, return the cell that strictly encloses that point
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800718 * @param x X coordinate of the point
719 * @param y Y coordinate of the point
720 * @param result Array of 2 ints to hold the x and y coordinate of the cell
721 */
Sunny Goyale9b651e2015-04-24 11:44:51 -0700722 public void pointToCellExact(int x, int y, int[] result) {
Winson Chung4b825dcd2011-06-19 12:41:22 -0700723 final int hStartPadding = getPaddingLeft();
724 final int vStartPadding = getPaddingTop();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800725
726 result[0] = (x - hStartPadding) / (mCellWidth + mWidthGap);
727 result[1] = (y - vStartPadding) / (mCellHeight + mHeightGap);
728
Adam Cohend22015c2010-07-26 22:02:18 -0700729 final int xAxis = mCountX;
730 final int yAxis = mCountY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800731
732 if (result[0] < 0) result[0] = 0;
733 if (result[0] >= xAxis) result[0] = xAxis - 1;
734 if (result[1] < 0) result[1] = 0;
735 if (result[1] >= yAxis) result[1] = yAxis - 1;
736 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700737
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800738 /**
739 * Given a point, return the cell that most closely encloses that point
740 * @param x X coordinate of the point
741 * @param y Y coordinate of the point
742 * @param result Array of 2 ints to hold the x and y coordinate of the cell
743 */
744 void pointToCellRounded(int x, int y, int[] result) {
745 pointToCellExact(x + (mCellWidth / 2), y + (mCellHeight / 2), result);
746 }
747
748 /**
749 * Given a cell coordinate, return the point that represents the upper left corner of that cell
Winson Chungaafa03c2010-06-11 17:34:16 -0700750 *
751 * @param cellX X coordinate of the cell
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800752 * @param cellY Y coordinate of the cell
Winson Chungaafa03c2010-06-11 17:34:16 -0700753 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800754 * @param result Array of 2 ints to hold the x and y coordinate of the point
755 */
756 void cellToPoint(int cellX, int cellY, int[] result) {
Winson Chung4b825dcd2011-06-19 12:41:22 -0700757 final int hStartPadding = getPaddingLeft();
758 final int vStartPadding = getPaddingTop();
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800759
760 result[0] = hStartPadding + cellX * (mCellWidth + mWidthGap);
761 result[1] = vStartPadding + cellY * (mCellHeight + mHeightGap);
762 }
763
Adam Cohene3e27a82011-04-15 12:07:39 -0700764 /**
Adam Cohen482ed822012-03-02 14:15:13 -0800765 * Given a cell coordinate, return the point that represents the center of the cell
Adam Cohene3e27a82011-04-15 12:07:39 -0700766 *
767 * @param cellX X coordinate of the cell
768 * @param cellY Y coordinate of the cell
769 *
770 * @param result Array of 2 ints to hold the x and y coordinate of the point
771 */
772 void cellToCenterPoint(int cellX, int cellY, int[] result) {
Adam Cohen47a876d2012-03-19 13:21:41 -0700773 regionToCenterPoint(cellX, cellY, 1, 1, result);
774 }
775
776 /**
777 * Given a cell coordinate and span return the point that represents the center of the regio
778 *
779 * @param cellX X coordinate of the cell
780 * @param cellY Y coordinate of the cell
781 *
782 * @param result Array of 2 ints to hold the x and y coordinate of the point
783 */
784 void regionToCenterPoint(int cellX, int cellY, int spanX, int spanY, int[] result) {
Winson Chung4b825dcd2011-06-19 12:41:22 -0700785 final int hStartPadding = getPaddingLeft();
786 final int vStartPadding = getPaddingTop();
Adam Cohen47a876d2012-03-19 13:21:41 -0700787 result[0] = hStartPadding + cellX * (mCellWidth + mWidthGap) +
788 (spanX * mCellWidth + (spanX - 1) * mWidthGap) / 2;
789 result[1] = vStartPadding + cellY * (mCellHeight + mHeightGap) +
790 (spanY * mCellHeight + (spanY - 1) * mHeightGap) / 2;
Adam Cohene3e27a82011-04-15 12:07:39 -0700791 }
792
Adam Cohen19f37922012-03-21 11:59:11 -0700793 /**
794 * Given a cell coordinate and span fills out a corresponding pixel rect
795 *
796 * @param cellX X coordinate of the cell
797 * @param cellY Y coordinate of the cell
798 * @param result Rect in which to write the result
799 */
800 void regionToRect(int cellX, int cellY, int spanX, int spanY, Rect result) {
801 final int hStartPadding = getPaddingLeft();
802 final int vStartPadding = getPaddingTop();
803 final int left = hStartPadding + cellX * (mCellWidth + mWidthGap);
804 final int top = vStartPadding + cellY * (mCellHeight + mHeightGap);
805 result.set(left, top, left + (spanX * mCellWidth + (spanX - 1) * mWidthGap),
806 top + (spanY * mCellHeight + (spanY - 1) * mHeightGap));
807 }
808
Adam Cohen482ed822012-03-02 14:15:13 -0800809 public float getDistanceFromCell(float x, float y, int[] cell) {
810 cellToCenterPoint(cell[0], cell[1], mTmpPoint);
Sunny Goyalf7a29e82015-04-24 15:20:43 -0700811 return (float) Math.hypot(x - mTmpPoint[0], y - mTmpPoint[1]);
Adam Cohen482ed822012-03-02 14:15:13 -0800812 }
813
Romain Guy84f296c2009-11-04 15:00:44 -0800814 int getCellWidth() {
815 return mCellWidth;
816 }
817
818 int getCellHeight() {
819 return mCellHeight;
820 }
821
Adam Cohend4844c32011-02-18 19:25:06 -0800822 int getWidthGap() {
823 return mWidthGap;
824 }
825
826 int getHeightGap() {
827 return mHeightGap;
828 }
829
Adam Cohenf0f4eda2013-06-06 21:27:03 -0700830 public void setFixedSize(int width, int height) {
831 mFixedWidth = width;
832 mFixedHeight = height;
833 }
834
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800835 @Override
836 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800837 int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800838 int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
Winson Chung5f8afe62013-08-12 16:19:28 -0700839 int widthSize = MeasureSpec.getSize(widthMeasureSpec);
840 int heightSize = MeasureSpec.getSize(heightMeasureSpec);
Winson Chung2d75f122013-09-23 16:53:31 -0700841 int childWidthSize = widthSize - (getPaddingLeft() + getPaddingRight());
842 int childHeightSize = heightSize - (getPaddingTop() + getPaddingBottom());
Winson Chung11a1a532013-09-13 11:14:45 -0700843 if (mFixedCellWidth < 0 || mFixedCellHeight < 0) {
Sunny Goyalc6205602015-05-21 20:46:33 -0700844 int cw = DeviceProfile.calculateCellWidth(childWidthSize, mCountX);
845 int ch = DeviceProfile.calculateCellHeight(childHeightSize, mCountY);
Winson Chung11a1a532013-09-13 11:14:45 -0700846 if (cw != mCellWidth || ch != mCellHeight) {
847 mCellWidth = cw;
848 mCellHeight = ch;
849 mShortcutsAndWidgets.setCellDimensions(mCellWidth, mCellHeight, mWidthGap,
850 mHeightGap, mCountX, mCountY);
851 }
Winson Chung5f8afe62013-08-12 16:19:28 -0700852 }
Winson Chungaafa03c2010-06-11 17:34:16 -0700853
Winson Chung2d75f122013-09-23 16:53:31 -0700854 int newWidth = childWidthSize;
855 int newHeight = childHeightSize;
Adam Cohenf0f4eda2013-06-06 21:27:03 -0700856 if (mFixedWidth > 0 && mFixedHeight > 0) {
857 newWidth = mFixedWidth;
858 newHeight = mFixedHeight;
859 } else if (widthSpecMode == MeasureSpec.UNSPECIFIED || heightSpecMode == MeasureSpec.UNSPECIFIED) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800860 throw new RuntimeException("CellLayout cannot have UNSPECIFIED dimensions");
861 }
862
Adam Cohend22015c2010-07-26 22:02:18 -0700863 int numWidthGaps = mCountX - 1;
864 int numHeightGaps = mCountY - 1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800865
Adam Cohen234c4cd2011-07-17 21:03:04 -0700866 if (mOriginalWidthGap < 0 || mOriginalHeightGap < 0) {
Winson Chung2d75f122013-09-23 16:53:31 -0700867 int hSpace = childWidthSize;
868 int vSpace = childHeightSize;
Adam Cohenf4bd5792012-04-27 11:35:29 -0700869 int hFreeSpace = hSpace - (mCountX * mCellWidth);
870 int vFreeSpace = vSpace - (mCountY * mCellHeight);
Winson Chung4b825dcd2011-06-19 12:41:22 -0700871 mWidthGap = Math.min(mMaxGap, numWidthGaps > 0 ? (hFreeSpace / numWidthGaps) : 0);
872 mHeightGap = Math.min(mMaxGap,numHeightGaps > 0 ? (vFreeSpace / numHeightGaps) : 0);
Winson Chung5f8afe62013-08-12 16:19:28 -0700873 mShortcutsAndWidgets.setCellDimensions(mCellWidth, mCellHeight, mWidthGap,
874 mHeightGap, mCountX, mCountY);
Adam Cohen234c4cd2011-07-17 21:03:04 -0700875 } else {
876 mWidthGap = mOriginalWidthGap;
877 mHeightGap = mOriginalHeightGap;
Winson Chungece7f5b2010-10-22 14:54:12 -0700878 }
Sunny Goyal4fe5a372015-05-14 19:55:10 -0700879
880 // Make the feedback view large enough to hold the blur bitmap.
881 mTouchFeedbackView.measure(
882 MeasureSpec.makeMeasureSpec(mCellWidth + mTouchFeedbackView.getExtraSize(),
883 MeasureSpec.EXACTLY),
884 MeasureSpec.makeMeasureSpec(mCellHeight + mTouchFeedbackView.getExtraSize(),
885 MeasureSpec.EXACTLY));
886
887 mShortcutsAndWidgets.measure(
888 MeasureSpec.makeMeasureSpec(newWidth, MeasureSpec.EXACTLY),
889 MeasureSpec.makeMeasureSpec(newHeight, MeasureSpec.EXACTLY));
890
891 int maxWidth = mShortcutsAndWidgets.getMeasuredWidth();
892 int maxHeight = mShortcutsAndWidgets.getMeasuredHeight();
Winson Chung2d75f122013-09-23 16:53:31 -0700893 if (mFixedWidth > 0 && mFixedHeight > 0) {
894 setMeasuredDimension(maxWidth, maxHeight);
895 } else {
896 setMeasuredDimension(widthSize, heightSize);
897 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800898 }
899
900 @Override
Michael Jurka28750fb2010-09-24 17:43:49 -0700901 protected void onLayout(boolean changed, int l, int t, int r, int b) {
Winson Chung38848ca2013-10-08 12:03:44 -0700902 int offset = getMeasuredWidth() - getPaddingLeft() - getPaddingRight() -
903 (mCountX * mCellWidth);
904 int left = getPaddingLeft() + (int) Math.ceil(offset / 2f);
905 int top = getPaddingTop();
Sunny Goyal4fe5a372015-05-14 19:55:10 -0700906
907 mTouchFeedbackView.layout(left, top,
908 left + mTouchFeedbackView.getMeasuredWidth(),
909 top + mTouchFeedbackView.getMeasuredHeight());
910 mShortcutsAndWidgets.layout(left, top,
911 left + r - l,
912 top + b - t);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800913 }
914
915 @Override
Michael Jurkadee05892010-07-27 10:01:56 -0700916 protected void onSizeChanged(int w, int h, int oldw, int oldh) {
917 super.onSizeChanged(w, h, oldw, oldh);
Winson Chung82a9bd22013-10-08 16:02:34 -0700918
919 // Expand the background drawing bounds by the padding baked into the background drawable
Sunny Goyal2805e632015-05-20 15:35:32 -0700920 mBackground.getPadding(mTempRect);
921 mBackground.setBounds(-mTempRect.left, -mTempRect.top,
922 w + mTempRect.right, h + mTempRect.bottom);
Michael Jurkadee05892010-07-27 10:01:56 -0700923 }
924
925 @Override
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800926 protected void setChildrenDrawingCacheEnabled(boolean enabled) {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700927 mShortcutsAndWidgets.setChildrenDrawingCacheEnabled(enabled);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800928 }
929
930 @Override
931 protected void setChildrenDrawnWithCacheEnabled(boolean enabled) {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700932 mShortcutsAndWidgets.setChildrenDrawnWithCacheEnabled(enabled);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800933 }
934
Michael Jurka5f1c5092010-09-03 14:15:02 -0700935 public float getBackgroundAlpha() {
936 return mBackgroundAlpha;
Michael Jurkadee05892010-07-27 10:01:56 -0700937 }
938
Michael Jurka5f1c5092010-09-03 14:15:02 -0700939 public void setBackgroundAlpha(float alpha) {
Michael Jurkaafaa0502011-12-13 18:22:50 -0800940 if (mBackgroundAlpha != alpha) {
941 mBackgroundAlpha = alpha;
Sunny Goyal2805e632015-05-20 15:35:32 -0700942 mBackground.setAlpha((int) (mBackgroundAlpha * 255));
Michael Jurkaafaa0502011-12-13 18:22:50 -0800943 }
Michael Jurkadee05892010-07-27 10:01:56 -0700944 }
945
Sunny Goyal2805e632015-05-20 15:35:32 -0700946 @Override
947 protected boolean verifyDrawable(Drawable who) {
948 return super.verifyDrawable(who) || (mIsDragTarget && who == mBackground);
949 }
950
Michael Jurkaa52570f2012-03-20 03:18:20 -0700951 public void setShortcutAndWidgetAlpha(float alpha) {
Sunny Goyal02b50812014-09-10 15:44:42 -0700952 mShortcutsAndWidgets.setAlpha(alpha);
Michael Jurkadee05892010-07-27 10:01:56 -0700953 }
954
Michael Jurkaa52570f2012-03-20 03:18:20 -0700955 public ShortcutAndWidgetContainer getShortcutsAndWidgets() {
Sunny Goyaldcbcc862014-08-12 15:58:36 -0700956 return mShortcutsAndWidgets;
Michael Jurkaa52570f2012-03-20 03:18:20 -0700957 }
958
Patrick Dubroy440c3602010-07-13 17:50:32 -0700959 public View getChildAt(int x, int y) {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700960 return mShortcutsAndWidgets.getChildAt(x, y);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700961 }
962
Adam Cohen76fc0852011-06-17 13:26:23 -0700963 public boolean animateChildToPosition(final View child, int cellX, int cellY, int duration,
Adam Cohen482ed822012-03-02 14:15:13 -0800964 int delay, boolean permanent, boolean adjustOccupied) {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700965 ShortcutAndWidgetContainer clc = getShortcutsAndWidgets();
Adam Cohen482ed822012-03-02 14:15:13 -0800966 boolean[][] occupied = mOccupied;
967 if (!permanent) {
968 occupied = mTmpOccupied;
969 }
970
Adam Cohen19f37922012-03-21 11:59:11 -0700971 if (clc.indexOfChild(child) != -1) {
Adam Cohenbfbfd262011-06-13 16:55:12 -0700972 final LayoutParams lp = (LayoutParams) child.getLayoutParams();
973 final ItemInfo info = (ItemInfo) child.getTag();
974
975 // We cancel any existing animations
976 if (mReorderAnimators.containsKey(lp)) {
977 mReorderAnimators.get(lp).cancel();
978 mReorderAnimators.remove(lp);
979 }
980
Adam Cohen482ed822012-03-02 14:15:13 -0800981 final int oldX = lp.x;
982 final int oldY = lp.y;
983 if (adjustOccupied) {
984 occupied[lp.cellX][lp.cellY] = false;
985 occupied[cellX][cellY] = true;
986 }
Adam Cohenbfbfd262011-06-13 16:55:12 -0700987 lp.isLockedToGrid = true;
Adam Cohen482ed822012-03-02 14:15:13 -0800988 if (permanent) {
989 lp.cellX = info.cellX = cellX;
990 lp.cellY = info.cellY = cellY;
991 } else {
992 lp.tmpCellX = cellX;
993 lp.tmpCellY = cellY;
994 }
Adam Cohenbfbfd262011-06-13 16:55:12 -0700995 clc.setupLp(lp);
996 lp.isLockedToGrid = false;
Adam Cohen482ed822012-03-02 14:15:13 -0800997 final int newX = lp.x;
998 final int newY = lp.y;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700999
Adam Cohen76fc0852011-06-17 13:26:23 -07001000 lp.x = oldX;
1001 lp.y = oldY;
Adam Cohen76fc0852011-06-17 13:26:23 -07001002
Adam Cohen482ed822012-03-02 14:15:13 -08001003 // Exit early if we're not actually moving the view
1004 if (oldX == newX && oldY == newY) {
1005 lp.isLockedToGrid = true;
1006 return true;
1007 }
1008
Michael Jurkaf1ad6082013-03-13 12:55:46 +01001009 ValueAnimator va = LauncherAnimUtils.ofFloat(child, 0f, 1f);
Adam Cohen482ed822012-03-02 14:15:13 -08001010 va.setDuration(duration);
1011 mReorderAnimators.put(lp, va);
1012
1013 va.addUpdateListener(new AnimatorUpdateListener() {
1014 @Override
Adam Cohenbfbfd262011-06-13 16:55:12 -07001015 public void onAnimationUpdate(ValueAnimator animation) {
Adam Cohen482ed822012-03-02 14:15:13 -08001016 float r = ((Float) animation.getAnimatedValue()).floatValue();
Adam Cohen19f37922012-03-21 11:59:11 -07001017 lp.x = (int) ((1 - r) * oldX + r * newX);
1018 lp.y = (int) ((1 - r) * oldY + r * newY);
Adam Cohen6b8a02d2012-03-22 15:13:40 -07001019 child.requestLayout();
Adam Cohenbfbfd262011-06-13 16:55:12 -07001020 }
1021 });
Adam Cohen482ed822012-03-02 14:15:13 -08001022 va.addListener(new AnimatorListenerAdapter() {
Adam Cohenbfbfd262011-06-13 16:55:12 -07001023 boolean cancelled = false;
1024 public void onAnimationEnd(Animator animation) {
1025 // If the animation was cancelled, it means that another animation
1026 // has interrupted this one, and we don't want to lock the item into
1027 // place just yet.
1028 if (!cancelled) {
1029 lp.isLockedToGrid = true;
Adam Cohen482ed822012-03-02 14:15:13 -08001030 child.requestLayout();
Adam Cohenbfbfd262011-06-13 16:55:12 -07001031 }
1032 if (mReorderAnimators.containsKey(lp)) {
1033 mReorderAnimators.remove(lp);
1034 }
1035 }
1036 public void onAnimationCancel(Animator animation) {
1037 cancelled = true;
1038 }
1039 });
Adam Cohen482ed822012-03-02 14:15:13 -08001040 va.setStartDelay(delay);
1041 va.start();
Adam Cohenbfbfd262011-06-13 16:55:12 -07001042 return true;
1043 }
1044 return false;
1045 }
1046
Adam Cohen482ed822012-03-02 14:15:13 -08001047 void visualizeDropLocation(View v, Bitmap dragOutline, int originX, int originY, int cellX,
Sunny Goyale78e3d72015-09-24 11:23:31 -07001048 int cellY, int spanX, int spanY, boolean resize, DropTarget.DragObject dragObject) {
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001049 final int oldDragCellX = mDragCell[0];
1050 final int oldDragCellY = mDragCell[1];
Adam Cohen482ed822012-03-02 14:15:13 -08001051
Adam Cohen2801caf2011-05-13 20:57:39 -07001052 if (dragOutline == null && v == null) {
Adam Cohen2801caf2011-05-13 20:57:39 -07001053 return;
1054 }
1055
Adam Cohen482ed822012-03-02 14:15:13 -08001056 if (cellX != oldDragCellX || cellY != oldDragCellY) {
Sunny Goyale78e3d72015-09-24 11:23:31 -07001057 Point dragOffset = dragObject.dragView.getDragVisualizeOffset();
1058 Rect dragRegion = dragObject.dragView.getDragRegion();
1059
Adam Cohen482ed822012-03-02 14:15:13 -08001060 mDragCell[0] = cellX;
1061 mDragCell[1] = cellY;
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001062 // Find the top left corner of the rect the object will occupy
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001063 final int[] topLeft = mTmpPoint;
Adam Cohen482ed822012-03-02 14:15:13 -08001064 cellToPoint(cellX, cellY, topLeft);
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001065
Joe Onorato4be866d2010-10-10 11:26:02 -07001066 int left = topLeft[0];
1067 int top = topLeft[1];
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001068
Winson Chungb8c69f32011-10-19 21:36:08 -07001069 if (v != null && dragOffset == null) {
Adam Cohen99e8b402011-03-25 19:23:43 -07001070 // When drawing the drag outline, it did not account for margin offsets
1071 // added by the view's parent.
1072 MarginLayoutParams lp = (MarginLayoutParams) v.getLayoutParams();
1073 left += lp.leftMargin;
1074 top += lp.topMargin;
Winson Chung150fbab2010-09-29 17:14:26 -07001075
Adam Cohen99e8b402011-03-25 19:23:43 -07001076 // Offsets due to the size difference between the View and the dragOutline.
1077 // There is a size difference to account for the outer blur, which may lie
1078 // outside the bounds of the view.
Winson Chunga9abd0e2010-10-27 17:18:37 -07001079 top += (v.getHeight() - dragOutline.getHeight()) / 2;
Adam Cohenae915ce2011-08-25 13:47:22 -07001080 // We center about the x axis
1081 left += ((mCellWidth * spanX) + ((spanX - 1) * mWidthGap)
1082 - dragOutline.getWidth()) / 2;
Adam Cohen66396872011-04-15 17:50:36 -07001083 } else {
Winson Chungb8c69f32011-10-19 21:36:08 -07001084 if (dragOffset != null && dragRegion != null) {
1085 // Center the drag region *horizontally* in the cell and apply a drag
1086 // outline offset
1087 left += dragOffset.x + ((mCellWidth * spanX) + ((spanX - 1) * mWidthGap)
1088 - dragRegion.width()) / 2;
Winson Chung69737c32013-10-08 17:00:19 -07001089 int cHeight = getShortcutsAndWidgets().getCellContentHeight();
1090 int cellPaddingY = (int) Math.max(0, ((mCellHeight - cHeight) / 2f));
1091 top += dragOffset.y + cellPaddingY;
Winson Chungb8c69f32011-10-19 21:36:08 -07001092 } else {
1093 // Center the drag outline in the cell
1094 left += ((mCellWidth * spanX) + ((spanX - 1) * mWidthGap)
1095 - dragOutline.getWidth()) / 2;
1096 top += ((mCellHeight * spanY) + ((spanY - 1) * mHeightGap)
1097 - dragOutline.getHeight()) / 2;
1098 }
Winson Chunga9abd0e2010-10-27 17:18:37 -07001099 }
Joe Onorato4be866d2010-10-10 11:26:02 -07001100 final int oldIndex = mDragOutlineCurrent;
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001101 mDragOutlineAnims[oldIndex].animateOut();
1102 mDragOutlineCurrent = (oldIndex + 1) % mDragOutlines.length;
Adam Cohend41fbf52012-02-16 23:53:59 -08001103 Rect r = mDragOutlines[mDragOutlineCurrent];
1104 r.set(left, top, left + dragOutline.getWidth(), top + dragOutline.getHeight());
1105 if (resize) {
Adam Cohen482ed822012-03-02 14:15:13 -08001106 cellToRect(cellX, cellY, spanX, spanY, r);
Adam Cohend41fbf52012-02-16 23:53:59 -08001107 }
Winson Chung150fbab2010-09-29 17:14:26 -07001108
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07001109 mDragOutlineAnims[mDragOutlineCurrent].setTag(dragOutline);
1110 mDragOutlineAnims[mDragOutlineCurrent].animateIn();
Sunny Goyale78e3d72015-09-24 11:23:31 -07001111
1112 if (dragObject.stateAnnouncer != null) {
1113 String msg;
1114 if (isHotseat()) {
1115 msg = getContext().getString(R.string.move_to_hotseat_position,
1116 Math.max(cellX, cellY) + 1);
1117 } else {
1118 msg = getContext().getString(R.string.move_to_empty_cell,
1119 cellY + 1, cellX + 1);
1120 }
1121 dragObject.stateAnnouncer.announce(msg);
1122 }
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07001123 }
1124 }
1125
Adam Cohene0310962011-04-18 16:15:31 -07001126 public void clearDragOutlines() {
1127 final int oldIndex = mDragOutlineCurrent;
1128 mDragOutlineAnims[oldIndex].animateOut();
Adam Cohend41fbf52012-02-16 23:53:59 -08001129 mDragCell[0] = mDragCell[1] = -1;
Adam Cohene0310962011-04-18 16:15:31 -07001130 }
1131
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001132 /**
Jeff Sharkey70864282009-04-07 21:08:40 -07001133 * Find a vacant area that will fit the given bounds nearest the requested
1134 * cell location. Uses Euclidean distance to score multiple vacant areas.
Winson Chungaafa03c2010-06-11 17:34:16 -07001135 *
Romain Guy51afc022009-05-04 18:03:43 -07001136 * @param pixelX The X location at which you want to search for a vacant area.
1137 * @param pixelY The Y location at which you want to search for a vacant area.
Jeff Sharkey70864282009-04-07 21:08:40 -07001138 * @param spanX Horizontal span of the object.
1139 * @param spanY Vertical span of the object.
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001140 * @param result Array in which to place the result, or null (in which case a new array will
1141 * be allocated)
Jeff Sharkey70864282009-04-07 21:08:40 -07001142 * @return The X, Y cell of a vacant area that can contain this object,
1143 * nearest the requested location.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001144 */
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001145 int[] findNearestVacantArea(int pixelX, int pixelY, int spanX, int spanY, int[] result) {
1146 return findNearestVacantArea(pixelX, pixelY, spanX, spanY, spanX, spanY, result, null);
Michael Jurka6a1435d2010-09-27 17:35:12 -07001147 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001148
Michael Jurka6a1435d2010-09-27 17:35:12 -07001149 /**
1150 * Find a vacant area that will fit the given bounds nearest the requested
1151 * cell location. Uses Euclidean distance to score multiple vacant areas.
1152 *
1153 * @param pixelX The X location at which you want to search for a vacant area.
1154 * @param pixelY The Y location at which you want to search for a vacant area.
Adam Cohend41fbf52012-02-16 23:53:59 -08001155 * @param minSpanX The minimum horizontal span required
1156 * @param minSpanY The minimum vertical span required
1157 * @param spanX Horizontal span of the object.
1158 * @param spanY Vertical span of the object.
1159 * @param result Array in which to place the result, or null (in which case a new array will
1160 * be allocated)
1161 * @return The X, Y cell of a vacant area that can contain this object,
1162 * nearest the requested location.
1163 */
1164 int[] findNearestVacantArea(int pixelX, int pixelY, int minSpanX, int minSpanY, int spanX,
1165 int spanY, int[] result, int[] resultSpan) {
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001166 return findNearestArea(pixelX, pixelY, minSpanX, minSpanY, spanX, spanY, true,
Adam Cohend41fbf52012-02-16 23:53:59 -08001167 result, resultSpan);
1168 }
1169
Adam Cohend41fbf52012-02-16 23:53:59 -08001170 private final Stack<Rect> mTempRectStack = new Stack<Rect>();
1171 private void lazyInitTempRectStack() {
1172 if (mTempRectStack.isEmpty()) {
1173 for (int i = 0; i < mCountX * mCountY; i++) {
1174 mTempRectStack.push(new Rect());
1175 }
1176 }
1177 }
Adam Cohen482ed822012-03-02 14:15:13 -08001178
Adam Cohend41fbf52012-02-16 23:53:59 -08001179 private void recycleTempRects(Stack<Rect> used) {
1180 while (!used.isEmpty()) {
1181 mTempRectStack.push(used.pop());
1182 }
1183 }
1184
1185 /**
1186 * Find a vacant area that will fit the given bounds nearest the requested
1187 * cell location. Uses Euclidean distance to score multiple vacant areas.
1188 *
1189 * @param pixelX The X location at which you want to search for a vacant area.
1190 * @param pixelY The Y location at which you want to search for a vacant area.
1191 * @param minSpanX The minimum horizontal span required
1192 * @param minSpanY The minimum vertical span required
1193 * @param spanX Horizontal span of the object.
1194 * @param spanY Vertical span of the object.
1195 * @param ignoreOccupied If true, the result can be an occupied cell
1196 * @param result Array in which to place the result, or null (in which case a new array will
1197 * be allocated)
1198 * @return The X, Y cell of a vacant area that can contain this object,
1199 * nearest the requested location.
1200 */
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001201 private int[] findNearestArea(int pixelX, int pixelY, int minSpanX, int minSpanY, int spanX,
1202 int spanY, boolean ignoreOccupied, int[] result, int[] resultSpan) {
Adam Cohend41fbf52012-02-16 23:53:59 -08001203 lazyInitTempRectStack();
Michael Jurkac6ee42e2010-09-30 12:04:50 -07001204
Adam Cohene3e27a82011-04-15 12:07:39 -07001205 // For items with a spanX / spanY > 1, the passed in point (pixelX, pixelY) corresponds
1206 // to the center of the item, but we are searching based on the top-left cell, so
1207 // we translate the point over to correspond to the top-left.
1208 pixelX -= (mCellWidth + mWidthGap) * (spanX - 1) / 2f;
1209 pixelY -= (mCellHeight + mHeightGap) * (spanY - 1) / 2f;
1210
Jeff Sharkey70864282009-04-07 21:08:40 -07001211 // Keep track of best-scoring drop area
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001212 final int[] bestXY = result != null ? result : new int[2];
Jeff Sharkey70864282009-04-07 21:08:40 -07001213 double bestDistance = Double.MAX_VALUE;
Adam Cohend41fbf52012-02-16 23:53:59 -08001214 final Rect bestRect = new Rect(-1, -1, -1, -1);
1215 final Stack<Rect> validRegions = new Stack<Rect>();
Winson Chungaafa03c2010-06-11 17:34:16 -07001216
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001217 final int countX = mCountX;
1218 final int countY = mCountY;
Patrick Dubroyde7658b2010-09-27 11:15:43 -07001219
Adam Cohend41fbf52012-02-16 23:53:59 -08001220 if (minSpanX <= 0 || minSpanY <= 0 || spanX <= 0 || spanY <= 0 ||
1221 spanX < minSpanX || spanY < minSpanY) {
1222 return bestXY;
1223 }
1224
1225 for (int y = 0; y < countY - (minSpanY - 1); y++) {
Michael Jurkac28de512010-08-13 11:27:44 -07001226 inner:
Adam Cohend41fbf52012-02-16 23:53:59 -08001227 for (int x = 0; x < countX - (minSpanX - 1); x++) {
1228 int ySize = -1;
1229 int xSize = -1;
Adam Cohendf035382011-04-11 17:22:04 -07001230 if (ignoreOccupied) {
Adam Cohend41fbf52012-02-16 23:53:59 -08001231 // First, let's see if this thing fits anywhere
1232 for (int i = 0; i < minSpanX; i++) {
1233 for (int j = 0; j < minSpanY; j++) {
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001234 if (mOccupied[x + i][y + j]) {
Adam Cohendf035382011-04-11 17:22:04 -07001235 continue inner;
1236 }
Michael Jurkac28de512010-08-13 11:27:44 -07001237 }
1238 }
Adam Cohend41fbf52012-02-16 23:53:59 -08001239 xSize = minSpanX;
1240 ySize = minSpanY;
1241
1242 // We know that the item will fit at _some_ acceptable size, now let's see
1243 // how big we can make it. We'll alternate between incrementing x and y spans
1244 // until we hit a limit.
1245 boolean incX = true;
1246 boolean hitMaxX = xSize >= spanX;
1247 boolean hitMaxY = ySize >= spanY;
1248 while (!(hitMaxX && hitMaxY)) {
1249 if (incX && !hitMaxX) {
1250 for (int j = 0; j < ySize; j++) {
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001251 if (x + xSize > countX -1 || mOccupied[x + xSize][y + j]) {
Adam Cohend41fbf52012-02-16 23:53:59 -08001252 // We can't move out horizontally
1253 hitMaxX = true;
1254 }
1255 }
1256 if (!hitMaxX) {
1257 xSize++;
1258 }
1259 } else if (!hitMaxY) {
1260 for (int i = 0; i < xSize; i++) {
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001261 if (y + ySize > countY - 1 || mOccupied[x + i][y + ySize]) {
Adam Cohend41fbf52012-02-16 23:53:59 -08001262 // We can't move out vertically
1263 hitMaxY = true;
1264 }
1265 }
1266 if (!hitMaxY) {
1267 ySize++;
1268 }
1269 }
1270 hitMaxX |= xSize >= spanX;
1271 hitMaxY |= ySize >= spanY;
1272 incX = !incX;
1273 }
1274 incX = true;
1275 hitMaxX = xSize >= spanX;
1276 hitMaxY = ySize >= spanY;
Michael Jurkac28de512010-08-13 11:27:44 -07001277 }
Sunny Goyal2805e632015-05-20 15:35:32 -07001278 final int[] cellXY = mTmpPoint;
Adam Cohene3e27a82011-04-15 12:07:39 -07001279 cellToCenterPoint(x, y, cellXY);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001280
Adam Cohend41fbf52012-02-16 23:53:59 -08001281 // We verify that the current rect is not a sub-rect of any of our previous
1282 // candidates. In this case, the current rect is disqualified in favour of the
1283 // containing rect.
1284 Rect currentRect = mTempRectStack.pop();
1285 currentRect.set(x, y, x + xSize, y + ySize);
1286 boolean contained = false;
1287 for (Rect r : validRegions) {
1288 if (r.contains(currentRect)) {
1289 contained = true;
1290 break;
1291 }
1292 }
1293 validRegions.push(currentRect);
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001294 double distance = Math.hypot(cellXY[0] - pixelX, cellXY[1] - pixelY);
Adam Cohen482ed822012-03-02 14:15:13 -08001295
Adam Cohend41fbf52012-02-16 23:53:59 -08001296 if ((distance <= bestDistance && !contained) ||
1297 currentRect.contains(bestRect)) {
Michael Jurkac28de512010-08-13 11:27:44 -07001298 bestDistance = distance;
1299 bestXY[0] = x;
1300 bestXY[1] = y;
Adam Cohend41fbf52012-02-16 23:53:59 -08001301 if (resultSpan != null) {
1302 resultSpan[0] = xSize;
1303 resultSpan[1] = ySize;
1304 }
1305 bestRect.set(currentRect);
Michael Jurkac28de512010-08-13 11:27:44 -07001306 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001307 }
1308 }
1309
Adam Cohenc0dcf592011-06-01 15:30:43 -07001310 // Return -1, -1 if no suitable location found
1311 if (bestDistance == Double.MAX_VALUE) {
1312 bestXY[0] = -1;
1313 bestXY[1] = -1;
Jeff Sharkey70864282009-04-07 21:08:40 -07001314 }
Adam Cohend41fbf52012-02-16 23:53:59 -08001315 recycleTempRects(validRegions);
Adam Cohenc0dcf592011-06-01 15:30:43 -07001316 return bestXY;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001317 }
Winson Chungaafa03c2010-06-11 17:34:16 -07001318
Adam Cohen482ed822012-03-02 14:15:13 -08001319 /**
1320 * Find a vacant area that will fit the given bounds nearest the requested
1321 * cell location, and will also weigh in a suggested direction vector of the
1322 * desired location. This method computers distance based on unit grid distances,
1323 * not pixel distances.
1324 *
Adam Cohen47a876d2012-03-19 13:21:41 -07001325 * @param cellX The X cell nearest to which you want to search for a vacant area.
1326 * @param cellY The Y cell nearest which you want to search for a vacant area.
Adam Cohen482ed822012-03-02 14:15:13 -08001327 * @param spanX Horizontal span of the object.
1328 * @param spanY Vertical span of the object.
Adam Cohen47a876d2012-03-19 13:21:41 -07001329 * @param direction The favored direction in which the views should move from x, y
1330 * @param exactDirectionOnly If this parameter is true, then only solutions where the direction
1331 * matches exactly. Otherwise we find the best matching direction.
1332 * @param occoupied The array which represents which cells in the CellLayout are occupied
1333 * @param blockOccupied The array which represents which cells in the specified block (cellX,
Winson Chung5f8afe62013-08-12 16:19:28 -07001334 * cellY, spanX, spanY) are occupied. This is used when try to move a group of views.
Adam Cohen482ed822012-03-02 14:15:13 -08001335 * @param result Array in which to place the result, or null (in which case a new array will
1336 * be allocated)
1337 * @return The X, Y cell of a vacant area that can contain this object,
1338 * nearest the requested location.
1339 */
1340 private int[] findNearestArea(int cellX, int cellY, int spanX, int spanY, int[] direction,
Adam Cohen47a876d2012-03-19 13:21:41 -07001341 boolean[][] occupied, boolean blockOccupied[][], int[] result) {
Adam Cohen482ed822012-03-02 14:15:13 -08001342 // Keep track of best-scoring drop area
1343 final int[] bestXY = result != null ? result : new int[2];
1344 float bestDistance = Float.MAX_VALUE;
1345 int bestDirectionScore = Integer.MIN_VALUE;
1346
1347 final int countX = mCountX;
1348 final int countY = mCountY;
1349
1350 for (int y = 0; y < countY - (spanY - 1); y++) {
1351 inner:
1352 for (int x = 0; x < countX - (spanX - 1); x++) {
1353 // First, let's see if this thing fits anywhere
1354 for (int i = 0; i < spanX; i++) {
1355 for (int j = 0; j < spanY; j++) {
Adam Cohen47a876d2012-03-19 13:21:41 -07001356 if (occupied[x + i][y + j] && (blockOccupied == null || blockOccupied[i][j])) {
Adam Cohen482ed822012-03-02 14:15:13 -08001357 continue inner;
1358 }
1359 }
1360 }
1361
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001362 float distance = (float) Math.hypot(x - cellX, y - cellY);
Adam Cohen482ed822012-03-02 14:15:13 -08001363 int[] curDirection = mTmpPoint;
Adam Cohen47a876d2012-03-19 13:21:41 -07001364 computeDirectionVector(x - cellX, y - cellY, curDirection);
1365 // The direction score is just the dot product of the two candidate direction
1366 // and that passed in.
Adam Cohen482ed822012-03-02 14:15:13 -08001367 int curDirectionScore = direction[0] * curDirection[0] +
1368 direction[1] * curDirection[1];
Adam Cohen47a876d2012-03-19 13:21:41 -07001369 boolean exactDirectionOnly = false;
1370 boolean directionMatches = direction[0] == curDirection[0] &&
1371 direction[0] == curDirection[0];
1372 if ((directionMatches || !exactDirectionOnly) &&
1373 Float.compare(distance, bestDistance) < 0 || (Float.compare(distance,
Adam Cohen482ed822012-03-02 14:15:13 -08001374 bestDistance) == 0 && curDirectionScore > bestDirectionScore)) {
1375 bestDistance = distance;
1376 bestDirectionScore = curDirectionScore;
1377 bestXY[0] = x;
1378 bestXY[1] = y;
1379 }
1380 }
1381 }
1382
1383 // Return -1, -1 if no suitable location found
1384 if (bestDistance == Float.MAX_VALUE) {
1385 bestXY[0] = -1;
1386 bestXY[1] = -1;
1387 }
1388 return bestXY;
1389 }
1390
1391 private boolean addViewToTempLocation(View v, Rect rectOccupiedByPotentialDrop,
Adam Cohen8baab352012-03-20 17:39:21 -07001392 int[] direction, ItemConfiguration currentState) {
1393 CellAndSpan c = currentState.map.get(v);
Adam Cohen482ed822012-03-02 14:15:13 -08001394 boolean success = false;
Adam Cohen8baab352012-03-20 17:39:21 -07001395 markCellsForView(c.x, c.y, c.spanX, c.spanY, mTmpOccupied, false);
Adam Cohen482ed822012-03-02 14:15:13 -08001396 markCellsForRect(rectOccupiedByPotentialDrop, mTmpOccupied, true);
1397
Adam Cohen8baab352012-03-20 17:39:21 -07001398 findNearestArea(c.x, c.y, c.spanX, c.spanY, direction, mTmpOccupied, null, mTempLocation);
Adam Cohen482ed822012-03-02 14:15:13 -08001399
1400 if (mTempLocation[0] >= 0 && mTempLocation[1] >= 0) {
Adam Cohen8baab352012-03-20 17:39:21 -07001401 c.x = mTempLocation[0];
1402 c.y = mTempLocation[1];
Adam Cohen482ed822012-03-02 14:15:13 -08001403 success = true;
Adam Cohen482ed822012-03-02 14:15:13 -08001404 }
Adam Cohen8baab352012-03-20 17:39:21 -07001405 markCellsForView(c.x, c.y, c.spanX, c.spanY, mTmpOccupied, true);
Adam Cohen482ed822012-03-02 14:15:13 -08001406 return success;
1407 }
1408
Adam Cohenf3900c22012-11-16 18:28:11 -08001409 /**
1410 * This helper class defines a cluster of views. It helps with defining complex edges
1411 * of the cluster and determining how those edges interact with other views. The edges
1412 * essentially define a fine-grained boundary around the cluster of views -- like a more
1413 * precise version of a bounding box.
1414 */
1415 private class ViewCluster {
1416 final static int LEFT = 0;
1417 final static int TOP = 1;
1418 final static int RIGHT = 2;
1419 final static int BOTTOM = 3;
Adam Cohen47a876d2012-03-19 13:21:41 -07001420
Adam Cohenf3900c22012-11-16 18:28:11 -08001421 ArrayList<View> views;
1422 ItemConfiguration config;
1423 Rect boundingRect = new Rect();
Adam Cohen47a876d2012-03-19 13:21:41 -07001424
Adam Cohenf3900c22012-11-16 18:28:11 -08001425 int[] leftEdge = new int[mCountY];
1426 int[] rightEdge = new int[mCountY];
1427 int[] topEdge = new int[mCountX];
1428 int[] bottomEdge = new int[mCountX];
1429 boolean leftEdgeDirty, rightEdgeDirty, topEdgeDirty, bottomEdgeDirty, boundingRectDirty;
1430
1431 @SuppressWarnings("unchecked")
1432 public ViewCluster(ArrayList<View> views, ItemConfiguration config) {
1433 this.views = (ArrayList<View>) views.clone();
1434 this.config = config;
1435 resetEdges();
Adam Cohen47a876d2012-03-19 13:21:41 -07001436 }
1437
Adam Cohenf3900c22012-11-16 18:28:11 -08001438 void resetEdges() {
1439 for (int i = 0; i < mCountX; i++) {
1440 topEdge[i] = -1;
1441 bottomEdge[i] = -1;
1442 }
1443 for (int i = 0; i < mCountY; i++) {
1444 leftEdge[i] = -1;
1445 rightEdge[i] = -1;
1446 }
1447 leftEdgeDirty = true;
1448 rightEdgeDirty = true;
1449 bottomEdgeDirty = true;
1450 topEdgeDirty = true;
1451 boundingRectDirty = true;
1452 }
Adam Cohen47a876d2012-03-19 13:21:41 -07001453
Adam Cohenf3900c22012-11-16 18:28:11 -08001454 void computeEdge(int which, int[] edge) {
1455 int count = views.size();
1456 for (int i = 0; i < count; i++) {
1457 CellAndSpan cs = config.map.get(views.get(i));
1458 switch (which) {
1459 case LEFT:
1460 int left = cs.x;
1461 for (int j = cs.y; j < cs.y + cs.spanY; j++) {
1462 if (left < edge[j] || edge[j] < 0) {
1463 edge[j] = left;
Adam Cohena56dc102012-07-13 13:41:42 -07001464 }
Adam Cohen47a876d2012-03-19 13:21:41 -07001465 }
Adam Cohenf3900c22012-11-16 18:28:11 -08001466 break;
1467 case RIGHT:
1468 int right = cs.x + cs.spanX;
1469 for (int j = cs.y; j < cs.y + cs.spanY; j++) {
1470 if (right > edge[j]) {
1471 edge[j] = right;
1472 }
1473 }
1474 break;
1475 case TOP:
1476 int top = cs.y;
1477 for (int j = cs.x; j < cs.x + cs.spanX; j++) {
1478 if (top < edge[j] || edge[j] < 0) {
1479 edge[j] = top;
1480 }
1481 }
1482 break;
1483 case BOTTOM:
1484 int bottom = cs.y + cs.spanY;
1485 for (int j = cs.x; j < cs.x + cs.spanX; j++) {
1486 if (bottom > edge[j]) {
1487 edge[j] = bottom;
1488 }
1489 }
1490 break;
Adam Cohen47a876d2012-03-19 13:21:41 -07001491 }
1492 }
1493 }
Adam Cohenf3900c22012-11-16 18:28:11 -08001494
1495 boolean isViewTouchingEdge(View v, int whichEdge) {
1496 CellAndSpan cs = config.map.get(v);
1497
1498 int[] edge = getEdge(whichEdge);
1499
1500 switch (whichEdge) {
1501 case LEFT:
1502 for (int i = cs.y; i < cs.y + cs.spanY; i++) {
1503 if (edge[i] == cs.x + cs.spanX) {
1504 return true;
1505 }
1506 }
1507 break;
1508 case RIGHT:
1509 for (int i = cs.y; i < cs.y + cs.spanY; i++) {
1510 if (edge[i] == cs.x) {
1511 return true;
1512 }
1513 }
1514 break;
1515 case TOP:
1516 for (int i = cs.x; i < cs.x + cs.spanX; i++) {
1517 if (edge[i] == cs.y + cs.spanY) {
1518 return true;
1519 }
1520 }
1521 break;
1522 case BOTTOM:
1523 for (int i = cs.x; i < cs.x + cs.spanX; i++) {
1524 if (edge[i] == cs.y) {
1525 return true;
1526 }
1527 }
1528 break;
1529 }
1530 return false;
1531 }
1532
1533 void shift(int whichEdge, int delta) {
1534 for (View v: views) {
1535 CellAndSpan c = config.map.get(v);
1536 switch (whichEdge) {
1537 case LEFT:
1538 c.x -= delta;
1539 break;
1540 case RIGHT:
1541 c.x += delta;
1542 break;
1543 case TOP:
1544 c.y -= delta;
1545 break;
1546 case BOTTOM:
1547 default:
1548 c.y += delta;
1549 break;
1550 }
1551 }
1552 resetEdges();
1553 }
1554
1555 public void addView(View v) {
1556 views.add(v);
1557 resetEdges();
1558 }
1559
1560 public Rect getBoundingRect() {
1561 if (boundingRectDirty) {
1562 boolean first = true;
1563 for (View v: views) {
1564 CellAndSpan c = config.map.get(v);
1565 if (first) {
1566 boundingRect.set(c.x, c.y, c.x + c.spanX, c.y + c.spanY);
1567 first = false;
1568 } else {
1569 boundingRect.union(c.x, c.y, c.x + c.spanX, c.y + c.spanY);
1570 }
1571 }
1572 }
1573 return boundingRect;
1574 }
1575
1576 public int[] getEdge(int which) {
1577 switch (which) {
1578 case LEFT:
1579 return getLeftEdge();
1580 case RIGHT:
1581 return getRightEdge();
1582 case TOP:
1583 return getTopEdge();
1584 case BOTTOM:
1585 default:
1586 return getBottomEdge();
1587 }
1588 }
1589
1590 public int[] getLeftEdge() {
1591 if (leftEdgeDirty) {
1592 computeEdge(LEFT, leftEdge);
1593 }
1594 return leftEdge;
1595 }
1596
1597 public int[] getRightEdge() {
1598 if (rightEdgeDirty) {
1599 computeEdge(RIGHT, rightEdge);
1600 }
1601 return rightEdge;
1602 }
1603
1604 public int[] getTopEdge() {
1605 if (topEdgeDirty) {
1606 computeEdge(TOP, topEdge);
1607 }
1608 return topEdge;
1609 }
1610
1611 public int[] getBottomEdge() {
1612 if (bottomEdgeDirty) {
1613 computeEdge(BOTTOM, bottomEdge);
1614 }
1615 return bottomEdge;
1616 }
1617
1618 PositionComparator comparator = new PositionComparator();
1619 class PositionComparator implements Comparator<View> {
1620 int whichEdge = 0;
1621 public int compare(View left, View right) {
1622 CellAndSpan l = config.map.get(left);
1623 CellAndSpan r = config.map.get(right);
1624 switch (whichEdge) {
1625 case LEFT:
1626 return (r.x + r.spanX) - (l.x + l.spanX);
1627 case RIGHT:
1628 return l.x - r.x;
1629 case TOP:
1630 return (r.y + r.spanY) - (l.y + l.spanY);
1631 case BOTTOM:
1632 default:
1633 return l.y - r.y;
1634 }
1635 }
1636 }
1637
1638 public void sortConfigurationForEdgePush(int edge) {
1639 comparator.whichEdge = edge;
1640 Collections.sort(config.sortedViews, comparator);
1641 }
Adam Cohen47a876d2012-03-19 13:21:41 -07001642 }
1643
Adam Cohenf3900c22012-11-16 18:28:11 -08001644 private boolean pushViewsToTempLocation(ArrayList<View> views, Rect rectOccupiedByPotentialDrop,
1645 int[] direction, View dragView, ItemConfiguration currentState) {
Adam Cohene0489502012-08-27 15:18:53 -07001646
Adam Cohenf3900c22012-11-16 18:28:11 -08001647 ViewCluster cluster = new ViewCluster(views, currentState);
1648 Rect clusterRect = cluster.getBoundingRect();
1649 int whichEdge;
1650 int pushDistance;
1651 boolean fail = false;
1652
1653 // Determine the edge of the cluster that will be leading the push and how far
1654 // the cluster must be shifted.
1655 if (direction[0] < 0) {
1656 whichEdge = ViewCluster.LEFT;
1657 pushDistance = clusterRect.right - rectOccupiedByPotentialDrop.left;
Adam Cohene0489502012-08-27 15:18:53 -07001658 } else if (direction[0] > 0) {
Adam Cohenf3900c22012-11-16 18:28:11 -08001659 whichEdge = ViewCluster.RIGHT;
1660 pushDistance = rectOccupiedByPotentialDrop.right - clusterRect.left;
1661 } else if (direction[1] < 0) {
1662 whichEdge = ViewCluster.TOP;
1663 pushDistance = clusterRect.bottom - rectOccupiedByPotentialDrop.top;
1664 } else {
1665 whichEdge = ViewCluster.BOTTOM;
1666 pushDistance = rectOccupiedByPotentialDrop.bottom - clusterRect.top;
Adam Cohene0489502012-08-27 15:18:53 -07001667 }
1668
Adam Cohenf3900c22012-11-16 18:28:11 -08001669 // Break early for invalid push distance.
1670 if (pushDistance <= 0) {
1671 return false;
Adam Cohene0489502012-08-27 15:18:53 -07001672 }
Adam Cohenf3900c22012-11-16 18:28:11 -08001673
1674 // Mark the occupied state as false for the group of views we want to move.
1675 for (View v: views) {
1676 CellAndSpan c = currentState.map.get(v);
1677 markCellsForView(c.x, c.y, c.spanX, c.spanY, mTmpOccupied, false);
1678 }
1679
1680 // We save the current configuration -- if we fail to find a solution we will revert
1681 // to the initial state. The process of finding a solution modifies the configuration
1682 // in place, hence the need for revert in the failure case.
1683 currentState.save();
1684
1685 // The pushing algorithm is simplified by considering the views in the order in which
1686 // they would be pushed by the cluster. For example, if the cluster is leading with its
1687 // left edge, we consider sort the views by their right edge, from right to left.
1688 cluster.sortConfigurationForEdgePush(whichEdge);
1689
1690 while (pushDistance > 0 && !fail) {
1691 for (View v: currentState.sortedViews) {
1692 // For each view that isn't in the cluster, we see if the leading edge of the
1693 // cluster is contacting the edge of that view. If so, we add that view to the
1694 // cluster.
1695 if (!cluster.views.contains(v) && v != dragView) {
1696 if (cluster.isViewTouchingEdge(v, whichEdge)) {
1697 LayoutParams lp = (LayoutParams) v.getLayoutParams();
1698 if (!lp.canReorder) {
1699 // The push solution includes the all apps button, this is not viable.
1700 fail = true;
1701 break;
1702 }
1703 cluster.addView(v);
1704 CellAndSpan c = currentState.map.get(v);
1705
1706 // Adding view to cluster, mark it as not occupied.
1707 markCellsForView(c.x, c.y, c.spanX, c.spanY, mTmpOccupied, false);
1708 }
1709 }
1710 }
1711 pushDistance--;
1712
1713 // The cluster has been completed, now we move the whole thing over in the appropriate
1714 // direction.
1715 cluster.shift(whichEdge, 1);
1716 }
1717
1718 boolean foundSolution = false;
1719 clusterRect = cluster.getBoundingRect();
1720
1721 // Due to the nature of the algorithm, the only check required to verify a valid solution
1722 // is to ensure that completed shifted cluster lies completely within the cell layout.
1723 if (!fail && clusterRect.left >= 0 && clusterRect.right <= mCountX && clusterRect.top >= 0 &&
1724 clusterRect.bottom <= mCountY) {
1725 foundSolution = true;
1726 } else {
1727 currentState.restore();
1728 }
1729
1730 // In either case, we set the occupied array as marked for the location of the views
1731 for (View v: cluster.views) {
1732 CellAndSpan c = currentState.map.get(v);
1733 markCellsForView(c.x, c.y, c.spanX, c.spanY, mTmpOccupied, true);
1734 }
1735
1736 return foundSolution;
Adam Cohene0489502012-08-27 15:18:53 -07001737 }
1738
Adam Cohen482ed822012-03-02 14:15:13 -08001739 private boolean addViewsToTempLocation(ArrayList<View> views, Rect rectOccupiedByPotentialDrop,
Adam Cohenf3900c22012-11-16 18:28:11 -08001740 int[] direction, View dragView, ItemConfiguration currentState) {
Adam Cohen482ed822012-03-02 14:15:13 -08001741 if (views.size() == 0) return true;
Adam Cohen482ed822012-03-02 14:15:13 -08001742
Adam Cohen8baab352012-03-20 17:39:21 -07001743 boolean success = false;
Adam Cohen482ed822012-03-02 14:15:13 -08001744 Rect boundingRect = null;
Adam Cohen8baab352012-03-20 17:39:21 -07001745 // We construct a rect which represents the entire group of views passed in
Adam Cohen482ed822012-03-02 14:15:13 -08001746 for (View v: views) {
Adam Cohen8baab352012-03-20 17:39:21 -07001747 CellAndSpan c = currentState.map.get(v);
Adam Cohen482ed822012-03-02 14:15:13 -08001748 if (boundingRect == null) {
Adam Cohen8baab352012-03-20 17:39:21 -07001749 boundingRect = new Rect(c.x, c.y, c.x + c.spanX, c.y + c.spanY);
Adam Cohen482ed822012-03-02 14:15:13 -08001750 } else {
Adam Cohen8baab352012-03-20 17:39:21 -07001751 boundingRect.union(c.x, c.y, c.x + c.spanX, c.y + c.spanY);
Adam Cohen482ed822012-03-02 14:15:13 -08001752 }
1753 }
Adam Cohen8baab352012-03-20 17:39:21 -07001754
Adam Cohen8baab352012-03-20 17:39:21 -07001755 // Mark the occupied state as false for the group of views we want to move.
Adam Cohenf3900c22012-11-16 18:28:11 -08001756 for (View v: views) {
Adam Cohen8baab352012-03-20 17:39:21 -07001757 CellAndSpan c = currentState.map.get(v);
1758 markCellsForView(c.x, c.y, c.spanX, c.spanY, mTmpOccupied, false);
1759 }
1760
Adam Cohen47a876d2012-03-19 13:21:41 -07001761 boolean[][] blockOccupied = new boolean[boundingRect.width()][boundingRect.height()];
1762 int top = boundingRect.top;
1763 int left = boundingRect.left;
Adam Cohen8baab352012-03-20 17:39:21 -07001764 // We mark more precisely which parts of the bounding rect are truly occupied, allowing
Adam Cohena56dc102012-07-13 13:41:42 -07001765 // for interlocking.
Adam Cohenf3900c22012-11-16 18:28:11 -08001766 for (View v: views) {
Adam Cohen8baab352012-03-20 17:39:21 -07001767 CellAndSpan c = currentState.map.get(v);
1768 markCellsForView(c.x - left, c.y - top, c.spanX, c.spanY, blockOccupied, true);
Adam Cohen47a876d2012-03-19 13:21:41 -07001769 }
1770
Adam Cohen482ed822012-03-02 14:15:13 -08001771 markCellsForRect(rectOccupiedByPotentialDrop, mTmpOccupied, true);
1772
Adam Cohenf3900c22012-11-16 18:28:11 -08001773 findNearestArea(boundingRect.left, boundingRect.top, boundingRect.width(),
1774 boundingRect.height(), direction, mTmpOccupied, blockOccupied, mTempLocation);
Adam Cohen482ed822012-03-02 14:15:13 -08001775
Adam Cohen8baab352012-03-20 17:39:21 -07001776 // If we successfuly found a location by pushing the block of views, we commit it
Adam Cohen482ed822012-03-02 14:15:13 -08001777 if (mTempLocation[0] >= 0 && mTempLocation[1] >= 0) {
Adam Cohen8baab352012-03-20 17:39:21 -07001778 int deltaX = mTempLocation[0] - boundingRect.left;
1779 int deltaY = mTempLocation[1] - boundingRect.top;
Adam Cohenf3900c22012-11-16 18:28:11 -08001780 for (View v: views) {
Adam Cohen8baab352012-03-20 17:39:21 -07001781 CellAndSpan c = currentState.map.get(v);
1782 c.x += deltaX;
1783 c.y += deltaY;
Adam Cohen482ed822012-03-02 14:15:13 -08001784 }
1785 success = true;
1786 }
Adam Cohen8baab352012-03-20 17:39:21 -07001787
1788 // In either case, we set the occupied array as marked for the location of the views
Adam Cohenf3900c22012-11-16 18:28:11 -08001789 for (View v: views) {
Adam Cohen8baab352012-03-20 17:39:21 -07001790 CellAndSpan c = currentState.map.get(v);
1791 markCellsForView(c.x, c.y, c.spanX, c.spanY, mTmpOccupied, true);
Adam Cohen482ed822012-03-02 14:15:13 -08001792 }
1793 return success;
1794 }
1795
1796 private void markCellsForRect(Rect r, boolean[][] occupied, boolean value) {
1797 markCellsForView(r.left, r.top, r.width(), r.height(), occupied, value);
1798 }
1799
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001800 // This method tries to find a reordering solution which satisfies the push mechanic by trying
1801 // to push items in each of the cardinal directions, in an order based on the direction vector
1802 // passed.
1803 private boolean attemptPushInDirection(ArrayList<View> intersectingViews, Rect occupied,
1804 int[] direction, View ignoreView, ItemConfiguration solution) {
1805 if ((Math.abs(direction[0]) + Math.abs(direction[1])) > 1) {
Winson Chung5f8afe62013-08-12 16:19:28 -07001806 // If the direction vector has two non-zero components, we try pushing
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001807 // separately in each of the components.
1808 int temp = direction[1];
1809 direction[1] = 0;
Adam Cohenf3900c22012-11-16 18:28:11 -08001810
1811 if (pushViewsToTempLocation(intersectingViews, occupied, direction,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001812 ignoreView, solution)) {
1813 return true;
1814 }
1815 direction[1] = temp;
1816 temp = direction[0];
1817 direction[0] = 0;
Adam Cohenf3900c22012-11-16 18:28:11 -08001818
1819 if (pushViewsToTempLocation(intersectingViews, occupied, direction,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001820 ignoreView, solution)) {
1821 return true;
1822 }
1823 // Revert the direction
1824 direction[0] = temp;
1825
1826 // Now we try pushing in each component of the opposite direction
1827 direction[0] *= -1;
1828 direction[1] *= -1;
1829 temp = direction[1];
1830 direction[1] = 0;
Adam Cohenf3900c22012-11-16 18:28:11 -08001831 if (pushViewsToTempLocation(intersectingViews, occupied, direction,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001832 ignoreView, solution)) {
1833 return true;
1834 }
1835
1836 direction[1] = temp;
1837 temp = direction[0];
1838 direction[0] = 0;
Adam Cohenf3900c22012-11-16 18:28:11 -08001839 if (pushViewsToTempLocation(intersectingViews, occupied, direction,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001840 ignoreView, solution)) {
1841 return true;
1842 }
1843 // revert the direction
1844 direction[0] = temp;
1845 direction[0] *= -1;
1846 direction[1] *= -1;
Winson Chung5f8afe62013-08-12 16:19:28 -07001847
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001848 } else {
1849 // If the direction vector has a single non-zero component, we push first in the
1850 // direction of the vector
Adam Cohenf3900c22012-11-16 18:28:11 -08001851 if (pushViewsToTempLocation(intersectingViews, occupied, direction,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001852 ignoreView, solution)) {
1853 return true;
1854 }
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001855 // Then we try the opposite direction
1856 direction[0] *= -1;
1857 direction[1] *= -1;
Adam Cohenf3900c22012-11-16 18:28:11 -08001858 if (pushViewsToTempLocation(intersectingViews, occupied, direction,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001859 ignoreView, solution)) {
1860 return true;
1861 }
1862 // Switch the direction back
1863 direction[0] *= -1;
1864 direction[1] *= -1;
Winson Chung5f8afe62013-08-12 16:19:28 -07001865
1866 // If we have failed to find a push solution with the above, then we try
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001867 // to find a solution by pushing along the perpendicular axis.
1868
1869 // Swap the components
1870 int temp = direction[1];
1871 direction[1] = direction[0];
1872 direction[0] = temp;
Adam Cohenf3900c22012-11-16 18:28:11 -08001873 if (pushViewsToTempLocation(intersectingViews, occupied, direction,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001874 ignoreView, solution)) {
1875 return true;
1876 }
1877
1878 // Then we try the opposite direction
1879 direction[0] *= -1;
1880 direction[1] *= -1;
Adam Cohenf3900c22012-11-16 18:28:11 -08001881 if (pushViewsToTempLocation(intersectingViews, occupied, direction,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001882 ignoreView, solution)) {
1883 return true;
1884 }
1885 // Switch the direction back
1886 direction[0] *= -1;
1887 direction[1] *= -1;
1888
1889 // Swap the components back
1890 temp = direction[1];
1891 direction[1] = direction[0];
1892 direction[0] = temp;
1893 }
1894 return false;
1895 }
1896
Adam Cohen482ed822012-03-02 14:15:13 -08001897 private boolean rearrangementExists(int cellX, int cellY, int spanX, int spanY, int[] direction,
Adam Cohen8baab352012-03-20 17:39:21 -07001898 View ignoreView, ItemConfiguration solution) {
Winson Chunge3e03bc2012-05-01 15:10:11 -07001899 // Return early if get invalid cell positions
1900 if (cellX < 0 || cellY < 0) return false;
Adam Cohen482ed822012-03-02 14:15:13 -08001901
Adam Cohen8baab352012-03-20 17:39:21 -07001902 mIntersectingViews.clear();
Adam Cohen482ed822012-03-02 14:15:13 -08001903 mOccupiedRect.set(cellX, cellY, cellX + spanX, cellY + spanY);
Adam Cohen482ed822012-03-02 14:15:13 -08001904
Adam Cohen8baab352012-03-20 17:39:21 -07001905 // Mark the desired location of the view currently being dragged.
Adam Cohen482ed822012-03-02 14:15:13 -08001906 if (ignoreView != null) {
Adam Cohen8baab352012-03-20 17:39:21 -07001907 CellAndSpan c = solution.map.get(ignoreView);
Adam Cohen19f37922012-03-21 11:59:11 -07001908 if (c != null) {
1909 c.x = cellX;
1910 c.y = cellY;
1911 }
Adam Cohen482ed822012-03-02 14:15:13 -08001912 }
Adam Cohen482ed822012-03-02 14:15:13 -08001913 Rect r0 = new Rect(cellX, cellY, cellX + spanX, cellY + spanY);
1914 Rect r1 = new Rect();
Adam Cohen8baab352012-03-20 17:39:21 -07001915 for (View child: solution.map.keySet()) {
Adam Cohen482ed822012-03-02 14:15:13 -08001916 if (child == ignoreView) continue;
Adam Cohen8baab352012-03-20 17:39:21 -07001917 CellAndSpan c = solution.map.get(child);
Adam Cohen482ed822012-03-02 14:15:13 -08001918 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Adam Cohen8baab352012-03-20 17:39:21 -07001919 r1.set(c.x, c.y, c.x + c.spanX, c.y + c.spanY);
Adam Cohen482ed822012-03-02 14:15:13 -08001920 if (Rect.intersects(r0, r1)) {
1921 if (!lp.canReorder) {
1922 return false;
1923 }
1924 mIntersectingViews.add(child);
1925 }
1926 }
Adam Cohen47a876d2012-03-19 13:21:41 -07001927
Adam Cohenfa3c58f2013-12-06 16:10:55 -08001928 solution.intersectingViews = new ArrayList<View>(mIntersectingViews);
1929
Winson Chung5f8afe62013-08-12 16:19:28 -07001930 // First we try to find a solution which respects the push mechanic. That is,
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001931 // we try to find a solution such that no displaced item travels through another item
1932 // without also displacing that item.
1933 if (attemptPushInDirection(mIntersectingViews, mOccupiedRect, direction, ignoreView,
Adam Cohen19f37922012-03-21 11:59:11 -07001934 solution)) {
Adam Cohen47a876d2012-03-19 13:21:41 -07001935 return true;
1936 }
Adam Cohen47a876d2012-03-19 13:21:41 -07001937
Adam Cohen4abc5bd2012-05-29 21:06:03 -07001938 // Next we try moving the views as a block, but without requiring the push mechanic.
Adam Cohenf3900c22012-11-16 18:28:11 -08001939 if (addViewsToTempLocation(mIntersectingViews, mOccupiedRect, direction, ignoreView,
Adam Cohen19f37922012-03-21 11:59:11 -07001940 solution)) {
Adam Cohen482ed822012-03-02 14:15:13 -08001941 return true;
1942 }
Adam Cohen47a876d2012-03-19 13:21:41 -07001943
Adam Cohen482ed822012-03-02 14:15:13 -08001944 // Ok, they couldn't move as a block, let's move them individually
1945 for (View v : mIntersectingViews) {
Adam Cohen8baab352012-03-20 17:39:21 -07001946 if (!addViewToTempLocation(v, mOccupiedRect, direction, solution)) {
Adam Cohen482ed822012-03-02 14:15:13 -08001947 return false;
1948 }
1949 }
1950 return true;
1951 }
1952
1953 /*
1954 * Returns a pair (x, y), where x,y are in {-1, 0, 1} corresponding to vector between
1955 * the provided point and the provided cell
1956 */
Adam Cohen47a876d2012-03-19 13:21:41 -07001957 private void computeDirectionVector(float deltaX, float deltaY, int[] result) {
Adam Cohen482ed822012-03-02 14:15:13 -08001958 double angle = Math.atan(((float) deltaY) / deltaX);
1959
1960 result[0] = 0;
1961 result[1] = 0;
1962 if (Math.abs(Math.cos(angle)) > 0.5f) {
1963 result[0] = (int) Math.signum(deltaX);
1964 }
1965 if (Math.abs(Math.sin(angle)) > 0.5f) {
1966 result[1] = (int) Math.signum(deltaY);
1967 }
1968 }
1969
Adam Cohen8baab352012-03-20 17:39:21 -07001970 private void copyOccupiedArray(boolean[][] occupied) {
1971 for (int i = 0; i < mCountX; i++) {
1972 for (int j = 0; j < mCountY; j++) {
1973 occupied[i][j] = mOccupied[i][j];
1974 }
1975 }
1976 }
1977
Sunny Goyalf7a29e82015-04-24 15:20:43 -07001978 private ItemConfiguration findReorderSolution(int pixelX, int pixelY, int minSpanX, int minSpanY,
Adam Cohenfa3c58f2013-12-06 16:10:55 -08001979 int spanX, int spanY, int[] direction, View dragView, boolean decX,
1980 ItemConfiguration solution) {
Adam Cohen8baab352012-03-20 17:39:21 -07001981 // Copy the current state into the solution. This solution will be manipulated as necessary.
1982 copyCurrentStateToSolution(solution, false);
1983 // Copy the current occupied array into the temporary occupied array. This array will be
1984 // manipulated as necessary to find a solution.
1985 copyOccupiedArray(mTmpOccupied);
Adam Cohen482ed822012-03-02 14:15:13 -08001986
1987 // We find the nearest cell into which we would place the dragged item, assuming there's
1988 // nothing in its way.
1989 int result[] = new int[2];
1990 result = findNearestArea(pixelX, pixelY, spanX, spanY, result);
1991
1992 boolean success = false;
1993 // First we try the exact nearest position of the item being dragged,
1994 // we will then want to try to move this around to other neighbouring positions
Adam Cohen8baab352012-03-20 17:39:21 -07001995 success = rearrangementExists(result[0], result[1], spanX, spanY, direction, dragView,
1996 solution);
Adam Cohen482ed822012-03-02 14:15:13 -08001997
1998 if (!success) {
1999 // We try shrinking the widget down to size in an alternating pattern, shrink 1 in
2000 // x, then 1 in y etc.
2001 if (spanX > minSpanX && (minSpanY == spanY || decX)) {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002002 return findReorderSolution(pixelX, pixelY, minSpanX, minSpanY, spanX - 1, spanY,
2003 direction, dragView, false, solution);
Adam Cohen482ed822012-03-02 14:15:13 -08002004 } else if (spanY > minSpanY) {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002005 return findReorderSolution(pixelX, pixelY, minSpanX, minSpanY, spanX, spanY - 1,
2006 direction, dragView, true, solution);
Adam Cohen482ed822012-03-02 14:15:13 -08002007 }
2008 solution.isSolution = false;
2009 } else {
2010 solution.isSolution = true;
2011 solution.dragViewX = result[0];
2012 solution.dragViewY = result[1];
2013 solution.dragViewSpanX = spanX;
2014 solution.dragViewSpanY = spanY;
Adam Cohen482ed822012-03-02 14:15:13 -08002015 }
2016 return solution;
2017 }
2018
2019 private void copyCurrentStateToSolution(ItemConfiguration solution, boolean temp) {
Michael Jurkaa52570f2012-03-20 03:18:20 -07002020 int childCount = mShortcutsAndWidgets.getChildCount();
Adam Cohen482ed822012-03-02 14:15:13 -08002021 for (int i = 0; i < childCount; i++) {
Michael Jurkaa52570f2012-03-20 03:18:20 -07002022 View child = mShortcutsAndWidgets.getChildAt(i);
Adam Cohen482ed822012-03-02 14:15:13 -08002023 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Adam Cohen8baab352012-03-20 17:39:21 -07002024 CellAndSpan c;
Adam Cohen482ed822012-03-02 14:15:13 -08002025 if (temp) {
Adam Cohen8baab352012-03-20 17:39:21 -07002026 c = new CellAndSpan(lp.tmpCellX, lp.tmpCellY, lp.cellHSpan, lp.cellVSpan);
Adam Cohen482ed822012-03-02 14:15:13 -08002027 } else {
Adam Cohen8baab352012-03-20 17:39:21 -07002028 c = new CellAndSpan(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan);
Adam Cohen482ed822012-03-02 14:15:13 -08002029 }
Adam Cohenf3900c22012-11-16 18:28:11 -08002030 solution.add(child, c);
Adam Cohen482ed822012-03-02 14:15:13 -08002031 }
2032 }
2033
2034 private void copySolutionToTempState(ItemConfiguration solution, View dragView) {
2035 for (int i = 0; i < mCountX; i++) {
2036 for (int j = 0; j < mCountY; j++) {
2037 mTmpOccupied[i][j] = false;
2038 }
2039 }
2040
Michael Jurkaa52570f2012-03-20 03:18:20 -07002041 int childCount = mShortcutsAndWidgets.getChildCount();
Adam Cohen482ed822012-03-02 14:15:13 -08002042 for (int i = 0; i < childCount; i++) {
Michael Jurkaa52570f2012-03-20 03:18:20 -07002043 View child = mShortcutsAndWidgets.getChildAt(i);
Adam Cohen482ed822012-03-02 14:15:13 -08002044 if (child == dragView) continue;
2045 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Adam Cohen8baab352012-03-20 17:39:21 -07002046 CellAndSpan c = solution.map.get(child);
2047 if (c != null) {
2048 lp.tmpCellX = c.x;
2049 lp.tmpCellY = c.y;
2050 lp.cellHSpan = c.spanX;
2051 lp.cellVSpan = c.spanY;
2052 markCellsForView(c.x, c.y, c.spanX, c.spanY, mTmpOccupied, true);
Adam Cohen482ed822012-03-02 14:15:13 -08002053 }
2054 }
2055 markCellsForView(solution.dragViewX, solution.dragViewY, solution.dragViewSpanX,
2056 solution.dragViewSpanY, mTmpOccupied, true);
2057 }
2058
2059 private void animateItemsToSolution(ItemConfiguration solution, View dragView, boolean
2060 commitDragView) {
2061
2062 boolean[][] occupied = DESTRUCTIVE_REORDER ? mOccupied : mTmpOccupied;
2063 for (int i = 0; i < mCountX; i++) {
2064 for (int j = 0; j < mCountY; j++) {
2065 occupied[i][j] = false;
2066 }
2067 }
2068
Michael Jurkaa52570f2012-03-20 03:18:20 -07002069 int childCount = mShortcutsAndWidgets.getChildCount();
Adam Cohen482ed822012-03-02 14:15:13 -08002070 for (int i = 0; i < childCount; i++) {
Michael Jurkaa52570f2012-03-20 03:18:20 -07002071 View child = mShortcutsAndWidgets.getChildAt(i);
Adam Cohen482ed822012-03-02 14:15:13 -08002072 if (child == dragView) continue;
Adam Cohen8baab352012-03-20 17:39:21 -07002073 CellAndSpan c = solution.map.get(child);
2074 if (c != null) {
Adam Cohen19f37922012-03-21 11:59:11 -07002075 animateChildToPosition(child, c.x, c.y, REORDER_ANIMATION_DURATION, 0,
2076 DESTRUCTIVE_REORDER, false);
Adam Cohen8baab352012-03-20 17:39:21 -07002077 markCellsForView(c.x, c.y, c.spanX, c.spanY, occupied, true);
Adam Cohen482ed822012-03-02 14:15:13 -08002078 }
2079 }
2080 if (commitDragView) {
2081 markCellsForView(solution.dragViewX, solution.dragViewY, solution.dragViewSpanX,
2082 solution.dragViewSpanY, occupied, true);
2083 }
2084 }
2085
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002086
2087 // This method starts or changes the reorder preview animations
2088 private void beginOrAdjustReorderPreviewAnimations(ItemConfiguration solution,
2089 View dragView, int delay, int mode) {
Adam Cohen19f37922012-03-21 11:59:11 -07002090 int childCount = mShortcutsAndWidgets.getChildCount();
Adam Cohen19f37922012-03-21 11:59:11 -07002091 for (int i = 0; i < childCount; i++) {
2092 View child = mShortcutsAndWidgets.getChildAt(i);
2093 if (child == dragView) continue;
2094 CellAndSpan c = solution.map.get(child);
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002095 boolean skip = mode == ReorderPreviewAnimation.MODE_HINT && solution.intersectingViews
2096 != null && !solution.intersectingViews.contains(child);
2097
Adam Cohen19f37922012-03-21 11:59:11 -07002098 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002099 if (c != null && !skip) {
2100 ReorderPreviewAnimation rha = new ReorderPreviewAnimation(child, mode, lp.cellX,
2101 lp.cellY, c.x, c.y, c.spanX, c.spanY);
Adam Cohend024f982012-05-23 18:26:45 -07002102 rha.animate();
Adam Cohen19f37922012-03-21 11:59:11 -07002103 }
2104 }
2105 }
2106
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002107 // Class which represents the reorder preview animations. These animations show that an item is
Adam Cohen19f37922012-03-21 11:59:11 -07002108 // in a temporary state, and hint at where the item will return to.
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002109 class ReorderPreviewAnimation {
Adam Cohen19f37922012-03-21 11:59:11 -07002110 View child;
Adam Cohend024f982012-05-23 18:26:45 -07002111 float finalDeltaX;
2112 float finalDeltaY;
2113 float initDeltaX;
2114 float initDeltaY;
2115 float finalScale;
2116 float initScale;
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002117 int mode;
2118 boolean repeating = false;
2119 private static final int PREVIEW_DURATION = 300;
2120 private static final int HINT_DURATION = Workspace.REORDER_TIMEOUT;
2121
2122 public static final int MODE_HINT = 0;
2123 public static final int MODE_PREVIEW = 1;
2124
Adam Cohene7587d22012-05-24 18:50:02 -07002125 Animator a;
Adam Cohen19f37922012-03-21 11:59:11 -07002126
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002127 public ReorderPreviewAnimation(View child, int mode, int cellX0, int cellY0, int cellX1,
2128 int cellY1, int spanX, int spanY) {
Adam Cohen19f37922012-03-21 11:59:11 -07002129 regionToCenterPoint(cellX0, cellY0, spanX, spanY, mTmpPoint);
2130 final int x0 = mTmpPoint[0];
2131 final int y0 = mTmpPoint[1];
2132 regionToCenterPoint(cellX1, cellY1, spanX, spanY, mTmpPoint);
2133 final int x1 = mTmpPoint[0];
2134 final int y1 = mTmpPoint[1];
2135 final int dX = x1 - x0;
2136 final int dY = y1 - y0;
Adam Cohend024f982012-05-23 18:26:45 -07002137 finalDeltaX = 0;
2138 finalDeltaY = 0;
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002139 int dir = mode == MODE_HINT ? -1 : 1;
Adam Cohen19f37922012-03-21 11:59:11 -07002140 if (dX == dY && dX == 0) {
2141 } else {
2142 if (dY == 0) {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002143 finalDeltaX = - dir * Math.signum(dX) * mReorderPreviewAnimationMagnitude;
Adam Cohen19f37922012-03-21 11:59:11 -07002144 } else if (dX == 0) {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002145 finalDeltaY = - dir * Math.signum(dY) * mReorderPreviewAnimationMagnitude;
Adam Cohen19f37922012-03-21 11:59:11 -07002146 } else {
2147 double angle = Math.atan( (float) (dY) / dX);
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002148 finalDeltaX = (int) (- dir * Math.signum(dX) *
2149 Math.abs(Math.cos(angle) * mReorderPreviewAnimationMagnitude));
2150 finalDeltaY = (int) (- dir * Math.signum(dY) *
2151 Math.abs(Math.sin(angle) * mReorderPreviewAnimationMagnitude));
Adam Cohen19f37922012-03-21 11:59:11 -07002152 }
2153 }
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002154 this.mode = mode;
Adam Cohend024f982012-05-23 18:26:45 -07002155 initDeltaX = child.getTranslationX();
2156 initDeltaY = child.getTranslationY();
Adam Cohen307fe232012-08-16 17:55:58 -07002157 finalScale = getChildrenScale() - 4.0f / child.getWidth();
Adam Cohend024f982012-05-23 18:26:45 -07002158 initScale = child.getScaleX();
Adam Cohen19f37922012-03-21 11:59:11 -07002159 this.child = child;
2160 }
2161
Adam Cohend024f982012-05-23 18:26:45 -07002162 void animate() {
Adam Cohen19f37922012-03-21 11:59:11 -07002163 if (mShakeAnimators.containsKey(child)) {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002164 ReorderPreviewAnimation oldAnimation = mShakeAnimators.get(child);
Adam Cohend024f982012-05-23 18:26:45 -07002165 oldAnimation.cancel();
Adam Cohen19f37922012-03-21 11:59:11 -07002166 mShakeAnimators.remove(child);
Adam Cohene7587d22012-05-24 18:50:02 -07002167 if (finalDeltaX == 0 && finalDeltaY == 0) {
2168 completeAnimationImmediately();
2169 return;
2170 }
Adam Cohen19f37922012-03-21 11:59:11 -07002171 }
Adam Cohend024f982012-05-23 18:26:45 -07002172 if (finalDeltaX == 0 && finalDeltaY == 0) {
Adam Cohen19f37922012-03-21 11:59:11 -07002173 return;
2174 }
Michael Jurkaf1ad6082013-03-13 12:55:46 +01002175 ValueAnimator va = LauncherAnimUtils.ofFloat(child, 0f, 1f);
Adam Cohene7587d22012-05-24 18:50:02 -07002176 a = va;
Tony Wickham489fc562015-09-02 14:45:39 -07002177
2178 // Animations are disabled in power save mode, causing the repeated animation to jump
2179 // spastically between beginning and end states. Since this looks bad, we don't repeat
2180 // the animation in power save mode.
2181 PowerManager powerManager = (PowerManager) getContext()
2182 .getSystemService(Context.POWER_SERVICE);
2183 boolean powerSaverOn = Utilities.ATLEAST_LOLLIPOP && powerManager.isPowerSaveMode();
2184 if (!powerSaverOn) {
2185 va.setRepeatMode(ValueAnimator.REVERSE);
2186 va.setRepeatCount(ValueAnimator.INFINITE);
2187 }
2188
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002189 va.setDuration(mode == MODE_HINT ? HINT_DURATION : PREVIEW_DURATION);
Adam Cohend024f982012-05-23 18:26:45 -07002190 va.setStartDelay((int) (Math.random() * 60));
Adam Cohen19f37922012-03-21 11:59:11 -07002191 va.addUpdateListener(new AnimatorUpdateListener() {
2192 @Override
2193 public void onAnimationUpdate(ValueAnimator animation) {
2194 float r = ((Float) animation.getAnimatedValue()).floatValue();
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002195 float r1 = (mode == MODE_HINT && repeating) ? 1.0f : r;
2196 float x = r1 * finalDeltaX + (1 - r1) * initDeltaX;
2197 float y = r1 * finalDeltaY + (1 - r1) * initDeltaY;
Adam Cohen19f37922012-03-21 11:59:11 -07002198 child.setTranslationX(x);
2199 child.setTranslationY(y);
Adam Cohend024f982012-05-23 18:26:45 -07002200 float s = r * finalScale + (1 - r) * initScale;
Brandon Keely50e6e562012-05-08 16:28:49 -07002201 child.setScaleX(s);
2202 child.setScaleY(s);
Adam Cohen19f37922012-03-21 11:59:11 -07002203 }
2204 });
2205 va.addListener(new AnimatorListenerAdapter() {
2206 public void onAnimationRepeat(Animator animation) {
Adam Cohen19f37922012-03-21 11:59:11 -07002207 // We make sure to end only after a full period
Adam Cohend024f982012-05-23 18:26:45 -07002208 initDeltaX = 0;
2209 initDeltaY = 0;
Adam Cohen307fe232012-08-16 17:55:58 -07002210 initScale = getChildrenScale();
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002211 repeating = true;
Adam Cohen19f37922012-03-21 11:59:11 -07002212 }
2213 });
Adam Cohen19f37922012-03-21 11:59:11 -07002214 mShakeAnimators.put(child, this);
2215 va.start();
2216 }
2217
Adam Cohend024f982012-05-23 18:26:45 -07002218 private void cancel() {
Adam Cohene7587d22012-05-24 18:50:02 -07002219 if (a != null) {
2220 a.cancel();
2221 }
Adam Cohen19f37922012-03-21 11:59:11 -07002222 }
Adam Cohene7587d22012-05-24 18:50:02 -07002223
Adam Cohen091440a2015-03-18 14:16:05 -07002224 @Thunk void completeAnimationImmediately() {
Adam Cohene7587d22012-05-24 18:50:02 -07002225 if (a != null) {
2226 a.cancel();
2227 }
Brandon Keely50e6e562012-05-08 16:28:49 -07002228
Michael Jurka2ecf9952012-06-18 12:52:28 -07002229 AnimatorSet s = LauncherAnimUtils.createAnimatorSet();
Adam Cohene7587d22012-05-24 18:50:02 -07002230 a = s;
Brandon Keely50e6e562012-05-08 16:28:49 -07002231 s.playTogether(
Adam Cohen307fe232012-08-16 17:55:58 -07002232 LauncherAnimUtils.ofFloat(child, "scaleX", getChildrenScale()),
2233 LauncherAnimUtils.ofFloat(child, "scaleY", getChildrenScale()),
Michael Jurka2ecf9952012-06-18 12:52:28 -07002234 LauncherAnimUtils.ofFloat(child, "translationX", 0f),
2235 LauncherAnimUtils.ofFloat(child, "translationY", 0f)
Brandon Keely50e6e562012-05-08 16:28:49 -07002236 );
2237 s.setDuration(REORDER_ANIMATION_DURATION);
2238 s.setInterpolator(new android.view.animation.DecelerateInterpolator(1.5f));
2239 s.start();
2240 }
Adam Cohen19f37922012-03-21 11:59:11 -07002241 }
2242
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002243 private void completeAndClearReorderPreviewAnimations() {
2244 for (ReorderPreviewAnimation a: mShakeAnimators.values()) {
Brandon Keely50e6e562012-05-08 16:28:49 -07002245 a.completeAnimationImmediately();
Adam Cohen19f37922012-03-21 11:59:11 -07002246 }
2247 mShakeAnimators.clear();
2248 }
2249
Adam Cohen482ed822012-03-02 14:15:13 -08002250 private void commitTempPlacement() {
2251 for (int i = 0; i < mCountX; i++) {
2252 for (int j = 0; j < mCountY; j++) {
2253 mOccupied[i][j] = mTmpOccupied[i][j];
2254 }
2255 }
Michael Jurkaa52570f2012-03-20 03:18:20 -07002256 int childCount = mShortcutsAndWidgets.getChildCount();
Adam Cohen482ed822012-03-02 14:15:13 -08002257 for (int i = 0; i < childCount; i++) {
Adam Cohenea889a22012-03-27 16:45:39 -07002258 View child = mShortcutsAndWidgets.getChildAt(i);
2259 LayoutParams lp = (LayoutParams) child.getLayoutParams();
2260 ItemInfo info = (ItemInfo) child.getTag();
Adam Cohen2acce882012-03-28 19:03:19 -07002261 // We do a null check here because the item info can be null in the case of the
2262 // AllApps button in the hotseat.
2263 if (info != null) {
Adam Cohen487f7dd2012-06-28 18:12:10 -07002264 if (info.cellX != lp.tmpCellX || info.cellY != lp.tmpCellY ||
2265 info.spanX != lp.cellHSpan || info.spanY != lp.cellVSpan) {
2266 info.requiresDbUpdate = true;
2267 }
Adam Cohen2acce882012-03-28 19:03:19 -07002268 info.cellX = lp.cellX = lp.tmpCellX;
2269 info.cellY = lp.cellY = lp.tmpCellY;
Adam Cohenbebf0422012-04-11 18:06:28 -07002270 info.spanX = lp.cellHSpan;
2271 info.spanY = lp.cellVSpan;
Adam Cohen2acce882012-03-28 19:03:19 -07002272 }
Adam Cohen482ed822012-03-02 14:15:13 -08002273 }
Adam Cohen2acce882012-03-28 19:03:19 -07002274 mLauncher.getWorkspace().updateItemLocationsInDatabase(this);
Adam Cohen482ed822012-03-02 14:15:13 -08002275 }
2276
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002277 private void setUseTempCoords(boolean useTempCoords) {
Michael Jurkaa52570f2012-03-20 03:18:20 -07002278 int childCount = mShortcutsAndWidgets.getChildCount();
Adam Cohen482ed822012-03-02 14:15:13 -08002279 for (int i = 0; i < childCount; i++) {
Michael Jurkaa52570f2012-03-20 03:18:20 -07002280 LayoutParams lp = (LayoutParams) mShortcutsAndWidgets.getChildAt(i).getLayoutParams();
Adam Cohen482ed822012-03-02 14:15:13 -08002281 lp.useTmpCoords = useTempCoords;
2282 }
2283 }
2284
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002285 private ItemConfiguration findConfigurationNoShuffle(int pixelX, int pixelY, int minSpanX, int minSpanY,
Adam Cohen482ed822012-03-02 14:15:13 -08002286 int spanX, int spanY, View dragView, ItemConfiguration solution) {
2287 int[] result = new int[2];
2288 int[] resultSpan = new int[2];
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002289 findNearestVacantArea(pixelX, pixelY, minSpanX, minSpanY, spanX, spanY, result,
Adam Cohen482ed822012-03-02 14:15:13 -08002290 resultSpan);
2291 if (result[0] >= 0 && result[1] >= 0) {
2292 copyCurrentStateToSolution(solution, false);
2293 solution.dragViewX = result[0];
2294 solution.dragViewY = result[1];
2295 solution.dragViewSpanX = resultSpan[0];
2296 solution.dragViewSpanY = resultSpan[1];
2297 solution.isSolution = true;
2298 } else {
2299 solution.isSolution = false;
2300 }
2301 return solution;
2302 }
2303
2304 public void prepareChildForDrag(View child) {
2305 markCellsAsUnoccupiedForView(child);
Adam Cohen482ed822012-03-02 14:15:13 -08002306 }
2307
Adam Cohen19f37922012-03-21 11:59:11 -07002308 /* This seems like it should be obvious and straight-forward, but when the direction vector
2309 needs to match with the notion of the dragView pushing other views, we have to employ
2310 a slightly more subtle notion of the direction vector. The question is what two points is
2311 the vector between? The center of the dragView and its desired destination? Not quite, as
2312 this doesn't necessarily coincide with the interaction of the dragView and items occupying
2313 those cells. Instead we use some heuristics to often lock the vector to up, down, left
2314 or right, which helps make pushing feel right.
2315 */
2316 private void getDirectionVectorForDrop(int dragViewCenterX, int dragViewCenterY, int spanX,
2317 int spanY, View dragView, int[] resultDirection) {
2318 int[] targetDestination = new int[2];
2319
2320 findNearestArea(dragViewCenterX, dragViewCenterY, spanX, spanY, targetDestination);
2321 Rect dragRect = new Rect();
2322 regionToRect(targetDestination[0], targetDestination[1], spanX, spanY, dragRect);
2323 dragRect.offset(dragViewCenterX - dragRect.centerX(), dragViewCenterY - dragRect.centerY());
2324
2325 Rect dropRegionRect = new Rect();
2326 getViewsIntersectingRegion(targetDestination[0], targetDestination[1], spanX, spanY,
2327 dragView, dropRegionRect, mIntersectingViews);
2328
2329 int dropRegionSpanX = dropRegionRect.width();
2330 int dropRegionSpanY = dropRegionRect.height();
2331
2332 regionToRect(dropRegionRect.left, dropRegionRect.top, dropRegionRect.width(),
2333 dropRegionRect.height(), dropRegionRect);
2334
2335 int deltaX = (dropRegionRect.centerX() - dragViewCenterX) / spanX;
2336 int deltaY = (dropRegionRect.centerY() - dragViewCenterY) / spanY;
2337
2338 if (dropRegionSpanX == mCountX || spanX == mCountX) {
2339 deltaX = 0;
2340 }
2341 if (dropRegionSpanY == mCountY || spanY == mCountY) {
2342 deltaY = 0;
2343 }
2344
2345 if (deltaX == 0 && deltaY == 0) {
2346 // No idea what to do, give a random direction.
2347 resultDirection[0] = 1;
2348 resultDirection[1] = 0;
2349 } else {
2350 computeDirectionVector(deltaX, deltaY, resultDirection);
2351 }
2352 }
2353
2354 // For a given cell and span, fetch the set of views intersecting the region.
2355 private void getViewsIntersectingRegion(int cellX, int cellY, int spanX, int spanY,
2356 View dragView, Rect boundingRect, ArrayList<View> intersectingViews) {
2357 if (boundingRect != null) {
2358 boundingRect.set(cellX, cellY, cellX + spanX, cellY + spanY);
2359 }
2360 intersectingViews.clear();
2361 Rect r0 = new Rect(cellX, cellY, cellX + spanX, cellY + spanY);
2362 Rect r1 = new Rect();
2363 final int count = mShortcutsAndWidgets.getChildCount();
2364 for (int i = 0; i < count; i++) {
2365 View child = mShortcutsAndWidgets.getChildAt(i);
2366 if (child == dragView) continue;
2367 LayoutParams lp = (LayoutParams) child.getLayoutParams();
2368 r1.set(lp.cellX, lp.cellY, lp.cellX + lp.cellHSpan, lp.cellY + lp.cellVSpan);
2369 if (Rect.intersects(r0, r1)) {
2370 mIntersectingViews.add(child);
2371 if (boundingRect != null) {
2372 boundingRect.union(r1);
2373 }
2374 }
2375 }
2376 }
2377
2378 boolean isNearestDropLocationOccupied(int pixelX, int pixelY, int spanX, int spanY,
2379 View dragView, int[] result) {
2380 result = findNearestArea(pixelX, pixelY, spanX, spanY, result);
2381 getViewsIntersectingRegion(result[0], result[1], spanX, spanY, dragView, null,
2382 mIntersectingViews);
2383 return !mIntersectingViews.isEmpty();
2384 }
2385
2386 void revertTempState() {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002387 completeAndClearReorderPreviewAnimations();
2388 if (isItemPlacementDirty() && !DESTRUCTIVE_REORDER) {
2389 final int count = mShortcutsAndWidgets.getChildCount();
2390 for (int i = 0; i < count; i++) {
2391 View child = mShortcutsAndWidgets.getChildAt(i);
2392 LayoutParams lp = (LayoutParams) child.getLayoutParams();
2393 if (lp.tmpCellX != lp.cellX || lp.tmpCellY != lp.cellY) {
2394 lp.tmpCellX = lp.cellX;
2395 lp.tmpCellY = lp.cellY;
2396 animateChildToPosition(child, lp.cellX, lp.cellY, REORDER_ANIMATION_DURATION,
2397 0, false, false);
2398 }
Adam Cohen19f37922012-03-21 11:59:11 -07002399 }
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002400 setItemPlacementDirty(false);
Adam Cohen19f37922012-03-21 11:59:11 -07002401 }
Adam Cohen19f37922012-03-21 11:59:11 -07002402 }
2403
Adam Cohenbebf0422012-04-11 18:06:28 -07002404 boolean createAreaForResize(int cellX, int cellY, int spanX, int spanY,
2405 View dragView, int[] direction, boolean commit) {
2406 int[] pixelXY = new int[2];
2407 regionToCenterPoint(cellX, cellY, spanX, spanY, pixelXY);
2408
2409 // First we determine if things have moved enough to cause a different layout
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002410 ItemConfiguration swapSolution = findReorderSolution(pixelXY[0], pixelXY[1], spanX, spanY,
Adam Cohenbebf0422012-04-11 18:06:28 -07002411 spanX, spanY, direction, dragView, true, new ItemConfiguration());
2412
2413 setUseTempCoords(true);
2414 if (swapSolution != null && swapSolution.isSolution) {
2415 // If we're just testing for a possible location (MODE_ACCEPT_DROP), we don't bother
2416 // committing anything or animating anything as we just want to determine if a solution
2417 // exists
2418 copySolutionToTempState(swapSolution, dragView);
2419 setItemPlacementDirty(true);
2420 animateItemsToSolution(swapSolution, dragView, commit);
2421
2422 if (commit) {
2423 commitTempPlacement();
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002424 completeAndClearReorderPreviewAnimations();
Adam Cohenbebf0422012-04-11 18:06:28 -07002425 setItemPlacementDirty(false);
2426 } else {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002427 beginOrAdjustReorderPreviewAnimations(swapSolution, dragView,
2428 REORDER_ANIMATION_DURATION, ReorderPreviewAnimation.MODE_PREVIEW);
Adam Cohenbebf0422012-04-11 18:06:28 -07002429 }
2430 mShortcutsAndWidgets.requestLayout();
2431 }
2432 return swapSolution.isSolution;
2433 }
2434
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002435 int[] performReorder(int pixelX, int pixelY, int minSpanX, int minSpanY, int spanX, int spanY,
Adam Cohen482ed822012-03-02 14:15:13 -08002436 View dragView, int[] result, int resultSpan[], int mode) {
Adam Cohen482ed822012-03-02 14:15:13 -08002437 // First we determine if things have moved enough to cause a different layout
Adam Cohen47a876d2012-03-19 13:21:41 -07002438 result = findNearestArea(pixelX, pixelY, spanX, spanY, result);
Adam Cohen482ed822012-03-02 14:15:13 -08002439
2440 if (resultSpan == null) {
2441 resultSpan = new int[2];
2442 }
2443
Adam Cohen19f37922012-03-21 11:59:11 -07002444 // When we are checking drop validity or actually dropping, we don't recompute the
2445 // direction vector, since we want the solution to match the preview, and it's possible
2446 // that the exact position of the item has changed to result in a new reordering outcome.
Adam Cohenb209e632012-03-27 17:09:36 -07002447 if ((mode == MODE_ON_DROP || mode == MODE_ON_DROP_EXTERNAL || mode == MODE_ACCEPT_DROP)
2448 && mPreviousReorderDirection[0] != INVALID_DIRECTION) {
Adam Cohen19f37922012-03-21 11:59:11 -07002449 mDirectionVector[0] = mPreviousReorderDirection[0];
2450 mDirectionVector[1] = mPreviousReorderDirection[1];
2451 // We reset this vector after drop
Adam Cohenb209e632012-03-27 17:09:36 -07002452 if (mode == MODE_ON_DROP || mode == MODE_ON_DROP_EXTERNAL) {
2453 mPreviousReorderDirection[0] = INVALID_DIRECTION;
2454 mPreviousReorderDirection[1] = INVALID_DIRECTION;
Adam Cohen19f37922012-03-21 11:59:11 -07002455 }
2456 } else {
2457 getDirectionVectorForDrop(pixelX, pixelY, spanX, spanY, dragView, mDirectionVector);
2458 mPreviousReorderDirection[0] = mDirectionVector[0];
2459 mPreviousReorderDirection[1] = mDirectionVector[1];
2460 }
2461
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002462 // Find a solution involving pushing / displacing any items in the way
2463 ItemConfiguration swapSolution = findReorderSolution(pixelX, pixelY, minSpanX, minSpanY,
Adam Cohen482ed822012-03-02 14:15:13 -08002464 spanX, spanY, mDirectionVector, dragView, true, new ItemConfiguration());
2465
2466 // We attempt the approach which doesn't shuffle views at all
2467 ItemConfiguration noShuffleSolution = findConfigurationNoShuffle(pixelX, pixelY, minSpanX,
2468 minSpanY, spanX, spanY, dragView, new ItemConfiguration());
2469
2470 ItemConfiguration finalSolution = null;
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002471
2472 // If the reorder solution requires resizing (shrinking) the item being dropped, we instead
2473 // favor a solution in which the item is not resized, but
Adam Cohen482ed822012-03-02 14:15:13 -08002474 if (swapSolution.isSolution && swapSolution.area() >= noShuffleSolution.area()) {
2475 finalSolution = swapSolution;
2476 } else if (noShuffleSolution.isSolution) {
2477 finalSolution = noShuffleSolution;
2478 }
2479
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002480 if (mode == MODE_SHOW_REORDER_HINT) {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002481 if (finalSolution != null) {
Adam Cohenfe692872013-12-11 14:47:23 -08002482 beginOrAdjustReorderPreviewAnimations(finalSolution, dragView, 0,
2483 ReorderPreviewAnimation.MODE_HINT);
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002484 result[0] = finalSolution.dragViewX;
2485 result[1] = finalSolution.dragViewY;
2486 resultSpan[0] = finalSolution.dragViewSpanX;
2487 resultSpan[1] = finalSolution.dragViewSpanY;
2488 } else {
2489 result[0] = result[1] = resultSpan[0] = resultSpan[1] = -1;
2490 }
2491 return result;
2492 }
2493
Adam Cohen482ed822012-03-02 14:15:13 -08002494 boolean foundSolution = true;
2495 if (!DESTRUCTIVE_REORDER) {
2496 setUseTempCoords(true);
2497 }
2498
2499 if (finalSolution != null) {
2500 result[0] = finalSolution.dragViewX;
2501 result[1] = finalSolution.dragViewY;
2502 resultSpan[0] = finalSolution.dragViewSpanX;
2503 resultSpan[1] = finalSolution.dragViewSpanY;
2504
2505 // If we're just testing for a possible location (MODE_ACCEPT_DROP), we don't bother
2506 // committing anything or animating anything as we just want to determine if a solution
2507 // exists
2508 if (mode == MODE_DRAG_OVER || mode == MODE_ON_DROP || mode == MODE_ON_DROP_EXTERNAL) {
2509 if (!DESTRUCTIVE_REORDER) {
2510 copySolutionToTempState(finalSolution, dragView);
2511 }
2512 setItemPlacementDirty(true);
2513 animateItemsToSolution(finalSolution, dragView, mode == MODE_ON_DROP);
2514
Adam Cohen19f37922012-03-21 11:59:11 -07002515 if (!DESTRUCTIVE_REORDER &&
2516 (mode == MODE_ON_DROP || mode == MODE_ON_DROP_EXTERNAL)) {
Adam Cohen482ed822012-03-02 14:15:13 -08002517 commitTempPlacement();
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002518 completeAndClearReorderPreviewAnimations();
Adam Cohen19f37922012-03-21 11:59:11 -07002519 setItemPlacementDirty(false);
2520 } else {
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002521 beginOrAdjustReorderPreviewAnimations(finalSolution, dragView,
2522 REORDER_ANIMATION_DURATION, ReorderPreviewAnimation.MODE_PREVIEW);
Adam Cohen482ed822012-03-02 14:15:13 -08002523 }
2524 }
2525 } else {
2526 foundSolution = false;
2527 result[0] = result[1] = resultSpan[0] = resultSpan[1] = -1;
2528 }
2529
2530 if ((mode == MODE_ON_DROP || !foundSolution) && !DESTRUCTIVE_REORDER) {
2531 setUseTempCoords(false);
2532 }
Adam Cohen482ed822012-03-02 14:15:13 -08002533
Michael Jurkaa52570f2012-03-20 03:18:20 -07002534 mShortcutsAndWidgets.requestLayout();
Adam Cohen482ed822012-03-02 14:15:13 -08002535 return result;
2536 }
2537
Adam Cohen19f37922012-03-21 11:59:11 -07002538 void setItemPlacementDirty(boolean dirty) {
2539 mItemPlacementDirty = dirty;
Adam Cohen482ed822012-03-02 14:15:13 -08002540 }
Adam Cohen19f37922012-03-21 11:59:11 -07002541 boolean isItemPlacementDirty() {
2542 return mItemPlacementDirty;
Adam Cohen482ed822012-03-02 14:15:13 -08002543 }
2544
Adam Cohen091440a2015-03-18 14:16:05 -07002545 @Thunk class ItemConfiguration {
Adam Cohen8baab352012-03-20 17:39:21 -07002546 HashMap<View, CellAndSpan> map = new HashMap<View, CellAndSpan>();
Adam Cohenf3900c22012-11-16 18:28:11 -08002547 private HashMap<View, CellAndSpan> savedMap = new HashMap<View, CellAndSpan>();
2548 ArrayList<View> sortedViews = new ArrayList<View>();
Adam Cohenfa3c58f2013-12-06 16:10:55 -08002549 ArrayList<View> intersectingViews;
Adam Cohen482ed822012-03-02 14:15:13 -08002550 boolean isSolution = false;
2551 int dragViewX, dragViewY, dragViewSpanX, dragViewSpanY;
2552
Adam Cohenf3900c22012-11-16 18:28:11 -08002553 void save() {
2554 // Copy current state into savedMap
2555 for (View v: map.keySet()) {
2556 map.get(v).copy(savedMap.get(v));
2557 }
2558 }
2559
2560 void restore() {
2561 // Restore current state from savedMap
2562 for (View v: savedMap.keySet()) {
2563 savedMap.get(v).copy(map.get(v));
2564 }
2565 }
2566
2567 void add(View v, CellAndSpan cs) {
2568 map.put(v, cs);
2569 savedMap.put(v, new CellAndSpan());
2570 sortedViews.add(v);
2571 }
2572
Adam Cohen482ed822012-03-02 14:15:13 -08002573 int area() {
2574 return dragViewSpanX * dragViewSpanY;
2575 }
Adam Cohen8baab352012-03-20 17:39:21 -07002576 }
2577
2578 private class CellAndSpan {
2579 int x, y;
2580 int spanX, spanY;
2581
Adam Cohenf3900c22012-11-16 18:28:11 -08002582 public CellAndSpan() {
2583 }
2584
2585 public void copy(CellAndSpan copy) {
2586 copy.x = x;
2587 copy.y = y;
2588 copy.spanX = spanX;
2589 copy.spanY = spanY;
2590 }
2591
Adam Cohen8baab352012-03-20 17:39:21 -07002592 public CellAndSpan(int x, int y, int spanX, int spanY) {
2593 this.x = x;
2594 this.y = y;
2595 this.spanX = spanX;
2596 this.spanY = spanY;
Adam Cohen482ed822012-03-02 14:15:13 -08002597 }
Adam Cohenf3900c22012-11-16 18:28:11 -08002598
2599 public String toString() {
2600 return "(" + x + ", " + y + ": " + spanX + ", " + spanY + ")";
2601 }
2602
Adam Cohen482ed822012-03-02 14:15:13 -08002603 }
2604
Adam Cohendf035382011-04-11 17:22:04 -07002605 /**
Adam Cohendf035382011-04-11 17:22:04 -07002606 * Find a starting cell position that will fit the given bounds nearest the requested
2607 * cell location. Uses Euclidean distance to score multiple vacant areas.
2608 *
2609 * @param pixelX The X location at which you want to search for a vacant area.
2610 * @param pixelY The Y location at which you want to search for a vacant area.
2611 * @param spanX Horizontal span of the object.
2612 * @param spanY Vertical span of the object.
2613 * @param ignoreView Considers space occupied by this view as unoccupied
2614 * @param result Previously returned value to possibly recycle.
2615 * @return The X, Y cell of a vacant area that can contain this object,
2616 * nearest the requested location.
2617 */
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002618 int[] findNearestArea(int pixelX, int pixelY, int spanX, int spanY, int[] result) {
2619 return findNearestArea(pixelX, pixelY, spanX, spanY, spanX, spanY, false, result, null);
Adam Cohendf035382011-04-11 17:22:04 -07002620 }
2621
Michael Jurka0280c3b2010-09-17 15:00:07 -07002622 boolean existsEmptyCell() {
2623 return findCellForSpan(null, 1, 1);
2624 }
2625
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002626 /**
Michael Jurka0280c3b2010-09-17 15:00:07 -07002627 * Finds the upper-left coordinate of the first rectangle in the grid that can
2628 * hold a cell of the specified dimensions. If intersectX and intersectY are not -1,
2629 * then this method will only return coordinates for rectangles that contain the cell
2630 * (intersectX, intersectY)
2631 *
2632 * @param cellXY The array that will contain the position of a vacant cell if such a cell
2633 * can be found.
2634 * @param spanX The horizontal span of the cell we want to find.
2635 * @param spanY The vertical span of the cell we want to find.
2636 *
2637 * @return True if a vacant cell of the specified dimension was found, false otherwise.
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07002638 */
Hyunyoung Song3f471442015-04-08 19:01:34 -07002639 public boolean findCellForSpan(int[] cellXY, int spanX, int spanY) {
Michael Jurka28750fb2010-09-24 17:43:49 -07002640 boolean foundCell = false;
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002641 final int endX = mCountX - (spanX - 1);
2642 final int endY = mCountY - (spanY - 1);
Michael Jurka0280c3b2010-09-17 15:00:07 -07002643
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002644 for (int y = 0; y < endY && !foundCell; y++) {
2645 inner:
2646 for (int x = 0; x < endX; x++) {
2647 for (int i = 0; i < spanX; i++) {
2648 for (int j = 0; j < spanY; j++) {
2649 if (mOccupied[x + i][y + j]) {
2650 // small optimization: we can skip to after the column we just found
2651 // an occupied cell
2652 x += i;
2653 continue inner;
Michael Jurka0280c3b2010-09-17 15:00:07 -07002654 }
2655 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07002656 }
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002657 if (cellXY != null) {
2658 cellXY[0] = x;
2659 cellXY[1] = y;
2660 }
2661 foundCell = true;
Michael Jurka0280c3b2010-09-17 15:00:07 -07002662 break;
Michael Jurka0280c3b2010-09-17 15:00:07 -07002663 }
2664 }
2665
Michael Jurka28750fb2010-09-24 17:43:49 -07002666 return foundCell;
Michael Jurka0280c3b2010-09-17 15:00:07 -07002667 }
2668
2669 /**
Winson Chungc07918d2011-07-01 15:35:26 -07002670 * A drag event has begun over this layout.
2671 * It may have begun over this layout (in which case onDragChild is called first),
2672 * or it may have begun on another layout.
2673 */
2674 void onDragEnter() {
Winson Chungc07918d2011-07-01 15:35:26 -07002675 mDragging = true;
2676 }
2677
2678 /**
Michael Jurka0280c3b2010-09-17 15:00:07 -07002679 * Called when drag has left this CellLayout or has been completed (successfully or not)
2680 */
2681 void onDragExit() {
Joe Onorato4be866d2010-10-10 11:26:02 -07002682 // This can actually be called when we aren't in a drag, e.g. when adding a new
2683 // item to this layout via the customize drawer.
2684 // Guard against that case.
2685 if (mDragging) {
2686 mDragging = false;
Patrick Dubroyde7658b2010-09-27 11:15:43 -07002687 }
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07002688
2689 // Invalidate the drag data
Adam Cohend41fbf52012-02-16 23:53:59 -08002690 mDragCell[0] = mDragCell[1] = -1;
Patrick Dubroy08ae2ec2010-10-14 23:54:22 -07002691 mDragOutlineAnims[mDragOutlineCurrent].animateOut();
2692 mDragOutlineCurrent = (mDragOutlineCurrent + 1) % mDragOutlineAnims.length;
Adam Cohen19f37922012-03-21 11:59:11 -07002693 revertTempState();
Michael Jurka33945b22010-12-21 18:19:38 -08002694 setIsDragOverlapping(false);
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07002695 }
2696
2697 /**
Winson Chungaafa03c2010-06-11 17:34:16 -07002698 * Mark a child as having been dropped.
Patrick Dubroyde7658b2010-09-27 11:15:43 -07002699 * At the beginning of the drag operation, the child may have been on another
Patrick Dubroyce34a972010-10-19 10:34:32 -07002700 * screen, but it is re-parented before this method is called.
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002701 *
2702 * @param child The child that is being dropped
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002703 */
Adam Cohen716b51e2011-06-30 12:09:54 -07002704 void onDropChild(View child) {
Romain Guyd94533d2009-08-17 10:01:15 -07002705 if (child != null) {
2706 LayoutParams lp = (LayoutParams) child.getLayoutParams();
Romain Guy84f296c2009-11-04 15:00:44 -08002707 lp.dropped = true;
Romain Guyd94533d2009-08-17 10:01:15 -07002708 child.requestLayout();
Tony Wickham1cdb6d02015-09-17 11:08:27 -07002709 markCellsAsOccupiedForView(child);
Romain Guyd94533d2009-08-17 10:01:15 -07002710 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002711 }
2712
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002713 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002714 * Computes a bounding rectangle for a range of cells
Winson Chungaafa03c2010-06-11 17:34:16 -07002715 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002716 * @param cellX X coordinate of upper left corner expressed as a cell position
2717 * @param cellY Y coordinate of upper left corner expressed as a cell position
Winson Chungaafa03c2010-06-11 17:34:16 -07002718 * @param cellHSpan Width in cells
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002719 * @param cellVSpan Height in cells
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07002720 * @param resultRect Rect into which to put the results
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002721 */
Adam Cohend41fbf52012-02-16 23:53:59 -08002722 public void cellToRect(int cellX, int cellY, int cellHSpan, int cellVSpan, Rect resultRect) {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002723 final int cellWidth = mCellWidth;
2724 final int cellHeight = mCellHeight;
2725 final int widthGap = mWidthGap;
2726 final int heightGap = mHeightGap;
Winson Chungaafa03c2010-06-11 17:34:16 -07002727
Winson Chung4b825dcd2011-06-19 12:41:22 -07002728 final int hStartPadding = getPaddingLeft();
2729 final int vStartPadding = getPaddingTop();
Winson Chungaafa03c2010-06-11 17:34:16 -07002730
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002731 int width = cellHSpan * cellWidth + ((cellHSpan - 1) * widthGap);
2732 int height = cellVSpan * cellHeight + ((cellVSpan - 1) * heightGap);
2733
2734 int x = hStartPadding + cellX * (cellWidth + widthGap);
2735 int y = vStartPadding + cellY * (cellHeight + heightGap);
Winson Chungaafa03c2010-06-11 17:34:16 -07002736
Patrick Dubroy6569f2c2010-07-12 14:25:18 -07002737 resultRect.set(x, y, x + width, y + height);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002738 }
Winson Chungaafa03c2010-06-11 17:34:16 -07002739
Michael Jurka0280c3b2010-09-17 15:00:07 -07002740 private void clearOccupiedCells() {
2741 for (int x = 0; x < mCountX; x++) {
2742 for (int y = 0; y < mCountY; y++) {
2743 mOccupied[x][y] = false;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002744 }
2745 }
Michael Jurka0280c3b2010-09-17 15:00:07 -07002746 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002747
Adam Cohend4844c32011-02-18 19:25:06 -08002748 public void markCellsAsOccupiedForView(View view) {
Michael Jurkaa52570f2012-03-20 03:18:20 -07002749 if (view == null || view.getParent() != mShortcutsAndWidgets) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07002750 LayoutParams lp = (LayoutParams) view.getLayoutParams();
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002751 markCellsForView(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan, mOccupied, true);
Michael Jurka0280c3b2010-09-17 15:00:07 -07002752 }
2753
Adam Cohend4844c32011-02-18 19:25:06 -08002754 public void markCellsAsUnoccupiedForView(View view) {
Michael Jurkaa52570f2012-03-20 03:18:20 -07002755 if (view == null || view.getParent() != mShortcutsAndWidgets) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07002756 LayoutParams lp = (LayoutParams) view.getLayoutParams();
Sunny Goyalf7a29e82015-04-24 15:20:43 -07002757 markCellsForView(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan, mOccupied, false);
Michael Jurka0280c3b2010-09-17 15:00:07 -07002758 }
2759
Adam Cohen482ed822012-03-02 14:15:13 -08002760 private void markCellsForView(int cellX, int cellY, int spanX, int spanY, boolean[][] occupied,
2761 boolean value) {
2762 if (cellX < 0 || cellY < 0) return;
Michael Jurka0280c3b2010-09-17 15:00:07 -07002763 for (int x = cellX; x < cellX + spanX && x < mCountX; x++) {
2764 for (int y = cellY; y < cellY + spanY && y < mCountY; y++) {
Adam Cohen482ed822012-03-02 14:15:13 -08002765 occupied[x][y] = value;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002766 }
2767 }
2768 }
2769
Adam Cohen2801caf2011-05-13 20:57:39 -07002770 public int getDesiredWidth() {
Michael Jurka8b805b12012-04-18 14:23:14 -07002771 return getPaddingLeft() + getPaddingRight() + (mCountX * mCellWidth) +
Adam Cohen2801caf2011-05-13 20:57:39 -07002772 (Math.max((mCountX - 1), 0) * mWidthGap);
2773 }
2774
2775 public int getDesiredHeight() {
Michael Jurka8b805b12012-04-18 14:23:14 -07002776 return getPaddingTop() + getPaddingBottom() + (mCountY * mCellHeight) +
Adam Cohen2801caf2011-05-13 20:57:39 -07002777 (Math.max((mCountY - 1), 0) * mHeightGap);
2778 }
2779
Michael Jurka66d72172011-04-12 16:29:25 -07002780 public boolean isOccupied(int x, int y) {
2781 if (x < mCountX && y < mCountY) {
2782 return mOccupied[x][y];
2783 } else {
2784 throw new RuntimeException("Position exceeds the bound of this CellLayout");
2785 }
2786 }
2787
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002788 @Override
2789 public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
2790 return new CellLayout.LayoutParams(getContext(), attrs);
2791 }
2792
2793 @Override
2794 protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
2795 return p instanceof CellLayout.LayoutParams;
2796 }
2797
2798 @Override
2799 protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
2800 return new CellLayout.LayoutParams(p);
2801 }
2802
2803 public static class LayoutParams extends ViewGroup.MarginLayoutParams {
2804 /**
2805 * Horizontal location of the item in the grid.
2806 */
2807 @ViewDebug.ExportedProperty
2808 public int cellX;
2809
2810 /**
2811 * Vertical location of the item in the grid.
2812 */
2813 @ViewDebug.ExportedProperty
2814 public int cellY;
2815
2816 /**
Adam Cohen482ed822012-03-02 14:15:13 -08002817 * Temporary horizontal location of the item in the grid during reorder
2818 */
2819 public int tmpCellX;
2820
2821 /**
2822 * Temporary vertical location of the item in the grid during reorder
2823 */
2824 public int tmpCellY;
2825
2826 /**
2827 * Indicates that the temporary coordinates should be used to layout the items
2828 */
2829 public boolean useTmpCoords;
2830
2831 /**
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002832 * Number of cells spanned horizontally by the item.
2833 */
2834 @ViewDebug.ExportedProperty
2835 public int cellHSpan;
2836
2837 /**
2838 * Number of cells spanned vertically by the item.
2839 */
2840 @ViewDebug.ExportedProperty
2841 public int cellVSpan;
Winson Chungaafa03c2010-06-11 17:34:16 -07002842
Adam Cohen1b607ed2011-03-03 17:26:50 -08002843 /**
2844 * Indicates whether the item will set its x, y, width and height parameters freely,
2845 * or whether these will be computed based on cellX, cellY, cellHSpan and cellVSpan.
2846 */
Adam Cohend4844c32011-02-18 19:25:06 -08002847 public boolean isLockedToGrid = true;
2848
Adam Cohen482ed822012-03-02 14:15:13 -08002849 /**
Adam Cohenec40b2b2013-07-23 15:52:40 -07002850 * Indicates that this item should use the full extents of its parent.
2851 */
2852 public boolean isFullscreen = false;
2853
2854 /**
Adam Cohen482ed822012-03-02 14:15:13 -08002855 * Indicates whether this item can be reordered. Always true except in the case of the
2856 * the AllApps button.
2857 */
2858 public boolean canReorder = true;
2859
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002860 // X coordinate of the view in the layout.
2861 @ViewDebug.ExportedProperty
2862 int x;
2863 // Y coordinate of the view in the layout.
2864 @ViewDebug.ExportedProperty
2865 int y;
2866
Romain Guy84f296c2009-11-04 15:00:44 -08002867 boolean dropped;
Romain Guyfcb9e712009-10-02 16:06:52 -07002868
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002869 public LayoutParams(Context c, AttributeSet attrs) {
2870 super(c, attrs);
2871 cellHSpan = 1;
2872 cellVSpan = 1;
2873 }
2874
2875 public LayoutParams(ViewGroup.LayoutParams source) {
2876 super(source);
2877 cellHSpan = 1;
2878 cellVSpan = 1;
2879 }
Winson Chungaafa03c2010-06-11 17:34:16 -07002880
2881 public LayoutParams(LayoutParams source) {
2882 super(source);
2883 this.cellX = source.cellX;
2884 this.cellY = source.cellY;
2885 this.cellHSpan = source.cellHSpan;
2886 this.cellVSpan = source.cellVSpan;
2887 }
2888
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002889 public LayoutParams(int cellX, int cellY, int cellHSpan, int cellVSpan) {
Romain Guy8f19cdd2010-01-08 15:07:00 -08002890 super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002891 this.cellX = cellX;
2892 this.cellY = cellY;
2893 this.cellHSpan = cellHSpan;
2894 this.cellVSpan = cellVSpan;
2895 }
2896
Adam Cohen2374abf2013-04-16 14:56:57 -07002897 public void setup(int cellWidth, int cellHeight, int widthGap, int heightGap,
2898 boolean invertHorizontally, int colCount) {
Adam Cohend4844c32011-02-18 19:25:06 -08002899 if (isLockedToGrid) {
2900 final int myCellHSpan = cellHSpan;
2901 final int myCellVSpan = cellVSpan;
Adam Cohen2374abf2013-04-16 14:56:57 -07002902 int myCellX = useTmpCoords ? tmpCellX : cellX;
2903 int myCellY = useTmpCoords ? tmpCellY : cellY;
2904
2905 if (invertHorizontally) {
2906 myCellX = colCount - myCellX - cellHSpan;
2907 }
Adam Cohen1b607ed2011-03-03 17:26:50 -08002908
Adam Cohend4844c32011-02-18 19:25:06 -08002909 width = myCellHSpan * cellWidth + ((myCellHSpan - 1) * widthGap) -
2910 leftMargin - rightMargin;
2911 height = myCellVSpan * cellHeight + ((myCellVSpan - 1) * heightGap) -
2912 topMargin - bottomMargin;
Winson Chungeecf02d2012-03-02 17:14:58 -08002913 x = (int) (myCellX * (cellWidth + widthGap) + leftMargin);
2914 y = (int) (myCellY * (cellHeight + heightGap) + topMargin);
Adam Cohend4844c32011-02-18 19:25:06 -08002915 }
2916 }
Winson Chungaafa03c2010-06-11 17:34:16 -07002917
Winson Chungaafa03c2010-06-11 17:34:16 -07002918 public String toString() {
2919 return "(" + this.cellX + ", " + this.cellY + ")";
2920 }
Adam Cohen7f4eabe2011-04-21 16:19:16 -07002921
2922 public void setWidth(int width) {
2923 this.width = width;
2924 }
2925
2926 public int getWidth() {
2927 return width;
2928 }
2929
2930 public void setHeight(int height) {
2931 this.height = height;
2932 }
2933
2934 public int getHeight() {
2935 return height;
2936 }
2937
2938 public void setX(int x) {
2939 this.x = x;
2940 }
2941
2942 public int getX() {
2943 return x;
2944 }
2945
2946 public void setY(int y) {
2947 this.y = y;
2948 }
2949
2950 public int getY() {
2951 return y;
2952 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002953 }
2954
Michael Jurka0280c3b2010-09-17 15:00:07 -07002955 // This class stores info for two purposes:
2956 // 1. When dragging items (mDragInfo in Workspace), we store the View, its cellX & cellY,
2957 // its spanX, spanY, and the screen it is on
2958 // 2. When long clicking on an empty cell in a CellLayout, we save information about the
2959 // cellX and cellY coordinates and which page was clicked. We then set this as a tag on
2960 // the CellLayout that was long clicked
Sunny Goyal83a8f042015-05-19 12:52:12 -07002961 public static final class CellInfo {
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002962 View cell;
Michael Jurkaa63c4522010-08-19 13:52:27 -07002963 int cellX = -1;
2964 int cellY = -1;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002965 int spanX;
2966 int spanY;
Adam Cohendcd297f2013-06-18 13:13:40 -07002967 long screenId;
Winson Chung3d503fb2011-07-13 17:25:49 -07002968 long container;
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002969
Sunny Goyal83a8f042015-05-19 12:52:12 -07002970 public CellInfo(View v, ItemInfo info) {
Adam Cohene0aaa0d2014-05-12 12:44:22 -07002971 cell = v;
2972 cellX = info.cellX;
2973 cellY = info.cellY;
2974 spanX = info.spanX;
2975 spanY = info.spanY;
2976 screenId = info.screenId;
2977 container = info.container;
2978 }
2979
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002980 @Override
2981 public String toString() {
Winson Chungaafa03c2010-06-11 17:34:16 -07002982 return "Cell[view=" + (cell == null ? "null" : cell.getClass())
2983 + ", x=" + cellX + ", y=" + cellY + "]";
The Android Open Source Project31dd5032009-03-03 19:32:27 -08002984 }
2985 }
Michael Jurkad771c962011-08-09 15:00:48 -07002986
Sunny Goyala9116722015-04-29 13:55:58 -07002987 public boolean findVacantCell(int spanX, int spanY, int[] outXY) {
2988 return Utilities.findVacantCell(outXY, spanX, spanY, mCountX, mCountY, mOccupied);
2989 }
Sunny Goyal9ca9c132015-04-29 14:57:22 -07002990
2991 public boolean isRegionVacant(int x, int y, int spanX, int spanY) {
2992 int x2 = x + spanX - 1;
2993 int y2 = y + spanY - 1;
2994 if (x < 0 || y < 0 || x2 >= mCountX || y2 >= mCountY) {
2995 return false;
2996 }
2997 for (int i = x; i <= x2; i++) {
2998 for (int j = y; j <= y2; j++) {
2999 if (mOccupied[i][j]) {
3000 return false;
3001 }
3002 }
3003 }
3004
3005 return true;
3006 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08003007}