Revert of Shelf Cleanup (- binary files)

ash/shelf/shelf_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 "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/root_window_controller.h"
 #include "ash/scoped_target_root_window.h"
+#include "ash/shelf/alternate_app_list_button.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
 #include "ash/shelf/overflow_button.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_item_delegate.h"
 #include "ash/shelf/shelf_item_delegate_manager.h"
@@ skipping 41 matching lines @@
 const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT = 1;
 const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT = 2;
 const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT = 3;
 
 // Default amount content is inset on the left edge.
 const int kDefaultLeadingInset = 8;
 
 // Minimum distance before drag starts.
 const int kMinimumDragDistance = 8;
 
+// Size between the buttons.
+const int kButtonSpacing = 4;
+const int kAlternateButtonSpacing = 10;
+
+// Size allocated to for each button.
+const int kButtonSize = 44;
+
 // Additional spacing for the left and right side of icons.
 const int kHorizontalIconSpacing = 2;
 
 // Inset for items which do not have an icon.
 const int kHorizontalNoIconInsetSpacing =
     kHorizontalIconSpacing + kDefaultLeadingInset;
 
 // The proportion of the shelf space reserved for non-panel icons. Panels
 // may flow into this space but will be put into the overflow bubble if there
 // is contention for the space.
@@ skipping 331 matching lines @@
 void ShelfView::Init() {
   model_->AddObserver(this);
 
   const ShelfItems& items(model_->items());
   for (ShelfItems::const_iterator i = items.begin(); i != items.end(); ++i) {
     views::View* child = CreateViewForItem(*i);
     child->SetPaintToLayer(true);
     view_model_->Add(child, static_cast<int>(i - items.begin()));
     AddChildView(child);
   }
+  ShelfStatusChanged();
   overflow_button_ = new OverflowButton(this);
   overflow_button_->set_context_menu_controller(this);
   ConfigureChildView(overflow_button_);
   AddChildView(overflow_button_);
+  UpdateFirstButtonPadding();
 
   // We'll layout when our bounds change.
 }
 
 void ShelfView::OnShelfAlignmentChanged() {
+  UpdateFirstButtonPadding();
   overflow_button_->OnShelfAlignmentChanged();
   LayoutToIdealBounds();
   for (int i=0; i < view_model_->view_size(); ++i) {
+    // TODO: remove when AppIcon is a Shelf Button.
+    if (TYPE_APP_LIST == model_->items()[i].type &&
+        !ash::switches::UseAlternateShelfLayout()) {
+      static_cast<AppListButton*>(view_model_->view_at(i))->SetImageAlignment(
+          layout_manager_->SelectValueForShelfAlignment(
+              views::ImageButton::ALIGN_CENTER,
+              views::ImageButton::ALIGN_LEFT,
+              views::ImageButton::ALIGN_RIGHT,
+              views::ImageButton::ALIGN_CENTER),
+          layout_manager_->SelectValueForShelfAlignment(
+              views::ImageButton::ALIGN_TOP,
+              views::ImageButton::ALIGN_MIDDLE,
+              views::ImageButton::ALIGN_MIDDLE,
+              views::ImageButton::ALIGN_BOTTOM));
+    }
     if (i >= first_visible_index_ && i <= last_visible_index_)
       view_model_->view_at(i)->Layout();
   }
   tooltip_->Close();
   if (overflow_bubble_)
     overflow_bubble_->Hide();
 }
 
 void ShelfView::SchedulePaintForAllButtons() {
   for (int i = 0; i < view_model_->view_size(); ++i) {
@@ skipping 233 matching lines @@
 
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
   views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
 }
 
 void ShelfView::UpdateAllButtonsVisibilityInOverflowMode() {
   // The overflow button is not shown in overflow mode.
   overflow_button_->SetVisible(false);
+  int last_button_index = model_->FirstPanelIndex() - 1;
   DCHECK_LT(last_visible_index_, view_model_->view_size());
   for (int i = 0; i < view_model_->view_size(); ++i) {
     bool visible = i >= first_visible_index_ &&
         i <= last_visible_index_;
+    if (!ash::switches::UseAlternateShelfLayout())
+      visible &= i != last_button_index;
 
     // To track the dragging of |drag_view_| continuously, its visibility
     // should be always true regardless of its position.
     if (dragged_off_from_overflow_to_shelf_ &&
         view_model_->view_at(i) == drag_view_)
       view_model_->view_at(i)->SetVisible(true);
     else
       view_model_->view_at(i)->SetVisible(visible);
   }
 }
 
 void ShelfView::CalculateIdealBounds(IdealBounds* bounds) {
   int available_size = layout_manager_->PrimaryAxisValue(width(), height());
   DCHECK(model_->item_count() == view_model_->view_size());
   if (!available_size)
     return;
 
   int first_panel_index = model_->FirstPanelIndex();
   int last_button_index = first_panel_index - 1;
 
-  int x = 0;
-  int y = 0;
+  // Initial x,y values account both leading_inset in primary
+  // coordinate and secondary coordinate based on the dynamic edge of the
+  // shelf (eg top edge on bottom-aligned shelf).
+  int inset = ash::switches::UseAlternateShelfLayout() ? 0 : leading_inset_;
+  int x = layout_manager_->SelectValueForShelfAlignment(inset, 0, 0, inset);
+  int y = layout_manager_->SelectValueForShelfAlignment(0, inset, inset, 0);
 
-  int button_size = kShelfButtonSize;
-  int button_spacing = kShelfButtonSpacing;
+  int button_size = GetButtonSize();
+  int button_spacing = GetButtonSpacing();
 
   int w = layout_manager_->PrimaryAxisValue(button_size, width());
   int h = layout_manager_->PrimaryAxisValue(height(), button_size);
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i < first_visible_index_) {
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, 0, 0));
       continue;
     }
 
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
     if (i != last_button_index) {
       x = layout_manager_->PrimaryAxisValue(x + w + button_spacing, x);
       y = layout_manager_->PrimaryAxisValue(y, y + h + button_spacing);
     }
   }
 
   if (is_overflow_mode()) {
     UpdateAllButtonsVisibilityInOverflowMode();
     return;
   }
 
