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 849
