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