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