blob: b1f9aec121afa3ce47d038537a56961a4087514a [file] [log] [blame]
/*
* Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.
* Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
* Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
* Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>
* 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 CSSPrimitiveValueMappings_h
#define CSSPrimitiveValueMappings_h
#include "ColorSpace.h"
#include "CSSPrimitiveValue.h"
#include "CSSValueKeywords.h"
#include "FontSmoothingMode.h"
#include "GraphicsTypes.h"
#include "Path.h"
#include "RenderStyleConstants.h"
#include "SVGRenderStyleDefs.h"
#include "TextDirection.h"
#include "TextOrientation.h"
#include "TextRenderingMode.h"
#include "ThemeTypes.h"
#include "UnicodeBidi.h"
namespace WebCore {
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case BNONE:
m_value.ident = CSSValueNone;
break;
case BHIDDEN:
m_value.ident = CSSValueHidden;
break;
case INSET:
m_value.ident = CSSValueInset;
break;
case GROOVE:
m_value.ident = CSSValueGroove;
break;
case RIDGE:
m_value.ident = CSSValueRidge;
break;
case OUTSET:
m_value.ident = CSSValueOutset;
break;
case DOTTED:
m_value.ident = CSSValueDotted;
break;
case DASHED:
m_value.ident = CSSValueDashed;
break;
case SOLID:
m_value.ident = CSSValueSolid;
break;
case DOUBLE:
m_value.ident = CSSValueDouble;
break;
}
}
template<> inline CSSPrimitiveValue::operator EBorderStyle() const
{
return (EBorderStyle)(m_value.ident - CSSValueNone);
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case CompositeClear:
m_value.ident = CSSValueClear;
break;
case CompositeCopy:
m_value.ident = CSSValueCopy;
break;
case CompositeSourceOver:
m_value.ident = CSSValueSourceOver;
break;
case CompositeSourceIn:
m_value.ident = CSSValueSourceIn;
break;
case CompositeSourceOut:
m_value.ident = CSSValueSourceOut;
break;
case CompositeSourceAtop:
m_value.ident = CSSValueSourceAtop;
break;
case CompositeDestinationOver:
m_value.ident = CSSValueDestinationOver;
break;
case CompositeDestinationIn:
m_value.ident = CSSValueDestinationIn;
break;
case CompositeDestinationOut:
m_value.ident = CSSValueDestinationOut;
break;
case CompositeDestinationAtop:
m_value.ident = CSSValueDestinationAtop;
break;
case CompositeXOR:
m_value.ident = CSSValueXor;
break;
case CompositePlusDarker:
m_value.ident = CSSValuePlusDarker;
break;
case CompositeHighlight:
m_value.ident = CSSValueHighlight;
break;
case CompositePlusLighter:
m_value.ident = CSSValuePlusLighter;
break;
}
}
template<> inline CSSPrimitiveValue::operator CompositeOperator() const
{
switch (m_value.ident) {
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 CSSValueHighlight:
return CompositeHighlight;
case CSSValuePlusLighter:
return CompositePlusLighter;
default:
ASSERT_NOT_REACHED();
return CompositeClear;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case NoControlPart:
m_value.ident = CSSValueNone;
break;
case CheckboxPart:
m_value.ident = CSSValueCheckbox;
break;
case RadioPart:
m_value.ident = CSSValueRadio;
break;
case PushButtonPart:
m_value.ident = CSSValuePushButton;
break;
case SquareButtonPart:
m_value.ident = CSSValueSquareButton;
break;
case ButtonPart:
m_value.ident = CSSValueButton;
break;
case ButtonBevelPart:
m_value.ident = CSSValueButtonBevel;
break;
case DefaultButtonPart:
m_value.ident = CSSValueDefaultButton;
break;
case InnerSpinButtonPart:
m_value.ident = CSSValueInnerSpinButton;
break;
case ListboxPart:
m_value.ident = CSSValueListbox;
break;
case ListButtonPart:
#if ENABLE(DATALIST)
m_value.ident = CSSValueListButton;
#endif
break;
case ListItemPart:
m_value.ident = CSSValueListitem;
break;
case MediaFullscreenButtonPart:
m_value.ident = CSSValueMediaFullscreenButton;
break;
case MediaPlayButtonPart:
m_value.ident = CSSValueMediaPlayButton;
break;
case MediaMuteButtonPart:
m_value.ident = CSSValueMediaMuteButton;
break;
case MediaSeekBackButtonPart:
m_value.ident = CSSValueMediaSeekBackButton;
break;
case MediaSeekForwardButtonPart:
m_value.ident = CSSValueMediaSeekForwardButton;
break;
case MediaRewindButtonPart:
m_value.ident = CSSValueMediaRewindButton;
break;
case MediaReturnToRealtimeButtonPart:
m_value.ident = CSSValueMediaReturnToRealtimeButton;
break;
case MediaToggleClosedCaptionsButtonPart:
m_value.ident = CSSValueMediaToggleClosedCaptionsButton;
break;
case MediaSliderPart:
m_value.ident = CSSValueMediaSlider;
break;
case MediaSliderThumbPart:
m_value.ident = CSSValueMediaSliderthumb;
break;
case MediaVolumeSliderContainerPart:
m_value.ident = CSSValueMediaVolumeSliderContainer;
break;
case MediaVolumeSliderPart:
m_value.ident = CSSValueMediaVolumeSlider;
break;
case MediaVolumeSliderMuteButtonPart:
m_value.ident = CSSValueMediaVolumeSliderMuteButton;
break;
case MediaVolumeSliderThumbPart:
m_value.ident = CSSValueMediaVolumeSliderthumb;
break;
case MediaControlsBackgroundPart:
m_value.ident = CSSValueMediaControlsBackground;
break;
case MediaControlsFullscreenBackgroundPart:
m_value.ident = CSSValueMediaControlsFullscreenBackground;
break;
case MediaCurrentTimePart:
m_value.ident = CSSValueMediaCurrentTimeDisplay;
break;
case MediaTimeRemainingPart:
m_value.ident = CSSValueMediaTimeRemainingDisplay;
break;
case MenulistPart:
m_value.ident = CSSValueMenulist;
break;
case MenulistButtonPart:
m_value.ident = CSSValueMenulistButton;
break;
case MenulistTextPart:
m_value.ident = CSSValueMenulistText;
break;
case MenulistTextFieldPart:
m_value.ident = CSSValueMenulistTextfield;
break;
case MeterPart:
m_value.ident = CSSValueMeter;
break;
case RelevancyLevelIndicatorPart:
m_value.ident = CSSValueRelevancyLevelIndicator;
break;
case ContinuousCapacityLevelIndicatorPart:
m_value.ident = CSSValueContinuousCapacityLevelIndicator;
break;
case DiscreteCapacityLevelIndicatorPart:
m_value.ident = CSSValueDiscreteCapacityLevelIndicator;
break;
case RatingLevelIndicatorPart:
m_value.ident = CSSValueRatingLevelIndicator;
break;
case OuterSpinButtonPart:
m_value.ident = CSSValueOuterSpinButton;
break;
case ProgressBarPart:
#if ENABLE(PROGRESS_TAG)
m_value.ident = CSSValueProgressBar;
#endif
break;
case ProgressBarValuePart:
#if ENABLE(PROGRESS_TAG)
m_value.ident = CSSValueProgressBarValue;
#endif
break;
case SliderHorizontalPart:
m_value.ident = CSSValueSliderHorizontal;
break;
case SliderVerticalPart:
m_value.ident = CSSValueSliderVertical;
break;
case SliderThumbHorizontalPart:
m_value.ident = CSSValueSliderthumbHorizontal;
break;
case SliderThumbVerticalPart:
m_value.ident = CSSValueSliderthumbVertical;
break;
case CaretPart:
m_value.ident = CSSValueCaret;
break;
case SearchFieldPart:
m_value.ident = CSSValueSearchfield;
break;
case SearchFieldDecorationPart:
m_value.ident = CSSValueSearchfieldDecoration;
break;
case SearchFieldResultsDecorationPart:
m_value.ident = CSSValueSearchfieldResultsDecoration;
break;
case SearchFieldResultsButtonPart:
m_value.ident = CSSValueSearchfieldResultsButton;
break;
case SearchFieldCancelButtonPart:
m_value.ident = CSSValueSearchfieldCancelButton;
break;
case TextFieldPart:
m_value.ident = CSSValueTextfield;
break;
case TextAreaPart:
m_value.ident = CSSValueTextarea;
break;
case CapsLockIndicatorPart:
m_value.ident = CSSValueCapsLockIndicator;
break;
case InputSpeechButtonPart:
#if ENABLE(INPUT_SPEECH)
m_value.ident = CSSValueWebkitInputSpeechButton;
#endif
break;
}
}
template<> inline CSSPrimitiveValue::operator ControlPart() const
{
if (m_value.ident == CSSValueNone)
return NoControlPart;
else
return ControlPart(m_value.ident - CSSValueCheckbox + 1);
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case ScrollBackgroundAttachment:
m_value.ident = CSSValueScroll;
break;
case LocalBackgroundAttachment:
m_value.ident = CSSValueLocal;
break;
case FixedBackgroundAttachment:
m_value.ident = CSSValueFixed;
break;
}
}
template<> inline CSSPrimitiveValue::operator EFillAttachment() const
{
switch (m_value.ident) {
case CSSValueScroll:
return ScrollBackgroundAttachment;
case CSSValueLocal:
return LocalBackgroundAttachment;
case CSSValueFixed:
return FixedBackgroundAttachment;
default:
ASSERT_NOT_REACHED();
return ScrollBackgroundAttachment;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case BorderFillBox:
m_value.ident = CSSValueBorderBox;
break;
case PaddingFillBox:
m_value.ident = CSSValuePaddingBox;
break;
case ContentFillBox:
m_value.ident = CSSValueContentBox;
break;
case TextFillBox:
m_value.ident = CSSValueText;
break;
}
}
template<> inline CSSPrimitiveValue::operator EFillBox() const
{
switch (m_value.ident) {
case CSSValueBorder:
case CSSValueBorderBox:
return BorderFillBox;
case CSSValuePadding:
case CSSValuePaddingBox:
return PaddingFillBox;
case CSSValueContent:
case CSSValueContentBox:
return ContentFillBox;
case CSSValueText:
case CSSValueWebkitText:
return TextFillBox;
default:
ASSERT_NOT_REACHED();
return BorderFillBox;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case RepeatFill:
m_value.ident = CSSValueRepeat;
break;
case NoRepeatFill:
m_value.ident = CSSValueNoRepeat;
break;
case RoundFill:
m_value.ident = CSSValueRound;
break;
case SpaceFill:
m_value.ident = CSSValueSpace;
break;
}
}
template<> inline CSSPrimitiveValue::operator EFillRepeat() const
{
switch (m_value.ident) {
case CSSValueRepeat:
return RepeatFill;
case CSSValueNoRepeat:
return NoRepeatFill;
case CSSValueRound:
return RoundFill;
case CSSValueSpace:
return SpaceFill;
default:
ASSERT_NOT_REACHED();
return RepeatFill;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case BSTRETCH:
m_value.ident = CSSValueStretch;
break;
case BSTART:
m_value.ident = CSSValueStart;
break;
case BCENTER:
m_value.ident = CSSValueCenter;
break;
case BEND:
m_value.ident = CSSValueEnd;
break;
case BBASELINE:
m_value.ident = CSSValueBaseline;
break;
case BJUSTIFY:
m_value.ident = CSSValueJustify;
break;
}
}
template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
{
switch (m_value.ident) {
case CSSValueStretch:
return BSTRETCH;
case CSSValueStart:
return BSTART;
case CSSValueEnd:
return BEND;
case CSSValueCenter:
return BCENTER;
case CSSValueBaseline:
return BBASELINE;
case CSSValueJustify:
return BJUSTIFY;
default:
ASSERT_NOT_REACHED();
return BSTRETCH;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case BNORMAL:
m_value.ident = CSSValueNormal;
break;
case BREVERSE:
m_value.ident = CSSValueReverse;
break;
}
}
template<> inline CSSPrimitiveValue::operator EBoxDirection() const
{
switch (m_value.ident) {
case CSSValueNormal:
return BNORMAL;
case CSSValueReverse:
return BREVERSE;
default:
ASSERT_NOT_REACHED();
return BNORMAL;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case SINGLE:
m_value.ident = CSSValueSingle;
break;
case MULTIPLE:
m_value.ident = CSSValueMultiple;
break;
}
}
template<> inline CSSPrimitiveValue::operator EBoxLines() const
{
switch (m_value.ident) {
case CSSValueSingle:
return SINGLE;
case CSSValueMultiple:
return MULTIPLE;
default:
ASSERT_NOT_REACHED();
return SINGLE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case HORIZONTAL:
m_value.ident = CSSValueHorizontal;
break;
case VERTICAL:
m_value.ident = CSSValueVertical;
break;
}
}
template<> inline CSSPrimitiveValue::operator EBoxOrient() const
{
switch (m_value.ident) {
case CSSValueHorizontal:
case CSSValueInlineAxis:
return HORIZONTAL;
case CSSValueVertical:
case CSSValueBlockAxis:
return VERTICAL;
default:
ASSERT_NOT_REACHED();
return HORIZONTAL;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case CAPLEFT:
m_value.ident = CSSValueLeft;
break;
case CAPRIGHT:
m_value.ident = CSSValueRight;
break;
case CAPTOP:
m_value.ident = CSSValueTop;
break;
case CAPBOTTOM:
m_value.ident = CSSValueBottom;
break;
}
}
template<> inline CSSPrimitiveValue::operator ECaptionSide() const
{
switch (m_value.ident) {
case CSSValueLeft:
return CAPLEFT;
case CSSValueRight:
return CAPRIGHT;
case CSSValueTop:
return CAPTOP;
case CSSValueBottom:
return CAPBOTTOM;
default:
ASSERT_NOT_REACHED();
return CAPTOP;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case CNONE:
m_value.ident = CSSValueNone;
break;
case CLEFT:
m_value.ident = CSSValueLeft;
break;
case CRIGHT:
m_value.ident = CSSValueRight;
break;
case CBOTH:
m_value.ident = CSSValueBoth;
break;
}
}
template<> inline CSSPrimitiveValue::operator EClear() const
{
switch (m_value.ident) {
case CSSValueNone:
return CNONE;
case CSSValueLeft:
return CLEFT;
case CSSValueRight:
return CRIGHT;
case CSSValueBoth:
return CBOTH;
default:
ASSERT_NOT_REACHED();
return CNONE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case CURSOR_AUTO:
m_value.ident = CSSValueAuto;
break;
case CURSOR_CROSS:
m_value.ident = CSSValueCrosshair;
break;
case CURSOR_DEFAULT:
m_value.ident = CSSValueDefault;
break;
case CURSOR_POINTER:
m_value.ident = CSSValuePointer;
break;
case CURSOR_MOVE:
m_value.ident = CSSValueMove;
break;
case CURSOR_CELL:
m_value.ident = CSSValueCell;
break;
case CURSOR_VERTICAL_TEXT:
m_value.ident = CSSValueVerticalText;
break;
case CURSOR_CONTEXT_MENU:
m_value.ident = CSSValueContextMenu;
break;
case CURSOR_ALIAS:
m_value.ident = CSSValueAlias;
break;
case CURSOR_COPY:
m_value.ident = CSSValueCopy;
break;
case CURSOR_NONE:
m_value.ident = CSSValueNone;
break;
case CURSOR_PROGRESS:
m_value.ident = CSSValueProgress;
break;
case CURSOR_NO_DROP:
m_value.ident = CSSValueNoDrop;
break;
case CURSOR_NOT_ALLOWED:
m_value.ident = CSSValueNotAllowed;
break;
case CURSOR_WEBKIT_ZOOM_IN:
m_value.ident = CSSValueWebkitZoomIn;
break;
case CURSOR_WEBKIT_ZOOM_OUT:
m_value.ident = CSSValueWebkitZoomOut;
break;
case CURSOR_E_RESIZE:
m_value.ident = CSSValueEResize;
break;
case CURSOR_NE_RESIZE:
m_value.ident = CSSValueNeResize;
break;
case CURSOR_NW_RESIZE:
m_value.ident = CSSValueNwResize;
break;
case CURSOR_N_RESIZE:
m_value.ident = CSSValueNResize;
break;
case CURSOR_SE_RESIZE:
m_value.ident = CSSValueSeResize;
break;
case CURSOR_SW_RESIZE:
m_value.ident = CSSValueSwResize;
break;
case CURSOR_S_RESIZE:
m_value.ident = CSSValueSResize;
break;
case CURSOR_W_RESIZE:
m_value.ident = CSSValueWResize;
break;
case CURSOR_EW_RESIZE:
m_value.ident = CSSValueEwResize;
break;
case CURSOR_NS_RESIZE:
m_value.ident = CSSValueNsResize;
break;
case CURSOR_NESW_RESIZE:
m_value.ident = CSSValueNeswResize;
break;
case CURSOR_NWSE_RESIZE:
m_value.ident = CSSValueNwseResize;
break;
case CURSOR_COL_RESIZE:
m_value.ident = CSSValueColResize;
break;
case CURSOR_ROW_RESIZE:
m_value.ident = CSSValueRowResize;
break;
case CURSOR_TEXT:
m_value.ident = CSSValueText;
break;
case CURSOR_WAIT:
m_value.ident = CSSValueWait;
break;
case CURSOR_HELP:
m_value.ident = CSSValueHelp;
break;
case CURSOR_ALL_SCROLL:
m_value.ident = CSSValueAllScroll;
break;
case CURSOR_WEBKIT_GRAB:
m_value.ident = CSSValueWebkitGrab;
break;
case CURSOR_WEBKIT_GRABBING:
m_value.ident = CSSValueWebkitGrabbing;
break;
}
}
template<> inline CSSPrimitiveValue::operator ECursor() const
{
if (m_value.ident == CSSValueCopy)
return CURSOR_COPY;
if (m_value.ident == CSSValueNone)
return CURSOR_NONE;
return static_cast<ECursor>(m_value.ident - CSSValueAuto);
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case INLINE:
m_value.ident = CSSValueInline;
break;
case BLOCK:
m_value.ident = CSSValueBlock;
break;
case LIST_ITEM:
m_value.ident = CSSValueListItem;
break;
case RUN_IN:
m_value.ident = CSSValueRunIn;
break;
case COMPACT:
m_value.ident = CSSValueCompact;
break;
case INLINE_BLOCK:
m_value.ident = CSSValueInlineBlock;
break;
case TABLE:
m_value.ident = CSSValueTable;
break;
case INLINE_TABLE:
m_value.ident = CSSValueInlineTable;
break;
case TABLE_ROW_GROUP:
m_value.ident = CSSValueTableRowGroup;
break;
case TABLE_HEADER_GROUP:
m_value.ident = CSSValueTableHeaderGroup;
break;
case TABLE_FOOTER_GROUP:
m_value.ident = CSSValueTableFooterGroup;
break;
case TABLE_ROW:
m_value.ident = CSSValueTableRow;
break;
case TABLE_COLUMN_GROUP:
m_value.ident = CSSValueTableColumnGroup;
break;
case TABLE_COLUMN:
m_value.ident = CSSValueTableColumn;
break;
case TABLE_CELL:
m_value.ident = CSSValueTableCell;
break;
case TABLE_CAPTION:
m_value.ident = CSSValueTableCaption;
break;
#if ENABLE(WCSS)
case WAP_MARQUEE:
m_value.ident = CSSValueWapMarquee;
break;
#endif
case BOX:
m_value.ident = CSSValueWebkitBox;
break;
case INLINE_BOX:
m_value.ident = CSSValueWebkitInlineBox;
break;
case NONE:
m_value.ident = CSSValueNone;
break;
}
}
template<> inline CSSPrimitiveValue::operator EDisplay() const
{
if (m_value.ident == CSSValueNone)
return NONE;
return static_cast<EDisplay>(m_value.ident - CSSValueInline);
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case SHOW:
m_value.ident = CSSValueShow;
break;
case HIDE:
m_value.ident = CSSValueHide;
break;
}
}
template<> inline CSSPrimitiveValue::operator EEmptyCell() const
{
switch (m_value.ident) {
case CSSValueShow:
return SHOW;
case CSSValueHide:
return HIDE;
default:
ASSERT_NOT_REACHED();
return SHOW;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case FNONE:
m_value.ident = CSSValueNone;
break;
case FLEFT:
m_value.ident = CSSValueLeft;
break;
case FRIGHT:
m_value.ident = CSSValueRight;
break;
}
}
template<> inline CSSPrimitiveValue::operator EFloat() const
{
switch (m_value.ident) {
case CSSValueLeft:
return FLEFT;
case CSSValueRight:
return FRIGHT;
case CSSValueNone:
case CSSValueCenter: // Non-standard CSS value
return FNONE;
default:
ASSERT_NOT_REACHED();
return FNONE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EKHTMLLineBreak e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case LBNORMAL:
m_value.ident = CSSValueNormal;
break;
case AFTER_WHITE_SPACE:
m_value.ident = CSSValueAfterWhiteSpace;
break;
}
}
template<> inline CSSPrimitiveValue::operator EKHTMLLineBreak() const
{
switch (m_value.ident) {
case CSSValueAfterWhiteSpace:
return AFTER_WHITE_SPACE;
case CSSValueNormal:
return LBNORMAL;
default:
ASSERT_NOT_REACHED();
return LBNORMAL;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case OUTSIDE:
m_value.ident = CSSValueOutside;
break;
case INSIDE:
m_value.ident = CSSValueInside;
break;
}
}
template<> inline CSSPrimitiveValue::operator EListStylePosition() const
{
return (EListStylePosition)(m_value.ident - CSSValueOutside);
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case Afar:
m_value.ident = CSSValueAfar;
break;
case Amharic:
m_value.ident = CSSValueAmharic;
break;
case AmharicAbegede:
m_value.ident = CSSValueAmharicAbegede;
break;
case ArabicIndic:
m_value.ident = CSSValueArabicIndic;
break;
case Armenian:
m_value.ident = CSSValueArmenian;
break;
case Asterisks:
m_value.ident = CSSValueAsterisks;
break;
case BinaryListStyle:
m_value.ident = CSSValueBinary;
break;
case Bengali:
m_value.ident = CSSValueBengali;
break;
case Cambodian:
m_value.ident = CSSValueCambodian;
break;
case Circle:
m_value.ident = CSSValueCircle;
break;
case CjkEarthlyBranch:
m_value.ident = CSSValueCjkEarthlyBranch;
break;
case CjkHeavenlyStem:
m_value.ident = CSSValueCjkHeavenlyStem;
break;
case CJKIdeographic:
m_value.ident = CSSValueCjkIdeographic;
break;
case DecimalLeadingZero:
m_value.ident = CSSValueDecimalLeadingZero;
break;
case DecimalListStyle:
m_value.ident = CSSValueDecimal;
break;
case Devanagari:
m_value.ident = CSSValueDevanagari;
break;
case Disc:
m_value.ident = CSSValueDisc;
break;
case Ethiopic:
m_value.ident = CSSValueEthiopic;
break;
case EthiopicAbegede:
m_value.ident = CSSValueEthiopicAbegede;
break;
case EthiopicAbegedeAmEt:
m_value.ident = CSSValueEthiopicAbegedeAmEt;
break;
case EthiopicAbegedeGez:
m_value.ident = CSSValueEthiopicAbegedeGez;
break;
case EthiopicAbegedeTiEr:
m_value.ident = CSSValueEthiopicAbegedeTiEr;
break;
case EthiopicAbegedeTiEt:
m_value.ident = CSSValueEthiopicAbegedeTiEt;
break;
case EthiopicHalehameAaEr:
m_value.ident = CSSValueEthiopicHalehameAaEr;
break;
case EthiopicHalehameAaEt:
m_value.ident = CSSValueEthiopicHalehameAaEt;
break;
case EthiopicHalehameAmEt:
m_value.ident = CSSValueEthiopicHalehameAmEt;
break;
case EthiopicHalehameGez:
m_value.ident = CSSValueEthiopicHalehameGez;
break;
case EthiopicHalehameOmEt:
m_value.ident = CSSValueEthiopicHalehameOmEt;
break;
case EthiopicHalehameSidEt:
m_value.ident = CSSValueEthiopicHalehameSidEt;
break;
case EthiopicHalehameSoEt:
m_value.ident = CSSValueEthiopicHalehameSoEt;
break;
case EthiopicHalehameTiEr:
m_value.ident = CSSValueEthiopicHalehameTiEr;
break;
case EthiopicHalehameTiEt:
m_value.ident = CSSValueEthiopicHalehameTiEt;
break;
case EthiopicHalehameTig:
m_value.ident = CSSValueEthiopicHalehameTig;
break;
case Footnotes:
m_value.ident = CSSValueFootnotes;
break;
case Georgian:
m_value.ident = CSSValueGeorgian;
break;
case Gujarati:
m_value.ident = CSSValueGujarati;
break;
case Gurmukhi:
m_value.ident = CSSValueGurmukhi;
break;
case Hangul:
m_value.ident = CSSValueHangul;
break;
case HangulConsonant:
m_value.ident = CSSValueHangulConsonant;
break;
case Hebrew:
m_value.ident = CSSValueHebrew;
break;
case Hiragana:
m_value.ident = CSSValueHiragana;
break;
case HiraganaIroha:
m_value.ident = CSSValueHiraganaIroha;
break;
case Kannada:
m_value.ident = CSSValueKannada;
break;
case Katakana:
m_value.ident = CSSValueKatakana;
break;
case KatakanaIroha:
m_value.ident = CSSValueKatakanaIroha;
break;
case Khmer:
m_value.ident = CSSValueKhmer;
break;
case Lao:
m_value.ident = CSSValueLao;
break;
case LowerAlpha:
m_value.ident = CSSValueLowerAlpha;
break;
case LowerArmenian:
m_value.ident = CSSValueLowerArmenian;
break;
case LowerGreek:
m_value.ident = CSSValueLowerGreek;
break;
case LowerHexadecimal:
m_value.ident = CSSValueLowerHexadecimal;
break;
case LowerLatin:
m_value.ident = CSSValueLowerLatin;
break;
case LowerNorwegian:
m_value.ident = CSSValueLowerNorwegian;
break;
case LowerRoman:
m_value.ident = CSSValueLowerRoman;
break;
case Malayalam:
m_value.ident = CSSValueMalayalam;
break;
case Mongolian:
m_value.ident = CSSValueMongolian;
break;
case Myanmar:
m_value.ident = CSSValueMyanmar;
break;
case NoneListStyle:
m_value.ident = CSSValueNone;
break;
case Octal:
m_value.ident = CSSValueOctal;
break;
case Oriya:
m_value.ident = CSSValueOriya;
break;
case Oromo:
m_value.ident = CSSValueOromo;
break;
case Persian:
m_value.ident = CSSValuePersian;
break;
case Sidama:
m_value.ident = CSSValueSidama;
break;
case Somali:
m_value.ident = CSSValueSomali;
break;
case Square:
m_value.ident = CSSValueSquare;
break;
case Telugu:
m_value.ident = CSSValueTelugu;
break;
case Thai:
m_value.ident = CSSValueThai;
break;
case Tibetan:
m_value.ident = CSSValueTibetan;
break;
case Tigre:
m_value.ident = CSSValueTigre;
break;
case TigrinyaEr:
m_value.ident = CSSValueTigrinyaEr;
break;
case TigrinyaErAbegede:
m_value.ident = CSSValueTigrinyaErAbegede;
break;
case TigrinyaEt:
m_value.ident = CSSValueTigrinyaEt;
break;
case TigrinyaEtAbegede:
m_value.ident = CSSValueTigrinyaEtAbegede;
break;
case UpperAlpha:
m_value.ident = CSSValueUpperAlpha;
break;
case UpperArmenian:
m_value.ident = CSSValueUpperArmenian;
break;
case UpperGreek:
m_value.ident = CSSValueUpperGreek;
break;
case UpperHexadecimal:
m_value.ident = CSSValueUpperHexadecimal;
break;
case UpperLatin:
m_value.ident = CSSValueUpperLatin;
break;
case UpperNorwegian:
m_value.ident = CSSValueUpperNorwegian;
break;
case UpperRoman:
m_value.ident = CSSValueUpperRoman;
break;
case Urdu:
m_value.ident = CSSValueUrdu;
break;
}
}
template<> inline CSSPrimitiveValue::operator EListStyleType() const
{
switch (m_value.ident) {
case CSSValueNone:
return NoneListStyle;
default:
return static_cast<EListStyleType>(m_value.ident - CSSValueDisc);
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case MCOLLAPSE:
m_value.ident = CSSValueCollapse;
break;
case MSEPARATE:
m_value.ident = CSSValueSeparate;
break;
case MDISCARD:
m_value.ident = CSSValueDiscard;
break;
}
}
template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
{
switch (m_value.ident) {
case CSSValueCollapse:
return MCOLLAPSE;
case CSSValueSeparate:
return MSEPARATE;
case CSSValueDiscard:
return MDISCARD;
default:
ASSERT_NOT_REACHED();
return MCOLLAPSE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case MNONE:
m_value.ident = CSSValueNone;
break;
case MSCROLL:
m_value.ident = CSSValueScroll;
break;
case MSLIDE:
m_value.ident = CSSValueSlide;
break;
case MALTERNATE:
m_value.ident = CSSValueAlternate;
break;
}
}
template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
{
switch (m_value.ident) {
case CSSValueNone:
return MNONE;
case CSSValueScroll:
return MSCROLL;
case CSSValueSlide:
return MSLIDE;
case CSSValueAlternate:
return MALTERNATE;
default:
ASSERT_NOT_REACHED();
return MNONE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case MFORWARD:
m_value.ident = CSSValueForwards;
break;
case MBACKWARD:
m_value.ident = CSSValueBackwards;
break;
case MAUTO:
m_value.ident = CSSValueAuto;
break;
case MUP:
m_value.ident = CSSValueUp;
break;
case MDOWN:
m_value.ident = CSSValueDown;
break;
case MLEFT:
m_value.ident = CSSValueLeft;
break;
case MRIGHT:
m_value.ident = CSSValueRight;
break;
}
}
template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
{
switch (m_value.ident) {
case CSSValueForwards:
return MFORWARD;
case CSSValueBackwards:
return MBACKWARD;
case CSSValueAuto:
return MAUTO;
case CSSValueAhead:
case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
return MUP;
case CSSValueReverse:
case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
return MDOWN;
case CSSValueLeft:
return MLEFT;
case CSSValueRight:
return MRIGHT;
default:
ASSERT_NOT_REACHED();
return MAUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMatchNearestMailBlockquoteColor e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case BCNORMAL:
m_value.ident = CSSValueNormal;
break;
case MATCH:
m_value.ident = CSSValueMatch;
break;
}
}
template<> inline CSSPrimitiveValue::operator EMatchNearestMailBlockquoteColor() const
{
switch (m_value.ident) {
case CSSValueNormal:
return BCNORMAL;
case CSSValueMatch:
return MATCH;
default:
ASSERT_NOT_REACHED();
return BCNORMAL;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case NBNORMAL:
m_value.ident = CSSValueNormal;
break;
case SPACE:
m_value.ident = CSSValueSpace;
break;
}
}
template<> inline CSSPrimitiveValue::operator ENBSPMode() const
{
switch (m_value.ident) {
case CSSValueSpace:
return SPACE;
case CSSValueNormal:
return NBNORMAL;
default:
ASSERT_NOT_REACHED();
return NBNORMAL;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case OVISIBLE:
m_value.ident = CSSValueVisible;
break;
case OHIDDEN:
m_value.ident = CSSValueHidden;
break;
case OSCROLL:
m_value.ident = CSSValueScroll;
break;
case OAUTO:
m_value.ident = CSSValueAuto;
break;
case OMARQUEE:
m_value.ident = CSSValueWebkitMarquee;
break;
case OOVERLAY:
m_value.ident = CSSValueOverlay;
break;
}
}
template<> inline CSSPrimitiveValue::operator EOverflow() const
{
switch (m_value.ident) {
case CSSValueVisible:
return OVISIBLE;
case CSSValueHidden:
return OHIDDEN;
case CSSValueScroll:
return OSCROLL;
case CSSValueAuto:
return OAUTO;
case CSSValueWebkitMarquee:
return OMARQUEE;
case CSSValueOverlay:
return OOVERLAY;
default:
ASSERT_NOT_REACHED();
return OVISIBLE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case PBAUTO:
m_value.ident = CSSValueAuto;
break;
case PBALWAYS:
m_value.ident = CSSValueAlways;
break;
case PBAVOID:
m_value.ident = CSSValueAvoid;
break;
}
}
template<> inline CSSPrimitiveValue::operator EPageBreak() const
{
switch (m_value.ident) {
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:
ASSERT_NOT_REACHED();
return PBAUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case StaticPosition:
m_value.ident = CSSValueStatic;
break;
case RelativePosition:
m_value.ident = CSSValueRelative;
break;
case AbsolutePosition:
m_value.ident = CSSValueAbsolute;
break;
case FixedPosition:
m_value.ident = CSSValueFixed;
break;
}
}
template<> inline CSSPrimitiveValue::operator EPosition() const
{
switch (m_value.ident) {
case CSSValueStatic:
return StaticPosition;
case CSSValueRelative:
return RelativePosition;
case CSSValueAbsolute:
return AbsolutePosition;
case CSSValueFixed:
return FixedPosition;
default:
ASSERT_NOT_REACHED();
return StaticPosition;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case RESIZE_BOTH:
m_value.ident = CSSValueBoth;
break;
case RESIZE_HORIZONTAL:
m_value.ident = CSSValueHorizontal;
break;
case RESIZE_VERTICAL:
m_value.ident = CSSValueVertical;
break;
case RESIZE_NONE:
m_value.ident = CSSValueNone;
break;
}
}
template<> inline CSSPrimitiveValue::operator EResize() const
{
switch (m_value.ident) {
case CSSValueBoth:
return RESIZE_BOTH;
case CSSValueHorizontal:
return RESIZE_HORIZONTAL;
case CSSValueVertical:
return RESIZE_VERTICAL;
case CSSValueAuto:
ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
return RESIZE_NONE;
case CSSValueNone:
return RESIZE_NONE;
default:
ASSERT_NOT_REACHED();
return RESIZE_NONE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case TAUTO:
m_value.ident = CSSValueAuto;
break;
case TFIXED:
m_value.ident = CSSValueFixed;
break;
}
}
template<> inline CSSPrimitiveValue::operator ETableLayout() const
{
switch (m_value.ident) {
case CSSValueFixed:
return TFIXED;
case CSSValueAuto:
return TAUTO;
default:
ASSERT_NOT_REACHED();
return TAUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case TAAUTO:
m_value.ident = CSSValueWebkitAuto;
break;
case TASTART:
m_value.ident = CSSValueStart;
break;
case TAEND:
m_value.ident = CSSValueEnd;
break;
case LEFT:
m_value.ident = CSSValueLeft;
break;
case RIGHT:
m_value.ident = CSSValueRight;
break;
case CENTER:
m_value.ident = CSSValueCenter;
break;
case JUSTIFY:
m_value.ident = CSSValueJustify;
break;
case WEBKIT_LEFT:
m_value.ident = CSSValueWebkitLeft;
break;
case WEBKIT_RIGHT:
m_value.ident = CSSValueWebkitRight;
break;
case WEBKIT_CENTER:
m_value.ident = CSSValueWebkitCenter;
break;
}
}
template<> inline CSSPrimitiveValue::operator ETextAlign() const
{
switch (m_value.ident) {
case CSSValueStart:
return TASTART;
case CSSValueEnd:
return TAEND;
default:
return static_cast<ETextAlign>(m_value.ident - CSSValueWebkitAuto);
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case TSNONE:
m_value.ident = CSSValueNone;
break;
case TSDISC:
m_value.ident = CSSValueDisc;
break;
case TSCIRCLE:
m_value.ident = CSSValueCircle;
break;
case TSSQUARE:
m_value.ident = CSSValueSquare;
break;
}
}
template<> inline CSSPrimitiveValue::operator ETextSecurity() const
{
switch (m_value.ident) {
case CSSValueNone:
return TSNONE;
case CSSValueDisc:
return TSDISC;
case CSSValueCircle:
return TSCIRCLE;
case CSSValueSquare:
return TSSQUARE;
default:
ASSERT_NOT_REACHED();
return TSNONE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case CAPITALIZE:
m_value.ident = CSSValueCapitalize;
break;
case UPPERCASE:
m_value.ident = CSSValueUppercase;
break;
case LOWERCASE:
m_value.ident = CSSValueLowercase;
break;
case TTNONE:
m_value.ident = CSSValueNone;
break;
}
}
template<> inline CSSPrimitiveValue::operator ETextTransform() const
{
switch (m_value.ident) {
case CSSValueCapitalize:
return CAPITALIZE;
case CSSValueUppercase:
return UPPERCASE;
case CSSValueLowercase:
return LOWERCASE;
case CSSValueNone:
return TTNONE;
default:
ASSERT_NOT_REACHED();
return TTNONE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case UBNormal:
m_value.ident = CSSValueNormal;
break;
case Embed:
m_value.ident = CSSValueEmbed;
break;
case Override:
m_value.ident = CSSValueBidiOverride;
break;
case Isolate:
m_value.ident = CSSValueWebkitIsolate;
}
}
template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
{
switch (m_value.ident) {
case CSSValueNormal:
return UBNormal;
case CSSValueEmbed:
return Embed;
case CSSValueBidiOverride:
return Override;
case CSSValueWebkitIsolate:
return Isolate;
default:
ASSERT_NOT_REACHED();
return UBNormal;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case DRAG_AUTO:
m_value.ident = CSSValueAuto;
break;
case DRAG_NONE:
m_value.ident = CSSValueNone;
break;
case DRAG_ELEMENT:
m_value.ident = CSSValueElement;
break;
}
}
template<> inline CSSPrimitiveValue::operator EUserDrag() const
{
switch (m_value.ident) {
case CSSValueAuto:
return DRAG_AUTO;
case CSSValueNone:
return DRAG_NONE;
case CSSValueElement:
return DRAG_ELEMENT;
default:
ASSERT_NOT_REACHED();
return DRAG_AUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case READ_ONLY:
m_value.ident = CSSValueReadOnly;
break;
case READ_WRITE:
m_value.ident = CSSValueReadWrite;
break;
case READ_WRITE_PLAINTEXT_ONLY:
m_value.ident = CSSValueReadWritePlaintextOnly;
break;
}
}
template<> inline CSSPrimitiveValue::operator EUserModify() const
{
return static_cast<EUserModify>(m_value.ident - CSSValueReadOnly);
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case SELECT_NONE:
m_value.ident = CSSValueNone;
break;
case SELECT_TEXT:
m_value.ident = CSSValueText;
break;
}
}
template<> inline CSSPrimitiveValue::operator EUserSelect() const
{
switch (m_value.ident) {
case CSSValueAuto:
return SELECT_TEXT;
case CSSValueNone:
return SELECT_NONE;
case CSSValueText:
return SELECT_TEXT;
default:
ASSERT_NOT_REACHED();
return SELECT_TEXT;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case VISIBLE:
m_value.ident = CSSValueVisible;
break;
case HIDDEN:
m_value.ident = CSSValueHidden;
break;
case COLLAPSE:
m_value.ident = CSSValueCollapse;
break;
}
}
template<> inline CSSPrimitiveValue::operator EVisibility() const
{
switch (m_value.ident) {
case CSSValueHidden:
return HIDDEN;
case CSSValueVisible:
return VISIBLE;
case CSSValueCollapse:
return COLLAPSE;
default:
ASSERT_NOT_REACHED();
return VISIBLE;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case NORMAL:
m_value.ident = CSSValueNormal;
break;
case PRE:
m_value.ident = CSSValuePre;
break;
case PRE_WRAP:
m_value.ident = CSSValuePreWrap;
break;
case PRE_LINE:
m_value.ident = CSSValuePreLine;
break;
case NOWRAP:
m_value.ident = CSSValueNowrap;
break;
case KHTML_NOWRAP:
m_value.ident = CSSValueWebkitNowrap;
break;
}
}
template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
{
switch (m_value.ident) {
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:
ASSERT_NOT_REACHED();
return NORMAL;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case NormalWordBreak:
m_value.ident = CSSValueNormal;
break;
case BreakAllWordBreak:
m_value.ident = CSSValueBreakAll;
break;
case BreakWordBreak:
m_value.ident = CSSValueBreakWord;
break;
}
}
template<> inline CSSPrimitiveValue::operator EWordBreak() const
{
switch (m_value.ident) {
case CSSValueBreakAll:
return BreakAllWordBreak;
case CSSValueBreakWord:
return BreakWordBreak;
case CSSValueNormal:
return NormalWordBreak;
default:
ASSERT_NOT_REACHED();
return NormalWordBreak;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordWrap e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case NormalWordWrap:
m_value.ident = CSSValueNormal;
break;
case BreakWordWrap:
m_value.ident = CSSValueBreakWord;
break;
}
}
template<> inline CSSPrimitiveValue::operator EWordWrap() const
{
switch (m_value.ident) {
case CSSValueBreakWord:
return BreakWordWrap;
case CSSValueNormal:
return NormalWordWrap;
default:
ASSERT_NOT_REACHED();
return NormalWordWrap;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case LTR:
m_value.ident = CSSValueLtr;
break;
case RTL:
m_value.ident = CSSValueRtl;
break;
}
}
template<> inline CSSPrimitiveValue::operator TextDirection() const
{
switch (m_value.ident) {
case CSSValueLtr:
return LTR;
case CSSValueRtl:
return RTL;
default:
ASSERT_NOT_REACHED();
return LTR;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case TopToBottomWritingMode:
m_value.ident = CSSValueHorizontalTb;
break;
case RightToLeftWritingMode:
m_value.ident = CSSValueVerticalRl;
break;
case LeftToRightWritingMode:
m_value.ident = CSSValueVerticalLr;
break;
case BottomToTopWritingMode:
m_value.ident = CSSValueHorizontalBt;
break;
}
}
template<> inline CSSPrimitiveValue::operator WritingMode() const
{
switch (m_value.ident) {
case CSSValueHorizontalTb:
return TopToBottomWritingMode;
case CSSValueVerticalRl:
return RightToLeftWritingMode;
case CSSValueVerticalLr:
return LeftToRightWritingMode;
case CSSValueHorizontalBt:
return BottomToTopWritingMode;
default:
ASSERT_NOT_REACHED();
return TopToBottomWritingMode;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case TextCombineNone:
m_value.ident = CSSValueNone;
break;
case TextCombineHorizontal:
m_value.ident = CSSValueHorizontal;
break;
}
}
template<> inline CSSPrimitiveValue::operator TextCombine() const
{
switch (m_value.ident) {
case CSSValueNone:
return TextCombineNone;
case CSSValueHorizontal:
return TextCombineHorizontal;
default:
ASSERT_NOT_REACHED();
return TextCombineNone;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (position) {
case TextEmphasisPositionOver:
m_value.ident = CSSValueOver;
break;
case TextEmphasisPositionUnder:
m_value.ident = CSSValueUnder;
break;
}
}
template<> inline CSSPrimitiveValue::operator TextEmphasisPosition() const
{
switch (m_value.ident) {
case CSSValueOver:
return TextEmphasisPositionOver;
case CSSValueUnder:
return TextEmphasisPositionUnder;
default:
ASSERT_NOT_REACHED();
return TextEmphasisPositionOver;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (fill) {
case TextEmphasisFillFilled:
m_value.ident = CSSValueFilled;
break;
case TextEmphasisFillOpen:
m_value.ident = CSSValueOpen;
break;
}
}
template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
{
switch (m_value.ident) {
case CSSValueFilled:
return TextEmphasisFillFilled;
case CSSValueOpen:
return TextEmphasisFillOpen;
default:
ASSERT_NOT_REACHED();
return TextEmphasisFillFilled;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (mark) {
case TextEmphasisMarkDot:
m_value.ident = CSSValueDot;
break;
case TextEmphasisMarkCircle:
m_value.ident = CSSValueCircle;
break;
case TextEmphasisMarkDoubleCircle:
m_value.ident = CSSValueDoubleCircle;
break;
case TextEmphasisMarkTriangle:
m_value.ident = CSSValueTriangle;
break;
case TextEmphasisMarkSesame:
m_value.ident = CSSValueSesame;
break;
case TextEmphasisMarkNone:
case TextEmphasisMarkAuto:
case TextEmphasisMarkCustom:
ASSERT_NOT_REACHED();
m_value.ident = CSSValueNone;
break;
}
}
template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
{
switch (m_value.ident) {
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:
ASSERT_NOT_REACHED();
return TextEmphasisMarkNone;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case TextOrientationVerticalRight:
m_value.ident = CSSValueVerticalRight;
break;
case TextOrientationUpright:
m_value.ident = CSSValueUpright;
break;
}
}
template<> inline CSSPrimitiveValue::operator TextOrientation() const
{
switch (m_value.ident) {
case CSSValueVerticalRight:
return TextOrientationVerticalRight;
case CSSValueUpright:
return TextOrientationUpright;
default:
ASSERT_NOT_REACHED();
return TextOrientationVerticalRight;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case PE_NONE:
m_value.ident = CSSValueNone;
break;
case PE_STROKE:
m_value.ident = CSSValueStroke;
break;
case PE_FILL:
m_value.ident = CSSValueFill;
break;
case PE_PAINTED:
m_value.ident = CSSValuePainted;
break;
case PE_VISIBLE:
m_value.ident = CSSValueVisible;
break;
case PE_VISIBLE_STROKE:
m_value.ident = CSSValueVisiblestroke;
break;
case PE_VISIBLE_FILL:
m_value.ident = CSSValueVisiblefill;
break;
case PE_VISIBLE_PAINTED:
m_value.ident = CSSValueVisiblepainted;
break;
case PE_AUTO:
m_value.ident = CSSValueAuto;
break;
case PE_ALL:
m_value.ident = CSSValueAll;
break;
}
}
template<> inline CSSPrimitiveValue::operator EPointerEvents() const
{
switch (m_value.ident) {
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;
default:
ASSERT_NOT_REACHED();
return PE_ALL;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (smoothing) {
case AutoSmoothing:
m_value.ident = CSSValueAuto;
return;
case NoSmoothing:
m_value.ident = CSSValueNone;
return;
case Antialiased:
m_value.ident = CSSValueAntialiased;
return;
case SubpixelAntialiased:
m_value.ident = CSSValueSubpixelAntialiased;
return;
}
ASSERT_NOT_REACHED();
m_value.ident = CSSValueAuto;
}
template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
{
switch (m_value.ident) {
case CSSValueAuto:
return AutoSmoothing;
case CSSValueNone:
return NoSmoothing;
case CSSValueAntialiased:
return Antialiased;
case CSSValueSubpixelAntialiased:
return SubpixelAntialiased;
}
ASSERT_NOT_REACHED();
return AutoSmoothing;
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case AutoTextRendering:
m_value.ident = CSSValueAuto;
break;
case OptimizeSpeed:
m_value.ident = CSSValueOptimizespeed;
break;
case OptimizeLegibility:
m_value.ident = CSSValueOptimizelegibility;
break;
case GeometricPrecision:
m_value.ident = CSSValueGeometricprecision;
break;
}
}
template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
{
switch (m_value.ident) {
case CSSValueAuto:
return AutoTextRendering;
case CSSValueOptimizespeed:
return OptimizeSpeed;
case CSSValueOptimizelegibility:
return OptimizeLegibility;
case CSSValueGeometricprecision:
return GeometricPrecision;
default:
ASSERT_NOT_REACHED();
return AutoTextRendering;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColorSpace space)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (space) {
case ColorSpaceDeviceRGB:
m_value.ident = CSSValueDefault;
break;
case ColorSpaceSRGB:
m_value.ident = CSSValueSrgb;
break;
case ColorSpaceLinearRGB:
// CSS color correction does not support linearRGB yet.
ASSERT_NOT_REACHED();
m_value.ident = CSSValueDefault;
break;
}
}
template<> inline CSSPrimitiveValue::operator ColorSpace() const
{
switch (m_value.ident) {
case CSSValueDefault:
return ColorSpaceDeviceRGB;
case CSSValueSrgb:
return ColorSpaceSRGB;
default:
ASSERT_NOT_REACHED();
return ColorSpaceDeviceRGB;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (hyphens) {
case HyphensNone:
m_value.ident = CSSValueNone;
break;
case HyphensManual:
m_value.ident = CSSValueManual;
break;
case HyphensAuto:
m_value.ident = CSSValueAuto;
break;
}
}
template<> inline CSSPrimitiveValue::operator Hyphens() const
{
switch (m_value.ident) {
case CSSValueNone:
return HyphensNone;
case CSSValueManual:
return HyphensManual;
case CSSValueAuto:
return HyphensAuto;
default:
ASSERT_NOT_REACHED();
return HyphensAuto;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case SpeakNone:
m_value.ident = CSSValueNone;
break;
case SpeakNormal:
m_value.ident = CSSValueNormal;
break;
case SpeakSpellOut:
m_value.ident = CSSValueSpellOut;
break;
case SpeakDigits:
m_value.ident = CSSValueDigits;
break;
case SpeakLiteralPunctuation:
m_value.ident = CSSValueLiteralPunctuation;
break;
case SpeakNoPunctuation:
m_value.ident = CSSValueNoPunctuation;
break;
}
}
template<> inline CSSPrimitiveValue::operator ESpeak() const
{
switch (m_value.ident) {
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:
ASSERT_NOT_REACHED();
return SpeakNormal;
}
}
#if ENABLE(SVG)
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case ButtCap:
m_value.ident = CSSValueButt;
break;
case RoundCap:
m_value.ident = CSSValueRound;
break;
case SquareCap:
m_value.ident = CSSValueSquare;
break;
}
}
template<> inline CSSPrimitiveValue::operator LineCap() const
{
switch (m_value.ident) {
case CSSValueButt:
return ButtCap;
case CSSValueRound:
return RoundCap;
case CSSValueSquare:
return SquareCap;
default:
ASSERT_NOT_REACHED();
return ButtCap;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case MiterJoin:
m_value.ident = CSSValueMiter;
break;
case RoundJoin:
m_value.ident = CSSValueRound;
break;
case BevelJoin:
m_value.ident = CSSValueBevel;
break;
}
}
template<> inline CSSPrimitiveValue::operator LineJoin() const
{
switch (m_value.ident) {
case CSSValueMiter:
return MiterJoin;
case CSSValueRound:
return RoundJoin;
case CSSValueBevel:
return BevelJoin;
default:
ASSERT_NOT_REACHED();
return MiterJoin;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case RULE_NONZERO:
m_value.ident = CSSValueNonzero;
break;
case RULE_EVENODD:
m_value.ident = CSSValueEvenodd;
break;
}
}
template<> inline CSSPrimitiveValue::operator WindRule() const
{
switch (m_value.ident) {
case CSSValueNonzero:
return RULE_NONZERO;
case CSSValueEvenodd:
return RULE_EVENODD;
default:
ASSERT_NOT_REACHED();
return RULE_NONZERO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case AB_AUTO:
m_value.ident = CSSValueAuto;
break;
case AB_BASELINE:
m_value.ident = CSSValueBaseline;
break;
case AB_BEFORE_EDGE:
m_value.ident = CSSValueBeforeEdge;
break;
case AB_TEXT_BEFORE_EDGE:
m_value.ident = CSSValueTextBeforeEdge;
break;
case AB_MIDDLE:
m_value.ident = CSSValueMiddle;
break;
case AB_CENTRAL:
m_value.ident = CSSValueCentral;
break;
case AB_AFTER_EDGE:
m_value.ident = CSSValueAfterEdge;
break;
case AB_TEXT_AFTER_EDGE:
m_value.ident = CSSValueTextAfterEdge;
break;
case AB_IDEOGRAPHIC:
m_value.ident = CSSValueIdeographic;
break;
case AB_ALPHABETIC:
m_value.ident = CSSValueAlphabetic;
break;
case AB_HANGING:
m_value.ident = CSSValueHanging;
break;
case AB_MATHEMATICAL:
m_value.ident = CSSValueMathematical;
break;
}
}
template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
{
switch (m_value.ident) {
case CSSValueAuto:
return AB_AUTO;
case CSSValueBaseline:
return AB_BASELINE;
case CSSValueBeforeEdge:
return AB_BEFORE_EDGE;
case CSSValueTextBeforeEdge:
return AB_TEXT_BEFORE_EDGE;
case CSSValueMiddle:
return AB_MIDDLE;
case CSSValueCentral:
return AB_CENTRAL;
case CSSValueAfterEdge:
return AB_AFTER_EDGE;
case CSSValueTextAfterEdge:
return AB_TEXT_AFTER_EDGE;
case CSSValueIdeographic:
return AB_IDEOGRAPHIC;
case CSSValueAlphabetic:
return AB_ALPHABETIC;
case CSSValueHanging:
return AB_HANGING;
case CSSValueMathematical:
return AB_MATHEMATICAL;
default:
ASSERT_NOT_REACHED();
return AB_AUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case CI_AUTO:
m_value.ident = CSSValueAuto;
break;
case CI_SRGB:
m_value.ident = CSSValueSrgb;
break;
case CI_LINEARRGB:
m_value.ident = CSSValueLinearrgb;
break;
}
}
template<> inline CSSPrimitiveValue::operator EColorInterpolation() const
{
switch (m_value.ident) {
case CSSValueSrgb:
return CI_SRGB;
case CSSValueLinearrgb:
return CI_LINEARRGB;
case CSSValueAuto:
return CI_AUTO;
default:
ASSERT_NOT_REACHED();
return CI_AUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case CR_AUTO:
m_value.ident = CSSValueAuto;
break;
case CR_OPTIMIZESPEED:
m_value.ident = CSSValueOptimizespeed;
break;
case CR_OPTIMIZEQUALITY:
m_value.ident = CSSValueOptimizequality;
break;
}
}
template<> inline CSSPrimitiveValue::operator EColorRendering() const
{
switch (m_value.ident) {
case CSSValueOptimizespeed:
return CR_OPTIMIZESPEED;
case CSSValueOptimizequality:
return CR_OPTIMIZEQUALITY;
case CSSValueAuto:
return CR_AUTO;
default:
ASSERT_NOT_REACHED();
return CR_AUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case DB_AUTO:
m_value.ident = CSSValueAuto;
break;
case DB_USE_SCRIPT:
m_value.ident = CSSValueUseScript;
break;
case DB_NO_CHANGE:
m_value.ident = CSSValueNoChange;
break;
case DB_RESET_SIZE:
m_value.ident = CSSValueResetSize;
break;
case DB_CENTRAL:
m_value.ident = CSSValueCentral;
break;
case DB_MIDDLE:
m_value.ident = CSSValueMiddle;
break;
case DB_TEXT_BEFORE_EDGE:
m_value.ident = CSSValueTextBeforeEdge;
break;
case DB_TEXT_AFTER_EDGE:
m_value.ident = CSSValueTextAfterEdge;
break;
case DB_IDEOGRAPHIC:
m_value.ident = CSSValueIdeographic;
break;
case DB_ALPHABETIC:
m_value.ident = CSSValueAlphabetic;
break;
case DB_HANGING:
m_value.ident = CSSValueHanging;
break;
case DB_MATHEMATICAL:
m_value.ident = CSSValueMathematical;
break;
}
}
template<> inline CSSPrimitiveValue::operator EDominantBaseline() const
{
switch (m_value.ident) {
case CSSValueAuto:
return DB_AUTO;
case CSSValueUseScript:
return DB_USE_SCRIPT;
case CSSValueNoChange:
return DB_NO_CHANGE;
case CSSValueResetSize:
return DB_RESET_SIZE;
case CSSValueIdeographic:
return DB_IDEOGRAPHIC;
case CSSValueAlphabetic:
return DB_ALPHABETIC;
case CSSValueHanging:
return DB_HANGING;
case CSSValueMathematical:
return DB_MATHEMATICAL;
case CSSValueCentral:
return DB_CENTRAL;
case CSSValueMiddle:
return DB_MIDDLE;
case CSSValueTextAfterEdge:
return DB_TEXT_AFTER_EDGE;
case CSSValueTextBeforeEdge:
return DB_TEXT_BEFORE_EDGE;
default:
ASSERT_NOT_REACHED();
return DB_AUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case IR_AUTO:
m_value.ident = CSSValueAuto;
break;
case IR_OPTIMIZESPEED:
m_value.ident = CSSValueOptimizespeed;
break;
case IR_OPTIMIZEQUALITY:
m_value.ident = CSSValueOptimizequality;
break;
}
}
template<> inline CSSPrimitiveValue::operator EImageRendering() const
{
switch (m_value.ident) {
case CSSValueAuto:
return IR_AUTO;
case CSSValueOptimizespeed:
return IR_OPTIMIZESPEED;
case CSSValueOptimizequality:
return IR_OPTIMIZEQUALITY;
default:
ASSERT_NOT_REACHED();
return IR_AUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case IR_AUTO:
m_value.ident = CSSValueAuto;
break;
case IR_OPTIMIZESPEED:
m_value.ident = CSSValueOptimizespeed;
break;
case SR_CRISPEDGES:
m_value.ident = CSSValueCrispedges;
break;
case SR_GEOMETRICPRECISION:
m_value.ident = CSSValueGeometricprecision;
break;
}
}
template<> inline CSSPrimitiveValue::operator EShapeRendering() const
{
switch (m_value.ident) {
case CSSValueAuto:
return SR_AUTO;
case CSSValueOptimizespeed:
return SR_OPTIMIZESPEED;
case CSSValueCrispedges:
return SR_CRISPEDGES;
case CSSValueGeometricprecision:
return SR_GEOMETRICPRECISION;
default:
ASSERT_NOT_REACHED();
return SR_AUTO;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case TA_START:
m_value.ident = CSSValueStart;
break;
case TA_MIDDLE:
m_value.ident = CSSValueMiddle;
break;
case TA_END:
m_value.ident = CSSValueEnd;
break;
}
}
template<> inline CSSPrimitiveValue::operator ETextAnchor() const
{
switch (m_value.ident) {
case CSSValueStart:
return TA_START;
case CSSValueMiddle:
return TA_MIDDLE;
case CSSValueEnd:
return TA_END;
default:
ASSERT_NOT_REACHED();
return TA_START;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SVGWritingMode e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case WM_LRTB:
m_value.ident = CSSValueLrTb;
break;
case WM_LR:
m_value.ident = CSSValueLr;
break;
case WM_RLTB:
m_value.ident = CSSValueRlTb;
break;
case WM_RL:
m_value.ident = CSSValueRl;
break;
case WM_TBRL:
m_value.ident = CSSValueTbRl;
break;
case WM_TB:
m_value.ident = CSSValueTb;
break;
}
}
template<> inline CSSPrimitiveValue::operator SVGWritingMode() const
{
switch (m_value.ident) {
case CSSValueLrTb:
return WM_LRTB;
case CSSValueLr:
return WM_LR;
case CSSValueRlTb:
return WM_RLTB;
case CSSValueRl:
return WM_RL;
case CSSValueTbRl:
return WM_TBRL;
case CSSValueTb:
return WM_TB;
default:
ASSERT_NOT_REACHED();
return WM_LRTB;
}
}
template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVectorEffect e)
: m_type(CSS_IDENT)
, m_hasCachedCSSText(false)
{
switch (e) {
case VE_NONE:
m_value.ident = CSSValueNone;
break;
case VE_NON_SCALING_STROKE:
m_value.ident = CSSValueNonScalingStroke;
break;
}
}
template<> inline CSSPrimitiveValue::operator EVectorEffect() const
{
switch (m_value.ident) {
case CSSValueNone:
return VE_NONE;
case CSSValueNonScalingStroke:
return VE_NON_SCALING_STROKE;
default:
ASSERT_NOT_REACHED();
return VE_NONE;
}
}
#endif
}
#endif