src/ash/system/tray/tray_background_view.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/system/tray/tray_background_view.h"
   6
   7 #include "ash/ash_switches.h"
   8 #include "ash/root_window_controller.h"
   9 #include "ash/screen_util.h"
  10 #include "ash/shelf/shelf_layout_manager.h"
  11 #include "ash/shelf/shelf_widget.h"
  12 #include "ash/shell.h"
  13 #include "ash/shell_window_ids.h"
  14 #include "ash/system/status_area_widget.h"
  15 #include "ash/system/status_area_widget_delegate.h"
  16 #include "ash/system/tray/system_tray.h"
  17 #include "ash/system/tray/tray_constants.h"
  18 #include "ash/system/tray/tray_event_filter.h"
  19 #include "ash/wm/window_animations.h"
  20 #include "grit/ash_resources.h"
  21 #include "ui/accessibility/ax_view_state.h"
  22 #include "ui/aura/window.h"
  23 #include "ui/aura/window_event_dispatcher.h"
  24 #include "ui/base/resource/resource_bundle.h"
  25 #include "ui/compositor/layer.h"
  26 #include "ui/compositor/layer_animation_element.h"
  27 #include "ui/compositor/scoped_layer_animation_settings.h"
  28 #include "ui/gfx/animation/tween.h"
  29 #include "ui/gfx/canvas.h"
  30 #include "ui/gfx/image/image_skia.h"
  31 #include "ui/gfx/image/image_skia_operations.h"
  32 #include "ui/gfx/rect.h"
  33 #include "ui/gfx/screen.h"
  34 #include "ui/gfx/skia_util.h"
  35 #include "ui/gfx/transform.h"
  36 #include "ui/views/background.h"
  37 #include "ui/views/layout/box_layout.h"
  38
  39 namespace {
  40
  41 const int kTrayBackgroundAlpha = 100;
  42 const int kTrayBackgroundHoverAlpha = 150;
  43 const SkColor kTrayBackgroundPressedColor = SkColorSetRGB(66, 129, 244);
  44
  45 const int kAnimationDurationForPopupMs = 200;
  46
  47 // Duration of opacity animation for visibility changes.
  48 const int kAnimationDurationForVisibilityMs = 250;
  49
  50 // When becoming visible delay the animation so that StatusAreaWidgetDelegate
  51 // can animate sibling views out of the position to be occuped by the
  52 // TrayBackgroundView.
  53 const int kShowAnimationDelayMs = 100;
  54
  55 }  // namespace
  56
  57 using views::TrayBubbleView;
  58
  59 namespace ash {
  60
  61 // static
  62 const char TrayBackgroundView::kViewClassName[] = "tray/TrayBackgroundView";
  63
  64 // Used to track when the anchor widget changes position on screen so that the
  65 // bubble position can be updated.
  66 class TrayBackgroundView::TrayWidgetObserver : public views::WidgetObserver {
  67  public:
  68   explicit TrayWidgetObserver(TrayBackgroundView* host)
  69       : host_(host) {
  70   }
  71
  72   virtual void OnWidgetBoundsChanged(views::Widget* widget,
  73                                      const gfx::Rect& new_bounds) OVERRIDE {
  74     host_->AnchorUpdated();
  75   }
  76
  77   virtual void OnWidgetVisibilityChanged(views::Widget* widget,
  78                                          bool visible) OVERRIDE {
  79     host_->AnchorUpdated();
  80   }
  81
  82  private:
  83   TrayBackgroundView* host_;
  84
  85   DISALLOW_COPY_AND_ASSIGN(TrayWidgetObserver);
  86 };
  87
  88 class TrayBackground : public views::Background {
  89  public:
  90   const static int kImageTypeDefault = 0;
  91   const static int kImageTypeOnBlack = 1;
  92   const static int kImageTypePressed = 2;
  93   const static int kNumStates = 3;
  94
  95   const static int kImageHorizontal = 0;
  96   const static int kImageVertical = 1;
  97   const static int kNumOrientations = 2;
  98
  99   explicit TrayBackground(TrayBackgroundView* tray_background_view) :
 100       tray_background_view_(tray_background_view) {
 101     set_alpha(kTrayBackgroundAlpha);
 102     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 103     leading_images_[kImageHorizontal][kImageTypeDefault] =
 104         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_LEFT).ToImageSkia();
 105     middle_images_[kImageHorizontal][kImageTypeDefault] =
 106         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_CENTER).ToImageSkia();
 107     trailing_images_[kImageHorizontal][kImageTypeDefault] =
 108         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_RIGHT).ToImageSkia();
 109
 110     leading_images_[kImageHorizontal][kImageTypeOnBlack] =
 111         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_LEFT_ONBLACK).ToImageSkia();
 112     middle_images_[kImageHorizontal][kImageTypeOnBlack] =
 113         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_CENTER_ONBLACK).ToImageSkia();
 114     trailing_images_[kImageHorizontal][kImageTypeOnBlack] =
 115         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_RIGHT_ONBLACK).ToImageSkia();
 116
 117     leading_images_[kImageHorizontal][kImageTypePressed] =
 118         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_LEFT_PRESSED).ToImageSkia();
 119     middle_images_[kImageHorizontal][kImageTypePressed] =
 120         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_CENTER_PRESSED).ToImageSkia();
 121     trailing_images_[kImageHorizontal][kImageTypePressed] =
 122         rb.GetImageNamed(IDR_AURA_TRAY_BG_HORIZ_RIGHT_PRESSED).ToImageSkia();
 123
 124     leading_images_[kImageVertical][kImageTypeDefault] =
 125         rb.GetImageNamed(IDR_AURA_TRAY_BG_VERTICAL_TOP).ToImageSkia();
 126     middle_images_[kImageVertical][kImageTypeDefault] =
 127         rb.GetImageNamed(
 128             IDR_AURA_TRAY_BG_VERTICAL_CENTER).ToImageSkia();
 129     trailing_images_[kImageVertical][kImageTypeDefault] =
 130         rb.GetImageNamed(IDR_AURA_TRAY_BG_VERTICAL_BOTTOM).ToImageSkia();
 131
 132     leading_images_[kImageVertical][kImageTypeOnBlack] =
 133         rb.GetImageNamed(IDR_AURA_TRAY_BG_VERTICAL_TOP_ONBLACK).ToImageSkia();
 134     middle_images_[kImageVertical][kImageTypeOnBlack] =
 135         rb.GetImageNamed(
 136             IDR_AURA_TRAY_BG_VERTICAL_CENTER_ONBLACK).ToImageSkia();
 137     trailing_images_[kImageVertical][kImageTypeOnBlack] =
 138         rb.GetImageNamed(
 139             IDR_AURA_TRAY_BG_VERTICAL_BOTTOM_ONBLACK).ToImageSkia();
 140
 141     leading_images_[kImageVertical][kImageTypePressed] =
 142         rb.GetImageNamed(IDR_AURA_TRAY_BG_VERTICAL_TOP_PRESSED).ToImageSkia();
 143     middle_images_[kImageVertical][kImageTypePressed] =
 144         rb.GetImageNamed(
 145             IDR_AURA_TRAY_BG_VERTICAL_CENTER_PRESSED).ToImageSkia();
 146     trailing_images_[kImageVertical][kImageTypePressed] =
 147         rb.GetImageNamed(
 148             IDR_AURA_TRAY_BG_VERTICAL_BOTTOM_PRESSED).ToImageSkia();
 149   }
 150
 151   virtual ~TrayBackground() {}
 152
 153   SkColor color() { return color_; }
 154   void set_color(SkColor color) { color_ = color; }
 155   void set_alpha(int alpha) { color_ = SkColorSetARGB(alpha, 0, 0, 0); }
 156
 157  private:
 158   ShelfWidget* GetShelfWidget() const {
 159     return RootWindowController::ForWindow(tray_background_view_->
 160         status_area_widget()->GetNativeWindow())->shelf();
 161   }
 162
 163   // Overridden from views::Background.
 164   virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
 165     int orientation = kImageHorizontal;
 166     ShelfWidget* shelf_widget = GetShelfWidget();
 167     if (shelf_widget &&
 168         !shelf_widget->shelf_layout_manager()->IsHorizontalAlignment())
 169       orientation = kImageVertical;
 170
 171     int state = kImageTypeDefault;
 172     if (tray_background_view_->draw_background_as_active())
 173       state = kImageTypePressed;
 174     else if (shelf_widget && shelf_widget->GetDimsShelf())
 175       state = kImageTypeOnBlack;
 176     else
 177       state = kImageTypeDefault;
 178
 179     const gfx::ImageSkia* leading = leading_images_[orientation][state];
 180     const gfx::ImageSkia* middle = middle_images_[orientation][state];
 181     const gfx::ImageSkia* trailing = trailing_images_[orientation][state];
 182
 183     gfx::Rect bounds(view->GetLocalBounds());
 184     gfx::Point leading_location, trailing_location;
 185     gfx::Rect middle_bounds;
 186
 187     if (orientation == kImageHorizontal) {
 188       leading_location = gfx::Point(0, 0);
 189       trailing_location = gfx::Point(bounds.width() - trailing->width(), 0);
 190       middle_bounds = gfx::Rect(
 191           leading->width(),
 192           0,
 193           bounds.width() - (leading->width() + trailing->width()),
 194           bounds.height());
 195     } else {
 196       leading_location = gfx::Point(0, 0);
 197       trailing_location = gfx::Point(0, bounds.height() - trailing->height());
 198       middle_bounds = gfx::Rect(
 199           0,
 200           leading->height(),
 201           bounds.width(),
 202           bounds.height() - (leading->height() + trailing->height()));
 203     }
 204
 205     canvas->DrawImageInt(*leading,
 206                          leading_location.x(),
 207                          leading_location.y());
 208
 209     canvas->DrawImageInt(*trailing,
 210                          trailing_location.x(),
 211                          trailing_location.y());
 212
 213     canvas->TileImageInt(*middle,
 214                          middle_bounds.x(),
 215                          middle_bounds.y(),
 216                          middle_bounds.width(),
 217                          middle_bounds.height());
 218   }
 219
 220   SkColor color_;
 221   // Reference to the TrayBackgroundView for which this is a background.
 222   TrayBackgroundView* tray_background_view_;
 223
 224   // References to the images used as backgrounds, they are owned by the
 225   // resource bundle class.
 226   const gfx::ImageSkia* leading_images_[kNumOrientations][kNumStates];
 227   const gfx::ImageSkia* middle_images_[kNumOrientations][kNumStates];
 228   const gfx::ImageSkia* trailing_images_[kNumOrientations][kNumStates];
 229
 230   DISALLOW_COPY_AND_ASSIGN(TrayBackground);
 231 };
 232
 233 TrayBackgroundView::TrayContainer::TrayContainer(ShelfAlignment alignment)
 234     : alignment_(alignment) {
 235   UpdateLayout();
 236 }
 237
 238 void TrayBackgroundView::TrayContainer::SetAlignment(ShelfAlignment alignment) {
 239   if (alignment_ == alignment)
 240     return;
 241   alignment_ = alignment;
 242   UpdateLayout();
 243 }
 244
 245 gfx::Size TrayBackgroundView::TrayContainer::GetPreferredSize() const {
 246   if (size_.IsEmpty())
 247     return views::View::GetPreferredSize();
 248   return size_;
 249 }
 250
 251 void TrayBackgroundView::TrayContainer::ChildPreferredSizeChanged(
 252     views::View* child) {
 253   PreferredSizeChanged();
 254 }
 255
 256 void TrayBackgroundView::TrayContainer::ChildVisibilityChanged(View* child) {
 257   PreferredSizeChanged();
 258 }
 259
 260 void TrayBackgroundView::TrayContainer::ViewHierarchyChanged(
 261     const ViewHierarchyChangedDetails& details) {
 262   if (details.parent == this)
 263     PreferredSizeChanged();
 264 }
 265
 266 void TrayBackgroundView::TrayContainer::UpdateLayout() {
 267   // Adjust the size of status tray dark background by adding additional
 268   // empty border.
 269   if (alignment_ == SHELF_ALIGNMENT_BOTTOM ||
 270       alignment_ == SHELF_ALIGNMENT_TOP) {
 271     SetBorder(views::Border::CreateEmptyBorder(
 272         kPaddingFromEdgeOfShelf,
 273         kPaddingFromEdgeOfShelf,
 274         kPaddingFromEdgeOfShelf,
 275         kPaddingFromEdgeOfShelf));
 276
 277     views::BoxLayout* layout =
 278         new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0);
 279     layout->set_main_axis_alignment(views::BoxLayout::MAIN_AXIS_ALIGNMENT_FILL);
 280     views::View::SetLayoutManager(layout);
 281   } else {
 282     SetBorder(views::Border::CreateEmptyBorder(
 283         kPaddingFromEdgeOfShelf,
 284         kPaddingFromEdgeOfShelf,
 285         kPaddingFromEdgeOfShelf,
 286         kPaddingFromEdgeOfShelf));
 287
 288     views::BoxLayout* layout =
 289         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0);
 290     layout->set_main_axis_alignment(views::BoxLayout::MAIN_AXIS_ALIGNMENT_FILL);
 291     views::View::SetLayoutManager(layout);
 292   }
 293   PreferredSizeChanged();
 294 }
 295
 296 ////////////////////////////////////////////////////////////////////////////////
 297 // TrayBackgroundView
 298
 299 TrayBackgroundView::TrayBackgroundView(StatusAreaWidget* status_area_widget)
 300     : status_area_widget_(status_area_widget),
 301       tray_container_(NULL),
 302       shelf_alignment_(SHELF_ALIGNMENT_BOTTOM),
 303       background_(NULL),
 304       hide_background_animator_(this, 0, kTrayBackgroundAlpha),
 305       hover_background_animator_(
 306           this,
 307           0,
 308           kTrayBackgroundHoverAlpha - kTrayBackgroundAlpha),
 309       hovered_(false),
 310       draw_background_as_active_(false),
 311       widget_observer_(new TrayWidgetObserver(this)) {
 312   set_notify_enter_exit_on_child(true);
 313
 314   // Initially we want to paint the background, but without the hover effect.
 315   hide_background_animator_.SetPaintsBackground(
 316       true, BACKGROUND_CHANGE_IMMEDIATE);
 317   hover_background_animator_.SetPaintsBackground(
 318       false, BACKGROUND_CHANGE_IMMEDIATE);
 319
 320   tray_container_ = new TrayContainer(shelf_alignment_);
 321   SetContents(tray_container_);
 322   tray_event_filter_.reset(new TrayEventFilter);
 323
 324   SetPaintToLayer(true);
 325   SetFillsBoundsOpaquely(false);
 326   // Start the tray items not visible, because visibility changes are animated.
 327   views::View::SetVisible(false);
 328 }
 329
 330 TrayBackgroundView::~TrayBackgroundView() {
 331   if (GetWidget())
 332     GetWidget()->RemoveObserver(widget_observer_.get());
 333 }
 334
 335 void TrayBackgroundView::Initialize() {
 336   GetWidget()->AddObserver(widget_observer_.get());
 337   SetTrayBorder();
 338 }
 339
 340 void TrayBackgroundView::SetVisible(bool visible) {
 341   if (visible == layer()->GetTargetVisibility())
 342     return;
 343
 344   if (visible) {
 345     // The alignment of the shelf can change while the TrayBackgroundView is
 346     // hidden. Reset the offscreen transform so that the animation to becoming
 347     // visible reflects the current layout.
 348     HideTransformation();
 349     // SetVisible(false) is defered until the animation for hiding is done.
 350     // Otherwise the view is immediately hidden and the animation does not
 351     // render.
 352     views::View::SetVisible(true);
 353     // If SetVisible(true) is called while animating to not visible, then
 354     // views::View::SetVisible(true) is a no-op. When the previous animation
 355     // ends layer->SetVisible(false) is called. To prevent this
 356     // layer->SetVisible(true) immediately interrupts the animation of this
 357     // property, and keeps the layer visible.
 358     layer()->SetVisible(true);
 359   }
 360
 361   ui::ScopedLayerAnimationSettings animation(layer()->GetAnimator());
 362   animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 363       kAnimationDurationForVisibilityMs));
 364   animation.SetPreemptionStrategy(
 365       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 366
 367   if (visible) {
 368     animation.SetTweenType(gfx::Tween::EASE_OUT);
 369     // Show is delayed so as to allow time for other children of
 370     // StatusAreaWidget to begin animating to their new positions.
 371     layer()->GetAnimator()->SchedulePauseForProperties(
 372         base::TimeDelta::FromMilliseconds(kShowAnimationDelayMs),
 373         ui::LayerAnimationElement::OPACITY |
 374         ui::LayerAnimationElement::TRANSFORM);
 375     layer()->SetOpacity(1.0f);
 376     gfx::Transform transform;
 377     transform.Translate(0.0f, 0.0f);
 378     layer()->SetTransform(transform);
 379   } else {
 380     // Listen only to the hide animation. As we cannot turn off visibility
 381     // until the animation is over.
 382     animation.AddObserver(this);
 383     animation.SetTweenType(gfx::Tween::EASE_IN);
 384     layer()->SetOpacity(0.0f);
 385     layer()->SetVisible(false);
 386     HideTransformation();
 387   }
 388 }
 389
 390 const char* TrayBackgroundView::GetClassName() const {
 391   return kViewClassName;
 392 }
 393
 394 void TrayBackgroundView::OnMouseEntered(const ui::MouseEvent& event) {
 395   hovered_ = true;
 396 }
 397
 398 void TrayBackgroundView::OnMouseExited(const ui::MouseEvent& event) {
 399   hovered_ = false;
 400 }
 401
 402 void TrayBackgroundView::ChildPreferredSizeChanged(views::View* child) {
 403   PreferredSizeChanged();
 404 }
 405
 406 void TrayBackgroundView::GetAccessibleState(ui::AXViewState* state) {
 407   state->role = ui::AX_ROLE_BUTTON;
 408   state->name = GetAccessibleNameForTray();
 409 }
 410
 411 void TrayBackgroundView::AboutToRequestFocusFromTabTraversal(bool reverse) {
 412   // Return focus to the login view. See crbug.com/120500.
 413   views::View* v = GetNextFocusableView();
 414   if (v)
 415     v->AboutToRequestFocusFromTabTraversal(reverse);
 416 }
 417
 418 bool TrayBackgroundView::PerformAction(const ui::Event& event) {
 419   return false;
 420 }
 421
 422 gfx::Rect TrayBackgroundView::GetFocusBounds() {
 423   // The tray itself expands to the right and bottom edge of the screen to make
 424   // sure clicking on the edges brings up the popup. However, the focus border
 425   // should be only around the container.
 426   return GetContentsBounds();
 427 }
 428
 429 void TrayBackgroundView::UpdateBackground(int alpha) {
 430   // The animator should never fire when the alternate shelf layout is used.
 431   if (!background_ || draw_background_as_active_)
 432     return;
 433   background_->set_alpha(hide_background_animator_.alpha() +
 434                          hover_background_animator_.alpha());
 435   SchedulePaint();
 436 }
 437
 438 void TrayBackgroundView::SetContents(views::View* contents) {
 439   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
 440   AddChildView(contents);
 441 }
 442
 443 void TrayBackgroundView::SetPaintsBackground(
 444     bool value, BackgroundAnimatorChangeType change_type) {
 445   hide_background_animator_.SetPaintsBackground(value, change_type);
 446 }
 447
 448 void TrayBackgroundView::SetContentsBackground() {
 449   background_ = new TrayBackground(this);
 450   tray_container_->set_background(background_);
 451 }
 452
 453 ShelfLayoutManager* TrayBackgroundView::GetShelfLayoutManager() {
 454   return ShelfLayoutManager::ForShelf(GetWidget()->GetNativeView());
 455 }
 456
 457 void TrayBackgroundView::SetShelfAlignment(ShelfAlignment alignment) {
 458   shelf_alignment_ = alignment;
 459   SetTrayBorder();
 460   tray_container_->SetAlignment(alignment);
 461 }
 462
 463 void TrayBackgroundView::SetTrayBorder() {
 464   views::View* parent = status_area_widget_->status_area_widget_delegate();
 465   // Tray views are laid out right-to-left or bottom-to-top
 466   bool on_edge = (this == parent->child_at(0));
 467   int left_edge, top_edge, right_edge, bottom_edge;
 468   if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
 469     top_edge = ShelfLayoutManager::kShelfItemInset;
 470     left_edge = 0;
 471     bottom_edge = kShelfSize -
 472         ShelfLayoutManager::kShelfItemInset - kShelfItemHeight;
 473     right_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
 474   } else if (shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
 475     top_edge = 0;
 476     left_edge = kShelfSize -
 477         ShelfLayoutManager::kShelfItemInset - kShelfItemHeight;
 478     bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
 479     right_edge = ShelfLayoutManager::kShelfItemInset;
 480   } else { // SHELF_ALIGNMENT_RIGHT
 481     top_edge = 0;
 482     left_edge = ShelfLayoutManager::kShelfItemInset;
 483     bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
 484     right_edge = kShelfSize -
 485         ShelfLayoutManager::kShelfItemInset - kShelfItemHeight;
 486   }
 487   SetBorder(views::Border::CreateEmptyBorder(
 488       top_edge, left_edge, bottom_edge, right_edge));
 489 }
 490
 491 void TrayBackgroundView::OnImplicitAnimationsCompleted() {
 492   // If there is another animation in the queue, the reverse animation was
 493   // triggered before the completion of animating to invisible. Do not turn off
 494   // the visibility so that the next animation may render. The value of
 495   // layer()->GetTargetVisibility() can be incorrect if the hide animation was
 496   // aborted to schedule an animation to become visible. As the new animation
 497   // is not yet added to the queue. crbug.com/374236
 498   if(layer()->GetAnimator()->is_animating() ||
 499      layer()->GetTargetVisibility())
 500     return;
 501   views::View::SetVisible(false);
 502 }
 503
 504 void TrayBackgroundView::HideTransformation() {
 505   gfx::Transform transform;
 506   if (shelf_alignment_ == SHELF_ALIGNMENT_BOTTOM ||
 507       shelf_alignment_ == SHELF_ALIGNMENT_TOP)
 508     transform.Translate(width(), 0.0f);
 509   else
 510     transform.Translate(0.0f, height());
 511   layer()->SetTransform(transform);
 512 }
 513
 514 void TrayBackgroundView::InitializeBubbleAnimations(
 515     views::Widget* bubble_widget) {
 516   wm::SetWindowVisibilityAnimationType(
 517       bubble_widget->GetNativeWindow(),
 518       wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
 519   wm::SetWindowVisibilityAnimationTransition(
 520       bubble_widget->GetNativeWindow(),
 521       wm::ANIMATE_HIDE);
 522   wm::SetWindowVisibilityAnimationDuration(
 523       bubble_widget->GetNativeWindow(),
 524       base::TimeDelta::FromMilliseconds(kAnimationDurationForPopupMs));
 525 }
 526
 527 aura::Window* TrayBackgroundView::GetBubbleWindowContainer() const {
 528   return ash::Shell::GetContainer(
 529       tray_container()->GetWidget()->GetNativeWindow()->GetRootWindow(),
 530       ash::kShellWindowId_SettingBubbleContainer);
 531 }
 532
 533 gfx::Rect TrayBackgroundView::GetBubbleAnchorRect(
 534     views::Widget* anchor_widget,
 535     TrayBubbleView::AnchorType anchor_type,
 536     TrayBubbleView::AnchorAlignment anchor_alignment) const {
 537   gfx::Rect rect;
 538   if (anchor_widget && anchor_widget->IsVisible()) {
 539     rect = anchor_widget->GetWindowBoundsInScreen();
 540     if (anchor_type == TrayBubbleView::ANCHOR_TYPE_TRAY) {
 541       if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
 542         bool rtl = base::i18n::IsRTL();
 543         rect.Inset(
 544             rtl ? kBubblePaddingHorizontalSide : 0,
 545             kBubblePaddingHorizontalBottom,
 546             rtl ? 0 : kBubblePaddingHorizontalSide,
 547             0);
 548       } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
 549         rect.Inset(0, 0, kBubblePaddingVerticalSide + 4,
 550                    kBubblePaddingVerticalBottom);
 551       } else {
 552         rect.Inset(kBubblePaddingVerticalSide, 0, 0,
 553                    kBubblePaddingVerticalBottom);
 554       }
 555     } else if (anchor_type == TrayBubbleView::ANCHOR_TYPE_BUBBLE) {
 556       // Invert the offsets to align with the bubble below.
 557       // Note that with the alternate shelf layout the tips are not shown and
 558       // the offsets for left and right alignment do not need to be applied.
 559       int vertical_alignment = 0;
 560       int horizontal_alignment = kBubblePaddingVerticalBottom;
 561       if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT)
 562         rect.Inset(vertical_alignment, 0, 0, horizontal_alignment);
 563       else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT)
 564         rect.Inset(0, 0, vertical_alignment, horizontal_alignment);
 565     }
 566   }
 567
 568   // TODO(jennyz): May need to add left/right alignment in the following code.
 569   if (rect.IsEmpty()) {
 570     aura::Window* target_root = anchor_widget ?
 571         anchor_widget->GetNativeView()->GetRootWindow() :
 572         Shell::GetPrimaryRootWindow();
 573     rect = target_root->bounds();
 574     rect = gfx::Rect(
 575         base::i18n::IsRTL() ? kPaddingFromRightEdgeOfScreenBottomAlignment :
 576         rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
 577         rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
 578         0, 0);
 579     rect = ScreenUtil::ConvertRectToScreen(target_root, rect);
 580   }
 581   return rect;
 582 }
 583
 584 TrayBubbleView::AnchorAlignment TrayBackgroundView::GetAnchorAlignment() const {
 585   switch (shelf_alignment_) {
 586     case SHELF_ALIGNMENT_BOTTOM:
 587       return TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
 588     case SHELF_ALIGNMENT_LEFT:
 589       return TrayBubbleView::ANCHOR_ALIGNMENT_LEFT;
 590     case SHELF_ALIGNMENT_RIGHT:
 591       return TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT;
 592     case SHELF_ALIGNMENT_TOP:
 593       return TrayBubbleView::ANCHOR_ALIGNMENT_TOP;
 594   }
 595   NOTREACHED();
 596   return TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
 597 }
 598
 599 void TrayBackgroundView::SetDrawBackgroundAsActive(bool visible) {
 600   draw_background_as_active_ = visible;
 601   if (!background_)
 602     return;
 603
 604   // Do not change gradually, changing color between grey and blue is weird.
 605   if (draw_background_as_active_)
 606     background_->set_color(kTrayBackgroundPressedColor);
 607   else if (hovered_)
 608     background_->set_alpha(kTrayBackgroundHoverAlpha);
 609   else
 610     background_->set_alpha(kTrayBackgroundAlpha);
 611   SchedulePaint();
 612 }
 613
 614 void TrayBackgroundView::UpdateBubbleViewArrow(
 615     views::TrayBubbleView* bubble_view) {
 616   // Nothing to do here.
 617 }
 618
 619 }  // namespace ash