Layout panels on top of their launcher icons

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 21 matching lines @@
 
 View* LauncherView::GetFocusTraversableParentView() {
   return this;
 }
 
 void LauncherView::LayoutToIdealBounds() {
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
   views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
+  FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
+                    OnLauncherIconPositionsChanged());
 }
 
 void LauncherView::CalculateIdealBounds(IdealBounds* bounds) {
   int available_width = width();
   if (!available_width)
     return;
 
   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);
+  // We report ideal bounds in GetScreenBoundsOfItemIconForWindow;
+  // we know them already here, so we report the change before animation.
+  FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
+                    OnLauncherIconPositionsChanged());

[Dmitry Lomov (no reviews), 2012/04/13 06:14:14]

This change is needed for Add test to work. I am not sure I am happy about it.
Tests for remove and move will not work because there are animations happening
before ideal bounds are calculated 

[sky, 2012/04/13 17:32:15]

This isn't the right place either. The notification should be sent from
LauncherItemRemoved/Added/Moved and OnBoundsChanged.

[Dmitry Lomov (no reviews), 2012/04/13 17:41:04]

No not really - we need to send notifiactions *after* ideal bounds has been
updated. In case of animations this may happen long after
LauncherItemRemoved/Added/Moved and OnBoundsChanged had exited. I am ok with
moving this back to  after the animation ends.

   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);
 }
 
 views::View* LauncherView::CreateViewForItem(const LauncherItem& item) {
   views::View* view = NULL;
   switch (item.type) {
@@ skipping 468 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