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