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