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