ash: Add launcher overflow bubble.

ash/launcher/launcher_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/launcher/launcher_view.h"
 
 #include <algorithm>
 
 #include "ash/launcher/app_list_button.h"
 #include "ash/launcher/launcher_button.h"
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/launcher/launcher_icon_observer.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_tooltip_manager.h"
+#include "ash/launcher/overflow_bubble.h"
 #include "ash/launcher/tabbed_launcher_button.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "base/auto_reset.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "grit/ui_resources.h"
 #include "ui/aura/window.h"
 #include "ui/base/animation/animation.h"
 #include "ui/base/animation/throb_animation.h"
@@ skipping 12 matching lines @@
 #include "ui/views/view_model_utils.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 
 using ui::Animation;
 using views::View;
 
 namespace ash {
 namespace internal {
 
-// Amount content is inset on the left edge.
-static const int kLeadingInset = 8;
+// Default amount content is inset on the left edge.
+static const int kDefaultLeadingInset = 8;
 
 // Minimum distance before drag starts.
 static const int kMinimumDragDistance = 8;
 
 // Size between the buttons.
 static const int kButtonSpacing = 4;
 
 namespace {
 
 // Custom FocusSearch used to navigate the launcher in the order items are in
@@ skipping 201 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
 };
 
 LauncherView::LauncherView(LauncherModel* model,
                            LauncherDelegate* delegate,
                            ShelfLayoutManager* shelf_layout_manager)
     : model_(model),
       delegate_(delegate),
       view_model_(new views::ViewModel),
+      first_visible_index_(0),
       last_visible_index_(-1),
       overflow_button_(NULL),
       dragging_(false),
       drag_view_(NULL),
       drag_offset_(0),
       start_drag_index_(-1),
       context_menu_id_(0),
-      alignment_(SHELF_ALIGNMENT_BOTTOM) {
+      alignment_(SHELF_ALIGNMENT_BOTTOM),
+      leading_inset_(kDefaultLeadingInset) {
   DCHECK(model_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
   focus_search_.reset(new LauncherFocusSearch(view_model_.get()));
   tooltip_.reset(new LauncherTooltipManager(alignment_, shelf_layout_manager));
 }
 
 LauncherView::~LauncherView() {
   bounds_animator_->RemoveObserver(this);
   model_->RemoveObserver(this);
 }
 
 void LauncherView::Init() {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   model_->AddObserver(this);
 
   const LauncherItems& items(model_->items());
   for (LauncherItems::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);
   }
   UpdateFirstButtonPadding();
 
   overflow_button_ = new views::ImageButton(this);
   overflow_button_->set_accessibility_focusable(true);
+  overflow_button_->SetImageAlignment(views::ImageButton::ALIGN_CENTER,
+                                      views::ImageButton::ALIGN_MIDDLE);
   overflow_button_->SetImage(
       views::CustomButton::BS_NORMAL,
       rb.GetImageNamed(IDR_AURA_LAUNCHER_OVERFLOW).ToImageSkia());
   overflow_button_->SetImage(
       views::CustomButton::BS_HOT,
       rb.GetImageNamed(IDR_AURA_LAUNCHER_OVERFLOW_HOT).ToImageSkia());
   overflow_button_->SetImage(
       views::CustomButton::BS_PUSHED,
       rb.GetImageNamed(IDR_AURA_LAUNCHER_OVERFLOW_PUSHED).ToImageSkia());
   overflow_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_AURA_LAUNCHER_OVERFLOW_NAME));
   overflow_button_->set_context_menu_controller(this);
   ConfigureChildView(overflow_button_);
   AddChildView(overflow_button_);
 
   // We'll layout when our bounds change.
 }
 
 void LauncherView::SetAlignment(ShelfAlignment alignment) {
   if (alignment_ == alignment)
     return;
   alignment_ = alignment;
   UpdateFirstButtonPadding();
   LayoutToIdealBounds();
   tooltip_->SetArrowLocation(alignment_);
+  if (overflow_bubble_.get())
+    overflow_bubble_->Hide();
 }
 
 gfx::Rect LauncherView::GetIdealBoundsOfItemIcon(LauncherID id) {
   int index = model_->ItemIndexByID(id);
   if (index == -1 || index > last_visible_index_)
     return gfx::Rect();
   const gfx::Rect& ideal_bounds(view_model_->ideal_bounds(index));
   DCHECK_NE(TYPE_APP_LIST, model_->items()[index].type);
   LauncherButton* button =
       static_cast<LauncherButton*>(view_model_->view_at(index));
   gfx::Rect icon_bounds = button->GetIconBounds();
   return gfx::Rect(ideal_bounds.x() + icon_bounds.x(),
                    ideal_bounds.y() + icon_bounds.y(),
                    icon_bounds.width(), icon_bounds.height());
 }
 
 bool LauncherView::IsShowingMenu() const {
 #if !defined(OS_MACOSX)
-  return (overflow_menu_runner_.get() &&
-          overflow_menu_runner_->IsRunning()) ||
-      (launcher_menu_runner_.get() &&
+  return (launcher_menu_runner_.get() &&
        launcher_menu_runner_->IsRunning());
 #endif
   return false;
 }
 
+bool LauncherView::IsShowingOverflowBubble() const {
+  return overflow_bubble_.get() && overflow_bubble_->IsShowing();
+}
+
 views::View* LauncherView::GetAppListButtonView() const {
   for (int i = 0; i < model_->item_count(); ++i) {
     if (model_->items()[i].type == TYPE_APP_LIST)
       return view_model_->view_at(i);
   }
 
   NOTREACHED() << "Applist button not found";
   return NULL;
 }
 
@@ skipping 22 matching lines @@
     views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
 
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
 }
 
 void LauncherView::CalculateIdealBounds(IdealBounds* bounds) {
   int available_size = primary_axis_coordinate(width(), height());
   if (!available_size)
     return;
 
-  int x = primary_axis_coordinate(kLeadingInset, 0);
-  int y = primary_axis_coordinate(0, kLeadingInset);
+  int x = primary_axis_coordinate(leading_inset(), 0);
+  int y = primary_axis_coordinate(0, leading_inset());
   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, kLauncherPreferredSize, kLauncherPreferredSize));
     x = primary_axis_coordinate(x + kLauncherPreferredSize + kButtonSpacing, 0);
     y = primary_axis_coordinate(0, y + kLauncherPreferredSize + kButtonSpacing);
   }
 
