Rename Launcher to Shelf.

ash/shelf/shelf_widget.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_widget.h"
 
 #include "ash/ash_switches.h"
 #include "ash/focus_cycler.h"
 #include "ash/root_window_controller.h"
 #include "ash/session_state_delegate.h"
@@ skipping 20 matching lines @@
 #include "ui/events/event_constants.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/accessible_pane_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace {
-// Size of black border at bottom (or side) of launcher.
+// Size of black border at bottom (or side) of shelf.
 const int kNumBlackPixels = 3;
 // Alpha to paint dimming image with.
 const int kDimAlpha = 128;
 
 // The time to dim and un-dim.
 const int kTimeToDimMs = 3000;  // Slow in dimming.
 const int kTimeToUnDimMs = 200;  // Fast in activating.
 
 // Class used to slightly dim shelf items when maximized and visible.
 class DimmerView : public views::View,
@@ skipping 26 matching lines @@
     SchedulePaint();
   }
 
   // views::View overrides:
   virtual void OnPaintBackground(gfx::Canvas* canvas) OVERRIDE;
 
   // A function to test the current alpha used.
   int get_dimming_alpha_for_test() { return alpha_; }
 
  private:
-  // This class monitors mouse events to see if it is on top of the launcher.
+  // This class monitors mouse events to see if it is on top of the shelf.
   class DimmerEventFilter : public ui::EventHandler {
    public:
     explicit DimmerEventFilter(DimmerView* owner);
     virtual ~DimmerEventFilter();
 
     // Overridden from ui::EventHandler:
     virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
     virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
 
    private:
@@ skipping 68 matching lines @@
   bool previous = force_hovered_;
   force_hovered_ = force;
   // If the forced change does change the result we apply the change.
   if (is_hovered_ || force_hovered_ != is_hovered_ || previous)
     SetHovered(is_hovered_);
 }
 
 void DimmerView::OnPaintBackground(gfx::Canvas* canvas) {
   SkPaint paint;
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  gfx::ImageSkia launcher_background =
+  gfx::ImageSkia shelf_background =
       *rb.GetImageNamed(IDR_AURA_LAUNCHER_DIMMING).ToImageSkia();
 
   if (shelf_->GetAlignment() != ash::SHELF_ALIGNMENT_BOTTOM) {
-    launcher_background = gfx::ImageSkiaOperations::CreateRotatedImage(
-        launcher_background,
+    shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
+        shelf_background,
         shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
             SkBitmapOperations::ROTATION_90_CW,
             SkBitmapOperations::ROTATION_90_CW,
             SkBitmapOperations::ROTATION_270_CW,
             SkBitmapOperations::ROTATION_180_CW));
   }
   paint.setAlpha(alpha_);
