4be26ed4078dffbc2bb0a400995e33f6637f37ba
[WebKit.git] / Source / WebCore / page / animation / ImplicitAnimation.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
31 #include "AnimationControllerPrivate.h"
32 #include "CompositeAnimation.h"
33 #include "EventNames.h"
34 #include "ImplicitAnimation.h"
35 #include "KeyframeAnimation.h"
36 #include "RenderLayer.h"
37 #include "RenderLayerBacking.h"
38 #include <wtf/UnusedParam.h>
39
40 namespace WebCore {
41
42 ImplicitAnimation::ImplicitAnimation(const Animation* transition, CSSPropertyID animatingProperty, RenderObject* renderer, CompositeAnimation* compAnim, RenderStyle* fromStyle)
43     : AnimationBase(transition, renderer, compAnim)
44     , m_transitionProperty(transition->property())
45     , m_animatingProperty(animatingProperty)
46     , m_overridden(false)
47     , m_active(true)
48     , m_fromStyle(fromStyle)
49 {
50     ASSERT(animatingProperty != CSSPropertyInvalid);
51 }
52
53 ImplicitAnimation::~ImplicitAnimation()
54 {
55     // // Make sure to tell the renderer that we are ending. This will make sure any accelerated animations are removed.
56     if (!postActive())
57         endAnimation();
58 }
59
60 bool ImplicitAnimation::shouldSendEventForListener(Document::ListenerType inListenerType) const
61 {
62     return m_object->document()->hasListenerType(inListenerType);
63 }
64
65 void ImplicitAnimation::animate(CompositeAnimation*, RenderObject*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle)
66 {
67     // If we get this far and the animation is done, it means we are cleaning up a just finished animation.
68     // So just return. Everything is already all cleaned up.
69     if (postActive())
70         return;
71
72     // Reset to start the transition if we are new
73     if (isNew())
74         reset(targetStyle);
75
76     // Run a cycle of animation.
77     // We know we will need a new render style, so make one if needed
78     if (!animatedStyle)
79         animatedStyle = RenderStyle::clone(targetStyle);
80
81     bool needsAnim = blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
82     // FIXME: we also need to detect cases where we have to software animate for other reasons,
83     // such as a child using inheriting the transform. https://bugs.webkit.org/show_bug.cgi?id=23902
84     if (needsAnim)
85         setAnimating();
86     else {
87 #if USE(ACCELERATED_COMPOSITING)
88         // If we are running an accelerated animation, set a flag in the style which causes the style
89         // to compare as different to any other style. This ensures that changes to the property
90         // that is animating are correctly detected during the animation (e.g. when a transition
91         // gets interrupted).
92         animatedStyle->setIsRunningAcceleratedAnimation();
93 #endif
94     }
95
96     // Fire the start timeout if needed
97     fireAnimationEventsIfNeeded();
98 }
99
100 void ImplicitAnimation::getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle)
101 {
102     if (!animatedStyle)
103         animatedStyle = RenderStyle::clone(m_toStyle.get());
104
105     blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
106 }
107
108 bool ImplicitAnimation::startAnimation(double timeOffset)
109 {
110 #if USE(ACCELERATED_COMPOSITING)
111     if (m_object && m_object->hasLayer()) {
112         RenderLayer* layer = toRenderBoxModelObject(m_object)->layer();
113         if (layer->isComposited())
114             return layer->backing()->startTransition(timeOffset, m_animatingProperty, m_fromStyle.get(), m_toStyle.get());
115     }
116 #else
117     UNUSED_PARAM(timeOffset);
118 #endif
119     return false;
120 }
121
122 void ImplicitAnimation::pauseAnimation(double timeOffset)
123 {
124     if (!m_object)
125         return;
126
127 #if USE(ACCELERATED_COMPOSITING)
128     if (m_object->hasLayer()) {
129         RenderLayer* layer = toRenderBoxModelObject(m_object)->layer();
130         if (layer->isComposited())
131             layer->backing()->transitionPaused(timeOffset, m_animatingProperty);
132     }
133 #else
134     UNUSED_PARAM(timeOffset);
135 #endif
136     // Restore the original (unanimated) style
137     if (!paused())
138         setNeedsStyleRecalc(m_object->node());
139 }
140
141 void ImplicitAnimation::endAnimation()
142 {
143 #if USE(ACCELERATED_COMPOSITING)
144     if (m_object && m_object->hasLayer()) {
145         RenderLayer* layer = toRenderBoxModelObject(m_object)->layer();
146         if (layer->isComposited())
147             layer->backing()->transitionFinished(m_animatingProperty);
148     }
149 #endif
150 }
151
152 void ImplicitAnimation::onAnimationEnd(double elapsedTime)
153 {
154     // If we have a keyframe animation on this property, this transition is being overridden. The keyframe
155     // animation keeps an unanimated style in case a transition starts while the keyframe animation is
156     // running. But now that the transition has completed, we need to update this style with its new
157     // destination. If we didn't, the next time through we would think a transition had started
158     // (comparing the old unanimated style with the new final style of the transition).
159     RefPtr<KeyframeAnimation> keyframeAnim = m_compAnim->getAnimationForProperty(m_animatingProperty);
160     if (keyframeAnim)
161         keyframeAnim->setUnanimatedStyle(m_toStyle);
162     
163     sendTransitionEvent(eventNames().webkitTransitionEndEvent, elapsedTime);
164     endAnimation();
165 }
166
167 bool ImplicitAnimation::sendTransitionEvent(const AtomicString& eventType, double elapsedTime)
168 {
169     if (eventType == eventNames().webkitTransitionEndEvent) {
170         Document::ListenerType listenerType = Document::TRANSITIONEND_LISTENER;
171
172         if (shouldSendEventForListener(listenerType)) {
173             String propertyName = getPropertyName(m_animatingProperty);
174                 
175             // Dispatch the event
176             RefPtr<Element> element = 0;
177             if (m_object->node() && m_object->node()->isElementNode())
178                 element = static_cast<Element*>(m_object->node());
179
180             ASSERT(!element || (element->document() && !element->document()->inPageCache()));
181             if (!element)
182                 return false;
183
184             // Schedule event handling
185             m_compAnim->animationController()->addEventToDispatch(element, eventType, propertyName, elapsedTime);
186
187             // Restore the original (unanimated) style
188             if (eventType == eventNames().webkitTransitionEndEvent && element->renderer())
189                 setNeedsStyleRecalc(element.get());
190
191             return true; // Did dispatch an event
192         }
193     }
194
195     return false; // Didn't dispatch an event
196 }
197
198 void ImplicitAnimation::reset(RenderStyle* to)
199 {
200     ASSERT(to);
201     ASSERT(m_fromStyle);
202
203     m_toStyle = to;
204
205     // Restart the transition
206     if (m_fromStyle && m_toStyle)
207         updateStateMachine(AnimationStateInputRestartAnimation, -1);
208         
209     // set the transform animation list
210     validateTransformFunctionList();
211 #if ENABLE(CSS_FILTERS)
212     checkForMatchingFilterFunctionLists();
213 #endif
214 }
215
216 void ImplicitAnimation::setOverridden(bool b)
217 {
218     if (b == m_overridden)
219         return;
220
221     m_overridden = b;
222     updateStateMachine(m_overridden ? AnimationStateInputPauseOverride : AnimationStateInputResumeOverride, -1);
223 }
224
225 bool ImplicitAnimation::affectsProperty(CSSPropertyID property) const
226 {
227     return (m_animatingProperty == property);
228 }
229
230 bool ImplicitAnimation::isTargetPropertyEqual(CSSPropertyID prop, const RenderStyle* targetStyle)
231 {
232     // We can get here for a transition that has not started yet. This would make m_toStyle unset and null. 
233     // So we check that here (see <https://bugs.webkit.org/show_bug.cgi?id=26706>)
234     if (!m_toStyle)
235         return false;
236     return propertiesEqual(prop, m_toStyle.get(), targetStyle);
237 }
238
239 void ImplicitAnimation::blendPropertyValueInStyle(CSSPropertyID prop, RenderStyle* currentStyle)
240 {
241     // We should never add a transition with a 0 duration and delay. But if we ever did
242     // it would have a null toStyle. So just in case, let's check that here. (See
243     // <https://bugs.webkit.org/show_bug.cgi?id=24787>
244     if (!m_toStyle)
245         return;
246         
247     blendProperties(this, prop, currentStyle, m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
248 }
249
250 void ImplicitAnimation::validateTransformFunctionList()
251 {
252     m_transformFunctionListValid = false;
253     
254     if (!m_fromStyle || !m_toStyle)
255         return;
256         
257     const TransformOperations* val = &m_fromStyle->transform();
258     const TransformOperations* toVal = &m_toStyle->transform();
259
260     if (val->operations().isEmpty())
261         val = toVal;
262
263     if (val->operations().isEmpty())
264         return;
265         
266     // An emtpy transform list matches anything.
267     if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal))
268         return;
269
270     // Transform lists match.
271     m_transformFunctionListValid = true;
272 }
273
274 #if ENABLE(CSS_FILTERS)
275 void ImplicitAnimation::checkForMatchingFilterFunctionLists()
276 {
277     m_filterFunctionListsMatch = false;
278     
279     if (!m_fromStyle || !m_toStyle)
280         return;
281         
282     const FilterOperations* val = &m_fromStyle->filter();
283     const FilterOperations* toVal = &m_toStyle->filter();
284
285     if (val->operations().isEmpty())
286         val = toVal;
287
288     if (val->operations().isEmpty())
289         return;
290         
291     // An emtpy filter list matches anything.
292     if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal))
293         return;
294
295     // Filter lists match.
296     m_filterFunctionListsMatch = true;
297 }
298 #endif
299
300 double ImplicitAnimation::timeToNextService()
301 {
302     double t = AnimationBase::timeToNextService();
303 #if USE(ACCELERATED_COMPOSITING)
304     if (t != 0 || preActive())
305         return t;
306         
307     // A return value of 0 means we need service. But if this is an accelerated animation we 
308     // only need service at the end of the transition.
309     if (animationOfPropertyIsAccelerated(m_animatingProperty) && isAccelerated()) {
310         bool isLooping;
311         getTimeToNextEvent(t, isLooping);
312     }
313 #endif
314     return t;
315 }
316
317 } // namespace WebCore