+  int app_list_index = view_model_->view_size() - 1;
+  if (is_overflow_mode()) {
+    last_visible_index_ = app_list_index - 1;
+    for (int i = 0; i < view_model_->view_size(); ++i) {
+      view_model_->view_at(i)->SetVisible(
+          i >= first_visible_index_ && i <= last_visible_index_);
+    }
+    return;
+  }
+
   if (view_model_->view_size() > 0) {
     // Makes the first launcher button include the leading inset.
     view_model_->set_ideal_bounds(0, gfx::Rect(gfx::Size(
-        primary_axis_coordinate(kLeadingInset + kLauncherPreferredSize,
+        primary_axis_coordinate(leading_inset() + kLauncherPreferredSize,
                                 kLauncherPreferredSize),
         primary_axis_coordinate(kLauncherPreferredSize,
-                                kLeadingInset + kLauncherPreferredSize))));
+                                leading_inset() + kLauncherPreferredSize))));
   }
 
   bounds->overflow_bounds.set_size(
       gfx::Size(kLauncherPreferredSize, kLauncherPreferredSize));
   last_visible_index_ = DetermineLastVisibleIndex(
-      available_size - kLeadingInset - kLauncherPreferredSize -
+      available_size - leading_inset() - kLauncherPreferredSize -
       kButtonSpacing - kLauncherPreferredSize);