+  // To address Fitt's law, we make the first shelf button include the
+  // leading inset (if there is one).
+  if (!ash::switches::UseAlternateShelfLayout()) {
+    if (view_model_->view_size() > 0) {
+      view_model_->set_ideal_bounds(0, gfx::Rect(gfx::Size(
+          layout_manager_->PrimaryAxisValue(inset + w, w),
+          layout_manager_->PrimaryAxisValue(h, inset + h))));
+    }
+  }
+
   // Right aligned icons.
   int end_position = available_size - button_spacing;
   x = layout_manager_->PrimaryAxisValue(end_position, 0);
   y = layout_manager_->PrimaryAxisValue(0, end_position);
   for (int i = view_model_->view_size() - 1;
        i >= first_panel_index; --i) {
     x = layout_manager_->PrimaryAxisValue(x - w - button_spacing, x);
     y = layout_manager_->PrimaryAxisValue(y, y - h - button_spacing);
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
     end_position = layout_manager_->PrimaryAxisValue(x, y);
   }
 
   // Icons on the left / top are guaranteed up to kLeftIconProportion of
   // the available space.
   int last_icon_position = layout_manager_->PrimaryAxisValue(
       view_model_->ideal_bounds(last_button_index).right(),
       view_model_->ideal_bounds(last_button_index).bottom())
-      + button_size;
+      + button_size + inset;
+  if (!ash::switches::UseAlternateShelfLayout())
+      last_icon_position += button_size;
   int reserved_icon_space = available_size * kReservedNonPanelIconProportion;
   if (last_icon_position < reserved_icon_space)
     end_position = last_icon_position;
   else
     end_position = std::max(end_position, reserved_icon_space);
 
   bounds->overflow_bounds.set_size(
       gfx::Size(layout_manager_->PrimaryAxisValue(w, width()),
                 layout_manager_->PrimaryAxisValue(height(), h)));
 
-  last_visible_index_ = DetermineLastVisibleIndex(
-      end_position - button_size);
+  if (ash::switches::UseAlternateShelfLayout()) {
+    last_visible_index_ = DetermineLastVisibleIndex(
+        end_position - button_size);
+  } else {
+    last_visible_index_ = DetermineLastVisibleIndex(
+        end_position - inset - 2 * button_size);
+  }
   last_hidden_index_ = DetermineFirstVisiblePanelIndex(end_position) - 1;
-  bool show_overflow = (last_visible_index_ < last_button_index ||
-                       last_hidden_index_ >= first_panel_index);
+  bool show_overflow =
+      ((ash::switches::UseAlternateShelfLayout() ? 0 : 1) +
+      last_visible_index_ < last_button_index ||
+      last_hidden_index_ >= first_panel_index);
 
   // Create Space for the overflow button
