Remove the -webkit-match-nearest-mail-blockquote-color property.
[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(ENBSPMode e)
1908     : CSSValue(PrimitiveClass)
1909 {
1910     m_primitiveUnitType = CSS_IDENT;
1911     switch (e) {
1912         case NBNORMAL:
1913             m_value.ident = CSSValueNormal;
1914             break;
1915         case SPACE:
1916             m_value.ident = CSSValueSpace;
1917             break;
1918     }
1919 }
1920
1921 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
1922 {
1923     switch (m_value.ident) {
1924         case CSSValueSpace:
1925             return SPACE;
1926         case CSSValueNormal:
1927             return NBNORMAL;
1928         default:
1929             ASSERT_NOT_REACHED();
1930             return NBNORMAL;
1931     }
1932 }
1933
1934 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
1935     : CSSValue(PrimitiveClass)
1936 {
1937     m_primitiveUnitType = CSS_IDENT;
1938     switch (e) {
1939         case OVISIBLE:
1940             m_value.ident = CSSValueVisible;
1941             break;
1942         case OHIDDEN:
1943             m_value.ident = CSSValueHidden;
1944             break;
1945         case OSCROLL:
1946             m_value.ident = CSSValueScroll;
1947             break;
1948         case OAUTO:
1949             m_value.ident = CSSValueAuto;
1950             break;
1951         case OMARQUEE:
1952             m_value.ident = CSSValueWebkitMarquee;
1953             break;
1954         case OOVERLAY:
1955             m_value.ident = CSSValueOverlay;
1956             break;
1957     }
1958 }
1959
1960 template<> inline CSSPrimitiveValue::operator EOverflow() const
1961 {
1962     switch (m_value.ident) {
1963         case CSSValueVisible:
1964             return OVISIBLE;
1965         case CSSValueHidden:
1966             return OHIDDEN;
1967         case CSSValueScroll:
1968             return OSCROLL;
1969         case CSSValueAuto:
1970             return OAUTO;
1971         case CSSValueWebkitMarquee:
1972             return OMARQUEE;
1973         case CSSValueOverlay:
1974             return OOVERLAY;
1975         default:
1976             ASSERT_NOT_REACHED();
1977             return OVISIBLE;
1978     }
1979 }
1980
1981 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
1982     : CSSValue(PrimitiveClass)
1983 {
1984     m_primitiveUnitType = CSS_IDENT;
1985     switch (e) {
1986         case PBAUTO:
1987             m_value.ident = CSSValueAuto;
1988             break;
1989         case PBALWAYS:
1990             m_value.ident = CSSValueAlways;
1991             break;
1992         case PBAVOID:
1993             m_value.ident = CSSValueAvoid;
1994             break;
1995     }
1996 }
1997
1998 template<> inline CSSPrimitiveValue::operator EPageBreak() const
1999 {
2000     switch (m_value.ident) {
2001         case CSSValueAuto:
2002             return PBAUTO;
2003         case CSSValueLeft:
2004         case CSSValueRight:
2005         case CSSValueAlways:
2006             return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always."
2007         case CSSValueAvoid:
2008             return PBAVOID;
2009         default:
2010             ASSERT_NOT_REACHED();
2011             return PBAUTO;
2012     }
2013 }
2014
2015 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
2016     : CSSValue(PrimitiveClass)
2017 {
2018     m_primitiveUnitType = CSS_IDENT;
2019     switch (e) {
2020         case StaticPosition:
2021             m_value.ident = CSSValueStatic;
2022             break;
2023         case RelativePosition:
2024             m_value.ident = CSSValueRelative;
2025             break;
2026         case AbsolutePosition:
2027             m_value.ident = CSSValueAbsolute;
2028             break;
2029         case FixedPosition:
2030             m_value.ident = CSSValueFixed;
2031             break;
2032     }
2033 }
2034
2035 template<> inline CSSPrimitiveValue::operator EPosition() const
2036 {
2037     switch (m_value.ident) {
2038         case CSSValueStatic:
2039             return StaticPosition;
2040         case CSSValueRelative:
2041             return RelativePosition;
2042         case CSSValueAbsolute:
2043             return AbsolutePosition;
2044         case CSSValueFixed:
2045             return FixedPosition;
2046         default:
2047             ASSERT_NOT_REACHED();
2048             return StaticPosition;
2049     }
2050 }
2051
2052 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
2053     : CSSValue(PrimitiveClass)
2054 {
2055     m_primitiveUnitType = CSS_IDENT;
2056     switch (e) {
2057         case RESIZE_BOTH:
2058             m_value.ident = CSSValueBoth;
2059             break;
2060         case RESIZE_HORIZONTAL:
2061             m_value.ident = CSSValueHorizontal;
2062             break;
2063         case RESIZE_VERTICAL:
2064             m_value.ident = CSSValueVertical;
2065             break;
2066         case RESIZE_NONE:
2067             m_value.ident = CSSValueNone;
2068             break;
2069     }
2070 }
2071
2072 template<> inline CSSPrimitiveValue::operator EResize() const
2073 {
2074     switch (m_value.ident) {
2075         case CSSValueBoth:
2076             return RESIZE_BOTH;
2077         case CSSValueHorizontal:
2078             return RESIZE_HORIZONTAL;
2079         case CSSValueVertical:
2080             return RESIZE_VERTICAL;
2081         case CSSValueAuto:
2082             ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2083             return RESIZE_NONE;
2084         case CSSValueNone:
2085             return RESIZE_NONE;
2086         default:
2087             ASSERT_NOT_REACHED();
2088             return RESIZE_NONE;
2089     }
2090 }
2091
2092 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2093     : CSSValue(PrimitiveClass)
2094 {
2095     m_primitiveUnitType = CSS_IDENT;
2096     switch (e) {
2097         case TAUTO:
2098             m_value.ident = CSSValueAuto;
2099             break;
2100         case TFIXED:
2101             m_value.ident = CSSValueFixed;
2102             break;
2103     }
2104 }
2105
2106 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2107 {
2108     switch (m_value.ident) {
2109         case CSSValueFixed:
2110             return TFIXED;
2111         case CSSValueAuto:
2112             return TAUTO;
2113         default:
2114             ASSERT_NOT_REACHED();
2115             return TAUTO;
2116     }
2117 }
2118
2119 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2120     : CSSValue(PrimitiveClass)
2121 {
2122     m_primitiveUnitType = CSS_IDENT;
2123     switch (e) {
2124     case TASTART:
2125         m_value.ident = CSSValueStart;
2126         break;
2127     case TAEND:
2128         m_value.ident = CSSValueEnd;
2129         break;
2130     case LEFT:
2131         m_value.ident = CSSValueLeft;
2132         break;
2133     case RIGHT:
2134         m_value.ident = CSSValueRight;
2135         break;
2136     case CENTER:
2137         m_value.ident = CSSValueCenter;
2138         break;
2139     case JUSTIFY:
2140         m_value.ident = CSSValueJustify;
2141         break;
2142     case WEBKIT_LEFT:
2143         m_value.ident = CSSValueWebkitLeft;
2144         break;
2145     case WEBKIT_RIGHT:
2146         m_value.ident = CSSValueWebkitRight;
2147         break;
2148     case WEBKIT_CENTER:
2149         m_value.ident = CSSValueWebkitCenter;
2150         break;
2151     }
2152 }
2153
2154 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2155 {
2156     switch (m_value.ident) {
2157     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2158     case CSSValueStart:
2159         return TASTART;
2160     case CSSValueEnd:
2161         return TAEND;
2162     default:
2163         return static_cast<ETextAlign>(m_value.ident - CSSValueLeft);
2164     }
2165 }
2166
2167 template<> inline CSSPrimitiveValue::operator ETextDecoration() const
2168 {
2169     switch (m_value.ident) {
2170     case CSSValueNone:
2171         return TDNONE;
2172     case CSSValueUnderline:
2173         return UNDERLINE;
2174     case CSSValueOverline:
2175         return OVERLINE;
2176     case CSSValueLineThrough:
2177         return LINE_THROUGH;
2178     case CSSValueBlink:
2179         return BLINK;
2180     default:
2181         ASSERT_NOT_REACHED();
2182         return TDNONE;
2183     }
2184 }
2185
2186 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2187     : CSSValue(PrimitiveClass)
2188 {
2189     m_primitiveUnitType = CSS_IDENT;
2190     switch (e) {
2191         case TSNONE:
2192             m_value.ident = CSSValueNone;
2193             break;
2194         case TSDISC:
2195             m_value.ident = CSSValueDisc;
2196             break;
2197         case TSCIRCLE:
2198             m_value.ident = CSSValueCircle;
2199             break;
2200         case TSSQUARE:
2201             m_value.ident = CSSValueSquare;
2202             break;
2203     }
2204 }
2205
2206 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2207 {
2208     switch (m_value.ident) {
2209         case CSSValueNone:
2210             return TSNONE;
2211         case CSSValueDisc:
2212             return TSDISC;
2213         case CSSValueCircle:
2214             return TSCIRCLE;
2215         case CSSValueSquare:
2216             return TSSQUARE;
2217         default:
2218             ASSERT_NOT_REACHED();
2219             return TSNONE;
2220     }
2221 }
2222
2223 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2224     : CSSValue(PrimitiveClass)
2225 {
2226     m_primitiveUnitType = CSS_IDENT;
2227     switch (e) {
2228         case CAPITALIZE:
2229             m_value.ident = CSSValueCapitalize;
2230             break;
2231         case UPPERCASE:
2232             m_value.ident = CSSValueUppercase;
2233             break;
2234         case LOWERCASE:
2235             m_value.ident = CSSValueLowercase;
2236             break;
2237         case TTNONE:
2238             m_value.ident = CSSValueNone;
2239             break;
2240     }
2241 }
2242
2243 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2244 {
2245     switch (m_value.ident) {
2246         case CSSValueCapitalize:
2247             return CAPITALIZE;
2248         case CSSValueUppercase:
2249             return UPPERCASE;
2250         case CSSValueLowercase:
2251             return LOWERCASE;
2252         case CSSValueNone:
2253             return TTNONE;
2254         default:
2255             ASSERT_NOT_REACHED();
2256             return TTNONE;
2257     }
2258 }
2259
2260 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2261 {
2262     switch (m_value.ident) {
2263     case CSSValueNormal:
2264         return UBNormal;
2265     case CSSValueEmbed:
2266         return Embed;
2267     case CSSValueBidiOverride:
2268         return Override;
2269     case CSSValueWebkitIsolate:
2270         return Isolate;
2271     case CSSValueWebkitPlaintext:
2272         return Plaintext;
2273     default:
2274         ASSERT_NOT_REACHED();
2275         return UBNormal;
2276     }
2277 }
2278
2279 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2280     : CSSValue(PrimitiveClass)
2281 {
2282     m_primitiveUnitType = CSS_IDENT;
2283     switch (e) {
2284         case DRAG_AUTO:
2285             m_value.ident = CSSValueAuto;
2286             break;
2287         case DRAG_NONE:
2288             m_value.ident = CSSValueNone;
2289             break;
2290         case DRAG_ELEMENT:
2291             m_value.ident = CSSValueElement;
2292             break;
2293     }
2294 }
2295
2296 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2297 {
2298     switch (m_value.ident) {
2299         case CSSValueAuto:
2300             return DRAG_AUTO;
2301         case CSSValueNone:
2302             return DRAG_NONE;
2303         case CSSValueElement:
2304             return DRAG_ELEMENT;
2305         default:
2306             ASSERT_NOT_REACHED();
2307             return DRAG_AUTO;
2308     }
2309 }
2310
2311 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2312     : CSSValue(PrimitiveClass)
2313 {
2314     m_primitiveUnitType = CSS_IDENT;
2315     switch (e) {
2316         case READ_ONLY:
2317             m_value.ident = CSSValueReadOnly;
2318             break;
2319         case READ_WRITE:
2320             m_value.ident = CSSValueReadWrite;
2321             break;
2322         case READ_WRITE_PLAINTEXT_ONLY:
2323             m_value.ident = CSSValueReadWritePlaintextOnly;
2324             break;
2325     }
2326 }
2327
2328 template<> inline CSSPrimitiveValue::operator EUserModify() const
2329 {
2330     switch (m_value.ident) {
2331     case CSSValueReadOnly:
2332         return READ_ONLY;
2333     case CSSValueReadWrite:
2334         return READ_WRITE;
2335     case CSSValueReadWritePlaintextOnly:
2336         return READ_WRITE_PLAINTEXT_ONLY;
2337     default:
2338         ASSERT_NOT_REACHED();
2339         return READ_ONLY;
2340     }
2341 }
2342
2343 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2344     : CSSValue(PrimitiveClass)
2345 {
2346     m_primitiveUnitType = CSS_IDENT;
2347     switch (e) {
2348         case SELECT_NONE:
2349             m_value.ident = CSSValueNone;
2350             break;
2351         case SELECT_TEXT:
2352             m_value.ident = CSSValueText;
2353             break;
2354     }
2355 }
2356
2357 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2358 {
2359     switch (m_value.ident) {
2360         case CSSValueAuto:
2361             return SELECT_TEXT;
2362         case CSSValueNone:
2363             return SELECT_NONE;
2364         case CSSValueText:
2365             return SELECT_TEXT;
2366         default:
2367             ASSERT_NOT_REACHED();
2368             return SELECT_TEXT;
2369     }
2370 }
2371
2372 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2373     : CSSValue(PrimitiveClass)
2374 {
2375     m_primitiveUnitType = CSS_IDENT;
2376     switch (a) {
2377     case TOP:
2378         m_value.ident = CSSValueTop;
2379         break;
2380     case BOTTOM:
2381         m_value.ident = CSSValueBottom;
2382         break;
2383     case MIDDLE:
2384         m_value.ident = CSSValueMiddle;
2385         break;
2386     case BASELINE:
2387         m_value.ident = CSSValueBaseline;
2388         break;
2389     case TEXT_BOTTOM:
2390         m_value.ident = CSSValueTextBottom;
2391         break;
2392     case TEXT_TOP:
2393         m_value.ident = CSSValueTextTop;
2394         break;
2395     case SUB:
2396         m_value.ident = CSSValueSub;
2397         break;
2398     case SUPER:
2399         m_value.ident = CSSValueSuper;
2400         break;
2401     case BASELINE_MIDDLE:
2402         m_value.ident = CSSValueWebkitBaselineMiddle;
2403         break;
2404     case LENGTH:
2405         m_value.ident = CSSValueInvalid;
2406     }
2407 }
2408
2409 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2410 {
2411     switch (m_value.ident) {
2412     case CSSValueTop:
2413         return TOP;
2414     case CSSValueBottom:
2415         return BOTTOM;
2416     case CSSValueMiddle:
2417         return MIDDLE;
2418     case CSSValueBaseline:
2419         return BASELINE;
2420     case CSSValueTextBottom:
2421         return TEXT_BOTTOM;
2422     case CSSValueTextTop:
2423         return TEXT_TOP;
2424     case CSSValueSub:
2425         return SUB;
2426     case CSSValueSuper:
2427         return SUPER;
2428     case CSSValueWebkitBaselineMiddle:
2429         return BASELINE_MIDDLE;
2430     default:
2431         ASSERT_NOT_REACHED();
2432         return TOP;
2433     }
2434 }
2435
2436 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
2437     : CSSValue(PrimitiveClass)
2438 {
2439     m_primitiveUnitType = CSS_IDENT;
2440     switch (e) {
2441         case VISIBLE:
2442             m_value.ident = CSSValueVisible;
2443             break;
2444         case HIDDEN:
2445             m_value.ident = CSSValueHidden;
2446             break;
2447         case COLLAPSE:
2448             m_value.ident = CSSValueCollapse;
2449             break;
2450     }
2451 }
2452
2453 template<> inline CSSPrimitiveValue::operator EVisibility() const
2454 {
2455     switch (m_value.ident) {
2456         case CSSValueHidden:
2457             return HIDDEN;
2458         case CSSValueVisible:
2459             return VISIBLE;
2460         case CSSValueCollapse:
2461             return COLLAPSE;
2462         default:
2463             ASSERT_NOT_REACHED();
2464             return VISIBLE;
2465     }
2466 }
2467
2468 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
2469     : CSSValue(PrimitiveClass)
2470 {
2471     m_primitiveUnitType = CSS_IDENT;
2472     switch (e) {
2473         case NORMAL:
2474             m_value.ident = CSSValueNormal;
2475             break;
2476         case PRE:
2477             m_value.ident = CSSValuePre;
2478             break;
2479         case PRE_WRAP:
2480             m_value.ident = CSSValuePreWrap;
2481             break;
2482         case PRE_LINE:
2483             m_value.ident = CSSValuePreLine;
2484             break;
2485         case NOWRAP:
2486             m_value.ident = CSSValueNowrap;
2487             break;
2488         case KHTML_NOWRAP:
2489             m_value.ident = CSSValueWebkitNowrap;
2490             break;
2491     }
2492 }
2493
2494 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
2495 {
2496     switch (m_value.ident) {
2497         case CSSValueWebkitNowrap:
2498             return KHTML_NOWRAP;
2499         case CSSValueNowrap:
2500             return NOWRAP;
2501         case CSSValuePre:
2502             return PRE;
2503         case CSSValuePreWrap:
2504             return PRE_WRAP;
2505         case CSSValuePreLine:
2506             return PRE_LINE;
2507         case CSSValueNormal:
2508             return NORMAL;
2509         default:
2510             ASSERT_NOT_REACHED();
2511             return NORMAL;
2512     }
2513 }
2514
2515 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
2516     : CSSValue(PrimitiveClass)
2517 {
2518     m_primitiveUnitType = CSS_IDENT;
2519     switch (e) {
2520         case NormalWordBreak:
2521             m_value.ident = CSSValueNormal;
2522             break;
2523         case BreakAllWordBreak:
2524             m_value.ident = CSSValueBreakAll;
2525             break;
2526         case BreakWordBreak:
2527             m_value.ident = CSSValueBreakWord;
2528             break;
2529     }
2530 }
2531
2532 template<> inline CSSPrimitiveValue::operator EWordBreak() const
2533 {
2534     switch (m_value.ident) {
2535         case CSSValueBreakAll:
2536             return BreakAllWordBreak;
2537         case CSSValueBreakWord:
2538             return BreakWordBreak;
2539         case CSSValueNormal:
2540             return NormalWordBreak;
2541         default:
2542         ASSERT_NOT_REACHED();
2543         return NormalWordBreak;
2544     }
2545 }
2546
2547 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordWrap e)
2548     : CSSValue(PrimitiveClass)
2549 {
2550     m_primitiveUnitType = CSS_IDENT;
2551     switch (e) {
2552         case NormalWordWrap:
2553             m_value.ident = CSSValueNormal;
2554             break;
2555         case BreakWordWrap:
2556             m_value.ident = CSSValueBreakWord;
2557             break;
2558     }
2559 }
2560
2561 template<> inline CSSPrimitiveValue::operator EWordWrap() const
2562 {
2563     switch (m_value.ident) {
2564         case CSSValueBreakWord:
2565             return BreakWordWrap;
2566         case CSSValueNormal:
2567             return NormalWordWrap;
2568         default:
2569             ASSERT_NOT_REACHED();
2570             return NormalWordWrap;
2571     }
2572 }
2573
2574 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
2575     : CSSValue(PrimitiveClass)
2576 {
2577     m_primitiveUnitType = CSS_IDENT;
2578     switch (e) {
2579         case LTR:
2580             m_value.ident = CSSValueLtr;
2581             break;
2582         case RTL:
2583             m_value.ident = CSSValueRtl;
2584             break;
2585     }
2586 }
2587
2588 template<> inline CSSPrimitiveValue::operator TextDirection() const
2589 {
2590     switch (m_value.ident) {
2591         case CSSValueLtr:
2592             return LTR;
2593         case CSSValueRtl:
2594             return RTL;
2595         default:
2596             ASSERT_NOT_REACHED();
2597             return LTR;
2598     }
2599 }
2600
2601 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
2602     : CSSValue(PrimitiveClass)
2603 {
2604     m_primitiveUnitType = CSS_IDENT;
2605     switch (e) {
2606     case TopToBottomWritingMode:
2607         m_value.ident = CSSValueHorizontalTb;
2608         break;
2609     case RightToLeftWritingMode:
2610         m_value.ident = CSSValueVerticalRl;
2611         break;
2612     case LeftToRightWritingMode:
2613         m_value.ident = CSSValueVerticalLr;
2614         break;
2615     case BottomToTopWritingMode:
2616         m_value.ident = CSSValueHorizontalBt;
2617         break;
2618     }
2619 }
2620
2621 template<> inline CSSPrimitiveValue::operator WritingMode() const
2622 {
2623     switch (m_value.ident) {
2624     case CSSValueHorizontalTb:
2625         return TopToBottomWritingMode;
2626     case CSSValueVerticalRl:
2627         return RightToLeftWritingMode;
2628     case CSSValueVerticalLr:
2629         return LeftToRightWritingMode;
2630     case CSSValueHorizontalBt:
2631         return BottomToTopWritingMode;
2632     default:
2633         ASSERT_NOT_REACHED();
2634         return TopToBottomWritingMode;
2635     }
2636 }
2637
2638 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
2639     : CSSValue(PrimitiveClass)
2640 {
2641     m_primitiveUnitType = CSS_IDENT;
2642     switch (e) {
2643     case TextCombineNone:
2644         m_value.ident = CSSValueNone;
2645         break;
2646     case TextCombineHorizontal:
2647         m_value.ident = CSSValueHorizontal;
2648         break;
2649     }
2650 }
2651
2652 template<> inline CSSPrimitiveValue::operator TextCombine() const
2653 {
2654     switch (m_value.ident) {
2655     case CSSValueNone:
2656         return TextCombineNone;
2657     case CSSValueHorizontal:
2658         return TextCombineHorizontal;
2659     default:
2660         ASSERT_NOT_REACHED();
2661         return TextCombineNone;
2662     }
2663 }
2664
2665 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
2666     : CSSValue(PrimitiveClass)
2667 {
2668     m_primitiveUnitType = CSS_IDENT;
2669     switch (position) {
2670     case TextEmphasisPositionOver:
2671         m_value.ident = CSSValueOver;
2672         break;
2673     case TextEmphasisPositionUnder:
2674         m_value.ident = CSSValueUnder;
2675         break;
2676     }
2677 }
2678
2679 template<> inline CSSPrimitiveValue::operator TextEmphasisPosition() const
2680 {
2681     switch (m_value.ident) {
2682     case CSSValueOver:
2683         return TextEmphasisPositionOver;
2684     case CSSValueUnder:
2685         return TextEmphasisPositionUnder;
2686     default:
2687         ASSERT_NOT_REACHED();
2688         return TextEmphasisPositionOver;
2689     }
2690 }
2691
2692 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
2693     : CSSValue(PrimitiveClass)
2694 {
2695     m_primitiveUnitType = CSS_IDENT;
2696     switch (overflow) {
2697     case TextOverflowClip:
2698         m_value.ident = CSSValueClip;
2699         break;
2700     case TextOverflowEllipsis:
2701         m_value.ident = CSSValueEllipsis;
2702         break;
2703     }
2704 }
2705
2706 template<> inline CSSPrimitiveValue::operator TextOverflow() const
2707 {
2708     switch (m_value.ident) {
2709     case CSSValueClip:
2710         return TextOverflowClip;
2711     case CSSValueEllipsis:
2712         return TextOverflowEllipsis;
2713     default:
2714         ASSERT_NOT_REACHED();
2715         return TextOverflowClip;
2716     }
2717 }
2718
2719 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
2720     : CSSValue(PrimitiveClass)
2721 {
2722     m_primitiveUnitType = CSS_IDENT;
2723     switch (fill) {
2724     case TextEmphasisFillFilled:
2725         m_value.ident = CSSValueFilled;
2726         break;
2727     case TextEmphasisFillOpen:
2728         m_value.ident = CSSValueOpen;
2729         break;
2730     }
2731 }
2732
2733 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
2734 {
2735     switch (m_value.ident) {
2736     case CSSValueFilled:
2737         return TextEmphasisFillFilled;
2738     case CSSValueOpen:
2739         return TextEmphasisFillOpen;
2740     default:
2741         ASSERT_NOT_REACHED();
2742         return TextEmphasisFillFilled;
2743     }
2744 }
2745
2746 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
2747     : CSSValue(PrimitiveClass)
2748 {
2749     m_primitiveUnitType = CSS_IDENT;
2750     switch (mark) {
2751     case TextEmphasisMarkDot:
2752         m_value.ident = CSSValueDot;
2753         break;
2754     case TextEmphasisMarkCircle:
2755         m_value.ident = CSSValueCircle;
2756         break;
2757     case TextEmphasisMarkDoubleCircle:
2758         m_value.ident = CSSValueDoubleCircle;
2759         break;
2760     case TextEmphasisMarkTriangle:
2761         m_value.ident = CSSValueTriangle;
2762         break;
2763     case TextEmphasisMarkSesame:
2764         m_value.ident = CSSValueSesame;
2765         break;
2766     case TextEmphasisMarkNone:
2767     case TextEmphasisMarkAuto:
2768     case TextEmphasisMarkCustom:
2769         ASSERT_NOT_REACHED();
2770         m_value.ident = CSSValueNone;
2771         break;
2772     }
2773 }
2774
2775 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
2776 {
2777     switch (m_value.ident) {
2778     case CSSValueNone:
2779         return TextEmphasisMarkNone;
2780     case CSSValueDot:
2781         return TextEmphasisMarkDot;
2782     case CSSValueCircle:
2783         return TextEmphasisMarkCircle;
2784     case CSSValueDoubleCircle:
2785         return TextEmphasisMarkDoubleCircle;
2786     case CSSValueTriangle:
2787         return TextEmphasisMarkTriangle;
2788     case CSSValueSesame:
2789         return TextEmphasisMarkSesame;
2790     default:
2791         ASSERT_NOT_REACHED();
2792         return TextEmphasisMarkNone;
2793     }
2794 }
2795
2796 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
2797     : CSSValue(PrimitiveClass)
2798 {
2799     m_primitiveUnitType = CSS_IDENT;
2800     switch (e) {
2801     case TextOrientationVerticalRight:
2802         m_value.ident = CSSValueVerticalRight;
2803         break;
2804     case TextOrientationUpright:
2805         m_value.ident = CSSValueUpright;
2806         break;
2807     }
2808 }
2809
2810 template<> inline CSSPrimitiveValue::operator TextOrientation() const
2811 {
2812     switch (m_value.ident) {
2813     case CSSValueVerticalRight:
2814         return TextOrientationVerticalRight;
2815     case CSSValueUpright:
2816         return TextOrientationUpright;
2817     default:
2818         ASSERT_NOT_REACHED();
2819         return TextOrientationVerticalRight;
2820     }
2821 }
2822
2823 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
2824     : CSSValue(PrimitiveClass)
2825 {
2826     m_primitiveUnitType = CSS_IDENT;
2827     switch (e) {
2828         case PE_NONE:
2829             m_value.ident = CSSValueNone;
2830             break;
2831         case PE_STROKE:
2832             m_value.ident = CSSValueStroke;
2833             break;
2834         case PE_FILL:
2835             m_value.ident = CSSValueFill;
2836             break;
2837         case PE_PAINTED:
2838             m_value.ident = CSSValuePainted;
2839             break;
2840         case PE_VISIBLE:
2841             m_value.ident = CSSValueVisible;
2842             break;
2843         case PE_VISIBLE_STROKE:
2844             m_value.ident = CSSValueVisiblestroke;
2845             break;
2846         case PE_VISIBLE_FILL:
2847             m_value.ident = CSSValueVisiblefill;
2848             break;
2849         case PE_VISIBLE_PAINTED:
2850             m_value.ident = CSSValueVisiblepainted;
2851             break;
2852         case PE_AUTO:
2853             m_value.ident = CSSValueAuto;
2854             break;
2855         case PE_ALL:
2856             m_value.ident = CSSValueAll;
2857             break;
2858     }
2859 }
2860
2861 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
2862 {
2863     switch (m_value.ident) {
2864         case CSSValueAll:
2865             return PE_ALL;
2866         case CSSValueAuto:
2867             return PE_AUTO;
2868         case CSSValueNone:
2869             return PE_NONE;
2870         case CSSValueVisiblepainted:
2871             return PE_VISIBLE_PAINTED;
2872         case CSSValueVisiblefill:
2873             return PE_VISIBLE_FILL;
2874         case CSSValueVisiblestroke:
2875             return PE_VISIBLE_STROKE;
2876         case CSSValueVisible:
2877             return PE_VISIBLE;
2878         case CSSValuePainted:
2879             return PE_PAINTED;
2880         case CSSValueFill:
2881             return PE_FILL;
2882         case CSSValueStroke:
2883             return PE_STROKE;
2884         default:
2885             ASSERT_NOT_REACHED();
2886             return PE_ALL;
2887     }
2888 }
2889
2890 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning)
2891     : CSSValue(PrimitiveClass)
2892 {
2893     m_primitiveUnitType = CSS_IDENT;
2894     switch (kerning) {
2895     case FontDescription::AutoKerning:
2896         m_value.ident = CSSValueAuto;
2897         return;
2898     case FontDescription::NormalKerning:
2899         m_value.ident = CSSValueNormal;
2900         return;
2901     case FontDescription::NoneKerning:
2902         m_value.ident = CSSValueNone;
2903         return;
2904     }
2905
2906     ASSERT_NOT_REACHED();
2907     m_value.ident = CSSValueAuto;
2908 }
2909
2910 template<> inline CSSPrimitiveValue::operator FontDescription::Kerning() const
2911 {
2912     switch (m_value.ident) {
2913     case CSSValueAuto:
2914         return FontDescription::AutoKerning;
2915     case CSSValueNormal:
2916         return FontDescription::NormalKerning;
2917     case CSSValueNone:
2918         return FontDescription::NoneKerning;
2919     }
2920
2921     ASSERT_NOT_REACHED();
2922     return FontDescription::AutoKerning;
2923 }
2924
2925 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
2926     : CSSValue(PrimitiveClass)
2927 {
2928     m_primitiveUnitType = CSS_IDENT;
2929     switch (smoothing) {
2930     case AutoSmoothing:
2931         m_value.ident = CSSValueAuto;
2932         return;
2933     case NoSmoothing:
2934         m_value.ident = CSSValueNone;
2935         return;
2936     case Antialiased:
2937         m_value.ident = CSSValueAntialiased;
2938         return;
2939     case SubpixelAntialiased:
2940         m_value.ident = CSSValueSubpixelAntialiased;
2941         return;
2942     }
2943
2944     ASSERT_NOT_REACHED();
2945     m_value.ident = CSSValueAuto;
2946 }
2947
2948 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
2949 {
2950     switch (m_value.ident) {
2951     case CSSValueAuto:
2952         return AutoSmoothing;
2953     case CSSValueNone:
2954         return NoSmoothing;
2955     case CSSValueAntialiased:
2956         return Antialiased;
2957     case CSSValueSubpixelAntialiased:
2958         return SubpixelAntialiased;
2959     }
2960
2961     ASSERT_NOT_REACHED();
2962     return AutoSmoothing;
2963 }
2964
2965 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
2966     : CSSValue(PrimitiveClass)
2967 {
2968     m_primitiveUnitType = CSS_IDENT;
2969     switch (weight) {
2970     case FontWeight900:
2971         m_value.ident = CSSValue900;
2972         return;
2973     case FontWeight800:
2974         m_value.ident = CSSValue800;
2975         return;
2976     case FontWeight700:
2977         m_value.ident = CSSValue700;
2978         return;
2979     case FontWeight600:
2980         m_value.ident = CSSValue600;
2981         return;
2982     case FontWeight500:
2983         m_value.ident = CSSValue500;
2984         return;
2985     case FontWeight400:
2986         m_value.ident = CSSValue400;
2987         return;
2988     case FontWeight300:
2989         m_value.ident = CSSValue300;
2990         return;
2991     case FontWeight200:
2992         m_value.ident = CSSValue200;
2993         return;
2994     case FontWeight100:
2995         m_value.ident = CSSValue100;
2996         return;
2997     }
2998
2999     ASSERT_NOT_REACHED();
3000     m_value.ident = CSSValueNormal;
3001 }
3002
3003 template<> inline CSSPrimitiveValue::operator FontWeight() const
3004 {
3005     switch (m_value.ident) {
3006     case CSSValueBold:
3007         return FontWeightBold;
3008     case CSSValueNormal:
3009         return FontWeightNormal;
3010     case CSSValue900:
3011         return FontWeight900;
3012     case CSSValue800:
3013         return FontWeight800;
3014     case CSSValue700:
3015         return FontWeight700;
3016     case CSSValue600:
3017         return FontWeight600;
3018     case CSSValue500:
3019         return FontWeight500;
3020     case CSSValue400:
3021         return FontWeight400;
3022     case CSSValue300:
3023         return FontWeight300;
3024     case CSSValue200:
3025         return FontWeight200;
3026     case CSSValue100:
3027         return FontWeight100;
3028     }
3029
3030     ASSERT_NOT_REACHED();
3031     return FontWeightNormal;
3032 }
3033
3034 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic)
3035     : CSSValue(PrimitiveClass)
3036 {
3037     m_primitiveUnitType = CSS_IDENT;
3038     switch (italic) {
3039     case FontItalicOff:
3040         m_value.ident = CSSValueNormal;
3041         return;
3042     case FontItalicOn:
3043         m_value.ident = CSSValueItalic;
3044         return;
3045     }
3046
3047     ASSERT_NOT_REACHED();
3048     m_value.ident = CSSValueNormal;
3049 }
3050
3051 template<> inline CSSPrimitiveValue::operator FontItalic() const
3052 {
3053     switch (m_value.ident) {
3054     case CSSValueOblique:
3055     // FIXME: oblique is the same as italic for the moment...
3056     case CSSValueItalic:
3057         return FontItalicOn;
3058     case CSSValueNormal:
3059         return FontItalicOff;
3060     }
3061     ASSERT_NOT_REACHED();
3062     return FontItalicOff;
3063 }
3064
3065 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
3066     : CSSValue(PrimitiveClass)
3067 {
3068     m_primitiveUnitType = CSS_IDENT;
3069     switch (smallCaps) {
3070     case FontSmallCapsOff:
3071         m_value.ident = CSSValueNormal;
3072         return;
3073     case FontSmallCapsOn:
3074         m_value.ident = CSSValueSmallCaps;
3075         return;
3076     }
3077
3078     ASSERT_NOT_REACHED();
3079     m_value.ident = CSSValueNormal;
3080 }
3081
3082 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
3083 {
3084     switch (m_value.ident) {
3085     case CSSValueSmallCaps:
3086         return FontSmallCapsOn;
3087     case CSSValueNormal:
3088         return FontSmallCapsOff;
3089     }
3090     ASSERT_NOT_REACHED();
3091     return FontSmallCapsOff;
3092 }
3093
3094 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
3095     : CSSValue(PrimitiveClass)
3096 {
3097     m_primitiveUnitType = CSS_IDENT;
3098     switch (e) {
3099         case AutoTextRendering:
3100             m_value.ident = CSSValueAuto;
3101             break;
3102         case OptimizeSpeed:
3103             m_value.ident = CSSValueOptimizespeed;
3104             break;
3105         case OptimizeLegibility:
3106             m_value.ident = CSSValueOptimizelegibility;
3107             break;
3108         case GeometricPrecision:
3109             m_value.ident = CSSValueGeometricprecision;
3110             break;
3111     }
3112 }
3113
3114 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3115 {
3116     switch (m_value.ident) {
3117         case CSSValueAuto:
3118             return AutoTextRendering;
3119         case CSSValueOptimizespeed:
3120             return OptimizeSpeed;
3121         case CSSValueOptimizelegibility:
3122             return OptimizeLegibility;
3123         case CSSValueGeometricprecision:
3124             return GeometricPrecision;
3125         default:
3126             ASSERT_NOT_REACHED();
3127             return AutoTextRendering;
3128     }
3129 }
3130
3131 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColorSpace space)
3132     : CSSValue(PrimitiveClass)
3133 {
3134     m_primitiveUnitType = CSS_IDENT;
3135     switch (space) {
3136     case ColorSpaceDeviceRGB:
3137         m_value.ident = CSSValueDefault;
3138         break;
3139     case ColorSpaceSRGB:
3140         m_value.ident = CSSValueSrgb;
3141         break;
3142     case ColorSpaceLinearRGB:
3143         // CSS color correction does not support linearRGB yet.
3144         ASSERT_NOT_REACHED();
3145         m_value.ident = CSSValueDefault;
3146         break;
3147     }
3148 }
3149
3150 template<> inline CSSPrimitiveValue::operator ColorSpace() const
3151 {
3152     switch (m_value.ident) {
3153     case CSSValueDefault:
3154         return ColorSpaceDeviceRGB;
3155     case CSSValueSrgb:
3156         return ColorSpaceSRGB;
3157     default:
3158         ASSERT_NOT_REACHED();
3159         return ColorSpaceDeviceRGB;
3160     }
3161 }
3162
3163 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3164     : CSSValue(PrimitiveClass)
3165 {
3166     m_primitiveUnitType = CSS_IDENT;
3167     switch (hyphens) {
3168     case HyphensNone:
3169         m_value.ident = CSSValueNone;
3170         break;
3171     case HyphensManual:
3172         m_value.ident = CSSValueManual;
3173         break;
3174     case HyphensAuto:
3175         m_value.ident = CSSValueAuto;
3176         break;
3177     }
3178 }
3179
3180 template<> inline CSSPrimitiveValue::operator Hyphens() const
3181 {
3182     switch (m_value.ident) {
3183     case CSSValueNone:
3184         return HyphensNone;
3185     case CSSValueManual:
3186         return HyphensManual;
3187     case CSSValueAuto:
3188         return HyphensAuto;
3189     default:
3190         ASSERT_NOT_REACHED();
3191         return HyphensAuto;
3192     }
3193 }
3194
3195 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap)
3196     : CSSValue(PrimitiveClass)
3197 {
3198     m_primitiveUnitType = CSS_IDENT;
3199     switch (gridSnap) {
3200     case LineSnapNone:
3201         m_value.ident = CSSValueNone;
3202         break;
3203     case LineSnapBaseline:
3204         m_value.ident = CSSValueBaseline;
3205         break;
3206     case LineSnapContain:
3207         m_value.ident = CSSValueContain;
3208         break;
3209     }
3210 }
3211
3212 template<> inline CSSPrimitiveValue::operator LineSnap() const
3213 {
3214     switch (m_value.ident) {
3215     case CSSValueNone:
3216         return LineSnapNone;
3217     case CSSValueBaseline:
3218         return LineSnapBaseline;
3219     case CSSValueContain:
3220         return LineSnapContain;
3221     default:
3222         ASSERT_NOT_REACHED();
3223         return LineSnapNone;
3224     }
3225 }
3226
3227 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign)
3228     : CSSValue(PrimitiveClass)
3229 {
3230     m_primitiveUnitType = CSS_IDENT;
3231     switch (lineAlign) {
3232     case LineAlignNone:
3233         m_value.ident = CSSValueNone;
3234         break;
3235     case LineAlignEdges:
3236         m_value.ident = CSSValueEdges;
3237         break;
3238     }
3239 }
3240
3241 template<> inline CSSPrimitiveValue::operator LineAlign() const
3242 {
3243     switch (m_value.ident) {
3244     case CSSValueNone:
3245         return LineAlignNone;
3246     case CSSValueEdges:
3247         return LineAlignEdges;
3248     default:
3249         ASSERT_NOT_REACHED();
3250         return LineAlignNone;
3251     }
3252 }
3253
3254 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3255     : CSSValue(PrimitiveClass)
3256 {
3257     m_primitiveUnitType = CSS_IDENT;
3258     switch (e) {
3259     case SpeakNone:
3260         m_value.ident = CSSValueNone;
3261         break;
3262     case SpeakNormal:
3263         m_value.ident = CSSValueNormal;
3264         break;
3265     case SpeakSpellOut:
3266         m_value.ident = CSSValueSpellOut;
3267         break;
3268     case SpeakDigits:
3269         m_value.ident = CSSValueDigits;
3270         break;
3271     case SpeakLiteralPunctuation:
3272         m_value.ident = CSSValueLiteralPunctuation;
3273         break;
3274     case SpeakNoPunctuation:
3275         m_value.ident = CSSValueNoPunctuation;
3276         break;
3277     }
3278 }
3279
3280 template<> inline CSSPrimitiveValue::operator Order() const
3281 {
3282     switch (m_value.ident) {
3283     case CSSValueLogical:
3284         return LogicalOrder;
3285     case CSSValueVisual:
3286         return VisualOrder;
3287     default:
3288         ASSERT_NOT_REACHED();
3289         return LogicalOrder;
3290     }
3291 }
3292
3293 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
3294     : CSSValue(PrimitiveClass)
3295 {
3296     m_primitiveUnitType = CSS_IDENT;
3297     switch (e) {
3298     case LogicalOrder:
3299         m_value.ident = CSSValueLogical;
3300         break;
3301     case VisualOrder:
3302         m_value.ident = CSSValueVisual;
3303         break;
3304     }
3305 }
3306
3307 template<> inline CSSPrimitiveValue::operator ESpeak() const
3308 {
3309     switch (m_value.ident) {
3310     case CSSValueNone:
3311         return SpeakNone;
3312     case CSSValueNormal:
3313         return SpeakNormal;
3314     case CSSValueSpellOut:
3315         return SpeakSpellOut;
3316     case CSSValueDigits:
3317         return SpeakDigits;
3318     case CSSValueLiteralPunctuation:
3319         return SpeakLiteralPunctuation;
3320     case CSSValueNoPunctuation:
3321         return SpeakNoPunctuation;
3322     default:
3323         ASSERT_NOT_REACHED();
3324         return SpeakNormal;
3325     }
3326 }
3327
3328 #if ENABLE(CSS_SHADERS)
3329 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CustomFilterOperation::MeshBoxType meshBoxType)
3330     : CSSValue(PrimitiveClass)
3331 {
3332     m_primitiveUnitType = CSS_IDENT;
3333     switch (meshBoxType) {
3334     case CustomFilterOperation::FILTER_BOX:
3335         m_value.ident = CSSValueFilterBox;
3336         break;
3337     case CustomFilterOperation::BORDER_BOX:
3338         m_value.ident = CSSValueBorderBox;
3339         break;
3340     case CustomFilterOperation::PADDING_BOX:
3341         m_value.ident = CSSValuePaddingBox;
3342         break;
3343     case CustomFilterOperation::CONTENT_BOX:
3344         m_value.ident = CSSValueContentBox;
3345         break;
3346     }
3347 }
3348
3349 template<> inline CSSPrimitiveValue::operator CustomFilterOperation::MeshBoxType() const
3350 {
3351     switch (m_value.ident) {
3352     case CSSValueFilterBox:
3353         return CustomFilterOperation::FILTER_BOX;
3354     case CSSValueBorderBox:
3355         return CustomFilterOperation::BORDER_BOX;
3356     case CSSValuePaddingBox:
3357         return CustomFilterOperation::PADDING_BOX;
3358     case CSSValueContentBox:
3359         return CustomFilterOperation::CONTENT_BOX;
3360     default:
3361         ASSERT_NOT_REACHED();
3362         return CustomFilterOperation::FILTER_BOX;
3363     }
3364 }
3365 #endif // ENABLE(CSS_SHADERS)
3366
3367 #if ENABLE(SVG)
3368
3369 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
3370     : CSSValue(PrimitiveClass)
3371 {
3372     m_primitiveUnitType = CSS_IDENT;
3373     switch (e) {
3374         case ButtCap:
3375             m_value.ident = CSSValueButt;
3376             break;
3377         case RoundCap:
3378             m_value.ident = CSSValueRound;
3379             break;
3380         case SquareCap:
3381             m_value.ident = CSSValueSquare;
3382             break;
3383     }
3384 }
3385
3386 template<> inline CSSPrimitiveValue::operator LineCap() const
3387 {
3388     switch (m_value.ident) {
3389         case CSSValueButt:
3390             return ButtCap;
3391         case CSSValueRound:
3392             return RoundCap;
3393         case CSSValueSquare:
3394             return SquareCap;
3395         default:
3396             ASSERT_NOT_REACHED();
3397             return ButtCap;
3398     }
3399 }
3400
3401 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
3402     : CSSValue(PrimitiveClass)
3403 {
3404     m_primitiveUnitType = CSS_IDENT;
3405     switch (e) {
3406         case MiterJoin:
3407             m_value.ident = CSSValueMiter;
3408             break;
3409         case RoundJoin:
3410             m_value.ident = CSSValueRound;
3411             break;
3412         case BevelJoin:
3413             m_value.ident = CSSValueBevel;
3414             break;
3415     }
3416 }
3417
3418 template<> inline CSSPrimitiveValue::operator LineJoin() const
3419 {
3420     switch (m_value.ident) {
3421         case CSSValueMiter:
3422             return MiterJoin;
3423         case CSSValueRound:
3424             return RoundJoin;
3425         case CSSValueBevel:
3426             return BevelJoin;
3427         default:
3428             ASSERT_NOT_REACHED();
3429             return MiterJoin;
3430     }
3431 }
3432
3433 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
3434     : CSSValue(PrimitiveClass)
3435 {
3436     m_primitiveUnitType = CSS_IDENT;
3437     switch (e) {
3438         case RULE_NONZERO:
3439             m_value.ident = CSSValueNonzero;
3440             break;
3441         case RULE_EVENODD:
3442             m_value.ident = CSSValueEvenodd;
3443             break;
3444     }
3445 }
3446
3447 template<> inline CSSPrimitiveValue::operator WindRule() const
3448 {
3449     switch (m_value.ident) {
3450         case CSSValueNonzero:
3451             return RULE_NONZERO;
3452         case CSSValueEvenodd:
3453             return RULE_EVENODD;
3454         default:
3455             ASSERT_NOT_REACHED();
3456             return RULE_NONZERO;
3457     }
3458 }
3459
3460
3461 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
3462     : CSSValue(PrimitiveClass)
3463 {
3464     m_primitiveUnitType = CSS_IDENT;
3465     switch (e) {
3466         case AB_AUTO:
3467             m_value.ident = CSSValueAuto;
3468             break;
3469         case AB_BASELINE:
3470             m_value.ident = CSSValueBaseline;
3471             break;
3472         case AB_BEFORE_EDGE:
3473             m_value.ident = CSSValueBeforeEdge;
3474             break;
3475         case AB_TEXT_BEFORE_EDGE:
3476             m_value.ident = CSSValueTextBeforeEdge;
3477             break;
3478         case AB_MIDDLE:
3479             m_value.ident = CSSValueMiddle;
3480             break;
3481         case AB_CENTRAL:
3482             m_value.ident = CSSValueCentral;
3483             break;
3484         case AB_AFTER_EDGE:
3485             m_value.ident = CSSValueAfterEdge;
3486             break;
3487         case AB_TEXT_AFTER_EDGE:
3488             m_value.ident = CSSValueTextAfterEdge;
3489             break;
3490         case AB_IDEOGRAPHIC:
3491             m_value.ident = CSSValueIdeographic;
3492             break;
3493         case AB_ALPHABETIC:
3494             m_value.ident = CSSValueAlphabetic;
3495             break;
3496         case AB_HANGING:
3497             m_value.ident = CSSValueHanging;
3498             break;
3499         case AB_MATHEMATICAL:
3500             m_value.ident = CSSValueMathematical;
3501             break;
3502     }
3503 }
3504
3505 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
3506 {
3507     switch (m_value.ident) {
3508         case CSSValueAuto:
3509             return AB_AUTO;
3510         case CSSValueBaseline:
3511             return AB_BASELINE;
3512         case CSSValueBeforeEdge:
3513             return AB_BEFORE_EDGE;
3514         case CSSValueTextBeforeEdge:
3515             return AB_TEXT_BEFORE_EDGE;
3516         case CSSValueMiddle:
3517             return AB_MIDDLE;
3518         case CSSValueCentral:
3519             return AB_CENTRAL;
3520         case CSSValueAfterEdge:
3521             return AB_AFTER_EDGE;
3522         case CSSValueTextAfterEdge:
3523             return AB_TEXT_AFTER_EDGE;
3524         case CSSValueIdeographic:
3525             return AB_IDEOGRAPHIC;
3526         case CSSValueAlphabetic:
3527             return AB_ALPHABETIC;
3528         case CSSValueHanging:
3529             return AB_HANGING;
3530         case CSSValueMathematical:
3531             return AB_MATHEMATICAL;
3532         default:
3533             ASSERT_NOT_REACHED();
3534             return AB_AUTO;
3535     }
3536 }
3537
3538 #endif
3539
3540 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
3541     : CSSValue(PrimitiveClass)
3542 {
3543     m_primitiveUnitType = CSS_IDENT;
3544     switch (e) {
3545     case BSEPARATE:
3546         m_value.ident = CSSValueSeparate;
3547         break;
3548     case BCOLLAPSE:
3549         m_value.ident = CSSValueCollapse;
3550         break;
3551     }
3552 }
3553
3554 template<> inline CSSPrimitiveValue::operator EBorderCollapse() const
3555 {
3556     switch (m_value.ident) {
3557     case CSSValueSeparate:
3558         return BSEPARATE;
3559     case CSSValueCollapse:
3560         return BCOLLAPSE;
3561     default:
3562         ASSERT_NOT_REACHED();
3563         return BSEPARATE;
3564     }
3565 }
3566
3567 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderFit e)
3568     : CSSValue(PrimitiveClass)
3569 {
3570     m_primitiveUnitType = CSS_IDENT;
3571     switch (e) {
3572     case BorderFitBorder:
3573         m_value.ident = CSSValueBorder;
3574         break;
3575     case BorderFitLines:
3576         m_value.ident = CSSValueLines;
3577         break;
3578     }
3579 }
3580
3581 template<> inline CSSPrimitiveValue::operator EBorderFit() const
3582 {
3583     switch (m_value.ident) {
3584     case CSSValueBorder:
3585         return BorderFitBorder;
3586     case CSSValueLines:
3587         return BorderFitLines;
3588     default:
3589         ASSERT_NOT_REACHED();
3590         return BorderFitLines;
3591     }
3592 }
3593
3594 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
3595     : CSSValue(PrimitiveClass)
3596 {
3597     m_primitiveUnitType = CSS_IDENT;
3598     switch (e) {
3599     case ImageRenderingAuto:
3600         m_value.ident = CSSValueAuto;
3601         break;
3602     case ImageRenderingOptimizeSpeed:
3603         m_value.ident = CSSValueOptimizespeed;
3604         break;
3605     case ImageRenderingOptimizeQuality:
3606         m_value.ident = CSSValueOptimizequality;
3607         break;
3608     case ImageRenderingOptimizeContrast:
3609         m_value.ident = CSSValueWebkitOptimizeContrast;
3610         break;
3611     }
3612 }
3613
3614 template<> inline CSSPrimitiveValue::operator EImageRendering() const
3615 {
3616     switch (m_value.ident) {
3617     case CSSValueAuto:
3618         return ImageRenderingAuto;
3619     case CSSValueOptimizespeed:
3620         return ImageRenderingOptimizeSpeed;
3621     case CSSValueOptimizequality:
3622         return ImageRenderingOptimizeQuality;
3623     case CSSValueWebkitOptimizeContrast:
3624         return ImageRenderingOptimizeContrast;
3625     default:
3626         ASSERT_NOT_REACHED();
3627         return ImageRenderingAuto;
3628     }
3629 }
3630
3631 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e)
3632     : CSSValue(PrimitiveClass)
3633 {
3634     m_primitiveUnitType = CSS_IDENT;
3635     switch (e) {
3636     case TransformStyle3DFlat:
3637         m_value.ident = CSSValueFlat;
3638         break;
3639     case TransformStyle3DPreserve3D:
3640         m_value.ident = CSSValuePreserve3d;
3641         break;
3642     }
3643 }
3644
3645 template<> inline CSSPrimitiveValue::operator ETransformStyle3D() const
3646 {
3647     switch (m_value.ident) {
3648     case CSSValueFlat:
3649         return TransformStyle3DFlat;
3650     case CSSValuePreserve3d:
3651         return TransformStyle3DPreserve3D;
3652     default:
3653         ASSERT_NOT_REACHED();
3654         return TransformStyle3DFlat;
3655     }
3656 }
3657
3658 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnAxis e)
3659     : CSSValue(PrimitiveClass)
3660 {
3661     m_primitiveUnitType = CSS_IDENT;
3662     switch (e) {
3663     case HorizontalColumnAxis:
3664         m_value.ident = CSSValueHorizontal;
3665         break;
3666     case VerticalColumnAxis:
3667         m_value.ident = CSSValueVertical;
3668         break;
3669     case AutoColumnAxis:
3670         m_value.ident = CSSValueAuto;
3671         break;
3672     }
3673 }
3674
3675 template<> inline CSSPrimitiveValue::operator ColumnAxis() const
3676 {
3677     switch (m_value.ident) {
3678     case CSSValueHorizontal:
3679         return HorizontalColumnAxis;
3680     case CSSValueVertical:
3681         return VerticalColumnAxis;
3682     case CSSValueAuto:
3683         return AutoColumnAxis;
3684     default:
3685         ASSERT_NOT_REACHED();
3686         return AutoColumnAxis;
3687     }
3688 }
3689
3690 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnProgression e)
3691     : CSSValue(PrimitiveClass)
3692 {
3693     m_primitiveUnitType = CSS_IDENT;
3694     switch (e) {
3695     case NormalColumnProgression:
3696         m_value.ident = CSSValueNormal;
3697         break;
3698     case ReverseColumnProgression:
3699         m_value.ident = CSSValueReverse;
3700         break;
3701     }
3702 }
3703
3704 template<> inline CSSPrimitiveValue::operator ColumnProgression() const
3705 {
3706     switch (m_value.ident) {
3707     case CSSValueNormal:
3708         return NormalColumnProgression;
3709     case CSSValueReverse:
3710         return ReverseColumnProgression;
3711     default:
3712         ASSERT_NOT_REACHED();
3713         return NormalColumnProgression;
3714     }
3715 }
3716
3717 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WrapFlow wrapFlow)
3718 : CSSValue(PrimitiveClass)
3719 {
3720     m_primitiveUnitType = CSS_IDENT;
3721     switch (wrapFlow) {
3722     case WrapFlowAuto:
3723         m_value.ident = CSSValueAuto;
3724         break;
3725     case WrapFlowBoth:
3726         m_value.ident = CSSValueBoth;
3727         break;
3728     case WrapFlowStart:
3729         m_value.ident = CSSValueStart;
3730         break;
3731     case WrapFlowEnd:
3732         m_value.ident = CSSValueEnd;
3733         break;
3734     case WrapFlowMaximum:
3735         m_value.ident = CSSValueMaximum;
3736         break;
3737     case WrapFlowClear:
3738         m_value.ident = CSSValueClear;
3739         break;
3740     }
3741 }
3742
3743 template<> inline CSSPrimitiveValue::operator WrapFlow() const
3744 {
3745     switch (m_value.ident) {
3746     case CSSValueAuto:
3747         return WrapFlowAuto;
3748     case CSSValueBoth:
3749         return WrapFlowBoth;
3750     case CSSValueStart:
3751         return WrapFlowStart;
3752     case CSSValueEnd:
3753         return WrapFlowEnd;
3754     case CSSValueMaximum:
3755         return WrapFlowMaximum;
3756     case CSSValueClear:
3757         return WrapFlowClear;
3758     default:
3759         ASSERT_NOT_REACHED();
3760         return WrapFlowAuto;
3761     }
3762 }
3763
3764 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WrapThrough wrapThrough)
3765 : CSSValue(PrimitiveClass)
3766 {
3767     m_primitiveUnitType = CSS_IDENT;
3768     switch (wrapThrough) {
3769     case WrapThroughWrap:
3770         m_value.ident = CSSValueWrap;
3771         break;
3772     case WrapThroughNone:
3773         m_value.ident = CSSValueNone;
3774         break;
3775     }
3776 }
3777
3778 template<> inline CSSPrimitiveValue::operator WrapThrough() const
3779 {
3780     switch (m_value.ident) {
3781     case CSSValueWrap:
3782         return WrapThroughWrap;
3783     case CSSValueNone:
3784         return WrapThroughNone;
3785     default:
3786         ASSERT_NOT_REACHED();
3787         return WrapThroughWrap;
3788     }
3789 }
3790
3791 enum LengthConversion {
3792     AnyConversion = ~0,
3793     FixedIntegerConversion = 1 << 0,
3794     FixedFloatConversion = 1 << 1,
3795     AutoConversion = 1 << 2,
3796     PercentConversion = 1 << 3,
3797     FractionConversion = 1 << 4,
3798     CalculatedConversion = 1 << 5,
3799     ViewportPercentageConversion = 1 << 6
3800 };
3801
3802 template<int supported> Length CSSPrimitiveValue::convertToLength(RenderStyle* style, RenderStyle* rootStyle, double multiplier, bool computingFontSize)
3803 {
3804     if ((supported & (FixedIntegerConversion | FixedFloatConversion)) && isFontRelativeLength() && (!style || !rootStyle))
3805         return Length(Undefined);
3806     if ((supported & FixedIntegerConversion) && isLength())
3807         return computeLength<Length>(style, rootStyle, multiplier, computingFontSize);
3808     if ((supported & FixedFloatConversion) && isLength())
3809         return Length(computeLength<double>(style, rootStyle, multiplier), Fixed);
3810     if ((supported & PercentConversion) && isPercentage())
3811         return Length(getDoubleValue(), Percent);
3812     if ((supported & FractionConversion) && isNumber())
3813         return Length(getDoubleValue() * 100.0, Percent);
3814     if ((supported & AutoConversion) && getIdent() == CSSValueAuto)
3815         return Length(Auto);
3816     if ((supported & CalculatedConversion) && isCalculated())
3817         return Length(cssCalcValue()->toCalcValue(style, rootStyle, multiplier));
3818     if ((supported & ViewportPercentageConversion) && isViewportPercentageLength())
3819         return viewportPercentageLength();
3820     return Length(Undefined);
3821 }
3822
3823 #if ENABLE(SVG)
3824
3825 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
3826     : CSSValue(PrimitiveClass)
3827 {
3828     m_primitiveUnitType = CSS_IDENT;
3829     switch (e) {
3830         case CI_AUTO:
3831             m_value.ident = CSSValueAuto;
3832             break;
3833         case CI_SRGB:
3834             m_value.ident = CSSValueSrgb;
3835             break;
3836         case CI_LINEARRGB:
3837             m_value.ident = CSSValueLinearrgb;
3838             break;
3839     }
3840 }
3841
3842 template<> inline CSSPrimitiveValue::operator EColorInterpolation() const
3843 {
3844     switch (m_value.ident) {
3845         case CSSValueSrgb:
3846             return CI_SRGB;
3847         case CSSValueLinearrgb:
3848             return CI_LINEARRGB;
3849         case CSSValueAuto:
3850             return CI_AUTO;
3851         default:
3852             ASSERT_NOT_REACHED();
3853             return CI_AUTO;
3854     }
3855 }
3856
3857 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
3858     : CSSValue(PrimitiveClass)
3859 {
3860     m_primitiveUnitType = CSS_IDENT;
3861     switch (e) {
3862         case CR_AUTO:
3863             m_value.ident = CSSValueAuto;
3864             break;
3865         case CR_OPTIMIZESPEED:
3866             m_value.ident = CSSValueOptimizespeed;
3867             break;
3868         case CR_OPTIMIZEQUALITY:
3869             m_value.ident = CSSValueOptimizequality;
3870             break;
3871     }
3872 }
3873
3874 template<> inline CSSPrimitiveValue::operator EColorRendering() const
3875 {
3876     switch (m_value.ident) {
3877         case CSSValueOptimizespeed:
3878             return CR_OPTIMIZESPEED;
3879         case CSSValueOptimizequality:
3880             return CR_OPTIMIZEQUALITY;
3881         case CSSValueAuto:
3882             return CR_AUTO;
3883         default:
3884             ASSERT_NOT_REACHED();
3885             return CR_AUTO;
3886     }
3887 }
3888
3889 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
3890     : CSSValue(PrimitiveClass)
3891 {
3892     m_primitiveUnitType = CSS_IDENT;
3893     switch (e) {
3894         case DB_AUTO:
3895             m_value.ident = CSSValueAuto;
3896             break;
3897         case DB_USE_SCRIPT:
3898             m_value.ident = CSSValueUseScript;
3899             break;
3900         case DB_NO_CHANGE:
3901             m_value.ident = CSSValueNoChange;
3902             break;
3903         case DB_RESET_SIZE:
3904             m_value.ident = CSSValueResetSize;
3905             break;
3906         case DB_CENTRAL:
3907             m_value.ident = CSSValueCentral;
3908             break;
3909         case DB_MIDDLE:
3910             m_value.ident = CSSValueMiddle;
3911             break;
3912         case DB_TEXT_BEFORE_EDGE:
3913             m_value.ident = CSSValueTextBeforeEdge;
3914             break;
3915         case DB_TEXT_AFTER_EDGE:
3916             m_value.ident = CSSValueTextAfterEdge;
3917             break;
3918         case DB_IDEOGRAPHIC:
3919             m_value.ident = CSSValueIdeographic;
3920             break;
3921         case DB_ALPHABETIC:
3922             m_value.ident = CSSValueAlphabetic;
3923             break;
3924         case DB_HANGING:
3925             m_value.ident = CSSValueHanging;
3926             break;
3927         case DB_MATHEMATICAL:
3928             m_value.ident = CSSValueMathematical;
3929             break;
3930     }
3931 }
3932
3933 template<> inline CSSPrimitiveValue::operator EDominantBaseline() const
3934 {
3935     switch (m_value.ident) {
3936         case CSSValueAuto:
3937             return DB_AUTO;
3938         case CSSValueUseScript:
3939             return DB_USE_SCRIPT;
3940         case CSSValueNoChange:
3941             return DB_NO_CHANGE;
3942         case CSSValueResetSize:
3943             return DB_RESET_SIZE;
3944         case CSSValueIdeographic:
3945             return DB_IDEOGRAPHIC;
3946         case CSSValueAlphabetic:
3947             return DB_ALPHABETIC;
3948         case CSSValueHanging:
3949             return DB_HANGING;
3950         case CSSValueMathematical:
3951             return DB_MATHEMATICAL;
3952         case CSSValueCentral:
3953             return DB_CENTRAL;
3954         case CSSValueMiddle:
3955             return DB_MIDDLE;
3956         case CSSValueTextAfterEdge:
3957             return DB_TEXT_AFTER_EDGE;
3958         case CSSValueTextBeforeEdge:
3959             return DB_TEXT_BEFORE_EDGE;
3960         default:
3961             ASSERT_NOT_REACHED();
3962             return DB_AUTO;
3963     }
3964 }
3965
3966 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
3967     : CSSValue(PrimitiveClass)
3968 {
3969     m_primitiveUnitType = CSS_IDENT;
3970     switch (e) {
3971     case SR_AUTO:
3972         m_value.ident = CSSValueAuto;
3973         break;
3974     case SR_OPTIMIZESPEED:
3975         m_value.ident = CSSValueOptimizespeed;
3976         break;
3977     case SR_CRISPEDGES:
3978         m_value.ident = CSSValueCrispedges;
3979         break;
3980     case SR_GEOMETRICPRECISION:
3981         m_value.ident = CSSValueGeometricprecision;
3982         break;
3983     }
3984 }
3985
3986 template<> inline CSSPrimitiveValue::operator EShapeRendering() const
3987 {
3988     switch (m_value.ident) {
3989     case CSSValueAuto:
3990         return SR_AUTO;
3991     case CSSValueOptimizespeed:
3992         return SR_OPTIMIZESPEED;
3993     case CSSValueCrispedges:
3994         return SR_CRISPEDGES;
3995     case CSSValueGeometricprecision:
3996         return SR_GEOMETRICPRECISION;
3997     default:
3998         ASSERT_NOT_REACHED();
3999         return SR_AUTO;
4000     }
4001 }
4002
4003 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
4004     : CSSValue(PrimitiveClass)
4005 {
4006     m_primitiveUnitType = CSS_IDENT;
4007     switch (e) {
4008         case TA_START:
4009             m_value.ident = CSSValueStart;
4010             break;
4011         case TA_MIDDLE:
4012             m_value.ident = CSSValueMiddle;
4013             break;
4014         case TA_END:
4015             m_value.ident = CSSValueEnd;
4016             break;
4017     }
4018 }
4019
4020 template<> inline CSSPrimitiveValue::operator ETextAnchor() const
4021 {
4022     switch (m_value.ident) {
4023         case CSSValueStart:
4024             return TA_START;
4025         case CSSValueMiddle:
4026             return TA_MIDDLE;
4027         case CSSValueEnd:
4028             return TA_END;
4029         default:
4030             ASSERT_NOT_REACHED();
4031             return TA_START;
4032     }
4033 }
4034
4035 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SVGWritingMode e)
4036     : CSSValue(PrimitiveClass)
4037 {
4038     m_primitiveUnitType = CSS_IDENT;
4039     switch (e) {
4040         case WM_LRTB:
4041             m_value.ident = CSSValueLrTb;
4042             break;
4043         case WM_LR:
4044             m_value.ident = CSSValueLr;
4045             break;
4046         case WM_RLTB:
4047             m_value.ident = CSSValueRlTb;
4048             break;
4049         case WM_RL:
4050             m_value.ident = CSSValueRl;
4051             break;
4052         case WM_TBRL:
4053             m_value.ident = CSSValueTbRl;
4054             break;
4055         case WM_TB:
4056             m_value.ident = CSSValueTb;
4057             break;
4058     }