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