*/
#include "config.h"
-#include "StyleBuilderFunctions.h"
-#include "CSSPropertyNames.h"
-#include "CSSValueKeywords.h"
-#include "StylePropertyShorthand.h"
+#include "core/CSSPropertyNames.h"
+#include "core/CSSValueKeywords.h"
+#include "core/StyleBuilderFunctions.h"
+#include "core/StylePropertyShorthand.h"
#include "core/css/BasicShapeFunctions.h"
#include "core/css/CSSAspectRatioValue.h"
#include "core/css/CSSCursorImageValue.h"
#include "core/css/CSSHelper.h"
#include "core/css/CSSImageSetValue.h"
#include "core/css/CSSLineBoxContainValue.h"
-#include "core/css/parser/BisonCSSParser.h"
#include "core/css/CSSPrimitiveValueMappings.h"
-#include "core/css/CSSProperty.h"
-#include "core/css/CSSReflectValue.h"
+#include "core/css/CSSPropertyMetadata.h"
#include "core/css/Counter.h"
#include "core/css/Pair.h"
-#include "core/css/Rect.h"
#include "core/css/StylePropertySet.h"
#include "core/css/StyleRule.h"
#include "core/css/resolver/ElementStyleResources.h"
#include "core/frame/LocalFrame.h"
#include "core/frame/Settings.h"
#include "core/rendering/style/CounterContent.h"
-#include "core/rendering/style/CursorList.h"
#include "core/rendering/style/QuotesData.h"
#include "core/rendering/style/RenderStyle.h"
#include "core/rendering/style/RenderStyleConstants.h"
#include "core/rendering/style/SVGRenderStyle.h"
-#include "core/rendering/style/SVGRenderStyleDefs.h"
#include "core/rendering/style/StyleGeneratedImage.h"
-#include "core/svg/SVGPaint.h"
#include "platform/fonts/FontDescription.h"
#include "wtf/MathExtras.h"
#include "wtf/StdLibExtras.h"
#include "wtf/Vector.h"
-namespace WebCore {
+namespace blink {
-static Length clipConvertToLength(StyleResolverState& state, CSSPrimitiveValue* value)
-{
- return value->convertToLength<FixedConversion | PercentConversion | AutoConversion>(state.cssToLengthConversionData());
-}
+namespace {
-void StyleBuilderFunctions::applyInitialCSSPropertyClip(StyleResolverState& state)
+static inline bool isValidVisitedLinkProperty(CSSPropertyID id)
{
- state.style()->setClip(Length(), Length(), Length(), Length());
- state.style()->setHasClip(false);
+ switch (id) {
+ case CSSPropertyBackgroundColor:
+ case CSSPropertyBorderLeftColor:
+ case CSSPropertyBorderRightColor:
+ case CSSPropertyBorderTopColor:
+ case CSSPropertyBorderBottomColor:
+ case CSSPropertyColor:
+ case CSSPropertyFill:
+ case CSSPropertyOutlineColor:
+ case CSSPropertyStroke:
+ case CSSPropertyTextDecorationColor:
+ case CSSPropertyWebkitColumnRuleColor:
+ case CSSPropertyWebkitTextEmphasisColor:
+ case CSSPropertyWebkitTextFillColor:
+ case CSSPropertyWebkitTextStrokeColor:
+ return true;
+ default:
+ return false;
+ }
}
-void StyleBuilderFunctions::applyInheritCSSPropertyClip(StyleResolverState& state)
-{
- RenderStyle* parentStyle = state.parentStyle();
- if (!parentStyle->hasClip())
- return applyInitialCSSPropertyClip(state);
- state.style()->setClip(parentStyle->clipTop(), parentStyle->clipRight(), parentStyle->clipBottom(), parentStyle->clipLeft());
- state.style()->setHasClip(true);
-}
+} // namespace
-void StyleBuilderFunctions::applyValueCSSPropertyClip(StyleResolverState& state, CSSValue* value)
+void StyleBuilder::applyProperty(CSSPropertyID id, StyleResolverState& state, CSSValue* value)
{
- if (!value->isPrimitiveValue())
- return;
+ ASSERT_WITH_MESSAGE(!isExpandedShorthand(id), "Shorthand property id = %d wasn't expanded at parsing time", id);
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+ bool isInherit = state.parentNode() && value->isInheritedValue();
+ bool isInitial = value->isInitialValue() || (!state.parentNode() && value->isInheritedValue());
- if (Rect* rect = primitiveValue->getRectValue()) {
- Length top = clipConvertToLength(state, rect->top());
- Length right = clipConvertToLength(state, rect->right());
- Length bottom = clipConvertToLength(state, rect->bottom());
- Length left = clipConvertToLength(state, rect->left());
- state.style()->setClip(top, right, bottom, left);
- state.style()->setHasClip(true);
- } else if (primitiveValue->getValueID() == CSSValueAuto) {
- state.style()->setClip(Length(), Length(), Length(), Length());
- state.style()->setHasClip(false);
+ ASSERT(!isInherit || !isInitial); // isInherit -> !isInitial && isInitial -> !isInherit
+ ASSERT(!isInherit || (state.parentNode() && state.parentStyle())); // isInherit -> (state.parentNode() && state.parentStyle())
+
+ if (!state.applyPropertyToRegularStyle() && (!state.applyPropertyToVisitedLinkStyle() || !isValidVisitedLinkProperty(id))) {
+ // Limit the properties that can be applied to only the ones honored by :visited.
+ return;
}
+
+ if (isInherit && !state.parentStyle()->hasExplicitlyInheritedProperties() && !CSSPropertyMetadata::isInheritedProperty(id))
+ state.parentStyle()->setHasExplicitlyInheritedProperties();
+
+ StyleBuilder::applyProperty(id, state, value, isInitial, isInherit);
}
void StyleBuilderFunctions::applyInitialCSSPropertyColor(StyleResolverState& state)
}
if (state.applyPropertyToRegularStyle())
- state.style()->setColor(state.document().textLinkColors().colorFromPrimitiveValue(primitiveValue, state.style()->color()));
+ state.style()->setColor(StyleBuilderConverter::convertColor(state, value));
if (state.applyPropertyToVisitedLinkStyle())
- state.style()->setVisitedLinkColor(state.document().textLinkColors().colorFromPrimitiveValue(primitiveValue, state.style()->color(), true));
+ state.style()->setVisitedLinkColor(StyleBuilderConverter::convertColor(state, value, true));
+}
+
+void StyleBuilderFunctions::applyInitialCSSPropertyJustifyItems(StyleResolverState& state)
+{
+ state.style()->setJustifyItems(RenderStyle::initialJustifyItems());
+ state.style()->setJustifyItemsOverflowAlignment(RenderStyle::initialJustifyItemsOverflowAlignment());
+ state.style()->setJustifyItemsPositionType(RenderStyle::initialJustifyItemsPositionType());
+}
+
+void StyleBuilderFunctions::applyInheritCSSPropertyJustifyItems(StyleResolverState& state)
+{
+ state.style()->setJustifyItems(state.parentStyle()->justifyItems());
+ state.style()->setJustifyItemsOverflowAlignment(state.parentStyle()->justifyItemsOverflowAlignment());
+ state.style()->setJustifyItemsPositionType(state.parentStyle()->justifyItemsPositionType());
+}
+
+void StyleBuilderFunctions::applyValueCSSPropertyJustifyItems(StyleResolverState& state, CSSValue* value)
+{
+
+ CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+ if (Pair* pairValue = primitiveValue->getPairValue()) {
+ if (pairValue->first()->getValueID() == CSSValueLegacy) {
+ state.style()->setJustifyItemsPositionType(LegacyPosition);
+ state.style()->setJustifyItems(*pairValue->second());
+ } else {
+ state.style()->setJustifyItems(*pairValue->first());
+ state.style()->setJustifyItemsOverflowAlignment(*pairValue->second());
+ }
+ } else {
+ state.style()->setJustifyItems(*primitiveValue);
+ }
}
void StyleBuilderFunctions::applyInitialCSSPropertyCursor(StyleResolverState& state)
int len = list->length();
state.style()->setCursor(CURSOR_AUTO);
for (int i = 0; i < len; i++) {
- CSSValue* item = list->itemWithoutBoundsCheck(i);
+ CSSValue* item = list->item(i);
if (item->isCursorImageValue()) {
CSSCursorImageValue* image = toCSSCursorImageValue(item);
if (image->updateIfSVGCursorIsUsed(state.element())) // Elements with SVG cursors are not allowed to share style.
state.style()->setUnique();
state.style()->addCursor(state.styleImage(CSSPropertyCursor, image), image->hotSpot());
- } else if (item->isPrimitiveValue()) {
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(item);
- if (primitiveValue->isValueID())
- state.style()->setCursor(*primitiveValue);
+ } else {
+ state.style()->setCursor(*toCSSPrimitiveValue(item));
}
}
- } else if (value->isPrimitiveValue()) {
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
- if (primitiveValue->isValueID() && state.style()->cursor() != ECursor(*primitiveValue))
- state.style()->setCursor(*primitiveValue);
+ } else {
+ state.style()->setCursor(*toCSSPrimitiveValue(value));
}
}
element->document().setDirectionSetOnDocumentElement(true);
}
-static inline bool isValidDisplayValue(StyleResolverState& state, EDisplay displayPropertyValue)
-{
- if (state.element() && state.element()->isSVGElement() && state.style()->styleType() == NOPSEUDO)
- return (displayPropertyValue == INLINE || displayPropertyValue == BLOCK || displayPropertyValue == NONE);
- return true;
-}
-
-void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolverState& state)
-{
- EDisplay display = state.parentStyle()->display();
- if (!isValidDisplayValue(state, display))
- return;
- state.style()->setDisplay(display);
-}
-
-void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolverState& state, CSSValue* value)
-{
- if (!value->isPrimitiveValue())
- return;
-
- EDisplay display = *toCSSPrimitiveValue(value);
-
- if (!isValidDisplayValue(state, display))
- return;
-
- state.style()->setDisplay(display);
-}
-
void StyleBuilderFunctions::applyInitialCSSPropertyFontFamily(StyleResolverState& state)
{
state.fontBuilder().setFontFamilyInitial();
state.fontBuilder().setFontFamilyValue(value);
}
-void StyleBuilderFunctions::applyInitialCSSPropertyFontSize(StyleResolverState& state)
-{
- state.fontBuilder().setFontSizeInitial();
-}
-
-void StyleBuilderFunctions::applyInheritCSSPropertyFontSize(StyleResolverState& state)
-{
- state.fontBuilder().setFontSizeInherit(state.parentFontDescription());
-}
-
-void StyleBuilderFunctions::applyValueCSSPropertyFontSize(StyleResolverState& state, CSSValue* value)
-{
- state.fontBuilder().setFontSizeValue(value, state.parentStyle(), state.rootElementStyle());
-}
-
-void StyleBuilderFunctions::applyInitialCSSPropertyFontWeight(StyleResolverState& state)
-{
- state.fontBuilder().setWeight(FontWeightNormal);
-}
-
-void StyleBuilderFunctions::applyInheritCSSPropertyFontWeight(StyleResolverState& state)
-{
- state.fontBuilder().setWeight(state.parentFontDescription().weight());
-}
-
-void StyleBuilderFunctions::applyValueCSSPropertyFontWeight(StyleResolverState& state, CSSValue* value)
-{
- if (!value->isPrimitiveValue())
- return;
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
- switch (primitiveValue->getValueID()) {
- case CSSValueInvalid:
- ASSERT_NOT_REACHED();
- break;
- case CSSValueBolder:
- state.fontBuilder().setWeight(state.parentStyle()->fontDescription().weight());
- state.fontBuilder().setWeightBolder();
- break;
- case CSSValueLighter:
- state.fontBuilder().setWeight(state.parentStyle()->fontDescription().weight());
- state.fontBuilder().setWeightLighter();
- break;
- default:
- state.fontBuilder().setWeight(*primitiveValue);
- }
-}
-
void StyleBuilderFunctions::applyValueCSSPropertyGlyphOrientationVertical(StyleResolverState& state, CSSValue* value)
{
if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueAuto)
- state.style()->accessSVGStyle()->setGlyphOrientationVertical(GO_AUTO);
+ state.style()->accessSVGStyle().setGlyphOrientationVertical(GO_AUTO);
else
- state.style()->accessSVGStyle()->setGlyphOrientationVertical(StyleBuilderConverter::convertGlyphOrientation(state, value));
+ state.style()->accessSVGStyle().setGlyphOrientationVertical(StyleBuilderConverter::convertGlyphOrientation(state, value));
}
void StyleBuilderFunctions::applyInitialCSSPropertyGridTemplateAreas(StyleResolverState& state)
}
CSSGridTemplateAreasValue* gridTemplateAreasValue = toCSSGridTemplateAreasValue(value);
- state.style()->setNamedGridArea(gridTemplateAreasValue->gridAreaMap());
+ const NamedGridAreaMap& newNamedGridAreas = gridTemplateAreasValue->gridAreaMap();
+
+ NamedGridLinesMap namedGridColumnLines = state.style()->namedGridColumnLines();
+ NamedGridLinesMap namedGridRowLines = state.style()->namedGridRowLines();
+ StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea(newNamedGridAreas, namedGridColumnLines, ForColumns);
+ StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea(newNamedGridAreas, namedGridRowLines, ForRows);
+ state.style()->setNamedGridColumnLines(namedGridColumnLines);
+ state.style()->setNamedGridRowLines(namedGridRowLines);
+
+ state.style()->setNamedGridArea(newNamedGridAreas);
state.style()->setNamedGridAreaRowCount(gridTemplateAreasValue->rowCount());
state.style()->setNamedGridAreaColumnCount(gridTemplateAreasValue->columnCount());
}
void StyleBuilderFunctions::applyValueCSSPropertyLineHeight(StyleResolverState& state, CSSValue* value)
{
- if (!value->isPrimitiveValue())
- return;
-
CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
Length lineHeight;
void StyleBuilderFunctions::applyValueCSSPropertyResize(StyleResolverState& state, CSSValue* value)
{
- if (!value->isPrimitiveValue())
- return;
-
CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
EResize r = RESIZE_NONE;
- switch (primitiveValue->getValueID()) {
- case 0:
- return;
- case CSSValueAuto:
+ if (primitiveValue->getValueID() == CSSValueAuto) {
if (Settings* settings = state.document().settings())
r = settings->textAreasAreResizable() ? RESIZE_BOTH : RESIZE_NONE;
- break;
- default:
+ } else {
r = *primitiveValue;
}
state.style()->setResize(r);
state.style()->setTextAlign(state.parentStyle()->textAlign());
}
-void StyleBuilderFunctions::applyValueCSSPropertyTextDecoration(StyleResolverState& state, CSSValue* value)
-{
- TextDecoration t = RenderStyle::initialTextDecoration();
- for (CSSValueListIterator i(value); i.hasMore(); i.advance()) {
- CSSValue* item = i.value();
- t |= *toCSSPrimitiveValue(item);
- }
- state.style()->setTextDecoration(t);
-}
-
void StyleBuilderFunctions::applyInheritCSSPropertyTextIndent(StyleResolverState& state)
{
state.style()->setTextIndent(state.parentStyle()->textIndent());
}
}
+void StyleBuilderFunctions::applyInheritCSSPropertyVerticalAlign(StyleResolverState& state)
+{
+ EVerticalAlign verticalAlign = state.parentStyle()->verticalAlign();
+ state.style()->setVerticalAlign(verticalAlign);
+ if (verticalAlign == LENGTH)
+ state.style()->setVerticalAlignLength(state.parentStyle()->verticalAlignLength());
+}
+
void StyleBuilderFunctions::applyValueCSSPropertyVerticalAlign(StyleResolverState& state, CSSValue* value)
{
if (!value->isPrimitiveValue())
CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
- if (primitiveValue->getValueID())
- return state.style()->setVerticalAlign(*primitiveValue);
+ if (primitiveValue->getValueID()) {
+ state.style()->setVerticalAlign(*primitiveValue);
+ return;
+ }
state.style()->setVerticalAlignLength(primitiveValue->convertToLength<FixedConversion | PercentConversion>(state.cssToLengthConversionData()));
}
-void StyleBuilderFunctions::applyValueCSSPropertyTouchAction(StyleResolverState& state, CSSValue* value)
-{
- TouchAction action = RenderStyle::initialTouchAction();
- for (CSSValueListIterator i(value); i.hasMore(); i.advance())
- action |= *toCSSPrimitiveValue(i.value());
-
- state.style()->setTouchAction(action);
-}
-
static void resetEffectiveZoom(StyleResolverState& state)
{
// Reset the zoom in effect. This allows the setZoom method to accurately compute a new zoom in effect.
state.style()->setFilter(operations);
}
-void StyleBuilderFunctions::applyInitialCSSPropertyFontVariantLigatures(StyleResolverState& state)
-{
- state.fontBuilder().setFontVariantLigaturesInitial();
-}
-
-void StyleBuilderFunctions::applyInheritCSSPropertyFontVariantLigatures(StyleResolverState& state)
-{
- state.fontBuilder().setFontVariantLigaturesInherit(state.parentFontDescription());
-}
-
-void StyleBuilderFunctions::applyValueCSSPropertyFontVariantLigatures(StyleResolverState& state, CSSValue* value)
-{
- state.fontBuilder().setFontVariantLigaturesValue(value);
-}
-
-void StyleBuilderFunctions::applyValueCSSPropertyInternalMarqueeIncrement(StyleResolverState& state, CSSValue* value)
-{
- if (!value->isPrimitiveValue())
- return;
-
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
- if (primitiveValue->getValueID()) {
- switch (primitiveValue->getValueID()) {
- case CSSValueSmall:
- state.style()->setMarqueeIncrement(Length(1, Fixed)); // 1px.
- break;
- case CSSValueNormal:
- state.style()->setMarqueeIncrement(Length(6, Fixed)); // 6px. The WinIE default.
- break;
- case CSSValueLarge:
- state.style()->setMarqueeIncrement(Length(36, Fixed)); // 36px.
- break;
- default:
- break;
- }
- } else {
- Length marqueeLength = primitiveValue->convertToLength<FixedConversion | PercentConversion>(state.cssToLengthConversionData());
- state.style()->setMarqueeIncrement(marqueeLength);
- }
-}
-
-void StyleBuilderFunctions::applyValueCSSPropertyInternalMarqueeSpeed(StyleResolverState& state, CSSValue* value)
-{
- if (!value->isPrimitiveValue())
- return;
-
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
- if (CSSValueID valueID = primitiveValue->getValueID()) {
- switch (valueID) {
- case CSSValueSlow:
- state.style()->setMarqueeSpeed(500); // 500 msec.
- break;
- case CSSValueNormal:
- state.style()->setMarqueeSpeed(85); // 85msec. The WinIE default.
- break;
- case CSSValueFast:
- state.style()->setMarqueeSpeed(10); // 10msec. Super fast.
- break;
- default:
- break;
- }
- } else if (primitiveValue->isTime()) {
- state.style()->setMarqueeSpeed(primitiveValue->computeTime<int, CSSPrimitiveValue::Milliseconds>());
- } else if (primitiveValue->isNumber()) { // For scrollamount support.
- state.style()->setMarqueeSpeed(primitiveValue->getIntValue());
- }
-}
-
-// FIXME: We should use the same system for this as the rest of the pseudo-shorthands (e.g. background-position)
-void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOrigin(StyleResolverState& state)
-{
- applyInitialCSSPropertyWebkitPerspectiveOriginX(state);
- applyInitialCSSPropertyWebkitPerspectiveOriginY(state);
-}
-
-void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOrigin(StyleResolverState& state)
-{
- applyInheritCSSPropertyWebkitPerspectiveOriginX(state);
- applyInheritCSSPropertyWebkitPerspectiveOriginY(state);
-}
-
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitPerspectiveOrigin(StyleResolverState&, CSSValue* value)
-{
- // This is expanded in the parser
- ASSERT_NOT_REACHED();
-}
-
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitTapHighlightColor(StyleResolverState& state, CSSValue* value)
-{
- if (!value->isPrimitiveValue())
- return;
- Color color = state.document().textLinkColors().colorFromPrimitiveValue(toCSSPrimitiveValue(value), state.style()->color());
- state.style()->setTapHighlightColor(color);
-}
-
void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state)
{
state.style()->setTextEmphasisFill(RenderStyle::initialTextEmphasisFill());
if (list->length() != 2)
return;
for (unsigned i = 0; i < 2; ++i) {
- CSSValue* item = list->itemWithoutBoundsCheck(i);
+ CSSValue* item = list->item(i);
if (!item->isPrimitiveValue())
continue;
}
}
-void StyleBuilderFunctions::applyValueCSSPropertyTextUnderlinePosition(StyleResolverState& state, CSSValue* value)
-{
- // This is true if value is 'auto' or 'alphabetic'.
- if (value->isPrimitiveValue()) {
- TextUnderlinePosition t = *toCSSPrimitiveValue(value);
- state.style()->setTextUnderlinePosition(t);
- return;
- }
-
- unsigned t = 0;
- for (CSSValueListIterator i(value); i.hasMore(); i.advance()) {
- CSSValue* item = i.value();
- TextUnderlinePosition t2 = *toCSSPrimitiveValue(item);
- t |= t2;
- }
- state.style()->setTextUnderlinePosition(static_cast<TextUnderlinePosition>(t));
-}
-
void StyleBuilderFunctions::applyInitialCSSPropertyWillChange(StyleResolverState& state)
{
state.style()->setWillChangeContents(false);
state.style()->setWillChangeScrollPosition(false);
state.style()->setWillChangeProperties(Vector<CSSPropertyID>());
+ state.style()->setSubtreeWillChangeContents(state.parentStyle()->subtreeWillChangeContents());
}
void StyleBuilderFunctions::applyInheritCSSPropertyWillChange(StyleResolverState& state)
state.style()->setWillChangeContents(state.parentStyle()->willChangeContents());
state.style()->setWillChangeScrollPosition(state.parentStyle()->willChangeScrollPosition());
state.style()->setWillChangeProperties(state.parentStyle()->willChangeProperties());
+ state.style()->setSubtreeWillChangeContents(state.parentStyle()->subtreeWillChangeContents());
}
void StyleBuilderFunctions::applyValueCSSPropertyWillChange(StyleResolverState& state, CSSValue* value)
state.style()->setWillChangeContents(willChangeContents);
state.style()->setWillChangeScrollPosition(willChangeScrollPosition);
state.style()->setWillChangeProperties(willChangeProperties);
+ state.style()->setSubtreeWillChangeContents(willChangeContents || state.parentStyle()->subtreeWillChangeContents());
}
-// Everything below this line is from the old StyleResolver::applyProperty
-// and eventually needs to move into new StyleBuilderFunctions calls intead.
-
-#define HANDLE_INHERIT(prop, Prop) \
-if (isInherit) { \
- state.style()->set##Prop(state.parentStyle()->prop()); \
- return; \
-}
-
-#define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
-HANDLE_INHERIT(prop, Prop) \
-if (isInitial) { \
- state.style()->set##Prop(RenderStyle::initial##Prop()); \
- return; \
-}
-
-#define HANDLE_SVG_INHERIT(prop, Prop) \
-if (isInherit) { \
- state.style()->accessSVGStyle()->set##Prop(state.parentStyle()->svgStyle()->prop()); \
- return; \
-}
-
-#define HANDLE_SVG_INHERIT_AND_INITIAL(prop, Prop) \
-HANDLE_SVG_INHERIT(prop, Prop) \
-if (isInitial) { \
- state.style()->accessSVGStyle()->set##Prop(SVGRenderStyle::initial##Prop()); \
- return; \
-}
-
-static Color colorFromSVGPaintCSSValue(SVGPaint* svgPaint, const Color& fgColor)
+void StyleBuilderFunctions::applyInitialCSSPropertyContent(StyleResolverState& state)
{
- Color color;
- if (svgPaint->paintType() == SVGPaint::SVG_PAINTTYPE_CURRENTCOLOR
- || svgPaint->paintType() == SVGPaint::SVG_PAINTTYPE_URI_CURRENTCOLOR)
- color = fgColor;
- else
- color = svgPaint->color();
- return color;
+ state.style()->clearContent();
}
-static inline bool isValidVisitedLinkProperty(CSSPropertyID id)
+void StyleBuilderFunctions::applyInheritCSSPropertyContent(StyleResolverState&)
{
- switch (id) {
- case CSSPropertyBackgroundColor:
- case CSSPropertyBorderLeftColor:
- case CSSPropertyBorderRightColor:
- case CSSPropertyBorderTopColor:
- case CSSPropertyBorderBottomColor:
- case CSSPropertyColor:
- case CSSPropertyFill:
- case CSSPropertyOutlineColor:
- case CSSPropertyStroke:
- case CSSPropertyTextDecorationColor:
- case CSSPropertyWebkitColumnRuleColor:
- case CSSPropertyWebkitTextEmphasisColor:
- case CSSPropertyWebkitTextFillColor:
- case CSSPropertyWebkitTextStrokeColor:
- return true;
- default:
- break;
- }
-
- return false;
+ // FIXME: In CSS3, it will be possible to inherit content. In CSS2 it is not. This
+ // note is a reminder that eventually "inherit" needs to be supported.
}
-
-void StyleBuilder::applyProperty(CSSPropertyID id, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyContent(StyleResolverState& state, CSSValue* value)
{
- ASSERT_WITH_MESSAGE(!isExpandedShorthand(id), "Shorthand property id = %d wasn't expanded at parsing time", id);
+ // list of string, uri, counter, attr, i
- bool isInherit = state.parentNode() && value->isInheritedValue();
- bool isInitial = value->isInitialValue() || (!state.parentNode() && value->isInheritedValue());
-
- ASSERT(!isInherit || !isInitial); // isInherit -> !isInitial && isInitial -> !isInherit
- ASSERT(!isInherit || (state.parentNode() && state.parentStyle())); // isInherit -> (state.parentNode() && state.parentStyle())
-
- if (!state.applyPropertyToRegularStyle() && (!state.applyPropertyToVisitedLinkStyle() || !isValidVisitedLinkProperty(id))) {
- // Limit the properties that can be applied to only the ones honored by :visited.
+ if (!value->isValueList())
return;
- }
- CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? toCSSPrimitiveValue(value) : 0;
- if (primitiveValue && primitiveValue->getValueID() == CSSValueCurrentcolor)
- state.style()->setHasCurrentColor();
+ bool didSet = false;
+ for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
+ CSSValue* item = i.value();
+ if (item->isImageGeneratorValue()) {
+ if (item->isGradientValue())
+ state.style()->setContent(StyleGeneratedImage::create(toCSSGradientValue(item)->gradientWithStylesResolved(state.document().textLinkColors(), state.style()->color()).get()), didSet);
+ else
+ state.style()->setContent(StyleGeneratedImage::create(toCSSImageGeneratorValue(item)), didSet);
+ didSet = true;
+ } else if (item->isImageSetValue()) {
+ state.style()->setContent(state.elementStyleResources().setOrPendingFromValue(CSSPropertyContent, toCSSImageSetValue(item)), didSet);
+ didSet = true;
+ }
- if (isInherit && !state.parentStyle()->hasExplicitlyInheritedProperties() && !CSSProperty::isInheritedProperty(id))
- state.parentStyle()->setHasExplicitlyInheritedProperties();
+ if (item->isImageValue()) {
+ state.style()->setContent(state.elementStyleResources().cachedOrPendingFromValue(state.document(), CSSPropertyContent, toCSSImageValue(item)), didSet);
+ didSet = true;
+ continue;
+ }
- if (StyleBuilder::applyProperty(id, state, value, isInitial, isInherit))
- return;
+ if (!item->isPrimitiveValue())
+ continue;
- // Fall back to the old switch statement, which is now in StyleBuilderCustom.cpp
- StyleBuilder::oldApplyProperty(id, state, value, isInitial, isInherit);
-}
+ CSSPrimitiveValue* contentValue = toCSSPrimitiveValue(item);
+ if (contentValue->isString()) {
+ state.style()->setContent(contentValue->getStringValue().impl(), didSet);
+ didSet = true;
+ } else if (contentValue->isAttr()) {
+ // FIXME: Can a namespace be specified for an attr(foo)?
+ if (state.style()->styleType() == NOPSEUDO)
+ state.style()->setUnique();
+ else
+ state.parentStyle()->setUnique();
+ QualifiedName attr(nullAtom, AtomicString(contentValue->getStringValue()), nullAtom);
+ const AtomicString& value = state.element()->getAttribute(attr);
+ state.style()->setContent(value.isNull() ? emptyString() : value.string(), didSet);
+ didSet = true;
+ // register the fact that the attribute value affects the style
+ state.contentAttrValues().append(attr.localName());
+ } else if (contentValue->isCounter()) {
+ Counter* counterValue = contentValue->getCounterValue();
+ EListStyleType listStyleType = NoneListStyle;
+ CSSValueID listStyleIdent = counterValue->listStyleIdent();
+ if (listStyleIdent != CSSValueNone)
+ listStyleType = static_cast<EListStyleType>(listStyleIdent - CSSValueDisc);
+ OwnPtr<CounterContent> counter = adoptPtr(new CounterContent(AtomicString(counterValue->identifier()), listStyleType, AtomicString(counterValue->separator())));
+ state.style()->setContent(counter.release(), didSet);
+ didSet = true;
+ } else {
+ switch (contentValue->getValueID()) {
+ case CSSValueOpenQuote:
+ state.style()->setContent(OPEN_QUOTE, didSet);
+ didSet = true;
+ break;
+ case CSSValueCloseQuote:
+ state.style()->setContent(CLOSE_QUOTE, didSet);
+ didSet = true;
+ break;
+ case CSSValueNoOpenQuote:
+ state.style()->setContent(NO_OPEN_QUOTE, didSet);
+ didSet = true;
+ break;
+ case CSSValueNoCloseQuote:
+ state.style()->setContent(NO_CLOSE_QUOTE, didSet);
+ didSet = true;
+ break;
+ default:
+ // normal and none do not have any effect.
+ { }
+ }
+ }
+ }
+ if (!didSet)
+ state.style()->clearContent();
+}
-void StyleBuilder::oldApplyProperty(CSSPropertyID id, StyleResolverState& state, CSSValue* value, bool isInitial, bool isInherit)
+void StyleBuilderFunctions::applyInitialCSSPropertyFont(StyleResolverState&)
{
- CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? toCSSPrimitiveValue(value) : 0;
+ ASSERT_NOT_REACHED();
+}
- // What follows is a list that maps the CSS properties into their corresponding front-end
- // RenderStyle values.
- switch (id) {
- case CSSPropertyContent:
- // list of string, uri, counter, attr, i
- {
- // FIXME: In CSS3, it will be possible to inherit content. In CSS2 it is not. This
- // note is a reminder that eventually "inherit" needs to be supported.
-
- if (isInitial) {
- state.style()->clearContent();
- return;
- }
+void StyleBuilderFunctions::applyInheritCSSPropertyFont(StyleResolverState&)
+{
+ ASSERT_NOT_REACHED();
+}
- if (!value->isValueList())
- return;
+void StyleBuilderFunctions::applyValueCSSPropertyFont(StyleResolverState& state, CSSValue* value)
+{
+ // Only System Font identifiers should come through this method
+ // all other values should have been handled when the shorthand
+ // was expanded by the parser.
+ // FIXME: System Font identifiers should not hijack this
+ // short-hand CSSProperty like this (crbug.com/353932)
+ state.style()->setLineHeight(RenderStyle::initialLineHeight());
+ state.setLineHeightValue(0);
+ state.fontBuilder().fromSystemFont(toCSSPrimitiveValue(value)->getValueID(), state.style()->effectiveZoom());
+}
- bool didSet = false;
- for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
- CSSValue* item = i.value();
- if (item->isImageGeneratorValue()) {
- if (item->isGradientValue())
- state.style()->setContent(StyleGeneratedImage::create(toCSSGradientValue(item)->gradientWithStylesResolved(state.document().textLinkColors(), state.style()->color()).get()), didSet);
- else
- state.style()->setContent(StyleGeneratedImage::create(toCSSImageGeneratorValue(item)), didSet);
- didSet = true;
- } else if (item->isImageSetValue()) {
- state.style()->setContent(state.elementStyleResources().setOrPendingFromValue(CSSPropertyContent, toCSSImageSetValue(item)), didSet);
- didSet = true;
- }
-
- if (item->isImageValue()) {
- state.style()->setContent(state.elementStyleResources().cachedOrPendingFromValue(state.document(), CSSPropertyContent, toCSSImageValue(item)), didSet);
- didSet = true;
- continue;
- }
-
- if (!item->isPrimitiveValue())
- continue;
-
- CSSPrimitiveValue* contentValue = toCSSPrimitiveValue(item);
-
- if (contentValue->isString()) {
- state.style()->setContent(contentValue->getStringValue().impl(), didSet);
- didSet = true;
- } else if (contentValue->isAttr()) {
- // FIXME: Can a namespace be specified for an attr(foo)?
- if (state.style()->styleType() == NOPSEUDO)
- state.style()->setUnique();
- else
- state.parentStyle()->setUnique();
- QualifiedName attr(nullAtom, AtomicString(contentValue->getStringValue()), nullAtom);
- const AtomicString& value = state.element()->getAttribute(attr);
- state.style()->setContent(value.isNull() ? emptyString() : value.string(), didSet);
- didSet = true;
- // register the fact that the attribute value affects the style
- state.contentAttrValues().append(attr.localName());
- } else if (contentValue->isCounter()) {
- Counter* counterValue = contentValue->getCounterValue();
- EListStyleType listStyleType = NoneListStyle;
- CSSValueID listStyleIdent = counterValue->listStyleIdent();
- if (listStyleIdent != CSSValueNone)
- listStyleType = static_cast<EListStyleType>(listStyleIdent - CSSValueDisc);
- OwnPtr<CounterContent> counter = adoptPtr(new CounterContent(AtomicString(counterValue->identifier()), listStyleType, AtomicString(counterValue->separator())));
- state.style()->setContent(counter.release(), didSet);
- didSet = true;
- } else {
- switch (contentValue->getValueID()) {
- case CSSValueOpenQuote:
- state.style()->setContent(OPEN_QUOTE, didSet);
- didSet = true;
- break;
- case CSSValueCloseQuote:
- state.style()->setContent(CLOSE_QUOTE, didSet);
- didSet = true;
- break;
- case CSSValueNoOpenQuote:
- state.style()->setContent(NO_OPEN_QUOTE, didSet);
- didSet = true;
- break;
- case CSSValueNoCloseQuote:
- state.style()->setContent(NO_CLOSE_QUOTE, didSet);
- didSet = true;
- break;
- default:
- // normal and none do not have any effect.
- { }
- }
- }
- }
- if (!didSet)
- state.style()->clearContent();
- return;
- }
- case CSSPropertyQuotes:
- HANDLE_INHERIT_AND_INITIAL(quotes, Quotes);
- if (value->isValueList()) {
- CSSValueList* list = toCSSValueList(value);
- RefPtr<QuotesData> quotes = QuotesData::create();
- for (size_t i = 0; i < list->length(); i += 2) {
- CSSValue* first = list->itemWithoutBoundsCheck(i);
- // item() returns null if out of bounds so this is safe.
- CSSValue* second = list->item(i + 1);
- if (!second)
- continue;
- String startQuote = toCSSPrimitiveValue(first)->getStringValue();
- String endQuote = toCSSPrimitiveValue(second)->getStringValue();
- quotes->addPair(std::make_pair(startQuote, endQuote));
- }
- state.style()->setQuotes(quotes);
- return;
- }
- if (primitiveValue) {
- if (primitiveValue->getValueID() == CSSValueNone)
- state.style()->setQuotes(QuotesData::create());
- }
- return;
- // Shorthand properties.
- case CSSPropertyFont:
- // Only System Font identifiers should come through this method
- // all other values should have been handled when the shorthand
- // was expanded by the parser.
- // FIXME: System Font identifiers should not hijack this
- // short-hand CSSProperty like this.
- ASSERT(!isInitial);
- ASSERT(!isInherit);
- ASSERT(primitiveValue);
- state.style()->setLineHeight(RenderStyle::initialLineHeight());
- state.setLineHeightValue(0);
- state.fontBuilder().fromSystemFont(primitiveValue->getValueID(), state.style()->effectiveZoom());
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitLocale(StyleResolverState& state, CSSValue* value)
+{
+ if (!value->isPrimitiveValue())
return;
- case CSSPropertyAnimation:
- case CSSPropertyBackground:
- case CSSPropertyBackgroundPosition:
- case CSSPropertyBackgroundRepeat:
- case CSSPropertyBorder:
- case CSSPropertyBorderBottom:
- case CSSPropertyBorderColor:
- case CSSPropertyBorderImage:
- case CSSPropertyBorderLeft:
- case CSSPropertyBorderRadius:
- case CSSPropertyBorderRight:
- case CSSPropertyBorderSpacing:
- case CSSPropertyBorderStyle:
- case CSSPropertyBorderTop:
- case CSSPropertyBorderWidth:
- case CSSPropertyListStyle:
- case CSSPropertyMargin:
- case CSSPropertyObjectPosition:
- case CSSPropertyOutline:
- case CSSPropertyOverflow:
- case CSSPropertyPadding:
- case CSSPropertyTransition:
- case CSSPropertyWebkitAnimation:
- case CSSPropertyWebkitBorderAfter:
- case CSSPropertyWebkitBorderBefore:
- case CSSPropertyWebkitBorderEnd:
- case CSSPropertyWebkitBorderStart:
- case CSSPropertyWebkitBorderRadius:
- case CSSPropertyWebkitColumns:
- case CSSPropertyWebkitColumnRule:
- case CSSPropertyFlex:
- case CSSPropertyFlexFlow:
- case CSSPropertyGrid:
- case CSSPropertyGridTemplate:
- case CSSPropertyGridColumn:
- case CSSPropertyGridRow:
- case CSSPropertyGridArea:
- case CSSPropertyWebkitMarginCollapse:
- case CSSPropertyWebkitMask:
- case CSSPropertyWebkitMaskPosition:
- case CSSPropertyWebkitMaskRepeat:
- case CSSPropertyWebkitTextEmphasis:
- case CSSPropertyWebkitTextStroke:
- case CSSPropertyWebkitTransition:
- case CSSPropertyWebkitTransformOrigin:
- ASSERT(isExpandedShorthand(id));
- ASSERT_NOT_REACHED();
- break;
+ const CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+ if (primitiveValue->getValueID() == CSSValueAuto)
+ state.style()->setLocale(nullAtom);
+ else
+ state.style()->setLocale(AtomicString(primitiveValue->getStringValue()));
+ state.fontBuilder().setScript(state.style()->locale());
+}
- // CSS3 Properties
- case CSSPropertyWebkitBoxReflect: {
- HANDLE_INHERIT_AND_INITIAL(boxReflect, BoxReflect)
- if (primitiveValue) {
- state.style()->setBoxReflect(RenderStyle::initialBoxReflect());
- return;
- }
+void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAppRegion(StyleResolverState&)
+{
+}
- if (!value->isReflectValue())
- return;
+void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAppRegion(StyleResolverState&)
+{
+}
- CSSReflectValue* reflectValue = toCSSReflectValue(value);
- RefPtr<StyleReflection> reflection = StyleReflection::create();
- reflection->setDirection(*reflectValue->direction());
- if (reflectValue->offset())
- reflection->setOffset(reflectValue->offset()->convertToLength<FixedConversion | PercentConversion>(state.cssToLengthConversionData()));
- NinePieceImage mask;
- mask.setMaskDefaults();
- state.styleMap().mapNinePieceImage(state.style(), id, reflectValue->mask(), mask);
- reflection->setMask(mask);
-
- state.style()->setBoxReflect(reflection.release());
- return;
- }
- case CSSPropertySrc: // Only used in @font-face rules.
- return;
- case CSSPropertyUnicodeRange: // Only used in @font-face rules.
- return;
- case CSSPropertyWebkitLocale: {
- HANDLE_INHERIT_AND_INITIAL(locale, Locale);
- if (!primitiveValue)
- return;
- if (primitiveValue->getValueID() == CSSValueAuto)
- state.style()->setLocale(nullAtom);
- else
- state.style()->setLocale(AtomicString(primitiveValue->getStringValue()));
- state.fontBuilder().setScript(state.style()->locale());
- return;
- }
- case CSSPropertyWebkitAppRegion: {
- if (!primitiveValue || !primitiveValue->getValueID())
- return;
- state.style()->setDraggableRegionMode(primitiveValue->getValueID() == CSSValueDrag ? DraggableRegionDrag : DraggableRegionNoDrag);
- state.document().setHasAnnotatedRegions(true);
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitAppRegion(StyleResolverState& state, CSSValue* value)
+{
+ if (!value->isPrimitiveValue())
return;
- }
- case CSSPropertyWebkitTextStrokeWidth: {
- HANDLE_INHERIT_AND_INITIAL(textStrokeWidth, TextStrokeWidth)
- float width = 0;
- switch (primitiveValue->getValueID()) {
- case CSSValueThin:
- case CSSValueMedium:
- case CSSValueThick: {
- double result = 1.0 / 48;
- if (primitiveValue->getValueID() == CSSValueMedium)
- result *= 3;
- else if (primitiveValue->getValueID() == CSSValueThick)
- result *= 5;
- width = CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS)->computeLength<float>(state.cssToLengthConversionData());
- break;
- }
- default:
- width = primitiveValue->computeLength<float>(state.cssToLengthConversionData());
- break;
- }
- state.style()->setTextStrokeWidth(width);
+ const CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+ if (!primitiveValue->getValueID())
return;
- }
- case CSSPropertyPerspective:
- case CSSPropertyWebkitPerspective: {
- HANDLE_INHERIT_AND_INITIAL(perspective, Perspective)
-
- if (!primitiveValue)
- return;
+ state.style()->setDraggableRegionMode(primitiveValue->getValueID() == CSSValueDrag ? DraggableRegionDrag : DraggableRegionNoDrag);
+ state.document().setHasAnnotatedRegions(true);
+}
- if (primitiveValue->getValueID() == CSSValueNone) {
- state.style()->setPerspective(0);
- return;
- }
+void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspective(StyleResolverState& state)
+{
+ applyInitialCSSPropertyPerspective(state);
+}
- float perspectiveValue;
- if (primitiveValue->isLength()) {
- perspectiveValue = primitiveValue->computeLength<float>(state.cssToLengthConversionData());
- } else if (id == CSSPropertyWebkitPerspective && primitiveValue->isNumber()) {
- // Prefixed version treats unitless numbers as px.
- perspectiveValue = CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX)->computeLength<float>(state.cssToLengthConversionData());
- } else {
- return;
- }
+void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspective(StyleResolverState& state)
+{
+ applyInheritCSSPropertyPerspective(state);
+}
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitPerspective(StyleResolverState& state, CSSValue* value)
+{
+ if (!value->isPrimitiveValue())
+ return;
+ CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+ if (primitiveValue->isNumber()) {
+ float perspectiveValue = CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX)->computeLength<float>(state.cssToLengthConversionData());
if (perspectiveValue >= 0.0f)
state.style()->setPerspective(perspectiveValue);
- return;
- }
- case CSSPropertyInternalCallback: {
- if (isInherit || isInitial)
- return;
- if (primitiveValue && primitiveValue->getValueID() == CSSValueInternalPresence) {
- state.style()->addCallbackSelector(state.currentRule()->selectorList().selectorsText());
- return;
- }
- break;
- }
- case CSSPropertyInvalid:
- return;
- // Directional properties are resolved by resolveDirectionAwareProperty() before the switch.
- case CSSPropertyWebkitBorderEndColor:
- case CSSPropertyWebkitBorderEndStyle:
- case CSSPropertyWebkitBorderEndWidth:
- case CSSPropertyWebkitBorderStartColor:
- case CSSPropertyWebkitBorderStartStyle:
- case CSSPropertyWebkitBorderStartWidth:
- case CSSPropertyWebkitBorderBeforeColor:
- case CSSPropertyWebkitBorderBeforeStyle:
- case CSSPropertyWebkitBorderBeforeWidth:
- case CSSPropertyWebkitBorderAfterColor:
- case CSSPropertyWebkitBorderAfterStyle:
- case CSSPropertyWebkitBorderAfterWidth:
- case CSSPropertyWebkitMarginEnd:
- case CSSPropertyWebkitMarginStart:
- case CSSPropertyWebkitMarginBefore:
- case CSSPropertyWebkitMarginAfter:
- case CSSPropertyWebkitMarginBeforeCollapse:
- case CSSPropertyWebkitMarginTopCollapse:
- case CSSPropertyWebkitMarginAfterCollapse:
- case CSSPropertyWebkitMarginBottomCollapse:
- case CSSPropertyWebkitPaddingEnd:
- case CSSPropertyWebkitPaddingStart:
- case CSSPropertyWebkitPaddingBefore:
- case CSSPropertyWebkitPaddingAfter:
- case CSSPropertyWebkitLogicalWidth:
- case CSSPropertyWebkitLogicalHeight:
- case CSSPropertyWebkitMinLogicalWidth:
- case CSSPropertyWebkitMinLogicalHeight:
- case CSSPropertyWebkitMaxLogicalWidth:
- case CSSPropertyWebkitMaxLogicalHeight:
- {
- CSSPropertyID newId = CSSProperty::resolveDirectionAwareProperty(id, state.style()->direction(), state.style()->writingMode());
- ASSERT(newId != id);
- return applyProperty(newId, state, value);
+ } else {
+ applyValueCSSPropertyPerspective(state, value);
}
- case CSSPropertyFontStretch:
- case CSSPropertyPage:
- case CSSPropertyTextLineThroughColor:
- case CSSPropertyTextLineThroughMode:
- case CSSPropertyTextLineThroughStyle:
- case CSSPropertyTextLineThroughWidth:
- case CSSPropertyTextOverlineColor:
- case CSSPropertyTextOverlineMode:
- case CSSPropertyTextOverlineStyle:
- case CSSPropertyTextOverlineWidth:
- case CSSPropertyTextUnderlineColor:
- case CSSPropertyTextUnderlineMode:
- case CSSPropertyTextUnderlineStyle:
- case CSSPropertyTextUnderlineWidth:
- case CSSPropertyWebkitFontSizeDelta:
- case CSSPropertyWebkitTextDecorationsInEffect:
- return;
-
- // CSS Text Layout Module Level 3: Vertical writing support
- case CSSPropertyWebkitWritingMode: {
- HANDLE_INHERIT_AND_INITIAL(writingMode, WritingMode);
-
- if (primitiveValue)
- state.setWritingMode(*primitiveValue);
+}
- // FIXME: It is not ok to modify document state while applying style.
- if (state.element() && state.element() == state.document().documentElement())
- state.document().setWritingModeSetOnDocumentElement(true);
+void StyleBuilderFunctions::applyValueCSSPropertyPerspective(StyleResolverState& state, CSSValue* value)
+{
+ if (!value->isPrimitiveValue())
return;
- }
-
- case CSSPropertyWebkitTextOrientation: {
- HANDLE_INHERIT_AND_INITIAL(textOrientation, TextOrientation);
-
- if (primitiveValue)
- state.setTextOrientation(*primitiveValue);
-
+ CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+ if (primitiveValue->getValueID() == CSSValueNone) {
+ state.style()->setPerspective(0);
return;
}
- case CSSPropertyWebkitLineBoxContain: {
- HANDLE_INHERIT_AND_INITIAL(lineBoxContain, LineBoxContain)
- if (primitiveValue && primitiveValue->getValueID() == CSSValueNone) {
- state.style()->setLineBoxContain(LineBoxContainNone);
- return;
- }
+ if (!primitiveValue->isLength())
+ return;
+ float perspectiveValue = primitiveValue->computeLength<float>(state.cssToLengthConversionData());
+ if (perspectiveValue >= 0.0f)
+ state.style()->setPerspective(perspectiveValue);
+}
- if (!value->isLineBoxContainValue())
- return;
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitWritingMode(StyleResolverState& state, CSSValue* value)
+{
+ if (value->isPrimitiveValue())
+ state.setWritingMode(*toCSSPrimitiveValue(value));
- state.style()->setLineBoxContain(toCSSLineBoxContainValue(value)->value());
- return;
- }
+ // FIXME: It is not ok to modify document state while applying style.
+ if (state.element() && state.element() == state.document().documentElement())
+ state.document().setWritingModeSetOnDocumentElement(true);
+}
- // CSS Fonts Module Level 3
- case CSSPropertyWebkitFontFeatureSettings: {
- if (primitiveValue && primitiveValue->getValueID() == CSSValueNormal) {
- state.fontBuilder().setFeatureSettingsNormal();
- return;
- }
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextOrientation(StyleResolverState& state, CSSValue* value)
+{
+ if (value->isPrimitiveValue())
+ state.setTextOrientation(*toCSSPrimitiveValue(value));
+}
- if (!value->isValueList())
- return;
+void StyleBuilderFunctions::applyInheritCSSPropertyBaselineShift(StyleResolverState& state)
+{
+ const SVGRenderStyle& parentSvgStyle = state.parentStyle()->svgStyle();
+ EBaselineShift baselineShift = parentSvgStyle.baselineShift();
+ SVGRenderStyle& svgStyle = state.style()->accessSVGStyle();
+ svgStyle.setBaselineShift(baselineShift);
+ if (baselineShift == BS_LENGTH)
+ svgStyle.setBaselineShiftValue(parentSvgStyle.baselineShiftValue());
+}
- state.fontBuilder().setFeatureSettingsValue(value);
+void StyleBuilderFunctions::applyValueCSSPropertyBaselineShift(StyleResolverState& state, CSSValue* value)
+{
+ SVGRenderStyle& svgStyle = state.style()->accessSVGStyle();
+ CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+ if (!primitiveValue->isValueID()) {
+ svgStyle.setBaselineShift(BS_LENGTH);
+ svgStyle.setBaselineShiftValue(SVGLength::fromCSSPrimitiveValue(primitiveValue));
return;
}
-
- case CSSPropertyJustifySelf: {
- HANDLE_INHERIT_AND_INITIAL(justifySelf, JustifySelf);
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
- if (Pair* pairValue = primitiveValue->getPairValue()) {
- state.style()->setJustifySelf(*pairValue->first());
- state.style()->setJustifySelfOverflowAlignment(*pairValue->second());
- } else {
- state.style()->setJustifySelf(*primitiveValue);
- }
+ switch (primitiveValue->getValueID()) {
+ case CSSValueBaseline:
+ svgStyle.setBaselineShift(BS_BASELINE);
return;
- }
-
- case CSSPropertyAlignSelf: {
- HANDLE_INHERIT_AND_INITIAL(alignSelf, AlignSelf);
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
- if (Pair* pairValue = primitiveValue->getPairValue()) {
- state.style()->setAlignSelf(*pairValue->first());
- state.style()->setAlignSelfOverflowAlignment(*pairValue->second());
- } else {
- state.style()->setAlignSelf(*primitiveValue);
- }
+ case CSSValueSub:
+ svgStyle.setBaselineShift(BS_SUB);
return;
- }
-
- case CSSPropertyAlignItems: {
- HANDLE_INHERIT_AND_INITIAL(alignItems, AlignItems);
- CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
- if (Pair* pairValue = primitiveValue->getPairValue()) {
- state.style()->setAlignItems(*pairValue->first());
- state.style()->setAlignItemsOverflowAlignment(*pairValue->second());
- } else {
- state.style()->setAlignItems(*primitiveValue);
- }
+ case CSSValueSuper:
+ svgStyle.setBaselineShift(BS_SUPER);
return;
+ default:
+ ASSERT_NOT_REACHED();
}
+}
- // These properties are aliased and we already applied the property on the prefixed version.
- case CSSPropertyAnimationDelay:
- case CSSPropertyAnimationDirection:
- case CSSPropertyAnimationDuration:
- case CSSPropertyAnimationFillMode:
- case CSSPropertyAnimationIterationCount:
- case CSSPropertyAnimationName:
- case CSSPropertyAnimationPlayState:
- case CSSPropertyAnimationTimingFunction:
- case CSSPropertyTransitionDelay:
- case CSSPropertyTransitionDuration:
- case CSSPropertyTransitionProperty:
- case CSSPropertyTransitionTimingFunction:
- return;
- // These properties are implemented in StyleBuilder::applyProperty.
- case CSSPropertyBackgroundAttachment:
- case CSSPropertyBackgroundBlendMode:
- case CSSPropertyBackgroundClip:
- case CSSPropertyBackgroundColor:
- case CSSPropertyBackgroundImage:
- case CSSPropertyBackgroundOrigin:
- case CSSPropertyBackgroundPositionX:
- case CSSPropertyBackgroundPositionY:
- case CSSPropertyBackgroundRepeatX:
- case CSSPropertyBackgroundRepeatY:
- case CSSPropertyBackgroundSize:
- case CSSPropertyBorderBottomColor:
- case CSSPropertyBorderBottomLeftRadius:
- case CSSPropertyBorderBottomRightRadius:
- case CSSPropertyBorderBottomStyle:
- case CSSPropertyBorderBottomWidth:
- case CSSPropertyBorderCollapse:
- case CSSPropertyBorderImageOutset:
- case CSSPropertyBorderImageRepeat:
- case CSSPropertyBorderImageSlice:
- case CSSPropertyBorderImageSource:
- case CSSPropertyBorderImageWidth:
- case CSSPropertyBorderLeftColor:
- case CSSPropertyBorderLeftStyle:
- case CSSPropertyBorderLeftWidth:
- case CSSPropertyBorderRightColor:
- case CSSPropertyBorderRightStyle:
- case CSSPropertyBorderRightWidth:
- case CSSPropertyBorderTopColor:
- case CSSPropertyBorderTopLeftRadius:
- case CSSPropertyBorderTopRightRadius:
- case CSSPropertyBorderTopStyle:
- case CSSPropertyBorderTopWidth:
- case CSSPropertyBottom:
- case CSSPropertyBoxShadow:
- case CSSPropertyBoxSizing:
- case CSSPropertyCaptionSide:
- case CSSPropertyClear:
- case CSSPropertyClip:
- case CSSPropertyColor:
- case CSSPropertyCounterIncrement:
- case CSSPropertyCounterReset:
- case CSSPropertyCursor:
- case CSSPropertyDirection:
- case CSSPropertyDisplay:
- case CSSPropertyEmptyCells:
- case CSSPropertyFloat:
- case CSSPropertyFontKerning:
- case CSSPropertyFontSize:
- case CSSPropertyFontStyle:
- case CSSPropertyFontVariant:
- case CSSPropertyFontVariantLigatures:
- case CSSPropertyFontWeight:
- case CSSPropertyGridAutoColumns:
- case CSSPropertyGridAutoRows:
- case CSSPropertyGridColumnStart:
- case CSSPropertyGridColumnEnd:
- case CSSPropertyGridRowStart:
- case CSSPropertyGridRowEnd:
- case CSSPropertyGridTemplateAreas:
- case CSSPropertyGridTemplateColumns:
- case CSSPropertyGridTemplateRows:
- case CSSPropertyHeight:
- case CSSPropertyImageRendering:
- case CSSPropertyIsolation:
- case CSSPropertyLeft:
- case CSSPropertyLetterSpacing:
- case CSSPropertyLineHeight:
- case CSSPropertyListStyleImage:
- case CSSPropertyListStylePosition:
- case CSSPropertyListStyleType:
- case CSSPropertyMarginBottom:
- case CSSPropertyMarginLeft:
- case CSSPropertyMarginRight:
- case CSSPropertyMarginTop:
- case CSSPropertyMaxHeight:
- case CSSPropertyMaxWidth:
- case CSSPropertyMinHeight:
- case CSSPropertyMixBlendMode:
- case CSSPropertyMinWidth:
- case CSSPropertyObjectFit:
- case CSSPropertyOpacity:
- case CSSPropertyOrphans:
- case CSSPropertyOutlineColor:
- case CSSPropertyOutlineOffset:
- case CSSPropertyOutlineStyle:
- case CSSPropertyOutlineWidth:
- case CSSPropertyOverflowWrap:
- case CSSPropertyOverflowX:
- case CSSPropertyOverflowY:
- case CSSPropertyPaddingBottom:
- case CSSPropertyPaddingLeft:
- case CSSPropertyPaddingRight:
- case CSSPropertyPaddingTop:
- case CSSPropertyPageBreakAfter:
- case CSSPropertyPageBreakBefore:
- case CSSPropertyPageBreakInside:
- case CSSPropertyPointerEvents:
- case CSSPropertyPosition:
- case CSSPropertyResize:
- case CSSPropertyRight:
- case CSSPropertyScrollBehavior:
- case CSSPropertySize:
- case CSSPropertySpeak:
- case CSSPropertyTabSize:
- case CSSPropertyTableLayout:
- case CSSPropertyTextAlign:
- case CSSPropertyTextAlignLast:
- case CSSPropertyTextDecoration:
- case CSSPropertyTextDecorationLine:
- case CSSPropertyTextDecorationStyle:
- case CSSPropertyTextDecorationColor:
- case CSSPropertyTextIndent:
- case CSSPropertyTextJustify:
- case CSSPropertyTextOverflow:
- case CSSPropertyTextRendering:
- case CSSPropertyTextShadow:
- case CSSPropertyTextTransform:
- case CSSPropertyTop:
- case CSSPropertyTouchAction:
- case CSSPropertyTouchActionDelay:
- case CSSPropertyUnicodeBidi:
- case CSSPropertyVerticalAlign:
- case CSSPropertyVisibility:
- case CSSPropertyWebkitAnimationDelay:
- case CSSPropertyWebkitAnimationDirection:
- case CSSPropertyWebkitAnimationDuration:
- case CSSPropertyWebkitAnimationFillMode:
- case CSSPropertyWebkitAnimationIterationCount:
- case CSSPropertyWebkitAnimationName:
- case CSSPropertyWebkitAnimationPlayState:
- case CSSPropertyWebkitAnimationTimingFunction:
- case CSSPropertyWebkitAppearance:
- case CSSPropertyWebkitAspectRatio:
- case CSSPropertyBackfaceVisibility:
- case CSSPropertyWebkitBackfaceVisibility:
- case CSSPropertyWebkitBackgroundClip:
- case CSSPropertyWebkitBackgroundComposite:
- case CSSPropertyWebkitBackgroundOrigin:
- case CSSPropertyWebkitBackgroundSize:
- case CSSPropertyWebkitBorderFit:
- case CSSPropertyWebkitBorderHorizontalSpacing:
- case CSSPropertyWebkitBorderImage:
- case CSSPropertyWebkitBorderVerticalSpacing:
- case CSSPropertyWebkitBoxAlign:
- case CSSPropertyWebkitBoxDecorationBreak:
- case CSSPropertyWebkitBoxDirection:
- case CSSPropertyWebkitBoxFlex:
- case CSSPropertyWebkitBoxFlexGroup:
- case CSSPropertyWebkitBoxLines:
- case CSSPropertyWebkitBoxOrdinalGroup:
- case CSSPropertyWebkitBoxOrient:
- case CSSPropertyWebkitBoxPack:
- case CSSPropertyWebkitBoxShadow:
- case CSSPropertyWebkitColumnBreakAfter:
- case CSSPropertyWebkitColumnBreakBefore:
- case CSSPropertyWebkitColumnBreakInside:
- case CSSPropertyWebkitColumnCount:
- case CSSPropertyColumnFill:
- case CSSPropertyWebkitColumnGap:
- case CSSPropertyWebkitColumnRuleColor:
- case CSSPropertyWebkitColumnRuleStyle:
- case CSSPropertyWebkitColumnRuleWidth:
- case CSSPropertyWebkitColumnSpan:
- case CSSPropertyWebkitColumnWidth:
- case CSSPropertyAlignContent:
- case CSSPropertyFlexBasis:
- case CSSPropertyFlexDirection:
- case CSSPropertyFlexGrow:
- case CSSPropertyFlexShrink:
- case CSSPropertyFlexWrap:
- case CSSPropertyJustifyContent:
- case CSSPropertyOrder:
- case CSSPropertyWebkitFilter:
- case CSSPropertyWebkitFontSmoothing:
- case CSSPropertyWebkitHighlight:
- case CSSPropertyWebkitHyphenateCharacter:
- case CSSPropertyWebkitLineBreak:
- case CSSPropertyWebkitLineClamp:
- case CSSPropertyInternalMarqueeDirection:
- case CSSPropertyInternalMarqueeIncrement:
- case CSSPropertyInternalMarqueeRepetition:
- case CSSPropertyInternalMarqueeSpeed:
- case CSSPropertyInternalMarqueeStyle:
- case CSSPropertyWebkitMaskBoxImage:
- case CSSPropertyWebkitMaskBoxImageOutset:
- case CSSPropertyWebkitMaskBoxImageRepeat:
- case CSSPropertyWebkitMaskBoxImageSlice:
- case CSSPropertyWebkitMaskBoxImageSource:
- case CSSPropertyWebkitMaskBoxImageWidth:
- case CSSPropertyWebkitMaskClip:
- case CSSPropertyWebkitMaskComposite:
- case CSSPropertyWebkitMaskImage:
- case CSSPropertyWebkitMaskOrigin:
- case CSSPropertyWebkitMaskPositionX:
- case CSSPropertyWebkitMaskPositionY:
- case CSSPropertyWebkitMaskRepeatX:
- case CSSPropertyWebkitMaskRepeatY:
- case CSSPropertyWebkitMaskSize:
- case CSSPropertyPerspectiveOrigin:
- case CSSPropertyWebkitPerspectiveOrigin:
- case CSSPropertyWebkitPerspectiveOriginX:
- case CSSPropertyWebkitPerspectiveOriginY:
- case CSSPropertyWebkitPrintColorAdjust:
- case CSSPropertyWebkitRtlOrdering:
- case CSSPropertyWebkitRubyPosition:
- case CSSPropertyWebkitTextCombine:
- case CSSPropertyTextUnderlinePosition:
- case CSSPropertyWebkitTextEmphasisColor:
- case CSSPropertyWebkitTextEmphasisPosition:
- case CSSPropertyWebkitTextEmphasisStyle:
- case CSSPropertyWebkitTextFillColor:
- case CSSPropertyWebkitTextSecurity:
- case CSSPropertyWebkitTextStrokeColor:
- case CSSPropertyTransform:
- case CSSPropertyWebkitTransform:
- case CSSPropertyWebkitTransformOriginX:
- case CSSPropertyWebkitTransformOriginY:
- case CSSPropertyWebkitTransformOriginZ:
- case CSSPropertyTransformOrigin:
- case CSSPropertyTransformStyle:
- case CSSPropertyWebkitTransformStyle:
- case CSSPropertyWebkitTransitionDelay:
- case CSSPropertyWebkitTransitionDuration:
- case CSSPropertyWebkitTransitionProperty:
- case CSSPropertyWebkitTransitionTimingFunction:
- case CSSPropertyWebkitUserDrag:
- case CSSPropertyWebkitUserModify:
- case CSSPropertyWebkitUserSelect:
- case CSSPropertyWebkitClipPath:
- case CSSPropertyWebkitWrapFlow:
- case CSSPropertyShapeMargin:
- case CSSPropertyShapeImageThreshold:
- case CSSPropertyWebkitWrapThrough:
- case CSSPropertyShapeOutside:
- case CSSPropertyWhiteSpace:
- case CSSPropertyWidows:
- case CSSPropertyWidth:
- case CSSPropertyWillChange:
- case CSSPropertyWordBreak:
- case CSSPropertyWordSpacing:
- case CSSPropertyWordWrap:
- case CSSPropertyZIndex:
- case CSSPropertyZoom:
- case CSSPropertyFontFamily:
- case CSSPropertyGridAutoFlow:
- case CSSPropertyMarker:
- case CSSPropertyAlignmentBaseline:
- case CSSPropertyBufferedRendering:
- case CSSPropertyClipRule:
- case CSSPropertyColorInterpolation:
- case CSSPropertyColorInterpolationFilters:
- case CSSPropertyColorRendering:
- case CSSPropertyDominantBaseline:
- case CSSPropertyFillRule:
- case CSSPropertyMaskSourceType:
- case CSSPropertyMaskType:
- case CSSPropertyShapeRendering:
- case CSSPropertyStrokeLinecap:
- case CSSPropertyStrokeLinejoin:
- case CSSPropertyTextAnchor:
- case CSSPropertyVectorEffect:
- case CSSPropertyWritingMode:
- case CSSPropertyClipPath:
- case CSSPropertyFillOpacity:
- case CSSPropertyFilter:
- case CSSPropertyFloodOpacity:
- case CSSPropertyMarkerEnd:
- case CSSPropertyMarkerMid:
- case CSSPropertyMarkerStart:
- case CSSPropertyMask:
- case CSSPropertyStopOpacity:
- case CSSPropertyStrokeDashoffset:
- case CSSPropertyStrokeMiterlimit:
- case CSSPropertyStrokeOpacity:
- case CSSPropertyStrokeWidth:
- case CSSPropertyStopColor:
- case CSSPropertyLightingColor:
- case CSSPropertyFloodColor:
- case CSSPropertyWebkitTapHighlightColor:
- case CSSPropertyPaintOrder:
- case CSSPropertyStrokeDasharray:
- case CSSPropertyGlyphOrientationHorizontal:
- case CSSPropertyGlyphOrientationVertical:
- ASSERT_NOT_REACHED();
- return;
- // Only used in @viewport rules
- case CSSPropertyMaxZoom:
- case CSSPropertyMinZoom:
- case CSSPropertyOrientation:
- case CSSPropertyUserZoom:
+void StyleBuilderFunctions::applyValueCSSPropertyGridAutoFlow(StyleResolverState& state, CSSValue* value)
+{
+ ASSERT(value->isValueList());
+ CSSValueList* list = toCSSValueList(value);
+
+ CSSPrimitiveValue* first = list->length() >= 1 ? toCSSPrimitiveValue(list->item(0)) : nullptr;
+
+ if (!first) {
+ applyInitialCSSPropertyGridAutoFlow(state);
return;
+ }
- case CSSPropertyBaselineShift:
- {
- HANDLE_SVG_INHERIT_AND_INITIAL(baselineShift, BaselineShift);
- if (!primitiveValue)
- break;
+ CSSPrimitiveValue* second = list->length() == 2 ? toCSSPrimitiveValue(list->item(1)) : nullptr;
- SVGRenderStyle* svgStyle = state.style()->accessSVGStyle();
- if (primitiveValue->getValueID()) {
- switch (primitiveValue->getValueID()) {
- case CSSValueBaseline:
- svgStyle->setBaselineShift(BS_BASELINE);
- break;
- case CSSValueSub:
- svgStyle->setBaselineShift(BS_SUB);
- break;
- case CSSValueSuper:
- svgStyle->setBaselineShift(BS_SUPER);
- break;
- default:
- break;
- }
+ GridAutoFlow autoFlow = RenderStyle::initialGridAutoFlow();
+ switch (first->getValueID()) {
+ case CSSValueRow:
+ if (second) {
+ if (second->getValueID() == CSSValueDense)
+ autoFlow = AutoFlowRowDense;
+ else
+ autoFlow = AutoFlowStackRow;
} else {
- svgStyle->setBaselineShift(BS_LENGTH);
- svgStyle->setBaselineShiftValue(SVGLength::fromCSSPrimitiveValue(primitiveValue));
+ autoFlow = AutoFlowRow;
}
-
break;
- }
- // end of ident only properties
- case CSSPropertyFill:
- {
- SVGRenderStyle* svgStyle = state.style()->accessSVGStyle();
- if (isInherit) {
- const SVGRenderStyle* svgParentStyle = state.parentStyle()->svgStyle();
- svgStyle->setFillPaint(svgParentStyle->fillPaintType(), svgParentStyle->fillPaintColor(), svgParentStyle->fillPaintUri(), state.applyPropertyToRegularStyle(), state.applyPropertyToVisitedLinkStyle());
- return;
- }
- if (isInitial) {
- svgStyle->setFillPaint(SVGRenderStyle::initialFillPaintType(), SVGRenderStyle::initialFillPaintColor(), SVGRenderStyle::initialFillPaintUri(), state.applyPropertyToRegularStyle(), state.applyPropertyToVisitedLinkStyle());
- return;
- }
- if (value->isSVGPaint()) {
- SVGPaint* svgPaint = toSVGPaint(value);
- svgStyle->setFillPaint(svgPaint->paintType(), colorFromSVGPaintCSSValue(svgPaint, state.style()->color()), svgPaint->uri(), state.applyPropertyToRegularStyle(), state.applyPropertyToVisitedLinkStyle());
+ case CSSValueColumn:
+ if (second) {
+ if (second->getValueID() == CSSValueDense)
+ autoFlow = AutoFlowColumnDense;
+ else
+ autoFlow = AutoFlowStackColumn;
+ } else {
+ autoFlow = AutoFlowColumn;
}
break;
- }
- case CSSPropertyStroke:
- {
- SVGRenderStyle* svgStyle = state.style()->accessSVGStyle();
- if (isInherit) {
- const SVGRenderStyle* svgParentStyle = state.parentStyle()->svgStyle();
- svgStyle->setStrokePaint(svgParentStyle->strokePaintType(), svgParentStyle->strokePaintColor(), svgParentStyle->strokePaintUri(), state.applyPropertyToRegularStyle(), state.applyPropertyToVisitedLinkStyle());
- return;
- }
- if (isInitial) {
- svgStyle->setStrokePaint(SVGRenderStyle::initialStrokePaintType(), SVGRenderStyle::initialStrokePaintColor(), SVGRenderStyle::initialStrokePaintUri(), state.applyPropertyToRegularStyle(), state.applyPropertyToVisitedLinkStyle());
- return;
- }
- if (value->isSVGPaint()) {
- SVGPaint* svgPaint = toSVGPaint(value);
- svgStyle->setStrokePaint(svgPaint->paintType(), colorFromSVGPaintCSSValue(svgPaint, state.style()->color()), svgPaint->uri(), state.applyPropertyToRegularStyle(), state.applyPropertyToVisitedLinkStyle());
- }
+ case CSSValueDense:
+ if (second && second->getValueID() == CSSValueColumn)
+ autoFlow = AutoFlowColumnDense;
+ else
+ autoFlow = AutoFlowRowDense;
break;
- }
- case CSSPropertyEnableBackground:
- // Silently ignoring this property for now
- // http://bugs.webkit.org/show_bug.cgi?id=6022
+ case CSSValueStack:
+ if (second && second->getValueID() == CSSValueColumn)
+ autoFlow = AutoFlowStackColumn;
+ else
+ autoFlow = AutoFlowStackRow;
+ break;
+ default:
+ ASSERT_NOT_REACHED();
break;
}
+
+ state.style()->setGridAutoFlow(autoFlow);
}
-} // namespace WebCore
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff