1 /*

     2  * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.

     3  * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.

     4  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

     5  * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>

     6  * Copyright (C) Research In Motion Limited 2010. All rights reserved.

     7  *

     8  * Redistribution and use in source and binary forms, with or without

     9  * modification, are permitted provided that the following conditions

    10  * are met:

    11  * 

    12  * 1. Redistributions of source code must retain the above copyright

    13  *    notice, this list of conditions and the following disclaimer.

    14  * 2. Redistributions in binary form must reproduce the above copyright

    15  *    notice, this list of conditions and the following disclaimer in the

    16  *    documentation and/or other materials provided with the distribution.

    17  * 

    18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

    19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

    20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

    21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

    22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

    23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    28  */

    29 

    30 #ifndef CSSPrimitiveValueMappings_h

    31 #define CSSPrimitiveValueMappings_h

    32 

    33 #include "ColorSpace.h"

    34 #include "CSSPrimitiveValue.h"

    35 #include "CSSValueKeywords.h"

    36 #include "FontSmoothingMode.h"

    37 #include "GraphicsTypes.h"

    38 #include "Path.h"

    39 #include "SVGRenderStyleDefs.h"

    40 #include "TextDirection.h"

    41 #include "TextRenderingMode.h"

    42 #include "ThemeTypes.h"

    43 

    44 namespace WebCore {

    45 

    46 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)

    47     : m_type(CSS_IDENT)

    48     , m_hasCachedCSSText(false)

    49 {

    50     switch (e) {

    51         case BNONE:

    52             m_value.ident = CSSValueNone;

    53             break;

    54         case BHIDDEN:

    55             m_value.ident = CSSValueHidden;

    56             break;

    57         case INSET:

    58             m_value.ident = CSSValueInset;

    59             break;

    60         case GROOVE:

    61             m_value.ident = CSSValueGroove;

    62             break;

    63         case RIDGE:

    64             m_value.ident = CSSValueRidge;

    65             break;

    66         case OUTSET:

    67             m_value.ident = CSSValueOutset;

    68             break;

    69         case DOTTED:

    70             m_value.ident = CSSValueDotted;

    71             break;

    72         case DASHED:

    73             m_value.ident = CSSValueDashed;

    74             break;

    75         case SOLID:

    76             m_value.ident = CSSValueSolid;

    77             break;

    78         case DOUBLE:

    79             m_value.ident = CSSValueDouble;

    80             break;

    81     }

    82 }

    83 

    84 template<> inline CSSPrimitiveValue::operator EBorderStyle() const

    85 {

    86     return (EBorderStyle)(m_value.ident - CSSValueNone);

    87 }

    88 

    89 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)

    90     : m_type(CSS_IDENT)

    91     , m_hasCachedCSSText(false)

    92 {

    93     switch (e) {

    94         case CompositeClear:

    95             m_value.ident = CSSValueClear;

    96             break;

    97         case CompositeCopy:

    98             m_value.ident = CSSValueCopy;

    99             break;

   100         case CompositeSourceOver:

   101             m_value.ident = CSSValueSourceOver;

   102             break;

   103         case CompositeSourceIn:

   104             m_value.ident = CSSValueSourceIn;

   105             break;

   106         case CompositeSourceOut:

   107             m_value.ident = CSSValueSourceOut;

   108             break;

   109         case CompositeSourceAtop:

   110             m_value.ident = CSSValueSourceAtop;

   111             break;

   112         case CompositeDestinationOver:

   113             m_value.ident = CSSValueDestinationOver;

   114             break;

   115         case CompositeDestinationIn:

   116             m_value.ident = CSSValueDestinationIn;

   117             break;

   118         case CompositeDestinationOut:

   119             m_value.ident = CSSValueDestinationOut;

   120             break;

   121         case CompositeDestinationAtop:

   122             m_value.ident = CSSValueDestinationAtop;

   123             break;

   124         case CompositeXOR:

   125             m_value.ident = CSSValueXor;

   126             break;

   127         case CompositePlusDarker:

   128             m_value.ident = CSSValuePlusDarker;

   129             break;

   130         case CompositeHighlight:

   131             m_value.ident = CSSValueHighlight;

   132             break;

   133         case CompositePlusLighter:

   134             m_value.ident = CSSValuePlusLighter;

   135             break;

   136     }

   137 }

   138 

   139 template<> inline CSSPrimitiveValue::operator CompositeOperator() const

   140 {

   141     switch (m_value.ident) {

   142         case CSSValueClear:

   143             return CompositeClear;

   144         case CSSValueCopy:

   145             return CompositeCopy;

   146         case CSSValueSourceOver:

   147             return CompositeSourceOver;

   148         case CSSValueSourceIn:

   149             return CompositeSourceIn;

   150         case CSSValueSourceOut:

   151             return CompositeSourceOut;

   152         case CSSValueSourceAtop:

   153             return CompositeSourceAtop;

   154         case CSSValueDestinationOver:

   155             return CompositeDestinationOver;

   156         case CSSValueDestinationIn:

   157             return CompositeDestinationIn;

   158         case CSSValueDestinationOut:

   159             return CompositeDestinationOut;

   160         case CSSValueDestinationAtop:

   161             return CompositeDestinationAtop;

   162         case CSSValueXor:

   163             return CompositeXOR;

   164         case CSSValuePlusDarker:

   165             return CompositePlusDarker;

   166         case CSSValueHighlight:

   167             return CompositeHighlight;

   168         case CSSValuePlusLighter:

   169             return CompositePlusLighter;

   170         default:

   171             ASSERT_NOT_REACHED();

   172             return CompositeClear;

   173     }

   174 }

   175 

   176 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)

   177     : m_type(CSS_IDENT)

   178     , m_hasCachedCSSText(false)

   179 {

   180     switch (e) {

   181         case NoControlPart:

   182             m_value.ident = CSSValueNone;

   183             break;

   184         case CheckboxPart:

   185             m_value.ident = CSSValueCheckbox;

   186             break;

   187         case RadioPart:

   188             m_value.ident = CSSValueRadio;

   189             break;

   190         case PushButtonPart:

   191             m_value.ident = CSSValuePushButton;

   192             break;

   193         case SquareButtonPart:

   194             m_value.ident = CSSValueSquareButton;

   195             break;

   196         case ButtonPart:

   197             m_value.ident = CSSValueButton;

   198             break;

   199         case ButtonBevelPart:

   200             m_value.ident = CSSValueButtonBevel;

   201             break;

   202         case DefaultButtonPart:

   203             m_value.ident = CSSValueDefaultButton;

   204             break;

   205         case InnerSpinButtonPart:

   206             m_value.ident = CSSValueInnerSpinButton;

   207             break;

   208         case ListboxPart:

   209             m_value.ident = CSSValueListbox;

   210             break;

   211         case ListButtonPart:

   212 #if ENABLE(DATALIST)

   213             m_value.ident = CSSValueListButton;

   214 #endif

   215             break;

   216         case ListItemPart:

   217             m_value.ident = CSSValueListitem;

   218             break;

   219         case MediaFullscreenButtonPart:

   220             m_value.ident = CSSValueMediaFullscreenButton;

   221             break;

   222         case MediaPlayButtonPart:

   223             m_value.ident = CSSValueMediaPlayButton;

   224             break;

   225         case MediaMuteButtonPart:

   226             m_value.ident = CSSValueMediaMuteButton;

   227             break;

   228         case MediaSeekBackButtonPart:

   229             m_value.ident = CSSValueMediaSeekBackButton;

   230             break;

   231         case MediaSeekForwardButtonPart:

   232             m_value.ident = CSSValueMediaSeekForwardButton;

   233             break;

   234         case MediaRewindButtonPart:

   235             m_value.ident = CSSValueMediaRewindButton;

   236             break;

   237         case MediaReturnToRealtimeButtonPart:

   238             m_value.ident = CSSValueMediaReturnToRealtimeButton;

   239             break;

   240         case MediaToggleClosedCaptionsButtonPart:

   241             m_value.ident = CSSValueMediaToggleClosedCaptionsButton;

   242             break;

   243         case MediaSliderPart:

   244             m_value.ident = CSSValueMediaSlider;

   245             break;

   246         case MediaSliderThumbPart:

   247             m_value.ident = CSSValueMediaSliderthumb;

   248             break;

   249         case MediaVolumeSliderContainerPart:

   250             m_value.ident = CSSValueMediaVolumeSliderContainer;

   251             break;

   252         case MediaVolumeSliderPart:

   253             m_value.ident = CSSValueMediaVolumeSlider;

   254             break;

   255         case MediaVolumeSliderMuteButtonPart:

   256             m_value.ident = CSSValueMediaVolumeSliderMuteButton;

   257             break;

   258         case MediaVolumeSliderThumbPart:

   259             m_value.ident = CSSValueMediaVolumeSliderthumb;

   260             break;

   261         case MediaControlsBackgroundPart:

   262             m_value.ident = CSSValueMediaControlsBackground;

   263             break;

   264         case MediaCurrentTimePart:

   265             m_value.ident = CSSValueMediaCurrentTimeDisplay;

   266             break;

   267         case MediaTimeRemainingPart:

   268             m_value.ident = CSSValueMediaTimeRemainingDisplay;

   269             break;

   270         case MenulistPart:

   271             m_value.ident = CSSValueMenulist;

   272             break;

   273         case MenulistButtonPart:

   274             m_value.ident = CSSValueMenulistButton;

   275             break;

   276         case MenulistTextPart:

   277             m_value.ident = CSSValueMenulistText;

   278             break;

   279         case MenulistTextFieldPart:

   280             m_value.ident = CSSValueMenulistTextfield;

   281             break;

   282         case MeterPart:

   283             m_value.ident = CSSValueMeter;

   284             break;

   285         case RelevancyLevelIndicatorPart:

   286             m_value.ident = CSSValueRelevancyLevelIndicator;

   287             break;

   288         case ContinuousCapacityLevelIndicatorPart:

   289             m_value.ident = CSSValueContinuousCapacityLevelIndicator;

   290             break;

   291         case DiscreteCapacityLevelIndicatorPart:

   292             m_value.ident = CSSValueDiscreteCapacityLevelIndicator;

   293             break;

   294         case RatingLevelIndicatorPart:

   295             m_value.ident = CSSValueRatingLevelIndicator;

   296             break;

   297         case OuterSpinButtonPart:

   298             m_value.ident = CSSValueOuterSpinButton;

   299             break;

   300         case ProgressBarPart:

   301 #if ENABLE(PROGRESS_TAG)

   302             m_value.ident = CSSValueProgressBar;

   303 #endif

   304             break;

   305         case ProgressBarValuePart:

   306 #if ENABLE(PROGRESS_TAG)

   307             m_value.ident = CSSValueProgressBarValue;

   308 #endif

   309             break;

   310         case SliderHorizontalPart:

   311             m_value.ident = CSSValueSliderHorizontal;

   312             break;

   313         case SliderVerticalPart:

   314             m_value.ident = CSSValueSliderVertical;

   315             break;

   316         case SliderThumbHorizontalPart:

   317             m_value.ident = CSSValueSliderthumbHorizontal;

   318             break;

   319         case SliderThumbVerticalPart:

   320             m_value.ident = CSSValueSliderthumbVertical;

   321             break;

   322         case CaretPart:

   323             m_value.ident = CSSValueCaret;

   324             break;

   325         case SearchFieldPart:

   326             m_value.ident = CSSValueSearchfield;

   327             break;

   328         case SearchFieldDecorationPart:

   329             m_value.ident = CSSValueSearchfieldDecoration;

   330             break;

   331         case SearchFieldResultsDecorationPart:

   332             m_value.ident = CSSValueSearchfieldResultsDecoration;

   333             break;

   334         case SearchFieldResultsButtonPart:

   335             m_value.ident = CSSValueSearchfieldResultsButton;

   336             break;

   337         case SearchFieldCancelButtonPart:

   338             m_value.ident = CSSValueSearchfieldCancelButton;

   339             break;

   340         case TextFieldPart:

   341             m_value.ident = CSSValueTextfield;

   342             break;

   343         case TextAreaPart:

   344             m_value.ident = CSSValueTextarea;

   345             break;

   346         case CapsLockIndicatorPart:

   347             m_value.ident = CSSValueCapsLockIndicator;

   348             break;

   349         case InputSpeechButtonPart:

   350 #if ENABLE(INPUT_SPEECH)

   351             m_value.ident = CSSValueInputSpeechButton;

   352 #endif

   353             break;

   354     }

   355 }

   356 

   357 template<> inline CSSPrimitiveValue::operator ControlPart() const

   358 {

   359     if (m_value.ident == CSSValueNone)

   360         return NoControlPart;

   361     else

   362         return ControlPart(m_value.ident - CSSValueCheckbox + 1);

   363 }

   364 

   365 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)

   366     : m_type(CSS_IDENT)

   367     , m_hasCachedCSSText(false)

   368 {

   369     switch (e) {

   370         case ScrollBackgroundAttachment:

   371             m_value.ident = CSSValueScroll;

   372             break;

   373         case LocalBackgroundAttachment:

   374             m_value.ident = CSSValueLocal;

   375             break;

   376         case FixedBackgroundAttachment:

   377             m_value.ident = CSSValueFixed;

   378             break;

   379     }

   380 }

   381 

   382 template<> inline CSSPrimitiveValue::operator EFillAttachment() const

   383 {

   384     switch (m_value.ident) {

   385         case CSSValueScroll:

   386             return ScrollBackgroundAttachment;

   387         case CSSValueLocal:

   388             return LocalBackgroundAttachment;

   389         case CSSValueFixed:

   390             return FixedBackgroundAttachment;

   391         default:

   392             ASSERT_NOT_REACHED();

   393             return ScrollBackgroundAttachment;

   394     }

   395 }

   396 

   397 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)

   398     : m_type(CSS_IDENT)

   399     , m_hasCachedCSSText(false)

   400 {

   401     switch (e) {

   402         case BorderFillBox:

   403             m_value.ident = CSSValueBorderBox;

   404             break;

   405         case PaddingFillBox:

   406             m_value.ident = CSSValuePaddingBox;

   407             break;

   408         case ContentFillBox:

   409             m_value.ident = CSSValueContentBox;

   410             break;

   411         case TextFillBox:

   412             m_value.ident = CSSValueText;

   413             break;

   414     }

   415 }

   416 

   417 template<> inline CSSPrimitiveValue::operator EFillBox() const

   418 {

   419     switch (m_value.ident) {

   420         case CSSValueBorder:

   421         case CSSValueBorderBox:

   422             return BorderFillBox;

   423         case CSSValuePadding:

   424         case CSSValuePaddingBox:

   425             return PaddingFillBox;

   426         case CSSValueContent:

   427         case CSSValueContentBox:

   428             return ContentFillBox;

   429         case CSSValueText:

   430         case CSSValueWebkitText:

   431             return TextFillBox;

   432         default:

   433             ASSERT_NOT_REACHED();

   434             return BorderFillBox;

   435     }

   436 }

   437 

   438 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)

   439     : m_type(CSS_IDENT)

   440     , m_hasCachedCSSText(false)

   441 {

   442     switch (e) {

   443         case RepeatFill:

   444             m_value.ident = CSSValueRepeat;

   445             break;

   446         case NoRepeatFill:

   447             m_value.ident = CSSValueNoRepeat;

   448             break;

   449         case RoundFill:

   450             m_value.ident = CSSValueRound;

   451             break;

   452         case SpaceFill:

   453             m_value.ident = CSSValueSpace;

   454             break;

   455     }

   456 }

   457 

   458 template<> inline CSSPrimitiveValue::operator EFillRepeat() const

   459 {

   460     switch (m_value.ident) {

   461         case CSSValueRepeat:

   462             return RepeatFill;

   463         case CSSValueNoRepeat:

   464             return NoRepeatFill;

   465         case CSSValueRound:

   466             return RoundFill;

   467         case CSSValueSpace:

   468             return SpaceFill;

   469         default:

   470             ASSERT_NOT_REACHED();

   471             return RepeatFill;

   472     }

   473 }

   474 

   475 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)

   476     : m_type(CSS_IDENT)

   477     , m_hasCachedCSSText(false)

   478 {

   479     switch (e) {

   480         case BSTRETCH:

   481             m_value.ident = CSSValueStretch;

   482             break;

   483         case BSTART:

   484             m_value.ident = CSSValueStart;

   485             break;

   486         case BCENTER:

   487             m_value.ident = CSSValueCenter;

   488             break;

   489         case BEND:

   490             m_value.ident = CSSValueEnd;

   491             break;

   492         case BBASELINE:

   493             m_value.ident = CSSValueBaseline;

   494             break;

   495         case BJUSTIFY:

   496             m_value.ident = CSSValueJustify;

   497             break;

   498     }

   499 }

   500 

   501 template<> inline CSSPrimitiveValue::operator EBoxAlignment() const

   502 {

   503     switch (m_value.ident) {

   504         case CSSValueStretch:

   505             return BSTRETCH;

   506         case CSSValueStart:

   507             return BSTART;

   508         case CSSValueEnd:

   509             return BEND;

   510         case CSSValueCenter:

   511             return BCENTER;

   512         case CSSValueBaseline:

   513             return BBASELINE;

   514         case CSSValueJustify:

   515             return BJUSTIFY;

   516         default:

   517             ASSERT_NOT_REACHED();

   518             return BSTRETCH;

   519     }

   520 }

   521 

   522 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)

   523     : m_type(CSS_IDENT)

   524     , m_hasCachedCSSText(false)

   525 {

   526     switch (e) {

   527         case BNORMAL:

   528             m_value.ident = CSSValueNormal;

   529             break;

   530         case BREVERSE:

   531             m_value.ident = CSSValueReverse;

   532             break;

   533     }

   534 }

   535 

   536 template<> inline CSSPrimitiveValue::operator EBoxDirection() const

   537 {

   538     switch (m_value.ident) {

   539         case CSSValueNormal:

   540             return BNORMAL;

   541         case CSSValueReverse:

   542             return BREVERSE;

   543         default:

   544             ASSERT_NOT_REACHED();

   545             return BNORMAL;

   546     }

   547 }

   548 

   549 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)

   550     : m_type(CSS_IDENT)

   551     , m_hasCachedCSSText(false)

   552 {

   553     switch (e) {

   554         case SINGLE:

   555             m_value.ident = CSSValueSingle;

   556             break;

   557         case MULTIPLE:

   558             m_value.ident = CSSValueMultiple;

   559             break;

   560     }

   561 }

   562 

   563 template<> inline CSSPrimitiveValue::operator EBoxLines() const

   564 {

   565     switch (m_value.ident) {

   566         case CSSValueSingle:

   567             return SINGLE;

   568         case CSSValueMultiple:

   569             return MULTIPLE;

   570         default:

   571             ASSERT_NOT_REACHED();

   572             return SINGLE;

   573     }

   574 }

   575 

   576 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)

   577     : m_type(CSS_IDENT)

   578     , m_hasCachedCSSText(false)

   579 {

   580     switch (e) {

   581         case HORIZONTAL:

   582             m_value.ident = CSSValueHorizontal;

   583             break;

   584         case VERTICAL:

   585             m_value.ident = CSSValueVertical;

   586             break;

   587     }

   588 }

   589 

   590 template<> inline CSSPrimitiveValue::operator EBoxOrient() const

   591 {

   592     switch (m_value.ident) {

   593         case CSSValueHorizontal:

   594         case CSSValueInlineAxis:

   595             return HORIZONTAL;

   596         case CSSValueVertical:

   597         case CSSValueBlockAxis:

   598             return VERTICAL;

   599         default:

   600             ASSERT_NOT_REACHED();

   601             return HORIZONTAL;

   602     }

   603 }

   604 

   605 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)

   606     : m_type(CSS_IDENT)

   607     , m_hasCachedCSSText(false)

   608 {

   609     switch (e) {

   610         case CAPLEFT:

   611             m_value.ident = CSSValueLeft;

   612             break;

   613         case CAPRIGHT:

   614             m_value.ident = CSSValueRight;

   615             break;

   616         case CAPTOP:

   617             m_value.ident = CSSValueTop;

   618             break;

   619         case CAPBOTTOM:

   620             m_value.ident = CSSValueBottom;

   621             break;

   622     }

   623 }

   624 

   625 template<> inline CSSPrimitiveValue::operator ECaptionSide() const

   626 {

   627     switch (m_value.ident) {

   628         case CSSValueLeft:

   629             return CAPLEFT;

   630         case CSSValueRight:

   631             return CAPRIGHT;

   632         case CSSValueTop:

   633             return CAPTOP;

   634         case CSSValueBottom:

   635             return CAPBOTTOM;

   636         default:

   637             ASSERT_NOT_REACHED();

   638             return CAPTOP;

   639     }

   640 }

   641 

   642 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)

   643     : m_type(CSS_IDENT)

   644     , m_hasCachedCSSText(false)

   645 {

   646     switch (e) {

   647         case CNONE:

   648             m_value.ident = CSSValueNone;

   649             break;

   650         case CLEFT:

   651             m_value.ident = CSSValueLeft;

   652             break;

   653         case CRIGHT:

   654             m_value.ident = CSSValueRight;

   655             break;

   656         case CBOTH:

   657             m_value.ident = CSSValueBoth;

   658             break;

   659     }

   660 }

   661 

   662 template<> inline CSSPrimitiveValue::operator EClear() const

   663 {

   664     switch (m_value.ident) {

   665         case CSSValueNone:

   666             return CNONE;

   667         case CSSValueLeft:

   668             return CLEFT;

   669         case CSSValueRight:

   670             return CRIGHT;

   671         case CSSValueBoth:

   672             return CBOTH;

   673         default:

   674             ASSERT_NOT_REACHED();

   675             return CNONE;

   676     }

   677 }

   678 

   679 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)

   680     : m_type(CSS_IDENT)

   681     , m_hasCachedCSSText(false)

   682 {

   683     switch (e) {

   684         case CURSOR_AUTO:

   685             m_value.ident = CSSValueAuto;

   686             break;

   687         case CURSOR_CROSS:

   688             m_value.ident = CSSValueCrosshair;

   689             break;

   690         case CURSOR_DEFAULT:

   691             m_value.ident = CSSValueDefault;

   692             break;

   693         case CURSOR_POINTER:

   694             m_value.ident = CSSValuePointer;

   695             break;

   696         case CURSOR_MOVE:

   697             m_value.ident = CSSValueMove;

   698             break;

   699         case CURSOR_CELL:

   700             m_value.ident = CSSValueCell;

   701             break;

   702         case CURSOR_VERTICAL_TEXT:

   703             m_value.ident = CSSValueVerticalText;

   704             break;

   705         case CURSOR_CONTEXT_MENU:

   706             m_value.ident = CSSValueContextMenu;

   707             break;

   708         case CURSOR_ALIAS:

   709             m_value.ident = CSSValueAlias;

   710             break;

   711         case CURSOR_COPY:

   712             m_value.ident = CSSValueCopy;

   713             break;

   714         case CURSOR_NONE:

   715             m_value.ident = CSSValueNone;

   716             break;

   717         case CURSOR_PROGRESS:

   718             m_value.ident = CSSValueProgress;

   719             break;

   720         case CURSOR_NO_DROP:

   721             m_value.ident = CSSValueNoDrop;

   722             break;

   723         case CURSOR_NOT_ALLOWED:

   724             m_value.ident = CSSValueNotAllowed;

   725             break;

   726         case CURSOR_WEBKIT_ZOOM_IN:

   727             m_value.ident = CSSValueWebkitZoomIn;

   728             break;

   729         case CURSOR_WEBKIT_ZOOM_OUT:

   730             m_value.ident = CSSValueWebkitZoomOut;

   731             break;

   732         case CURSOR_E_RESIZE:

   733             m_value.ident = CSSValueEResize;

   734             break;

   735         case CURSOR_NE_RESIZE:

   736             m_value.ident = CSSValueNeResize;

   737             break;

   738         case CURSOR_NW_RESIZE:

   739             m_value.ident = CSSValueNwResize;

   740             break;

   741         case CURSOR_N_RESIZE:

   742             m_value.ident = CSSValueNResize;

   743             break;

   744         case CURSOR_SE_RESIZE:

   745             m_value.ident = CSSValueSeResize;

   746             break;

   747         case CURSOR_SW_RESIZE:

   748             m_value.ident = CSSValueSwResize;

   749             break;

   750         case CURSOR_S_RESIZE:

   751             m_value.ident = CSSValueSResize;

   752             break;

   753         case CURSOR_W_RESIZE:

   754             m_value.ident = CSSValueWResize;

   755             break;

   756         case CURSOR_EW_RESIZE:

   757             m_value.ident = CSSValueEwResize;

   758             break;

   759         case CURSOR_NS_RESIZE:

   760             m_value.ident = CSSValueNsResize;

   761             break;

   762         case CURSOR_NESW_RESIZE:

   763             m_value.ident = CSSValueNeswResize;

   764             break;

   765         case CURSOR_NWSE_RESIZE:

   766             m_value.ident = CSSValueNwseResize;

   767             break;

   768         case CURSOR_COL_RESIZE:

   769             m_value.ident = CSSValueColResize;

   770             break;

   771         case CURSOR_ROW_RESIZE:

   772             m_value.ident = CSSValueRowResize;

   773             break;

   774         case CURSOR_TEXT:

   775             m_value.ident = CSSValueText;

   776             break;

   777         case CURSOR_WAIT:

   778             m_value.ident = CSSValueWait;

   779             break;

   780         case CURSOR_HELP:

   781             m_value.ident = CSSValueHelp;

   782             break;

   783         case CURSOR_ALL_SCROLL:

   784             m_value.ident = CSSValueAllScroll;

   785             break;

   786         case CURSOR_WEBKIT_GRAB:

   787             m_value.ident = CSSValueWebkitGrab;

   788             break;

   789         case CURSOR_WEBKIT_GRABBING:

   790             m_value.ident = CSSValueWebkitGrabbing;

   791             break;

   792     }

   793 }

   794 

   795 template<> inline CSSPrimitiveValue::operator ECursor() const

   796 {

   797     if (m_value.ident == CSSValueCopy)

   798         return CURSOR_COPY;

   799     if (m_value.ident == CSSValueNone)

   800         return CURSOR_NONE;

   801     return static_cast<ECursor>(m_value.ident - CSSValueAuto);

   802 }

   803 

   804 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)

   805     : m_type(CSS_IDENT)

   806     , m_hasCachedCSSText(false)

   807 {

   808     switch (e) {

   809         case INLINE:

   810             m_value.ident = CSSValueInline;

   811             break;

   812         case BLOCK:

   813             m_value.ident = CSSValueBlock;

   814             break;

   815         case LIST_ITEM:

   816             m_value.ident = CSSValueListItem;

   817             break;

   818         case RUN_IN:

   819             m_value.ident = CSSValueRunIn;

   820             break;

   821         case COMPACT:

   822             m_value.ident = CSSValueCompact;

   823             break;

   824         case INLINE_BLOCK:

   825             m_value.ident = CSSValueInlineBlock;

   826             break;

   827         case TABLE:

   828             m_value.ident = CSSValueTable;

   829             break;

   830         case INLINE_TABLE:

   831             m_value.ident = CSSValueInlineTable;

   832             break;

   833         case TABLE_ROW_GROUP:

   834             m_value.ident = CSSValueTableRowGroup;

   835             break;

   836         case TABLE_HEADER_GROUP:

   837             m_value.ident = CSSValueTableHeaderGroup;

   838             break;

   839         case TABLE_FOOTER_GROUP:

   840             m_value.ident = CSSValueTableFooterGroup;

   841             break;

   842         case TABLE_ROW:

   843             m_value.ident = CSSValueTableRow;

   844             break;

   845         case TABLE_COLUMN_GROUP:

   846             m_value.ident = CSSValueTableColumnGroup;

   847             break;

   848         case TABLE_COLUMN:

   849             m_value.ident = CSSValueTableColumn;

   850             break;

   851         case TABLE_CELL:

   852             m_value.ident = CSSValueTableCell;

   853             break;

   854         case TABLE_CAPTION:

   855             m_value.ident = CSSValueTableCaption;

   856             break;

   857 #if ENABLE(WCSS)

   858         case WAP_MARQUEE:

   859             m_value.ident = CSSValueWapMarquee;

   860             break;

   861 #endif

   862         case BOX:

   863             m_value.ident = CSSValueWebkitBox;

   864             break;

   865         case INLINE_BOX:

   866             m_value.ident = CSSValueWebkitInlineBox;

   867             break;

   868         case NONE:

   869             m_value.ident = CSSValueNone;

   870             break;

   871     }

   872 }

   873 

   874 template<> inline CSSPrimitiveValue::operator EDisplay() const

   875 {

   876     if (m_value.ident == CSSValueNone)

   877         return NONE;

   878     return static_cast<EDisplay>(m_value.ident - CSSValueInline);

   879 }

   880 

   881 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)

   882     : m_type(CSS_IDENT)

   883     , m_hasCachedCSSText(false)

   884 {

   885     switch (e) {

   886         case SHOW:

   887             m_value.ident = CSSValueShow;

   888             break;

   889         case HIDE:

   890             m_value.ident = CSSValueHide;

   891             break;

   892     }

   893 }

   894 

   895 template<> inline CSSPrimitiveValue::operator EEmptyCell() const

   896 {

   897     switch (m_value.ident) {

   898         case CSSValueShow:

   899             return SHOW;

   900         case CSSValueHide:

   901             return HIDE;

   902         default:

   903             ASSERT_NOT_REACHED();

   904             return SHOW;

   905     }

   906 }

   907 

   908 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)

   909     : m_type(CSS_IDENT)

   910     , m_hasCachedCSSText(false)

   911 {

   912     switch (e) {

   913         case FNONE:

   914             m_value.ident = CSSValueNone;

   915             break;

   916         case FLEFT:

   917             m_value.ident = CSSValueLeft;

   918             break;

   919         case FRIGHT:

   920             m_value.ident = CSSValueRight;

   921             break;

   922     }

   923 }

   924 

   925 template<> inline CSSPrimitiveValue::operator EFloat() const

   926 {

   927     switch (m_value.ident) {

   928         case CSSValueLeft:

   929             return FLEFT;

   930         case CSSValueRight:

   931             return FRIGHT;

   932         case CSSValueNone:

   933         case CSSValueCenter:  // Non-standard CSS value

   934             return FNONE;

   935         default:

   936             ASSERT_NOT_REACHED();

   937             return FNONE;

   938     }

   939 }

   940 

   941 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EKHTMLLineBreak e)

   942     : m_type(CSS_IDENT)

   943     , m_hasCachedCSSText(false)

   944 {

   945     switch (e) {

   946         case LBNORMAL:

   947             m_value.ident = CSSValueNormal;

   948             break;

   949         case AFTER_WHITE_SPACE:

   950             m_value.ident = CSSValueAfterWhiteSpace;

   951             break;

   952     }

   953 }

   954 

   955 template<> inline CSSPrimitiveValue::operator EKHTMLLineBreak() const

   956 {

   957     switch (m_value.ident) {

   958         case CSSValueAfterWhiteSpace:

   959             return AFTER_WHITE_SPACE;

   960         case CSSValueNormal:

   961             return LBNORMAL;

   962         default:

   963             ASSERT_NOT_REACHED();

   964             return LBNORMAL;

   965     }

   966 }

   967 

   968 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)

   969     : m_type(CSS_IDENT)

   970     , m_hasCachedCSSText(false)

   971 {

   972     switch (e) {

   973         case OUTSIDE:

   974             m_value.ident = CSSValueOutside;

   975             break;

   976         case INSIDE:

   977             m_value.ident = CSSValueInside;

   978             break;

   979     }

   980 }

   981 

   982 template<> inline CSSPrimitiveValue::operator EListStylePosition() const

   983 {

   984     return (EListStylePosition)(m_value.ident - CSSValueOutside);

   985 }

   986 

   987 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)

   988     : m_type(CSS_IDENT)

   989     , m_hasCachedCSSText(false)

   990 {

   991     switch (e) {

   992     case Afar:

   993         m_value.ident = CSSValueAfar;

   994         break;

   995     case Amharic:

   996         m_value.ident = CSSValueAmharic;

   997         break;

   998     case AmharicAbegede:

   999         m_value.ident = CSSValueAmharicAbegede;

  1000         break;

  1001     case ArabicIndic:

  1002         m_value.ident = CSSValueArabicIndic;

  1003         break;

  1004     case Armenian:

  1005         m_value.ident = CSSValueArmenian;

  1006         break;

  1007     case BinaryListStyle:

  1008         m_value.ident = CSSValueBinary;

  1009         break;

  1010     case Bengali:

  1011         m_value.ident = CSSValueBengali;

  1012         break;

  1013     case Cambodian:

  1014         m_value.ident = CSSValueCambodian;

  1015         break;

  1016     case Circle:

  1017         m_value.ident = CSSValueCircle;

  1018         break;

  1019     case CjkEarthlyBranch:

  1020         m_value.ident = CSSValueCjkEarthlyBranch;

  1021         break;

  1022     case CjkHeavenlyStem:

  1023         m_value.ident = CSSValueCjkHeavenlyStem;

  1024         break;

  1025     case CJKIdeographic:

  1026         m_value.ident = CSSValueCjkIdeographic;

  1027         break;

  1028     case DecimalLeadingZero:

  1029         m_value.ident = CSSValueDecimalLeadingZero;

  1030         break;

  1031     case DecimalListStyle:

  1032         m_value.ident = CSSValueDecimal;

  1033         break;

  1034     case Devanagari:

  1035         m_value.ident = CSSValueDevanagari;

  1036         break;

  1037     case Disc:

  1038         m_value.ident = CSSValueDisc;

  1039         break;

  1040     case Ethiopic:

  1041         m_value.ident = CSSValueEthiopic;

  1042         break;

  1043     case EthiopicAbegede:

  1044         m_value.ident = CSSValueEthiopicAbegede;

  1045         break;

  1046     case EthiopicAbegedeAmEt:

  1047         m_value.ident = CSSValueEthiopicAbegedeAmEt;

  1048         break;

  1049     case EthiopicAbegedeGez:

  1050         m_value.ident = CSSValueEthiopicAbegedeGez;

  1051         break;

  1052     case EthiopicAbegedeTiEr:

  1053         m_value.ident = CSSValueEthiopicAbegedeTiEr;

  1054         break;

  1055     case EthiopicAbegedeTiEt:

  1056         m_value.ident = CSSValueEthiopicAbegedeTiEt;

  1057         break;

  1058     case EthiopicHalehameAaEr:

  1059         m_value.ident = CSSValueEthiopicHalehameAaEr;

  1060         break;

  1061     case EthiopicHalehameAaEt:

  1062         m_value.ident = CSSValueEthiopicHalehameAaEt;

  1063         break;

  1064     case EthiopicHalehameAmEt:

  1065         m_value.ident = CSSValueEthiopicHalehameAmEt;

  1066         break;

  1067     case EthiopicHalehameGez:

  1068         m_value.ident = CSSValueEthiopicHalehameGez;

  1069         break;

  1070     case EthiopicHalehameOmEt:

  1071         m_value.ident = CSSValueEthiopicHalehameOmEt;

  1072         break;

  1073     case EthiopicHalehameSidEt:

  1074         m_value.ident = CSSValueEthiopicHalehameSidEt;

  1075         break;

  1076     case EthiopicHalehameSoEt:

  1077         m_value.ident = CSSValueEthiopicHalehameSoEt;

  1078         break;

  1079     case EthiopicHalehameTiEr:

  1080         m_value.ident = CSSValueEthiopicHalehameTiEr;

  1081         break;

  1082     case EthiopicHalehameTiEt:

  1083         m_value.ident = CSSValueEthiopicHalehameTiEt;

  1084         break;

  1085     case EthiopicHalehameTig:

  1086         m_value.ident = CSSValueEthiopicHalehameTig;

  1087         break;

  1088     case Georgian:

  1089         m_value.ident = CSSValueGeorgian;

  1090         break;

  1091     case Gujarati:

  1092         m_value.ident = CSSValueGujarati;

  1093         break;

  1094     case Gurmukhi:

  1095         m_value.ident = CSSValueGurmukhi;

  1096         break;

  1097     case Hangul:

  1098         m_value.ident = CSSValueHangul;

  1099         break;

  1100     case HangulConsonant:

  1101         m_value.ident = CSSValueHangulConsonant;

  1102         break;

  1103     case Hebrew:

  1104         m_value.ident = CSSValueHebrew;

  1105         break;

  1106     case Hiragana:

  1107         m_value.ident = CSSValueHiragana;

  1108         break;

  1109     case HiraganaIroha:

  1110         m_value.ident = CSSValueHiraganaIroha;

  1111         break;

  1112     case Kannada:

  1113         m_value.ident = CSSValueKannada;

  1114         break;

  1115     case Katakana:

  1116         m_value.ident = CSSValueKatakana;

  1117         break;

  1118     case KatakanaIroha:

  1119         m_value.ident = CSSValueKatakanaIroha;

  1120         break;

  1121     case Khmer:

  1122         m_value.ident = CSSValueKhmer;

  1123         break;

  1124     case Lao:

  1125         m_value.ident = CSSValueLao;

  1126         break;

  1127     case LowerAlpha:

  1128         m_value.ident = CSSValueLowerAlpha;

  1129         break;

  1130     case LowerGreek:

  1131         m_value.ident = CSSValueLowerGreek;

  1132         break;

  1133     case LowerHexadecimal:

  1134         m_value.ident = CSSValueLowerHexadecimal;