ash/wm/window_animations.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/wm/window_animations.h"
   6
   7 #include <math.h>
   8
   9 #include <algorithm>
  10 #include <vector>
  11
  12 #include "ash/screen_util.h"
  13 #include "ash/shelf/shelf.h"
  14 #include "ash/shelf/shelf_layout_manager.h"
  15 #include "ash/shelf/shelf_widget.h"
  16 #include "ash/shell.h"
  17 #include "ash/wm/window_util.h"
  18 #include "ash/wm/workspace_controller.h"
  19 #include "base/command_line.h"
  20 #include "base/compiler_specific.h"
  21 #include "base/logging.h"
  22 #include "base/message_loop/message_loop.h"
  23 #include "base/stl_util.h"
  24 #include "base/time/time.h"
  25 #include "ui/aura/client/aura_constants.h"
  26 #include "ui/aura/window.h"
  27 #include "ui/aura/window_observer.h"
  28 #include "ui/aura/window_property.h"
  29 #include "ui/compositor/compositor_observer.h"
  30 #include "ui/compositor/layer.h"
  31 #include "ui/compositor/layer_animation_observer.h"
  32 #include "ui/compositor/layer_animation_sequence.h"
  33 #include "ui/compositor/layer_animator.h"
  34 #include "ui/compositor/layer_tree_owner.h"
  35 #include "ui/compositor/scoped_layer_animation_settings.h"
  36 #include "ui/gfx/interpolated_transform.h"
  37 #include "ui/gfx/screen.h"
  38 #include "ui/gfx/vector3d_f.h"
  39 #include "ui/views/view.h"
  40 #include "ui/views/widget/widget.h"
  41 #include "ui/wm/core/window_util.h"
  42
  43 namespace ash {
  44 namespace {
  45 const int kLayerAnimationsForMinimizeDurationMS = 200;
  46
  47 // Durations for the cross-fade animation, in milliseconds.
  48 const float kCrossFadeDurationMinMs = 200.f;
  49 const float kCrossFadeDurationMaxMs = 400.f;
  50
  51 // Durations for the brightness/grayscale fade animation, in milliseconds.
  52 const int kBrightnessGrayscaleFadeDurationMs = 1000;
  53
  54 // Brightness/grayscale values for hide/show window animations.
  55 const float kWindowAnimation_HideBrightnessGrayscale = 1.f;
  56 const float kWindowAnimation_ShowBrightnessGrayscale = 0.f;
  57
  58 const float kWindowAnimation_HideOpacity = 0.f;
  59 const float kWindowAnimation_ShowOpacity = 1.f;
  60
  61 // Scales for AshWindow above/below current workspace.
  62 const float kLayerScaleAboveSize = 1.1f;
  63 const float kLayerScaleBelowSize = .9f;
  64
  65 int64 Round64(float f) {
  66   return static_cast<int64>(f + 0.5f);
  67 }
  68
  69 base::TimeDelta GetCrossFadeDuration(aura::Window* window,
  70                                      const gfx::RectF& old_bounds,
  71                                      const gfx::Rect& new_bounds) {
  72   if (::wm::WindowAnimationsDisabled(window))
  73     return base::TimeDelta();
  74
  75   int old_area = static_cast<int>(old_bounds.width() * old_bounds.height());
  76   int new_area = new_bounds.width() * new_bounds.height();
  77   int max_area = std::max(old_area, new_area);
  78   // Avoid divide by zero.
  79   if (max_area == 0)
  80     return base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS);
  81
  82   int delta_area = std::abs(old_area - new_area);
  83   // If the area didn't change, the animation is instantaneous.
  84   if (delta_area == 0)
  85     return base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS);
  86
  87   float factor =
  88       static_cast<float>(delta_area) / static_cast<float>(max_area);
  89   const float kRange = kCrossFadeDurationMaxMs - kCrossFadeDurationMinMs;
  90   return base::TimeDelta::FromMilliseconds(
  91       Round64(kCrossFadeDurationMinMs + (factor * kRange)));
  92 }
  93
  94 }  // namespace
  95
  96 const int kCrossFadeDurationMS = 200;
  97
  98 void AddLayerAnimationsForMinimize(aura::Window* window, bool show) {
  99   // Recalculate the transform at restore time since the launcher item may have
 100   // moved while the window was minimized.
 101   gfx::Rect bounds = window->bounds();
 102   gfx::Rect target_bounds = GetMinimizeAnimationTargetBoundsInScreen(window);
 103   target_bounds =
 104       ScreenUtil::ConvertRectFromScreen(window->parent(), target_bounds);
 105
 106   float scale_x = static_cast<float>(target_bounds.width()) / bounds.width();
 107   float scale_y = static_cast<float>(target_bounds.height()) / bounds.height();
 108
 109   scoped_ptr<ui::InterpolatedTransform> scale(
 110       new ui::InterpolatedScale(gfx::Point3F(1, 1, 1),
 111                                 gfx::Point3F(scale_x, scale_y, 1)));
 112
 113   scoped_ptr<ui::InterpolatedTransform> translation(
 114       new ui::InterpolatedTranslation(
 115           gfx::Point(),
 116           gfx::Point(target_bounds.x() - bounds.x(),
 117                      target_bounds.y() - bounds.y())));
 118
 119   scale->SetChild(translation.release());
 120   scale->SetReversed(show);
 121
 122   base::TimeDelta duration = window->layer()->GetAnimator()->
 123       GetTransitionDuration();
 124
 125   scoped_ptr<ui::LayerAnimationElement> transition(
 126       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
 127           scale.release(), duration));
 128
 129   transition->set_tween_type(
 130       show ? gfx::Tween::EASE_IN : gfx::Tween::EASE_IN_OUT);
 131
 132   window->layer()->GetAnimator()->ScheduleAnimation(
 133       new ui::LayerAnimationSequence(transition.release()));
 134
 135   // When hiding a window, turn off blending until the animation is 3 / 4 done
 136   // to save bandwidth and reduce jank.
 137   if (!show) {
 138     window->layer()->GetAnimator()->SchedulePauseForProperties(
 139         (duration * 3) / 4, ui::LayerAnimationElement::OPACITY);
 140   }
 141
 142   // Fade in and out quickly when the window is small to reduce jank.
 143   float opacity = show ? 1.0f : 0.0f;
 144   window->layer()->GetAnimator()->ScheduleAnimation(
 145       new ui::LayerAnimationSequence(
 146           ui::LayerAnimationElement::CreateOpacityElement(
 147               opacity, duration / 4)));
 148
 149   // Reset the transform to identity when the minimize animation is completed.
 150   window->layer()->GetAnimator()->ScheduleAnimation(
 151       new ui::LayerAnimationSequence(
 152           ui::LayerAnimationElement::CreateTransformElement(
 153               gfx::Transform(),
 154               base::TimeDelta())));
 155 }
 156
 157 void AnimateShowWindow_Minimize(aura::Window* window) {
 158   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 159   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
 160   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
 161       kLayerAnimationsForMinimizeDurationMS);
 162   settings.SetTransitionDuration(duration);
 163   AddLayerAnimationsForMinimize(window, true);
 164
 165   // Now that the window has been restored, we need to clear its animation style
 166   // to default so that normal animation applies.
 167   ::wm::SetWindowVisibilityAnimationType(
 168       window, ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 169 }
 170
 171 void AnimateHideWindow_Minimize(aura::Window* window) {
 172   // Property sets within this scope will be implicitly animated.
 173   ::wm::ScopedHidingAnimationSettings hiding_settings(window);
 174   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
 175       kLayerAnimationsForMinimizeDurationMS);
 176   hiding_settings.layer_animation_settings()->SetTransitionDuration(duration);
 177   window->layer()->SetVisible(false);
 178
 179   AddLayerAnimationsForMinimize(window, false);
 180 }
 181
 182 void AnimateShowHideWindowCommon_BrightnessGrayscale(aura::Window* window,
 183                                                      bool show) {
 184   float start_value, end_value;
 185   if (show) {
 186     start_value = kWindowAnimation_HideBrightnessGrayscale;
 187     end_value = kWindowAnimation_ShowBrightnessGrayscale;
 188   } else {
 189     start_value = kWindowAnimation_ShowBrightnessGrayscale;
 190     end_value = kWindowAnimation_HideBrightnessGrayscale;
 191   }
 192
 193   window->layer()->SetLayerBrightness(start_value);
 194   window->layer()->SetLayerGrayscale(start_value);
 195   if (show) {
 196     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
 197     window->layer()->SetVisible(true);
 198   }
 199
 200   base::TimeDelta duration =
 201       base::TimeDelta::FromMilliseconds(kBrightnessGrayscaleFadeDurationMs);
 202
 203   if (show) {
 204     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
 205     window->layer()->GetAnimator()->
 206         ScheduleTogether(
 207             CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
 208   } else {
 209     ::wm::ScopedHidingAnimationSettings hiding_settings(window);
 210     window->layer()->GetAnimator()->
 211         ScheduleTogether(
 212             CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
 213     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 214     window->layer()->SetVisible(false);
 215   }
 216 }
 217
 218 void AnimateShowWindow_BrightnessGrayscale(aura::Window* window) {
 219   AnimateShowHideWindowCommon_BrightnessGrayscale(window, true);
 220 }
 221
 222 void AnimateHideWindow_BrightnessGrayscale(aura::Window* window) {
 223   AnimateShowHideWindowCommon_BrightnessGrayscale(window, false);
 224 }
 225
 226 bool AnimateShowWindow(aura::Window* window) {
 227   if (!::wm::HasWindowVisibilityAnimationTransition(
 228           window, ::wm::ANIMATE_SHOW)) {
 229     return false;
 230   }
 231
 232   switch (::wm::GetWindowVisibilityAnimationType(window)) {
 233     case WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
 234       AnimateShowWindow_Minimize(window);
 235       return true;
 236     case WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
 237       AnimateShowWindow_BrightnessGrayscale(window);
 238       return true;
 239     default:
 240       NOTREACHED();
 241       return false;
 242   }
 243 }
 244
 245 bool AnimateHideWindow(aura::Window* window) {
 246   if (!::wm::HasWindowVisibilityAnimationTransition(
 247           window, ::wm::ANIMATE_HIDE)) {
 248     return false;
 249   }
 250
 251   switch (::wm::GetWindowVisibilityAnimationType(window)) {
 252     case WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
 253       AnimateHideWindow_Minimize(window);
 254       return true;
 255     case WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
 256       AnimateHideWindow_BrightnessGrayscale(window);
 257       return true;
 258     default:
 259       NOTREACHED();
 260       return false;
 261   }
 262 }
 263
 264 // Observer for a window cross-fade animation. If either the window closes or
 265 // the layer's animation completes or compositing is aborted due to GPU crash,
 266 // it deletes the layer and removes itself as an observer.
 267 class CrossFadeObserver : public ui::CompositorObserver,
 268                           public aura::WindowObserver,
 269                           public ui::ImplicitAnimationObserver {
 270  public:
 271   // Observes |window| for destruction, but does not take ownership.
 272   // Takes ownership of |layer| and its child layers.
 273   CrossFadeObserver(aura::Window* window,
 274                     scoped_ptr<ui::LayerTreeOwner> layer_owner)
 275       : window_(window),
 276         layer_owner_(layer_owner.Pass()) {
 277     window_->AddObserver(this);
 278     layer_owner_->root()->GetCompositor()->AddObserver(this);
 279   }
 280   virtual ~CrossFadeObserver() {
 281     window_->RemoveObserver(this);
 282     window_ = NULL;
 283     layer_owner_->root()->GetCompositor()->RemoveObserver(this);
 284   }
 285
 286   // ui::CompositorObserver overrides:
 287   virtual void OnCompositingDidCommit(ui::Compositor* compositor) override {
 288   }
 289   virtual void OnCompositingStarted(ui::Compositor* compositor,
 290                                     base::TimeTicks start_time) override {
 291   }
 292   virtual void OnCompositingEnded(ui::Compositor* compositor) override {
 293   }
 294   virtual void OnCompositingAborted(ui::Compositor* compositor) override {
 295     // Triggers OnImplicitAnimationsCompleted() to be called and deletes us.
 296     layer_owner_->root()->GetAnimator()->StopAnimating();
 297   }
 298   virtual void OnCompositingLockStateChanged(
 299       ui::Compositor* compositor) override {
 300   }
 301
 302   // aura::WindowObserver overrides:
 303   virtual void OnWindowDestroying(aura::Window* window) override {
 304     // Triggers OnImplicitAnimationsCompleted() to be called and deletes us.
 305     layer_owner_->root()->GetAnimator()->StopAnimating();
 306   }
 307   virtual void OnWindowRemovingFromRootWindow(aura::Window* window,
 308                                               aura::Window* new_root) override {
 309     layer_owner_->root()->GetAnimator()->StopAnimating();
 310   }
 311
 312   // ui::ImplicitAnimationObserver overrides:
 313   virtual void OnImplicitAnimationsCompleted() override {
 314     delete this;
 315   }
 316
 317  private:
 318   aura::Window* window_;  // not owned
 319   scoped_ptr<ui::LayerTreeOwner> layer_owner_;
 320
 321   DISALLOW_COPY_AND_ASSIGN(CrossFadeObserver);
 322 };
 323
 324 base::TimeDelta CrossFadeAnimation(
 325     aura::Window* window,
 326     scoped_ptr<ui::LayerTreeOwner> old_layer_owner,
 327     gfx::Tween::Type tween_type) {
 328   DCHECK(old_layer_owner->root());
 329   const gfx::Rect old_bounds(old_layer_owner->root()->bounds());
 330   gfx::RectF old_transformed_bounds(old_bounds);
 331   gfx::Transform old_transform(old_layer_owner->root()->transform());
 332   gfx::Transform old_transform_in_root;
 333   old_transform_in_root.Translate(old_bounds.x(), old_bounds.y());
 334   old_transform_in_root.PreconcatTransform(old_transform);
 335   old_transform_in_root.Translate(-old_bounds.x(), -old_bounds.y());
 336   old_transform_in_root.TransformRect(&old_transformed_bounds);
 337   const gfx::Rect new_bounds(window->bounds());
 338   const bool old_on_top = (old_bounds.width() > new_bounds.width());
 339
 340   // Shorten the animation if there's not much visual movement.
 341   const base::TimeDelta duration = GetCrossFadeDuration(window,
 342       old_transformed_bounds, new_bounds);
 343
 344   // Scale up the old layer while translating to new position.
 345   {
 346     ui::Layer* old_layer = old_layer_owner->root();
 347     old_layer->GetAnimator()->StopAnimating();
 348     old_layer->SetTransform(old_transform);
 349     ui::ScopedLayerAnimationSettings settings(old_layer->GetAnimator());
 350
 351     // Animation observer owns the old layer and deletes itself.
 352     settings.AddObserver(new CrossFadeObserver(window, old_layer_owner.Pass()));
 353     settings.SetTransitionDuration(duration);
 354     settings.SetTweenType(tween_type);
 355     gfx::Transform out_transform;
 356     float scale_x = static_cast<float>(new_bounds.width()) /
 357         static_cast<float>(old_bounds.width());
 358     float scale_y = static_cast<float>(new_bounds.height()) /
 359         static_cast<float>(old_bounds.height());
 360     out_transform.Translate(new_bounds.x() - old_bounds.x(),
 361                             new_bounds.y() - old_bounds.y());
 362     out_transform.Scale(scale_x, scale_y);
 363     old_layer->SetTransform(out_transform);
 364     if (old_on_top) {
 365       // The old layer is on top, and should fade out.  The new layer below will
 366       // stay opaque to block the desktop.
 367       old_layer->SetOpacity(kWindowAnimation_HideOpacity);
 368     }
 369     // In tests |old_layer| is deleted here, as animations have zero duration.
 370     old_layer = NULL;
 371   }
 372
 373   // Set the new layer's current transform, such that the user sees a scaled
 374   // version of the window with the original bounds at the original position.
 375   gfx::Transform in_transform;
 376   const float scale_x = old_transformed_bounds.width() /
 377       static_cast<float>(new_bounds.width());
 378   const float scale_y = old_transformed_bounds.height() /
 379       static_cast<float>(new_bounds.height());
 380   in_transform.Translate(old_transformed_bounds.x() - new_bounds.x(),
 381                          old_transformed_bounds.y() - new_bounds.y());
 382   in_transform.Scale(scale_x, scale_y);
 383   window->layer()->SetTransform(in_transform);
 384   if (!old_on_top) {
 385     // The new layer is on top and should fade in.  The old layer below will
 386     // stay opaque and block the desktop.
 387     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 388   }
 389   {
 390     // Animate the new layer to the identity transform, so the window goes to
 391     // its newly set bounds.
 392     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
 393     settings.SetTransitionDuration(duration);
 394     settings.SetTweenType(tween_type);
 395     window->layer()->SetTransform(gfx::Transform());
 396     if (!old_on_top) {
 397       // New layer is on top, fade it in.
 398       window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
 399     }
 400   }
 401   return duration;
 402 }
 403
 404 bool AnimateOnChildWindowVisibilityChanged(aura::Window* window, bool visible) {
 405   if (::wm::WindowAnimationsDisabled(window))
 406     return false;
 407
 408   // Attempt to run CoreWm supplied animation types.
 409   if (::wm::AnimateOnChildWindowVisibilityChanged(window, visible))
 410     return true;
 411
 412   // Otherwise try to run an Ash-specific animation.
 413   if (visible)
 414     return AnimateShowWindow(window);
 415   // Don't start hiding the window again if it's already being hidden.
 416   return window->layer()->GetTargetOpacity() != 0.0f &&
 417       AnimateHideWindow(window);
 418 }
 419
 420 std::vector<ui::LayerAnimationSequence*>
 421 CreateBrightnessGrayscaleAnimationSequence(float target_value,
 422                                            base::TimeDelta duration) {
 423   gfx::Tween::Type animation_type = gfx::Tween::EASE_OUT;
 424   scoped_ptr<ui::LayerAnimationSequence> brightness_sequence(
 425       new ui::LayerAnimationSequence());
 426   scoped_ptr<ui::LayerAnimationSequence> grayscale_sequence(
 427       new ui::LayerAnimationSequence());
 428
 429   scoped_ptr<ui::LayerAnimationElement> brightness_element(
 430       ui::LayerAnimationElement::CreateBrightnessElement(
 431           target_value, duration));
 432   brightness_element->set_tween_type(animation_type);
 433   brightness_sequence->AddElement(brightness_element.release());
 434
 435   scoped_ptr<ui::LayerAnimationElement> grayscale_element(
 436       ui::LayerAnimationElement::CreateGrayscaleElement(
 437           target_value, duration));
 438   grayscale_element->set_tween_type(animation_type);
 439   grayscale_sequence->AddElement(grayscale_element.release());
 440
 441   std::vector<ui::LayerAnimationSequence*> animations;
 442   animations.push_back(brightness_sequence.release());
 443   animations.push_back(grayscale_sequence.release());
 444
 445   return animations;
 446 }
 447
 448 // Returns scale related to the specified AshWindowScaleType.
 449 void SetTransformForScaleAnimation(ui::Layer* layer,
 450                                    LayerScaleAnimationDirection type) {
 451   const float scale =
 452       type == LAYER_SCALE_ANIMATION_ABOVE ? kLayerScaleAboveSize :
 453           kLayerScaleBelowSize;
 454   gfx::Transform transform;
 455   transform.Translate(-layer->bounds().width() * (scale - 1.0f) / 2,
 456                       -layer->bounds().height() * (scale - 1.0f) / 2);
 457   transform.Scale(scale, scale);
 458   layer->SetTransform(transform);
 459 }
 460
 461 gfx::Rect GetMinimizeAnimationTargetBoundsInScreen(aura::Window* window) {
 462   Shelf* shelf = Shelf::ForWindow(window);
 463   // Shelf is created lazily and can be NULL.
 464   if (!shelf)
 465     return gfx::Rect();
 466   gfx::Rect item_rect = shelf->GetScreenBoundsOfItemIconForWindow(window);
 467
 468   // The launcher item is visible and has an icon.
 469   if (!item_rect.IsEmpty())
 470     return item_rect;
 471
 472   // If both the icon width and height are 0, then there is no icon in the
 473   // launcher for |window|. If the launcher is auto hidden, one of the height or
 474   // width will be 0 but the position in the launcher and the major dimension
 475   // are still reported correctly and the window can be animated to the launcher
 476   // item's light bar.
 477   ShelfLayoutManager* layout_manager = ShelfLayoutManager::ForShelf(window);
 478   if (item_rect.width() != 0 || item_rect.height() != 0) {
 479     if (layout_manager->visibility_state() == SHELF_AUTO_HIDE) {
 480       gfx::Rect shelf_bounds = shelf->shelf_widget()->GetWindowBoundsInScreen();
 481       switch (layout_manager->GetAlignment()) {
 482         case SHELF_ALIGNMENT_BOTTOM:
 483           item_rect.set_y(shelf_bounds.y());
 484           break;
 485         case SHELF_ALIGNMENT_LEFT:
 486           item_rect.set_x(shelf_bounds.right());
 487           break;
 488         case SHELF_ALIGNMENT_RIGHT:
 489           item_rect.set_x(shelf_bounds.x());
 490           break;
 491         case SHELF_ALIGNMENT_TOP:
 492           item_rect.set_y(shelf_bounds.bottom());
 493           break;
 494       }
 495       return item_rect;
 496     }
 497   }
 498
 499   // Coming here, there is no visible icon of that shelf item and we zoom back
 500   // to the location of the application launcher (which is fixed as first item
 501   // of the shelf).
 502   gfx::Rect work_area =
 503       Shell::GetScreen()->GetDisplayNearestWindow(window).work_area();
 504   int ltr_adjusted_x = base::i18n::IsRTL() ? work_area.right() : work_area.x();
 505   switch (layout_manager->GetAlignment()) {
 506     case SHELF_ALIGNMENT_BOTTOM:
 507       return gfx::Rect(ltr_adjusted_x, work_area.bottom(), 0, 0);
 508     case SHELF_ALIGNMENT_TOP:
 509       return gfx::Rect(ltr_adjusted_x, work_area.y(), 0, 0);
 510     case SHELF_ALIGNMENT_LEFT:
 511       return gfx::Rect(work_area.x(), work_area.y(), 0, 0);
 512     case SHELF_ALIGNMENT_RIGHT:
 513       return gfx::Rect(work_area.right(), work_area.y(), 0, 0);
 514   }
 515   NOTREACHED();
 516   return gfx::Rect();
 517 }
 518
 519 }  // namespace ash