-  int app_list_index = view_model_->view_size() - 1;
   bool show_overflow = (last_visible_index_ + 1 < app_list_index);
 
   for (int i = 0; i < view_model_->view_size(); ++i) {
     view_model_->view_at(i)->SetVisible(
         i == app_list_index || i <= last_visible_index_);
   }
 
   overflow_button_->SetVisible(show_overflow);
   if (show_overflow) {
     DCHECK_NE(0, view_model_->view_size());
     if (last_visible_index_ == -1) {
-      x = primary_axis_coordinate(kLeadingInset, 0);
-      y = primary_axis_coordinate(0, kLeadingInset);
+      x = primary_axis_coordinate(leading_inset(), 0);
+      y = primary_axis_coordinate(0, leading_inset());
     } else {
       x = primary_axis_coordinate(
           view_model_->ideal_bounds(last_visible_index_).right(), 0);
       y = primary_axis_coordinate(0,
           view_model_->ideal_bounds(last_visible_index_).bottom());
     }
     gfx::Rect app_list_bounds = view_model_->ideal_bounds(app_list_index);
+    bounds->overflow_bounds.set_x(x);
+    bounds->overflow_bounds.set_y(y);
+    x = primary_axis_coordinate(x + kLauncherPreferredSize + kButtonSpacing, 0);
+    y = primary_axis_coordinate(0, y + kLauncherPreferredSize + kButtonSpacing);
     app_list_bounds.set_x(x);
     app_list_bounds.set_y(y);
     view_model_->set_ideal_bounds(app_list_index, app_list_bounds);
-    x = primary_axis_coordinate(x + kLauncherPreferredSize + kButtonSpacing, 0);
-    y = primary_axis_coordinate(0, y + kLauncherPreferredSize + kButtonSpacing);
-    bounds->overflow_bounds.set_x(x);
-    bounds->overflow_bounds.set_y(y);
+  } else {
+    if (overflow_bubble_.get())
+      overflow_bubble_->Hide();
   }
 }
 
 int LauncherView::DetermineLastVisibleIndex(int max_value) {
   int index = view_model_->view_size() - 1;
   while (index >= 0 &&
          primary_axis_coordinate(
              view_model_->ideal_bounds(index).right(),
              view_model_->ideal_bounds(index).bottom()) > max_value) {
     index--;
@@ skipping 219 matching lines @@
   while (index < view_model_->view_size()) {
     const LauncherItem& item = model_->items()[index];
     if (item.type == TYPE_TABBED ||
         item.type == TYPE_APP_PANEL ||
         item.type == TYPE_APP_SHORTCUT)
       items->push_back(item);
     index++;
   }
 }
 
-void LauncherView::ShowOverflowMenu() {
-#if !defined(OS_MACOSX)
-  if (!delegate_)
-    return;
+void LauncherView::ShowOverflowBubble() {
+  int first_overflow_index = last_visible_index_ + 1;
+  DCHECK_LT(first_overflow_index, view_model_->view_size() - 1);
 
-  std::vector<LauncherItem> items;
-  GetOverflowItems(&items);
-  if (items.empty())
-    return;
+  if (!overflow_bubble_.get())
+    overflow_bubble_.reset(new OverflowBubble());
 
-  MenuDelegateImpl menu_delegate;
-  ui::SimpleMenuModel menu_model(&menu_delegate);
-  for (size_t i = 0; i < items.size(); ++i)
-    menu_model.AddItem(static_cast<int>(i), delegate_->GetTitle(items[i]));
-  views::MenuModelAdapter menu_adapter(&menu_model);
-  overflow_menu_runner_.reset(new views::MenuRunner(menu_adapter.CreateMenu()));
-  gfx::Rect bounds(overflow_button_->size());
-  gfx::Point origin;
-  ConvertPointToScreen(overflow_button_, &origin);
-  if (overflow_menu_runner_->RunMenuAt(GetWidget(), NULL,
-          gfx::Rect(origin, size()), views::MenuItemView::TOPLEFT, 0) ==
-      views::MenuRunner::MENU_DELETED)
-    return;
+  overflow_bubble_->Show(delegate_,
+                         model_,
+                         overflow_button_,
+                         alignment_,
+                         first_overflow_index);
 
   Shell::GetInstance()->UpdateShelfVisibility();
-
-  if (menu_delegate.activated_command_id() == -1)
-    return;
-
-  LauncherID activated_id = items[menu_delegate.activated_command_id()].id;
-  LauncherItems::const_iterator window_iter = model_->ItemByID(activated_id);
-  if (window_iter == model_->items().end())
-    return;  // Window was deleted while menu was up.
-  delegate_->ItemClicked(*window_iter, ui::EF_NONE);
-#endif  // !defined(OS_MACOSX)
 }
 
 void LauncherView::UpdateFirstButtonPadding() {
   // Creates an empty border for first launcher 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)->set_border(views::Border::CreateEmptyBorder(
-        primary_axis_coordinate(0, kLeadingInset),
-        primary_axis_coordinate(kLeadingInset, 0),
+        primary_axis_coordinate(0, leading_inset()),
+        primary_axis_coordinate(leading_inset(), 0),
         0,
         0));
   }
 }
 
 bool LauncherView::ShouldHideTooltip(const gfx::Point& cursor_location) {
   gfx::Rect active_bounds;
 
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
@@ skipping 24 matching lines @@
   // Restore previous position, tracking the position of the modified view.
   views::View* removed_view =
       (modified_index >= 0) ? view_model_->view_at(modified_index) : NULL;
   model_->Move(drag_view_index, start_drag_index_);
   return removed_view ? view_model_->GetIndexOfView(removed_view) : -1;
 }
 
 gfx::Size LauncherView::GetPreferredSize() {
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
+
+  const int app_list_index = view_model_->view_size() - 1;
+  const int last_button_index = is_overflow_mode() ?
+      last_visible_index_ : app_list_index;
+  const gfx::Rect last_button_bounds =
+      last_button_index  >= first_visible_index_ ?
+          view_model_->view_at(last_button_index)->bounds() :
+          gfx::Rect(gfx::Size(kLauncherPreferredSize,
+                              kLauncherPreferredSize));
+
   if (is_horizontal_alignment()) {
-    if (view_model_->view_size() >= 2) {
-      // Should always have two items.
-      return gfx::Size(view_model_->ideal_bounds(1).right() + kLeadingInset,
-                       kLauncherPreferredSize);
-    }
-    return gfx::Size(kLauncherPreferredSize * 2 + kLeadingInset * 2,
+    return gfx::Size(last_button_bounds.right() + leading_inset(),
                      kLauncherPreferredSize);
   }
-  if (view_model_->view_size() >= 2) {
-    // Should always have two items.
-    return gfx::Size(kLauncherPreferredSize,
-                     view_model_->ideal_bounds(1).bottom() + kLeadingInset);
-  }
+
   return gfx::Size(kLauncherPreferredSize,
-                   kLauncherPreferredSize * 2 + kLeadingInset * 2);
+                   last_button_bounds.bottom() + leading_inset());
 }
 
 void LauncherView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   LayoutToIdealBounds();
   FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
                     OnLauncherIconPositionsChanged());
