Resize app list items 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 53 matching lines @@
 const int kTopPadding = 1;
 const int kBottomPadding = 24;
 
 // Padding space in pixels between pages.
 const int kPagePadding = 40;
 
 // Preferred tile size when showing in fixed layout.
 const int kPreferredTileWidth = 88;
 const int kPreferredTileHeight = 98;
 
+const int kExperimentalPreferredTileWidth = 90;
+const int kExperimentalPrefferedTileHeight = 90;
+
+// Padding on each side of a tile.
+const int kExperimentalTileLeftRightPadding = 15;
+const int kExperimentalTileTopBottomPadding = 11;
+
 // Width in pixels of the area on the sides that triggers a page flip.
 const int kPageFlipZoneSize = 40;
 
 // Delay in milliseconds to do the page flip.
 const int kPageFlipDelayInMs = 1000;
 
 // How many pages on either side of the selected one we prerender.
 const int kPrerenderPages = 1;
 
 // The drag and drop proxy should get scaled by this factor.
 const float kDragAndDropProxyScale = 1.5f;
 
 // Delays in milliseconds to show folder dropping preview circle.
 const int kFolderDroppingDelay = 150;
 
 // 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 = 39;
 
+// Returns the size of a tile view excluding its padding.
+gfx::Size GetTileViewSize() {
+  return switches::IsExperimentalAppListEnabled()
+             ? gfx::Size(kExperimentalPreferredTileWidth,
+                         kExperimentalPrefferedTileHeight)
+             : gfx::Size(kPreferredTileWidth, kPreferredTileHeight);
+}
+
+// Returns the size of a tile view inccluding its padding.
+gfx::Size GetTotalTileSize() {
+  gfx::Size size = GetTileViewSize();
+  if (switches::IsExperimentalAppListEnabled())
+    size.Enlarge(2 * kExperimentalTileLeftRightPadding,
+                 2 * kExperimentalTileTopBottomPadding);
+  return size;
+}
+
 // 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,
                            const gfx::Rect& layer_target)
@@ skipping 924 matching lines @@
   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);
