animation_builder.cc | Explore in Territory

// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/views/animation/animation_builder.h"

#include <algorithm>
#include <tuple>
#include <utility>
#include <vector>

#include "base/check_op.h"
#include "base/debug/alias.h"
#include "base/functional/callback.h"
#include "base/location.h"
#include "base/memory/ptr_util.h"
#include "base/no_destructor.h"
#include "base/ranges/algorithm.h"
#include "base/time/time.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_animation_element.h"
#include "ui/compositor/layer_animation_observer.h"
#include "ui/compositor/layer_animation_sequence.h"
#include "ui/compositor/layer_animator.h"
#include "ui/compositor/layer_owner.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/views/animation/animation_abort_handle.h"
#include "ui/views/animation/animation_key.h"
#include "ui/views/animation/animation_sequence_block.h"

namespace views {

AnimationBuilder::Observer::Observer() = default;

AnimationBuilder::Observer::~Observer() { … }

void AnimationBuilder::Observer::SetOnStarted(base::OnceClosure callback) { … }

void AnimationBuilder::Observer::SetOnEnded(base::OnceClosure callback,
                                            base::Location location) { … }

void AnimationBuilder::Observer::SetOnWillRepeat(
    base::RepeatingClosure callback) { … }

void AnimationBuilder::Observer::SetOnAborted(base::OnceClosure callback,
                                              base::Location location) { … }

void AnimationBuilder::Observer::SetOnScheduled(base::OnceClosure callback) { … }

void AnimationBuilder::Observer::OnLayerAnimationStarted(
    ui::LayerAnimationSequence* sequence) { … }

void AnimationBuilder::Observer::SetAbortHandle(
    AnimationAbortHandle* abort_handle) { … }

void AnimationBuilder::Observer::OnLayerAnimationEnded(
    ui::LayerAnimationSequence* sequence) { … }

void AnimationBuilder::Observer::OnLayerAnimationWillRepeat(
    ui::LayerAnimationSequence* sequence) { … }

void AnimationBuilder::Observer::OnLayerAnimationAborted(
    ui::LayerAnimationSequence* sequence) { … }

void AnimationBuilder::Observer::OnLayerAnimationScheduled(
    ui::LayerAnimationSequence* sequence) { … }

void AnimationBuilder::Observer::OnAttachedToSequence(
    ui::LayerAnimationSequence* sequence) { … }

void AnimationBuilder::Observer::OnDetachedFromSequence(
    ui::LayerAnimationSequence* sequence) { … }

bool AnimationBuilder::Observer::RequiresNotificationWhenAnimatorDestroyed()
    const { … }

struct AnimationBuilder::Value { … };

AnimationBuilder::AnimationBuilder() = default;

AnimationBuilder::AnimationBuilder(AnimationBuilder&& rhs) = default;

AnimationBuilder& AnimationBuilder::operator=(AnimationBuilder&& rhs) = default;

AnimationBuilder::~AnimationBuilder() { … }

AnimationBuilder& AnimationBuilder::SetPreemptionStrategy(
    ui::LayerAnimator::PreemptionStrategy preemption_strategy) { … }

AnimationBuilder& AnimationBuilder::OnStarted(base::OnceClosure callback) { … }

AnimationBuilder& AnimationBuilder::OnEnded(base::OnceClosure callback,
                                            base::Location location) { … }

AnimationBuilder& AnimationBuilder::OnWillRepeat(
    base::RepeatingClosure callback) { … }

AnimationBuilder& AnimationBuilder::OnAborted(base::OnceClosure callback,
                                              base::Location location) { … }

AnimationBuilder& AnimationBuilder::OnScheduled(base::OnceClosure callback) { … }

AnimationSequenceBlock& AnimationBuilder::Once() { … }

AnimationSequenceBlock& AnimationBuilder::Repeatedly() { … }

void AnimationBuilder::AddLayerAnimationElement(
    base::PassKey<AnimationSequenceBlock>,
    AnimationKey key,
    base::TimeDelta start,
    base::TimeDelta original_duration,
    std::unique_ptr<ui::LayerAnimationElement> element) { … }

std::unique_ptr<AnimationSequenceBlock> AnimationBuilder::SwapCurrentSequence(
    base::PassKey<AnimationSequenceBlock>,
    std::unique_ptr<AnimationSequenceBlock> new_sequence) { … }

void AnimationBuilder::BlockEndedAt(base::PassKey<AnimationSequenceBlock>,
                                    base::TimeDelta end) { … }

void AnimationBuilder::TerminateSequence(base::PassKey<AnimationSequenceBlock>,
                                         bool repeating) { … }

AnimationSequenceBlock& AnimationBuilder::GetCurrentSequence() { … }

std::unique_ptr<AnimationAbortHandle> AnimationBuilder::GetAbortHandle() { … }

AnimationBuilder::Observer* AnimationBuilder::GetObserver() { … }

// static
void AnimationBuilder::SetObserverDeletedCallbackForTesting(
    base::RepeatingClosure deleted_closure) { … }

AnimationSequenceBlock& AnimationBuilder::NewSequence(bool repeating) { … }

// static
base::RepeatingClosure& AnimationBuilder::GetObserverDeletedCallback() { … }

}  // namespace views
chromium/ui/views/animation/animation_builder.cc
