Rename Launcher to Shelf.

ash/wm/panels/panel_layout_manager.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/wm/panels/panel_layout_manager.h"
 
 #include <algorithm>
 #include <map>
 
-#include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 20 matching lines @@
 namespace {
 const int kPanelIdealSpacing = 4;
 
 const float kMaxHeightFactor = .80f;
 const float kMaxWidthFactor = .50f;
 
 // Duration for panel animations.
 const int kPanelSlideDurationMilliseconds = 50;
 const int kCalloutFadeDurationMilliseconds = 50;
 
-// Offset used when sliding panel in/out of the launcher. Used for minimizing,
+// Offset used when sliding panel in/out of the shelf. Used for minimizing,
 // restoring and the initial showing of a panel.
 const int kPanelSlideInOffset = 20;
 
 // Callout arrow dimensions.
 const int kArrowWidth = 18;
 const int kArrowHeight = 9;
 
 class CalloutWidgetBackground : public views::Background {
  public:
   CalloutWidgetBackground() : alignment_(SHELF_ALIGNMENT_BOTTOM) {
@@ skipping 189 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PanelCalloutWidget);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager public implementation:
 PanelLayoutManager::PanelLayoutManager(aura::Window* panel_container)
     : panel_container_(panel_container),
       in_add_window_(false),
       in_layout_(false),
       dragged_panel_(NULL),
-      launcher_(NULL),
+      shelf_(NULL),
       shelf_layout_manager_(NULL),
       last_active_panel_(NULL),
       weak_factory_(this) {
   DCHECK(panel_container);
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       AddObserver(this);
   Shell::GetInstance()->display_controller()->AddObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 PanelLayoutManager::~PanelLayoutManager() {
   Shutdown();
 }
 
 void PanelLayoutManager::Shutdown() {
   if (shelf_layout_manager_)
     shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = NULL;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     delete iter->callout_widget;
   }
   panel_windows_.clear();
-  if (launcher_)
-    launcher_->RemoveIconObserver(this);
-  launcher_ = NULL;
+  if (shelf_)
+    shelf_->RemoveIconObserver(this);
+  shelf_ = NULL;
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       RemoveObserver(this);
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
   Shell::GetInstance()->RemoveShellObserver(this);
 }
 
 void PanelLayoutManager::StartDragging(aura::Window* panel) {
   DCHECK(!dragged_panel_);
   dragged_panel_ = panel;
   Relayout();
 }
 
 void PanelLayoutManager::FinishDragging() {
   dragged_panel_ = NULL;
   Relayout();
 }
 
-void PanelLayoutManager::SetLauncher(ash::Launcher* launcher) {
-  DCHECK(!launcher_);
+void PanelLayoutManager::SetShelf(Shelf* shelf) {
+  DCHECK(!shelf_);
   DCHECK(!shelf_layout_manager_);
-  launcher_ = launcher;
-  launcher_->AddIconObserver(this);
-  if (launcher_->shelf_widget()) {
-    shelf_layout_manager_ = ash::internal::ShelfLayoutManager::ForLauncher(
-        launcher_->shelf_widget()->GetNativeWindow());
+  shelf_ = shelf;
+  shelf_->AddIconObserver(this);
+  if (shelf_->shelf_widget()) {
+    shelf_layout_manager_ = ash::internal::ShelfLayoutManager::ForShelf(
+        shelf_->shelf_widget()->GetNativeWindow());
     WillChangeVisibilityState(shelf_layout_manager_->visibility_state());
     shelf_layout_manager_->AddObserver(this);
   }
 }
 
 void PanelLayoutManager::ToggleMinimize(aura::Window* panel) {
   DCHECK(panel->parent() == panel_container_);
   wm::WindowState* window_state = wm::GetWindowState(panel);
   if (window_state->IsMinimized())
     window_state->Restore();
@@ skipping 225 matching lines @@
   views::corewm::SetWindowVisibilityAnimationType(
       panel, WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
   ui::Layer* layer = panel->layer();
   ui::ScopedLayerAnimationSettings panel_slide_settings(layer->GetAnimator());
   panel_slide_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   panel_slide_settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kPanelSlideDurationMilliseconds));
   gfx::Rect bounds(panel->bounds());
   bounds.Offset(GetSlideInAnimationOffset(
-      launcher_->shelf_widget()->GetAlignment()));
+      shelf_->shelf_widget()->GetAlignment()));
   SetChildBoundsDirect(panel, bounds);
   panel->Hide();
   PanelList::iterator found =
       std::find(panel_windows_.begin(), panel_windows_.end(), panel);
   if (found != panel_windows_.end()) {
     layer->SetOpacity(0);
     // The next time the window is visible it should slide into place.
     found->slide_in = true;
   }
   if (wm::IsActiveWindow(panel))
     wm::DeactivateWindow(panel);
   Relayout();
 }
 
 void PanelLayoutManager::RestorePanel(aura::Window* panel) {
   panel->Show();
   Relayout();
 }
 
 void PanelLayoutManager::Relayout() {
-  if (!launcher_ || !launcher_->shelf_widget())
+  if (!shelf_ || !shelf_->shelf_widget())
     return;
 
   if (in_layout_)
     return;
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
-  ShelfAlignment alignment = launcher_->shelf_widget()->GetAlignment();
+  ShelfAlignment alignment = shelf_->shelf_widget()->GetAlignment();
   bool horizontal = alignment == SHELF_ALIGNMENT_TOP ||
                     alignment == SHELF_ALIGNMENT_BOTTOM;
-  gfx::Rect launcher_bounds = ash::ScreenAsh::ConvertRectFromScreen(
-      panel_container_, launcher_->shelf_widget()->GetWindowBoundsInScreen());
+  gfx::Rect shelf_bounds = ash::ScreenAsh::ConvertRectFromScreen(
+      panel_container_, shelf_->shelf_widget()->GetWindowBoundsInScreen());
   int panel_start_bounds = kPanelIdealSpacing;
   int panel_end_bounds = horizontal ?
       panel_container_->bounds().width() - kPanelIdealSpacing :
       panel_container_->bounds().height() - kPanelIdealSpacing;
   aura::Window* active_panel = NULL;
   std::vector<VisiblePanelPositionInfo> visible_panels;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     aura::Window* panel = iter->window;
     iter->callout_widget->SetAlignment(alignment);
 
     // Consider the dragged panel as part of the layout as long as it is
-    // touching the launcher.
+    // touching the shelf.
     if (!panel->IsVisible() ||
         (panel == dragged_panel_ &&
-         !BoundsAdjacent(panel->bounds(), launcher_bounds))) {
+         !BoundsAdjacent(panel->bounds(), shelf_bounds))) {
       continue;
     }
 
     // If the shelf is currently hidden (full-screen mode), minimize panel until
     // full-screen mode is exited.
     if (restore_windows_on_shelf_visible_) {
       wm::GetWindowState(panel)->Minimize();
       restore_windows_on_shelf_visible_->Add(panel);
       continue;
     }
 
-    gfx::Rect icon_bounds =
-        launcher_->GetScreenBoundsOfItemIconForWindow(panel);
+    gfx::Rect icon_bounds = shelf_->GetScreenBoundsOfItemIconForWindow(panel);
 
     // If both the icon width and height are 0 then there is no icon in the
-    // launcher. If the launcher is hidden, one of the height or width will be
-    // 0 but the position in the launcher and major dimension is still reported
+    // shelf. If the shelf is hidden, one of the height or width will be
+    // 0 but the position in the shelf and major dimension is still reported
     // correctly and the panel can be aligned above where the hidden icon is.
     if (icon_bounds.width() == 0 && icon_bounds.height() == 0)
       continue;
 
     if (panel->HasFocus() ||
         panel->Contains(
             aura::client::GetFocusClient(panel)->GetFocusedWindow())) {
       DCHECK(!active_panel);
       active_panel = panel;
     }
@@ skipping 38 matching lines @@
   FanOutPanels(visible_panels.begin() + first_overlapping_panel,
                visible_panels.end());
 
   for (size_t i = 0; i < visible_panels.size(); ++i) {
     if (visible_panels[i].window == dragged_panel_)
       continue;
     bool slide_in = visible_panels[i].slide_in;
     gfx::Rect bounds = visible_panels[i].window->GetTargetBounds();
     switch (alignment) {
       case SHELF_ALIGNMENT_BOTTOM:
-        bounds.set_y(launcher_bounds.y() - bounds.height());
+        bounds.set_y(shelf_bounds.y() - bounds.height());
         break;
       case SHELF_ALIGNMENT_LEFT:
-        bounds.set_x(launcher_bounds.right());
+        bounds.set_x(shelf_bounds.right());
         break;
       case SHELF_ALIGNMENT_RIGHT:
-        bounds.set_x(launcher_bounds.x() - bounds.width());
+        bounds.set_x(shelf_bounds.x() - bounds.width());
         break;
       case SHELF_ALIGNMENT_TOP:
-        bounds.set_y(launcher_bounds.bottom());
+        bounds.set_y(shelf_bounds.bottom());
         break;
     }
-    bool on_launcher = visible_panels[i].window->GetTargetBounds() == bounds;
+    bool on_shelf = visible_panels[i].window->GetTargetBounds() == bounds;
 
     if (horizontal) {
       bounds.set_x(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     } else {
       bounds.set_y(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     }
 
     ui::Layer* layer = visible_panels[i].window->layer();
     if (slide_in) {
-      // New windows shift up from the launcher  into position.
+      // New windows shift up from the shelf into position.
       gfx::Rect initial_bounds(bounds);
       initial_bounds.Offset(GetSlideInAnimationOffset(alignment));
       SetChildBoundsDirect(visible_panels[i].window, initial_bounds);
-      // Set on launcher so that the panel animates into its target position.
-      on_launcher = true;
+      // Set on shelf so that the panel animates into its target position.
+      on_shelf = true;
     }
 
-    if (on_launcher) {
+    if (on_shelf) {
       ui::ScopedLayerAnimationSettings panel_slide_settings(
           layer->GetAnimator());
       panel_slide_settings.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       panel_slide_settings.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kPanelSlideDurationMilliseconds));
       SetChildBoundsDirect(visible_panels[i].window, bounds);
       if (slide_in)
         layer->SetOpacity(1);
     } else {
-      // If the launcher moved don't animate, move immediately to the new
+      // If the shelf moved don't animate, move immediately to the new
       // target location.
       SetChildBoundsDirect(visible_panels[i].window, bounds);
     }
   }
 
   UpdateStacking(active_panel);
   UpdateCallouts();
 }
 
 void PanelLayoutManager::UpdateStacking(aura::Window* active_panel) {
   if (!active_panel) {
     if (!last_active_panel_)
       return;
     active_panel = last_active_panel_;
   }
 
-  ShelfAlignment alignment = launcher_->alignment();
+  ShelfAlignment alignment = shelf_->alignment();
   bool horizontal = alignment == SHELF_ALIGNMENT_TOP ||
                     alignment == SHELF_ALIGNMENT_BOTTOM;
 
   // We want to to stack the panels like a deck of cards:
   // ,--,--,--,-------.--.--.
   // |  |  |  |       |  |  |
   // |  |  |  |       |  |  |
   //
   // We use the middle of each panel to figure out how to stack the panels. This
   // allows us to update the stacking when a panel is being dragged around by
-  // the titlebar--even though it doesn't update the launcher icon positions, we
+  // the titlebar--even though it doesn't update the shelf icon positions, we
   // still want the visual effect.
   std::map<int, aura::Window*> window_ordering;
   for (PanelList::const_iterator it = panel_windows_.begin();
        it != panel_windows_.end(); ++it) {
     gfx::Rect bounds = it->window->bounds();
     window_ordering.insert(std::make_pair(horizontal ?
                                               bounds.x() + bounds.width() / 2 :
                                               bounds.y() + bounds.height() / 2,
                                           it->window));
   }
@@ skipping 16 matching lines @@
     previous_panel = it->second;
   }
 
   panel_container_->StackChildAtTop(active_panel);
   if (dragged_panel_ && dragged_panel_->parent() == panel_container_)
     panel_container_->StackChildAtTop(dragged_panel_);
   last_active_panel_ = active_panel;
 }
 
 void PanelLayoutManager::UpdateCallouts() {
-  ShelfAlignment alignment = launcher_->alignment();
+  ShelfAlignment alignment = shelf_->alignment();
   bool horizontal = alignment == SHELF_ALIGNMENT_TOP ||
                     alignment == SHELF_ALIGNMENT_BOTTOM;
 
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     aura::Window* panel = iter->window;
     views::Widget* callout_widget = iter->callout_widget;
 
     gfx::Rect current_bounds = panel->GetBoundsInScreen();
     gfx::Rect bounds = ScreenAsh::ConvertRectToScreen(panel->parent(),
                                                       panel->GetTargetBounds());
-    gfx::Rect icon_bounds =
-        launcher_->GetScreenBoundsOfItemIconForWindow(panel);
+    gfx::Rect icon_bounds = shelf_->GetScreenBoundsOfItemIconForWindow(panel);
     if (icon_bounds.IsEmpty() || !panel->layer()->GetTargetVisibility() ||
         panel == dragged_panel_) {
       callout_widget->Hide();
       callout_widget->GetNativeWindow()->layer()->SetOpacity(0);
       continue;
     }
 
     gfx::Rect callout_bounds = callout_widget->GetWindowBoundsInScreen();
     gfx::Vector2d slide_vector = bounds.origin() - current_bounds.origin();
     int slide_distance = horizontal ? slide_vector.x() : slide_vector.y();
@@ skipping 71 matching lines @@
 
 void PanelLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propogate automatically to this class, so manually recalculate bounds.
   OnWindowResized();
 }
 
 }  // namespace internal
 }  // namespace ash