Animate window control changes in TouchView

ash/frame/caption_buttons/frame_caption_button_container_view.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/frame/caption_buttons/frame_caption_button_container_view.h"
 
 #include <cmath>
+#include <map>

[flackr, 2014/05/08 19:02:21]

unused?

[jonross, 2014/05/08 21:15:40]

Cpplint, used outside my changed.

 
 #include "ash/ash_switches.h"
 #include "ash/frame/caption_buttons/alternate_frame_size_button.h"
 #include "ash/frame/caption_buttons/frame_caption_button.h"
 #include "ash/frame/caption_buttons/frame_maximize_button.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/shell.h"
 #include "grit/ui_strings.h"  // Accessibility names
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/point.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace ash {
 
 namespace {
 
+// Visual design parameters for animating the transition to maximize mode.
+// When the size button hides we delay sliding the minimize button into its
+// location. Also used to delay showing the size button so that the minimize
+// button slides out of that position.
+const int kAnimationDelay = 100;

[flackr, 2014/05/08 19:02:21]

Units?

[jonross, 2014/05/08 21:15:40]

Done.

+const int kMinimizeSlideDuration = 500;
+const int kSizeFadeDuration = 250;
+
 // Converts |point| from |src| to |dst| and hittests against |dst|.
 bool ConvertPointToViewAndHitTest(const views::View* src,
                                   const views::View* dst,
                                   const gfx::Point& point) {
   gfx::Point converted(point);
   views::View::ConvertPointToTarget(src, dst, &converted);
   return dst->HitTestPoint(converted);
 }
 
 }  // namespace
 
 // static
 const char FrameCaptionButtonContainerView::kViewClassName[] =
     "FrameCaptionButtonContainerView";
 
 FrameCaptionButtonContainerView::FrameCaptionButtonContainerView(
     views::Widget* frame,
     MinimizeAllowed minimize_allowed)
     : frame_(frame),
       minimize_button_(NULL),
       size_button_(NULL),
       close_button_(NULL) {
   bool alternate_style = switches::UseAlternateFrameCaptionButtonStyle();
 
+  SetPaintToLayer(true);
+  SetFillsBoundsOpaquely(false);
+
   // Insert the buttons left to right.
   minimize_button_ = new FrameCaptionButton(this, CAPTION_BUTTON_ICON_MINIMIZE);
   minimize_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_MINIMIZE));
   // Hide |minimize_button_| when using the non-alternate button style because
   // |size_button_| is capable of minimizing in this case.
   minimize_button_->SetVisible(
       minimize_allowed == MINIMIZE_ALLOWED &&
       (alternate_style || !frame_->widget_delegate()->CanMaximize()));
+  minimize_button_->SetPaintToLayer(true);
+  minimize_button_->SetFillsBoundsOpaquely(false);
   AddChildView(minimize_button_);
 
   if (alternate_style)
     size_button_ = new AlternateFrameSizeButton(this, frame, this);
   else
     size_button_ = new FrameMaximizeButton(this, frame);
   size_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_MAXIMIZE));
+  size_button_->SetPaintToLayer(true);
+  size_button_->SetFillsBoundsOpaquely(false);
   UpdateSizeButtonVisibility(false);
   AddChildView(size_button_);
 
   close_button_ = new FrameCaptionButton(this, CAPTION_BUTTON_ICON_CLOSE);
   close_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_CLOSE));
