src/ui/wm/core/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 "ui/wm/core/window_animations.h"
   6
   7 #include <math.h>
   8
   9 #include <algorithm>
  10 #include <vector>
  11
  12 #include "base/command_line.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/logging.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/stl_util.h"
  17 #include "base/time/time.h"
  18 #include "ui/aura/client/aura_constants.h"
  19 #include "ui/aura/window.h"
  20 #include "ui/aura/window_delegate.h"
  21 #include "ui/aura/window_observer.h"
  22 #include "ui/aura/window_property.h"
  23 #include "ui/compositor/compositor_observer.h"
  24 #include "ui/compositor/layer.h"
  25 #include "ui/compositor/layer_animation_observer.h"
  26 #include "ui/compositor/layer_animation_sequence.h"
  27 #include "ui/compositor/layer_animator.h"
  28 #include "ui/compositor/layer_tree_owner.h"
  29 #include "ui/compositor/scoped_layer_animation_settings.h"
  30 #include "ui/gfx/animation/animation.h"
  31 #include "ui/gfx/interpolated_transform.h"
  32 #include "ui/gfx/rect_conversions.h"
  33 #include "ui/gfx/screen.h"
  34 #include "ui/gfx/vector2d.h"
  35 #include "ui/gfx/vector3d_f.h"
  36 #include "ui/wm/core/window_util.h"
  37 #include "ui/wm/core/wm_core_switches.h"
  38 #include "ui/wm/public/animation_host.h"
  39
  40 DECLARE_WINDOW_PROPERTY_TYPE(int)
  41 DECLARE_WINDOW_PROPERTY_TYPE(wm::WindowVisibilityAnimationType)
  42 DECLARE_WINDOW_PROPERTY_TYPE(wm::WindowVisibilityAnimationTransition)
  43 DECLARE_WINDOW_PROPERTY_TYPE(float)
  44 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(WM_EXPORT, bool)
  45
  46 namespace wm {
  47 namespace {
  48 const float kWindowAnimation_Vertical_TranslateY = 15.f;
  49
  50 // A base class for hiding animation observer which has two roles:
  51 // 1) Notifies AnimationHost at the end of hiding animation.
  52 // 2) Detaches the window's layers for hiding animation and deletes
  53 // them upon completion of the animation. This is necessary to a)
  54 // ensure that the animation continues in the event of the window being
  55 // deleted, and b) to ensure that the animation is visible even if the
  56 // window gets restacked below other windows when focus or activation
  57 // changes.
  58 // The subclass will determine when the animation is completed.
  59 class HidingWindowAnimationObserverBase : public aura::WindowObserver {
  60  public:
  61   HidingWindowAnimationObserverBase(aura::Window* window) : window_(window) {
  62     window_->AddObserver(this);
  63   }
  64   virtual ~HidingWindowAnimationObserverBase() {
  65     if (window_)
  66       window_->RemoveObserver(this);
  67   }
  68
  69   // aura::WindowObserver:
  70   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
  71     DCHECK_EQ(window, window_);
  72     WindowInvalid();
  73   }
  74
  75   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
  76     DCHECK_EQ(window, window_);
  77     WindowInvalid();
  78   }
  79
  80   // Detach the current layers and create new layers for |window_|.
  81   // Stack the original layers above |window_| and its transient
  82   // children.  If the window has transient children, the original
  83   // layers will be moved above the top most transient child so that
  84   // activation change does not put the window above the animating
  85   // layer.
  86   void DetachAndRecreateLayers() {
  87     layer_owner_ = RecreateLayers(window_);
  88     if (window_->parent()) {
  89       const aura::Window::Windows& transient_children =
  90           GetTransientChildren(window_);
  91       aura::Window::Windows::const_iterator iter =
  92           std::find(window_->parent()->children().begin(),
  93                     window_->parent()->children().end(),
  94                     window_);
  95       DCHECK(iter != window_->parent()->children().end());
  96       aura::Window* topmost_transient_child = NULL;
  97       for (++iter; iter != window_->parent()->children().end(); ++iter) {
  98         if (std::find(transient_children.begin(),
  99                       transient_children.end(),
 100                       *iter) != transient_children.end()) {
 101           topmost_transient_child = *iter;
 102         }
 103       }
 104       if (topmost_transient_child) {
 105         window_->parent()->layer()->StackAbove(
 106             layer_owner_->root(), topmost_transient_child->layer());
 107       }
 108     }
 109   }
 110
 111  protected:
 112   // Invoked when the hiding animation is completed.  It will delete
 113   // 'this', and no operation should be made on this object after this
 114   // point.
 115   void OnAnimationCompleted() {
 116     // Window may have been destroyed by this point.
 117     if (window_) {
 118       aura::client::AnimationHost* animation_host =
 119           aura::client::GetAnimationHost(window_);
 120       if (animation_host)
 121         animation_host->OnWindowHidingAnimationCompleted();
 122       window_->RemoveObserver(this);
 123     }
 124     delete this;
 125   }
 126
 127  private:
 128   // Invoked when the window is destroyed (or destroying).
 129   void WindowInvalid() {
 130     layer_owner_->root()->SuppressPaint();
 131
 132     window_->RemoveObserver(this);
 133     window_ = NULL;
 134   }
 135
 136   aura::Window* window_;
 137
 138   // The owner of detached layers.
 139   scoped_ptr<ui::LayerTreeOwner> layer_owner_;
 140
 141   DISALLOW_COPY_AND_ASSIGN(HidingWindowAnimationObserverBase);
 142 };
 143
 144 }  // namespace
 145
 146 DEFINE_WINDOW_PROPERTY_KEY(int,
 147                            kWindowVisibilityAnimationTypeKey,
 148                            WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 149 DEFINE_WINDOW_PROPERTY_KEY(int, kWindowVisibilityAnimationDurationKey, 0);
 150 DEFINE_WINDOW_PROPERTY_KEY(WindowVisibilityAnimationTransition,
 151                            kWindowVisibilityAnimationTransitionKey,
 152                            ANIMATE_BOTH);
 153 DEFINE_WINDOW_PROPERTY_KEY(float,
 154                            kWindowVisibilityAnimationVerticalPositionKey,
 155                            kWindowAnimation_Vertical_TranslateY);
 156
 157 // A HidingWindowAnimationObserver that deletes observer and detached
 158 // layers upon the completion of the implicit animation.
 159 class ImplicitHidingWindowAnimationObserver
 160     : public HidingWindowAnimationObserverBase,
 161       public ui::ImplicitAnimationObserver {
 162  public:
 163   ImplicitHidingWindowAnimationObserver(
 164       aura::Window* window,
 165       ui::ScopedLayerAnimationSettings* settings);
 166   virtual ~ImplicitHidingWindowAnimationObserver() {}
 167
 168   // ui::ImplicitAnimationObserver:
 169   virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 170
 171  private:
 172   DISALLOW_COPY_AND_ASSIGN(ImplicitHidingWindowAnimationObserver);
 173 };
 174
 175 namespace {
 176
 177 const int kDefaultAnimationDurationForMenuMS = 150;
 178
 179 const float kWindowAnimation_HideOpacity = 0.f;
 180 const float kWindowAnimation_ShowOpacity = 1.f;
 181 const float kWindowAnimation_TranslateFactor = 0.5f;
 182 const float kWindowAnimation_ScaleFactor = .95f;
 183
 184 const int kWindowAnimation_Rotate_DurationMS = 180;
 185 const int kWindowAnimation_Rotate_OpacityDurationPercent = 90;
 186 const float kWindowAnimation_Rotate_TranslateY = -20.f;
 187 const float kWindowAnimation_Rotate_PerspectiveDepth = 500.f;
 188 const float kWindowAnimation_Rotate_DegreesX = 5.f;
 189 const float kWindowAnimation_Rotate_ScaleFactor = .99f;
 190
 191 const float kWindowAnimation_Bounce_Scale = 1.02f;
 192 const int kWindowAnimation_Bounce_DurationMS = 180;
 193 const int kWindowAnimation_Bounce_GrowShrinkDurationPercent = 40;
 194
 195 base::TimeDelta GetWindowVisibilityAnimationDuration(
 196     const aura::Window& window) {
 197   int duration =
 198       window.GetProperty(kWindowVisibilityAnimationDurationKey);
 199   if (duration == 0 && window.type() == ui::wm::WINDOW_TYPE_MENU) {
 200     return base::TimeDelta::FromMilliseconds(
 201         kDefaultAnimationDurationForMenuMS);
 202   }
 203   return base::TimeDelta::FromInternalValue(duration);
 204 }
 205
 206 // Gets/sets the WindowVisibilityAnimationType associated with a window.
 207 // TODO(beng): redundant/fold into method on public api?
 208 int GetWindowVisibilityAnimationType(aura::Window* window) {
 209   int type = window->GetProperty(kWindowVisibilityAnimationTypeKey);
 210   if (type == WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT) {
 211     return (window->type() == ui::wm::WINDOW_TYPE_MENU ||
 212             window->type() == ui::wm::WINDOW_TYPE_TOOLTIP)
 213                ? WINDOW_VISIBILITY_ANIMATION_TYPE_FADE
 214                : WINDOW_VISIBILITY_ANIMATION_TYPE_DROP;
 215   }
 216   return type;
 217 }
 218
 219 void GetTransformRelativeToRoot(ui::Layer* layer, gfx::Transform* transform) {
 220   const ui::Layer* root = layer;
 221   while (root->parent())
 222     root = root->parent();
 223   layer->GetTargetTransformRelativeTo(root, transform);
 224 }
 225
 226 gfx::Rect GetLayerWorldBoundsAfterTransform(ui::Layer* layer,
 227                                             const gfx::Transform& transform) {
 228   gfx::Transform in_world = transform;
 229   GetTransformRelativeToRoot(layer, &in_world);
 230
 231   gfx::RectF transformed = layer->bounds();
 232   in_world.TransformRect(&transformed);
 233
 234   return gfx::ToEnclosingRect(transformed);
 235 }
 236
 237 // Augment the host window so that the enclosing bounds of the full
 238 // animation will fit inside of it.
 239 void AugmentWindowSize(aura::Window* window,
 240                        const gfx::Transform& end_transform) {
 241   aura::client::AnimationHost* animation_host =
 242       aura::client::GetAnimationHost(window);
 243   if (!animation_host)
 244     return;
 245
 246   const gfx::Rect& world_at_start = window->bounds();
 247   gfx::Rect world_at_end =
 248       GetLayerWorldBoundsAfterTransform(window->layer(), end_transform);
 249   gfx::Rect union_in_window_space =
 250       gfx::UnionRects(world_at_start, world_at_end);
 251
 252   // Calculate the top left and bottom right deltas to be added to the window
 253   // bounds.
 254   gfx::Vector2d top_left_delta(world_at_start.x() - union_in_window_space.x(),
 255                                world_at_start.y() - union_in_window_space.y());
 256
 257   gfx::Vector2d bottom_right_delta(
 258       union_in_window_space.x() + union_in_window_space.width() -
 259           (world_at_start.x() + world_at_start.width()),
 260       union_in_window_space.y() + union_in_window_space.height() -
 261           (world_at_start.y() + world_at_start.height()));
 262
 263   DCHECK(top_left_delta.x() >= 0 && top_left_delta.y() >= 0 &&
 264          bottom_right_delta.x() >= 0 && bottom_right_delta.y() >= 0);
 265
 266   animation_host->SetHostTransitionOffsets(top_left_delta, bottom_right_delta);
 267 }
 268
 269 // Shows a window using an animation, animating its opacity from 0.f to 1.f,
 270 // its visibility to true, and its transform from |start_transform| to
 271 // |end_transform|.
 272 void AnimateShowWindowCommon(aura::Window* window,
 273                              const gfx::Transform& start_transform,
 274                              const gfx::Transform& end_transform) {
 275   AugmentWindowSize(window, end_transform);
 276
 277   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 278   window->layer()->SetTransform(start_transform);
 279   window->layer()->SetVisible(true);
 280
 281   {
 282     // Property sets within this scope will be implicitly animated.
 283     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
 284     base::TimeDelta duration = GetWindowVisibilityAnimationDuration(*window);
 285     if (duration.ToInternalValue() > 0)
 286       settings.SetTransitionDuration(duration);
 287
 288     window->layer()->SetTransform(end_transform);
 289     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
 290   }
 291 }
 292
 293 // Hides a window using an animation, animating its opacity from 1.f to 0.f,
 294 // its visibility to false, and its transform to |end_transform|.
 295 void AnimateHideWindowCommon(aura::Window* window,
 296                              const gfx::Transform& end_transform) {
 297   AugmentWindowSize(window, end_transform);
 298
 299   // Property sets within this scope will be implicitly animated.
 300   ScopedHidingAnimationSettings hiding_settings(window);
 301   base::TimeDelta duration = GetWindowVisibilityAnimationDuration(*window);
 302   if (duration.ToInternalValue() > 0)
 303     hiding_settings.layer_animation_settings()->SetTransitionDuration(duration);
 304
 305   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 306   window->layer()->SetTransform(end_transform);
 307   window->layer()->SetVisible(false);
 308 }
 309
 310 static gfx::Transform GetScaleForWindow(aura::Window* window) {
 311   gfx::Rect bounds = window->bounds();
 312   gfx::Transform scale = gfx::GetScaleTransform(
 313       gfx::Point(kWindowAnimation_TranslateFactor * bounds.width(),
 314                  kWindowAnimation_TranslateFactor * bounds.height()),
 315       kWindowAnimation_ScaleFactor);
 316   return scale;
 317 }
 318
 319 // Show/Hide windows using a shrink animation.
 320 void AnimateShowWindow_Drop(aura::Window* window) {
 321   AnimateShowWindowCommon(window, GetScaleForWindow(window), gfx::Transform());
 322 }
 323
 324 void AnimateHideWindow_Drop(aura::Window* window) {
 325   AnimateHideWindowCommon(window, GetScaleForWindow(window));
 326 }
 327
 328 // Show/Hide windows using a vertical Glenimation.
 329 void AnimateShowWindow_Vertical(aura::Window* window) {
 330   gfx::Transform transform;
 331   transform.Translate(0, window->GetProperty(
 332       kWindowVisibilityAnimationVerticalPositionKey));
 333   AnimateShowWindowCommon(window, transform, gfx::Transform());
 334 }
 335
 336 void AnimateHideWindow_Vertical(aura::Window* window) {
 337   gfx::Transform transform;
 338   transform.Translate(0, window->GetProperty(
 339       kWindowVisibilityAnimationVerticalPositionKey));
 340   AnimateHideWindowCommon(window, transform);
 341 }
 342
 343 // Show/Hide windows using a fade.
 344 void AnimateShowWindow_Fade(aura::Window* window) {
 345   AnimateShowWindowCommon(window, gfx::Transform(), gfx::Transform());
 346 }
 347
 348 void AnimateHideWindow_Fade(aura::Window* window) {
 349   AnimateHideWindowCommon(window, gfx::Transform());
 350 }
 351
 352 ui::LayerAnimationElement* CreateGrowShrinkElement(
 353     aura::Window* window, bool grow) {
 354   scoped_ptr<ui::InterpolatedTransform> scale(new ui::InterpolatedScale(
 355       gfx::Point3F(kWindowAnimation_Bounce_Scale,
 356                    kWindowAnimation_Bounce_Scale,
 357                    1),
 358       gfx::Point3F(1, 1, 1)));
 359   scoped_ptr<ui::InterpolatedTransform> scale_about_pivot(
 360       new ui::InterpolatedTransformAboutPivot(
 361           gfx::Point(window->bounds().width() * 0.5,
 362                      window->bounds().height() * 0.5),
 363           scale.release()));
 364   scale_about_pivot->SetReversed(grow);
 365   scoped_ptr<ui::LayerAnimationElement> transition(
 366       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
 367           scale_about_pivot.release(),
 368           base::TimeDelta::FromMilliseconds(
 369               kWindowAnimation_Bounce_DurationMS *
 370                   kWindowAnimation_Bounce_GrowShrinkDurationPercent / 100)));
 371   transition->set_tween_type(grow ? gfx::Tween::EASE_OUT : gfx::Tween::EASE_IN);
 372   return transition.release();
 373 }
 374
 375 void AnimateBounce(aura::Window* window) {
 376   ui::ScopedLayerAnimationSettings scoped_settings(
 377       window->layer()->GetAnimator());
 378   scoped_settings.SetPreemptionStrategy(
 379       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 380   scoped_ptr<ui::LayerAnimationSequence> sequence(
 381       new ui::LayerAnimationSequence);
 382   sequence->AddElement(CreateGrowShrinkElement(window, true));
 383   sequence->AddElement(ui::LayerAnimationElement::CreatePauseElement(
 384       ui::LayerAnimationElement::BOUNDS,
 385       base::TimeDelta::FromMilliseconds(
 386         kWindowAnimation_Bounce_DurationMS *
 387             (100 - 2 * kWindowAnimation_Bounce_GrowShrinkDurationPercent) /
 388             100)));
 389   sequence->AddElement(CreateGrowShrinkElement(window, false));
 390   window->layer()->GetAnimator()->StartAnimation(sequence.release());
 391 }
 392
 393 // A HidingWindowAnimationObserver that deletes observer and detached
 394 // layers when the last_sequence has been completed or aborted.
 395 class RotateHidingWindowAnimationObserver
 396     : public HidingWindowAnimationObserverBase,
 397       public ui::LayerAnimationObserver {
 398  public:
 399   RotateHidingWindowAnimationObserver(aura::Window* window)
 400       : HidingWindowAnimationObserverBase(window), last_sequence_(NULL) {}
 401   virtual ~RotateHidingWindowAnimationObserver() {}
 402
 403   void set_last_sequence(ui::LayerAnimationSequence* last_sequence) {
 404     last_sequence_ = last_sequence;
 405   }
 406
 407   // ui::LayerAnimationObserver:
 408   virtual void OnLayerAnimationEnded(
 409       ui::LayerAnimationSequence* sequence) OVERRIDE {
 410     if (last_sequence_ == sequence)
 411       OnAnimationCompleted();
 412   }
 413   virtual void OnLayerAnimationAborted(
 414       ui::LayerAnimationSequence* sequence) OVERRIDE {
 415     if (last_sequence_ == sequence)
 416       OnAnimationCompleted();
 417   }
 418   virtual void OnLayerAnimationScheduled(
 419       ui::LayerAnimationSequence* sequence) OVERRIDE {}
 420
 421  private:
 422   ui::LayerAnimationSequence* last_sequence_;
 423
 424   DISALLOW_COPY_AND_ASSIGN(RotateHidingWindowAnimationObserver);
 425 };
 426
 427 void AddLayerAnimationsForRotate(aura::Window* window, bool show) {
 428   if (show)
 429     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 430
 431   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
 432       kWindowAnimation_Rotate_DurationMS);
 433
 434   RotateHidingWindowAnimationObserver* observer = NULL;
 435
 436   if (!show) {
 437     observer = new RotateHidingWindowAnimationObserver(window);
 438     window->layer()->GetAnimator()->SchedulePauseForProperties(
 439         duration * (100 - kWindowAnimation_Rotate_OpacityDurationPercent) / 100,
 440         ui::LayerAnimationElement::OPACITY);
 441   }
 442   scoped_ptr<ui::LayerAnimationElement> opacity(
 443       ui::LayerAnimationElement::CreateOpacityElement(
 444           show ? kWindowAnimation_ShowOpacity : kWindowAnimation_HideOpacity,
 445           duration * kWindowAnimation_Rotate_OpacityDurationPercent / 100));
 446   opacity->set_tween_type(gfx::Tween::EASE_IN_OUT);
 447   window->layer()->GetAnimator()->ScheduleAnimation(
 448       new ui::LayerAnimationSequence(opacity.release()));
 449
 450   float xcenter = window->bounds().width() * 0.5;
 451
 452   gfx::Transform transform;
 453   transform.Translate(xcenter, 0);
 454   transform.ApplyPerspectiveDepth(kWindowAnimation_Rotate_PerspectiveDepth);
 455   transform.Translate(-xcenter, 0);
 456   scoped_ptr<ui::InterpolatedTransform> perspective(
 457       new ui::InterpolatedConstantTransform(transform));
 458
 459   scoped_ptr<ui::InterpolatedTransform> scale(
 460       new ui::InterpolatedScale(1, kWindowAnimation_Rotate_ScaleFactor));
 461   scoped_ptr<ui::InterpolatedTransform> scale_about_pivot(
 462       new ui::InterpolatedTransformAboutPivot(
 463           gfx::Point(xcenter, kWindowAnimation_Rotate_TranslateY),
 464           scale.release()));
 465
 466   scoped_ptr<ui::InterpolatedTransform> translation(
 467       new ui::InterpolatedTranslation(gfx::Point(), gfx::Point(
 468           0, kWindowAnimation_Rotate_TranslateY)));
 469
 470   scoped_ptr<ui::InterpolatedTransform> rotation(
 471       new ui::InterpolatedAxisAngleRotation(
 472           gfx::Vector3dF(1, 0, 0), 0, kWindowAnimation_Rotate_DegreesX));
 473
 474   scale_about_pivot->SetChild(perspective.release());
 475   translation->SetChild(scale_about_pivot.release());
 476   rotation->SetChild(translation.release());
 477   rotation->SetReversed(show);
 478
 479   scoped_ptr<ui::LayerAnimationElement> transition(
 480       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
 481           rotation.release(), duration));
 482   ui::LayerAnimationSequence* last_sequence =
 483       new ui::LayerAnimationSequence(transition.release());
 484   window->layer()->GetAnimator()->ScheduleAnimation(last_sequence);
 485   if (observer) {
 486     observer->set_last_sequence(last_sequence);
 487     observer->DetachAndRecreateLayers();
 488   }
 489 }
 490
 491 void AnimateShowWindow_Rotate(aura::Window* window) {
 492   AddLayerAnimationsForRotate(window, true);
 493 }
 494
 495 void AnimateHideWindow_Rotate(aura::Window* window) {
 496   AddLayerAnimationsForRotate(window, false);
 497 }
 498
 499 bool AnimateShowWindow(aura::Window* window) {
 500   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_SHOW)) {
 501     if (HasWindowVisibilityAnimationTransition(window, ANIMATE_HIDE)) {
 502       // Since hide animation may have changed opacity and transform,
 503       // reset them to show the window.
 504       window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
 505       window->layer()->SetTransform(gfx::Transform());
 506     }
 507     return false;
 508   }
 509
 510   switch (GetWindowVisibilityAnimationType(window)) {
 511     case WINDOW_VISIBILITY_ANIMATION_TYPE_DROP:
 512       AnimateShowWindow_Drop(window);
 513       return true;
 514     case WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL:
 515       AnimateShowWindow_Vertical(window);
 516       return true;
 517     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
 518       AnimateShowWindow_Fade(window);
 519       return true;
 520     case WINDOW_VISIBILITY_ANIMATION_TYPE_ROTATE:
 521       AnimateShowWindow_Rotate(window);
 522       return true;
 523     default:
 524       return false;
 525   }
 526 }
 527
 528 bool AnimateHideWindow(aura::Window* window) {
 529   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_HIDE)) {
 530     if (HasWindowVisibilityAnimationTransition(window, ANIMATE_SHOW)) {
 531       // Since show animation may have changed opacity and transform,
 532       // reset them, though the change should be hidden.
 533       window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 534       window->layer()->SetTransform(gfx::Transform());
 535     }
 536     return false;
 537   }
 538
 539   switch (GetWindowVisibilityAnimationType(window)) {
 540     case WINDOW_VISIBILITY_ANIMATION_TYPE_DROP:
 541       AnimateHideWindow_Drop(window);
 542       return true;
 543     case WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL:
 544       AnimateHideWindow_Vertical(window);
 545       return true;
 546     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
 547       AnimateHideWindow_Fade(window);
 548       return true;
 549     case WINDOW_VISIBILITY_ANIMATION_TYPE_ROTATE:
 550       AnimateHideWindow_Rotate(window);
 551       return true;
 552     default:
 553       return false;
 554   }
 555 }
 556
 557 }  // namespace
 558
 559 ////////////////////////////////////////////////////////////////////////////////
 560 // ImplicitHidingWindowAnimationObserver
 561
 562 ImplicitHidingWindowAnimationObserver::ImplicitHidingWindowAnimationObserver(
 563     aura::Window* window,
 564     ui::ScopedLayerAnimationSettings* settings)
 565     : HidingWindowAnimationObserverBase(window) {
 566   settings->AddObserver(this);
 567 }
 568
 569 void ImplicitHidingWindowAnimationObserver::OnImplicitAnimationsCompleted() {
 570   OnAnimationCompleted();
 571 }
 572
 573 ////////////////////////////////////////////////////////////////////////////////
 574 // ScopedHidingAnimationSettings
 575
 576 ScopedHidingAnimationSettings::ScopedHidingAnimationSettings(
 577     aura::Window* window)
 578     : layer_animation_settings_(window->layer()->GetAnimator()),
 579       observer_(new ImplicitHidingWindowAnimationObserver(
 580           window,
 581           &layer_animation_settings_)) {
 582 }
 583
 584 ScopedHidingAnimationSettings::~ScopedHidingAnimationSettings() {
 585   observer_->DetachAndRecreateLayers();
 586 }
 587
 588 ////////////////////////////////////////////////////////////////////////////////
 589 // External interface
 590
 591 void SetWindowVisibilityAnimationType(aura::Window* window, int type) {
 592   window->SetProperty(kWindowVisibilityAnimationTypeKey, type);
 593 }
 594
 595 int GetWindowVisibilityAnimationType(aura::Window* window) {
 596   return window->GetProperty(kWindowVisibilityAnimationTypeKey);
 597 }
 598
 599 void SetWindowVisibilityAnimationTransition(
 600     aura::Window* window,
 601     WindowVisibilityAnimationTransition transition) {
 602   window->SetProperty(kWindowVisibilityAnimationTransitionKey, transition);
 603 }
 604
 605 bool HasWindowVisibilityAnimationTransition(
 606     aura::Window* window,
 607     WindowVisibilityAnimationTransition transition) {
 608   WindowVisibilityAnimationTransition prop = window->GetProperty(
 609       kWindowVisibilityAnimationTransitionKey);
 610   return (prop & transition) != 0;
 611 }
 612
 613 void SetWindowVisibilityAnimationDuration(aura::Window* window,
 614                                           const base::TimeDelta& duration) {
 615   window->SetProperty(kWindowVisibilityAnimationDurationKey,
 616                       static_cast<int>(duration.ToInternalValue()));
 617 }
 618
 619 base::TimeDelta GetWindowVisibilityAnimationDuration(
 620     const aura::Window& window) {
 621   return base::TimeDelta::FromInternalValue(
 622       window.GetProperty(kWindowVisibilityAnimationDurationKey));
 623 }
 624
 625 void SetWindowVisibilityAnimationVerticalPosition(aura::Window* window,
 626                                                   float position) {
 627   window->SetProperty(kWindowVisibilityAnimationVerticalPositionKey, position);
 628 }
 629
 630 bool AnimateOnChildWindowVisibilityChanged(aura::Window* window, bool visible) {
 631   if (WindowAnimationsDisabled(window))
 632     return false;
 633   if (visible)
 634     return AnimateShowWindow(window);
 635   // Don't start hiding the window again if it's already being hidden.
 636   return window->layer()->GetTargetOpacity() != 0.0f &&
 637       AnimateHideWindow(window);
 638 }
 639
 640 bool AnimateWindow(aura::Window* window, WindowAnimationType type) {
 641   switch (type) {
 642   case WINDOW_ANIMATION_TYPE_BOUNCE:
 643     AnimateBounce(window);
 644     return true;
 645   default:
 646     NOTREACHED();
 647     return false;
 648   }
 649 }
 650
 651 bool WindowAnimationsDisabled(aura::Window* window) {
 652   return (!gfx::Animation::ShouldRenderRichAnimation() || (window &&
 653           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
 654       CommandLine::ForCurrentProcess()->HasSwitch(
 655           switches::kWindowAnimationsDisabled));
 656 }
 657
 658 }  // namespace wm