2010-07-08 Eric Carlson <eric.carlson@apple.com>
[WebKit-https.git] / 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 "FontSmoothingMode.h"
37 #include "GraphicsTypes.h"
38 #include "Path.h"
39 #include "RenderStyleConstants.h"
40 #include "SVGRenderStyleDefs.h"
41 #include "TextDirection.h"
42 #include "TextRenderingMode.h"
43 #include "ThemeTypes.h"
44
45 namespace WebCore {
46
47 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
48     : m_type(CSS_IDENT)
49     , m_hasCachedCSSText(false)
50 {
51     switch (e) {
52         case BNONE:
53             m_value.ident = CSSValueNone;
54             break;
55         case BHIDDEN:
56             m_value.ident = CSSValueHidden;
57             break;
58         case INSET:
59             m_value.ident = CSSValueInset;
60             break;
61         case GROOVE:
62             m_value.ident = CSSValueGroove;
63             break;
64         case RIDGE:
65             m_value.ident = CSSValueRidge;
66             break;
67         case OUTSET:
68             m_value.ident = CSSValueOutset;
69             break;
70         case DOTTED:
71             m_value.ident = CSSValueDotted;
72             break;
73         case DASHED:
74             m_value.ident = CSSValueDashed;
75             break;
76         case SOLID:
77             m_value.ident = CSSValueSolid;
78             break;
79         case DOUBLE:
80             m_value.ident = CSSValueDouble;
81             break;
82     }
83 }
84
85 template<> inline CSSPrimitiveValue::operator EBorderStyle() const
86 {
87     return (EBorderStyle)(m_value.ident - CSSValueNone);
88 }
89
90 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
91     : m_type(CSS_IDENT)
92     , m_hasCachedCSSText(false)
93 {
94     switch (e) {
95         case CompositeClear:
96             m_value.ident = CSSValueClear;
97             break;
98         case CompositeCopy:
99             m_value.ident = CSSValueCopy;
100             break;
101         case CompositeSourceOver:
102             m_value.ident = CSSValueSourceOver;
103             break;
104         case CompositeSourceIn:
105             m_value.ident = CSSValueSourceIn;
106             break;
107         case CompositeSourceOut:
108             m_value.ident = CSSValueSourceOut;
109             break;
110         case CompositeSourceAtop:
111             m_value.ident = CSSValueSourceAtop;
112             break;
113         case CompositeDestinationOver:
114             m_value.ident = CSSValueDestinationOver;
115             break;
116         case CompositeDestinationIn:
117             m_value.ident = CSSValueDestinationIn;
118             break;
119         case CompositeDestinationOut:
120             m_value.ident = CSSValueDestinationOut;
121             break;
122         case CompositeDestinationAtop:
123             m_value.ident = CSSValueDestinationAtop;
124             break;
125         case CompositeXOR:
126             m_value.ident = CSSValueXor;
127             break;
128         case CompositePlusDarker:
129             m_value.ident = CSSValuePlusDarker;
130             break;
131         case CompositeHighlight:
132             m_value.ident = CSSValueHighlight;
133             break;
134         case CompositePlusLighter:
135             m_value.ident = CSSValuePlusLighter;
136             break;
137     }
138 }
139
140 template<> inline CSSPrimitiveValue::operator CompositeOperator() const
141 {
142     switch (m_value.ident) {
143         case CSSValueClear:
144             return CompositeClear;
145         case CSSValueCopy:
146             return CompositeCopy;
147         case CSSValueSourceOver:
148             return CompositeSourceOver;
149         case CSSValueSourceIn:
150             return CompositeSourceIn;
151         case CSSValueSourceOut:
152             return CompositeSourceOut;
153         case CSSValueSourceAtop:
154             return CompositeSourceAtop;
155         case CSSValueDestinationOver:
156             return CompositeDestinationOver;
157         case CSSValueDestinationIn:
158             return CompositeDestinationIn;
159         case CSSValueDestinationOut:
160             return CompositeDestinationOut;
161         case CSSValueDestinationAtop:
162             return CompositeDestinationAtop;
163         case CSSValueXor:
164             return CompositeXOR;
165         case CSSValuePlusDarker:
166             return CompositePlusDarker;
167         case CSSValueHighlight:
168             return CompositeHighlight;
169         case CSSValuePlusLighter:
170             return CompositePlusLighter;
171         default:
172             ASSERT_NOT_REACHED();
173             return CompositeClear;
174     }
175 }
176
177 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
178     : m_type(CSS_IDENT)
179     , m_hasCachedCSSText(false)
180 {
181     switch (e) {
182         case NoControlPart:
183             m_value.ident = CSSValueNone;
184             break;
185         case CheckboxPart:
186             m_value.ident = CSSValueCheckbox;
187             break;
188         case RadioPart:
189             m_value.ident = CSSValueRadio;
190             break;
191         case PushButtonPart:
192             m_value.ident = CSSValuePushButton;
193             break;
194         case SquareButtonPart:
195             m_value.ident = CSSValueSquareButton;
196             break;
197         case ButtonPart:
198             m_value.ident = CSSValueButton;
199             break;
200         case ButtonBevelPart:
201             m_value.ident = CSSValueButtonBevel;
202             break;
203         case DefaultButtonPart:
204             m_value.ident = CSSValueDefaultButton;
205             break;
206         case InnerSpinButtonPart:
207             m_value.ident = CSSValueInnerSpinButton;
208             break;
209         case ListboxPart:
210             m_value.ident = CSSValueListbox;
211             break;
212         case ListButtonPart:
213 #if ENABLE(DATALIST)
214             m_value.ident = CSSValueListButton;
215 #endif
216             break;
217         case ListItemPart:
218             m_value.ident = CSSValueListitem;
219             break;
220         case MediaFullscreenButtonPart:
221             m_value.ident = CSSValueMediaFullscreenButton;
222             break;
223         case MediaPlayButtonPart:
224             m_value.ident = CSSValueMediaPlayButton;
225             break;
226         case MediaMuteButtonPart:
227             m_value.ident = CSSValueMediaMuteButton;
228             break;
229         case MediaSeekBackButtonPart:
230             m_value.ident = CSSValueMediaSeekBackButton;
231             break;
232         case MediaSeekForwardButtonPart:
233             m_value.ident = CSSValueMediaSeekForwardButton;
234             break;
235         case MediaRewindButtonPart:
236             m_value.ident = CSSValueMediaRewindButton;
237             break;
238         case MediaReturnToRealtimeButtonPart:
239             m_value.ident = CSSValueMediaReturnToRealtimeButton;
240             break;
241         case MediaToggleClosedCaptionsButtonPart:
242             m_value.ident = CSSValueMediaToggleClosedCaptionsButton;
243             break;
244         case MediaSliderPart:
245             m_value.ident = CSSValueMediaSlider;
246             break;
247         case MediaSliderThumbPart:
248             m_value.ident = CSSValueMediaSliderthumb;
249             break;
250         case MediaVolumeSliderContainerPart:
251             m_value.ident = CSSValueMediaVolumeSliderContainer;
252             break;
253         case MediaVolumeSliderPart:
254             m_value.ident = CSSValueMediaVolumeSlider;
255             break;
256         case MediaVolumeSliderMuteButtonPart:
257             m_value.ident = CSSValueMediaVolumeSliderMuteButton;
258             break;
259         case MediaVolumeSliderThumbPart:
260             m_value.ident = CSSValueMediaVolumeSliderthumb;
261             break;
262         case MediaControlsBackgroundPart:
263             m_value.ident = CSSValueMediaControlsBackground;
264             break;
265         case MediaCurrentTimePart:
266             m_value.ident = CSSValueMediaCurrentTimeDisplay;
267             break;
268         case MediaTimeRemainingPart:
269             m_value.ident = CSSValueMediaTimeRemainingDisplay;
270             break;
271         case MenulistPart:
272             m_value.ident = CSSValueMenulist;
273             break;
274         case MenulistButtonPart:
275             m_value.ident = CSSValueMenulistButton;
276             break;
277         case MenulistTextPart:
278             m_value.ident = CSSValueMenulistText;
279             break;
280         case MenulistTextFieldPart:
281             m_value.ident = CSSValueMenulistTextfield;
282             break;
283         case MeterPart:
284             m_value.ident = CSSValueMeter;
285             break;
286         case RelevancyLevelIndicatorPart:
287             m_value.ident = CSSValueRelevancyLevelIndicator;
288             break;
289         case ContinuousCapacityLevelIndicatorPart:
290             m_value.ident = CSSValueContinuousCapacityLevelIndicator;
291             break;
292         case DiscreteCapacityLevelIndicatorPart:
293             m_value.ident = CSSValueDiscreteCapacityLevelIndicator;
294             break;
295         case RatingLevelIndicatorPart:
296             m_value.ident = CSSValueRatingLevelIndicator;
297             break;
298         case OuterSpinButtonPart:
299             m_value.ident = CSSValueOuterSpinButton;
300             break;
301         case ProgressBarPart:
302 #if ENABLE(PROGRESS_TAG)
303             m_value.ident = CSSValueProgressBar;
304 #endif
305             break;
306         case ProgressBarValuePart:
307 #if ENABLE(PROGRESS_TAG)
308             m_value.ident = CSSValueProgressBarValue;
309 #endif
310             break;
311         case SliderHorizontalPart:
312             m_value.ident = CSSValueSliderHorizontal;
313             break;
314         case SliderVerticalPart:
315             m_value.ident = CSSValueSliderVertical;
316             break;
317         case SliderThumbHorizontalPart:
318             m_value.ident = CSSValueSliderthumbHorizontal;
319             break;
320         case SliderThumbVerticalPart:
321             m_value.ident = CSSValueSliderthumbVertical;
322             break;
323         case CaretPart:
324             m_value.ident = CSSValueCaret;
325             break;
326         case SearchFieldPart:
327             m_value.ident = CSSValueSearchfield;
328             break;
329         case SearchFieldDecorationPart:
330             m_value.ident = CSSValueSearchfieldDecoration;
331             break;
332         case SearchFieldResultsDecorationPart:
333             m_value.ident = CSSValueSearchfieldResultsDecoration;
334             break;
335         case SearchFieldResultsButtonPart:
336             m_value.ident = CSSValueSearchfieldResultsButton;
337             break;
338         case SearchFieldCancelButtonPart:
339             m_value.ident = CSSValueSearchfieldCancelButton;
340             break;
341         case TextFieldPart:
342             m_value.ident = CSSValueTextfield;
343             break;
344         case TextAreaPart:
345             m_value.ident = CSSValueTextarea;
346             break;
347         case CapsLockIndicatorPart:
348             m_value.ident = CSSValueCapsLockIndicator;
349             break;
350         case InputSpeechButtonPart:
351 #if ENABLE(INPUT_SPEECH)
352             m_value.ident = CSSValueInputSpeechButton;
353 #endif
354             break;
355     }
356 }
357
358 template<> inline CSSPrimitiveValue::operator ControlPart() const
359 {
360     if (m_value.ident == CSSValueNone)
361         return NoControlPart;
362     else
363         return ControlPart(m_value.ident - CSSValueCheckbox + 1);
364 }
365
366 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
367     : m_type(CSS_IDENT)
368     , m_hasCachedCSSText(false)
369 {
370     switch (e) {
371         case ScrollBackgroundAttachment:
372             m_value.ident = CSSValueScroll;
373             break;
374         case LocalBackgroundAttachment:
375             m_value.ident = CSSValueLocal;
376             break;
377         case FixedBackgroundAttachment:
378             m_value.ident = CSSValueFixed;
379             break;
380     }
381 }
382
383 template<> inline CSSPrimitiveValue::operator EFillAttachment() const
384 {
385     switch (m_value.ident) {
386         case CSSValueScroll:
387             return ScrollBackgroundAttachment;
388         case CSSValueLocal:
389             return LocalBackgroundAttachment;
390         case CSSValueFixed:
391             return FixedBackgroundAttachment;
392         default:
393             ASSERT_NOT_REACHED();
394             return ScrollBackgroundAttachment;
395     }
396 }
397
398 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
399     : m_type(CSS_IDENT)
400     , m_hasCachedCSSText(false)
401 {
402     switch (e) {
403         case BorderFillBox:
404             m_value.ident = CSSValueBorderBox;
405             break;
406         case PaddingFillBox:
407             m_value.ident = CSSValuePaddingBox;
408             break;
409         case ContentFillBox:
410             m_value.ident = CSSValueContentBox;
411             break;
412         case TextFillBox:
413             m_value.ident = CSSValueText;
414             break;
415     }
416 }
417
418 template<> inline CSSPrimitiveValue::operator EFillBox() const
419 {
420     switch (m_value.ident) {
421         case CSSValueBorder:
422         case CSSValueBorderBox:
423             return BorderFillBox;
424         case CSSValuePadding:
425         case CSSValuePaddingBox:
426             return PaddingFillBox;
427         case CSSValueContent:
428         case CSSValueContentBox:
429             return ContentFillBox;
430         case CSSValueText:
431         case CSSValueWebkitText:
432             return TextFillBox;
433         default:
434             ASSERT_NOT_REACHED();
435             return BorderFillBox;
436     }
437 }
438
439 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
440     : m_type(CSS_IDENT)
441     , m_hasCachedCSSText(false)
442 {
443     switch (e) {
444         case RepeatFill:
445             m_value.ident = CSSValueRepeat;
446             break;
447         case NoRepeatFill:
448             m_value.ident = CSSValueNoRepeat;
449             break;
450         case RoundFill:
451             m_value.ident = CSSValueRound;
452             break;
453         case SpaceFill:
454             m_value.ident = CSSValueSpace;
455             break;
456     }
457 }
458
459 template<> inline CSSPrimitiveValue::operator EFillRepeat() const
460 {
461     switch (m_value.ident) {
462         case CSSValueRepeat:
463             return RepeatFill;
464         case CSSValueNoRepeat:
465             return NoRepeatFill;
466         case CSSValueRound:
467             return RoundFill;
468         case CSSValueSpace:
469             return SpaceFill;
470         default:
471             ASSERT_NOT_REACHED();
472             return RepeatFill;
473     }
474 }
475
476 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
477     : m_type(CSS_IDENT)
478     , m_hasCachedCSSText(false)
479 {
480     switch (e) {
481         case BSTRETCH:
482             m_value.ident = CSSValueStretch;
483             break;
484         case BSTART:
485             m_value.ident = CSSValueStart;
486             break;
487         case BCENTER:
488             m_value.ident = CSSValueCenter;
489             break;
490         case BEND:
491             m_value.ident = CSSValueEnd;
492             break;
493         case BBASELINE:
494             m_value.ident = CSSValueBaseline;
495             break;
496         case BJUSTIFY:
497             m_value.ident = CSSValueJustify;
498             break;
499     }
500 }
501
502 template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
503 {
504     switch (m_value.ident) {
505         case CSSValueStretch:
506             return BSTRETCH;
507         case CSSValueStart:
508             return BSTART;
509         case CSSValueEnd:
510             return BEND;
511         case CSSValueCenter:
512             return BCENTER;
513         case CSSValueBaseline:
514             return BBASELINE;
515         case CSSValueJustify:
516             return BJUSTIFY;
517         default:
518             ASSERT_NOT_REACHED();
519             return BSTRETCH;
520     }
521 }
522
523 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
524     : m_type(CSS_IDENT)
525     , m_hasCachedCSSText(false)
526 {
527     switch (e) {
528         case BNORMAL:
529             m_value.ident = CSSValueNormal;
530             break;
531         case BREVERSE:
532             m_value.ident = CSSValueReverse;
533             break;
534     }
535 }
536
537 template<> inline CSSPrimitiveValue::operator EBoxDirection() const
538 {
539     switch (m_value.ident) {
540         case CSSValueNormal:
541             return BNORMAL;
542         case CSSValueReverse:
543             return BREVERSE;
544         default:
545             ASSERT_NOT_REACHED();
546             return BNORMAL;
547     }
548 }
549
550 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
551     : m_type(CSS_IDENT)
552     , m_hasCachedCSSText(false)
553 {
554     switch (e) {
555         case SINGLE:
556             m_value.ident = CSSValueSingle;
557             break;
558         case MULTIPLE:
559             m_value.ident = CSSValueMultiple;
560             break;
561     }
562 }
563
564 template<> inline CSSPrimitiveValue::operator EBoxLines() const
565 {
566     switch (m_value.ident) {
567         case CSSValueSingle:
568             return SINGLE;
569         case CSSValueMultiple:
570             return MULTIPLE;
571         default:
572             ASSERT_NOT_REACHED();
573             return SINGLE;
574     }
575 }
576
577 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
578     : m_type(CSS_IDENT)
579     , m_hasCachedCSSText(false)
580 {
581     switch (e) {
582         case HORIZONTAL:
583             m_value.ident = CSSValueHorizontal;
584             break;
585         case VERTICAL:
586             m_value.ident = CSSValueVertical;
587             break;
588     }
589 }
590
591 template<> inline CSSPrimitiveValue::operator EBoxOrient() const
592 {
593     switch (m_value.ident) {
594         case CSSValueHorizontal:
595         case CSSValueInlineAxis:
596             return HORIZONTAL;
597         case CSSValueVertical:
598         case CSSValueBlockAxis:
599             return VERTICAL;
600         default:
601             ASSERT_NOT_REACHED();
602             return HORIZONTAL;
603     }
604 }
605
606 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
607     : m_type(CSS_IDENT)
608     , m_hasCachedCSSText(false)
609 {
610     switch (e) {
611         case CAPLEFT:
612             m_value.ident = CSSValueLeft;
613             break;
614         case CAPRIGHT:
615             m_value.ident = CSSValueRight;
616             break;
617         case CAPTOP:
618             m_value.ident = CSSValueTop;
619             break;
620         case CAPBOTTOM:
621             m_value.ident = CSSValueBottom;
622             break;
623     }
624 }
625
626 template<> inline CSSPrimitiveValue::operator ECaptionSide() const
627 {
628     switch (m_value.ident) {
629         case CSSValueLeft:
630             return CAPLEFT;
631         case CSSValueRight:
632             return CAPRIGHT;
633         case CSSValueTop:
634             return CAPTOP;
635         case CSSValueBottom:
636             return CAPBOTTOM;
637         default:
638             ASSERT_NOT_REACHED();
639             return CAPTOP;
640     }
641 }
642
643 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
644     : m_type(CSS_IDENT)
645     , m_hasCachedCSSText(false)
646 {
647     switch (e) {
648         case CNONE:
649             m_value.ident = CSSValueNone;
650             break;
651         case CLEFT:
652             m_value.ident = CSSValueLeft;
653             break;
654         case CRIGHT:
655             m_value.ident = CSSValueRight;
656             break;
657         case CBOTH:
658             m_value.ident = CSSValueBoth;
659             break;
660     }
661 }
662
663 template<> inline CSSPrimitiveValue::operator EClear() const
664 {
665     switch (m_value.ident) {
666         case CSSValueNone:
667             return CNONE;
668         case CSSValueLeft:
669             return CLEFT;
670         case CSSValueRight:
671             return CRIGHT;
672         case CSSValueBoth:
673             return CBOTH;
674         default:
675             ASSERT_NOT_REACHED();
676             return CNONE;
677     }
678 }
679
680 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
681     : m_type(CSS_IDENT)
682     , m_hasCachedCSSText(false)
683 {
684     switch (e) {
685         case CURSOR_AUTO:
686             m_value.ident = CSSValueAuto;
687             break;
688         case CURSOR_CROSS:
689             m_value.ident = CSSValueCrosshair;
690             break;
691         case CURSOR_DEFAULT:
692             m_value.ident = CSSValueDefault;
693             break;
694         case CURSOR_POINTER:
695             m_value.ident = CSSValuePointer;
696             break;
697         case CURSOR_MOVE:
698             m_value.ident = CSSValueMove;
699             break;
700         case CURSOR_CELL:
701             m_value.ident = CSSValueCell;
702             break;
703         case CURSOR_VERTICAL_TEXT:
704             m_value.ident = CSSValueVerticalText;
705             break;
706         case CURSOR_CONTEXT_MENU:
707             m_value.ident = CSSValueContextMenu;
708             break;
709         case CURSOR_ALIAS:
710             m_value.ident = CSSValueAlias;
711             break;
712         case CURSOR_COPY:
713             m_value.ident = CSSValueCopy;
714             break;
715         case CURSOR_NONE:
716             m_value.ident = CSSValueNone;
717             break;
718         case CURSOR_PROGRESS:
719             m_value.ident = CSSValueProgress;
720             break;
721         case CURSOR_NO_DROP:
722             m_value.ident = CSSValueNoDrop;
723             break;
724         case CURSOR_NOT_ALLOWED:
725             m_value.ident = CSSValueNotAllowed;
726             break;
727         case CURSOR_WEBKIT_ZOOM_IN:
728             m_value.ident = CSSValueWebkitZoomIn;
729             break;
730         case CURSOR_WEBKIT_ZOOM_OUT:
731             m_value.ident = CSSValueWebkitZoomOut;
732             break;
733         case CURSOR_E_RESIZE:
734             m_value.ident = CSSValueEResize;
735             break;
736         case CURSOR_NE_RESIZE:
737             m_value.ident = CSSValueNeResize;
738             break;
739         case CURSOR_NW_RESIZE:
740             m_value.ident = CSSValueNwResize;
741             break;
742         case CURSOR_N_RESIZE:
743             m_value.ident = CSSValueNResize;
744             break;
745         case CURSOR_SE_RESIZE:
746             m_value.ident = CSSValueSeResize;
747             break;
748         case CURSOR_SW_RESIZE:
749             m_value.ident = CSSValueSwResize;
750             break;
751         case CURSOR_S_RESIZE:
752             m_value.ident = CSSValueSResize;
753             break;
754         case CURSOR_W_RESIZE:
755             m_value.ident = CSSValueWResize;
756             break;
757         case CURSOR_EW_RESIZE:
758             m_value.ident = CSSValueEwResize;
759             break;
760         case CURSOR_NS_RESIZE:
761             m_value.ident = CSSValueNsResize;
762             break;
763         case CURSOR_NESW_RESIZE:
764             m_value.ident = CSSValueNeswResize;
765             break;
766         case CURSOR_NWSE_RESIZE:
767             m_value.ident = CSSValueNwseResize;
768             break;
769         case CURSOR_COL_RESIZE:
770             m_value.ident = CSSValueColResize;
771             break;
772         case CURSOR_ROW_RESIZE:
773             m_value.ident = CSSValueRowResize;
774             break;
775         case CURSOR_TEXT:
776             m_value.ident = CSSValueText;
777             break;
778         case CURSOR_WAIT:
779             m_value.ident = CSSValueWait;
780             break;
781         case CURSOR_HELP:
782             m_value.ident = CSSValueHelp;
783             break;
784         case CURSOR_ALL_SCROLL:
785             m_value.ident = CSSValueAllScroll;
786             break;
787         case CURSOR_WEBKIT_GRAB:
788             m_value.ident = CSSValueWebkitGrab;
789             break;
790         case CURSOR_WEBKIT_GRABBING:
791             m_value.ident = CSSValueWebkitGrabbing;
792             break;
793     }
794 }
795
796 template<> inline CSSPrimitiveValue::operator ECursor() const
797 {
798     if (m_value.ident == CSSValueCopy)
799         return CURSOR_COPY;
800     if (m_value.ident == CSSValueNone)
801         return CURSOR_NONE;
802     return static_cast<ECursor>(m_value.ident - CSSValueAuto);
803 }
804
805 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
806     : m_type(CSS_IDENT)
807     , m_hasCachedCSSText(false)
808 {
809     switch (e) {
810         case INLINE:
811             m_value.ident = CSSValueInline;
812             break;
813         case BLOCK:
814             m_value.ident = CSSValueBlock;
815             break;
816         case LIST_ITEM:
817             m_value.ident = CSSValueListItem;
818             break;
819         case RUN_IN:
820             m_value.ident = CSSValueRunIn;
821             break;
822         case COMPACT:
823             m_value.ident = CSSValueCompact;
824             break;
825         case INLINE_BLOCK:
826             m_value.ident = CSSValueInlineBlock;
827             break;
828         case TABLE:
829             m_value.ident = CSSValueTable;
830             break;
831         case INLINE_TABLE:
832             m_value.ident = CSSValueInlineTable;
833             break;
834         case TABLE_ROW_GROUP:
835             m_value.ident = CSSValueTableRowGroup;
836             break;
837         case TABLE_HEADER_GROUP:
838             m_value.ident = CSSValueTableHeaderGroup;
839             break;
840         case TABLE_FOOTER_GROUP:
841             m_value.ident = CSSValueTableFooterGroup;
842             break;
843         case TABLE_ROW:
844             m_value.ident = CSSValueTableRow;
845             break;
846         case TABLE_COLUMN_GROUP:
847             m_value.ident = CSSValueTableColumnGroup;
848             break;
849         case TABLE_COLUMN:
850             m_value.ident = CSSValueTableColumn;
851             break;
852         case TABLE_CELL:
853             m_value.ident = CSSValueTableCell;
854             break;
855         case TABLE_CAPTION:
856             m_value.ident = CSSValueTableCaption;
857             break;
858 #if ENABLE(WCSS)
859         case WAP_MARQUEE:
860             m_value.ident = CSSValueWapMarquee;
861             break;
862 #endif
863         case BOX:
864             m_value.ident = CSSValueWebkitBox;
865             break;
866         case INLINE_BOX:
867             m_value.ident = CSSValueWebkitInlineBox;
868             break;
869         case NONE:
870             m_value.ident = CSSValueNone;
871             break;
872     }
873 }
874
875 template<> inline CSSPrimitiveValue::operator EDisplay() const
876 {
877     if (m_value.ident == CSSValueNone)
878         return NONE;
879     return static_cast<EDisplay>(m_value.ident - CSSValueInline);
880 }
881
882 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
883     : m_type(CSS_IDENT)
884     , m_hasCachedCSSText(false)
885 {
886     switch (e) {
887         case SHOW:
888             m_value.ident = CSSValueShow;
889             break;
890         case HIDE:
891             m_value.ident = CSSValueHide;
892             break;
893     }
894 }
895
896 template<> inline CSSPrimitiveValue::operator EEmptyCell() const
897 {
898     switch (m_value.ident) {
899         case CSSValueShow:
900             return SHOW;
901         case CSSValueHide:
902             return HIDE;
903         default:
904             ASSERT_NOT_REACHED();
905             return SHOW;
906     }
907 }
908
909 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
910     : m_type(CSS_IDENT)
911     , m_hasCachedCSSText(false)
912 {
913     switch (e) {
914         case FNONE:
915             m_value.ident = CSSValueNone;
916             break;
917         case FLEFT:
918             m_value.ident = CSSValueLeft;
919             break;
920         case FRIGHT:
921             m_value.ident = CSSValueRight;
922             break;
923     }
924 }
925
926 template<> inline CSSPrimitiveValue::operator EFloat() const
927 {
928     switch (m_value.ident) {
929         case CSSValueLeft:
930             return FLEFT;
931         case CSSValueRight:
932             return FRIGHT;
933         case CSSValueNone:
934         case CSSValueCenter:  // Non-standard CSS value
935             return FNONE;
936         default:
937             ASSERT_NOT_REACHED();
938             return FNONE;
939     }
940 }
941
942 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EKHTMLLineBreak e)
943     : m_type(CSS_IDENT)
944     , m_hasCachedCSSText(false)
945 {
946     switch (e) {
947         case LBNORMAL:
948             m_value.ident = CSSValueNormal;
949             break;
950         case AFTER_WHITE_SPACE:
951             m_value.ident = CSSValueAfterWhiteSpace;
952             break;
953     }
954 }
955
956 template<> inline CSSPrimitiveValue::operator EKHTMLLineBreak() const
957 {
958     switch (m_value.ident) {
959         case CSSValueAfterWhiteSpace:
960             return AFTER_WHITE_SPACE;
961         case CSSValueNormal:
962             return LBNORMAL;
963         default:
964             ASSERT_NOT_REACHED();
965             return LBNORMAL;
966     }
967 }
968
969 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
970     : m_type(CSS_IDENT)
971     , m_hasCachedCSSText(false)
972 {
973     switch (e) {
974         case OUTSIDE:
975             m_value.ident = CSSValueOutside;
976             break;
977         case INSIDE:
978             m_value.ident = CSSValueInside;
979             break;
980     }
981 }
982
983 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
984 {
985     return (EListStylePosition)(m_value.ident - CSSValueOutside);
986 }
987
988 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
989     : m_type(CSS_IDENT)
990     , m_hasCachedCSSText(false)
991 {
992     switch (e) {
993     case Afar:
994         m_value.ident = CSSValueAfar;
995         break;
996     case Amharic:
997         m_value.ident = CSSValueAmharic;
998         break;
999     case AmharicAbegede:
1000         m_value.ident = CSSValueAmharicAbegede;
1001         break;
1002     case ArabicIndic:
1003         m_value.ident = CSSValueArabicIndic;
1004         break;
1005     case Armenian:
1006         m_value.ident = CSSValueArmenian;
1007         break;
1008     case BinaryListStyle:
1009         m_value.ident = CSSValueBinary;
1010         break;
1011     case Bengali:
1012         m_value.ident = CSSValueBengali;
1013         break;
1014     case Cambodian:
1015         m_value.ident = CSSValueCambodian;
1016         break;
1017     case Circle:
1018         m_value.ident = CSSValueCircle;
1019         break;
1020     case CjkEarthlyBranch:
1021         m_value.ident = CSSValueCjkEarthlyBranch;
1022         break;
1023     case CjkHeavenlyStem:
1024         m_value.ident = CSSValueCjkHeavenlyStem;
1025         break;
1026     case CJKIdeographic:
1027         m_value.ident = CSSValueCjkIdeographic;
1028         break;
1029     case DecimalLeadingZero:
1030         m_value.ident = CSSValueDecimalLeadingZero;
1031         break;
1032     case DecimalListStyle:
1033         m_value.ident = CSSValueDecimal;
1034         break;
1035     case Devanagari:
1036         m_value.ident = CSSValueDevanagari;
1037         break;
1038     case Disc:
1039         m_value.ident = CSSValueDisc;
1040         break;
1041     case Ethiopic:
1042         m_value.ident = CSSValueEthiopic;
1043         break;
1044     case EthiopicAbegede:
1045         m_value.ident = CSSValueEthiopicAbegede;
1046         break;
1047     case EthiopicAbegedeAmEt:
1048         m_value.ident = CSSValueEthiopicAbegedeAmEt;
1049         break;
1050     case EthiopicAbegedeGez:
1051         m_value.ident = CSSValueEthiopicAbegedeGez;
1052         break;
1053     case EthiopicAbegedeTiEr:
1054         m_value.ident = CSSValueEthiopicAbegedeTiEr;
1055         break;
1056     case EthiopicAbegedeTiEt:
1057         m_value.ident = CSSValueEthiopicAbegedeTiEt;
1058         break;
1059     case EthiopicHalehameAaEr:
1060         m_value.ident = CSSValueEthiopicHalehameAaEr;
1061         break;
1062     case EthiopicHalehameAaEt:
1063         m_value.ident = CSSValueEthiopicHalehameAaEt;
1064         break;
1065     case EthiopicHalehameAmEt:
1066         m_value.ident = CSSValueEthiopicHalehameAmEt;
1067         break;
1068     case EthiopicHalehameGez:
1069         m_value.ident = CSSValueEthiopicHalehameGez;
1070         break;
1071     case EthiopicHalehameOmEt:
1072         m_value.ident = CSSValueEthiopicHalehameOmEt;
1073         break;
1074     case EthiopicHalehameSidEt:
1075         m_value.ident = CSSValueEthiopicHalehameSidEt;
1076         break;
1077     case EthiopicHalehameSoEt:
1078         m_value.ident = CSSValueEthiopicHalehameSoEt;
1079         break;
1080     case EthiopicHalehameTiEr:
1081         m_value.ident = CSSValueEthiopicHalehameTiEr;
1082         break;
1083     case EthiopicHalehameTiEt:
1084         m_value.ident = CSSValueEthiopicHalehameTiEt;
1085         break;
1086     case EthiopicHalehameTig:
1087         m_value.ident = CSSValueEthiopicHalehameTig;
1088         break;
1089     case Georgian:
1090         m_value.ident = CSSValueGeorgian;
1091         break;
1092     case Gujarati:
1093         m_value.ident = CSSValueGujarati;
1094         break;
1095     case Gurmukhi:
1096         m_value.ident = CSSValueGurmukhi;
1097         break;
1098     case Hangul:
1099         m_value.ident = CSSValueHangul;
1100         break;
1101     case HangulConsonant:
1102         m_value.ident = CSSValueHangulConsonant;
1103         break;
1104     case Hebrew:
1105         m_value.ident = CSSValueHebrew;
1106         break;
1107     case Hiragana:
1108         m_value.ident = CSSValueHiragana;
1109         break;
1110     case HiraganaIroha:
1111         m_value.ident = CSSValueHiraganaIroha;
1112         break;
1113     case Kannada:
1114         m_value.ident = CSSValueKannada;
1115         break;
1116     case Katakana:
1117         m_value.ident = CSSValueKatakana;
1118         break;
1119     case KatakanaIroha:
1120         m_value.ident = CSSValueKatakanaIroha;
1121         break;
1122     case Khmer:
1123         m_value.ident = CSSValueKhmer;
1124         break;
1125     case Lao:
1126         m_value.ident = CSSValueLao;
1127         break;
1128     case LowerAlpha:
1129         m_value.ident = CSSValueLowerAlpha;
1130         break;
1131     case LowerGreek:
1132         m_value.ident = CSSValueLowerGreek;
1133         break;
1134     case LowerHexadecimal:
1135         m_value.ident = CSSValueLowerHexadecimal;
1136         break;
1137     case LowerLatin:
1138         m_value.ident = CSSValueLowerLatin;
1139         break;
1140     case LowerNorwegian:
1141         m_value.ident = CSSValueLowerNorwegian;
1142         break;
1143     case LowerRoman:
1144         m_value.ident = CSSValueLowerRoman;
1145         break;
1146     case Malayalam:
1147         m_value.ident = CSSValueMalayalam;
1148         break;
1149     case Mongolian:
1150         m_value.ident = CSSValueMongolian;
1151         break;
1152     case Myanmar:
1153         m_value.ident = CSSValueMyanmar;
1154         break;
1155     case NoneListStyle:
1156         m_value.ident = CSSValueNone;
1157         break;
1158     case Octal:
1159         m_value.ident = CSSValueOctal;
1160         break;
1161     case Oriya:
1162         m_value.ident = CSSValueOriya;
1163         break;
1164     case Oromo:
1165         m_value.ident = CSSValueOromo;
1166         break;
1167     case Persian:
1168         m_value.ident = CSSValuePersian;
1169         break;
1170     case Sidama:
1171         m_value.ident = CSSValueSidama;
1172         break;
1173     case Somali:
1174         m_value.ident = CSSValueSomali;
1175         break;
1176     case Square:
1177         m_value.ident = CSSValueSquare;
1178         break;
1179     case Telugu:
1180         m_value.ident = CSSValueTelugu;
1181         break;
1182     case Thai:
1183         m_value.ident = CSSValueThai;
1184         break;
1185     case Tibetan:
1186         m_value.ident = CSSValueTibetan;
1187         break;
1188     case Tigre:
1189         m_value.ident = CSSValueTigre;
1190         break;
1191     case TigrinyaEr:
1192         m_value.ident = CSSValueTigrinyaEr;
1193         break;
1194     case TigrinyaErAbegede:
1195         m_value.ident = CSSValueTigrinyaErAbegede;
1196         break;
1197     case TigrinyaEt:
1198         m_value.ident = CSSValueTigrinyaEt;
1199         break;
1200     case TigrinyaEtAbegede:
1201         m_value.ident = CSSValueTigrinyaEtAbegede;
1202         break;
1203     case UpperAlpha:
1204         m_value.ident = CSSValueUpperAlpha;
1205         break;
1206     case UpperGreek:
1207         m_value.ident = CSSValueUpperGreek;
1208         break;
1209     case UpperHexadecimal:
1210         m_value.ident = CSSValueUpperHexadecimal;
1211         break;
1212     case UpperLatin:
1213         m_value.ident = CSSValueUpperLatin;
1214         break;
1215     case UpperNorwegian:
1216         m_value.ident = CSSValueUpperNorwegian;
1217         break;
1218     case UpperRoman:
1219         m_value.ident = CSSValueUpperRoman;
1220         break;
1221     case Urdu:
1222         m_value.ident = CSSValueUrdu;
1223         break;
1224     }
1225 }
1226
1227 template<> inline CSSPrimitiveValue::operator EListStyleType() const
1228 {
1229     switch (m_value.ident) {
1230         case CSSValueNone:
1231             return NoneListStyle;
1232         default:
1233             return static_cast<EListStyleType>(m_value.ident - CSSValueDisc);
1234     }
1235 }
1236
1237 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
1238     : m_type(CSS_IDENT)
1239     , m_hasCachedCSSText(false)
1240 {
1241     switch (e) {
1242         case MCOLLAPSE:
1243             m_value.ident = CSSValueCollapse;
1244             break;
1245         case MSEPARATE:
1246             m_value.ident = CSSValueSeparate;
1247             break;
1248         case MDISCARD:
1249             m_value.ident = CSSValueDiscard;
1250             break;
1251     }
1252 }
1253
1254 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
1255 {
1256     switch (m_value.ident) {
1257         case CSSValueCollapse:
1258             return MCOLLAPSE;
1259         case CSSValueSeparate:
1260             return MSEPARATE;
1261         case CSSValueDiscard:
1262             return MDISCARD;
1263         default:
1264             ASSERT_NOT_REACHED();
1265             return MCOLLAPSE;
1266     }
1267 }
1268
1269 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
1270     : m_type(CSS_IDENT)
1271     , m_hasCachedCSSText(false)
1272 {
1273     switch (e) {
1274         case MNONE:
1275             m_value.ident = CSSValueNone;
1276             break;
1277         case MSCROLL:
1278             m_value.ident = CSSValueScroll;
1279             break;
1280         case MSLIDE:
1281             m_value.ident = CSSValueSlide;
1282             break;
1283         case MALTERNATE:
1284             m_value.ident = CSSValueAlternate;
1285             break;
1286     }
1287 }
1288
1289 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
1290 {
1291     switch (m_value.ident) {
1292         case CSSValueNone:
1293             return MNONE;
1294         case CSSValueScroll:
1295             return MSCROLL;
1296         case CSSValueSlide:
1297             return MSLIDE;
1298         case CSSValueAlternate:
1299             return MALTERNATE;
1300         default:
1301             ASSERT_NOT_REACHED();
1302             return MNONE;
1303     }
1304 }
1305
1306 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
1307     : m_type(CSS_IDENT)
1308     , m_hasCachedCSSText(false)
1309 {
1310     switch (e) {
1311         case MFORWARD:
1312             m_value.ident = CSSValueForwards;
1313             break;
1314         case MBACKWARD:
1315             m_value.ident = CSSValueBackwards;
1316             break;
1317         case MAUTO:
1318             m_value.ident = CSSValueAuto;
1319             break;
1320         case MUP:
1321             m_value.ident = CSSValueUp;
1322             break;
1323         case MDOWN:
1324             m_value.ident = CSSValueDown;
1325             break;
1326         case MLEFT:
1327             m_value.ident = CSSValueLeft;
1328             break;
1329         case MRIGHT:
1330             m_value.ident = CSSValueRight;
1331             break;
1332     }
1333 }
1334
1335 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
1336 {
1337     switch (m_value.ident) {
1338         case CSSValueForwards:
1339             return MFORWARD;
1340         case CSSValueBackwards:
1341             return MBACKWARD;
1342         case CSSValueAuto:
1343             return MAUTO;
1344         case CSSValueAhead:
1345         case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
1346             return MUP;
1347         case CSSValueReverse:
1348         case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
1349             return MDOWN;
1350         case CSSValueLeft:
1351             return MLEFT;
1352         case CSSValueRight:
1353             return MRIGHT;
1354         default:
1355             ASSERT_NOT_REACHED();
1356             return MAUTO;
1357     }
1358 }
1359
1360 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMatchNearestMailBlockquoteColor e)
1361     : m_type(CSS_IDENT)
1362     , m_hasCachedCSSText(false)
1363 {
1364     switch (e) {
1365         case BCNORMAL:
1366             m_value.ident = CSSValueNormal;
1367             break;
1368         case MATCH:
1369             m_value.ident = CSSValueMatch;
1370             break;
1371     }
1372 }
1373
1374 template<> inline CSSPrimitiveValue::operator EMatchNearestMailBlockquoteColor() const
1375 {
1376     switch (m_value.ident) {
1377         case CSSValueNormal:
1378             return BCNORMAL;
1379         case CSSValueMatch:
1380             return MATCH;
1381         default:
1382             ASSERT_NOT_REACHED();
1383             return BCNORMAL;
1384     }
1385 }
1386
1387 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
1388     : m_type(CSS_IDENT)
1389     , m_hasCachedCSSText(false)
1390 {
1391     switch (e) {
1392         case NBNORMAL:
1393             m_value.ident = CSSValueNormal;
1394             break;
1395         case SPACE:
1396             m_value.ident = CSSValueSpace;
1397             break;
1398     }
1399 }
1400
1401 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
1402 {
1403     switch (m_value.ident) {
1404         case CSSValueSpace:
1405             return SPACE;
1406         case CSSValueNormal:
1407             return NBNORMAL;
1408         default:
1409             ASSERT_NOT_REACHED();
1410             return NBNORMAL;
1411     }
1412 }
1413
1414 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
1415     : m_type(CSS_IDENT)
1416     , m_hasCachedCSSText(false)
1417 {
1418     switch (e) {
1419         case OVISIBLE:
1420             m_value.ident = CSSValueVisible;
1421             break;
1422         case OHIDDEN:
1423             m_value.ident = CSSValueHidden;
1424             break;
1425         case OSCROLL:
1426             m_value.ident = CSSValueScroll;
1427             break;
1428         case OAUTO:
1429             m_value.ident = CSSValueAuto;
1430             break;
1431         case OMARQUEE:
1432             m_value.ident = CSSValueWebkitMarquee;
1433             break;
1434         case OOVERLAY:
1435             m_value.ident = CSSValueOverlay;
1436             break;
1437     }
1438 }
1439
1440 template<> inline CSSPrimitiveValue::operator EOverflow() const
1441 {
1442     switch (m_value.ident) {
1443         case CSSValueVisible:
1444             return OVISIBLE;
1445         case CSSValueHidden:
1446             return OHIDDEN;
1447         case CSSValueScroll:
1448             return OSCROLL;
1449         case CSSValueAuto:
1450             return OAUTO;
1451         case CSSValueWebkitMarquee:
1452             return OMARQUEE;
1453         case CSSValueOverlay:
1454             return OOVERLAY;
1455         default:
1456             ASSERT_NOT_REACHED();
1457             return OVISIBLE;
1458     }
1459 }
1460
1461 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
1462     : m_type(CSS_IDENT)
1463     , m_hasCachedCSSText(false)
1464 {
1465     switch (e) {
1466         case PBAUTO:
1467             m_value.ident = CSSValueAuto;
1468             break;
1469         case PBALWAYS:
1470             m_value.ident = CSSValueAlways;
1471             break;
1472         case PBAVOID:
1473             m_value.ident = CSSValueAvoid;
1474             break;
1475     }
1476 }
1477
1478 template<> inline CSSPrimitiveValue::operator EPageBreak() const
1479 {
1480     switch (m_value.ident) {
1481         case CSSValueAuto:
1482             return PBAUTO;
1483         case CSSValueLeft:
1484         case CSSValueRight:
1485         case CSSValueAlways:
1486             return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always."
1487         case CSSValueAvoid:
1488             return PBAVOID;
1489         default:
1490             ASSERT_NOT_REACHED();
1491             return PBAUTO;
1492     }
1493 }
1494
1495 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
1496     : m_type(CSS_IDENT)
1497     , m_hasCachedCSSText(false)
1498 {
1499     switch (e) {
1500         case StaticPosition:
1501             m_value.ident = CSSValueStatic;
1502             break;
1503         case RelativePosition:
1504             m_value.ident = CSSValueRelative;
1505             break;
1506         case AbsolutePosition:
1507             m_value.ident = CSSValueAbsolute;
1508             break;
1509         case FixedPosition:
1510             m_value.ident = CSSValueFixed;
1511             break;
1512     }
1513 }
1514
1515 template<> inline CSSPrimitiveValue::operator EPosition() const
1516 {
1517     switch (m_value.ident) {
1518         case CSSValueStatic:
1519             return StaticPosition;
1520         case CSSValueRelative:
1521             return RelativePosition;
1522         case CSSValueAbsolute:
1523             return AbsolutePosition;
1524         case CSSValueFixed:
1525             return FixedPosition;
1526         default:
1527             ASSERT_NOT_REACHED();
1528             return StaticPosition;
1529     }
1530 }
1531
1532 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
1533     : m_type(CSS_IDENT)
1534     , m_hasCachedCSSText(false)
1535 {
1536     switch (e) {
1537         case RESIZE_BOTH:
1538             m_value.ident = CSSValueBoth;
1539             break;
1540         case RESIZE_HORIZONTAL:
1541             m_value.ident = CSSValueHorizontal;
1542             break;
1543         case RESIZE_VERTICAL:
1544             m_value.ident = CSSValueVertical;
1545             break;
1546         case RESIZE_NONE:
1547             m_value.ident = CSSValueNone;
1548             break;
1549     }
1550 }
1551
1552 template<> inline CSSPrimitiveValue::operator EResize() const
1553 {
1554     switch (m_value.ident) {
1555         case CSSValueBoth:
1556             return RESIZE_BOTH;
1557         case CSSValueHorizontal:
1558             return RESIZE_HORIZONTAL;
1559         case CSSValueVertical:
1560             return RESIZE_VERTICAL;
1561         case CSSValueAuto:
1562             ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
1563             return RESIZE_NONE;
1564         case CSSValueNone:
1565             return RESIZE_NONE;
1566         default:
1567             ASSERT_NOT_REACHED();
1568             return RESIZE_NONE;
1569     }
1570 }
1571
1572 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
1573     : m_type(CSS_IDENT)
1574     , m_hasCachedCSSText(false)
1575 {
1576     switch (e) {
1577         case TAUTO:
1578             m_value.ident = CSSValueAuto;
1579             break;
1580         case TFIXED:
1581             m_value.ident = CSSValueFixed;
1582             break;
1583     }
1584 }
1585
1586 template<> inline CSSPrimitiveValue::operator ETableLayout() const
1587 {
1588     switch (m_value.ident) {
1589         case CSSValueFixed:
1590             return TFIXED;
1591         case CSSValueAuto:
1592             return TAUTO;
1593         default:
1594             ASSERT_NOT_REACHED();
1595             return TAUTO;
1596     }
1597 }
1598
1599 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
1600     : m_type(CSS_IDENT)
1601     , m_hasCachedCSSText(false)
1602 {
1603     switch (e) {
1604         case TAAUTO:
1605             m_value.ident = CSSValueAuto;
1606             break;
1607         case LEFT:
1608             m_value.ident = CSSValueLeft;
1609             break;
1610         case RIGHT:
1611             m_value.ident = CSSValueRight;
1612             break;
1613         case CENTER:
1614             m_value.ident = CSSValueCenter;
1615             break;
1616         case JUSTIFY:
1617             m_value.ident = CSSValueJustify;
1618             break;
1619         case WEBKIT_LEFT:
1620             m_value.ident = CSSValueWebkitLeft;
1621             break;
1622         case WEBKIT_RIGHT:
1623             m_value.ident = CSSValueWebkitRight;
1624             break;
1625         case WEBKIT_CENTER:
1626             m_value.ident = CSSValueWebkitCenter;
1627             break;
1628     }
1629 }
1630
1631 template<> inline CSSPrimitiveValue::operator ETextAlign() const
1632 {
1633     switch (m_value.ident) {
1634         case CSSValueStart:
1635         case CSSValueEnd:
1636             ASSERT_NOT_REACHED(); // Depends on direction, thus should be handled by the caller.
1637             return LEFT;
1638         default:
1639             return static_cast<ETextAlign>(m_value.ident - CSSValueWebkitAuto);
1640     }
1641 }
1642
1643 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
1644     : m_type(CSS_IDENT)
1645     , m_hasCachedCSSText(false)
1646 {
1647     switch (e) {
1648         case TSNONE:
1649             m_value.ident = CSSValueNone;
1650             break;
1651         case TSDISC:
1652             m_value.ident = CSSValueDisc;
1653             break;
1654         case TSCIRCLE:
1655             m_value.ident = CSSValueCircle;
1656             break;
1657         case TSSQUARE:
1658             m_value.ident = CSSValueSquare;
1659             break;
1660     }
1661 }
1662
1663 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
1664 {
1665     switch (m_value.ident) {
1666         case CSSValueNone:
1667             return TSNONE;
1668         case CSSValueDisc:
1669             return TSDISC;
1670         case CSSValueCircle:
1671             return TSCIRCLE;
1672         case CSSValueSquare:
1673             return TSSQUARE;
1674         default:
1675             ASSERT_NOT_REACHED();
1676             return TSNONE;
1677     }
1678 }
1679
1680 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
1681     : m_type(CSS_IDENT)
1682     , m_hasCachedCSSText(false)
1683 {
1684     switch (e) {
1685         case CAPITALIZE:
1686             m_value.ident = CSSValueCapitalize;
1687             break;
1688         case UPPERCASE:
1689             m_value.ident = CSSValueUppercase;
1690             break;
1691         case LOWERCASE:
1692             m_value.ident = CSSValueLowercase;
1693             break;
1694         case TTNONE:
1695             m_value.ident = CSSValueNone;
1696             break;
1697     }
1698 }
1699
1700 template<> inline CSSPrimitiveValue::operator ETextTransform() const
1701 {
1702     switch (m_value.ident) {
1703         case CSSValueCapitalize:
1704             return CAPITALIZE;
1705         case CSSValueUppercase:
1706             return UPPERCASE;
1707         case CSSValueLowercase:
1708             return LOWERCASE;
1709         case CSSValueNone:
1710             return TTNONE;
1711         default:
1712             ASSERT_NOT_REACHED();
1713             return TTNONE;
1714     }
1715 }
1716
1717 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
1718     : m_type(CSS_IDENT)
1719     , m_hasCachedCSSText(false)
1720 {
1721     switch (e) {
1722         case UBNormal:
1723             m_value.ident = CSSValueNormal;
1724             break;
1725         case Embed:
1726             m_value.ident = CSSValueEmbed;
1727             break;
1728         case Override:
1729             m_value.ident = CSSValueBidiOverride;
1730             break;
1731     }
1732 }
1733
1734 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
1735 {
1736     switch (m_value.ident) {
1737         case CSSValueNormal:
1738             return UBNormal; 
1739         case CSSValueEmbed:
1740             return Embed; 
1741         case CSSValueBidiOverride:
1742             return Override;
1743         default:
1744             ASSERT_NOT_REACHED();
1745             return UBNormal;
1746     }
1747 }
1748
1749 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
1750     : m_type(CSS_IDENT)
1751     , m_hasCachedCSSText(false)
1752 {
1753     switch (e) {
1754         case DRAG_AUTO:
1755             m_value.ident = CSSValueAuto;
1756             break;
1757         case DRAG_NONE:
1758             m_value.ident = CSSValueNone;
1759             break;
1760         case DRAG_ELEMENT:
1761             m_value.ident = CSSValueElement;
1762             break;
1763     }
1764 }
1765
1766 template<> inline CSSPrimitiveValue::operator EUserDrag() const
1767 {
1768     switch (m_value.ident) {
1769         case CSSValueAuto:
1770             return DRAG_AUTO;
1771         case CSSValueNone:
1772             return DRAG_NONE;
1773         case CSSValueElement:
1774             return DRAG_ELEMENT;
1775         default:
1776             ASSERT_NOT_REACHED();
1777             return DRAG_AUTO;
1778     }
1779 }
1780
1781 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
1782     : m_type(CSS_IDENT)
1783     , m_hasCachedCSSText(false)
1784 {
1785     switch (e) {
1786         case READ_ONLY:
1787             m_value.ident = CSSValueReadOnly;
1788             break;
1789         case READ_WRITE:
1790             m_value.ident = CSSValueReadWrite;
1791             break;
1792         case READ_WRITE_PLAINTEXT_ONLY:
1793             m_value.ident = CSSValueReadWritePlaintextOnly;
1794             break;
1795     }
1796 }
1797
1798 template<> inline CSSPrimitiveValue::operator EUserModify() const
1799 {
1800     return static_cast<EUserModify>(m_value.ident - CSSValueReadOnly);
1801 }
1802
1803 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
1804     : m_type(CSS_IDENT)
1805     , m_hasCachedCSSText(false)
1806 {
1807     switch (e) {
1808         case SELECT_NONE:
1809             m_value.ident = CSSValueNone;
1810             break;
1811         case SELECT_TEXT:
1812             m_value.ident = CSSValueText;
1813             break;
1814     }
1815 }
1816
1817 template<> inline CSSPrimitiveValue::operator EUserSelect() const
1818 {
1819     switch (m_value.ident) {
1820         case CSSValueAuto:
1821             return SELECT_TEXT;
1822         case CSSValueNone:
1823             return SELECT_NONE;
1824         case CSSValueText:
1825             return SELECT_TEXT;
1826         default:
1827             ASSERT_NOT_REACHED();
1828             return SELECT_TEXT;
1829     }
1830 }
1831
1832 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
1833     : m_type(CSS_IDENT)
1834     , m_hasCachedCSSText(false)
1835 {
1836     switch (e) {
1837         case VISIBLE:
1838             m_value.ident = CSSValueVisible;
1839             break;
1840         case HIDDEN:
1841             m_value.ident = CSSValueHidden;
1842             break;
1843         case COLLAPSE:
1844             m_value.ident = CSSValueCollapse;
1845             break;
1846     }
1847 }
1848
1849 template<> inline CSSPrimitiveValue::operator EVisibility() const
1850 {
1851     switch (m_value.ident) {
1852         case CSSValueHidden:
1853             return HIDDEN;
1854         case CSSValueVisible:
1855             return VISIBLE;
1856         case CSSValueCollapse:
1857             return COLLAPSE;
1858         default:
1859             ASSERT_NOT_REACHED();
1860             return VISIBLE;
1861     }
1862 }
1863
1864 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
1865     : m_type(CSS_IDENT)
1866     , m_hasCachedCSSText(false)
1867 {
1868     switch (e) {
1869         case NORMAL:
1870             m_value.ident = CSSValueNormal;
1871             break;
1872         case PRE:
1873             m_value.ident = CSSValuePre;
1874             break;
1875         case PRE_WRAP:
1876             m_value.ident = CSSValuePreWrap;
1877             break;
1878         case PRE_LINE:
1879             m_value.ident = CSSValuePreLine;
1880             break;
1881         case NOWRAP:
1882             m_value.ident = CSSValueNowrap;
1883             break;
1884         case KHTML_NOWRAP:
1885             m_value.ident = CSSValueWebkitNowrap;
1886             break;
1887     }
1888 }
1889
1890 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
1891 {
1892     switch (m_value.ident) {
1893         case CSSValueWebkitNowrap:
1894             return KHTML_NOWRAP;
1895         case CSSValueNowrap:
1896             return NOWRAP;
1897         case CSSValuePre:
1898             return PRE;
1899         case CSSValuePreWrap:
1900             return PRE_WRAP;
1901         case CSSValuePreLine:
1902             return PRE_LINE;
1903         case CSSValueNormal:
1904             return NORMAL;
1905         default:
1906             ASSERT_NOT_REACHED();
1907             return NORMAL;
1908     }
1909 }
1910
1911 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
1912     : m_type(CSS_IDENT)
1913     , m_hasCachedCSSText(false)
1914 {
1915     switch (e) {
1916         case NormalWordBreak:
1917             m_value.ident = CSSValueNormal;
1918             break;
1919         case BreakAllWordBreak:
1920             m_value.ident = CSSValueBreakAll;
1921             break;
1922         case BreakWordBreak:
1923             m_value.ident = CSSValueBreakWord;
1924             break;
1925     }
1926 }
1927
1928 template<> inline CSSPrimitiveValue::operator EWordBreak() const
1929 {
1930     switch (m_value.ident) {
1931         case CSSValueBreakAll:
1932             return BreakAllWordBreak;
1933         case CSSValueBreakWord:
1934             return BreakWordBreak;
1935         case CSSValueNormal:
1936             return NormalWordBreak;
1937         default:
1938         ASSERT_NOT_REACHED();
1939         return NormalWordBreak;
1940     }
1941 }
1942
1943 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordWrap e)
1944     : m_type(CSS_IDENT)
1945     , m_hasCachedCSSText(false)
1946 {
1947     switch (e) {
1948         case NormalWordWrap:
1949             m_value.ident = CSSValueNormal;
1950             break;
1951         case BreakWordWrap:
1952             m_value.ident = CSSValueBreakWord;
1953             break;
1954     }
1955 }
1956
1957 template<> inline CSSPrimitiveValue::operator EWordWrap() const
1958 {
1959     switch (m_value.ident) {
1960         case CSSValueBreakWord:
1961             return BreakWordWrap;
1962         case CSSValueNormal:
1963             return NormalWordWrap;
1964         default:
1965             ASSERT_NOT_REACHED();
1966             return NormalWordWrap;
1967     }
1968 }
1969
1970 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
1971     : m_type(CSS_IDENT)
1972     , m_hasCachedCSSText(false)
1973 {
1974     switch (e) {
1975         case LTR:
1976             m_value.ident = CSSValueLtr;
1977             break;
1978         case RTL:
1979             m_value.ident = CSSValueRtl;
1980             break;
1981     }
1982 }
1983
1984 template<> inline CSSPrimitiveValue::operator TextDirection() const
1985 {
1986     switch (m_value.ident) {
1987         case CSSValueLtr:
1988             return LTR;
1989         case CSSValueRtl:
1990             return RTL;
1991         default:
1992             ASSERT_NOT_REACHED();
1993             return LTR;
1994     }
1995 }
1996
1997 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
1998     : m_type(CSS_IDENT)
1999     , m_hasCachedCSSText(false)
2000 {
2001     switch (e) {
2002         case PE_NONE:
2003             m_value.ident = CSSValueNone;
2004             break;
2005         case PE_STROKE:
2006             m_value.ident = CSSValueStroke;
2007             break;
2008         case PE_FILL:
2009             m_value.ident = CSSValueFill;
2010             break;
2011         case PE_PAINTED:
2012             m_value.ident = CSSValuePainted;
2013             break;
2014         case PE_VISIBLE:
2015             m_value.ident = CSSValueVisible;
2016             break;
2017         case PE_VISIBLE_STROKE:
2018             m_value.ident = CSSValueVisiblestroke;
2019             break;
2020         case PE_VISIBLE_FILL:
2021             m_value.ident = CSSValueVisiblefill;
2022             break;
2023         case PE_VISIBLE_PAINTED:
2024             m_value.ident = CSSValueVisiblepainted;
2025             break;
2026         case PE_AUTO:
2027             m_value.ident = CSSValueAuto;
2028             break;
2029         case PE_ALL:
2030             m_value.ident = CSSValueAll;
2031             break;
2032     }
2033 }
2034
2035 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
2036 {
2037     switch (m_value.ident) {
2038         case CSSValueAll:
2039             return PE_ALL;
2040         case CSSValueAuto:
2041             return PE_AUTO;
2042         case CSSValueNone:
2043             return PE_NONE;
2044         case CSSValueVisiblepainted:
2045             return PE_VISIBLE_PAINTED;
2046         case CSSValueVisiblefill:
2047             return PE_VISIBLE_FILL;
2048         case CSSValueVisiblestroke:
2049             return PE_VISIBLE_STROKE;
2050         case CSSValueVisible:
2051             return PE_VISIBLE;
2052         case CSSValuePainted:
2053             return PE_PAINTED;
2054         case CSSValueFill:
2055             return PE_FILL;
2056         case CSSValueStroke:
2057             return PE_STROKE;
2058         default:
2059             ASSERT_NOT_REACHED();
2060             return PE_ALL;
2061     }
2062 }
2063
2064 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
2065     : m_type(CSS_IDENT)
2066     , m_hasCachedCSSText(false)
2067 {
2068     switch (smoothing) {
2069     case AutoSmoothing:
2070         m_value.ident = CSSValueAuto;
2071         return;
2072     case NoSmoothing:
2073         m_value.ident = CSSValueNone;
2074         return;
2075     case Antialiased:
2076         m_value.ident = CSSValueAntialiased;
2077         return;
2078     case SubpixelAntialiased:
2079         m_value.ident = CSSValueSubpixelAntialiased;
2080         return;
2081     }
2082     
2083     ASSERT_NOT_REACHED();
2084     m_value.ident = CSSValueAuto;
2085 }
2086
2087 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
2088 {
2089     switch (m_value.ident) {
2090     case CSSValueAuto:
2091         return AutoSmoothing;
2092     case CSSValueNone:
2093         return NoSmoothing;
2094     case CSSValueAntialiased:
2095         return Antialiased;
2096     case CSSValueSubpixelAntialiased:
2097         return SubpixelAntialiased;
2098     }
2099     
2100     ASSERT_NOT_REACHED();
2101     return AutoSmoothing;
2102 }
2103
2104 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
2105     : m_type(CSS_IDENT)
2106     , m_hasCachedCSSText(false)
2107 {
2108     switch (e) {
2109         case AutoTextRendering:
2110             m_value.ident = CSSValueAuto;
2111             break;
2112         case OptimizeSpeed:
2113             m_value.ident = CSSValueOptimizespeed;
2114             break;
2115         case OptimizeLegibility:
2116             m_value.ident = CSSValueOptimizelegibility;
2117             break;
2118         case GeometricPrecision:
2119             m_value.ident = CSSValueGeometricprecision;
2120             break;
2121     }
2122 }
2123
2124 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
2125 {
2126     switch (m_value.ident) {
2127         case CSSValueAuto:
2128             return AutoTextRendering;
2129         case CSSValueOptimizespeed:
2130             return OptimizeSpeed;
2131         case CSSValueOptimizelegibility:
2132             return OptimizeLegibility;
2133         case CSSValueGeometricprecision:
2134             return GeometricPrecision;
2135         default:
2136             ASSERT_NOT_REACHED();
2137             return AutoTextRendering;
2138     }
2139 }
2140
2141 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColorSpace space)
2142     : m_type(CSS_IDENT)
2143     , m_hasCachedCSSText(false)
2144 {
2145     switch (space) {
2146         case DeviceColorSpace:
2147             m_value.ident = CSSValueDefault;
2148             break;
2149         case sRGBColorSpace:
2150             m_value.ident = CSSValueSrgb;
2151             break;
2152     }
2153 }
2154
2155 template<> inline CSSPrimitiveValue::operator ColorSpace() const
2156 {
2157     switch (m_value.ident) {
2158         case CSSValueDefault:
2159             return DeviceColorSpace;
2160         case CSSValueSrgb:
2161             return sRGBColorSpace;
2162         default:
2163             ASSERT_NOT_REACHED();
2164             return DeviceColorSpace;
2165     }
2166 }
2167
2168 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
2169     : m_type(CSS_IDENT)
2170     , m_hasCachedCSSText(false)
2171 {
2172     switch (hyphens) {
2173     case HyphensNone:
2174         m_value.ident = CSSValueNone;
2175         break;
2176     case HyphensManual:
2177         m_value.ident = CSSValueManual;
2178         break;
2179     case HyphensAuto:
2180         m_value.ident = CSSValueAuto;
2181         break;
2182     }
2183 }
2184
2185 template<> inline CSSPrimitiveValue::operator Hyphens() const
2186 {
2187     switch (m_value.ident) {
2188     case CSSValueNone:
2189         return HyphensNone;
2190     case CSSValueManual:
2191         return HyphensManual;
2192     case CSSValueAuto:
2193         return HyphensAuto;
2194     default:
2195         ASSERT_NOT_REACHED();
2196         return HyphensAuto;
2197     }
2198 }
2199
2200 #if ENABLE(SVG)
2201
2202 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
2203     : m_type(CSS_IDENT)
2204     , m_hasCachedCSSText(false)
2205 {
2206     switch (e) {
2207         case ButtCap:
2208             m_value.ident = CSSValueButt;
2209             break;
2210         case RoundCap:
2211             m_value.ident = CSSValueRound;
2212             break;
2213         case SquareCap:
2214             m_value.ident = CSSValueSquare;
2215             break;
2216     }
2217 }
2218
2219 template<> inline CSSPrimitiveValue::operator LineCap() const
2220 {
2221     switch (m_value.ident) {
2222         case CSSValueButt:
2223             return ButtCap;
2224         case CSSValueRound:
2225             return RoundCap;
2226         case CSSValueSquare:
2227             return SquareCap;
2228         default:
2229             ASSERT_NOT_REACHED();
2230             return ButtCap;
2231     }
2232 }
2233
2234 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
2235     : m_type(CSS_IDENT)
2236     , m_hasCachedCSSText(false)
2237 {
2238     switch (e) {
2239         case MiterJoin:
2240             m_value.ident = CSSValueMiter;
2241             break;
2242         case RoundJoin:
2243             m_value.ident = CSSValueRound;
2244             break;
2245         case BevelJoin:
2246             m_value.ident = CSSValueBevel;
2247             break;
2248     }
2249 }
2250
2251 template<> inline CSSPrimitiveValue::operator LineJoin() const
2252 {
2253     switch (m_value.ident) {
2254         case CSSValueMiter:
2255             return MiterJoin;
2256         case CSSValueRound:
2257             return RoundJoin;
2258         case CSSValueBevel:
2259             return BevelJoin;
2260         default:
2261             ASSERT_NOT_REACHED();
2262             return MiterJoin;
2263     }
2264 }
2265
2266 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
2267     : m_type(CSS_IDENT)
2268     , m_hasCachedCSSText(false)
2269 {
2270     switch (e) {
2271         case RULE_NONZERO:
2272             m_value.ident = CSSValueNonzero;
2273             break;
2274         case RULE_EVENODD:
2275             m_value.ident = CSSValueEvenodd;
2276             break;
2277     }
2278 }
2279
2280 template<> inline CSSPrimitiveValue::operator WindRule() const
2281 {
2282     switch (m_value.ident) {
2283         case CSSValueNonzero:
2284             return RULE_NONZERO;
2285         case CSSValueEvenodd:
2286             return RULE_EVENODD;
2287         default:
2288             ASSERT_NOT_REACHED();
2289             return RULE_NONZERO;
2290     }
2291 }
2292
2293
2294 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
2295     : m_type(CSS_IDENT)
2296     , m_hasCachedCSSText(false)
2297 {
2298     switch (e) {
2299         case AB_AUTO:
2300             m_value.ident = CSSValueAuto;
2301             break;
2302         case AB_BASELINE:
2303             m_value.ident = CSSValueBaseline;
2304             break;
2305         case AB_BEFORE_EDGE:
2306             m_value.ident = CSSValueBeforeEdge;
2307             break;
2308         case AB_TEXT_BEFORE_EDGE:
2309             m_value.ident = CSSValueTextBeforeEdge;
2310             break;
2311         case AB_MIDDLE:
2312             m_value.ident = CSSValueMiddle;
2313             break;
2314         case AB_CENTRAL:
2315             m_value.ident = CSSValueCentral;
2316             break;
2317         case AB_AFTER_EDGE:
2318             m_value.ident = CSSValueAfterEdge;
2319             break;
2320         case AB_TEXT_AFTER_EDGE:
2321             m_value.ident = CSSValueTextAfterEdge;
2322             break;
2323         case AB_IDEOGRAPHIC:
2324             m_value.ident = CSSValueIdeographic;
2325             break;
2326         case AB_ALPHABETIC:
2327             m_value.ident = CSSValueAlphabetic;
2328             break;
2329         case AB_HANGING:
2330             m_value.ident = CSSValueHanging;
2331             break;
2332         case AB_MATHEMATICAL:
2333             m_value.ident = CSSValueMathematical;
2334             break;
2335     }
2336 }
2337
2338 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
2339 {
2340     switch (m_value.ident) {
2341         case CSSValueAuto:
2342             return AB_AUTO;
2343         case CSSValueBaseline:
2344             return AB_BASELINE;
2345         case CSSValueBeforeEdge:
2346             return AB_BEFORE_EDGE;
2347         case CSSValueTextBeforeEdge:
2348             return AB_TEXT_BEFORE_EDGE;
2349         case CSSValueMiddle:
2350             return AB_MIDDLE;
2351         case CSSValueCentral:
2352             return AB_CENTRAL;
2353         case CSSValueAfterEdge:
2354             return AB_AFTER_EDGE;
2355         case CSSValueTextAfterEdge:
2356             return AB_TEXT_AFTER_EDGE;
2357         case CSSValueIdeographic:
2358             return AB_IDEOGRAPHIC;
2359         case CSSValueAlphabetic:
2360             return AB_ALPHABETIC;
2361         case CSSValueHanging:
2362             return AB_HANGING;
2363         case CSSValueMathematical:
2364             return AB_MATHEMATICAL;
2365         default:
2366             ASSERT_NOT_REACHED();
2367             return AB_AUTO;
2368     }
2369 }
2370
2371 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
2372     : m_type(CSS_IDENT)
2373     , m_hasCachedCSSText(false)
2374 {
2375     switch (e) {
2376         case CI_AUTO:
2377             m_value.ident = CSSValueAuto;
2378             break;
2379         case CI_SRGB:
2380             m_value.ident = CSSValueSrgb;
2381             break;
2382         case CI_LINEARRGB:
2383             m_value.ident = CSSValueLinearrgb;
2384             break;
2385     }
2386 }
2387
2388 template<> inline CSSPrimitiveValue::operator EColorInterpolation() const
2389 {
2390     switch (m_value.ident) {
2391         case CSSValueSrgb:
2392             return CI_SRGB;
2393         case CSSValueLinearrgb:
2394             return CI_LINEARRGB;
2395         case CSSValueAuto:
2396             return CI_AUTO;
2397         default:
2398             ASSERT_NOT_REACHED();
2399             return CI_AUTO;
2400     }
2401 }
2402
2403 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
2404     : m_type(CSS_IDENT)
2405     , m_hasCachedCSSText(false)
2406 {
2407     switch (e) {
2408         case CR_AUTO:
2409             m_value.ident = CSSValueAuto;
2410             break;
2411         case CR_OPTIMIZESPEED:
2412             m_value.ident = CSSValueOptimizespeed;
2413             break;
2414         case CR_OPTIMIZEQUALITY:
2415             m_value.ident = CSSValueOptimizequality;
2416             break;
2417     }
2418 }
2419
2420 template<> inline CSSPrimitiveValue::operator EColorRendering() const
2421 {
2422     switch (m_value.ident) {
2423         case CSSValueOptimizespeed:
2424             return CR_OPTIMIZESPEED;
2425         case CSSValueOptimizequality:
2426             return CR_OPTIMIZEQUALITY;
2427         case CSSValueAuto:
2428             return CR_AUTO;
2429         default:
2430             ASSERT_NOT_REACHED();
2431             return CR_AUTO;
2432     }
2433 }
2434
2435 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
2436     : m_type(CSS_IDENT)
2437     , m_hasCachedCSSText(false)
2438 {
2439     switch (e) {
2440         case DB_AUTO:
2441             m_value.ident = CSSValueAuto;
2442             break;
2443         case DB_USE_SCRIPT:
2444             m_value.ident = CSSValueUseScript;
2445             break;
2446         case DB_NO_CHANGE:
2447             m_value.ident = CSSValueNoChange;
2448             break;
2449         case DB_RESET_SIZE:
2450             m_value.ident = CSSValueResetSize;
2451             break;
2452         case DB_CENTRAL:
2453             m_value.ident = CSSValueCentral;
2454             break;
2455         case DB_MIDDLE:
2456             m_value.ident = CSSValueMiddle;
2457             break;
2458         case DB_TEXT_BEFORE_EDGE:
2459             m_value.ident = CSSValueTextBeforeEdge;
2460             break;
2461         case DB_TEXT_AFTER_EDGE:
2462             m_value.ident = CSSValueTextAfterEdge;
2463             break;
2464         case DB_IDEOGRAPHIC:
2465             m_value.ident = CSSValueIdeographic;
2466             break;
2467         case DB_ALPHABETIC:
2468             m_value.ident = CSSValueAlphabetic;
2469             break;
2470         case DB_HANGING:
2471             m_value.ident = CSSValueHanging;
2472             break;
2473         case DB_MATHEMATICAL:
2474             m_value.ident = CSSValueMathematical;
2475             break;
2476     }
2477 }
2478
2479 template<> inline CSSPrimitiveValue::operator EDominantBaseline() const
2480 {
2481     switch (m_value.ident) {
2482         case CSSValueAuto:
2483             return DB_AUTO;
2484         case CSSValueUseScript:
2485             return DB_USE_SCRIPT;
2486         case CSSValueNoChange:
2487             return DB_NO_CHANGE;
2488         case CSSValueResetSize:
2489             return DB_RESET_SIZE;
2490         case CSSValueIdeographic:
2491             return DB_IDEOGRAPHIC;
2492         case CSSValueAlphabetic:
2493             return DB_ALPHABETIC;
2494         case CSSValueHanging:
2495             return DB_HANGING;
2496         case CSSValueMathematical:
2497             return DB_MATHEMATICAL;
2498         case CSSValueCentral:
2499             return DB_CENTRAL;
2500         case CSSValueMiddle:
2501             return DB_MIDDLE;
2502         case CSSValueTextAfterEdge:
2503             return DB_TEXT_AFTER_EDGE;
2504         case CSSValueTextBeforeEdge:
2505             return DB_TEXT_BEFORE_EDGE;
2506         default:
2507             ASSERT_NOT_REACHED();
2508             return DB_AUTO;
2509     }
2510 }
2511
2512 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
2513     : m_type(CSS_IDENT)
2514     , m_hasCachedCSSText(false)
2515 {
2516     switch (e) {
2517         case IR_AUTO:
2518             m_value.ident = CSSValueAuto;
2519             break;
2520         case IR_OPTIMIZESPEED:
2521             m_value.ident = CSSValueOptimizespeed;
2522             break;
2523         case IR_OPTIMIZEQUALITY:
2524             m_value.ident = CSSValueOptimizequality;
2525             break;
2526     }
2527 }
2528
2529 template<> inline CSSPrimitiveValue::operator EImageRendering() const
2530 {
2531     switch (m_value.ident) {
2532         case CSSValueAuto:
2533             return IR_AUTO;
2534         case CSSValueOptimizespeed:
2535             return IR_OPTIMIZESPEED;
2536         case CSSValueOptimizequality:
2537             return IR_OPTIMIZEQUALITY;
2538         default:
2539             ASSERT_NOT_REACHED();
2540             return IR_AUTO;
2541     }
2542 }
2543
2544 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
2545     : m_type(CSS_IDENT)
2546     , m_hasCachedCSSText(false)
2547 {
2548     switch (e) {
2549         case IR_AUTO:
2550             m_value.ident = CSSValueAuto;
2551             break;
2552         case IR_OPTIMIZESPEED:
2553             m_value.ident = CSSValueOptimizespeed;
2554             break;
2555         case SR_CRISPEDGES:
2556             m_value.ident = CSSValueCrispedges;
2557             break;
2558         case SR_GEOMETRICPRECISION:
2559             m_value.ident = CSSValueGeometricprecision;
2560             break;
2561     }
2562 }
2563
2564 template<> inline CSSPrimitiveValue::operator EShapeRendering() const
2565 {
2566     switch (m_value.ident) {
2567         case CSSValueAuto:
2568             return SR_AUTO;
2569         case CSSValueOptimizespeed:
2570             return SR_OPTIMIZESPEED;
2571         case CSSValueCrispedges:
2572             return SR_CRISPEDGES;
2573         case CSSValueGeometricprecision:
2574             return SR_GEOMETRICPRECISION;
2575         default:
2576             ASSERT_NOT_REACHED();
2577             return SR_AUTO;
2578     }
2579 }
2580
2581 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
2582     : m_type(CSS_IDENT)
2583     , m_hasCachedCSSText(false)
2584 {
2585     switch (e) {
2586         case TA_START:
2587             m_value.ident = CSSValueStart;
2588             break;
2589         case TA_MIDDLE:
2590             m_value.ident = CSSValueMiddle;
2591             break;
2592         case TA_END:
2593             m_value.ident = CSSValueEnd;
2594             break;
2595     }
2596 }
2597
2598 template<> inline CSSPrimitiveValue::operator ETextAnchor() const
2599 {
2600     switch (m_value.ident) {
2601         case CSSValueStart:
2602             return TA_START;
2603         case CSSValueMiddle:
2604             return TA_MIDDLE;
2605         case CSSValueEnd:
2606             return TA_END;
2607         default:
2608             ASSERT_NOT_REACHED();
2609             return TA_START;
2610     }
2611 }
2612
2613 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWritingMode e)
2614     : m_type(CSS_IDENT)
2615     , m_hasCachedCSSText(false)
2616 {
2617     switch (e) {
2618         case WM_LRTB:
2619             m_value.ident = CSSValueLrTb;
2620             break;
2621         case WM_LR:
2622             m_value.ident = CSSValueLr;
2623             break;
2624         case WM_RLTB:
2625             m_value.ident = CSSValueRlTb;
2626             break;
2627         case WM_RL:
2628             m_value.ident = CSSValueRl;
2629             break;
2630         case WM_TBRL:
2631             m_value.ident = CSSValueTbRl;
2632             break;
2633         case WM_TB:
2634             m_value.ident = CSSValueTb;
2635             break;
2636     }
2637 }
2638
2639 template<> inline CSSPrimitiveValue::operator EWritingMode() const
2640 {
2641     return static_cast<EWritingMode>(m_value.ident - CSSValueLrTb);
2642 }
2643
2644 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVectorEffect e)
2645     : m_type(CSS_IDENT)
2646     , m_hasCachedCSSText(false)
2647 {
2648     switch (e) {
2649     case VE_NONE:
2650         m_value.ident = CSSValueNone;
2651         break;
2652     case VE_NON_SCALING_STROKE:
2653         m_value.ident = CSSValueNonScalingStroke;
2654         break;
2655     }
2656 }
2657
2658 template<> inline CSSPrimitiveValue::operator EVectorEffect() const
2659 {
2660     switch (m_value.ident) {
2661     case CSSValueNone:
2662         return VE_NONE;
2663     case CSSValueNonScalingStroke:
2664         return VE_NON_SCALING_STROKE;
2665     default:
2666         ASSERT_NOT_REACHED();
2667         return VE_NONE;
2668     }
2669 }
2670
2671 #endif
2672
2673 }
2674
2675 #endif