[ash-md] Fades overview header in and out

ash/common/wm/overview/window_selector_item.cc

 // Copyright 2013 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/common/wm/overview/window_selector_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/metrics/user_metrics_action.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/wm/overview/cleanup_animation_observer.h"
 #include "ash/common/wm/overview/overview_animation_type.h"
 #include "ash/common/wm/overview/scoped_overview_animation_settings.h"
 #include "ash/common/wm/overview/scoped_overview_animation_settings_factory.h"
 #include "ash/common/wm/overview/scoped_transform_overview_window.h"
 #include "ash/common/wm/overview/window_selector.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
@@ skipping 38 matching lines @@
 static const int kWindowSelectorMargin = kWindowMarginMD * 2;
 
 // Foreground label color.
 static const SkColor kLabelColor = SK_ColorWHITE;
 
 // TODO(tdanderson): Move this to a central location.
 static const SkColor kCloseButtonColor = SK_ColorWHITE;
 
 // Label background color used with Material Design.
 // TODO(varkha): Make background color conform to window header.
-static const SkColor kLabelBackgroundColor = SkColorSetARGB(25, 255, 255, 255);
+static const SkColor kLabelBackgroundColor = SkColorSetARGB(254, 225, 225, 225);
 
 // Corner radius for the selection tiles used with Material Design.
 static int kLabelBackgroundRadius = 2;
 
 // Label shadow color.
 static const SkColor kLabelShadow = SkColorSetARGB(176, 0, 0, 0);
 
 // Vertical padding for the label, on top of it.
 static const int kVerticalLabelPadding = 20;
 
 // Horizontal padding for the label, on both sides. Used with Material Design.
 static const int kHorizontalLabelPaddingMD = 8;
 
 // Solid shadow length from the label
 static const int kVerticalShadowOffset = 1;
 
 // Amount of blur applied to the label shadow
 static const int kShadowBlur = 10;
 
 // Height of an item header in Material Design.
 static const int kHeaderHeight = 32;
 
 // Opacity for dimmed items.
 static const float kDimmedItemOpacity = 0.5f;
 
 // Opacity for fading out during closing a window.
 static const float kClosingItemOpacity = 0.8f;
 
+// Opacity for the item header.
+static const float kHeaderOpacity = 0.2f;
+
 // Duration of background opacity transition for the selected label.
 static const int kSelectorFadeInMilliseconds = 350;
 
+// The time duration for fade out animations when exiting overview mode.
+const int kTransitionMilliseconds = 300;
+
 // Before closing a window animate both the window and the caption to shrink by
 // this fraction of size.
 static const float kPreCloseScale = 0.02f;
 
 // Convenience method to fade in a Window with predefined animation settings.
 // Note: The fade in animation will occur after a delay where the delay is how
 // long the lay out animations take.
 void SetupFadeInAfterLayout(views::Widget* widget) {
   WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget);
   window->SetOpacity(0.0f);
   std::unique_ptr<ScopedOverviewAnimationSettings>
       scoped_overview_animation_settings =
           ScopedOverviewAnimationSettingsFactory::Get()
               ->CreateOverviewAnimationSettings(
                   OverviewAnimationType::
                       OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN,
                   window);
   window->SetOpacity(1.0f);
 }
 
+void SetupOpacityAfterLayout(views::Widget* widget) {
+  WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget);
+  std::unique_ptr<ScopedOverviewAnimationSettings>
+      scoped_overview_animation_settings =
+          ScopedOverviewAnimationSettingsFactory::Get()
+              ->CreateOverviewAnimationSettings(
+                  OverviewAnimationType::OVERVIEW_ANIMATION_FADE_IN_HEADER,
+                  window);
+  window->SetOpacity(kHeaderOpacity);
+}
+
 // An image button with a close window icon.
 class OverviewCloseButton : public views::ImageButton {
  public:
   explicit OverviewCloseButton(views::ButtonListener* listener);
   ~OverviewCloseButton() override;
 
  private:
   gfx::ImageSkia icon_image_;
 
   DISALLOW_COPY_AND_ASSIGN(OverviewCloseButton);
@@ skipping 125 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(CaptionContainerView);
 };
 
 WindowSelectorItem::WindowSelectorItem(WmWindow* window,
                                        WindowSelector* window_selector)
     : dimmed_(false),
       root_window_(window->GetRootWindow()),
       transform_window_(window),
       in_bounds_update_(false),