-  if (show_overflow && last_visible_index_ > 0 &&
-      last_visible_index_ < last_button_index)
+  if (show_overflow && ash::switches::UseAlternateShelfLayout() &&
+      last_visible_index_ > 0 && last_visible_index_ < last_button_index)
     --last_visible_index_;
   for (int i = 0; i < view_model_->view_size(); ++i) {
     bool visible = i <= last_visible_index_ || i > last_hidden_index_;
+    // Always show the app list.
+    if (!ash::switches::UseAlternateShelfLayout())
+      visible |= (i == last_button_index);
     // To receive drag event continously from |drag_view_| during the dragging
     // off from the shelf, don't make |drag_view_| invisible. It will be
     // eventually invisible and removed from the |view_model_| by
     // FinalizeRipOffDrag().
     if (dragged_off_shelf_ && view_model_->view_at(i) == drag_view_)
       continue;
     view_model_->view_at(i)->SetVisible(visible);
   }
 
   overflow_button_->SetVisible(show_overflow);
   if (show_overflow) {
     DCHECK_NE(0, view_model_->view_size());
     if (last_visible_index_ == -1) {
-      x = 0;
-      y = 0;
+      x = layout_manager_->SelectValueForShelfAlignment(inset, 0, 0, inset);
+      y = layout_manager_->SelectValueForShelfAlignment(0, inset, inset, 0);
+    } else if (last_visible_index_ == last_button_index
+        && !ash::switches::UseAlternateShelfLayout()) {
+      x = view_model_->ideal_bounds(last_visible_index_).x();
+      y = view_model_->ideal_bounds(last_visible_index_).y();
     } else {
       x = layout_manager_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).right(),
           view_model_->ideal_bounds(last_visible_index_).x());
       y = layout_manager_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).y(),
           view_model_->ideal_bounds(last_visible_index_).bottom());
     }
     // Set all hidden panel icon positions to be on the overflow button.
     for (int i = first_panel_index; i <= last_hidden_index_; ++i)
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
 
     // Add more space between last visible item and overflow button.
     // Without this, two buttons look too close compared with other items.
-    x = layout_manager_->PrimaryAxisValue(x + button_spacing, x);
-    y = layout_manager_->PrimaryAxisValue(y, y + button_spacing);
+    if (ash::switches::UseAlternateShelfLayout()) {
+      x = layout_manager_->PrimaryAxisValue(x + button_spacing, x);
+      y = layout_manager_->PrimaryAxisValue(y, y + button_spacing);
+    }
 
     bounds->overflow_bounds.set_x(x);
     bounds->overflow_bounds.set_y(y);
