Source/WebCore/css/CSSPrimitiveValueMappings.h

   1 /*
   2  * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.
   3  * Copyright (C) 2008, 2009, 2010, 2011 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 "FontDescription.h"
  37 #include "FontSmoothingMode.h"
  38 #include "GraphicsTypes.h"
  39 #include "Path.h"
  40 #include "RenderStyleConstants.h"
  41 #include "SVGRenderStyleDefs.h"
  42 #include "TextDirection.h"
  43 #include "TextOrientation.h"
  44 #include "TextRenderingMode.h"
  45 #include "ThemeTypes.h"
  46 #include "UnicodeBidi.h"
  47
  48 #if ENABLE(CSS_SHADERS)
  49 #include "CustomFilterOperation.h"
  50 #endif
  51
  52 #include <wtf/MathExtras.h>
  53
  54 namespace WebCore {
  55
  56 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(short i)
  57     : CSSValue(PrimitiveClass)
  58 {
  59     m_primitiveUnitType = CSS_NUMBER;
  60     m_value.num = static_cast<double>(i);
  61 }
  62
  63 template<> inline CSSPrimitiveValue::operator short() const
  64 {
  65     if (m_primitiveUnitType == CSS_NUMBER)
  66         return clampTo<short>(m_value.num);
  67
  68     ASSERT_NOT_REACHED();
  69     return 0;
  70 }
  71
  72 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned short i)
  73     : CSSValue(PrimitiveClass)
  74 {
  75     m_primitiveUnitType = CSS_NUMBER;
  76     m_value.num = static_cast<double>(i);
  77 }
  78
  79 template<> inline CSSPrimitiveValue::operator unsigned short() const
  80 {
  81     if (m_primitiveUnitType == CSS_NUMBER)
  82         return clampTo<unsigned short>(m_value.num);
  83
  84     ASSERT_NOT_REACHED();
  85     return 0;
  86 }
  87
  88 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(int i)
  89     : CSSValue(PrimitiveClass)
  90 {
  91     m_primitiveUnitType = CSS_NUMBER;
  92     m_value.num = static_cast<double>(i);
  93 }
  94
  95 template<> inline CSSPrimitiveValue::operator int() const
  96 {
  97     if (m_primitiveUnitType == CSS_NUMBER)
  98         return clampTo<int>(m_value.num);
  99
 100     ASSERT_NOT_REACHED();
 101     return 0;
 102 }
 103
 104 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned i)
 105     : CSSValue(PrimitiveClass)
 106 {
 107     m_primitiveUnitType = CSS_NUMBER;
 108     m_value.num = static_cast<double>(i);
 109 }
 110
 111 template<> inline CSSPrimitiveValue::operator unsigned() const
 112 {
 113     if (m_primitiveUnitType == CSS_NUMBER)
 114         return clampTo<unsigned>(m_value.num);
 115
 116     ASSERT_NOT_REACHED();
 117     return 0;
 118 }
 119
 120
 121 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(float i)
 122     : CSSValue(PrimitiveClass)
 123 {
 124     m_primitiveUnitType = CSS_NUMBER;
 125     m_value.num = static_cast<double>(i);
 126 }
 127
 128 template<> inline CSSPrimitiveValue::operator float() const
 129 {
 130     if (m_primitiveUnitType == CSS_NUMBER)
 131         return clampTo<float>(m_value.num);
 132
 133     ASSERT_NOT_REACHED();
 134     return 0.0f;
 135 }
 136
 137 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
 138     : CSSValue(PrimitiveClass)
 139 {
 140     switch (columnSpan) {
 141     case ColumnSpanAll:
 142         m_primitiveUnitType = CSS_IDENT;
 143         m_value.ident = CSSValueAll;
 144         break;
 145     case ColumnSpanOne:
 146         m_primitiveUnitType = CSS_NUMBER;
 147         m_value.num = 1;
 148         break;
 149     }
 150 }
 151
 152 template<> inline CSSPrimitiveValue::operator ColumnSpan() const
 153 {
 154     if (m_primitiveUnitType == CSS_IDENT && m_value.ident == CSSValueAll)
 155         return ColumnSpanAll;
 156     if (m_primitiveUnitType == CSS_NUMBER && m_value.num == 1)
 157         return ColumnSpanOne;
 158     ASSERT_NOT_REACHED();
 159     return ColumnSpanOne;
 160 }
 161
 162
 163 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
 164     : CSSValue(PrimitiveClass)
 165 {
 166     m_primitiveUnitType = CSS_IDENT;
 167     switch (value) {
 168     case PrintColorAdjustExact:
 169         m_value.ident = CSSValueExact;
 170         break;
 171     case PrintColorAdjustEconomy:
 172         m_value.ident = CSSValueEconomy;
 173         break;
 174     }
 175 }
 176
 177 template<> inline CSSPrimitiveValue::operator PrintColorAdjust() const
 178 {
 179     switch (m_value.ident) {
 180     case CSSValueEconomy:
 181         return PrintColorAdjustEconomy;
 182     case CSSValueExact:
 183         return PrintColorAdjustExact;
 184     default:
 185         ASSERT_NOT_REACHED();
 186         return PrintColorAdjustEconomy;
 187     }
 188 }
 189
 190
 191 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
 192     : CSSValue(PrimitiveClass)
 193 {
 194     m_primitiveUnitType = CSS_IDENT;
 195     switch (e) {
 196         case BNONE:
 197             m_value.ident = CSSValueNone;
 198             break;
 199         case BHIDDEN:
 200             m_value.ident = CSSValueHidden;
 201             break;
 202         case INSET:
 203             m_value.ident = CSSValueInset;
 204             break;
 205         case GROOVE:
 206             m_value.ident = CSSValueGroove;
 207             break;
 208         case RIDGE:
 209             m_value.ident = CSSValueRidge;
 210             break;
 211         case OUTSET:
 212             m_value.ident = CSSValueOutset;
 213             break;
 214         case DOTTED:
 215             m_value.ident = CSSValueDotted;
 216             break;
 217         case DASHED:
 218             m_value.ident = CSSValueDashed;
 219             break;
 220         case SOLID:
 221             m_value.ident = CSSValueSolid;
 222             break;
 223         case DOUBLE:
 224             m_value.ident = CSSValueDouble;
 225             break;
 226     }
 227 }
 228
 229 template<> inline CSSPrimitiveValue::operator EBorderStyle() const
 230 {
 231     if (m_value.ident == CSSValueAuto) // Valid for CSS outline-style
 232         return DOTTED;
 233     return (EBorderStyle)(m_value.ident - CSSValueNone);
 234 }
 235
 236 template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
 237 {
 238     if (m_value.ident == CSSValueAuto)
 239         return AUTO_ON;
 240     return AUTO_OFF;
 241 }
 242
 243 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
 244     : CSSValue(PrimitiveClass)
 245 {
 246     m_primitiveUnitType = CSS_IDENT;
 247     switch (e) {
 248         case CompositeClear:
 249             m_value.ident = CSSValueClear;
 250             break;
 251         case CompositeCopy:
 252             m_value.ident = CSSValueCopy;
 253             break;
 254         case CompositeSourceOver:
 255             m_value.ident = CSSValueSourceOver;
 256             break;
 257         case CompositeSourceIn:
 258             m_value.ident = CSSValueSourceIn;
 259             break;
 260         case CompositeSourceOut:
 261             m_value.ident = CSSValueSourceOut;
 262             break;
 263         case CompositeSourceAtop:
 264             m_value.ident = CSSValueSourceAtop;
 265             break;
 266         case CompositeDestinationOver:
 267             m_value.ident = CSSValueDestinationOver;
 268             break;
 269         case CompositeDestinationIn:
 270             m_value.ident = CSSValueDestinationIn;
 271             break;
 272         case CompositeDestinationOut:
 273             m_value.ident = CSSValueDestinationOut;
 274             break;
 275         case CompositeDestinationAtop:
 276             m_value.ident = CSSValueDestinationAtop;
 277             break;
 278         case CompositeXOR:
 279             m_value.ident = CSSValueXor;
 280             break;
 281         case CompositePlusDarker:
 282             m_value.ident = CSSValuePlusDarker;
 283             break;
 284         case CompositePlusLighter:
 285             m_value.ident = CSSValuePlusLighter;
 286             break;
 287     }
 288 }
 289
 290 template<> inline CSSPrimitiveValue::operator CompositeOperator() const
 291 {
 292     switch (m_value.ident) {
 293         case CSSValueClear:
 294             return CompositeClear;
 295         case CSSValueCopy:
 296             return CompositeCopy;
 297         case CSSValueSourceOver:
 298             return CompositeSourceOver;
 299         case CSSValueSourceIn:
 300             return CompositeSourceIn;
 301         case CSSValueSourceOut:
 302             return CompositeSourceOut;
 303         case CSSValueSourceAtop:
 304             return CompositeSourceAtop;
 305         case CSSValueDestinationOver:
 306             return CompositeDestinationOver;
 307         case CSSValueDestinationIn:
 308             return CompositeDestinationIn;
 309         case CSSValueDestinationOut:
 310             return CompositeDestinationOut;
 311         case CSSValueDestinationAtop:
 312             return CompositeDestinationAtop;
 313         case CSSValueXor:
 314             return CompositeXOR;
 315         case CSSValuePlusDarker:
 316             return CompositePlusDarker;
 317         case CSSValuePlusLighter:
 318             return CompositePlusLighter;
 319         default:
 320             ASSERT_NOT_REACHED();
 321             return CompositeClear;
 322     }
 323 }
 324
 325 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
 326     : CSSValue(PrimitiveClass)
 327 {
 328     m_primitiveUnitType = CSS_IDENT;
 329     switch (e) {
 330         case NoControlPart:
 331             m_value.ident = CSSValueNone;
 332             break;
 333         case CheckboxPart:
 334             m_value.ident = CSSValueCheckbox;
 335             break;
 336         case RadioPart:
 337             m_value.ident = CSSValueRadio;
 338             break;
 339         case PushButtonPart:
 340             m_value.ident = CSSValuePushButton;
 341             break;
 342         case SquareButtonPart:
 343             m_value.ident = CSSValueSquareButton;
 344             break;
 345         case ButtonPart:
 346             m_value.ident = CSSValueButton;
 347             break;
 348         case ButtonBevelPart:
 349             m_value.ident = CSSValueButtonBevel;
 350             break;
 351         case DefaultButtonPart:
 352             m_value.ident = CSSValueDefaultButton;
 353             break;
 354         case InnerSpinButtonPart:
 355             m_value.ident = CSSValueInnerSpinButton;
 356             break;
 357         case ListboxPart:
 358             m_value.ident = CSSValueListbox;
 359             break;
 360         case ListButtonPart:
 361 #if ENABLE(DATALIST)
 362             m_value.ident = CSSValueListButton;
 363 #endif
 364             break;
 365         case ListItemPart:
 366             m_value.ident = CSSValueListitem;
 367             break;
 368         case MediaFullscreenButtonPart:
 369             m_value.ident = CSSValueMediaFullscreenButton;
 370             break;
 371         case MediaPlayButtonPart:
 372             m_value.ident = CSSValueMediaPlayButton;
 373             break;
 374         case MediaMuteButtonPart:
 375             m_value.ident = CSSValueMediaMuteButton;
 376             break;
 377         case MediaSeekBackButtonPart:
 378             m_value.ident = CSSValueMediaSeekBackButton;
 379             break;
 380         case MediaSeekForwardButtonPart:
 381             m_value.ident = CSSValueMediaSeekForwardButton;
 382             break;
 383         case MediaRewindButtonPart:
 384             m_value.ident = CSSValueMediaRewindButton;
 385             break;
 386         case MediaReturnToRealtimeButtonPart:
 387             m_value.ident = CSSValueMediaReturnToRealtimeButton;
 388             break;
 389         case MediaToggleClosedCaptionsButtonPart:
 390             m_value.ident = CSSValueMediaToggleClosedCaptionsButton;
 391             break;
 392         case MediaSliderPart:
 393             m_value.ident = CSSValueMediaSlider;
 394             break;
 395         case MediaSliderThumbPart:
 396             m_value.ident = CSSValueMediaSliderthumb;
 397             break;
 398         case MediaVolumeSliderContainerPart:
 399             m_value.ident = CSSValueMediaVolumeSliderContainer;
 400             break;
 401         case MediaVolumeSliderPart:
 402             m_value.ident = CSSValueMediaVolumeSlider;
 403             break;
 404         case MediaVolumeSliderMuteButtonPart:
 405             m_value.ident = CSSValueMediaVolumeSliderMuteButton;
 406             break;
 407         case MediaVolumeSliderThumbPart:
 408             m_value.ident = CSSValueMediaVolumeSliderthumb;
 409             break;
 410         case MediaControlsBackgroundPart:
 411             m_value.ident = CSSValueMediaControlsBackground;
 412             break;
 413         case MediaControlsFullscreenBackgroundPart:
 414             m_value.ident = CSSValueMediaControlsFullscreenBackground;
 415             break;
 416         case MediaCurrentTimePart:
 417             m_value.ident = CSSValueMediaCurrentTimeDisplay;
 418             break;
 419         case MediaTimeRemainingPart:
 420             m_value.ident = CSSValueMediaTimeRemainingDisplay;
 421             break;
 422         case MenulistPart:
 423             m_value.ident = CSSValueMenulist;
 424             break;
 425         case MenulistButtonPart:
 426             m_value.ident = CSSValueMenulistButton;
 427             break;
 428         case MenulistTextPart:
 429             m_value.ident = CSSValueMenulistText;
 430             break;
 431         case MenulistTextFieldPart:
 432             m_value.ident = CSSValueMenulistTextfield;
 433             break;
 434         case MeterPart:
 435             m_value.ident = CSSValueMeter;
 436             break;
 437         case RelevancyLevelIndicatorPart:
 438             m_value.ident = CSSValueRelevancyLevelIndicator;
 439             break;
 440         case ContinuousCapacityLevelIndicatorPart:
 441             m_value.ident = CSSValueContinuousCapacityLevelIndicator;
 442             break;
 443         case DiscreteCapacityLevelIndicatorPart:
 444             m_value.ident = CSSValueDiscreteCapacityLevelIndicator;
 445             break;
 446         case RatingLevelIndicatorPart:
 447             m_value.ident = CSSValueRatingLevelIndicator;
 448             break;
 449         case ProgressBarPart:
 450 #if ENABLE(PROGRESS_TAG)
 451             m_value.ident = CSSValueProgressBar;
 452 #endif
 453             break;
 454         case ProgressBarValuePart:
 455 #if ENABLE(PROGRESS_TAG)
 456             m_value.ident = CSSValueProgressBarValue;
 457 #endif
 458             break;
 459         case SliderHorizontalPart:
 460             m_value.ident = CSSValueSliderHorizontal;
 461             break;
 462         case SliderVerticalPart:
 463             m_value.ident = CSSValueSliderVertical;
 464             break;
 465         case SliderThumbHorizontalPart:
 466             m_value.ident = CSSValueSliderthumbHorizontal;
 467             break;
 468         case SliderThumbVerticalPart:
 469             m_value.ident = CSSValueSliderthumbVertical;
 470             break;
 471         case CaretPart:
 472             m_value.ident = CSSValueCaret;
 473             break;
 474         case SearchFieldPart:
 475             m_value.ident = CSSValueSearchfield;
 476             break;
 477         case SearchFieldDecorationPart:
 478             m_value.ident = CSSValueSearchfieldDecoration;
 479             break;
 480         case SearchFieldResultsDecorationPart:
 481             m_value.ident = CSSValueSearchfieldResultsDecoration;
 482             break;
 483         case SearchFieldResultsButtonPart:
 484             m_value.ident = CSSValueSearchfieldResultsButton;
 485             break;
 486         case SearchFieldCancelButtonPart:
 487             m_value.ident = CSSValueSearchfieldCancelButton;
 488             break;
 489         case TextFieldPart:
 490             m_value.ident = CSSValueTextfield;
 491             break;
 492         case TextAreaPart:
 493             m_value.ident = CSSValueTextarea;
 494             break;
 495         case CapsLockIndicatorPart:
 496             m_value.ident = CSSValueCapsLockIndicator;
 497             break;
 498         case InputSpeechButtonPart:
 499 #if ENABLE(INPUT_SPEECH)
 500             m_value.ident = CSSValueWebkitInputSpeechButton;
 501 #endif
 502             break;
 503     }
 504 }
 505
 506 template<> inline CSSPrimitiveValue::operator ControlPart() const
 507 {
 508     if (m_value.ident == CSSValueNone)
 509         return NoControlPart;
 510     else
 511         return ControlPart(m_value.ident - CSSValueCheckbox + 1);
 512 }
 513
 514 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
 515     : CSSValue(PrimitiveClass)
 516 {
 517     m_primitiveUnitType = CSS_IDENT;
 518     switch (e) {
 519     case BackfaceVisibilityVisible:
 520         m_value.ident = CSSValueVisible;
 521         break;
 522     case BackfaceVisibilityHidden:
 523         m_value.ident = CSSValueHidden;
 524         break;
 525     }
 526 }
 527
 528 template<> inline CSSPrimitiveValue::operator EBackfaceVisibility() const
 529 {
 530     switch (m_value.ident) {
 531     case CSSValueVisible:
 532         return BackfaceVisibilityVisible;
 533     case CSSValueHidden:
 534         return BackfaceVisibilityHidden;
 535     default:
 536         ASSERT_NOT_REACHED();
 537         return BackfaceVisibilityHidden;
 538     }
 539 }
 540
 541
 542 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
 543     : CSSValue(PrimitiveClass)
 544 {
 545     m_primitiveUnitType = CSS_IDENT;
 546     switch (e) {
 547         case ScrollBackgroundAttachment:
 548             m_value.ident = CSSValueScroll;
 549             break;
 550         case LocalBackgroundAttachment:
 551             m_value.ident = CSSValueLocal;
 552             break;
 553         case FixedBackgroundAttachment:
 554             m_value.ident = CSSValueFixed;
 555             break;
 556     }
 557 }
 558
 559 template<> inline CSSPrimitiveValue::operator EFillAttachment() const
 560 {
 561     switch (m_value.ident) {
 562         case CSSValueScroll:
 563             return ScrollBackgroundAttachment;
 564         case CSSValueLocal:
 565             return LocalBackgroundAttachment;
 566         case CSSValueFixed:
 567             return FixedBackgroundAttachment;
 568         default:
 569             ASSERT_NOT_REACHED();
 570             return ScrollBackgroundAttachment;
 571     }
 572 }
 573
 574 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
 575     : CSSValue(PrimitiveClass)
 576 {
 577     m_primitiveUnitType = CSS_IDENT;
 578     switch (e) {
 579         case BorderFillBox:
 580             m_value.ident = CSSValueBorderBox;
 581             break;
 582         case PaddingFillBox:
 583             m_value.ident = CSSValuePaddingBox;
 584             break;
 585         case ContentFillBox:
 586             m_value.ident = CSSValueContentBox;
 587             break;
 588         case TextFillBox:
 589             m_value.ident = CSSValueText;
 590             break;
 591     }
 592 }
 593
 594 template<> inline CSSPrimitiveValue::operator EFillBox() const
 595 {
 596     switch (m_value.ident) {
 597         case CSSValueBorder:
 598         case CSSValueBorderBox:
 599             return BorderFillBox;
 600         case CSSValuePadding:
 601         case CSSValuePaddingBox:
 602             return PaddingFillBox;
 603         case CSSValueContent:
 604         case CSSValueContentBox:
 605             return ContentFillBox;
 606         case CSSValueText:
 607         case CSSValueWebkitText:
 608             return TextFillBox;
 609         default:
 610             ASSERT_NOT_REACHED();
 611             return BorderFillBox;
 612     }
 613 }
 614
 615 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
 616     : CSSValue(PrimitiveClass)
 617 {
 618     m_primitiveUnitType = CSS_IDENT;
 619     switch (e) {
 620         case RepeatFill:
 621             m_value.ident = CSSValueRepeat;
 622             break;
 623         case NoRepeatFill:
 624             m_value.ident = CSSValueNoRepeat;
 625             break;
 626         case RoundFill:
 627             m_value.ident = CSSValueRound;
 628             break;
 629         case SpaceFill:
 630             m_value.ident = CSSValueSpace;
 631             break;
 632     }
 633 }
 634
 635 template<> inline CSSPrimitiveValue::operator EFillRepeat() const
 636 {
 637     switch (m_value.ident) {
 638         case CSSValueRepeat:
 639             return RepeatFill;
 640         case CSSValueNoRepeat:
 641             return NoRepeatFill;
 642         case CSSValueRound:
 643             return RoundFill;
 644         case CSSValueSpace:
 645             return SpaceFill;
 646         default:
 647             ASSERT_NOT_REACHED();
 648             return RepeatFill;
 649     }
 650 }
 651
 652 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e)
 653     : CSSValue(PrimitiveClass)
 654 {
 655     m_primitiveUnitType = CSS_IDENT;
 656     switch (e) {
 657     case Start:
 658         m_value.ident = CSSValueStart;
 659         break;
 660     case Center:
 661         m_value.ident = CSSValueCenter;
 662         break;
 663     case End:
 664         m_value.ident = CSSValueEnd;
 665         break;
 666     case Justify:
 667         m_value.ident = CSSValueJustify;
 668         break;
 669     }
 670 }
 671
 672 template<> inline CSSPrimitiveValue::operator EBoxPack() const
 673 {
 674     switch (m_value.ident) {
 675     case CSSValueStart:
 676         return Start;
 677     case CSSValueEnd:
 678         return End;
 679     case CSSValueCenter:
 680         return Center;
 681     case CSSValueJustify:
 682         return Justify;
 683     default:
 684         ASSERT_NOT_REACHED();
 685         return Justify;
 686     }
 687 }
 688
 689 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
 690     : CSSValue(PrimitiveClass)
 691 {
 692     m_primitiveUnitType = CSS_IDENT;
 693     switch (e) {
 694         case BSTRETCH:
 695             m_value.ident = CSSValueStretch;
 696             break;
 697         case BSTART:
 698             m_value.ident = CSSValueStart;
 699             break;
 700         case BCENTER:
 701             m_value.ident = CSSValueCenter;
 702             break;
 703         case BEND:
 704             m_value.ident = CSSValueEnd;
 705             break;
 706         case BBASELINE:
 707             m_value.ident = CSSValueBaseline;
 708             break;
 709     }
 710 }
 711
 712 template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
 713 {
 714     switch (m_value.ident) {
 715         case CSSValueStretch:
 716             return BSTRETCH;
 717         case CSSValueStart:
 718             return BSTART;
 719         case CSSValueEnd:
 720             return BEND;
 721         case CSSValueCenter:
 722             return BCENTER;
 723         case CSSValueBaseline:
 724             return BBASELINE;
 725         default:
 726             ASSERT_NOT_REACHED();
 727             return BSTRETCH;
 728     }
 729 }
 730
 731 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e)
 732     : CSSValue(PrimitiveClass)
 733 {
 734     m_primitiveUnitType = CSS_IDENT;
 735     switch (e) {
 736     case BORDER_BOX:
 737         m_value.ident = CSSValueBorderBox;
 738         break;
 739     case CONTENT_BOX:
 740         m_value.ident = CSSValueContentBox;
 741         break;
 742     }
 743 }
 744
 745 template<> inline CSSPrimitiveValue::operator EBoxSizing() const
 746 {
 747     switch (m_value.ident) {
 748     case CSSValueBorderBox:
 749         return BORDER_BOX;
 750     case CSSValueContentBox:
 751         return CONTENT_BOX;
 752     default:
 753         ASSERT_NOT_REACHED();
 754         return BORDER_BOX;
 755     }
 756 }
 757
 758 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
 759     : CSSValue(PrimitiveClass)
 760 {
 761     m_primitiveUnitType = CSS_IDENT;
 762     switch (e) {
 763         case BNORMAL:
 764             m_value.ident = CSSValueNormal;
 765             break;
 766         case BREVERSE:
 767             m_value.ident = CSSValueReverse;
 768             break;
 769     }
 770 }
 771
 772 template<> inline CSSPrimitiveValue::operator EBoxDirection() const
 773 {
 774     switch (m_value.ident) {
 775         case CSSValueNormal:
 776             return BNORMAL;
 777         case CSSValueReverse:
 778             return BREVERSE;
 779         default:
 780             ASSERT_NOT_REACHED();
 781             return BNORMAL;
 782     }
 783 }
 784
 785 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
 786     : CSSValue(PrimitiveClass)
 787 {
 788     m_primitiveUnitType = CSS_IDENT;
 789     switch (e) {
 790         case SINGLE:
 791             m_value.ident = CSSValueSingle;
 792             break;
 793         case MULTIPLE:
 794             m_value.ident = CSSValueMultiple;
 795             break;
 796     }
 797 }
 798
 799 template<> inline CSSPrimitiveValue::operator EBoxLines() const
 800 {
 801     switch (m_value.ident) {
 802         case CSSValueSingle:
 803             return SINGLE;
 804         case CSSValueMultiple:
 805             return MULTIPLE;
 806         default:
 807             ASSERT_NOT_REACHED();
 808             return SINGLE;
 809     }
 810 }
 811
 812 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
 813     : CSSValue(PrimitiveClass)
 814 {
 815     m_primitiveUnitType = CSS_IDENT;
 816     switch (e) {
 817         case HORIZONTAL:
 818             m_value.ident = CSSValueHorizontal;
 819             break;
 820         case VERTICAL:
 821             m_value.ident = CSSValueVertical;
 822             break;
 823     }
 824 }
 825
 826 template<> inline CSSPrimitiveValue::operator EBoxOrient() const
 827 {
 828     switch (m_value.ident) {
 829         case CSSValueHorizontal:
 830         case CSSValueInlineAxis:
 831             return HORIZONTAL;
 832         case CSSValueVertical:
 833         case CSSValueBlockAxis:
 834             return VERTICAL;
 835         default:
 836             ASSERT_NOT_REACHED();
 837             return HORIZONTAL;
 838     }
 839 }
 840
 841 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
 842     : CSSValue(PrimitiveClass)
 843 {
 844     m_primitiveUnitType = CSS_IDENT;
 845     switch (e) {
 846         case CAPLEFT:
 847             m_value.ident = CSSValueLeft;
 848             break;
 849         case CAPRIGHT:
 850             m_value.ident = CSSValueRight;
 851             break;
 852         case CAPTOP:
 853             m_value.ident = CSSValueTop;
 854             break;
 855         case CAPBOTTOM:
 856             m_value.ident = CSSValueBottom;
 857             break;
 858     }
 859 }
 860
 861 template<> inline CSSPrimitiveValue::operator ECaptionSide() const
 862 {
 863     switch (m_value.ident) {
 864         case CSSValueLeft:
 865             return CAPLEFT;
 866         case CSSValueRight:
 867             return CAPRIGHT;
 868         case CSSValueTop:
 869             return CAPTOP;
 870         case CSSValueBottom:
 871             return CAPBOTTOM;
 872         default:
 873             ASSERT_NOT_REACHED();
 874             return CAPTOP;
 875     }
 876 }
 877
 878 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
 879     : CSSValue(PrimitiveClass)
 880 {
 881     m_primitiveUnitType = CSS_IDENT;
 882     switch (e) {
 883         case CNONE:
 884             m_value.ident = CSSValueNone;
 885             break;
 886         case CLEFT:
 887             m_value.ident = CSSValueLeft;
 888             break;
 889         case CRIGHT:
 890             m_value.ident = CSSValueRight;
 891             break;
 892         case CBOTH:
 893             m_value.ident = CSSValueBoth;
 894             break;
 895     }
 896 }
 897
 898 template<> inline CSSPrimitiveValue::operator EClear() const
 899 {
 900     switch (m_value.ident) {
 901         case CSSValueNone:
 902             return CNONE;
 903         case CSSValueLeft:
 904             return CLEFT;
 905         case CSSValueRight:
 906             return CRIGHT;
 907         case CSSValueBoth:
 908             return CBOTH;
 909         default:
 910             ASSERT_NOT_REACHED();
 911             return CNONE;
 912     }
 913 }
 914
 915 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
 916     : CSSValue(PrimitiveClass)
 917 {
 918     m_primitiveUnitType = CSS_IDENT;
 919     switch (e) {
 920         case CURSOR_AUTO:
 921             m_value.ident = CSSValueAuto;
 922             break;
 923         case CURSOR_CROSS:
 924             m_value.ident = CSSValueCrosshair;
 925             break;
 926         case CURSOR_DEFAULT:
 927             m_value.ident = CSSValueDefault;
 928             break;
 929         case CURSOR_POINTER:
 930             m_value.ident = CSSValuePointer;
 931             break;
 932         case CURSOR_MOVE:
 933             m_value.ident = CSSValueMove;
 934             break;
 935         case CURSOR_CELL:
 936             m_value.ident = CSSValueCell;
 937             break;
 938         case CURSOR_VERTICAL_TEXT:
 939             m_value.ident = CSSValueVerticalText;
 940             break;
 941         case CURSOR_CONTEXT_MENU:
 942             m_value.ident = CSSValueContextMenu;
 943             break;
 944         case CURSOR_ALIAS:
 945             m_value.ident = CSSValueAlias;
 946             break;
 947         case CURSOR_COPY:
 948             m_value.ident = CSSValueCopy;
 949             break;
 950         case CURSOR_NONE:
 951             m_value.ident = CSSValueNone;
 952             break;
 953         case CURSOR_PROGRESS:
 954             m_value.ident = CSSValueProgress;
 955             break;
 956         case CURSOR_NO_DROP:
 957             m_value.ident = CSSValueNoDrop;
 958             break;
 959         case CURSOR_NOT_ALLOWED:
 960             m_value.ident = CSSValueNotAllowed;
 961             break;
 962         case CURSOR_WEBKIT_ZOOM_IN:
 963             m_value.ident = CSSValueWebkitZoomIn;
 964             break;
 965         case CURSOR_WEBKIT_ZOOM_OUT:
 966             m_value.ident = CSSValueWebkitZoomOut;
 967             break;
 968         case CURSOR_E_RESIZE:
 969             m_value.ident = CSSValueEResize;
 970             break;
 971         case CURSOR_NE_RESIZE:
 972             m_value.ident = CSSValueNeResize;
 973             break;
 974         case CURSOR_NW_RESIZE:
 975             m_value.ident = CSSValueNwResize;
 976             break;
 977         case CURSOR_N_RESIZE:
 978             m_value.ident = CSSValueNResize;
 979             break;
 980         case CURSOR_SE_RESIZE:
 981             m_value.ident = CSSValueSeResize;
 982             break;
 983         case CURSOR_SW_RESIZE:
 984             m_value.ident = CSSValueSwResize;
 985             break;
 986         case CURSOR_S_RESIZE:
 987             m_value.ident = CSSValueSResize;
 988             break;
 989         case CURSOR_W_RESIZE:
 990             m_value.ident = CSSValueWResize;
 991             break;
 992         case CURSOR_EW_RESIZE:
 993             m_value.ident = CSSValueEwResize;
 994             break;
 995         case CURSOR_NS_RESIZE:
 996             m_value.ident = CSSValueNsResize;
 997             break;
 998         case CURSOR_NESW_RESIZE:
 999             m_value.ident = CSSValueNeswResize;
1000             break;
1001         case CURSOR_NWSE_RESIZE:
1002             m_value.ident = CSSValueNwseResize;
1003             break;
1004         case CURSOR_COL_RESIZE:
1005             m_value.ident = CSSValueColResize;
1006             break;
1007         case CURSOR_ROW_RESIZE:
1008             m_value.ident = CSSValueRowResize;
1009             break;
1010         case CURSOR_TEXT:
1011             m_value.ident = CSSValueText;
1012             break;
1013         case CURSOR_WAIT:
1014             m_value.ident = CSSValueWait;
1015             break;
1016         case CURSOR_HELP:
1017             m_value.ident = CSSValueHelp;
1018             break;
1019         case CURSOR_ALL_SCROLL:
1020             m_value.ident = CSSValueAllScroll;
1021             break;
1022         case CURSOR_WEBKIT_GRAB:
1023             m_value.ident = CSSValueWebkitGrab;
1024             break;
1025         case CURSOR_WEBKIT_GRABBING:
1026             m_value.ident = CSSValueWebkitGrabbing;
1027             break;
1028     }
1029 }
1030
1031 template<> inline CSSPrimitiveValue::operator ECursor() const
1032 {
1033     if (m_value.ident == CSSValueCopy)
1034         return CURSOR_COPY;
1035     if (m_value.ident == CSSValueNone)
1036         return CURSOR_NONE;
1037     return static_cast<ECursor>(m_value.ident - CSSValueAuto);
1038 }
1039
1040 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
1041     : CSSValue(PrimitiveClass)
1042 {
1043     m_primitiveUnitType = CSS_IDENT;
1044     switch (e) {
1045         case INLINE:
1046             m_value.ident = CSSValueInline;
1047             break;
1048         case BLOCK:
1049             m_value.ident = CSSValueBlock;
1050             break;
1051         case LIST_ITEM:
1052             m_value.ident = CSSValueListItem;
1053             break;
1054         case RUN_IN:
1055             m_value.ident = CSSValueRunIn;
1056             break;
1057         case COMPACT:
1058             m_value.ident = CSSValueCompact;
1059             break;
1060         case INLINE_BLOCK:
1061             m_value.ident = CSSValueInlineBlock;
1062             break;
1063         case TABLE:
1064             m_value.ident = CSSValueTable;
1065             break;
1066         case INLINE_TABLE:
1067             m_value.ident = CSSValueInlineTable;
1068             break;
1069         case TABLE_ROW_GROUP:
1070             m_value.ident = CSSValueTableRowGroup;
1071             break;
1072         case TABLE_HEADER_GROUP:
1073             m_value.ident = CSSValueTableHeaderGroup;
1074             break;
1075         case TABLE_FOOTER_GROUP:
1076             m_value.ident = CSSValueTableFooterGroup;
1077             break;
1078         case TABLE_ROW:
1079             m_value.ident = CSSValueTableRow;
1080             break;
1081         case TABLE_COLUMN_GROUP:
1082             m_value.ident = CSSValueTableColumnGroup;
1083             break;
1084         case TABLE_COLUMN:
1085             m_value.ident = CSSValueTableColumn;
1086             break;
1087         case TABLE_CELL:
1088             m_value.ident = CSSValueTableCell;
1089             break;
1090         case TABLE_CAPTION:
1091             m_value.ident = CSSValueTableCaption;
1092             break;
1093         case BOX:
1094             m_value.ident = CSSValueWebkitBox;
1095             break;
1096         case INLINE_BOX:
1097             m_value.ident = CSSValueWebkitInlineBox;
1098             break;
1099         case FLEXBOX:
1100             m_value.ident = CSSValueWebkitFlexbox;
1101             break;
1102         case INLINE_FLEXBOX:
1103             m_value.ident = CSSValueWebkitInlineFlexbox;
1104             break;
1105 #if ENABLE(CSS_GRID_LAYOUT)
1106         case GRID:
1107             m_value.ident = CSSValueWebkitGrid;
1108             break;
1109         case INLINE_GRID:
1110             m_value.ident = CSSValueWebkitInlineGrid;
1111             break;
1112 #endif
1113         case NONE:
1114             m_value.ident = CSSValueNone;
1115             break;
1116     }
1117 }
1118
1119 template<> inline CSSPrimitiveValue::operator EDisplay() const
1120 {
1121     if (m_value.ident == CSSValueNone)
1122         return NONE;
1123
1124     EDisplay display = static_cast<EDisplay>(m_value.ident - CSSValueInline);
1125     ASSERT(display >= INLINE && display <= NONE);
1126     return display;
1127 }
1128
1129 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
1130     : CSSValue(PrimitiveClass)
1131 {
1132     m_primitiveUnitType = CSS_IDENT;
1133     switch (e) {
1134         case SHOW:
1135             m_value.ident = CSSValueShow;
1136             break;
1137         case HIDE:
1138             m_value.ident = CSSValueHide;
1139             break;
1140     }
1141 }
1142
1143 template<> inline CSSPrimitiveValue::operator EEmptyCell() const
1144 {
1145     switch (m_value.ident) {
1146         case CSSValueShow:
1147             return SHOW;
1148         case CSSValueHide:
1149             return HIDE;
1150         default:
1151             ASSERT_NOT_REACHED();
1152             return SHOW;
1153     }
1154 }
1155
1156 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexAlign e)
1157     : CSSValue(PrimitiveClass)
1158 {
1159     m_primitiveUnitType = CSS_IDENT;
1160     switch (e) {
1161     case AlignAuto:
1162         m_value.ident = CSSValueAuto;
1163         break;
1164     case AlignStart:
1165         m_value.ident = CSSValueStart;
1166         break;
1167     case AlignEnd:
1168         m_value.ident = CSSValueEnd;
1169         break;
1170     case AlignCenter:
1171         m_value.ident = CSSValueCenter;
1172         break;
1173     case AlignStretch:
1174         m_value.ident = CSSValueStretch;
1175         break;
1176     case AlignBaseline:
1177         m_value.ident = CSSValueBaseline;
1178         break;
1179     }
1180 }
1181
1182 template<> inline CSSPrimitiveValue::operator EFlexAlign() const
1183 {
1184     switch (m_value.ident) {
1185     case CSSValueAuto:
1186         return AlignAuto;
1187     case CSSValueStart:
1188         return AlignStart;
1189     case CSSValueEnd:
1190         return AlignEnd;
1191     case CSSValueCenter:
1192         return AlignCenter;
1193     case CSSValueStretch:
1194         return AlignStretch;
1195     case CSSValueBaseline:
1196         return AlignBaseline;
1197     default:
1198         ASSERT_NOT_REACHED();
1199         return AlignStart;
1200     }
1201 }
1202
1203 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexPack e)
1204     : CSSValue(PrimitiveClass)
1205 {
1206     m_primitiveUnitType = CSS_IDENT;
1207     switch (e) {
1208     case PackStart:
1209         m_value.ident = CSSValueStart;
1210         break;
1211     case PackEnd:
1212         m_value.ident = CSSValueEnd;
1213         break;
1214     case PackCenter:
1215         m_value.ident = CSSValueCenter;
1216         break;
1217     case PackJustify:
1218         m_value.ident = CSSValueJustify;
1219         break;
1220     }
1221 }
1222
1223 template<> inline CSSPrimitiveValue::operator EFlexPack() const
1224 {
1225     switch (m_value.ident) {
1226     case CSSValueStart:
1227         return PackStart;
1228     case CSSValueEnd:
1229         return PackEnd;
1230     case CSSValueCenter:
1231         return PackCenter;
1232     case CSSValueJustify:
1233         return PackJustify;
1234     default:
1235         ASSERT_NOT_REACHED();
1236         return PackStart;
1237     }
1238 }
1239
1240 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
1241     : CSSValue(PrimitiveClass)
1242 {
1243     m_primitiveUnitType = CSS_IDENT;
1244     switch (e) {
1245     case FlowRow:
1246         m_value.ident = CSSValueRow;
1247         break;
1248     case FlowRowReverse:
1249         m_value.ident = CSSValueRowReverse;
1250         break;
1251     case FlowColumn:
1252         m_value.ident = CSSValueColumn;
1253         break;
1254     case FlowColumnReverse:
1255         m_value.ident = CSSValueColumnReverse;
1256         break;
1257     }
1258 }
1259
1260 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1261 {
1262     switch (m_value.ident) {
1263     case CSSValueRow:
1264         return FlowRow;
1265     case CSSValueRowReverse:
1266         return FlowRowReverse;
1267     case CSSValueColumn:
1268         return FlowColumn;
1269     case CSSValueColumnReverse:
1270         return FlowColumnReverse;
1271     default:
1272         ASSERT_NOT_REACHED();
1273         return FlowRow;
1274     }
1275 }
1276
1277 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1278     : CSSValue(PrimitiveClass)
1279 {
1280     m_primitiveUnitType = CSS_IDENT;
1281     switch (e) {
1282     case FlexNoWrap:
1283         m_value.ident = CSSValueNowrap;
1284         break;
1285     case FlexWrap:
1286         m_value.ident = CSSValueWrap;
1287         break;
1288     case FlexWrapReverse:
1289         m_value.ident = CSSValueWrapReverse;
1290         break;
1291     }
1292 }
1293
1294 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1295 {
1296     switch (m_value.ident) {
1297     case CSSValueNowrap:
1298         return FlexNoWrap;
1299     case CSSValueWrap:
1300         return FlexWrap;
1301     case CSSValueWrapReverse:
1302         return FlexWrapReverse;
1303     default:
1304         ASSERT_NOT_REACHED();
1305         return FlexNoWrap;
1306     }
1307 }
1308
1309 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1310     : CSSValue(PrimitiveClass)
1311 {
1312     m_primitiveUnitType = CSS_IDENT;
1313     switch (e) {
1314         case NoFloat:
1315             m_value.ident = CSSValueNone;
1316             break;
1317         case LeftFloat:
1318             m_value.ident = CSSValueLeft;
1319             break;
1320         case RightFloat:
1321             m_value.ident = CSSValueRight;
1322             break;
1323         case PositionedFloat:
1324             m_value.ident = CSSValueWebkitPositioned;
1325             break;
1326     }
1327 }
1328
1329 template<> inline CSSPrimitiveValue::operator EFloat() const
1330 {
1331     switch (m_value.ident) {
1332         case CSSValueLeft:
1333             return LeftFloat;
1334         case CSSValueRight:
1335             return RightFloat;
1336         case CSSValueNone:
1337         case CSSValueCenter:  // Non-standard CSS value
1338             return NoFloat;
1339         case CSSValueWebkitPositioned:
1340             return PositionedFloat;
1341         default:
1342             ASSERT_NOT_REACHED();
1343             return NoFloat;
1344     }
1345 }
1346
1347 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EKHTMLLineBreak e)
1348     : CSSValue(PrimitiveClass)
1349 {
1350     m_primitiveUnitType = CSS_IDENT;
1351     switch (e) {
1352         case LBNORMAL:
1353             m_value.ident = CSSValueNormal;
1354             break;
1355         case AFTER_WHITE_SPACE:
1356             m_value.ident = CSSValueAfterWhiteSpace;
1357             break;
1358     }
1359 }
1360
1361 template<> inline CSSPrimitiveValue::operator EKHTMLLineBreak() const
1362 {
1363     switch (m_value.ident) {
1364         case CSSValueAfterWhiteSpace:
1365             return AFTER_WHITE_SPACE;
1366         case CSSValueNormal:
1367             return LBNORMAL;
1368         default:
1369             ASSERT_NOT_REACHED();
1370             return LBNORMAL;
1371     }
1372 }
1373
1374 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1375     : CSSValue(PrimitiveClass)
1376 {
1377     m_primitiveUnitType = CSS_IDENT;
1378     switch (e) {
1379         case OUTSIDE:
1380             m_value.ident = CSSValueOutside;
1381             break;
1382         case INSIDE:
1383             m_value.ident = CSSValueInside;
1384             break;
1385     }
1386 }
1387
1388 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1389 {
1390     return (EListStylePosition)(m_value.ident - CSSValueOutside);
1391 }
1392
1393 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1394     : CSSValue(PrimitiveClass)
1395 {
1396     m_primitiveUnitType = CSS_IDENT;
1397     switch (e) {
1398     case Afar:
1399         m_value.ident = CSSValueAfar;
1400         break;
1401     case Amharic:
1402         m_value.ident = CSSValueAmharic;
1403         break;
1404     case AmharicAbegede:
1405         m_value.ident = CSSValueAmharicAbegede;
1406         break;
1407     case ArabicIndic:
1408         m_value.ident = CSSValueArabicIndic;
1409         break;
1410     case Armenian:
1411         m_value.ident = CSSValueArmenian;
1412         break;
1413     case Asterisks:
1414         m_value.ident = CSSValueAsterisks;
1415         break;
1416     case BinaryListStyle:
1417         m_value.ident = CSSValueBinary;
1418         break;
1419     case Bengali:
1420         m_value.ident = CSSValueBengali;
1421         break;
1422     case Cambodian:
1423         m_value.ident = CSSValueCambodian;
1424         break;
1425     case Circle:
1426         m_value.ident = CSSValueCircle;
1427         break;
1428     case CjkEarthlyBranch:
1429         m_value.ident = CSSValueCjkEarthlyBranch;
1430         break;
1431     case CjkHeavenlyStem:
1432         m_value.ident = CSSValueCjkHeavenlyStem;
1433         break;
1434     case CJKIdeographic:
1435         m_value.ident = CSSValueCjkIdeographic;
1436         break;
1437     case DecimalLeadingZero:
1438         m_value.ident = CSSValueDecimalLeadingZero;
1439         break;
1440     case DecimalListStyle:
1441         m_value.ident = CSSValueDecimal;
1442         break;
1443     case Devanagari:
1444         m_value.ident = CSSValueDevanagari;
1445         break;
1446     case Disc:
1447         m_value.ident = CSSValueDisc;
1448         break;
1449     case Ethiopic:
1450         m_value.ident = CSSValueEthiopic;
1451         break;
1452     case EthiopicAbegede:
1453         m_value.ident = CSSValueEthiopicAbegede;
1454         break;
1455     case EthiopicAbegedeAmEt:
1456         m_value.ident = CSSValueEthiopicAbegedeAmEt;
1457         break;
1458     case EthiopicAbegedeGez:
1459         m_value.ident = CSSValueEthiopicAbegedeGez;
1460         break;
1461     case EthiopicAbegedeTiEr:
1462         m_value.ident = CSSValueEthiopicAbegedeTiEr;
1463         break;
1464     case EthiopicAbegedeTiEt:
1465         m_value.ident = CSSValueEthiopicAbegedeTiEt;
1466         break;
1467     case EthiopicHalehameAaEr:
1468         m_value.ident = CSSValueEthiopicHalehameAaEr;
1469         break;
1470     case EthiopicHalehameAaEt:
1471         m_value.ident = CSSValueEthiopicHalehameAaEt;
1472         break;
1473     case EthiopicHalehameAmEt:
1474         m_value.ident = CSSValueEthiopicHalehameAmEt;
1475         break;
1476     case EthiopicHalehameGez:
1477         m_value.ident = CSSValueEthiopicHalehameGez;
1478         break;
1479     case EthiopicHalehameOmEt:
1480         m_value.ident = CSSValueEthiopicHalehameOmEt;
1481         break;
1482     case EthiopicHalehameSidEt:
1483         m_value.ident = CSSValueEthiopicHalehameSidEt;
1484         break;
1485     case EthiopicHalehameSoEt:
1486         m_value.ident = CSSValueEthiopicHalehameSoEt;
1487         break;
1488     case EthiopicHalehameTiEr:
1489         m_value.ident = CSSValueEthiopicHalehameTiEr;
1490         break;
1491     case EthiopicHalehameTiEt:
1492         m_value.ident = CSSValueEthiopicHalehameTiEt;
1493         break;
1494     case EthiopicHalehameTig:
1495         m_value.ident = CSSValueEthiopicHalehameTig;
1496         break;
1497     case Footnotes:
1498         m_value.ident = CSSValueFootnotes;
1499         break;
1500     case Georgian:
1501         m_value.ident = CSSValueGeorgian;
1502         break;
1503     case Gujarati:
1504         m_value.ident = CSSValueGujarati;
1505         break;
1506     case Gurmukhi:
1507         m_value.ident = CSSValueGurmukhi;
1508         break;
1509     case Hangul:
1510         m_value.ident = CSSValueHangul;
1511         break;
1512     case HangulConsonant:
1513         m_value.ident = CSSValueHangulConsonant;
1514         break;
1515     case Hebrew:
1516         m_value.ident = CSSValueHebrew;
1517         break;
1518     case Hiragana:
1519         m_value.ident = CSSValueHiragana;
1520         break;
1521     case HiraganaIroha:
1522         m_value.ident = CSSValueHiraganaIroha;
1523         break;
1524     case Kannada:
1525         m_value.ident = CSSValueKannada;
1526         break;
1527     case Katakana:
1528         m_value.ident = CSSValueKatakana;
1529         break;
1530     case KatakanaIroha:
1531         m_value.ident = CSSValueKatakanaIroha;
1532         break;
1533     case Khmer:
1534         m_value.ident = CSSValueKhmer;
1535         break;
1536     case Lao:
1537         m_value.ident = CSSValueLao;
1538         break;
1539     case LowerAlpha:
1540         m_value.ident = CSSValueLowerAlpha;
1541         break;
1542     case LowerArmenian:
1543         m_value.ident = CSSValueLowerArmenian;
1544         break;
1545     case LowerGreek:
1546         m_value.ident = CSSValueLowerGreek;
1547         break;
1548     case LowerHexadecimal:
1549         m_value.ident = CSSValueLowerHexadecimal;
1550         break;
1551     case LowerLatin:
1552         m_value.ident = CSSValueLowerLatin;
1553         break;
1554     case LowerNorwegian:
1555         m_value.ident = CSSValueLowerNorwegian;
1556         break;
1557     case LowerRoman:
1558         m_value.ident = CSSValueLowerRoman;
1559         break;
1560     case Malayalam:
1561         m_value.ident = CSSValueMalayalam;
1562         break;
1563     case Mongolian:
1564         m_value.ident = CSSValueMongolian;
1565         break;
1566     case Myanmar:
1567         m_value.ident = CSSValueMyanmar;
1568         break;
1569     case NoneListStyle:
1570         m_value.ident = CSSValueNone;
1571         break;
1572     case Octal:
1573         m_value.ident = CSSValueOctal;
1574         break;
1575     case Oriya:
1576         m_value.ident = CSSValueOriya;
1577         break;
1578     case Oromo:
1579         m_value.ident = CSSValueOromo;
1580         break;
1581     case Persian:
1582         m_value.ident = CSSValuePersian;
1583         break;
1584     case Sidama:
1585         m_value.ident = CSSValueSidama;
1586         break;
1587     case Somali:
1588         m_value.ident = CSSValueSomali;
1589         break;
1590     case Square:
1591         m_value.ident = CSSValueSquare;
1592         break;
1593     case Telugu:
1594         m_value.ident = CSSValueTelugu;
1595         break;
1596     case Thai:
1597         m_value.ident = CSSValueThai;
1598         break;
1599     case Tibetan:
1600         m_value.ident = CSSValueTibetan;
1601         break;
1602     case Tigre:
1603         m_value.ident = CSSValueTigre;
1604         break;
1605     case TigrinyaEr:
1606         m_value.ident = CSSValueTigrinyaEr;
1607         break;
1608     case TigrinyaErAbegede:
1609         m_value.ident = CSSValueTigrinyaErAbegede;
1610         break;
1611     case TigrinyaEt:
1612         m_value.ident = CSSValueTigrinyaEt;
1613         break;
1614     case TigrinyaEtAbegede:
1615         m_value.ident = CSSValueTigrinyaEtAbegede;
1616         break;
1617     case UpperAlpha:
1618         m_value.ident = CSSValueUpperAlpha;
1619         break;
1620     case UpperArmenian:
1621         m_value.ident = CSSValueUpperArmenian;
1622         break;
1623     case UpperGreek:
1624         m_value.ident = CSSValueUpperGreek;
1625         break;
1626     case UpperHexadecimal:
1627         m_value.ident = CSSValueUpperHexadecimal;
1628         break;
1629     case UpperLatin:
1630         m_value.ident = CSSValueUpperLatin;
1631         break;
1632     case UpperNorwegian:
1633         m_value.ident = CSSValueUpperNorwegian;
1634         break;
1635     case UpperRoman:
1636         m_value.ident = CSSValueUpperRoman;
1637         break;
1638     case Urdu:
1639         m_value.ident = CSSValueUrdu;
1640         break;
1641     }
1642 }
1643
1644 template<> inline CSSPrimitiveValue::operator EListStyleType() const
1645 {
1646     switch (m_value.ident) {
1647         case CSSValueNone:
1648             return NoneListStyle;
1649         default:
1650             return static_cast<EListStyleType>(m_value.ident - CSSValueDisc);
1651     }
1652 }
1653
1654 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
1655     : CSSValue(PrimitiveClass)
1656 {
1657     m_primitiveUnitType = CSS_IDENT;
1658     switch (e) {
1659         case MCOLLAPSE:
1660             m_value.ident = CSSValueCollapse;
1661             break;
1662         case MSEPARATE:
1663             m_value.ident = CSSValueSeparate;
1664             break;
1665         case MDISCARD:
1666             m_value.ident = CSSValueDiscard;
1667             break;
1668     }
1669 }
1670
1671 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
1672 {
1673     switch (m_value.ident) {
1674         case CSSValueCollapse:
1675             return MCOLLAPSE;
1676         case CSSValueSeparate:
1677             return MSEPARATE;
1678         case CSSValueDiscard:
1679             return MDISCARD;
1680         default:
1681             ASSERT_NOT_REACHED();
1682             return MCOLLAPSE;
1683     }
1684 }
1685
1686 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
1687     : CSSValue(PrimitiveClass)
1688 {
1689     m_primitiveUnitType = CSS_IDENT;
1690     switch (e) {
1691         case MNONE:
1692             m_value.ident = CSSValueNone;
1693             break;
1694         case MSCROLL:
1695             m_value.ident = CSSValueScroll;
1696             break;
1697         case MSLIDE:
1698             m_value.ident = CSSValueSlide;
1699             break;
1700         case MALTERNATE:
1701             m_value.ident = CSSValueAlternate;
1702             break;
1703     }
1704 }
1705
1706 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
1707 {
1708     switch (m_value.ident) {
1709         case CSSValueNone:
1710             return MNONE;
1711         case CSSValueScroll:
1712             return MSCROLL;
1713         case CSSValueSlide:
1714             return MSLIDE;
1715         case CSSValueAlternate:
1716             return MALTERNATE;
1717         default:
1718             ASSERT_NOT_REACHED();
1719             return MNONE;
1720     }
1721 }
1722
1723 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionOverflow e)
1724     : CSSValue(PrimitiveClass)
1725 {
1726     m_primitiveUnitType = CSS_IDENT;
1727     switch (e) {
1728     case AutoRegionOverflow:
1729         m_value.ident = CSSValueAuto;
1730         break;
1731     case BreakRegionOverflow:
1732         m_value.ident = CSSValueBreak;
1733         break;
1734     }
1735 }
1736
1737 template<> inline CSSPrimitiveValue::operator RegionOverflow() const
1738 {
1739     switch (m_value.ident) {
1740     case CSSValueAuto:
1741         return AutoRegionOverflow;
1742     case CSSValueBreak:
1743         return BreakRegionOverflow;
1744     default:
1745         ASSERT_NOT_REACHED();
1746         return AutoRegionOverflow;
1747     }
1748 }
1749
1750 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
1751     : CSSValue(PrimitiveClass)
1752 {
1753     m_primitiveUnitType = CSS_IDENT;
1754     switch (e) {
1755         case MFORWARD:
1756             m_value.ident = CSSValueForwards;
1757             break;
1758         case MBACKWARD:
1759             m_value.ident = CSSValueBackwards;
1760             break;
1761         case MAUTO:
1762             m_value.ident = CSSValueAuto;
1763             break;
1764         case MUP:
1765             m_value.ident = CSSValueUp;
1766             break;
1767         case MDOWN:
1768             m_value.ident = CSSValueDown;
1769             break;
1770         case MLEFT:
1771             m_value.ident = CSSValueLeft;
1772             break;
1773         case MRIGHT:
1774             m_value.ident = CSSValueRight;
1775             break;
1776     }
1777 }
1778
1779 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
1780 {
1781     switch (m_value.ident) {
1782         case CSSValueForwards:
1783             return MFORWARD;
1784         case CSSValueBackwards:
1785             return MBACKWARD;
1786         case CSSValueAuto:
1787             return MAUTO;
1788         case CSSValueAhead:
1789         case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
1790             return MUP;
1791         case CSSValueReverse:
1792         case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
1793             return MDOWN;
1794         case CSSValueLeft:
1795             return MLEFT;
1796         case CSSValueRight:
1797             return MRIGHT;
1798         default:
1799             ASSERT_NOT_REACHED();
1800             return MAUTO;
1801     }
1802 }
1803
1804 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMatchNearestMailBlockquoteColor e)
1805     : CSSValue(PrimitiveClass)
1806 {
1807     m_primitiveUnitType = CSS_IDENT;
1808     switch (e) {
1809         case BCNORMAL:
1810             m_value.ident = CSSValueNormal;
1811             break;
1812         case MATCH:
1813             m_value.ident = CSSValueMatch;
1814             break;
1815     }
1816 }
1817
1818 template<> inline CSSPrimitiveValue::operator EMatchNearestMailBlockquoteColor() const
1819 {
1820     switch (m_value.ident) {
1821         case CSSValueNormal:
1822             return BCNORMAL;
1823         case CSSValueMatch:
1824             return MATCH;
1825         default:
1826             ASSERT_NOT_REACHED();
1827             return BCNORMAL;
1828     }
1829 }
1830
1831 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
1832     : CSSValue(PrimitiveClass)
1833 {
1834     m_primitiveUnitType = CSS_IDENT;
1835     switch (e) {
1836         case NBNORMAL:
1837             m_value.ident = CSSValueNormal;
1838             break;
1839         case SPACE:
1840             m_value.ident = CSSValueSpace;
1841             break;
1842     }
1843 }
1844
1845 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
1846 {
1847     switch (m_value.ident) {
1848         case CSSValueSpace:
1849             return SPACE;
1850         case CSSValueNormal:
1851             return NBNORMAL;
1852         default:
1853             ASSERT_NOT_REACHED();
1854             return NBNORMAL;
1855     }
1856 }
1857
1858 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
1859     : CSSValue(PrimitiveClass)
1860 {
1861     m_primitiveUnitType = CSS_IDENT;
1862     switch (e) {
1863         case OVISIBLE:
1864             m_value.ident = CSSValueVisible;
1865             break;
1866         case OHIDDEN:
1867             m_value.ident = CSSValueHidden;
1868             break;
1869         case OSCROLL:
1870             m_value.ident = CSSValueScroll;
1871             break;
1872         case OAUTO:
1873             m_value.ident = CSSValueAuto;
1874             break;
1875         case OMARQUEE:
1876             m_value.ident = CSSValueWebkitMarquee;
1877             break;
1878         case OOVERLAY:
1879             m_value.ident = CSSValueOverlay;
1880             break;
1881     }
1882 }
1883
1884 template<> inline CSSPrimitiveValue::operator EOverflow() const
1885 {
1886     switch (m_value.ident) {
1887         case CSSValueVisible:
1888             return OVISIBLE;
1889         case CSSValueHidden:
1890             return OHIDDEN;
1891         case CSSValueScroll:
1892             return OSCROLL;
1893         case CSSValueAuto:
1894             return OAUTO;
1895         case CSSValueWebkitMarquee:
1896             return OMARQUEE;
1897         case CSSValueOverlay:
1898             return OOVERLAY;
1899         default:
1900             ASSERT_NOT_REACHED();
1901             return OVISIBLE;
1902     }
1903 }
1904
1905 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
1906     : CSSValue(PrimitiveClass)
1907 {
1908     m_primitiveUnitType = CSS_IDENT;
1909     switch (e) {
1910         case PBAUTO:
1911             m_value.ident = CSSValueAuto;
1912             break;
1913         case PBALWAYS:
1914             m_value.ident = CSSValueAlways;
1915             break;
1916         case PBAVOID:
1917             m_value.ident = CSSValueAvoid;
1918             break;
1919     }
1920 }
1921
1922 template<> inline CSSPrimitiveValue::operator EPageBreak() const
1923 {
1924     switch (m_value.ident) {
1925         case CSSValueAuto:
1926             return PBAUTO;
1927         case CSSValueLeft:
1928         case CSSValueRight:
1929         case CSSValueAlways:
1930             return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always."
1931         case CSSValueAvoid:
1932             return PBAVOID;
1933         default:
1934             ASSERT_NOT_REACHED();
1935             return PBAUTO;
1936     }
1937 }
1938
1939 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
1940     : CSSValue(PrimitiveClass)
1941 {
1942     m_primitiveUnitType = CSS_IDENT;
1943     switch (e) {
1944         case StaticPosition:
1945             m_value.ident = CSSValueStatic;
1946             break;
1947         case RelativePosition:
1948             m_value.ident = CSSValueRelative;
1949             break;
1950         case AbsolutePosition:
1951             m_value.ident = CSSValueAbsolute;
1952             break;
1953         case FixedPosition:
1954             m_value.ident = CSSValueFixed;
1955             break;
1956     }
1957 }
1958
1959 template<> inline CSSPrimitiveValue::operator EPosition() const
1960 {
1961     switch (m_value.ident) {
1962         case CSSValueStatic:
1963             return StaticPosition;
1964         case CSSValueRelative:
1965             return RelativePosition;
1966         case CSSValueAbsolute:
1967             return AbsolutePosition;
1968         case CSSValueFixed:
1969             return FixedPosition;
1970         default:
1971             ASSERT_NOT_REACHED();
1972             return StaticPosition;
1973     }
1974 }
1975
1976 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
1977     : CSSValue(PrimitiveClass)
1978 {
1979     m_primitiveUnitType = CSS_IDENT;
1980     switch (e) {
1981         case RESIZE_BOTH:
1982             m_value.ident = CSSValueBoth;
1983             break;
1984         case RESIZE_HORIZONTAL:
1985             m_value.ident = CSSValueHorizontal;
1986             break;
1987         case RESIZE_VERTICAL:
1988             m_value.ident = CSSValueVertical;
1989             break;
1990         case RESIZE_NONE:
1991             m_value.ident = CSSValueNone;
1992             break;
1993     }
1994 }
1995
1996 template<> inline CSSPrimitiveValue::operator EResize() const
1997 {
1998     switch (m_value.ident) {
1999         case CSSValueBoth:
2000             return RESIZE_BOTH;
2001         case CSSValueHorizontal:
2002             return RESIZE_HORIZONTAL;
2003         case CSSValueVertical:
2004             return RESIZE_VERTICAL;
2005         case CSSValueAuto:
2006             ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2007             return RESIZE_NONE;
2008         case CSSValueNone:
2009             return RESIZE_NONE;
2010         default:
2011             ASSERT_NOT_REACHED();
2012             return RESIZE_NONE;
2013     }
2014 }
2015
2016 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2017     : CSSValue(PrimitiveClass)
2018 {
2019     m_primitiveUnitType = CSS_IDENT;
2020     switch (e) {
2021         case TAUTO:
2022             m_value.ident = CSSValueAuto;
2023             break;
2024         case TFIXED:
2025             m_value.ident = CSSValueFixed;
2026             break;
2027     }
2028 }
2029
2030 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2031 {
2032     switch (m_value.ident) {
2033         case CSSValueFixed:
2034             return TFIXED;
2035         case CSSValueAuto:
2036             return TAUTO;
2037         default:
2038             ASSERT_NOT_REACHED();
2039             return TAUTO;
2040     }
2041 }
2042
2043 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2044     : CSSValue(PrimitiveClass)
2045 {
2046     m_primitiveUnitType = CSS_IDENT;
2047     switch (e) {
2048     case TAAUTO:
2049         m_value.ident = CSSValueWebkitAuto;
2050         break;
2051     case TASTART:
2052         m_value.ident = CSSValueStart;
2053         break;
2054     case TAEND:
2055         m_value.ident = CSSValueEnd;
2056         break;
2057     case LEFT:
2058         m_value.ident = CSSValueLeft;
2059         break;
2060     case RIGHT:
2061         m_value.ident = CSSValueRight;
2062         break;
2063     case CENTER:
2064         m_value.ident = CSSValueCenter;
2065         break;
2066     case JUSTIFY:
2067         m_value.ident = CSSValueJustify;
2068         break;
2069     case WEBKIT_LEFT:
2070         m_value.ident = CSSValueWebkitLeft;
2071         break;
2072     case WEBKIT_RIGHT:
2073         m_value.ident = CSSValueWebkitRight;
2074         break;
2075     case WEBKIT_CENTER:
2076         m_value.ident = CSSValueWebkitCenter;
2077         break;
2078     }
2079 }
2080
2081 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2082 {
2083     switch (m_value.ident) {
2084         case CSSValueStart:
2085             return TASTART;
2086         case CSSValueEnd:
2087             return TAEND;
2088         default:
2089             return static_cast<ETextAlign>(m_value.ident - CSSValueWebkitAuto);
2090     }
2091 }
2092
2093 template<> inline CSSPrimitiveValue::operator ETextDecoration() const
2094 {
2095     switch (m_value.ident) {
2096     case CSSValueNone:
2097         return TDNONE;
2098     case CSSValueUnderline:
2099         return UNDERLINE;
2100     case CSSValueOverline:
2101         return OVERLINE;
2102     case CSSValueLineThrough:
2103         return LINE_THROUGH;
2104     case CSSValueBlink:
2105         return BLINK;
2106     default:
2107         ASSERT_NOT_REACHED();
2108         return TDNONE;
2109     }
2110 }
2111
2112 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2113     : CSSValue(PrimitiveClass)
2114 {
2115     m_primitiveUnitType = CSS_IDENT;
2116     switch (e) {
2117         case TSNONE:
2118             m_value.ident = CSSValueNone;
2119             break;
2120         case TSDISC:
2121             m_value.ident = CSSValueDisc;
2122             break;
2123         case TSCIRCLE:
2124             m_value.ident = CSSValueCircle;
2125             break;
2126         case TSSQUARE:
2127             m_value.ident = CSSValueSquare;
2128             break;
2129     }
2130 }
2131
2132 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2133 {
2134     switch (m_value.ident) {
2135         case CSSValueNone:
2136             return TSNONE;
2137         case CSSValueDisc:
2138             return TSDISC;
2139         case CSSValueCircle:
2140             return TSCIRCLE;
2141         case CSSValueSquare:
2142             return TSSQUARE;
2143         default:
2144             ASSERT_NOT_REACHED();
2145             return TSNONE;
2146     }
2147 }
2148
2149 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2150     : CSSValue(PrimitiveClass)
2151 {
2152     m_primitiveUnitType = CSS_IDENT;
2153     switch (e) {
2154         case CAPITALIZE:
2155             m_value.ident = CSSValueCapitalize;
2156             break;
2157         case UPPERCASE:
2158             m_value.ident = CSSValueUppercase;
2159             break;
2160         case LOWERCASE:
2161             m_value.ident = CSSValueLowercase;
2162             break;
2163         case TTNONE:
2164             m_value.ident = CSSValueNone;
2165             break;
2166     }
2167 }
2168
2169 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2170 {
2171     switch (m_value.ident) {
2172         case CSSValueCapitalize:
2173             return CAPITALIZE;
2174         case CSSValueUppercase:
2175             return UPPERCASE;
2176         case CSSValueLowercase:
2177             return LOWERCASE;
2178         case CSSValueNone:
2179             return TTNONE;
2180         default:
2181             ASSERT_NOT_REACHED();
2182             return TTNONE;
2183     }
2184 }
2185
2186 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2187     : CSSValue(PrimitiveClass)
2188 {
2189     m_primitiveUnitType = CSS_IDENT;
2190     switch (e) {
2191     case UBNormal:
2192         m_value.ident = CSSValueNormal;
2193         break;
2194     case Embed:
2195         m_value.ident = CSSValueEmbed;
2196         break;
2197     case Override:
2198         m_value.ident = CSSValueBidiOverride;
2199         break;
2200     case Isolate:
2201         m_value.ident = CSSValueWebkitIsolate;
2202         break;
2203     case Plaintext:
2204         m_value.ident = CSSValueWebkitPlaintext;
2205         break;
2206     }
2207 }
2208
2209 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2210 {
2211     switch (m_value.ident) {
2212     case CSSValueNormal:
2213         return UBNormal;
2214     case CSSValueEmbed:
2215         return Embed;
2216     case CSSValueBidiOverride:
2217         return Override;
2218     case CSSValueWebkitIsolate:
2219         return Isolate;
2220     case CSSValueWebkitPlaintext:
2221         return Plaintext;
2222     default:
2223         ASSERT_NOT_REACHED();
2224         return UBNormal;
2225     }
2226 }
2227
2228 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2229     : CSSValue(PrimitiveClass)
2230 {
2231     m_primitiveUnitType = CSS_IDENT;
2232     switch (e) {
2233         case DRAG_AUTO:
2234             m_value.ident = CSSValueAuto;
2235             break;
2236         case DRAG_NONE:
2237             m_value.ident = CSSValueNone;
2238             break;
2239         case DRAG_ELEMENT:
2240             m_value.ident = CSSValueElement;
2241             break;
2242     }
2243 }
2244
2245 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2246 {
2247     switch (m_value.ident) {
2248         case CSSValueAuto:
2249             return DRAG_AUTO;
2250         case CSSValueNone:
2251             return DRAG_NONE;
2252         case CSSValueElement:
2253             return DRAG_ELEMENT;
2254         default:
2255             ASSERT_NOT_REACHED();
2256             return DRAG_AUTO;
2257     }
2258 }
2259
2260 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2261     : CSSValue(PrimitiveClass)
2262 {
2263     m_primitiveUnitType = CSS_IDENT;
2264     switch (e) {
2265         case READ_ONLY:
2266             m_value.ident = CSSValueReadOnly;
2267             break;
2268         case READ_WRITE:
2269             m_value.ident = CSSValueReadWrite;
2270             break;
2271         case READ_WRITE_PLAINTEXT_ONLY:
2272             m_value.ident = CSSValueReadWritePlaintextOnly;
2273             break;
2274     }
2275 }
2276
2277 template<> inline CSSPrimitiveValue::operator EUserModify() const
2278 {
2279     return static_cast<EUserModify>(m_value.ident - CSSValueReadOnly);
2280 }
2281
2282 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2283     : CSSValue(PrimitiveClass)
2284 {
2285     m_primitiveUnitType = CSS_IDENT;
2286     switch (e) {
2287         case SELECT_NONE:
2288             m_value.ident = CSSValueNone;
2289             break;
2290         case SELECT_TEXT:
2291             m_value.ident = CSSValueText;
2292             break;
2293     }
2294 }
2295
2296 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2297 {
2298     switch (m_value.ident) {
2299         case CSSValueAuto:
2300             return SELECT_TEXT;
2301         case CSSValueNone:
2302             return SELECT_NONE;
2303         case CSSValueText:
2304             return SELECT_TEXT;
2305         default:
2306             ASSERT_NOT_REACHED();
2307             return SELECT_TEXT;
2308     }
2309 }
2310
2311 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2312     : CSSValue(PrimitiveClass)
2313 {
2314     m_primitiveUnitType = CSS_IDENT;
2315     switch (a) {
2316     case TOP:
2317         m_value.ident = CSSValueTop;
2318         break;
2319     case BOTTOM:
2320         m_value.ident = CSSValueBottom;
2321         break;
2322     case MIDDLE:
2323         m_value.ident = CSSValueMiddle;
2324         break;
2325     case BASELINE:
2326         m_value.ident = CSSValueBaseline;
2327         break;
2328     case TEXT_BOTTOM:
2329         m_value.ident = CSSValueTextBottom;
2330         break;
2331     case TEXT_TOP:
2332         m_value.ident = CSSValueTextTop;
2333         break;
2334     case SUB:
2335         m_value.ident = CSSValueSub;
2336         break;
2337     case SUPER:
2338         m_value.ident = CSSValueSuper;
2339         break;
2340     case BASELINE_MIDDLE:
2341         m_value.ident = CSSValueWebkitBaselineMiddle;
2342         break;
2343     case LENGTH:
2344         m_value.ident = CSSValueInvalid;
2345     }
2346 }
2347
2348 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2349 {
2350     switch (m_value.ident) {
2351     case CSSValueTop:
2352         return TOP;
2353     case CSSValueBottom:
2354         return BOTTOM;
2355     case CSSValueMiddle:
2356         return MIDDLE;
2357     case CSSValueBaseline:
2358         return BASELINE;
2359     case CSSValueTextBottom:
2360         return TEXT_BOTTOM;
2361     case CSSValueTextTop:
2362         return TEXT_TOP;
2363     case CSSValueSub:
2364         return SUB;
2365     case CSSValueSuper:
2366         return SUPER;
2367     case CSSValueWebkitBaselineMiddle:
2368         return BASELINE_MIDDLE;
2369     default:
2370         ASSERT_NOT_REACHED();
2371         return TOP;
2372     }
2373 }
2374
2375 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
2376     : CSSValue(PrimitiveClass)
2377 {
2378     m_primitiveUnitType = CSS_IDENT;
2379     switch (e) {
2380         case VISIBLE:
2381             m_value.ident = CSSValueVisible;
2382             break;
2383         case HIDDEN:
2384             m_value.ident = CSSValueHidden;
2385             break;
2386         case COLLAPSE:
2387             m_value.ident = CSSValueCollapse;
2388             break;
2389     }
2390 }
2391
2392 template<> inline CSSPrimitiveValue::operator EVisibility() const
2393 {
2394     switch (m_value.ident) {
2395         case CSSValueHidden:
2396             return HIDDEN;
2397         case CSSValueVisible:
2398             return VISIBLE;
2399         case CSSValueCollapse:
2400             return COLLAPSE;
2401         default:
2402             ASSERT_NOT_REACHED();
2403             return VISIBLE;
2404     }
2405 }
2406
2407 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
2408     : CSSValue(PrimitiveClass)
2409 {
2410     m_primitiveUnitType = CSS_IDENT;
2411     switch (e) {
2412         case NORMAL:
2413             m_value.ident = CSSValueNormal;
2414             break;
2415         case PRE:
2416             m_value.ident = CSSValuePre;
2417             break;
2418         case PRE_WRAP:
2419             m_value.ident = CSSValuePreWrap;
2420             break;
2421         case PRE_LINE:
2422             m_value.ident = CSSValuePreLine;
2423             break;
2424         case NOWRAP:
2425             m_value.ident = CSSValueNowrap;
2426             break;
2427         case KHTML_NOWRAP:
2428             m_value.ident = CSSValueWebkitNowrap;
2429             break;
2430     }
2431 }
2432
2433 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
2434 {
2435     switch (m_value.ident) {
2436         case CSSValueWebkitNowrap:
2437             return KHTML_NOWRAP;
2438         case CSSValueNowrap:
2439             return NOWRAP;
2440         case CSSValuePre:
2441             return PRE;
2442         case CSSValuePreWrap:
2443             return PRE_WRAP;
2444         case CSSValuePreLine:
2445             return PRE_LINE;
2446         case CSSValueNormal:
2447             return NORMAL;
2448         default:
2449             ASSERT_NOT_REACHED();
2450             return NORMAL;
2451     }
2452 }
2453
2454 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
2455     : CSSValue(PrimitiveClass)
2456 {
2457     m_primitiveUnitType = CSS_IDENT;
2458     switch (e) {
2459         case NormalWordBreak:
2460             m_value.ident = CSSValueNormal;
2461             break;
2462         case BreakAllWordBreak:
2463             m_value.ident = CSSValueBreakAll;
2464             break;
2465         case BreakWordBreak:
2466             m_value.ident = CSSValueBreakWord;
2467             break;
2468     }
2469 }
2470
2471 template<> inline CSSPrimitiveValue::operator EWordBreak() const
2472 {
2473     switch (m_value.ident) {
2474         case CSSValueBreakAll:
2475             return BreakAllWordBreak;
2476         case CSSValueBreakWord:
2477             return BreakWordBreak;
2478         case CSSValueNormal:
2479             return NormalWordBreak;
2480         default:
2481         ASSERT_NOT_REACHED();
2482         return NormalWordBreak;
2483     }
2484 }
2485
2486 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordWrap e)
2487     : CSSValue(PrimitiveClass)
2488 {
2489     m_primitiveUnitType = CSS_IDENT;
2490     switch (e) {
2491         case NormalWordWrap:
2492             m_value.ident = CSSValueNormal;
2493             break;
2494         case BreakWordWrap:
2495             m_value.ident = CSSValueBreakWord;
2496             break;
2497     }
2498 }
2499
2500 template<> inline CSSPrimitiveValue::operator EWordWrap() const
2501 {
2502     switch (m_value.ident) {
2503         case CSSValueBreakWord:
2504             return BreakWordWrap;
2505         case CSSValueNormal:
2506             return NormalWordWrap;
2507         default:
2508             ASSERT_NOT_REACHED();
2509             return NormalWordWrap;
2510     }
2511 }
2512
2513 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
2514     : CSSValue(PrimitiveClass)
2515 {
2516     m_primitiveUnitType = CSS_IDENT;
2517     switch (e) {
2518         case LTR:
2519             m_value.ident = CSSValueLtr;
2520             break;
2521         case RTL:
2522             m_value.ident = CSSValueRtl;
2523             break;
2524     }
2525 }
2526
2527 template<> inline CSSPrimitiveValue::operator TextDirection() const
2528 {
2529     switch (m_value.ident) {
2530         case CSSValueLtr:
2531             return LTR;
2532         case CSSValueRtl:
2533             return RTL;
2534         default:
2535             ASSERT_NOT_REACHED();
2536             return LTR;
2537     }
2538 }
2539
2540 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
2541     : CSSValue(PrimitiveClass)
2542 {
2543     m_primitiveUnitType = CSS_IDENT;
2544     switch (e) {
2545     case TopToBottomWritingMode:
2546         m_value.ident = CSSValueHorizontalTb;
2547         break;
2548     case RightToLeftWritingMode:
2549         m_value.ident = CSSValueVerticalRl;
2550         break;
2551     case LeftToRightWritingMode:
2552         m_value.ident = CSSValueVerticalLr;
2553         break;
2554     case BottomToTopWritingMode:
2555         m_value.ident = CSSValueHorizontalBt;
2556         break;
2557     }
2558 }
2559
2560 template<> inline CSSPrimitiveValue::operator WritingMode() const
2561 {
2562     switch (m_value.ident) {
2563     case CSSValueHorizontalTb:
2564         return TopToBottomWritingMode;
2565     case CSSValueVerticalRl:
2566         return RightToLeftWritingMode;
2567     case CSSValueVerticalLr:
2568         return LeftToRightWritingMode;
2569     case CSSValueHorizontalBt:
2570         return BottomToTopWritingMode;
2571     default:
2572         ASSERT_NOT_REACHED();
2573         return TopToBottomWritingMode;
2574     }
2575 }
2576
2577 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
2578     : CSSValue(PrimitiveClass)
2579 {
2580     m_primitiveUnitType = CSS_IDENT;
2581     switch (e) {
2582     case TextCombineNone:
2583         m_value.ident = CSSValueNone;
2584         break;
2585     case TextCombineHorizontal:
2586         m_value.ident = CSSValueHorizontal;
2587         break;
2588     }
2589 }
2590
2591 template<> inline CSSPrimitiveValue::operator TextCombine() const
2592 {
2593     switch (m_value.ident) {
2594     case CSSValueNone:
2595         return TextCombineNone;
2596     case CSSValueHorizontal:
2597         return TextCombineHorizontal;
2598     default:
2599         ASSERT_NOT_REACHED();
2600         return TextCombineNone;
2601     }
2602 }
2603
2604 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
2605     : CSSValue(PrimitiveClass)
2606 {
2607     m_primitiveUnitType = CSS_IDENT;
2608     switch (position) {
2609     case TextEmphasisPositionOver:
2610         m_value.ident = CSSValueOver;
2611         break;
2612     case TextEmphasisPositionUnder:
2613         m_value.ident = CSSValueUnder;
2614         break;
2615     }
2616 }
2617
2618 template<> inline CSSPrimitiveValue::operator TextEmphasisPosition() const
2619 {
2620     switch (m_value.ident) {
2621     case CSSValueOver:
2622         return TextEmphasisPositionOver;
2623     case CSSValueUnder:
2624         return TextEmphasisPositionUnder;
2625     default:
2626         ASSERT_NOT_REACHED();
2627         return TextEmphasisPositionOver;
2628     }
2629 }
2630
2631 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
2632     : CSSValue(PrimitiveClass)
2633 {
2634     m_primitiveUnitType = CSS_IDENT;
2635     switch (overflow) {
2636     case TextOverflowClip:
2637         m_value.ident = CSSValueClip;
2638         break;
2639     case TextOverflowEllipsis:
2640         m_value.ident = CSSValueEllipsis;
2641         break;
2642     }
2643 }
2644
2645 template<> inline CSSPrimitiveValue::operator TextOverflow() const
2646 {
2647     switch (m_value.ident) {
2648     case CSSValueClip:
2649         return TextOverflowClip;
2650     case CSSValueEllipsis:
2651         return TextOverflowEllipsis;
2652     default:
2653         ASSERT_NOT_REACHED();
2654         return TextOverflowClip;
2655     }
2656 }
2657
2658 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
2659     : CSSValue(PrimitiveClass)
2660 {
2661     m_primitiveUnitType = CSS_IDENT;
2662     switch (fill) {
2663     case TextEmphasisFillFilled:
2664         m_value.ident = CSSValueFilled;
2665         break;
2666     case TextEmphasisFillOpen:
2667         m_value.ident = CSSValueOpen;
2668         break;
2669     }
2670 }
2671
2672 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
2673 {
2674     switch (m_value.ident) {
2675     case CSSValueFilled:
2676         return TextEmphasisFillFilled;
2677     case CSSValueOpen:
2678         return TextEmphasisFillOpen;
2679     default:
2680         ASSERT_NOT_REACHED();
2681         return TextEmphasisFillFilled;
2682     }
2683 }
2684
2685 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
2686     : CSSValue(PrimitiveClass)
2687 {
2688     m_primitiveUnitType = CSS_IDENT;
2689     switch (mark) {
2690     case TextEmphasisMarkDot:
2691         m_value.ident = CSSValueDot;
2692         break;
2693     case TextEmphasisMarkCircle:
2694         m_value.ident = CSSValueCircle;
2695         break;
2696     case TextEmphasisMarkDoubleCircle:
2697         m_value.ident = CSSValueDoubleCircle;
2698         break;
2699     case TextEmphasisMarkTriangle:
2700         m_value.ident = CSSValueTriangle;
2701         break;
2702     case TextEmphasisMarkSesame:
2703         m_value.ident = CSSValueSesame;
2704         break;
2705     case TextEmphasisMarkNone:
2706     case TextEmphasisMarkAuto:
2707     case TextEmphasisMarkCustom:
2708         ASSERT_NOT_REACHED();
2709         m_value.ident = CSSValueNone;
2710         break;
2711     }
2712 }
2713
2714 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
2715 {
2716     switch (m_value.ident) {
2717     case CSSValueNone:
2718         return TextEmphasisMarkNone;
2719     case CSSValueDot:
2720         return TextEmphasisMarkDot;
2721     case CSSValueCircle:
2722         return TextEmphasisMarkCircle;
2723     case CSSValueDoubleCircle:
2724         return TextEmphasisMarkDoubleCircle;
2725     case CSSValueTriangle:
2726         return TextEmphasisMarkTriangle;
2727     case CSSValueSesame:
2728         return TextEmphasisMarkSesame;
2729     default:
2730         ASSERT_NOT_REACHED();
2731         return TextEmphasisMarkNone;
2732     }
2733 }
2734
2735 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
2736     : CSSValue(PrimitiveClass)
2737 {
2738     m_primitiveUnitType = CSS_IDENT;
2739     switch (e) {
2740     case TextOrientationVerticalRight:
2741         m_value.ident = CSSValueVerticalRight;
2742         break;
2743     case TextOrientationUpright:
2744         m_value.ident = CSSValueUpright;
2745         break;
2746     }
2747 }
2748
2749 template<> inline CSSPrimitiveValue::operator TextOrientation() const
2750 {
2751     switch (m_value.ident) {
2752     case CSSValueVerticalRight:
2753         return TextOrientationVerticalRight;
2754     case CSSValueUpright:
2755         return TextOrientationUpright;
2756     default:
2757         ASSERT_NOT_REACHED();
2758         return TextOrientationVerticalRight;
2759     }
2760 }
2761
2762 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
2763     : CSSValue(PrimitiveClass)
2764 {
2765     m_primitiveUnitType = CSS_IDENT;
2766     switch (e) {
2767         case PE_NONE:
2768             m_value.ident = CSSValueNone;
2769             break;
2770         case PE_STROKE:
2771             m_value.ident = CSSValueStroke;
2772             break;
2773         case PE_FILL:
2774             m_value.ident = CSSValueFill;
2775             break;
2776         case PE_PAINTED:
2777             m_value.ident = CSSValuePainted;
2778             break;
2779         case PE_VISIBLE:
2780             m_value.ident = CSSValueVisible;
2781             break;
2782         case PE_VISIBLE_STROKE:
2783             m_value.ident = CSSValueVisiblestroke;
2784             break;
2785         case PE_VISIBLE_FILL:
2786             m_value.ident = CSSValueVisiblefill;
2787             break;
2788         case PE_VISIBLE_PAINTED:
2789             m_value.ident = CSSValueVisiblepainted;
2790             break;
2791         case PE_AUTO:
2792             m_value.ident = CSSValueAuto;
2793             break;
2794         case PE_ALL:
2795             m_value.ident = CSSValueAll;
2796             break;
2797     }
2798 }
2799
2800 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
2801 {
2802     switch (m_value.ident) {
2803         case CSSValueAll:
2804             return PE_ALL;
2805         case CSSValueAuto:
2806             return PE_AUTO;
2807         case CSSValueNone:
2808             return PE_NONE;
2809         case CSSValueVisiblepainted:
2810             return PE_VISIBLE_PAINTED;
2811         case CSSValueVisiblefill:
2812             return PE_VISIBLE_FILL;
2813         case CSSValueVisiblestroke:
2814             return PE_VISIBLE_STROKE;
2815         case CSSValueVisible:
2816             return PE_VISIBLE;
2817         case CSSValuePainted:
2818             return PE_PAINTED;
2819         case CSSValueFill:
2820             return PE_FILL;
2821         case CSSValueStroke:
2822             return PE_STROKE;
2823         default:
2824             ASSERT_NOT_REACHED();
2825             return PE_ALL;
2826     }
2827 }
2828
2829 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
2830     : CSSValue(PrimitiveClass)
2831 {
2832     m_primitiveUnitType = CSS_IDENT;
2833     switch (smoothing) {
2834     case AutoSmoothing:
2835         m_value.ident = CSSValueAuto;
2836         return;
2837     case NoSmoothing:
2838         m_value.ident = CSSValueNone;
2839         return;
2840     case Antialiased:
2841         m_value.ident = CSSValueAntialiased;
2842         return;
2843     case SubpixelAntialiased:
2844         m_value.ident = CSSValueSubpixelAntialiased;
2845         return;
2846     }
2847
2848     ASSERT_NOT_REACHED();
2849     m_value.ident = CSSValueAuto;
2850 }
2851
2852 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
2853 {
2854     switch (m_value.ident) {
2855     case CSSValueAuto:
2856         return AutoSmoothing;
2857     case CSSValueNone:
2858         return NoSmoothing;
2859     case CSSValueAntialiased:
2860         return Antialiased;
2861     case CSSValueSubpixelAntialiased:
2862         return SubpixelAntialiased;
2863     }
2864
2865     ASSERT_NOT_REACHED();
2866     return AutoSmoothing;
2867 }
2868
2869 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
2870     : CSSValue(PrimitiveClass)
2871 {
2872     m_primitiveUnitType = CSS_IDENT;
2873     switch (weight) {
2874     case FontWeight900:
2875         m_value.ident = CSSValue900;
2876         return;
2877     case FontWeight800:
2878         m_value.ident = CSSValue800;
2879         return;
2880     case FontWeight700:
2881         m_value.ident = CSSValue700;
2882         return;
2883     case FontWeight600:
2884         m_value.ident = CSSValue600;
2885         return;
2886     case FontWeight500:
2887         m_value.ident = CSSValue500;
2888         return;
2889     case FontWeight400:
2890         m_value.ident = CSSValue400;
2891         return;
2892     case FontWeight300:
2893         m_value.ident = CSSValue300;
2894         return;
2895     case FontWeight200:
2896         m_value.ident = CSSValue200;
2897         return;
2898     case FontWeight100:
2899         m_value.ident = CSSValue100;
2900         return;
2901     }
2902
2903     ASSERT_NOT_REACHED();
2904     m_value.ident = CSSValueNormal;
2905 }
2906
2907 template<> inline CSSPrimitiveValue::operator FontWeight() const
2908 {
2909     switch (m_value.ident) {
2910     case CSSValueBold:
2911         return FontWeightBold;
2912     case CSSValueNormal:
2913         return FontWeightNormal;
2914     case CSSValue900:
2915         return FontWeight900;
2916     case CSSValue800:
2917         return FontWeight800;
2918     case CSSValue700:
2919         return FontWeight700;
2920     case CSSValue600:
2921         return FontWeight600;
2922     case CSSValue500:
2923         return FontWeight500;
2924     case CSSValue400:
2925         return FontWeight400;
2926     case CSSValue300:
2927         return FontWeight300;
2928     case CSSValue200:
2929         return FontWeight200;
2930     case CSSValue100:
2931         return FontWeight100;
2932     }
2933
2934     ASSERT_NOT_REACHED();
2935     return FontWeightNormal;
2936 }
2937
2938 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic)
2939     : CSSValue(PrimitiveClass)
2940 {
2941     m_primitiveUnitType = CSS_IDENT;
2942     switch (italic) {
2943     case FontItalicOff:
2944         m_value.ident = CSSValueNormal;
2945         return;
2946     case FontItalicOn:
2947         m_value.ident = CSSValueItalic;
2948         return;
2949     }
2950
2951     ASSERT_NOT_REACHED();
2952     m_value.ident = CSSValueNormal;
2953 }
2954
2955 template<> inline CSSPrimitiveValue::operator FontItalic() const
2956 {
2957     switch (m_value.ident) {
2958     case CSSValueOblique:
2959     // FIXME: oblique is the same as italic for the moment...
2960     case CSSValueItalic:
2961         return FontItalicOn;
2962     case CSSValueNormal:
2963         return FontItalicOff;
2964     }
2965     ASSERT_NOT_REACHED();
2966     return FontItalicOff;
2967 }
2968
2969 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
2970     : CSSValue(PrimitiveClass)
2971 {
2972     m_primitiveUnitType = CSS_IDENT;
2973     switch (smallCaps) {
2974     case FontSmallCapsOff:
2975         m_value.ident = CSSValueNormal;
2976         return;
2977     case FontSmallCapsOn:
2978         m_value.ident = CSSValueSmallCaps;
2979         return;
2980     }
2981
2982     ASSERT_NOT_REACHED();
2983     m_value.ident = CSSValueNormal;
2984 }
2985
2986 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
2987 {
2988     switch (m_value.ident) {
2989     case CSSValueSmallCaps:
2990         return FontSmallCapsOn;
2991     case CSSValueNormal:
2992         return FontSmallCapsOff;
2993     }
2994     ASSERT_NOT_REACHED();
2995     return FontSmallCapsOff;
2996 }
2997
2998 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
2999     : CSSValue(PrimitiveClass)
3000 {
3001     m_primitiveUnitType = CSS_IDENT;
3002     switch (e) {
3003         case AutoTextRendering:
3004             m_value.ident = CSSValueAuto;
3005             break;
3006         case OptimizeSpeed:
3007             m_value.ident = CSSValueOptimizespeed;
3008             break;
3009         case OptimizeLegibility:
3010             m_value.ident = CSSValueOptimizelegibility;
3011             break;
3012         case GeometricPrecision:
3013             m_value.ident = CSSValueGeometricprecision;
3014             break;
3015     }
3016 }
3017
3018 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3019 {
3020     switch (m_value.ident) {
3021         case CSSValueAuto:
3022             return AutoTextRendering;
3023         case CSSValueOptimizespeed:
3024             return OptimizeSpeed;
3025         case CSSValueOptimizelegibility:
3026             return OptimizeLegibility;
3027         case CSSValueGeometricprecision:
3028             return GeometricPrecision;
3029         default:
3030             ASSERT_NOT_REACHED();
3031             return AutoTextRendering;
3032     }
3033 }
3034
3035 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColorSpace space)
3036     : CSSValue(PrimitiveClass)
3037 {
3038     m_primitiveUnitType = CSS_IDENT;
3039     switch (space) {
3040     case ColorSpaceDeviceRGB:
3041         m_value.ident = CSSValueDefault;
3042         break;
3043     case ColorSpaceSRGB:
3044         m_value.ident = CSSValueSrgb;
3045         break;
3046     case ColorSpaceLinearRGB:
3047         // CSS color correction does not support linearRGB yet.
3048         ASSERT_NOT_REACHED();
3049         m_value.ident = CSSValueDefault;
3050         break;
3051     }
3052 }
3053
3054 template<> inline CSSPrimitiveValue::operator ColorSpace() const
3055 {
3056     switch (m_value.ident) {
3057     case CSSValueDefault:
3058         return ColorSpaceDeviceRGB;
3059     case CSSValueSrgb:
3060         return ColorSpaceSRGB;
3061     default:
3062         ASSERT_NOT_REACHED();
3063         return ColorSpaceDeviceRGB;
3064     }
3065 }
3066
3067 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3068     : CSSValue(PrimitiveClass)
3069 {
3070     m_primitiveUnitType = CSS_IDENT;
3071     switch (hyphens) {
3072     case HyphensNone:
3073         m_value.ident = CSSValueNone;
3074         break;
3075     case HyphensManual:
3076         m_value.ident = CSSValueManual;
3077         break;
3078     case HyphensAuto:
3079         m_value.ident = CSSValueAuto;
3080         break;
3081     }
3082 }
3083
3084 template<> inline CSSPrimitiveValue::operator Hyphens() const
3085 {
3086     switch (m_value.ident) {
3087     case CSSValueNone:
3088         return HyphensNone;
3089     case CSSValueManual:
3090         return HyphensManual;
3091     case CSSValueAuto:
3092         return HyphensAuto;
3093     default:
3094         ASSERT_NOT_REACHED();
3095         return HyphensAuto;
3096     }
3097 }
3098
3099 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineGridSnap gridSnap)
3100     : CSSValue(PrimitiveClass)
3101 {
3102     m_primitiveUnitType = CSS_IDENT;
3103     switch (gridSnap) {
3104     case LineGridSnapNone:
3105         m_value.ident = CSSValueNone;
3106         break;
3107     case LineGridSnapBaseline:
3108         m_value.ident = CSSValueBaseline;
3109         break;
3110     case LineGridSnapBounds:
3111         m_value.ident = CSSValueBounds;
3112         break;
3113     }
3114 }
3115
3116 template<> inline CSSPrimitiveValue::operator LineGridSnap() const
3117 {
3118     switch (m_value.ident) {
3119     case CSSValueNone:
3120         return LineGridSnapNone;
3121     case CSSValueBaseline:
3122         return LineGridSnapBaseline;
3123     case CSSValueBounds:
3124         return LineGridSnapBounds;
3125     default:
3126         ASSERT_NOT_REACHED();
3127         return LineGridSnapNone;
3128     }
3129 }
3130
3131 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3132     : CSSValue(PrimitiveClass)
3133 {
3134     m_primitiveUnitType = CSS_IDENT;
3135     switch (e) {
3136     case SpeakNone:
3137         m_value.ident = CSSValueNone;
3138         break;
3139     case SpeakNormal:
3140         m_value.ident = CSSValueNormal;
3141         break;
3142     case SpeakSpellOut:
3143         m_value.ident = CSSValueSpellOut;
3144         break;
3145     case SpeakDigits:
3146         m_value.ident = CSSValueDigits;
3147         break;
3148     case SpeakLiteralPunctuation:
3149         m_value.ident = CSSValueLiteralPunctuation;
3150         break;
3151     case SpeakNoPunctuation:
3152         m_value.ident = CSSValueNoPunctuation;
3153         break;
3154     }
3155 }
3156
3157 template<> inline CSSPrimitiveValue::operator Order() const
3158 {
3159     switch (m_value.ident) {
3160     case CSSValueLogical:
3161         return LogicalOrder;
3162     case CSSValueVisual:
3163         return VisualOrder;
3164     default:
3165         ASSERT_NOT_REACHED();
3166         return LogicalOrder;
3167     }
3168 }
3169
3170 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
3171     : CSSValue(PrimitiveClass)
3172 {
3173     m_primitiveUnitType = CSS_IDENT;
3174     switch (e) {
3175     case LogicalOrder:
3176         m_value.ident = CSSValueLogical;
3177         break;
3178     case VisualOrder:
3179         m_value.ident = CSSValueVisual;
3180         break;
3181     }
3182 }
3183
3184 template<> inline CSSPrimitiveValue::operator ESpeak() const
3185 {
3186     switch (m_value.ident) {
3187     case CSSValueNone:
3188         return SpeakNone;
3189     case CSSValueNormal:
3190         return SpeakNormal;
3191     case CSSValueSpellOut:
3192         return SpeakSpellOut;
3193     case CSSValueDigits:
3194         return SpeakDigits;
3195     case CSSValueLiteralPunctuation:
3196         return SpeakLiteralPunctuation;
3197     case CSSValueNoPunctuation:
3198         return SpeakNoPunctuation;
3199     default:
3200         ASSERT_NOT_REACHED();
3201         return SpeakNormal;
3202     }
3203 }
3204
3205 #if ENABLE(CSS_SHADERS)
3206 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CustomFilterOperation::MeshBoxType meshBoxType)
3207     : CSSValue(PrimitiveClass)
3208 {
3209     m_primitiveUnitType = CSS_IDENT;
3210     switch (meshBoxType) {
3211     case CustomFilterOperation::FILTER_BOX:
3212         m_value.ident = CSSValueFilterBox;
3213         break;
3214     case CustomFilterOperation::BORDER_BOX:
3215         m_value.ident = CSSValueBorderBox;
3216         break;
3217     case CustomFilterOperation::PADDING_BOX:
3218         m_value.ident = CSSValuePaddingBox;
3219         break;
3220     case CustomFilterOperation::CONTENT_BOX:
3221         m_value.ident = CSSValueContentBox;
3222         break;
3223     }
3224 }
3225
3226 template<> inline CSSPrimitiveValue::operator CustomFilterOperation::MeshBoxType() const
3227 {
3228     switch (m_value.ident) {
3229     case CSSValueFilterBox:
3230         return CustomFilterOperation::FILTER_BOX;
3231     case CSSValueBorderBox:
3232         return CustomFilterOperation::BORDER_BOX;
3233     case CSSValuePaddingBox:
3234         return CustomFilterOperation::PADDING_BOX;
3235     case CSSValueContentBox:
3236         return CustomFilterOperation::CONTENT_BOX;
3237     default:
3238         ASSERT_NOT_REACHED();
3239         return CustomFilterOperation::FILTER_BOX;
3240     }
3241 }
3242 #endif // ENABLE(CSS_SHADERS)
3243
3244 #if ENABLE(SVG)
3245
3246 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
3247     : CSSValue(PrimitiveClass)
3248 {
3249     m_primitiveUnitType = CSS_IDENT;
3250     switch (e) {
3251         case ButtCap:
3252             m_value.ident = CSSValueButt;
3253             break;
3254         case RoundCap:
3255             m_value.ident = CSSValueRound;
3256             break;
3257         case SquareCap:
3258             m_value.ident = CSSValueSquare;
3259             break;
3260     }
3261 }
3262
3263 template<> inline CSSPrimitiveValue::operator LineCap() const
3264 {
3265     switch (m_value.ident) {
3266         case CSSValueButt:
3267             return ButtCap;
3268         case CSSValueRound:
3269             return RoundCap;
3270         case CSSValueSquare:
3271             return SquareCap;
3272         default:
3273             ASSERT_NOT_REACHED();
3274             return ButtCap;
3275     }
3276 }
3277
3278 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
3279     : CSSValue(PrimitiveClass)
3280 {
3281     m_primitiveUnitType = CSS_IDENT;
3282     switch (e) {
3283         case MiterJoin:
3284             m_value.ident = CSSValueMiter;
3285             break;
3286         case RoundJoin:
3287             m_value.ident = CSSValueRound;
3288             break;
3289         case BevelJoin:
3290             m_value.ident = CSSValueBevel;
3291             break;
3292     }
3293 }
3294
3295 template<> inline CSSPrimitiveValue::operator LineJoin() const
3296 {
3297     switch (m_value.ident) {
3298         case CSSValueMiter:
3299             return MiterJoin;
3300         case CSSValueRound:
3301             return RoundJoin;
3302         case CSSValueBevel:
3303             return BevelJoin;
3304         default:
3305             ASSERT_NOT_REACHED();
3306             return MiterJoin;
3307     }
3308 }
3309
3310 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
3311     : CSSValue(PrimitiveClass)
3312 {
3313     m_primitiveUnitType = CSS_IDENT;
3314     switch (e) {
3315         case RULE_NONZERO:
3316             m_value.ident = CSSValueNonzero;
3317             break;
3318         case RULE_EVENODD:
3319             m_value.ident = CSSValueEvenodd;
3320             break;
3321     }
3322 }
3323
3324 template<> inline CSSPrimitiveValue::operator WindRule() const
3325 {
3326     switch (m_value.ident) {
3327         case CSSValueNonzero:
3328             return RULE_NONZERO;
3329         case CSSValueEvenodd:
3330             return RULE_EVENODD;
3331         default:
3332             ASSERT_NOT_REACHED();
3333             return RULE_NONZERO;
3334     }
3335 }
3336
3337
3338 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
3339     : CSSValue(PrimitiveClass)
3340 {
3341     m_primitiveUnitType = CSS_IDENT;
3342     switch (e) {
3343         case AB_AUTO:
3344             m_value.ident = CSSValueAuto;
3345             break;
3346         case AB_BASELINE:
3347             m_value.ident = CSSValueBaseline;
3348             break;
3349         case AB_BEFORE_EDGE:
3350             m_value.ident = CSSValueBeforeEdge;
3351             break;
3352         case AB_TEXT_BEFORE_EDGE:
3353             m_value.ident = CSSValueTextBeforeEdge;
3354             break;
3355         case AB_MIDDLE:
3356             m_value.ident = CSSValueMiddle;
3357             break;
3358         case AB_CENTRAL:
3359             m_value.ident = CSSValueCentral;
3360             break;
3361         case AB_AFTER_EDGE:
3362             m_value.ident = CSSValueAfterEdge;
3363             break;
3364         case AB_TEXT_AFTER_EDGE:
3365             m_value.ident = CSSValueTextAfterEdge;
3366             break;
3367         case AB_IDEOGRAPHIC:
3368             m_value.ident = CSSValueIdeographic;
3369             break;
3370         case AB_ALPHABETIC:
3371             m_value.ident = CSSValueAlphabetic;
3372             break;
3373         case AB_HANGING:
3374             m_value.ident = CSSValueHanging;
3375             break;
3376         case AB_MATHEMATICAL:
3377             m_value.ident = CSSValueMathematical;
3378             break;
3379     }
3380 }
3381
3382 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
3383 {
3384     switch (m_value.ident) {
3385         case CSSValueAuto:
3386             return AB_AUTO;
3387         case CSSValueBaseline:
3388             return AB_BASELINE;
3389         case CSSValueBeforeEdge:
3390             return AB_BEFORE_EDGE;
3391         case CSSValueTextBeforeEdge:
3392             return AB_TEXT_BEFORE_EDGE;
3393         case CSSValueMiddle:
3394             return AB_MIDDLE;
3395         case CSSValueCentral:
3396             return AB_CENTRAL;
3397         case CSSValueAfterEdge:
3398             return AB_AFTER_EDGE;
3399         case CSSValueTextAfterEdge:
3400             return AB_TEXT_AFTER_EDGE;
3401         case CSSValueIdeographic:
3402             return AB_IDEOGRAPHIC;
3403         case CSSValueAlphabetic:
3404             return AB_ALPHABETIC;
3405         case CSSValueHanging:
3406             return AB_HANGING;
3407         case CSSValueMathematical:
3408             return AB_MATHEMATICAL;
3409         default:
3410             ASSERT_NOT_REACHED();
3411             return AB_AUTO;
3412     }
3413 }
3414
3415 #endif
3416
3417 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
3418     : CSSValue(PrimitiveClass)
3419 {
3420     m_primitiveUnitType = CSS_IDENT;
3421     switch (e) {
3422     case BSEPARATE:
3423         m_value.ident = CSSValueSeparate;
3424         break;
3425     case BCOLLAPSE:
3426         m_value.ident = CSSValueCollapse;
3427         break;
3428     }
3429 }
3430
3431 template<> inline CSSPrimitiveValue::operator EBorderCollapse() const
3432 {
3433     switch (m_value.ident) {
3434     case CSSValueSeparate:
3435         return BSEPARATE;
3436     case CSSValueCollapse:
3437         return BCOLLAPSE;
3438     default:
3439         ASSERT_NOT_REACHED();
3440         return BSEPARATE;
3441     }
3442 }
3443
3444 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderFit e)
3445     : CSSValue(PrimitiveClass)
3446 {
3447     m_primitiveUnitType = CSS_IDENT;
3448     switch (e) {
3449     case BorderFitBorder:
3450         m_value.ident = CSSValueBorder;
3451         break;
3452     case BorderFitLines:
3453         m_value.ident = CSSValueLines;
3454         break;
3455     }
3456 }
3457
3458 template<> inline CSSPrimitiveValue::operator EBorderFit() const
3459 {
3460     switch (m_value.ident) {
3461     case CSSValueBorder:
3462         return BorderFitBorder;
3463     case CSSValueLines:
3464         return BorderFitLines;
3465     default:
3466         ASSERT_NOT_REACHED();
3467         return BorderFitLines;
3468     }
3469 }
3470
3471 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
3472     : CSSValue(PrimitiveClass)
3473 {