Add new attention state to launcher

ash/launcher/launcher_button.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/launcher/launcher_button.h"
 
 #include <algorithm>
 
 #include "ash/launcher/launcher_button_host.h"
 #include "grit/ui_resources.h"
 #include "ui/base/accessibility/accessible_view_state.h"
+#include "ui/base/animation/animation_delegate.h"
+#include "ui/base/animation/throb_animation.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/controls/image_view.h"
 
 namespace {
 const int kBarHeight = 3;
 const int kBarSpacing = 5;
 const int kIconHeight = 32;
 const int kIconWidth = 48;
 const int kHopSpacing = 2;
 const int kActiveBarColor = 0xe6ffffff;
 const int kInactiveBarColor = 0x80ffffff;
 const int kHopUpMS = 200;
 const int kHopDownMS = 200;
-
-// Used to allow Mouse...() messages to go to the parent view.
-class MouseIgnoredImageView : public views::ImageView {
- public:
-  bool HitTest(const gfx::Point& l) const OVERRIDE {
-    return false;
-  }
-};
+const int kAttentionThrobDurationMS = 2000;
 
 bool ShouldHop(int state) {
   return state & ash::internal::LauncherButton::STATE_HOVERED ||
       state & ash::internal::LauncherButton::STATE_ACTIVE;
 }
 
 } // namespace
 
 namespace ash {
 
 namespace internal {
 
+class LauncherButton::BarView : public views::ImageView,
+                                public ui::AnimationDelegate {
+ public:
+  BarView() : animation_(new ui::ThrobAnimation(this)) {

[sky, 2012/05/18 16:38:30]

ALLOW_THIS_IN_INITIALIAZER_LIST

+    animation_->SetThrobDuration(kAttentionThrobDurationMS);
+    animation_->SetTweenType(ui::Tween::SMOOTH_IN_OUT);
+  }
+
+  // View overrides.
+  bool HitTest(const gfx::Point& l) const OVERRIDE {
+    // Allow Mouse...() messages to go to the parent view.
+    return false;
+  }
+
+  void OnPaint(gfx::Canvas* canvas) {

[sky, 2012/05/18 16:38:30]

virtual OVERRIDE

+    if (animation_->is_animating()) {
+      int alpha = animation_->CurrentValueBetween(0, 255);
+      canvas->SaveLayerAlpha(alpha);
+      views::ImageView::OnPaint(canvas);
+      canvas->Restore();
+    } else {
+      views::ImageView::OnPaint(canvas);
+    }
+  }
+
+  // ui::AnimationDelegate overrides.
+  void AnimationProgressed(const ui::Animation* animation) {

[sky, 2012/05/18 16:38:30]

virtual OVERRIDE

+    SchedulePaint();
+  }
+
+  void ShowAttention(bool show) {
+    if (show)
+      animation_->StartThrobbing(-1);
+    else
+      animation_->Reset();
+  }
+
+ private:
+  scoped_ptr<ui::ThrobAnimation> animation_;

[sky, 2012/05/18 16:38:30]

Since you create this in the constructor, no need to use scoped_ptr, make it a
value.

+};

[sky, 2012/05/18 16:38:30]

DISALLOW_...

+
 LauncherButton::IconView::IconView() : icon_size_(kIconHeight) {
 }
 
 LauncherButton::IconView::~IconView() {
 }
 
 bool LauncherButton::IconView::HitTest(const gfx::Point& l) const {
   return false;
 }
 
 LauncherButton* LauncherButton::Create(views::ButtonListener* listener,
                                        LauncherButtonHost* host) {
   LauncherButton* button = new LauncherButton(listener, host);
   button->Init();
   return button;
 }
 
 LauncherButton::LauncherButton(views::ButtonListener* listener,
                                LauncherButtonHost* host)
     : CustomButton(listener),
       host_(host),
       icon_view_(NULL),
-      bar_(new MouseIgnoredImageView),
+      bar_(new BarView),
       state_(STATE_NORMAL) {
   set_accessibility_focusable(true);
   bar_->SetHorizontalAlignment(views::ImageView::CENTER);
   bar_->SetVerticalAlignment(views::ImageView::TRAILING);
   AddChildView(bar_);
 }
 
 LauncherButton::~LauncherButton() {
 }
 
@@ skipping 62 matching lines @@
       ui::ScopedLayerAnimationSettings scoped_setter(
           icon_view_->layer()->GetAnimator());
       scoped_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kHopUpMS));
       state_ |= state;
       UpdateState();
     } else {
       state_ |= state;
       UpdateState();
     }
+    if (state & STATE_ATTENTION)
+      bar_->ShowAttention(true);
   }
 }
 
 void LauncherButton::ClearState(State state) {
   if (state_ & state) {
     if (!ShouldHop(state) || ShouldHop(state_)) {
       ui::ScopedLayerAnimationSettings scoped_setter(
           icon_view_->layer()->GetAnimator());
       scoped_setter.SetTweenType(ui::Tween::LINEAR);
       scoped_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kHopDownMS));
       state_ &= ~state;
       UpdateState();
     } else {
       state_ &= ~state;
       UpdateState();
     }
+    if (state & STATE_ATTENTION)
+      bar_->ShowAttention(false);
   }
 }
 
 gfx::Rect LauncherButton::GetIconBounds() const {
   return icon_view_->bounds();
 }
 
 bool LauncherButton::OnMousePressed(const views::MouseEvent& event) {
   CustomButton::OnMousePressed(event);
   host_->MousePressedOnButton(this, event);
@@ skipping 68 matching lines @@
 }
 
 void LauncherButton::UpdateState() {
   if (state_ == STATE_NORMAL) {
     bar_->SetVisible(false);
   } else {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     int bar_id;
     bar_->SetVisible(true);
 
-    if (state_ & STATE_HOVERED)
+    if (state_ & STATE_ACTIVE || state_ & STATE_ATTENTION)
+      bar_id = IDR_AURA_LAUNCHER_UNDERLINE_ACTIVE;
+    else if (state_ & STATE_HOVERED)
       bar_id = IDR_AURA_LAUNCHER_UNDERLINE_HOVER;
-    else if (state_ & STATE_ACTIVE)
-      bar_id = IDR_AURA_LAUNCHER_UNDERLINE_ACTIVE;
     else
       bar_id = IDR_AURA_LAUNCHER_UNDERLINE_RUNNING;
 
     bar_->SetImage(rb.GetImageNamed(bar_id).ToSkBitmap());
   }
 
   Layout();
   SchedulePaint();
 }
 }  // namespace internal
 }  // namespace ash