/* * Copyright (C) 2007 Alexey Proskuryakov . * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved. * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/) * Copyright (C) 2009 Jeff Schiller * Copyright (C) Research In Motion Limited 2010. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef SKY_ENGINE_CORE_CSS_CSSPRIMITIVEVALUEMAPPINGS_H_ #define SKY_ENGINE_CORE_CSS_CSSPRIMITIVEVALUEMAPPINGS_H_ #include "gen/sky/core/CSSValueKeywords.h" #include "sky/engine/core/css/CSSCalculationValue.h" #include "sky/engine/core/css/CSSPrimitiveValue.h" #include "sky/engine/core/css/CSSPrimitiveValueMappings.h" #include "sky/engine/core/css/CSSToLengthConversionData.h" #include "sky/engine/core/rendering/style/RenderStyleConstants.h" #include "sky/engine/platform/Length.h" #include "sky/engine/platform/fonts/FontDescription.h" #include "sky/engine/platform/fonts/FontSmoothingMode.h" #include "sky/engine/platform/fonts/TextRenderingMode.h" #include "sky/engine/platform/graphics/GraphicsTypes.h" #include "sky/engine/platform/graphics/Path.h" #include "sky/engine/platform/text/TextDirection.h" #include "sky/engine/platform/text/UnicodeBidi.h" #include "sky/engine/wtf/MathExtras.h" namespace blink { template<> inline CSSPrimitiveValue::CSSPrimitiveValue(short i) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_NUMBER; m_value.num = static_cast(i); } template<> inline CSSPrimitiveValue::operator short() const { ASSERT(isNumber()); return clampTo(getDoubleValue()); } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned short i) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_NUMBER; m_value.num = static_cast(i); } template<> inline CSSPrimitiveValue::operator unsigned short() const { ASSERT(isNumber()); return clampTo(getDoubleValue()); } template<> inline CSSPrimitiveValue::operator int() const { ASSERT(isNumber()); return clampTo(getDoubleValue()); } template<> inline CSSPrimitiveValue::operator unsigned() const { ASSERT(isNumber()); return clampTo(getDoubleValue()); } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(float i) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_NUMBER; m_value.num = static_cast(i); } template<> inline CSSPrimitiveValue::operator float() const { ASSERT(isNumber()); return clampTo(getDoubleValue()); } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnFill columnFill) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (columnFill) { case ColumnFillAuto: m_value.valueID = CSSValueAuto; break; case ColumnFillBalance: m_value.valueID = CSSValueBalance; break; } } template<> inline CSSPrimitiveValue::operator ColumnFill() const { if (m_primitiveUnitType == CSS_VALUE_ID) { if (m_value.valueID == CSSValueBalance) return ColumnFillBalance; if (m_value.valueID == CSSValueAuto) return ColumnFillAuto; } ASSERT_NOT_REACHED(); return ColumnFillBalance; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case BNONE: m_value.valueID = CSSValueNone; break; case BHIDDEN: m_value.valueID = CSSValueHidden; break; case INSET: m_value.valueID = CSSValueInset; break; case GROOVE: m_value.valueID = CSSValueGroove; break; case RIDGE: m_value.valueID = CSSValueRidge; break; case OUTSET: m_value.valueID = CSSValueOutset; break; case DOTTED: m_value.valueID = CSSValueDotted; break; case DASHED: m_value.valueID = CSSValueDashed; break; case SOLID: m_value.valueID = CSSValueSolid; break; case DOUBLE: m_value.valueID = CSSValueDouble; break; } } template<> inline CSSPrimitiveValue::operator EBorderStyle() const { ASSERT(isValueID()); if (m_value.valueID == CSSValueAuto) // Valid for CSS outline-style return DOTTED; return (EBorderStyle)(m_value.valueID - CSSValueNone); } template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const { if (m_value.valueID == CSSValueAuto) return AUTO_ON; return AUTO_OFF; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case CompositeClear: m_value.valueID = CSSValueClear; break; case CompositeCopy: m_value.valueID = CSSValueCopy; break; case CompositeSourceOver: m_value.valueID = CSSValueSourceOver; break; case CompositeSourceIn: m_value.valueID = CSSValueSourceIn; break; case CompositeSourceOut: m_value.valueID = CSSValueSourceOut; break; case CompositeSourceAtop: m_value.valueID = CSSValueSourceAtop; break; case CompositeDestinationOver: m_value.valueID = CSSValueDestinationOver; break; case CompositeDestinationIn: m_value.valueID = CSSValueDestinationIn; break; case CompositeDestinationOut: m_value.valueID = CSSValueDestinationOut; break; case CompositeDestinationAtop: m_value.valueID = CSSValueDestinationAtop; break; case CompositeXOR: m_value.valueID = CSSValueXor; break; case CompositePlusDarker: m_value.valueID = CSSValuePlusDarker; break; case CompositePlusLighter: m_value.valueID = CSSValuePlusLighter; break; case CompositeDifference: ASSERT_NOT_REACHED(); break; } } template<> inline CSSPrimitiveValue::operator CompositeOperator() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueClear: return CompositeClear; case CSSValueCopy: return CompositeCopy; case CSSValueSourceOver: return CompositeSourceOver; case CSSValueSourceIn: return CompositeSourceIn; case CSSValueSourceOut: return CompositeSourceOut; case CSSValueSourceAtop: return CompositeSourceAtop; case CSSValueDestinationOver: return CompositeDestinationOver; case CSSValueDestinationIn: return CompositeDestinationIn; case CSSValueDestinationOut: return CompositeDestinationOut; case CSSValueDestinationAtop: return CompositeDestinationAtop; case CSSValueXor: return CompositeXOR; case CSSValuePlusDarker: return CompositePlusDarker; case CSSValuePlusLighter: return CompositePlusLighter; default: break; } ASSERT_NOT_REACHED(); return CompositeClear; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case BackfaceVisibilityVisible: m_value.valueID = CSSValueVisible; break; case BackfaceVisibilityHidden: m_value.valueID = CSSValueHidden; break; } } template<> inline CSSPrimitiveValue::operator EBackfaceVisibility() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueVisible: return BackfaceVisibilityVisible; case CSSValueHidden: return BackfaceVisibilityHidden; default: break; } ASSERT_NOT_REACHED(); return BackfaceVisibilityHidden; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case LocalBackgroundAttachment: m_value.valueID = CSSValueLocal; break; case FixedBackgroundAttachment: m_value.valueID = CSSValueFixed; break; } } template<> inline CSSPrimitiveValue::operator EFillAttachment() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueLocal: return LocalBackgroundAttachment; case CSSValueFixed: return FixedBackgroundAttachment; default: break; } ASSERT_NOT_REACHED(); return LocalBackgroundAttachment; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case BorderFillBox: m_value.valueID = CSSValueBorderBox; break; case PaddingFillBox: m_value.valueID = CSSValuePaddingBox; break; case ContentFillBox: m_value.valueID = CSSValueContentBox; break; } } template<> inline CSSPrimitiveValue::operator EFillBox() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueBorder: case CSSValueBorderBox: return BorderFillBox; case CSSValuePadding: case CSSValuePaddingBox: return PaddingFillBox; case CSSValueContent: case CSSValueContentBox: return ContentFillBox; default: break; } ASSERT_NOT_REACHED(); return BorderFillBox; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case RepeatFill: m_value.valueID = CSSValueRepeat; break; case NoRepeatFill: m_value.valueID = CSSValueNoRepeat; break; case RoundFill: m_value.valueID = CSSValueRound; break; case SpaceFill: m_value.valueID = CSSValueSpace; break; } } template<> inline CSSPrimitiveValue::operator EFillRepeat() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueRepeat: return RepeatFill; case CSSValueNoRepeat: return NoRepeatFill; case CSSValueRound: return RoundFill; case CSSValueSpace: return SpaceFill; default: break; } ASSERT_NOT_REACHED(); return RepeatFill; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case Start: m_value.valueID = CSSValueStart; break; case Center: m_value.valueID = CSSValueCenter; break; case End: m_value.valueID = CSSValueEnd; break; case Justify: m_value.valueID = CSSValueJustify; break; } } template<> inline CSSPrimitiveValue::operator EBoxPack() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueStart: return Start; case CSSValueEnd: return End; case CSSValueCenter: return Center; case CSSValueJustify: return Justify; default: break; } ASSERT_NOT_REACHED(); return Justify; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case BSTRETCH: m_value.valueID = CSSValueStretch; break; case BSTART: m_value.valueID = CSSValueStart; break; case BCENTER: m_value.valueID = CSSValueCenter; break; case BEND: m_value.valueID = CSSValueEnd; break; case BBASELINE: m_value.valueID = CSSValueBaseline; break; } } template<> inline CSSPrimitiveValue::operator EBoxAlignment() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueStretch: return BSTRETCH; case CSSValueStart: return BSTART; case CSSValueEnd: return BEND; case CSSValueCenter: return BCENTER; case CSSValueBaseline: return BBASELINE; default: break; } ASSERT_NOT_REACHED(); return BSTRETCH; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case DSLICE: m_value.valueID = CSSValueSlice; break; case DCLONE: m_value.valueID = CSSValueClone; break; } } template<> inline CSSPrimitiveValue::operator EBoxDecorationBreak() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueSlice: return DSLICE; case CSSValueClone: return DCLONE; default: break; } ASSERT_NOT_REACHED(); return DSLICE; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackgroundEdgeOrigin e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case TopEdge: m_value.valueID = CSSValueTop; break; case RightEdge: m_value.valueID = CSSValueRight; break; case BottomEdge: m_value.valueID = CSSValueBottom; break; case LeftEdge: m_value.valueID = CSSValueLeft; break; } } template<> inline CSSPrimitiveValue::operator BackgroundEdgeOrigin() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueTop: return TopEdge; case CSSValueRight: return RightEdge; case CSSValueBottom: return BottomEdge; case CSSValueLeft: return LeftEdge; default: break; } ASSERT_NOT_REACHED(); return TopEdge; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case BORDER_BOX: m_value.valueID = CSSValueBorderBox; break; case CONTENT_BOX: m_value.valueID = CSSValueContentBox; break; } } template<> inline CSSPrimitiveValue::operator EBoxSizing() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueBorderBox: return BORDER_BOX; case CSSValueContentBox: return CONTENT_BOX; default: break; } ASSERT_NOT_REACHED(); return BORDER_BOX; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case BNORMAL: m_value.valueID = CSSValueNormal; break; case BREVERSE: m_value.valueID = CSSValueReverse; break; } } template<> inline CSSPrimitiveValue::operator EBoxDirection() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNormal: return BNORMAL; case CSSValueReverse: return BREVERSE; default: break; } ASSERT_NOT_REACHED(); return BNORMAL; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case SINGLE: m_value.valueID = CSSValueSingle; break; case MULTIPLE: m_value.valueID = CSSValueMultiple; break; } } template<> inline CSSPrimitiveValue::operator EBoxLines() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueSingle: return SINGLE; case CSSValueMultiple: return MULTIPLE; default: break; } ASSERT_NOT_REACHED(); return SINGLE; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case HORIZONTAL: m_value.valueID = CSSValueHorizontal; break; case VERTICAL: m_value.valueID = CSSValueVertical; break; } } template<> inline CSSPrimitiveValue::operator EBoxOrient() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueHorizontal: case CSSValueInlineAxis: return HORIZONTAL; case CSSValueVertical: case CSSValueBlockAxis: return VERTICAL; default: break; } ASSERT_NOT_REACHED(); return HORIZONTAL; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case CAPLEFT: m_value.valueID = CSSValueLeft; break; case CAPRIGHT: m_value.valueID = CSSValueRight; break; case CAPTOP: m_value.valueID = CSSValueTop; break; case CAPBOTTOM: m_value.valueID = CSSValueBottom; break; } } template<> inline CSSPrimitiveValue::operator ECaptionSide() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueLeft: return CAPLEFT; case CSSValueRight: return CAPRIGHT; case CSSValueTop: return CAPTOP; case CSSValueBottom: return CAPBOTTOM; default: break; } ASSERT_NOT_REACHED(); return CAPTOP; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case CURSOR_AUTO: m_value.valueID = CSSValueAuto; break; case CURSOR_CROSS: m_value.valueID = CSSValueCrosshair; break; case CURSOR_DEFAULT: m_value.valueID = CSSValueDefault; break; case CURSOR_POINTER: m_value.valueID = CSSValuePointer; break; case CURSOR_MOVE: m_value.valueID = CSSValueMove; break; case CURSOR_CELL: m_value.valueID = CSSValueCell; break; case CURSOR_VERTICAL_TEXT: m_value.valueID = CSSValueVerticalText; break; case CURSOR_CONTEXT_MENU: m_value.valueID = CSSValueContextMenu; break; case CURSOR_ALIAS: m_value.valueID = CSSValueAlias; break; case CURSOR_COPY: m_value.valueID = CSSValueCopy; break; case CURSOR_NONE: m_value.valueID = CSSValueNone; break; case CURSOR_PROGRESS: m_value.valueID = CSSValueProgress; break; case CURSOR_NO_DROP: m_value.valueID = CSSValueNoDrop; break; case CURSOR_NOT_ALLOWED: m_value.valueID = CSSValueNotAllowed; break; case CURSOR_ZOOM_IN: m_value.valueID = CSSValueZoomIn; break; case CURSOR_ZOOM_OUT: m_value.valueID = CSSValueZoomOut; break; case CURSOR_E_RESIZE: m_value.valueID = CSSValueEResize; break; case CURSOR_NE_RESIZE: m_value.valueID = CSSValueNeResize; break; case CURSOR_NW_RESIZE: m_value.valueID = CSSValueNwResize; break; case CURSOR_N_RESIZE: m_value.valueID = CSSValueNResize; break; case CURSOR_SE_RESIZE: m_value.valueID = CSSValueSeResize; break; case CURSOR_SW_RESIZE: m_value.valueID = CSSValueSwResize; break; case CURSOR_S_RESIZE: m_value.valueID = CSSValueSResize; break; case CURSOR_W_RESIZE: m_value.valueID = CSSValueWResize; break; case CURSOR_EW_RESIZE: m_value.valueID = CSSValueEwResize; break; case CURSOR_NS_RESIZE: m_value.valueID = CSSValueNsResize; break; case CURSOR_NESW_RESIZE: m_value.valueID = CSSValueNeswResize; break; case CURSOR_NWSE_RESIZE: m_value.valueID = CSSValueNwseResize; break; case CURSOR_COL_RESIZE: m_value.valueID = CSSValueColResize; break; case CURSOR_ROW_RESIZE: m_value.valueID = CSSValueRowResize; break; case CURSOR_TEXT: m_value.valueID = CSSValueText; break; case CURSOR_WAIT: m_value.valueID = CSSValueWait; break; case CURSOR_HELP: m_value.valueID = CSSValueHelp; break; case CURSOR_ALL_SCROLL: m_value.valueID = CSSValueAllScroll; break; case CURSOR_WEBKIT_GRAB: m_value.valueID = CSSValueWebkitGrab; break; case CURSOR_WEBKIT_GRABBING: m_value.valueID = CSSValueWebkitGrabbing; break; } } template<> inline CSSPrimitiveValue::operator ECursor() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueCopy: return CURSOR_COPY; case CSSValueWebkitZoomIn: return CURSOR_ZOOM_IN; case CSSValueWebkitZoomOut: return CURSOR_ZOOM_OUT; case CSSValueNone: return CURSOR_NONE; default: return static_cast(m_value.valueID - CSSValueAuto); } } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case INLINE: m_value.valueID = CSSValueInline; break; case PARAGRAPH: m_value.valueID = CSSValueParagraph; break; case BLOCK: m_value.valueID = CSSValueBlock; break; case INLINE_BLOCK: m_value.valueID = CSSValueInlineBlock; break; case FLEX: m_value.valueID = CSSValueFlex; break; case INLINE_FLEX: m_value.valueID = CSSValueInlineFlex; break; case NONE: m_value.valueID = CSSValueNone; break; } } template<> inline CSSPrimitiveValue::operator EDisplay() const { ASSERT(isValueID()); if (m_value.valueID == CSSValueNone) return NONE; EDisplay display = static_cast(m_value.valueID - CSSValueInline); ASSERT(display >= INLINE && display <= NONE); return display; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case SHOW: m_value.valueID = CSSValueShow; break; case HIDE: m_value.valueID = CSSValueHide; break; } } template<> inline CSSPrimitiveValue::operator EEmptyCell() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueShow: return SHOW; case CSSValueHide: return HIDE; default: break; } ASSERT_NOT_REACHED(); return SHOW; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifyContent e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case JustifyFlexStart: m_value.valueID = CSSValueFlexStart; break; case JustifyFlexEnd: m_value.valueID = CSSValueFlexEnd; break; case JustifyCenter: m_value.valueID = CSSValueCenter; break; case JustifySpaceBetween: m_value.valueID = CSSValueSpaceBetween; break; case JustifySpaceAround: m_value.valueID = CSSValueSpaceAround; break; } } template<> inline CSSPrimitiveValue::operator EJustifyContent() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueFlexStart: return JustifyFlexStart; case CSSValueFlexEnd: return JustifyFlexEnd; case CSSValueCenter: return JustifyCenter; case CSSValueSpaceBetween: return JustifySpaceBetween; case CSSValueSpaceAround: return JustifySpaceAround; default: break; } ASSERT_NOT_REACHED(); return JustifyFlexStart; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case FlowRow: m_value.valueID = CSSValueRow; break; case FlowRowReverse: m_value.valueID = CSSValueRowReverse; break; case FlowColumn: m_value.valueID = CSSValueColumn; break; case FlowColumnReverse: m_value.valueID = CSSValueColumnReverse; break; } } template<> inline CSSPrimitiveValue::operator EFlexDirection() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueRow: return FlowRow; case CSSValueRowReverse: return FlowRowReverse; case CSSValueColumn: return FlowColumn; case CSSValueColumnReverse: return FlowColumnReverse; default: break; } ASSERT_NOT_REACHED(); return FlowRow; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case AlignContentFlexStart: m_value.valueID = CSSValueFlexStart; break; case AlignContentFlexEnd: m_value.valueID = CSSValueFlexEnd; break; case AlignContentCenter: m_value.valueID = CSSValueCenter; break; case AlignContentSpaceBetween: m_value.valueID = CSSValueSpaceBetween; break; case AlignContentSpaceAround: m_value.valueID = CSSValueSpaceAround; break; case AlignContentStretch: m_value.valueID = CSSValueStretch; break; } } template<> inline CSSPrimitiveValue::operator EAlignContent() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueFlexStart: return AlignContentFlexStart; case CSSValueFlexEnd: return AlignContentFlexEnd; case CSSValueCenter: return AlignContentCenter; case CSSValueSpaceBetween: return AlignContentSpaceBetween; case CSSValueSpaceAround: return AlignContentSpaceAround; case CSSValueStretch: return AlignContentStretch; default: break; } ASSERT_NOT_REACHED(); return AlignContentStretch; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case FlexNoWrap: m_value.valueID = CSSValueNowrap; break; case FlexWrap: m_value.valueID = CSSValueWrap; break; case FlexWrapReverse: m_value.valueID = CSSValueWrapReverse; break; } } template<> inline CSSPrimitiveValue::operator EFlexWrap() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNowrap: return FlexNoWrap; case CSSValueWrap: return FlexWrap; case CSSValueWrapReverse: return FlexWrapReverse; default: break; } ASSERT_NOT_REACHED(); return FlexNoWrap; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case LineBreakAuto: m_value.valueID = CSSValueAuto; break; case LineBreakLoose: m_value.valueID = CSSValueLoose; break; case LineBreakNormal: m_value.valueID = CSSValueNormal; break; case LineBreakStrict: m_value.valueID = CSSValueStrict; break; case LineBreakAfterWhiteSpace: m_value.valueID = CSSValueAfterWhiteSpace; break; } } template<> inline CSSPrimitiveValue::operator LineBreak() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return LineBreakAuto; case CSSValueLoose: return LineBreakLoose; case CSSValueNormal: return LineBreakNormal; case CSSValueStrict: return LineBreakStrict; case CSSValueAfterWhiteSpace: return LineBreakAfterWhiteSpace; default: break; } ASSERT_NOT_REACHED(); return LineBreakAuto; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case OUTSIDE: m_value.valueID = CSSValueOutside; break; case INSIDE: m_value.valueID = CSSValueInside; break; } } template<> inline CSSPrimitiveValue::operator EListStylePosition() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueOutside: return OUTSIDE; case CSSValueInside: return INSIDE; default: break; } ASSERT_NOT_REACHED(); return OUTSIDE; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case Afar: m_value.valueID = CSSValueAfar; break; case Amharic: m_value.valueID = CSSValueAmharic; break; case AmharicAbegede: m_value.valueID = CSSValueAmharicAbegede; break; case ArabicIndic: m_value.valueID = CSSValueArabicIndic; break; case Armenian: m_value.valueID = CSSValueArmenian; break; case Asterisks: m_value.valueID = CSSValueAsterisks; break; case BinaryListStyle: m_value.valueID = CSSValueBinary; break; case Bengali: m_value.valueID = CSSValueBengali; break; case Cambodian: m_value.valueID = CSSValueCambodian; break; case Circle: m_value.valueID = CSSValueCircle; break; case CjkEarthlyBranch: m_value.valueID = CSSValueCjkEarthlyBranch; break; case CjkHeavenlyStem: m_value.valueID = CSSValueCjkHeavenlyStem; break; case CJKIdeographic: m_value.valueID = CSSValueCjkIdeographic; break; case DecimalLeadingZero: m_value.valueID = CSSValueDecimalLeadingZero; break; case DecimalListStyle: m_value.valueID = CSSValueDecimal; break; case Devanagari: m_value.valueID = CSSValueDevanagari; break; case Disc: m_value.valueID = CSSValueDisc; break; case Ethiopic: m_value.valueID = CSSValueEthiopic; break; case EthiopicAbegede: m_value.valueID = CSSValueEthiopicAbegede; break; case EthiopicAbegedeAmEt: m_value.valueID = CSSValueEthiopicAbegedeAmEt; break; case EthiopicAbegedeGez: m_value.valueID = CSSValueEthiopicAbegedeGez; break; case EthiopicAbegedeTiEr: m_value.valueID = CSSValueEthiopicAbegedeTiEr; break; case EthiopicAbegedeTiEt: m_value.valueID = CSSValueEthiopicAbegedeTiEt; break; case EthiopicHalehameAaEr: m_value.valueID = CSSValueEthiopicHalehameAaEr; break; case EthiopicHalehameAaEt: m_value.valueID = CSSValueEthiopicHalehameAaEt; break; case EthiopicHalehameAmEt: m_value.valueID = CSSValueEthiopicHalehameAmEt; break; case EthiopicHalehameGez: m_value.valueID = CSSValueEthiopicHalehameGez; break; case EthiopicHalehameOmEt: m_value.valueID = CSSValueEthiopicHalehameOmEt; break; case EthiopicHalehameSidEt: m_value.valueID = CSSValueEthiopicHalehameSidEt; break; case EthiopicHalehameSoEt: m_value.valueID = CSSValueEthiopicHalehameSoEt; break; case EthiopicHalehameTiEr: m_value.valueID = CSSValueEthiopicHalehameTiEr; break; case EthiopicHalehameTiEt: m_value.valueID = CSSValueEthiopicHalehameTiEt; break; case EthiopicHalehameTig: m_value.valueID = CSSValueEthiopicHalehameTig; break; case Footnotes: m_value.valueID = CSSValueFootnotes; break; case Georgian: m_value.valueID = CSSValueGeorgian; break; case Gujarati: m_value.valueID = CSSValueGujarati; break; case Gurmukhi: m_value.valueID = CSSValueGurmukhi; break; case Hangul: m_value.valueID = CSSValueHangul; break; case HangulConsonant: m_value.valueID = CSSValueHangulConsonant; break; case Hebrew: m_value.valueID = CSSValueHebrew; break; case Hiragana: m_value.valueID = CSSValueHiragana; break; case HiraganaIroha: m_value.valueID = CSSValueHiraganaIroha; break; case Kannada: m_value.valueID = CSSValueKannada; break; case Katakana: m_value.valueID = CSSValueKatakana; break; case KatakanaIroha: m_value.valueID = CSSValueKatakanaIroha; break; case Khmer: m_value.valueID = CSSValueKhmer; break; case Lao: m_value.valueID = CSSValueLao; break; case LowerAlpha: m_value.valueID = CSSValueLowerAlpha; break; case LowerArmenian: m_value.valueID = CSSValueLowerArmenian; break; case LowerGreek: m_value.valueID = CSSValueLowerGreek; break; case LowerHexadecimal: m_value.valueID = CSSValueLowerHexadecimal; break; case LowerLatin: m_value.valueID = CSSValueLowerLatin; break; case LowerNorwegian: m_value.valueID = CSSValueLowerNorwegian; break; case LowerRoman: m_value.valueID = CSSValueLowerRoman; break; case Malayalam: m_value.valueID = CSSValueMalayalam; break; case Mongolian: m_value.valueID = CSSValueMongolian; break; case Myanmar: m_value.valueID = CSSValueMyanmar; break; case NoneListStyle: m_value.valueID = CSSValueNone; break; case Octal: m_value.valueID = CSSValueOctal; break; case Oriya: m_value.valueID = CSSValueOriya; break; case Oromo: m_value.valueID = CSSValueOromo; break; case Persian: m_value.valueID = CSSValuePersian; break; case Sidama: m_value.valueID = CSSValueSidama; break; case Somali: m_value.valueID = CSSValueSomali; break; case Square: m_value.valueID = CSSValueSquare; break; case Telugu: m_value.valueID = CSSValueTelugu; break; case Thai: m_value.valueID = CSSValueThai; break; case Tibetan: m_value.valueID = CSSValueTibetan; break; case Tigre: m_value.valueID = CSSValueTigre; break; case TigrinyaEr: m_value.valueID = CSSValueTigrinyaEr; break; case TigrinyaErAbegede: m_value.valueID = CSSValueTigrinyaErAbegede; break; case TigrinyaEt: m_value.valueID = CSSValueTigrinyaEt; break; case TigrinyaEtAbegede: m_value.valueID = CSSValueTigrinyaEtAbegede; break; case UpperAlpha: m_value.valueID = CSSValueUpperAlpha; break; case UpperArmenian: m_value.valueID = CSSValueUpperArmenian; break; case UpperGreek: m_value.valueID = CSSValueUpperGreek; break; case UpperHexadecimal: m_value.valueID = CSSValueUpperHexadecimal; break; case UpperLatin: m_value.valueID = CSSValueUpperLatin; break; case UpperNorwegian: m_value.valueID = CSSValueUpperNorwegian; break; case UpperRoman: m_value.valueID = CSSValueUpperRoman; break; case Urdu: m_value.valueID = CSSValueUrdu; break; } } template<> inline CSSPrimitiveValue::operator EListStyleType() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNone: return NoneListStyle; default: return static_cast(m_value.valueID - CSSValueDisc); } } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case OVISIBLE: m_value.valueID = CSSValueVisible; break; case OHIDDEN: m_value.valueID = CSSValueHidden; break; case OAUTO: m_value.valueID = CSSValueAuto; break; case OOVERLAY: m_value.valueID = CSSValueOverlay; break; case OPAGEDX: m_value.valueID = CSSValueWebkitPagedX; break; case OPAGEDY: m_value.valueID = CSSValueWebkitPagedY; break; } } template<> inline CSSPrimitiveValue::operator EOverflow() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueVisible: return OVISIBLE; case CSSValueHidden: return OHIDDEN; case CSSValueAuto: return OAUTO; case CSSValueOverlay: return OOVERLAY; case CSSValueWebkitPagedX: return OPAGEDX; case CSSValueWebkitPagedY: return OPAGEDY; default: break; } ASSERT_NOT_REACHED(); return OVISIBLE; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case PBAUTO: m_value.valueID = CSSValueAuto; break; case PBALWAYS: m_value.valueID = CSSValueAlways; break; case PBAVOID: m_value.valueID = CSSValueAvoid; break; } } template<> inline CSSPrimitiveValue::operator EPageBreak() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return PBAUTO; case CSSValueLeft: case CSSValueRight: case CSSValueAlways: return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always." case CSSValueAvoid: return PBAVOID; default: break; } ASSERT_NOT_REACHED(); return PBAUTO; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case StaticPosition: m_value.valueID = CSSValueStatic; break; case AbsolutePosition: m_value.valueID = CSSValueAbsolute; break; } } template<> inline CSSPrimitiveValue::operator EPosition() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueStatic: return StaticPosition; case CSSValueAbsolute: return AbsolutePosition; default: break; } ASSERT_NOT_REACHED(); return StaticPosition; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case TAUTO: m_value.valueID = CSSValueAuto; break; case TFIXED: m_value.valueID = CSSValueFixed; break; } } template<> inline CSSPrimitiveValue::operator ETableLayout() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueFixed: return TFIXED; case CSSValueAuto: return TAUTO; default: break; } ASSERT_NOT_REACHED(); return TAUTO; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case TASTART: m_value.valueID = CSSValueStart; break; case TAEND: m_value.valueID = CSSValueEnd; break; case LEFT: m_value.valueID = CSSValueLeft; break; case RIGHT: m_value.valueID = CSSValueRight; break; case CENTER: m_value.valueID = CSSValueCenter; break; case JUSTIFY: m_value.valueID = CSSValueJustify; break; } } template<> inline CSSPrimitiveValue::operator ETextAlign() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueStart: return TASTART; case CSSValueEnd: return TAEND; default: return static_cast(m_value.valueID - CSSValueLeft); } } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case TextAlignLastStart: m_value.valueID = CSSValueStart; break; case TextAlignLastEnd: m_value.valueID = CSSValueEnd; break; case TextAlignLastLeft: m_value.valueID = CSSValueLeft; break; case TextAlignLastRight: m_value.valueID = CSSValueRight; break; case TextAlignLastCenter: m_value.valueID = CSSValueCenter; break; case TextAlignLastJustify: m_value.valueID = CSSValueJustify; break; case TextAlignLastAuto: m_value.valueID = CSSValueAuto; break; } } template<> inline CSSPrimitiveValue::operator TextAlignLast() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return TextAlignLastAuto; case CSSValueStart: return TextAlignLastStart; case CSSValueEnd: return TextAlignLastEnd; case CSSValueLeft: return TextAlignLastLeft; case CSSValueRight: return TextAlignLastRight; case CSSValueCenter: return TextAlignLastCenter; case CSSValueJustify: return TextAlignLastJustify; default: break; } ASSERT_NOT_REACHED(); return TextAlignLastAuto; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case TextJustifyAuto: m_value.valueID = CSSValueAuto; break; case TextJustifyNone: m_value.valueID = CSSValueNone; break; case TextJustifyInterWord: m_value.valueID = CSSValueInterWord; break; case TextJustifyDistribute: m_value.valueID = CSSValueDistribute; break; } } template<> inline CSSPrimitiveValue::operator TextJustify() const { switch (m_value.valueID) { case CSSValueAuto: return TextJustifyAuto; case CSSValueNone: return TextJustifyNone; case CSSValueInterWord: return TextJustifyInterWord; case CSSValueDistribute: return TextJustifyDistribute; default: break; } ASSERT_NOT_REACHED(); return TextJustifyAuto; } template<> inline CSSPrimitiveValue::operator TextDecoration() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNone: return TextDecorationNone; case CSSValueUnderline: return TextDecorationUnderline; case CSSValueOverline: return TextDecorationOverline; case CSSValueLineThrough: return TextDecorationLineThrough; case CSSValueBlink: return TextDecorationBlink; default: break; } ASSERT_NOT_REACHED(); return TextDecorationNone; } template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueSolid: return TextDecorationStyleSolid; case CSSValueDouble: return TextDecorationStyleDouble; case CSSValueDotted: return TextDecorationStyleDotted; case CSSValueDashed: return TextDecorationStyleDashed; case CSSValueWavy: return TextDecorationStyleWavy; default: break; } ASSERT_NOT_REACHED(); return TextDecorationStyleSolid; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case TextUnderlinePositionAuto: m_value.valueID = CSSValueAuto; break; case TextUnderlinePositionUnder: m_value.valueID = CSSValueUnder; break; } // FIXME: Implement support for 'under left' and 'under right' values. } template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return TextUnderlinePositionAuto; case CSSValueUnder: return TextUnderlinePositionUnder; default: break; } // FIXME: Implement support for 'under left' and 'under right' values. ASSERT_NOT_REACHED(); return TextUnderlinePositionAuto; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case UBNormal: m_value.valueID = CSSValueNormal; break; case Embed: m_value.valueID = CSSValueEmbed; break; case Override: m_value.valueID = CSSValueBidiOverride; break; case Isolate: m_value.valueID = CSSValueWebkitIsolate; break; case IsolateOverride: m_value.valueID = CSSValueWebkitIsolateOverride; break; case Plaintext: m_value.valueID = CSSValueWebkitPlaintext; break; } } template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNormal: return UBNormal; case CSSValueEmbed: return Embed; case CSSValueBidiOverride: return Override; case CSSValueWebkitIsolate: return Isolate; case CSSValueWebkitIsolateOverride: return IsolateOverride; case CSSValueWebkitPlaintext: return Plaintext; default: break; } ASSERT_NOT_REACHED(); return UBNormal; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case DRAG_AUTO: m_value.valueID = CSSValueAuto; break; case DRAG_NONE: m_value.valueID = CSSValueNone; break; case DRAG_ELEMENT: m_value.valueID = CSSValueElement; break; default: break; } } template<> inline CSSPrimitiveValue::operator EUserDrag() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return DRAG_AUTO; case CSSValueNone: return DRAG_NONE; case CSSValueElement: return DRAG_ELEMENT; default: break; } ASSERT_NOT_REACHED(); return DRAG_AUTO; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case READ_ONLY: m_value.valueID = CSSValueReadOnly; break; case READ_WRITE: m_value.valueID = CSSValueReadWrite; break; case READ_WRITE_PLAINTEXT_ONLY: m_value.valueID = CSSValueReadWritePlaintextOnly; break; } } template<> inline CSSPrimitiveValue::operator EUserModify() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueReadOnly: return READ_ONLY; case CSSValueReadWrite: return READ_WRITE; case CSSValueReadWritePlaintextOnly: return READ_WRITE_PLAINTEXT_ONLY; default: break; } ASSERT_NOT_REACHED(); return READ_ONLY; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case SELECT_NONE: m_value.valueID = CSSValueNone; break; case SELECT_TEXT: m_value.valueID = CSSValueText; break; case SELECT_ALL: m_value.valueID = CSSValueAll; break; } } template<> inline CSSPrimitiveValue::operator EUserSelect() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return SELECT_TEXT; case CSSValueNone: return SELECT_NONE; case CSSValueText: return SELECT_TEXT; case CSSValueAll: return SELECT_ALL; default: break; } ASSERT_NOT_REACHED(); return SELECT_TEXT; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (a) { case TOP: m_value.valueID = CSSValueTop; break; case BOTTOM: m_value.valueID = CSSValueBottom; break; case MIDDLE: m_value.valueID = CSSValueMiddle; break; case BASELINE: m_value.valueID = CSSValueBaseline; break; case TEXT_BOTTOM: m_value.valueID = CSSValueTextBottom; break; case TEXT_TOP: m_value.valueID = CSSValueTextTop; break; case SUB: m_value.valueID = CSSValueSub; break; case SUPER: m_value.valueID = CSSValueSuper; break; case BASELINE_MIDDLE: m_value.valueID = CSSValueWebkitBaselineMiddle; break; case LENGTH: m_value.valueID = CSSValueInvalid; } } template<> inline CSSPrimitiveValue::operator EVerticalAlign() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueTop: return TOP; case CSSValueBottom: return BOTTOM; case CSSValueMiddle: return MIDDLE; case CSSValueBaseline: return BASELINE; case CSSValueTextBottom: return TEXT_BOTTOM; case CSSValueTextTop: return TEXT_TOP; case CSSValueSub: return SUB; case CSSValueSuper: return SUPER; case CSSValueWebkitBaselineMiddle: return BASELINE_MIDDLE; default: break; } ASSERT_NOT_REACHED(); return TOP; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case VISIBLE: m_value.valueID = CSSValueVisible; break; case HIDDEN: m_value.valueID = CSSValueHidden; break; case COLLAPSE: m_value.valueID = CSSValueCollapse; break; } } template<> inline CSSPrimitiveValue::operator EVisibility() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueHidden: return HIDDEN; case CSSValueVisible: return VISIBLE; case CSSValueCollapse: return COLLAPSE; default: break; } ASSERT_NOT_REACHED(); return VISIBLE; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case NORMAL: m_value.valueID = CSSValueNormal; break; case PRE: m_value.valueID = CSSValuePre; break; case PRE_WRAP: m_value.valueID = CSSValuePreWrap; break; case PRE_LINE: m_value.valueID = CSSValuePreLine; break; case NOWRAP: m_value.valueID = CSSValueNowrap; break; case KHTML_NOWRAP: m_value.valueID = CSSValueWebkitNowrap; break; } } template<> inline CSSPrimitiveValue::operator EWhiteSpace() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueWebkitNowrap: return KHTML_NOWRAP; case CSSValueNowrap: return NOWRAP; case CSSValuePre: return PRE; case CSSValuePreWrap: return PRE_WRAP; case CSSValuePreLine: return PRE_LINE; case CSSValueNormal: return NORMAL; default: break; } ASSERT_NOT_REACHED(); return NORMAL; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case NormalWordBreak: m_value.valueID = CSSValueNormal; break; case BreakAllWordBreak: m_value.valueID = CSSValueBreakAll; break; case BreakWordBreak: m_value.valueID = CSSValueBreakWord; break; } } template<> inline CSSPrimitiveValue::operator EWordBreak() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueBreakAll: return BreakAllWordBreak; case CSSValueBreakWord: return BreakWordBreak; case CSSValueNormal: return NormalWordBreak; default: break; } ASSERT_NOT_REACHED(); return NormalWordBreak; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case NormalOverflowWrap: m_value.valueID = CSSValueNormal; break; case BreakOverflowWrap: m_value.valueID = CSSValueBreakWord; break; } } template<> inline CSSPrimitiveValue::operator EOverflowWrap() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueBreakWord: return BreakOverflowWrap; case CSSValueNormal: return NormalOverflowWrap; default: break; } ASSERT_NOT_REACHED(); return NormalOverflowWrap; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case LTR: m_value.valueID = CSSValueLtr; break; case RTL: m_value.valueID = CSSValueRtl; break; } } template<> inline CSSPrimitiveValue::operator TextDirection() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueLtr: return LTR; case CSSValueRtl: return RTL; default: break; } ASSERT_NOT_REACHED(); return LTR; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (position) { case TextEmphasisPositionOver: m_value.valueID = CSSValueOver; break; case TextEmphasisPositionUnder: m_value.valueID = CSSValueUnder; break; } } template<> inline CSSPrimitiveValue::operator TextEmphasisPosition() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueOver: return TextEmphasisPositionOver; case CSSValueUnder: return TextEmphasisPositionUnder; default: break; } ASSERT_NOT_REACHED(); return TextEmphasisPositionOver; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (overflow) { case TextOverflowClip: m_value.valueID = CSSValueClip; break; case TextOverflowEllipsis: m_value.valueID = CSSValueEllipsis; break; } } template<> inline CSSPrimitiveValue::operator TextOverflow() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueClip: return TextOverflowClip; case CSSValueEllipsis: return TextOverflowEllipsis; default: break; } ASSERT_NOT_REACHED(); return TextOverflowClip; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (fill) { case TextEmphasisFillFilled: m_value.valueID = CSSValueFilled; break; case TextEmphasisFillOpen: m_value.valueID = CSSValueOpen; break; } } template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueFilled: return TextEmphasisFillFilled; case CSSValueOpen: return TextEmphasisFillOpen; default: break; } ASSERT_NOT_REACHED(); return TextEmphasisFillFilled; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (mark) { case TextEmphasisMarkDot: m_value.valueID = CSSValueDot; break; case TextEmphasisMarkCircle: m_value.valueID = CSSValueCircle; break; case TextEmphasisMarkDoubleCircle: m_value.valueID = CSSValueDoubleCircle; break; case TextEmphasisMarkTriangle: m_value.valueID = CSSValueTriangle; break; case TextEmphasisMarkSesame: m_value.valueID = CSSValueSesame; break; case TextEmphasisMarkNone: case TextEmphasisMarkAuto: case TextEmphasisMarkCustom: ASSERT_NOT_REACHED(); m_value.valueID = CSSValueNone; break; } } template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNone: return TextEmphasisMarkNone; case CSSValueDot: return TextEmphasisMarkDot; case CSSValueCircle: return TextEmphasisMarkCircle; case CSSValueDoubleCircle: return TextEmphasisMarkDoubleCircle; case CSSValueTriangle: return TextEmphasisMarkTriangle; case CSSValueSesame: return TextEmphasisMarkSesame; default: break; } ASSERT_NOT_REACHED(); return TextEmphasisMarkNone; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case TextOrientationSideways: m_value.valueID = CSSValueSideways; break; case TextOrientationSidewaysRight: m_value.valueID = CSSValueSidewaysRight; break; case TextOrientationVerticalRight: m_value.valueID = CSSValueVerticalRight; break; case TextOrientationUpright: m_value.valueID = CSSValueUpright; break; } } template<> inline CSSPrimitiveValue::operator TextOrientation() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueSideways: return TextOrientationSideways; case CSSValueSidewaysRight: return TextOrientationSidewaysRight; case CSSValueVerticalRight: return TextOrientationVerticalRight; case CSSValueUpright: return TextOrientationUpright; default: break; } ASSERT_NOT_REACHED(); return TextOrientationVerticalRight; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case PE_NONE: m_value.valueID = CSSValueNone; break; case PE_STROKE: m_value.valueID = CSSValueStroke; break; case PE_FILL: m_value.valueID = CSSValueFill; break; case PE_PAINTED: m_value.valueID = CSSValuePainted; break; case PE_VISIBLE: m_value.valueID = CSSValueVisible; break; case PE_VISIBLE_STROKE: m_value.valueID = CSSValueVisiblestroke; break; case PE_VISIBLE_FILL: m_value.valueID = CSSValueVisiblefill; break; case PE_VISIBLE_PAINTED: m_value.valueID = CSSValueVisiblepainted; break; case PE_AUTO: m_value.valueID = CSSValueAuto; break; case PE_ALL: m_value.valueID = CSSValueAll; break; case PE_BOUNDINGBOX: m_value.valueID = CSSValueBoundingBox; break; } } template<> inline CSSPrimitiveValue::operator EPointerEvents() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAll: return PE_ALL; case CSSValueAuto: return PE_AUTO; case CSSValueNone: return PE_NONE; case CSSValueVisiblepainted: return PE_VISIBLE_PAINTED; case CSSValueVisiblefill: return PE_VISIBLE_FILL; case CSSValueVisiblestroke: return PE_VISIBLE_STROKE; case CSSValueVisible: return PE_VISIBLE; case CSSValuePainted: return PE_PAINTED; case CSSValueFill: return PE_FILL; case CSSValueStroke: return PE_STROKE; case CSSValueBoundingBox: return PE_BOUNDINGBOX; default: break; } ASSERT_NOT_REACHED(); return PE_ALL; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (kerning) { case FontDescription::AutoKerning: m_value.valueID = CSSValueAuto; return; case FontDescription::NormalKerning: m_value.valueID = CSSValueNormal; return; case FontDescription::NoneKerning: m_value.valueID = CSSValueNone; return; } ASSERT_NOT_REACHED(); m_value.valueID = CSSValueAuto; } template<> inline CSSPrimitiveValue::operator FontDescription::Kerning() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return FontDescription::AutoKerning; case CSSValueNormal: return FontDescription::NormalKerning; case CSSValueNone: return FontDescription::NoneKerning; default: break; } ASSERT_NOT_REACHED(); return FontDescription::AutoKerning; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (fit) { case ObjectFitFill: m_value.valueID = CSSValueFill; break; case ObjectFitContain: m_value.valueID = CSSValueContain; break; case ObjectFitCover: m_value.valueID = CSSValueCover; break; case ObjectFitNone: m_value.valueID = CSSValueNone; break; case ObjectFitScaleDown: m_value.valueID = CSSValueScaleDown; break; } } template<> inline CSSPrimitiveValue::operator ObjectFit() const { switch (m_value.valueID) { case CSSValueFill: return ObjectFitFill; case CSSValueContain: return ObjectFitContain; case CSSValueCover: return ObjectFitCover; case CSSValueNone: return ObjectFitNone; case CSSValueScaleDown: return ObjectFitScaleDown; default: ASSERT_NOT_REACHED(); return ObjectFitFill; } } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillSizeType fillSize) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (fillSize) { case Contain: m_value.valueID = CSSValueContain; break; case Cover: m_value.valueID = CSSValueCover; break; case SizeNone: m_value.valueID = CSSValueNone; break; case SizeLength: default: ASSERT_NOT_REACHED(); } } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (smoothing) { case AutoSmoothing: m_value.valueID = CSSValueAuto; return; case NoSmoothing: m_value.valueID = CSSValueNone; return; case Antialiased: m_value.valueID = CSSValueAntialiased; return; case SubpixelAntialiased: m_value.valueID = CSSValueSubpixelAntialiased; return; } ASSERT_NOT_REACHED(); m_value.valueID = CSSValueAuto; } template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return AutoSmoothing; case CSSValueNone: return NoSmoothing; case CSSValueAntialiased: return Antialiased; case CSSValueSubpixelAntialiased: return SubpixelAntialiased; default: break; } ASSERT_NOT_REACHED(); return AutoSmoothing; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (weight) { case FontWeight900: m_value.valueID = CSSValue900; return; case FontWeight800: m_value.valueID = CSSValue800; return; case FontWeight700: m_value.valueID = CSSValueBold; return; case FontWeight600: m_value.valueID = CSSValue600; return; case FontWeight500: m_value.valueID = CSSValue500; return; case FontWeight400: m_value.valueID = CSSValueNormal; return; case FontWeight300: m_value.valueID = CSSValue300; return; case FontWeight200: m_value.valueID = CSSValue200; return; case FontWeight100: m_value.valueID = CSSValue100; return; } ASSERT_NOT_REACHED(); m_value.valueID = CSSValueNormal; } template<> inline CSSPrimitiveValue::operator FontWeight() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueBold: return FontWeightBold; case CSSValueNormal: return FontWeightNormal; case CSSValue900: return FontWeight900; case CSSValue800: return FontWeight800; case CSSValue700: return FontWeight700; case CSSValue600: return FontWeight600; case CSSValue500: return FontWeight500; case CSSValue400: return FontWeight400; case CSSValue300: return FontWeight300; case CSSValue200: return FontWeight200; case CSSValue100: return FontWeight100; default: break; } ASSERT_NOT_REACHED(); return FontWeightNormal; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontStyle italic) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (italic) { case FontStyleNormal: m_value.valueID = CSSValueNormal; return; case FontStyleItalic: m_value.valueID = CSSValueItalic; return; } ASSERT_NOT_REACHED(); m_value.valueID = CSSValueNormal; } template<> inline CSSPrimitiveValue::operator FontStyle() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueOblique: // FIXME: oblique is the same as italic for the moment... case CSSValueItalic: return FontStyleItalic; case CSSValueNormal: return FontStyleNormal; default: break; } ASSERT_NOT_REACHED(); return FontStyleNormal; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontStretch stretch) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (stretch) { case FontStretchUltraCondensed: m_value.valueID = CSSValueUltraCondensed; return; case FontStretchExtraCondensed: m_value.valueID = CSSValueExtraCondensed; return; case FontStretchCondensed: m_value.valueID = CSSValueCondensed; return; case FontStretchSemiCondensed: m_value.valueID = CSSValueSemiCondensed; return; case FontStretchNormal: m_value.valueID = CSSValueNormal; return; case FontStretchSemiExpanded: m_value.valueID = CSSValueSemiExpanded; return; case FontStretchExpanded: m_value.valueID = CSSValueExpanded; return; case FontStretchExtraExpanded: m_value.valueID = CSSValueExtraExpanded; return; case FontStretchUltraExpanded: m_value.valueID = CSSValueUltraExpanded; return; } ASSERT_NOT_REACHED(); m_value.valueID = CSSValueNormal; } template<> inline CSSPrimitiveValue::operator FontStretch() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueUltraCondensed: return FontStretchUltraCondensed; case CSSValueExtraCondensed: return FontStretchExtraCondensed; case CSSValueCondensed: return FontStretchCondensed; case CSSValueSemiCondensed: return FontStretchSemiCondensed; case CSSValueNormal: return FontStretchNormal; case CSSValueSemiExpanded: return FontStretchSemiExpanded; case CSSValueExpanded: return FontStretchExpanded; case CSSValueExtraExpanded: return FontStretchExtraExpanded; case CSSValueUltraExpanded: return FontStretchUltraExpanded; default: break; } ASSERT_NOT_REACHED(); return FontStretchNormal; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontVariant smallCaps) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (smallCaps) { case FontVariantNormal: m_value.valueID = CSSValueNormal; return; case FontVariantSmallCaps: m_value.valueID = CSSValueSmallCaps; return; } ASSERT_NOT_REACHED(); m_value.valueID = CSSValueNormal; } template<> inline CSSPrimitiveValue::operator FontVariant() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueSmallCaps: return FontVariantSmallCaps; case CSSValueNormal: return FontVariantNormal; default: break; } ASSERT_NOT_REACHED(); return FontVariantNormal; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case AutoTextRendering: m_value.valueID = CSSValueAuto; break; case OptimizeSpeed: m_value.valueID = CSSValueOptimizespeed; break; case OptimizeLegibility: m_value.valueID = CSSValueOptimizelegibility; break; case GeometricPrecision: m_value.valueID = CSSValueGeometricprecision; break; } } template<> inline CSSPrimitiveValue::operator TextRenderingMode() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return AutoTextRendering; case CSSValueOptimizespeed: return OptimizeSpeed; case CSSValueOptimizelegibility: return OptimizeLegibility; case CSSValueGeometricprecision: return GeometricPrecision; default: break; } ASSERT_NOT_REACHED(); return AutoTextRendering; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case SpeakNone: m_value.valueID = CSSValueNone; break; case SpeakNormal: m_value.valueID = CSSValueNormal; break; case SpeakSpellOut: m_value.valueID = CSSValueSpellOut; break; case SpeakDigits: m_value.valueID = CSSValueDigits; break; case SpeakLiteralPunctuation: m_value.valueID = CSSValueLiteralPunctuation; break; case SpeakNoPunctuation: m_value.valueID = CSSValueNoPunctuation; break; } } template<> inline CSSPrimitiveValue::operator Order() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueLogical: return LogicalOrder; case CSSValueVisual: return VisualOrder; default: break; } ASSERT_NOT_REACHED(); return LogicalOrder; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case LogicalOrder: m_value.valueID = CSSValueLogical; break; case VisualOrder: m_value.valueID = CSSValueVisual; break; } } template<> inline CSSPrimitiveValue::operator ESpeak() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNone: return SpeakNone; case CSSValueNormal: return SpeakNormal; case CSSValueSpellOut: return SpeakSpellOut; case CSSValueDigits: return SpeakDigits; case CSSValueLiteralPunctuation: return SpeakLiteralPunctuation; case CSSValueNoPunctuation: return SpeakNoPunctuation; default: break; } ASSERT_NOT_REACHED(); return SpeakNormal; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(blink::WebBlendMode blendMode) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (blendMode) { case blink::WebBlendModeNormal: m_value.valueID = CSSValueNormal; break; case blink::WebBlendModeMultiply: m_value.valueID = CSSValueMultiply; break; case blink::WebBlendModeScreen: m_value.valueID = CSSValueScreen; break; case blink::WebBlendModeOverlay: m_value.valueID = CSSValueOverlay; break; case blink::WebBlendModeDarken: m_value.valueID = CSSValueDarken; break; case blink::WebBlendModeLighten: m_value.valueID = CSSValueLighten; break; case blink::WebBlendModeColorDodge: m_value.valueID = CSSValueColorDodge; break; case blink::WebBlendModeColorBurn: m_value.valueID = CSSValueColorBurn; break; case blink::WebBlendModeHardLight: m_value.valueID = CSSValueHardLight; break; case blink::WebBlendModeSoftLight: m_value.valueID = CSSValueSoftLight; break; case blink::WebBlendModeDifference: m_value.valueID = CSSValueDifference; break; case blink::WebBlendModeExclusion: m_value.valueID = CSSValueExclusion; break; case blink::WebBlendModeHue: m_value.valueID = CSSValueHue; break; case blink::WebBlendModeSaturation: m_value.valueID = CSSValueSaturation; break; case blink::WebBlendModeColor: m_value.valueID = CSSValueColor; break; case blink::WebBlendModeLuminosity: m_value.valueID = CSSValueLuminosity; break; } } template<> inline CSSPrimitiveValue::operator blink::WebBlendMode() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNormal: return blink::WebBlendModeNormal; case CSSValueMultiply: return blink::WebBlendModeMultiply; case CSSValueScreen: return blink::WebBlendModeScreen; case CSSValueOverlay: return blink::WebBlendModeOverlay; case CSSValueDarken: return blink::WebBlendModeDarken; case CSSValueLighten: return blink::WebBlendModeLighten; case CSSValueColorDodge: return blink::WebBlendModeColorDodge; case CSSValueColorBurn: return blink::WebBlendModeColorBurn; case CSSValueHardLight: return blink::WebBlendModeHardLight; case CSSValueSoftLight: return blink::WebBlendModeSoftLight; case CSSValueDifference: return blink::WebBlendModeDifference; case CSSValueExclusion: return blink::WebBlendModeExclusion; case CSSValueHue: return blink::WebBlendModeHue; case CSSValueSaturation: return blink::WebBlendModeSaturation; case CSSValueColor: return blink::WebBlendModeColor; case CSSValueLuminosity: return blink::WebBlendModeLuminosity; default: break; } ASSERT_NOT_REACHED(); return blink::WebBlendModeNormal; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case ButtCap: m_value.valueID = CSSValueButt; break; case RoundCap: m_value.valueID = CSSValueRound; break; case SquareCap: m_value.valueID = CSSValueSquare; break; } } template<> inline CSSPrimitiveValue::operator LineCap() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueButt: return ButtCap; case CSSValueRound: return RoundCap; case CSSValueSquare: return SquareCap; default: break; } ASSERT_NOT_REACHED(); return ButtCap; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case MiterJoin: m_value.valueID = CSSValueMiter; break; case RoundJoin: m_value.valueID = CSSValueRound; break; case BevelJoin: m_value.valueID = CSSValueBevel; break; } } template<> inline CSSPrimitiveValue::operator LineJoin() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueMiter: return MiterJoin; case CSSValueRound: return RoundJoin; case CSSValueBevel: return BevelJoin; default: break; } ASSERT_NOT_REACHED(); return MiterJoin; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case RULE_NONZERO: m_value.valueID = CSSValueNonzero; break; case RULE_EVENODD: m_value.valueID = CSSValueEvenodd; break; } } template<> inline CSSPrimitiveValue::operator WindRule() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNonzero: return RULE_NONZERO; case CSSValueEvenodd: return RULE_EVENODD; default: break; } ASSERT_NOT_REACHED(); return RULE_NONZERO; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case ImageRenderingAuto: m_value.valueID = CSSValueAuto; break; case ImageRenderingOptimizeSpeed: m_value.valueID = CSSValueOptimizespeed; break; case ImageRenderingOptimizeQuality: m_value.valueID = CSSValueOptimizequality; break; case ImageRenderingPixelated: m_value.valueID = CSSValuePixelated; break; case ImageRenderingOptimizeContrast: m_value.valueID = CSSValueWebkitOptimizeContrast; break; } } template<> inline CSSPrimitiveValue::operator EImageRendering() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueAuto: return ImageRenderingAuto; case CSSValueOptimizespeed: return ImageRenderingOptimizeSpeed; case CSSValueOptimizequality: return ImageRenderingOptimizeQuality; case CSSValuePixelated: return ImageRenderingPixelated; case CSSValueWebkitOptimizeContrast: return ImageRenderingOptimizeContrast; default: break; } ASSERT_NOT_REACHED(); return ImageRenderingAuto; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (e) { case TransformStyle3DFlat: m_value.valueID = CSSValueFlat; break; case TransformStyle3DPreserve3D: m_value.valueID = CSSValuePreserve3d; break; } } template<> inline CSSPrimitiveValue::operator ETransformStyle3D() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueFlat: return TransformStyle3DFlat; case CSSValuePreserve3d: return TransformStyle3DPreserve3D; default: break; } ASSERT_NOT_REACHED(); return TransformStyle3DFlat; } enum LengthConversion { AnyConversion = ~0, FixedConversion = 1 << 0, AutoConversion = 1 << 1, PercentConversion = 1 << 2, }; template Length CSSPrimitiveValue::convertToLength(const CSSToLengthConversionData& conversionData) { if ((supported & FixedConversion) && isLength()) return computeLength(conversionData); if ((supported & PercentConversion) && isPercentage()) return Length(getDoubleValue(), Percent); if ((supported & AutoConversion) && getValueID() == CSSValueAuto) return Length(Auto); if ((supported & FixedConversion) && (supported & PercentConversion) && isCalculated()) return Length(cssCalcValue()->toCalcValue(conversionData)); ASSERT_NOT_REACHED(); return Length(0, Fixed); } template<> inline CSSPrimitiveValue::operator TouchAction() const { ASSERT(isValueID()); switch (m_value.valueID) { case CSSValueNone: return TouchActionNone; case CSSValueAuto: return TouchActionAuto; case CSSValuePanX: return TouchActionPanX; case CSSValuePanY: return TouchActionPanY; case CSSValueManipulation: return TouchActionPanX | TouchActionPanY | TouchActionPinchZoom; default: break; } ASSERT_NOT_REACHED(); return TouchActionNone; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TouchActionDelay t) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (t) { case TouchActionDelayNone: m_value.valueID = CSSValueNone; break; case TouchActionDelayScript: m_value.valueID = CSSValueScript; break; } } template<> inline CSSPrimitiveValue::operator TouchActionDelay() const { switch (m_value.valueID) { case CSSValueNone: return TouchActionDelayNone; case CSSValueScript: return TouchActionDelayScript; default: break; } ASSERT_NOT_REACHED(); return TouchActionDelayNone; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (cssBox) { case MarginBox: m_value.valueID = CSSValueMarginBox; break; case BorderBox: m_value.valueID = CSSValueBorderBox; break; case PaddingBox: m_value.valueID = CSSValuePaddingBox; break; case ContentBox: m_value.valueID = CSSValueContentBox; break; case BoxMissing: // The missing box should convert to a null primitive value. ASSERT_NOT_REACHED(); } } template<> inline CSSPrimitiveValue::operator CSSBoxType() const { switch (getValueID()) { case CSSValueMarginBox: return MarginBox; case CSSValueBorderBox: return BorderBox; case CSSValuePaddingBox: return PaddingBox; case CSSValueContentBox: return ContentBox; default: break; } ASSERT_NOT_REACHED(); return ContentBox; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (itemPosition) { case ItemPositionAuto: m_value.valueID = CSSValueAuto; break; case ItemPositionStretch: m_value.valueID = CSSValueStretch; break; case ItemPositionBaseline: m_value.valueID = CSSValueBaseline; break; case ItemPositionLastBaseline: m_value.valueID = CSSValueLastBaseline; break; case ItemPositionCenter: m_value.valueID = CSSValueCenter; break; case ItemPositionStart: m_value.valueID = CSSValueStart; break; case ItemPositionEnd: m_value.valueID = CSSValueEnd; break; case ItemPositionSelfStart: m_value.valueID = CSSValueSelfStart; break; case ItemPositionSelfEnd: m_value.valueID = CSSValueSelfEnd; break; case ItemPositionFlexStart: m_value.valueID = CSSValueFlexStart; break; case ItemPositionFlexEnd: m_value.valueID = CSSValueFlexEnd; break; case ItemPositionLeft: m_value.valueID = CSSValueLeft; break; case ItemPositionRight: m_value.valueID = CSSValueRight; break; } } template<> inline CSSPrimitiveValue::operator ItemPosition() const { switch (m_value.valueID) { case CSSValueAuto: return ItemPositionAuto; case CSSValueStretch: return ItemPositionStretch; case CSSValueBaseline: return ItemPositionBaseline; case CSSValueLastBaseline: return ItemPositionLastBaseline; case CSSValueCenter: return ItemPositionCenter; case CSSValueStart: return ItemPositionStart; case CSSValueEnd: return ItemPositionEnd; case CSSValueSelfStart: return ItemPositionSelfStart; case CSSValueSelfEnd: return ItemPositionSelfEnd; case CSSValueFlexStart: return ItemPositionFlexStart; case CSSValueFlexEnd: return ItemPositionFlexEnd; case CSSValueLeft: return ItemPositionLeft; case CSSValueRight: return ItemPositionRight; default: break; } ASSERT_NOT_REACHED(); return ItemPositionAuto; } template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment) : CSSValue(PrimitiveClass) { m_primitiveUnitType = CSS_VALUE_ID; switch (overflowAlignment) { case OverflowAlignmentDefault: m_value.valueID = CSSValueDefault; break; case OverflowAlignmentTrue: m_value.valueID = CSSValueTrue; break; case OverflowAlignmentSafe: m_value.valueID = CSSValueSafe; break; } } template<> inline CSSPrimitiveValue::operator OverflowAlignment() const { switch (m_value.valueID) { case CSSValueTrue: return OverflowAlignmentTrue; case CSSValueSafe: return OverflowAlignmentSafe; default: break; } ASSERT_NOT_REACHED(); return OverflowAlignmentTrue; } } #endif // SKY_ENGINE_CORE_CSS_CSSPRIMITIVEVALUEMAPPINGS_H_