Add LauncherIconObserver.

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 "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/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"
@@ skipping 229 matching lines @@
     return NULL;
 
   return static_cast<LauncherButton*>(
       launcher_view_->view_model_->view_at(index));
 }
 
 LauncherView::LauncherView(LauncherModel* model, LauncherDelegate* delegate)
     : model_(model),
       delegate_(delegate),
       view_model_(new views::ViewModel),
+      last_visible_index_(-1),
       overflow_button_(NULL),
       dragging_(NULL),
       drag_view_(NULL),
       drag_offset_(0),
       start_drag_index_(-1),
       context_menu_id_(0) {
   DCHECK(model_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   set_context_menu_controller(this);
   focus_search_.reset(new LauncherFocusSearch(view_model_.get()));
@@ skipping 30 matching lines @@
       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.
 }
 
 gfx::Rect LauncherView::GetIdealBoundsOfItemIcon(LauncherID id) {
   int index = model_->ItemIndexByID(id);
-  if (index == -1 || !view_model_->view_at(index)->visible())
+  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());
 }
@@ skipping 38 matching lines @@
   int x = kLeadingInset;
   for (int i = 0; i < view_model_->view_size(); ++i) {
     gfx::Size pref(kButtonWidth, kButtonHeight);
     view_model_->set_ideal_bounds(i, gfx::Rect(
         x, (kLauncherPreferredHeight - pref.height()) / 2, pref.width(),
         pref.height()));
     x += pref.width() + kButtonSpacing;
   }
 
   bounds->overflow_bounds.set_size(gfx::Size(kButtonWidth, kButtonHeight));
