Make apps grid view scroll vertically in experimental app list.

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 879 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) {
+  const ui::GestureEventDetails& details = event->details();
   switch (event->type()) {
     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());
+    case ui::ET_GESTURE_SCROLL_UPDATE: {
+      float scroll = GetScrollAxis() == SCROLL_AXIS_HORIZONTAL
+                         ? details.scroll_x()
+                         : details.scroll_y();
+      gfx::Rect bounds(GetContentsBounds());
+      int width = GetScrollAxis() == SCROLL_AXIS_HORIZONTAL ? bounds.width()
+                                                            : bounds.height();
+      // scroll > 0 means moving contents right or down. That is, transitioning
+      // to the previous page.
+      pagination_model_.UpdateScroll(scroll / 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: {
+      float velocity = GetScrollAxis() == SCROLL_AXIS_HORIZONTAL
+                           ? details.velocity_x()
+                           : details.velocity_y();
       pagination_model_.EndScroll(true);
-      if (fabs(event->details().velocity_x()) > kMinHorizVelocityToSwitchPage) {
-        pagination_model_.SelectPageRelative(
-            event->details().velocity_x() < 0 ? 1 : -1, true);
-      }
+      if (fabs(velocity) > kMinHorizVelocityToSwitchPage)
+        pagination_model_.SelectPageRelative(velocity < 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
+  if (GetScrollAxis() == SCROLL_AXIS_HORIZONTAL) {

[Matt Giuca, 2014/08/28 08:35:20]

Ugh, this duplication (with OnMouseWheel) is getting out of hand. Will be
deduped in the next CL!

+    // If the view scrolls horizontally, both horizontal and vertical scroll
+    // events are valid (vertical scroll events simulate mouse wheel).
+    if (std::abs(event->x_offset()) > std::abs(event->y_offset()))
+      offset = event->x_offset();
+    else
+      offset = event->y_offset();
+  } else {
+    // If the view scrolls vertically, only vertical scroll events are valid.
     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();
   }
 }
 
@@ skipping 56 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
+  if (GetScrollAxis() == SCROLL_AXIS_HORIZONTAL) {
+    // If the view scrolls horizontally, both horizontal and vertical scroll
+    // events are valid (since most mouse wheels only have vertical scrolling).
+    if (abs(event.x_offset()) > abs(event.y_offset()))
+      offset = event.x_offset();
+    else
+      offset = event.y_offset();
+  } else {
+    // If the view scrolls vertically, only vertical scroll events are valid.
     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;
 }
@@ skipping 171 matching lines @@
   gfx::Rect rect(GetContentsBounds());
   if (rect.IsEmpty())
     return;
 
   gfx::Size tile_size(kPreferredTileWidth, kPreferredTileHeight);
 
   gfx::Rect grid_rect(gfx::Size(tile_size.width() * cols_,
                                 tile_size.height() * rows_per_page_));
   grid_rect.Intersect(rect);
 
-  // Page width including padding pixels. A tile.x + page_width means the same
-  // tile slot in the next page.
+  // Page size including padding pixels. A tile.x + page_width means the same
+  // tile slot in the next page; similarly for tile.y + page_height.
   const int page_width = grid_rect.width() + kPagePadding;
+  const int page_height = grid_rect.height() + kPagePadding;
 
   // If there is a transition, calculates offset for current and target page.
   const int current_page = pagination_model_.selected_page();
   const PaginationModel::Transition& transition =
       pagination_model_.transition();
   const bool is_valid = pagination_model_.is_valid_page(transition.target_page);
 
-  // Transition to right means negative offset.
+  // Transition to previous page means negative offset.
   const int dir = transition.target_page > current_page ? -1 : 1;
-  const int transition_offset = is_valid ?
-      transition.progress * page_width * dir : 0;
 
   const int total_views =
       view_model_.view_size() + pulsing_blocks_model_.view_size();
   int slot_index = 0;
   for (int i = 0; i < total_views; ++i) {
     if (i < view_model_.view_size() && view_model_.view_at(i) == drag_view_) {
       if (EnableFolderDragDropUI() && drop_attempt_ == DROP_FOR_FOLDER)
         ++slot_index;
       continue;
     }
 
     Index view_index = GetIndexFromModelIndex(slot_index);
 
     if (drop_target_ == view_index) {
       if (EnableFolderDragDropUI() && drop_attempt_ == DROP_FOR_FOLDER) {
         view_index = GetIndexFromModelIndex(slot_index);
       } else if (!EnableFolderDragDropUI() ||
                  drop_attempt_ == DROP_FOR_REORDER) {
         ++slot_index;
         view_index = GetIndexFromModelIndex(slot_index);
       }
     }
 
-    // Decides an x_offset for current item.
+    // Decide the x or y offset for current item.
     int x_offset = 0;
-    if (view_index.page < current_page)
-      x_offset = -page_width;
-    else if (view_index.page > current_page)
-      x_offset = page_width;
+    int y_offset = 0;
 
-    if (is_valid) {
-      if (view_index.page == current_page ||
-          view_index.page == transition.target_page) {
-        x_offset += transition_offset;
+    if (GetScrollAxis() == SCROLL_AXIS_HORIZONTAL) {
+      if (view_index.page < current_page)
+        x_offset = -page_width;
+      else if (view_index.page > current_page)
+        x_offset = page_width;
+
+      if (is_valid) {
+        if (view_index.page == current_page ||
+            view_index.page == transition.target_page) {
+          x_offset += transition.progress * page_width * dir;
+        }
+      }
+    } else {
+      if (view_index.page < current_page)
+        y_offset = -page_height;
+      else if (view_index.page > current_page)
+        y_offset = page_height;
+
+      if (is_valid) {
+        if (view_index.page == current_page ||
+            view_index.page == transition.target_page) {
+          y_offset += transition.progress * page_height * dir;
+        }
       }
     }
 
     const int row = view_index.slot / cols_;
     const int col = view_index.slot % cols_;
     gfx::Rect tile_slot(
         gfx::Point(grid_rect.x() + col * tile_size.width() + x_offset,
-                   grid_rect.y() + row * tile_size.height()),
+                   grid_rect.y() + row * tile_size.height() + y_offset),
         tile_size);
     if (i < view_model_.view_size()) {
       view_model_.set_ideal_bounds(i, tile_slot);
     } else {
       pulsing_blocks_model_.set_ideal_bounds(i - view_model_.view_size(),
                                              tile_slot);
     }
 
     ++slot_index;
   }
@@ skipping 968 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);
 }
 
+// static
+AppsGridView::ScrollAxis AppsGridView::GetScrollAxis() {
+  // The experimental app list transitions vertically.
+  return app_list::switches::IsExperimentalAppListEnabled()
+             ? SCROLL_AXIS_VERTICAL
+             : SCROLL_AXIS_HORIZONTAL;
+}
+
 }  // namespace app_list