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