0
|
1 |
/*
|
|
2 |
* Copyright (C) 2007 Apple Inc. All rights reserved.
|
|
3 |
*
|
|
4 |
* Redistribution and use in source and binary forms, with or without
|
|
5 |
* modification, are permitted provided that the following conditions
|
|
6 |
* are met:
|
|
7 |
*
|
|
8 |
* 1. Redistributions of source code must retain the above copyright
|
|
9 |
* notice, this list of conditions and the following disclaimer.
|
|
10 |
* 2. Redistributions in binary form must reproduce the above copyright
|
|
11 |
* notice, this list of conditions and the following disclaimer in the
|
|
12 |
* documentation and/or other materials provided with the distribution.
|
|
13 |
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
|
|
14 |
* its contributors may be used to endorse or promote products derived
|
|
15 |
* from this software without specific prior written permission.
|
|
16 |
*
|
|
17 |
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
|
|
18 |
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
19 |
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
20 |
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
|
|
21 |
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
22 |
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
23 |
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
24 |
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
25 |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
26 |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
27 |
*/
|
|
28 |
|
|
29 |
#ifndef AnimationBase_h
|
|
30 |
#define AnimationBase_h
|
|
31 |
|
|
32 |
#include "AtomicString.h"
|
|
33 |
#include <wtf/HashMap.h>
|
|
34 |
|
|
35 |
namespace WebCore {
|
|
36 |
|
|
37 |
class Animation;
|
|
38 |
class AnimationBase;
|
|
39 |
class AnimationController;
|
|
40 |
class CompositeAnimation;
|
|
41 |
class Element;
|
|
42 |
class Node;
|
|
43 |
class RenderObject;
|
|
44 |
class RenderStyle;
|
|
45 |
class TimingFunction;
|
|
46 |
|
|
47 |
class AnimationBase : public RefCounted<AnimationBase> {
|
|
48 |
friend class CompositeAnimation;
|
|
49 |
|
|
50 |
public:
|
|
51 |
AnimationBase(const Animation* transition, RenderObject* renderer, CompositeAnimation* compAnim);
|
|
52 |
virtual ~AnimationBase();
|
|
53 |
|
|
54 |
RenderObject* renderer() const { return m_object; }
|
|
55 |
void clearRenderer() { m_object = 0; }
|
|
56 |
|
|
57 |
double duration() const;
|
|
58 |
|
|
59 |
// Animations and Transitions go through the states below. When entering the STARTED state
|
|
60 |
// the animation is started. This may or may not require deferred response from the animator.
|
|
61 |
// If so, we stay in this state until that response is received (and it returns the start time).
|
|
62 |
// Otherwise, we use the current time as the start time and go immediately to AnimationStateLooping
|
|
63 |
// or AnimationStateEnding.
|
|
64 |
enum AnimState {
|
|
65 |
AnimationStateNew, // animation just created, animation not running yet
|
|
66 |
AnimationStateStartWaitTimer, // start timer running, waiting for fire
|
|
67 |
AnimationStateStartWaitStyleAvailable, // waiting for style setup so we can start animations
|
|
68 |
AnimationStateStartWaitResponse, // animation started, waiting for response
|
|
69 |
AnimationStateLooping, // response received, animation running, loop timer running, waiting for fire
|
|
70 |
AnimationStateEnding, // received, animation running, end timer running, waiting for fire
|
|
71 |
AnimationStatePausedWaitTimer, // in pause mode when animation started
|
|
72 |
AnimationStatePausedWaitResponse, // animation paused when in STARTING state
|
|
73 |
AnimationStatePausedRun, // animation paused when in LOOPING or ENDING state
|
|
74 |
AnimationStateDone // end timer fired, animation finished and removed
|
|
75 |
};
|
|
76 |
|
|
77 |
enum AnimStateInput {
|
|
78 |
AnimationStateInputMakeNew, // reset back to new from any state
|
|
79 |
AnimationStateInputStartAnimation, // animation requests a start
|
|
80 |
AnimationStateInputRestartAnimation, // force a restart from any state
|
|
81 |
AnimationStateInputStartTimerFired, // start timer fired
|
|
82 |
AnimationStateInputStyleAvailable, // style is setup, ready to start animating
|
|
83 |
AnimationStateInputStartTimeSet, // m_startTime was set
|
|
84 |
AnimationStateInputLoopTimerFired, // loop timer fired
|
|
85 |
AnimationStateInputEndTimerFired, // end timer fired
|
|
86 |
AnimationStateInputPauseOverride, // pause an animation due to override
|
|
87 |
AnimationStateInputResumeOverride, // resume an overridden animation
|
|
88 |
AnimationStateInputPlayStateRunnning, // play state paused -> running
|
|
89 |
AnimationStateInputPlayStatePaused, // play state running -> paused
|
|
90 |
AnimationStateInputEndAnimation // force an end from any state
|
|
91 |
};
|
|
92 |
|
|
93 |
// Called when animation is in AnimationStateNew to start animation
|
|
94 |
void updateStateMachine(AnimStateInput, double param);
|
|
95 |
|
|
96 |
// Animation has actually started, at passed time
|
|
97 |
void onAnimationStartResponse(double startTime)
|
|
98 |
{
|
|
99 |
updateStateMachine(AnimationBase::AnimationStateInputStartTimeSet, startTime);
|
|
100 |
}
|
|
101 |
|
|
102 |
// Called to change to or from paused state
|
|
103 |
void updatePlayState(bool running);
|
|
104 |
bool playStatePlaying() const;
|
|
105 |
|
|
106 |
bool waitingToStart() const { return m_animState == AnimationStateNew || m_animState == AnimationStateStartWaitTimer; }
|
|
107 |
bool preActive() const
|
|
108 |
{
|
|
109 |
return m_animState == AnimationStateNew || m_animState == AnimationStateStartWaitTimer || m_animState == AnimationStateStartWaitStyleAvailable || m_animState == AnimationStateStartWaitResponse;
|
|
110 |
}
|
|
111 |
|
|
112 |
bool postActive() const { return m_animState == AnimationStateDone; }
|
|
113 |
bool active() const { return !postActive() && !preActive(); }
|
|
114 |
bool running() const { return !isNew() && !postActive(); }
|
|
115 |
bool paused() const { return m_pauseTime >= 0; }
|
|
116 |
bool isNew() const { return m_animState == AnimationStateNew; }
|
|
117 |
bool waitingForStartTime() const { return m_animState == AnimationStateStartWaitResponse; }
|
|
118 |
bool waitingForStyleAvailable() const { return m_animState == AnimationStateStartWaitStyleAvailable; }
|
|
119 |
|
|
120 |
// "animating" means that something is running that requires a timer to keep firing
|
|
121 |
// (e.g. a software animation)
|
|
122 |
void setAnimating(bool inAnimating = true) { m_isAnimating = inAnimating; }
|
|
123 |
virtual double timeToNextService();
|
|
124 |
|
|
125 |
double progress(double scale, double offset, const TimingFunction*) const;
|
|
126 |
|
|
127 |
virtual void animate(CompositeAnimation*, RenderObject*, const RenderStyle* /*currentStyle*/, RenderStyle* /*targetStyle*/, RefPtr<RenderStyle>& /*animatedStyle*/) = 0;
|
|
128 |
virtual void getAnimatedStyle(RefPtr<RenderStyle>& /*animatedStyle*/) = 0;
|
|
129 |
|
|
130 |
virtual bool shouldFireEvents() const { return false; }
|
|
131 |
|
|
132 |
void fireAnimationEventsIfNeeded();
|
|
133 |
|
|
134 |
bool animationsMatch(const Animation*) const;
|
|
135 |
|
|
136 |
void setAnimation(const Animation* anim) { m_animation = const_cast<Animation*>(anim); }
|
|
137 |
|
|
138 |
// Return true if this animation is overridden. This will only be the case for
|
|
139 |
// ImplicitAnimations and is used to determine whether or not we should force
|
|
140 |
// set the start time. If an animation is overridden, it will probably not get
|
|
141 |
// back the AnimationStateInputStartTimeSet input.
|
|
142 |
virtual bool overridden() const { return false; }
|
|
143 |
|
|
144 |
// Does this animation/transition involve the given property?
|
|
145 |
virtual bool affectsProperty(int /*property*/) const { return false; }
|
|
146 |
bool isAnimatingProperty(int property, bool isRunningNow) const
|
|
147 |
{
|
|
148 |
if (m_fallbackAnimating)
|
|
149 |
return false;
|
|
150 |
|
|
151 |
if (isRunningNow)
|
|
152 |
return (!waitingToStart() && !postActive()) && affectsProperty(property);
|
|
153 |
|
|
154 |
return !postActive() && affectsProperty(property);
|
|
155 |
}
|
|
156 |
|
|
157 |
bool isTransformFunctionListValid() const { return m_transformFunctionListValid; }
|
|
158 |
|
|
159 |
// Freeze the animation; used by DumpRenderTree.
|
|
160 |
void freezeAtTime(double t);
|
|
161 |
|
|
162 |
double beginAnimationUpdateTime() const;
|
|
163 |
|
|
164 |
double getElapsedTime() const;
|
|
165 |
|
|
166 |
AnimationBase* next() const { return m_next; }
|
|
167 |
void setNext(AnimationBase* animation) { m_next = animation; }
|
|
168 |
|
|
169 |
void styleAvailable()
|
|
170 |
{
|
|
171 |
ASSERT(waitingForStyleAvailable());
|
|
172 |
updateStateMachine(AnimationBase::AnimationStateInputStyleAvailable, -1);
|
|
173 |
}
|
|
174 |
|
|
175 |
#if USE(ACCELERATED_COMPOSITING)
|
|
176 |
static bool animationOfPropertyIsAccelerated(int prop);
|
|
177 |
#endif
|
|
178 |
|
|
179 |
protected:
|
|
180 |
virtual void overrideAnimations() { }
|
|
181 |
virtual void resumeOverriddenAnimations() { }
|
|
182 |
|
|
183 |
CompositeAnimation* compositeAnimation() { return m_compAnim; }
|
|
184 |
|
|
185 |
// These are called when the corresponding timer fires so subclasses can do any extra work
|
|
186 |
virtual void onAnimationStart(double /*elapsedTime*/) { }
|
|
187 |
virtual void onAnimationIteration(double /*elapsedTime*/) { }
|
|
188 |
virtual void onAnimationEnd(double /*elapsedTime*/) { }
|
|
189 |
virtual bool startAnimation(double /*beginTime*/) { return false; }
|
|
190 |
virtual void endAnimation(bool /*reset*/) { }
|
|
191 |
|
|
192 |
void goIntoEndingOrLoopingState();
|
|
193 |
|
|
194 |
bool isFallbackAnimating() const { return m_fallbackAnimating; }
|
|
195 |
|
|
196 |
static bool propertiesEqual(int prop, const RenderStyle* a, const RenderStyle* b);
|
|
197 |
static int getPropertyAtIndex(int, bool& isShorthand);
|
|
198 |
static int getNumProperties();
|
|
199 |
|
|
200 |
// Return true if we need to start software animation timers
|
|
201 |
static bool blendProperties(const AnimationBase* anim, int prop, RenderStyle* dst, const RenderStyle* a, const RenderStyle* b, double progress);
|
|
202 |
|
|
203 |
static void setNeedsStyleRecalc(Node*);
|
|
204 |
|
|
205 |
void getTimeToNextEvent(double& time, bool& isLooping) const;
|
|
206 |
|
|
207 |
AnimState m_animState;
|
|
208 |
|
|
209 |
bool m_isAnimating; // transition/animation requires continual timer firing
|
|
210 |
double m_startTime;
|
|
211 |
double m_pauseTime;
|
|
212 |
double m_requestedStartTime;
|
|
213 |
RenderObject* m_object;
|
|
214 |
|
|
215 |
RefPtr<Animation> m_animation;
|
|
216 |
CompositeAnimation* m_compAnim;
|
|
217 |
bool m_fallbackAnimating; // true when animating an accelerated property but have to fall back to software
|
|
218 |
bool m_transformFunctionListValid;
|
|
219 |
double m_totalDuration, m_nextIterationDuration;
|
|
220 |
|
|
221 |
AnimationBase* m_next;
|
|
222 |
};
|
|
223 |
|
|
224 |
} // namespace WebCore
|
|
225 |
|
|
226 |
#endif // AnimationBase_h
|