void GraphicsLayerAnimations::add(const GraphicsLayerAnimation& animation)
{
// Remove the old state if we are resuming a paused animation.
remove(animation.name());
m_animations.append(animation);
}
void ArgumentCoder<GraphicsLayerAnimation>::encode(ArgumentEncoder& encoder, const GraphicsLayerAnimation& animation)
{
encoder << animation.name();
encoder << animation.boxSize();
encoder.encodeEnum(animation.state());
encoder << animation.startTime();
encoder << animation.pauseTime();
encoder << animation.listsMatch();
RefPtr<Animation> animationObject = animation.animation();
encoder.encodeEnum(animationObject->direction());
encoder << static_cast<uint32_t>(animationObject->fillMode());
encoder << animationObject->duration();
encoder << animationObject->iterationCount();
encodeTimingFunction(encoder, animationObject->timingFunction().get());
const KeyframeValueList& keyframes = animation.keyframes();
encoder.encodeEnum(keyframes.property());
encoder << static_cast<uint32_t>(keyframes.size());
for (size_t i = 0; i < keyframes.size(); ++i) {
const AnimationValue* value = keyframes.at(i);
encoder << value->keyTime();
encodeTimingFunction(encoder, value->timingFunction());
switch (keyframes.property()) {
case AnimatedPropertyOpacity:
encoder << static_cast<const FloatAnimationValue*>(value)->value();
break;
case AnimatedPropertyWebkitTransform:
encoder << *static_cast<const TransformAnimationValue*>(value)->value();
break;
#if ENABLE(CSS_FILTERS)
case AnimatedPropertyWebkitFilter:
encoder << *static_cast<const FilterAnimationValue*>(value)->value();
break;
#endif
default:
break;
}
}
}
bool ArgumentCoder<GraphicsLayerAnimation>::decode(ArgumentDecoder* decoder, GraphicsLayerAnimation& animation)
{
String name;
IntSize boxSize;
GraphicsLayerAnimation::AnimationState state;
double startTime;
double pauseTime;
bool listsMatch;
Animation::AnimationDirection direction;
unsigned fillMode;
double duration;
double iterationCount;
RefPtr<TimingFunction> timingFunction;
RefPtr<Animation> animationObject;
if (!decoder->decode(name))
return false;
if (!decoder->decode(boxSize))
return false;
if (!decoder->decodeEnum(state))
return false;
if (!decoder->decodeDouble(startTime))
return false;
if (!decoder->decodeDouble(pauseTime))
return false;
if (!decoder->decodeBool(listsMatch))
return false;
if (!decoder->decodeEnum(direction))
return false;
if (!decoder->decodeUInt32(fillMode))
return false;
if (!decoder->decodeDouble(duration))
return false;
if (!decoder->decodeDouble(iterationCount))
return false;
if (!decodeTimingFunction(decoder, timingFunction))
return false;
animationObject = Animation::create();
animationObject->setDirection(direction);
animationObject->setFillMode(fillMode);
animationObject->setDuration(duration);
animationObject->setIterationCount(iterationCount);
if (timingFunction)
animationObject->setTimingFunction(timingFunction);
AnimatedPropertyID property;
if (!decoder->decodeEnum(property))
return false;
KeyframeValueList keyframes(property);
unsigned keyframesSize;
if (!decoder->decodeUInt32(keyframesSize))
return false;
for (unsigned i = 0; i < keyframesSize; ++i) {
float keyTime;
RefPtr<TimingFunction> timingFunction;
if (!decoder->decode(keyTime))
return false;
if (!decodeTimingFunction(decoder, timingFunction))
return false;
switch (property) {
case AnimatedPropertyOpacity: {
float value;
if (!decoder->decodeFloat(value))
return false;
keyframes.insert(new FloatAnimationValue(keyTime, value, timingFunction));
break;
}
case AnimatedPropertyWebkitTransform: {
TransformOperations transform;
if (!decoder->decode(transform))
return false;
keyframes.insert(new TransformAnimationValue(keyTime, &transform, timingFunction));
break;
}
#if ENABLE(CSS_FILTERS)
case AnimatedPropertyWebkitFilter: {
FilterOperations filter;
if (!decoder->decode(filter))
return false;
keyframes.insert(new FilterAnimationValue(keyTime, &filter, timingFunction));
break;
}
#endif
default:
break;
}
}
animation = GraphicsLayerAnimation(name, keyframes, boxSize, animationObject.get(), startTime, listsMatch);
animation.setState(state, pauseTime);
return true;
}
