blob: e93de9972d4bf389a3007bd87edc7a1673ceb691 [file] [log] [blame]
/*
* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
* (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
* Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
* Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
* Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
* Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
* Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
* Copyright (C) Research In Motion Limited 2011. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "CSSToStyleMap.h"
#include "Animation.h"
#include "CSSBorderImageSliceValue.h"
#include "CSSImageGeneratorValue.h"
#include "CSSImageSetValue.h"
#include "CSSImageValue.h"
#include "CSSPrimitiveValue.h"
#include "CSSPrimitiveValueMappings.h"
#include "CSSTimingFunctionValue.h"
#include "CSSValueKeywords.h"
#include "FillLayer.h"
#include "Pair.h"
#include "Rect.h"
#include "StyleBuilderConverter.h"
#include "StyleResolver.h"
namespace WebCore {
CSSToStyleMap::CSSToStyleMap(StyleResolver* resolver)
: m_resolver(resolver)
{
}
RenderStyle* CSSToStyleMap::style() const
{
return m_resolver->style();
}
const RenderStyle* CSSToStyleMap::rootElementStyle() const
{
return m_resolver->rootElementStyle();
}
bool CSSToStyleMap::useSVGZoomRules() const
{
return m_resolver->useSVGZoomRules();
}
RefPtr<StyleImage> CSSToStyleMap::styleImage(CSSValue& value)
{
return m_resolver->styleImage(value);
}
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).valueID()) {
case CSSValueFixed:
layer.setAttachment(FillAttachment::FixedBackground);
break;
case CSSValueScroll:
layer.setAttachment(FillAttachment::ScrollBackground);
break;
case CSSValueLocal:
layer.setAttachment(FillAttachment::LocalBackground);
break;
default:
return;
}
}
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::mapFillComposite(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setComposite(FillLayer::initialFillComposite(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
layer.setComposite(downcast<CSSPrimitiveValue>(value));
}
void CSSToStyleMap::mapFillBlendMode(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setBlendMode(FillLayer::initialFillBlendMode(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
layer.setBlendMode(downcast<CSSPrimitiveValue>(value));
}
void CSSToStyleMap::mapFillOrigin(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setOrigin(FillLayer::initialFillOrigin(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
layer.setOrigin(downcast<CSSPrimitiveValue>(value));
}
void CSSToStyleMap::mapFillImage(CSSPropertyID propertyID, FillLayer& layer, CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setImage(FillLayer::initialFillImage(layer.type()));
return;
}
layer.setImage(styleImage(value));
}
void CSSToStyleMap::mapFillRepeatX(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setRepeatX(FillLayer::initialFillRepeatX(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
layer.setRepeatX(downcast<CSSPrimitiveValue>(value));
}
void CSSToStyleMap::mapFillRepeatY(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setRepeatY(FillLayer::initialFillRepeatY(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
layer.setRepeatY(downcast<CSSPrimitiveValue>(value));
}
static inline bool convertToLengthSize(const CSSPrimitiveValue& primitiveValue, CSSToLengthConversionData conversionData, LengthSize& size)
{
if (auto* pair = primitiveValue.pairValue()) {
size.width = pair->first()->convertToLength<AnyConversion>(conversionData);
size.height = pair->second()->convertToLength<AnyConversion>(conversionData);
} else
size.width = primitiveValue.convertToLength<AnyConversion>(conversionData);
return !size.width.isUndefined() && !size.height.isUndefined();
}
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.valueID()) {
case CSSValueContain:
fillSize.type = FillSizeType::Contain;
break;
case CSSValueCover:
fillSize.type = FillSizeType::Cover;
break;
default:
ASSERT(fillSize.type == FillSizeType::Size);
if (!convertToLengthSize(primitiveValue, m_resolver->state().cssToLengthConversionData(), fillSize.size))
return;
break;
}
layer.setSize(fillSize);
}
void CSSToStyleMap::mapFillXPosition(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(propertyID)) {
layer.setXPosition(FillLayer::initialFillXPosition(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto* primitiveValue = &downcast<CSSPrimitiveValue>(value);
Pair* pair = primitiveValue->pairValue();
Length length;
if (pair) {
ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPositionX || propertyID == CSSPropertyWebkitMaskPositionX);
length = StyleBuilderConverter::convertLength(*m_resolver, *pair->second());
} else
length = StyleBuilderConverter::convertPositionComponentX(*m_resolver, value);
layer.setXPosition(length);
if (pair)
layer.setBackgroundXOrigin(*pair->first());
}
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->pairValue();
Length length;
if (pair) {
ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPositionY || propertyID == CSSPropertyWebkitMaskPositionY);
length = StyleBuilderConverter::convertLength(*m_resolver, *pair->second());
} else
length = StyleBuilderConverter::convertPositionComponentY(*m_resolver, value);
layer.setYPosition(length);
if (pair)
layer.setBackgroundYOrigin(*pair->first());
}
void CSSToStyleMap::mapFillMaskSourceType(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
MaskSourceType type = FillLayer::initialFillMaskSourceType(layer.type());
if (value.treatAsInitialValue(propertyID)) {
layer.setMaskSourceType(type);
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).valueID()) {
case CSSValueAlpha:
type = MaskSourceType::Alpha;
break;
case CSSValueLuminance:
type = MaskSourceType::Luminance;
break;
case CSSValueAuto:
break;
default:
ASSERT_NOT_REACHED();
}
layer.setMaskSourceType(type);
}
void CSSToStyleMap::mapAnimationDelay(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimationDelay)) {
animation.setDelay(Animation::initialDelay());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
animation.setDelay(downcast<CSSPrimitiveValue>(value).computeTime<double, CSSPrimitiveValue::Seconds>());
}
void CSSToStyleMap::mapAnimationDirection(Animation& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimationDirection)) {
layer.setDirection(Animation::initialDirection());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).valueID()) {
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::mapAnimationDuration(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimationDuration)) {
animation.setDuration(Animation::initialDuration());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
animation.setDuration(downcast<CSSPrimitiveValue>(value).computeTime<double, CSSPrimitiveValue::Seconds>());
}
void CSSToStyleMap::mapAnimationFillMode(Animation& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimationFillMode)) {
layer.setFillMode(Animation::initialFillMode());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).valueID()) {
case CSSValueNone:
layer.setFillMode(AnimationFillMode::None);
break;
case CSSValueForwards:
layer.setFillMode(AnimationFillMode::Forwards);
break;
case CSSValueBackwards:
layer.setFillMode(AnimationFillMode::Backwards);
break;
case CSSValueBoth:
layer.setFillMode(AnimationFillMode::Both);
break;
default:
break;
}
}
void CSSToStyleMap::mapAnimationIterationCount(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimationIterationCount)) {
animation.setIterationCount(Animation::initialIterationCount());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.valueID() == CSSValueInfinite)
animation.setIterationCount(Animation::IterationCountInfinite);
else
animation.setIterationCount(primitiveValue.floatValue());
}
void CSSToStyleMap::mapAnimationName(Animation& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimationName)) {
layer.setName(Animation::initialName());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.valueID() == CSSValueNone)
layer.setIsNoneAnimation(true);
else
layer.setName(primitiveValue.stringValue(), m_resolver->state().styleScopeOrdinal());
}
void CSSToStyleMap::mapAnimationPlayState(Animation& layer, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimationPlayState)) {
layer.setPlayState(Animation::initialPlayState());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
AnimationPlayState playState = (downcast<CSSPrimitiveValue>(value).valueID() == CSSValuePaused) ? AnimationPlayState::Paused : AnimationPlayState::Playing;
layer.setPlayState(playState);
}
void CSSToStyleMap::mapAnimationProperty(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimation)) {
animation.setAnimationMode(Animation::AnimateAll);
animation.setProperty(CSSPropertyInvalid);
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.valueID() == CSSValueAll) {
animation.setAnimationMode(Animation::AnimateAll);
animation.setProperty(CSSPropertyInvalid);
return;
}
if (primitiveValue.valueID() == CSSValueNone) {
animation.setAnimationMode(Animation::AnimateNone);
animation.setProperty(CSSPropertyInvalid);
return;
}
if (primitiveValue.propertyID() == CSSPropertyInvalid) {
animation.setAnimationMode(Animation::AnimateUnknownProperty);
animation.setProperty(CSSPropertyInvalid);
animation.setUnknownProperty(primitiveValue.stringValue());
return;
}
animation.setAnimationMode(Animation::AnimateSingleProperty);
animation.setProperty(primitiveValue.propertyID());
}
void CSSToStyleMap::mapAnimationTimingFunction(Animation& animation, const CSSValue& value)
{
if (value.treatAsInitialValue(CSSPropertyAnimationTimingFunction)) {
animation.setTimingFunction(Animation::initialTimingFunction());
return;
}
if (is<CSSPrimitiveValue>(value)) {
switch (downcast<CSSPrimitiveValue>(value).valueID()) {
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::mapNinePieceImage(CSSPropertyID property, CSSValue* value, NinePieceImage& image)
{
// If we're not a value list, then we are "none" and don't need to alter the empty image at all.
if (!is<CSSValueList>(value))
return;
// Retrieve the border image value.
CSSValueList& borderImage = downcast<CSSValueList>(*value);
for (auto& current : borderImage) {
if (is<CSSImageValue>(current) || is<CSSImageGeneratorValue>(current) || is<CSSImageSetValue>(current))
image.setImage(styleImage(current.get()));
else if (is<CSSBorderImageSliceValue>(current))
mapNinePieceImageSlice(current, image);
else if (is<CSSValueList>(current)) {
CSSValueList& slashList = downcast<CSSValueList>(current.get());
// Map in the image slices.
if (is<CSSBorderImageSliceValue>(slashList.item(0)))
mapNinePieceImageSlice(*slashList.item(0), image);
// Map in the border slices.
if (slashList.item(1))
image.setBorderSlices(mapNinePieceImageQuad(*slashList.item(1)));
// Map in the outset.
if (slashList.item(2))
image.setOutset(mapNinePieceImageQuad(*slashList.item(2)));
} else if (is<CSSPrimitiveValue>(current)) {
// Set the appropriate rules for stretch/round/repeat of the slices.
mapNinePieceImageRepeat(current, image);
}
}
if (property == CSSPropertyWebkitBorderImage) {
// We have to preserve the legacy behavior of -webkit-border-image and make the border slices
// also set the border widths. We don't need to worry about percentages, since we don't even support
// those on real borders yet.
if (image.borderSlices().top().isFixed())
style()->setBorderTopWidth(image.borderSlices().top().value());
if (image.borderSlices().right().isFixed())
style()->setBorderRightWidth(image.borderSlices().right().value());
if (image.borderSlices().bottom().isFixed())
style()->setBorderBottomWidth(image.borderSlices().bottom().value());
if (image.borderSlices().left().isFixed())
style()->setBorderLeftWidth(image.borderSlices().left().value());
}
}
void CSSToStyleMap::mapNinePieceImageSlice(CSSValue& value, NinePieceImage& image)
{
if (!is<CSSBorderImageSliceValue>(value))
return;
// Retrieve the border image value.
auto& borderImageSlice = downcast<CSSBorderImageSliceValue>(value);
// Set up a length box to represent our image slices.
LengthBox box;
Quad* slices = borderImageSlice.slices();
if (slices->top()->isPercentage())
box.top() = Length(slices->top()->doubleValue(), Percent);
else
box.top() = Length(slices->top()->intValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->bottom()->isPercentage())
box.bottom() = Length(slices->bottom()->doubleValue(), Percent);
else
box.bottom() = Length((int)slices->bottom()->floatValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->left()->isPercentage())
box.left() = Length(slices->left()->doubleValue(), Percent);
else
box.left() = Length(slices->left()->intValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
if (slices->right()->isPercentage())
box.right() = Length(slices->right()->doubleValue(), Percent);
else
box.right() = Length(slices->right()->intValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
image.setImageSlices(box);
// Set our fill mode.
image.setFill(borderImageSlice.m_fill);
}
LengthBox CSSToStyleMap::mapNinePieceImageQuad(CSSValue& value)
{
if (!is<CSSPrimitiveValue>(value))
return LengthBox();
// Get our zoom value.
CSSToLengthConversionData conversionData = useSVGZoomRules() ? m_resolver->state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f) : m_resolver->state().cssToLengthConversionData();
// Retrieve the primitive value.
auto& borderWidths = downcast<CSSPrimitiveValue>(value);
// Set up a length box to represent our image slices.
LengthBox box; // Defaults to 'auto' so we don't have to handle that explicitly below.
Quad* slices = borderWidths.quadValue();
if (slices->top()->isNumber())
box.top() = Length(slices->top()->intValue(), Relative);
else if (slices->top()->isPercentage())
box.top() = Length(slices->top()->doubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
else if (slices->top()->valueID() != CSSValueAuto)
box.top() = slices->top()->computeLength<Length>(conversionData);
if (slices->right()->isNumber())
box.right() = Length(slices->right()->intValue(), Relative);
else if (slices->right()->isPercentage())
box.right() = Length(slices->right()->doubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
else if (slices->right()->valueID() != CSSValueAuto)
box.right() = slices->right()->computeLength<Length>(conversionData);
if (slices->bottom()->isNumber())
box.bottom() = Length(slices->bottom()->intValue(), Relative);
else if (slices->bottom()->isPercentage())
box.bottom() = Length(slices->bottom()->doubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
else if (slices->bottom()->valueID() != CSSValueAuto)
box.bottom() = slices->bottom()->computeLength<Length>(conversionData);
if (slices->left()->isNumber())
box.left() = Length(slices->left()->intValue(), Relative);
else if (slices->left()->isPercentage())
box.left() = Length(slices->left()->doubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
else if (slices->left()->valueID() != CSSValueAuto)
box.left() = slices->left()->computeLength<Length>(conversionData);
return box;
}
void CSSToStyleMap::mapNinePieceImageRepeat(CSSValue& value, NinePieceImage& image)
{
if (!is<CSSPrimitiveValue>(value))
return;
CSSPrimitiveValue& primitiveValue = downcast<CSSPrimitiveValue>(value);
Pair* pair = primitiveValue.pairValue();
if (!pair || !pair->first() || !pair->second())
return;
CSSValueID firstIdentifier = pair->first()->valueID();
CSSValueID secondIdentifier = pair->second()->valueID();
ENinePieceImageRule horizontalRule;
switch (firstIdentifier) {
case CSSValueStretch:
horizontalRule = StretchImageRule;
break;
case CSSValueRound:
horizontalRule = RoundImageRule;
break;
case CSSValueSpace:
horizontalRule = SpaceImageRule;
break;
default: // CSSValueRepeat
horizontalRule = RepeatImageRule;
break;
}
image.setHorizontalRule(horizontalRule);
ENinePieceImageRule verticalRule;
switch (secondIdentifier) {
case CSSValueStretch:
verticalRule = StretchImageRule;
break;
case CSSValueRound:
verticalRule = RoundImageRule;
break;
case CSSValueSpace:
verticalRule = SpaceImageRule;
break;
default: // CSSValueRepeat
verticalRule = RepeatImageRule;
break;
}
image.setVerticalRule(verticalRule);
}
};