+    views::View* view = new PulsingBlockView(GetTotalTileSize(), true);
     pulsing_blocks_model_.Add(view, 0);
     AddChildView(view);
   }
 }
 
 views::View* AppsGridView::CreateViewForItemAtIndex(size_t index) {
   // The drag_view_ might be pending for deletion, therefore view_model_
   // may have one more item than item_list_.
   DCHECK_LE(index, item_list_->item_count());
   AppListItemView* view = new AppListItemView(this,
@@ skipping 191 matching lines @@
     const gfx::Rect& target = view_model_.ideal_bounds(i);
     if (bounds_animator_.GetTargetBounds(view) == target)
       continue;
 
     const gfx::Rect& current = view->bounds();
     const bool current_visible = visible_bounds.Intersects(current);
     const bool target_visible = visible_bounds.Intersects(target);
     const bool visible = current_visible || target_visible;
 
     const int y_diff = target.y() - current.y();
-    if (visible && y_diff && y_diff % kPreferredTileHeight == 0) {
+    if (visible && y_diff && y_diff % GetTotalTileSize().height() == 0) {
       AnimationBetweenRows(view,
                            current_visible,
                            current,
                            target_visible,
                            target);
     } else if (visible || bounds_animator_.IsAnimating(view)) {
       bounds_animator_.AnimateViewTo(view, target);
       bounds_animator_.SetAnimationDelegate(
           view,
           scoped_ptr<gfx::AnimationDelegate>(
@@ skipping 21 matching lines @@
 
   scoped_ptr<ui::Layer> layer;
   if (animate_current) {
     layer = view->RecreateLayer();
     layer->SuppressPaint();
 
     view->SetFillsBoundsOpaquely(false);
     view->layer()->SetOpacity(0.f);
   }
 
+  gfx::Size total_tile_size = GetTotalTileSize();
   gfx::Rect current_out(current);
-  current_out.Offset(dir * kPreferredTileWidth, 0);
+  current_out.Offset(dir * total_tile_size.width(), 0);
 
   gfx::Rect target_in(target);
   if (animate_target)
-    target_in.Offset(-dir * kPreferredTileWidth, 0);
+    target_in.Offset(-dir * total_tile_size.width(), 0);
   view->SetBoundsRect(target_in);
   bounds_animator_.AnimateViewTo(view, target);
 
   bounds_animator_.SetAnimationDelegate(
       view,
       scoped_ptr<gfx::AnimationDelegate>(
           new RowMoveAnimationDelegate(view, layer.release(), current_out)));
 }
 
 void AppsGridView::ExtractDragLocation(const ui::LocatedEvent& event,
@@ skipping 74 matching lines @@
   gfx::Point reorder_placeholder_center =
       GetExpectedTileBounds(reorder_placeholder_.slot).CenterPoint();
 
   int x_offset_direction = 0;
   if (grid_index == reorder_placeholder_) {
     x_offset_direction = reorder_placeholder_center.x() < point.x() ? -1 : 1;
   } else {
     x_offset_direction = reorder_placeholder_ < grid_index ? -1 : 1;
   }
 
+  gfx::Size total_tile_size = GetTotalTileSize();
   int row = grid_index.slot / cols_;
 
   // Offset the target column based on the direction of the target. This will
   // result in earlier targets getting their reorder zone shifted backwards
   // and later targets getting their reorder zones shifted forwards.
   //
   // This makes eordering feel like the user is slotting items into the spaces
   // between apps.
   int x_offset = x_offset_direction *
-                 (kPreferredTileWidth - kFolderDroppingCircleRadius) / 2;
-  int col = (point.x() - bounds.x() + x_offset) / kPreferredTileWidth;
+                 (total_tile_size.width() - kFolderDroppingCircleRadius) / 2;
+  int col = (point.x() - bounds.x() + x_offset) / total_tile_size.width();
   col = ClampToRange(col, 0, cols_ - 1);
   *drop_target =
       std::min(Index(pagination_model_.selected_page(), row * cols_ + col),
                GetLastViewIndex());
 }
 
 void AppsGridView::OnReorderTimer() {
   if (drop_attempt_ == DROP_FOR_REORDER) {
     reorder_placeholder_ = reorder_drop_target_;
     AnimateToIdealBounds();
@@ skipping 641 matching lines @@
   // Items can be dropped into non-folders (which have no children) or folders
   // that have fewer than the max allowed items.
   // OEM folder does not allow to drag/drop other items in it.
   return target_item->ChildItemCount() < kMaxFolderItems &&
          !IsOEMFolderItem(target_item);
 }
 
 AppsGridView::Index AppsGridView::GetNearestTileIndexForPoint(
     const gfx::Point& point) const {
   gfx::Rect bounds = GetContentsBounds();
-  int col =
-      ClampToRange((point.x() - bounds.x()) / kPreferredTileWidth, 0, cols_);
+  gfx::Size total_tile_size = GetTotalTileSize();
+  int col = ClampToRange(
+      (point.x() - bounds.x()) / total_tile_size.width(), 0, cols_);
   int row = ClampToRange(
-      (point.y() - bounds.y()) / kPreferredTileHeight, 0, rows_per_page_);
+      (point.y() - bounds.y()) / total_tile_size.height(), 0, rows_per_page_);
   return Index(pagination_model_.selected_page(), row * cols_ + col);
 }
 
 gfx::Size AppsGridView::GetTileGridSize() const {
   gfx::Rect bounds = GetExpectedTileBounds(0, 0);
   bounds.Union(GetExpectedTileBounds(rows_per_page_ - 1, cols_ - 1));
+  if (switches::IsExperimentalAppListEnabled())
+    bounds.Inset(-kExperimentalTileLeftRightPadding,
+                 -kExperimentalTileTopBottomPadding);
   return bounds.size();
 }
 
 gfx::Rect AppsGridView::GetExpectedTileBounds(int slot) const {
   return GetExpectedTileBounds(slot / cols_, slot % cols_);
 }
 
 gfx::Rect AppsGridView::GetExpectedTileBounds(int row, int col) const {
   gfx::Rect bounds(GetContentsBounds());
-  gfx::Size tile_size(kPreferredTileWidth, kPreferredTileHeight);
-  return gfx::Rect(gfx::Point(bounds.x() + col * tile_size.width(),
-                              bounds.y() + row * tile_size.height()),
-                   tile_size);
+  gfx::Size total_tile_size = GetTotalTileSize();
+  gfx::Rect tile_bounds(gfx::Point(bounds.x() + col * total_tile_size.width(),
+                                   bounds.y() + row * total_tile_size.height()),
+                        total_tile_size);
+  tile_bounds.ClampToCenteredSize(GetTileViewSize());
+  return tile_bounds;
 }
 
 views::View* AppsGridView::GetViewAtSlotOnCurrentPage(int slot) {
   if (slot < 0)
     return NULL;
 
   // Calculate the original bound of the tile at |index|.
   int row = slot / cols_;
   int col = slot % cols_;
   gfx::Rect tile_rect = GetExpectedTileBounds(row, col);
 
   for (int i = 0; i < view_model_.view_size(); ++i) {
     views::View* view = view_model_.view_at(i);
     if (view->bounds() == tile_rect && view != drag_view_)
       return view;
   }
   return NULL;
 }
 
 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