PassRefPtr<TimingFunction> CSSToStyleMap::animationTimingFunction(CSSValue* value, bool allowInitial)
{
if (allowInitial && value->isInitialValue()) {
return CSSAnimationData::initialAnimationTimingFunction();
}
if (value->isPrimitiveValue()) {
CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
switch (primitiveValue->getValueID()) {
case CSSValueLinear:
return LinearTimingFunction::preset();
break;
case CSSValueEase:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
break;
case CSSValueEaseIn:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
break;
case CSSValueEaseOut:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut);
break;
case CSSValueEaseInOut:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut);
break;
case CSSValueStepStart:
return StepsTimingFunction::preset(StepsTimingFunction::Start);
break;
case CSSValueStepMiddle:
return StepsTimingFunction::preset(StepsTimingFunction::Middle);
break;
case CSSValueStepEnd:
return StepsTimingFunction::preset(StepsTimingFunction::End);
break;
default:
break;
}
return nullptr;
}
if (value->isCubicBezierTimingFunctionValue()) {
CSSCubicBezierTimingFunctionValue* cubicTimingFunction = toCSSCubicBezierTimingFunctionValue(value);
return CubicBezierTimingFunction::create(cubicTimingFunction->x1(), cubicTimingFunction->y1(), cubicTimingFunction->x2(), cubicTimingFunction->y2());
} else if (value->isStepsTimingFunctionValue()) {
CSSStepsTimingFunctionValue* stepsTimingFunction = toCSSStepsTimingFunctionValue(value);
return StepsTimingFunction::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtPosition());
}
return nullptr;
}
PassRefPtr<TimingFunction> CSSToStyleMap::mapAnimationTimingFunction(CSSValue* value, bool allowStepMiddle)
{
// FIXME: We should probably only call into this function with a valid
// single timing function value which isn't initial or inherit. We can
// currently get into here with initial since the parser expands unset
// properties in shorthands to initial.
if (value->isPrimitiveValue()) {
CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
switch (primitiveValue->getValueID()) {
case CSSValueLinear:
return LinearTimingFunction::shared();
case CSSValueEase:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
case CSSValueEaseIn:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
case CSSValueEaseOut:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut);
case CSSValueEaseInOut:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut);
case CSSValueStepStart:
return StepsTimingFunction::preset(StepsTimingFunction::Start);
case CSSValueStepMiddle:
if (allowStepMiddle)
return StepsTimingFunction::preset(StepsTimingFunction::Middle);
return CSSTimingData::initialTimingFunction();
case CSSValueStepEnd:
return StepsTimingFunction::preset(StepsTimingFunction::End);
default:
ASSERT_NOT_REACHED();
return CSSTimingData::initialTimingFunction();
}
}
if (value->isCubicBezierTimingFunctionValue()) {
CSSCubicBezierTimingFunctionValue* cubicTimingFunction = toCSSCubicBezierTimingFunctionValue(value);
return CubicBezierTimingFunction::create(cubicTimingFunction->x1(), cubicTimingFunction->y1(), cubicTimingFunction->x2(), cubicTimingFunction->y2());
}
if (value->isInitialValue())
return CSSTimingData::initialTimingFunction();
CSSStepsTimingFunctionValue* stepsTimingFunction = toCSSStepsTimingFunctionValue(value);
if (stepsTimingFunction->stepAtPosition() == StepsTimingFunction::Middle && !allowStepMiddle)
return CSSTimingData::initialTimingFunction();
return StepsTimingFunction::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtPosition());
}
void CSSToStyleMap::mapAnimationTimingFunction(Animation* animation, CSSValue* value)
{
if (value->isInitialValue()) {
animation->setTimingFunction(Animation::initialAnimationTimingFunction());
return;
}
if (value->isPrimitiveValue()) {
CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
switch (primitiveValue->getValueID()) {
case CSSValueLinear:
animation->setTimingFunction(LinearTimingFunction::create());
break;
case CSSValueEase:
animation->setTimingFunction(CubicBezierTimingFunction::create());
break;
case CSSValueEaseIn:
animation->setTimingFunction(CubicBezierTimingFunction::create(CubicBezierTimingFunction::EaseIn));
break;
case CSSValueEaseOut:
animation->setTimingFunction(CubicBezierTimingFunction::create(CubicBezierTimingFunction::EaseOut));
break;
case CSSValueEaseInOut:
animation->setTimingFunction(CubicBezierTimingFunction::create(CubicBezierTimingFunction::EaseInOut));
break;
case CSSValueStepStart:
animation->setTimingFunction(StepsTimingFunction::create(1, true));
break;
case CSSValueStepEnd:
animation->setTimingFunction(StepsTimingFunction::create(1, false));
break;
default:
break;
}
return;
}
if (value->isCubicBezierTimingFunctionValue()) {
CSSCubicBezierTimingFunctionValue* cubicTimingFunction = static_cast<CSSCubicBezierTimingFunctionValue*>(value);
animation->setTimingFunction(CubicBezierTimingFunction::create(cubicTimingFunction->x1(), cubicTimingFunction->y1(), cubicTimingFunction->x2(), cubicTimingFunction->y2()));
} else if (value->isStepsTimingFunctionValue()) {
CSSStepsTimingFunctionValue* stepsTimingFunction = static_cast<CSSStepsTimingFunctionValue*>(value);
animation->setTimingFunction(StepsTimingFunction::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtStart()));
} else if (value->isLinearTimingFunctionValue())
animation->setTimingFunction(LinearTimingFunction::create());
}
