void CSSToStyleMap::mapAnimationDirection(Animation& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimationDirection)) {
layer.setDirection(Animation::initialDirection());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
case CSSValueNormal:
layer.setDirection(Animation::AnimationDirectionNormal);
break;
case CSSValueAlternate:
layer.setDirection(Animation::AnimationDirectionAlternate);
break;
case CSSValueReverse:
layer.setDirection(Animation::AnimationDirectionReverse);
break;
case CSSValueAlternateReverse:
layer.setDirection(Animation::AnimationDirectionAlternateReverse);
break;
default:
break;
}
}
void CSSToStyleMap::mapAnimationTrigger(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimationTrigger)) {
animation.setTrigger(Animation::initialTrigger());
return;
}
if (value.isPrimitiveValue()) {
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.getValueID() == CSSValueAuto)
animation.setTrigger(AutoAnimationTrigger::create());
return;
}
if (value.isAnimationTriggerScrollValue()) {
auto& scrollTrigger = downcast<CSSAnimationTriggerScrollValue>(value);
const CSSPrimitiveValue& startValue = downcast<CSSPrimitiveValue>(scrollTrigger.startValue());
Length startLength = startValue.computeLength<Length>(m_resolver->state().cssToLengthConversionData());
Length endLength;
if (scrollTrigger.hasEndValue()) {
const CSSPrimitiveValue* endValue = downcast<CSSPrimitiveValue>(scrollTrigger.endValue());
endLength = endValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
}
animation.setTrigger(ScrollAnimationTrigger::create(startLength, endLength));
}
}
void CSSToStyleMap::mapAnimationFillMode(Animation& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimationFillMode)) {
layer.setFillMode(Animation::initialFillMode());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
case CSSValueNone:
layer.setFillMode(AnimationFillModeNone);
break;
case CSSValueForwards:
layer.setFillMode(AnimationFillModeForwards);
break;
case CSSValueBackwards:
layer.setFillMode(AnimationFillModeBackwards);
break;
case CSSValueBoth:
layer.setFillMode(AnimationFillModeBoth);
break;
default:
break;
}
}
void CSSToStyleMap::mapFillMaskSourceType(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
EMaskSourceType type = FillLayer::initialFillMaskSourceType(layer.type());
if (value.treatAsInitialValue(propertyID)) {
layer.setMaskSourceType(type);
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
case CSSValueAlpha:
type = EMaskSourceType::MaskAlpha;
break;
case CSSValueLuminance:
type = EMaskSourceType::MaskLuminance;
break;
case CSSValueAuto:
break;
default:
ASSERT_NOT_REACHED();
}
layer.setMaskSourceType(type);
}
void CSSToStyleMap::mapFillYPosition(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setYPosition(FillLayer::initialFillYPosition(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto* primitiveValue = &downcast<CSSPrimitiveValue>(value);
Pair* pair = primitiveValue->getPairValue();
if (pair) {
ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPositionY || propertyID == CSSPropertyWebkitMaskPositionY);
primitiveValue = pair->second();
}
Length length;
if (primitiveValue->isLength())
length = primitiveValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
else if (primitiveValue->isPercentage())
length = Length(primitiveValue->getDoubleValue(), Percent);
else if (primitiveValue->isCalculatedPercentageWithLength())
length = Length(primitiveValue->cssCalcValue()->createCalculationValue(m_resolver->state().cssToLengthConversionData()));
else
return;
layer.setYPosition(length);
if (pair)
layer.setBackgroundYOrigin(*pair->first());
}
void CSSToStyleMap::mapFillSize(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setSize(FillLayer::initialFillSize(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
FillSize fillSize;
switch (primitiveValue.getValueID()) {
case CSSValueContain:
fillSize.type = Contain;
break;
case CSSValueCover:
fillSize.type = Cover;
break;
default:
ASSERT(fillSize.type == SizeLength);
if (!convertToLengthSize(primitiveValue, m_resolver->state().cssToLengthConversionData(), fillSize.size))
return;
break;
}
layer.setSize(fillSize);
}
void CSSToStyleMap::mapFillImage(CSSPropertyID propertyID, FillLayer& layer, CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setImage(FillLayer::initialFillImage(layer.type()));
return;
}
layer.setImage(styleImage(propertyID, value));
}
void CSSToStyleMap::mapFillClip(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setClip(FillLayer::initialFillClip(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
layer.setClip(downcast<CSSPrimitiveValue>(value));
}
void CSSToStyleMap::mapAnimationDuration(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimationDuration)) {
animation.setDuration(Animation::initialDuration());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
animation.setDuration(downcast<CSSPrimitiveValue>(value).computeTime<double, CSSPrimitiveValue::Seconds>());
}
void CSSToStyleMap::mapAnimationPlayState(Animation& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimationPlayState)) {
layer.setPlayState(Animation::initialPlayState());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
EAnimPlayState playState = (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValuePaused) ? AnimPlayStatePaused : AnimPlayStatePlaying;
layer.setPlayState(playState);
}
void CSSToStyleMap::mapAnimationName(Animation& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimationName)) {
layer.setName(Animation::initialName());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.getValueID() == CSSValueNone)
layer.setIsNoneAnimation(true);
else
layer.setName(primitiveValue.getStringValue());
}
void CSSToStyleMap::mapAnimationIterationCount(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimationIterationCount)) {
animation.setIterationCount(Animation::initialIterationCount());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.getValueID() == CSSValueInfinite)
animation.setIterationCount(Animation::IterationCountInfinite);
else
animation.setIterationCount(primitiveValue.getFloatValue());
}
void CSSToStyleMap::mapAnimationTimingFunction(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimationTimingFunction)) {
animation.setTimingFunction(Animation::initialTimingFunction());
return;
}
if (is<CSSPrimitiveValue>(value)) {
switch (downcast<CSSPrimitiveValue>(value).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 (is<CSSCubicBezierTimingFunctionValue>(value)) {
auto& cubicTimingFunction = downcast<CSSCubicBezierTimingFunctionValue>(value);
animation.setTimingFunction(CubicBezierTimingFunction::create(cubicTimingFunction.x1(), cubicTimingFunction.y1(), cubicTimingFunction.x2(), cubicTimingFunction.y2()));
} else if (is<CSSStepsTimingFunctionValue>(value)) {
auto& stepsTimingFunction = downcast<CSSStepsTimingFunctionValue>(value);
animation.setTimingFunction(StepsTimingFunction::create(stepsTimingFunction.numberOfSteps(), stepsTimingFunction.stepAtStart()));
} else if (is<CSSSpringTimingFunctionValue>(value)) {
auto& springTimingFunction = downcast<CSSSpringTimingFunctionValue>(value);
animation.setTimingFunction(SpringTimingFunction::create(springTimingFunction.mass(), springTimingFunction.stiffness(), springTimingFunction.damping(), springTimingFunction.initialVelocity()));
}
}
void CSSToStyleMap::mapAnimationProperty(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyWebkitAnimation)) {
animation.setAnimationMode(Animation::AnimateAll);
animation.setProperty(CSSPropertyInvalid);
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.getValueID() == CSSValueAll) {
animation.setAnimationMode(Animation::AnimateAll);
animation.setProperty(CSSPropertyInvalid);
} else if (primitiveValue.getValueID() == CSSValueNone) {
animation.setAnimationMode(Animation::AnimateNone);
animation.setProperty(CSSPropertyInvalid);
} else {
animation.setAnimationMode(Animation::AnimateSingleProperty);
animation.setProperty(primitiveValue.getPropertyID());
}
}
void CSSToStyleMap::mapFillAttachment(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setAttachment(FillLayer::initialFillAttachment(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
case CSSValueFixed:
layer.setAttachment(FixedBackgroundAttachment);
break;
case CSSValueScroll:
layer.setAttachment(ScrollBackgroundAttachment);
break;
case CSSValueLocal:
layer.setAttachment(LocalBackgroundAttachment);
break;
default:
return;
}
}