-  canvas->DrawImageInt(
-      launcher_background,
-      0, 0, launcher_background.width(), launcher_background.height(),
-      0, 0, width(), height(),
-      false,
-      paint);
+  canvas->DrawImageInt(shelf_background,
+                       0,
+                       0,
+                       shelf_background.width(),
+                       shelf_background.height(),
+                       0,
+                       0,
+                       width(),
+                       height(),
+                       false,
+                       paint);
 }
 
 DimmerView::DimmerEventFilter::DimmerEventFilter(DimmerView* owner)
     : owner_(owner),
       mouse_inside_(false),
       touch_inside_(false) {
   ash::Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 DimmerView::DimmerEventFilter::~DimmerEventFilter() {
@@ skipping 139 matching lines @@
     views::Widget::InitParams params(
         views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
     params.can_activate = false;
     params.accept_events = false;
     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.parent = shelf_->GetNativeView();
     dimmer_->Init(params);
     dimmer_->GetNativeWindow()->SetName("ShelfDimmer");
     dimmer_->SetBounds(shelf_->GetWindowBoundsInScreen());
-    // The launcher should not take focus when it is initially shown.
+    // The shelf should not take focus when it is initially shown.
     dimmer_->set_focus_on_creation(false);
     dimmer_view_ = new DimmerView(shelf_, disable_dimming_animations_for_test_);
     dimmer_->SetContentsView(dimmer_view_);
     dimmer_->GetNativeView()->SetName("ShelfDimmerView");
     dimmer_->Show();
     shelf_->GetNativeView()->AddObserver(this);
   } else {
     // Some unit tests will come here with a destroyed window.
     if (shelf_->GetNativeView())
       shelf_->GetNativeView()->RemoveObserver(this);
     dimmer_view_ = NULL;
     dimmer_.reset(NULL);
   }
 }
 
 bool ShelfWidget::DelegateView::GetDimmed() const {
   return dimmer_.get() && dimmer_->IsVisible();
 }
 
 void ShelfWidget::DelegateView::SetParentLayer(ui::Layer* layer) {
   layer->Add(&opaque_background_);
   ReorderLayers();
 }
 
 void ShelfWidget::DelegateView::OnPaintBackground(gfx::Canvas* canvas) {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  gfx::ImageSkia launcher_background =
+  gfx::ImageSkia shelf_background =
       *rb.GetImageSkiaNamed(IDR_AURA_LAUNCHER_BACKGROUND);
   if (SHELF_ALIGNMENT_BOTTOM != shelf_->GetAlignment())
-    launcher_background = gfx::ImageSkiaOperations::CreateRotatedImage(
-        launcher_background,
+    shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
+        shelf_background,
         shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
             SkBitmapOperations::ROTATION_90_CW,
             SkBitmapOperations::ROTATION_90_CW,
             SkBitmapOperations::ROTATION_270_CW,
             SkBitmapOperations::ROTATION_180_CW));
   const gfx::Rect dock_bounds(shelf_->shelf_layout_manager()->dock_bounds());
   SkPaint paint;
   paint.setAlpha(alpha_);
-  canvas->DrawImageInt(
-      launcher_background,
-      0, 0, launcher_background.width(), launcher_background.height(),
-      (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
-       dock_bounds.x() == 0 && dock_bounds.width() > 0) ?
-           dock_bounds.width() : 0, 0,
-      SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() ?
-          width() - dock_bounds.width() : width(), height(),
-      false,
-      paint);
+  canvas->DrawImageInt(shelf_background,
+                       0,
+                       0,
+                       shelf_background.width(),
+                       shelf_background.height(),
+                       (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
+                        dock_bounds.x() == 0 && dock_bounds.width() > 0)
+                           ? dock_bounds.width()
+                           : 0,
+                       0,
+                       SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment()
+                           ? width() - dock_bounds.width()
+                           : width(),
+                       height(),
+                       false,
+                       paint);
   if (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
       dock_bounds.width() > 0) {
     // The part of the shelf background that is in the corner below the docked
     // windows close to the work area is an arched gradient that blends
     // vertically oriented docked background and horizontal shelf.
-    gfx::ImageSkia launcher_corner =
+    gfx::ImageSkia shelf_corner =
         *rb.GetImageSkiaNamed(IDR_AURA_LAUNCHER_CORNER);
     if (dock_bounds.x() == 0) {
-      launcher_corner = gfx::ImageSkiaOperations::CreateRotatedImage(
-          launcher_corner, SkBitmapOperations::ROTATION_90_CW);
+      shelf_corner = gfx::ImageSkiaOperations::CreateRotatedImage(
+          shelf_corner, SkBitmapOperations::ROTATION_90_CW);
     }
     canvas->DrawImageInt(
-        launcher_corner,
-        0, 0, launcher_corner.width(), launcher_corner.height(),
+        shelf_corner,
+        0,
+        0,
+        shelf_corner.width(),
+        shelf_corner.height(),
         dock_bounds.x() > 0 ? dock_bounds.x() : dock_bounds.width() - height(),
         0,
-        height(), height(),
+        height(),
+        height(),
         false,
         paint);
     // The part of the shelf background that is just below the docked windows
     // is drawn using the last (lowest) 1-pixel tall strip of the image asset.
     // This avoids showing the border 3D shadow between the shelf and the dock.
-    canvas->DrawImageInt(
-        launcher_background,
-        0, launcher_background.height() - 1, launcher_background.width(), 1,
-        dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0, 0,
-        dock_bounds.width() - height(), height(),
-        false,
-        paint);
+    canvas->DrawImageInt(shelf_background,
+                         0,
+                         shelf_background.height() - 1,
+                         shelf_background.width(),
+                         1,
+                         dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0,
+                         0,
+                         dock_bounds.width() - height(),
+                         height(),
+                         false,
+                         paint);
   }
   gfx::Rect black_rect =
       shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
           gfx::Rect(0, height() - kNumBlackPixels, width(), kNumBlackPixels),
           gfx::Rect(0, 0, kNumBlackPixels, height()),
           gfx::Rect(width() - kNumBlackPixels, 0, kNumBlackPixels, height()),
           gfx::Rect(0, 0, width(), kNumBlackPixels));
   canvas->FillRect(black_rect, SK_ColorBLACK);
 }
 
