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