Split app list drop target into reorder and folder drop targets.

ui/app_list/views/apps_grid_view.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/app_list/views/apps_grid_view.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
@@ skipping 598 matching lines @@
 
     StartSettingUpSynchronousDrag();
     if (!dragging_for_reparent_item_)
       StartDragAndDropHostDrag(point);
   }
 
   if (drag_pointer_ != pointer)
     return;
 
   last_drag_point_ = point;
-  const Index last_drop_target = drop_target_;
+  const Index last_reorder_drop_target = reorder_drop_target_;
+  const Index last_folder_drop_target = folder_drop_target_;
   DropAttempt last_drop_attempt = drop_attempt_;
   CalculateDropTarget(last_drag_point_, false);
 
   if (IsPointWithinDragBuffer(last_drag_point_))
     MaybeStartPageFlipTimer(last_drag_point_);
   else
     StopPageFlipTimer();
 
   if (page_switcher_view_) {
     gfx::Point page_switcher_point(last_drag_point_);
     views::View::ConvertPointToTarget(
         this, page_switcher_view_, &page_switcher_point);
     page_switcher_view_->UpdateUIForDragPoint(page_switcher_point);
   }
 
   if (!EnableFolderDragDropUI()) {
-    if (last_drop_target != drop_target_)
+    if (last_reorder_drop_target != reorder_drop_target_)
       AnimateToIdealBounds();
     drag_view_->SetPosition(drag_view_start_ + drag_vector);
     return;
   }
 
   // Update drag with folder UI enabled.
-  if (last_drop_target != drop_target_ ||
+  if (last_folder_drop_target != folder_drop_target_ ||
+      last_reorder_drop_target != reorder_drop_target_ ||
       last_drop_attempt != drop_attempt_) {
     if (drop_attempt_ == DROP_FOR_REORDER) {
       folder_dropping_timer_.Stop();
       reorder_timer_.Start(FROM_HERE,
           base::TimeDelta::FromMilliseconds(kReorderDelay),
           this, &AppsGridView::OnReorderTimer);
     } else if (drop_attempt_ == DROP_FOR_FOLDER) {
       reorder_timer_.Stop();
       folder_dropping_timer_.Start(FROM_HERE,
           base::TimeDelta::FromMilliseconds(kFolderDroppingDelay),
           this, &AppsGridView::OnFolderDroppingTimer);
     }
 
     // Reset the previous drop target.
-    SetAsFolderDroppingTarget(last_drop_target, false);
+    SetAsFolderDroppingTarget(last_folder_drop_target, false);
   }
 
   drag_view_->SetPosition(drag_view_start_ + drag_vector);
 }
 
 void AppsGridView::EndDrag(bool cancel) {
   // EndDrag was called before if |drag_view_| is NULL.
   if (!drag_view_)
     return;
 
@@ skipping 22 matching lines @@
       // An EndDrag can be received during a reparent via a model change. This
       // is always a cancel and needs to be forwarded to the folder.
       DCHECK(cancel);
       delegate_->CancelDragInActiveFolder();
       return;
     }
 
     if (!cancel && dragging()) {
       // Regular drag ending path, ie, not for reparenting.
       CalculateDropTarget(last_drag_point_, true);
-      if (IsValidIndex(drop_target_)) {
-        if (!EnableFolderDragDropUI()) {
-            MoveItemInModel(drag_view_, drop_target_);
-        } else {
-          if (drop_attempt_ == DROP_FOR_REORDER)
-            MoveItemInModel(drag_view_, drop_target_);
-          else if (drop_attempt_ == DROP_FOR_FOLDER)
-            MoveItemToFolder(drag_view_, drop_target_);
-        }
+      if (EnableFolderDragDropUI() && drop_attempt_ == DROP_FOR_FOLDER &&
+          IsValidIndex(folder_drop_target_)) {
+        MoveItemToFolder(drag_view_, folder_drop_target_);
+      } else if (IsValidIndex(reorder_drop_target_)) {
+        MoveItemInModel(drag_view_, reorder_drop_target_);
       }
     }
   }
 
   if (drag_and_drop_host_) {
     // If we had a drag and drop proxy icon, we delete it and make the real
     // item visible again.
     drag_and_drop_host_->DestroyDragIconProxy();
     if (landed_in_drag_and_drop_host) {
       // Move the item directly to the target location, avoiding the "zip back"
       // animation if the user was pinning it to the shelf.
-      int i = drop_target_.slot;
+      int i = reorder_drop_target_.slot;
       gfx::Rect bounds = view_model_.ideal_bounds(i);
       drag_view_->SetBoundsRect(bounds);
     }
     // Fade in slowly if it landed in the shelf.
     SetViewHidden(drag_view_,
                   false /* show */,
                   !landed_in_drag_and_drop_host /* animate */);
   }
 
   // The drag can be ended after the synchronous drag is created but before it
   // is Run().
   CleanUpSynchronousDrag();
 
