Rework app list item drag zones.

ui/app_list/views/apps_grid_view.h

 // 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.
 
 #ifndef UI_APP_LIST_VIEWS_APPS_GRID_VIEW_H_
 #define UI_APP_LIST_VIEWS_APPS_GRID_VIEW_H_
 
 #include <set>
 #include <string>
 
@@ skipping 217 matching lines @@
   struct Index {
     Index() : page(-1), slot(-1) {}
     Index(int page, int slot) : page(page), slot(slot) {}
 
     bool operator==(const Index& other) const {
       return page == other.page && slot == other.slot;
     }
     bool operator!=(const Index& other) const {
       return page != other.page || slot != other.slot;
     }
+    bool operator<(const Index& other) const {
+      if (page != other.page)
+        return page < other.page;
+
+      return slot < other.slot;
+    }
 
     int page;  // Which page an item view is on.
     int slot;  // Which slot in the page an item view is in.
   };
 
   int tiles_per_page() const { return cols_ * rows_per_page_; }
 
   // Updates from model.
   void Update();
 
@@ skipping 11 matching lines @@
   // struct above with page/slot info of where to display the item.
   Index GetIndexFromModelIndex(int model_index) const;
   int GetModelIndexFromIndex(const Index& index) const;
 
   void SetSelectedItemByIndex(const Index& index);
   bool IsValidIndex(const Index& index) const;
 
   Index GetIndexOfView(const views::View* view) const;
   views::View* GetViewAtIndex(const Index& index) const;
 
+  // Gets the index of the AppListItemView at the end of the view model.
+  Index GetLastViewIndex() const;
+
   void MoveSelected(int page_delta, int slot_x_delta, int slot_y_delta);
 
   void CalculateIdealBounds();
   void AnimateToIdealBounds();
 
   // Invoked when the given |view|'s current bounds and target bounds are on
   // different rows. To avoid moving diagonally, |view| would be put into a
   // slot prior |target| and fade in while moving to |target|. In the meanwhile,
   // a layer copy of |view| would start at |current| and fade out while moving
   // to succeeding slot of |current|. |animate_current| controls whether to run
   // fading out animation from |current|. |animate_target| controls whether to
   // run fading in animation to |target|.
   void AnimationBetweenRows(views::View* view,
                             bool animate_current,
                             const gfx::Rect& current,
                             bool animate_target,
                             const gfx::Rect& target);
 
   // Extracts drag location info from |event| into |drag_point|.
   void ExtractDragLocation(const ui::LocatedEvent& event,
                            gfx::Point* drag_point);
 
-  // Calculates reorder and folder drop targets based on |drag_point|.
-  // |drag_point| is in the grid view's coordinates. When
-  // |use_page_button_hovering| is true and |drag_point| is hovering on a page
-  // button, use the last slot on that page as drop target.
-  void CalculateDropTarget(const gfx::Point& drag_point,
-                           bool use_page_button_hovering);
+  // Updates |reorder_drop_target_|, |folder_drop_target_| and |drop_attempt_|
+  // based on |drag_view_|'s position.
+  void CalculateDropTarget();
 
-  // Same as CalculateDropTarget, but with folder UI enabled. The drop target
-  // can be either a target for re-ordering, or a target folder to move the
-  // dragged item into if |drag_view_| enters its re-ordering or folder
-  // dropping circle.
-  void CalculateDropTargetWithFolderEnabled(const gfx::Point& drag_point,
-                                            bool use_page_button_hovering);
+  // If |point| is a valid folder drop target, returns true and sets
+  // |drop_target| to the index of the view to do a folder drop for.
+  bool CalculateFolderDropTarget(const gfx::Point& point,
+                                 Index* drop_target) const;
+
+  // Calculates the reorder target |point| and sets |drop_target| to the index
+  // of the view to reorder.
+  void CalculateReorderDropTarget(const gfx::Point& point,
+                                  Index* drop_target) const;
 
   // Prepares |drag_and_drop_host_| for dragging. |grid_location| contains
   // the drag point in this grid view's coordinates.
   void StartDragAndDropHostDrag(const gfx::Point& grid_location);
 
   // Dispatch the drag and drop update event to the dnd host (if needed).
   void DispatchDragEventToDragAndDropHost(
       const gfx::Point& location_in_screen_coordinates);
 
   // Starts the page flip timer if |drag_point| is in left/right side page flip
