f8444ca6a38b4e45e3fd4976460aeb705c1d299b
[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 AlignStart:
1162         m_value.ident = CSSValueStart;
1163         break;
1164     case AlignEnd:
1165         m_value.ident = CSSValueEnd;
1166         break;
1167     case AlignCenter:
1168         m_value.ident = CSSValueCenter;
1169         break;
1170     case AlignStretch:
1171         m_value.ident = CSSValueStretch;
1172         break;
1173     case AlignBaseline:
1174         m_value.ident = CSSValueBaseline;
1175         break;
1176     }
1177 }
1178
1179 template<> inline CSSPrimitiveValue::operator EFlexAlign() const
1180 {
1181     switch (m_value.ident) {
1182     case CSSValueStart:
1183         return AlignStart;
1184     case CSSValueEnd:
1185         return AlignEnd;
1186     case CSSValueCenter:
1187         return AlignCenter;
1188     case CSSValueStretch:
1189         return AlignStretch;
1190     case CSSValueBaseline:
1191         return AlignBaseline;
1192     default:
1193         ASSERT_NOT_REACHED();
1194         return AlignStart;
1195     }
1196 }
1197
1198 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexPack e)
1199     : CSSValue(PrimitiveClass)
1200 {
1201     m_primitiveUnitType = CSS_IDENT;
1202     switch (e) {
1203     case PackStart:
1204         m_value.ident = CSSValueStart;
1205         break;
1206     case PackEnd:
1207         m_value.ident = CSSValueEnd;
1208         break;
1209     case PackCenter:
1210         m_value.ident = CSSValueCenter;
1211         break;
1212     case PackJustify:
1213         m_value.ident = CSSValueJustify;
1214         break;
1215     }
1216 }
1217
1218 template<> inline CSSPrimitiveValue::operator EFlexPack() const
1219 {
1220     switch (m_value.ident) {
1221     case CSSValueStart:
1222         return PackStart;
1223     case CSSValueEnd:
1224         return PackEnd;
1225     case CSSValueCenter:
1226         return PackCenter;
1227     case CSSValueJustify:
1228         return PackJustify;
1229     default:
1230         ASSERT_NOT_REACHED();
1231         return PackStart;
1232     }
1233 }
1234
1235 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
1236     : CSSValue(PrimitiveClass)
1237 {
1238     m_primitiveUnitType = CSS_IDENT;
1239     switch (e) {
1240     case FlowRow:
1241         m_value.ident = CSSValueRow;
1242         break;
1243     case FlowRowReverse:
1244         m_value.ident = CSSValueRowReverse;
1245         break;
1246     case FlowColumn:
1247         m_value.ident = CSSValueColumn;
1248         break;
1249     case FlowColumnReverse:
1250         m_value.ident = CSSValueColumnReverse;
1251         break;
1252     }
1253 }
1254
1255 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1256 {
1257     switch (m_value.ident) {
1258     case CSSValueRow:
1259         return FlowRow;
1260     case CSSValueRowReverse:
1261         return FlowRowReverse;
1262     case CSSValueColumn:
1263         return FlowColumn;
1264     case CSSValueColumnReverse:
1265         return FlowColumnReverse;
1266     default:
1267         ASSERT_NOT_REACHED();
1268         return FlowRow;
1269     }
1270 }
1271
1272 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1273     : CSSValue(PrimitiveClass)
1274 {
1275     m_primitiveUnitType = CSS_IDENT;
1276     switch (e) {
1277     case FlexNoWrap:
1278         m_value.ident = CSSValueNowrap;
1279         break;
1280     case FlexWrap:
1281         m_value.ident = CSSValueWrap;
1282         break;
1283     case FlexWrapReverse:
1284         m_value.ident = CSSValueWrapReverse;
1285         break;
1286     }
1287 }
1288
1289 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1290 {
1291     switch (m_value.ident) {
1292     case CSSValueNowrap:
1293         return FlexNoWrap;
1294     case CSSValueWrap:
1295         return FlexWrap;
1296     case CSSValueWrapReverse:
1297         return FlexWrapReverse;
1298     default:
1299         ASSERT_NOT_REACHED();
1300         return FlexNoWrap;
1301     }
1302 }
1303
1304 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1305     : CSSValue(PrimitiveClass)
1306 {
1307     m_primitiveUnitType = CSS_IDENT;
1308     switch (e) {
1309         case NoFloat:
1310             m_value.ident = CSSValueNone;
1311             break;
1312         case LeftFloat:
1313             m_value.ident = CSSValueLeft;
1314             break;
1315         case RightFloat:
1316             m_value.ident = CSSValueRight;
1317             break;
1318         case PositionedFloat:
1319             m_value.ident = CSSValueWebkitPositioned;
1320             break;
1321     }
1322 }
1323
1324 template<> inline CSSPrimitiveValue::operator EFloat() const
1325 {
1326     switch (m_value.ident) {
1327         case CSSValueLeft:
1328             return LeftFloat;
1329         case CSSValueRight:
1330             return RightFloat;
1331         case CSSValueNone:
1332         case CSSValueCenter:  // Non-standard CSS value
1333             return NoFloat;
1334         case CSSValueWebkitPositioned:
1335             return PositionedFloat;
1336         default:
1337             ASSERT_NOT_REACHED();
1338             return NoFloat;
1339     }
1340 }
1341
1342 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EKHTMLLineBreak e)
1343     : CSSValue(PrimitiveClass)
1344 {
1345     m_primitiveUnitType = CSS_IDENT;
1346     switch (e) {
1347         case LBNORMAL:
1348             m_value.ident = CSSValueNormal;
1349             break;
1350         case AFTER_WHITE_SPACE:
1351             m_value.ident = CSSValueAfterWhiteSpace;
1352             break;
1353     }
1354 }
1355
1356 template<> inline CSSPrimitiveValue::operator EKHTMLLineBreak() const
1357 {
1358     switch (m_value.ident) {
1359         case CSSValueAfterWhiteSpace:
1360             return AFTER_WHITE_SPACE;
1361         case CSSValueNormal:
1362             return LBNORMAL;
1363         default:
1364             ASSERT_NOT_REACHED();
1365             return LBNORMAL;
1366     }
1367 }
1368
1369 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1370     : CSSValue(PrimitiveClass)
1371 {
1372     m_primitiveUnitType = CSS_IDENT;
1373     switch (e) {
1374         case OUTSIDE:
1375             m_value.ident = CSSValueOutside;
1376             break;
1377         case INSIDE:
1378             m_value.ident = CSSValueInside;
1379             break;
1380     }
1381 }
1382
1383 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1384 {
1385     return (EListStylePosition)(m_value.ident - CSSValueOutside);
1386 }
1387
1388 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1389     : CSSValue(PrimitiveClass)
1390 {
1391     m_primitiveUnitType = CSS_IDENT;
1392     switch (e) {
1393     case Afar:
1394         m_value.ident = CSSValueAfar;
1395         break;
1396     case Amharic:
1397         m_value.ident = CSSValueAmharic;
1398         break;
1399     case AmharicAbegede:
1400         m_value.ident = CSSValueAmharicAbegede;
1401         break;
1402     case ArabicIndic:
1403         m_value.ident = CSSValueArabicIndic;
1404         break;
1405     case Armenian:
1406         m_value.ident = CSSValueArmenian;
1407         break;
1408     case Asterisks:
1409         m_value.ident = CSSValueAsterisks;
1410         break;
1411     case BinaryListStyle:
1412         m_value.ident = CSSValueBinary;
1413         break;
1414     case Bengali:
1415         m_value.ident = CSSValueBengali;
1416         break;
1417     case Cambodian:
1418         m_value.ident = CSSValueCambodian;
1419         break;
1420     case Circle:
1421         m_value.ident = CSSValueCircle;
1422         break;
1423     case CjkEarthlyBranch:
1424         m_value.ident = CSSValueCjkEarthlyBranch;
1425         break;
1426     case CjkHeavenlyStem:
1427         m_value.ident = CSSValueCjkHeavenlyStem;
1428         break;
1429     case CJKIdeographic:
1430         m_value.ident = CSSValueCjkIdeographic;
1431         break;
1432     case DecimalLeadingZero:
1433         m_value.ident = CSSValueDecimalLeadingZero;
1434         break;
1435     case DecimalListStyle:
1436         m_value.ident = CSSValueDecimal;
1437         break;
1438     case Devanagari:
1439         m_value.ident = CSSValueDevanagari;
1440         break;
1441     case Disc:
1442         m_value.ident = CSSValueDisc;
1443         break;
1444     case Ethiopic:
1445         m_value.ident = CSSValueEthiopic;
1446         break;
1447     case EthiopicAbegede:
1448         m_value.ident = CSSValueEthiopicAbegede;
1449         break;
1450     case EthiopicAbegedeAmEt:
1451         m_value.ident = CSSValueEthiopicAbegedeAmEt;
1452         break;
1453     case EthiopicAbegedeGez:
1454         m_value.ident = CSSValueEthiopicAbegedeGez;
1455         break;
1456     case EthiopicAbegedeTiEr:
1457         m_value.ident = CSSValueEthiopicAbegedeTiEr;
1458         break;
1459     case EthiopicAbegedeTiEt:
1460         m_value.ident = CSSValueEthiopicAbegedeTiEt;
1461         break;
1462     case EthiopicHalehameAaEr:
1463         m_value.ident = CSSValueEthiopicHalehameAaEr;
1464         break;
1465     case EthiopicHalehameAaEt:
1466         m_value.ident = CSSValueEthiopicHalehameAaEt;
1467         break;
1468     case EthiopicHalehameAmEt:
1469         m_value.ident = CSSValueEthiopicHalehameAmEt;
1470         break;
1471     case EthiopicHalehameGez:
1472         m_value.ident = CSSValueEthiopicHalehameGez;
1473         break;
1474     case EthiopicHalehameOmEt:
1475         m_value.ident = CSSValueEthiopicHalehameOmEt;
1476         break;
1477     case EthiopicHalehameSidEt:
1478         m_value.ident = CSSValueEthiopicHalehameSidEt;
1479         break;
1480     case EthiopicHalehameSoEt:
1481         m_value.ident = CSSValueEthiopicHalehameSoEt;
1482         break;
1483     case EthiopicHalehameTiEr:
1484         m_value.ident = CSSValueEthiopicHalehameTiEr;
1485         break;
1486     case EthiopicHalehameTiEt:
1487         m_value.ident = CSSValueEthiopicHalehameTiEt;
1488         break;
1489     case EthiopicHalehameTig:
1490         m_value.ident = CSSValueEthiopicHalehameTig;
1491         break;
1492     case Footnotes:
1493         m_value.ident = CSSValueFootnotes;
1494         break;
1495     case Georgian:
1496         m_value.ident = CSSValueGeorgian;
1497         break;
1498     case Gujarati:
1499         m_value.ident = CSSValueGujarati;
1500         break;
1501     case Gurmukhi:
1502         m_value.ident = CSSValueGurmukhi;
1503         break;
1504     case Hangul:
1505         m_value.ident = CSSValueHangul;
1506         break;
1507     case HangulConsonant:
1508         m_value.ident = CSSValueHangulConsonant;
1509         break;
1510     case Hebrew:
1511         m_value.ident = CSSValueHebrew;
1512         break;
1513     case Hiragana:
1514         m_value.ident = CSSValueHiragana;
1515         break;
1516     case HiraganaIroha:
1517         m_value.ident = CSSValueHiraganaIroha;
1518         break;
1519     case Kannada:
1520         m_value.ident = CSSValueKannada;
1521         break;
1522     case Katakana:
1523         m_value.ident = CSSValueKatakana;
1524         break;
1525     case KatakanaIroha:
1526         m_value.ident = CSSValueKatakanaIroha;
1527         break;
1528     case Khmer:
1529         m_value.ident = CSSValueKhmer;
1530         break;
1531     case Lao:
1532         m_value.ident = CSSValueLao;
1533         break;
1534     case LowerAlpha:
1535         m_value.ident = CSSValueLowerAlpha;
1536         break;
1537     case LowerArmenian:
1538         m_value.ident = CSSValueLowerArmenian;
1539         break;
1540     case LowerGreek:
1541         m_value.ident = CSSValueLowerGreek;
1542         break;
1543     case LowerHexadecimal:
1544         m_value.ident = CSSValueLowerHexadecimal;
1545         break;
1546     case LowerLatin:
1547         m_value.ident = CSSValueLowerLatin;
1548         break;
1549     case LowerNorwegian:
1550         m_value.ident = CSSValueLowerNorwegian;
1551         break;
1552     case LowerRoman:
1553         m_value.ident = CSSValueLowerRoman;
1554         break;
1555     case Malayalam:
1556         m_value.ident = CSSValueMalayalam;
1557         break;
1558     case Mongolian:
1559         m_value.ident = CSSValueMongolian;
1560         break;
1561     case Myanmar:
1562         m_value.ident = CSSValueMyanmar;
1563         break;
1564     case NoneListStyle:
1565         m_value.ident = CSSValueNone;
1566         break;
1567     case Octal:
1568         m_value.ident = CSSValueOctal;
1569         break;
1570     case Oriya:
1571         m_value.ident = CSSValueOriya;
1572         break;
1573     case Oromo:
1574         m_value.ident = CSSValueOromo;
1575         break;
1576     case Persian:
1577         m_value.ident = CSSValuePersian;
1578         break;
1579     case Sidama:
1580         m_value.ident = CSSValueSidama;
1581         break;
1582     case Somali:
1583         m_value.ident = CSSValueSomali;
1584         break;
1585     case Square:
1586         m_value.ident = CSSValueSquare;
1587         break;
1588     case Telugu:
1589         m_value.ident = CSSValueTelugu;
1590         break;
1591     case Thai:
1592         m_value.ident = CSSValueThai;
1593         break;
1594     case Tibetan:
1595         m_value.ident = CSSValueTibetan;
1596         break;
1597     case Tigre:
1598         m_value.ident = CSSValueTigre;
1599         break;
1600     case TigrinyaEr:
1601         m_value.ident = CSSValueTigrinyaEr;
1602         break;
1603     case TigrinyaErAbegede:
1604         m_value.ident = CSSValueTigrinyaErAbegede;
1605         break;
1606     case TigrinyaEt:
1607         m_value.ident = CSSValueTigrinyaEt;
1608         break;
1609     case TigrinyaEtAbegede:
1610         m_value.ident = CSSValueTigrinyaEtAbegede;
1611         break;
1612     case UpperAlpha:
1613         m_value.ident = CSSValueUpperAlpha;
1614         break;
1615     case UpperArmenian:
1616         m_value.ident = CSSValueUpperArmenian;
1617         break;
1618     case UpperGreek:
1619         m_value.ident = CSSValueUpperGreek;
1620         break;
1621     case UpperHexadecimal:
1622         m_value.ident = CSSValueUpperHexadecimal;
1623         break;
1624     case UpperLatin:
1625         m_value.ident = CSSValueUpperLatin;
1626         break;
1627     case UpperNorwegian:
1628         m_value.ident = CSSValueUpperNorwegian;
1629         break;
1630     case UpperRoman:
1631         m_value.ident = CSSValueUpperRoman;
1632         break;
1633     case Urdu:
1634         m_value.ident = CSSValueUrdu;
1635         break;
1636     }
1637 }
1638
1639 template<> inline CSSPrimitiveValue::operator EListStyleType() const
1640 {
1641     switch (m_value.ident) {
1642         case CSSValueNone:
1643             return NoneListStyle;
1644         default:
1645             return static_cast<EListStyleType>(m_value.ident - CSSValueDisc);
1646     }
1647 }
1648
1649 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
1650     : CSSValue(PrimitiveClass)
1651 {
1652     m_primitiveUnitType = CSS_IDENT;
1653     switch (e) {
1654         case MCOLLAPSE:
1655             m_value.ident = CSSValueCollapse;
1656             break;
1657         case MSEPARATE:
1658             m_value.ident = CSSValueSeparate;
1659             break;
1660         case MDISCARD:
1661             m_value.ident = CSSValueDiscard;
1662             break;
1663     }
1664 }
1665
1666 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
1667 {
1668     switch (m_value.ident) {
1669         case CSSValueCollapse:
1670             return MCOLLAPSE;
1671         case CSSValueSeparate:
1672             return MSEPARATE;
1673         case CSSValueDiscard:
1674             return MDISCARD;
1675         default:
1676             ASSERT_NOT_REACHED();
1677             return MCOLLAPSE;
1678     }
1679 }
1680
1681 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
1682     : CSSValue(PrimitiveClass)
1683 {
1684     m_primitiveUnitType = CSS_IDENT;
1685     switch (e) {
1686         case MNONE:
1687             m_value.ident = CSSValueNone;
1688             break;
1689         case MSCROLL:
1690             m_value.ident = CSSValueScroll;
1691             break;
1692         case MSLIDE:
1693             m_value.ident = CSSValueSlide;
1694             break;
1695         case MALTERNATE:
1696             m_value.ident = CSSValueAlternate;
1697             break;
1698     }
1699 }
1700
1701 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
1702 {
1703     switch (m_value.ident) {
1704         case CSSValueNone:
1705             return MNONE;
1706         case CSSValueScroll:
1707             return MSCROLL;
1708         case CSSValueSlide:
1709             return MSLIDE;
1710         case CSSValueAlternate:
1711             return MALTERNATE;
1712         default:
1713             ASSERT_NOT_REACHED();
1714             return MNONE;
1715     }
1716 }
1717
1718 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionOverflow e)
1719     : CSSValue(PrimitiveClass)
1720 {
1721     m_primitiveUnitType = CSS_IDENT;
1722     switch (e) {
1723     case AutoRegionOverflow:
1724         m_value.ident = CSSValueAuto;
1725         break;
1726     case BreakRegionOverflow:
1727         m_value.ident = CSSValueBreak;
1728         break;
1729     }
1730 }
1731
1732 template<> inline CSSPrimitiveValue::operator RegionOverflow() const
1733 {
1734     switch (m_value.ident) {
1735     case CSSValueAuto:
1736         return AutoRegionOverflow;
1737     case CSSValueBreak:
1738         return BreakRegionOverflow;
1739     default:
1740         ASSERT_NOT_REACHED();
1741         return AutoRegionOverflow;
1742     }
1743 }
1744
1745 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
1746     : CSSValue(PrimitiveClass)
1747 {
1748     m_primitiveUnitType = CSS_IDENT;
1749     switch (e) {
1750         case MFORWARD:
1751             m_value.ident = CSSValueForwards;
1752             break;
1753         case MBACKWARD:
1754             m_value.ident = CSSValueBackwards;
1755             break;
1756         case MAUTO:
1757             m_value.ident = CSSValueAuto;
1758             break;
1759         case MUP:
1760             m_value.ident = CSSValueUp;
1761             break;
1762         case MDOWN:
1763             m_value.ident = CSSValueDown;
1764             break;
1765         case MLEFT:
1766             m_value.ident = CSSValueLeft;
1767             break;
1768         case MRIGHT:
1769             m_value.ident = CSSValueRight;
1770             break;
1771     }
1772 }
1773
1774 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
1775 {
1776     switch (m_value.ident) {
1777         case CSSValueForwards:
1778             return MFORWARD;
1779         case CSSValueBackwards:
1780             return MBACKWARD;
1781         case CSSValueAuto:
1782             return MAUTO;
1783         case CSSValueAhead:
1784         case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
1785             return MUP;
1786         case CSSValueReverse:
1787         case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
1788             return MDOWN;
1789         case CSSValueLeft:
1790             return MLEFT;
1791         case CSSValueRight:
1792             return MRIGHT;
1793         default:
1794             ASSERT_NOT_REACHED();
1795             return MAUTO;
1796     }
1797 }
1798
1799 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMatchNearestMailBlockquoteColor e)
1800     : CSSValue(PrimitiveClass)
1801 {
1802     m_primitiveUnitType = CSS_IDENT;
1803     switch (e) {
1804         case BCNORMAL:
1805             m_value.ident = CSSValueNormal;
1806             break;
1807         case MATCH:
1808             m_value.ident = CSSValueMatch;
1809             break;
1810     }
1811 }
1812
1813 template<> inline CSSPrimitiveValue::operator EMatchNearestMailBlockquoteColor() const
1814 {
1815     switch (m_value.ident) {
1816         case CSSValueNormal:
1817             return BCNORMAL;
1818         case CSSValueMatch:
1819             return MATCH;
1820         default:
1821             ASSERT_NOT_REACHED();
1822             return BCNORMAL;
1823     }
1824 }
1825
1826 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
1827     : CSSValue(PrimitiveClass)
1828 {
1829     m_primitiveUnitType = CSS_IDENT;
1830     switch (e) {
1831         case NBNORMAL:
1832             m_value.ident = CSSValueNormal;
1833             break;
1834         case SPACE:
1835             m_value.ident = CSSValueSpace;
1836             break;
1837     }
1838 }
1839
1840 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
1841 {
1842     switch (m_value.ident) {
1843         case CSSValueSpace:
1844             return SPACE;
1845         case CSSValueNormal:
1846             return NBNORMAL;
1847         default:
1848             ASSERT_NOT_REACHED();
1849             return NBNORMAL;
1850     }
1851 }
1852
1853 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
1854     : CSSValue(PrimitiveClass)
1855 {
1856     m_primitiveUnitType = CSS_IDENT;
1857     switch (e) {
1858         case OVISIBLE:
1859             m_value.ident = CSSValueVisible;
1860             break;
1861         case OHIDDEN:
1862             m_value.ident = CSSValueHidden;
1863             break;
1864         case OSCROLL:
1865             m_value.ident = CSSValueScroll;
1866             break;
1867         case OAUTO:
1868             m_value.ident = CSSValueAuto;
1869             break;
1870         case OMARQUEE:
1871             m_value.ident = CSSValueWebkitMarquee;
1872             break;
1873         case OOVERLAY:
1874             m_value.ident = CSSValueOverlay;
1875             break;
1876     }
1877 }
1878
1879 template<> inline CSSPrimitiveValue::operator EOverflow() const
1880 {
1881     switch (m_value.ident) {
1882         case CSSValueVisible:
1883             return OVISIBLE;
1884         case CSSValueHidden:
1885             return OHIDDEN;
1886         case CSSValueScroll:
1887             return OSCROLL;
1888         case CSSValueAuto:
1889             return OAUTO;
1890         case CSSValueWebkitMarquee:
1891             return OMARQUEE;
1892         case CSSValueOverlay:
1893             return OOVERLAY;
1894         default:
1895             ASSERT_NOT_REACHED();
1896             return OVISIBLE;
1897     }
1898 }
1899
1900 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
1901     : CSSValue(PrimitiveClass)
1902 {
1903     m_primitiveUnitType = CSS_IDENT;
1904     switch (e) {
1905         case PBAUTO:
1906             m_value.ident = CSSValueAuto;
1907             break;
1908         case PBALWAYS:
1909             m_value.ident = CSSValueAlways;
1910             break;
1911         case PBAVOID:
1912             m_value.ident = CSSValueAvoid;
1913             break;
1914     }
1915 }
1916
1917 template<> inline CSSPrimitiveValue::operator EPageBreak() const
1918 {
1919     switch (m_value.ident) {
1920         case CSSValueAuto:
1921             return PBAUTO;
1922         case CSSValueLeft:
1923         case CSSValueRight:
1924         case CSSValueAlways:
1925             return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always."
1926         case CSSValueAvoid:
1927             return PBAVOID;
1928         default:
1929             ASSERT_NOT_REACHED();
1930             return PBAUTO;
1931     }
1932 }
1933
1934 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
1935     : CSSValue(PrimitiveClass)
1936 {
1937     m_primitiveUnitType = CSS_IDENT;
1938     switch (e) {
1939         case StaticPosition:
1940             m_value.ident = CSSValueStatic;
1941             break;
1942         case RelativePosition:
1943             m_value.ident = CSSValueRelative;
1944             break;
1945         case AbsolutePosition:
1946             m_value.ident = CSSValueAbsolute;
1947             break;
1948         case FixedPosition:
1949             m_value.ident = CSSValueFixed;
1950             break;
1951     }
1952 }
1953
1954 template<> inline CSSPrimitiveValue::operator EPosition() const
1955 {
1956     switch (m_value.ident) {
1957         case CSSValueStatic:
1958             return StaticPosition;
1959         case CSSValueRelative:
1960             return RelativePosition;
1961         case CSSValueAbsolute:
1962             return AbsolutePosition;
1963         case CSSValueFixed:
1964             return FixedPosition;
1965         default:
1966             ASSERT_NOT_REACHED();
1967             return StaticPosition;
1968     }
1969 }
1970
1971 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
1972     : CSSValue(PrimitiveClass)
1973 {
1974     m_primitiveUnitType = CSS_IDENT;
1975     switch (e) {
1976         case RESIZE_BOTH:
1977             m_value.ident = CSSValueBoth;
1978             break;
1979         case RESIZE_HORIZONTAL:
1980             m_value.ident = CSSValueHorizontal;
1981             break;
1982         case RESIZE_VERTICAL:
1983             m_value.ident = CSSValueVertical;
1984             break;
1985         case RESIZE_NONE:
1986             m_value.ident = CSSValueNone;
1987             break;
1988     }
1989 }
1990
1991 template<> inline CSSPrimitiveValue::operator EResize() const
1992 {
1993     switch (m_value.ident) {
1994         case CSSValueBoth:
1995             return RESIZE_BOTH;
1996         case CSSValueHorizontal:
1997             return RESIZE_HORIZONTAL;
1998         case CSSValueVertical:
1999             return RESIZE_VERTICAL;
2000         case CSSValueAuto:
2001             ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2002             return RESIZE_NONE;
2003         case CSSValueNone:
2004             return RESIZE_NONE;
2005         default:
2006             ASSERT_NOT_REACHED();
2007             return RESIZE_NONE;
2008     }
2009 }
2010
2011 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2012     : CSSValue(PrimitiveClass)
2013 {
2014     m_primitiveUnitType = CSS_IDENT;
2015     switch (e) {
2016         case TAUTO:
2017             m_value.ident = CSSValueAuto;
2018             break;
2019         case TFIXED:
2020             m_value.ident = CSSValueFixed;
2021             break;
2022     }
2023 }
2024
2025 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2026 {
2027     switch (m_value.ident) {
2028         case CSSValueFixed:
2029             return TFIXED;
2030         case CSSValueAuto:
2031             return TAUTO;
2032         default:
2033             ASSERT_NOT_REACHED();
2034             return TAUTO;
2035     }
2036 }
2037
2038 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2039     : CSSValue(PrimitiveClass)
2040 {
2041     m_primitiveUnitType = CSS_IDENT;
2042     switch (e) {
2043     case TAAUTO:
2044         m_value.ident = CSSValueWebkitAuto;
2045         break;
2046     case TASTART:
2047         m_value.ident = CSSValueStart;
2048         break;
2049     case TAEND:
2050         m_value.ident = CSSValueEnd;
2051         break;
2052     case LEFT:
2053         m_value.ident = CSSValueLeft;
2054         break;
2055     case RIGHT:
2056         m_value.ident = CSSValueRight;
2057         break;
2058     case CENTER:
2059         m_value.ident = CSSValueCenter;
2060         break;
2061     case JUSTIFY:
2062         m_value.ident = CSSValueJustify;
2063         break;
2064     case WEBKIT_LEFT:
2065         m_value.ident = CSSValueWebkitLeft;
2066         break;
2067     case WEBKIT_RIGHT:
2068         m_value.ident = CSSValueWebkitRight;
2069         break;
2070     case WEBKIT_CENTER:
2071         m_value.ident = CSSValueWebkitCenter;
2072         break;
2073     }
2074 }
2075
2076 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2077 {
2078     switch (m_value.ident) {
2079         case CSSValueStart:
2080             return TASTART;
2081         case CSSValueEnd:
2082             return TAEND;
2083         default:
2084             return static_cast<ETextAlign>(m_value.ident - CSSValueWebkitAuto);
2085     }
2086 }
2087
2088 template<> inline CSSPrimitiveValue::operator ETextDecoration() const
2089 {
2090     switch (m_value.ident) {
2091     case CSSValueNone:
2092         return TDNONE;
2093     case CSSValueUnderline:
2094         return UNDERLINE;
2095     case CSSValueOverline:
2096         return OVERLINE;
2097     case CSSValueLineThrough:
2098         return LINE_THROUGH;
2099     case CSSValueBlink:
2100         return BLINK;
2101     default:
2102         ASSERT_NOT_REACHED();
2103         return TDNONE;
2104     }
2105 }
2106
2107 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2108     : CSSValue(PrimitiveClass)
2109 {
2110     m_primitiveUnitType = CSS_IDENT;
2111     switch (e) {
2112         case TSNONE:
2113             m_value.ident = CSSValueNone;
2114             break;
2115         case TSDISC:
2116             m_value.ident = CSSValueDisc;
2117             break;
2118         case TSCIRCLE:
2119             m_value.ident = CSSValueCircle;
2120             break;
2121         case TSSQUARE:
2122             m_value.ident = CSSValueSquare;
2123             break;
2124     }
2125 }
2126
2127 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2128 {
2129     switch (m_value.ident) {
2130         case CSSValueNone:
2131             return TSNONE;
2132         case CSSValueDisc:
2133             return TSDISC;
2134         case CSSValueCircle:
2135             return TSCIRCLE;
2136         case CSSValueSquare:
2137             return TSSQUARE;
2138         default:
2139             ASSERT_NOT_REACHED();
2140             return TSNONE;
2141     }
2142 }
2143
2144 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2145     : CSSValue(PrimitiveClass)
2146 {
2147     m_primitiveUnitType = CSS_IDENT;
2148     switch (e) {
2149         case CAPITALIZE:
2150             m_value.ident = CSSValueCapitalize;
2151             break;
2152         case UPPERCASE:
2153             m_value.ident = CSSValueUppercase;
2154             break;
2155         case LOWERCASE:
2156             m_value.ident = CSSValueLowercase;
2157             break;
2158         case TTNONE:
2159             m_value.ident = CSSValueNone;
2160             break;
2161     }
2162 }
2163
2164 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2165 {
2166     switch (m_value.ident) {
2167         case CSSValueCapitalize:
2168             return CAPITALIZE;
2169         case CSSValueUppercase:
2170             return UPPERCASE;
2171         case CSSValueLowercase:
2172             return LOWERCASE;
2173         case CSSValueNone:
2174             return TTNONE;
2175         default:
2176             ASSERT_NOT_REACHED();
2177             return TTNONE;
2178     }
2179 }
2180
2181 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2182     : CSSValue(PrimitiveClass)
2183 {
2184     m_primitiveUnitType = CSS_IDENT;
2185     switch (e) {
2186     case UBNormal:
2187         m_value.ident = CSSValueNormal;
2188         break;
2189     case Embed:
2190         m_value.ident = CSSValueEmbed;
2191         break;
2192     case Override:
2193         m_value.ident = CSSValueBidiOverride;
2194         break;
2195     case Isolate:
2196         m_value.ident = CSSValueWebkitIsolate;
2197         break;
2198     case Plaintext:
2199         m_value.ident = CSSValueWebkitPlaintext;
2200         break;
2201     }
2202 }
2203
2204 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2205 {
2206     switch (m_value.ident) {
2207     case CSSValueNormal:
2208         return UBNormal;
2209     case CSSValueEmbed:
2210         return Embed;
2211     case CSSValueBidiOverride:
2212         return Override;
2213     case CSSValueWebkitIsolate:
2214         return Isolate;
2215     case CSSValueWebkitPlaintext:
2216         return Plaintext;
2217     default:
2218         ASSERT_NOT_REACHED();
2219         return UBNormal;
2220     }
2221 }
2222
2223 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2224     : CSSValue(PrimitiveClass)
2225 {
2226     m_primitiveUnitType = CSS_IDENT;
2227     switch (e) {
2228         case DRAG_AUTO:
2229             m_value.ident = CSSValueAuto;
2230             break;
2231         case DRAG_NONE:
2232             m_value.ident = CSSValueNone;
2233             break;
2234         case DRAG_ELEMENT:
2235             m_value.ident = CSSValueElement;
2236             break;
2237     }
2238 }
2239
2240 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2241 {
2242     switch (m_value.ident) {
2243         case CSSValueAuto:
2244             return DRAG_AUTO;
2245         case CSSValueNone:
2246             return DRAG_NONE;
2247         case CSSValueElement:
2248             return DRAG_ELEMENT;
2249         default:
2250             ASSERT_NOT_REACHED();
2251             return DRAG_AUTO;
2252     }
2253 }
2254
2255 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2256     : CSSValue(PrimitiveClass)
2257 {
2258     m_primitiveUnitType = CSS_IDENT;
2259     switch (e) {
2260         case READ_ONLY:
2261             m_value.ident = CSSValueReadOnly;
2262             break;
2263         case READ_WRITE:
2264             m_value.ident = CSSValueReadWrite;
2265             break;
2266         case READ_WRITE_PLAINTEXT_ONLY:
2267             m_value.ident = CSSValueReadWritePlaintextOnly;
2268             break;
2269     }
2270 }
2271
2272 template<> inline CSSPrimitiveValue::operator EUserModify() const
2273 {
2274     return static_cast<EUserModify>(m_value.ident - CSSValueReadOnly);
2275 }
2276
2277 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2278     : CSSValue(PrimitiveClass)
2279 {
2280     m_primitiveUnitType = CSS_IDENT;
2281     switch (e) {
2282         case SELECT_NONE:
2283             m_value.ident = CSSValueNone;
2284             break;
2285         case SELECT_TEXT:
2286             m_value.ident = CSSValueText;
2287             break;
2288     }
2289 }
2290
2291 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2292 {
2293     switch (m_value.ident) {
2294         case CSSValueAuto:
2295             return SELECT_TEXT;
2296         case CSSValueNone:
2297             return SELECT_NONE;
2298         case CSSValueText:
2299             return SELECT_TEXT;
2300         default:
2301             ASSERT_NOT_REACHED();
2302             return SELECT_TEXT;
2303     }
2304 }
2305
2306 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2307     : CSSValue(PrimitiveClass)
2308 {
2309     m_primitiveUnitType = CSS_IDENT;
2310     switch (a) {
2311     case TOP:
2312         m_value.ident = CSSValueTop;
2313         break;
2314     case BOTTOM:
2315         m_value.ident = CSSValueBottom;
2316         break;
2317     case MIDDLE:
2318         m_value.ident = CSSValueMiddle;
2319         break;
2320     case BASELINE:
2321         m_value.ident = CSSValueBaseline;
2322         break;
2323     case TEXT_BOTTOM:
2324         m_value.ident = CSSValueTextBottom;
2325         break;
2326     case TEXT_TOP:
2327         m_value.ident = CSSValueTextTop;
2328         break;
2329     case SUB:
2330         m_value.ident = CSSValueSub;
2331         break;
2332     case SUPER:
2333         m_value.ident = CSSValueSuper;
2334         break;
2335     case BASELINE_MIDDLE:
2336         m_value.ident = CSSValueWebkitBaselineMiddle;
2337         break;
2338     case LENGTH:
2339         m_value.ident = CSSValueInvalid;
2340     }
2341 }
2342
2343 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2344 {
2345     switch (m_value.ident) {
2346     case CSSValueTop:
2347         return TOP;
2348     case CSSValueBottom:
2349         return BOTTOM;
2350     case CSSValueMiddle:
2351         return MIDDLE;
2352     case CSSValueBaseline:
2353         return BASELINE;
2354     case CSSValueTextBottom:
2355         return TEXT_BOTTOM;
2356     case CSSValueTextTop:
2357         return TEXT_TOP;
2358     case CSSValueSub:
2359         return SUB;
2360     case CSSValueSuper:
2361         return SUPER;
2362     case CSSValueWebkitBaselineMiddle:
2363         return BASELINE_MIDDLE;
2364     default:
2365         ASSERT_NOT_REACHED();
2366         return TOP;
2367     }
2368 }
2369
2370 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
2371     : CSSValue(PrimitiveClass)
2372 {
2373     m_primitiveUnitType = CSS_IDENT;
2374     switch (e) {
2375         case VISIBLE:
2376             m_value.ident = CSSValueVisible;
2377             break;
2378         case HIDDEN:
2379             m_value.ident = CSSValueHidden;
2380             break;
2381         case COLLAPSE:
2382             m_value.ident = CSSValueCollapse;
2383             break;
2384     }
2385 }
2386
2387 template<> inline CSSPrimitiveValue::operator EVisibility() const
2388 {
2389     switch (m_value.ident) {
2390         case CSSValueHidden:
2391             return HIDDEN;
2392         case CSSValueVisible:
2393             return VISIBLE;
2394         case CSSValueCollapse:
2395             return COLLAPSE;
2396         default:
2397             ASSERT_NOT_REACHED();
2398             return VISIBLE;
2399     }
2400 }
2401
2402 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
2403     : CSSValue(PrimitiveClass)
2404 {
2405     m_primitiveUnitType = CSS_IDENT;
2406     switch (e) {
2407         case NORMAL:
2408             m_value.ident = CSSValueNormal;
2409             break;
2410         case PRE:
2411             m_value.ident = CSSValuePre;
2412             break;
2413         case PRE_WRAP:
2414             m_value.ident = CSSValuePreWrap;
2415             break;
2416         case PRE_LINE:
2417             m_value.ident = CSSValuePreLine;
2418             break;
2419         case NOWRAP:
2420             m_value.ident = CSSValueNowrap;
2421             break;
2422         case KHTML_NOWRAP:
2423             m_value.ident = CSSValueWebkitNowrap;
2424             break;
2425     }
2426 }
2427
2428 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
2429 {
2430     switch (m_value.ident) {
2431         case CSSValueWebkitNowrap:
2432             return KHTML_NOWRAP;
2433         case CSSValueNowrap:
2434             return NOWRAP;
2435         case CSSValuePre:
2436             return PRE;
2437         case CSSValuePreWrap:
2438             return PRE_WRAP;
2439         case CSSValuePreLine:
2440             return PRE_LINE;
2441         case CSSValueNormal:
2442             return NORMAL;
2443         default:
2444             ASSERT_NOT_REACHED();
2445             return NORMAL;
2446     }
2447 }
2448
2449 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
2450     : CSSValue(PrimitiveClass)
2451 {
2452     m_primitiveUnitType = CSS_IDENT;
2453     switch (e) {
2454         case NormalWordBreak:
2455             m_value.ident = CSSValueNormal;
2456             break;
2457         case BreakAllWordBreak:
2458             m_value.ident = CSSValueBreakAll;
2459             break;
2460         case BreakWordBreak:
2461             m_value.ident = CSSValueBreakWord;
2462             break;
2463     }
2464 }
2465
2466 template<> inline CSSPrimitiveValue::operator EWordBreak() const
2467 {
2468     switch (m_value.ident) {
2469         case CSSValueBreakAll:
2470             return BreakAllWordBreak;
2471         case CSSValueBreakWord:
2472             return BreakWordBreak;
2473         case CSSValueNormal:
2474             return NormalWordBreak;
2475         default:
2476         ASSERT_NOT_REACHED();
2477         return NormalWordBreak;
2478     }
2479 }
2480
2481 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordWrap e)
2482     : CSSValue(PrimitiveClass)
2483 {
2484     m_primitiveUnitType = CSS_IDENT;
2485     switch (e) {
2486         case NormalWordWrap:
2487             m_value.ident = CSSValueNormal;
2488             break;
2489         case BreakWordWrap:
2490             m_value.ident = CSSValueBreakWord;
2491             break;
2492     }
2493 }
2494
2495 template<> inline CSSPrimitiveValue::operator EWordWrap() const
2496 {
2497     switch (m_value.ident) {
2498         case CSSValueBreakWord:
2499             return BreakWordWrap;
2500         case CSSValueNormal:
2501             return NormalWordWrap;
2502         default:
2503             ASSERT_NOT_REACHED();
2504             return NormalWordWrap;
2505     }
2506 }
2507
2508 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
2509     : CSSValue(PrimitiveClass)
2510 {
2511     m_primitiveUnitType = CSS_IDENT;
2512     switch (e) {
2513         case LTR:
2514             m_value.ident = CSSValueLtr;
2515             break;
2516         case RTL:
2517             m_value.ident = CSSValueRtl;
2518             break;
2519     }
2520 }
2521
2522 template<> inline CSSPrimitiveValue::operator TextDirection() const
2523 {
2524     switch (m_value.ident) {
2525         case CSSValueLtr:
2526             return LTR;
2527         case CSSValueRtl:
2528             return RTL;
2529         default:
2530             ASSERT_NOT_REACHED();
2531             return LTR;
2532     }
2533 }
2534
2535 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
2536     : CSSValue(PrimitiveClass)
2537 {
2538     m_primitiveUnitType = CSS_IDENT;
2539     switch (e) {
2540     case TopToBottomWritingMode:
2541         m_value.ident = CSSValueHorizontalTb;
2542         break;
2543     case RightToLeftWritingMode:
2544         m_value.ident = CSSValueVerticalRl;
2545         break;
2546     case LeftToRightWritingMode:
2547         m_value.ident = CSSValueVerticalLr;
2548         break;
2549     case BottomToTopWritingMode:
2550         m_value.ident = CSSValueHorizontalBt;
2551         break;
2552     }
2553 }
2554
2555 template<> inline CSSPrimitiveValue::operator WritingMode() const
2556 {
2557     switch (m_value.ident) {
2558     case CSSValueHorizontalTb:
2559         return TopToBottomWritingMode;
2560     case CSSValueVerticalRl:
2561         return RightToLeftWritingMode;
2562     case CSSValueVerticalLr:
2563         return LeftToRightWritingMode;
2564     case CSSValueHorizontalBt:
2565         return BottomToTopWritingMode;
2566     default:
2567         ASSERT_NOT_REACHED();
2568         return TopToBottomWritingMode;
2569     }
2570 }
2571
2572 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
2573     : CSSValue(PrimitiveClass)
2574 {
2575     m_primitiveUnitType = CSS_IDENT;
2576     switch (e) {
2577     case TextCombineNone:
2578         m_value.ident = CSSValueNone;
2579         break;
2580     case TextCombineHorizontal:
2581         m_value.ident = CSSValueHorizontal;
2582         break;
2583     }
2584 }
2585
2586 template<> inline CSSPrimitiveValue::operator TextCombine() const
2587 {
2588     switch (m_value.ident) {
2589     case CSSValueNone:
2590         return TextCombineNone;
2591     case CSSValueHorizontal:
2592         return TextCombineHorizontal;
2593     default:
2594         ASSERT_NOT_REACHED();
2595         return TextCombineNone;
2596     }
2597 }
2598
2599 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
2600     : CSSValue(PrimitiveClass)
2601 {
2602     m_primitiveUnitType = CSS_IDENT;
2603     switch (position) {
2604     case TextEmphasisPositionOver:
2605         m_value.ident = CSSValueOver;
2606         break;
2607     case TextEmphasisPositionUnder:
2608         m_value.ident = CSSValueUnder;
2609         break;
2610     }
2611 }
2612
2613 template<> inline CSSPrimitiveValue::operator TextEmphasisPosition() const
2614 {
2615     switch (m_value.ident) {
2616     case CSSValueOver:
2617         return TextEmphasisPositionOver;
2618     case CSSValueUnder:
2619         return TextEmphasisPositionUnder;
2620     default:
2621         ASSERT_NOT_REACHED();
2622         return TextEmphasisPositionOver;
2623     }
2624 }
2625
2626 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
2627     : CSSValue(PrimitiveClass)
2628 {
2629     m_primitiveUnitType = CSS_IDENT;
2630     switch (overflow) {
2631     case TextOverflowClip:
2632         m_value.ident = CSSValueClip;
2633         break;
2634     case TextOverflowEllipsis:
2635         m_value.ident = CSSValueEllipsis;
2636         break;
2637     }
2638 }
2639
2640 template<> inline CSSPrimitiveValue::operator TextOverflow() const
2641 {
2642     switch (m_value.ident) {
2643     case CSSValueClip:
2644         return TextOverflowClip;
2645     case CSSValueEllipsis:
2646         return TextOverflowEllipsis;
2647     default:
2648         ASSERT_NOT_REACHED();
2649         return TextOverflowClip;
2650     }
2651 }
2652
2653 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
2654     : CSSValue(PrimitiveClass)
2655 {
2656     m_primitiveUnitType = CSS_IDENT;
2657     switch (fill) {
2658     case TextEmphasisFillFilled:
2659         m_value.ident = CSSValueFilled;
2660         break;
2661     case TextEmphasisFillOpen:
2662         m_value.ident = CSSValueOpen;
2663         break;
2664     }
2665 }
2666
2667 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
2668 {
2669     switch (m_value.ident) {
2670     case CSSValueFilled:
2671         return TextEmphasisFillFilled;
2672     case CSSValueOpen:
2673         return TextEmphasisFillOpen;
2674     default:
2675         ASSERT_NOT_REACHED();
2676         return TextEmphasisFillFilled;
2677     }
2678 }
2679
2680 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
2681     : CSSValue(PrimitiveClass)
2682 {
2683     m_primitiveUnitType = CSS_IDENT;
2684     switch (mark) {
2685     case TextEmphasisMarkDot:
2686         m_value.ident = CSSValueDot;
2687         break;
2688     case TextEmphasisMarkCircle:
2689         m_value.ident = CSSValueCircle;
2690         break;
2691     case TextEmphasisMarkDoubleCircle:
2692         m_value.ident = CSSValueDoubleCircle;
2693         break;
2694     case TextEmphasisMarkTriangle:
2695         m_value.ident = CSSValueTriangle;
2696         break;
2697     case TextEmphasisMarkSesame:
2698         m_value.ident = CSSValueSesame;
2699         break;
2700     case TextEmphasisMarkNone:
2701     case TextEmphasisMarkAuto:
2702     case TextEmphasisMarkCustom:
2703         ASSERT_NOT_REACHED();
2704         m_value.ident = CSSValueNone;
2705         break;
2706     }
2707 }
2708
2709 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
2710 {
2711     switch (m_value.ident) {
2712     case CSSValueNone:
2713         return TextEmphasisMarkNone;
2714     case CSSValueDot:
2715         return TextEmphasisMarkDot;
2716     case CSSValueCircle:
2717         return TextEmphasisMarkCircle;
2718     case CSSValueDoubleCircle:
2719         return TextEmphasisMarkDoubleCircle;
2720     case CSSValueTriangle:
2721         return TextEmphasisMarkTriangle;
2722     case CSSValueSesame:
2723         return TextEmphasisMarkSesame;
2724     default:
2725         ASSERT_NOT_REACHED();
2726         return TextEmphasisMarkNone;
2727     }
2728 }
2729
2730 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
2731     : CSSValue(PrimitiveClass)
2732 {
2733     m_primitiveUnitType = CSS_IDENT;
2734     switch (e) {
2735     case TextOrientationVerticalRight:
2736         m_value.ident = CSSValueVerticalRight;
2737         break;
2738     case TextOrientationUpright:
2739         m_value.ident = CSSValueUpright;
2740         break;
2741     }
2742 }
2743
2744 template<> inline CSSPrimitiveValue::operator TextOrientation() const
2745 {
2746     switch (m_value.ident) {
2747     case CSSValueVerticalRight:
2748         return TextOrientationVerticalRight;
2749     case CSSValueUpright:
2750         return TextOrientationUpright;
2751     default:
2752         ASSERT_NOT_REACHED();
2753         return TextOrientationVerticalRight;
2754     }
2755 }
2756
2757 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
2758     : CSSValue(PrimitiveClass)
2759 {
2760     m_primitiveUnitType = CSS_IDENT;
2761     switch (e) {
2762         case PE_NONE:
2763             m_value.ident = CSSValueNone;
2764             break;
2765         case PE_STROKE:
2766             m_value.ident = CSSValueStroke;
2767             break;
2768         case PE_FILL:
2769             m_value.ident = CSSValueFill;
2770             break;
2771         case PE_PAINTED:
2772             m_value.ident = CSSValuePainted;
2773             break;
2774         case PE_VISIBLE:
2775             m_value.ident = CSSValueVisible;
2776             break;
2777         case PE_VISIBLE_STROKE:
2778             m_value.ident = CSSValueVisiblestroke;
2779             break;
2780         case PE_VISIBLE_FILL:
2781             m_value.ident = CSSValueVisiblefill;
2782             break;
2783         case PE_VISIBLE_PAINTED:
2784             m_value.ident = CSSValueVisiblepainted;
2785             break;
2786         case PE_AUTO:
2787             m_value.ident = CSSValueAuto;
2788             break;
2789         case PE_ALL:
2790             m_value.ident = CSSValueAll;
2791             break;
2792     }
2793 }
2794
2795 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
2796 {
2797     switch (m_value.ident) {
2798         case CSSValueAll:
2799             return PE_ALL;
2800         case CSSValueAuto:
2801             return PE_AUTO;
2802         case CSSValueNone:
2803             return PE_NONE;
2804         case CSSValueVisiblepainted:
2805             return PE_VISIBLE_PAINTED;
2806         case CSSValueVisiblefill:
2807             return PE_VISIBLE_FILL;
2808         case CSSValueVisiblestroke:
2809             return PE_VISIBLE_STROKE;
2810         case CSSValueVisible:
2811             return PE_VISIBLE;
2812         case CSSValuePainted:
2813             return PE_PAINTED;
2814         case CSSValueFill:
2815             return PE_FILL;
2816         case CSSValueStroke:
2817             return PE_STROKE;
2818         default:
2819             ASSERT_NOT_REACHED();
2820             return PE_ALL;
2821     }
2822 }
2823
2824 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
2825     : CSSValue(PrimitiveClass)
2826 {
2827     m_primitiveUnitType = CSS_IDENT;
2828     switch (smoothing) {
2829     case AutoSmoothing:
2830         m_value.ident = CSSValueAuto;
2831         return;
2832     case NoSmoothing:
2833         m_value.ident = CSSValueNone;
2834         return;
2835     case Antialiased:
2836         m_value.ident = CSSValueAntialiased;
2837         return;
2838     case SubpixelAntialiased:
2839         m_value.ident = CSSValueSubpixelAntialiased;
2840         return;
2841     }
2842
2843     ASSERT_NOT_REACHED();
2844     m_value.ident = CSSValueAuto;
2845 }
2846
2847 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
2848 {
2849     switch (m_value.ident) {
2850     case CSSValueAuto:
2851         return AutoSmoothing;
2852     case CSSValueNone:
2853         return NoSmoothing;
2854     case CSSValueAntialiased:
2855         return Antialiased;
2856     case CSSValueSubpixelAntialiased:
2857         return SubpixelAntialiased;
2858     }
2859
2860     ASSERT_NOT_REACHED();
2861     return AutoSmoothing;
2862 }
2863
2864 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
2865     : CSSValue(PrimitiveClass)
2866 {
2867     m_primitiveUnitType = CSS_IDENT;
2868     switch (weight) {
2869     case FontWeight900:
2870         m_value.ident = CSSValue900;
2871         return;
2872     case FontWeight800:
2873         m_value.ident = CSSValue800;
2874         return;
2875     case FontWeight700:
2876         m_value.ident = CSSValue700;
2877         return;
2878     case FontWeight600:
2879         m_value.ident = CSSValue600;
2880         return;
2881     case FontWeight500:
2882         m_value.ident = CSSValue500;
2883         return;
2884     case FontWeight400:
2885         m_value.ident = CSSValue400;
2886         return;
2887     case FontWeight300:
2888         m_value.ident = CSSValue300;
2889         return;
2890     case FontWeight200:
2891         m_value.ident = CSSValue200;
2892         return;
2893     case FontWeight100:
2894         m_value.ident = CSSValue100;
2895         return;
2896     }
2897
2898     ASSERT_NOT_REACHED();
2899     m_value.ident = CSSValueNormal;
2900 }
2901
2902 template<> inline CSSPrimitiveValue::operator FontWeight() const
2903 {
2904     switch (m_value.ident) {
2905     case CSSValueBold:
2906         return FontWeightBold;
2907     case CSSValueNormal:
2908         return FontWeightNormal;
2909     case CSSValue900:
2910         return FontWeight900;
2911     case CSSValue800:
2912         return FontWeight800;
2913     case CSSValue700:
2914         return FontWeight700;
2915     case CSSValue600:
2916         return FontWeight600;
2917     case CSSValue500:
2918         return FontWeight500;
2919     case CSSValue400:
2920         return FontWeight400;
2921     case CSSValue300:
2922         return FontWeight300;
2923     case CSSValue200:
2924         return FontWeight200;
2925     case CSSValue100:
2926         return FontWeight100;
2927     }
2928
2929     ASSERT_NOT_REACHED();
2930     return FontWeightNormal;
2931 }
2932
2933 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic)
2934     : CSSValue(PrimitiveClass)
2935 {
2936     m_primitiveUnitType = CSS_IDENT;
2937     switch (italic) {
2938     case FontItalicOff:
2939         m_value.ident = CSSValueNormal;
2940         return;
2941     case FontItalicOn:
2942         m_value.ident = CSSValueItalic;
2943         return;
2944     }
2945
2946     ASSERT_NOT_REACHED();
2947     m_value.ident = CSSValueNormal;
2948 }
2949
2950 template<> inline CSSPrimitiveValue::operator FontItalic() const
2951 {
2952     switch (m_value.ident) {
2953     case CSSValueOblique:
2954     // FIXME: oblique is the same as italic for the moment...
2955     case CSSValueItalic:
2956         return FontItalicOn;
2957     case CSSValueNormal:
2958         return FontItalicOff;
2959     }
2960     ASSERT_NOT_REACHED();
2961     return FontItalicOff;
2962 }
2963
2964 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
2965     : CSSValue(PrimitiveClass)
2966 {
2967     m_primitiveUnitType = CSS_IDENT;
2968     switch (smallCaps) {
2969     case FontSmallCapsOff:
2970         m_value.ident = CSSValueNormal;
2971         return;
2972     case FontSmallCapsOn:
2973         m_value.ident = CSSValueSmallCaps;
2974         return;
2975     }
2976
2977     ASSERT_NOT_REACHED();
2978     m_value.ident = CSSValueNormal;
2979 }
2980
2981 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
2982 {
2983     switch (m_value.ident) {
2984     case CSSValueSmallCaps:
2985         return FontSmallCapsOn;
2986     case CSSValueNormal:
2987         return FontSmallCapsOff;
2988     }
2989     ASSERT_NOT_REACHED();
2990     return FontSmallCapsOff;
2991 }
2992
2993 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
2994     : CSSValue(PrimitiveClass)
2995 {
2996     m_primitiveUnitType = CSS_IDENT;
2997     switch (e) {
2998         case AutoTextRendering:
2999             m_value.ident = CSSValueAuto;
3000             break;
3001         case OptimizeSpeed:
3002             m_value.ident = CSSValueOptimizespeed;
3003             break;
3004         case OptimizeLegibility:
3005             m_value.ident = CSSValueOptimizelegibility;
3006             break;
3007         case GeometricPrecision:
3008             m_value.ident = CSSValueGeometricprecision;
3009             break;
3010     }
3011 }
3012
3013 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3014 {
3015     switch (m_value.ident) {
3016         case CSSValueAuto:
3017             return AutoTextRendering;
3018         case CSSValueOptimizespeed:
3019             return OptimizeSpeed;
3020         case CSSValueOptimizelegibility:
3021             return OptimizeLegibility;
3022         case CSSValueGeometricprecision:
3023             return GeometricPrecision;
3024         default:
3025             ASSERT_NOT_REACHED();
3026             return AutoTextRendering;
3027     }
3028 }
3029
3030 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColorSpace space)
3031     : CSSValue(PrimitiveClass)
3032 {
3033     m_primitiveUnitType = CSS_IDENT;
3034     switch (space) {
3035     case ColorSpaceDeviceRGB:
3036         m_value.ident = CSSValueDefault;
3037         break;
3038     case ColorSpaceSRGB:
3039         m_value.ident = CSSValueSrgb;
3040         break;
3041     case ColorSpaceLinearRGB:
3042         // CSS color correction does not support linearRGB yet.
3043         ASSERT_NOT_REACHED();
3044         m_value.ident = CSSValueDefault;
3045         break;
3046     }
3047 }
3048
3049 template<> inline CSSPrimitiveValue::operator ColorSpace() const
3050 {
3051     switch (m_value.ident) {
3052     case CSSValueDefault:
3053         return ColorSpaceDeviceRGB;
3054     case CSSValueSrgb:
3055         return ColorSpaceSRGB;
3056     default:
3057         ASSERT_NOT_REACHED();
3058         return ColorSpaceDeviceRGB;
3059     }
3060 }
3061
3062 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3063     : CSSValue(PrimitiveClass)
3064 {
3065     m_primitiveUnitType = CSS_IDENT;
3066     switch (hyphens) {
3067     case HyphensNone:
3068         m_value.ident = CSSValueNone;
3069         break;
3070     case HyphensManual:
3071         m_value.ident = CSSValueManual;
3072         break;
3073     case HyphensAuto:
3074         m_value.ident = CSSValueAuto;
3075         break;
3076     }
3077 }
3078
3079 template<> inline CSSPrimitiveValue::operator Hyphens() const
3080 {
3081     switch (m_value.ident) {
3082     case CSSValueNone:
3083         return HyphensNone;
3084     case CSSValueManual:
3085         return HyphensManual;
3086     case CSSValueAuto:
3087         return HyphensAuto;
3088     default:
3089         ASSERT_NOT_REACHED();
3090         return HyphensAuto;
3091     }
3092 }
3093
3094 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineGridSnap gridSnap)
3095     : CSSValue(PrimitiveClass)
3096 {
3097     m_primitiveUnitType = CSS_IDENT;
3098     switch (gridSnap) {
3099     case LineGridSnapNone:
3100         m_value.ident = CSSValueNone;
3101         break;
3102     case LineGridSnapBaseline:
3103         m_value.ident = CSSValueBaseline;
3104         break;
3105     case LineGridSnapBounds:
3106         m_value.ident = CSSValueBounds;
3107         break;
3108     }
3109 }
3110
3111 template<> inline CSSPrimitiveValue::operator LineGridSnap() const
3112 {
3113     switch (m_value.ident) {
3114     case CSSValueNone:
3115         return LineGridSnapNone;
3116     case CSSValueBaseline:
3117         return LineGridSnapBaseline;
3118     case CSSValueBounds:
3119         return LineGridSnapBounds;
3120     default:
3121         ASSERT_NOT_REACHED();
3122         return LineGridSnapNone;
3123     }
3124 }
3125
3126 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3127     : CSSValue(PrimitiveClass)
3128 {
3129     m_primitiveUnitType = CSS_IDENT;
3130     switch (e) {
3131     case SpeakNone:
3132         m_value.ident = CSSValueNone;
3133         break;
3134     case SpeakNormal:
3135         m_value.ident = CSSValueNormal;
3136         break;
3137     case SpeakSpellOut:
3138         m_value.ident = CSSValueSpellOut;
3139         break;
3140     case SpeakDigits:
3141         m_value.ident = CSSValueDigits;
3142         break;
3143     case SpeakLiteralPunctuation:
3144         m_value.ident = CSSValueLiteralPunctuation;
3145         break;
3146     case SpeakNoPunctuation:
3147         m_value.ident = CSSValueNoPunctuation;
3148         break;
3149     }
3150 }
3151
3152 template<> inline CSSPrimitiveValue::operator Order() const
3153 {
3154     switch (m_value.ident) {
3155     case CSSValueLogical:
3156         return LogicalOrder;
3157     case CSSValueVisual:
3158         return VisualOrder;
3159     default:
3160         ASSERT_NOT_REACHED();
3161         return LogicalOrder;
3162     }
3163 }
3164
3165 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
3166     : CSSValue(PrimitiveClass)
3167 {
3168     m_primitiveUnitType = CSS_IDENT;
3169     switch (e) {
3170     case LogicalOrder:
3171         m_value.ident = CSSValueLogical;
3172         break;
3173     case VisualOrder:
3174         m_value.ident = CSSValueVisual;
3175         break;
3176     }
3177 }
3178
3179 template<> inline CSSPrimitiveValue::operator ESpeak() const
3180 {
3181     switch (m_value.ident) {
3182     case CSSValueNone:
3183         return SpeakNone;
3184     case CSSValueNormal:
3185         return SpeakNormal;
3186     case CSSValueSpellOut:
3187         return SpeakSpellOut;
3188     case CSSValueDigits:
3189         return SpeakDigits;
3190     case CSSValueLiteralPunctuation:
3191         return SpeakLiteralPunctuation;
3192     case CSSValueNoPunctuation:
3193         return SpeakNoPunctuation;
3194     default:
3195         ASSERT_NOT_REACHED();
3196         return SpeakNormal;
3197     }
3198 }
3199
3200 #if ENABLE(CSS_SHADERS)
3201 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CustomFilterOperation::MeshBoxType meshBoxType)
3202     : CSSValue(PrimitiveClass)
3203 {
3204     m_primitiveUnitType = CSS_IDENT;
3205     switch (meshBoxType) {
3206     case CustomFilterOperation::FILTER_BOX:
3207         m_value.ident = CSSValueFilterBox;
3208         break;
3209     case CustomFilterOperation::BORDER_BOX:
3210         m_value.ident = CSSValueBorderBox;
3211         break;
3212     case CustomFilterOperation::PADDING_BOX:
3213         m_value.ident = CSSValuePaddingBox;
3214         break;
3215     case CustomFilterOperation::CONTENT_BOX:
3216         m_value.ident = CSSValueContentBox;
3217         break;
3218     }
3219 }
3220
3221 template<> inline CSSPrimitiveValue::operator CustomFilterOperation::MeshBoxType() const
3222 {
3223     switch (m_value.ident) {
3224     case CSSValueFilterBox:
3225         return CustomFilterOperation::FILTER_BOX;
3226     case CSSValueBorderBox:
3227         return CustomFilterOperation::BORDER_BOX;
3228     case CSSValuePaddingBox:
3229         return CustomFilterOperation::PADDING_BOX;
3230     case CSSValueContentBox:
3231         return CustomFilterOperation::CONTENT_BOX;
3232     default:
3233         ASSERT_NOT_REACHED();
3234         return CustomFilterOperation::FILTER_BOX;
3235     }
3236 }
3237 #endif // ENABLE(CSS_SHADERS)
3238
3239 #if ENABLE(SVG)
3240
3241 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
3242     : CSSValue(PrimitiveClass)
3243 {
3244     m_primitiveUnitType = CSS_IDENT;
3245     switch (e) {
3246         case ButtCap:
3247             m_value.ident = CSSValueButt;
3248             break;
3249         case RoundCap:
3250             m_value.ident = CSSValueRound;
3251             break;
3252         case SquareCap:
3253             m_value.ident = CSSValueSquare;
3254             break;
3255     }
3256 }
3257
3258 template<> inline CSSPrimitiveValue::operator LineCap() const
3259 {
3260     switch (m_value.ident) {
3261         case CSSValueButt:
3262             return ButtCap;
3263         case CSSValueRound:
3264             return RoundCap;
3265         case CSSValueSquare:
3266             return SquareCap;
3267         default:
3268             ASSERT_NOT_REACHED();
3269             return ButtCap;
3270     }
3271 }
3272
3273 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
3274     : CSSValue(PrimitiveClass)
3275 {
3276     m_primitiveUnitType = CSS_IDENT;
3277     switch (e) {
3278         case MiterJoin:
3279             m_value.ident = CSSValueMiter;
3280             break;
3281         case RoundJoin:
3282             m_value.ident = CSSValueRound;
3283             break;
3284         case BevelJoin:
3285             m_value.ident = CSSValueBevel;
3286             break;
3287     }
3288 }
3289
3290 template<> inline CSSPrimitiveValue::operator LineJoin() const
3291 {
3292     switch (m_value.ident) {
3293         case CSSValueMiter:
3294             return MiterJoin;
3295         case CSSValueRound:
3296             return RoundJoin;
3297         case CSSValueBevel:
3298             return BevelJoin;
3299         default:
3300             ASSERT_NOT_REACHED();
3301             return MiterJoin;
3302     }
3303 }
3304
3305 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
3306     : CSSValue(PrimitiveClass)
3307 {
3308     m_primitiveUnitType = CSS_IDENT;
3309     switch (e) {
3310         case RULE_NONZERO:
3311             m_value.ident = CSSValueNonzero;
3312             break;
3313         case RULE_EVENODD:
3314             m_value.ident = CSSValueEvenodd;
3315             break;
3316     }
3317 }
3318
3319 template<> inline CSSPrimitiveValue::operator WindRule() const
3320 {
3321     switch (m_value.ident) {
3322         case CSSValueNonzero:
3323             return RULE_NONZERO;
3324         case CSSValueEvenodd:
3325             return RULE_EVENODD;
3326         default:
3327             ASSERT_NOT_REACHED();
3328             return RULE_NONZERO;
3329     }
3330 }
3331
3332
3333 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
3334     : CSSValue(PrimitiveClass)
3335 {
3336     m_primitiveUnitType = CSS_IDENT;
3337     switch (e) {
3338         case AB_AUTO:
3339             m_value.ident = CSSValueAuto;
3340             break;
3341         case AB_BASELINE:
3342             m_value.ident = CSSValueBaseline;
3343             break;
3344         case AB_BEFORE_EDGE:
3345             m_value.ident = CSSValueBeforeEdge;
3346             break;
3347         case AB_TEXT_BEFORE_EDGE:
3348             m_value.ident = CSSValueTextBeforeEdge;
3349             break;
3350         case AB_MIDDLE:
3351             m_value.ident = CSSValueMiddle;
3352             break;
3353         case AB_CENTRAL:
3354             m_value.ident = CSSValueCentral;
3355             break;
3356         case AB_AFTER_EDGE:
3357             m_value.ident = CSSValueAfterEdge;
3358             break;
3359         case AB_TEXT_AFTER_EDGE:
3360             m_value.ident = CSSValueTextAfterEdge;
3361             break;
3362         case AB_IDEOGRAPHIC:
3363             m_value.ident = CSSValueIdeographic;
3364             break;
3365         case AB_ALPHABETIC:
3366             m_value.ident = CSSValueAlphabetic;
3367             break;
3368         case AB_HANGING:
3369             m_value.ident = CSSValueHanging;
3370             break;
3371         case AB_MATHEMATICAL:
3372             m_value.ident = CSSValueMathematical;
3373             break;
3374     }
3375 }
3376
3377 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
3378 {
3379     switch (m_value.ident) {
3380         case CSSValueAuto:
3381             return AB_AUTO;
3382         case CSSValueBaseline:
3383             return AB_BASELINE;
3384         case CSSValueBeforeEdge:
3385             return AB_BEFORE_EDGE;
3386         case CSSValueTextBeforeEdge:
3387             return AB_TEXT_BEFORE_EDGE;
3388         case CSSValueMiddle:
3389             return AB_MIDDLE;
3390         case CSSValueCentral:
3391             return AB_CENTRAL;
3392         case CSSValueAfterEdge:
3393             return AB_AFTER_EDGE;
3394         case CSSValueTextAfterEdge:
3395             return AB_TEXT_AFTER_EDGE;
3396         case CSSValueIdeographic:
3397             return AB_IDEOGRAPHIC;
3398         case CSSValueAlphabetic:
3399             return AB_ALPHABETIC;
3400         case CSSValueHanging:
3401             return AB_HANGING;
3402         case CSSValueMathematical:
3403             return AB_MATHEMATICAL;
3404         default:
3405             ASSERT_NOT_REACHED();
3406             return AB_AUTO;
3407     }
3408 }
3409
3410 #endif
3411
3412 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
3413     : CSSValue(PrimitiveClass)
3414 {
3415     m_primitiveUnitType = CSS_IDENT;
3416     switch (e) {
3417     case BSEPARATE:
3418         m_value.ident = CSSValueSeparate;
3419         break;
3420     case BCOLLAPSE:
3421         m_value.ident = CSSValueCollapse;
3422         break;
3423     }
3424 }
3425
3426 template<> inline CSSPrimitiveValue::operator EBorderCollapse() const
3427 {
3428     switch (m_value.ident) {
3429     case CSSValueSeparate:
3430         return BSEPARATE;
3431     case CSSValueCollapse:
3432         return BCOLLAPSE;
3433     default:
3434         ASSERT_NOT_REACHED();
3435         return BSEPARATE;
3436     }
3437 }
3438
3439 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderFit e)
3440     : CSSValue(PrimitiveClass)
3441 {
3442     m_primitiveUnitType = CSS_IDENT;
3443     switch (e) {
3444     case BorderFitBorder:
3445         m_value.ident = CSSValueBorder;
3446         break;
3447     case BorderFitLines:
3448         m_value.ident = CSSValueLines;
3449         break;
3450     }
3451 }
3452
3453 template<> inline CSSPrimitiveValue::operator EBorderFit() const
3454 {
3455     switch (m_value.ident) {
3456     case CSSValueBorder:
3457         return BorderFitBorder;
3458     case CSSValueLines:
3459         return BorderFitLines;
3460     default:
3461         ASSERT_NOT_REACHED();
3462         return BorderFitLines;
3463     }
3464 }
3465
3466 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
3467     : CSSValue(PrimitiveClass)
3468 {
3469     m_primitiveUnitType = CSS_IDENT;
3470     switch (e) {
3471     case ImageRenderingAuto:
3472         m_value.ident = CSSValueAuto;
3473         break;
3474     case ImageRenderingOptimizeSpeed:
3475         m_value.ident = CSSValueOptimizespeed;
3476         break;
3477     case ImageRenderingOptimizeQuality:
3478         m_value.ident = CSSValueOptimizequality;
3479         break;
3480     case ImageRenderingOptimizeContrast:
3481         m_value.ident = CSSValueWebkitOptimizeContrast;
3482         break;
3483     }
3484 }
3485
3486 template<> inline CSSPrimitiveValue::operator EImageRendering() const
3487 {
3488     switch (m_value.ident) {
3489     case CSSValueAuto:
3490         return ImageRenderingAuto;
3491     case CSSValueOptimizespeed:
3492         return ImageRenderingOptimizeSpeed;
3493     case CSSValueOptimizequality:
3494         return ImageRenderingOptimizeQuality;
3495     case CSSValueWebkitOptimizeContrast:
3496         return ImageRenderingOptimizeContrast;
3497     default:
3498         ASSERT_NOT_REACHED();
3499         return ImageRenderingAuto;
3500     }
3501 }
3502
3503 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e)
3504     : CSSValue(PrimitiveClass)
3505 {
3506     m_primitiveUnitType = CSS_IDENT;
3507     switch (e) {
3508     case TransformStyle3DFlat:
3509         m_value.ident = CSSValueFlat;
3510         break;
3511     case TransformStyle3DPreserve3D:
3512         m_value.ident = CSSValuePreserve3d;
3513         break;
3514     }
3515 }
3516
3517 template<> inline CSSPrimitiveValue::operator ETransformStyle3D() const
3518 {
3519     switch (m_value.ident) {
3520     case CSSValueFlat:
3521         return TransformStyle3DFlat;
3522     case CSSValuePreserve3d:
3523         return TransformStyle3DPreserve3D;
3524     default:
3525         ASSERT_NOT_REACHED();
3526         return TransformStyle3DFlat;
3527     }
3528 }
3529
3530 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnAxis e)
3531     : CSSValue(PrimitiveClass)
3532 {
3533     m_primitiveUnitType = CSS_IDENT;
3534     switch (e) {
3535     case HorizontalColumnAxis:
3536         m_value.ident = CSSValueHorizontal;
3537         break;
3538     case VerticalColumnAxis:
3539         m_value.ident = CSSValueVertical;
3540         break;
3541     case AutoColumnAxis:
3542         m_value.ident = CSSValueAuto;
3543         break;
3544     }
3545 }
3546
3547 template<> inline CSSPrimitiveValue::operator ColumnAxis() const
3548 {
3549     switch (m_value.ident) {
3550     case CSSValueHorizontal:
3551         return HorizontalColumnAxis;
3552     case CSSValueVertical:
3553         return VerticalColumnAxis;
3554     case CSSValueAuto:
3555         return AutoColumnAxis;
3556     default:
3557         ASSERT_NOT_REACHED();
3558         return AutoColumnAxis;
3559     }
3560 }
3561
3562 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WrapFlow wrapFlow)
3563 : CSSValue(PrimitiveClass)
3564 {
3565     m_primitiveUnitType = CSS_IDENT;
3566     switch (wrapFlow) {
3567     case WrapFlowAuto:
3568         m_value.ident = CSSValueAuto;
3569         break;
3570     case WrapFlowBoth:
3571         m_value.ident = CSSValueBoth;
3572         break;
3573     case WrapFlowLeft:
3574         m_value.ident = CSSValueLeft;
3575         break;
3576     case WrapFlowRight:
3577         m_value.ident = CSSValueRight;
3578         break;
3579     case WrapFlowMaximum:
3580         m_value.ident = CSSValueMaximum;
3581         break;
3582     case WrapFlowClear:
3583         m_value.ident = CSSValueClear;
3584         break;
3585     }
3586 }
3587
3588 template<> inline CSSPrimitiveValue::operator WrapFlow() const
3589 {
3590     switch (m_value.ident) {
3591     case CSSValueAuto:
3592         return WrapFlowAuto;
3593     case CSSValueBoth:
3594         return WrapFlowBoth;
3595     case CSSValueLeft:
3596         return WrapFlowLeft;
3597     case CSSValueRight:
3598         return WrapFlowRight;
3599     case CSSValueMaximum:
3600         return WrapFlowMaximum;
3601     case CSSValueClear:
3602         return WrapFlowClear;
3603     default:
3604         ASSERT_NOT_REACHED();
3605         return WrapFlowAuto;
3606     }
3607 }
3608
3609 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WrapThrough wrapThrough)
3610 : CSSValue(PrimitiveClass)
3611 {
3612     m_primitiveUnitType = CSS_IDENT;
3613     switch (wrapThrough) {
3614     case WrapThroughWrap:
3615         m_value.ident = CSSValueWrap;
3616         break;
3617     case WrapThroughNone:
3618         m_value.ident = CSSValueNone;
3619         break;
3620     }
3621 }
3622
3623 template<> inline CSSPrimitiveValue::operator WrapThrough() const
3624 {
3625     switch (m_value.ident) {
3626     case CSSValueWrap:
3627         return WrapThroughWrap;
3628     case CSSValueNone:
3629         return WrapThroughNone;
3630     default:
3631         ASSERT_NOT_REACHED();
3632         return WrapThroughWrap;
3633     }
3634 }
3635
3636 #if ENABLE(SVG)
3637
3638 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
3639     : CSSValue(PrimitiveClass)
3640 {
3641     m_primitiveUnitType = CSS_IDENT;
3642     switch (e) {
3643         case CI_AUTO:
3644             m_value.ident = CSSValueAuto;
3645             break;
3646         case CI_SRGB:
3647             m_value.ident = CSSValueSrgb;
3648             break;
3649         case CI_LINEARRGB:
3650             m_value.ident = CSSValueLinearrgb;
3651             break;
3652     }
3653 }
3654
3655 template<> inline CSSPrimitiveValue::operator EColorInterpolation() const
3656 {
3657     switch (m_value.ident) {
3658         case CSSValueSrgb:
3659             return CI_SRGB;
3660         case CSSValueLinearrgb:
3661             return CI_LINEARRGB;
3662         case CSSValueAuto:
3663             return CI_AUTO;
3664         default:
3665             ASSERT_NOT_REACHED();
3666             return CI_AUTO;
3667     }
3668 }
3669
3670 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
3671     : CSSValue(PrimitiveClass)
3672 {
3673     m_primitiveUnitType = CSS_IDENT;
3674     switch (e) {
3675         case CR_AUTO:
3676             m_value.ident = CSSValueAuto;
3677             break;
3678         case CR_OPTIMIZESPEED:
3679             m_value.ident = CSSValueOptimizespeed;
3680             break;
3681         case CR_OPTIMIZEQUALITY:
3682             m_value.ident = CSSValueOptimizequality;
3683             break;
3684     }
3685 }
3686
3687 template<> inline CSSPrimitiveValue::operator EColorRendering() const
3688 {
3689     switch (m_value.ident) {
3690         case CSSValueOptimizespeed:
3691             return CR_OPTIMIZESPEED;
3692         case CSSValueOptimizequality:
3693             return CR_OPTIMIZEQUALITY;
3694         case CSSValueAuto:
3695             return CR_AUTO;
3696         default:
3697             ASSERT_NOT_REACHED();
3698             return CR_AUTO;
3699     }
3700 }
3701
3702 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
3703     : CSSValue(PrimitiveClass)
3704 {
3705     m_primitiveUnitType = CSS_IDENT;
3706     switch (e) {
3707         case DB_AUTO:
3708             m_value.ident = CSSValueAuto;
3709             break;
3710         case DB_USE_SCRIPT:
3711             m_value.ident = CSSValueUseScript;
3712             break;
3713         case DB_NO_CHANGE:
3714             m_value.ident = CSSValueNoChange;
3715             break;
3716         case DB_RESET_SIZE:
3717             m_value.ident = CSSValueResetSize;
3718             break;
3719         case DB_CENTRAL:
3720             m_value.ident = CSSValueCentral;
3721             break;
3722         case DB_MIDDLE:
3723             m_value.ident = CSSValueMiddle;
3724             break;
3725         case DB_TEXT_BEFORE_EDGE:
3726             m_value.ident = CSSValueTextBeforeEdge;
3727             break;
3728         case DB_TEXT_AFTER_EDGE:
3729             m_value.ident = CSSValueTextAfterEdge;
3730             break;
3731         case DB_IDEOGRAPHIC:
3732             m_value.ident = CSSValueIdeographic;
3733             break;
3734         case DB_ALPHABETIC:
3735             m_value.ident = CSSValueAlphabetic;
3736             break;
3737         case DB_HANGING:
3738             m_value.ident = CSSValueHanging;
3739             break;
3740         case DB_MATHEMATICAL:
3741             m_value.ident = CSSValueMathematical;
3742             break;
3743     }
3744 }
3745
3746 template<> inline CSSPrimitiveValue::operator EDominantBaseline() const
3747 {
3748     switch (m_value.ident) {
3749         case CSSValueAuto:
3750             return DB_AUTO;
3751         case CSSValueUseScript:
3752             return DB_USE_SCRIPT;
3753         case CSSValueNoChange:
3754             return DB_NO_CHANGE;
3755         case CSSValueResetSize:
3756             return DB_RESET_SIZE;
3757         case CSSValueIdeographic:
3758             return DB_IDEOGRAPHIC;
3759         case CSSValueAlphabetic:
3760             return DB_ALPHABETIC;
3761         case CSSValueHanging:
3762             return DB_HANGING;
3763         case CSSValueMathematical:
3764             return DB_MATHEMATICAL;
3765         case CSSValueCentral:
3766             return DB_CENTRAL;
3767         case CSSValueMiddle:
3768             return DB_MIDDLE;
3769         case CSSValueTextAfterEdge:
3770             return DB_TEXT_AFTER_EDGE;
3771         case CSSValueTextBeforeEdge:
3772             return DB_TEXT_BEFORE_EDGE;
3773         default:
3774             ASSERT_NOT_REACHED();
3775             return DB_AUTO;
3776     }
3777 }
3778
3779 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
3780     : CSSValue(PrimitiveClass)
3781 {
3782     m_primitiveUnitType = CSS_IDENT;
3783     switch (e) {
3784     case SR_AUTO:
3785         m_value.ident = CSSValueAuto;
3786         break;
3787     case SR_OPTIMIZESPEED:
3788         m_value.ident = CSSValueOptimizespeed;
3789         break;
3790     case SR_CRISPEDGES:
3791         m_value.ident = CSSValueCrispedges;
3792         break;
3793     case SR_GEOMETRICPRECISION:
3794         m_value.ident = CSSValueGeometricprecision;
3795         break;
3796     }
3797 }
3798
3799 template<> inline CSSPrimitiveValue::operator EShapeRendering() const
3800 {
3801     switch (m_value.ident) {
3802     case CSSValueAuto:
3803         return SR_AUTO;
3804     case CSSValueOptimizespeed:
3805         return SR_OPTIMIZESPEED;
3806     case CSSValueCrispedges:
3807         return SR_CRISPEDGES;
3808     case CSSValueGeometricprecision:
3809         return SR_GEOMETRICPRECISION;
3810     default:
3811         ASSERT_NOT_REACHED();
3812         return SR_AUTO;
3813     }
3814 }
3815
3816 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
3817     : CSSValue(PrimitiveClass)
3818 {
3819     m_primitiveUnitType = CSS_IDENT;
3820     switch (e) {
3821         case TA_START:
3822             m_value.ident = CSSValueStart;
3823             break;
3824         case TA_MIDDLE:
3825             m_value.ident = CSSValueMiddle;
3826             break;
3827         case TA_END:
3828             m_value.ident = CSSValueEnd;
3829             break;
3830     }
3831 }
3832
3833 template<> inline CSSPrimitiveValue::operator ETextAnchor() const
3834 {
3835     switch (m_value.ident) {
3836         case CSSValueStart:
3837             return TA_START;
3838         case CSSValueMiddle:
3839             return TA_MIDDLE;
3840         case CSSValueEnd:
3841             return TA_END;
3842         default:
3843             ASSERT_NOT_REACHED();
3844             return TA_START;
3845     }
3846 }
3847
3848 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SVGWritingMode e)
3849     : CSSValue(PrimitiveClass)
3850 {
3851     m_primitiveUnitType = CSS_IDENT;
3852     switch (e) {
3853         case WM_LRTB:
3854             m_value.ident = CSSValueLrTb;
3855             break;
3856         case WM_LR:
3857             m_value.ident = CSSValueLr;
3858             break;
3859         case WM_RLTB:
3860             m_value.ident = CSSValueRlTb;
3861             break;
3862         case WM_RL:
3863             m_value.ident = CSSValueRl;
3864             break;
3865         case WM_TBRL:
3866             m_value.ident = CSSValueTbRl;
3867             break;
3868         case WM_TB:
3869             m_value.ident = CSSValueTb;
3870             break;
3871     }
3872 }
3873
3874 template<> inline CSSPrimitiveValue::operator SVGWritingMode() const
3875 {
3876     switch (m_value.ident) {
3877     case CSSValueLrTb:
3878         return WM_LRTB;
3879     case CSSValueLr:
3880         return WM_LR;
3881     case CSSValueRlTb:
3882         return WM_RLTB;
3883     case CSSValueRl:
3884         return WM_RL;
3885     case CSSValueTbRl:
3886         return WM_TBRL;
3887     case CSSValueTb:
3888         return WM_TB;
3889     default:
3890         ASSERT_NOT_REACHED();
3891         return WM_LRTB;
3892     }
3893 }
3894
3895 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVectorEffect e)
3896     : CSSValue(PrimitiveClass)
3897 {
3898     m_primitiveUnitType = CSS_IDENT;
3899     switch (e) {
3900     case VE_NONE:
3901         m_value.ident = CSSValueNone;
3902         break;
3903     case VE_NON_SCALING_STROKE:
3904         m_value.ident = CSSValueNonScalingStroke;
3905         break;
3906     }
3907 }
3908
3909 template<> inline CSSPrimitiveValue::operator EVectorEffect() const
3910 {
3911     switch (m_value.ident) {
3912     case CSSValueNone:
3913         return VE_NONE;
3914     case CSSValueNonScalingStroke:
3915         return VE_NON_SCALING_STROKE;
3916     default:
3917         ASSERT_NOT_REACHED();
3918         return VE_NONE;
3919     }
3920 }
3921
3922 #endif // ENABLE(SVG)
3923
3924 }
3925
3926 #endif