blob: fcaf020372db6f81eb680664e11b978df1e07c9b [file] [log] [blame]
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Joe Onoratoa5902522009-07-30 13:37:37 -070017package com.android.launcher2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080018
Adam Cohendf2cc412011-04-27 16:56:57 -070019import android.animation.Animator;
20import android.animation.AnimatorListenerAdapter;
Adam Cohendf2cc412011-04-27 16:56:57 -070021import android.animation.ObjectAnimator;
22import android.animation.PropertyValuesHolder;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080023import android.content.Context;
Adam Cohen76fc0852011-06-17 13:26:23 -070024import android.content.res.Resources;
Winson Chung043f2af2012-03-01 16:09:54 -080025import android.graphics.PointF;
Romain Guyfb5411e2010-02-24 10:04:17 -080026import android.graphics.Rect;
Adam Cohenbadf71e2011-05-26 19:08:29 -070027import android.graphics.drawable.Drawable;
Adam Cohen7a14d0b2011-06-24 11:36:35 -070028import android.text.InputType;
Adam Cohene601a432011-07-26 21:51:30 -070029import android.text.Selection;
30import android.text.Spannable;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080031import android.util.AttributeSet;
Adam Cohen76fc0852011-06-17 13:26:23 -070032import android.view.ActionMode;
33import android.view.KeyEvent;
Adam Cohendf2cc412011-04-27 16:56:57 -070034import android.view.LayoutInflater;
Adam Cohen76fc0852011-06-17 13:26:23 -070035import android.view.Menu;
36import android.view.MenuItem;
Adam Cohen0c872ba2011-05-05 10:34:16 -070037import android.view.MotionEvent;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080038import android.view.View;
Adam Cohen3371da02011-10-25 21:38:29 -070039import android.view.accessibility.AccessibilityEvent;
40import android.view.accessibility.AccessibilityManager;
Adam Cohen76fc0852011-06-17 13:26:23 -070041import android.view.inputmethod.EditorInfo;
42import android.view.inputmethod.InputMethodManager;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080043import android.widget.LinearLayout;
Adam Cohendf2cc412011-04-27 16:56:57 -070044import android.widget.TextView;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080045
Romain Guyedcce092010-03-04 13:03:17 -080046import com.android.launcher.R;
Adam Cohena9cf38f2011-05-02 15:36:58 -070047import com.android.launcher2.FolderInfo.FolderListener;
Romain Guyedcce092010-03-04 13:03:17 -080048
Adam Cohenc0dcf592011-06-01 15:30:43 -070049import java.util.ArrayList;
50
The Android Open Source Project31dd5032009-03-03 19:32:27 -080051/**
52 * Represents a set of icons chosen by the user or generated by the system.
53 */
Adam Cohen8dfcba42011-07-07 16:38:18 -070054public class Folder extends LinearLayout implements DragSource, View.OnClickListener,
Adam Cohenea0818d2011-09-30 20:06:58 -070055 View.OnLongClickListener, DropTarget, FolderListener, TextView.OnEditorActionListener,
56 View.OnFocusChangeListener {
The Android Open Source Project31dd5032009-03-03 19:32:27 -080057
Michael Jurka3a9fced2012-04-13 14:44:29 -070058 @SuppressWarnings("unused")
Adam Cohendf2cc412011-04-27 16:56:57 -070059 private static final String TAG = "Launcher.Folder";
60
Adam Cohen4eac29a2011-07-11 17:53:37 -070061 protected DragController mDragController;
62 protected Launcher mLauncher;
63 protected FolderInfo mInfo;
64
Adam Cohendf2cc412011-04-27 16:56:57 -070065 static final int STATE_NONE = -1;
66 static final int STATE_SMALL = 0;
67 static final int STATE_ANIMATING = 1;
68 static final int STATE_OPEN = 2;
69
70 private int mExpandDuration;
71 protected CellLayout mContent;
72 private final LayoutInflater mInflater;
73 private final IconCache mIconCache;
74 private int mState = STATE_NONE;
Adam Cohenbfbfd262011-06-13 16:55:12 -070075 private static final int REORDER_ANIMATION_DURATION = 230;
76 private static final int ON_EXIT_CLOSE_DELAY = 800;
Adam Cohen2801caf2011-05-13 20:57:39 -070077 private boolean mRearrangeOnClose = false;
78 private FolderIcon mFolderIcon;
79 private int mMaxCountX;
80 private int mMaxCountY;
Adam Cohen78dc83e2011-11-15 17:10:00 -080081 private int mMaxNumItems;
Adam Cohen7c693212011-05-18 15:26:57 -070082 private ArrayList<View> mItemsInReadingOrder = new ArrayList<View>();
Adam Cohenbadf71e2011-05-26 19:08:29 -070083 private Drawable mIconDrawable;
Adam Cohen7c693212011-05-18 15:26:57 -070084 boolean mItemsInvalidated = false;
Adam Cohenbfbfd262011-06-13 16:55:12 -070085 private ShortcutInfo mCurrentDragInfo;
86 private View mCurrentDragView;
87 boolean mSuppressOnAdd = false;
88 private int[] mTargetCell = new int[2];
89 private int[] mPreviousTargetCell = new int[2];
90 private int[] mEmptyCell = new int[2];
91 private Alarm mReorderAlarm = new Alarm();
92 private Alarm mOnExitAlarm = new Alarm();
Adam Cohen76fc0852011-06-17 13:26:23 -070093 private int mFolderNameHeight;
Adam Cohen8e776a62011-06-28 18:10:06 -070094 private Rect mTempRect = new Rect();
Adam Cohen67bd9cc2011-07-29 14:07:04 -070095 private boolean mDragInProgress = false;
96 private boolean mDeleteFolderOnDropCompleted = false;
97 private boolean mSuppressFolderDeletion = false;
Adam Cohen05e0f402011-08-01 12:12:49 -070098 private boolean mItemAddedBackToSelfViaIcon = false;
Adam Cohenac56cff2011-09-28 20:45:37 -070099 FolderEditText mFolderName;
Adam Cohen228da5a2011-07-27 22:23:47 -0700100
Adam Cohen76fc0852011-06-17 13:26:23 -0700101 private boolean mIsEditingName = false;
102 private InputMethodManager mInputMethodManager;
Adam Cohendf2cc412011-04-27 16:56:57 -0700103
Adam Cohena65beee2011-06-27 21:32:23 -0700104 private static String sDefaultFolderName;
105 private static String sHintText;
106
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800107 /**
108 * Used to inflate the Workspace from XML.
109 *
110 * @param context The application's context.
111 * @param attrs The attribtues set containing the Workspace's customization values.
112 */
113 public Folder(Context context, AttributeSet attrs) {
114 super(context, attrs);
115 setAlwaysDrawnWithCacheEnabled(false);
Adam Cohendf2cc412011-04-27 16:56:57 -0700116 mInflater = LayoutInflater.from(context);
117 mIconCache = ((LauncherApplication)context.getApplicationContext()).getIconCache();
Adam Cohen78dc83e2011-11-15 17:10:00 -0800118
119 Resources res = getResources();
120 mMaxCountX = res.getInteger(R.integer.folder_max_count_x);
121 mMaxCountY = res.getInteger(R.integer.folder_max_count_y);
122 mMaxNumItems = res.getInteger(R.integer.folder_max_num_items);
123 if (mMaxCountX < 0 || mMaxCountY < 0 || mMaxNumItems < 0) {
124 mMaxCountX = LauncherModel.getCellCountX();
125 mMaxCountY = LauncherModel.getCellCountY();
126 mMaxNumItems = mMaxCountX * mMaxCountY;
127 }
Adam Cohen76fc0852011-06-17 13:26:23 -0700128
129 mInputMethodManager = (InputMethodManager)
130 mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
131
Adam Cohen76fc0852011-06-17 13:26:23 -0700132 mExpandDuration = res.getInteger(R.integer.config_folderAnimDuration);
Adam Cohen4ef610f2011-06-21 22:37:36 -0700133
134 if (sDefaultFolderName == null) {
135 sDefaultFolderName = res.getString(R.string.folder_name);
136 }
Adam Cohena65beee2011-06-27 21:32:23 -0700137 if (sHintText == null) {
138 sHintText = res.getString(R.string.folder_hint_text);
139 }
Adam Cohen4eac29a2011-07-11 17:53:37 -0700140 mLauncher = (Launcher) context;
Adam Cohenac56cff2011-09-28 20:45:37 -0700141 // We need this view to be focusable in touch mode so that when text editing of the folder
142 // name is complete, we have something to focus on, thus hiding the cursor and giving
143 // reliable behvior when clicking the text field (since it will always gain focus on click).
144 setFocusableInTouchMode(true);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800145 }
146
147 @Override
148 protected void onFinishInflate() {
149 super.onFinishInflate();
Adam Cohendf2cc412011-04-27 16:56:57 -0700150 mContent = (CellLayout) findViewById(R.id.folder_content);
Adam Cohen2801caf2011-05-13 20:57:39 -0700151 mContent.setGridSize(0, 0);
Michael Jurkaa52570f2012-03-20 03:18:20 -0700152 mContent.getShortcutsAndWidgets().setMotionEventSplittingEnabled(false);
Adam Cohenac56cff2011-09-28 20:45:37 -0700153 mFolderName = (FolderEditText) findViewById(R.id.folder_name);
154 mFolderName.setFolder(this);
Adam Cohenea0818d2011-09-30 20:06:58 -0700155 mFolderName.setOnFocusChangeListener(this);
Adam Cohen76fc0852011-06-17 13:26:23 -0700156
157 // We find out how tall the text view wants to be (it is set to wrap_content), so that
158 // we can allocate the appropriate amount of space for it.
159 int measureSpec = MeasureSpec.UNSPECIFIED;
160 mFolderName.measure(measureSpec, measureSpec);
161 mFolderNameHeight = mFolderName.getMeasuredHeight();
162
163 // We disable action mode for now since it messes up the view on phones
164 mFolderName.setCustomSelectionActionModeCallback(mActionModeCallback);
Adam Cohen76fc0852011-06-17 13:26:23 -0700165 mFolderName.setOnEditorActionListener(this);
Adam Cohen4ef610f2011-06-21 22:37:36 -0700166 mFolderName.setSelectAllOnFocus(true);
Adam Cohen7a14d0b2011-06-24 11:36:35 -0700167 mFolderName.setInputType(mFolderName.getInputType() |
168 InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS | InputType.TYPE_TEXT_FLAG_CAP_WORDS);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800169 }
Adam Cohen2801caf2011-05-13 20:57:39 -0700170
Adam Cohen76fc0852011-06-17 13:26:23 -0700171 private ActionMode.Callback mActionModeCallback = new ActionMode.Callback() {
172 public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
173 return false;
174 }
175
176 public boolean onCreateActionMode(ActionMode mode, Menu menu) {
177 return false;
178 }
179
180 public void onDestroyActionMode(ActionMode mode) {
181 }
182
183 public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
184 return false;
185 }
186 };
187
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800188 public void onClick(View v) {
Adam Cohendf2cc412011-04-27 16:56:57 -0700189 Object tag = v.getTag();
190 if (tag instanceof ShortcutInfo) {
191 // refactor this code from Folder
192 ShortcutInfo item = (ShortcutInfo) tag;
193 int[] pos = new int[2];
194 v.getLocationOnScreen(pos);
195 item.intent.setSourceBounds(new Rect(pos[0], pos[1],
196 pos[0] + v.getWidth(), pos[1] + v.getHeight()));
197 mLauncher.startActivitySafely(item.intent, item);
Adam Cohendf2cc412011-04-27 16:56:57 -0700198 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800199 }
200
201 public boolean onLongClick(View v) {
Adam Cohendf2cc412011-04-27 16:56:57 -0700202 Object tag = v.getTag();
203 if (tag instanceof ShortcutInfo) {
Adam Cohendf2cc412011-04-27 16:56:57 -0700204 ShortcutInfo item = (ShortcutInfo) tag;
205 if (!v.isInTouchMode()) {
206 return false;
207 }
208
Winson Chung7d7541e2011-09-16 20:14:36 -0700209 mLauncher.dismissFolderCling(null);
210
Adam Cohendf2cc412011-04-27 16:56:57 -0700211 mLauncher.getWorkspace().onDragStartedWithItem(v);
Adam Cohenac8c8762011-07-13 11:15:27 -0700212 mLauncher.getWorkspace().beginDragShared(v, this);
Adam Cohenbadf71e2011-05-26 19:08:29 -0700213 mIconDrawable = ((TextView) v).getCompoundDrawables()[1];
Adam Cohen76078c42011-06-09 15:06:52 -0700214
215 mCurrentDragInfo = item;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700216 mEmptyCell[0] = item.cellX;
217 mEmptyCell[1] = item.cellY;
218 mCurrentDragView = v;
Adam Cohenfc53cd22011-07-20 15:45:11 -0700219
220 mContent.removeView(mCurrentDragView);
221 mInfo.remove(mCurrentDragInfo);
Adam Cohen67bd9cc2011-07-29 14:07:04 -0700222 mDragInProgress = true;
Adam Cohen05e0f402011-08-01 12:12:49 -0700223 mItemAddedBackToSelfViaIcon = false;
Adam Cohendf2cc412011-04-27 16:56:57 -0700224 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800225 return true;
226 }
227
Adam Cohen76fc0852011-06-17 13:26:23 -0700228 public boolean isEditingName() {
229 return mIsEditingName;
230 }
231
232 public void startEditingFolderName() {
Adam Cohena65beee2011-06-27 21:32:23 -0700233 mFolderName.setHint("");
Adam Cohen76fc0852011-06-17 13:26:23 -0700234 mIsEditingName = true;
235 }
236
237 public void dismissEditingName() {
238 mInputMethodManager.hideSoftInputFromWindow(getWindowToken(), 0);
239 doneEditingFolderName(true);
240 }
241
242 public void doneEditingFolderName(boolean commit) {
Adam Cohena65beee2011-06-27 21:32:23 -0700243 mFolderName.setHint(sHintText);
Adam Cohen1df26a32011-08-12 16:15:23 -0700244 // Convert to a string here to ensure that no other state associated with the text field
245 // gets saved.
Adam Cohen3371da02011-10-25 21:38:29 -0700246 String newTitle = mFolderName.getText().toString();
247 mInfo.setTitle(newTitle);
Adam Cohen76fc0852011-06-17 13:26:23 -0700248 LauncherModel.updateItemInDatabase(mLauncher, mInfo);
Adam Cohenac56cff2011-09-28 20:45:37 -0700249
Adam Cohen3371da02011-10-25 21:38:29 -0700250 if (commit) {
251 sendCustomAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED,
252 String.format(mContext.getString(R.string.folder_renamed), newTitle));
253 }
Adam Cohenac56cff2011-09-28 20:45:37 -0700254 // In order to clear the focus from the text field, we set the focus on ourself. This
255 // ensures that every time the field is clicked, focus is gained, giving reliable behavior.
256 requestFocus();
257
Adam Cohene601a432011-07-26 21:51:30 -0700258 Selection.setSelection((Spannable) mFolderName.getText(), 0, 0);
Adam Cohen76fc0852011-06-17 13:26:23 -0700259 mIsEditingName = false;
260 }
261
262 public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
263 if (actionId == EditorInfo.IME_ACTION_DONE) {
264 dismissEditingName();
265 return true;
266 }
267 return false;
268 }
269
270 public View getEditTextRegion() {
271 return mFolderName;
272 }
273
Adam Cohenbadf71e2011-05-26 19:08:29 -0700274 public Drawable getDragDrawable() {
275 return mIconDrawable;
276 }
277
Adam Cohen0c872ba2011-05-05 10:34:16 -0700278 /**
279 * We need to handle touch events to prevent them from falling through to the workspace below.
280 */
281 @Override
282 public boolean onTouchEvent(MotionEvent ev) {
283 return true;
284 }
285
Joe Onorato00acb122009-08-04 16:04:30 -0400286 public void setDragController(DragController dragController) {
287 mDragController = dragController;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800288 }
289
Adam Cohen2801caf2011-05-13 20:57:39 -0700290 void setFolderIcon(FolderIcon icon) {
291 mFolderIcon = icon;
292 }
293
Adam Cohen3371da02011-10-25 21:38:29 -0700294 @Override
295 public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
296 // When the folder gets focus, we don't want to announce the list of items.
297 return true;
298 }
299
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800300 /**
301 * @return the FolderInfo object associated with this folder
302 */
303 FolderInfo getInfo() {
304 return mInfo;
305 }
306
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800307 void bind(FolderInfo info) {
308 mInfo = info;
Adam Cohendf2cc412011-04-27 16:56:57 -0700309 ArrayList<ShortcutInfo> children = info.contents;
Adam Cohenc508b2d2011-06-28 14:41:44 -0700310 ArrayList<ShortcutInfo> overflow = new ArrayList<ShortcutInfo>();
Adam Cohen7c693212011-05-18 15:26:57 -0700311 setupContentForNumItems(children.size());
Adam Cohen0057bbc2011-08-12 18:30:51 -0700312 int count = 0;
Adam Cohendf2cc412011-04-27 16:56:57 -0700313 for (int i = 0; i < children.size(); i++) {
314 ShortcutInfo child = (ShortcutInfo) children.get(i);
Adam Cohenc508b2d2011-06-28 14:41:44 -0700315 if (!createAndAddShortcut(child)) {
316 overflow.add(child);
Adam Cohen0057bbc2011-08-12 18:30:51 -0700317 } else {
318 count++;
Adam Cohenc508b2d2011-06-28 14:41:44 -0700319 }
Adam Cohendf2cc412011-04-27 16:56:57 -0700320 }
Adam Cohenc508b2d2011-06-28 14:41:44 -0700321
Adam Cohen0057bbc2011-08-12 18:30:51 -0700322 // We rearrange the items in case there are any empty gaps
323 setupContentForNumItems(count);
324
Adam Cohenc508b2d2011-06-28 14:41:44 -0700325 // If our folder has too many items we prune them from the list. This is an issue
326 // when upgrading from the old Folders implementation which could contain an unlimited
327 // number of items.
328 for (ShortcutInfo item: overflow) {
329 mInfo.remove(item);
330 LauncherModel.deleteItemFromDatabase(mLauncher, item);
331 }
332
Adam Cohen4dbe6d92011-05-18 17:14:15 -0700333 mItemsInvalidated = true;
Adam Cohenac56cff2011-09-28 20:45:37 -0700334 updateTextViewFocus();
Adam Cohena9cf38f2011-05-02 15:36:58 -0700335 mInfo.addListener(this);
Adam Cohen4ef610f2011-06-21 22:37:36 -0700336
Adam Cohenafb01ee2011-06-23 15:38:03 -0700337 if (!sDefaultFolderName.contentEquals(mInfo.title)) {
Adam Cohen4ef610f2011-06-21 22:37:36 -0700338 mFolderName.setText(mInfo.title);
339 } else {
340 mFolderName.setText("");
341 }
Adam Cohendf2cc412011-04-27 16:56:57 -0700342 }
343
344 /**
345 * Creates a new UserFolder, inflated from R.layout.user_folder.
346 *
347 * @param context The application's context.
348 *
349 * @return A new UserFolder.
350 */
351 static Folder fromXml(Context context) {
352 return (Folder) LayoutInflater.from(context).inflate(R.layout.user_folder, null);
353 }
354
355 /**
356 * This method is intended to make the UserFolder to be visually identical in size and position
357 * to its associated FolderIcon. This allows for a seamless transition into the expanded state.
358 */
359 private void positionAndSizeAsIcon() {
Adam Cohen3e8f8112011-07-02 18:03:00 -0700360 if (!(getParent() instanceof DragLayer)) return;
Adam Cohen662b5982011-12-13 17:45:21 -0800361 setScaleX(0.8f);
362 setScaleY(0.8f);
363 setAlpha(0f);
Adam Cohendf2cc412011-04-27 16:56:57 -0700364 mState = STATE_SMALL;
365 }
366
367 public void animateOpen() {
Adam Cohen3e8f8112011-07-02 18:03:00 -0700368 positionAndSizeAsIcon();
369
Adam Cohen8e776a62011-06-28 18:10:06 -0700370 if (!(getParent() instanceof DragLayer)) return;
Adam Cohen2801caf2011-05-13 20:57:39 -0700371 centerAboutIcon();
Adam Cohen662b5982011-12-13 17:45:21 -0800372 PropertyValuesHolder alpha = PropertyValuesHolder.ofFloat("alpha", 1);
373 PropertyValuesHolder scaleX = PropertyValuesHolder.ofFloat("scaleX", 1.0f);
374 PropertyValuesHolder scaleY = PropertyValuesHolder.ofFloat("scaleY", 1.0f);
375 ObjectAnimator oa = ObjectAnimator.ofPropertyValuesHolder(this, alpha, scaleX, scaleY);
Adam Cohen6441de02011-12-14 14:25:32 -0800376
Adam Cohen2801caf2011-05-13 20:57:39 -0700377 oa.addListener(new AnimatorListenerAdapter() {
Adam Cohendf2cc412011-04-27 16:56:57 -0700378 @Override
379 public void onAnimationStart(Animator animation) {
Adam Cohen3371da02011-10-25 21:38:29 -0700380 sendCustomAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED,
381 String.format(mContext.getString(R.string.folder_opened),
382 mContent.getCountX(), mContent.getCountY()));
Adam Cohendf2cc412011-04-27 16:56:57 -0700383 mState = STATE_ANIMATING;
384 }
385 @Override
386 public void onAnimationEnd(Animator animation) {
Adam Cohen2801caf2011-05-13 20:57:39 -0700387 mState = STATE_OPEN;
Winson Chung7a74ac92011-09-20 17:43:51 -0700388
389 Cling cling = mLauncher.showFirstRunFoldersCling();
390 if (cling != null) {
391 cling.bringToFront();
392 }
Adam Cohenac56cff2011-09-28 20:45:37 -0700393 setFocusOnFirstChild();
Adam Cohendf2cc412011-04-27 16:56:57 -0700394 }
395 });
Adam Cohen2801caf2011-05-13 20:57:39 -0700396 oa.setDuration(mExpandDuration);
397 oa.start();
Adam Cohendf2cc412011-04-27 16:56:57 -0700398 }
399
Adam Cohen3371da02011-10-25 21:38:29 -0700400 private void sendCustomAccessibilityEvent(int type, String text) {
401 if (AccessibilityManager.getInstance(mContext).isEnabled()) {
402 AccessibilityEvent event = AccessibilityEvent.obtain(type);
403 onInitializeAccessibilityEvent(event);
404 event.getText().add(text);
405 AccessibilityManager.getInstance(mContext).sendAccessibilityEvent(event);
406 }
407 }
408
Adam Cohenac56cff2011-09-28 20:45:37 -0700409 private void setFocusOnFirstChild() {
410 View firstChild = mContent.getChildAt(0, 0);
411 if (firstChild != null) {
412 firstChild.requestFocus();
413 }
414 }
415
Adam Cohendf2cc412011-04-27 16:56:57 -0700416 public void animateClosed() {
Adam Cohen8e776a62011-06-28 18:10:06 -0700417 if (!(getParent() instanceof DragLayer)) return;
Adam Cohen662b5982011-12-13 17:45:21 -0800418 PropertyValuesHolder alpha = PropertyValuesHolder.ofFloat("alpha", 0);
419 PropertyValuesHolder scaleX = PropertyValuesHolder.ofFloat("scaleX", 0.9f);
420 PropertyValuesHolder scaleY = PropertyValuesHolder.ofFloat("scaleY", 0.9f);
421 ObjectAnimator oa = ObjectAnimator.ofPropertyValuesHolder(this, alpha, scaleX, scaleY);
Adam Cohendf2cc412011-04-27 16:56:57 -0700422
Adam Cohen2801caf2011-05-13 20:57:39 -0700423 oa.addListener(new AnimatorListenerAdapter() {
Adam Cohendf2cc412011-04-27 16:56:57 -0700424 @Override
425 public void onAnimationEnd(Animator animation) {
Adam Cohen2801caf2011-05-13 20:57:39 -0700426 onCloseComplete();
Adam Cohen2801caf2011-05-13 20:57:39 -0700427 mState = STATE_SMALL;
Adam Cohendf2cc412011-04-27 16:56:57 -0700428 }
429 @Override
430 public void onAnimationStart(Animator animation) {
Adam Cohen3371da02011-10-25 21:38:29 -0700431 sendCustomAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED,
432 mContext.getString(R.string.folder_closed));
Adam Cohendf2cc412011-04-27 16:56:57 -0700433 mState = STATE_ANIMATING;
434 }
435 });
Adam Cohen2801caf2011-05-13 20:57:39 -0700436 oa.setDuration(mExpandDuration);
437 oa.start();
Adam Cohendf2cc412011-04-27 16:56:57 -0700438 }
439
440 void notifyDataSetChanged() {
441 // recreate all the children if the data set changes under us. We may want to do this more
442 // intelligently (ie just removing the views that should no longer exist)
443 mContent.removeAllViewsInLayout();
444 bind(mInfo);
445 }
446
Adam Cohencb3382b2011-05-24 14:07:08 -0700447 public boolean acceptDrop(DragObject d) {
448 final ItemInfo item = (ItemInfo) d.dragInfo;
Adam Cohendf2cc412011-04-27 16:56:57 -0700449 final int itemType = item.itemType;
Adam Cohen2801caf2011-05-13 20:57:39 -0700450 return ((itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION ||
451 itemType == LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT) &&
452 !isFull());
Adam Cohendf2cc412011-04-27 16:56:57 -0700453 }
454
Adam Cohendf2cc412011-04-27 16:56:57 -0700455 protected boolean findAndSetEmptyCells(ShortcutInfo item) {
456 int[] emptyCell = new int[2];
457 if (mContent.findCellForSpan(emptyCell, item.spanX, item.spanY)) {
458 item.cellX = emptyCell[0];
459 item.cellY = emptyCell[1];
Adam Cohendf2cc412011-04-27 16:56:57 -0700460 return true;
461 } else {
462 return false;
463 }
464 }
465
Adam Cohenc508b2d2011-06-28 14:41:44 -0700466 protected boolean createAndAddShortcut(ShortcutInfo item) {
Adam Cohendf2cc412011-04-27 16:56:57 -0700467 final TextView textView =
Adam Cohene87b9242011-06-29 14:01:26 -0700468 (TextView) mInflater.inflate(R.layout.application, this, false);
Adam Cohendf2cc412011-04-27 16:56:57 -0700469 textView.setCompoundDrawablesWithIntrinsicBounds(null,
470 new FastBitmapDrawable(item.getIcon(mIconCache)), null, null);
471 textView.setText(item.title);
472 textView.setTag(item);
473
474 textView.setOnClickListener(this);
475 textView.setOnLongClickListener(this);
476
Adam Cohenc508b2d2011-06-28 14:41:44 -0700477 // We need to check here to verify that the given item's location isn't already occupied
478 // by another item. If it is, we need to find the next available slot and assign
479 // it that position. This is an issue when upgrading from the old Folders implementation
480 // which could contain an unlimited number of items.
Adam Cohen0057bbc2011-08-12 18:30:51 -0700481 if (mContent.getChildAt(item.cellX, item.cellY) != null || item.cellX < 0 || item.cellY < 0
482 || item.cellX >= mContent.getCountX() || item.cellY >= mContent.getCountY()) {
Adam Cohenc508b2d2011-06-28 14:41:44 -0700483 if (!findAndSetEmptyCells(item)) {
484 return false;
485 }
486 }
487
Adam Cohendf2cc412011-04-27 16:56:57 -0700488 CellLayout.LayoutParams lp =
489 new CellLayout.LayoutParams(item.cellX, item.cellY, item.spanX, item.spanY);
490 boolean insert = false;
Adam Cohenac56cff2011-09-28 20:45:37 -0700491 textView.setOnKeyListener(new FolderKeyEventListener());
Adam Cohendf2cc412011-04-27 16:56:57 -0700492 mContent.addViewToCellLayout(textView, insert ? 0 : -1, (int)item.id, lp, true);
Adam Cohenc508b2d2011-06-28 14:41:44 -0700493 return true;
Adam Cohendf2cc412011-04-27 16:56:57 -0700494 }
495
Adam Cohencb3382b2011-05-24 14:07:08 -0700496 public void onDragEnter(DragObject d) {
Adam Cohenbfbfd262011-06-13 16:55:12 -0700497 mPreviousTargetCell[0] = -1;
498 mPreviousTargetCell[1] = -1;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700499 mOnExitAlarm.cancelAlarm();
500 }
501
502 OnAlarmListener mReorderAlarmListener = new OnAlarmListener() {
503 public void onAlarm(Alarm alarm) {
504 realTimeReorder(mEmptyCell, mTargetCell);
505 }
506 };
507
508 boolean readingOrderGreaterThan(int[] v1, int[] v2) {
509 if (v1[1] > v2[1] || (v1[1] == v2[1] && v1[0] > v2[0])) {
510 return true;
511 } else {
512 return false;
513 }
514 }
515
516 private void realTimeReorder(int[] empty, int[] target) {
517 boolean wrap;
518 int startX;
519 int endX;
520 int startY;
Adam Cohen76fc0852011-06-17 13:26:23 -0700521 int delay = 0;
522 float delayAmount = 30;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700523 if (readingOrderGreaterThan(target, empty)) {
524 wrap = empty[0] >= mContent.getCountX() - 1;
525 startY = wrap ? empty[1] + 1 : empty[1];
526 for (int y = startY; y <= target[1]; y++) {
527 startX = y == empty[1] ? empty[0] + 1 : 0;
528 endX = y < target[1] ? mContent.getCountX() - 1 : target[0];
529 for (int x = startX; x <= endX; x++) {
530 View v = mContent.getChildAt(x,y);
531 if (mContent.animateChildToPosition(v, empty[0], empty[1],
Adam Cohen482ed822012-03-02 14:15:13 -0800532 REORDER_ANIMATION_DURATION, delay, true, true)) {
Adam Cohenbfbfd262011-06-13 16:55:12 -0700533 empty[0] = x;
534 empty[1] = y;
Adam Cohen76fc0852011-06-17 13:26:23 -0700535 delay += delayAmount;
536 delayAmount *= 0.9;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700537 }
538 }
539 }
540 } else {
541 wrap = empty[0] == 0;
542 startY = wrap ? empty[1] - 1 : empty[1];
543 for (int y = startY; y >= target[1]; y--) {
544 startX = y == empty[1] ? empty[0] - 1 : mContent.getCountX() - 1;
545 endX = y > target[1] ? 0 : target[0];
546 for (int x = startX; x >= endX; x--) {
547 View v = mContent.getChildAt(x,y);
548 if (mContent.animateChildToPosition(v, empty[0], empty[1],
Adam Cohen482ed822012-03-02 14:15:13 -0800549 REORDER_ANIMATION_DURATION, delay, true, true)) {
Adam Cohenbfbfd262011-06-13 16:55:12 -0700550 empty[0] = x;
551 empty[1] = y;
Adam Cohen76fc0852011-06-17 13:26:23 -0700552 delay += delayAmount;
553 delayAmount *= 0.9;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700554 }
555 }
556 }
557 }
Adam Cohendf2cc412011-04-27 16:56:57 -0700558 }
559
Adam Cohencb3382b2011-05-24 14:07:08 -0700560 public void onDragOver(DragObject d) {
Adam Cohenbfbfd262011-06-13 16:55:12 -0700561 float[] r = getDragViewVisualCenter(d.x, d.y, d.xOffset, d.yOffset, d.dragView, null);
562 mTargetCell = mContent.findNearestArea((int) r[0], (int) r[1], 1, 1, mTargetCell);
563
564 if (mTargetCell[0] != mPreviousTargetCell[0] || mTargetCell[1] != mPreviousTargetCell[1]) {
565 mReorderAlarm.cancelAlarm();
566 mReorderAlarm.setOnAlarmListener(mReorderAlarmListener);
567 mReorderAlarm.setAlarm(150);
568 mPreviousTargetCell[0] = mTargetCell[0];
569 mPreviousTargetCell[1] = mTargetCell[1];
570 }
Adam Cohendf2cc412011-04-27 16:56:57 -0700571 }
572
Adam Cohenbfbfd262011-06-13 16:55:12 -0700573 // This is used to compute the visual center of the dragView. The idea is that
574 // the visual center represents the user's interpretation of where the item is, and hence
575 // is the appropriate point to use when determining drop location.
576 private float[] getDragViewVisualCenter(int x, int y, int xOffset, int yOffset,
577 DragView dragView, float[] recycle) {
578 float res[];
579 if (recycle == null) {
580 res = new float[2];
581 } else {
582 res = recycle;
583 }
584
585 // These represent the visual top and left of drag view if a dragRect was provided.
586 // If a dragRect was not provided, then they correspond to the actual view left and
587 // top, as the dragRect is in that case taken to be the entire dragView.
588 // R.dimen.dragViewOffsetY.
589 int left = x - xOffset;
590 int top = y - yOffset;
591
592 // In order to find the visual center, we shift by half the dragRect
593 res[0] = left + dragView.getDragRegion().width() / 2;
594 res[1] = top + dragView.getDragRegion().height() / 2;
595
596 return res;
597 }
598
599 OnAlarmListener mOnExitAlarmListener = new OnAlarmListener() {
600 public void onAlarm(Alarm alarm) {
Adam Cohen3e8f8112011-07-02 18:03:00 -0700601 completeDragExit();
Adam Cohenbfbfd262011-06-13 16:55:12 -0700602 }
603 };
604
Adam Cohen95bb8002011-07-03 23:40:28 -0700605 public void completeDragExit() {
Adam Cohen3e8f8112011-07-02 18:03:00 -0700606 mLauncher.closeFolder();
607 mCurrentDragInfo = null;
608 mCurrentDragView = null;
609 mSuppressOnAdd = false;
610 mRearrangeOnClose = true;
611 }
612
Adam Cohencb3382b2011-05-24 14:07:08 -0700613 public void onDragExit(DragObject d) {
Adam Cohenbfbfd262011-06-13 16:55:12 -0700614 // We only close the folder if this is a true drag exit, ie. not because a drop
615 // has occurred above the folder.
616 if (!d.dragComplete) {
617 mOnExitAlarm.setOnAlarmListener(mOnExitAlarmListener);
618 mOnExitAlarm.setAlarm(ON_EXIT_CLOSE_DELAY);
619 }
620 mReorderAlarm.cancelAlarm();
Adam Cohen2801caf2011-05-13 20:57:39 -0700621 }
622
Winson Chunga48487a2012-03-20 16:19:37 -0700623 public void onDropCompleted(View target, DragObject d, boolean isFlingToDelete,
624 boolean success) {
Adam Cohen67bd9cc2011-07-29 14:07:04 -0700625 if (success) {
Adam Cohen05e0f402011-08-01 12:12:49 -0700626 if (mDeleteFolderOnDropCompleted && !mItemAddedBackToSelfViaIcon) {
Adam Cohen67bd9cc2011-07-29 14:07:04 -0700627 replaceFolderWithFinalItem();
628 }
629 } else {
630 // The drag failed, we need to return the item to the folder
631 mFolderIcon.onDrop(d);
632
633 // We're going to trigger a "closeFolder" which may occur before this item has
634 // been added back to the folder -- this could cause the folder to be deleted
635 if (mOnExitAlarm.alarmPending()) {
636 mSuppressFolderDeletion = true;
637 }
638 }
639
640 if (target != this) {
641 if (mOnExitAlarm.alarmPending()) {
642 mOnExitAlarm.cancelAlarm();
643 completeDragExit();
644 }
645 }
646 mDeleteFolderOnDropCompleted = false;
647 mDragInProgress = false;
Adam Cohen05e0f402011-08-01 12:12:49 -0700648 mItemAddedBackToSelfViaIcon = false;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700649 mCurrentDragInfo = null;
650 mCurrentDragView = null;
651 mSuppressOnAdd = false;
Adam Cohen4045eb72011-10-06 11:44:26 -0700652
653 // Reordering may have occured, and we need to save the new item locations. We do this once
654 // at the end to prevent unnecessary database operations.
655 updateItemLocationsInDatabase();
656 }
657
Winson Chunga48487a2012-03-20 16:19:37 -0700658 @Override
Winson Chung043f2af2012-03-01 16:09:54 -0800659 public boolean supportsFlingToDelete() {
660 return true;
661 }
662
Winson Chunga48487a2012-03-20 16:19:37 -0700663 public void onFlingToDelete(DragObject d, int x, int y, PointF vec) {
664 // Do nothing
665 }
666
667 @Override
668 public void onFlingToDeleteCompleted() {
669 // Do nothing
670 }
671
Adam Cohen4045eb72011-10-06 11:44:26 -0700672 private void updateItemLocationsInDatabase() {
673 ArrayList<View> list = getItemsInReadingOrder();
674 for (int i = 0; i < list.size(); i++) {
675 View v = list.get(i);
676 ItemInfo info = (ItemInfo) v.getTag();
677 LauncherModel.moveItemInDatabase(mLauncher, info, mInfo.id, 0,
678 info.cellX, info.cellY);
679 }
Adam Cohen67bd9cc2011-07-29 14:07:04 -0700680 }
Adam Cohen228da5a2011-07-27 22:23:47 -0700681
Adam Cohen67bd9cc2011-07-29 14:07:04 -0700682 public void notifyDrop() {
683 if (mDragInProgress) {
Adam Cohen05e0f402011-08-01 12:12:49 -0700684 mItemAddedBackToSelfViaIcon = true;
Adam Cohen76078c42011-06-09 15:06:52 -0700685 }
Adam Cohendf2cc412011-04-27 16:56:57 -0700686 }
687
688 public boolean isDropEnabled() {
689 return true;
690 }
691
Adam Cohencb3382b2011-05-24 14:07:08 -0700692 public DropTarget getDropTargetDelegate(DragObject d) {
Adam Cohendf2cc412011-04-27 16:56:57 -0700693 return null;
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800694 }
Adam Cohena9cf38f2011-05-02 15:36:58 -0700695
Adam Cohen4045eb72011-10-06 11:44:26 -0700696 private void setupContentDimensions(int count) {
Adam Cohen2801caf2011-05-13 20:57:39 -0700697 ArrayList<View> list = getItemsInReadingOrder();
698
699 int countX = mContent.getCountX();
700 int countY = mContent.getCountY();
Adam Cohen7c693212011-05-18 15:26:57 -0700701 boolean done = false;
Adam Cohen2801caf2011-05-13 20:57:39 -0700702
Adam Cohen7c693212011-05-18 15:26:57 -0700703 while (!done) {
704 int oldCountX = countX;
705 int oldCountY = countY;
706 if (countX * countY < count) {
707 // Current grid is too small, expand it
Adam Cohen78dc83e2011-11-15 17:10:00 -0800708 if ((countX <= countY || countY == mMaxCountY) && countX < mMaxCountX) {
Adam Cohen7c693212011-05-18 15:26:57 -0700709 countX++;
710 } else if (countY < mMaxCountY) {
711 countY++;
712 }
713 if (countY == 0) countY++;
714 } else if ((countY - 1) * countX >= count && countY >= countX) {
715 countY = Math.max(0, countY - 1);
716 } else if ((countX - 1) * countY >= count) {
717 countX = Math.max(0, countX - 1);
Adam Cohen2801caf2011-05-13 20:57:39 -0700718 }
Adam Cohen7c693212011-05-18 15:26:57 -0700719 done = countX == oldCountX && countY == oldCountY;
Adam Cohen2801caf2011-05-13 20:57:39 -0700720 }
Adam Cohen7c693212011-05-18 15:26:57 -0700721 mContent.setGridSize(countX, countY);
Adam Cohen2801caf2011-05-13 20:57:39 -0700722 arrangeChildren(list);
723 }
724
725 public boolean isFull() {
Adam Cohen78dc83e2011-11-15 17:10:00 -0800726 return getItemCount() >= mMaxNumItems;
Adam Cohen2801caf2011-05-13 20:57:39 -0700727 }
728
729 private void centerAboutIcon() {
Adam Cohen8e776a62011-06-28 18:10:06 -0700730 DragLayer.LayoutParams lp = (DragLayer.LayoutParams) getLayoutParams();
Adam Cohen2801caf2011-05-13 20:57:39 -0700731
732 int width = getPaddingLeft() + getPaddingRight() + mContent.getDesiredWidth();
Adam Cohenf4bb1cd2011-07-22 14:36:03 -0700733 int height = getPaddingTop() + getPaddingBottom() + mContent.getDesiredHeight()
734 + mFolderNameHeight;
Adam Cohen8e776a62011-06-28 18:10:06 -0700735 DragLayer parent = (DragLayer) mLauncher.findViewById(R.id.drag_layer);
Adam Cohen2801caf2011-05-13 20:57:39 -0700736
Adam Cohen8e776a62011-06-28 18:10:06 -0700737 parent.getDescendantRectRelativeToSelf(mFolderIcon, mTempRect);
738
739 int centerX = mTempRect.centerX();
740 int centerY = mTempRect.centerY();
Adam Cohen2801caf2011-05-13 20:57:39 -0700741 int centeredLeft = centerX - width / 2;
742 int centeredTop = centerY - height / 2;
743
Adam Cohen7cc1bc42011-12-13 21:28:43 -0800744 int currentPage = mLauncher.getWorkspace().getCurrentPage();
745 // In case the workspace is scrolling, we need to use the final scroll to compute
746 // the folders bounds.
747 mLauncher.getWorkspace().setFinalScrollForPageChange(currentPage);
Adam Cohen35e7e642011-07-17 14:47:18 -0700748 // We first fetch the currently visible CellLayoutChildren
Adam Cohen7cc1bc42011-12-13 21:28:43 -0800749 CellLayout currentLayout = (CellLayout) mLauncher.getWorkspace().getChildAt(currentPage);
Michael Jurkaa52570f2012-03-20 03:18:20 -0700750 ShortcutAndWidgetContainer boundingLayout = currentLayout.getShortcutsAndWidgets();
Adam Cohen35e7e642011-07-17 14:47:18 -0700751 Rect bounds = new Rect();
752 parent.getDescendantRectRelativeToSelf(boundingLayout, bounds);
Adam Cohen7cc1bc42011-12-13 21:28:43 -0800753 // We reset the workspaces scroll
754 mLauncher.getWorkspace().resetFinalScrollForPageChange(currentPage);
Adam Cohen2801caf2011-05-13 20:57:39 -0700755
Adam Cohen35e7e642011-07-17 14:47:18 -0700756 // We need to bound the folder to the currently visible CellLayoutChildren
757 int left = Math.min(Math.max(bounds.left, centeredLeft),
758 bounds.left + bounds.width() - width);
759 int top = Math.min(Math.max(bounds.top, centeredTop),
760 bounds.top + bounds.height() - height);
761 // If the folder doesn't fit within the bounds, center it about the desired bounds
762 if (width >= bounds.width()) {
763 left = bounds.left + (bounds.width() - width) / 2;
Adam Cohen0e4857c2011-06-30 17:05:14 -0700764 }
Adam Cohen35e7e642011-07-17 14:47:18 -0700765 if (height >= bounds.height()) {
766 top = bounds.top + (bounds.height() - height) / 2;
Adam Cohen0e4857c2011-06-30 17:05:14 -0700767 }
Adam Cohen2801caf2011-05-13 20:57:39 -0700768
769 int folderPivotX = width / 2 + (centeredLeft - left);
770 int folderPivotY = height / 2 + (centeredTop - top);
771 setPivotX(folderPivotX);
772 setPivotY(folderPivotY);
773 int folderIconPivotX = (int) (mFolderIcon.getMeasuredWidth() *
774 (1.0f * folderPivotX / width));
775 int folderIconPivotY = (int) (mFolderIcon.getMeasuredHeight() *
776 (1.0f * folderPivotY / height));
777 mFolderIcon.setPivotX(folderIconPivotX);
778 mFolderIcon.setPivotY(folderIconPivotY);
779
Adam Cohen662b5982011-12-13 17:45:21 -0800780 lp.width = width;
781 lp.height = height;
782 lp.x = left;
783 lp.y = top;
Adam Cohen2801caf2011-05-13 20:57:39 -0700784 }
785
786 private void setupContentForNumItems(int count) {
Adam Cohen4045eb72011-10-06 11:44:26 -0700787 setupContentDimensions(count);
Adam Cohen2801caf2011-05-13 20:57:39 -0700788
Adam Cohen8e776a62011-06-28 18:10:06 -0700789 DragLayer.LayoutParams lp = (DragLayer.LayoutParams) getLayoutParams();
Adam Cohen2801caf2011-05-13 20:57:39 -0700790 if (lp == null) {
Adam Cohen8e776a62011-06-28 18:10:06 -0700791 lp = new DragLayer.LayoutParams(0, 0);
792 lp.customPosition = true;
Adam Cohen2801caf2011-05-13 20:57:39 -0700793 setLayoutParams(lp);
794 }
795 centerAboutIcon();
796 }
797
Adam Cohen234c4cd2011-07-17 21:03:04 -0700798 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
799 int width = getPaddingLeft() + getPaddingRight() + mContent.getDesiredWidth();
Adam Cohenf4bb1cd2011-07-22 14:36:03 -0700800 int height = getPaddingTop() + getPaddingBottom() + mContent.getDesiredHeight()
801 + mFolderNameHeight;
Adam Cohen234c4cd2011-07-17 21:03:04 -0700802
803 int contentWidthSpec = MeasureSpec.makeMeasureSpec(mContent.getDesiredWidth(),
804 MeasureSpec.EXACTLY);
805 int contentHeightSpec = MeasureSpec.makeMeasureSpec(mContent.getDesiredHeight(),
806 MeasureSpec.EXACTLY);
807 mContent.measure(contentWidthSpec, contentHeightSpec);
808
809 mFolderName.measure(contentWidthSpec,
810 MeasureSpec.makeMeasureSpec(mFolderNameHeight, MeasureSpec.EXACTLY));
811 setMeasuredDimension(width, height);
812 }
813
Adam Cohen2801caf2011-05-13 20:57:39 -0700814 private void arrangeChildren(ArrayList<View> list) {
815 int[] vacant = new int[2];
816 if (list == null) {
817 list = getItemsInReadingOrder();
818 }
819 mContent.removeAllViews();
820
821 for (int i = 0; i < list.size(); i++) {
822 View v = list.get(i);
823 mContent.getVacantCell(vacant, 1, 1);
824 CellLayout.LayoutParams lp = (CellLayout.LayoutParams) v.getLayoutParams();
825 lp.cellX = vacant[0];
826 lp.cellY = vacant[1];
827 ItemInfo info = (ItemInfo) v.getTag();
Adam Cohen2792a332011-09-26 21:09:47 -0700828 if (info.cellX != vacant[0] || info.cellY != vacant[1]) {
829 info.cellX = vacant[0];
830 info.cellY = vacant[1];
831 LauncherModel.addOrMoveItemInDatabase(mLauncher, info, mInfo.id, 0,
832 info.cellX, info.cellY);
833 }
Adam Cohen2801caf2011-05-13 20:57:39 -0700834 boolean insert = false;
835 mContent.addViewToCellLayout(v, insert ? 0 : -1, (int)info.id, lp, true);
836 }
Adam Cohen7c693212011-05-18 15:26:57 -0700837 mItemsInvalidated = true;
Adam Cohen2801caf2011-05-13 20:57:39 -0700838 }
839
Adam Cohena9cf38f2011-05-02 15:36:58 -0700840 public int getItemCount() {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700841 return mContent.getShortcutsAndWidgets().getChildCount();
Adam Cohena9cf38f2011-05-02 15:36:58 -0700842 }
843
844 public View getItemAt(int index) {
Michael Jurkaa52570f2012-03-20 03:18:20 -0700845 return mContent.getShortcutsAndWidgets().getChildAt(index);
Adam Cohena9cf38f2011-05-02 15:36:58 -0700846 }
847
Adam Cohen2801caf2011-05-13 20:57:39 -0700848 private void onCloseComplete() {
Adam Cohen05e0f402011-08-01 12:12:49 -0700849 DragLayer parent = (DragLayer) getParent();
Adam Cohen4554ee12011-08-03 16:13:21 -0700850 parent.removeView(this);
851 mDragController.removeDropTarget((DropTarget) this);
Adam Cohen05e0f402011-08-01 12:12:49 -0700852 clearFocus();
Adam Cohenac56cff2011-09-28 20:45:37 -0700853 mFolderIcon.requestFocus();
Adam Cohen05e0f402011-08-01 12:12:49 -0700854
Adam Cohen2801caf2011-05-13 20:57:39 -0700855 if (mRearrangeOnClose) {
856 setupContentForNumItems(getItemCount());
857 mRearrangeOnClose = false;
858 }
Adam Cohenafb01ee2011-06-23 15:38:03 -0700859 if (getItemCount() <= 1) {
Adam Cohen67bd9cc2011-07-29 14:07:04 -0700860 if (!mDragInProgress && !mSuppressFolderDeletion) {
861 replaceFolderWithFinalItem();
862 } else if (mDragInProgress) {
863 mDeleteFolderOnDropCompleted = true;
864 }
Adam Cohenafb01ee2011-06-23 15:38:03 -0700865 }
Adam Cohen67bd9cc2011-07-29 14:07:04 -0700866 mSuppressFolderDeletion = false;
Adam Cohenafb01ee2011-06-23 15:38:03 -0700867 }
868
869 private void replaceFolderWithFinalItem() {
870 ItemInfo finalItem = null;
871
872 if (getItemCount() == 1) {
873 finalItem = mInfo.contents.get(0);
874 }
875
876 // Remove the folder completely
Winson Chung3d503fb2011-07-13 17:25:49 -0700877 CellLayout cellLayout = mLauncher.getCellLayout(mInfo.container, mInfo.screen);
Adam Cohenafb01ee2011-06-23 15:38:03 -0700878 cellLayout.removeView(mFolderIcon);
879 if (mFolderIcon instanceof DropTarget) {
880 mDragController.removeDropTarget((DropTarget) mFolderIcon);
881 }
882 mLauncher.removeFolder(mInfo);
883
884 if (finalItem != null) {
Winson Chung3d503fb2011-07-13 17:25:49 -0700885 LauncherModel.addOrMoveItemInDatabase(mLauncher, finalItem, mInfo.container,
886 mInfo.screen, mInfo.cellX, mInfo.cellY);
Adam Cohenafb01ee2011-06-23 15:38:03 -0700887 }
Adam Cohen716b51e2011-06-30 12:09:54 -0700888 LauncherModel.deleteItemFromDatabase(mLauncher, mInfo);
Adam Cohenafb01ee2011-06-23 15:38:03 -0700889
890 // Add the last remaining child to the workspace in place of the folder
891 if (finalItem != null) {
892 View child = mLauncher.createShortcut(R.layout.application, cellLayout,
893 (ShortcutInfo) finalItem);
894
Winson Chung3d503fb2011-07-13 17:25:49 -0700895 mLauncher.getWorkspace().addInScreen(child, mInfo.container, mInfo.screen, mInfo.cellX,
896 mInfo.cellY, mInfo.spanX, mInfo.spanY);
Adam Cohenafb01ee2011-06-23 15:38:03 -0700897 }
Adam Cohen2801caf2011-05-13 20:57:39 -0700898 }
899
Adam Cohenac56cff2011-09-28 20:45:37 -0700900 // This method keeps track of the last item in the folder for the purposes
901 // of keyboard focus
902 private void updateTextViewFocus() {
903 View lastChild = getItemAt(getItemCount() - 1);
904 getItemAt(getItemCount() - 1);
905 if (lastChild != null) {
906 mFolderName.setNextFocusDownId(lastChild.getId());
907 mFolderName.setNextFocusRightId(lastChild.getId());
908 mFolderName.setNextFocusLeftId(lastChild.getId());
909 mFolderName.setNextFocusUpId(lastChild.getId());
910 }
911 }
912
Adam Cohenbfbfd262011-06-13 16:55:12 -0700913 public void onDrop(DragObject d) {
914 ShortcutInfo item;
915 if (d.dragInfo instanceof ApplicationInfo) {
916 // Came from all apps -- make a copy
917 item = ((ApplicationInfo) d.dragInfo).makeShortcut();
918 item.spanX = 1;
919 item.spanY = 1;
920 } else {
921 item = (ShortcutInfo) d.dragInfo;
922 }
Adam Cohen05e0f402011-08-01 12:12:49 -0700923 // Dragged from self onto self, currently this is the only path possible, however
924 // we keep this as a distinct code path.
Adam Cohenbfbfd262011-06-13 16:55:12 -0700925 if (item == mCurrentDragInfo) {
926 ShortcutInfo si = (ShortcutInfo) mCurrentDragView.getTag();
927 CellLayout.LayoutParams lp = (CellLayout.LayoutParams) mCurrentDragView.getLayoutParams();
928 si.cellX = lp.cellX = mEmptyCell[0];
929 si.cellX = lp.cellY = mEmptyCell[1];
930 mContent.addViewToCellLayout(mCurrentDragView, -1, (int)item.id, lp, true);
Adam Cohenfc53cd22011-07-20 15:45:11 -0700931 if (d.dragView.hasDrawn()) {
932 mLauncher.getDragLayer().animateViewIntoPosition(d.dragView, mCurrentDragView);
933 } else {
934 mCurrentDragView.setVisibility(VISIBLE);
935 }
Adam Cohene9166b22011-07-08 17:11:11 -0700936 mItemsInvalidated = true;
Adam Cohen4045eb72011-10-06 11:44:26 -0700937 setupContentDimensions(getItemCount());
Adam Cohen716b51e2011-06-30 12:09:54 -0700938 mSuppressOnAdd = true;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700939 }
940 mInfo.add(item);
941 }
942
943 public void onAdd(ShortcutInfo item) {
944 mItemsInvalidated = true;
Adam Cohen05e0f402011-08-01 12:12:49 -0700945 // If the item was dropped onto this open folder, we have done the work associated
946 // with adding the item to the folder, as indicated by mSuppressOnAdd being set
Adam Cohenbfbfd262011-06-13 16:55:12 -0700947 if (mSuppressOnAdd) return;
948 if (!findAndSetEmptyCells(item)) {
949 // The current layout is full, can we expand it?
950 setupContentForNumItems(getItemCount() + 1);
951 findAndSetEmptyCells(item);
952 }
953 createAndAddShortcut(item);
954 LauncherModel.addOrMoveItemInDatabase(
955 mLauncher, item, mInfo.id, 0, item.cellX, item.cellY);
956 }
957
Adam Cohena9cf38f2011-05-02 15:36:58 -0700958 public void onRemove(ShortcutInfo item) {
Adam Cohen7c693212011-05-18 15:26:57 -0700959 mItemsInvalidated = true;
Adam Cohen05e0f402011-08-01 12:12:49 -0700960 // If this item is being dragged from this open folder, we have already handled
961 // the work associated with removing the item, so we don't have to do anything here.
Adam Cohenbfbfd262011-06-13 16:55:12 -0700962 if (item == mCurrentDragInfo) return;
Adam Cohendf1e4e82011-06-24 15:57:39 -0700963 View v = getViewForInfo(item);
Adam Cohena9cf38f2011-05-02 15:36:58 -0700964 mContent.removeView(v);
Adam Cohen2801caf2011-05-13 20:57:39 -0700965 if (mState == STATE_ANIMATING) {
966 mRearrangeOnClose = true;
967 } else {
968 setupContentForNumItems(getItemCount());
969 }
Adam Cohenafb01ee2011-06-23 15:38:03 -0700970 if (getItemCount() <= 1) {
971 replaceFolderWithFinalItem();
972 }
Adam Cohena9cf38f2011-05-02 15:36:58 -0700973 }
Adam Cohen7c693212011-05-18 15:26:57 -0700974
Adam Cohendf1e4e82011-06-24 15:57:39 -0700975 private View getViewForInfo(ShortcutInfo item) {
976 for (int j = 0; j < mContent.getCountY(); j++) {
977 for (int i = 0; i < mContent.getCountX(); i++) {
978 View v = mContent.getChildAt(i, j);
979 if (v.getTag() == item) {
980 return v;
981 }
982 }
983 }
984 return null;
985 }
986
Adam Cohen76078c42011-06-09 15:06:52 -0700987 public void onItemsChanged() {
Adam Cohenac56cff2011-09-28 20:45:37 -0700988 updateTextViewFocus();
Adam Cohen76078c42011-06-09 15:06:52 -0700989 }
Adam Cohenac56cff2011-09-28 20:45:37 -0700990
Adam Cohen76fc0852011-06-17 13:26:23 -0700991 public void onTitleChanged(CharSequence title) {
992 }
Adam Cohen76078c42011-06-09 15:06:52 -0700993
Adam Cohen7c693212011-05-18 15:26:57 -0700994 public ArrayList<View> getItemsInReadingOrder() {
Adam Cohen76078c42011-06-09 15:06:52 -0700995 return getItemsInReadingOrder(true);
996 }
997
998 public ArrayList<View> getItemsInReadingOrder(boolean includeCurrentDragItem) {
Adam Cohen7c693212011-05-18 15:26:57 -0700999 if (mItemsInvalidated) {
1000 mItemsInReadingOrder.clear();
1001 for (int j = 0; j < mContent.getCountY(); j++) {
1002 for (int i = 0; i < mContent.getCountX(); i++) {
1003 View v = mContent.getChildAt(i, j);
1004 if (v != null) {
Adam Cohen76078c42011-06-09 15:06:52 -07001005 ShortcutInfo info = (ShortcutInfo) v.getTag();
1006 if (info != mCurrentDragInfo || includeCurrentDragItem) {
1007 mItemsInReadingOrder.add(v);
1008 }
Adam Cohen7c693212011-05-18 15:26:57 -07001009 }
1010 }
1011 }
1012 mItemsInvalidated = false;
1013 }
1014 return mItemsInReadingOrder;
1015 }
Adam Cohen8dfcba42011-07-07 16:38:18 -07001016
1017 public void getLocationInDragLayer(int[] loc) {
1018 mLauncher.getDragLayer().getLocationInDragLayer(this, loc);
1019 }
Adam Cohenea0818d2011-09-30 20:06:58 -07001020
1021 public void onFocusChange(View v, boolean hasFocus) {
1022 if (v == mFolderName && hasFocus) {
1023 startEditingFolderName();
1024 }
1025 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001026}