-  SetAsFolderDroppingTarget(drop_target_, false);
+  SetAsFolderDroppingTarget(folder_drop_target_, false);
   ClearDragState();
   AnimateToIdealBounds();
 
   StopPageFlipTimer();
 
   // If user releases mouse inside a folder's grid view, burst the folder
   // container ink bubble.
   if (folder_delegate_ && !IsDraggingForReparentInHiddenGridView())
     folder_delegate_->UpdateFolderViewBackground(false);
 }
@@ skipping 80 matching lines @@
   UpdateDrag(pointer, drag_point);
 }
 
 bool AppsGridView::IsDraggedView(const views::View* view) const {
   return drag_view_ == view;
 }
 
 void AppsGridView::ClearDragState() {
   drop_attempt_ = DROP_FOR_NONE;
   drag_pointer_ = NONE;
-  drop_target_ = Index();
+  reorder_drop_target_ = Index();
+  folder_drop_target_ = Index();
   drag_start_grid_view_ = gfx::Point();
   drag_start_page_ = -1;
   drag_view_offset_ = gfx::Point();
 
   if (drag_view_) {
     drag_view_->OnDragEnded();
     if (IsDraggingForReparentInRootLevelGridView()) {
       const int drag_view_index = view_model_.GetIndexOfView(drag_view_);
       CHECK_EQ(view_model_.view_size() - 1, drag_view_index);
       DeleteItemViewAtIndex(drag_view_index);
@@ skipping 334 matching lines @@
   int slot_index = 0;
   for (int i = 0; i < total_views; ++i) {
     if (i < view_model_.view_size() && view_model_.view_at(i) == drag_view_) {
       if (EnableFolderDragDropUI() && drop_attempt_ == DROP_FOR_FOLDER)
         ++slot_index;
       continue;
     }
 
     Index view_index = GetIndexFromModelIndex(slot_index);
 
-    if (drop_target_ == view_index) {
-      if (EnableFolderDragDropUI() && drop_attempt_ == DROP_FOR_FOLDER) {
-        view_index = GetIndexFromModelIndex(slot_index);
-      } else if (!EnableFolderDragDropUI() ||
-                 drop_attempt_ == DROP_FOR_REORDER) {
-        ++slot_index;
-        view_index = GetIndexFromModelIndex(slot_index);
-      }
+    // Leaves a blank space in the grid for the current reorder drop target.
+    if (reorder_drop_target_ == view_index &&
+        drop_attempt_ == DROP_FOR_REORDER) {
+      ++slot_index;
+      view_index = GetIndexFromModelIndex(slot_index);
     }
 
     // Decide the x or y offset for current item.
     int x_offset = 0;
     int y_offset = 0;
 
     if (pagination_controller_->scroll_axis() ==
         PaginationController::SCROLL_AXIS_HORIZONTAL) {
       if (view_index.page < current_page)
         x_offset = -page_width;
@@ skipping 137 matching lines @@
 #endif
 }
 
 void AppsGridView::CalculateDropTarget(const gfx::Point& drag_point,
                                        bool use_page_button_hovering) {
   if (EnableFolderDragDropUI()) {
     CalculateDropTargetWithFolderEnabled(drag_point, use_page_button_hovering);
     return;
   }
 
+  drop_attempt_ = DROP_FOR_REORDER;
+
   int current_page = pagination_model_.selected_page();
   gfx::Point point(drag_point);
   if (!IsPointWithinDragBuffer(drag_point)) {
     point = drag_start_grid_view_;
     current_page = drag_start_page_;
   }
 
   if (use_page_button_hovering && page_switcher_view_ &&
       page_switcher_view_->bounds().Contains(point)) {
     gfx::Point page_switcher_point(point);
     views::View::ConvertPointToTarget(this, page_switcher_view_,
                                       &page_switcher_point);
     int page = page_switcher_view_->GetPageForPoint(page_switcher_point);
     if (pagination_model_.is_valid_page(page)) {
-      drop_target_.page = page;
-      drop_target_.slot = tiles_per_page() - 1;
+      reorder_drop_target_.page = page;
+      reorder_drop_target_.slot = tiles_per_page() - 1;
     }
   } else {
     gfx::Rect bounds(GetContentsBounds());
     const int drop_row = (point.y() - bounds.y()) / kPreferredTileHeight;
     const int drop_col = std::min(cols_ - 1,
         (point.x() - bounds.x()) / kPreferredTileWidth);
 
-    drop_target_.page = current_page;
-    drop_target_.slot = std::max(0, std::min(
-        tiles_per_page() - 1,
-        drop_row * cols_ + drop_col));
+    reorder_drop_target_.page = current_page;
+    reorder_drop_target_.slot = std::max(
+        0, std::min(tiles_per_page() - 1, drop_row * cols_ + drop_col));
   }
 
   // Limits to the last possible slot on last page.
-  if (drop_target_.page == pagination_model_.total_pages() - 1) {
-    drop_target_.slot = std::min(
-        (view_model_.view_size() - 1) % tiles_per_page(),
-        drop_target_.slot);
+  if (reorder_drop_target_.page == pagination_model_.total_pages() - 1) {
+    reorder_drop_target_.slot =
+        std::min((view_model_.view_size() - 1) % tiles_per_page(),
+                 reorder_drop_target_.slot);
   }
 }
 
 
 void AppsGridView::CalculateDropTargetWithFolderEnabled(
     const gfx::Point& drag_point,
     bool use_page_button_hovering) {

[Matt Giuca, 2014/09/12 01:13:28]

Shouldn't this set drop_attempt_ to DROP_FOR_FOLDER if successful?

(Since it sets drop_attempt_ = DROP_FOR_NONE in other cases, and also since
CalculateDropTarget is now setting DROP_FOR_REORDER -- it seems logical to set
drop_attempt_ in all situations, rather than leaving it unchanged in the folder
case.)

[calamity, 2014/09/12 08:26:06]

I think this will be fine for now. This is all getting blown away soon anyhow.

   gfx::Point point(drag_point);
   if (!IsPointWithinDragBuffer(drag_point)) {
     point = drag_start_grid_view_;
   }
 
   if (use_page_button_hovering && page_switcher_view_ &&
       page_switcher_view_->bounds().Contains(point)) {
     gfx::Point page_switcher_point(point);
     views::View::ConvertPointToTarget(this, page_switcher_view_,
                                       &page_switcher_point);
     int page = page_switcher_view_->GetPageForPoint(page_switcher_point);
     if (pagination_model_.is_valid_page(page))
       drop_attempt_ = DROP_FOR_NONE;
   } else {
     DCHECK(drag_view_);
     // Try to find the nearest target for folder dropping or re-ordering.
-    drop_target_ = GetNearestTileForDragView();
+    CalculateNearestTileForDragView();
   }
 }
 
 void AppsGridView::OnReorderTimer() {
   if (drop_attempt_ == DROP_FOR_REORDER)
     AnimateToIdealBounds();
 }
 
 void AppsGridView::OnFolderItemReparentTimer() {
   DCHECK(folder_delegate_);
   if (drag_out_of_folder_container_ && drag_view_) {
     folder_delegate_->ReparentItem(drag_view_, last_drag_point_);
 
     // Set the flag in the folder's grid view.
     dragging_for_reparent_item_ = true;
 
     // Do not observe any data change since it is going to be hidden.
     item_list_->RemoveObserver(this);
     item_list_ = NULL;
   }
 }
 
 void AppsGridView::OnFolderDroppingTimer() {
   if (drop_attempt_ == DROP_FOR_FOLDER)
-    SetAsFolderDroppingTarget(drop_target_, true);
+    SetAsFolderDroppingTarget(folder_drop_target_, true);
 }
 
 void AppsGridView::UpdateDragStateInsideFolder(Pointer pointer,
                                                const gfx::Point& drag_point) {
   if (IsUnderOEMFolder())
     return;
 
   if (IsDraggingForReparentInHiddenGridView()) {
     // Dispatch drag event to root level grid view for re-parenting folder
     // folder item purpose.
@@ skipping 62 matching lines @@
     bool events_forwarded_to_drag_drop_host,
     bool cancel_drag) {
   // EndDrag was called before if |drag_view_| is NULL.
   if (!drag_view_)
     return;
 
   DCHECK(IsDraggingForReparentInRootLevelGridView());
   bool cancel_reparent = cancel_drag || drop_attempt_ == DROP_FOR_NONE;
   if (!events_forwarded_to_drag_drop_host && !cancel_reparent) {
     CalculateDropTarget(last_drag_point_, true);
-    if (IsValidIndex(drop_target_)) {
-      if (drop_attempt_ == DROP_FOR_REORDER) {
-        ReparentItemForReorder(drag_view_, drop_target_);
-      } else if (drop_attempt_ == DROP_FOR_FOLDER) {
-        ReparentItemToAnotherFolder(drag_view_, drop_target_);
-      }
+    if (drop_attempt_ == DROP_FOR_REORDER &&
+        IsValidIndex(reorder_drop_target_)) {
+      ReparentItemForReorder(drag_view_, reorder_drop_target_);
+    } else if (drop_attempt_ == DROP_FOR_FOLDER &&
+               IsValidIndex(folder_drop_target_)) {
+      ReparentItemToAnotherFolder(drag_view_, folder_drop_target_);
     }
     SetViewHidden(drag_view_, false /* show */, true /* no animate */);
   }
 
   // The drag can be ended after the synchronous drag is created but before it
   // is Run().
   CleanUpSynchronousDrag();
 
-  SetAsFolderDroppingTarget(drop_target_, false);
+  SetAsFolderDroppingTarget(folder_drop_target_, false);
   if (cancel_reparent) {
     CancelFolderItemReparent(drag_view_);
   } else {
     // By setting |drag_view_| to NULL here, we prevent ClearDragState() from
     // cleaning up the newly created AppListItemView, effectively claiming
     // ownership of the newly created drag view.
     drag_view_->OnDragEnded();
     drag_view_ = NULL;
   }
   ClearDragState();
   AnimateToIdealBounds();
 
   StopPageFlipTimer();
 }
 
 void AppsGridView::EndDragForReparentInHiddenFolderGridView() {
   if (drag_and_drop_host_) {
     // If we had a drag and drop proxy icon, we delete it and make the real
     // item visible again.
     drag_and_drop_host_->DestroyDragIconProxy();
   }
 
   // The drag can be ended after the synchronous drag is created but before it
   // is Run().
   CleanUpSynchronousDrag();
 
-  SetAsFolderDroppingTarget(drop_target_, false);
+  SetAsFolderDroppingTarget(folder_drop_target_, false);
   ClearDragState();
 }
 
 void AppsGridView::OnFolderItemRemoved() {
   DCHECK(folder_delegate_);
   item_list_ = NULL;
 }
 
 void AppsGridView::StartDragAndDropHostDrag(const gfx::Point& grid_location) {
   // When a drag and drop host is given, the item can be dragged out of the app
@@ skipping 468 matching lines @@
 
 void AppsGridView::OnImplicitAnimationsCompleted() {
   if (layer()->opacity() == 0.0f)
     SetVisible(false);
 }
 
 bool AppsGridView::EnableFolderDragDropUI() {
   // Enable drag and drop folder UI only if it is at the app list root level
   // and the switch is on and the target folder can still accept new items.
   return model_->folders_enabled() && !folder_delegate_ &&
-      CanDropIntoTarget(drop_target_);
+         CanDropIntoTarget(folder_drop_target_);
 }
 
 bool AppsGridView::CanDropIntoTarget(const Index& drop_target) {
   views::View* target_view = GetViewAtSlotOnCurrentPage(drop_target.slot);
   if (!target_view)
     return true;
 
   AppListItem* target_item =
       static_cast<AppListItemView*>(target_view)->item();
   // Items can be dropped into non-folders (which have no children) or folders
   // that have fewer than the max allowed items.
   // OEM folder does not allow to drag/drop other items in it.
   return target_item->ChildItemCount() < kMaxFolderItems &&
          !IsOEMFolderItem(target_item);
 }
 
 // TODO(jennyz): Optimize the calculation for finding nearest tile.
-AppsGridView::Index AppsGridView::GetNearestTileForDragView() {
+void AppsGridView::CalculateNearestTileForDragView() {
   Index nearest_tile;
   nearest_tile.page = -1;
   nearest_tile.slot = -1;
   int d_min = -1;
 
   // Calculate the top left tile |drag_view| intersects.
   gfx::Point pt = drag_view_->bounds().origin();
   CalculateNearestTileForVertex(pt, &nearest_tile, &d_min);
 
   // Calculate the top right tile |drag_view| intersects.
@@ skipping 10 matching lines @@
 
   const int d_folder_dropping =
       kFolderDroppingCircleRadius + kGridIconDimension / 2;
   const int d_reorder = kReorderDroppingCircleRadius + kGridIconDimension / 2;
 
   // If user drags an item across pages to the last page, and targets it
   // to the last empty slot on it, push the last item for re-ordering.
   if (IsLastPossibleDropTarget(nearest_tile) && d_min < d_reorder) {
     drop_attempt_ = DROP_FOR_REORDER;
     nearest_tile.slot = nearest_tile.slot - 1;
-    return nearest_tile;
+    reorder_drop_target_ = nearest_tile;
+    return;
   }
 
   if (IsValidIndex(nearest_tile)) {
     if (d_min < d_folder_dropping) {
       views::View* target_view = GetViewAtSlotOnCurrentPage(nearest_tile.slot);
       if (target_view &&
           !IsFolderItem(static_cast<AppListItemView*>(drag_view_)->item())) {
         // If a non-folder item is dragged to the target slot with an item
         // sitting on it, attempt to drop the dragged item into the folder
         // containing the item on nearest_tile.
         drop_attempt_ = DROP_FOR_FOLDER;
-        return nearest_tile;
+        folder_drop_target_ = nearest_tile;
+        return;
       } else {
         // If the target slot is blank, or the dragged item is a folder, attempt
         // to re-order.
         drop_attempt_ = DROP_FOR_REORDER;
-        return nearest_tile;
+        reorder_drop_target_ = nearest_tile;
+        return;
       }
     } else if (d_min < d_reorder) {
       // Entering the re-order circle of the slot.
       drop_attempt_ = DROP_FOR_REORDER;
-      return nearest_tile;
+      reorder_drop_target_ = nearest_tile;
+      return;
     }
   }
 
-  // If |drag_view| is not entering the re-order or fold dropping region of
-  // any items, cancel any previous re-order or folder dropping timer, and
-  // return itself.
+  // If |drag_view| is not entering the re-order or folder dropping region of
+  // any items, cancel any previous re-order or folder dropping timer.
   drop_attempt_ = DROP_FOR_NONE;
   reorder_timer_.Stop();
   folder_dropping_timer_.Stop();
 
   // When dragging for reparent a folder item, it should go back to its parent
   // folder item if there is no drop target.
   if (IsDraggingForReparentInRootLevelGridView()) {
     DCHECK(activated_folder_item_view_);
-    return GetIndexOfView(activated_folder_item_view_);
+    folder_drop_target_ = GetIndexOfView(activated_folder_item_view_);
   }
-
-  return GetIndexOfView(drag_view_);
 }
 
 void AppsGridView::CalculateNearestTileForVertex(const gfx::Point& vertex,
                                                  Index* nearest_tile,
                                                  int* d_min) {
   Index target_index;
   gfx::Rect target_bounds = GetTileBoundsForPoint(vertex, &target_index);
 
   if (target_bounds.IsEmpty() || target_index == *nearest_tile)
     return;
@@ skipping 73 matching lines @@
 void AppsGridView::SetAsFolderDroppingTarget(const Index& target_index,
                                              bool is_target_folder) {
   AppListItemView* target_view =
       static_cast<AppListItemView*>(
           GetViewAtSlotOnCurrentPage(target_index.slot));
   if (target_view)
     target_view->SetAsAttemptedFolderTarget(is_target_folder);
 }
 
 }  // namespace app_list