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