Refactor app list event handling and prerendering.

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 74 matching lines @@
 // Delays in milliseconds to show re-order preview.
 const int kReorderDelay = 120;
 
 // Delays in milliseconds to show folder item reparent UI.
 const int kFolderItemReparentDelay = 50;
 
 // Radius of the circle, in which if entered, show folder dropping preview
 // UI.
 const int kFolderDroppingCircleRadius = 15;
 
+// Constants for dealing with scroll events.
+const int kMinMouseWheelToSwitchPage = 20;
+const int kMinScrollToSwitchPage = 20;
+const int kMinHorizVelocityToSwitchPage = 800;
+
+const double kFinishTransitionThreshold = 0.33;
 
 // RowMoveAnimationDelegate is used when moving an item into a different row.
 // Before running the animation, the item's layer is re-created and kept in
 // the original position, then the item is moved to just before its target
 // position and opacity set to 0. When the animation runs, this delegate moves
 // the layer and fades it out while fading in the item at the same time.
 class RowMoveAnimationDelegate : public gfx::AnimationDelegate {
  public:
   RowMoveAnimationDelegate(views::View* view,
                            ui::Layer* layer,
@@ skipping 734 matching lines @@
 void AppsGridView::SetDragViewVisible(bool visible) {
   DCHECK(drag_view_);
   SetViewHidden(drag_view_, !visible, true);
 }
 
 void AppsGridView::SetDragAndDropHostOfCurrentAppList(
     ApplicationDragAndDropHost* drag_and_drop_host) {
   drag_and_drop_host_ = drag_and_drop_host;
 }
 
-void AppsGridView::Prerender(int page_index) {
+void AppsGridView::Prerender() {
   Layout();
-  int start = std::max(0, (page_index - kPrerenderPages) * tiles_per_page());
+  int selected_page = std::max(0, pagination_model_.selected_page());
+  int start = std::max(0, (selected_page - kPrerenderPages) * tiles_per_page());
   int end = std::min(view_model_.view_size(),
-                     (page_index + 1 + kPrerenderPages) * tiles_per_page());
+                     (selected_page + 1 + kPrerenderPages) * tiles_per_page());
   for (int i = start; i < end; i++) {
     AppListItemView* v = static_cast<AppListItemView*>(view_model_.view_at(i));
     v->Prerender();
   }
 }
 
 bool AppsGridView::IsAnimatingView(views::View* view) {
   return bounds_animator_.IsAnimating(view);
 }
 
@@ skipping 18 matching lines @@
 }
 
 bool AppsGridView::CanDrop(const OSExchangeData& data) {
   return true;
 }
 
 int AppsGridView::OnDragUpdated(const ui::DropTargetEvent& event) {
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
+void AppsGridView::OnGestureEvent(ui::GestureEvent* event) {

[calamity, 2014/08/29 04:15:09]

nit: May as well move this behind all the View overrides (behind
ViewHierarchyChanged).

[Matt Giuca, 2014/08/29 06:28:19]

Done.

+  switch (event->type()) {

[calamity, 2014/08/29 04:15:10]

I have a feeling this could change the folder behavior since the original code
used GetAppsPaginatinoModel(). In particular, I think gesture stuff that didn't
do anything before might do something now..

Could you please check that it hasn't changed. Otherwise, it should be a simple
matter of adding checks for folder_delegate_ in each of the event handlers.

[Matt Giuca, 2014/08/29 06:28:19]

Seems to be OK, but haven't tested on ChromeOS (will do).

[Matt Giuca, 2014/08/29 07:47:28]

Ugh, I can't test on ChromeOS because login manager is required for folders and
it's currently crashing.

But it looks like it will be fine. ash::AppListController does the overscrolling
by observing the AppsGridView instance of the PaginationModel. So any nested
PaginationModel will be ignored for overscroll purposes.

+    case ui::ET_GESTURE_SCROLL_BEGIN:
+      pagination_model_.StartScroll();
+      event->SetHandled();
+      return;
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+      // event->details.scroll_x() > 0 means moving contents to right. That is,
+      // transitioning to previous page.
+      pagination_model_.UpdateScroll(event->details().scroll_x() /
+                                     GetContentsBounds().width());
+      event->SetHandled();
+      return;
+    case ui::ET_GESTURE_SCROLL_END:
+      pagination_model_.EndScroll(pagination_model_.transition().progress <
+                                  kFinishTransitionThreshold);
+      event->SetHandled();
+      return;
+    case ui::ET_SCROLL_FLING_START: {
+      pagination_model_.EndScroll(true);
+      if (fabs(event->details().velocity_x()) > kMinHorizVelocityToSwitchPage) {
+        pagination_model_.SelectPageRelative(
+            event->details().velocity_x() < 0 ? 1 : -1, true);
+      }
+      event->SetHandled();
+      return;
+    }
+    default:
+      break;
+  }
+}
+
+void AppsGridView::OnScrollEvent(ui::ScrollEvent* event) {
+  if (event->type() == ui::ET_SCROLL_FLING_CANCEL)
+    return;
+
+  float offset;
+  if (std::abs(event->x_offset()) > std::abs(event->y_offset()))
+    offset = event->x_offset();
+  else
+    offset = event->y_offset();
+
+  if (std::abs(offset) > kMinScrollToSwitchPage) {
+    if (!pagination_model_.has_transition()) {
+      pagination_model_.SelectPageRelative(offset > 0 ? -1 : 1, true);
+    }
+    event->SetHandled();
+    event->StopPropagation();
+  }
+}
+
 void AppsGridView::Layout() {
   if (bounds_animator_.IsAnimating())
     bounds_animator_.Cancel();
 
   CalculateIdealBounds();
   for (int i = 0; i < view_model_.view_size(); ++i) {
     views::View* view = view_model_.view_at(i);
     if (view != drag_view_)
       view->SetBoundsRect(view_model_.ideal_bounds(i));
   }
@@ skipping 44 matching lines @@
 }
 
 bool AppsGridView::OnKeyReleased(const ui::KeyEvent& event) {
   bool handled = false;
   if (selected_view_)
     handled = selected_view_->OnKeyReleased(event);
 
   return handled;
 }
 
+bool AppsGridView::OnMouseWheel(const ui::MouseWheelEvent& event) {
+  int offset;
+  if (abs(event.x_offset()) > abs(event.y_offset()))
+    offset = event.x_offset();
+  else
+    offset = event.y_offset();
+
+  if (abs(offset) > kMinMouseWheelToSwitchPage) {
+    if (!pagination_model_.has_transition()) {
+      pagination_model_.SelectPageRelative(offset > 0 ? -1 : 1, true);
+    }
+    return true;
+  }
+
+  return false;
+}
+
 void AppsGridView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (!details.is_add && details.parent == this) {
     // The view being delete should not have reference in |view_model_|.
     CHECK_EQ(-1, view_model_.GetIndexOfView(details.child));
 
     if (selected_view_ == details.child)
       selected_view_ = NULL;
     if (activated_folder_item_view_ == details.child)
       activated_folder_item_view_ = NULL;
@@ skipping 1205 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