ash/shelf/shelf_widget.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/shelf/shelf_widget.h"
   6
   7 #include "ash/ash_switches.h"
   8 #include "ash/focus_cycler.h"
   9 #include "ash/root_window_controller.h"
  10 #include "ash/session/session_state_delegate.h"
  11 #include "ash/shelf/shelf_constants.h"
  12 #include "ash/shelf/shelf_delegate.h"
  13 #include "ash/shelf/shelf_layout_manager.h"
  14 #include "ash/shelf/shelf_model.h"
  15 #include "ash/shelf/shelf_navigator.h"
  16 #include "ash/shelf/shelf_view.h"
  17 #include "ash/shelf/shelf_widget.h"
  18 #include "ash/shell.h"
  19 #include "ash/shell_window_ids.h"
  20 #include "ash/system/tray/system_tray_delegate.h"
  21 #include "ash/wm/status_area_layout_manager.h"
  22 #include "ash/wm/window_properties.h"
  23 #include "ash/wm/workspace_controller.h"
  24 #include "grit/ash_resources.h"
  25 #include "ui/aura/window.h"
  26 #include "ui/aura/window_event_dispatcher.h"
  27 #include "ui/aura/window_observer.h"
  28 #include "ui/base/resource/resource_bundle.h"
  29 #include "ui/compositor/layer.h"
  30 #include "ui/compositor/scoped_layer_animation_settings.h"
  31 #include "ui/events/event_constants.h"
  32 #include "ui/gfx/canvas.h"
  33 #include "ui/gfx/image/image.h"
  34 #include "ui/gfx/image/image_skia_operations.h"
  35 #include "ui/gfx/skbitmap_operations.h"
  36 #include "ui/views/accessible_pane_view.h"
  37 #include "ui/views/widget/widget.h"
  38 #include "ui/views/widget/widget_delegate.h"
  39 #include "ui/wm/core/easy_resize_window_targeter.h"
  40 #include "ui/wm/public/activation_client.h"
  41
  42 namespace {
  43 // Size of black border at bottom (or side) of shelf.
  44 const int kNumBlackPixels = 3;
  45 // Alpha to paint dimming image with.
  46 const int kDimAlpha = 128;
  47
  48 // The time to dim and un-dim.
  49 const int kTimeToDimMs = 3000;  // Slow in dimming.
  50 const int kTimeToUnDimMs = 200;  // Fast in activating.
  51
  52 // Class used to slightly dim shelf items when maximized and visible.
  53 class DimmerView : public views::View,
  54                    public views::WidgetDelegate,
  55                    ash::BackgroundAnimatorDelegate {
  56  public:
  57   // If |disable_dimming_animations_for_test| is set, all alpha animations will
  58   // be performed instantly.
  59   DimmerView(ash::ShelfWidget* shelf_widget,
  60              bool disable_dimming_animations_for_test);
  61   virtual ~DimmerView();
  62
  63   // Called by |DimmerEventFilter| when the mouse |hovered| state changes.
  64   void SetHovered(bool hovered);
  65
  66   // Force the dimmer to be undimmed.
  67   void ForceUndimming(bool force);
  68
  69   // views::WidgetDelegate overrides:
  70   virtual views::Widget* GetWidget() override {
  71     return View::GetWidget();
  72   }
  73   virtual const views::Widget* GetWidget() const override {
  74     return View::GetWidget();
  75   }
  76
  77   // ash::BackgroundAnimatorDelegate overrides:
  78   virtual void UpdateBackground(int alpha) override {
  79     alpha_ = alpha;
  80     SchedulePaint();
  81   }
  82
  83   // views::View overrides:
  84   virtual void OnPaintBackground(gfx::Canvas* canvas) override;
  85
  86   // A function to test the current alpha used.
  87   int get_dimming_alpha_for_test() { return alpha_; }
  88
  89  private:
  90   // This class monitors mouse events to see if it is on top of the shelf.
  91   class DimmerEventFilter : public ui::EventHandler {
  92    public:
  93     explicit DimmerEventFilter(DimmerView* owner);
  94     virtual ~DimmerEventFilter();
  95
  96     // Overridden from ui::EventHandler:
  97     virtual void OnMouseEvent(ui::MouseEvent* event) override;
  98     virtual void OnTouchEvent(ui::TouchEvent* event) override;
  99
 100    private:
 101     // The owning class.
 102     DimmerView* owner_;
 103
 104     // TRUE if the mouse is inside the shelf.
 105     bool mouse_inside_;
 106
 107     // TRUE if a touch event is inside the shelf.
 108     bool touch_inside_;
 109
 110     DISALLOW_COPY_AND_ASSIGN(DimmerEventFilter);
 111   };
 112
 113   // The owning shelf.
 114   ash::ShelfWidget* shelf_;
 115
 116   // The alpha to use for covering the shelf.
 117   int alpha_;
 118
 119   // True if the event filter claims that we should not be dimmed.
 120   bool is_hovered_;
 121
 122   // True if someone forces us not to be dimmed (e.g. a menu is open).
 123   bool force_hovered_;
 124
 125   // True if animations should be suppressed for a test.
 126   bool disable_dimming_animations_for_test_;
 127
 128   // The animator for the background transitions.
 129   ash::BackgroundAnimator background_animator_;
 130
 131   // Notification of entering / exiting of the shelf area by mouse.
 132   scoped_ptr<DimmerEventFilter> event_filter_;
 133
 134   DISALLOW_COPY_AND_ASSIGN(DimmerView);
 135 };
 136
 137 DimmerView::DimmerView(ash::ShelfWidget* shelf_widget,
 138                        bool disable_dimming_animations_for_test)
 139     : shelf_(shelf_widget),
 140       alpha_(kDimAlpha),
 141       is_hovered_(false),
 142       force_hovered_(false),
 143       disable_dimming_animations_for_test_(disable_dimming_animations_for_test),
 144       background_animator_(this, 0, kDimAlpha) {
 145   event_filter_.reset(new DimmerEventFilter(this));
 146   // Make sure it is undimmed at the beginning and then fire off the dimming
 147   // animation.
 148   background_animator_.SetPaintsBackground(false,
 149                                            ash::BACKGROUND_CHANGE_IMMEDIATE);
 150   SetHovered(false);
 151 }
 152
 153 DimmerView::~DimmerView() {
 154 }
 155
 156 void DimmerView::SetHovered(bool hovered) {
 157   // Remember the hovered state so that we can correct the state once a
 158   // possible force state has disappeared.
 159   is_hovered_ = hovered;
 160   // Undimm also if we were forced to by e.g. an open menu.
 161   hovered |= force_hovered_;
 162   background_animator_.SetDuration(hovered ? kTimeToUnDimMs : kTimeToDimMs);
 163   background_animator_.SetPaintsBackground(!hovered,
 164       disable_dimming_animations_for_test_ ?
 165           ash::BACKGROUND_CHANGE_IMMEDIATE : ash::BACKGROUND_CHANGE_ANIMATE);
 166 }
 167
 168 void DimmerView::ForceUndimming(bool force) {
 169   bool previous = force_hovered_;
 170   force_hovered_ = force;
 171   // If the forced change does change the result we apply the change.
 172   if (is_hovered_ || force_hovered_ != is_hovered_ || previous)
 173     SetHovered(is_hovered_);
 174 }
 175
 176 void DimmerView::OnPaintBackground(gfx::Canvas* canvas) {
 177   SkPaint paint;
 178   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 179   gfx::ImageSkia shelf_background =
 180       *rb.GetImageNamed(IDR_ASH_SHELF_DIMMING).ToImageSkia();
 181
 182   if (shelf_->GetAlignment() != ash::SHELF_ALIGNMENT_BOTTOM) {
 183     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
 184         shelf_background,
 185         shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
 186             SkBitmapOperations::ROTATION_90_CW,
 187             SkBitmapOperations::ROTATION_90_CW,
 188             SkBitmapOperations::ROTATION_270_CW,
 189             SkBitmapOperations::ROTATION_180_CW));
 190   }
 191   paint.setAlpha(alpha_);
 192   canvas->DrawImageInt(shelf_background,
 193                        0,
 194                        0,
 195                        shelf_background.width(),
 196                        shelf_background.height(),
 197                        0,
 198                        0,
 199                        width(),
 200                        height(),
 201                        false,
 202                        paint);
 203 }
 204
 205 DimmerView::DimmerEventFilter::DimmerEventFilter(DimmerView* owner)
 206     : owner_(owner),
 207       mouse_inside_(false),
 208       touch_inside_(false) {
 209   ash::Shell::GetInstance()->AddPreTargetHandler(this);
 210 }
 211
 212 DimmerView::DimmerEventFilter::~DimmerEventFilter() {
 213   ash::Shell::GetInstance()->RemovePreTargetHandler(this);
 214 }
 215
 216 void DimmerView::DimmerEventFilter::OnMouseEvent(ui::MouseEvent* event) {
 217   if (event->type() != ui::ET_MOUSE_MOVED &&
 218       event->type() != ui::ET_MOUSE_DRAGGED)
 219     return;
 220   bool inside = owner_->GetBoundsInScreen().Contains(event->root_location());
 221   if (mouse_inside_ || touch_inside_ != inside || touch_inside_)
 222     owner_->SetHovered(inside || touch_inside_);
 223   mouse_inside_ = inside;
 224 }
 225
 226 void DimmerView::DimmerEventFilter::OnTouchEvent(ui::TouchEvent* event) {
 227   bool touch_inside = false;
 228   if (event->type() != ui::ET_TOUCH_RELEASED &&
 229       event->type() != ui::ET_TOUCH_CANCELLED)
 230     touch_inside = owner_->GetBoundsInScreen().Contains(event->root_location());
 231
 232   if (mouse_inside_ || touch_inside_ != mouse_inside_ || touch_inside)
 233     owner_->SetHovered(mouse_inside_ || touch_inside);
 234   touch_inside_ = touch_inside;
 235 }
 236
 237 using ash::ShelfLayoutManager;
 238
 239 // ShelfWindowTargeter makes it easier to resize windows with the mouse when the
 240 // window-edge slightly overlaps with the shelf edge. The targeter also makes it
 241 // easier to drag the shelf out with touch while it is hidden.
 242 class ShelfWindowTargeter : public wm::EasyResizeWindowTargeter,
 243                             public ash::ShelfLayoutManagerObserver {
 244  public:
 245   ShelfWindowTargeter(aura::Window* container,
 246                       ShelfLayoutManager* shelf)
 247       : wm::EasyResizeWindowTargeter(container, gfx::Insets(), gfx::Insets()),
 248         shelf_(shelf) {
 249     WillChangeVisibilityState(shelf_->visibility_state());
 250     shelf_->AddObserver(this);
 251   }
 252
 253   virtual ~ShelfWindowTargeter() {
 254     // |shelf_| may have been destroyed by this time.
 255     if (shelf_)
 256       shelf_->RemoveObserver(this);
 257   }
 258
 259  private:
 260   gfx::Insets GetInsetsForAlignment(int distance,
 261                                     ash::ShelfAlignment alignment) {
 262     switch (alignment) {
 263       case ash::SHELF_ALIGNMENT_BOTTOM:
 264         return gfx::Insets(distance, 0, 0, 0);
 265       case ash::SHELF_ALIGNMENT_LEFT:
 266         return gfx::Insets(0, 0, 0, distance);
 267       case ash::SHELF_ALIGNMENT_RIGHT:
 268         return gfx::Insets(0, distance, 0, 0);
 269       case ash::SHELF_ALIGNMENT_TOP:
 270         return gfx::Insets(0, 0, distance, 0);
 271     }
 272     NOTREACHED();
 273     return gfx::Insets();
 274   }
 275
 276   // ash::ShelfLayoutManagerObserver:
 277   virtual void WillDeleteShelf() override {
 278     shelf_ = NULL;
 279   }
 280
 281   virtual void WillChangeVisibilityState(
 282       ash::ShelfVisibilityState new_state) override {
 283     gfx::Insets mouse_insets;
 284     gfx::Insets touch_insets;
 285     if (new_state == ash::SHELF_VISIBLE) {
 286       // Let clicks at the very top of the shelf through so windows can be
 287       // resized with the bottom-right corner and bottom edge.
 288       mouse_insets = GetInsetsForAlignment(
 289           ShelfLayoutManager::kWorkspaceAreaVisibleInset,
 290           shelf_->GetAlignment());
 291     } else if (new_state == ash::SHELF_AUTO_HIDE) {
 292       // Extend the touch hit target out a bit to allow users to drag shelf out
 293       // while hidden.
 294       touch_insets = GetInsetsForAlignment(
 295           -ShelfLayoutManager::kWorkspaceAreaAutoHideInset,
 296           shelf_->GetAlignment());
 297     }
 298
 299     set_mouse_extend(mouse_insets);
 300     set_touch_extend(touch_insets);
 301   }
 302
 303   ShelfLayoutManager* shelf_;
 304
 305   DISALLOW_COPY_AND_ASSIGN(ShelfWindowTargeter);
 306 };
 307
 308 }  // namespace
 309
 310 namespace ash {
 311
 312 // The contents view of the Shelf. This view contains ShelfView and
 313 // sizes it to the width of the shelf minus the size of the status area.
 314 class ShelfWidget::DelegateView : public views::WidgetDelegate,
 315                                   public views::AccessiblePaneView,
 316                                   public BackgroundAnimatorDelegate,
 317                                   public aura::WindowObserver {
 318  public:
 319   explicit DelegateView(ShelfWidget* shelf);
 320   virtual ~DelegateView();
 321
 322   void set_focus_cycler(FocusCycler* focus_cycler) {
 323     focus_cycler_ = focus_cycler;
 324   }
 325   FocusCycler* focus_cycler() { return focus_cycler_; }
 326
 327   ui::Layer* opaque_background() { return &opaque_background_; }
 328   ui::Layer* opaque_foreground() { return &opaque_foreground_; }
 329
 330   // Set if the shelf area is dimmed (eg when a window is maximized).
 331   void SetDimmed(bool dimmed);
 332   bool GetDimmed() const;
 333
 334   void SetParentLayer(ui::Layer* layer);
 335
 336   // views::View overrides:
 337   virtual void OnPaintBackground(gfx::Canvas* canvas) override;
 338
 339   // views::WidgetDelegateView overrides:
 340   virtual views::Widget* GetWidget() override {
 341     return View::GetWidget();
 342   }
 343   virtual const views::Widget* GetWidget() const override {
 344     return View::GetWidget();
 345   }
 346
 347   virtual bool CanActivate() const override;
 348   virtual void Layout() override;
 349   virtual void ReorderChildLayers(ui::Layer* parent_layer) override;
 350   // This will be called when the parent local bounds change.
 351   virtual void OnBoundsChanged(const gfx::Rect& old_bounds) override;
 352
 353   // aura::WindowObserver overrides:
 354   // This will be called when the shelf itself changes its absolute position.
 355   // Since the |dimmer_| panel needs to be placed in screen coordinates it needs
 356   // to be repositioned. The difference to the OnBoundsChanged call above is
 357   // that this gets also triggered when the shelf only moves.
 358   virtual void OnWindowBoundsChanged(aura::Window* window,
 359                                      const gfx::Rect& old_bounds,
 360                                      const gfx::Rect& new_bounds) override;
 361
 362   // BackgroundAnimatorDelegate overrides:
 363   virtual void UpdateBackground(int alpha) override;
 364
 365   // Force the shelf to be presented in an undimmed state.
 366   void ForceUndimming(bool force);
 367
 368   // A function to test the current alpha used by the dimming bar. If there is
 369   // no dimmer active, the function will return -1.
 370   int GetDimmingAlphaForTest();
 371
 372   // A function to test the bounds of the dimming bar. Returns gfx::Rect() if
 373   // the dimmer is inactive.
 374   gfx::Rect GetDimmerBoundsForTest();
 375
 376   // Disable dimming animations for running tests. This needs to be called
 377   // prior to the creation of of the |dimmer_|.
 378   void disable_dimming_animations_for_test() {
 379     disable_dimming_animations_for_test_ = true;
 380   }
 381
 382  private:
 383   ShelfWidget* shelf_;
 384   scoped_ptr<views::Widget> dimmer_;
 385   FocusCycler* focus_cycler_;
 386   int alpha_;
 387   // A black background layer which is shown when a maximized window is visible.
 388   ui::Layer opaque_background_;
 389   // A black foreground layer which is shown while transitioning between users.
 390   // Note: Since the back- and foreground layers have different functions they
 391   // can be used simultaneously - so no repurposing possible.
 392   ui::Layer opaque_foreground_;
 393
 394   // The view which does the dimming.
 395   DimmerView* dimmer_view_;
 396
 397   // True if dimming animations should be turned off.
 398   bool disable_dimming_animations_for_test_;
 399
 400   DISALLOW_COPY_AND_ASSIGN(DelegateView);
 401 };
 402
 403 ShelfWidget::DelegateView::DelegateView(ShelfWidget* shelf)
 404     : shelf_(shelf),
 405       focus_cycler_(NULL),
 406       alpha_(0),
 407       opaque_background_(ui::LAYER_SOLID_COLOR),
 408       opaque_foreground_(ui::LAYER_SOLID_COLOR),
 409       dimmer_view_(NULL),
 410       disable_dimming_animations_for_test_(false) {
 411   set_allow_deactivate_on_esc(true);
 412   opaque_background_.SetColor(SK_ColorBLACK);
 413   opaque_background_.SetBounds(GetLocalBounds());
 414   opaque_background_.SetOpacity(0.0f);
 415   opaque_foreground_.SetColor(SK_ColorBLACK);
 416   opaque_foreground_.SetBounds(GetLocalBounds());
 417   opaque_foreground_.SetOpacity(0.0f);
 418 }
 419
 420 ShelfWidget::DelegateView::~DelegateView() {
 421   // Make sure that the dimmer goes away since it might have set an observer.
 422   SetDimmed(false);
 423 }
 424
 425 void ShelfWidget::DelegateView::SetDimmed(bool value) {
 426   if (value == (dimmer_.get() != NULL))
 427     return;
 428
 429   if (value) {
 430     dimmer_.reset(new views::Widget);
 431     views::Widget::InitParams params(
 432         views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 433     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
 434     params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
 435     params.accept_events = false;
 436     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 437     params.parent = shelf_->GetNativeView();
 438     dimmer_->Init(params);
 439     dimmer_->GetNativeWindow()->SetName("ShelfDimmer");
 440     dimmer_->SetBounds(shelf_->GetWindowBoundsInScreen());
 441     // The shelf should not take focus when it is initially shown.
 442     dimmer_->set_focus_on_creation(false);
 443     dimmer_view_ = new DimmerView(shelf_, disable_dimming_animations_for_test_);
 444     dimmer_->SetContentsView(dimmer_view_);
 445     dimmer_->GetNativeView()->SetName("ShelfDimmerView");
 446     dimmer_->Show();
 447     shelf_->GetNativeView()->AddObserver(this);
 448   } else {
 449     // Some unit tests will come here with a destroyed window.
 450     if (shelf_->GetNativeView())
 451       shelf_->GetNativeView()->RemoveObserver(this);
 452     dimmer_view_ = NULL;
 453     dimmer_.reset(NULL);
 454   }
 455 }
 456
 457 bool ShelfWidget::DelegateView::GetDimmed() const {
 458   return dimmer_.get() && dimmer_->IsVisible();
 459 }
 460
 461 void ShelfWidget::DelegateView::SetParentLayer(ui::Layer* layer) {
 462   layer->Add(&opaque_background_);
 463   layer->Add(&opaque_foreground_);
 464   ReorderLayers();
 465 }
 466
 467 void ShelfWidget::DelegateView::OnPaintBackground(gfx::Canvas* canvas) {
 468   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 469   gfx::ImageSkia shelf_background =
 470       *rb.GetImageSkiaNamed(IDR_ASH_SHELF_BACKGROUND);
 471   if (SHELF_ALIGNMENT_BOTTOM != shelf_->GetAlignment())
 472     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
 473         shelf_background,
 474         shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
 475             SkBitmapOperations::ROTATION_90_CW,
 476             SkBitmapOperations::ROTATION_90_CW,
 477             SkBitmapOperations::ROTATION_270_CW,
 478             SkBitmapOperations::ROTATION_180_CW));
 479   const gfx::Rect dock_bounds(shelf_->shelf_layout_manager()->dock_bounds());
 480   SkPaint paint;
 481   paint.setAlpha(alpha_);
 482   canvas->DrawImageInt(shelf_background,
 483                        0,
 484                        0,
 485                        shelf_background.width(),
 486                        shelf_background.height(),
 487                        (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
 488                         dock_bounds.x() == 0 && dock_bounds.width() > 0)
 489                            ? dock_bounds.width()
 490                            : 0,
 491                        0,
 492                        SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment()
 493                            ? width() - dock_bounds.width()
 494                            : width(),
 495                        height(),
 496                        false,
 497                        paint);
 498   if (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
 499       dock_bounds.width() > 0) {
 500     // The part of the shelf background that is in the corner below the docked
 501     // windows close to the work area is an arched gradient that blends
 502     // vertically oriented docked background and horizontal shelf.
 503     gfx::ImageSkia shelf_corner = *rb.GetImageSkiaNamed(IDR_ASH_SHELF_CORNER);
 504     if (dock_bounds.x() == 0) {
 505       shelf_corner = gfx::ImageSkiaOperations::CreateRotatedImage(
 506           shelf_corner, SkBitmapOperations::ROTATION_90_CW);
 507     }
 508     canvas->DrawImageInt(
 509         shelf_corner,
 510         0,
 511         0,
 512         shelf_corner.width(),
 513         shelf_corner.height(),
 514         dock_bounds.x() > 0 ? dock_bounds.x() : dock_bounds.width() - height(),
 515         0,
 516         height(),
 517         height(),
 518         false,
 519         paint);
 520     // The part of the shelf background that is just below the docked windows
 521     // is drawn using the last (lowest) 1-pixel tall strip of the image asset.
 522     // This avoids showing the border 3D shadow between the shelf and the dock.
 523     canvas->DrawImageInt(shelf_background,
 524                          0,
 525                          shelf_background.height() - 1,
 526                          shelf_background.width(),
 527                          1,
 528                          dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0,
 529                          0,
 530                          dock_bounds.width() - height(),
 531                          height(),
 532                          false,
 533                          paint);
 534   }
 535   gfx::Rect black_rect =
 536       shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
 537           gfx::Rect(0, height() - kNumBlackPixels, width(), kNumBlackPixels),
 538           gfx::Rect(0, 0, kNumBlackPixels, height()),
 539           gfx::Rect(width() - kNumBlackPixels, 0, kNumBlackPixels, height()),
 540           gfx::Rect(0, 0, width(), kNumBlackPixels));
 541   canvas->FillRect(black_rect, SK_ColorBLACK);
 542 }
 543
 544 bool ShelfWidget::DelegateView::CanActivate() const {
 545   // Allow to activate as fallback.
 546   if (shelf_->activating_as_fallback_)
 547     return true;
 548   // Allow to activate from the focus cycler.
 549   if (focus_cycler_ && focus_cycler_->widget_activating() == GetWidget())
 550     return true;
 551   // Disallow activating in other cases, especially when using mouse.
 552   return false;
 553 }
 554
 555 void ShelfWidget::DelegateView::Layout() {
 556   for(int i = 0; i < child_count(); ++i) {
 557     if (shelf_->shelf_layout_manager()->IsHorizontalAlignment()) {
 558       child_at(i)->SetBounds(child_at(i)->x(), child_at(i)->y(),
 559                              child_at(i)->width(), height());
 560     } else {
 561       child_at(i)->SetBounds(child_at(i)->x(), child_at(i)->y(),
 562                              width(), child_at(i)->height());
 563     }
 564   }
 565 }
 566
 567 void ShelfWidget::DelegateView::ReorderChildLayers(ui::Layer* parent_layer) {
 568   views::View::ReorderChildLayers(parent_layer);
 569   parent_layer->StackAtBottom(&opaque_background_);
 570   parent_layer->StackAtTop(&opaque_foreground_);
 571 }
 572
 573 void ShelfWidget::DelegateView::OnBoundsChanged(const gfx::Rect& old_bounds) {
 574   opaque_background_.SetBounds(GetLocalBounds());
 575   opaque_foreground_.SetBounds(GetLocalBounds());
 576   if (dimmer_)
 577     dimmer_->SetBounds(GetBoundsInScreen());
 578 }
 579
 580 void ShelfWidget::DelegateView::OnWindowBoundsChanged(
 581     aura::Window* window,
 582     const gfx::Rect& old_bounds,
 583     const gfx::Rect& new_bounds) {
 584   // Coming here the shelf got repositioned and since the |dimmer_| is placed
 585   // in screen coordinates and not relative to the parent it needs to be
 586   // repositioned accordingly.
 587   dimmer_->SetBounds(GetBoundsInScreen());
 588 }
 589
 590 void ShelfWidget::DelegateView::ForceUndimming(bool force) {
 591   if (GetDimmed())
 592     dimmer_view_->ForceUndimming(force);
 593 }
 594
 595 int ShelfWidget::DelegateView::GetDimmingAlphaForTest() {
 596   if (GetDimmed())
 597     return dimmer_view_->get_dimming_alpha_for_test();
 598   return -1;
 599 }
 600
 601 gfx::Rect ShelfWidget::DelegateView::GetDimmerBoundsForTest() {
 602   if (GetDimmed())
 603     return dimmer_view_->GetBoundsInScreen();
 604   return gfx::Rect();
 605 }
 606
 607 void ShelfWidget::DelegateView::UpdateBackground(int alpha) {
 608   alpha_ = alpha;
 609   SchedulePaint();
 610 }
 611
 612 ShelfWidget::ShelfWidget(aura::Window* shelf_container,
 613                          aura::Window* status_container,
 614                          WorkspaceController* workspace_controller)
 615     : delegate_view_(new DelegateView(this)),
 616       background_animator_(delegate_view_, 0, kShelfBackgroundAlpha),
 617       activating_as_fallback_(false),
 618       window_container_(shelf_container) {
 619   views::Widget::InitParams params(
 620       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
 621   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
 622   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 623   params.parent = shelf_container;
 624   params.delegate = delegate_view_;
 625   Init(params);
 626
 627   // The shelf should not take focus when initially shown.
 628   set_focus_on_creation(false);
 629   SetContentsView(delegate_view_);
 630   delegate_view_->SetParentLayer(GetLayer());
 631
 632   status_area_widget_ = new StatusAreaWidget(status_container);
 633   status_area_widget_->CreateTrayViews();
 634   if (Shell::GetInstance()->session_state_delegate()->
 635           IsActiveUserSessionStarted()) {
 636     status_area_widget_->Show();
 637   }
 638   Shell::GetInstance()->focus_cycler()->AddWidget(status_area_widget_);
 639
 640   shelf_layout_manager_ = new ShelfLayoutManager(this);
 641   shelf_layout_manager_->AddObserver(this);
 642   shelf_container->SetLayoutManager(shelf_layout_manager_);
 643   shelf_layout_manager_->set_workspace_controller(workspace_controller);
 644   workspace_controller->SetShelf(shelf_layout_manager_);
 645
 646   status_container->SetLayoutManager(
 647       new StatusAreaLayoutManager(status_container, this));
 648
 649   shelf_container->SetEventTargeter(scoped_ptr<ui::EventTargeter>(new
 650       ShelfWindowTargeter(shelf_container, shelf_layout_manager_)));
 651   status_container->SetEventTargeter(scoped_ptr<ui::EventTargeter>(new
 652       ShelfWindowTargeter(status_container, shelf_layout_manager_)));
 653
 654   views::Widget::AddObserver(this);
 655 }
 656
 657 ShelfWidget::~ShelfWidget() {
 658   RemoveObserver(this);
 659 }
 660
 661 void ShelfWidget::SetPaintsBackground(
 662     ShelfBackgroundType background_type,
 663     BackgroundAnimatorChangeType change_type) {
 664   ui::Layer* opaque_background = delegate_view_->opaque_background();
 665   float target_opacity =
 666       (background_type == SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
 667   scoped_ptr<ui::ScopedLayerAnimationSettings> opaque_background_animation;
 668   if (change_type != BACKGROUND_CHANGE_IMMEDIATE) {
 669     opaque_background_animation.reset(new ui::ScopedLayerAnimationSettings(
 670         opaque_background->GetAnimator()));
 671     opaque_background_animation->SetTransitionDuration(
 672         base::TimeDelta::FromMilliseconds(kTimeToSwitchBackgroundMs));
 673   }
 674   opaque_background->SetOpacity(target_opacity);
 675
 676   // TODO(mukai): use ui::Layer on both opaque_background and normal background
 677   // retire background_animator_ at all. It would be simpler.
 678   // See also DockedBackgroundWidget::SetPaintsBackground.
 679   background_animator_.SetPaintsBackground(
 680       background_type != SHELF_BACKGROUND_DEFAULT,
 681       change_type);
 682   delegate_view_->SchedulePaint();
 683 }
 684
 685 ShelfBackgroundType ShelfWidget::GetBackgroundType() const {
 686   if (delegate_view_->opaque_background()->GetTargetOpacity() == 1.0f)
 687     return SHELF_BACKGROUND_MAXIMIZED;
 688   if (background_animator_.paints_background())
 689     return SHELF_BACKGROUND_OVERLAP;
 690
 691   return SHELF_BACKGROUND_DEFAULT;
 692 }
 693
 694 void ShelfWidget::HideShelfBehindBlackBar(bool hide, int animation_time_ms) {
 695   if (IsShelfHiddenBehindBlackBar() == hide)
 696     return;
 697
 698   ui::Layer* opaque_foreground = delegate_view_->opaque_foreground();
 699   float target_opacity = hide ? 1.0f : 0.0f;
 700   scoped_ptr<ui::ScopedLayerAnimationSettings> opaque_foreground_animation;
 701   opaque_foreground_animation.reset(new ui::ScopedLayerAnimationSettings(
 702       opaque_foreground->GetAnimator()));
 703   opaque_foreground_animation->SetTransitionDuration(
 704       base::TimeDelta::FromMilliseconds(animation_time_ms));
 705   opaque_foreground_animation->SetPreemptionStrategy(
 706       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 707
 708   opaque_foreground->SetOpacity(target_opacity);
 709 }
 710
 711 bool ShelfWidget::IsShelfHiddenBehindBlackBar() const {
 712   return delegate_view_->opaque_foreground()->GetTargetOpacity() != 0.0f;
 713 }
 714
 715 // static
 716 bool ShelfWidget::ShelfAlignmentAllowed() {
 717   if (Shell::GetInstance()->system_tray_delegate()->IsUserSupervised())
 718     return false;
 719
 720   user::LoginStatus login_status =
 721       Shell::GetInstance()->system_tray_delegate()->GetUserLoginStatus();
 722
 723   switch (login_status) {
 724     case user::LOGGED_IN_USER:
 725     case user::LOGGED_IN_OWNER:
 726       return true;
 727     case user::LOGGED_IN_LOCKED:
 728     case user::LOGGED_IN_PUBLIC:
 729     case user::LOGGED_IN_SUPERVISED:
 730     case user::LOGGED_IN_GUEST:
 731     case user::LOGGED_IN_RETAIL_MODE:
 732     case user::LOGGED_IN_KIOSK_APP:
 733     case user::LOGGED_IN_NONE:
 734       return false;
 735   }
 736
 737   DCHECK(false);
 738   return false;
 739 }
 740
 741 ShelfAlignment ShelfWidget::GetAlignment() const {
 742   return shelf_layout_manager_->GetAlignment();
 743 }
 744
 745 void ShelfWidget::SetAlignment(ShelfAlignment alignment) {
 746   if (shelf_)
 747     shelf_->SetAlignment(alignment);
 748   status_area_widget_->SetShelfAlignment(alignment);
 749   delegate_view_->SchedulePaint();
 750 }
 751
 752 void ShelfWidget::SetDimsShelf(bool dimming) {
 753   delegate_view_->SetDimmed(dimming);
 754   // Repaint all children, allowing updates to reflect dimmed state eg:
 755   // status area background, app list button and overflow button.
 756   if (shelf_)
 757     shelf_->SchedulePaint();
 758   status_area_widget_->SchedulePaint();
 759 }
 760
 761 bool ShelfWidget::GetDimsShelf() const {
 762   return delegate_view_->GetDimmed();
 763 }
 764
 765 void ShelfWidget::CreateShelf() {
 766   if (shelf_)
 767     return;
 768
 769   Shell* shell = Shell::GetInstance();
 770   // This needs to be called before shelf_model().
 771   ShelfDelegate* shelf_delegate = shell->GetShelfDelegate();
 772   if (!shelf_delegate)
 773     return;  // Not ready to create Shelf.
 774
 775   shelf_.reset(
 776       new Shelf(shell->shelf_model(), shell->GetShelfDelegate(), this));
 777   SetFocusCycler(shell->focus_cycler());
 778
 779   // Inform the root window controller.
 780   RootWindowController::ForWindow(window_container_)->OnShelfCreated();
 781
 782   shelf_->SetVisible(
 783       shell->session_state_delegate()->IsActiveUserSessionStarted());
 784   shelf_layout_manager_->LayoutShelf();
 785   Show();
 786 }
 787
 788 bool ShelfWidget::IsShelfVisible() const {
 789   return shelf_.get() && shelf_->IsVisible();
 790 }
 791
 792 void ShelfWidget::SetShelfVisibility(bool visible) {
 793   if (shelf_)
 794     shelf_->SetVisible(visible);
 795 }
 796
 797 void ShelfWidget::SetFocusCycler(FocusCycler* focus_cycler) {
 798   delegate_view_->set_focus_cycler(focus_cycler);
 799   if (focus_cycler)
 800     focus_cycler->AddWidget(this);
 801 }
 802
 803 FocusCycler* ShelfWidget::GetFocusCycler() {
 804   return delegate_view_->focus_cycler();
 805 }
 806
 807 void ShelfWidget::ShutdownStatusAreaWidget() {
 808   if (status_area_widget_)
 809     status_area_widget_->Shutdown();
 810   status_area_widget_ = NULL;
 811 }
 812
 813 void ShelfWidget::ForceUndimming(bool force) {
 814   delegate_view_->ForceUndimming(force);
 815 }
 816
 817 void ShelfWidget::OnWidgetActivationChanged(views::Widget* widget,
 818                                             bool active) {
 819   activating_as_fallback_ = false;
 820   if (active)
 821     delegate_view_->SetPaneFocusAndFocusDefault();
 822   else
 823     delegate_view_->GetFocusManager()->ClearFocus();
 824 }
 825
 826 int ShelfWidget::GetDimmingAlphaForTest() {
 827   if (delegate_view_)
 828     return delegate_view_->GetDimmingAlphaForTest();
 829   return -1;
 830 }
 831
 832 gfx::Rect ShelfWidget::GetDimmerBoundsForTest() {
 833   if (delegate_view_)
 834     return delegate_view_->GetDimmerBoundsForTest();
 835   return gfx::Rect();
 836 }
 837
 838 void ShelfWidget::DisableDimmingAnimationsForTest() {
 839   DCHECK(delegate_view_);
 840   return delegate_view_->disable_dimming_animations_for_test();
 841 }
 842
 843 void ShelfWidget::WillDeleteShelf() {
 844   shelf_layout_manager_->RemoveObserver(this);
 845   shelf_layout_manager_ = NULL;
 846 }
 847
 848 }  // namespace ash