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