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 165 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 37 matching lines @@
       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_pointer_(NONE),
       drag_and_drop_host_(NULL),
       forward_events_to_drag_and_drop_host_(false),
+      drag_start_page_(-1),
       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_);
 }
 
 AppsGridView::~AppsGridView() {
   if (model_) {
@@ skipping 59 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 105 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 (!HitTestPoint(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 (!HitTestPoint(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;
 
   if (pagination_model_->is_valid_page(new_page_flip_target)) {
+    StopPageFlipTimer();
     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();
+    StopPageFlipTimer();

[xiyuan, 2013/07/19 04:36:46]

nit: We probably could move this to be before the "if" since we are doing it in
both branches now.

[koz (OOO until 15th September), 2013/07/19 08:00:32]

Done.

   }
 }
 
 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 114 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