Fix unsigned/enum problem on Win32. r=darin.
[WebKit-https.git] / WebCore / page / AnimationController.cpp
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 #include "config.h"
30 #include "AnimationController.h"
31
32 #include "CSSPropertyNames.h"
33 #include "Document.h"
34 #include "FloatConversion.h"
35 #include "Frame.h"
36 #include "RenderObject.h"
37 #include "RenderStyle.h"
38 #include "SystemTime.h"
39 #include "Timer.h"
40
41 namespace WebCore {
42
43 static const double cAnimationTimerDelay = 0.025;
44
45 struct CurveData {
46     CurveData(double p1x, double p1y, double p2x, double p2y)
47     {
48         // Calculate the polynomial coefficients, implicit first and last control points are (0,0) and (1,1).
49         cx = 3.0 * p1x;
50         bx = 3.0 * (p2x - p1x) - cx;
51         ax = 1.0 - cx -bx;
52          
53         cy = 3.0 * p1y;
54         by = 3.0 * (p2y - p1y) - cy;
55         ay = 1.0 - cy - by;
56     }
57     
58     double sampleCurveX(double t)
59     {
60         // `ax t^3 + bx t^2 + cx t' expanded using Horner's rule.
61         return ((ax * t + bx) * t + cx) * t;
62     }
63     
64     double sampleCurveY(double t)
65     {
66         return ((ay * t + by) * t + cy) * t;
67     }
68     
69     double sampleCurveDerivativeX(double t)
70     {
71         return (3.0 * ax * t + 2.0 * bx) * t + cx;
72     }
73     
74     // Given an x value, find a parametric value it came from.
75     double solveCurveX(double x, double epsilon)
76     {
77         double t0;
78         double t1;
79         double t2;
80         double x2;
81         double d2;
82         int i;
83
84         // First try a few iterations of Newton's method -- normally very fast.
85         for (t2 = x, i = 0; i < 8; i++) {
86             x2 = sampleCurveX(t2) - x;
87             if (fabs (x2) < epsilon)
88                 return t2;
89             d2 = sampleCurveDerivativeX(t2);
90             if (fabs(d2) < 1e-6)
91                 break;
92             t2 = t2 - x2 / d2;
93         }
94
95         // Fall back to the bisection method for reliability.
96         t0 = 0.0;
97         t1 = 1.0;
98         t2 = x;
99
100         if (t2 < t0)
101             return t0;
102         if (t2 > t1)
103             return t1;
104
105         while (t0 < t1) {
106             x2 = sampleCurveX(t2);
107             if (fabs(x2 - x) < epsilon)
108                 return t2;
109             if (x > x2)
110                 t0 = t2;
111             else
112                 t1 = t2;
113             t2 = (t1 - t0) * .5 + t0;
114         }
115
116         // Failure.
117         return t2;
118     }
119     
120 private:
121     double ax;
122     double bx;
123     double cx;
124     
125     double ay;
126     double by;
127     double cy;
128 };
129
130 // The epsilon value we pass to solveCurveX given that the animation is going to run over |dur| seconds. The longer the
131 // animation, the more precision we need in the timing function result to avoid ugly discontinuities.
132 static inline double solveEpsilon(double duration) { return 1. / (200. * duration); }
133
134 static inline double solveCubicBezierFunction(double p1x, double p1y, double p2x, double p2y, double t, double duration)
135 {
136     // Convert from input time to parametric value in curve, then from
137     // that to output time.
138     CurveData c(p1x, p1y, p2x, p2y);
139     t = c.solveCurveX(t, solveEpsilon(duration));
140     t = c.sampleCurveY(t);
141     return t;
142 }
143
144 class CompositeImplicitAnimation;
145
146 class ImplicitAnimation : public Noncopyable {
147 public:
148     ImplicitAnimation(const Transition*);
149     ~ImplicitAnimation();
150
151     void animate(CompositeImplicitAnimation*, RenderObject*, RenderStyle* currentStyle, RenderStyle* targetStyle, RenderStyle*& animatedStyle);
152
153     void reset(RenderObject*, RenderStyle* from, RenderStyle* to);
154     
155     double progress() const;
156
157     bool finished() const { return m_finished; }
158
159 private:
160     // The two styles that we are blending.
161     RenderStyle* m_fromStyle;
162     RenderStyle* m_toStyle;
163
164     int m_property;
165     TimingFunction m_function;
166     double m_duration;
167
168     int m_repeatCount;
169     int m_iteration;
170     
171     bool m_finished;    
172     double m_startTime;
173     bool m_paused;
174     double m_pauseTime;
175 };
176
177 class CompositeImplicitAnimation : public Noncopyable {
178 public:
179     ~CompositeImplicitAnimation() { deleteAllValues(m_animations); }
180
181     RenderStyle* animate(RenderObject*, RenderStyle* currentStyle, RenderStyle* targetStyle);
182
183     bool animating() const;
184
185     bool hasAnimationForProperty(int prop) const { return m_animations.contains(prop); }
186
187     void reset(RenderObject*);
188
189 private:
190     HashMap<int, ImplicitAnimation*> m_animations;
191 };
192
193 ImplicitAnimation::ImplicitAnimation(const Transition* transition)
194 : m_fromStyle(0)
195 , m_toStyle(0)
196 , m_property(transition->transitionProperty())
197 , m_function(transition->transitionTimingFunction())
198 , m_duration(transition->transitionDuration() / 1000.0)
199 , m_repeatCount(transition->transitionRepeatCount())
200 , m_iteration(0)
201 , m_finished(false)
202 , m_startTime(currentTime())
203 , m_paused(false)
204 , m_pauseTime(m_startTime)
205 {
206 }
207
208 ImplicitAnimation::~ImplicitAnimation()
209 {
210     ASSERT(!m_fromStyle && !m_toStyle);
211 }
212
213 void ImplicitAnimation::reset(RenderObject* renderer, RenderStyle* from, RenderStyle* to)
214 {
215     if (m_fromStyle)
216         m_fromStyle->deref(renderer->renderArena());
217     if (m_toStyle)
218         m_toStyle->deref(renderer->renderArena());
219     m_fromStyle = from;
220     if (m_fromStyle)
221         m_fromStyle->ref();
222     m_toStyle = to;
223     if (m_toStyle)
224         m_toStyle->ref();
225     m_finished = false;
226     if (from || to)
227         m_startTime = currentTime();
228 }
229
230 double ImplicitAnimation::progress() const
231 {
232     double elapsedTime = currentTime() - m_startTime;
233     
234     if (m_finished || !m_duration || elapsedTime >= m_duration)
235         return 1.0;
236
237     if (m_function.type() == LinearTimingFunction)
238         return elapsedTime / m_duration;
239     
240     // Cubic bezier.
241     return solveCubicBezierFunction(m_function.x1(), m_function.y1(), 
242                                     m_function.x2(), m_function.y2(),
243                                     elapsedTime / m_duration, m_duration);
244 }
245
246 static inline int blendFunc(int from, int to, double progress)
247 {  
248     return int(from + (to - from) * progress);
249 }
250
251 static inline double blendFunc(double from, double to, double progress)
252 {  
253     return from + (to - from) * progress;
254 }
255
256 static inline float blendFunc(float from, float to, double progress)
257 {  
258     return narrowPrecisionToFloat(from + (to - from) * progress);
259 }
260
261 static inline Color blendFunc(const Color& from, const Color& to, double progress)
262 {  
263     return Color(blendFunc(from.red(), to.red(), progress),
264                  blendFunc(from.green(), to.green(), progress),
265                  blendFunc(from.blue(), to.blue(), progress),
266                  blendFunc(from.alpha(), to.alpha(), progress));
267 }
268
269 static inline Length blendFunc(const Length& from, const Length& to, double progress)
270 {  
271     return to.blend(from, progress);
272 }
273
274 static inline IntSize blendFunc(const IntSize& from, const IntSize& to, double progress)
275 {  
276     return IntSize(blendFunc(from.width(), to.width(), progress),
277                    blendFunc(from.height(), to.height(), progress));
278 }
279
280 static inline ShadowData* blendFunc(const ShadowData* from, const ShadowData* to, double progress)
281 {  
282     ASSERT(from && to);
283     return new ShadowData(blendFunc(from->x, to->x, progress), blendFunc(from->y, to->y, progress), blendFunc(from->blur, to->blur, progress), blendFunc(from->color, to->color, progress));
284 }
285
286 static inline TransformOperations blendFunc(const TransformOperations& from, const TransformOperations& to, double progress)
287 {    
288     // Blend any operations whose types actually match up.  Otherwise don't bother.
289     unsigned fromSize = from.size();
290     unsigned toSize = to.size();
291     unsigned size = max(fromSize, toSize);
292     TransformOperations result;
293     for (unsigned i = 0; i < size; i++) {
294         TransformOperation* fromOp = i < fromSize ? from[i].get() : 0;
295         TransformOperation* toOp = i < toSize ? to[i].get() : 0;
296         TransformOperation* blendedOp = toOp ? toOp->blend(fromOp, progress) : fromOp->blend(0, progress, true);
297         result.append(blendedOp);
298     }
299     return result;
300 }
301
302 static inline EVisibility blendFunc(EVisibility from, EVisibility to, double progress)
303 {
304     // Any non-zero result means we consider the object to be visible.  Only at 0 do we consider the object to be
305     // invisible.   The invisible value we use (HIDDEN vs. COLLAPSE) depends on the specified from/to values.
306     double fromVal = from == VISIBLE ? 1. : 0.;
307     double toVal = to == VISIBLE ? 1. : 0.;
308     if (fromVal == toVal)
309         return to;
310     double result = blendFunc(fromVal, toVal, progress);
311     return result > 0. ? VISIBLE : (to != VISIBLE ? to : from);
312 }
313
314 #define BLEND(prop, getter, setter) \
315     if (m_property == prop && m_toStyle->getter() != targetStyle->getter()) \
316         reset(renderer, currentStyle, targetStyle); \
317     \
318     if ((m_property == cAnimateAll && !animation->hasAnimationForProperty(prop)) || m_property == prop) { \
319         if (m_fromStyle->getter() != m_toStyle->getter()) {\
320             m_finished = false; \
321             if (!animatedStyle) \
322                 animatedStyle = new (renderer->renderArena()) RenderStyle(*targetStyle); \
323             animatedStyle->setter(blendFunc(m_fromStyle->getter(), m_toStyle->getter(), progress()));\
324             if (m_property == prop) \
325                 return; \
326         }\
327     }\
328
329 #define BLEND_SHADOW(prop, getter, setter) \
330     if (m_property == prop && (!m_toStyle->getter() || !targetStyle->getter() || *m_toStyle->getter() != *targetStyle->getter())) \
331         reset(renderer, currentStyle, targetStyle); \
332     \
333     if ((m_property == cAnimateAll && !animation->hasAnimationForProperty(prop)) || m_property == prop) { \
334         if (m_fromStyle->getter() && m_toStyle->getter() && *m_fromStyle->getter() != *m_toStyle->getter()) {\
335             m_finished = false; \
336             if (!animatedStyle) \
337                 animatedStyle = new (renderer->renderArena()) RenderStyle(*targetStyle); \
338             animatedStyle->setter(blendFunc(m_fromStyle->getter(), m_toStyle->getter(), progress()));\
339             if (m_property == prop) \
340                 return; \
341         }\
342     }
343
344 void ImplicitAnimation::animate(CompositeImplicitAnimation* animation, RenderObject* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle, RenderStyle*& animatedStyle)
345 {
346     // FIXME: If we have no transition-property, then the only way to tell if our goal state changed is to check
347     // every single animatable property.  For now we'll just diff the styles to ask that question,
348     // but we should really exclude non-animatable properties.
349     if (!m_toStyle || (m_property == cAnimateAll && targetStyle->diff(m_toStyle)))
350         reset(renderer, currentStyle, targetStyle);
351
352     // FIXME: Blow up shorthands so that they can be honored.
353     m_finished = true;
354     BLEND(CSS_PROP_LEFT, left, setLeft);
355     BLEND(CSS_PROP_RIGHT, right, setRight);
356     BLEND(CSS_PROP_TOP, top, setTop);
357     BLEND(CSS_PROP_BOTTOM, bottom, setBottom);
358     BLEND(CSS_PROP_WIDTH, width, setWidth);
359     BLEND(CSS_PROP_HEIGHT, height, setHeight);
360     BLEND(CSS_PROP_BORDER_LEFT_WIDTH, borderLeftWidth, setBorderLeftWidth);
361     BLEND(CSS_PROP_BORDER_RIGHT_WIDTH, borderRightWidth, setBorderRightWidth);
362     BLEND(CSS_PROP_BORDER_TOP_WIDTH, borderTopWidth, setBorderTopWidth);
363     BLEND(CSS_PROP_BORDER_BOTTOM_WIDTH, borderBottomWidth, setBorderBottomWidth);
364     BLEND(CSS_PROP_MARGIN_LEFT, marginLeft, setMarginLeft);
365     BLEND(CSS_PROP_MARGIN_RIGHT, marginRight, setMarginRight);
366     BLEND(CSS_PROP_MARGIN_TOP, marginTop, setMarginTop);
367     BLEND(CSS_PROP_MARGIN_BOTTOM, marginBottom, setMarginBottom);
368     BLEND(CSS_PROP_PADDING_LEFT, paddingLeft, setPaddingLeft);
369     BLEND(CSS_PROP_PADDING_RIGHT, paddingRight, setPaddingRight);
370     BLEND(CSS_PROP_PADDING_TOP, paddingTop, setPaddingTop);
371     BLEND(CSS_PROP_PADDING_BOTTOM, paddingBottom, setPaddingBottom);
372     BLEND(CSS_PROP_OPACITY, opacity, setOpacity);
373     BLEND(CSS_PROP_COLOR, color, setColor);
374     BLEND(CSS_PROP_BACKGROUND_COLOR, backgroundColor, setBackgroundColor);
375     BLEND(CSS_PROP__WEBKIT_COLUMN_RULE_COLOR, columnRuleColor, setColumnRuleColor);
376     BLEND(CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH, columnRuleWidth, setColumnRuleWidth);
377     BLEND(CSS_PROP__WEBKIT_COLUMN_GAP, columnGap, setColumnGap);
378     BLEND(CSS_PROP__WEBKIT_COLUMN_COUNT, columnCount, setColumnCount);
379     BLEND(CSS_PROP__WEBKIT_COLUMN_WIDTH, columnWidth, setColumnWidth);
380     BLEND(CSS_PROP__WEBKIT_TEXT_STROKE_COLOR, textStrokeColor, setTextStrokeColor);
381     BLEND(CSS_PROP__WEBKIT_TEXT_FILL_COLOR, textFillColor, setTextFillColor);
382     BLEND(CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING, horizontalBorderSpacing, setHorizontalBorderSpacing);
383     BLEND(CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING, verticalBorderSpacing, setVerticalBorderSpacing);
384     BLEND(CSS_PROP_BORDER_LEFT_COLOR, borderLeftColor, setBorderLeftColor);
385     BLEND(CSS_PROP_BORDER_RIGHT_COLOR, borderRightColor, setBorderRightColor);
386     BLEND(CSS_PROP_BORDER_TOP_COLOR, borderTopColor, setBorderTopColor);
387     BLEND(CSS_PROP_BORDER_BOTTOM_COLOR, borderBottomColor, setBorderBottomColor);
388     BLEND(CSS_PROP_Z_INDEX, zIndex, setZIndex);
389     BLEND(CSS_PROP_LINE_HEIGHT, lineHeight, setLineHeight);
390     BLEND(CSS_PROP_OUTLINE_COLOR, outlineColor, setOutlineColor);
391     BLEND(CSS_PROP_OUTLINE_OFFSET, outlineOffset, setOutlineOffset);
392     BLEND(CSS_PROP_OUTLINE_WIDTH, outlineWidth, setOutlineWidth);
393     BLEND(CSS_PROP_LETTER_SPACING, letterSpacing, setLetterSpacing);
394     BLEND(CSS_PROP_WORD_SPACING, wordSpacing, setWordSpacing);
395     BLEND_SHADOW(CSS_PROP__WEBKIT_BOX_SHADOW, boxShadow, setBoxShadow);
396     BLEND_SHADOW(CSS_PROP_TEXT_SHADOW, textShadow, setTextShadow);
397     BLEND(CSS_PROP__WEBKIT_TRANSFORM, transform, setTransform);
398     BLEND(CSS_PROP__WEBKIT_TRANSFORM_ORIGIN_X, transformOriginX, setTransformOriginX);
399     BLEND(CSS_PROP__WEBKIT_TRANSFORM_ORIGIN_Y, transformOriginY, setTransformOriginY);
400     BLEND(CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS, borderTopLeftRadius, setBorderTopLeftRadius);
401     BLEND(CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS, borderTopRightRadius, setBorderTopRightRadius);
402     BLEND(CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS, borderBottomLeftRadius, setBorderBottomLeftRadius);
403     BLEND(CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS, borderBottomRightRadius, setBorderBottomRightRadius);
404     BLEND(CSS_PROP_VISIBILITY, visibility, setVisibility);
405 }
406
407 RenderStyle* CompositeImplicitAnimation::animate(RenderObject* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
408 {
409     // Get the animation layers from the target style.
410     // For each one, we need to create a new animation unless one exists already (later occurrences of duplicate
411     // triggers in the layer list get ignored).
412     if (m_animations.isEmpty()) {
413         for (const Transition* transition = targetStyle->transitions(); transition; transition = transition->next()) {
414             int property = transition->transitionProperty();
415             int duration = transition->transitionDuration();
416             int repeatCount = transition->transitionRepeatCount();
417             if (property && duration && repeatCount && !m_animations.contains(property)) {
418                 ImplicitAnimation* animation = new ImplicitAnimation(transition);
419                 m_animations.set(property, animation);
420             }
421         }
422     }
423
424     // Now that we have animation objects ready, let them know about the new goal state.  We want them
425     // to fill in a RenderStyle*& only if needed.
426     RenderStyle* result = 0;
427     HashMap<int, ImplicitAnimation*>::iterator end = m_animations.end();
428     for (HashMap<int, ImplicitAnimation*>::iterator it = m_animations.begin(); it != end; ++it)
429         it->second->animate(this, renderer, currentStyle, targetStyle, result);
430     
431     if (result)
432         return result;
433
434     return targetStyle;
435 }
436
437 bool CompositeImplicitAnimation::animating() const
438 {
439     HashMap<int, ImplicitAnimation*>::const_iterator end = m_animations.end();
440     for (HashMap<int, ImplicitAnimation*>::const_iterator it = m_animations.begin(); it != end; ++it)
441         if (!it->second->finished())
442             return true;
443     return false;
444 }
445
446 void CompositeImplicitAnimation::reset(RenderObject* renderer)
447 {
448     HashMap<int, ImplicitAnimation*>::const_iterator end = m_animations.end();
449     for (HashMap<int, ImplicitAnimation*>::const_iterator it = m_animations.begin(); it != end; ++it)
450         it->second->reset(renderer, 0, 0);
451 }
452
453 class AnimationControllerPrivate {
454 public:
455     AnimationControllerPrivate(Frame*);
456     ~AnimationControllerPrivate();
457
458     CompositeImplicitAnimation* get(RenderObject*);
459     bool clear(RenderObject*);
460     
461     void timerFired(Timer<AnimationControllerPrivate>*);
462     void updateTimer();
463
464     bool hasImplicitAnimations() const { return !m_animations.isEmpty(); }
465
466 private:
467     HashMap<RenderObject*, CompositeImplicitAnimation*> m_animations;
468     Timer<AnimationControllerPrivate> m_timer;
469     Frame* m_frame;
470 };
471
472 AnimationControllerPrivate::AnimationControllerPrivate(Frame* frame)
473     : m_timer(this, &AnimationControllerPrivate::timerFired)
474     , m_frame(frame)
475 {
476 }
477
478 AnimationControllerPrivate::~AnimationControllerPrivate()
479 {
480     deleteAllValues(m_animations);
481 }
482
483 CompositeImplicitAnimation* AnimationControllerPrivate::get(RenderObject* renderer)
484 {
485     CompositeImplicitAnimation* animation = m_animations.get(renderer);
486     if (!animation) {
487         animation = new CompositeImplicitAnimation();
488         m_animations.set(renderer, animation);
489     }
490     return animation;
491 }
492
493 bool AnimationControllerPrivate::clear(RenderObject* renderer)
494 {
495     CompositeImplicitAnimation* animation = m_animations.take(renderer);
496     if (!animation)
497         return false;
498     animation->reset(renderer);
499     delete animation;
500     return true;
501 }
502
503 void AnimationControllerPrivate::updateTimer()
504 {
505     bool animating = false;
506     HashMap<RenderObject*, CompositeImplicitAnimation*>::iterator end = m_animations.end();
507     for (HashMap<RenderObject*, CompositeImplicitAnimation*>::iterator it = m_animations.begin(); it != end; ++it) {
508         if (it->second->animating()) {
509             animating = true;
510             break;
511         }
512     }
513     
514     if (animating) {
515         if (!m_timer.isActive())
516             m_timer.startRepeating(cAnimationTimerDelay);
517     } else if (m_timer.isActive())
518         m_timer.stop();
519 }
520
521 void AnimationControllerPrivate::timerFired(Timer<AnimationControllerPrivate>* timer)
522 {
523     // When the timer fires, all we do is call setChanged on all DOM nodes with running animations and then do an immediate
524     // updateRendering.  It will then call back to us with new information.
525     bool animating = false;
526     HashMap<RenderObject*, CompositeImplicitAnimation*>::iterator end = m_animations.end();
527     for (HashMap<RenderObject*, CompositeImplicitAnimation*>::iterator it = m_animations.begin(); it != end; ++it) {
528         if (it->second->animating()) {
529             animating = true;
530             it->first->element()->setChanged();
531         }
532     }
533     
534     m_frame->document()->updateRendering();
535     
536     updateTimer();
537 }
538
539 AnimationController::AnimationController(Frame* frame)
540 :m_data(new AnimationControllerPrivate(frame))
541 {
542
543 }
544
545 AnimationController::~AnimationController()
546 {
547     delete m_data;
548 }
549
550 void AnimationController::cancelImplicitAnimations(RenderObject* renderer)
551 {
552     if (!m_data->hasImplicitAnimations())
553         return;
554
555     if (m_data->clear(renderer))
556         renderer->element()->setChanged();
557 }
558
559 RenderStyle* AnimationController::updateImplicitAnimations(RenderObject* renderer, RenderStyle* newStyle)
560 {
561     // Fetch our current set of implicit animations from a hashtable.  We then compare them
562     // against the animations in the style and make sure we're in sync.  If destination values
563     // have changed, we reset the animation.  We then do a blend to get new values and we return
564     // a new style.
565     ASSERT(renderer->element()); // FIXME: We do not animate generated content yet.
566     
567     CompositeImplicitAnimation* animation = m_data->get(renderer);
568     RenderStyle* result = animation->animate(renderer, renderer->style(), newStyle);
569     m_data->updateTimer();
570     return result;
571 }
572
573 void AnimationController::suspendAnimations()
574 {
575     // FIXME: Walk the whole hashtable and call pause on each animation.
576     // Kill our timer.
577 }
578
579 void AnimationController::resumeAnimations()
580 {
581     // FIXME: Walk the whole hashtable and call resume on each animation.
582     // Start our timer.
583 }
584
585 }