+      selected_(false),
+      first_time_(true),
       caption_container_view_(nullptr),
       window_label_button_view_(nullptr),
       close_button_(new OverviewCloseButton(this)),
       window_selector_(window_selector) {
   CreateWindowLabel(window->GetTitle());
   if (!ash::MaterialDesignController::IsOverviewMaterial()) {
     views::Widget::InitParams params;
     params.type = views::Widget::InitParams::TYPE_POPUP;
     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
@@ skipping 23 matching lines @@
 WindowSelectorItem::~WindowSelectorItem() {
   GetWindow()->RemoveObserver(this);
 }
 
 WmWindow* WindowSelectorItem::GetWindow() {
   return transform_window_.window();
 }
 
 void WindowSelectorItem::RestoreWindow() {
   transform_window_.RestoreWindow();
+  UpdateHeaderLayout(
+      OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS);
+  FadeOut(std::move(window_label_));
+  if (window_label_selector_)
+    FadeOut(std::move(window_label_selector_));
 }
 
 void WindowSelectorItem::ShowWindowOnExit() {
   transform_window_.ShowWindowOnExit();
 }
 
 void WindowSelectorItem::PrepareForOverview() {
   transform_window_.PrepareForOverview();
 }
 
@@ skipping 18 matching lines @@
   // SetItemBounds is called before UpdateHeaderLayout so the header can
   // properly use the updated windows bounds.
   UpdateHeaderLayout(animation_type);
   if (!ash::MaterialDesignController::IsOverviewMaterial())
     UpdateWindowLabel(target_bounds, animation_type);
 }
 
 void WindowSelectorItem::SetSelected(bool selected) {
   if (!ash::MaterialDesignController::IsOverviewMaterial())
     return;
+  selected_ = selected;
   WmWindow* window =
       WmLookup::Get()->GetWindowForWidget(window_label_selector_.get());
   ui::ScopedLayerAnimationSettings animation_settings(
       window->GetLayer()->GetAnimator());
   animation_settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kSelectorFadeInMilliseconds));
   animation_settings.SetTweenType(selected ? gfx::Tween::FAST_OUT_LINEAR_IN
                                            : gfx::Tween::LINEAR_OUT_SLOW_IN);
   animation_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  window->SetOpacity(selected ? 0.0f : 1.0f);
+  window->SetOpacity(selected ? 0.0f : kHeaderOpacity);
 
   ui::ScopedLayerAnimationSettings animation_settings_shadow(
       shadow_->shadow_layer()->GetAnimator());
   animation_settings_shadow.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kSelectorFadeInMilliseconds));
   animation_settings_shadow.SetTweenType(selected
                                              ? gfx::Tween::FAST_OUT_LINEAR_IN
                                              : gfx::Tween::LINEAR_OUT_SLOW_IN);
   animation_settings_shadow.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