+  close_button_->SetPaintToLayer(true);
+  close_button_->SetFillsBoundsOpaquely(false);
   AddChildView(close_button_);
 }
 
 FrameCaptionButtonContainerView::~FrameCaptionButtonContainerView() {
 }
 
 FrameMaximizeButton*
 FrameCaptionButtonContainerView::GetOldStyleSizeButton() {
   return switches::UseAlternateFrameCaptionButtonStyle() ?
       NULL : static_cast<FrameMaximizeButton*>(size_button_);
@@ skipping 50 matching lines @@
 }
 
 void FrameCaptionButtonContainerView::UpdateSizeButtonVisibility(
     bool force_hidden) {
   // TODO(flackr): Refactor the Maximize Mode notifications. Currently
   // UpdateSizeButtonVisibilty requires a force_hidden parameter. This is
   // because Shell::IsMaximizeWindowManagerEnabled is still false at the
   // time when ShellObserver::OnMaximizeModeStarted is called. This prevents
   // this method from performing that check, and instead relies on the calling
   // code to tell it to force being hidden.
-  size_button_->SetVisible(
-      !force_hidden && frame_->widget_delegate()->CanMaximize());
+
+  bool visible = !force_hidden && frame_->widget_delegate()->CanMaximize();
+
+  // Turning visibility off prevents animations from rendering. Setting the
+  // size button visibility to false will occur after the animation.
+  if (visible)
+    size_button_->SetVisible(visible);
+
+  ui::ScopedLayerAnimationSettings settings(
+      size_button_->layer()->GetAnimator());
+  settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kSizeFadeDuration));
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+
+  if (visible) {
+    settings.SetTweenType(gfx::Tween::EASE_OUT);
+    // Delay fade in so that the minimize button has begun its sliding
+    // animation. For visual design.
+    size_button_->layer()->GetAnimator()->SchedulePauseForProperties(
+        base::TimeDelta::FromMilliseconds(kAnimationDelay),
+        ui::LayerAnimationElement::OPACITY);
+    size_button_->layer()->SetOpacity(1.0f);
+  } else {
+    settings.SetTweenType(gfx::Tween::EASE_IN);
+    settings.AddObserver(this);

[flackr, 2014/05/08 19:02:21]

nit: comment this will SetVisible(false) when animation is complete.

[jonross, 2014/05/08 21:15:40]

Done.

+    size_button_->layer()->SetOpacity(0.0f);

[flackr, 2014/05/08 19:02:21]

Also ->SetVisible(false);

[jonross, 2014/05/08 21:15:40]

Done.

+  }
 }
 
 gfx::Size FrameCaptionButtonContainerView::GetPreferredSize() {
   int width = 0;
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
     if (child->visible())
       width += child_at(i)->GetPreferredSize().width();
   }
   return gfx::Size(width, close_button_->GetPreferredSize().height());
 }
 
 void FrameCaptionButtonContainerView::Layout() {
-  int x = 0;
-  for (int i = 0; i < child_count(); ++i) {
+  scoped_ptr<ui::ScopedLayerAnimationSettings> animation;
+  int x = width();
+  for (int i = child_count() - 1; i >= 0; --i) {
     views::View* child = child_at(i);
-    if (!child->visible())
+    if (!child->visible() ||
+        (child == size_button_ && child->layer()->GetTargetOpacity() == 0.0f))

[flackr, 2014/05/08 19:02:21]

GetTargetVisibility. Try to avoid making this specific to size_button_, assume
any button could animate.

[jonross, 2014/05/08 21:15:40]

Done.

       continue;
 
     gfx::Size size = child->GetPreferredSize();
+    // Animate the minimize button if the size button is currently animating
+    // its visibility.
+    if (child == minimize_button_ &&
+        size_button_->layer()->GetAnimator()->is_animating()) {

[flackr, 2014/05/08 19:02:21]

This is awfully specific to the button that's going away and the button order.
Instead, if you're traversing from right to left, you could track if you've seen
a button which is animating and delay the movement of all buttons after it.

[jonross, 2014/05/08 21:15:40]

Done.

+      if (size_button_->layer()->GetTargetOpacity() == 1.0f) {
+        child->SetBounds(x, 0, size.width(), size.height());
+      } else {
+        // Delay sliding to where the size button was located. For visual
+        // design.
+        child->layer()->GetAnimator()->SchedulePauseForProperties(
+             base::TimeDelta::FromMilliseconds(kAnimationDelay),
+             ui::LayerAnimationElement::BOUNDS);
+      }
+
+      ui::ScopedLayerAnimationSettings* settings =
+          new ui::ScopedLayerAnimationSettings(child->layer()->GetAnimator());
+      settings->SetTransitionDuration(
+          base::TimeDelta::FromMilliseconds(kMinimizeSlideDuration));
+      settings->SetPreemptionStrategy(
+          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+      settings->SetTweenType(gfx::Tween::EASE_OUT);
+      animation.reset(settings);
+    }
+    x -= size.width();
     child->SetBounds(x, 0, size.width(), size.height());
-    x += size.width();
   }
 }
 
 const char* FrameCaptionButtonContainerView::GetClassName() const {
   return kViewClassName;
 }
 
 void FrameCaptionButtonContainerView::SetButtonIcon(FrameCaptionButton* button,
                                                     CaptionButtonIcon icon,
                                                     Animate animate) {
@@ skipping 31 matching lines @@
   }
 
   // Abort any animations of the button icons.
   SetButtonsToNormal(ANIMATE_NO);
 
   ash::UserMetricsAction action =
       ash::UMA_WINDOW_MAXIMIZE_BUTTON_CLICK_MINIMIZE;
   if (sender == minimize_button_) {
     frame_->Minimize();
   } else if (sender == size_button_) {
-    if (frame_->IsFullscreen()) { // Can be clicked in immersive fullscreen.
+    if (frame_->IsFullscreen()) {  // Can be clicked in immersive fullscreen.

[flackr, 2014/05/08 19:02:21]

Why two spaces before comment?

[jonross, 2014/05/08 21:15:40]

cpplint marked this.

       frame_->SetFullscreen(false);
       action = ash::UMA_WINDOW_MAXIMIZE_BUTTON_CLICK_EXIT_FULLSCREEN;
     } else if (frame_->IsMaximized()) {
       frame_->Restore();
       action = ash::UMA_WINDOW_MAXIMIZE_BUTTON_CLICK_RESTORE;
     } else {
       frame_->Maximize();
       action = ash::UMA_WINDOW_MAXIMIZE_BUTTON_CLICK_MAXIMIZE;
     }
-  } else if(sender == close_button_) {
+  } else if (sender == close_button_) {
     frame_->Close();
     action = ash::UMA_WINDOW_CLOSE_BUTTON_CLICK;
   } else {
     return;
   }
   ash::Shell::GetInstance()->metrics()->RecordUserMetricsAction(action);
 }
 
 bool FrameCaptionButtonContainerView::IsMinimizeButtonVisible() const {
   return minimize_button_->visible();
@@ skipping 56 matching lines @@
     FrameCaptionButton* button = buttons[i];
     views::Button::ButtonState new_state = views::Button::STATE_NORMAL;
     if (button == to_hover)
       new_state = views::Button::STATE_HOVERED;
     else if (button == to_press)
       new_state = views::Button::STATE_PRESSED;
     button->SetState(new_state);
   }
 }
 
+void FrameCaptionButtonContainerView::OnImplicitAnimationsCompleted() {
+  size_button_->SetVisible(false);
+  // TODO(jonross): currently we need to delay telling the parent about the
+  // size change from visibility. When the size changes this forces a relayout
+  // and we want to animate both the bounds of FrameCaptionButtonContainerView
+  // along with that of its children. However when the parent is currently
+  // having its bounds changed this leads to strange animations where this view
+  // renders outside of its parents. Create a more specific animation where

[flackr, 2014/05/08 19:02:21]

Can we avoid this by animating Translate transforms to the correct location but
having the bounds set immediately?

+  // height and y are immediately fixed, and where we only animate width and x.
+  PreferredSizeChanged();
+}
+
 FrameCaptionButtonContainerView::ButtonIconIds::ButtonIconIds()
     : icon_image_id(-1),
       inactive_icon_image_id(-1),
       hovered_background_image_id(-1),
       pressed_background_image_id(-1) {
 }
 
 FrameCaptionButtonContainerView::ButtonIconIds::ButtonIconIds(
     int icon_id,
     int inactive_icon_id,
     int hovered_background_id,
     int pressed_background_id)
     : icon_image_id(icon_id),
       inactive_icon_image_id(inactive_icon_id),
       hovered_background_image_id(hovered_background_id),
       pressed_background_image_id(pressed_background_id) {
 }
 
 FrameCaptionButtonContainerView::ButtonIconIds::~ButtonIconIds() {
 }
 
 }  // namespace ash