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