Adds the option of aligning the launcher to the left or right. There

ash/launcher/launcher.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.h"
 
 #include "ash/focus_cycler.h"
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_view.h"
@@ skipping 19 matching lines @@
 }
 
 // The contents view of the Widget. This view contains LauncherView and
 // sizes it to the width of the widget minus the size of the status area.
 class Launcher::DelegateView : public views::WidgetDelegate,
                                public views::AccessiblePaneView{
  public:
   explicit DelegateView(Launcher* launcher);
   virtual ~DelegateView();
 
-  void SetStatusWidth(int width);
-  int status_width() const { return status_width_; }
-
   void set_focus_cycler(internal::FocusCycler* focus_cycler) {
     focus_cycler_ = focus_cycler;
   }
   internal::FocusCycler* focus_cycler() {
     return focus_cycler_;
   }
 
   // views::View overrides
   virtual gfx::Size GetPreferredSize() OVERRIDE;
   virtual void Layout() OVERRIDE;
 
   // views::WidgetDelegateView overrides:
   virtual views::Widget* GetWidget() OVERRIDE {
     return View::GetWidget();
   }
   virtual const views::Widget* GetWidget() const OVERRIDE {
     return View::GetWidget();
   }
   virtual bool CanActivate() const OVERRIDE {
     // We don't want mouse clicks to activate us, but we need to allow
     // activation when the user is using the keyboard (FocusCycler).
     return focus_cycler_ && focus_cycler_->widget_activating() == GetWidget();
   }
 
  private:
   Launcher* launcher_;
-
-  // Width of the status area.
-  int status_width_;
-
   internal::FocusCycler* focus_cycler_;
 
   DISALLOW_COPY_AND_ASSIGN(DelegateView);
 };
 
 Launcher::DelegateView::DelegateView(Launcher* launcher)
     : launcher_(launcher),
-      status_width_(0),
       focus_cycler_(NULL) {
 }
 
 Launcher::DelegateView::~DelegateView() {
 }
 
-void Launcher::DelegateView::SetStatusWidth(int width) {
-  if (status_width_ == width)
-    return;
-
-  status_width_ = width;
-  Layout();
-}
-
 gfx::Size Launcher::DelegateView::GetPreferredSize() {
   return child_count() > 0 ? child_at(0)->GetPreferredSize() : gfx::Size();
 }
 
 void Launcher::DelegateView::Layout() {
   if (child_count() == 0)
     return;
-  child_at(0)->SetBounds(0, 0, std::max(0, width() - status_width_), height());
+  if (launcher_->alignment_ == SHELF_ALIGNMENT_BOTTOM) {
+    int w = std::max(0, width() - launcher_->status_size_.width());
+    child_at(0)->SetBounds(0, 0, w, height());
+  } else {
+    int h = std::max(0, height() - launcher_->status_size_.height());
+    child_at(0)->SetBounds(0, 0, width(), h);
+  }
 }
 
 // Launcher --------------------------------------------------------------------
 
 Launcher::Launcher(aura::Window* window_container)
     : widget_(NULL),
       window_container_(window_container),
       delegate_view_(NULL),
       launcher_view_(NULL),
+      alignment_(SHELF_ALIGNMENT_BOTTOM),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           background_animator_(this, 0, kBackgroundAlpha)) {
   model_.reset(new LauncherModel);
   if (Shell::GetInstance()->delegate()) {
     delegate_.reset(
         Shell::GetInstance()->delegate()->CreateLauncherDelegate(model_.get()));
   }
 
   widget_.reset(new views::Widget);
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   // The launcher only ever draws a solid color.
   params.layer_type = ui::LAYER_SOLID_COLOR;
   params.transparent = true;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = Shell::GetInstance()->GetContainer(
       ash::internal::kShellWindowId_LauncherContainer);
   launcher_view_ = new internal::LauncherView(model_.get(), delegate_.get());
   launcher_view_->Init();
   delegate_view_ = new DelegateView(this);
   delegate_view_->AddChildView(launcher_view_);
   params.delegate = delegate_view_;
   widget_->Init(params);
   widget_->GetNativeWindow()->SetName("LauncherWindow");
   gfx::Size pref =
       static_cast<views::View*>(launcher_view_)->GetPreferredSize();
-  widget_->SetBounds(gfx::Rect(0, 0, pref.width(), pref.height()));
+  widget_->SetBounds(gfx::Rect(pref));
   // The launcher should not take focus when it is initially shown.
   widget_->set_focus_on_creation(false);
   widget_->SetContentsView(delegate_view_);
   widget_->Show();
   widget_->GetNativeView()->SetName("LauncherView");
 }
 
 Launcher::~Launcher() {
 }
 
 void Launcher::SetFocusCycler(internal::FocusCycler* focus_cycler) {
   delegate_view_->set_focus_cycler(focus_cycler);
   focus_cycler->AddWidget(widget_.get());
 }
 
 internal::FocusCycler* Launcher::GetFocusCycler() {
   return delegate_view_->focus_cycler();
 }
 
+void Launcher::SetAlignment(ShelfAlignment alignment) {
+  alignment_ = alignment;
+  launcher_view_->SetAlignment(alignment);
+  // ShelfLayoutManager will resize the launcher.
+}
+
 void Launcher::SetPaintsBackground(
       bool value,
       internal::BackgroundAnimator::ChangeType change_type) {
   background_animator_.SetPaintsBackground(value, change_type);
 }
 
-void Launcher::SetStatusWidth(int width) {
-  delegate_view_->SetStatusWidth(width);
-}
+void Launcher::SetStatusSize(const gfx::Size& size) {
+  if (status_size_ == size)
+    return;
 
-int Launcher::GetStatusWidth() {
-  return delegate_view_->status_width();
+  status_size_ = size;
+  delegate_view_->Layout();
 }
 
 gfx::Rect Launcher::GetScreenBoundsOfItemIconForWindow(aura::Window* window) {
   if (!delegate_.get())
     return gfx::Rect();
 
   LauncherID id = delegate_->GetIDByWindow(window);
   gfx::Rect bounds(launcher_view_->GetIdealBoundsOfItemIcon(id));
   if (bounds.IsEmpty())
     return bounds;
@@ skipping 25 matching lines @@
 internal::LauncherView* Launcher::GetLauncherViewForTest() {
   return launcher_view_;
 }
 
 void Launcher::UpdateBackground(int alpha) {
   ui::Layer* layer = widget_->GetNativeView()->layer();
   layer->SetColor(SkColorSetARGB(alpha, 0, 0, 0));
 }
 
 }  // namespace ash