void AnimationControllerPrivate::styleAvailable()
{
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin();
it != animationsEnd; ++it) {
it->second->styleAvailable();
}
}
CompositeAnimation* AnimationControllerPrivate::accessCompositeAnimation(RenderObject* renderer)
{
CompositeAnimation* animation = m_compositeAnimations.get(renderer);
if (!animation) {
animation = new CompositeAnimation(m_frame->animation());
m_compositeAnimations.set(renderer, animation);
}
return animation;
}
PassRefPtr<CompositeAnimation> AnimationControllerPrivate::accessCompositeAnimation(RenderObject* renderer)
{
RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
if (!animation) {
animation = CompositeAnimation::create(m_frame->animation());
m_compositeAnimations.set(renderer, animation);
}
return animation;
}
void AnimationControllerPrivate::resumeAnimations(Document* document)
{
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
RenderObject* renderer = it->first;
CompositeAnimation* compAnim = it->second;
if (renderer->document() == document)
compAnim->resumeAnimations();
}
updateAnimationTimer();
}
bool AnimationControllerPrivate::isAnimatingPropertyOnRenderer(RenderObject* obj, int property, bool isRunningNow) const
{
CompositeAnimation* animation = m_compositeAnimations.get(obj);
if (!animation) return false;
return animation->isAnimatingProperty(property, isRunningNow);
}
void AnimationControllerPrivate::styleAvailable()
{
// styleAvailable() can call event handlers which would ultimately delete a CompositeAnimation
// from the m_compositeAnimations table. So we can't iterate it directly. We will instead build
// a list of CompositeAnimations which need the styleAvailable() call iterate over that.
Vector<RefPtr<CompositeAnimation> > list;
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it)
if (it->second->isWaitingForStyleAvailable())
list.append(it->second);
Vector<RefPtr<CompositeAnimation> >::const_iterator listEnd = list.end();
for (Vector<RefPtr<CompositeAnimation> >::const_iterator it = list.begin(); it != listEnd; ++it)
(*it)->styleAvailable();
}
void AnimationControllerPrivate::updateAnimationTimer(bool callSetChanged/* = false*/)
{
double needsService = -1;
bool calledSetChanged = false;
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
RefPtr<CompositeAnimation> compAnim = it->second;
if (!compAnim->isSuspended()) {
double t = compAnim->willNeedService();
if (t != -1 && (t < needsService || needsService == -1))
needsService = t;
if (needsService == 0) {
if (callSetChanged) {
Node* node = it->first->element();
ASSERT(!node || (node->document() && !node->document()->inPageCache()));
node->setChanged(AnimationStyleChange);
calledSetChanged = true;
}
else
break;
}
}
}
if (calledSetChanged)
m_frame->document()->updateRendering();
// If we want service immediately, we start a repeating timer to reduce the overhead of starting
if (needsService == 0) {
if (!m_animationTimer.isActive() || m_animationTimer.repeatInterval() == 0)
m_animationTimer.startRepeating(cAnimationTimerDelay);
return;
}
// If we don't need service, we want to make sure the timer is no longer running
if (needsService < 0) {
if (m_animationTimer.isActive())
m_animationTimer.stop();
return;
}
// Otherwise, we want to start a one-shot timer so we get here again
if (m_animationTimer.isActive())
m_animationTimer.stop();
m_animationTimer.startOneShot(needsService);
}
void AnimationControllerPrivate::updateAnimationTimer()
{
bool animating = false;
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
CompositeAnimation* compAnim = it->second;
if (!compAnim->suspended() && compAnim->animating()) {
animating = true;
break;
}
}
if (animating) {
if (!m_animationTimer.isActive())
m_animationTimer.startRepeating(cAnimationTimerDelay);
} else if (m_animationTimer.isActive())
m_animationTimer.stop();
}
bool AnimationControllerPrivate::clear(RenderObject* renderer)
{
// Return false if we didn't do anything OR we are suspended (so we don't try to
// do a setChanged() when suspended).
PassRefPtr<CompositeAnimation> animation = m_compositeAnimations.take(renderer);
if (!animation)
return false;
animation->clearRenderer();
return animation->isSuspended();
}
bool AnimationControllerPrivate::clear(RenderObject* renderer)
{
// Return false if we didn't do anything OR we are suspended (so we don't try to
// do a setChanged() when suspended
CompositeAnimation* animation = m_compositeAnimations.take(renderer);
if (!animation)
return false;
animation->resetTransitions(renderer);
bool wasSuspended = animation->suspended();
delete animation;
return !wasSuspended;
}
void AnimationControllerPrivate::animationTimerFired(Timer<AnimationControllerPrivate>* timer)
{
// When the timer fires, all we do is call setChanged on all DOM nodes with running animations and then do an immediate
// updateRendering. It will then call back to us with new information.
bool animating = false;
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
CompositeAnimation* compAnim = it->second;
if (!compAnim->suspended() && compAnim->animating()) {
animating = true;
compAnim->setAnimating(false);
Node* node = it->first->element();
ASSERT(!node || (node->document() && !node->document()->inPageCache()));
node->setChanged(AnimationStyleChange);
}
}
m_frame->document()->updateRendering();
updateAnimationTimer();
}
