App list uses PaginationModel to transition between pages.

ui/app_list/views/contents_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/contents_view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "ui/app_list/app_list_constants.h"
 #include "ui/app_list/app_list_switches.h"
 #include "ui/app_list/app_list_view_delegate.h"
-#include "ui/app_list/pagination_model.h"
 #include "ui/app_list/views/app_list_folder_view.h"
 #include "ui/app_list/views/app_list_main_view.h"
 #include "ui/app_list/views/apps_container_view.h"
 #include "ui/app_list/views/apps_grid_view.h"
 #include "ui/app_list/views/search_result_list_view.h"
 #include "ui/app_list/views/start_page_view.h"
 #include "ui/events/event.h"
-#include "ui/views/animation/bounds_animator.h"
 #include "ui/views/view_model.h"
 #include "ui/views/view_model_utils.h"
 
 namespace app_list {
 
 namespace {
 
 const int kMinMouseWheelToSwitchPage = 20;
 const int kMinScrollToSwitchPage = 20;
 const int kMinHorizVelocityToSwitchPage = 800;
 
 const double kFinishTransitionThreshold = 0.33;
 
 }  // namespace
 
 ContentsView::ContentsView(AppListMainView* app_list_main_view,
                            AppListModel* model,
                            AppListViewDelegate* view_delegate)
     : start_page_view_(NULL),
       app_list_main_view_(app_list_main_view),
-      view_model_(new views::ViewModel),
-      bounds_animator_(new views::BoundsAnimator(this)) {
+      view_model_(new views::ViewModel) {
   DCHECK(model);
 
   search_results_view_ =
       new SearchResultListView(app_list_main_view, view_delegate);
   AddLauncherPage(search_results_view_, NAMED_PAGE_SEARCH_RESULTS);
 
   if (app_list::switches::IsExperimentalAppListEnabled()) {
     start_page_view_ = new StartPageView(app_list_main_view, view_delegate);
     AddLauncherPage(start_page_view_, NAMED_PAGE_START);
   }
 
   apps_container_view_ = new AppsContainerView(app_list_main_view, model);
-  active_page_ = AddLauncherPage(apps_container_view_, NAMED_PAGE_APPS);
+  int apps_page_index = AddLauncherPage(apps_container_view_, NAMED_PAGE_APPS);
 
   search_results_view_->SetResults(model->results());
+
+  pagination_model_.SetTotalPages(view_model_->view_size());
+  pagination_model_.SelectPage(apps_page_index, false);
+  pagination_model_.AddObserver(this);
 }
 
 ContentsView::~ContentsView() {
+  pagination_model_.RemoveObserver(this);
 }
 
 void ContentsView::CancelDrag() {
   if (apps_container_view_->apps_grid_view()->has_dragged_view())
     apps_container_view_->apps_grid_view()->EndDrag(true);
   if (apps_container_view_->app_list_folder_view()
           ->items_grid_view()
           ->has_dragged_view()) {
     apps_container_view_->app_list_folder_view()->items_grid_view()->EndDrag(
         true);
   }
 }
 
 void ContentsView::SetDragAndDropHostOfCurrentAppList(
     ApplicationDragAndDropHost* drag_and_drop_host) {
   apps_container_view_->SetDragAndDropHostOfCurrentAppList(drag_and_drop_host);
 }
 
 void ContentsView::SetActivePage(int page_index) {
-  if (active_page_ == page_index)
+  if (GetActivePageIndex() == page_index)
     return;
 
-  active_page_ = page_index;
+  // Start animating to the new page.
+  pagination_model_.SelectPage(page_index, true);
   ActivePageChanged();
 }
 
+int ContentsView::GetActivePageIndex() const {
+  // The active page is changed at the beginning of an animation, not the end.
+  return pagination_model_.SelectedTargetPage();
+}
+
 bool ContentsView::IsNamedPageActive(NamedPage named_page) const {
   std::map<NamedPage, int>::const_iterator it =
       named_page_to_view_.find(named_page);
   if (it == named_page_to_view_.end())
     return false;
-  return it->second == active_page_;
+  return it->second == GetActivePageIndex();
 }
 
 int ContentsView::GetPageIndexForNamedPage(NamedPage named_page) const {
   // Find the index of the view corresponding to the given named_page.
   std::map<NamedPage, int>::const_iterator it =
       named_page_to_view_.find(named_page);
   // GetPageIndexForNamedPage should never be called on a named_page that does
   // not have a corresponding view.
   DCHECK(it != named_page_to_view_.end());
   return it->second;
 }
 
 void ContentsView::ActivePageChanged() {
   // TODO(xiyuan): Highlight default match instead of the first.
   if (IsNamedPageActive(NAMED_PAGE_SEARCH_RESULTS) &&
       search_results_view_->visible()) {
     search_results_view_->SetSelectedIndex(0);
   }
   search_results_view_->UpdateAutoLaunchState();
 
   // Notify parent AppListMainView of the page change.
   app_list_main_view_->OnContentsViewActivePageChanged();
 
   if (IsNamedPageActive(NAMED_PAGE_START))
     start_page_view_->Reset();
-
-  AnimateToIdealBounds();
 }
 
-void ContentsView::CalculateIdealBounds() {
+void ContentsView::CalculateAndSetBounds(bool ideal) {
   gfx::Rect rect(GetContentsBounds());
   if (rect.IsEmpty())
     return;
 
-  if (app_list::switches::IsExperimentalAppListEnabled()) {
-    gfx::Rect incoming_target(rect);
-    gfx::Rect outgoing_target(rect);
-    outgoing_target.set_x(-outgoing_target.width());
-
-    for (int i = 0; i < view_model_->view_size(); ++i) {
-      view_model_->set_ideal_bounds(
-          i, i == active_page_ ? incoming_target : outgoing_target);
+  // The bounds calculations will potentially be mid-transition (depending on
+  // the state of the PaginationModel).
+  int current_page = std::max(0, pagination_model_.selected_page());

[calamity, 2014/06/12 03:05:08]

When can this be negative?

[Matt Giuca, 2014/06/16 00:59:05]

pagination_model_.selected_page() is -1 by default, which means "the default
value" which as far as I can tell always means 0. Not sure why it is this way,
and doesn't just default to 0, but there is a common idiom to use std::max(0,
pagination_model_.selected_page()) to get the "real" selected page.

+  int target_page = current_page;
+  double progress = 1;
+  if (pagination_model_.has_transition()) {
+    const PaginationModel::Transition& transition =
+        pagination_model_.transition();
+    if (pagination_model_.is_valid_page(transition.target_page)) {
+      target_page = transition.target_page;
+      // If |ideal|, assume that any pending animation has already completed.
+      if (!ideal)
+        progress = transition.progress;
     }
-    return;
   }
 
-  gfx::Rect container_frame(rect);
-  gfx::Rect results_frame(rect);
+  gfx::Rect incoming_target(rect);
+  gfx::Rect outgoing_target(rect);
+  int dir = target_page > current_page ? -1 : 1;
 
-  // Offsets apps grid and result list based on |active_page_|.
-  // SearchResultListView is on top of apps grid. Visible view is left in
-  // visible area and invisible ones is put out of the visible area.
-  int contents_area_height = rect.height();
-  if (IsNamedPageActive(NAMED_PAGE_APPS))
-    results_frame.Offset(0, -contents_area_height);
-  else if (IsNamedPageActive(NAMED_PAGE_SEARCH_RESULTS))
-    container_frame.Offset(0, contents_area_height);
-  else
-    NOTREACHED() << "Page " << active_page_ << " invalid in current app list.";
+  if (app_list::switches::IsExperimentalAppListEnabled()) {
+    // The experimental app list transitions horizontally.
+    int page_width = rect.width();
+    int transition_offset = progress * page_width * dir;
 
-  view_model_->set_ideal_bounds(GetPageIndexForNamedPage(NAMED_PAGE_APPS),
-                                container_frame);
-  view_model_->set_ideal_bounds(
-      GetPageIndexForNamedPage(NAMED_PAGE_SEARCH_RESULTS), results_frame);
-}
+    outgoing_target.set_x(transition_offset);
+    incoming_target.set_x(dir < 0 ? transition_offset + page_width
+                                  : transition_offset - page_width);
+  } else {
+    // The normal app list transitions vertically.
+    int page_height = rect.height();
+    int transition_offset = progress * page_height * dir;
 
-void ContentsView::AnimateToIdealBounds() {
-  CalculateIdealBounds();
-  for (int i = 0; i < view_model_->view_size(); ++i) {
-    bounds_animator_->AnimateViewTo(view_model_->view_at(i),
-                                    view_model_->ideal_bounds(i));
+    outgoing_target.set_y(transition_offset);
+    incoming_target.set_y(dir < 0 ? transition_offset + page_height
+                                  : transition_offset - page_height);
+  }
+
+  if (ideal) {
+    view_model_->set_ideal_bounds(current_page, outgoing_target);
+    view_model_->set_ideal_bounds(target_page, incoming_target);

[calamity, 2014/06/12 03:05:08]

It looks like ideal bounds aren't really used anywhere else in this class but
semantically they denote where the view should end up on animation completion.

If that's the case, they should always be set by this method.

[Matt Giuca, 2014/06/16 00:59:05]

I guess if something isn't used at all, but semantically represents something,
it probably should be removed entirely.

It actually is used, though, just at initialization time, Layout() is called
which sets everything to its ideal position, so I do need this (or more
refactoring is required).
I don't see why the ideal bounds should always be set. Conceptually, this method
is just two separate functions (one sets the ideal bounds, the other sets the
actual bounds), but since they share almost all the code, they are merged into
one.

Having this always set the ideal bounds would break the code reuse because I'd
have to do the main computation twice.

+  } else {
+    view_model_->view_at(current_page)->SetBoundsRect(outgoing_target);
+    view_model_->view_at(target_page)->SetBoundsRect(incoming_target);
   }
 }
 
 PaginationModel* ContentsView::GetAppsPaginationModel() {
   return apps_container_view_->apps_grid_view()->pagination_model();
 }
 
 void ContentsView::ShowSearchResults(bool show) {
   NamedPage new_named_page = show ? NAMED_PAGE_SEARCH_RESULTS : NAMED_PAGE_APPS;
   SetActivePage(GetPageIndexForNamedPage(new_named_page));
@@ skipping 15 matching lines @@
   view_model_->Add(view, page_index);
   return page_index;
 }
 
 int ContentsView::AddLauncherPage(views::View* view, NamedPage named_page) {
   int page_index = AddLauncherPage(view);
   named_page_to_view_.insert(std::pair<NamedPage, int>(named_page, page_index));
   return page_index;
 }
 
+void ContentsView::FinishCurrentAnimationForTests() {
+  if (!pagination_model_.has_transition())
+    return;

[calamity, 2014/06/12 03:05:08]

nit: blank line after early return.

[Matt Giuca, 2014/06/16 00:59:05]

Done.

+  pagination_model_.SelectPage(pagination_model_.transition().target_page,
+                               false);
+}
+
 gfx::Size ContentsView::GetPreferredSize() const {
   const gfx::Size container_size =
       apps_container_view_->apps_grid_view()->GetPreferredSize();
   const gfx::Size results_size = search_results_view_->GetPreferredSize();
 
   int width = std::max(container_size.width(), results_size.width());
   int height = std::max(container_size.height(), results_size.height());
   return gfx::Size(width, height);
 }
 
 void ContentsView::Layout() {
-  CalculateIdealBounds();
+  CalculateAndSetBounds(true);
   views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
 }
 
 bool ContentsView::OnKeyPressed(const ui::KeyEvent& event) {
-  return view_model_->view_at(active_page_)->OnKeyPressed(event);
+  return view_model_->view_at(GetActivePageIndex())->OnKeyPressed(event);
 }
 
 bool ContentsView::OnMouseWheel(const ui::MouseWheelEvent& event) {
   if (!IsNamedPageActive(NAMED_PAGE_APPS))
     return false;
 
   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 (!GetAppsPaginationModel()->has_transition()) {
       GetAppsPaginationModel()->SelectPageRelative(offset > 0 ? -1 : 1, true);
     }
     return true;
   }
 
   return false;
 }
 
+void ContentsView::TotalPagesChanged() {
+}
+
+void ContentsView::SelectedPageChanged(int old_selected, int new_selected) {
+}
+
+void ContentsView::TransitionStarted() {
+}
+
+void ContentsView::TransitionChanged() {
+  CalculateAndSetBounds(false);
+}
+
 void ContentsView::OnGestureEvent(ui::GestureEvent* event) {
   if (!IsNamedPageActive(NAMED_PAGE_APPS))
     return;
 
   switch (event->type()) {
     case ui::ET_GESTURE_SCROLL_BEGIN:
       GetAppsPaginationModel()->StartScroll();
       event->SetHandled();
       return;
     case ui::ET_GESTURE_SCROLL_UPDATE:
@@ skipping 38 matching lines @@
   if (std::abs(offset) > kMinScrollToSwitchPage) {
     if (!GetAppsPaginationModel()->has_transition()) {
       GetAppsPaginationModel()->SelectPageRelative(offset > 0 ? -1 : 1, true);
     }
     event->SetHandled();
     event->StopPropagation();
   }
 }
 
 }  // namespace app_list