@@ skipping 100 matching lines @@
           screen_rect, target_bounds, top_view_inset, title_height);
   gfx::Transform transform = ScopedTransformOverviewWindow::GetTransformForRect(
       screen_rect, selector_item_bounds);
   ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
   transform_window_.BeginScopedAnimation(animation_type, &animation_settings);
   // Rounded corners are achieved by using a mask layer on the original window
   // before the transform. Dividing by scale factor obtains the corner radius
   // which when scaled will yield |kLabelBackgroundRadius|.
   transform_window_.SetTransform(
       root_window_, transform, use_mask_, use_shape_,
-      (kLabelBackgroundRadius / GetItemScale(target_bounds.size())));
+      (kLabelBackgroundRadius / GetItemScale(target_bounds.size())),
+      animation_type != OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
   transform_window_.set_overview_transform(transform);
 }
 
 void WindowSelectorItem::SetOpacity(float opacity) {
   window_label_->SetOpacity(opacity);
+  if (window_label_selector_) {
+    window_label_selector_->SetOpacity(selected_ ? 0.f
+                                                 : kHeaderOpacity * opacity);
+  }
+
   if (!ash::MaterialDesignController::IsOverviewMaterial())
     close_button_widget_->SetOpacity(opacity);
 
   transform_window_.SetOpacity(opacity);
 }
 
 void WindowSelectorItem::UpdateWindowLabel(
     const gfx::Rect& window_bounds,
     OverviewAnimationType animation_type) {
   if (!window_label_->IsVisible()) {
@@ skipping 10 matching lines @@
               animation_type,
               WmLookup::Get()->GetWindowForWidget(window_label_.get()));
 
   WmWindow* window_label_window =
       WmLookup::Get()->GetWindowForWidget(window_label_.get());
   window_label_window->SetBounds(label_bounds);
 }
 
 void WindowSelectorItem::CreateWindowLabel(const base::string16& title) {
   const bool material = ash::MaterialDesignController::IsOverviewMaterial();
-  window_label_.reset(new views::Widget);
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.visible_on_all_workspaces = true;
-  window_label_->set_focus_on_creation(false);
   root_window_->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           window_label_.get(), kShellWindowId_StatusContainer, &params);
