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