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