+
+  if (material) {
+    views::View* background_view =
+        new RoundedContainerView(kLabelBackgroundRadius, kLabelBackgroundColor);
+    window_label_selector_.reset(new views::Widget);
+    params.activatable = views::Widget::InitParams::Activatable::ACTIVATABLE_NO;
+    params.accept_events = false;
+    window_label_selector_->Init(params);
+    window_label_selector_->set_focus_on_creation(false);
+    window_label_selector_->SetContentsView(background_view);
+    window_label_selector_->Show();
+  }
+
+  params.activatable =
+      views::Widget::InitParams::Activatable::ACTIVATABLE_DEFAULT;
+  params.accept_events = true;
+  window_label_.reset(new views::Widget);
+  window_label_->set_focus_on_creation(false);
   window_label_->Init(params);
   window_label_button_view_ = new OverviewLabelButton(this, title);
   window_label_button_view_->SetBorder(views::Border::NullBorder());
   window_label_button_view_->SetEnabledTextColors(kLabelColor);
   window_label_button_view_->set_animate_on_state_change(false);
   if (material) {
     window_label_button_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   } else {
     window_label_button_view_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
     window_label_button_view_->SetTextShadows(gfx::ShadowValues(
@@ skipping 11 matching lines @@
         new CaptionContainerView(window_label_button_view_, close_button_);
     window_label_->SetContentsView(caption_container_view_);
     window_label_button_view_->SetVisible(false);
     window_label_->Show();
 
     shadow_.reset(new ::wm::Shadow());
     shadow_->Init(::wm::Shadow::STYLE_INACTIVE);
     shadow_->layer()->SetVisible(true);
     window_label_->GetLayer()->Add(shadow_->layer());
     window_label_->GetLayer()->SetMasksToBounds(false);
-
-    views::View* background_view =
-        new RoundedContainerView(kLabelBackgroundRadius, kLabelBackgroundColor);
-    window_label_selector_.reset(new views::Widget);
-    params.activatable = views::Widget::InitParams::Activatable::ACTIVATABLE_NO;
-    params.accept_events = false;
-    window_label_selector_->Init(params);
-    window_label_selector_->set_focus_on_creation(false);
-    window_label_selector_->SetContentsView(background_view);
-    window_label_selector_->Show();
+    UpdateHeaderLayout(OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
   } else {
     // Indicate that the label will be drawn onto a transparent background
     // (disables subpixel antialiasing).
     window_label_button_view_->SetBackgroundColorHint(SK_ColorTRANSPARENT);
     window_label_->SetContentsView(window_label_button_view_);
   }
+  first_time_ = false;
 }
 
 void WindowSelectorItem::UpdateHeaderLayout(
     OverviewAnimationType animation_type) {
   gfx::Rect transformed_window_bounds = root_window_->ConvertRectFromScreen(
       transform_window_.GetTransformedBounds(hide_header()));
 
   if (ash::MaterialDesignController::IsOverviewMaterial()) {
     gfx::Rect label_rect(close_button_->GetPreferredSize());
-    label_rect.set_y(-label_rect.height());
+    if (first_time_) {
+      if (transform_window_.GetTopInset() == 0) {
+        label_rect.set_y(0);
+        label_rect.set_height(0);
+      } else {
+        label_rect.set_y(-transform_window_.GetTopInset());
+      }
+    } else {
+      label_rect.set_y(-label_rect.height());
+    }
     label_rect.set_width(transformed_window_bounds.width());
 
     if (!window_label_button_view_->visible()) {
       window_label_button_view_->SetVisible(true);
       SetupFadeInAfterLayout(window_label_.get());
       SetupFadeInAfterLayout(window_label_selector_.get());
+      SetupOpacityAfterLayout(window_label_selector_.get());
     }
     WmWindow* window_label_window =
         WmLookup::Get()->GetWindowForWidget(window_label_.get());
     WmWindow* window_label_selector_window =
         WmLookup::Get()->GetWindowForWidget(window_label_selector_.get());
     std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
         ScopedOverviewAnimationSettingsFactory::Get()
             ->CreateOverviewAnimationSettings(animation_type,
                                               window_label_window);
     std::unique_ptr<ScopedOverviewAnimationSettings>
@@ skipping 38 matching lines @@
 }
 
 void WindowSelectorItem::AnimateOpacity(float opacity,
                                         OverviewAnimationType animation_type) {
   DCHECK_GE(opacity, 0.f);
   DCHECK_LE(opacity, 1.f);
   ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
   transform_window_.BeginScopedAnimation(animation_type, &animation_settings);
   transform_window_.SetOpacity(opacity);
 
+  const float header_opacity = selected_ ? 0.f : kHeaderOpacity * opacity;
   WmWindow* window_label_window =
       WmLookup::Get()->GetWindowForWidget(window_label_.get());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings_label =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type,
                                             window_label_window);
-  window_label_window->SetOpacity(opacity);
+  window_label_window->SetOpacity(header_opacity);
 
   WmWindow* window_label_selector_window =
       WmLookup::Get()->GetWindowForWidget(window_label_selector_.get());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings_selector =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type,
                                             window_label_selector_window);
-  window_label_selector_window->SetOpacity(opacity);
+  window_label_selector_window->SetOpacity(header_opacity);
 }
 
 void WindowSelectorItem::UpdateCloseButtonAccessibilityName() {
   close_button_->SetAccessibleName(l10n_util::GetStringFUTF16(
       IDS_ASH_OVERVIEW_CLOSE_ITEM_BUTTON_ACCESSIBLE_NAME,
       GetWindow()->GetTitle()));
 }
 
+void WindowSelectorItem::FadeOut(std::unique_ptr<views::Widget> widget) {
+  widget->SetOpacity(1.f);
+
+  // Fade out the widget. This animation continues past the lifetime of |this|.
+  WmWindow* widget_window = WmLookup::Get()->GetWindowForWidget(widget.get());
+  ui::ScopedLayerAnimationSettings animation_settings(
+      widget_window->GetLayer()->GetAnimator());
+  animation_settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kTransitionMilliseconds));
+  animation_settings.SetTweenType(gfx::Tween::EASE_OUT);
+  animation_settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  // CleanupAnimationObserver will delete itself (and the widget) when the
+  // opacity animation is complete.
+  // Ownership over the observer is passed to the window_selector_->delegate()
+  // which has longer lifetime so that animations can continue even after the
+  // overview mode is shut down.
+  views::Widget* widget_ptr = widget.get();
+  std::unique_ptr<CleanupAnimationObserver> observer(
+      new CleanupAnimationObserver(std::move(widget)));
+  animation_settings.AddObserver(observer.get());
+  window_selector_->delegate()->AddDelayedAnimationObserver(
+      std::move(observer));
+  widget_ptr->SetOpacity(0.f);
+}
+
 }  // namespace ash