RenderStyle* AnimationController::updateAnimations(RenderObject* renderer, RenderStyle* newStyle)
{
// don't do anything if we're in the cache
if (!renderer->document() || renderer->document()->inPageCache())
return newStyle;
RenderStyle* oldStyle = renderer->style();
if ((!oldStyle || (!oldStyle->animations() && !oldStyle->transitions())) &&
(!newStyle->animations() && !newStyle->transitions()))
return newStyle;
RenderStyle* blendedStyle = newStyle;
// Fetch our current set of implicit animations from a hashtable. We then compare them
// against the animations in the style and make sure we're in sync. If destination values
// have changed, we reset the animation. We then do a blend to get new values and we return
// a new style.
ASSERT(renderer->element()); // FIXME: We do not animate generated content yet.
CompositeAnimation* rendererAnimations = m_data->accessCompositeAnimation(renderer);
blendedStyle = rendererAnimations->animate(renderer, oldStyle, newStyle);
m_data->updateAnimationTimer();
if (blendedStyle != newStyle) {
// If the animations/transitions change opacity or transform, we neeed to update
// the style to impose the stacking rules. Note that this is also
// done in CSSStyleSelector::adjustRenderStyle().
if (blendedStyle->hasAutoZIndex() && (blendedStyle->opacity() < 1.0f || blendedStyle->hasTransform()))
blendedStyle->setZIndex(0);
}
return blendedStyle;
}
double AnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/* = DoNotCallSetChanged*/)
{
double timeToNextService = -1;
bool calledSetChanged = false;
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
CompositeAnimation* compAnim = it->value.get();
if (!compAnim->isSuspended() && compAnim->hasAnimations()) {
double t = compAnim->timeToNextService();
if (t != -1 && (t < timeToNextService || timeToNextService == -1))
timeToNextService = t;
if (!timeToNextService) {
if (callSetChanged == CallSetChanged) {
Node* node = it->key->node();
ASSERT(!node || (node->document() && !node->document()->inPageCache()));
node->setNeedsStyleRecalc(SyntheticStyleChange);
calledSetChanged = true;
}
else
break;
}
}
}
if (calledSetChanged)
m_frame->document()->updateStyleIfNeeded();
return timeToNextService;
}
void AnimationControllerPrivate::updateAnimations(double& timeToNextService, double& timeToNextEvent, SetNeedsStyleRecalc callSetNeedsStyleRecalc/* = DoNotCallSetNeedsStyleRecalc*/)
{
double minTimeToNextService = -1;
double minTimeToNextEvent = -1;
bool updateStyleNeeded = false;
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
CompositeAnimation* compAnim = it->value.get();
if (compAnim->hasAnimations()) {
double t = compAnim->timeToNextService();
if (t != -1 && (t < minTimeToNextService || minTimeToNextService == -1))
minTimeToNextService = t;
double nextEvent = compAnim->timeToNextEvent();
if (nextEvent != -1 && (nextEvent < minTimeToNextEvent || minTimeToNextEvent == -1))
minTimeToNextEvent = nextEvent;
if (callSetNeedsStyleRecalc == CallSetNeedsStyleRecalc) {
if (!t) {
Node* node = it->key->node();
node->setNeedsStyleRecalc(LocalStyleChange, StyleChangeFromRenderer);
updateStyleNeeded = true;
}
} else if (!minTimeToNextService && !minTimeToNextEvent) {
// Found the minimum values and do not need to mark for style recalc.
break;
}
}
}
if (updateStyleNeeded)
m_frame->document()->updateStyleIfNeeded();
timeToNextService = minTimeToNextService;
timeToNextEvent = minTimeToNextEvent;
}
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);
}
unsigned AnimationControllerPrivate::numberOfActiveAnimations() const
{
unsigned count = 0;
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
CompositeAnimation* compAnim = it->second.get();
count += compAnim->numberOfActiveAnimations();
}
return count;
}
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::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();
}
unsigned AnimationControllerPrivate::numberOfActiveAnimations(Document* document) const
{
unsigned count = 0;
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
RenderObject* renderer = it->key;
CompositeAnimation* compAnim = it->value.get();
if (&renderer->document() == document)
count += compAnim->numberOfActiveAnimations();
}
return count;
}
void AnimationControllerPrivate::resumeAnimationsForDocument(Document* document)
{
setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
RenderObject* renderer = it->key;
if (&renderer->document() == document) {
CompositeAnimation* compAnim = it->value.get();
compAnim->resumeAnimations();
}
}
updateAnimationTimer();
}
void AnimationControllerPrivate::suspendAnimations(Document* document)
{
setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
RenderObjectAnimationMap::const_iterator animationsEnd = m_compositeAnimations.end();
for (RenderObjectAnimationMap::const_iterator it = m_compositeAnimations.begin(); it != animationsEnd; ++it) {
RenderObject* renderer = it->first;
if (renderer->document() == document) {
CompositeAnimation* compAnim = it->second.get();
compAnim->suspendAnimations();
}
}
updateAnimationTimer();
}
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) {
CompositeAnimation* compAnim = it->second.get();
if (!compAnim->suspended() && compAnim->hasAnimations()) {
double t = compAnim->timeToNextService();
if (t != -1 && (t < needsService || needsService == -1))
needsService = t;
if (needsService == 0) {
if (callSetChanged) {
Node* node = it->first->node();
ASSERT(!node || (node->document() && !node->document()->inPageCache()));
node->setNeedsStyleRecalc(SyntheticStyleChange);
calledSetChanged = true;
}
else
break;
}
}
}
if (calledSetChanged)
m_frame->document()->updateStyleIfNeeded();
// 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();
}
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();
}
void AnimationController::setTransitionStartTime(RenderObject* obj, int property, double t)
{
CompositeAnimation* rendererAnimations = m_data->accessCompositeAnimation(obj);
rendererAnimations->setTransitionStartTime(property, t);
}
void AnimationController::setAnimationStartTime(RenderObject* obj, double t)
{
CompositeAnimation* rendererAnimations = m_data->accessCompositeAnimation(obj);
rendererAnimations->setAnimationStartTime(t);
}