-  int last_visible_index = DetermineLastVisibleIndex(
+  last_visible_index_ = DetermineLastVisibleIndex(
       available_width - kLeadingInset - bounds->overflow_bounds.width() -
       kButtonSpacing - kButtonWidth);
   bool show_overflow =
-      (last_visible_index + 1 != view_model_->view_size());
+      (last_visible_index_ + 1 != view_model_->view_size());
   int app_list_index = view_model_->view_size() - 1;
   if (overflow_button_->visible() != show_overflow) {
     // Only change visibility of the views if the visibility of the overflow
     // button changes. Otherwise we'll effect the insertion animation, which
     // changes the visibility.
-    for (int i = 0; i <= last_visible_index; ++i)
+    for (int i = 0; i <= last_visible_index_; ++i)
       view_model_->view_at(i)->SetVisible(true);
-    for (int i = last_visible_index + 1; i < view_model_->view_size(); ++i) {
+    for (int i = last_visible_index_ + 1; i < view_model_->view_size(); ++i) {
       if (i != app_list_index)
         view_model_->view_at(i)->SetVisible(false);
     }
   }
   overflow_button_->SetVisible(show_overflow);
   if (show_overflow) {
     DCHECK_NE(0, view_model_->view_size());
     // We always want the app list visible.
     gfx::Rect app_list_bounds = view_model_->ideal_bounds(app_list_index);
-    x = last_visible_index == -1 ?
-        kLeadingInset : view_model_->ideal_bounds(last_visible_index).right();
+    x = last_visible_index_ == -1 ?
+        kLeadingInset : view_model_->ideal_bounds(last_visible_index_).right();
     app_list_bounds.set_x(x);
     view_model_->set_ideal_bounds(app_list_index, app_list_bounds);
     x = app_list_bounds.right() + kButtonSpacing;
     bounds->overflow_bounds.set_x(x);
     bounds->overflow_bounds.set_y(
         (kLauncherPreferredHeight - bounds->overflow_bounds.height()) / 2);
   }
 }
 
 int LauncherView::DetermineLastVisibleIndex(int max_x) {
   int index = view_model_->view_size() - 1;
   while (index >= 0 && view_model_->ideal_bounds(index).right() > max_x)
     index--;
   return index;
 }
 
+void LauncherView::AddIconObserver(LauncherIconObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void LauncherView::RemoveIconObserver(LauncherIconObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void LauncherView::AnimateToIdealBounds() {
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
   for (int i = 0; i < view_model_->view_size(); ++i) {
     bounds_animator_->AnimateViewTo(view_model_->view_at(i),
                                     view_model_->ideal_bounds(i));
   }
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
 }
 
@@ skipping 117 matching lines @@
     return;
 
   // Remove the observer while we mutate the model so that we don't attempt to
   // cancel the drag.
   model_->RemoveObserver(this);
   model_->Move(current_index, target_index);
   model_->AddObserver(this);
   view_model_->Move(current_index, target_index);
   AnimateToIdealBounds();
   bounds_animator_->StopAnimatingView(drag_view_);
+
+  FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
+                    OnLauncherIconPositionsChanged());
 }
 
 bool LauncherView::SameDragType(LauncherItemType typea,
                                 LauncherItemType typeb) const {
   switch(typea) {
     case TYPE_TABBED:
     case TYPE_APP_PANEL:
       return (typeb == TYPE_TABBED || typeb == TYPE_APP_PANEL);
     case TYPE_APP_SHORTCUT:
     case TYPE_APP_LIST:
@@ skipping 101 matching lines @@
     // Should always have two items.
     return gfx::Size(view_model_->ideal_bounds(1).right() + kLeadingInset,
                      kLauncherPreferredHeight);
   }
   return gfx::Size(kButtonWidth * 2 + kLeadingInset * 2,
                    kLauncherPreferredHeight);
 }
 
 void LauncherView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   LayoutToIdealBounds();
+  FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
+                    OnLauncherIconPositionsChanged());
 }
 
 views::FocusTraversable* LauncherView::GetPaneFocusTraversable() {
   return this;
 }
 
 void LauncherView::LauncherItemAdded(int model_index) {
   CancelDrag(NULL);
 
   views::View* view = CreateViewForItem(model_->items()[model_index]);
@@ skipping 11 matching lines @@
   view->SetBoundsRect(view_model_->ideal_bounds(model_index));
 
   // The first animation moves all the views to their target position. |view| is
   // hidden, so it visually appears as though we are providing space for
   // it. When done we'll fade the view in.
   AnimateToIdealBounds();
   if (!overflow_button_->visible()) {
     bounds_animator_->SetAnimationDelegate(
         view, new StartFadeAnimationDelegate(this, view), true);
   }
+
+  FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
+                    OnLauncherIconPositionsChanged());
 }
 
 void LauncherView::LauncherItemRemoved(int model_index, LauncherID id) {
 #if !defined(OS_MACOSX)
   if (id == context_menu_id_)
     launcher_menu_runner_.reset();
 #endif
   views::View* view = view_model_->view_at(model_index);
   CancelDrag(view);
   view_model_->Remove(model_index);
   // The first animation fades out the view. When done we'll animate the rest of
   // the views to their target location.
   bounds_animator_->AnimateViewTo(view, view->bounds());
   bounds_animator_->SetAnimationDelegate(
       view, new FadeOutAnimationDelegate(this, view), true);
+
+  // The animation will eventually update the ideal bounds, but we want to
+  // force an update immediately so we can notify launcher icon observers.
+  IdealBounds ideal_bounds;
+  CalculateIdealBounds(&ideal_bounds);
+
+  FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
+                    OnLauncherIconPositionsChanged());
 }
 
 void LauncherView::LauncherItemChanged(int model_index,
                                        const ash::LauncherItem& old_item) {
   const LauncherItem& item(model_->items()[model_index]);
   if (old_item.type != item.type) {
     // Type changed, swap the views.
     scoped_ptr<views::View> old_view(view_model_->view_at(model_index));
     bounds_animator_->StopAnimatingView(old_view.get());
     CancelDrag(old_view.get());
@@ skipping 29 matching lines @@
     }
 
     default:
       break;
   }
 }
 
 void LauncherView::LauncherItemMoved(int start_index, int target_index) {
   view_model_->Move(start_index, target_index);
   AnimateToIdealBounds();
+  FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
+                    OnLauncherIconPositionsChanged());
 }
 
 void LauncherView::LauncherItemWillChange(int index) {
   const LauncherItem& item(model_->items()[index]);
   views::View* view = view_model_->view_at(index);
   if (item.type == TYPE_TABBED)
     static_cast<TabbedLauncherButton*>(view)->PrepareForImageChange();
 }
 
 void LauncherView::MousePressedOnButton(views::View* view,
@@ skipping 118 matching lines @@
           source->GetWidget(), NULL, gfx::Rect(point, gfx::Size()),
           views::MenuItemView::TOPLEFT, 0) == views::MenuRunner::MENU_DELETED)
     return;
 
   Shell::GetInstance()->UpdateShelfVisibility();
 #endif
 }
 
 }  // namespace internal
 }  // namespace ash