blob: b05db20a6149ac14d7dbde8e570db412d066fbf8 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_
#define UI_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_
#include <vector>
#include "base/gtest_prod_util.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/time.h"
#include "ui/compositor/compositor_export.h"
#include "ui/compositor/layer_animation_element.h"
namespace ui {
class LayerAnimationDelegate;
class LayerAnimationObserver;
// Contains a collection of layer animation elements to be played one after
// another. Although it has a similar interface to LayerAnimationElement, it is
// not a LayerAnimationElement (i.e., it is not permitted to have a sequence in
// a sequence). Sequences own their elements, and sequences are themselves owned
// by a LayerAnimator.
//
// TODO(vollick) Create a 'blended' sequence for transitioning between
// sequences.
// TODO(vollick) Eventually, the LayerAnimator will switch to a model where new
// work is scheduled rather than calling methods directly. This should make it
// impossible for temporary pointers to running animations to go stale. When
// this happens, there will be no need for LayerAnimationSequences to support
// weak pointers.
class COMPOSITOR_EXPORT LayerAnimationSequence
: public base::SupportsWeakPtr<LayerAnimationSequence> {
public:
LayerAnimationSequence();
// Takes ownership of the given element and adds it to the sequence.
explicit LayerAnimationSequence(LayerAnimationElement* element);
virtual ~LayerAnimationSequence();
// Updates the delegate to the appropriate value for |elapsed|, which is in
// the range [0, Duration()]. If the animation is not aborted, it is
// guaranteed that Animate will be called with elapsed = Duration(). Requests
// a redraw if it is required.
void Progress(base::TimeDelta elapsed, LayerAnimationDelegate* delegate);
// Sets the target value to the value that would have been set had
// the sequence completed. Does nothing if the sequence is cyclic.
void GetTargetValue(LayerAnimationElement::TargetValue* target) const;
// Aborts the given animation.
void Abort();
// All properties modified by the sequence.
const LayerAnimationElement::AnimatableProperties& properties() const {
return properties_;
}
// The total, finite duration of one cycle of the sequence.
base::TimeDelta duration() const {
return duration_;
}
// Adds an element to the sequence. The sequences takes ownership of this
// element.
void AddElement(LayerAnimationElement* element);
// Sequences can be looped indefinitely.
void set_is_cyclic(bool is_cyclic) { is_cyclic_ = is_cyclic; }
bool is_cyclic() const { return is_cyclic_; }
// Returns true if this sequence has at least one element affecting a
// property in |other|.
bool HasCommonProperty(
const LayerAnimationElement::AnimatableProperties& other) const;
// These functions are used for adding or removing observers from the observer
// list. The observers are notified when animations end.
void AddObserver(LayerAnimationObserver* observer);
void RemoveObserver(LayerAnimationObserver* observer);
// Called when the animator schedules this sequence.
void OnScheduled();
// Called when the animator is destroyed.
void OnAnimatorDestroyed();
private:
typedef std::vector<linked_ptr<LayerAnimationElement> > Elements;
FRIEND_TEST_ALL_PREFIXES(LayerAnimatorTest,
ObserverReleasedBeforeAnimationSequenceEnds);
// Notifies the observers that this sequence has been scheduled.
void NotifyScheduled();
// Notifies the observers that this sequence has ended.
void NotifyEnded();
// Notifies the observers that this sequence has been aborted.
void NotifyAborted();
// The sum of the durations of all the elements in the sequence.
base::TimeDelta duration_;
// The union of all the properties modified by all elements in the sequence.
LayerAnimationElement::AnimatableProperties properties_;
// The elements in the sequence.
Elements elements_;
// True if the sequence should be looped forever.
bool is_cyclic_;
// These are used when animating to efficiently find the next element.
size_t last_element_;
base::TimeDelta last_start_;
// These parties are notified when layer animations end.
ObserverList<LayerAnimationObserver> observers_;
DISALLOW_COPY_AND_ASSIGN(LayerAnimationSequence);
};
} // namespace ui
#endif // UI_COMPOSITOR_LAYER_ANIMATION_SEQUENCE_H_
|
