Animate the OverviewButtonTray

ash/system/tray/tray_background_view.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/tray_background_view.h"
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/system/status_area_widget_delegate.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray/tray_event_filter.h"
 #include "ash/wm/window_animations.h"
 #include "grit/ash_resources.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.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_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
+#include "ui/gfx/transform.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/box_layout.h"
 
 namespace {
 
 const int kTrayBackgroundAlpha = 100;
 const int kTrayBackgroundHoverAlpha = 150;
 const SkColor kTrayBackgroundPressedColor = SkColorSetRGB(66, 129, 244);
 
 const int kAnimationDurationForPopupMS = 200;
+const int kAnimationDurationForVisibility = 200;
 
 }  // namespace
 
 using views::TrayBubbleView;
 
 namespace ash {
 
 // static
 const char TrayBackgroundView::kViewClassName[] = "tray/TrayBackgroundView";
 
@@ skipping 249 matching lines @@
 
   // Initially we want to paint the background, but without the hover effect.
   hide_background_animator_.SetPaintsBackground(
       true, BACKGROUND_CHANGE_IMMEDIATE);
   hover_background_animator_.SetPaintsBackground(
       false, BACKGROUND_CHANGE_IMMEDIATE);
 
   tray_container_ = new TrayContainer(shelf_alignment_);
   SetContents(tray_container_);
   tray_event_filter_.reset(new TrayEventFilter);
+
+  SetPaintToLayer(true);
+  SetFillsBoundsOpaquely(false);
 }
 
 TrayBackgroundView::~TrayBackgroundView() {
   if (GetWidget())
     GetWidget()->RemoveObserver(widget_observer_.get());
 }
 
 void TrayBackgroundView::Initialize() {
   GetWidget()->AddObserver(widget_observer_.get());
   SetTrayBorder();
 }
 
+void TrayBackgroundView::SetVisible(bool set_visible) {

[flackr, 2014/04/30 16:06:40]

s/set_visible/visible to match the variable name in definition in .h file and
overridden method.

[jonross, 2014/04/30 21:25:38]

Done.

+  if (set_visible == visible())
+    return;
+
+  if (set_visible)
+    views::View::SetVisible(set_visible);

[flackr, 2014/04/30 16:06:40]

I believe you should be able to SetVisible(false) in the scope of the
ScopedLayerAnimationSettings, and then it will automagically keep the layer
visible until the animation is complete and you won't need the animation
observer.

[jonross, 2014/04/30 21:25:38]

In order to user layer()->SetVisibility(false) I would need to detach the layer
from the tree. This is typically done when a window is about to be destroyed.

Other areas use the pattern of an animation listener. For this change we will
stick with this pattern.

+
+  layer()->GetAnimator()->StopAnimating();
+  ui::ScopedLayerAnimationSettings animation(layer()->GetAnimator());
+  animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
+      kAnimationDurationForVisibility));
+  animation.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  animation.AddObserver(this);
+
+  if (set_visible) {
+    layer()->SetOpacity(1.0f);
+    gfx::Transform transform;
+    transform.Translate(0.0f, 0.0f);
+    transform.Scale(1.0f, 1.0f);
+    layer()->SetTransform(transform);
+  } else {
+    layer()->SetOpacity(0.0f);
+    gfx::Transform transform;
+    if (shelf_alignment_ == SHELF_ALIGNMENT_BOTTOM ||
+         shelf_alignment_ == SHELF_ALIGNMENT_TOP) {

[flackr, 2014/04/30 16:06:40]

nit: bad indent, should line up with above line.

[jonross, 2014/04/30 21:25:38]

Done.

+      transform.Translate(width(), height() / 2.0f);
+    } else {
+      transform.Translate(width() / 2.0f, height());
+    }
+    transform.Scale(0.01f, 0.01f);

[flackr, 2014/04/30 16:06:40]

Use constants for non 0 or 1 values.

[jonross, 2014/04/30 21:25:38]

Done.

+    layer()->SetTransform(transform);
+  }
+}
+
 const char* TrayBackgroundView::GetClassName() const {
   return kViewClassName;
 }
 
 void TrayBackgroundView::OnMouseEntered(const ui::MouseEvent& event) {
   hovered_ = true;
 }
 
 void TrayBackgroundView::OnMouseExited(const ui::MouseEvent& event) {
   hovered_ = false;
@@ skipping 48 matching lines @@
 void TrayBackgroundView::SetContentsBackground() {
   background_ = new TrayBackground(this);
   tray_container_->set_background(background_);
 }
 
 ShelfLayoutManager* TrayBackgroundView::GetShelfLayoutManager() {
   return ShelfLayoutManager::ForShelf(GetWidget()->GetNativeView());
 }
 
 void TrayBackgroundView::SetShelfAlignment(ShelfAlignment alignment) {
+  if (!visible() && shelf_alignment_ != alignment) {
+    // A translation transform was applied when becoming hidden. Swap the
+    // transform to be the offscreen position for the new alignment.

[flackr, 2014/04/30 16:06:40]

It'd probably make more sense to set the correct transform to transition in from
in Show before the scope of the ScopedLayerAnimationSettings object.

[jonross, 2014/04/30 21:25:38]

Done.

+    gfx::Transform transform;
+    if (alignment == SHELF_ALIGNMENT_BOTTOM || alignment == SHELF_ALIGNMENT_TOP)
+      transform.Translate(width(), height() /  2.0f);
+    else
+      transform.Translate(width() /2.0f, height());
+    transform.Scale(0.01f, 0.01f);
+    layer()->SetTransform(transform);
+  }
+
   shelf_alignment_ = alignment;
   SetTrayBorder();
   tray_container_->SetAlignment(alignment);
 }
 
 void TrayBackgroundView::SetTrayBorder() {
   views::View* parent = status_area_widget_->status_area_widget_delegate();
   // Tray views are laid out right-to-left or bottom-to-top
   bool on_edge = (this == parent->child_at(0));
   int left_edge, top_edge, right_edge, bottom_edge;
@@ skipping 13 matching lines @@
     top_edge = 0;
     left_edge = ShelfLayoutManager::kShelfItemInset;
     bottom_edge = on_edge ? kPaddingFromEdgeOfShelf : 0;
     right_edge = kShelfSize -
         ShelfLayoutManager::kShelfItemInset - kShelfItemHeight;
   }
   SetBorder(views::Border::CreateEmptyBorder(
       top_edge, left_edge, bottom_edge, right_edge));
 }
 
+void TrayBackgroundView::OnImplicitAnimationsCompleted() {
+  if (layer()->opacity() == 0.0f)
+    views::View::SetVisible(false);
+}
+
 void TrayBackgroundView::InitializeBubbleAnimations(
     views::Widget* bubble_widget) {
   wm::SetWindowVisibilityAnimationType(
       bubble_widget->GetNativeWindow(),
       wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   wm::SetWindowVisibilityAnimationTransition(
       bubble_widget->GetNativeWindow(),
       wm::ANIMATE_HIDE);
   wm::SetWindowVisibilityAnimationDuration(
       bubble_widget->GetNativeWindow(),
@@ skipping 86 matching lines @@
     background_->set_alpha(kTrayBackgroundAlpha);
   SchedulePaint();
 }
 
 void TrayBackgroundView::UpdateBubbleViewArrow(
     views::TrayBubbleView* bubble_view) {
   // Nothing to do here.
 }
 
 }  // namespace ash