ash/shelf/shelf_button.cc

   1 // Copyright 2013 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_button.h"
   6
   7 #include <algorithm>
   8
   9 #include "ash/ash_constants.h"
  10 #include "ash/ash_switches.h"
  11 #include "ash/shelf/shelf_button_host.h"
  12 #include "ash/shelf/shelf_layout_manager.h"
  13 #include "grit/ash_resources.h"
  14 #include "skia/ext/image_operations.h"
  15 #include "ui/base/accessibility/accessible_view_state.h"
  16 #include "ui/base/resource/resource_bundle.h"
  17 #include "ui/compositor/layer.h"
  18 #include "ui/compositor/scoped_layer_animation_settings.h"
  19 #include "ui/events/event_constants.h"
  20 #include "ui/gfx/animation/animation_delegate.h"
  21 #include "ui/gfx/animation/throb_animation.h"
  22 #include "ui/gfx/canvas.h"
  23 #include "ui/gfx/image/image.h"
  24 #include "ui/gfx/image/image_skia_operations.h"
  25 #include "ui/gfx/skbitmap_operations.h"
  26 #include "ui/views/controls/image_view.h"
  27
  28 namespace {
  29
  30 // Size of the bar. This is along the opposite axis of the shelf. For example,
  31 // if the shelf is aligned horizontally then this is the height of the bar.
  32 const int kBarSize = 3;
  33 const int kIconSize = 32;
  34 const int kHopSpacing = 2;
  35 const int kIconPad = 8;
  36 const int kAlternateIconPad = 5;
  37 const int kAlternateIconPadVertical = 6;
  38 const int kHopUpMS = 0;
  39 const int kHopDownMS = 200;
  40 const int kAttentionThrobDurationMS = 800;
  41
  42 bool ShouldHop(int state) {
  43   return state & ash::internal::ShelfButton::STATE_HOVERED ||
  44          state & ash::internal::ShelfButton::STATE_ACTIVE ||
  45          state & ash::internal::ShelfButton::STATE_FOCUSED;
  46 }
  47
  48 // Simple AnimationDelegate that owns a single ThrobAnimation instance to
  49 // keep all Draw Attention animations in sync.
  50 class ShelfButtonAnimation : public gfx::AnimationDelegate {
  51  public:
  52   class Observer {
  53    public:
  54     virtual void AnimationProgressed() = 0;
  55
  56    protected:
  57     virtual ~Observer() {}
  58   };
  59
  60   static ShelfButtonAnimation* GetInstance() {
  61     static ShelfButtonAnimation* s_instance = new ShelfButtonAnimation();
  62     return s_instance;
  63   }
  64
  65   void AddObserver(Observer* observer) {
  66     observers_.AddObserver(observer);
  67   }
  68
  69   void RemoveObserver(Observer* observer) {
  70     observers_.RemoveObserver(observer);
  71     if (!observers_.might_have_observers())
  72       animation_.Stop();
  73   }
  74
  75   int GetAlpha() {
  76     return GetThrobAnimation().CurrentValueBetween(0, 255);
  77   }
  78
  79   double GetAnimation() {
  80     return GetThrobAnimation().GetCurrentValue();
  81   }
  82
  83  private:
  84   ShelfButtonAnimation()
  85       : animation_(this) {
  86     animation_.SetThrobDuration(kAttentionThrobDurationMS);
  87     animation_.SetTweenType(gfx::Tween::SMOOTH_IN_OUT);
  88   }
  89
  90   virtual ~ShelfButtonAnimation() {
  91   }
  92
  93   gfx::ThrobAnimation& GetThrobAnimation() {
  94     if (!animation_.is_animating()) {
  95       animation_.Reset();
  96       animation_.StartThrobbing(-1 /*throb indefinitely*/);
  97     }
  98     return animation_;
  99   }
 100
 101   // gfx::AnimationDelegate
 102   virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE {
 103     if (animation != &animation_)
 104       return;
 105     if (!animation_.is_animating())
 106       return;
 107     FOR_EACH_OBSERVER(Observer, observers_, AnimationProgressed());
 108   }
 109
 110   gfx::ThrobAnimation animation_;
 111   ObserverList<Observer> observers_;
 112
 113   DISALLOW_COPY_AND_ASSIGN(ShelfButtonAnimation);
 114 };
 115
 116 }  // namespace
 117
 118 namespace ash {
 119 namespace internal {
 120
 121 ////////////////////////////////////////////////////////////////////////////////
 122 // ShelfButton::BarView
 123
 124 class ShelfButton::BarView : public views::ImageView,
 125                              public ShelfButtonAnimation::Observer {
 126  public:
 127   BarView(ShelfButton* host)
 128       : host_(host),
 129         show_attention_(false) {
 130   }
 131
 132   virtual ~BarView() {
 133     if (show_attention_)
 134       ShelfButtonAnimation::GetInstance()->RemoveObserver(this);
 135   }
 136
 137   // View
 138   virtual bool HitTestRect(const gfx::Rect& rect) const OVERRIDE {
 139     // Allow Mouse...() messages to go to the parent view.
 140     return false;
 141   }
 142
 143   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
 144     if (show_attention_) {
 145       int alpha = ShelfButtonAnimation::GetInstance()->GetAlpha();
 146       canvas->SaveLayerAlpha(alpha);
 147       views::ImageView::OnPaint(canvas);
 148       canvas->Restore();
 149     } else {
 150       views::ImageView::OnPaint(canvas);
 151     }
 152   }
 153
 154   // ShelfButtonAnimation::Observer
 155   virtual void AnimationProgressed() OVERRIDE {
 156     UpdateBounds();
 157     SchedulePaint();
 158   }
 159
 160   void SetBarBoundsRect(const gfx::Rect& bounds) {
 161     base_bounds_ = bounds;
 162     UpdateBounds();
 163   }
 164
 165   void ShowAttention(bool show) {
 166     if (show_attention_ != show) {
 167       show_attention_ = show;
 168       if (show_attention_)
 169         ShelfButtonAnimation::GetInstance()->AddObserver(this);
 170       else
 171         ShelfButtonAnimation::GetInstance()->RemoveObserver(this);
 172     }
 173     UpdateBounds();
 174   }
 175
 176  private:
 177   void UpdateBounds() {
 178     gfx::Rect bounds = base_bounds_;
 179     if (show_attention_) {
 180       // Scale from .35 to 1.0 of the total width (which is wider than the
 181       // visible width of the image, so the animation "rests" briefly at full
 182       // visible width.
 183       double animation = ShelfButtonAnimation::GetInstance()->GetAnimation();
 184       double scale = (.35 + .65 * animation);
 185       if (host_->shelf_layout_manager()->GetAlignment() ==
 186           SHELF_ALIGNMENT_BOTTOM) {
 187         bounds.set_width(base_bounds_.width() * scale);
 188         int x_offset = (base_bounds_.width() - bounds.width()) / 2;
 189         bounds.set_x(base_bounds_.x() + x_offset);
 190       } else {
 191         bounds.set_height(base_bounds_.height() * scale);
 192         int y_offset = (base_bounds_.height() - bounds.height()) / 2;
 193         bounds.set_y(base_bounds_.y() + y_offset);
 194       }
 195     }
 196     SetBoundsRect(bounds);
 197   }
 198
 199   ShelfButton* host_;
 200   bool show_attention_;
 201   gfx::Rect base_bounds_;
 202
 203   DISALLOW_COPY_AND_ASSIGN(BarView);
 204 };
 205
 206 ////////////////////////////////////////////////////////////////////////////////
 207 // ShelfButton::IconView
 208
 209 ShelfButton::IconView::IconView() : icon_size_(kIconSize) {
 210 }
 211
 212 ShelfButton::IconView::~IconView() {
 213 }
 214
 215 bool ShelfButton::IconView::HitTestRect(const gfx::Rect& rect) const {
 216   // Return false so that ShelfButton gets all the mouse events.
 217   return false;
 218 }
 219
 220 ////////////////////////////////////////////////////////////////////////////////
 221 // ShelfButton
 222
 223 ShelfButton* ShelfButton::Create(views::ButtonListener* listener,
 224                                  ShelfButtonHost* host,
 225                                  ShelfLayoutManager* shelf_layout_manager) {
 226   ShelfButton* button = new ShelfButton(listener, host, shelf_layout_manager);
 227   button->Init();
 228   return button;
 229 }
 230
 231 ShelfButton::ShelfButton(views::ButtonListener* listener,
 232                          ShelfButtonHost* host,
 233                          ShelfLayoutManager* shelf_layout_manager)
 234     : CustomButton(listener),
 235       host_(host),
 236       icon_view_(NULL),
 237       bar_(new BarView(this)),
 238       state_(STATE_NORMAL),
 239       shelf_layout_manager_(shelf_layout_manager),
 240       destroyed_flag_(NULL) {
 241   SetAccessibilityFocusable(true);
 242
 243   const gfx::ShadowValue kShadows[] = {
 244     gfx::ShadowValue(gfx::Point(0, 2), 0, SkColorSetARGB(0x1A, 0, 0, 0)),
 245     gfx::ShadowValue(gfx::Point(0, 3), 1, SkColorSetARGB(0x1A, 0, 0, 0)),
 246     gfx::ShadowValue(gfx::Point(0, 0), 1, SkColorSetARGB(0x54, 0, 0, 0)),
 247   };
 248   icon_shadows_.assign(kShadows, kShadows + arraysize(kShadows));
 249
 250   AddChildView(bar_);
 251 }
 252
 253 ShelfButton::~ShelfButton() {
 254   if (destroyed_flag_)
 255     *destroyed_flag_ = true;
 256 }
 257
 258 void ShelfButton::SetShadowedImage(const gfx::ImageSkia& image) {
 259   icon_view_->SetImage(gfx::ImageSkiaOperations::CreateImageWithDropShadow(
 260       image, icon_shadows_));
 261 }
 262
 263 void ShelfButton::SetImage(const gfx::ImageSkia& image) {
 264   if (image.isNull()) {
 265     // TODO: need an empty image.
 266     icon_view_->SetImage(image);
 267     return;
 268   }
 269
 270   if (icon_view_->icon_size() == 0) {
 271     SetShadowedImage(image);
 272     return;
 273   }
 274
 275   // Resize the image maintaining our aspect ratio.
 276   int pref = icon_view_->icon_size();
 277   float aspect_ratio =
 278       static_cast<float>(image.width()) / static_cast<float>(image.height());
 279   int height = pref;
 280   int width = static_cast<int>(aspect_ratio * height);
 281   if (width > pref) {
 282     width = pref;
 283     height = static_cast<int>(width / aspect_ratio);
 284   }
 285
 286   if (width == image.width() && height == image.height()) {
 287     SetShadowedImage(image);
 288     return;
 289   }
 290
 291   SetShadowedImage(gfx::ImageSkiaOperations::CreateResizedImage(image,
 292       skia::ImageOperations::RESIZE_BEST, gfx::Size(width, height)));
 293 }
 294
 295 const gfx::ImageSkia& ShelfButton::GetImage() const {
 296   return icon_view_->GetImage();
 297 }
 298
 299 void ShelfButton::AddState(State state) {
 300   if (!(state_ & state)) {
 301     if (!ash::switches::UseAlternateShelfLayout() &&
 302         (ShouldHop(state) || !ShouldHop(state_))) {
 303       ui::ScopedLayerAnimationSettings scoped_setter(
 304           icon_view_->layer()->GetAnimator());
 305       scoped_setter.SetTransitionDuration(
 306           base::TimeDelta::FromMilliseconds(kHopUpMS));
 307     }
 308     state_ |= state;
 309     Layout();
 310     if (state & STATE_ATTENTION)
 311       bar_->ShowAttention(true);
 312   }
 313 }
 314
 315 void ShelfButton::ClearState(State state) {
 316   if (state_ & state) {
 317     if (!ash::switches::UseAlternateShelfLayout() &&
 318         (!ShouldHop(state) || ShouldHop(state_))) {
 319       ui::ScopedLayerAnimationSettings scoped_setter(
 320           icon_view_->layer()->GetAnimator());
 321       scoped_setter.SetTweenType(gfx::Tween::LINEAR);
 322       scoped_setter.SetTransitionDuration(
 323           base::TimeDelta::FromMilliseconds(kHopDownMS));
 324     }
 325     state_ &= ~state;
 326     Layout();
 327     if (state & STATE_ATTENTION)
 328       bar_->ShowAttention(false);
 329   }
 330 }
 331
 332 gfx::Rect ShelfButton::GetIconBounds() const {
 333   return icon_view_->bounds();
 334 }
 335
 336 void ShelfButton::ShowContextMenu(const gfx::Point& p,
 337                                   ui::MenuSourceType source_type) {
 338   if (!context_menu_controller())
 339     return;
 340
 341   bool destroyed = false;
 342   destroyed_flag_ = &destroyed;
 343
 344   CustomButton::ShowContextMenu(p, source_type);
 345
 346   if (!destroyed) {
 347     destroyed_flag_ = NULL;
 348     // The menu will not propagate mouse events while its shown. To address,
 349     // the hover state gets cleared once the menu was shown (and this was not
 350     // destroyed).
 351     ClearState(STATE_HOVERED);
 352   }
 353 }
 354
 355 bool ShelfButton::OnMousePressed(const ui::MouseEvent& event) {
 356   CustomButton::OnMousePressed(event);
 357   host_->PointerPressedOnButton(this, ShelfButtonHost::MOUSE, event);
 358   return true;
 359 }
 360
 361 void ShelfButton::OnMouseReleased(const ui::MouseEvent& event) {
 362   CustomButton::OnMouseReleased(event);
 363   host_->PointerReleasedOnButton(this, ShelfButtonHost::MOUSE, false);
 364 }
 365
 366 void ShelfButton::OnMouseCaptureLost() {
 367   ClearState(STATE_HOVERED);
 368   host_->PointerReleasedOnButton(this, ShelfButtonHost::MOUSE, true);
 369   CustomButton::OnMouseCaptureLost();
 370 }
 371
 372 bool ShelfButton::OnMouseDragged(const ui::MouseEvent& event) {
 373   CustomButton::OnMouseDragged(event);
 374   host_->PointerDraggedOnButton(this, ShelfButtonHost::MOUSE, event);
 375   return true;
 376 }
 377
 378 void ShelfButton::OnMouseMoved(const ui::MouseEvent& event) {
 379   CustomButton::OnMouseMoved(event);
 380   host_->MouseMovedOverButton(this);
 381 }
 382
 383 void ShelfButton::OnMouseEntered(const ui::MouseEvent& event) {
 384   AddState(STATE_HOVERED);
 385   CustomButton::OnMouseEntered(event);
 386   host_->MouseEnteredButton(this);
 387 }
 388
 389 void ShelfButton::OnMouseExited(const ui::MouseEvent& event) {
 390   ClearState(STATE_HOVERED);
 391   CustomButton::OnMouseExited(event);
 392   host_->MouseExitedButton(this);
 393 }
 394
 395 void ShelfButton::GetAccessibleState(ui::AccessibleViewState* state) {
 396   state->role = ui::AccessibilityTypes::ROLE_PUSHBUTTON;
 397   state->name = host_->GetAccessibleName(this);
 398 }
 399
 400 void ShelfButton::Layout() {
 401   const gfx::Rect button_bounds(GetContentsBounds());
 402   int icon_pad = kIconPad;
 403   if (ash::switches::UseAlternateShelfLayout()) {
 404       icon_pad =
 405           shelf_layout_manager_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM ?
 406           kAlternateIconPadVertical : kAlternateIconPad;
 407   }
 408   int x_offset = shelf_layout_manager_->PrimaryAxisValue(0, icon_pad);
 409   int y_offset = shelf_layout_manager_->PrimaryAxisValue(icon_pad, 0);
 410
 411   int icon_width = std::min(kIconSize,
 412       button_bounds.width() - x_offset);
 413   int icon_height = std::min(kIconSize,
 414       button_bounds.height() - y_offset);
 415
 416   // If on the left or top 'invert' the inset so the constant gap is on
 417   // the interior (towards the center of display) edge of the shelf.
 418   if (SHELF_ALIGNMENT_LEFT == shelf_layout_manager_->GetAlignment())
 419     x_offset = button_bounds.width() - (kIconSize + icon_pad);
 420
 421   if (SHELF_ALIGNMENT_TOP == shelf_layout_manager_->GetAlignment())
 422     y_offset = button_bounds.height() - (kIconSize + icon_pad);
 423
 424   if (ShouldHop(state_) && !ash::switches::UseAlternateShelfLayout()) {
 425     x_offset += shelf_layout_manager_->SelectValueForShelfAlignment(
 426         0, kHopSpacing, -kHopSpacing, 0);
 427     y_offset += shelf_layout_manager_->SelectValueForShelfAlignment(
 428         -kHopSpacing, 0, 0, kHopSpacing);
 429   }
 430
 431   // Center icon with respect to the secondary axis, and ensure
 432   // that the icon doesn't occlude the bar highlight.
 433   if (shelf_layout_manager_->IsHorizontalAlignment()) {
 434     x_offset = std::max(0, button_bounds.width() - icon_width) / 2;
 435     if (y_offset + icon_height + kBarSize > button_bounds.height())
 436       icon_height = button_bounds.height() - (y_offset + kBarSize);
 437   } else {
 438     y_offset = std::max(0, button_bounds.height() - icon_height) / 2;
 439     if (x_offset + icon_width + kBarSize > button_bounds.width())
 440       icon_width = button_bounds.width() - (x_offset + kBarSize);
 441   }
 442
 443   icon_view_->SetBoundsRect(gfx::Rect(
 444       button_bounds.x() + x_offset,
 445       button_bounds.y() + y_offset,
 446       icon_width,
 447       icon_height));
 448
 449   // Icon size has been incorrect when running
 450   // PanelLayoutManagerTest.PanelAlignmentSecondDisplay on valgrind bot, see
 451   // http://crbug.com/234854.
 452   DCHECK_LE(icon_width, kIconSize);
 453   DCHECK_LE(icon_height, kIconSize);
 454
 455   bar_->SetBarBoundsRect(button_bounds);
 456
 457   UpdateState();
 458 }
 459
 460 void ShelfButton::ChildPreferredSizeChanged(views::View* child) {
 461   Layout();
 462 }
 463
 464 void ShelfButton::OnFocus() {
 465   AddState(STATE_FOCUSED);
 466   CustomButton::OnFocus();
 467 }
 468
 469 void ShelfButton::OnBlur() {
 470   ClearState(STATE_FOCUSED);
 471   CustomButton::OnBlur();
 472 }
 473
 474 void ShelfButton::OnPaint(gfx::Canvas* canvas) {
 475   CustomButton::OnPaint(canvas);
 476   if (HasFocus()) {
 477     gfx::Rect paint_bounds(GetLocalBounds());
 478     paint_bounds.Inset(1, 1, 1, 1);
 479     canvas->DrawSolidFocusRect(paint_bounds, kFocusBorderColor);
 480   }
 481 }
 482
 483 void ShelfButton::OnGestureEvent(ui::GestureEvent* event) {
 484   switch (event->type()) {
 485     case ui::ET_GESTURE_TAP_DOWN:
 486       AddState(STATE_HOVERED);
 487       return CustomButton::OnGestureEvent(event);
 488     case ui::ET_GESTURE_END:
 489       ClearState(STATE_HOVERED);
 490       return CustomButton::OnGestureEvent(event);
 491     case ui::ET_GESTURE_SCROLL_BEGIN:
 492       host_->PointerPressedOnButton(this, ShelfButtonHost::TOUCH, *event);
 493       event->SetHandled();
 494       return;
 495     case ui::ET_GESTURE_SCROLL_UPDATE:
 496       host_->PointerDraggedOnButton(this, ShelfButtonHost::TOUCH, *event);
 497       event->SetHandled();
 498       return;
 499     case ui::ET_GESTURE_SCROLL_END:
 500     case ui::ET_SCROLL_FLING_START:
 501       host_->PointerReleasedOnButton(this, ShelfButtonHost::TOUCH, false);
 502       event->SetHandled();
 503       return;
 504     default:
 505       return CustomButton::OnGestureEvent(event);
 506   }
 507 }
 508
 509 void ShelfButton::Init() {
 510   icon_view_ = CreateIconView();
 511
 512   // TODO: refactor the layers so each button doesn't require 2.
 513   icon_view_->SetPaintToLayer(true);
 514   icon_view_->SetFillsBoundsOpaquely(false);
 515   icon_view_->SetHorizontalAlignment(views::ImageView::CENTER);
 516   icon_view_->SetVerticalAlignment(views::ImageView::LEADING);
 517
 518   AddChildView(icon_view_);
 519 }
 520
 521 ShelfButton::IconView* ShelfButton::CreateIconView() {
 522   return new IconView;
 523 }
 524
 525 bool ShelfButton::IsShelfHorizontal() const {
 526   return shelf_layout_manager_->IsHorizontalAlignment();
 527 }
 528
 529 void ShelfButton::UpdateState() {
 530   UpdateBar();
 531
 532   icon_view_->SetHorizontalAlignment(
 533       shelf_layout_manager_->PrimaryAxisValue(views::ImageView::CENTER,
 534                                               views::ImageView::LEADING));
 535   icon_view_->SetVerticalAlignment(
 536       shelf_layout_manager_->PrimaryAxisValue(views::ImageView::LEADING,
 537                                               views::ImageView::CENTER));
 538   SchedulePaint();
 539 }
 540
 541 void ShelfButton::UpdateBar() {
 542   if (state_ & STATE_HIDDEN) {
 543     bar_->SetVisible(false);
 544     return;
 545   }
 546
 547   int bar_id = 0;
 548   if (ash::switches::UseAlternateShelfLayout()) {
 549     if (state_ & STATE_ACTIVE)
 550       bar_id = IDR_AURA_LAUNCHER_UNDERLINE_ACTIVE_ALTERNATE;
 551     else if (state_ & STATE_RUNNING)
 552       bar_id = IDR_AURA_LAUNCHER_UNDERLINE_RUNNING_ALTERNATE;
 553   } else {
 554     if (state_ & (STATE_ACTIVE | STATE_ATTENTION))
 555       bar_id = IDR_AURA_LAUNCHER_UNDERLINE_ACTIVE;
 556     else if (state_ & (STATE_HOVERED | STATE_FOCUSED))
 557       bar_id = IDR_AURA_LAUNCHER_UNDERLINE_HOVER;
 558     else
 559       bar_id = IDR_AURA_LAUNCHER_UNDERLINE_RUNNING;
 560   }
 561
 562   if (bar_id != 0) {
 563     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 564     const gfx::ImageSkia* image = rb.GetImageNamed(bar_id).ToImageSkia();
 565     if (shelf_layout_manager_->GetAlignment() == SHELF_ALIGNMENT_BOTTOM) {
 566       bar_->SetImage(*image);
 567     } else {
 568       bar_->SetImage(gfx::ImageSkiaOperations::CreateRotatedImage(*image,
 569           shelf_layout_manager_->SelectValueForShelfAlignment(
 570               SkBitmapOperations::ROTATION_90_CW,
 571               SkBitmapOperations::ROTATION_90_CW,
 572               SkBitmapOperations::ROTATION_270_CW,
 573               SkBitmapOperations::ROTATION_180_CW)));
 574     }
 575     bar_->SetHorizontalAlignment(
 576         shelf_layout_manager_->SelectValueForShelfAlignment(
 577             views::ImageView::CENTER,
 578             views::ImageView::LEADING,
 579             views::ImageView::TRAILING,
 580             views::ImageView::CENTER));
 581     bar_->SetVerticalAlignment(
 582         shelf_layout_manager_->SelectValueForShelfAlignment(
 583             views::ImageView::TRAILING,
 584             views::ImageView::CENTER,
 585             views::ImageView::CENTER,
 586             views::ImageView::LEADING));
 587     bar_->SchedulePaint();
 588   }
 589
 590   bar_->SetVisible(bar_id != 0 && state_ != STATE_NORMAL);
 591 }
 592
 593 }  // namespace internal
 594 }  // namespace ash