Make dragging outside the app list scroll back to its original position.

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 "ui/app_list/app_list_item_model.h"
 #include "ui/app_list/apps_grid_view_delegate.h"
@@ skipping 18 matching lines @@
 #include "base/files/file_path.h"
 #include "base/win/shortcut.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/dragdrop/drop_target_win.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_win.h"
 #endif
 
 namespace {
 
+// Distance a drag needs to be from the app grid to be considered 'outside', at
+// which point we rearrange the apps to their pre-drag configuration, as a drop
+// then would be canceled. We have a buffer to make it easier to drag apps to
+// other pages.
+const int kDragBufferPx = 20;
+
 // Padding space in pixels for fixed layout.
 const int kLeftRightPadding = 20;
 const int kTopPadding = 1;
 
 // Padding space in pixels between pages.
 const int kPagePadding = 40;
 
 // Preferred tile size when showing in fixed layout.
 const int kPreferredTileWidth = 88;
 const int kPreferredTileHeight = 98;
@@ skipping 127 matching lines @@
   virtual void OnDragSourceCancel() OVERRIDE {
     canceled_ = true;
   }
 
   virtual void OnDragSourceDrop() OVERRIDE {
   }
 
   virtual void OnDragSourceMove() OVERRIDE {
     grid_view_->UpdateDrag(app_list::AppsGridView::MOUSE,
                            GetCursorInGridViewCoords());
-
-    // Don't turn pages if the cursor is dragged outside the view.
-    if (!IsCursorWithinGridView())
-      grid_view_->StopPageFlipTimer();
   }
 
   void SetupExchangeData(ui::OSExchangeData* data) {
     data->SetFilename(shortcut_path_);
     gfx::ImageSkia image(drag_view_->GetDragImage());
     gfx::Size image_size(image.size());
     drag_utils::SetDragImageOnDataObject(
         image,
         image.size(),
         gfx::Vector2d(drag_view_offset_.x(), drag_view_offset_.y()),
@@ skipping 34 matching lines @@
 AppsGridView::AppsGridView(AppsGridViewDelegate* delegate,
                            PaginationModel* pagination_model)
     : model_(NULL),
       delegate_(delegate),
       pagination_model_(pagination_model),
       page_switcher_view_(new PageSwitcher(pagination_model)),
       cols_(0),
       rows_per_page_(0),
       selected_view_(NULL),
       drag_view_(NULL),
+      drag_start_page_(-1),
       drag_pointer_(NONE),
       drag_and_drop_host_(NULL),
       forward_events_to_drag_and_drop_host_(false),
       page_flip_target_(-1),
       page_flip_delay_in_ms_(kPageFlipDelayInMs),
       bounds_animator_(this) {
   last_created_grid_view_for_test = this;
   pagination_model_->AddObserver(this);
   AddChildView(page_switcher_view_);
 }
@@ skipping 62 matching lines @@
 
 void AppsGridView::InitiateDrag(AppListItemView* view,
                                 Pointer pointer,
                                 const ui::LocatedEvent& event) {
   DCHECK(view);
   if (drag_view_ || pulsing_blocks_model_.view_size())
     return;
 
   drag_view_ = view;
   drag_view_offset_ = event.location();
+  drag_start_page_ = pagination_model_->selected_page();
   ExtractDragLocation(event, &drag_start_grid_view_);
   drag_view_start_ = gfx::Point(drag_view_->x(), drag_view_->y());
 }
 
 void AppsGridView::OnGotShortcutPath(const base::FilePath& path) {
 #if defined(OS_WIN) && !defined(USE_AURA)
   // Drag may have ended before we get the shortcut path.
   if (!synchronous_drag_)
     return;
   // Setting the shortcut path here means the next time we hit UpdateDrag()
@@ skipping 64 matching lines @@
     StartDragAndDropHostDrag(point);
   }
 
   if (drag_pointer_ != pointer)
     return;
 
   last_drag_point_ = point;
   const Index last_drop_target = drop_target_;
   CalculateDropTarget(last_drag_point_, false);
 
-  MaybeStartPageFlipTimer(last_drag_point_);
+  if (IsPointWithinDragBuffer(last_drag_point_))
+    MaybeStartPageFlipTimer(last_drag_point_);
+  else
+    StopPageFlipTimer();
 
   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 (last_drop_target != drop_target_)
     AnimateToIdealBounds();
 
   drag_view_->SetPosition(drag_view_start_ + drag_vector);
@@ skipping 20 matching lines @@
     HideView(drag_view_, false);
   }
 
   // The drag can be ended after the synchronous drag is created but before it
   // is Run().
   CleanUpSynchronousDrag();
 
   drag_pointer_ = NONE;
   drop_target_ = Index();
   drag_view_ = NULL;
+  drag_start_grid_view_ = gfx::Point();
+  drag_start_page_ = -1;
+  drag_view_offset_ = gfx::Point();
   AnimateToIdealBounds();
 
   StopPageFlipTimer();
 }
 
 void AppsGridView::StopPageFlipTimer() {
   page_flip_timer_.Stop();
   page_flip_target_ = -1;
 }
 
@@ skipping 430 matching lines @@
   // For non-aura, root location is not clearly defined but |drag_view_| does
   // not have the scale transform. So no round error would be introduced and
   // it's okay to use View::ConvertPointToTarget.
   *drag_point = event.location();
   views::View::ConvertPointToTarget(drag_view_, this, drag_point);
 #endif
 }
 
 void AppsGridView::CalculateDropTarget(const gfx::Point& drag_point,
                                        bool use_page_button_hovering) {
-  const int current_page = pagination_model_->selected_page();
+  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_->bounds().Contains(drag_point)) {
-    gfx::Point page_switcher_point(drag_point);
+      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;
     }
   } else {
-    const int drop_row = drag_point.y() / kPreferredTileHeight;
+    const int drop_row = point.y() / kPreferredTileHeight;
     const int drop_col = std::min(cols_ - 1,
-                                  drag_point.x() / kPreferredTileWidth);
+                                  point.x() / kPreferredTileWidth);
 
     drop_target_.page = current_page;
     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(
@@ skipping 56 matching lines @@
         // From now on we forward the drag events.
         forward_events_to_drag_and_drop_host_ = true;
         // Any flip operations are stopped.
         StopPageFlipTimer();
       }
     }
   }
 }
 
 void AppsGridView::MaybeStartPageFlipTimer(const gfx::Point& drag_point) {
+  if (!IsPointWithinDragBuffer(drag_point))
+    StopPageFlipTimer();
   int new_page_flip_target = -1;
 
   if (page_switcher_view_->bounds().Contains(drag_point)) {
     gfx::Point page_switcher_point(drag_point);
     views::View::ConvertPointToTarget(this, page_switcher_view_,
                                       &page_switcher_point);
     new_page_flip_target =
         page_switcher_view_->GetPageForPoint(page_switcher_point);
   }
 
   // TODO(xiyuan): Fix this for RTL.
   if (new_page_flip_target == -1 && drag_point.x() < kPageFlipZoneSize)
     new_page_flip_target = pagination_model_->selected_page() - 1;
 
   if (new_page_flip_target == -1 &&
       drag_point.x() > width() - kPageFlipZoneSize) {
     new_page_flip_target = pagination_model_->selected_page() + 1;
   }
 
   if (new_page_flip_target == page_flip_target_)
     return;
 
+  StopPageFlipTimer();
   if (pagination_model_->is_valid_page(new_page_flip_target)) {
     page_flip_target_ = new_page_flip_target;
-    page_flip_timer_.Stop();
 
     if (page_flip_target_ != pagination_model_->selected_page()) {
       page_flip_timer_.Start(FROM_HERE,
           base::TimeDelta::FromMilliseconds(page_flip_delay_in_ms_),
           this, &AppsGridView::OnPageFlipTimer);
     }
-  } else {
-    page_flip_target_ = -1;
-    page_flip_timer_.Stop();
   }
 }
 
 void AppsGridView::OnPageFlipTimer() {
   DCHECK(pagination_model_->is_valid_page(page_flip_target_));
   pagination_model_->SelectPage(page_flip_target_, true);
 }
 
 void AppsGridView::MoveItemInModel(views::View* item_view,
                                    const Index& target) {
@@ skipping 16 matching lines @@
 void AppsGridView::CancelContextMenusOnCurrentPage() {
   int start = pagination_model_->selected_page() * tiles_per_page();
   int end = std::min(view_model_.view_size(), start + tiles_per_page());
   for (int i = start; i < end; ++i) {
     AppListItemView* view =
         static_cast<AppListItemView*>(view_model_.view_at(i));
     view->CancelContextMenu();
   }
 }
 
+bool AppsGridView::IsPointWithinDragBuffer(const gfx::Point& point) const {
+  gfx::Rect rect(GetLocalBounds());
+  rect.Inset(-kDragBufferPx, -kDragBufferPx, -kDragBufferPx, -kDragBufferPx);
+  return rect.Contains(point);
+}
+
 void AppsGridView::ButtonPressed(views::Button* sender,
                                  const ui::Event& event) {
   if (dragging())
     return;
 
   if (strcmp(sender->GetClassName(), AppListItemView::kViewClassName))
     return;
 
   if (delegate_) {
     delegate_->ActivateApp(static_cast<AppListItemView*>(sender)->model(),
@@ skipping 78 matching lines @@
 
 void AppsGridView::HideView(views::View* view, bool hide) {
 #if defined(USE_AURA)
   ui::ScopedLayerAnimationSettings animator(view->layer()->GetAnimator());
   animator.SetPreemptionStrategy(ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
   view->layer()->SetOpacity(hide ? 0 : 1);
 #endif
 }
 
 }  // namespace app_list