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