/*
 * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.
 * Copyright (C) 2008 Apple Inc. 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 "CSSPrimitiveValue.h"
#include "CSSValueKeywords.h"
#include "RenderStyle.h"

namespace WebCore {

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case BNONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case BHIDDEN:
            m_value.ident = CSS_VAL_HIDDEN;
            break;
        case INSET:
            m_value.ident = CSS_VAL_INSET;
            break;
        case GROOVE:
            m_value.ident = CSS_VAL_GROOVE;
            break;
        case RIDGE:
            m_value.ident = CSS_VAL_RIDGE;
            break;
        case OUTSET:
            m_value.ident = CSS_VAL_OUTSET;
            break;
        case DOTTED:
            m_value.ident = CSS_VAL_DOTTED;
            break;
        case DASHED:
            m_value.ident = CSS_VAL_DASHED;
            break;
        case SOLID:
            m_value.ident = CSS_VAL_SOLID;
            break;
        case DOUBLE:
            m_value.ident = CSS_VAL_DOUBLE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EBorderStyle() const
{
    return (EBorderStyle)(m_value.ident - CSS_VAL_NONE);
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case CompositeClear:
            m_value.ident = CSS_VAL_CLEAR;
            break;
        case CompositeCopy:
            m_value.ident = CSS_VAL_COPY;
            break;
        case CompositeSourceOver:
            m_value.ident = CSS_VAL_SOURCE_OVER;
            break;
        case CompositeSourceIn:
            m_value.ident = CSS_VAL_SOURCE_IN;
            break;
        case CompositeSourceOut:
            m_value.ident = CSS_VAL_SOURCE_OUT;
            break;
        case CompositeSourceAtop:
            m_value.ident = CSS_VAL_SOURCE_ATOP;
            break;
        case CompositeDestinationOver:
            m_value.ident = CSS_VAL_DESTINATION_OVER;
            break;
        case CompositeDestinationIn:
            m_value.ident = CSS_VAL_DESTINATION_IN;
            break;
        case CompositeDestinationOut:
            m_value.ident = CSS_VAL_DESTINATION_OUT;
            break;
        case CompositeDestinationAtop:
            m_value.ident = CSS_VAL_DESTINATION_ATOP;
            break;
        case CompositeXOR:
            m_value.ident = CSS_VAL_XOR;
            break;
        case CompositePlusDarker:
            m_value.ident = CSS_VAL_PLUS_DARKER;
            break;
        case CompositeHighlight:
            m_value.ident = CSS_VAL_HIGHLIGHT;
            break;
        case CompositePlusLighter:
            m_value.ident = CSS_VAL_PLUS_LIGHTER;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator CompositeOperator() const
{
    switch (m_value.ident) {
        case CSS_VAL_CLEAR:
            return CompositeClear;
        case CSS_VAL_COPY:
            return CompositeCopy;
        case CSS_VAL_SOURCE_OVER:
            return CompositeSourceOver;
        case CSS_VAL_SOURCE_IN:
            return CompositeSourceIn;
        case CSS_VAL_SOURCE_OUT:
            return CompositeSourceOut;
        case CSS_VAL_SOURCE_ATOP:
            return CompositeSourceAtop;
        case CSS_VAL_DESTINATION_OVER:
            return CompositeDestinationOver;
        case CSS_VAL_DESTINATION_IN:
            return CompositeDestinationIn;
        case CSS_VAL_DESTINATION_OUT:
            return CompositeDestinationOut;
        case CSS_VAL_DESTINATION_ATOP:
            return CompositeDestinationAtop;
        case CSS_VAL_XOR:
            return CompositeXOR;
        case CSS_VAL_PLUS_DARKER:
            return CompositePlusDarker;
        case CSS_VAL_HIGHLIGHT:
            return CompositeHighlight;
        case CSS_VAL_PLUS_LIGHTER:
            return CompositePlusLighter;
        default:
            ASSERT_NOT_REACHED();
            return CompositeClear;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAppearance e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case NoAppearance:
            m_value.ident = CSS_VAL_NONE;
            break;
        case CheckboxAppearance:
            m_value.ident = CSS_VAL_CHECKBOX;
            break;
        case RadioAppearance:
            m_value.ident = CSS_VAL_RADIO;
            break;
        case PushButtonAppearance:
            m_value.ident = CSS_VAL_PUSH_BUTTON;
            break;
        case SquareButtonAppearance:
            m_value.ident = CSS_VAL_SQUARE_BUTTON;
            break;
        case ButtonAppearance:
            m_value.ident = CSS_VAL_BUTTON;
            break;
        case ButtonBevelAppearance:
            m_value.ident = CSS_VAL_BUTTON_BEVEL;
            break;
        case ListboxAppearance:
            m_value.ident = CSS_VAL_LISTBOX;
            break;
        case ListItemAppearance:
            m_value.ident = CSS_VAL_LISTITEM;
            break;
        case MediaFullscreenButtonAppearance:
            m_value.ident = CSS_VAL_MEDIA_FULLSCREEN_BUTTON;
            break;
        case MediaPlayButtonAppearance:
            m_value.ident = CSS_VAL_MEDIA_PLAY_BUTTON;
            break;
        case MediaMuteButtonAppearance:
            m_value.ident = CSS_VAL_MEDIA_MUTE_BUTTON;
            break;
        case MediaSeekBackButtonAppearance:
            m_value.ident = CSS_VAL_MEDIA_SEEK_BACK_BUTTON;
            break;
        case MediaSeekForwardButtonAppearance:
            m_value.ident = CSS_VAL_MEDIA_SEEK_FORWARD_BUTTON;
            break;
        case MediaSliderAppearance:
            m_value.ident = CSS_VAL_MEDIA_SLIDER;
            break;
        case MediaSliderThumbAppearance:
            m_value.ident = CSS_VAL_MEDIA_SLIDERTHUMB;
            break;
        case MenulistAppearance:
            m_value.ident = CSS_VAL_MENULIST;
            break;
        case MenulistButtonAppearance:
            m_value.ident = CSS_VAL_MENULIST_BUTTON;
            break;
        case MenulistTextAppearance:
            m_value.ident = CSS_VAL_MENULIST_TEXT;
            break;
        case MenulistTextFieldAppearance:
            m_value.ident = CSS_VAL_MENULIST_TEXTFIELD;
            break;
        case ScrollbarButtonUpAppearance:
            m_value.ident = CSS_VAL_SCROLLBARBUTTON_UP;
            break;
        case ScrollbarButtonDownAppearance:
            m_value.ident = CSS_VAL_SCROLLBARBUTTON_DOWN;
            break;
        case ScrollbarButtonLeftAppearance:
            m_value.ident = CSS_VAL_SCROLLBARBUTTON_LEFT;
            break;
        case ScrollbarButtonRightAppearance:
            m_value.ident = CSS_VAL_SCROLLBARBUTTON_RIGHT;
            break;
        case ScrollbarTrackHorizontalAppearance:
            m_value.ident = CSS_VAL_SCROLLBARTRACK_HORIZONTAL;
            break;
        case ScrollbarTrackVerticalAppearance:
            m_value.ident = CSS_VAL_SCROLLBARTRACK_VERTICAL;
            break;
        case ScrollbarThumbHorizontalAppearance:
            m_value.ident = CSS_VAL_SCROLLBARTHUMB_HORIZONTAL;
            break;
        case ScrollbarThumbVerticalAppearance:
            m_value.ident = CSS_VAL_SCROLLBARTHUMB_VERTICAL;
            break;
        case ScrollbarGripperHorizontalAppearance:
            m_value.ident = CSS_VAL_SCROLLBARGRIPPER_HORIZONTAL;
            break;
        case ScrollbarGripperVerticalAppearance:
            m_value.ident = CSS_VAL_SCROLLBARGRIPPER_VERTICAL;
            break;
        case SliderHorizontalAppearance:
            m_value.ident = CSS_VAL_SLIDER_HORIZONTAL;
            break;
        case SliderVerticalAppearance:
            m_value.ident = CSS_VAL_SLIDER_VERTICAL;
            break;
        case SliderThumbHorizontalAppearance:
            m_value.ident = CSS_VAL_SLIDERTHUMB_HORIZONTAL;
            break;
        case SliderThumbVerticalAppearance:
            m_value.ident = CSS_VAL_SLIDERTHUMB_VERTICAL;
            break;
        case CaretAppearance:
            m_value.ident = CSS_VAL_CARET;
            break;
        case SearchFieldAppearance:
            m_value.ident = CSS_VAL_SEARCHFIELD;
            break;
        case SearchFieldDecorationAppearance:
            m_value.ident = CSS_VAL_SEARCHFIELD_DECORATION;
            break;
        case SearchFieldResultsDecorationAppearance:
            m_value.ident = CSS_VAL_SEARCHFIELD_RESULTS_DECORATION;
            break;
        case SearchFieldResultsButtonAppearance:
            m_value.ident = CSS_VAL_SEARCHFIELD_RESULTS_BUTTON;
            break;
        case SearchFieldCancelButtonAppearance:
            m_value.ident = CSS_VAL_SEARCHFIELD_CANCEL_BUTTON;
            break;
        case TextFieldAppearance:
            m_value.ident = CSS_VAL_TEXTFIELD;
            break;
        case TextAreaAppearance:
            m_value.ident = CSS_VAL_TEXTAREA;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EAppearance() const
{
    if (m_value.ident == CSS_VAL_NONE)
        return NoAppearance;
    else
        return EAppearance(m_value.ident - CSS_VAL_CHECKBOX + 1);
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackgroundBox e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case BGBORDER:
            m_value.ident = CSS_VAL_BORDER;
            break;
        case BGPADDING:
            m_value.ident = CSS_VAL_PADDING;
            break;
        case BGCONTENT:
            m_value.ident = CSS_VAL_CONTENT;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EBackgroundBox() const
{
    switch (m_value.ident) {
        case CSS_VAL_BORDER:
            return BGBORDER;
        case CSS_VAL_PADDING:
            return BGPADDING;
        case CSS_VAL_CONTENT:
            return BGCONTENT;
        default:
            ASSERT_NOT_REACHED();
            return BGBORDER;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackgroundRepeat e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case REPEAT:
            m_value.ident = CSS_VAL_REPEAT;
            break;
        case REPEAT_X:
            m_value.ident = CSS_VAL_REPEAT_X;
            break;
        case REPEAT_Y:
            m_value.ident = CSS_VAL_REPEAT_Y;
            break;
        case NO_REPEAT:
            m_value.ident = CSS_VAL_NO_REPEAT;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EBackgroundRepeat() const
{
    switch (m_value.ident) {
        case CSS_VAL_REPEAT:
            return REPEAT;
        case CSS_VAL_REPEAT_X:
            return REPEAT_X;
        case CSS_VAL_REPEAT_Y:
            return REPEAT_Y;
        case CSS_VAL_NO_REPEAT:
            return NO_REPEAT;
        default:
            ASSERT_NOT_REACHED();
            return REPEAT;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case BSTRETCH:
            m_value.ident = CSS_VAL_STRETCH;
            break;
        case BSTART:
            m_value.ident = CSS_VAL_START;
            break;
        case BCENTER:
            m_value.ident = CSS_VAL_CENTER;
            break;
        case BEND:
            m_value.ident = CSS_VAL_END;
            break;
        case BBASELINE:
            m_value.ident = CSS_VAL_BASELINE;
            break;
        case BJUSTIFY:
            m_value.ident = CSS_VAL_JUSTIFY;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
{
    switch (m_value.ident) {
        case CSS_VAL_STRETCH:
            return BSTRETCH;
        case CSS_VAL_START:
            return BSTART;
        case CSS_VAL_END:
            return BEND;
        case CSS_VAL_CENTER:
            return BCENTER;
        case CSS_VAL_BASELINE:
            return BBASELINE;
        case CSS_VAL_JUSTIFY:
            return BJUSTIFY;
        default:
            ASSERT_NOT_REACHED();
            return BSTRETCH;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case BNORMAL:
            m_value.ident = CSS_VAL_NORMAL;
            break;
        case BREVERSE:
            m_value.ident = CSS_VAL_REVERSE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EBoxDirection() const
{
    switch (m_value.ident) {
        case CSS_VAL_NORMAL:
            return BNORMAL;
        case CSS_VAL_REVERSE:
            return BREVERSE;
        default:
            ASSERT_NOT_REACHED();
            return BNORMAL;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case SINGLE:
            m_value.ident = CSS_VAL_SINGLE;
            break;
        case MULTIPLE:
            m_value.ident = CSS_VAL_MULTIPLE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EBoxLines() const
{
    switch (m_value.ident) {
        case CSS_VAL_SINGLE:
            return SINGLE;
        case CSS_VAL_MULTIPLE:
            return MULTIPLE;
        default:
            ASSERT_NOT_REACHED();
            return SINGLE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case HORIZONTAL:
            m_value.ident = CSS_VAL_HORIZONTAL;
            break;
        case VERTICAL:
            m_value.ident = CSS_VAL_VERTICAL;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EBoxOrient() const
{
    switch (m_value.ident) {
        case CSS_VAL_HORIZONTAL:
        case CSS_VAL_INLINE_AXIS:
            return HORIZONTAL;
        case CSS_VAL_VERTICAL:
            return VERTICAL;
        default:
            ASSERT_NOT_REACHED();
            return HORIZONTAL;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case CAPLEFT:
            m_value.ident = CSS_VAL_LEFT;
            break;
        case CAPRIGHT:
            m_value.ident = CSS_VAL_RIGHT;
            break;
        case CAPTOP:
            m_value.ident = CSS_VAL_TOP;
            break;
        case CAPBOTTOM:
            m_value.ident = CSS_VAL_BOTTOM;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ECaptionSide() const
{
    switch (m_value.ident) {
        case CSS_VAL_LEFT:
            return CAPLEFT;
        case CSS_VAL_RIGHT:
            return CAPRIGHT;
        case CSS_VAL_TOP:
            return CAPTOP;
        case CSS_VAL_BOTTOM:
            return CAPBOTTOM;
        default:
            ASSERT_NOT_REACHED();
            return CAPTOP;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case CNONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case CLEFT:
            m_value.ident = CSS_VAL_LEFT;
            break;
        case CRIGHT:
            m_value.ident = CSS_VAL_RIGHT;
            break;
        case CBOTH:
            m_value.ident = CSS_VAL_BOTH;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EClear() const
{
    switch (m_value.ident) {
        case CSS_VAL_NONE:
            return CNONE;
        case CSS_VAL_LEFT:
            return CLEFT;
        case CSS_VAL_RIGHT:
            return CRIGHT;
        case CSS_VAL_BOTH:
            return CBOTH;
        default:
            ASSERT_NOT_REACHED();
            return CNONE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case CURSOR_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case CURSOR_CROSS:
            m_value.ident = CSS_VAL_CROSSHAIR;
            break;
        case CURSOR_DEFAULT:
            m_value.ident = CSS_VAL_DEFAULT;
            break;
        case CURSOR_POINTER:
            m_value.ident = CSS_VAL_POINTER;
            break;
        case CURSOR_MOVE:
            m_value.ident = CSS_VAL_MOVE;
            break;
        case CURSOR_CELL:
            m_value.ident = CSS_VAL_CELL;
            break;
        case CURSOR_VERTICAL_TEXT:
            m_value.ident = CSS_VAL_VERTICAL_TEXT;
            break;
        case CURSOR_CONTEXT_MENU:
            m_value.ident = CSS_VAL_CONTEXT_MENU;
            break;
        case CURSOR_ALIAS:
            m_value.ident = CSS_VAL_ALIAS;
            break;
        case CURSOR_COPY:
            m_value.ident = CSS_VAL_COPY;
            break;
        case CURSOR_NONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case CURSOR_PROGRESS:
            m_value.ident = CSS_VAL_PROGRESS;
            break;
        case CURSOR_NO_DROP:
            m_value.ident = CSS_VAL_NO_DROP;
            break;
        case CURSOR_NOT_ALLOWED:
            m_value.ident = CSS_VAL_NOT_ALLOWED;
            break;
        case CURSOR_WEBKIT_ZOOM_IN:
            m_value.ident = CSS_VAL__WEBKIT_ZOOM_IN;
            break;
        case CURSOR_WEBKIT_ZOOM_OUT:
            m_value.ident = CSS_VAL__WEBKIT_ZOOM_OUT;
            break;
        case CURSOR_E_RESIZE:
            m_value.ident = CSS_VAL_E_RESIZE;
            break;
        case CURSOR_NE_RESIZE:
            m_value.ident = CSS_VAL_NE_RESIZE;
            break;
        case CURSOR_NW_RESIZE:
            m_value.ident = CSS_VAL_NW_RESIZE;
            break;
        case CURSOR_N_RESIZE:
            m_value.ident = CSS_VAL_N_RESIZE;
            break;
        case CURSOR_SE_RESIZE:
            m_value.ident = CSS_VAL_SE_RESIZE;
            break;
        case CURSOR_SW_RESIZE:
            m_value.ident = CSS_VAL_SW_RESIZE;
            break;
        case CURSOR_S_RESIZE:
            m_value.ident = CSS_VAL_S_RESIZE;
            break;
        case CURSOR_W_RESIZE:
            m_value.ident = CSS_VAL_W_RESIZE;
            break;
        case CURSOR_EW_RESIZE:
            m_value.ident = CSS_VAL_EW_RESIZE;
            break;
        case CURSOR_NS_RESIZE:
            m_value.ident = CSS_VAL_NS_RESIZE;
            break;
        case CURSOR_NESW_RESIZE:
            m_value.ident = CSS_VAL_NESW_RESIZE;
            break;
        case CURSOR_NWSE_RESIZE:
            m_value.ident = CSS_VAL_NWSE_RESIZE;
            break;
        case CURSOR_COL_RESIZE:
            m_value.ident = CSS_VAL_COL_RESIZE;
            break;
        case CURSOR_ROW_RESIZE:
            m_value.ident = CSS_VAL_ROW_RESIZE;
            break;
        case CURSOR_TEXT:
            m_value.ident = CSS_VAL_TEXT;
            break;
        case CURSOR_WAIT:
            m_value.ident = CSS_VAL_WAIT;
            break;
        case CURSOR_HELP:
            m_value.ident = CSS_VAL_HELP;
            break;
        case CURSOR_ALL_SCROLL:
            m_value.ident = CSS_VAL_ALL_SCROLL;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ECursor() const
{
    if (m_value.ident == CSS_VAL_COPY)
        return CURSOR_COPY;
    if (m_value.ident == CSS_VAL_NONE)
        return CURSOR_NONE;
    return static_cast<ECursor>(m_value.ident - CSS_VAL_AUTO);
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case INLINE:
            m_value.ident = CSS_VAL_INLINE;
            break;
        case BLOCK:
            m_value.ident = CSS_VAL_BLOCK;
            break;
        case LIST_ITEM:
            m_value.ident = CSS_VAL_LIST_ITEM;
            break;
        case RUN_IN:
            m_value.ident = CSS_VAL_RUN_IN;
            break;
        case COMPACT:
            m_value.ident = CSS_VAL_COMPACT;
            break;
        case INLINE_BLOCK:
            m_value.ident = CSS_VAL_INLINE_BLOCK;
            break;
        case TABLE:
            m_value.ident = CSS_VAL_TABLE;
            break;
        case INLINE_TABLE:
            m_value.ident = CSS_VAL_INLINE_TABLE;
            break;
        case TABLE_ROW_GROUP:
            m_value.ident = CSS_VAL_TABLE_ROW_GROUP;
            break;
        case TABLE_HEADER_GROUP:
            m_value.ident = CSS_VAL_TABLE_HEADER_GROUP;
            break;
        case TABLE_FOOTER_GROUP:
            m_value.ident = CSS_VAL_TABLE_FOOTER_GROUP;
            break;
        case TABLE_ROW:
            m_value.ident = CSS_VAL_TABLE_ROW;
            break;
        case TABLE_COLUMN_GROUP:
            m_value.ident = CSS_VAL_TABLE_COLUMN_GROUP;
            break;
        case TABLE_COLUMN:
            m_value.ident = CSS_VAL_TABLE_COLUMN;
            break;
        case TABLE_CELL:
            m_value.ident = CSS_VAL_TABLE_CELL;
            break;
        case TABLE_CAPTION:
            m_value.ident = CSS_VAL_TABLE_CAPTION;
            break;
        case BOX:
            m_value.ident = CSS_VAL__WEBKIT_BOX;
            break;
        case INLINE_BOX:
            m_value.ident = CSS_VAL__WEBKIT_INLINE_BOX;
            break;
        case NONE:
            m_value.ident = CSS_VAL_NONE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EDisplay() const
{
    if (m_value.ident == CSS_VAL_NONE)
        return NONE;
    return static_cast<EDisplay>(m_value.ident - CSS_VAL_INLINE);
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case SHOW:
            m_value.ident = CSS_VAL_SHOW;
            break;
        case HIDE:
            m_value.ident = CSS_VAL_HIDE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EEmptyCell() const
{
    switch (m_value.ident) {
        case CSS_VAL_SHOW:
            return SHOW;
        case CSS_VAL_HIDE:
            return HIDE;
        default:
            ASSERT_NOT_REACHED();
            return SHOW;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case FNONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case FLEFT:
            m_value.ident = CSS_VAL_LEFT;
            break;
        case FRIGHT:
            m_value.ident = CSS_VAL_RIGHT;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EFloat() const
{
    switch (m_value.ident) {
        case CSS_VAL_LEFT:
            return FLEFT;
        case CSS_VAL_RIGHT:
            return FRIGHT;
        case CSS_VAL_NONE:
        case CSS_VAL_CENTER:  // Non-standard CSS value
            return FNONE;
        default:
            ASSERT_NOT_REACHED();
            return FNONE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EKHTMLLineBreak e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case LBNORMAL:
            m_value.ident = CSS_VAL_NORMAL;
            break;
        case AFTER_WHITE_SPACE:
            m_value.ident = CSS_VAL_AFTER_WHITE_SPACE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EKHTMLLineBreak() const
{
    switch (m_value.ident) {
        case CSS_VAL_AFTER_WHITE_SPACE:
            return AFTER_WHITE_SPACE;
        case CSS_VAL_NORMAL:
            return LBNORMAL;
        default:
            ASSERT_NOT_REACHED();
            return LBNORMAL;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case OUTSIDE:
            m_value.ident = CSS_VAL_OUTSIDE;
            break;
        case INSIDE:
            m_value.ident = CSS_VAL_INSIDE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EListStylePosition() const
{
    return (EListStylePosition)(m_value.ident - CSS_VAL_OUTSIDE);
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case LNONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case DISC:
            m_value.ident = CSS_VAL_DISC;
            break;
        case CIRCLE:
            m_value.ident = CSS_VAL_CIRCLE;
            break;
        case SQUARE:
            m_value.ident = CSS_VAL_SQUARE;
            break;
        case LDECIMAL:
            m_value.ident = CSS_VAL_DECIMAL;
            break;
        case DECIMAL_LEADING_ZERO:
            m_value.ident = CSS_VAL_DECIMAL_LEADING_ZERO;
            break;
        case LOWER_ROMAN:
            m_value.ident = CSS_VAL_LOWER_ROMAN;
            break;
        case UPPER_ROMAN:
            m_value.ident = CSS_VAL_UPPER_ROMAN;
            break;
        case LOWER_GREEK:
            m_value.ident = CSS_VAL_LOWER_GREEK;
            break;
        case LOWER_ALPHA:
            m_value.ident = CSS_VAL_LOWER_ALPHA;
            break;
        case LOWER_LATIN:
            m_value.ident = CSS_VAL_LOWER_LATIN;
            break;
        case UPPER_ALPHA:
            m_value.ident = CSS_VAL_UPPER_ALPHA;
            break;
        case UPPER_LATIN:
            m_value.ident = CSS_VAL_UPPER_LATIN;
            break;
        case HEBREW:
            m_value.ident = CSS_VAL_HEBREW;
            break;
        case ARMENIAN:
            m_value.ident = CSS_VAL_ARMENIAN;
            break;
        case GEORGIAN:
            m_value.ident = CSS_VAL_GEORGIAN;
            break;
        case CJK_IDEOGRAPHIC:
            m_value.ident = CSS_VAL_CJK_IDEOGRAPHIC;
            break;
        case HIRAGANA:
            m_value.ident = CSS_VAL_HIRAGANA;
            break;
        case KATAKANA:
            m_value.ident = CSS_VAL_KATAKANA;
            break;
        case HIRAGANA_IROHA:
            m_value.ident = CSS_VAL_HIRAGANA_IROHA;
            break;
        case KATAKANA_IROHA:
            m_value.ident = CSS_VAL_KATAKANA_IROHA;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EListStyleType() const
{
    switch (m_value.ident) {
        case CSS_VAL_NONE:
            return LNONE;
        default:
            return static_cast<EListStyleType>(m_value.ident - CSS_VAL_DISC);
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case MCOLLAPSE:
            m_value.ident = CSS_VAL_COLLAPSE;
            break;
        case MSEPARATE:
            m_value.ident = CSS_VAL_SEPARATE;
            break;
        case MDISCARD:
            m_value.ident = CSS_VAL_DISCARD;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
{
    switch (m_value.ident) {
        case CSS_VAL_COLLAPSE:
            return MCOLLAPSE;
        case CSS_VAL_SEPARATE:
            return MSEPARATE;
        case CSS_VAL_DISCARD:
            return MDISCARD;
        default:
            ASSERT_NOT_REACHED();
            return MCOLLAPSE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case MNONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case MSCROLL:
            m_value.ident = CSS_VAL_SCROLL;
            break;
        case MSLIDE:
            m_value.ident = CSS_VAL_SLIDE;
            break;
        case MALTERNATE:
            m_value.ident = CSS_VAL_ALTERNATE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
{
    switch (m_value.ident) {
        case CSS_VAL_NONE:
            return MNONE;
        case CSS_VAL_SCROLL:
            return MSCROLL;
        case CSS_VAL_SLIDE:
            return MSLIDE;
        case CSS_VAL_ALTERNATE:
            return MALTERNATE;
        default:
            ASSERT_NOT_REACHED();
            return MNONE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case MFORWARD:
            m_value.ident = CSS_VAL_FORWARDS;
            break;
        case MBACKWARD:
            m_value.ident = CSS_VAL_BACKWARDS;
            break;
        case MAUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case MUP:
            m_value.ident = CSS_VAL_UP;
            break;
        case MDOWN:
            m_value.ident = CSS_VAL_DOWN;
            break;
        case MLEFT:
            m_value.ident = CSS_VAL_LEFT;
            break;
        case MRIGHT:
            m_value.ident = CSS_VAL_RIGHT;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
{
    switch (m_value.ident) {
        case CSS_VAL_FORWARDS:
            return MFORWARD;
        case CSS_VAL_BACKWARDS:
            return MBACKWARD;
        case CSS_VAL_AUTO:
            return MAUTO;
        case CSS_VAL_AHEAD:
        case CSS_VAL_UP: // We don't support vertical languages, so AHEAD just maps to UP.
            return MUP;
        case CSS_VAL_REVERSE:
        case CSS_VAL_DOWN: // REVERSE just maps to DOWN, since we don't do vertical text.
            return MDOWN;
        case CSS_VAL_LEFT:
            return MLEFT;
        case CSS_VAL_RIGHT:
            return MRIGHT;
        default:
            ASSERT_NOT_REACHED();
            return MAUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMatchNearestMailBlockquoteColor e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case BCNORMAL:
            m_value.ident = CSS_VAL_NORMAL;
            break;
        case MATCH:
            m_value.ident = CSS_VAL_MATCH;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EMatchNearestMailBlockquoteColor() const
{
    switch (m_value.ident) {
        case CSS_VAL_NORMAL:
            return BCNORMAL;
        case CSS_VAL_MATCH:
            return MATCH;
        default:
            ASSERT_NOT_REACHED();
            return BCNORMAL;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case NBNORMAL:
            m_value.ident = CSS_VAL_NORMAL;
            break;
        case SPACE:
            m_value.ident = CSS_VAL_SPACE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ENBSPMode() const
{
    switch (m_value.ident) {
        case CSS_VAL_SPACE:
            return SPACE;
        case CSS_VAL_NORMAL:
            return NBNORMAL;
        default:
            ASSERT_NOT_REACHED();
            return NBNORMAL;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case OVISIBLE:
            m_value.ident = CSS_VAL_VISIBLE;
            break;
        case OHIDDEN:
            m_value.ident = CSS_VAL_HIDDEN;
            break;
        case OSCROLL:
            m_value.ident = CSS_VAL_SCROLL;
            break;
        case OAUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case OMARQUEE:
            m_value.ident = CSS_VAL__WEBKIT_MARQUEE;
            break;
        case OOVERLAY:
            m_value.ident = CSS_VAL_OVERLAY;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EOverflow() const
{
    switch (m_value.ident) {
        case CSS_VAL_VISIBLE:
            return OVISIBLE;
        case CSS_VAL_HIDDEN:
            return OHIDDEN;
        case CSS_VAL_SCROLL:
            return OSCROLL;
        case CSS_VAL_AUTO:
            return OAUTO;
        case CSS_VAL__WEBKIT_MARQUEE:
            return OMARQUEE;
        case CSS_VAL_OVERLAY:
            return OOVERLAY;
        default:
            ASSERT_NOT_REACHED();
            return OVISIBLE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case PBAUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case PBALWAYS:
            m_value.ident = CSS_VAL_ALWAYS;
            break;
        case PBAVOID:
            m_value.ident = CSS_VAL_AVOID;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EPageBreak() const
{
    switch (m_value.ident) {
        case CSS_VAL_AUTO:
            return PBAUTO;
        case CSS_VAL_LEFT:
        case CSS_VAL_RIGHT:
        case CSS_VAL_ALWAYS:
            return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always."
        case CSS_VAL_AVOID:
            return PBAVOID;
        default:
            ASSERT_NOT_REACHED();
            return PBAUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case StaticPosition:
            m_value.ident = CSS_VAL_STATIC;
            break;
        case RelativePosition:
            m_value.ident = CSS_VAL_RELATIVE;
            break;
        case AbsolutePosition:
            m_value.ident = CSS_VAL_ABSOLUTE;
            break;
        case FixedPosition:
            m_value.ident = CSS_VAL_FIXED;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EPosition() const
{
    switch (m_value.ident) {
        case CSS_VAL_STATIC:
            return StaticPosition;
        case CSS_VAL_RELATIVE:
            return RelativePosition;
        case CSS_VAL_ABSOLUTE:
            return AbsolutePosition;
        case CSS_VAL_FIXED:
            return FixedPosition;
        default:
            ASSERT_NOT_REACHED();
            return StaticPosition;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case RESIZE_BOTH:
            m_value.ident = CSS_VAL_BOTH;
            break;
        case RESIZE_HORIZONTAL:
            m_value.ident = CSS_VAL_HORIZONTAL;
            break;
        case RESIZE_VERTICAL:
            m_value.ident = CSS_VAL_VERTICAL;
            break;
        case RESIZE_NONE:
            m_value.ident = CSS_VAL_NONE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EResize() const
{
    switch (m_value.ident) {
        case CSS_VAL_BOTH:
            return RESIZE_BOTH;
        case CSS_VAL_HORIZONTAL:
            return RESIZE_HORIZONTAL;
        case CSS_VAL_VERTICAL:
            return RESIZE_VERTICAL;
        case CSS_VAL_AUTO:
            ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
            return RESIZE_NONE;
        case CSS_VAL_NONE:
            return RESIZE_NONE;
        default:
            ASSERT_NOT_REACHED();
            return RESIZE_NONE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case TAUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case TFIXED:
            m_value.ident = CSS_VAL_FIXED;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ETableLayout() const
{
    switch (m_value.ident) {
        case CSS_VAL_FIXED:
            return TFIXED;
        case CSS_VAL_AUTO:
            return TAUTO;
        default:
            ASSERT_NOT_REACHED();
            return TAUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case TAAUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case LEFT:
            m_value.ident = CSS_VAL_LEFT;
            break;
        case RIGHT:
            m_value.ident = CSS_VAL_RIGHT;
            break;
        case CENTER:
            m_value.ident = CSS_VAL_CENTER;
            break;
        case JUSTIFY:
            m_value.ident = CSS_VAL_JUSTIFY;
            break;
        case WEBKIT_LEFT:
            m_value.ident = CSS_VAL__WEBKIT_LEFT;
            break;
        case WEBKIT_RIGHT:
            m_value.ident = CSS_VAL__WEBKIT_RIGHT;
            break;
        case WEBKIT_CENTER:
            m_value.ident = CSS_VAL__WEBKIT_CENTER;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ETextAlign() const
{
    switch (m_value.ident) {
        case CSS_VAL_START:
        case CSS_VAL_END:
            ASSERT_NOT_REACHED(); // Depends on direction, thus should be handled by the caller.
            return LEFT;
        default:
            return static_cast<ETextAlign>(m_value.ident - CSS_VAL__WEBKIT_AUTO);
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case TSNONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case TSDISC:
            m_value.ident = CSS_VAL_DISC;
            break;
        case TSCIRCLE:
            m_value.ident = CSS_VAL_CIRCLE;
            break;
        case TSSQUARE:
            m_value.ident = CSS_VAL_SQUARE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ETextSecurity() const
{
    switch (m_value.ident) {
        case CSS_VAL_NONE:
            return TSNONE;
        case CSS_VAL_DISC:
            return TSDISC;
        case CSS_VAL_CIRCLE:
            return TSCIRCLE;
        case CSS_VAL_SQUARE:
            return TSSQUARE;
        default:
            ASSERT_NOT_REACHED();
            return TSNONE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case CAPITALIZE:
            m_value.ident = CSS_VAL_CAPITALIZE;
            break;
        case UPPERCASE:
            m_value.ident = CSS_VAL_UPPERCASE;
            break;
        case LOWERCASE:
            m_value.ident = CSS_VAL_LOWERCASE;
            break;
        case TTNONE:
            m_value.ident = CSS_VAL_NONE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ETextTransform() const
{
    switch (m_value.ident) {
        case CSS_VAL_CAPITALIZE:
            return CAPITALIZE;
        case CSS_VAL_UPPERCASE:
            return UPPERCASE;
        case CSS_VAL_LOWERCASE:
            return LOWERCASE;
        case CSS_VAL_NONE:
            return TTNONE;
        default:
            ASSERT_NOT_REACHED();
            return TTNONE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case UBNormal:
            m_value.ident = CSS_VAL_NORMAL;
            break;
        case Embed:
            m_value.ident = CSS_VAL_EMBED;
            break;
        case Override:
            m_value.ident = CSS_VAL_BIDI_OVERRIDE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
{
    switch (m_value.ident) {
        case CSS_VAL_NORMAL:
            return UBNormal; 
        case CSS_VAL_EMBED:
            return Embed; 
        case CSS_VAL_BIDI_OVERRIDE:
            return Override;
        default:
            ASSERT_NOT_REACHED();
            return UBNormal;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case DRAG_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case DRAG_NONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case DRAG_ELEMENT:
            m_value.ident = CSS_VAL_ELEMENT;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EUserDrag() const
{
    switch (m_value.ident) {
        case CSS_VAL_AUTO:
            return DRAG_AUTO;
        case CSS_VAL_NONE:
            return DRAG_NONE;
        case CSS_VAL_ELEMENT:
            return DRAG_ELEMENT;
        default:
            ASSERT_NOT_REACHED();
            return DRAG_AUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case READ_ONLY:
            m_value.ident = CSS_VAL_READ_ONLY;
            break;
        case READ_WRITE:
            m_value.ident = CSS_VAL_READ_WRITE;
            break;
        case READ_WRITE_PLAINTEXT_ONLY:
            m_value.ident = CSS_VAL_READ_WRITE_PLAINTEXT_ONLY;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EUserModify() const
{
    return static_cast<EUserModify>(m_value.ident - CSS_VAL_READ_ONLY);
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case SELECT_NONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case SELECT_TEXT:
            m_value.ident = CSS_VAL_TEXT;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EUserSelect() const
{
    switch (m_value.ident) {
        case CSS_VAL_AUTO:
            return SELECT_TEXT;
        case CSS_VAL_NONE:
            return SELECT_NONE;
        case CSS_VAL_TEXT:
            return SELECT_TEXT;
        default:
            ASSERT_NOT_REACHED();
            return SELECT_TEXT;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case VISIBLE:
            m_value.ident = CSS_VAL_VISIBLE;
            break;
        case HIDDEN:
            m_value.ident = CSS_VAL_HIDDEN;
            break;
        case COLLAPSE:
            m_value.ident = CSS_VAL_COLLAPSE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EVisibility() const
{
    switch (m_value.ident) {
        case CSS_VAL_HIDDEN:
            return HIDDEN;
        case CSS_VAL_VISIBLE:
            return VISIBLE;
        case CSS_VAL_COLLAPSE:
            return COLLAPSE;
        default:
            ASSERT_NOT_REACHED();
            return VISIBLE;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case NORMAL:
            m_value.ident = CSS_VAL_NORMAL;
            break;
        case PRE:
            m_value.ident = CSS_VAL_PRE;
            break;
        case PRE_WRAP:
            m_value.ident = CSS_VAL_PRE_WRAP;
            break;
        case PRE_LINE:
            m_value.ident = CSS_VAL_PRE_LINE;
            break;
        case NOWRAP:
            m_value.ident = CSS_VAL_NOWRAP;
            break;
        case KHTML_NOWRAP:
            m_value.ident = CSS_VAL__WEBKIT_NOWRAP;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
{
    switch (m_value.ident) {
        case CSS_VAL__WEBKIT_NOWRAP:
            return KHTML_NOWRAP;
        case CSS_VAL_NOWRAP:
            return NOWRAP;
        case CSS_VAL_PRE:
            return PRE;
        case CSS_VAL_PRE_WRAP:
            return PRE_WRAP;
        case CSS_VAL_PRE_LINE:
            return PRE_LINE;
        case CSS_VAL_NORMAL:
            return NORMAL;
        default:
            ASSERT_NOT_REACHED();
            return NORMAL;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case NormalWordBreak:
            m_value.ident = CSS_VAL_NORMAL;
            break;
        case BreakAllWordBreak:
            m_value.ident = CSS_VAL_BREAK_ALL;
            break;
        case BreakWordBreak:
            m_value.ident = CSS_VAL_BREAK_WORD;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EWordBreak() const
{
    switch (m_value.ident) {
        case CSS_VAL_BREAK_ALL:
            return BreakAllWordBreak;
        case CSS_VAL_BREAK_WORD:
            return BreakWordBreak;
        case CSS_VAL_NORMAL:
            return NormalWordBreak;
        default:
        ASSERT_NOT_REACHED();
        return NormalWordBreak;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordWrap e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case NormalWordWrap:
            m_value.ident = CSS_VAL_NORMAL;
            break;
        case BreakWordWrap:
            m_value.ident = CSS_VAL_BREAK_WORD;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EWordWrap() const
{
    switch (m_value.ident) {
        case CSS_VAL_BREAK_WORD:
            return BreakWordWrap;
        case CSS_VAL_NORMAL:
            return NormalWordWrap;
        default:
            ASSERT_NOT_REACHED();
            return NormalWordWrap;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case LTR:
            m_value.ident = CSS_VAL_LTR;
            break;
        case RTL:
            m_value.ident = CSS_VAL_RTL;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator TextDirection() const
{
    switch (m_value.ident) {
        case CSS_VAL_LTR:
            return LTR;
        case CSS_VAL_RTL:
            return RTL;
        default:
            ASSERT_NOT_REACHED();
            return LTR;
    }
}

#if ENABLE(SVG)

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case ButtCap:
            m_value.ident = CSS_VAL_BUTT;
            break;
        case RoundCap:
            m_value.ident = CSS_VAL_ROUND;
            break;
        case SquareCap:
            m_value.ident = CSS_VAL_SQUARE;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator LineCap() const
{
    switch (m_value.ident) {
        case CSS_VAL_BUTT:
            return ButtCap;
        case CSS_VAL_ROUND:
            return RoundCap;
        case CSS_VAL_SQUARE:
            return SquareCap;
        default:
            ASSERT_NOT_REACHED();
            return ButtCap;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case MiterJoin:
            m_value.ident = CSS_VAL_MITER;
            break;
        case RoundJoin:
            m_value.ident = CSS_VAL_ROUND;
            break;
        case BevelJoin:
            m_value.ident = CSS_VAL_BEVEL;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator LineJoin() const
{
    switch (m_value.ident) {
        case CSS_VAL_MITER:
            return MiterJoin;
        case CSS_VAL_ROUND:
            return RoundJoin;
        case CSS_VAL_BEVEL:
            return BevelJoin;
        default:
            ASSERT_NOT_REACHED();
            return MiterJoin;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case RULE_NONZERO:
            m_value.ident = CSS_VAL_NONZERO;
            break;
        case RULE_EVENODD:
            m_value.ident = CSS_VAL_EVENODD;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator WindRule() const
{
    switch (m_value.ident) {
        case CSS_VAL_NONZERO:
            return RULE_NONZERO;
        case CSS_VAL_EVENODD:
            return RULE_EVENODD;
        default:
            ASSERT_NOT_REACHED();
            return RULE_NONZERO;
    }
}


template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case AB_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case AB_BASELINE:
            m_value.ident = CSS_VAL_BASELINE;
            break;
        case AB_BEFORE_EDGE:
            m_value.ident = CSS_VAL_BEFORE_EDGE;
            break;
        case AB_TEXT_BEFORE_EDGE:
            m_value.ident = CSS_VAL_TEXT_BEFORE_EDGE;
            break;
        case AB_MIDDLE:
            m_value.ident = CSS_VAL_MIDDLE;
            break;
        case AB_CENTRAL:
            m_value.ident = CSS_VAL_CENTRAL;
            break;
        case AB_AFTER_EDGE:
            m_value.ident = CSS_VAL_AFTER_EDGE;
            break;
        case AB_TEXT_AFTER_EDGE:
            m_value.ident = CSS_VAL_TEXT_AFTER_EDGE;
            break;
        case AB_IDEOGRAPHIC:
            m_value.ident = CSS_VAL_IDEOGRAPHIC;
            break;
        case AB_ALPHABETIC:
            m_value.ident = CSS_VAL_ALPHABETIC;
            break;
        case AB_HANGING:
            m_value.ident = CSS_VAL_HANGING;
            break;
        case AB_MATHEMATICAL:
            m_value.ident = CSS_VAL_MATHEMATICAL;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
{
    switch (m_value.ident) {
        case CSS_VAL_AUTO:
            return AB_AUTO;
        case CSS_VAL_BASELINE:
            return AB_BASELINE;
        case CSS_VAL_BEFORE_EDGE:
            return AB_BEFORE_EDGE;
        case CSS_VAL_TEXT_BEFORE_EDGE:
            return AB_TEXT_BEFORE_EDGE;
        case CSS_VAL_MIDDLE:
            return AB_MIDDLE;
        case CSS_VAL_CENTRAL:
            return AB_CENTRAL;
        case CSS_VAL_AFTER_EDGE:
            return AB_AFTER_EDGE;
        case CSS_VAL_TEXT_AFTER_EDGE:
            return AB_TEXT_AFTER_EDGE;
        case CSS_VAL_IDEOGRAPHIC:
            return AB_IDEOGRAPHIC;
        case CSS_VAL_ALPHABETIC:
            return AB_ALPHABETIC;
        case CSS_VAL_HANGING:
            return AB_HANGING;
        case CSS_VAL_MATHEMATICAL:
            return AB_MATHEMATICAL;
        default:
            ASSERT_NOT_REACHED();
            return AB_AUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case CI_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case CI_SRGB:
            m_value.ident = CSS_VAL_SRGB;
            break;
        case CI_LINEARRGB:
            m_value.ident = CSS_VAL_LINEARRGB;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EColorInterpolation() const
{
    switch (m_value.ident) {
        case CSS_VAL_SRGB:
            return CI_SRGB;
        case CSS_VAL_LINEARRGB:
            return CI_LINEARRGB;
        case CSS_VAL_AUTO:
            return CI_AUTO;
        default:
            ASSERT_NOT_REACHED();
            return CI_AUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case CR_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case CR_OPTIMIZESPEED:
            m_value.ident = CSS_VAL_OPTIMIZESPEED;
            break;
        case CR_OPTIMIZEQUALITY:
            m_value.ident = CSS_VAL_OPTIMIZEQUALITY;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EColorRendering() const
{
    switch (m_value.ident) {
        case CSS_VAL_OPTIMIZESPEED:
            return CR_OPTIMIZESPEED;
        case CSS_VAL_OPTIMIZEQUALITY:
            return CR_OPTIMIZEQUALITY;
        case CSS_VAL_AUTO:
            return CR_AUTO;
        default:
            ASSERT_NOT_REACHED();
            return CR_AUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case DB_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case DB_USE_SCRIPT:
            m_value.ident = CSS_VAL_USE_SCRIPT;
            break;
        case DB_NO_CHANGE:
            m_value.ident = CSS_VAL_NO_CHANGE;
            break;
        case DB_RESET_SIZE:
            m_value.ident = CSS_VAL_RESET_SIZE;
            break;
        case DB_CENTRAL:
            m_value.ident = CSS_VAL_CENTRAL;
            break;
        case DB_MIDDLE:
            m_value.ident = CSS_VAL_MIDDLE;
            break;
        case DB_TEXT_BEFORE_EDGE:
            m_value.ident = CSS_VAL_TEXT_BEFORE_EDGE;
            break;
        case DB_TEXT_AFTER_EDGE:
            m_value.ident = CSS_VAL_TEXT_AFTER_EDGE;
            break;
        case DB_IDEOGRAPHIC:
            m_value.ident = CSS_VAL_IDEOGRAPHIC;
            break;
        case DB_ALPHABETIC:
            m_value.ident = CSS_VAL_ALPHABETIC;
            break;
        case DB_HANGING:
            m_value.ident = CSS_VAL_HANGING;
            break;
        case DB_MATHEMATICAL:
            m_value.ident = CSS_VAL_MATHEMATICAL;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EDominantBaseline() const
{
    switch (m_value.ident) {
        case CSS_VAL_AUTO:
            return DB_AUTO;
        case CSS_VAL_USE_SCRIPT:
            return DB_USE_SCRIPT;
        case CSS_VAL_NO_CHANGE:
            return DB_NO_CHANGE;
        case CSS_VAL_RESET_SIZE:
            return DB_RESET_SIZE;
        case CSS_VAL_IDEOGRAPHIC:
            return DB_IDEOGRAPHIC;
        case CSS_VAL_ALPHABETIC:
            return DB_ALPHABETIC;
        case CSS_VAL_HANGING:
            return DB_HANGING;
        case CSS_VAL_MATHEMATICAL:
            return DB_MATHEMATICAL;
        case CSS_VAL_CENTRAL:
            return DB_CENTRAL;
        case CSS_VAL_MIDDLE:
            return DB_MIDDLE;
        case CSS_VAL_TEXT_AFTER_EDGE:
            return DB_TEXT_AFTER_EDGE;
        case CSS_VAL_TEXT_BEFORE_EDGE:
            return DB_TEXT_BEFORE_EDGE;
        default:
            ASSERT_NOT_REACHED();
            return DB_AUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case IR_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case IR_OPTIMIZESPEED:
            m_value.ident = CSS_VAL_OPTIMIZESPEED;
            break;
        case IR_OPTIMIZEQUALITY:
            m_value.ident = CSS_VAL_OPTIMIZEQUALITY;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EImageRendering() const
{
    switch (m_value.ident) {
        case CSS_VAL_AUTO:
            return IR_AUTO;
        case CSS_VAL_OPTIMIZESPEED:
            return IR_OPTIMIZESPEED;
        case CSS_VAL_OPTIMIZEQUALITY:
            return IR_OPTIMIZEQUALITY;
        default:
            ASSERT_NOT_REACHED();
            return IR_AUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case PE_NONE:
            m_value.ident = CSS_VAL_NONE;
            break;
        case PE_STROKE:
            m_value.ident = CSS_VAL_STROKE;
            break;
        case PE_FILL:
            m_value.ident = CSS_VAL_FILL;
            break;
        case PE_PAINTED:
            m_value.ident = CSS_VAL_PAINTED;
            break;
        case PE_VISIBLE:
            m_value.ident = CSS_VAL_VISIBLE;
            break;
        case PE_VISIBLE_STROKE:
            m_value.ident = CSS_VAL_VISIBLESTROKE;
            break;
        case PE_VISIBLE_FILL:
            m_value.ident = CSS_VAL_VISIBLEFILL;
            break;
        case PE_VISIBLE_PAINTED:
            m_value.ident = CSS_VAL_VISIBLEPAINTED;
            break;
        case PE_ALL:
            m_value.ident = CSS_VAL_ALL;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EPointerEvents() const
{
    switch (m_value.ident) {
        case CSS_VAL_ALL:
            return PE_ALL;
        case CSS_VAL_NONE:
            return PE_NONE;
        case CSS_VAL_VISIBLEPAINTED:
            return PE_VISIBLE_PAINTED;
        case CSS_VAL_VISIBLEFILL:
            return PE_VISIBLE_FILL;
        case CSS_VAL_VISIBLESTROKE:
            return PE_VISIBLE_STROKE;
        case CSS_VAL_VISIBLE:
            return PE_VISIBLE;
        case CSS_VAL_PAINTED:
            return PE_PAINTED;
        case CSS_VAL_FILL:
            return PE_FILL;
        case CSS_VAL_STROKE:
            return PE_STROKE;
        default:
            ASSERT_NOT_REACHED();
            return PE_ALL;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case IR_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case IR_OPTIMIZESPEED:
            m_value.ident = CSS_VAL_OPTIMIZESPEED;
            break;
        case SR_CRISPEDGES:
            m_value.ident = CSS_VAL_CRISPEDGES;
            break;
        case SR_GEOMETRICPRECISION:
            m_value.ident = CSS_VAL_GEOMETRICPRECISION;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EShapeRendering() const
{
    switch (m_value.ident) {
        case CSS_VAL_AUTO:
            return SR_AUTO;
        case CSS_VAL_OPTIMIZESPEED:
            return SR_OPTIMIZESPEED;
        case CSS_VAL_CRISPEDGES:
            return SR_CRISPEDGES;
        case CSS_VAL_GEOMETRICPRECISION:
            return SR_GEOMETRICPRECISION;
        default:
            ASSERT_NOT_REACHED();
            return SR_AUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case TA_START:
            m_value.ident = CSS_VAL_START;
            break;
        case TA_MIDDLE:
            m_value.ident = CSS_VAL_MIDDLE;
            break;
        case TA_END:
            m_value.ident = CSS_VAL_END;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ETextAnchor() const
{
    switch (m_value.ident) {
        case CSS_VAL_START:
            return TA_START;
        case CSS_VAL_MIDDLE:
            return TA_MIDDLE;
        case CSS_VAL_END:
            return TA_END;
        default:
            ASSERT_NOT_REACHED();
            return TA_START;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextRendering e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case TR_AUTO:
            m_value.ident = CSS_VAL_AUTO;
            break;
        case TR_OPTIMIZESPEED:
            m_value.ident = CSS_VAL_OPTIMIZESPEED;
            break;
        case TR_OPTIMIZELEGIBILITY:
            m_value.ident = CSS_VAL_OPTIMIZELEGIBILITY;
            break;
        case TR_GEOMETRICPRECISION:
            m_value.ident = CSS_VAL_GEOMETRICPRECISION;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator ETextRendering() const
{
    switch (m_value.ident) {
        case CSS_VAL_AUTO:
            return TR_AUTO;
        case CSS_VAL_OPTIMIZESPEED:
            return TR_OPTIMIZESPEED;
        case CSS_VAL_OPTIMIZELEGIBILITY:
            return TR_OPTIMIZELEGIBILITY;
        case CSS_VAL_GEOMETRICPRECISION:
            return TR_GEOMETRICPRECISION;
        default:
            ASSERT_NOT_REACHED();
            return TR_AUTO;
    }
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWritingMode e)
    : m_type(CSS_IDENT)
{
    switch (e) {
        case WM_LRTB:
            m_value.ident = CSS_VAL_LR_TB;
            break;
        case WM_LR:
            m_value.ident = CSS_VAL_LR;
            break;
        case WM_RLTB:
            m_value.ident = CSS_VAL_RL_TB;
            break;
        case WM_RL:
            m_value.ident = CSS_VAL_RL;
            break;
        case WM_TBRL:
            m_value.ident = CSS_VAL_TB_RL;
            break;
        case WM_TB:
            m_value.ident = CSS_VAL_TB;
            break;
    }
}

template<> inline CSSPrimitiveValue::operator EWritingMode() const
{
    return static_cast<EWritingMode>(m_value.ident - CSS_VAL_LR_TB);
}

#endif

}

#endif
