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