@@ skipping 67 matching lines @@
   // changing the size of it. If |immediate| is set the change will be
   // immediately applied - otherwise it will change gradually.
   // If |hide| is set the view will get hidden, otherwise it gets shown.
   void SetViewHidden(views::View* view, bool hide, bool immediate);
 
   // Whether the folder drag-and-drop UI should be enabled.
   bool EnableFolderDragDropUI();
 
   // Whether target specified by |drap_target| can accept more items to be
   // dropped into it.
-  bool CanDropIntoTarget(const Index& drop_target);
-
-  // Calculates the visual index of the nearest tile for which |drag_view_|
-  // enters either its re-ordering or folder dropping circle.
-  void CalculateNearestTileForDragView();
-
-  // Calculates |nearest_tile| in which |vertex| of the |drag_view| is
-  // enclosed.
-  // *|nearest_tile| and *|d_min| will be updated based on the calculation.
-  // *|d_min| is the distance between |nearest_tile| and |drag_view_|.
-  void CalculateNearestTileForVertex(
-      const gfx::Point& vertex, Index* nearest_tile, int* d_min);
-
-  // Returns the bounds of the tile in which |point| is enclosed if there
-  // is a valid item sits on the tile.
-  gfx::Rect GetTileBoundsForPoint(const gfx::Point& point, Index* tile_index);
+  bool CanDropIntoTarget(const Index& drop_target) const;
 
   // Returns the size of the entire tile grid.
   gfx::Size GetTileGridSize() const;
 
-  // Gets the expected bounds of a tile located at |row| and |col| on the
-  // current page.
+  // Returns the slot number which the given |point| falls into or the closest
+  // slot if |point| is outside the page's bounds.
+  Index GetNearestTileIndexForPoint(const gfx::Point& point) const;
+
+  // Gets the bounds of the tile located at |slot| on the current page.
+  gfx::Rect GetExpectedTileBounds(int slot) const;
+
+  // Gets the bounds of the tile located at |row| and |col| on the current page.
   gfx::Rect GetExpectedTileBounds(int row, int col) const;
 
-  // Returns true if the slot of |index| is the last possible slot to drop
-  // an item, i.e. first empty slot next to the last item on the last page.
-  bool IsLastPossibleDropTarget(const Index& index) const;
-
   // Gets the item view located at |slot| on the current page. If there is
   // no item located at |slot|, returns NULL.
   views::View* GetViewAtSlotOnCurrentPage(int slot);
 
   // Sets state of the view with |target_index| to |is_target_folder| for
   // dropping |drag_view_|.
   void SetAsFolderDroppingTarget(const Index& target_index,
                                  bool is_target_folder);
 
   // Invoked when |reorder_timer_| fires to show re-order preview UI.
@@ skipping 84 matching lines @@
 #endif
 
   Pointer drag_pointer_;
 
   // The most recent reorder drop target.
   Index reorder_drop_target_;
 
   // The most recent folder drop target.
   Index folder_drop_target_;
 
+  // The index where an empty slot has been left as a placeholder for the
+  // reorder drop target. This updates when the reorder animation triggers.
+  Index reorder_placeholder_;
+
   // The current action that ending a drag will perform.
   DropAttempt drop_attempt_;
 
   // Timer for re-ordering the |drop_target_| and |drag_view_|.
   base::OneShotTimer<AppsGridView> reorder_timer_;
 
   // Timer for dropping |drag_view_| into the folder containing
   // the |drop_target_|.
   base::OneShotTimer<AppsGridView> folder_dropping_timer_;
 
@@ skipping 31 matching lines @@
 
   // True if the drag_view_ item is a folder item being dragged for reparenting.
   bool dragging_for_reparent_item_;
 
   DISALLOW_COPY_AND_ASSIGN(AppsGridView);
 };
 
 }  // namespace app_list
 
 #endif  // UI_APP_LIST_VIEWS_APPS_GRID_VIEW_H_