Store AppItems as pages in AppListModel.

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 "content/public/browser/web_contents.h"
 #include "ui/app_list/app_list_item_model.h"
@@ skipping 254 matching lines @@
 }
 
 AppsGridView::~AppsGridView() {
   // Coming here |drag_view_| should already be canceled since otherwise the
   // drag would disappear after the app list got animated away and closed,
   // which would look odd.
   DCHECK(!drag_view_);
   if (drag_view_)
     EndDrag(true);
 
-  if (model_) {
+  if (model_)
     model_->RemoveObserver(this);
-    model_->apps()->RemoveObserver(this);
-  }
+
   pagination_model_->RemoveObserver(this);
 }
 
 void AppsGridView::SetLayout(int icon_size, int cols, int rows_per_page) {
   icon_size_.SetSize(icon_size, icon_size);
   cols_ = cols;
   rows_per_page_ = rows_per_page;
 
   set_border(views::Border::CreateEmptyBorder(kTopPadding,
                                               kLeftRightPadding,
                                               0,
                                               kLeftRightPadding));
 }
 
 void AppsGridView::SetModel(AppListModel* model) {
-  if (model_) {
+  if (model_)
     model_->RemoveObserver(this);
-    model_->apps()->RemoveObserver(this);
-  }
 
   model_ = model;
-  if (model_) {
+  if (model_)
     model_->AddObserver(this);
-    model_->apps()->AddObserver(this);
-  }
   Update();
 }
 
 void AppsGridView::SetSelectedView(views::View* view) {
   if (IsSelectedView(view) || IsDraggedView(view))
     return;
 
   Index index = GetIndexOfView(view);
   if (IsValidIndex(index))
     SetSelectedItemByIndex(index);
@@ skipping 313 matching lines @@
 
 // static
 AppsGridView* AppsGridView::GetLastGridViewForTest() {
   return last_created_grid_view_for_test;
 }
 
 void AppsGridView::Update() {
   DCHECK(!selected_view_ && !drag_view_);
 
   view_model_.Clear();
-  if (model_ && model_->apps()->item_count())
-    ListItemsAdded(0, model_->apps()->item_count());
+  if (model_) {
+    for (size_t page = 0; page < model_->GetNumAppPages(); ++page) {
+      const AppListModel::AppItems& apps = model_->GetAppItemsForPage(page);
+      if (apps.item_count())
+        OnListItemsAdded(page, 0, apps.item_count());
+    }
+  }
 }
 
 void AppsGridView::UpdatePaging() {
   int total_page = start_page_view_ ? 1 : 0;
   if (view_model_.view_size() && tiles_per_page())
     total_page += (view_model_.view_size() - 1) / tiles_per_page() + 1;
 
   pagination_model_->SetTotalPages(total_page);
 }
 
 void AppsGridView::UpdatePulsingBlockViews() {
+  if (model_->GetNumAppPages() == 0)
+    return;
+
+  const AppListModel::AppItems& apps = model_->GetAppItemsForPage(0);
   const int available_slots =
-      tiles_per_page() - model_->apps()->item_count() % tiles_per_page();
+      tiles_per_page() - apps.item_count()  % tiles_per_page();
   const int desired = model_->status() == AppListModel::STATUS_SYNCING ?
       available_slots : 0;
 
   if (pulsing_blocks_model_.view_size() == desired)
     return;
 
   while (pulsing_blocks_model_.view_size() > desired) {
     views::View* view = pulsing_blocks_model_.view_at(0);
     pulsing_blocks_model_.Remove(0);
     delete view;
   }
 
   while (pulsing_blocks_model_.view_size() < desired) {
     views::View* view = new PulsingBlockView(
         gfx::Size(kPreferredTileWidth, kPreferredTileHeight), true);
     pulsing_blocks_model_.Add(view, 0);
     AddChildView(view);
   }
 }
 
-views::View* AppsGridView::CreateViewForItemAtIndex(size_t index) {
-  DCHECK_LT(index, model_->apps()->item_count());
-  AppListItemView* view = new AppListItemView(this,
-                                              model_->apps()->GetItemAt(index));
+views::View* AppsGridView::CreateViewForItemAtIndex(size_t page_idx,
+                                                    size_t item_idx) {
+  AppListItemModel* item = model_->GetItemAt(page_idx, item_idx);
+  CHECK(item);
+  AppListItemView* view = new AppListItemView(this, item);
   view->SetIconSize(icon_size_);
 #if defined(USE_AURA)
   view->SetPaintToLayer(true);
   view->SetFillsBoundsOpaquely(false);
 #endif
   return view;
 }
 
 AppsGridView::Index AppsGridView::GetIndexFromModelIndex(
     int model_index) const {
@@ skipping 407 matching lines @@
   }
 }
 
 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) {
+  Index current = GetIndexOfView(item_view);
   int current_model_index = view_model_.GetIndexOfView(item_view);
   DCHECK_GE(current_model_index, 0);
 
   int target_model_index = GetModelIndexFromIndex(target);
   if (target_model_index == current_model_index)
     return;
 
-  model_->apps()->RemoveObserver(this);
-  model_->apps()->Move(current_model_index, target_model_index);
+  model_->RemoveObserver(this);
+  model_->MoveItem(current.page, current.slot,
+                   target.page, target.slot);
   view_model_.Move(current_model_index, target_model_index);
-  model_->apps()->AddObserver(this);
+  model_->AddObserver(this);
 
   if (pagination_model_->selected_page() != target.page)
     pagination_model_->SelectPage(target.page, false);
 }
 
 void AppsGridView::CancelContextMenusOnCurrentPage() {
   int start = pagination_model_->selected_page() * tiles_per_page();
   int end = std::min(view_model_.view_size(), start + tiles_per_page());
   for (int i = start; i < end; ++i) {
     AppListItemView* view =
@@ skipping 38 matching lines @@
   const PaginationModel::Transition& transition =
       pagination_model_->transition();
   if (current_page == 0 || transition.target_page == 0) {
     const int dir = transition.target_page > current_page ? -1 : 1;
     start_page_bounds.Offset(transition.progress * page_width * dir, 0);
   }
 
   start_page_view_->SetBoundsRect(start_page_bounds);
 }
 
-void AppsGridView::ListItemsAdded(size_t start, size_t count) {
+void AppsGridView::OnListItemsAdded(size_t page_index,
+                                    size_t start, size_t count) {
   EndDrag(true);
 
+  size_t offset = page_index * AppListModel::GetNumAppsPerPage();

[xiyuan, 2013/10/18 23:04:08]

int offset = GetModelIndexFromIndex(Index(page_index, 0));

GetModelIndexFromIndex does a similar thing but with consideration of a start
page.

--show-app-list-start-page would trigger the start page.

[stevenjb, 2013/10/19 01:04:43]

Ah, thanks. Will do.

   for (size_t i = start; i < start + count; ++i) {
-    views::View* view = CreateViewForItemAtIndex(i);
-    view_model_.Add(view, i);
+    views::View* view = CreateViewForItemAtIndex(page_index, i);
+    view_model_.Add(view, offset + i);
     AddChildView(view);
   }
 
   UpdatePaging();
   UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
-void AppsGridView::ListItemsRemoved(size_t start, size_t count) {
+void AppsGridView::OnListItemsRemoved(size_t page_index,
+                                      size_t start, size_t count) {
   EndDrag(true);
 
+  size_t index = page_index * AppListModel::GetNumAppsPerPage() + start;

[xiyuan, 2013/10/18 23:04:08]

GetModelIndexFromIndex(Index(page_index, start));

[stevenjb, 2013/10/19 01:04:43]

Ditto

   for (size_t i = 0; i < count; ++i) {
-    views::View* view = view_model_.view_at(start);
-    view_model_.Remove(start);
+    views::View* view = view_model_.view_at(index);
+    view_model_.Remove(index);
     delete view;
   }
 
   UpdatePaging();
   UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
-void AppsGridView::ListItemMoved(size_t index, size_t target_index) {
+void AppsGridView::OnListItemMoved(size_t page_index,
+                                   size_t index, size_t target_index) {
   EndDrag(true);
-  view_model_.Move(index, target_index);
+  size_t offset = page_index * AppListModel::GetNumAppsPerPage();

[xiyuan, 2013/10/18 23:04:08]

use GetModelIndexFromIndex

[stevenjb, 2013/10/19 01:04:43]

Ditto

+  view_model_.Move(offset + index, offset + target_index);
 
   UpdatePaging();
   AnimateToIdealBounds();
 }
 
-void AppsGridView::ListItemsChanged(size_t start, size_t count) {
-  NOTREACHED();
-}
-
 void AppsGridView::TotalPagesChanged() {
 }
 
 void AppsGridView::SelectedPageChanged(int old_selected, int new_selected) {
   if (dragging()) {
     CalculateDropTarget(last_drag_point_, true);
     Layout();
     MaybeStartPageFlipTimer(last_drag_point_);
   } else {
     ClearSelectedView(selected_view_);
@@ skipping 24 matching lines @@
 #if defined(USE_AURA)
   ui::ScopedLayerAnimationSettings animator(view->layer()->GetAnimator());
   animator.SetPreemptionStrategy(
       immediate ? ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET :
                   ui::LayerAnimator::BLEND_WITH_CURRENT_ANIMATION);
   view->layer()->SetOpacity(hide ? 0 : 1);
 #endif
 }
 
 }  // namespace app_list