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