Reland 140878 - cleanup: Remove applist v1 code.

ui/app_list/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/apps_grid_view.h"
 
 #include <algorithm>
 
 #include "ui/app_list/app_list_item_view.h"
 #include "ui/app_list/pagination_model.h"
@@ skipping 11 matching lines @@
 
 }  // namespace
 
 namespace app_list {
 
 AppsGridView::AppsGridView(views::ButtonListener* listener,
                                    PaginationModel* pagination_model)
     : model_(NULL),
       listener_(listener),
       pagination_model_(pagination_model),
-      fixed_layout_(false),
       cols_(0),
       rows_per_page_(0),
       selected_item_index_(-1) {
   set_focusable(true);
   pagination_model_->AddObserver(this);
 }
 
 AppsGridView::~AppsGridView() {
   if (model_)
     model_->RemoveObserver(this);
   pagination_model_->RemoveObserver(this);
 }
 
-void AppsGridView::CalculateLayout(const gfx::Size& content_size,
-                                       int num_of_tiles,
-                                       gfx::Size* icon_size,
-                                       int* rows,
-                                       int* cols) {
-  DCHECK(!content_size.IsEmpty() && num_of_tiles);
-
-  // Icon sizes to try.
-  const int kIconSizes[] = { 128, 96, 64, 48, 32 };
-
-  double aspect = static_cast<double>(content_size.width()) /
-      content_size.height();
-
-  // Chooses the biggest icon size that could fit all tiles.
-  gfx::Size tile_size;
-  for (size_t i = 0; i < arraysize(kIconSizes); ++i) {
-    icon_size->SetSize(kIconSizes[i], kIconSizes[i]);
-    tile_size = AppListItemView::GetPreferredSizeForIconSize(
-        *icon_size);
-
-    int max_cols = content_size.width() / tile_size.width();
-    int max_rows = content_size.height() / tile_size.height();
-
-    // Skip if |tile_size| could not fit into |content_size|.
-    if (max_cols * max_rows < num_of_tiles)
-      continue;
-
-    // Find a rows/cols pair that has a aspect ratio closest to |aspect|.
-    double min_aspect_diff = 1e5;
-    for (int c = std::max(max_cols / 2, 1); c <= max_cols; ++c) {
-      int r = std::min((num_of_tiles - 1) / c + 1, max_rows);
-      if (c * r < num_of_tiles)
-        continue;
-
-      double aspect_diff = fabs(static_cast<double>(c) / r - aspect);
-      if (aspect_diff < min_aspect_diff) {
-        *cols = c;
-        *rows = r;
-        min_aspect_diff = aspect_diff;
-      }
-    }
-
-    DCHECK((*rows) * (*cols) >= num_of_tiles);
-    return;
-  }
-
-  // No icon size that could fit all tiles.
-  *cols = std::max(content_size.width() / tile_size.width(), 1);
-  *rows = (num_of_tiles - 1) / (*cols) + 1;
-}
-
 void AppsGridView::SetLayout(int icon_size, int cols, int rows_per_page) {
-  fixed_layout_ = true;
-
   icon_size_.SetSize(icon_size, icon_size);
   cols_ = cols;
   rows_per_page_ = rows_per_page;
 
   set_border(views::Border::CreateEmptyBorder(kTopPadding,
                                               kLeftRightPadding,
                                               0,
                                               kLeftRightPadding));
 }
 
@@ skipping 12 matching lines @@
   if (index >= 0)
     SetSelectedItemByIndex(index);
 }
 
 void AppsGridView::ClearSelectedItem(AppListItemView* item) {
   int index = GetIndexOf(item);
   if (index == selected_item_index_)
     SetSelectedItemByIndex(-1);
 }
 
+bool AppsGridView::IsSelectedItem(const AppListItemView* item) const {
+  return selected_item_index_ != -1 &&
+      selected_item_index_ == GetIndexOf(item);
+}
+
+void AppsGridView::EnsureItemVisible(const AppListItemView* item) {
+  int index = GetIndexOf(item);
+  if (index >= 0 && tiles_per_page())
+    pagination_model_->SelectPage(index / tiles_per_page());
+}
+
 gfx::Size AppsGridView::GetPreferredSize() {
-  if (!fixed_layout_)
-    return gfx::Size();
-
   gfx::Insets insets(GetInsets());
   gfx::Size tile_size = gfx::Size(kPreferredTileWidth, kPreferredTileHeight);
   return gfx::Size(tile_size.width() * cols_ + insets.width(),
                    tile_size.height() * rows_per_page_ + insets.height());
 }
 
 void AppsGridView::Layout() {
   gfx::Rect rect(GetContentsBounds());
-  if (rect.IsEmpty() || child_count() == 0)
+  if (rect.IsEmpty() || child_count() == 0 || !tiles_per_page())
     return;
 
-  gfx::Size tile_size;
-  if (fixed_layout_) {
-    tile_size = gfx::Size(kPreferredTileWidth, kPreferredTileHeight);
-  } else {
-    int rows = 0;
-    CalculateLayout(rect.size(), child_count(), &icon_size_, &rows, &cols_);
+  gfx::Size tile_size(kPreferredTileWidth, kPreferredTileHeight);
 
-    tile_size = AppListItemView::GetPreferredSizeForIconSize(
-        icon_size_);
-    rows_per_page_ = tile_size.height() ?
-        std::max(rect.height() / tile_size.height(), 1) : 1;
-
-    tile_size.set_width(std::max(rect.width() / (cols_ + 1),
-                                 tile_size.width()));
-    tile_size.set_height(std::max(rect.height() / (rows_per_page_ + 1),
-                                  tile_size.height()));
-  }
-
-  if (!tiles_per_page())
-    return;
 
   pagination_model_->SetTotalPages((child_count() - 1) / tiles_per_page() + 1);
   if (pagination_model_->selected_page() < 0)
     pagination_model_->SelectPage(0);
 
   gfx::Rect grid_rect = rect.Center(
       gfx::Size(tile_size.width() * cols_,
                 tile_size.height() * rows_per_page_));
   grid_rect = grid_rect.Intersect(rect);
 
@@ skipping 98 matching lines @@
 
 AppListItemView* AppsGridView::GetItemViewAtIndex(int index) {
   return static_cast<AppListItemView*>(child_at(index));
 }
 
 void AppsGridView::SetSelectedItemByIndex(int index) {
   if (selected_item_index_ == index)
     return;
 
   if (selected_item_index_ >= 0)
-    GetItemViewAtIndex(selected_item_index_)->SetSelected(false);
+    GetItemViewAtIndex(selected_item_index_)->SchedulePaint();
 
   if (index < 0 || index >= child_count()) {
     selected_item_index_ = -1;
   } else {
     selected_item_index_ = index;
-    GetItemViewAtIndex(selected_item_index_)->SetSelected(true);
+    GetItemViewAtIndex(selected_item_index_)->SchedulePaint();
 
     if (tiles_per_page())
       pagination_model_->SelectPage(selected_item_index_ / tiles_per_page());
   }
 }
 
 void AppsGridView::ListItemsAdded(size_t start, size_t count) {
   for (size_t i = start; i < start + count; ++i) {
     AddChildViewAt(new AppListItemView(this, model_->GetItemAt(i), listener_),
                    i);
@@ skipping 15 matching lines @@
 }
 
 void AppsGridView::TotalPagesChanged() {
 }
 
 void AppsGridView::SelectedPageChanged(int old_selected, int new_selected) {
   Layout();
 }
 
 }  // namespace app_list