ash: Animate changes in the uber tray.

ash/system/tray/system_tray.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/system/tray/system_tray.h"
 
 #include "ash/shell.h"
 #include "ash/shell/panel_window.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/tray/tray_constants.h"
@@ skipping 10 matching lines @@
 #include "grit/ash_strings.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/events.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/views/border.h"
 #include "ui/views/bubble/bubble_delegate.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 
 namespace {
 
 const int kPaddingFromRightEdgeOfScreen = 15;
 const int kPaddingFromBottomOfScreen = 10;
 
 const int kAnimationDurationForPopupMS = 200;
+const int kTrayItemAnimationDurationMS = 200;
 
 const int kArrowHeight = 10;
 const int kArrowWidth = 20;
 const int kArrowPaddingFromRight = 20;
 
 const int kShadowOffset = 3;
 const int kShadowHeight = 3;
 
 const int kLeftPadding = 4;
 const int kBottomLineHeight = 1;
 
 const int kTrayIconHeight = 29;
 
 const SkColor kShadowColor = SkColorSetARGB(25, 0, 0, 0);
 
 const SkColor kTrayBackgroundAlpha = 100;
 const SkColor kTrayBackgroundHoverAlpha = 150;
 
 // Container for items in the tray. It makes sure the widget is updated
 // correctly when the visibility/size of the tray item changes.
-// TODO: setup animation.
-class TrayItemContainer : public views::View {
+class TrayItemContainer : public views::View,
+                          public ui::AnimationDelegate {
  public:
-  explicit TrayItemContainer(views::View* view) : child_(view) {
+  explicit TrayItemContainer(views::View* view)
+      : child_(view),
+        processing_(false) {
     AddChildView(child_);
     SetVisible(child_->visible());
+
+    child_->SetPaintToLayer(true);
+    child_->SetFillsBoundsOpaquely(false);
   }
 
   virtual ~TrayItemContainer() {}
 
  private:
   // Makes sure the widget relayouts after the size/visibility of the view
   // changes.
   void ApplyChange() {
-    // Forcing the widget to the new size is sufficient. The positing is taken
-    // care of by the layout manager (ShelfLayoutManager).
+    // Forcing the widget to the new size is sufficient. The positioning is
+    // taken care of by the layout manager (ShelfLayoutManager).
     GetWidget()->SetSize(GetWidget()->GetContentsView()->GetPreferredSize());
   }
 
   // Overridden from views::View.
   virtual void Layout() {
     child_->SetBoundsRect(gfx::Rect(size()));
   }
 
   virtual gfx::Size GetPreferredSize() OVERRIDE {
+    if (!animation_.get() || !animation_->is_animating())
+      return child_->GetPreferredSize();
     gfx::Size size = child_->GetPreferredSize();
+    size.set_width(std::max(1,
+        static_cast<int>(size.width() * animation_->GetCurrentValue())));
     size.set_height(kTrayIconHeight);
     return size;
   }
 
   virtual void ChildPreferredSizeChanged(views::View* child) OVERRIDE {
     ApplyChange();
   }
 
   virtual void ChildVisibilityChanged(views::View* child) OVERRIDE {
-    if (visible() == child_->visible())
+    if (processing_)
       return;
-    SetVisible(child_->visible());
+    processing_ = true;
+    if (!animation_.get()) {
+      animation_.reset(new ui::SlideAnimation(this));
+      animation_->SetSlideDuration(kTrayItemAnimationDurationMS);
+      animation_->SetTweenType(ui::Tween::LINEAR);
+    }
+
+    if (!child_->visible()) {
+      // child_ is hiding. To animate nicely, it is necessary to redisplay the
+      // child view during animation.
+      child_->SetVisible(true);

[sadrul, 2012/04/02 20:41:12]

This is a bit hacky. This can cause a bug if the icon is re-displayed before
this animation ends (e.g. quickly toggles the caps-lock). Something like
aura::Window::AcquireLayer for views::View could be useful here?

+      animation_->Hide();
+      AnimationProgressed(animation_.get());
+    } else {
+      SetVisible(true);
+      animation_->Show();
+      AnimationProgressed(animation_.get());
+    }
+    processing_ = false;
+  }
+
+  // Overridden from ui::AnimationDelegate.
+  virtual void AnimationProgressed(const ui::Animation* animation) OVERRIDE {
+    ui::Transform transform;
+    transform.SetScale(animation->GetCurrentValue(),
+                       animation->GetCurrentValue());
+    transform.ConcatTranslate(0, animation->CurrentValueBetween(
+        static_cast<double>(height()) / 2, 0.));
+    child_->layer()->SetTransform(transform);
     ApplyChange();
   }
 
+  virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE {
+    processing_ = true;
+    if (animation->GetCurrentValue() < 0.1) {
+      child_->SetVisible(false);
+      SetVisible(false);
+    } else {
+      child_->SetVisible(true);
+      SetVisible(true);
+    }
+    processing_ = false;
+  }
+
+  virtual void AnimationCanceled(const ui::Animation* animation) OVERRIDE {
+    AnimationEnded(animation);
+  }
+
   views::View* child_;
+  bool processing_;
+  scoped_ptr<ui::SlideAnimation> animation_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayItemContainer);
 };
 
 // A view with some special behaviour for tray items in the popup:
 // - changes background color on hover.
 // - TODO: accessibility
 class TrayPopupItemContainer : public views::View {
  public:
   explicit TrayPopupItemContainer(views::View* view) : hover_(false) {
@@ skipping 540 matching lines @@
       popup_->Hide();
     }
   }
   return base::EVENT_CONTINUE;
 }
 
 void SystemTray::DidProcessEvent(const base::NativeEvent& event) {
 }
 
 }  // namespace ash