@@ skipping 163 matching lines @@
 
   DCHECK(false);
   return false;
 }
 
 ShelfAlignment ShelfWidget::GetAlignment() const {
   return shelf_layout_manager_->GetAlignment();
 }
 
 void ShelfWidget::SetAlignment(ShelfAlignment alignment) {
-  if (launcher_)
-    launcher_->SetAlignment(alignment);
+  if (shelf_)
+    shelf_->SetAlignment(alignment);
   status_area_widget_->SetShelfAlignment(alignment);
   delegate_view_->SchedulePaint();
 }
 
 void ShelfWidget::SetDimsShelf(bool dimming) {
   delegate_view_->SetDimmed(dimming);
   // Repaint all children, allowing updates to reflect dimmed state eg:
   // status area background, app list button and overflow button.
-  if (launcher_)
-    launcher_->SchedulePaint();
+  if (shelf_)
+    shelf_->SchedulePaint();
   status_area_widget_->GetContentsView()->SchedulePaint();
 }
 
 bool ShelfWidget::GetDimsShelf() const {
   return delegate_view_->GetDimmed();
 }
 
-void ShelfWidget::CreateLauncher() {
-  if (launcher_)
+void ShelfWidget::CreateShelf() {
+  if (shelf_)
     return;
 
   Shell* shell = Shell::GetInstance();
   // This needs to be called before shelf_model().
   ShelfDelegate* shelf_delegate = shell->GetShelfDelegate();
   if (!shelf_delegate)
-    return;  // Not ready to create Launcher
+    return;  // Not ready to create Shelf.
 
-  launcher_.reset(new Launcher(shell->shelf_model(),
-                               shell->GetShelfDelegate(),
-                               this));
+  shelf_.reset(
+      new Shelf(shell->shelf_model(), shell->GetShelfDelegate(), this));
   SetFocusCycler(shell->focus_cycler());
 
   // Inform the root window controller.
-  internal::RootWindowController::ForWindow(window_container_)->
-      OnLauncherCreated();
+  internal::RootWindowController::ForWindow(window_container_)
+      ->OnShelfCreated();
 
-  launcher_->SetVisible(
+  shelf_->SetVisible(
       shell->session_state_delegate()->IsActiveUserSessionStarted());
   shelf_layout_manager_->LayoutShelf();
   Show();
 }
 
-bool ShelfWidget::IsLauncherVisible() const {
-  return launcher_.get() && launcher_->IsVisible();
+bool ShelfWidget::IsShelfVisible() const {
+  return shelf_.get() && shelf_->IsVisible();
 }
 
-void ShelfWidget::SetLauncherVisibility(bool visible) {
-  if (launcher_)
-    launcher_->SetVisible(visible);
+void ShelfWidget::SetShelfVisibility(bool visible) {
+  if (shelf_)
+    shelf_->SetVisible(visible);
 }
 
 void ShelfWidget::SetFocusCycler(internal::FocusCycler* focus_cycler) {
   delegate_view_->set_focus_cycler(focus_cycler);
   if (focus_cycler)
     focus_cycler->AddWidget(this);
 }
 
 internal::FocusCycler* ShelfWidget::GetFocusCycler() {
   return delegate_view_->focus_cycler();
@@ skipping 34 matching lines @@
   DCHECK(delegate_view_);
   return delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::WillDeleteShelf() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = NULL;
 }
 
 }  // namespace ash