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 226 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 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_);

[xiyuan, 2013/07/19 01:06:33]

I wonder if we should also update MaybeStartPageFlipTimer to suppress auto
flipping when some conditions met, e.g. user dragged out of bound for too long,
or too far etc.

[koz (OOO until 15th September), 2013/07/19 04:03:57]

Good idea! Done.

 
   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 (!HitTestPoint(drag_point)) {
+    point = drag_start_grid_view_;
+    current_page = drag_start_page_;

[xiyuan, 2013/07/19 00:59:59]

Should we jus return here? Otherwise, this would change to before-drag-start
state.

[koz (OOO until 15th September), 2013/07/19 04:03:57]

That's the intent of this change - to have the drag return to the "before drag"
state if the user drags the app out, ie: the same state that they will be in
after they drop the app outside the launcher. The reason I want that is twofold:

 - if the user drops an app while the drag is outside the launcher it will (on
Windows) revert the app launcher back to its original state anyway, so reverting
to that state while the drag is in process would be a better indication of the
result of the drag.

 - currently dragging an app outside the launcher causes the apps inside the
launcher to rearrange themselves despite the dragged app being nowhere near them
which looks weird

We could solve the second problem by simply ignoring drag events that occur
outside the app launcher, but that wouldn't help the (somewhat less important)
first case. Would you prefer that?

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

Okay. How about add a threshold for resetting to original state? This way, user
does not trigger the reset by accident when trying to flip the page by dragging
the item close the edge. And when user drags the item out of the launcher far
enough, we take that as user's intent to drop it out of the launcher and reset
to the original state. That is, we stop rearranging when the drag is out of the
launcher and reset to the original state when the drag is out far enough. What
do you think?

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

Yeah, that sounds good. Including turning the page back to where they were
originally?

+  }
 
   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 224 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