Added llvm into exceptions as we can't add README.chromium into 3rd party repository
[chromium-blink-merge.git] / ash / wm / window_animations.cc
blobdbd8bf3dcf52ecd33c3ece4c1a10968081256e92
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.
5 #include "ash/wm/window_animations.h"
7 #include <math.h>
9 #include <algorithm>
10 #include <vector>
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/geometry/vector3d_f.h"
37 #include "ui/gfx/interpolated_transform.h"
38 #include "ui/gfx/screen.h"
39 #include "ui/views/view.h"
40 #include "ui/views/widget/widget.h"
41 #include "ui/wm/core/window_util.h"
43 namespace ash {
44 namespace {
45 const int kLayerAnimationsForMinimizeDurationMS = 200;
47 // Durations for the cross-fade animation, in milliseconds.
48 const float kCrossFadeDurationMinMs = 200.f;
49 const float kCrossFadeDurationMaxMs = 400.f;
51 // Durations for the brightness/grayscale fade animation, in milliseconds.
52 const int kBrightnessGrayscaleFadeDurationMs = 1000;
54 // Brightness/grayscale values for hide/show window animations.
55 const float kWindowAnimation_HideBrightnessGrayscale = 1.f;
56 const float kWindowAnimation_ShowBrightnessGrayscale = 0.f;
58 const float kWindowAnimation_HideOpacity = 0.f;
59 const float kWindowAnimation_ShowOpacity = 1.f;
61 // Scales for AshWindow above/below current workspace.
62 const float kLayerScaleAboveSize = 1.1f;
63 const float kLayerScaleBelowSize = .9f;
65 int64 Round64(float f) {
66 return static_cast<int64>(f + 0.5f);
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();
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);
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);
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)));
94 } // namespace
96 const int kCrossFadeDurationMS = 200;
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);
106 float scale_x = static_cast<float>(target_bounds.width()) / bounds.width();
107 float scale_y = static_cast<float>(target_bounds.height()) / bounds.height();
109 scoped_ptr<ui::InterpolatedTransform> scale(
110 new ui::InterpolatedScale(gfx::Point3F(1, 1, 1),
111 gfx::Point3F(scale_x, scale_y, 1)));
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())));
119 scale->SetChild(translation.release());
120 scale->SetReversed(show);
122 base::TimeDelta duration = window->layer()->GetAnimator()->
123 GetTransitionDuration();
125 scoped_ptr<ui::LayerAnimationElement> transition(
126 ui::LayerAnimationElement::CreateInterpolatedTransformElement(
127 scale.release(), duration));
129 transition->set_tween_type(
130 show ? gfx::Tween::EASE_IN : gfx::Tween::EASE_IN_OUT);
132 window->layer()->GetAnimator()->ScheduleAnimation(
133 new ui::LayerAnimationSequence(transition.release()));
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);
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)));
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())));
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);
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);
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);
179 AddLayerAnimationsForMinimize(window, false);
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;
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);
200 base::TimeDelta duration =
201 base::TimeDelta::FromMilliseconds(kBrightnessGrayscaleFadeDurationMs);
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);
218 void AnimateShowWindow_BrightnessGrayscale(aura::Window* window) {
219 AnimateShowHideWindowCommon_BrightnessGrayscale(window, true);
222 void AnimateHideWindow_BrightnessGrayscale(aura::Window* window) {
223 AnimateShowHideWindowCommon_BrightnessGrayscale(window, false);
226 bool AnimateShowWindow(aura::Window* window) {
227 if (!::wm::HasWindowVisibilityAnimationTransition(
228 window, ::wm::ANIMATE_SHOW)) {
229 return false;
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;
245 bool AnimateHideWindow(aura::Window* window) {
246 if (!::wm::HasWindowVisibilityAnimationTransition(
247 window, ::wm::ANIMATE_HIDE)) {
248 return false;
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;
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);
280 ~CrossFadeObserver() override {
281 window_->RemoveObserver(this);
282 window_ = NULL;
283 layer_owner_->root()->GetCompositor()->RemoveObserver(this);
286 // ui::CompositorObserver overrides:
287 void OnCompositingDidCommit(ui::Compositor* compositor) override {}
288 void OnCompositingStarted(ui::Compositor* compositor,
289 base::TimeTicks start_time) override {}
290 void OnCompositingEnded(ui::Compositor* compositor) override {}
291 void OnCompositingAborted(ui::Compositor* compositor) override {
292 // Triggers OnImplicitAnimationsCompleted() to be called and deletes us.
293 layer_owner_->root()->GetAnimator()->StopAnimating();
295 void OnCompositingLockStateChanged(ui::Compositor* compositor) override {}
296 void OnCompositingShuttingDown(ui::Compositor* compositor) override {}
298 // aura::WindowObserver overrides:
299 void OnWindowDestroying(aura::Window* window) override {
300 // Triggers OnImplicitAnimationsCompleted() to be called and deletes us.
301 layer_owner_->root()->GetAnimator()->StopAnimating();
303 void OnWindowRemovingFromRootWindow(aura::Window* window,
304 aura::Window* new_root) override {
305 layer_owner_->root()->GetAnimator()->StopAnimating();
308 // ui::ImplicitAnimationObserver overrides:
309 void OnImplicitAnimationsCompleted() override { delete this; }
311 private:
312 aura::Window* window_; // not owned
313 scoped_ptr<ui::LayerTreeOwner> layer_owner_;
315 DISALLOW_COPY_AND_ASSIGN(CrossFadeObserver);
318 base::TimeDelta CrossFadeAnimation(
319 aura::Window* window,
320 scoped_ptr<ui::LayerTreeOwner> old_layer_owner,
321 gfx::Tween::Type tween_type) {
322 DCHECK(old_layer_owner->root());
323 const gfx::Rect old_bounds(old_layer_owner->root()->bounds());
324 gfx::RectF old_transformed_bounds(old_bounds);
325 gfx::Transform old_transform(old_layer_owner->root()->transform());
326 gfx::Transform old_transform_in_root;
327 old_transform_in_root.Translate(old_bounds.x(), old_bounds.y());
328 old_transform_in_root.PreconcatTransform(old_transform);
329 old_transform_in_root.Translate(-old_bounds.x(), -old_bounds.y());
330 old_transform_in_root.TransformRect(&old_transformed_bounds);
331 const gfx::Rect new_bounds(window->bounds());
332 const bool old_on_top = (old_bounds.width() > new_bounds.width());
334 // Shorten the animation if there's not much visual movement.
335 const base::TimeDelta duration = GetCrossFadeDuration(window,
336 old_transformed_bounds, new_bounds);
338 // Scale up the old layer while translating to new position.
340 ui::Layer* old_layer = old_layer_owner->root();
341 old_layer->GetAnimator()->StopAnimating();
342 old_layer->SetTransform(old_transform);
343 ui::ScopedLayerAnimationSettings settings(old_layer->GetAnimator());
345 // Animation observer owns the old layer and deletes itself.
346 settings.AddObserver(new CrossFadeObserver(window, old_layer_owner.Pass()));
347 settings.SetTransitionDuration(duration);
348 settings.SetTweenType(tween_type);
349 gfx::Transform out_transform;
350 float scale_x = static_cast<float>(new_bounds.width()) /
351 static_cast<float>(old_bounds.width());
352 float scale_y = static_cast<float>(new_bounds.height()) /
353 static_cast<float>(old_bounds.height());
354 out_transform.Translate(new_bounds.x() - old_bounds.x(),
355 new_bounds.y() - old_bounds.y());
356 out_transform.Scale(scale_x, scale_y);
357 old_layer->SetTransform(out_transform);
358 if (old_on_top) {
359 // The old layer is on top, and should fade out. The new layer below will
360 // stay opaque to block the desktop.
361 old_layer->SetOpacity(kWindowAnimation_HideOpacity);
363 // In tests |old_layer| is deleted here, as animations have zero duration.
364 old_layer = NULL;
367 // Set the new layer's current transform, such that the user sees a scaled
368 // version of the window with the original bounds at the original position.
369 gfx::Transform in_transform;
370 const float scale_x = old_transformed_bounds.width() /
371 static_cast<float>(new_bounds.width());
372 const float scale_y = old_transformed_bounds.height() /
373 static_cast<float>(new_bounds.height());
374 in_transform.Translate(old_transformed_bounds.x() - new_bounds.x(),
375 old_transformed_bounds.y() - new_bounds.y());
376 in_transform.Scale(scale_x, scale_y);
377 window->layer()->SetTransform(in_transform);
378 if (!old_on_top) {
379 // The new layer is on top and should fade in. The old layer below will
380 // stay opaque and block the desktop.
381 window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
384 // Animate the new layer to the identity transform, so the window goes to
385 // its newly set bounds.
386 ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
387 settings.SetTransitionDuration(duration);
388 settings.SetTweenType(tween_type);
389 window->layer()->SetTransform(gfx::Transform());
390 if (!old_on_top) {
391 // New layer is on top, fade it in.
392 window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
395 return duration;
398 bool AnimateOnChildWindowVisibilityChanged(aura::Window* window, bool visible) {
399 if (::wm::WindowAnimationsDisabled(window))
400 return false;
402 // Attempt to run CoreWm supplied animation types.
403 if (::wm::AnimateOnChildWindowVisibilityChanged(window, visible))
404 return true;
406 // Otherwise try to run an Ash-specific animation.
407 if (visible)
408 return AnimateShowWindow(window);
409 // Don't start hiding the window again if it's already being hidden.
410 return window->layer()->GetTargetOpacity() != 0.0f &&
411 AnimateHideWindow(window);
414 std::vector<ui::LayerAnimationSequence*>
415 CreateBrightnessGrayscaleAnimationSequence(float target_value,
416 base::TimeDelta duration) {
417 gfx::Tween::Type animation_type = gfx::Tween::EASE_OUT;
418 scoped_ptr<ui::LayerAnimationSequence> brightness_sequence(
419 new ui::LayerAnimationSequence());
420 scoped_ptr<ui::LayerAnimationSequence> grayscale_sequence(
421 new ui::LayerAnimationSequence());
423 scoped_ptr<ui::LayerAnimationElement> brightness_element(
424 ui::LayerAnimationElement::CreateBrightnessElement(
425 target_value, duration));
426 brightness_element->set_tween_type(animation_type);
427 brightness_sequence->AddElement(brightness_element.release());
429 scoped_ptr<ui::LayerAnimationElement> grayscale_element(
430 ui::LayerAnimationElement::CreateGrayscaleElement(
431 target_value, duration));
432 grayscale_element->set_tween_type(animation_type);
433 grayscale_sequence->AddElement(grayscale_element.release());
435 std::vector<ui::LayerAnimationSequence*> animations;
436 animations.push_back(brightness_sequence.release());
437 animations.push_back(grayscale_sequence.release());
439 return animations;
442 // Returns scale related to the specified AshWindowScaleType.
443 void SetTransformForScaleAnimation(ui::Layer* layer,
444 LayerScaleAnimationDirection type) {
445 const float scale =
446 type == LAYER_SCALE_ANIMATION_ABOVE ? kLayerScaleAboveSize :
447 kLayerScaleBelowSize;
448 gfx::Transform transform;
449 transform.Translate(-layer->bounds().width() * (scale - 1.0f) / 2,
450 -layer->bounds().height() * (scale - 1.0f) / 2);
451 transform.Scale(scale, scale);
452 layer->SetTransform(transform);
455 gfx::Rect GetMinimizeAnimationTargetBoundsInScreen(aura::Window* window) {
456 Shelf* shelf = Shelf::ForWindow(window);
457 // Shelf is created lazily and can be NULL.
458 if (!shelf)
459 return gfx::Rect();
460 gfx::Rect item_rect = shelf->GetScreenBoundsOfItemIconForWindow(window);
462 // The launcher item is visible and has an icon.
463 if (!item_rect.IsEmpty())
464 return item_rect;
466 // If both the icon width and height are 0, then there is no icon in the
467 // launcher for |window|. If the launcher is auto hidden, one of the height or
468 // width will be 0 but the position in the launcher and the major dimension
469 // are still reported correctly and the window can be animated to the launcher
470 // item's light bar.
471 ShelfLayoutManager* layout_manager = ShelfLayoutManager::ForShelf(window);
472 if (item_rect.width() != 0 || item_rect.height() != 0) {
473 if (layout_manager->visibility_state() == SHELF_AUTO_HIDE) {
474 gfx::Rect shelf_bounds = shelf->shelf_widget()->GetWindowBoundsInScreen();
475 switch (layout_manager->GetAlignment()) {
476 case SHELF_ALIGNMENT_BOTTOM:
477 item_rect.set_y(shelf_bounds.y());
478 break;
479 case SHELF_ALIGNMENT_LEFT:
480 item_rect.set_x(shelf_bounds.right());
481 break;
482 case SHELF_ALIGNMENT_RIGHT:
483 item_rect.set_x(shelf_bounds.x());
484 break;
485 case SHELF_ALIGNMENT_TOP:
486 item_rect.set_y(shelf_bounds.bottom());
487 break;
489 return item_rect;
493 // Coming here, there is no visible icon of that shelf item and we zoom back
494 // to the location of the application launcher (which is fixed as first item
495 // of the shelf).
496 gfx::Rect work_area =
497 Shell::GetScreen()->GetDisplayNearestWindow(window).work_area();
498 int ltr_adjusted_x = base::i18n::IsRTL() ? work_area.right() : work_area.x();
499 switch (layout_manager->GetAlignment()) {
500 case SHELF_ALIGNMENT_BOTTOM:
501 return gfx::Rect(ltr_adjusted_x, work_area.bottom(), 0, 0);
502 case SHELF_ALIGNMENT_TOP:
503 return gfx::Rect(ltr_adjusted_x, work_area.y(), 0, 0);
504 case SHELF_ALIGNMENT_LEFT:
505 return gfx::Rect(work_area.x(), work_area.y(), 0, 0);
506 case SHELF_ALIGNMENT_RIGHT:
507 return gfx::Rect(work_area.right(), work_area.y(), 0, 0);
509 NOTREACHED();
510 return gfx::Rect();
513 } // namespace ash