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