+    if (!ash::switches::UseAlternateShelfLayout()) {
+      // Position app list after overflow button.
+      gfx::Rect app_list_bounds = view_model_->ideal_bounds(last_button_index);
+
+      x = layout_manager_->PrimaryAxisValue(x + w + button_spacing, x);
+      y = layout_manager_->PrimaryAxisValue(y, y + h + button_spacing);
+      app_list_bounds.set_x(x);
+      app_list_bounds.set_y(y);
+      view_model_->set_ideal_bounds(last_button_index, app_list_bounds);
+    }
     if (overflow_bubble_.get() && overflow_bubble_->IsShowing())
       UpdateOverflowRange(overflow_bubble_->shelf_view());
   } else {
     if (overflow_bubble_)
       overflow_bubble_->Hide();
   }
 }
 
 int ShelfView::DetermineLastVisibleIndex(int max_value) const {
   int index = model_->FirstPanelIndex() - 1;
@@ skipping 28 matching lines @@
 void ShelfView::AnimateToIdealBounds() {
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
   for (int i = 0; i < view_model_->view_size(); ++i) {
     View* view = view_model_->view_at(i);
     bounds_animator_->AnimateViewTo(view, view_model_->ideal_bounds(i));
     // Now that the item animation starts, we have to make sure that the
     // padding of the first gets properly transferred to the new first item.
     if (i && view->border())
       view->SetBorder(views::Border::NullBorder());
+    else if (!i && !view->border())
+      UpdateFirstButtonPadding();
   }
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
 }
 
 views::View* ShelfView::CreateViewForItem(const ShelfItem& item) {
   views::View* view = NULL;
   switch (item.type) {
     case TYPE_BROWSER_SHORTCUT:
     case TYPE_APP_SHORTCUT:
     case TYPE_WINDOWED_APP:
     case TYPE_PLATFORM_APP:
     case TYPE_DIALOG:
     case TYPE_APP_PANEL: {
       ShelfButton* button = ShelfButton::Create(this, this, layout_manager_);
       button->SetImage(item.image);
       ReflectItemStatus(item, button);
       view = button;
       break;
     }
 
     case TYPE_APP_LIST: {
-      view = new AppListButton(this, this, layout_manager_->shelf_widget());
+      if (ash::switches::UseAlternateShelfLayout()) {
+        view = new AlternateAppListButton(this,
+                                          this,
+                                          layout_manager_->shelf_widget());
+      } else {
+        // TODO(dave): turn this into a ShelfButton too.
+        AppListButton* button = new AppListButton(this, this);
+        button->SetImageAlignment(
+            layout_manager_->SelectValueForShelfAlignment(
+                views::ImageButton::ALIGN_CENTER,
+                views::ImageButton::ALIGN_LEFT,
+                views::ImageButton::ALIGN_RIGHT,
+                views::ImageButton::ALIGN_CENTER),
+            layout_manager_->SelectValueForShelfAlignment(
+                views::ImageButton::ALIGN_TOP,
+                views::ImageButton::ALIGN_MIDDLE,
+                views::ImageButton::ALIGN_MIDDLE,
+                views::ImageButton::ALIGN_BOTTOM));
+        view = button;
+      }
       break;
     }
 
     default:
       break;
   }
   view->set_context_menu_controller(this);
 
   DCHECK(view);
   ConfigureChildView(view);
@@ skipping 336 matching lines @@
   overflow_view->set_owner_overflow_bubble(overflow_bubble_.get());
   overflow_view->OnShelfAlignmentChanged();
   overflow_view->main_shelf_ = this;
   UpdateOverflowRange(overflow_view);
 
   overflow_bubble_->Show(overflow_button_, overflow_view);
 
   Shell::GetInstance()->UpdateShelfVisibility();
 }
 
+void ShelfView::UpdateFirstButtonPadding() {
+  if (ash::switches::UseAlternateShelfLayout())
+    return;
+
+  // Creates an empty border for first shelf button to make included leading
+  // inset act as the button's padding. This is only needed on button creation
+  // and when shelf alignment changes.
+  if (view_model_->view_size() > 0) {
+    view_model_->view_at(0)->SetBorder(views::Border::CreateEmptyBorder(
+        layout_manager_->PrimaryAxisValue(0, leading_inset_),
+        layout_manager_->PrimaryAxisValue(leading_inset_, 0),
+        0,
+        0));
+  }
+}
+
 void ShelfView::OnFadeOutAnimationEnded() {
   AnimateToIdealBounds();
   StartFadeInLastVisibleItem();
 }
 
 void ShelfView::StartFadeInLastVisibleItem() {
   // If overflow button is visible and there is a valid new last item, fading
   // the new last item in after sliding animation is finished.
   if (overflow_button_->visible() && last_visible_index_ >= 0) {
     views::View* last_visible_view = view_model_->view_at(last_visible_index_);
     last_visible_view->layer()->SetOpacity(0);
     bounds_animator_->SetAnimationDelegate(
         last_visible_view,
         new ShelfView::StartFadeAnimationDelegate(this, last_visible_view),
         true);
   }
 }
 
 void ShelfView::UpdateOverflowRange(ShelfView* overflow_view) {
   const int first_overflow_index = last_visible_index_ + 1;
   const int last_overflow_index = last_hidden_index_;
   DCHECK_LE(first_overflow_index, last_overflow_index);
   DCHECK_LT(last_overflow_index, view_model_->view_size());
 
   overflow_view->first_visible_index_ = first_overflow_index;
   overflow_view->last_visible_index_ = last_overflow_index;
 }
 
+int ShelfView::GetButtonSize() const {
+  return ash::switches::UseAlternateShelfLayout() ?
+      kButtonSize : kShelfPreferredSize;
+}
+
+int ShelfView::GetButtonSpacing() const {
+  return ash::switches::UseAlternateShelfLayout() ?
+      kAlternateButtonSpacing : kButtonSpacing;
+}
+
 bool ShelfView::ShouldHideTooltip(const gfx::Point& cursor_location) {
   gfx::Rect active_bounds;
 
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
     if (child == overflow_button_)
       continue;
     if (!ShouldShowTooltipForView(child))
       continue;
 
@@ skipping 12 matching lines @@
 }
 
 gfx::Rect ShelfView::GetBoundsForDragInsertInScreen() {
   gfx::Size preferred_size;
   if (is_overflow_mode()) {
     DCHECK(owner_overflow_bubble_);
     gfx::Rect bubble_bounds =
         owner_overflow_bubble_->bubble_view()->GetBubbleBounds();
     preferred_size = bubble_bounds.size();
   } else {
+    const int preferred_shelf_size = layout_manager_->GetPreferredShelfSize();
+
     const int last_button_index = view_model_->view_size() - 1;
     gfx::Rect last_button_bounds =
         view_model_->view_at(last_button_index)->bounds();
     if (overflow_button_->visible() &&
         model_->GetItemIndexForType(TYPE_APP_PANEL) == -1) {
       // When overflow button is visible and shelf has no panel items,
       // last_button_bounds should be overflow button's bounds.
       last_button_bounds = overflow_button_->bounds();
     }
 
     if (layout_manager_->IsHorizontalAlignment()) {
       preferred_size = gfx::Size(last_button_bounds.right() + leading_inset_,
-                                 kShelfSize);
+                                 preferred_shelf_size);
     } else {
-      preferred_size = gfx::Size(kShelfSize,
+      preferred_size = gfx::Size(preferred_shelf_size,
                                  last_button_bounds.bottom() + leading_inset_);
     }
   }
   gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
 
   // In overflow mode, we should use OverflowBubbleView as a source for
   // converting |origin| to screen coordinates. When a scroll operation is
   // occurred in OverflowBubble, the bounds of ShelfView in OverflowBubble can
   // be changed.
   if (is_overflow_mode())
@@ skipping 30 matching lines @@
   // the list.
   if (at_end)
     return view_model_->view_size();
   return modified_view ? view_model_->GetIndexOfView(modified_view) : -1;
 }
 
 gfx::Size ShelfView::GetPreferredSize() {
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
 
+  const int preferred_size = layout_manager_->GetPreferredShelfSize();
+
   int last_button_index = is_overflow_mode() ?
       last_visible_index_ : view_model_->view_size() - 1;
 
   // When an item is dragged off from the overflow bubble, it is moved to last
   // position and and changed to invisible. Overflow bubble size should be
   // shrunk to fit only for visible items.
   // If |dragged_off_from_overflow_to_shelf_| is set, there will be no invisible
   // items in the shelf.
   if (is_overflow_mode() &&
       dragged_off_shelf_ &&
       !dragged_off_from_overflow_to_shelf_ &&
       RemovableByRipOff(view_model_->GetIndexOfView(drag_view_)) == REMOVABLE)
     last_button_index--;
 
   const gfx::Rect last_button_bounds =
       last_button_index  >= first_visible_index_ ?
           view_model_->ideal_bounds(last_button_index) :
-          gfx::Rect(gfx::Size(kShelfSize, kShelfSize));
+          gfx::Rect(gfx::Size(preferred_size, preferred_size));
 
   if (layout_manager_->IsHorizontalAlignment()) {
-    return gfx::Size(last_button_bounds.right() + leading_inset_, kShelfSize);
+    return gfx::Size(last_button_bounds.right() + leading_inset_,
+                     preferred_size);
   }
 
-  return gfx::Size(kShelfSize,
+  return gfx::Size(preferred_size,
                    last_button_bounds.bottom() + leading_inset_);
 }
 
 void ShelfView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   // This bounds change is produced by the shelf movement and all content has
   // to follow. Using an animation at that time would produce a time lag since
   // the animation of the BoundsAnimator has itself a delay before it arrives
   // at the required location. As such we tell the animator to go there
   // immediately.
   BoundsAnimatorDisabler disabler(bounds_animator_.get());
@@ skipping 144 matching lines @@
   view_model_->Move(start_index, target_index);
   // When cancelling a drag due to a shelf item being added, the currently
   // dragged item is moved back to its initial position. AnimateToIdealBounds
   // will be called again when the new item is added to the |view_model_| but
   // at this time the |view_model_| is inconsistent with the |model_|.
   if (!cancelling_drag_model_changed_)
     AnimateToIdealBounds();
 }
 
 void ShelfView::ShelfStatusChanged() {
-  // Nothing to do here.
+  if (ash::switches::UseAlternateShelfLayout())
+    return;
+  AppListButton* app_list_button =
+      static_cast<AppListButton*>(GetAppListButtonView());
+  if (model_->status() == ShelfModel::STATUS_LOADING)
+    app_list_button->StartLoadingAnimation();
+  else
+    app_list_button->StopLoadingAnimation();
 }
 
 void ShelfView::PointerPressedOnButton(views::View* view,
                                        Pointer pointer,
                                        const ui::LocatedEvent& event) {
   if (drag_view_)
     return;
 
   int index = view_model_->GetIndexOfView(view);
   if (index == -1)
@@ skipping 356 matching lines @@
       break;
     case SHELF_ALIGNMENT_TOP:
       distance = coordinate.y() - bounds.bottom();
       break;
   }
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace internal
 }  // namespace ash