// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/shelf/window_scale_animation.h"
#include <optional>
#include <vector>
#include "ash/public/cpp/shelf_config.h"
#include "ash/public/cpp/window_backdrop.h"
#include "ash/public/cpp/window_properties.h"
#include "ash/screen_util.h"
#include "ash/shelf/shelf.h"
#include "ash/shell.h"
#include "ash/wm/window_state.h"
#include "ash/wm/window_util.h"
#include "base/containers/unique_ptr_adapters.h"
#include "base/memory/raw_ptr.h"
#include "base/time/time.h"
#include "ui/aura/window.h"
#include "ui/aura/window_observer.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_animation_observer.h"
#include "ui/compositor/layer_animator.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/gfx/animation/tween.h"
#include "ui/gfx/geometry/transform.h"
#include "ui/wm/core/scoped_animation_disabler.h"
namespace ash {
namespace {
// The time to do window transform to scale up to its original position or
// scale down to homescreen animation.
constexpr base::TimeDelta kWindowScaleUpOrDownTime = base::Milliseconds(350);
// The delay to do window opacity fade out when scaling down the dragged window.
constexpr base::TimeDelta kWindowFadeOutDelay = base::Milliseconds(100);
// The window scale down factor if we head to home screen after drag ends.
constexpr float kWindowScaleDownFactor = 0.001f;
// The fast animation time to do window transform for transient child window.
// This will only be used in tests.
constexpr base::TimeDelta kFastAnimationTime = base::Milliseconds(100);
// This will only be updated to true in tests via
// |EnableScopedFastAnimationForTransientChildForTest()|.
bool g_should_use_fast_animation_for_transient_child = false;
// Returns the transform that should be applied to |window| if we should head to
// shelf after dragging.
gfx::Transform GetWindowTransformToShelf(aura::Window* window) {
// The origin of bounds returned by GetBoundsInScreen() is transformed using
// the window's transform. The transform that should be applied to the
// window is calculated relative to the window bounds with no transforms
// applied, and thus need the un-transformed window origin.
const gfx::RectF window_bounds(window->GetBoundsInScreen());
gfx::PointF origin = window_bounds.origin();
gfx::PointF origin_without_transform =
window->transform().InverseMapPoint(origin).value_or(origin);
gfx::Transform transform;
Shelf* shelf = Shelf::ForWindow(window);
const gfx::Rect shelf_item_bounds =
shelf->GetScreenBoundsOfItemIconForWindow(window);
if (!shelf_item_bounds.IsEmpty()) {
const gfx::RectF shelf_item_bounds_f(shelf_item_bounds);
const gfx::PointF shelf_item_center = shelf_item_bounds_f.CenterPoint();
transform.Translate(shelf_item_center.x() - origin_without_transform.x(),
shelf_item_center.y() - origin_without_transform.y());
transform.Scale(shelf_item_bounds_f.width() / window_bounds.width(),
shelf_item_bounds_f.height() / window_bounds.height());
} else {
const gfx::PointF shelf_center_point =
gfx::RectF(shelf->GetIdealBounds()).CenterPoint();
transform.Translate(shelf_center_point.x() - origin_without_transform.x(),
shelf_center_point.y() - origin_without_transform.y());
transform.Scale(kWindowScaleDownFactor, kWindowScaleDownFactor);
}
return transform;
}
base::TimeDelta GetWindowAnimationTime(aura::Window* window) {
if (g_should_use_fast_animation_for_transient_child &&
window != wm::GetTransientRoot(window)) {
return kFastAnimationTime;
}
return kWindowScaleUpOrDownTime;
}
} // namespace
// -----------------------------------------------------------------------------
// WindowScaleAnimation::AnimationObserver:
// It's owned by |WindowScaleAnimation| and will be destroyed when its
// |window_| animation is completed or its |window_| is being destroyed.
class WindowScaleAnimation::AnimationObserver
: public ui::ImplicitAnimationObserver,
public aura::WindowObserver {
public:
AnimationObserver(aura::Window* window,
WindowScaleAnimation* window_scale_animation)
: window_(window), window_scale_animation_(window_scale_animation) {
window_observation_.Observe(window_.get());
}
AnimationObserver(const AnimationObserver&) = delete;
AnimationObserver& operator=(const AnimationObserver&) = delete;
~AnimationObserver() override {
// Explicitly stopping observing will prevent
// `OnImplicitAnimationsCompleted()` from being called.
StopObservingImplicitAnimations();
}
aura::Window* window() { return window_; }
// ui::ImplicitAnimationObserver:
void OnImplicitAnimationsCompleted() override {
window_scale_animation_->DestroyWindowAnimationObserver(this);
// |this| is destroyed after the above line.
}
// aura::WindowObserver:
void OnWindowDestroying(aura::Window* window) override {
window_scale_animation_->DestroyWindowAnimationObserver(this);
// |this| is destroyed after the above line.
}
private:
// Pointers to the window and the parent scale animation. Guaranteed to
// outlive `this`.
const raw_ptr<aura::Window> window_;
const raw_ptr<WindowScaleAnimation> window_scale_animation_;
base::ScopedObservation<aura::Window, aura::WindowObserver>
window_observation_{this};
};
WindowScaleAnimation::WindowScaleAnimation(WindowScaleType scale_type,
base::OnceClosure opt_callback)
: opt_callback_(std::move(opt_callback)), scale_type_(scale_type) {}
WindowScaleAnimation::~WindowScaleAnimation() {
if (!opt_callback_.is_null())
std::move(opt_callback_).Run();
}
void WindowScaleAnimation::Start(aura::Window* window) {
// In the destructor of `ScopedLayerAnimationSettings`, it will activate all
// of its observers. What we want is to activate the observer for each
// transient child window after the for loop is done, otherwise `this` can be
// early released via `WindowScaleAnimation::DestroyWindowAnimationObserver`.
// Hence creating this vector outside of the for loop.
std::vector<std::unique_ptr<ui::ScopedLayerAnimationSettings>> all_settings;
for (auto* transient_window : GetTransientTreeIterator(window)) {
window_animation_observers_.push_back(
std::make_unique<AnimationObserver>(transient_window, this));
WindowBackdrop::Get(transient_window)->DisableBackdrop();
all_settings.push_back(std::make_unique<ui::ScopedLayerAnimationSettings>(
transient_window->layer()->GetAnimator()));
auto* settings = all_settings.back().get();
settings->SetTransitionDuration(GetWindowAnimationTime(transient_window));
settings->SetPreemptionStrategy(
ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
settings->SetTweenType(gfx::Tween::FAST_OUT_SLOW_IN);
settings->AddObserver(window_animation_observers_.back().get());
if (scale_type_ == WindowScaleType::kScaleDownToShelf) {
transient_window->layer()->GetAnimator()->SchedulePauseForProperties(
kWindowFadeOutDelay, ui::LayerAnimationElement::OPACITY);
transient_window->layer()->SetTransform(
GetWindowTransformToShelf(transient_window));
transient_window->layer()->SetOpacity(0.f);
} else {
transient_window->layer()->SetTransform(gfx::Transform());
}
}
}
// static
base::AutoReset<bool>
WindowScaleAnimation::EnableScopedFastAnimationForTransientChildForTest() {
return base::AutoReset<bool>(&g_should_use_fast_animation_for_transient_child,
true);
}
void WindowScaleAnimation::DestroyWindowAnimationObserver(
WindowScaleAnimation::AnimationObserver* animation_observer) {
// `animation_observer` will get deleted on the next line.
auto* window = animation_observer->window();
std::erase_if(window_animation_observers_,
base::MatchesUniquePtr(animation_observer));
if (window_animation_observers_.empty()) {
// Do the scale transform for the entire transient tree.
OnScaleWindowsOnAnimationsCompleted(window);
// self-destructed when all windows' transform animation is done.
delete this;
}
}
void WindowScaleAnimation::OnScaleWindowsOnAnimationsCompleted(
aura::Window* window) {
// Scale-down or scale-up window(s) with the windows' descending order
// in the transient tree. We need to use this fixed order to ensure the
// transient child window will be visible after returning back from home
// screen to the window. If the transient child window is minimized before its
// parent window, its visibility is not controlled by its parent anymore.
// Check |TransientWindowManager::UpdateTransientChildVisibility()| for more
// details.
const bool is_scaling_down =
scale_type_ == WindowScaleAnimation::WindowScaleType::kScaleDownToShelf;
for (auto* transient_window : GetTransientTreeIterator(window)) {
if (transient_window->is_destroying())
continue;
if (is_scaling_down) {
// Minimize the dragged window after transform animation is completed.
window_util::MinimizeAndHideWithoutAnimation({transient_window});
// Reset its transform to identity transform and its original backdrop
// mode.
transient_window->layer()->SetTransform(gfx::Transform());
transient_window->layer()->SetOpacity(1.f);
}
WindowBackdrop::Get(transient_window)->RestoreBackdrop();
}
}
} // namespace ash
Codebase Browser
chromium