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