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