+
+  if (IsShowingOverflowBubble())
+    overflow_bubble_->Hide();
 }
 
 views::FocusTraversable* LauncherView::GetPaneFocusTraversable() {
   return this;
 }
 
 void LauncherView::OnMouseMoved(const views::MouseEvent& event) {
   if (ShouldHideTooltip(event.location()) && tooltip_->IsVisible())
     tooltip_->Close();
 }
@@ skipping 185 matching lines @@
   }
   return string16();
 }
 
 void LauncherView::ButtonPressed(views::Button* sender,
                                  const views::Event& event) {
   // Do not handle mouse release during drag.
   if (dragging_)
     return;
 
-  if (sender == overflow_button_)
-    ShowOverflowMenu();
+  if (sender == overflow_button_) {
+    ShowOverflowBubble();
+    return;
+  }
 
   if (!delegate_)
     return;
   int view_index = view_model_->GetIndexOfView(sender);
   // May be -1 while in the process of animating closed.
   if (view_index == -1)
     return;
 
   switch (model_->items()[view_index].type) {
     case TYPE_TABBED:
@@ skipping 46 matching lines @@
           views::MenuItemView::TOPLEFT, 0) == views::MenuRunner::MENU_DELETED)
     return;
 
   Shell::GetInstance()->UpdateShelfVisibility();
 #endif
 }
 
 void LauncherView::OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) {
   FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
                     OnLauncherIconPositionsChanged());
+  PreferredSizeChanged();
 }
 
 void LauncherView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
 }
 
 }  // namespace internal
 }  // namespace ash