blob: bd38fb45b9d67300761443f978d46a8d0ab0eddb (
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
131
|
// Copyright (c) 2009 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.
// Inspired by NSAnimation
#ifndef APP_ANIMATION_H_
#define APP_ANIMATION_H_
#include "base/time.h"
#include "base/timer.h"
class Animation;
// AnimationDelegate
//
// Implement this interface when you want to receive notifications about the
// state of an animation.
//
class AnimationDelegate {
public:
// Called when an animation has started.
virtual void AnimationStarted(const Animation* animation) {
}
// Called when an animation has completed.
virtual void AnimationEnded(const Animation* animation) {
}
// Called when an animation has progressed.
virtual void AnimationProgressed(const Animation* animation) {
}
// Called when an animation has been canceled.
virtual void AnimationCanceled(const Animation* animation) {
}
protected:
virtual ~AnimationDelegate() {}
};
// Animation
//
// This class provides a basic implementation of an object that uses a timer
// to increment its state over the specified time and frame-rate. To
// actually do something useful with this you need to subclass it and override
// AnimateToState and optionally GetCurrentValue to update your state.
//
// The Animation notifies a delegate when events of interest occur.
//
// The practice is to instantiate a subclass and call Init and any other
// initialization specific to the subclass, and then call |Start|. The
// animation uses the current thread's message loop.
//
class Animation {
public:
// Initializes everything except the duration.
//
// Caller must make sure to call SetDuration() if they use this
// constructor; it is preferable to use the full one, but sometimes
// duration can change between calls to Start() and we need to
// expose this interface.
Animation(int frame_rate, AnimationDelegate* delegate);
// Initializes all fields.
Animation(int duration, int frame_rate, AnimationDelegate* delegate);
virtual ~Animation();
// Reset state so that the animation can be started again.
virtual void Reset();
// Called when the animation progresses. Subclasses override this to
// efficiently update their state.
virtual void AnimateToState(double state) = 0;
// Gets the value for the current state, according to the animation
// curve in use. This class provides only for a linear relationship,
// however subclasses can override this to provide others.
virtual double GetCurrentValue() const;
// Start the animation.
void Start();
// Stop the animation.
void Stop();
// Skip to the end of the current animation.
void End();
// Return whether this animation is animating.
bool IsAnimating() const;
// Changes the length of the animation. This resets the current
// state of the animation to the beginning.
void SetDuration(int duration);
// Returns true if rich animations should be rendered.
// Looks at session type (e.g. remote desktop) and accessibility settings
// to give guidance for heavy animations such as "start download" arrow.
static bool ShouldRenderRichAnimation();
protected:
// Overriddable, called by Run.
virtual void Step();
// Calculates the timer interval from the constructor list.
base::TimeDelta CalculateInterval(int frame_rate);
// Whether or not we are currently animating.
bool animating_;
int frame_rate_;
base::TimeDelta timer_interval_;
base::TimeDelta duration_;
// Current state, on a scale from 0.0 to 1.0.
double state_;
base::Time start_time_;
AnimationDelegate* delegate_;
base::RepeatingTimer<Animation> timer_;
private:
// Called when the animation's timer expires, calls Step.
void Run();
DISALLOW_COPY_AND_ASSIGN(Animation);
};
#endif // APP_ANIMATION_H_
|
